[removed] old tool that was not used for a long time. (replaced by flint)
authortzachid <tzachid@ad392aa1-c5ef-ae45-8dd8-e69d62a5ef86>
Sun, 4 May 2008 09:03:21 +0000 (09:03 +0000)
committertzachid <tzachid@ad392aa1-c5ef-ae45-8dd8-e69d62a5ef86>
Sun, 4 May 2008 09:03:21 +0000 (09:03 +0000)
git-svn-id: svn://openib.tc.cornell.edu/gen1/trunk@1123 ad392aa1-c5ef-ae45-8dd8-e69d62a5ef86

tools/fwupdate/dirs [deleted file]
tools/fwupdate/user/SOURCES [deleted file]
tools/fwupdate/user/flint-tools.cpp [deleted file]
tools/fwupdate/user/flint-tools.h [deleted file]
tools/fwupdate/user/flint.cpp [deleted file]
tools/fwupdate/user/makefile [deleted file]
tools/fwupdate/user/mtcr.h [deleted file]

diff --git a/tools/fwupdate/dirs b/tools/fwupdate/dirs
deleted file mode 100644 (file)
index 389156f..0000000
+++ /dev/null
@@ -1,2 +0,0 @@
-DIRS=\\r
-       user\r
diff --git a/tools/fwupdate/user/SOURCES b/tools/fwupdate/user/SOURCES
deleted file mode 100644 (file)
index d676539..0000000
+++ /dev/null
@@ -1,21 +0,0 @@
-TARGETNAME=hcafwupdate\r
-TARGETPATH=..\..\..\bin\user\obj$(BUILD_ALT_DIR)\r
-TARGETTYPE=PROGRAM\r
-UMTYPE=console\r
-USE_MSVCRT=1\r
-\r
-SOURCES=flint.cpp \\r
-               flint-tools.cpp\r
-\r
-INCLUDES= ..\..\..\inc;..\..\..\inc\user;\r
-\r
-TARGETLIBS= \\r
-!if $(FREEBUILD)\r
-                       $(TARGETPATH)\*\complib.lib \\r
-                       $(TARGETPATH)\*\ibal.lib\r
-!else\r
-                       $(TARGETPATH)\*\complibd.lib \\r
-                       $(TARGETPATH)\*\ibald.lib\r
-!endif\r
-\r
-MSC_WARNING_LEVEL= /W3\r
diff --git a/tools/fwupdate/user/flint-tools.cpp b/tools/fwupdate/user/flint-tools.cpp
deleted file mode 100644 (file)
index 4bcaf7e..0000000
+++ /dev/null
@@ -1,368 +0,0 @@
-/*\r
- * Copyright (c) 2005 SilverStorm Technologies.  All rights reserved.\r
- * Copyright (c) 2004-2005 Mellanox Technologies Ltd.  All rights reserved.\r
- *\r
- * This software is available to you under the OpenIB.org BSD license\r
- * below:\r
- *\r
- *     Redistribution and use in source and binary forms, with or\r
- *     without modification, are permitted provided that the following\r
- *     conditions are met:\r
- *\r
- *      - Redistributions of source code must retain the above\r
- *        copyright notice, this list of conditions and the following\r
- *        disclaimer.\r
- *\r
- *      - Redistributions in binary form must reproduce the above\r
- *        copyright notice, this list of conditions and the following\r
- *        disclaimer in the documentation and/or other materials\r
- *        provided with the distribution.\r
- *\r
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
- * SOFTWARE.\r
- *\r
- * $Id$\r
- */\r
-\r
-#include <string.h>\r
-#include <stdio.h>\r
-#include <stdlib.h>\r
-#include "flint-tools.h"\r
-\r
-FlashCommandLine::FlashCommandLine()\r
-{\r
-    initialize();\r
-}\r
-\r
-FlashCommandLine::FlashCommandLine(int argc, char **argv)\r
-{\r
-    initialize();\r
-    parse(argc, argv);\r
-}\r
-\r
-void FlashCommandLine::initialize()\r
-{\r
-    m_options = no_prompts;\r
-    m_usedefaultdevice = true; // use the default device name\r
-    m_readguidsfromflash = true; // read the current guids from the flash  \r
-    m_isFlashDeviceOption = false;\r
-    //m_device[MAXPATHLEN];\r
-    m_defaultdevice = "//mt23108_pciconf"; // default the device for now\r
-    //m_nodeguidstr[MAXPATHLEN];\r
-    //m_rawfile[MAXPATHLEN]; \r
-}\r
-\r
-bool FlashCommandLine::isOption(Options opt)\r
-{\r
-    return ((m_options & opt)==opt);\r
-}\r
-\r
-bool FlashCommandLine::isFlashDeviceOption(void)\r
-{\r
-    return (m_isFlashDeviceOption);\r
-}\r
-\r
-static char                    optarg[MAXPATHLEN];\r
-        static struct option long_options[] = \r
-        {\r
-           {"noquery"        , 0, 0, 'q'},\r
-           {"silent"         , 0, 0, 's'},\r
-           {"burn"           , 0, 0, 'b'},\r
-           {"debug"          , 0, 0, 'x'},\r
-           {"dump-flash"     , 0, 0, 'p'},\r
-           {"dump-image"     , 0, 0, 'z'},\r
-           {"device"         , 1, 0, 'd'},\r
-           {"guid"           , 1, 0, 'n'},\r
-           {"noverify"       , 0, 0, 'y'},\r
-           {"verify-flash"   , 0, 0, 'v'},\r
-           {"verify-image"   , 0, 0, 'g'},\r
-           {"image-info"     , 0, 0, 'i'},\r
-           {"flash-info"     , 0, 0, 'j'},\r
-           {"no-prompts"     , 0, 0, 'k'},\r
-           {"prompt"         , 0, 0, 'l'},\r
-           {"write-file"     , 1, 0, 'w'},\r
-           {"force"          , 0, 0, 'f'},\r
-           {"flash-format"   , 0, 0, 'A'},\r
-           {"nobestdevice"   , 0, 0, 'c'},\r
-           {"burn-invariant" , 0, 0, 'B'},\r
-           {"help"           , 0, 0, 'h'},\r
-           {0, 0, 0, 0}\r
-        };\r
-        static char *short_options="qsbxpzdnyvgijwfcBh";\r
-\r
-\r
-char getopt_long(\r
-       int                             argc,\r
-       char                            *argv[],\r
-       const char                      *short_option,\r
-       const struct option *long_option,\r
-       void                            *unused )\r
-{\r
-       static int i = 1;\r
-       char            ret = -1;\r
-\r
-       UNUSED_PARAM( unused );\r
-       \r
-       if ( i == argc )\r
-               return ret;\r
-\r
-       if( argv[i][0] != '-' )\r
-               return ret;\r
-       \r
-       if ( isalpha(argv[i][1]))\r
-       {\r
-               ret = argv[i][1];\r
-               char *tmp_buf = &argv[i][2];\r
-               \r
-               for(;;)\r
-               {\r
-                       if ( *tmp_buf == '\0')\r
-                       {\r
-                               i++;\r
-                               tmp_buf = &argv[i][0];\r
-                       }\r
-\r
-                       if (  *tmp_buf != '-' )\r
-                       {\r
-                               \r
-                               if (isalnum( *tmp_buf ) )\r
-                               {\r
-                                       sscanf(argv[i],"%s", &optarg);\r
-                                       return ret;\r
-                               }\r
-                       }\r
-                       return ret;\r
-               }\r
-       }\r
-       return ret;\r
-}\r
-\r
-int32_t FlashCommandLine::parse(int argc, char **argv)\r
-{\r
-    int opt; \r
-    bool rawFileRequired=false;\r
-       int i = 0;\r
-\r
-       cl_memset (m_device,0, MAXPATHLEN );\r
-       cl_memset (m_rawfile,0, MAXPATHLEN );\r
-    strncpy(m_program, argv[0], MAXPATHLEN);\r
-       strncpy(m_device, m_defaultdevice, MAXPATHLEN); // set the device name to the default\r
-       \r
-\r
-    // process the FlashCommandLine to determine desired actions\r
-    if (argc < 2)\r
-    {\r
-        usage(argv[0]);\r
-        return -1;\r
-    }\r
-\r
-    while (1) \r
-    {\r
-        int option_index = 0;\r
-               cl_memset (optarg, 0, sizeof(optarg));\r
-               if (++i >= argc )\r
-                       return 1;\r
-               \r
-               //opt = getopt_long (argc, argv, short_options , long_options, &option_index);\r
-               opt = argv[i][1];\r
-               if (argv[i][2] != '\0')\r
-                       cl_memcpy(optarg, &argv[i][2], min( strlen(argv[i]), MAXPATHLEN));\r
-               if ( ++i < argc && argv[i][0] != '-' )\r
-               {\r
-                       cl_memcpy(optarg, &argv[i][0], min( strlen(argv[i]), MAXPATHLEN));\r
-               }\r
-                       \r
-        if (opt == -1)\r
-           break;\r
-        \r
-        switch (opt) \r
-        {\r
-            case 'q':\r
-                m_options |= noquery; // query and show guids, no write\r
-                break;\r
-            case 'b':\r
-                m_options |= burn; // query and show guids, no write\r
-                m_isFlashDeviceOption = true;\r
-                rawFileRequired=true;\r
-                break;\r
-            case 'd':\r
-                m_usedefaultdevice=false; // don't use the default device\r
-                //m_options |= disable_bestdevice; \r
-                //strncpy(m_device, optarg, MAXPATHLEN); // set the device name\r
-                               strncpy(m_device, m_defaultdevice, MAXPATHLEN); // use default - we don't export device name so far\r
-                break;           \r
-            case 'n':\r
-                m_readguidsfromflash=false;\r
-                strncpy(m_nodeguidstr, optarg, MAXPATHLEN); // set the node guid string\r
-                break;            \r
-            case 's':\r
-                m_options |= silent; // be very quite\r
-                break;\r
-            case 'x':\r
-                m_options |= debug; // be very noisy\r
-                break;\r
-            case 'y':\r
-                m_options ^= verify_flash;               \r
-                m_isFlashDeviceOption = true;\r
-                break;\r
-            case 'v':\r
-                m_options |= verify_flash;                 \r
-                m_isFlashDeviceOption = true;\r
-                break;\r
-            case 'g':\r
-                m_options |= verify_image; \r
-                rawFileRequired=true;\r
-                               strncpy(m_rawfile, optarg, min(strlen (optarg),MAXPATHLEN));\r
-                break;\r
-            case 'p':\r
-                m_options |= dump_flash;\r
-                m_isFlashDeviceOption = true;\r
-                break;\r
-            case 'z':\r
-                m_options |= dump_image; \r
-                rawFileRequired=true;\r
-                               strncpy(m_rawfile, optarg, min(strlen (optarg),MAXPATHLEN));\r
-                break;            \r
-            case 'i':\r
-                m_options |= show_image_info; \r
-                rawFileRequired = true;\r
-                break;            \r
-            case 'j':\r
-                m_options |= show_flash_info; \r
-                m_isFlashDeviceOption = true;\r
-                break;\r
-            case 'k':\r
-                break;  // obsolete be silent about for backward support\r
-            case 'l':\r
-                m_options ^= no_prompts; \r
-                break;\r
-            case 'f':\r
-                m_options |= force; \r
-                break;\r
-            case 'A':\r
-                m_options |= flash_format;\r
-                m_isFlashDeviceOption = true;\r
-                break;\r
-            case 'w':\r
-                strncpy(m_revision, optarg, revisionStringLength); // set the node guid string\r
-                m_options |= write_file;\r
-                rawFileRequired=true;\r
-                break;\r
-            case 'c':\r
-                m_options |= disable_bestdevice; \r
-                break;\r
-            case 'B':\r
-                m_options |= burn_invariant_section; \r
-                break;            \r
-            case 'h': // display some useful usage information           \r
-            default:\r
-                usage(argv[0]);\r
-                exit(-1);\r
-        } // end case\r
-\r
-               if ( rawFileRequired && m_rawfile[0] == '\0' )\r
-               {\r
-                       cl_memcpy(m_rawfile, optarg, min(strlen (optarg),MAXPATHLEN));\r
-                       if ( strlen (m_rawfile ) == 0 )\r
-                       {\r
-                               fprintf(stderr, "Empty firmware filename.\n");\r
-                       usage(argv[0]);\r
-                       exit(-1);\r
-                       }\r
-               }\r
-    } // end while\r
-\r
-    return 1;\r
-}\r
-\r
-uint8_t FlashCommandLine::getOptions()\r
-{\r
-    return (uint8_t)m_options;\r
-}\r
-\r
-char *FlashCommandLine::getProgramName()\r
-{\r
-    return m_program;\r
-}\r
-\r
-\r
-char *FlashCommandLine::getDeviceName()\r
-{\r
-    return m_device;\r
-}\r
-\r
-char *FlashCommandLine::getDefaultDeviceName()\r
-{\r
-    return m_defaultdevice;\r
-}\r
-\r
-char *FlashCommandLine::getNodeGUID()\r
-{\r
-    return m_nodeguidstr;\r
-}\r
-\r
-char *FlashCommandLine::getRawFileName()\r
-{\r
-    return m_rawfile;\r
-}\r
-\r
-char *FlashCommandLine::getRevisionString()\r
-{\r
-    return m_revision;\r
-}\r
-\r
-\r
-bool FlashCommandLine::useDefaultDevice()\r
-{\r
-    return m_usedefaultdevice;\r
-}\r
-\r
-bool FlashCommandLine::useFlashNodeGUID()\r
-{\r
-    return m_readguidsfromflash;\r
-}\r
-\r
-\r
-void FlashCommandLine::usage(const char *progname)\r
-{\r
-    char *rversion = "$Revision$";\r
-    char version[128];\r
-    uint32_t x;\r
-\r
-    for (x=0;x<128;x++)\r
-    {\r
-        if (rversion[x+11] == '$')\r
-        {\r
-            break;\r
-        }\r
-        version[x] = rversion[x+11];\r
-    }\r
-\r
-    fprintf(stdout, "usage: %s [-b][-q][-x][-p][-z][-d device][-n 0x0000000000000000]\n"                    \r
-                    "                   [-v][-g][-i][-w revision][-h][-c][raw-firmware-file]\n"\r
-                    "version: %s\n"\r
-                    "  --noquery       |-q  - do not query device guids\n"\r
-                    "  --burn          |-b  - burn raw image file to flash device\n"\r
-                    "  --debug         |-x  - enable debug mode\n"\r
-                    "  --dump-flash    |-p  - dump flash image to stdout\n"\r
-                    "  --dump-image    |-z  - dump raw file image to stdout\n"\r
-                    "  --device        |-d  - the hca configuration device (*_pciconf# or *_cr#)\n"\r
-                    "  --guid          |-n  - the 64 bit GUID to use for the hca device\n"\r
-                    "  --verify-flash  |-v  - verify the flash image\n"\r
-                    "  --verify-image  |-g  - verify the raw file image\n"\r
-                    "  --image-info    |-i  - display raw file image information\n"\r
-                    "  --flash-info    |-j  - display flash image information\n"                   \r
-                    "  --prompts       |-l  - at decision points prompt the end user\n"\r
-                    "  --write-file    |-w  - write image to file injecting the VSD section\n"\r
-                    "  --nobestdevice  |-c  - use exactly the device the -d option specified\n"\r
-                    "  --burn-invariant|-B  - burn the invariant section\n"\r
-                    "  --help          |-h  - this usage clause\n",\r
-                    progname, version);\r
-}\r
-\r
diff --git a/tools/fwupdate/user/flint-tools.h b/tools/fwupdate/user/flint-tools.h
deleted file mode 100644 (file)
index 32f53c2..0000000
+++ /dev/null
@@ -1,160 +0,0 @@
-/*\r
- * Copyright (c) 2004-2005 Mellanox Technologies Ltd.  All rights reserved.\r
- *\r
- * This software is available to you under the OpenIB.org BSD license\r
- * below:\r
- *\r
- *     Redistribution and use in source and binary forms, with or\r
- *     without modification, are permitted provided that the following\r
- *     conditions are met:\r
- *\r
- *      - Redistributions of source code must retain the above\r
- *        copyright notice, this list of conditions and the following\r
- *        disclaimer.\r
- *\r
- *      - Redistributions in binary form must reproduce the above\r
- *        copyright notice, this list of conditions and the following\r
- *        disclaimer in the documentation and/or other materials\r
- *        provided with the distribution.\r
- *\r
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
- * SOFTWARE.\r
- *\r
- * $Id$\r
- */\r
-\r
-\r
-#ifndef _FLINT_TOOLS_H\r
-#define _FLINT_TOOLS_H\r
-\r
-#define __STDC_FORMAT_MACROS\r
-\r
-#include <sys/stat.h>\r
-#include <sys/types.h>\r
-#include <ctype.h>\r
-#include <signal.h>\r
-#include <fcntl.h>\r
-#include <errno.h>\r
-#include <time.h>\r
-#include <stdarg.h>\r
-#include <stdlib.h>\r
-#include <stdio.h>\r
-#include <io.h>\r
-#include "complib/cl_byteswap.h"\r
-#include "complib/cl_memory.h"\r
-#include "complib/cl_debug.h"\r
-#include "complib/cl_types.h"\r
-#include "iba/ib_types.h"\r
-#include "iba/ib_al.h"\r
-\r
-#ifndef MAXPATHLEN\r
-#define MAXPATHLEN  (128)\r
-#endif\r
-\r
-#ifndef PRIx32\r
-#define PRIx32 "x"\r
-#endif\r
-\r
-#ifndef PRIX32\r
-#define PRIX32 "X"\r
-#endif\r
-\r
-#ifndef PRId32\r
-#define PRId32 "d"\r
-#endif\r
-\r
-#define __be32_to_cpu(s) cl_ntoh32(s)\r
-#define __cpu_to_be32(s)  __be32_to_cpu(s)\r
-\r
-#include "mtcr.h"\r
-\r
-/* define some debug helpers  *********************/\r
-\r
- extern u_int32_t              g_fw_dbg_lvl;\r
-\r
-#define FW_DBG_ERROR   CL_DBG_ERROR\r
-#define FW_DBG_FULL            CL_DBG_ALL\r
-#define FW_DBG_TRACE   \r
-#define FW_ENTER( msg_lvl )                    \\r
-       CL_ENTER( msg_lvl, g_fw_dbg_lvl )\r
-\r
-#define FW_EXIT( msg_lvl )                             \\r
-       CL_EXIT( msg_lvl, g_fw_dbg_lvl )\r
-\r
-#define FW_TRACE( msg_lvl, msg )               \\r
-       CL_TRACE( msg_lvl, g_fw_dbg_lvl, msg )\r
-\r
-#define FW_TRACE_EXIT( msg_lvl, msg )  \\r
-       CL_TRACE_EXIT( msg_lvl, g_fw_dbg_lvl, msg )\r
-\r
-#define FW_PRINT( msg_lvl, msg )               \\r
-       CL_PRINT( msg_lvl, g_fw_dbg_lvl, msg )\r
-/**************************************************/\r
-struct option\r
-{\r
-       const char              *long_name;\r
-       unsigned long   flag;\r
-       void                    *pfn_handler;\r
-       char                    short_name;\r
-};\r
-\r
-class FlashCommandLine\r
-{\r
-public:\r
-    enum Constants {\r
-        revisionStringLength = 25\r
-    };\r
-    FlashCommandLine();\r
-    FlashCommandLine(int argc, char **argv);\r
-    int32_t  parse(int argc, char **argv);\r
-    enum Options {  none                   =    0x0, \r
-                    silent                 =    0x1, \r
-                    debug                  =    0x2, \r
-                    verify_image           =    0x4, \r
-                    verify_flash           =    0x8, \r
-                    dump_image             =   0x10,\r
-                    dump_flash             =   0x20,\r
-                    burn                   =   0x40,\r
-                    noquery                =   0x80,\r
-                    no_prompts             =  0x100,\r
-                    write_file             =  0x200,\r
-                    show_image_info        =  0x400,\r
-                    show_flash_info        =  0x800,\r
-                    force                  = 0x1000,\r
-                    flash_format           = 0x2000,\r
-                    disable_bestdevice     = 0x4000,\r
-                    burn_invariant_section = 0x8000\r
-                    };\r
-    uint8_t getOptions();\r
-    char *getProgramName();\r
-    char *getDeviceName();\r
-    char *getDefaultDeviceName();\r
-    char *getNodeGUID();\r
-    char *getRawFileName();\r
-    char *getRevisionString();\r
-    bool useDefaultDevice();\r
-    bool useFlashNodeGUID();\r
-    void usage(const char *progname);\r
-    bool isOption(Options opt);\r
-    bool isFlashDeviceOption(void);\r
-protected:\r
-    void  initialize();\r
-private:\r
-    int   m_options;\r
-    bool  m_isFlashDeviceOption;\r
-    bool  m_usedefaultdevice;     \r
-    bool  m_readguidsfromflash;    \r
-    char  m_device[MAXPATHLEN];\r
-    char *m_defaultdevice;\r
-    char  m_nodeguidstr[MAXPATHLEN];\r
-    char  m_rawfile[MAXPATHLEN];\r
-    char  m_program[MAXPATHLEN];\r
-    char  m_revision[revisionStringLength];\r
-};\r
-#endif\r
diff --git a/tools/fwupdate/user/flint.cpp b/tools/fwupdate/user/flint.cpp
deleted file mode 100644 (file)
index 85acd41..0000000
+++ /dev/null
@@ -1,2756 +0,0 @@
-/*\r
- * Copyright (c) 2005 SilverStorm Technologies.  All rights reserved.\r
- * Copyright (c) 2004-2005 Mellanox Technologies Ltd.  All rights reserved.\r
- *\r
- * This software is available to you under the OpenIB.org BSD license\r
- * below:\r
- *\r
- *     Redistribution and use in source and binary forms, with or\r
- *     without modification, are permitted provided that the following\r
- *     conditions are met:\r
- *\r
- *      - Redistributions of source code must retain the above\r
- *        copyright notice, this list of conditions and the following\r
- *        disclaimer.\r
- *\r
- *      - Redistributions in binary form must reproduce the above\r
- *        copyright notice, this list of conditions and the following\r
- *        disclaimer in the documentation and/or other materials\r
- *        provided with the distribution.\r
- *\r
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
- * SOFTWARE.\r
- *\r
- * $Id$\r
- */\r
-\r
-\r
-#include "flint-tools.h"\r
-#include <complib/cl_byteswap.h>\r
-\r
-bool DebugMode = false;\r
-bool DisableBestDevice = false;\r
-\r
-static uint32_t TAVOR_TYPE = 23108;\r
-static uint32_t ARBEL_TYPE = 25208;\r
-static int mellanox_mode = 0;\r
-static uint32_t devRevision;\r
-static uint32_t devType;\r
-static uint32_t devId;\r
-static char bestDev[MAXPATHLEN];\r
-\r
-char *techSupportMessage = "Use the --force option to skip this check.  This operation\n"\r
-                           "allows any firmware to be placed on the HCA device, but could cause the\n"\r
-                           "the device to cease functioning.  If this occurs, please contact\n"\r
-                           "technical support.\n";\r
-\r
-\r
-#define M_DEBUG printf\r
-#define LOCK_FILE_NAME "C:\\fwupdate.lck"\r
-\r
-static int file_lock;\r
-static int FwUpdateLock(void);\r
-static void FwUpdateUnlock(void);\r
-\r
-// global defines\r
-\r
-u_int32_t      g_fw_dbg_lvl = CL_DBG_ERROR ;\r
-\r
-#define BE2CPU32(s) __be32_to_cpu(s)\r
-#define TOCPU1(s) s = __be32_to_cpu(s)\r
-\r
-#define TOCPU(s,bsz) do {                                                    \\r
-    uint32_t *p = (uint32_t *)(s);                               \\r
-    for (uint32_t ii=0; ii<bsz/sizeof(uint32_t); ii++,p++) \\r
-        *p = __be32_to_cpu(*p);                                          \\r
-    } while(0)\r
-#define TOCPUBY(s, bsz) do {                                                  \\r
-    uint32_t *p = (uint32_t *)(&s);                              \\r
-    for (uint32_t ii=0; ii<bsz/sizeof(uint32_t); ii++,p++) \\r
-        *p = __be32_to_cpu(*p);                                          \\r
-    } while(0)\r
-#define CRC(c, s, bsz) do {                                                   \\r
-    uint32_t *p = (uint32_t *)(s);                               \\r
-    for (uint32_t ii=0; ii<bsz/sizeof(uint32_t); ii++)     \\r
-        c << *p++;                                                       \\r
-    } while(0)\r
-#define CRCBY(c, s, bsz) do {                                                 \\r
-    uint32_t *p = (uint32_t *)(&s);                              \\r
-    for (uint32_t ii=0; ii<bsz/sizeof(uint32_t); ii++)     \\r
-        c << *p++;                                                       \\r
-    } while(0)\r
-#define CRC1(c, s,bsz) do {                                                  \\r
-    uint32_t *p = (uint32_t *)(s);                               \\r
-    for (uint32_t ii=0; ii<bsz/sizeof(uint32_t) - 1; ii++) \\r
-        {c << *p++;  }                                                     \\r
-    } while(0)\r
-#define CRC1BY(c, s, bsz) do {                                                \\r
-    uint32_t *p = (uint32_t *)(&s);                              \\r
-    for (uint32_t ii=0; ii<bsz/sizeof(uint32_t) - 1; ii++) \\r
-        { c << *p++;  }                                                     \\r
-    } while(0)\r
-#define CHECKB2(f,b,o,n,p) do { if (!checkBoot2(f,b,o,n,p)) return false; } while (0)\r
-#define CHECKGN(f,b,o,n,p) do { if (!checkGen(f,b,o,n,p)) return false; } while (0)\r
-#define CHECKLS(f,o,p) do { if (!checkList(f,o,p)) return false; } while(0)\r
-#define READBUF(f,o,d,l,p) do { if (!f.read(o,d,l)) { \\r
-    printf("%s - read error (%s)\n", p, f._err);      \\r
-    return false; }} while (0)\r
-enum { SIGNATURE=0x5a445a44, SECT_SIZE=0x10000 };\r
-struct PS {\r
-    uint32_t fi_addr;\r
-    uint32_t fi_size;\r
-    uint32_t signature;\r
-    uint32_t fw_reserved[5];\r
-    uint32_t vsd[52];\r
-       union {\r
-               uint32_t        as_uint32[4];\r
-               char            as_str[16];\r
-       } psid;\r
-    uint32_t branch_to;\r
-    uint32_t crc016;\r
-};\r
-enum {\r
-       H_FIRST=1,\r
-       H_DDR=1,\r
-       H_CNF=2,\r
-       H_JMP=3,\r
-       H_EMT=4,\r
-       H_ROM=5,\r
-       H_GUID=6,\r
-       H_BOARD_ID=7,\r
-       H_USER_DATA=8,\r
-       H_FW_CONF=9,\r
-       H_LAST  =9\r
-};\r
-\r
-struct GPH {\r
-    uint32_t type;\r
-    uint32_t size;\r
-    uint32_t param;\r
-    uint32_t next;\r
-};\r
-\r
-typedef struct hca_dev {\r
-    TO_LONG_PTR(ib_al_handle_t, ph_al);\r
-       TO_LONG_PTR(ib_al_handle_t ,    h_al);\r
-    TO_LONG_PTR(ib_ca_handle_t* , ph_ca);\r
-       TO_LONG_PTR(ib_ca_handle_t ,    h_ca);\r
-    ib_net64_t       *ca_guid;\r
-       HANDLE                  dev_handle;\r
-    size_t           ca_guids_count;\r
-    void            *ptr;\r
-} hca_dev_t;\r
-\r
-#define GUIDS 4\r
-#define MST_MAX_FLASH  (512*1024)      // 512K\r
-#define READ4(f,o,d,p) do { if (!f.read(o,d)) {  \\r
-    printf("%s - read error (%s)\n", p, f._err); \\r
-    return false; }} while (0)\r
-    \r
-// forward function declaration\r
-uint32_t HcaDevnameToDevId(const char *devname);\r
-uint32_t HcaDevnameToDevType(const char *devname);\r
-bool probePciBusForHcaDevice(const char *devname);\r
-bool isMstLoaded(void);\r
-bool getGUID(const char *s, uint64_t *guid);\r
-bool extractGUIDptr(uint32_t sign, uint32_t *buf, uint32_t buf_len, char *pref, uint32_t *ind, uint32_t *nguids);\r
-void printStatus(const uint32_t status);\r
-void printPercent(const uint32_t percent, const uint32_t reset);\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-//                                                                    //\r
-// ****************************************************************** //\r
-//                        CRC16 CALCULATION                           //\r
-// ****************************************************************** //\r
-//                                                                    //\r
-////////////////////////////////////////////////////////////////////////\r
-class Crc16\r
-{\r
-public:\r
-    Crc16(bool d = false) : _debug(d) { clear();       }\r
-    uint16_t       get()              { return _crc;   }\r
-    void           clear()            { _crc = 0xffff; }\r
-    void           operator<<(uint32_t val) { add(val); }\r
-    void           add(uint32_t val);\r
-    void           finish();\r
-private:\r
-    uint16_t       _crc;\r
-    bool           _debug;\r
-};\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-void Crc16::add(uint32_t o)\r
-{\r
-    if (_debug)\r
-        printf("Crc16::add(%08"PRIx32")\n", o);\r
-    for (uint32_t i=0; i<32; i++)\r
-    {\r
-        if (_crc & 0x8000)\r
-            _crc = (((_crc<<1) | (o>>31)) ^  0x100b) & 0xffff;\r
-        else\r
-            _crc=((_crc<<1) | (o>>31)) & 0xffff;\r
-        o = (o<<1) & 0xffffffff;\r
-    }\r
-} // Crc16::add\r
-\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-void Crc16::finish()\r
-{\r
-    for (uint32_t i=0; i<16; i++)\r
-    {\r
-        if (_crc & 0x8000)\r
-            _crc=((_crc<<1)  ^  0x100b) & 0xffff;\r
-        else\r
-            _crc=(_crc<<1) & 0xffff;\r
-    }\r
-\r
-    // Revert 16 low bits\r
-    _crc = _crc ^ 0xffff;\r
-\r
-} // Crc16::finish\r
-\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-//                                                                    //\r
-// ****************************************************************** //\r
-//                        FLASH ACCESS                                //\r
-// ****************************************************************** //\r
-//                                                                    //\r
-////////////////////////////////////////////////////////////////////////\r
-//#define FUJITSU_BYTE_MODE\r
-\r
-// Common base class for Flash and for FImage\r
-class FBase\r
-{\r
-public:\r
-    FBase()          {m_debug=false;}\r
-\r
-    virtual bool open(const char *)                           = 0;\r
-    virtual void close()                                      = 0;\r
-    virtual bool read(uint32_t addr, uint32_t *data)  = 0;\r
-    virtual bool read(uint32_t addr, void *data, uint32_t len) = 0;\r
-    virtual bool dump()                                       = 0;\r
-    virtual uint32_t getClassType()                              = 0;\r
-    bool verify();\r
-    void setDebug(bool on) { m_debug = on; };\r
-    bool isDebug() { return m_debug; };\r
-    char *_err;\r
-\r
-protected:\r
-    char _msg[1024];\r
-    bool m_debug;\r
-};\r
-\r
-// Flash image (RO)\r
-class FImage : public FBase\r
-{\r
-public:\r
-    FImage() : _buf(0) {  }\r
-    FImage(bool debug) : _buf(0) { setDebug(debug); }\r
-    virtual ~FImage() { close(); }\r
-\r
-    enum { RawImageFileType = 1 };\r
-\r
-    uint32_t *getBuf()      { return _buf; }\r
-    uint32_t getBufLength() { return _len; }\r
-    virtual bool open(const char *fname);\r
-    virtual void close();\r
-    virtual bool read(uint32_t addr, uint32_t *data);\r
-    virtual bool read(uint32_t addr, void *data, uint32_t len);\r
-    virtual bool dump();\r
-    virtual uint32_t getClassType() { return RawImageFileType; };\r
-\r
-private:\r
-    uint32_t *_buf;\r
-    uint32_t _len;\r
-};\r
-\r
-// Flash access (R/W)\r
-class Flash : public FBase\r
-{\r
-public:\r
-    enum GPIO_STATE { High, Low };\r
-\r
-    Flash() : curr_sector(0xffffffff), m_curr_bank(0xffffffff), m_gpio_state(Flash::Low) {}\r
-    virtual ~Flash()  { close(); };\r
-\r
-    enum { SECT_SIZE = 0x10000, SECT_MASK = 0xffff0000, FlashDeviceType = 2 };\r
-       enum {  FW_READ         = 0x00,\r
-                       FW_WRITE        = 0x01,\r
-                       FW_READ_CMD = 0x08,\r
-                       FW_WRITE_CMD= 0x09,\r
-                       FW_OPEN_IF      = 0xe7,\r
-                       FW_CLOSE_IF     = 0x7e };\r
-    uint32_t  curr_sector;\r
-    hca_dev_t  m_mf;\r
-    virtual bool open(const char *);\r
-    virtual void close();\r
-    virtual bool read(uint32_t addr, uint32_t *data);\r
-    virtual bool read(uint32_t addr, void *data, uint32_t len);\r
-    virtual bool dump();\r
-    virtual uint32_t getClassType() { return FlashDeviceType; };\r
-    void setGPIOState(GPIO_STATE state);\r
-    bool format();\r
-    bool write(uint32_t addr, uint32_t data);\r
-    bool write(uint32_t addr, void *data, uint32_t cnt,\r
-               bool noerase = false, bool noverify = false);\r
-    bool write_image(uint32_t addr, void *data, uint32_t cnt, bool eraseInvariant = false, bool report=false);\r
-    bool erase_sector(uint32_t addr);\r
-\r
-    ib_api_status_t  access(/*hca_dev_t *mf,*/ u_int32_t offset, void *data, u_int32_t length, u_int32_t operation);\r
-private:\r
-\r
-    uint32_t  m_curr_bank;\r
-    GPIO_STATE      m_gpio_state;\r
-    uint32_t  m_dir;\r
-    uint32_t  m_pol;\r
-    uint32_t  m_mod;\r
-    uint32_t  m_data;\r
-\r
-    bool         hca_open (void);\r
-    void             hca_close ();\r
-    bool          set_bank(uint32_t bank);\r
-    bool          write_internal(uint32_t addr, uint8_t data);\r
-\r
-    enum FlashCmds {IDLE=0,\r
-                                       READ4=(1<<29),\r
-                                       WRITE1=(2<<29)\r
-       };\r
-\r
-    enum {     TRANS = 4096 };\r
-    enum {     BANK_SHIFT = 19,\r
-                       BANK_MASK = 0xfff80000\r
-       };\r
-    \r
-       enum {  FLASH    = 0xf01a4, \r
-                       ADDR_MSK=0x7ffffUL, \r
-                       CMD_MASK=0xe0000000UL\r
-       };\r
-    \r
-       enum {  CPUMODE  = 0xf0150, \r
-                       CPUMODE_MSK=0xc0000000UL, \r
-                       CPUMODE_SHIFT=30\r
-       };\r
-    \r
-       enum {  SEMAP63    = 0xf03fc,\r
-                       GPIO_DIR_L = 0xf008c,\r
-                       GPIO_POL_L = 0xf0094,\r
-                       GPIO_MOD_L = 0xf009c,\r
-                       GPIO_DAT_L = 0xf0084,\r
-                       GPIO_DATACLEAR_L = 0xf00d4,\r
-                       GPIO_DATASET_L = 0xf00dc \r
-       };\r
-\r
-    // FLASH constants\r
-    enum { FLASH_CMD_CNT  = 5000,    // Number of reads till flash cmd is zeroed\r
-           ERASE_DELAY    = 20000,  // Delay between reads when wating for sector erase\r
-           ERASE_CNT      = 80,      // Maximal number of reads when wating for sector erase\r
-           READ_CNT_FAST  = 5000,    // Number of fast reads after write byte\r
-           READ_CNT_SLOW  = 50,      // Number of slow reads after write byte\r
-           READ_DELAY     = 10000,  // Delay between slow reads after write byte\r
-           WR_REPORT_FAST = 256,     // Report frequency when write (fast interfaces)\r
-           WR_REPORT_SLOW = 4,       // Report frequency when write (slow interfaces)\r
-           RD_REPORT_FAST = 4096,    // Report frequency when read (fast interfaces)\r
-           RD_REPORT_SLOW = 64,      // Report frequency when read (slow interfaces)\r
-           GPIO_SEM_TRIES = 10240    // Number of tries to obtain a GPIO sem.\r
-       };\r
-\r
-};\r
-\r
-bool FImage::dump()\r
-{\r
-    uint32_t word;\r
-    uint32_t position = 0;\r
-    \r
-    while (1)\r
-    {\r
-        if (!this->read(position, &word))\r
-        {\r
-            break;\r
-        }\r
-\r
-        if ((position % 16) == 0)\r
-        {\r
-            printf("\n%08"PRIx32": ", position);\r
-        }\r
-        printf(" %08"PRIx32"", word);\r
-\r
-        position = position + 4;\r
-    }\r
-    printf("\n");\r
-    return true;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool FImage::open(const char *fname)\r
-{\r
-    struct _stat        stat_buf;\r
-    int32_t            r_cnt;\r
-\r
-    uint32_t fd = _open(fname, _O_BINARY | _O_RDONLY, S_IREAD);\r
-    if (!fd )\r
-    {\r
-        sprintf(_msg, "Can't open file \"%s\" - %s\n", fname, \r
-                strerror(errno));\r
-        _err = &_msg[0];\r
-        return false;\r
-    }\r
-    if (_fstat(fd, &stat_buf) < 0)\r
-    {\r
-        sprintf(_msg, "Can't stat file \"%s\" - %s\n", fname,\r
-                strerror(errno));\r
-        _err = &_msg[0];\r
-        return false;\r
-    }\r
-    if (stat_buf.st_size & 0x3)\r
-    {\r
-        _err = "Image size should be 4-bytes aligned.";\r
-        return false;\r
-    }\r
-\r
-    _buf = new uint32_t[stat_buf.st_size/4];\r
-    if ((r_cnt = _read(fd, _buf, stat_buf.st_size)) != stat_buf.st_size)\r
-    {\r
-        if (r_cnt < 0)\r
-            sprintf(_msg, "Read error on file \"%s\" - %s\n",\r
-                    fname, strerror(errno));\r
-        else\r
-            sprintf(_msg, "Read error on file \"%s\" - read only %d bytes (from %ld)\n",\r
-                    fname, r_cnt, stat_buf.st_size);\r
-        _err = &_msg[0];\r
-        return false;\r
-    }\r
-\r
-    _len = stat_buf.st_size;\r
-    _close(fd);\r
-    return true;\r
-} // FImage::open\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-void FImage::close()\r
-{\r
-    delete [] _buf;\r
-    _buf = 0;\r
-} // FImage::close\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool FImage::read(uint32_t addr, uint32_t *data)\r
-{\r
-    if (addr & 0x3)\r
-    {\r
-        _err = "Address should be 4-bytes aligned.";\r
-        return false;\r
-    }\r
-    if (!_buf)\r
-    {\r
-        _err = "Not opened";\r
-        return false;\r
-    }\r
-    if (addr > _len-4)\r
-    {\r
-        sprintf(_msg, "Address (0x%x) is out of image limits\n", addr);\r
-        _err = &_msg[0];\r
-        return false;\r
-    }\r
-    *data = _buf[addr/4];\r
-    return true;\r
-} // FImage::read\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool FImage::read(uint32_t addr, void *data, uint32_t len)\r
-{\r
-    if (addr & 0x3)\r
-    {\r
-        _err = "Address should be 4-bytes aligned.";\r
-        return false;\r
-    }\r
-    if (len & 0x3)\r
-    {\r
-        _err = "Length should be 4-bytes aligned.";\r
-        return false;\r
-    }\r
-    if (!_buf)\r
-    {\r
-        _err = "Not opened";\r
-        return false;\r
-    }\r
-\r
-    uint32_t *p = (uint32_t *)data;\r
-    for (uint32_t i=0; i<len/4; i++)\r
-    {\r
-        if (!read(addr, p++))\r
-            return false;\r
-        addr += 4;\r
-    }\r
-    return true;\r
-} // FImage::read\r
-\r
-Flash device;\r
-FImage image;\r
-void __cdecl catch_signal( int sig );\r
-\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-#define MWRITE4(offs,val, cmd) access(&m_mf, offs, val, 4, cmd )\r
-#define MREAD4(offs,val, cmd)  access(&m_mf, offs, val, 4, cmd )\r
-\r
-void Flash::setGPIOState(GPIO_STATE state)\r
-{\r
-    m_gpio_state = state;\r
-}\r
-\r
-bool Flash::dump()\r
-{\r
-    uint32_t word;\r
-    uint32_t position = 0;\r
-    uint32_t max_size = 0;\r
-    PS    ps;\r
-    \r
-    this->read(SECT_SIZE, &ps, sizeof(ps));\r
-    \r
-    TOCPUBY(ps,sizeof(ps));\r
-\r
-    // Signature\r
-    if (ps.signature != SIGNATURE)\r
-    {        \r
-        max_size = MST_MAX_FLASH;\r
-    } else\r
-    {\r
-        max_size = ps.fi_size;\r
-    }\r
-\r
-    while (position < max_size )\r
-    {\r
-        if (!this->read(position, &word))\r
-        {\r
-            break;\r
-        }\r
-\r
-        if ((position % 16) == 0)\r
-        {\r
-            printf("\n%08"PRIx32": ", position);\r
-        }\r
-        printf(" %08"PRIx32"", word);\r
-\r
-        position = position + 4;\r
-    }\r
-    printf("\n");\r
-    return true;\r
-}\r
-\r
-bool Flash::format()\r
-{\r
-    uint32_t position = 0;\r
-    uint32_t max_size = 0;\r
-    PS    ps;\r
-    uint32_t percent = 0;\r
-    uint32_t prev=0;\r
-    this->read(SECT_SIZE, &ps, sizeof(ps));\r
-    \r
-    TOCPUBY(ps, sizeof(ps));\r
-\r
-    // Signature\r
-    if (ps.signature != SIGNATURE)\r
-    {        \r
-        max_size = MST_MAX_FLASH;\r
-    } else\r
-    {\r
-        max_size = ps.fi_size;\r
-    }\r
-\r
-    printPercent(0,1);\r
-   \r
-    while (position < max_size )\r
-    {\r
-        this->erase_sector(position);\r
-        percent = (uint32_t)(((float)position / (float)max_size) * 100.00);\r
-        if (percent != prev)\r
-            printPercent(percent,0);\r
-        prev = percent;\r
-        position = position + SECT_SIZE; // increment by 65k sectors\r
-    }\r
-    printPercent(100,0);\r
-    printStatus(0);\r
-    return true;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool Flash::open(const char *device )\r
-{\r
-    // Open device\r
-    bool status = false;\r
-    if (!device)\r
-    {\r
-        M_DEBUG("Specify HCA to work with\n");\r
-        return status;\r
-    }              \r
-       m_mf.ph_al = (ib_al_handle_t VOID_PTR64 *)(intn_t)&m_mf.h_al;\r
-       m_mf.ph_ca = (ib_ca_handle_t VOID_PTR64 *)(intn_t)&m_mf.h_ca;\r
-    if ( !(hca_open()))\r
-    {\r
-        M_DEBUG("Failed to open HCA \n");\r
-        return status;\r
-    }\r
-    \r
-    //M_DEBUG("Open HCA  GUID %"PRIx64"\n", cl_ntoh64(*m_mf.ca_guid));\r
-    \r
-    m_curr_bank = 0xffffffff;\r
-\r
-    // Obtain GPIO Semaphore\r
-    uint32_t cnt=0;\r
-    uint32_t word;\r
-       \r
-       MREAD4(FLASH, &word, FW_OPEN_IF );\r
-\r
-    while ( !status )\r
-       {\r
-               MREAD4(SEMAP63, &word, FW_READ_CMD);\r
-               if( !word )\r
-               {\r
-                       status = true;\r
-                       break;\r
-               }\r
-        if (++cnt > GPIO_SEM_TRIES)\r
-        {\r
-            _err = "cannot obtain GPIO semaophore (63)";\r
-            break;\r
-        }\r
-    } /* while */\r
-\r
-       if ( !status )\r
-       {\r
-               MREAD4(FLASH, &word, FW_CLOSE_IF );\r
-               return status;\r
-       }\r
-\r
-    //M_DEBUG("Acquired GPIO sempahore.\n");\r
-\r
-    // Save old values\r
-    MREAD4(GPIO_DIR_L, &m_dir, FW_READ_CMD);\r
-    MREAD4(GPIO_POL_L, &m_pol, FW_READ_CMD);\r
-    MREAD4(GPIO_MOD_L, &m_mod, FW_READ_CMD);\r
-    MREAD4(GPIO_DAT_L, &m_data, FW_READ_CMD);\r
-\r
-    //M_DEBUG("Read GPIO information.\n");\r
-\r
-    // Set Direction=1, Polarity=0, Mode=0 for 3 GPIO lower bits\r
-    uint32_t dir;\r
-    uint32_t pol;\r
-    uint32_t mod;\r
-\r
-    dir = m_dir | 0x70;\r
-    pol = m_pol & ~0x70;\r
-    mod = m_mod & ~0x70;\r
-\r
-    MWRITE4(GPIO_DIR_L, &dir, FW_WRITE_CMD);\r
-    MWRITE4(GPIO_POL_L, &pol, FW_WRITE_CMD);\r
-    MWRITE4(GPIO_MOD_L, &mod, FW_WRITE_CMD);\r
-\r
-  //  M_DEBUG("Set GPIO bits.\n");\r
-\r
-    // Set CPUMODE\r
-    MREAD4(CPUMODE, &word, FW_READ_CMD);\r
-    word &= ~CPUMODE_MSK;\r
-    word |= 1 << CPUMODE_SHIFT;\r
-    MWRITE4(CPUMODE, &word, FW_WRITE_CMD);\r
-\r
-\r
-    //M_DEBUG("Set cpu mode.\n");\r
-\r
-    // Reset flash\r
-    status = write_internal(0, 0xf0);\r
-       M_DEBUG("Flash Open %s\n", ((status)?"OK":"FAIL"));\r
-       return status;\r
-} // Flash::open\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-void Flash::close()\r
-{\r
-       uint32_t data = 0;\r
-\r
-    if (!m_mf.h_ca)\r
-        return;\r
-\r
-    m_gpio_state = Flash::Low;\r
-    set_bank(0);\r
-\r
-    // Restore origin values\r
-    MWRITE4(GPIO_DIR_L, &m_dir, FW_WRITE_CMD);\r
-    MWRITE4(GPIO_POL_L, &m_pol, FW_WRITE_CMD);\r
-    MWRITE4(GPIO_MOD_L, &m_mod, FW_WRITE_CMD);\r
-    MWRITE4(GPIO_DAT_L, &m_data, FW_WRITE_CMD);\r
-\r
-    // Free GPIO Semaphore\r
-    MWRITE4(SEMAP63, &data, FW_WRITE_CMD);\r
-       \r
-       // free kernel BusInterface\r
-       MREAD4(FLASH, &data, FW_CLOSE_IF );\r
-\r
-    hca_close();\r
-    m_mf.h_ca = 0;\r
-    m_curr_bank = 0xffffffff;\r
-} // Flash::close\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool Flash::set_bank(uint32_t bank)\r
-{\r
-       uint32_t        data = 0x70;\r
-    if (!m_mf.h_ca)\r
-    {\r
-        _err = "Not opened";\r
-        return false;\r
-    }\r
-       \r
-    //printf("\n*** Flash::set_bank(0x%"PRIx32") : 0x%"PRIx32"\n", bank, (BANK_SHIFT-4) & 0x70);\r
-    MWRITE4(GPIO_DATACLEAR_L, &data, FW_WRITE_CMD);\r
-    if (m_gpio_state == Flash::Low)\r
-    {\r
-               data &= (bank >> (BANK_SHIFT-4));\r
-               MWRITE4(GPIO_DATASET_L, &data, FW_WRITE_CMD );\r
-    } else\r
-    {\r
-               data |= (bank >> (BANK_SHIFT-4));\r
-        MWRITE4(GPIO_DATASET_L, &data, FW_WRITE_CMD);\r
-    }\r
-\r
-    return true;\r
-} // Flash::set_bank\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool Flash::read(uint32_t addr, uint32_t *data)\r
-{\r
-    if (!m_mf.h_al)\r
-    {\r
-        _err = "Not opened";\r
-        return false;\r
-    }\r
-\r
-    uint32_t cmd;\r
-    if (addr & 0x3)\r
-    {\r
-        _err = "Address should be 4-bytes aligned.";\r
-        return false;\r
-    }\r
-\r
-    uint32_t bank = addr & BANK_MASK;\r
-    if (bank != m_curr_bank)\r
-    {\r
-        m_curr_bank = bank;\r
-        if (!set_bank(bank))\r
-            return false;\r
-    }\r
-       MREAD4(addr, &cmd, FW_READ ); // new read \r
-    cmd = __be32_to_cpu(cmd);\r
-    memcpy(data, &cmd, sizeof(uint32_t));\r
-\r
-    return true;\r
-} // Flash::read\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool Flash::read(uint32_t addr, void *data, uint32_t len)\r
-{\r
-    if (addr & 0x3)\r
-    {\r
-        _err = "Address should be 4-bytes aligned.";\r
-        return false;\r
-    }\r
-    if (len & 0x3)\r
-    {\r
-        _err = "Length should be 4-bytes aligned.";\r
-        return false;\r
-    }\r
-\r
-    uint32_t *p = (uint32_t *)data;\r
-    for (uint32_t i=0; i<len/4; i++)\r
-    {\r
-        if (!read(addr, p++))\r
-            return false;\r
-        addr += 4;\r
-    }\r
-    return true;\r
-} // Flash::flash_read\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool Flash::write_internal(uint32_t addr, uint8_t data)\r
-{\r
-       MWRITE4(addr, &data, FW_WRITE);\r
-    return true;\r
-} // Flash::write_internal\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool Flash::erase_sector(uint32_t addr)\r
-{\r
-    uint32_t   word = 0;\r
-    uint32_t   cnt = 0;\r
-\r
-    // Just to insure zeroes because erase completion waits for ones\r
-    if (!write(addr, &word, sizeof(word), true))\r
-        return false;\r
-\r
-    // erase sector sequence\r
-#ifdef FUJITSU_BYTE_MODE\r
-    if (!write_internal(0xaaa, 0xaa))\r
-        return false;\r
-    if (!write_internal(0x555, 0x55))\r
-        return false;\r
-    if (!write_internal(0xaaa, 0x80))\r
-        return false;\r
-    if (!write_internal(0xaaa, 0xaa))\r
-        return false;\r
-    if (!write_internal(0x555, 0x55))\r
-        return false;\r
-    if (!write_internal(addr, 0x30))\r
-        return false;\r
-#else /* FUJITSU_WORD_MODE */\r
-    if (!write_internal(0x555, 0xaa))\r
-        return false;\r
-    if (!write_internal(0x2aa, 0x55))\r
-        return false;\r
-    if (!write_internal(0x555, 0x80))\r
-        return false;\r
-    if (!write_internal(0x555, 0xaa))\r
-        return false;\r
-    if (!write_internal(0x2aa, 0x55))\r
-        return false;\r
-    if (!write_internal(addr, 0x30))\r
-        return false;\r
-#endif\r
-\r
-    // Wait while erase completes\r
-    do\r
-    {\r
-        // Timeout checks\r
-        if (++cnt > ERASE_CNT)\r
-        {\r
-            _err = "Flash erase sector timeout";\r
-            return false;\r
-        }\r
-        if (!read(addr, &word))\r
-            return false;\r
-\r
-        //printf("erase_sector: addr:%08"PRIx32", %08"PRIx32"\n", addr, word);\r
-        Sleep(ERASE_DELAY/1000);\r
-    } while (word != 0xffffffff);\r
-\r
-    return true;\r
-} // Flash::erase_sector\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool Flash::write(uint32_t addr, uint32_t data)\r
-{\r
-    if (!m_mf.h_al)\r
-    {\r
-        _err = "Not opened";\r
-        return false;\r
-    }\r
-    if (addr & 0x3)\r
-    {\r
-        _err = "Address should be 4-bytes aligned.";\r
-        return false;\r
-    }\r
-\r
-    uint32_t word;\r
-    uint32_t sector = addr & SECT_MASK;\r
-    uint32_t word_in_sector = (addr & ~SECT_MASK)/sizeof(uint32_t);\r
-\r
-    if (!read(addr, &word))\r
-        return false;\r
-    if (word == data)\r
-        return true;   // already there\r
-\r
-    uint32_t buff[SECT_SIZE/sizeof(uint32_t)];\r
-    if (!read(sector, buff, SECT_SIZE))\r
-        return false;\r
-    buff[word_in_sector] = data;\r
-    return write(sector, buff, SECT_SIZE);\r
-} // Flash::write\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool Flash::write(uint32_t addr, void *data, uint32_t cnt,\r
-                  bool noerase, bool noverify)\r
-{\r
-    if (!m_mf.h_al)\r
-    {\r
-        _err = "Not opened";\r
-        return false;\r
-    }\r
-    if (addr & 0x3)\r
-    {\r
-        _err = "Address should be 4-bytes aligned.";\r
-        return false;\r
-    }\r
-\r
-       if ( !data )\r
-               return true;\r
-\r
-    char         *p = (char *)data;\r
-\r
-    for (uint32_t i=0; i<cnt; i++,addr++)\r
-    {\r
-        uint32_t  word;\r
-        uint8_t   act, exp;\r
-        uint32_t  cnt1 = 0;\r
-\r
-            uint32_t bank = addr & BANK_MASK;\r
-            if (bank != m_curr_bank)\r
-            {\r
-                m_curr_bank = bank;\r
-                if (!set_bank(bank))\r
-                    return false;\r
-            }\r
-\r
-            if (!noerase)\r
-            {\r
-                uint32_t sector = addr & SECT_MASK;\r
-                if (sector != curr_sector)\r
-                {\r
-                    curr_sector = sector;\r
-                    if (!erase_sector(curr_sector))\r
-                        return false;\r
-                }\r
-            }\r
-\r
-#ifdef FUJITSU_BYTE_MODE\r
-            if (!write_internal(0xaaa, 0xaa))\r
-                return false;\r
-            if (!write_internal(0x555, 0x55))\r
-                return false;\r
-            if (!write_internal(0xaaa, 0xa0))\r
-                return false;\r
-#else /* FUJITSU_WORD_MODE */\r
-            if (!write_internal(0x555, 0xaa))\r
-                return false;\r
-            if (!write_internal(0x2aa, 0x55))\r
-                return false;\r
-            if (!write_internal(0x555, 0xa0))\r
-                return false;\r
-#endif\r
-\r
-            if (!write_internal(addr, *p++))\r
-                return false;\r
-           \r
-                       if ( !noverify )\r
-                       {\r
-                               if ( !read (addr &~3, &word) )\r
-                                       return false;\r
-#if __BYTE_ORDER == __LITTLE_ENDIAN\r
-                act = (word >> ((addr & 3) * 8)) & 0xff;\r
-#elif __BYTE_ORDER == __BIG_ENDIAN\r
-                act = (word >> ((3 - (addr & 3)) * 8)) & 0xff;\r
-#endif                 \r
-                               exp = *(p-1) & 0xff;\r
-                               if ( act != exp )\r
-                               {\r
-                                       M_DEBUG("Flash write error - read value %#x doesn't written value %#x", act, exp);\r
-                                       return false;\r
-                               }\r
-                       }\r
-       }\r
-       return true;\r
-} // flash_write\r
-\r
-void Flash::hca_close (void)\r
-{\r
-\r
-    if (m_mf.h_ca)\r
-        ib_close_ca( m_mf.h_ca, NULL );\r
-    if (m_mf.h_al)\r
-        ib_close_al( m_mf.h_al);\r
-}\r
- bool Flash::hca_open(void)\r
-{\r
-    ib_api_status_t ib_status = IB_SUCCESS;\r
-\r
-    /* Open ibal */\r
-    ib_status = ib_open_al( m_mf.ph_al );\r
-    if ( ib_status != IB_SUCCESS )\r
-    {\r
-        M_DEBUG("Failed ot open AL status %#x\n", ib_status);\r
-        return false;\r
-    }\r
-\r
-    ib_status = ib_get_ca_guids ( *m_mf.ph_al, NULL, &m_mf.ca_guids_count );\r
-    if (m_mf.ca_guids_count == 0)\r
-    {\r
-        M_DEBUG("FOUND NO GUIDS\n");\r
-        return false;\r
-    }\r
-   \r
-    m_mf.ca_guid =(ib_net64_t *)cl_zalloc(m_mf.ca_guids_count*sizeof(ib_net64_t));\r
-    if(m_mf.ca_guid == NULL)\r
-    {\r
-        M_DEBUG("Failed to allocate memory for CA GUID table\n");\r
-        return false;\r
-    }\r
-\r
-   ib_status = ib_get_ca_guids (*m_mf.ph_al, m_mf.ca_guid, &m_mf.ca_guids_count );\r
-   if (ib_status != IB_SUCCESS)\r
-   {\r
-       M_DEBUG("Failed to get CA GUIDs\n");\r
-       return false;\r
-   }\r
-\r
-   ib_status = ib_open_ca( *m_mf.ph_al, m_mf.ca_guid[0], NULL, &m_mf, m_mf.ph_ca );\r
-   if (ib_status != IB_SUCCESS)\r
-   {\r
-       M_DEBUG("Failed to open CA\n");\r
-       return false;\r
-   }\r
-\r
-   return true;\r
-}\r
-\r
-#define STR_LEN        128\r
-void printPercent(const uint32_t percent, const uint32_t reset)\r
-{\r
-#define PRECISION 2\r
-#define NO_OF_PARTS (100 / (PRECISION))\r
-                                /*"12345678901234567890123456789012345678901234567890"*/\r
-  char markerBar[NO_OF_PARTS+1] = "                                                  ";\r
-  static uint32_t prevNoOfXs = 0;\r
-  uint32_t noOfXs = 0;\r
-  uint32_t x;\r
-  char str[STR_LEN];\r
-  cl_memset(str,0,STR_LEN);\r
-\r
-  markerBar[NO_OF_PARTS+1] = '\0';\r
-\r
-  if (reset == 1)\r
-  {\r
-    sprintf(str,"|%s| %3d%%", markerBar, percent);\r
-    prevNoOfXs = 0;\r
-  }\r
-  else\r
-  {\r
-    noOfXs = percent / PRECISION;\r
-    for (x = 0; x < NO_OF_PARTS; x++)\r
-    {\r
-      if (x < noOfXs)\r
-       markerBar[x] = '*';\r
-    }\r
-    if (noOfXs>prevNoOfXs)\r
-    {\r
-      sprintf(str,"|%s| %3d%%", markerBar, percent);\r
-      //printf("|%s| %3d%%", markerBar, percent);\r
-      prevNoOfXs = noOfXs;\r
-    }\r
-  }\r
-  printf("\r%s",str);\r
-  fflush(stdout);\r
-}\r
-\r
-void printStatus(const uint32_t status)\r
-{\r
-       printf("[%s]\n",((status == 0)?"SUCCESS":"FAILED"));\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool Flash::write_image(uint32_t addr, void *data, uint32_t cnt, bool eraseInvariant, bool report)\r
-{\r
-    uint8_t  *p = (uint8_t *)data;\r
-    uint32_t  curr_addr = addr;\r
-    uint32_t  towrite = cnt;\r
-    uint32_t  perc = 0xffffffff;\r
-    bool noerase = false;\r
-\r
-    curr_sector = 0xffffffff;  // Erase sector first time\r
-    if (report)\r
-    {\r
-        printf("writing: ");\r
-        printPercent(0,1);\r
-        fflush(stdout);\r
-    }\r
-\r
-    while (towrite)\r
-    {   \r
-        // Write\r
-        uint32_t trans = (towrite > (uint32_t)TRANS) ? (uint32_t)TRANS : towrite;\r
-        \r
-        if (eraseInvariant) \r
-        {\r
-            noerase = false;\r
-        } else\r
-        {\r
-            if (curr_addr < SECT_SIZE) \r
-            {\r
-                noerase = true;\r
-            } else\r
-            {\r
-                noerase = false;\r
-            }\r
-        }\r
-\r
-        if (!noerase)\r
-        {        \r
-            if (!write(curr_addr, p, trans, noerase, true))\r
-            {\r
-                printStatus(1);\r
-                return false;\r
-            }\r
-        }\r
-        p += trans;\r
-        curr_addr += trans;\r
-        towrite -= trans;\r
-\r
-        // Report\r
-        if (report)\r
-        {\r
-            uint32_t new_perc = ((cnt - towrite) * 100) / cnt;\r
-            if (new_perc != perc)\r
-            {\r
-                printPercent(new_perc,0);\r
-                fflush(stdout);\r
-                perc = new_perc;\r
-            }\r
-        }\r
-    }\r
-\r
-    if (report)\r
-    {\r
-        printPercent(100,0);\r
-        printStatus(0);\r
-        fflush(stdout);\r
-    }\r
-\r
-    return true;\r
-} //  Flash::write_image\r
-\r
-\r
-/*\r
-       Note:\r
-       for read - data return in native Endian mode,\r
-       for write - data should be written in BigEndian mode \r
-       check where data is actually converted !!!!\r
-*/\r
-ib_api_status_t Flash::access(/*hca_dev_t *dev,*/ u_int32_t offset, void *p_data, uint32_t length, uint32_t operation )\r
-{\r
-       \r
-       ib_ci_op_t                      ci_op;\r
-       ib_api_status_t         ib_status;\r
-\r
-       BOOL                    dev_status;\r
-       DWORD                   bytes_ret;\r
-\r
-       ci_op.buf_size = length;\r
-       ci_op.p_buf     =  p_data;\r
-       ci_op.buf_info = offset;\r
-       ci_op.num_bytes_ret = sizeof (ib_ci_op_t);\r
-       ci_op.command = operation;\r
-\r
-       ib_status = ib_ci_call (m_mf.h_ca, NULL, 0, &ci_op);\r
-\r
-       if ( ib_status != IB_SUCCESS )\r
-       {\r
-               FW_TRACE (FW_DBG_ERROR,("Failed ib_ci_call return status %#x\n", ib_status ));\r
-               return ib_status;\r
-       }\r
-       return IB_SUCCESS;\r
-}\r
-\r
-bool getGUIDsFromFlash(FBase &device, uint64_t guids[GUIDS])\r
-{\r
-    uint32_t NODE_GUIDH, NODE_GUIDL;\r
-    uint32_t PORT1_GUIDH, PORT1_GUIDL;\r
-    uint32_t PORT2_GUIDH, PORT2_GUIDL;\r
-    uint32_t prim_ptr;\r
-    uint32_t signature;\r
-    PS    ps;\r
-    bool isFailSafe = false;\r
-\r
-    READ4(device, 0x24, &signature, "Signature");\r
-    TOCPU1(signature);\r
-\r
-    if (signature == SIGNATURE)\r
-    {\r
-        // Fail Safe image\r
-        \r
-        // Assume flash has been verified, and both images have the same guids, therefore,\r
-        // we only need to read the primary image's guids\r
-        device.read(SECT_SIZE, &ps, sizeof(ps));\r
-        TOCPUBY(ps,sizeof(ps));\r
-        READ4(device, ps.fi_addr+0x24, &prim_ptr, "Primary Section");        \r
-        M_DEBUG("Firmware Address  : 0x%"PRIx32"\n", ps.fi_addr);\r
-        M_DEBUG("Node GUID Offset  : 0x%"PRIx32"\n", prim_ptr);        \r
-        prim_ptr = BE2CPU32(prim_ptr)+ps.fi_addr;\r
-        isFailSafe = true;\r
-    }\r
-    else\r
-    {\r
-        // Short image\r
-        prim_ptr = signature;       \r
-    }\r
-\r
-        printf("Found valid GUID pointer     : %08"PRIx32"\n", prim_ptr);\r
-    if (prim_ptr < MST_MAX_FLASH || isFailSafe) \r
-    {\r
-        READ4(device, prim_ptr, &NODE_GUIDH, "Node GUID High");\r
-        READ4(device, prim_ptr+4, &NODE_GUIDL, "Node GUID Low");\r
-        guids[0] = BE2CPU32(NODE_GUIDH);\r
-        guids[0] = (guids[0]<<32) | BE2CPU32(NODE_GUIDL);\r
-        READ4(device, prim_ptr+8, &PORT1_GUIDH, "Port 1 GUID High");\r
-        READ4(device, prim_ptr+12, &PORT1_GUIDL, "Port 1 GUID Low");\r
-        guids[1] = BE2CPU32(PORT1_GUIDH);\r
-        guids[1] = (guids[1]<<32) | BE2CPU32(PORT1_GUIDL);\r
-        READ4(device, prim_ptr+16, &PORT2_GUIDH, "Port 2 GUID High");\r
-        READ4(device, prim_ptr+20, &PORT2_GUIDL, "Port 2 GUID Low");\r
-        guids[2] = BE2CPU32(PORT2_GUIDH);\r
-        guids[2] = (guids[2]<<32) | BE2CPU32(PORT2_GUIDL);\r
-\r
-        guids[3] = guids[0];\r
-        printf("Found device's existing GUIDs:\n");\r
-        printf("Node  GUID                   : 0x%016"PRIx64"\n", guids[0]);\r
-        printf("Port1 GUID                   : 0x%016"PRIx64"\n", guids[1]);\r
-        printf("Port2 GUID                   : 0x%016"PRIx64"\n", guids[2]);\r
-    } else \r
-    {\r
-        printf("Found an invalid GUID pointer!\n");\r
-        return false;\r
-    }\r
-\r
-    return true;\r
-}\r
-\r
-bool getGUIDs(char *guidString, uint64_t guids[GUIDS])\r
-{\r
-    uint32_t PORT1_GUIDH, PORT1_GUIDL;\r
-    uint32_t PORT2_GUIDH, PORT2_GUIDL;\r
-    uint64_t GUID; //strtoull(guidString, (char **)NULL, 0);\r
-    uint32_t NODE_GUIDH;\r
-    uint32_t NODE_GUIDL;\r
-\r
-    if (!getGUID(guidString, &GUID))\r
-    {\r
-        return false;\r
-    }\r
-\r
-    NODE_GUIDH = (uint32_t)(GUID >> 32);\r
-    NODE_GUIDL = (uint32_t)GUID;\r
-\r
-    if ((NODE_GUIDH & 0xffffffff) == 0x00066a00\r
-        && ((NODE_GUIDL & 0xf8000000) == 0x98000000 \r
-            || (NODE_GUIDL & 0xf8000000) == 0xb0000000))\r
-    {\r
-        // Always make it a InfiniCon NODE GUID\r
-        NODE_GUIDL = (NODE_GUIDL & 0x0FFFFFFF) | 0x98000000;\r
-\r
-        // Convert to the InfiniCon Node Guid Convention.\r
-        PORT1_GUIDH = NODE_GUIDH;\r
-        PORT1_GUIDL = (NODE_GUIDL & 0x07ffffff) | 0xa0000000;\r
-        PORT2_GUIDH = NODE_GUIDH | 1;\r
-        PORT2_GUIDL = (NODE_GUIDL & 0x07ffffff) | 0xa0000000;\r
-    } else {\r
-        // Treat everything else as a Mellanox Node Guid Convention.\r
-        PORT1_GUIDH=NODE_GUIDH;\r
-        PORT1_GUIDL=NODE_GUIDL+1;\r
-        if ( PORT1_GUIDL==0 ) {\r
-            PORT1_GUIDH++;\r
-        }\r
-        PORT2_GUIDH=PORT1_GUIDH;\r
-        PORT2_GUIDL=PORT1_GUIDL+1;\r
-        if ( PORT2_GUIDL==0 ) {\r
-            PORT2_GUIDH++;\r
-        }\r
-    }\r
-\r
-    guids[0] = NODE_GUIDH;\r
-    guids[0] = (guids[0]<<32) | NODE_GUIDL;\r
-\r
-    guids[1] = PORT1_GUIDH;\r
-    guids[1] = (guids[1]<<32) | PORT1_GUIDL;\r
-\r
-    guids[2] = PORT2_GUIDH;\r
-    guids[2] = (guids[2]<<32) | PORT2_GUIDL;\r
-\r
-    guids[3] = guids[0];\r
-\r
-    printf("Using user specified GUIDs   :\n");\r
-    printf("Node   GUID                  : 0x%016"PRIx64"\n", guids[0]);\r
-    printf("Port 1 GUID                  : 0x%016"PRIx64"\n", guids[1]);\r
-    printf("Port 2 GUID                  : 0x%016"PRIx64"\n", guids[2]);\r
-    return true;\r
-}\r
-\r
-bool _silent = false;\r
-#define report  printf\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool isInvariantSectionEqual(FBase& f1, FBase& f2)\r
-{\r
-    uint32_t size1;\r
-    uint32_t size2;\r
-    uint32_t beg  = 0x0;\r
-    uint32_t offs = 0x28;\r
-    const char* pr = "isInvariantSectionEqual";\r
-    uint32_t *buf1;\r
-    uint32_t *buf2;\r
-    bool status = true;\r
-\r
-    // Size\r
-    READ4(f1, offs+beg+4, &size1, pr);\r
-    READ4(f2, offs+beg+4, &size2, pr);\r
-    TOCPU1(size1);\r
-    TOCPU1(size2);\r
-\r
-//    M_DEBUG("Invariant sector size1: %"PRId32"\n", size1);\r
-//    M_DEBUG("Invariant sector size2: %"PRId32"\n", size2);\r
-\r
-    if (size1 != size2)\r
-    {\r
-        M_DEBUG("Invariant sector sizes do not match.\n");\r
-        return false;\r
-    }\r
-\r
-    buf1 = (uint32_t *)cl_zalloc((size1+4)*4);\r
-        if (!buf1)\r
-        {\r
-            cl_dbg_out("Failed to allocate memory size =%d", size1+4 );\r
-            return false;\r
-        }\r
-    buf2 = (uint32_t *)cl_zalloc( (size2+4)*4);\r
-        if (!buf2)\r
-        {\r
-            cl_free(buf1);\r
-            cl_dbg_out("Failed to allocate memory size =%d", size2+4 );\r
-            return false;\r
-        }\r
-    \r
-    READBUF(f1, offs+beg, buf1, (size1+4)*4, pr);\r
-    READBUF(f2, offs+beg, buf2, (size2+4)*4, pr);\r
-    \r
-    if ( cl_memcmp(buf1, buf2, (size1+4)*4) )\r
-    {\r
-       // M_DEBUG("Invariant sections are not equal.\n");\r
-        status = false;\r
-    }\r
-    cl_free(buf1);\r
-    cl_free(buf2);    \r
-    return status;\r
-} // isInvariantSectionEqual\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool checkBoot2(FBase& f, uint32_t beg, uint32_t offs, uint32_t& next, const char *pref)\r
-{\r
-    char         pr[256];\r
-    uint32_t size;\r
-    uint32_t *buff;\r
-       uint32_t *safe_buf;\r
-    //sprintf(pr, "%s /0x%08"PRIx32"/ (BOOT2)", pref, offs+beg);\r
-\r
-    // Size\r
-    READ4(f, offs+beg+4, &size, pr);\r
-    TOCPU1(size);\r
-\r
-    if (size > 1048576 || size < 4)\r
-    {\r
-        report("%s /0x%08"PRIx32"/ - unexpected size (0x%x)\n", pr, offs+beg+4, size);\r
-        return false;\r
-    }\r
-\r
-    //sprintf(pr, "%s /0x%08"PRIx32"-0x%08"PRIx32" (0x%06"PRIx32")/ (BOOT2)", pref, offs+beg, offs+beg+(size+4)*4-1, (size+4)*4);\r
-\r
-    // CRC\r
-    Crc16        crc;\r
-    buff = (uint32_t*)cl_zalloc((size+4)*4);\r
-       if (buff)\r
-               safe_buf = buff;\r
-    READBUF(f, offs+beg, buff, (size+4)*4, pr);\r
-    TOCPU(buff, (size+4)*4 );\r
-    CRC1(crc, buff, (size+4)*4 );\r
-    crc.finish();\r
-    uint32_t crc_act = *(buff+size+3);\r
-    if (crc.get() != crc_act)\r
-    {\r
-        report("%s /0x%08"PRIx32"/ - wrong CRC (exp:0x%x, act:0x%x)\n",\r
-               pr, offs+beg, crc.get(), crc_act);\r
-        cl_free(safe_buf);\r
-        return false;\r
-    }\r
-\r
-    //report("%s - OK\n", pr);\r
-    next = offs + (size+4)*4;\r
-    cl_free(safe_buf);\r
-    return true;\r
-} // checkBoot2\r
-\r
-static uint32_t part_cnt;\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool checkGen(FBase& f, uint32_t beg,\r
-              uint32_t offs, uint32_t& next, const char *pref)\r
-{\r
-    uint32_t size=0;\r
-    char         pr[1024];\r
-    GPH          gph;\r
-    cl_memset(pr,0,1024);\r
-    // GPH\r
-    sprintf(pr, "%s /0x%08"PRIx32"/ (GeneralHeader)", pref, offs+beg);\r
-    READBUF(f, offs+beg, &gph, sizeof(GPH), pr);\r
-    TOCPUBY(gph, sizeof(GPH));\r
-\r
-    // Body\r
-\r
-    part_cnt++;\r
-\r
-    // May be BOOT3?\r
-    if (gph.type < H_FIRST  ||  gph.type > H_LAST)\r
-    {\r
-        if (part_cnt > 2)\r
-        {\r
-            report("%s /0x%"PRIx32"/ - Invalid partition type (%"PRIx32")\n",\r
-                   pref, offs+beg, gph.type);\r
-            return false;\r
-        }\r
-        else\r
-            return checkBoot2(f, beg, offs, next, pref);\r
-    }\r
-\r
-    // All partitions here\r
-    offs += beg;\r
-    switch(gph.type)\r
-    {\r
-    case H_DDR:\r
-        size = gph.size * sizeof(uint32_t);\r
-        sprintf(pr, "%s /0x%08"PRIx32"-0x%08"PRIx32" (0x%06"PRIx32")/ (DDR)",\r
-                pref, offs, offs+size+(unsigned)sizeof(gph)+3, size+(unsigned)sizeof(gph)+4);\r
-        break;\r
-    case H_CNF:\r
-        size = gph.size * sizeof(uint32_t);\r
-        sprintf(pr, "%s /0x%08"PRIx32"-0x%08"PRIx32" (0x%06"PRIx32")/ (Configuration)",\r
-                pref, offs, offs+size+(unsigned)sizeof(gph)+3, size+(unsigned)sizeof(gph)+4);\r
-        break;\r
-    case H_JMP:\r
-        size = gph.size * sizeof(uint32_t);\r
-        sprintf(pr, "%s /0x%08"PRIx32"-0x%08"PRIx32" (0x%06"PRIx32")/ (Jump addresses)",\r
-                pref, offs, offs+size+(unsigned)sizeof(gph)+3, size+(unsigned)sizeof(gph)+4);\r
-        break;\r
-    case H_EMT:\r
-        size = gph.size;\r
-        size = (size + 3) / 4 * 4;\r
-        sprintf(pr, "%s /0x%08"PRIx32"-0x%08"PRIx32" (0x%06"PRIx32")/ (EMT Service)",\r
-                pref, offs, offs+size+(unsigned)sizeof(gph)+3, size+(unsigned)sizeof(gph)+4);\r
-        break;\r
-    case H_FW_CONF:\r
-        size = gph.size * sizeof(uint32_t);\r
-        sprintf(pr, "%s /0x%08x-0x%08x (0x%06x)/ (FW Configuration)",\r
-                pref, offs, offs+size+(uint32_t)sizeof(gph)+3,\r
-                size+(uint32_t)sizeof(gph)+4);\r
-        break;\r
-    case H_ROM:\r
-        size = gph.size * sizeof(uint32_t);\r
-        sprintf(pr, "%s /0x%08"PRIx32"-0x%08"PRIx32" (0x%06"PRIx32")/ (ROM)",\r
-                pref, offs, offs+size+(unsigned)sizeof(gph)+3, size+(unsigned)sizeof(gph)+4);\r
-        break;\r
-    case H_GUID:\r
-        size = gph.size * sizeof(uint32_t);\r
-        sprintf(pr, "%s /0x%08"PRIx32"-0x%08"PRIx32" (0x%06"PRIx32")/ (GUID)",\r
-                pref, offs, offs+size+(unsigned)sizeof(gph)+3, size+(unsigned)sizeof(gph)+4);\r
-        break;\r
-    case H_USER_DATA:\r
-        size = gph.size * sizeof(uint32_t);\r
-        sprintf(pr, "%s /0x%08x-0x%08x (0x%06x)/ (User Data)",\r
-                pref, offs, offs+size+(uint32_t)sizeof(gph)+3,\r
-                size+(uint32_t)sizeof(gph)+4);\r
-        break;\r
-    case H_BOARD_ID:\r
-        size = gph.size * sizeof(uint32_t);\r
-        sprintf(pr, "%s /0x%08"PRIx32"-0x%08"PRIx32" (0x%06"PRIx32")/ (Board ID)",\r
-                pref, offs, offs+size+(unsigned)sizeof(gph)+3,size+(u_int32_t)sizeof(gph)+4);\r
-        break; \r
-    default:\r
-        // For forward compatibility, try analyzing even if section type is uncknown\r
-        // Assuming the size is in DW, like all other sections (except emt service).\r
-        // If this assumption is wrong, CRC calc would fail - no harm done.\r
-        size = gph.size * sizeof(uint32_t);\r
-        sprintf(pr, "%s /0x%08x-0x%08x (0x%06x)/ (UNKNOWN SECTION TYPE (%d))",\r
-                pref, offs, offs+size+(uint32_t)sizeof(gph)+3,\r
-                size+(uint32_t)sizeof(gph)+4, gph.type);\r
-    }\r
-\r
-    // CRC\r
-    Crc16        crc;\r
-    uint32_t  *buff;\r
-    buff = (uint32_t*)cl_zalloc(size);\r
-    READBUF(f, offs+sizeof(gph), buff, size, pr);\r
-    TOCPU(buff,size);\r
-    CRCBY(crc, gph, sizeof(GPH));\r
-    CRC(crc, buff,size);\r
-    crc.finish();\r
-    uint32_t crc_act;\r
-    READ4(f, offs+sizeof(gph)+size, &crc_act, pr);\r
-    TOCPU1(crc_act);\r
-    if (crc.get() != crc_act)\r
-    {\r
-        report("%s /0x%08"PRIx32"/ - wrong CRC (exp:0x%x, act:0x%x)\n",\r
-               pr, offs, crc.get(), crc_act);\r
-        cl_free(buff);\r
-        return false;\r
-    }\r
-\r
-    report("%s - OK\n", pr);\r
-    next = gph.next;\r
-    cl_free(buff);\r
-    return true;\r
-} // checkGen\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool checkPS(FBase& f, uint32_t offs, uint32_t& next, const char *pref)\r
-{\r
-    Crc16 crc;\r
-    PS    ps;\r
-    f.read(offs, &ps, sizeof(ps));\r
-    TOCPUBY(ps, sizeof(ps));\r
-\r
-    // Signature\r
-    if (ps.signature != SIGNATURE)\r
-    {\r
-        report("%s Pointer Sector /0x%08"PRIx32"/ - wrong signature (%08"PRIx32")\n",\r
-               pref, offs, ps.signature);\r
-        return false;\r
-    }\r
-\r
-    // CRC\r
-    CRC1BY(crc, ps, sizeof(PS));\r
-    crc.finish();\r
-    if (crc.get() != ps.crc016)\r
-    {\r
-        report("%s Pointer Sector /0x%08"PRIx32"/ - wrong CRC (exp:0x%"PRIx32", act:0x%x)\n",\r
-               pref, offs, ps.crc016, crc.get());\r
-        return false;\r
-    }\r
-\r
-    next = ps.fi_addr;\r
-    report("%s Image /0x%08"PRIx32"-0x%08"PRIx32" (0x%06"PRIx32")/ - OK\n", pref, offs,\r
-           offs+(unsigned)sizeof(ps)-1, (unsigned)sizeof(ps));\r
-    return true;\r
-} // checkPS\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool checkList(FBase& f, uint32_t offs, const char *pref)\r
-{\r
-    uint32_t next_ptr;\r
-\r
-    CHECKB2(f, offs, 0x28, next_ptr, pref);\r
-    part_cnt = 1;\r
-    while (next_ptr && next_ptr != 0xff000000)\r
-        CHECKGN(f, offs, next_ptr, next_ptr, pref);\r
-    return true;\r
-} // checkList\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool FBase::verify()\r
-{\r
-    uint32_t prim_ptr, scnd_ptr;\r
-    uint32_t signature;\r
-    \r
-    READ4((*this), 0x24, &signature, "Signature");\r
-    TOCPU1(signature);\r
-    if (signature == SIGNATURE)\r
-    {\r
-        // Full image\r
-        report("\nFailsafe image:\n\n");\r
-        CHECKB2((*this), 0, 0x28, prim_ptr, "Invariant      ");\r
-        report("\n");\r
-        if (checkPS((*this), SECT_SIZE, prim_ptr, "Primary  "))\r
-            CHECKLS((*this), prim_ptr, "               ");\r
-        report("\n");\r
-        if (checkPS((*this), SECT_SIZE * 2, scnd_ptr, "Secondary"))\r
-            CHECKLS((*this), scnd_ptr, "               ");\r
-    }\r
-    else\r
-    {\r
-        // Short image\r
-        report("\nShort image:\n");\r
-        CHECKLS((*this), 0, "    ");\r
-    }\r
-    \r
-    return true;\r
-} // Verify\r
-\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-//                                                                    //\r
-// ****************************************************************** //\r
-//                       GUIDs TREATMENT                              //\r
-// ****************************************************************** //\r
-//                                                                    //\r
-////////////////////////////////////////////////////////////////////////\r
-#define GETGUID(s, g) do { if (!getGUID(s,g)) return 1; } while (0)\r
-#define GETBSN(s, g)  do { if (!getBSN(s,g)) return 1; } while (0)\r
-\r
-#define BSN_RET do {                                            \\r
-    printf("Invalid BSN. Should be MTxxxxxRddmmyy-nnn[-cc]\n"); \\r
-    return false;                                               \\r
-} while(0)\r
-#define BSN_RET1(s) do {                                             \\r
-    printf("Valid BSN format is: MTxxxxxRddmmyy-nnn[-cc]\n%s.\n",s); \\r
-    return false;                                                    \\r
-} while(0)\r
-uint32_t BSN_subfield(const char *s, uint32_t beg, uint32_t len)\r
-{\r
-    char buf[64];\r
-    strncpy(buf, &s[beg], len);\r
-    buf[len] = '\0';\r
-    return strtoul(&buf[0], 0, 10);\r
-}\r
-bool getBSN(char *s, uint64_t *guid)\r
-{\r
-    const uint64_t COMPANY_ID = 0x0002c9;\r
-    const uint64_t  TYPE      = 1;\r
-    bool cc_present = false;\r
-    char *p;\r
-    uint32_t  i;\r
-\r
-    // Convert to lowercase\r
-    for (p = s; *p; p++)\r
-        *p = (char)tolower(*p);\r
-\r
-    // Check validity\r
-    p = s;\r
-    if (strncmp(p, "mt", 2))     // MT\r
-        BSN_RET;\r
-    p += 2;\r
-    for (i=0; i<5; i++)\r
-        if (!isdigit(*p++))      // xxxxx\r
-            BSN_RET;\r
-    if (*p < 'a' || *p > 'z')    // R\r
-        BSN_RET;\r
-    p++;\r
-    for (i=0; i<6; i++)          // ddmmyy\r
-        if (!isdigit(*p++))\r
-            BSN_RET;\r
-    if (*p++ != '-')             // -\r
-        BSN_RET;\r
-    for (i=0; i<3; i++)          // nnn\r
-        if (!isdigit(*p++))\r
-            BSN_RET;\r
-    if (*p)\r
-    {\r
-        cc_present = true;\r
-        if (*p++ != '-')         // -\r
-            BSN_RET;\r
-        for (i=0; i<2; i++)      // cc\r
-            if (!isdigit(*p++))\r
-                BSN_RET;\r
-    }\r
-\r
-    uint32_t dd = BSN_subfield(s, 8, 2);\r
-    if (dd > 31)\r
-        BSN_RET1("Day (dd) should not exceed 31");\r
-    if (!dd)\r
-        BSN_RET1("Day (dd) can't be zero");\r
-    uint32_t mm = BSN_subfield(s, 10, 2);\r
-    if (mm > 12)\r
-        BSN_RET1("Months (mm) should not exceed 12");\r
-    if (!mm)\r
-        BSN_RET1("Months (mm) can't be zero");\r
-    uint32_t yy = BSN_subfield(s, 12, 2);\r
-    if (yy > 99)\r
-        BSN_RET1("Year (yy) should not exceed 99");\r
-    if (!yy)\r
-        BSN_RET1("Year (yy) can't be zero");\r
-    uint32_t num = BSN_subfield(s, 15, 3);\r
-    if (num > 999)\r
-        BSN_RET1("Number (num) should not exceed 999");\r
-    if (!num)\r
-        BSN_RET1("Number (num) can't be zero");\r
-    uint32_t cc = 1;\r
-    if (cc_present)\r
-    {\r
-        cc = BSN_subfield(s, 19, 2);\r
-        if (cc > 14)\r
-            BSN_RET1("Chip number (cc) should not exceed 14");\r
-        if (!cc)\r
-            BSN_RET1("Chip number (cc) can't be zero");\r
-    }\r
-    uint64_t id = ((((yy*12+mm-1)*31+ dd-1) * 1000) + num-1) * 112;\r
-    id += (cc-1)*8;\r
-    *guid = (COMPANY_ID << 40) | (TYPE << 32) | id;\r
-    return true;\r
-}\r
-\r
-bool getGUID(const char *s, uint64_t *guid)\r
-{\r
-    char          str[17], *endp;\r
-    int          i,j;\r
-    uint32_t      h,l;\r
-    memset(str, '0', 15);\r
-    str[16] = '\0';\r
-\r
-    for (i=(int)strlen(s)-1,j=15;i >= 0 && j >= 0 ; i-- )\r
-    {\r
-        if (isxdigit(s[i]))\r
-            str[j--] = s[i];\r
-    }\r
-    l = strtoul(&str[8], &endp, 16);\r
-    if (*endp)\r
-    {\r
-        printf("Invalid GUID syntax (%s)\n", &str[8]);\r
-        return false;\r
-    }\r
-    str[8] = '\0';\r
-    h = strtoul(&str[0], &endp, 16);\r
-    if (*endp)\r
-    {\r
-        printf("Invalid GUID syntax (%s)\n", str);\r
-        return false;\r
-    }\r
-    *guid = ((uint64_t)h << 32) | l;\r
-    return true;\r
-} // getGUID\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool extractGUIDptr(uint32_t sign, uint32_t *buf, uint32_t buf_len,\r
-                     char *pref, uint32_t *ind, uint32_t *nguids)\r
-{\r
-    uint32_t offs = 0;\r
-\r
-    // Check signature\r
-    if (sign)\r
-    {\r
-        uint32_t signature = buf[(sign + 8)/4];\r
-        TOCPU1(signature);\r
-        if (signature != SIGNATURE)\r
-        {\r
-            printf("%s pointer section not valid\n", pref);\r
-            return false;\r
-        }\r
-        offs = buf[sign/4];\r
-        TOCPU1(offs);\r
-    }\r
-\r
-    // Get GUID ptr\r
-    *ind = buf[(offs+0x24)/4];\r
-    TOCPU1(*ind);\r
-    *ind += offs;\r
-    if (*ind >= (uint32_t)buf_len)\r
-    {\r
-        printf("%s image - insane GUID pointer (%08"PRIx32")\n", pref, *ind);\r
-        return false;\r
-    }\r
-    *nguids = buf[*ind/4 - 3];\r
-    TOCPU1(*nguids);\r
-    *nguids /= 2;\r
-\r
-    // More sanity check\r
-    if (*nguids > GUIDS)\r
-    {\r
-        printf("%s image - insane number of GUIDs (%d)\n", pref, *nguids);\r
-        return false;\r
-    }\r
-\r
-    return true;\r
-} // extractGUIDptr\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-void patchGUIDsSection(\r
-    uint32_t *buf, \r
-    uint32_t ind,                      \r
-    uint64_t guids[GUIDS], \r
-    uint32_t nguids)\r
-{\r
-    uint32_t       i, word;\r
-    uint32_t       new_buf[GUIDS*2];\r
-    Crc16              crc;\r
-\r
-    // Form new GUID section\r
-    for (i=0; i<(uint32_t)nguids; i++)\r
-    {\r
-        new_buf[i*2] = (uint32_t)(guids[i] >> 32);\r
-        new_buf[i*2+1] = (uint32_t)(guids[i] & 0xffffffff);\r
-    }\r
-\r
-    // Calculate new CRC16\r
-    for (i=ind/4 - 4; i<ind/4; i++)\r
-    {\r
-        word = buf[i];\r
-        TOCPU1(word);\r
-        crc << word;\r
-    }\r
-    for (i=0; i<(uint32_t)nguids*2; i++)\r
-        crc << new_buf[i];\r
-\r
-    // Patch GUIDs\r
-    TOCPU(new_buf,GUIDS*2*4);\r
-    memcpy(&buf[ind/4], &new_buf[0], nguids * 2 * sizeof(uint32_t));\r
-\r
-    // Insert new CRC\r
-    crc.finish();\r
-    word = crc.get();\r
-    TOCPU1(word);\r
-    buf[ind/4 + nguids*2] = word;\r
-} // patchGUIDsSection\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-bool patchGUIDs(FImage& f, uint64_t guids[GUIDS],\r
-               bool interactive)\r
-{\r
-    uint64_t           old_guids[GUIDS];\r
-    uint32_t       *buf = f.getBuf();\r
-    uint32_t                buf_len = f.getBufLength();\r
-    uint32_t       signature = buf[0x24/4];\r
-    uint32_t       ind1=0,ind2=0;\r
-    uint32_t                nguid1, nguid2;\r
-\r
-    TOCPU1(signature);\r
-    if (signature == SIGNATURE)\r
-    {\r
-        // fail safe       \r
-        M_DEBUG("Extracting GUIDs from PPS    : ");\r
-        if (!extractGUIDptr(SECT_SIZE, buf, buf_len, "Primary", &ind1, &nguid1))\r
-        {\r
-            M_DEBUG("Failed\n");\r
-            return false;\r
-        }\r
-\r
-        M_DEBUG("[SUCCESS]\n");\r
-\r
-        M_DEBUG("Extracting GUIDs from SPS    : ");\r
-        if (!extractGUIDptr(SECT_SIZE*2, buf, buf_len, "Secondary", &ind2,\r
-                            &nguid2))\r
-        {\r
-            M_DEBUG("Failed\n");\r
-            return false;\r
-        }\r
-        M_DEBUG("[SUCCESS]\n");\r
-    }\r
-    else\r
-    {\r
-        // Short image\r
-        M_DEBUG("Extracting GUIDs from PS     : ");\r
-        if (!extractGUIDptr(0, buf, buf_len, "Primary", &ind1, &nguid1))\r
-        {\r
-            M_DEBUG("Failed\n");\r
-            return false;\r
-        }\r
-\r
-        M_DEBUG("[SUCCESS]\n");\r
-    }\r
-\r
-    // Print old GUIDs and get confirmation\r
-    if (interactive)\r
-    {\r
-        bool old_guids_fmt = nguid1 < GUIDS;\r
-        for (uint32_t i=0; i<GUIDS; i++)\r
-        {\r
-            uint32_t h = buf[ind1/4 + i*2];\r
-            TOCPU1(h);\r
-            uint32_t l = buf[ind1/4 + i*2 + 1];\r
-            TOCPU1(l);\r
-            old_guids[i] = ((uint64_t)h << 32) | l;\r
-        }\r
-        if ( !(old_guids[0] == guids[0]) || !(old_guids[1] == guids[1]) || !(old_guids[2] == guids[2]))\r
-        {\r
-            if (old_guids_fmt)\r
-                printf("    Old image!!!! Only %d GUIDs may be set.\n", nguid1);\r
-            printf("    Old GUIDs (inside image) are:\n");\r
-            printf("        Node:      %016"PRIx64"\n", old_guids[0]);\r
-            printf("        Port1:     %016"PRIx64"\n", old_guids[1]);\r
-            printf("        Port2:     %016"PRIx64"\n", old_guids[2]);\r
-            if (!old_guids_fmt)\r
-                printf("        Sys.Image: %016"PRIx64"\n", old_guids[3]);\r
-            printf("\n    You are about to change them to the following GUIDs:\n");\r
-            printf("        Node:      %016"PRIx64"\n", guids[0]);\r
-            printf("        Port1:     %016"PRIx64"\n", guids[1]);\r
-            printf("        Port2:     %016"PRIx64"\n", guids[2]);\r
-            if (!old_guids_fmt)\r
-                printf("        Sys.Image: %016"PRIx64"\n", guids[3]);\r
-            printf("\n    Is it OK ? (y/n) [n] : ");\r
-            fflush(stdout);\r
-            char c = (char)getchar();\r
-            if (c != '\n')\r
-                while (getchar() != '\n');\r
-            if (c != 'y')\r
-                return false;\r
-        }\r
-    }\r
-\r
-    // Path GUIDs section\r
-    patchGUIDsSection(buf, ind1, guids, nguid1);\r
-\r
-    M_DEBUG("Inserting GUIDs into PPS     : [SUCCESS]\n");\r
-\r
-    if (ind2)\r
-    {\r
-        M_DEBUG("Inserting GUIDs into SPS     : [SUCCESS]\n");\r
-        patchGUIDsSection(buf, ind2, guids, nguid2);\r
-    }\r
-\r
-    return true;\r
-} // patchGUIDs\r
-\r
-void patchVSDSection(\r
-    uint32_t *buffer, \r
-    uint32_t pointerSectorOffset,\r
-    uint32_t companyid,\r
-    time_t   timestamp,\r
-    char     *revision)\r
-{\r
-    uint32_t       i, x, word, offset=0;\r
-    uint32_t       newbuffer[sizeof(PS)];\r
-    Crc16          crc;    \r
-    PS ps;\r
-\r
-    memcpy(newbuffer, (buffer+pointerSectorOffset/sizeof(uint32_t)), sizeof(PS));\r
-\r
-    memcpy(&ps, newbuffer, sizeof(PS));        \r
-    ps.vsd[0] = __cpu_to_be32(companyid);\r
-    // Currently time_t is 32 bits, but this will only last until the \r
-    // year 2037.  Therefore, I am leaving 64bits for when the time_t\r
-    // size is increased which will probably provide an Epoch time far larger \r
-    // than man will exist.  Note:  Although, I have provided the space for a \r
-    // larger time_t this code will need to be modified to handle the 64bit\r
-    // Epoch time before 2037.\r
-#ifdef _WIN64\r
-       *((uint64_t*)&ps.vsd[1]) = cl_ntoh64(timestamp);\r
-#else\r
-    ps.vsd[1] = (uint32_t)0;\r
-    ps.vsd[2] = __cpu_to_be32(timestamp);\r
-#endif\r
-    \r
-    if (NULL != revision)\r
-    {\r
-        for (x=3;x<9;x++)\r
-        {          \r
-            memcpy(&ps.vsd[x], revision+offset, sizeof(uint32_t));\r
-            ps.vsd[x] = __cpu_to_be32(ps.vsd[x]);\r
-            offset = offset + 4;\r
-        }\r
-    }\r
-    memcpy(newbuffer, &ps, sizeof(PS));\r
-\r
-    // Calculate new CRC16\r
-    for (i=0; i<((sizeof(PS)/sizeof(uint32_t))-1); i++)\r
-    {\r
-        word = newbuffer[i];\r
-        TOCPU1(word);\r
-        crc << word;\r
-    }\r
-\r
-    // Insert new CRC\r
-    crc.finish();\r
-    word = crc.get();\r
-    TOCPU1(word);\r
-    ps.crc016 = word;\r
-    memcpy(newbuffer, &ps, sizeof(PS));\r
-    // patch VSD in buffer\r
-    memcpy(buffer+pointerSectorOffset/sizeof(uint32_t), newbuffer, sizeof(PS));\r
-\r
-} // patchGUIDsSection\r
-\r
-bool patchVSDs(FImage &image, char *revision)\r
-{\r
-    uint32_t signature;\r
-    uint32_t companyid = 0x0000066A; // InfiniCon\r
-\r
-    READ4(image, 0x24, &signature, "Signature");\r
-    TOCPU1(signature);\r
-\r
-    if (signature == SIGNATURE)\r
-    {   \r
-        time_t etime;\r
-        \r
-        etime = time(NULL);\r
-        printf("%s%s", \r
-               (device.getClassType()==Flash::FlashDeviceType?"Burn Date                    : ":"Creation                    : "),\r
-               asctime(localtime(&etime)));\r
-        patchVSDSection(image.getBuf(), SECT_SIZE  , companyid, etime, revision);\r
-        patchVSDSection(image.getBuf(), SECT_SIZE*2, companyid, etime, revision);\r
-        return true;\r
-    }\r
-    else\r
-    {\r
-        //printf("Can not inject VSD into a Short Image.\n");        \r
-        return false;\r
-    }\r
-}\r
-\r
-bool burnImageToFlash(FlashCommandLine cl)\r
-{\r
-    //Flash    device;\r
-    uint64_t guids[GUIDS];\r
-    bool insertGUIDs = false;\r
-    uint32_t Fhardwareversion=0;\r
-    uint32_t Ihardwareversion=0;\r
-    uint32_t Fsignature=0;\r
-    uint32_t Isignature=0;\r
-    \r
-    if (!device.open(cl.getDeviceName()))\r
-    {\r
-        printf("Error: %s %s\n", device._err, cl.getDeviceName());\r
-        return false;\r
-    }\r
-    \r
-    // We are always able to get the revision from the pci bus.\r
-       device.read(0x10, &Fhardwareversion, sizeof(Fhardwareversion));\r
-       TOCPU1(Fhardwareversion);\r
-       Fhardwareversion >>=24;\r
-\r
-    if (Fhardwareversion > 0xA0)\r
-    {\r
-        device.read(0x24, &Fsignature, sizeof(Fsignature));\r
-        TOCPU1(Fsignature);\r
-    }\r
-    \r
-    if (!cl.isOption(FlashCommandLine::force))\r
-    {\r
-        if (Fhardwareversion != 0xA1 && Fhardwareversion != 0xA0)\r
-        {\r
-            printf("!!!WARNING!!!\n"\r
-                   "Unable to determine the device\'s %s firmware revision (unknown rev %x)!\n"\r
-                   "It could be a corrupted firmware or an unsupported board revision.\n"\r
-                   "%s"\r
-                   "Aborting operation.\n",\r
-                   cl.getDeviceName(),\r
-                   Fhardwareversion,\r
-                   techSupportMessage);\r
-            return false;\r
-        }\r
-    } else\r
-    {\r
-        printf("!!!WARNING!!! Skipping flash device hardware revision integrity check.\n");\r
-    }\r
-\r
-    M_DEBUG("Open raw file.\n");\r
-\r
-    if (!image.open(cl.getRawFileName()))\r
-    {\r
-        printf("Error: %s %s\n", image._err, cl.getRawFileName());\r
-        return false;\r
-    }\r
-\r
-    M_DEBUG("Verify raw file.\n");\r
-\r
-    _silent = true;\r
-    if (!image.verify())\r
-    {\r
-        printf("%s is not a valid image\n", cl.getRawFileName());\r
-        return false;\r
-    }\r
-\r
-    image.read(0x24, &Isignature);\r
-    TOCPU1(Isignature);\r
-\r
-    image.read(0x10, &Ihardwareversion, sizeof(Ihardwareversion));\r
-       TOCPU1(Ihardwareversion);\r
-       Ihardwareversion >>=24;\r
-\r
-    M_DEBUG("Verify hardware and signature information.\n");\r
-\r
-    if (!cl.isOption(FlashCommandLine::force))\r
-    {\r
-        if (Ihardwareversion != 0xA1 && Ihardwareversion != 0xA0)\r
-        {\r
-            printf("!!!WARNING!!!\n"\r
-                   "Unable to determine the image\'s %s firmware revision (unknown rev %x)!\n"\r
-                   "It could be a corrupted image or an unsupported board revision.\n"\r
-                   "%s"\r
-                   "Aborting operation.\n",\r
-                   cl.getDeviceName(),\r
-                   Ihardwareversion,\r
-                   techSupportMessage);\r
-            return false;\r
-        }\r
-        else if (Fhardwareversion != Ihardwareversion)\r
-        {\r
-            printf("!!!WARNING!!! "\r
-                   "An HCA Rev %X firmware can not be used with HCA Rev %X device!!!\n"\r
-                   "Aborting operation.\n",\r
-                   Ihardwareversion,\r
-                   Fhardwareversion);\r
-            return false;\r
-        }\r
-               /*\r
-        if (Fhardwareversion == 0xA0)\r
-        {\r
-            if (Isignature == SIGNATURE)\r
-            {\r
-                printf("!!!WARNING!!! "\r
-                       "Rev A0 HCA's will not work with a fail safe image!!!\n"\r
-                       "%s"\r
-                       "Aborting operation.\n", techSupportMessage);\r
-                return false;\r
-            }\r
-        }\r
-               */\r
-    } else\r
-    {\r
-        printf("!!!DANGER!!!! Skipping image file hardware revision integrity check.\n");              \r
-    }\r
-\r
-    printf("HCA Rev                      : %"PRIX32"\n", Fhardwareversion);\r
-    printf("Image Rev                    : %"PRIX32"\n", Ihardwareversion);\r
-\r
-    if (!cl.useFlashNodeGUID())\r
-    {   // the user specified the guid at the command line\r
-        if (!getGUIDs(cl.getNodeGUID(),guids))\r
-        {\r
-            printf("Aborting burn operation.\n");\r
-            device.close();\r
-            return false;\r
-        }\r
-        insertGUIDs = true;\r
-    } else\r
-    {\r
-        // should we query the flash device for the guids\r
-        // If we don't query the flash for the guids, and\r
-        // we don't specify the guids at the command line\r
-        // then we will use the guids supplied in the raw\r
-        // image file\r
-           M_DEBUG("Query the flash device\n");\r
-        if (!cl.isOption(FlashCommandLine::noquery))\r
-        {\r
-            // obtain the guids from the flash\r
-            if (!getGUIDsFromFlash(device, guids))\r
-            {            \r
-                printf("The image on the flash device appears corrupted!\n"  \r
-                       "Unable to determine the GUIDs from the flash device %s.\n"\r
-                       "Try the -n <0xGUID> option.  If this fails, then contact\n" \r
-                       "SilverStorm Technologies technical support.\n",\r
-                       cl.getDeviceName());\r
-                device.close();\r
-                return false;\r
-            }\r
-            insertGUIDs = true;\r
-        }        \r
-    }\r
-\r
-    bool interactive;\r
-\r
-    if (cl.isOption(FlashCommandLine::no_prompts))\r
-    {\r
-        interactive=false;\r
-    } \r
-    else\r
-    {\r
-        interactive = (_isatty(_fileno( stdin )) > 0 ? true: false);\r
-    }\r
-    \r
-    bool eraseInvariant = false;\r
-\r
-    if (cl.isOption(FlashCommandLine::burn_invariant_section))\r
-    {   \r
-        M_DEBUG("Always burn invariant section.\n");\r
-        eraseInvariant = true;\r
-    } else // only burn the invariant section if it differs\r
-    {\r
-        if (isInvariantSectionEqual(device, image)) \r
-        {\r
-            M_DEBUG("The invariant sections are equal.\n");\r
-            eraseInvariant = false;\r
-        } else\r
-        {                     \r
-            M_DEBUG("The invariant sections differ.\n");\r
-            eraseInvariant = true;\r
-        }          \r
-    }\r
-\r
-    M_DEBUG("Patch GUIDs.\n");\r
-\r
-    // Patch GUIDs\r
-    if (insertGUIDs && !patchGUIDs(image, guids, interactive))\r
-    {\r
-        printf("Aborting burn operation at user request.\n");\r
-        return true;\r
-    }\r
-\r
-    M_DEBUG("Patch VSDs.\n");\r
-\r
-    // Patch VSDs\r
-    if (!patchVSDs(image, NULL))\r
-    {\r
-        // if this fails it means it's a short image, and we should just continue on\r
-    }\r
-\r
-    M_DEBUG("Write firmware.\n");\r
-\r
-    // Burn it\r
-    if (!device.write_image(0, image.getBuf(), image.getBufLength(), eraseInvariant, (_isatty(_fileno( stdin )) > 0? true: false)) )\r
-    {\r
-        printf("Error: %s\n", device._err);\r
-        return false;\r
-    }\r
-    \r
-    device.close();\r
-    image.close();\r
-\r
-    return true;\r
-}\r
-\r
-bool patchVSDToRawImage(FlashCommandLine cl)\r
-{    \r
-    printf("Attempting to insert VSD section into the %s file: \n", cl.getRawFileName());\r
-\r
-    if (!image.open(cl.getRawFileName()))\r
-    {\r
-        printf("Error: %s\n", image._err);\r
-        printf("Aborting operation.\n");\r
-        return false;\r
-    }\r
-\r
-    if (!patchVSDs(image, cl.getRevisionString()))\r
-    {\r
-        printf("Failed.\n"\r
-               "!!!WARNING!!!\n"\r
-               "Unable to inject the VSD into a Short Image.\n"\r
-               "Short images do not support the VSD section.\n"\r
-               "Only Fail Safe images support the VSD section.\n"\r
-               "Aborting operation.\n");\r
-        return false;\r
-    }\r
-\r
-    FILE *fd;\r
-    void *write_buffer;\r
-    uint32_t buflen = image.getBufLength();\r
-\r
-    // it is necessary to close the file prior to re-opening for write privileges\r
-    // this allows us to write to the same file without using a temporary file\r
-    write_buffer = malloc(buflen);\r
-    memcpy(write_buffer, image.getBuf(), buflen); \r
-    image.close();  \r
-        \r
-    // only open the file, if any things fails, then the image verify\r
-    // will indicate issues\r
-    if ((fd = fopen(cl.getRawFileName(),"w")) != NULL)\r
-    {\r
-        fwrite(write_buffer, buflen, 1, fd);\r
-        fclose(fd);\r
-    } else\r
-    {\r
-        printf("Failed.\n"\r
-               "Unable to write to raw image file %s.\n", cl.getRawFileName());\r
-        _silent=true;\r
-        if (!image.verify()) // verify file integrity\r
-        {\r
-            printf("!!!WARNING!!! "\r
-                   "The file appears to have been corrupted!!!\n");            \r
-            return false;\r
-        } else\r
-        {\r
-            printf("File appears to be valid, but the VSD injection failed.\n");\r
-        }\r
-        _silent=false;\r
-\r
-        return false;\r
-    }\r
-    \r
-    // ok to free the buffer now\r
-    free(write_buffer);    \r
-\r
-    if (!image.open(cl.getRawFileName()))\r
-    {\r
-        printf("Error: %s\n", image._err);\r
-        printf("Aborting operation.\n");\r
-        return false;\r
-    }\r
-    _silent=true;\r
-    if (!image.verify()) // verify file integrity\r
-    {\r
-        printf("Failed Verification.\n"\r
-               "The file %s appears to have been corrupted\n", cl.getRawFileName());\r
-        return false;\r
-    }\r
-    _silent=false;\r
-    image.close();\r
-    printf("Insertion                    : [SUCCESS]\n");\r
-    printf("Done.\n");\r
-    return true;\r
-}\r
-\r
-bool showInfo(FBase &device, FlashCommandLine cl)\r
-{\r
-    uint32_t NODE_GUIDH, NODE_GUIDL;\r
-    uint32_t PORT1_GUIDH, PORT1_GUIDL;\r
-    uint32_t PORT2_GUIDH, PORT2_GUIDL;\r
-    uint32_t hardwareversion;\r
-    uint32_t psptr;\r
-    uint32_t signature;\r
-    int section = 1;\r
-    PS    ps;\r
-       time_t myTime;\r
-    bool isFailSafe = false;\r
-    uint64_t guids[GUIDS];\r
-    char revision[FlashCommandLine::revisionStringLength];\r
-\r
-    READ4(device, 0x24, &signature, "Signature");\r
-    TOCPU1(signature);\r
-\r
-    if (DebugMode)\r
-    {\r
-        _silent=false;\r
-    } else\r
-    {\r
-        _silent=false;\r
-    }\r
-    \r
-    if (signature == SIGNATURE)\r
-    {\r
-        uint8_t offset =0, x=0;\r
-        // Fail Safe image\r
-        \r
-        // verify the image invariant section\r
-        if (!checkBoot2(device, 0, 0x28, psptr, "Invariant\t"))\r
-        {\r
-            printf("Invariant section is not valid!");\r
-            _silent=false;\r
-            return false;\r
-        }\r
-\r
-        if (!checkPS(device, SECT_SIZE, psptr, "Primary\t"))\r
-        {\r
-            M_DEBUG("Primary section is not valid\n");\r
-            // If the primary is invalid then try secondary section         \r
-            if (!checkPS(device, SECT_SIZE*2, psptr, "Secondary\t"))\r
-            {\r
-                printf("Firmware is corrupted.  Unable to display information.\n");\r
-                _silent=false;\r
-                return false;\r
-            }\r
-            section=2; // secondary is valid, use it\r
-        }\r
-        \r
-        device.read(0x10, &hardwareversion, sizeof(hardwareversion));\r
-               TOCPU1(hardwareversion);\r
-               hardwareversion >>=24;\r
-        device.read(SECT_SIZE*section, &ps, sizeof(ps));\r
-        TOCPUBY(ps,sizeof(ps));\r
-               printf("PSID              : %s\n",ps.psid.as_str);\r
-               printf("Image Type        : Fail Safe\n");\r
-        if (hardwareversion != 0xA0 && hardwareversion != 0xA1)\r
-        {\r
-            printf("Hardware Version  : 0xInvalid\n");\r
-\r
-        } else\r
-        {\r
-            printf("Hardware Version  : 0x%"PRIX32"\n", hardwareversion);\r
-        }\r
-        printf("Company           : %s\n",  ps.vsd[0]==0x00066A?"SilverStorm Technologies":"Mellanox, Inc");\r
-\r
-               myTime = ps.vsd[2];\r
-        printf("%s Date     : %s", (device.getClassType()==Flash::FlashDeviceType?"Burn    ":"Creation"), asctime(localtime(&myTime))); \r
-\r
-        for (x=3;x<9;x++)\r
-        {                      \r
-            memcpy(revision+offset, &ps.vsd[x], sizeof(uint32_t));\r
-            offset = offset + 4;\r
-        }\r
-        revision[FlashCommandLine::revisionStringLength-1]='\0';\r
-        printf("Firmware Revision : %s\n", revision);\r
-        READ4(device, ps.fi_addr+0x24, &psptr, "pointer section");        \r
-        printf("Firmware Address  : 0x%"PRIx32"\n", ps.fi_addr);\r
-        printf("Node GUID Offset  : 0x%"PRIx32"\n", psptr);        \r
-        psptr = BE2CPU32(psptr)+ps.fi_addr;        \r
-        isFailSafe = true;\r
-    }\r
-    else\r
-    {\r
-        if (!checkList(device, 0,""))\r
-        {\r
-            printf("Firmware is not valid.  Can not display information.\n");\r
-            _silent=false;\r
-            return false;\r
-        }\r
-        // Short image\r
-        // Assume flash has been verified, and both images have the same guids, therefore,\r
-        // we only need to read the primary image's guids\r
-        device.read(0x10, &hardwareversion, sizeof(hardwareversion));\r
-               TOCPU1(hardwareversion);\r
-               hardwareversion >>=24;\r
-        printf("Image Type        : Short\n");\r
-        if (hardwareversion != 0xA0 && hardwareversion != 0xA1)\r
-        {\r
-            printf("Hardware Version  : 0xInvalid\n");\r
-\r
-        } else\r
-        {\r
-            printf("Hardware Version  : 0x%X\n", hardwareversion);\r
-        }\r
-        printf("Company           :   Unknown\n");\r
-        printf("%s Date     :   Unknown\n", (device.getClassType()==Flash::FlashDeviceType?"Burn    ":"Creation")); \r
-        printf("Firmware Revision :   Unknown\n");   \r
-        printf("Firmware Address  : 0xUnknown\n");\r
-        psptr = signature;  \r
-        if (psptr < MST_MAX_FLASH )\r
-        {\r
-            printf("Node GUID Offset  : 0x%"PRIx32"\n", psptr); \r
-        } else\r
-        {\r
-            printf("Node GUID Offset  : 0x%"PRIx32" !!! Error: Invalid !!!\n", psptr); \r
-        }\r
-     \r
-    }\r
-\r
-    if (psptr < MST_MAX_FLASH || isFailSafe) \r
-    {\r
-        READ4(device, psptr, &NODE_GUIDH, "Node GUID High");\r
-        READ4(device, psptr+4, &NODE_GUIDL, "Node GUID Low");\r
-        guids[0] = BE2CPU32(NODE_GUIDH);\r
-        guids[0] = (guids[0]<<32) | BE2CPU32(NODE_GUIDL);\r
-        READ4(device, psptr+8, &PORT1_GUIDH, "Port 1 GUID High");\r
-        READ4(device, psptr+12, &PORT1_GUIDL, "Port 1 GUID Low");\r
-        guids[1] = BE2CPU32(PORT1_GUIDH);\r
-        guids[1] = (guids[1]<<32) | BE2CPU32(PORT1_GUIDL);\r
-        READ4(device, psptr+16, &PORT2_GUIDH, "Port 2 GUID High");\r
-        READ4(device, psptr+20, &PORT2_GUIDL, "Port 2 GUID Low");\r
-        guids[2] = BE2CPU32(PORT2_GUIDH);\r
-        guids[2] = (guids[2]<<32) | BE2CPU32(PORT2_GUIDL);\r
-\r
-        guids[3] = guids[0];\r
-        printf("Node  GUID        : 0x%016"PRIx64"\n", guids[0]);\r
-        printf("Port1 GUID        : 0x%016"PRIx64"\n", guids[1]);\r
-        printf("Port2 GUID        : 0x%016"PRIx64"\n", guids[2]);\r
-    } else \r
-    {\r
-        printf("Node  GUID        : 0xInvalid\n");\r
-        printf("Port1 GUID        : 0xInvalid\n");\r
-        printf("Port2 GUID        : 0xInvalid\n");\r
-        printf("!!! WARNING: The flash %s is corrupted.\n"\r
-               "You must use the -n <0xGUID> and --force option to update this device.\n", \r
-               cl.getDeviceName());           \r
-        _silent=false;\r
-        return false;\r
-    }\r
-    _silent=false;\r
-    return true;\r
-}\r
-\r
-////////////////////////////////////////////////////////////////////////\r
-//                                                                    //\r
-// ****************************************************************** //\r
-//                           MAIN                                     //\r
-// ****************************************************************** //\r
-//                                                                    //\r
-////////////////////////////////////////////////////////////////////////\r
-int __cdecl\r
-main(uint32_t ac, char *av[])\r
-{\r
-    FlashCommandLine cl;\r
-\r
-       //try to get lock on box\r
-       if (FwUpdateLock() != 0 )\r
-               return -1;\r
-       \r
-       // register unlock func in exit\r
-       _onexit((_onexit_t)FwUpdateUnlock);\r
-       \r
-       cl.parse(ac, av);\r
-\r
-    if (cl.isOption(FlashCommandLine::debug))\r
-    {\r
-        DebugMode = true;\r
-               g_fw_dbg_lvl = 1;\r
-    }\r
-\r
-    if (cl.isOption(FlashCommandLine::disable_bestdevice))\r
-    {\r
-        DisableBestDevice = true;\r
-    }\r
-\r
-    \r
-    if (cl.isOption(FlashCommandLine::flash_format))\r
-    {\r
-        if (!device.open(cl.getDeviceName()))\r
-        {\r
-            printf("Error: %s %s\n", device._err, cl.getDeviceName());\r
-            return -1;\r
-        }\r
-\r
-        device.format();\r
-        device.close();        \r
-    }\r
-\r
-       if (cl.isOption(FlashCommandLine::show_image_info))\r
-    {\r
-        if (!image.open(cl.getRawFileName()))\r
-        {\r
-            printf("Error: %s\n", image._err);\r
-            return -1;\r
-        }\r
-\r
-        showInfo(image, cl);\r
-        image.close();\r
-    }\r
-\r
-    if (cl.isOption(FlashCommandLine::show_flash_info))\r
-    {\r
-        if (!device.open(cl.getDeviceName()))\r
-        {\r
-            printf("Error: %s %s\n", device._err, cl.getDeviceName());\r
-                       return -1;\r
-        }\r
-\r
-        showInfo(device, cl);\r
-        device.close();\r
-    }\r
-\r
-    if (cl.isOption(FlashCommandLine::dump_image))\r
-    {\r
-        if (!image.open(cl.getRawFileName()))\r
-        {\r
-            printf("Error: %s\n", image._err);\r
-            return -1;\r
-        }\r
-        image.dump();\r
-        image.close();\r
-\r
-    }\r
-    \r
-    if (cl.isOption(FlashCommandLine::dump_flash))\r
-    {\r
-        if (!device.open(cl.getDeviceName()))\r
-        {\r
-            printf("Error: %s %s\n", device._err, cl.getDeviceName());\r
-            return -1;\r
-        }\r
-        device.dump();\r
-        device.close();    \r
-    }\r
-\r
-    if (cl.isOption(FlashCommandLine::verify_image))\r
-    {\r
-        if (!image.open(cl.getRawFileName()))\r
-        {\r
-            printf("Error: %s\n", image._err);\r
-            return -1;\r
-        }\r
-        image.verify();\r
-        image.close();\r
-    }\r
-\r
-    if (cl.isOption(FlashCommandLine::verify_flash))\r
-    {\r
-        if (!device.open(cl.getDeviceName()))\r
-        {\r
-            printf("Error: %s %s\n", device._err, cl.getDeviceName());\r
-            return -1;\r
-        }\r
-        device.verify();\r
-        device.close();\r
-    }\r
-\r
-    if (cl.isOption(FlashCommandLine::write_file))\r
-    {\r
-        if (!patchVSDToRawImage(cl))\r
-        {\r
-            return -1;\r
-        }        \r
-    }\r
-\r
-    if (cl.isOption(FlashCommandLine::burn))\r
-    {\r
-        if (!burnImageToFlash(cl))\r
-        {\r
-            return -1;\r
-        }\r
-\r
-        // For A0 HCAs we need to write to both banks of the flash.\r
-        if ((devType == TAVOR_TYPE) && (devRevision == 0xA0))\r
-        {\r
-            device.setGPIOState(Flash::High);\r
-\r
-            if (!burnImageToFlash(cl))\r
-            {\r
-                return -1;\r
-            }\r
-        }\r
-    }\r
-\r
-    return 0;\r
-}\r
-\r
-bool probePciBusForHcaDevice(const char *device)\r
-{\r
-    FILE *stream;\r
-    char output[MAXPATHLEN];\r
-       char tmpRevision[5];\r
-       uint32_t i;\r
-\r
-    devId = HcaDevnameToDevId(device);\r
-    devType = HcaDevnameToDevType(device);\r
-\r
-       sprintf(output,"lspci -m -n | grep 15b3 | grep %x",devType);\r
-    stream = _popen(output, "r");\r
-    \r
-    if (NULL == stream)\r
-    {\r
-        printf("Error probing the PCI bus for HCA devcies.\n");\r
-        return false;\r
-    }\r
-    M_DEBUG("Probing PCI bus for HCA devices.\n");\r
-       i = 0;\r
-    while (fgets(output, MAXPATHLEN, stream))\r
-    {\r
-        if (mellanox_mode)\r
-               {\r
-                       if (i++ != devId) continue;\r
-               } else\r
-               {\r
-                       if (++i != devId) continue;\r
-               }\r
-                       \r
-        if (strlen(output)>1)\r
-            output[strlen(output)-1]='\0';\r
-\r
-        tmpRevision[0] = '0';\r
-        tmpRevision[1] = 'x';\r
-        tmpRevision[2] = output[37];\r
-        tmpRevision[3] = output[38];\r
-        tmpRevision[4] = '\0';\r
-\r
-        // probably should check errno in case of an invalid revision\r
-        devRevision = strtol(tmpRevision, (char**)NULL, 0);     \r
-\r
-        sprintf(bestDev, "/dev/mst/mt%d_pci_cr%d", devType, devId);\r
-\r
-        M_DEBUG("Trying device %s.\n", bestDev);\r
-\r
-        if (NULL != fopen(bestDev, "r"))\r
-        {\r
-            M_DEBUG("HCA %d (Rev. %"PRIx32") using device name %s.\n", devId, devRevision, bestDev);\r
-        } else\r
-        {\r
-            sprintf(bestDev, "/dev/mst/mt%d_pciconf%d", devType, devId);\r
-            M_DEBUG("Trying device %s.\n", bestDev);\r
-\r
-            if (NULL != fopen(bestDev, "r"))\r
-            {\r
-               M_DEBUG("HCA %d (Rev. %"PRIx32") using device name %s.\n", devId, devRevision, bestDev);\r
-            } else\r
-            {\r
-               printf("We found HCA %d on the PCI bus, but it does not appear to be operating properly.\n", devId);\r
-               printf("Please verify the mst device driver is running without errors.  If the problem persist,\n"\r
-                   "then contact technical support.\n");\r
-            }\r
-                       _pclose(stream);\r
-                       return false;\r
-        }       \r
-       _pclose(stream);    \r
-       return true;\r
-    }\r
-\r
-    printf("Specified device %d not found.\n", devId);\r
-    printf("Found %d device%s of type mt%d\n",i,(i==1)?"":"s",devType);\r
-    _pclose(stream);    \r
-    return false;\r
-}\r
-\r
-uint32_t HcaDevnameToDevId(const char *devname)\r
-{\r
-    if (strlen(devname) >= 1)\r
-    {\r
-        if (isdigit(devname[strlen(devname)-1]))\r
-        {\r
-            return ((uint8_t)devname[strlen(devname)-1])-48;\r
-        } else\r
-        {\r
-            M_DEBUG("Device name should end with a numeric value between 1 and 9.\n");\r
-        }\r
-    \r
-    } else\r
-    {\r
-        M_DEBUG("Device name is too short.\n");\r
-    }\r
-    \r
-    M_DEBUG("Invalid device name using default device 1.\n");\r
-    return 1;\r
-}\r
-\r
-uint32_t HcaDevnameToDevType(const char *devname)\r
-{\r
-       uint32_t type = 0;\r
-       char *str;\r
-\r
-       str = strstr(devname, "mt");\r
-       if (str)\r
-       {\r
-               str += 2;\r
-               type = strtol(str, NULL, 10);\r
-       }\r
-       if ((type != TAVOR_TYPE) && (type != ARBEL_TYPE))\r
-       {\r
-        M_DEBUG("Device name should contain device type, using mt23108.\n");\r
-               type = TAVOR_TYPE;\r
-       }\r
-    return type;\r
-}\r
-\r
-bool isMstLoaded(void)\r
-{\r
-    FILE *stream;\r
-    char output[MAXPATHLEN];\r
-\r
-    /* Check for infinicon-compiled mst driver. */\r
-    stream = _popen("/sbin/lsmod | grep mst |cut -d\" \" -f1", "r");\r
-    \r
-    if (NULL == stream)\r
-        return false;\r
-\r
-    fgets(output, MAXPATHLEN, stream);\r
-\r
-    if (strlen(output)>1)\r
-        output[strlen(output)-1]='\0';\r
-\r
-    _pclose(stream);\r
-\r
-    if ((NULL != output) && (strncmp("mst", output, MAXPATHLEN) == 0))\r
-        return true;\r
-\r
-    /* That failed - check for mellanox-compiled mst driver. */\r
-    stream = _popen("/sbin/lsmod | grep mst_pci |cut -d\" \" -f1", "r");\r
-    \r
-    if (NULL == stream)\r
-        return false;\r
-\r
-    fgets(output, MAXPATHLEN, stream);\r
-\r
-    if (strlen(output)>1)\r
-        output[strlen(output)-1]='\0';\r
-\r
-    _pclose(stream);\r
-\r
-    if ((NULL != output) && (strncmp("mst_pci", output, MAXPATHLEN) == 0))\r
-    {\r
-        mellanox_mode = 1;\r
-        return true;\r
-    }\r
-    else\r
-        return false;\r
-}\r
-\r
-void __cdecl catch_signal( int sig )\r
-{\r
-    //fprintf( stdout, "\nProgram Interrupted.  Closing devices.\n" );\r
-    //device.close();\r
-    //image.close();\r
-    //exit( 0 );\r
-}\r
-\r
-static int\r
-FwUpdateLock(void)\r
-{\r
-       int status = 0;\r
-       if ((file_lock = _open( LOCK_FILE_NAME, _O_CREAT | _O_EXCL, _S_IREAD | _S_IWRITE )) == -1 )\r
-       {\r
-               printf("One instance is running already\n");\r
-               status = -1;\r
-       }\r
-       return status;\r
-}\r
-static void \r
-FwUpdateUnlock(void)\r
-{\r
-       if ((_close(file_lock)) != -1 )\r
-       {\r
-               if ((_unlink(LOCK_FILE_NAME)) != -1 )\r
-               {\r
-                       return;\r
-               }\r
-       }\r
-       printf("Unlock can not release lock\n");\r
-}
\ No newline at end of file
diff --git a/tools/fwupdate/user/makefile b/tools/fwupdate/user/makefile
deleted file mode 100644 (file)
index 66f1c8e..0000000
+++ /dev/null
@@ -1,8 +0,0 @@
-#\r
-# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source\r
-# file to this component.  This file merely indirects to the real make file\r
-# that is shared by all the driver components of the Windows NT DDK\r
-#\r
-\r
-!INCLUDE $(NTMAKEENV)\makefile.def\r
-\r
diff --git a/tools/fwupdate/user/mtcr.h b/tools/fwupdate/user/mtcr.h
deleted file mode 100644 (file)
index 719beec..0000000
+++ /dev/null
@@ -1,227 +0,0 @@
-/*\r
- * Copyright (c) 2004-2005 Mellanox Technologies Ltd.  All rights reserved.\r
- *\r
- * This software is available to you under the OpenIB.org BSD license\r
- * below:\r
- *\r
- *     Redistribution and use in source and binary forms, with or\r
- *     without modification, are permitted provided that the following\r
- *     conditions are met:\r
- *\r
- *      - Redistributions of source code must retain the above\r
- *        copyright notice, this list of conditions and the following\r
- *        disclaimer.\r
- *\r
- *      - Redistributions in binary form must reproduce the above\r
- *        copyright notice, this list of conditions and the following\r
- *        disclaimer in the documentation and/or other materials\r
- *        provided with the distribution.\r
- *\r
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
- * SOFTWARE.\r
- *\r
- * $Id$\r
- */\r
-\r
-#ifndef _MST_H\r
-#define _MST_H\r
-\r
-#include <sys/types.h>\r
-\r
-#ifdef WIN32\r
-\r
-#define MTCR_API\r
-\r
-typedef unsigned __int8  u_int8_t;\r
-typedef __int8           int8_t;\r
-typedef unsigned __int16 u_int16_t;\r
-typedef __int16          int16_t;\r
-typedef unsigned __int32 u_int32_t;\r
-typedef __int32          int32_t;\r
-typedef unsigned __int64 u_int64_t;\r
-typedef __int64          int64_t;\r
-#if defined(_WIN64)\r
-    typedef __int64 MT_long_ptr_t;\r
-    typedef unsigned __int64 MT_ulong_ptr_t;\r
-#else\r
-    typedef long MT_long_ptr_t;\r
-    typedef unsigned long MT_ulong_ptr_t;\r
-#endif\r
-       \r
-#else  /* UNIX */\r
-\r
-#define MTCR_API\r
-\r
-#endif\r
-\r
-\r
-#ifdef __cplusplus\r
-extern "C" {\r
-#endif\r
-\r
-typedef struct mib_private_t {\r
-    int  dummy;\r
-} MIB_Private;\r
-\r
-typedef enum { MACCELERATE, MRESTORE, MREAD4, MWRITE4, MREAD64, MWRITE64 } mif_ioctl_cmd_t;\r
-\r
-typedef enum MType_t {MST_PCI, MST_PCICONF, MST_CALBR, MST_USB, MST_IB, MST_IF, MST_PPC, MST_USB_DIMAX} MType;\r
-typedef enum DType_t {MST_GAMLA, MST_TAVOR, MST_DIMM, MST_NOADDR} DType;\r
-#define MST_ANAFA2 MST_TAVOR\r
-#define MST_EEPROM MST_GAMLA\r
-enum Mdevs_t {\r
-    MDEVS_GAMLA     = 0x01, // Each device that actually is a Gamla\r
-    MDEVS_I2CM      = 0x02, // Each device that can work as I2C master\r
-    MDEVS_MEM       = 0x04, // Each device that is a memory driver (vtop)\r
-    MDEVS_TAVOR_DDR = 0x08, // Each device that maps to Tavor DDR\r
-    MDEVS_TAVOR_UAR = 0x10, // Each device that maps to Tavor UAR\r
-    MDEVS_TAVOR_CR  = 0x20, // Each device that maps to Tavor CR\r
-    MDEVS_IF        = 0x40, // Standard device  interface\r
-    MDEVS_REM       = 0x80, // Remote devices\r
-    MDEVS_PPC       = 0x100, // PPC devices\r
-    MDEVS_TAVOR     = (MDEVS_TAVOR_DDR|MDEVS_TAVOR_UAR|MDEVS_TAVOR_CR),\r
-    MDEVS_ALL       = 0xffffffff\r
-};\r
-\r
-// All fields in follow structure are not supposed to be used\r
-// or modified by user programs. Except i2c_slave that may be\r
-// modified before each access to target I2C slave address\r
-typedef struct mfile_t {\r
-    MType         tp;           // type of driver\r
-    DType         dtype;        // target device to access to\r
-    DType         itype;        // interface device to access via\r
-    int           is_i2cm;      // use device as I2C master\r
-    unsigned char i2c_slave;\r
-#ifdef __WIN__\r
-    MT_ulong_ptr_t fd;\r
-#else\r
-    int           fd;\r
-#endif\r
-    int           sock;         // in not -1 - remote interface\r
-    void          *ptr;\r
-    MIB_Private   mib;          // Data for IB interface (if relevant)\r
-    unsigned int  i2c_RESERVED; // Reserved for internal usage (i2c internal)\r
-} mfile;\r
-\r
-typedef struct mif_param_st {\r
-       mif_ioctl_cmd_t cmd;\r
-\r
-        DType dtype;\r
-\r
-        char addr;\r
-        int len;\r
-        int imm;\r
-        int offset;\r
-        void * buf;\r
-} mif_param_t;\r
-\r
-#ifdef WIN32\r
-#define FromHandle(h)  ((MT_long_ptr_t)(h))\r
-#define ToHandle(h)            ((HANDLE)(h))\r
-#else\r
-#define FromHandle(h)  ((int)(h))\r
-#define ToHandle(h)            ((HANDLE)(h))\r
-#endif\r
-\r
-/*\r
- * Get list of MST (Mellanox Software Tools) devices.\r
- * Put all device names as null-terminated strings to buf.\r
- *\r
- * Return number of devices found or -1 if buf overflow\r
- */\r
-MTCR_API int mdevices(char *buf, int len, int mask);\r
-\r
-/*\r
- * Open Mellanox Software tools (mst) driver.\r
- * Return valid mfile ptr or 0 on failure\r
- */\r
-\r
-/*\r
- * Open Mellanox Software tools (mst) driver. Device type==TAVOR\r
- * Return valid mfile ptr or 0 on failure\r
- */\r
-MTCR_API mfile *mopen(int hca_num);\r
-\r
-/*\r
- * Close Mellanox driver\r
- * req. descriptor\r
- */\r
-MTCR_API int mclose(mfile *mf);\r
-\r
-/*\r
- * Accelerate device if possible.\r
- * When device is I2C master - overclock it\r
- */\r
-MTCR_API void maccelerate(mfile *mf);\r
-\r
-/*\r
- * Restore normal settings, if device was accelerated.\r
- */\r
-MTCR_API void mrestore(mfile *mf);\r
-\r
-/*\r
- * Read 4 bytes, return number of succ. read bytes or -1 on failure\r
- */\r
-MTCR_API int mread4(mfile *mf, unsigned int offset, u_int32_t *value);\r
-\r
-/*\r
- * Write 4 bytes, return number of succ. written bytes or -1 on failure\r
- */\r
-MTCR_API int mwrite4(mfile *mf, unsigned int offset, u_int32_t value);\r
-\r
-/*\r
- * Read up to 64 bytes, return number of succ. read bytes or -1 on failure\r
- *\r
- * This makes sense only w/ CALIBRE/DevaSys interfaces *to EEPROM reading only*\r
- */\r
-MTCR_API int mread64(mfile *mf, unsigned int offset, void *data, int length);\r
-\r
-/*\r
- * Write up to 64 bytes, return number of succ. written bytes or -1 on failure\r
- *\r
- * This makes sense only w/ CALIBRE/DevaSys interfaces *to EEPROM burning only*\r
- */\r
-MTCR_API int mwrite64(mfile *mf, unsigned int offset, void *data, int length);\r
-\r
-/*\r
- * Set a new value for i2c_slave\r
- * Return previous value\r
- */\r
-MTCR_API unsigned char mset_i2c_slave(mfile *mf, unsigned char new_i2c_slave);\r
-\r
-/*\r
- * get free phys. contigous pages \r
- * order should be in range [0..9]\r
- * the size of allocated memory will be (2^order * 4096)\r
- * return pointer to virtual address mapped to the allocated area\r
- * on failure returns 0 and errno is set\r
- */\r
-MTCR_API void *mget_free_pages (mfile *mf, unsigned int order);\r
-\r
-/*\r
- * free phys. contigous pages \r
- * order should be in range [0..9]\r
- * vma is freed\r
- * on success returns 0\r
- * on failure returns -1 and errno is set\r
- */\r
-MTCR_API int mfree_pages (mfile *mf, void *addr, unsigned int order);\r
-\r
-/*\r
- * translate virtual address to physical address\r
- * return physical address on success, or 0 on error\r
- */\r
-MTCR_API unsigned long mvtop (mfile *mf, void *va);\r
-\r
-#ifdef __cplusplus\r
-}\r
-#endif\r
-\r
-\r
-#endif\r