Changeset 16393


Ignore:
Timestamp:
2009-06-09T10:04:52+02:00 (7 years ago)
Author:
florian
Message:

[brcm63xx] rework imagetag firmware generator and MTD partition parser to accomodate with all known
imagetag versions from Broadcom and vendors, patch from Daniel Dickinson (fixes #4987).

Location:
trunk
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/brcm63xx/files/drivers/mtd/maps/bcm963xx-flash.c

    r15900 r16393  
    4444}; 
    4545 
     46static struct tagiddesc_t tagidtab[NUM_TAGID] = TAGID_DEFINITIONS; 
     47 
     48static uint32_t tagcrc32tab[256] = { 
     49        0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 
     50        0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 
     51        0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 
     52        0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 
     53        0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 
     54        0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 
     55        0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, 
     56        0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 
     57        0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 
     58        0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, 
     59        0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 
     60        0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 
     61        0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 
     62        0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 
     63        0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, 
     64        0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 
     65        0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 
     66        0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 
     67        0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 
     68        0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 
     69        0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 
     70        0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, 
     71        0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 
     72        0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 
     73        0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 
     74        0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 
     75        0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 
     76        0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 
     77        0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 
     78        0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 
     79        0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 
     80        0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D 
     81}; 
     82 
     83static uint32_t tagcrc32(uint32_t crc, uint8_t *data, size_t len) 
     84{ 
     85        while (len--) 
     86                crc = (crc >> 8) ^ tagcrc32tab[(crc ^ *data++) & 0xFF]; 
     87 
     88        return crc; 
     89} 
     90 
    4691static int parse_cfe_partitions( struct mtd_info *master, struct mtd_partition **pparts) 
    4792{ 
    4893        int nrparts = 3, curpart = 0; /* CFE,NVRAM and global LINUX are always present. */ 
    49         struct bcm_tag *buf; 
     94        union bcm_tag *buf; 
    5095        struct mtd_partition *parts; 
    5196        int ret; 
     
    5398        unsigned int rootfsaddr, kerneladdr, spareaddr; 
    5499        unsigned int rootfslen, kernellen, sparelen, totallen; 
     100        unsigned char *tagid; 
    55101        int namelen = 0; 
    56102        int i; 
     103        uint32_t tagidcrc; 
     104        uint32_t calctagidcrc; 
     105        bool tagid_match = false; 
     106        char *boardid; 
     107        char *tagversion; 
     108        char *matchtagid; 
    57109 
    58110        /* Allocate memory for buffer */ 
    59         buf = vmalloc(sizeof(struct bcm_tag)); 
     111        buf = vmalloc(sizeof(union bcm_tag)); 
    60112        if (!buf) 
    61113                return -ENOMEM; 
    62114 
    63115        /* Get the tag */ 
    64         ret = master->read(master,master->erasesize,sizeof(struct bcm_tag), &retlen, (void *)buf); 
    65         if (retlen != sizeof(struct bcm_tag)){ 
     116        ret = master->read(master,master->erasesize,sizeof(union bcm_tag), &retlen, (void *)buf); 
     117        if (retlen != sizeof(union bcm_tag)){ 
    66118                vfree(buf); 
    67119                return -EIO; 
    68120        } 
    69         printk(KERN_INFO PFX "CFE boot tag found with version %s and board type %s.\n",buf->tagVersion,buf->boardid); 
    70          
    71         /* Get the values and calculate */ 
    72         sscanf(buf->rootAddress,"%u", &rootfsaddr); 
     121 
     122        /* tagId isn't in the same location, so we check each tagid against the 
     123         * tagid CRC.  If the CRC is valid we have found the right tag and so 
     124         * use that tag 
     125         */ 
     126 
     127        for (i = 0; i < NUM_TAGID; i++) { 
     128          switch(i) { 
     129          case 0: 
     130            matchtagid = "bccfe"; 
     131            tagid = &(buf->bccfe.tagId[0]); 
     132            sscanf(buf->bccfe.rootAddress,"%u", &rootfsaddr); 
     133            sscanf(buf->bccfe.rootLength, "%u", &rootfslen); 
     134            sscanf(buf->bccfe.kernelAddress, "%u", &kerneladdr); 
     135            sscanf(buf->bccfe.kernelLength, "%u", &kernellen); 
     136            sscanf(buf->bccfe.totalLength, "%u", &totallen); 
     137            tagidcrc = buf->bccfe.tagIdCRC; 
     138            tagversion = &(buf->bccfe.tagVersion[0]); 
     139            boardid = &(buf->bccfe.boardid[0]); 
     140            break; 
     141          case 1: 
     142            matchtagid = "bc300"; 
     143            tagid = &(buf->bc300.tagId[0]); 
     144            sscanf(buf->bc300.rootAddress,"%u", &rootfsaddr); 
     145            sscanf(buf->bc300.rootLength, "%u", &rootfslen); 
     146            sscanf(buf->bc300.kernelAddress, "%u", &kerneladdr); 
     147            sscanf(buf->bc300.kernelLength, "%u", &kernellen); 
     148            sscanf(buf->bc300.totalLength, "%u", &totallen); 
     149            tagidcrc = buf->bc300.tagIdCRC; 
     150            tagversion = &(buf->bc300.tagVersion[0]); 
     151            boardid = &(buf->bc300.boardid[0]); 
     152            break; 
     153          case 2: 
     154            matchtagid = "ag306"; 
     155            tagid = &(buf->ag306.tagId[0]); 
     156            sscanf(buf->ag306.rootAddress,"%u", &rootfsaddr); 
     157            sscanf(buf->ag306.rootLength, "%u", &rootfslen); 
     158            sscanf(buf->ag306.kernelAddress, "%u", &kerneladdr); 
     159            sscanf(buf->ag306.kernelLength, "%u", &kernellen); 
     160            sscanf(buf->ag306.totalLength, "%u", &totallen); 
     161            tagidcrc = buf->ag306.tagIdCRC; 
     162            tagversion = &(buf->ag306.tagVersion[0]); 
     163            boardid = &(buf->ag306.boardid[0]); 
     164            break; 
     165          case 3: 
     166            matchtagid = "bc308"; 
     167            tagid = &(buf->bc308.tagId[0]); 
     168            sscanf(buf->bc308.rootAddress,"%u", &rootfsaddr); 
     169            sscanf(buf->bc308.rootLength, "%u", &rootfslen); 
     170            sscanf(buf->bc308.kernelAddress, "%u", &kerneladdr); 
     171            sscanf(buf->bc308.kernelLength, "%u", &kernellen); 
     172            sscanf(buf->bc308.totalLength, "%u", &totallen); 
     173            tagidcrc = buf->bc308.tagIdCRC; 
     174            tagversion = &(buf->bc308.tagVersion[0]); 
     175            boardid = &(buf->bc308.boardid[0]); 
     176            break; 
     177          case 4: 
     178            matchtagid = "bc310"; 
     179            tagid = &(buf->bc310.tagId[0]); 
     180            sscanf(buf->bc310.rootAddress,"%u", &rootfsaddr); 
     181            sscanf(buf->bc310.rootLength, "%u", &rootfslen); 
     182            sscanf(buf->bc310.kernelAddress, "%u", &kerneladdr); 
     183            sscanf(buf->bc310.kernelLength, "%u", &kernellen); 
     184            sscanf(buf->bc310.totalLength, "%u", &totallen); 
     185            tagidcrc = buf->bc310.tagIdCRC; 
     186            tagversion = &(buf->bc310.tagVersion[0]); 
     187            boardid = &(buf->bc310.boardid[0]); 
     188            break; 
     189          } 
     190          if (strncmp(tagid, matchtagid, TAGID_LEN) != 0) { 
     191            continue; 
     192          } 
     193 
     194          calctagidcrc = tagcrc32(IMAGETAG_CRC_START, tagid, TAGID_LEN); 
     195          if (tagidcrc = calctagidcrc) { 
     196            tagid_match = true; 
     197            break; 
     198          } 
     199        } 
     200 
     201        if (!tagid_match) { 
     202          printk(KERN_ERR PFX "Failed to find a valid tag id\n"); 
     203          return -EIO; 
     204        } 
     205 
     206        printk(KERN_INFO PFX "CFE boot tag found with version %s, board type %s, and tagid %s.\n",tagversion,boardid,tagid); 
     207         
    73208        rootfsaddr = rootfsaddr - EXTENDED_SIZE; 
    74         sscanf(buf->rootLength, "%u", &rootfslen); 
    75         sscanf(buf->kernelAddress, "%u", &kerneladdr); 
    76209        kerneladdr = kerneladdr - EXTENDED_SIZE; 
    77         sscanf(buf->kernelLength, "%u", &kernellen); 
    78         sscanf(buf->totalLength, "%u", &totallen); 
    79210        spareaddr = roundup(totallen,master->erasesize) + master->erasesize; 
    80211        sparelen = master->size - spareaddr - master->erasesize; 
  • trunk/target/linux/brcm63xx/files/include/asm-mips/mach-bcm63xx/bcm_tag.h

    r15253 r16393  
    44#define IMAGE_LEN 10                   /* Length of Length Field */ 
    55#define ADDRESS_LEN 12                 /* Length of Address field */ 
     6#define TAGID_LEN  6                   /* Length of tag ID */ 
     7#define TAGINFO_LEN 20                 /* Length of vendor information field in tag */ 
     8#define TAGVER_LEN 4                   /* Length of Tag Version */ 
    69 
    7 struct bcm_tag { 
    8         unsigned char tagVersion[4];                            // Version of the image tag 
    9         unsigned char sig_1[20];                                // Company Line 1 
    10         unsigned char sig_2[14];                                // Company Line 2 
    11         unsigned char chipid[6];                                        // Chip this image is for 
    12         unsigned char boardid[16];                              // Board name 
    13         unsigned char big_endian[2];                             // Map endianness -- 1 BE 0 LE 
    14         unsigned char totalLength[IMAGE_LEN];           //Total length of image 
    15         unsigned char cfeAddress[ADDRESS_LEN];  // Address in memory of CFE 
    16         unsigned char cfeLength[IMAGE_LEN];             // Size of CFE 
    17         unsigned char cfeRootAddress[ADDRESS_LEN];         // Address in memory of rootfs 
    18         unsigned char cfeRootLength[IMAGE_LEN];            // Size of rootfs 
    19         unsigned char kernelAddress[ADDRESS_LEN];       // Address in memory of kernel 
    20         unsigned char kernelLength[IMAGE_LEN];  // Size of kernel 
    21         unsigned char dualImage[2];                             // Unused at present 
    22         unsigned char inactiveFlag[2];                  // Unused at present 
    23         unsigned char reserved1[74];                            // Reserved area not in use 
    24         unsigned char imageCRC[4];                              // CRC32 of images 
    25 //      unsigned char reserved2[16];                    // Unused at present 
    26         unsigned char reserved2[4];                     //Unused 
    27         unsigned char rootAddress[ADDRESS_LEN];         // Address in memory of rootfs 
    28         unsigned char headerCRC[4];                     // CRC32 of header excluding tagVersion 
    29 //      unsigned char reserved3[16];                    // Unused at present 
    30         unsigned char reserved3[6];                     // Unused at present 
    31         unsigned char rootLength[IMAGE_LEN];            // Size of rootfs 
     10#define NUM_TAGID 5 
     11#define IMAGETAG_CRC_START              0xFFFFFFFF 
     12 
     13struct tagiddesc_t { 
     14  char tagid[TAGID_LEN + 1]; 
     15  char tagiddesc[80]; 
     16}; 
     17 
     18 // what is called bc308 may actually be BT Voyager-specific 
     19 // bc310 should be right  
     20#define TAGID_DEFINITIONS { \ 
     21  { "bccfe", "Broadcom CFE flash image" }, \ 
     22  { "bc300", "Broadcom code version 3.00-3.06 and all ftp/tftp flash" }, \ 
     23  { "ag306", "Alice Gate (Pirelli, based on Broadcom 3.06)" }, \ 
     24  { "bc308", "Broadcom code version 3.08" }, \ 
     25  { "bc310", "Broadcom code version 3.10-3.12" }, \ 
     26} 
     27 
     28struct bcm_tag_bccfe { 
     29        unsigned char tagVersion[TAGVER_LEN];                    // 0-3: Version of the image tag 
     30        unsigned char sig_1[20];                        // 4-23: Company Line 1 
     31        unsigned char sig_2[14];                        // 24-37: Company Line 2 
     32        unsigned char chipid[6];                        // 38-43: Chip this image is for 
     33        unsigned char boardid[16];                      // 44-59: Board name 
     34        unsigned char big_endian[2];                    // 60-61: Map endianness -- 1 BE 0 LE 
     35        unsigned char totalLength[IMAGE_LEN];           // 62-71: Total length of image 
     36        unsigned char cfeAddress[ADDRESS_LEN];          // 72-83: Address in memory of CFE 
     37        unsigned char cfeLength[IMAGE_LEN];             // 84-93: Size of CFE 
     38        unsigned char rootAddress[ADDRESS_LEN];         // 94-105: Address in memory of rootfs 
     39        unsigned char rootLength[IMAGE_LEN];            // 106-115: Size of rootfs 
     40        unsigned char kernelAddress[ADDRESS_LEN];       // 116-127: Address in memory of kernel 
     41        unsigned char kernelLength[IMAGE_LEN];          // 128-137: Size of kernel 
     42        unsigned char dualImage[2];                     // 138-139: Unused at present 
     43        unsigned char inactiveFlag[2];                  // 140-141: Unused at present 
     44        unsigned char information1[TAGINFO_LEN];        // 142-161: Unused at present 
     45        unsigned char tagId[TAGID_LEN];                 // 162-167: Identifies which type of tag this is, currently two-letter company code, and then three digits for version of broadcom code in which this tag was first introduced 
     46        unsigned char tagIdCRC[4];                      // 168-171: CRC32 of tagId 
     47        unsigned char reserved1[44];                    // 172-215: Reserved area not in use 
     48        unsigned char imageCRC[4];                      // 216-219: CRC32 of images 
     49        unsigned char reserved2[16];                    // 220-235: Unused at present 
     50        unsigned char headerCRC[4];                     // 236-239: CRC32 of header excluding tagVersion 
     51        unsigned char reserved3[16];                    // 240-255: Unused at present 
     52}; 
     53 
     54struct bcm_tag_bc300 { 
     55        unsigned char tagVersion[4];                    // 0-3: Version of the image tag 
     56        unsigned char sig_1[20];                        // 4-23: Company Line 1 
     57        unsigned char sig_2[14];                        // 24-37: Company Line 2 
     58        unsigned char chipid[6];                        // 38-43: Chip this image is for 
     59        unsigned char boardid[16];                      // 44-59: Board name 
     60        unsigned char big_endian[2];                    // 60-61: Map endianness -- 1 BE 0 LE 
     61        unsigned char totalLength[IMAGE_LEN];           // 62-71: Total length of image 
     62        unsigned char cfeAddress[ADDRESS_LEN];          // 72-83: Address in memory of CFE 
     63        unsigned char cfeLength[IMAGE_LEN];             // 84-93: Size of CFE 
     64        unsigned char flashImageStart[ADDRESS_LEN];     // 94-105: Address in memory of kernel (start of image) 
     65        unsigned char flashRootLength[IMAGE_LEN];       // 106-115: Size of rootfs + deadcode (web flash uses this + kernelLength to determine the size of the kernel+rootfs flash image) 
     66        unsigned char kernelAddress[ADDRESS_LEN];       // 116-127: Address in memory of kernel 
     67        unsigned char kernelLength[IMAGE_LEN];          // 128-137: Size of kernel 
     68        unsigned char dualImage[2];                     // 138-139: Unused at present 
     69        unsigned char inactiveFlag[2];                  // 140-141: Unused at present 
     70        unsigned char information1[TAGINFO_LEN];        // 142-161: Unused at present 
     71        unsigned char tagId[TAGID_LEN];                 // 162-167: Identifies which type of tag this is, currently two-letter company code, and then three digits for version of broadcom code in which this tag was first introduced 
     72        unsigned char tagIdCRC[4];                      // 168-173: CRC32 to ensure validity of tagId 
     73        unsigned char rootAddress[ADDRESS_LEN];         // 174-183: Address in memory of rootfs partition 
     74        unsigned char rootLength[IMAGE_LEN];            // 184-193: Size of rootfs partition 
     75        unsigned char reserved1[22];                    // 194-215: Reserved area not in use 
     76        unsigned char imageCRC[4];                      // 216-219: CRC32 of images 
     77        unsigned char reserved2[16];                    // 220-235: Unused at present 
     78        unsigned char headerCRC[4];                     // 236-239: CRC32 of header excluding tagVersion 
     79        unsigned char reserved3[16];                    // 240-255: Unused at present 
     80}; 
     81 
     82struct bcm_tag_ag306 { 
     83        unsigned char tagVersion[4];                    // 0-3: Version of the image tag 
     84        unsigned char sig_1[20];                        // 4-23: Company Line 1 
     85        unsigned char sig_2[14];                        // 24-37: Company Line 2 
     86        unsigned char chipid[6];                        // 38-43: Chip this image is for 
     87        unsigned char boardid[16];                      // 44-59: Board name 
     88        unsigned char big_endian[2];                    // 60-61: Map endianness -- 1 BE 0 LE 
     89        unsigned char totalLength[IMAGE_LEN];           // 62-71: Total length of image 
     90        unsigned char cfeAddress[ADDRESS_LEN];          // 72-83: Address in memory of CFE 
     91        unsigned char cfeLength[IMAGE_LEN];             // 84-93: Size of CFE 
     92        unsigned char flashImageStart[ADDRESS_LEN];     // 94-105: Address in memory of kernel (start of image) 
     93        unsigned char flashRootLength[IMAGE_LEN];       // 106-115: Size of rootfs + deadcode (web flash uses this + kernelLength to determine the size of the kernel+rootfs flash image) 
     94        unsigned char kernelAddress[ADDRESS_LEN];       // 116-127: Address in memory of kernel 
     95        unsigned char kernelLength[IMAGE_LEN];          // 128-137: Size of kernel 
     96        unsigned char dualImage[2];                     // 138-139: Unused at present 
     97        unsigned char inactiveFlag[2];                  // 140-141: Unused at present 
     98        unsigned char information1[TAGINFO_LEN];        // 142-161: Unused at present 
     99        unsigned char information2[54];                 // 162-215: Compilation and related information (not generated/used by OpenWRT) 
     100        unsigned char kernelCRC[4] ;                    // 216-219: CRC32 of images 
     101        unsigned char rootAddress[ADDRESS_LEN];         // 220-231: Address in memory of rootfs partition 
     102        unsigned char tagIdCRC[4];                      // 232-235: Checksum to ensure validity of tagId 
     103        unsigned char headerCRC[4];                     // 236-239: CRC32 of header excluding tagVersion 
     104        unsigned char rootLength[IMAGE_LEN];            // 240-249: Size of rootfs 
     105        unsigned char tagId[TAGID_LEN];                 // 250-255: Identifies which type of tag this is, currently two-letter company code, and then three digits for version of broadcom code in which this tag was first introduced 
     106}; 
     107 
     108struct bcm_tag_bc308 { 
     109        unsigned char tagVersion[4];                    // 0-3: Version of the image tag 
     110        unsigned char sig_1[20];                        // 4-23: Company Line 1 
     111        unsigned char sig_2[14];                        // 24-37: Company Line 2 
     112        unsigned char chipid[6];                        // 38-43: Chip this image is for 
     113        unsigned char boardid[16];                      // 44-59: Board name 
     114        unsigned char big_endian[2];                    // 60-61: Map endianness -- 1 BE 0 LE 
     115        unsigned char totalLength[IMAGE_LEN];           // 62-71: Total length of image 
     116        unsigned char cfeAddress[ADDRESS_LEN];          // 72-83: Address in memory of CFE 
     117        unsigned char cfeLength[IMAGE_LEN];             // 84-93: Size of CFE 
     118        unsigned char flashImageStart[ADDRESS_LEN];     // 94-105: Address in memory of kernel (start of image) 
     119        unsigned char flashRootLength[IMAGE_LEN];       // 106-115: Size of rootfs + deadcode (web flash uses this + kernelLength to determine the size of the kernel+rootfs flash image) 
     120        unsigned char kernelAddress[ADDRESS_LEN];       // 116-127: Address in memory of kernel 
     121        unsigned char kernelLength[IMAGE_LEN];          // 128-137: Size of kernel 
     122        unsigned char dualImage[2];                     // 138-139: Unused at present 
     123        unsigned char inactiveFlag[2];                  // 140-141: Unused at present 
     124        unsigned char information1[TAGINFO_LEN+2];      // 142-163: Unused at present 
     125        unsigned char tagId[TAGID_LEN];                 // 164-169: Identifies which type of tag this is, currently two-letter company code, and then three digits for version of broadcom code in which this tag was first introduced 
     126        unsigned char rootAddress[ADDRESS_LEN];         // 170-181: Address in memory of rootfs partition 
     127        unsigned char rootLength[IMAGE_LEN];            // 182-191: Size of rootfs partition 
     128        unsigned char flashLayoutVer[2];                // 192-193: Version flash layout 
     129        unsigned char curflashLayoutVer[2];             // 194-195: Unused at present 
     130        unsigned char kernelCRC[4];                     // 196-199: Guessed to be kernel CRC 
     131        unsigned char reserved4[16];                    // 200-215: Reserved area; unused at present 
     132        unsigned char imageCRC[4];                      // 216-219: CRC32 of images 
     133        unsigned char reserved2[12];                    // 220-231: Unused at present 
     134        unsigned char tagIdCRC[4];                      // 232-235: CRC32 to ensure validity of tagId 
     135        unsigned char headerCRC[4];                     // 236-239: CRC32 of header excluding tagVersion 
     136        unsigned char reserved3[16];                    // 240-255: Unused at present 
     137}; 
     138 
     139struct bcm_tag_bc310 { 
     140        unsigned char tagVersion[4];                    // 0-3: Version of the image tag 
     141        unsigned char sig_1[20];                        // 4-23: Company Line 1 
     142        unsigned char sig_2[14];                        // 24-37: Company Line 2 
     143        unsigned char chipid[6];                        // 38-43: Chip this image is for 
     144        unsigned char boardid[16];                      // 44-59: Board name 
     145        unsigned char big_endian[2];                    // 60-61: Map endianness -- 1 BE 0 LE 
     146        unsigned char totalLength[IMAGE_LEN];           // 62-71: Total length of image 
     147        unsigned char cfeAddress[ADDRESS_LEN];          // 72-83: Address in memory of CFE 
     148        unsigned char cfeLength[IMAGE_LEN];             // 84-93: Size of CFE 
     149        unsigned char flashImageStart[ADDRESS_LEN];     // 94-105: Address in memory of kernel (start of image) 
     150        unsigned char flashRootLength[IMAGE_LEN];       // 106-115: Size of rootfs + deadcode (web flash uses this + kernelLength to determine the size of the kernel+rootfs flash image) 
     151        unsigned char kernelAddress[ADDRESS_LEN];       // 116-127: Address in memory of kernel 
     152        unsigned char kernelLength[IMAGE_LEN];          // 128-137: Size of kernel 
     153        unsigned char dualImage[2];                     // 138-139: Unused at present 
     154        unsigned char inactiveFlag[2];                  // 140-141: Unused at present 
     155        unsigned char information1[TAGINFO_LEN];        // 142-161: Unused at present; Some vendors use this for optional information 
     156        unsigned char tagId[6];                         // 162-167: Identifies which type of tag this is, currently two-letter company code, and then three digits for version of broadcom code in which this tag was first introduced 
     157        unsigned char tagIdCRC[4];                      // 168-171: CRC32 to ensure validity of tagId 
     158        unsigned char rootAddress[ADDRESS_LEN];         // 172-183: Address in memory of rootfs partition 
     159        unsigned char rootLength[IMAGE_LEN];            // 184-193: Size of rootfs partition 
     160        unsigned char reserved1[22];                    // 193-215: Reserved area not in use 
     161        unsigned char imageCRC[4];                      // 216-219: CRC32 of images 
     162        unsigned char rootfsCRC[4];                     // 220-227: CRC32 of rootfs partition 
     163        unsigned char kernelCRC[4];                     // 224-227: CRC32 of kernel partition 
     164        unsigned char reserved2[8];                     // 228-235: Unused at present 
     165        unsigned char headerCRC[4];                     // 235-239: CRC32 of header excluding tagVersion 
     166        unsigned char reserved3[16];                    // 240-255: Unused at present 
     167}; 
     168 
     169union bcm_tag { 
     170  struct bcm_tag_bccfe bccfe; 
     171  struct bcm_tag_bc300 bc300; 
     172  struct bcm_tag_ag306 ag306; 
     173  struct bcm_tag_bc308 bc308; 
     174  struct bcm_tag_bc310 bc310; 
    32175}; 
    33176 
  • trunk/target/linux/brcm63xx/image/Makefile

    r15253 r16393  
    1818                RAMSIZE=$(RAMSIZE) 
    1919 
     20SVN_REVISION=r$(shell svn info|grep Revision|cut -f1 -d\ ) 
     21 
    2022define trxalign/jffs2-128k 
    2123-a 0x20000 
     
    3133        # Generate the tagged image 
    3234        $(STAGING_DIR_HOST)/bin/imagetag -i $(KDIR)/vmlinux.lzma.cfe -f $(KDIR)/root.$(1) \ 
    33                 -o $(BIN_DIR)/openwrt-$(2)-$(1)-cfe.bin \ 
    34                 -b $(2) -c $(3) -e $(LOADADDR) -l $(LOADADDR) 
     35                -o $(BIN_DIR)/openwrt-$(2)-$(1)-$(6)-cfe.bin \ 
     36                -b $(2) -c $(3) -e $(LOADADDR) -l $(LOADADDR) \ 
     37                -t $(4) -d "$(5)" 
    3538#               -b $(2) -c $(3) -e $(KERNEL_ENTRY) -l $(LOADADDR) 
    3639 
     
    4043        # Generate the tagged image 
    4144        $(STAGING_DIR_HOST)/bin/imagetag -i $(KDIR)/vmlinux.lzma.cfe -f $(KDIR)/root.$(1) \ 
    42                 -o $(BIN_DIR)/openwrt-$(2)-$(1)-cfe.bin \ 
     45                -o $(BIN_DIR)/openwrt-$(2)-$(1)-$(7)-cfe.bin \ 
    4346                -b $(2) -c $(3) -e $(LOADADDR) -l $(LOADADDR) \ 
    44                 -v 8 -m IMAGE -k 0x20000 -n $(4) -p alice 
     47                -v 8 -m IMAGE -k 0x20000 -n $(4) -t $(5) 
    4548endef 
    4649 
     
    9699        $(STAGING_DIR_HOST)/bin/trx -o $(BIN_DIR)/openwrt-$(BOARD)-$(1).trx -f $(KDIR)/loader.gz -f $(KDIR)/vmlinux.lzma $(call trxalign/$(1)) -f $(KDIR)/root.$(1) 
    97100        dd if=$(KDIR)/root.$(1) of=$(BIN_DIR)/openwrt-$(BOARD)-root.$(1) bs=128k conv=sync 
    98         $(call Image/Build/CFE,$(1),96345GW2,6345) 
    99         $(call Image/Build/CFE,$(1),96348GW,6348) 
     101        # Various routers 
     102        $(call Image/Build/CFE,$(1),96345GW2,6345,bccfe,,bccfe) 
     103        $(call Image/Build/CFE,$(1),96345GW2,6345,bc300,,bc300) 
     104        $(call Image/Build/CFE,$(1),96345GW2,6345,bc310,OpenWRT-$(SVN_REVISION),bc310) 
     105        $(call Image/Build/CFE,$(1),96348GW,6348,bccfe,,bcfe) 
     106        # BT Voyager V2500V 
     107        $(call Image/Build/CFE,$(1),V2500V_BB,6348,bc308,,btvgr) 
     108        # Tecom GW6000 
     109        $(call Image/Build/CFE,$(1),96348GW,6348,bc300,,bc300) 
     110        # Tecom GW6200 
     111        $(call Image/Build/CFE,$(1),96348GW,6348,bc310,$(shell printf '\x99'),gw6200) 
    100112        # Neufbox4 
    101         $(call Image/Build/CFE,$(1),96358VW,6358) 
    102         # Comtrend 536 
    103         $(call Image/Build/CFE,$(1),96348GW-11,6348) 
     113        $(call Image/Build/CFE,$(1),96358VW,6358,bccfe,,bccfe) 
     114        $(call Image/Build/CFE,$(1),96358VW,6358,bc310,OpenWRT-$(SVN_REVISION),nb4) 
     115        # Comtrend 536, 5621 
     116        $(call Image/Build/CFE,$(1),96348GW-11,6348,bccfe,,bccfe) 
     117        $(call Image/Build/CFE,$(1),96348GW-11,6348,bc300,,bc300) 
    104118        # Davolink DV201AMR 
    105119        $(call Image/Build/CFEOLD,$(1),DV201AMR,6348) 
    106120        # USR 9108 
    107         $(call Image/Build/CFE,$(1),96348GW-A,6348) 
    108         # DG834GT 
    109         $(call Image/Build/CFE,$(1),96348GW-10,6348) 
     121        $(call Image/Build/CFE,$(1),96348GW-A,6348,bccfe,,bccfe) 
     122        $(call Image/Build/CFE,$(1),96348GW-A,6348,bc300,,bc300) 
     123        $(call Image/Build/CFE,$(1),96348GW-A,6348,bc310,OpenWRT-$(SVN_REVISION),bc310) 
     124        # NetGear DG834GT 
     125        $(call Image/Build/CFE,$(1),96348GW-10,6348,bccfe,,bccfe) 
     126        $(call Image/Build/CFE,$(1),96348GW-10,6348,bc300,,bc300) 
     127 
    110128        # Sagem F@ST2404 
    111         $(call Image/Build/CFE,$(1),F@ST2404,6348) 
     129        $(call Image/Build/CFE,$(1),F@ST2404,6348,bccfe,,bccfe) 
     130        $(call Image/Build/CFE,$(1),F@ST2404,6348,bc300,,bc300) 
     131        $(call Image/Build/CFE,$(1),F@ST2404,6348,bc310,OpenWRT-$(SVN_REVISION),bc310) 
    112132        # Inventel Livebox 
    113133        $(call Image/Build/RedBoot,livebox) 
    114134        # Pirelli Alice Gate VoIP 2 Plus Wi-Fi AGPF-S0 
    115         $(call Image/Build/CFEAGPF,$(1),AGPF-S0,6358,0x20000) 
     135        $(call Image/Build/CFEAGPF,$(1),AGPF-S0,6358,0x20000,bccfe,,bccfe) 
     136        $(call Image/Build/CFEAGPF,$(1),AGPF-S0,6358,0x20000,ag306,,agv2+w) 
    116137endef 
    117138 
  • trunk/tools/firmware-utils/Makefile

    r15245 r16393  
    1111include $(INCLUDE_DIR)/host-build.mk 
    1212 
     13include $(INCLUDE_DIR)/kernel.mk 
     14 
    1315define cc 
    1416        $(CC) $(HOST_CFLAGS) -include endian.h -o $(HOST_BUILD_DIR)/bin/$(1) src/$(1).c $(2) 
     
    1820        $(CC) $(HOST_CFLAGS) -include endian.h -o $(HOST_BUILD_DIR)/bin/$(firstword $(1)) $(foreach src,$(1),src/$(src).c) $(2) 
    1921endef 
     22 
     23define cc3 
     24        $(CC) $(HOST_CFLAGS) -I$(CURDIR)/../../target/linux/brcm63xx/files/include/asm-mips/mach-bcm63xx -include endian.h -o $(HOST_BUILD_DIR)/bin/$(1) src/$(1).c $(2) 
     25endef 
     26 
    2027 
    2128define Host/Compile 
     
    3643        $(call cc,mkfwimage,-lz) 
    3744        $(call cc,mkfwimage2,-lz) 
    38         $(call cc,imagetag) 
     45        $(call cc3,imagetag) 
    3946        $(call cc,add_header) 
    4047        $(call cc,makeamitbin) 
  • trunk/tools/firmware-utils/src/imagetag.c

    r15977 r16393  
    55 * 
    66 * Copyright (C) 2008 Axel Gembe <ago@bastart.eu.org> 
     7 * Copyright (C) 2009 Daniel Dickinson <crazycshore@gmail.com> 
    78 */ 
    89 
     
    1617#include <netinet/in.h> 
    1718 
     19#include "bcm_tag.h" 
     20 
    1821#define IMAGETAG_MAGIC1                 "Broadcom Corporatio" 
    1922#define IMAGETAG_MAGIC2                 "ver. 2.0" 
    2023#define IMAGETAG_VER                    "6" 
    2124#define IMAGETAG_DEFAULT_LOADADDR       0x80010000 
    22 #define IMAGETAG_CRC_START              0xFFFFFFFF 
    2325#define DEFAULT_FW_OFFSET               0x10000 
    2426#define DEFAULT_FLASH_START             0xBFC00000 
    2527#define DEFAULT_FLASH_BS                (64 * 1024) 
    2628#define DEADCODE                        0xDEADC0DE 
     29 
     30union int2char { 
     31  uint32_t input; 
     32  unsigned char output[4]; 
     33}; 
     34 
     35/* This appears to be necessary due to alignment issues */ 
     36#define int2tag(tag, value)  intchar.input = htonl(value);      \ 
     37          strncpy(tag, intchar.output, sizeof(union int2char)) 
    2738 
    2839/* Kernel header */ 
     
    3344}; 
    3445 
    35 /* Image component */ 
    36 struct imagecomp { 
    37         uint8_t                 address[12];    /* Address of this component as ASCII */ 
    38         uint8_t                 len[10];        /* Length of this component as ASCII */ 
    39 }; 
    40  
    41 /* Image tag */ 
    42 struct imagetag { 
    43         uint8_t                 tagver[4];      /*   0 -   3: Version of the tag as ASCII (2) */ 
    44         uint8_t                 sig1[20];       /*   4 -  23: BCM_MAGIC_1 */ 
    45         uint8_t                 sig2[14];       /*  24 -  37: BCM_MAGIC_2 */ 
    46         uint8_t                 chipid[6];      /*  38 -  43: Chip id as ASCII (6345) */ 
    47         uint8_t                 boardid[16];    /*  44 -  59: Board id as ASCII (96345GW2, etc...) */ 
    48         uint8_t                 bigendian[2];   /*  60 -  61: "1" for big endian, "0" for little endian */ 
    49         uint8_t                 imagelen[10];   /*  62 -  71: The length of all data that follows */ 
    50         struct imagecomp        cfe;            /*  72 -  93: The offset and length of CFE */ 
    51         struct imagecomp        rootfs; /*  94 - 115: The offset and length of the root file system */ 
    52         struct imagecomp        kernel;         /* 116 - 137: The offset and length of the kernel */ 
    53         uint8_t                 dualimage[2];   /* 138 - 139: use "0" here */ 
    54         uint8_t                 inactive[2];    /* 140 - 141: use "0" here */ 
    55         uint8_t                 reserved1[74];  /* 142 - 215: reserved */ 
    56         uint32_t                imagecrc;       /* 216 - 219: crc of the images (net byte order) */ 
    57 //      uint8_t                 reserved2[16];  /* 220 - 235: reserved */ 
    58         uint8_t                 reserved2[4];   /* 220 - 223: reserved */ 
    59         uint8_t                 wrtrootfsaddr[12];      /* 224 - 235: wrt rootfs address */ 
    60         uint32_t                headercrc;      /* 236 - 239: crc starting from sig1 until headercrc (net byte order) */ 
    61 //      uint8_t                 reserved3[16];  /* 240 - 255: reserved */ 
    62         uint8_t                 reserved3[6];   /* 240 - 245: reserved */ 
    63         uint8_t                 wrtrootfslen[10];       /* 246 - 255: wrt rootfs lenght */ 
    64 }; 
     46static struct tagiddesc_t tagidtab[NUM_TAGID] = TAGID_DEFINITIONS; 
    6547 
    6648static uint32_t crc32tab[256] = { 
     
    149131            const uint32_t loadaddr, const uint32_t entry, 
    150132            const char *ver, const char *magic2, const uint32_t flash_bs, 
    151             const char *profile) 
     133            const char *tagid, const char *information) 
    152134{ 
    153         struct imagetag tag; 
     135        union bcm_tag tag; 
    154136        struct kernelhdr khdr; 
    155137        FILE *kernelfile = NULL, *rootfsfile = NULL, *binfile; 
    156138        size_t kerneloff, kernellen, rootfsoff, rootfslen, read, imagelen, rootfsoffpadlen; 
    157139        uint8_t readbuf[1024]; 
    158         uint32_t crc = IMAGETAG_CRC_START; 
     140        uint32_t imagecrc = IMAGETAG_CRC_START; 
     141        uint32_t kernelcrc = IMAGETAG_CRC_START; 
     142        uint32_t rootfscrc = IMAGETAG_CRC_START; 
    159143        const uint32_t deadcode = htonl(DEADCODE); 
    160  
    161         memset(&tag, 0, sizeof(struct imagetag)); 
    162  
    163         if (strlen(boardid) >= sizeof(tag.boardid)) { 
     144        union int2char intchar; 
     145 
     146        memset(&tag, 0, sizeof(union bcm_tag)); 
     147 
     148        /* All imagetags have boardid in the same location and of the same 
     149         * size, so we just use the bccfe one 
     150         */ 
     151        if (strlen(boardid) >= sizeof(tag.bccfe.boardid)) { 
    164152                fprintf(stderr, "Board id is too long!\n"); 
    165153                return 1; 
    166154        } 
    167155 
    168         if (strlen(chipid) >= sizeof(tag.chipid)) { 
     156        /* Likewise chipid */ 
     157        if (strlen(chipid) >= sizeof(tag.bccfe.chipid)) { 
    169158                fprintf(stderr, "Chip id is too long!\n"); 
    170159                return 1; 
     
    202191        rootfsoff = (rootfsoff % flash_bs) > 0 ? (((rootfsoff / flash_bs) + 1) * flash_bs) : rootfsoff; 
    203192        rootfslen = getlen(rootfsfile); 
    204         rootfslen = (rootfslen % flash_bs) > 0 ? (((rootfslen / flash_bs) + 1) * flash_bs) : rootfslen; 
     193        rootfslen = ( (rootfslen % flash_bs) > 0 ? (((rootfslen / flash_bs) + 1) * flash_bs) : rootfslen ); 
    205194        imagelen = rootfsoff + rootfslen - kerneloff + sizeof(deadcode); 
    206195        rootfsoffpadlen = rootfsoff - (kerneloff + kernellen); 
     
    232221 
    233222        /* Choose and compute the CRC32 that should be inserted in the tag */ 
    234         /* and fill reserved tag following profile specification           */ 
    235         if ( profile && (strcmp(profile, "alice") == 0)) { 
    236                 crc = compute_crc32(crc, binfile, kerneloff - fwaddr, kernellen + rootfsoffpadlen); 
    237                 /* Should fill alice_data and put them on reserved1 */ 
    238         } 
    239         else { 
     223        if ( tagid && ( (strncmp(tagid, "bccfe", TAGID_LEN) == 0)) || ( strncmp(tagid, "bc300", TAGID_LEN) == 0)) { 
    240224                /* Compute the crc32 of the entire image (deadC0de included) */ 
    241                 crc = compute_crc32(crc, binfile, kerneloff - fwaddr, imagelen); 
    242         } 
    243  
     225                imagecrc = compute_crc32(imagecrc, binfile, kerneloff - fwaddr, imagelen); 
     226        } else if ( tagid && (strncmp(tagid, "ag306", TAGID_LEN) == 0)) { 
     227                /* Compute the crc32 of the kernel and padding between kernel and rootfs) */ 
     228                kernelcrc = compute_crc32(kernelcrc, binfile, kerneloff - fwaddr, kernellen + rootfsoffpadlen); 
     229        } else if ( tagid && ( (strncmp(tagid, "bc308", TAGID_LEN) == 0))) { 
     230                /* Compute the crc32 of the entire image (deadC0de included) */ 
     231                imagecrc = compute_crc32(imagecrc, binfile, kerneloff - fwaddr, imagelen); 
     232                /* Compute the crc32 of the kernel and padding between kernel and rootfs) */ 
     233                kernelcrc = compute_crc32(kernelcrc, binfile, kerneloff - fwaddr, kernellen + rootfsoffpadlen); 
     234        } else if ( tagid && (strncmp(tagid, "bc310", TAGID_LEN) == 0) ) { 
     235                /* Compute the crc32 of the entire image (deadC0de included) */ 
     236                imagecrc = compute_crc32(imagecrc, binfile, kerneloff - fwaddr, imagelen); 
     237                /* Compute the crc32 of the kernel and padding between kernel and rootfs) */ 
     238                kernelcrc = compute_crc32(kernelcrc, binfile, kerneloff - fwaddr, kernellen + rootfsoffpadlen); 
     239                /* Compute the crc32 of the flashImageStart to rootLength.  
     240                 * The broadcom firmware assumes the rootfs starts the image, 
     241                 * therefore uses the rootfs start to determine where to flash 
     242                 * the image.  Since we have the kernel first we have to give 
     243                 * it the kernel address, but the crc uses the length 
     244                 * associated with this address, which is added to the kernel 
     245                 * length to determine the length of image to flash and thus 
     246                 * needs to be rootfs + deadcode 
     247                 */ 
     248                rootfscrc = compute_crc32(rootfscrc, binfile, kerneloff - fwaddr, rootfslen + sizeof(deadcode)); 
     249        } 
    244250         
    245251        /* Close the files */ 
     
    247253        fclose(rootfsfile); 
    248254 
    249         /* Build the tag */ 
    250         strcpy(tag.tagver, ver); 
    251         strncpy(tag.sig1, IMAGETAG_MAGIC1, sizeof(tag.sig1) - 1); 
    252         strncpy(tag.sig2, magic2, sizeof(tag.sig2) - 1); 
    253         strcpy(tag.chipid, chipid); 
    254         strcpy(tag.boardid, boardid); 
    255         strcpy(tag.bigendian, "1"); 
    256         sprintf(tag.imagelen, "%lu", imagelen); 
    257  
    258         /* We don't include CFE */ 
    259         strcpy(tag.cfe.address, "0"); 
    260         strcpy(tag.cfe.len, "0"); 
    261  
    262         if (kernelfile) { 
    263                 sprintf(tag.kernel.address, "%lu", kerneloff); 
    264                 sprintf(tag.kernel.len, "%lu", kernellen + rootfsoffpadlen); 
    265         } 
    266  
    267         if (rootfsfile) { 
    268                 sprintf(tag.rootfs.address, "%lu", kerneloff); 
    269                 sprintf(tag.rootfs.len, "%lu", rootfslen + sizeof(deadcode)); 
    270                 sprintf(tag.wrtrootfsaddr, "%lu", rootfsoff); 
    271                 sprintf(tag.wrtrootfslen, "%lu", rootfslen); 
    272         } 
    273  
    274         tag.imagecrc = htonl(crc); 
    275         tag.headercrc = htonl(crc32(IMAGETAG_CRC_START, (uint8_t*)&tag, sizeof(tag) - 20)); 
     255        if ( tagid && (strcmp(tagid, "bccfe") == 0)) { 
     256          /* Build the tag */ 
     257          strncpy(tag.bccfe.tagVersion, ver, TAGVER_LEN); 
     258          strncpy(tag.bccfe.sig_1, IMAGETAG_MAGIC1, sizeof(tag.bccfe.sig_1) - 1); 
     259          strncpy(tag.bccfe.sig_2, magic2, sizeof(tag.bccfe.sig_2) - 1); 
     260          strcpy(tag.bccfe.chipid, chipid); 
     261          strcpy(tag.bccfe.boardid, boardid); 
     262          strcpy(tag.bccfe.big_endian, "1"); 
     263          sprintf(tag.bccfe.totalLength, "%lu", imagelen); 
     264 
     265          /* We don't include CFE */ 
     266          strcpy(tag.bccfe.cfeAddress, "0"); 
     267          strcpy(tag.bccfe.cfeLength, "0"); 
     268 
     269          if (kernelfile) { 
     270            sprintf(tag.bccfe.kernelAddress, "%lu", kerneloff); 
     271            sprintf(tag.bccfe.kernelLength, "%lu", kernellen + rootfsoffpadlen); 
     272          } 
     273 
     274          if (rootfsfile) { 
     275            sprintf(tag.bccfe.rootAddress, "%lu", rootfsoff); 
     276            sprintf(tag.bccfe.rootLength, "%lu", rootfslen); 
     277          } 
     278 
     279          strncpy(tag.bccfe.tagId, "bccfe", TAGID_LEN); 
     280 
     281          int2tag(tag.bccfe.tagIdCRC, crc32(IMAGETAG_CRC_START, (uint8_t*)&(tag.bccfe.tagId[0]), TAGID_LEN)); 
     282          int2tag(tag.bccfe.imageCRC, imagecrc); 
     283          int2tag(tag.bccfe.headerCRC, crc32(IMAGETAG_CRC_START, (uint8_t*)&tag, sizeof(tag) - 20)); 
     284        } else if ( tagid && (strcmp(tagid, "bc300") == 0)) { 
     285          /* Build the tag */ 
     286          strncpy(tag.bc300.tagVersion, ver, TAGVER_LEN); 
     287          strncpy(tag.bc300.sig_1, IMAGETAG_MAGIC1, sizeof(tag.bc300.sig_1) - 1); 
     288          strncpy(tag.bc300.sig_2, magic2, sizeof(tag.bc300.sig_2) - 1); 
     289          strcpy(tag.bc300.chipid, chipid); 
     290          strcpy(tag.bc300.boardid, boardid); 
     291          strcpy(tag.bc300.big_endian, "1"); 
     292          sprintf(tag.bc300.totalLength, "%lu", imagelen); 
     293 
     294          /* We don't include CFE */ 
     295          strcpy(tag.bc300.cfeAddress, "0"); 
     296          strcpy(tag.bc300.cfeLength, "0"); 
     297 
     298          if (kernelfile) { 
     299            sprintf(tag.bc300.kernelAddress, "%lu", kerneloff); 
     300            sprintf(tag.bc300.kernelLength, "%lu", kernellen + rootfsoffpadlen); 
     301          } 
     302 
     303          if (rootfsfile) { 
     304            sprintf(tag.bc300.flashImageStart, "%lu", kerneloff); 
     305            sprintf(tag.bc300.flashRootLength, "%lu", rootfslen + sizeof(deadcode)); 
     306            sprintf(tag.bc300.rootAddress, "%lu", rootfsoff); 
     307            sprintf(tag.bc300.rootLength, "%lu", rootfslen); 
     308          } 
     309 
     310          strncpy(tag.bc300.tagId, "bc300", TAGID_LEN); 
     311 
     312          int2tag(tag.bc300.tagIdCRC, crc32(IMAGETAG_CRC_START, (uint8_t*)&(tag.bc300.tagId[0]), TAGID_LEN)); 
     313          int2tag(tag.bc300.imageCRC, imagecrc); 
     314          int2tag(tag.bc300.headerCRC, crc32(IMAGETAG_CRC_START, (uint8_t*)&tag, sizeof(tag) - 20)); 
     315        } else if ( tagid && (strcmp(tagid, "ag306") == 0)) { 
     316          /* Build the tag */ 
     317          strncpy(tag.ag306.tagVersion, ver, TAGVER_LEN); 
     318          strncpy(tag.ag306.sig_1, IMAGETAG_MAGIC1, sizeof(tag.ag306.sig_1) - 1); 
     319          strncpy(tag.ag306.sig_2, magic2, sizeof(tag.ag306.sig_2) - 1); 
     320          strcpy(tag.ag306.chipid, chipid); 
     321          strcpy(tag.ag306.boardid, boardid); 
     322          strcpy(tag.ag306.big_endian, "1"); 
     323          sprintf(tag.ag306.totalLength, "%lu", imagelen); 
     324 
     325          /* We don't include CFE */ 
     326          strcpy(tag.ag306.cfeAddress, "0"); 
     327          strcpy(tag.ag306.cfeLength, "0"); 
     328 
     329          if (kernelfile) { 
     330            sprintf(tag.ag306.kernelAddress, "%lu", kerneloff); 
     331            sprintf(tag.ag306.kernelLength, "%lu", kernellen + rootfsoffpadlen); 
     332          } 
     333 
     334          if (rootfsfile) { 
     335            sprintf(tag.ag306.flashImageStart, "%lu", kerneloff); 
     336            sprintf(tag.ag306.flashRootLength, "%lu", rootfslen + sizeof(deadcode)); 
     337            sprintf(tag.ag306.rootAddress, "%lu", rootfsoff); 
     338            sprintf(tag.ag306.rootLength, "%lu", rootfslen); 
     339          } 
     340 
     341          strncpy(tag.ag306.tagId, "ag306", TAGID_LEN); 
     342 
     343          int2tag(tag.ag306.tagIdCRC, crc32(IMAGETAG_CRC_START, (uint8_t*)&(tag.ag306.tagId[0]), TAGID_LEN)); 
     344          int2tag(tag.ag306.kernelCRC, kernelcrc); 
     345          int2tag(tag.ag306.headerCRC, crc32(IMAGETAG_CRC_START, (uint8_t*)&tag, sizeof(tag) - 20)); 
     346        } else if ( tagid && (strcmp(tagid, "bc308") == 0)) { 
     347          /* Build the tag */ 
     348          strncpy(tag.bc308.tagVersion, ver, TAGVER_LEN); 
     349          strncpy(tag.bc308.sig_1, IMAGETAG_MAGIC1, sizeof(tag.bc308.sig_1) - 1); 
     350          strncpy(tag.bc308.sig_2, magic2, sizeof(tag.bc308.sig_2) - 1); 
     351          strcpy(tag.bc308.chipid, chipid); 
     352          strcpy(tag.bc308.boardid, boardid); 
     353          strcpy(tag.bc308.big_endian, "1"); 
     354          sprintf(tag.bc308.totalLength, "%lu", imagelen); 
     355 
     356          /* We don't include CFE */ 
     357          strcpy(tag.bc308.cfeAddress, "0"); 
     358          strcpy(tag.bc308.cfeLength, "0"); 
     359 
     360          if (kernelfile) { 
     361            sprintf(tag.bc308.kernelAddress, "%lu", kerneloff); 
     362            sprintf(tag.bc308.kernelLength, "%lu", kernellen + rootfsoffpadlen); 
     363          } 
     364 
     365          if (rootfsfile) { 
     366            sprintf(tag.bc308.flashImageStart, "%lu", kerneloff); 
     367            sprintf(tag.bc308.flashRootLength, "%lu", rootfslen + sizeof(deadcode)); 
     368            sprintf(tag.bc308.rootAddress, "%lu", rootfsoff); 
     369            sprintf(tag.bc308.rootLength, "%lu", rootfslen); 
     370          } 
     371 
     372          strncpy(tag.bc308.tagId, "bc308", TAGID_LEN); 
     373          strcpy(tag.bc308.flashLayoutVer, "5"); // This is needed at least for BT Voyager 
     374 
     375          int2tag(tag.bc308.tagIdCRC, crc32(IMAGETAG_CRC_START, (uint8_t*)&(tag.bc308.tagId[0]), TAGID_LEN)); 
     376          int2tag(tag.bc308.imageCRC, imagecrc); 
     377          int2tag(tag.bc308.kernelCRC, kernelcrc); 
     378          int2tag(tag.bc308.headerCRC, crc32(IMAGETAG_CRC_START, (uint8_t*)&tag, sizeof(tag) - 20)); 
     379        } else if ( tagid && (strcmp(tagid, "bc310") == 0)) { 
     380          /* Build the tag */ 
     381          strncpy(tag.bc310.tagVersion, ver, TAGVER_LEN); 
     382          strncpy(tag.bc310.sig_1, IMAGETAG_MAGIC1, sizeof(tag.bc310.sig_1) - 1); 
     383          strncpy(tag.bc310.sig_2, magic2, sizeof(tag.bc310.sig_2) - 1); 
     384          strcpy(tag.bc310.chipid, chipid); 
     385          strcpy(tag.bc310.boardid, boardid); 
     386          strcpy(tag.bc310.big_endian, "1"); 
     387          sprintf(tag.bc310.totalLength, "%lu", imagelen); 
     388 
     389          /* We don't include CFE */ 
     390          strcpy(tag.bc310.cfeAddress, "0"); 
     391          strcpy(tag.bc310.cfeLength, "0"); 
     392 
     393          if (kernelfile) { 
     394            sprintf(tag.bc310.kernelAddress, "%lu", kerneloff); 
     395            sprintf(tag.bc310.kernelLength, "%lu", kernellen + rootfsoffpadlen); 
     396          } 
     397 
     398          if (rootfsfile) { 
     399            sprintf(tag.bc310.flashImageStart, "%lu", kerneloff); 
     400            sprintf(tag.bc310.flashRootLength, "%lu", rootfslen + sizeof(deadcode)); 
     401            sprintf(tag.bc310.rootAddress, "%lu", rootfsoff); 
     402            sprintf(tag.bc310.rootLength, "%lu", rootfslen); 
     403          } 
     404 
     405          strncpy(tag.bc310.tagId, "bc310", TAGID_LEN); 
     406          if (information) { 
     407            strncpy(tag.bc310.information1, information, TAGINFO_LEN); 
     408          } 
     409 
     410          int2tag(tag.bc310.tagIdCRC, crc32(IMAGETAG_CRC_START, (uint8_t*)&(tag.bc310.tagId[0]), TAGID_LEN)); 
     411          int2tag(tag.bc310.imageCRC, imagecrc); 
     412          int2tag(tag.bc310.kernelCRC, kernelcrc); 
     413          int2tag(tag.bc310.rootfsCRC, rootfscrc); 
     414          int2tag(tag.bc310.headerCRC, crc32(IMAGETAG_CRC_START, (uint8_t*)&tag, sizeof(tag) - 20)); 
     415        } 
    276416 
    277417        fseek(binfile, 0L, SEEK_SET); 
     
    285425int main(int argc, char **argv) 
    286426{ 
    287         int c; 
    288         char *kernel, *rootfs, *bin, *boardid, *chipid, *magic2, *ver, *profile; 
     427        int c, i; 
     428        char *kernel, *rootfs, *bin, *boardid, *chipid, *magic2, *ver, *tagid, *information; 
    289429        uint32_t flashstart, fwoffset, loadaddr, entry; 
    290430        uint32_t fwaddr, flash_bs; 
     431        int tagidfound = 0; 
    291432         
    292         kernel = rootfs = bin = boardid = chipid = magic2 = ver = profile = NULL; 
     433        kernel = rootfs = bin = boardid = chipid = magic2 = ver = tagid = information = NULL; 
    293434        entry = 0; 
    294435 
     
    298439        flash_bs = DEFAULT_FLASH_BS; 
    299440 
    300         printf("Broadcom image tagger - v0.1.2\n"); 
     441        printf("Broadcom image tagger - v0.2.0\n"); 
    301442        printf("Copyright (C) 2008 Axel Gembe\n"); 
    302  
    303         while ((c = getopt(argc, argv, "i:f:o:b:c:s:n:v:m:k:l:e:h:p:")) != -1) { 
     443        printf("Copyright (C) 2009 Daniel Dickinson\n"); 
     444 
     445        while ((c = getopt(argc, argv, "i:f:o:b:c:s:n:v:m:k:l:e:h:t:d:")) != -1) { 
    304446                switch (c) { 
    305447                        case 'i': 
     
    339481                                entry = strtoul(optarg, NULL, 16); 
    340482                                break; 
    341                         case 'p': 
    342                                 profile = optarg; 
     483                        case 't': 
     484                                tagid = optarg; 
     485                                break; 
     486                        case 'd': 
     487                                information = optarg; 
    343488                                break; 
    344489                        case 'h': 
     
    357502                                fprintf(stderr, "       -l <loadaddr>           - Address where the kernel expects to be loaded (defaults to 0x80010000)\n"); 
    358503                                fprintf(stderr, "       -e <entry>              - Address where the kernel entry point will end up\n"); 
    359                                 fprintf(stderr, "       -p <profile>            - Specify profile for particular devices, use 'list' to see available devices\n"); 
     504                                fprintf(stderr, "       -t <tagid> - type if imagetag to create, use 'list' to see available choices"); 
     505                                fprintf(stderr, "       -d <information> - vendor specific information, for those that need it"); 
    360506                                fprintf(stderr, "       -h                      - Displays this text\n\n"); 
    361507                                return 1; 
     
    373519        } 
    374520         
    375         if (profile && (strcmp(profile, "list") == 0)) { 
    376                 fprintf(stderr, "\n----------------------------------------\n"); 
    377                 fprintf(stderr, "\tAvailable Profiles:"); 
    378                 fprintf(stderr, "\n\n"); 
    379                 fprintf(stderr, "\t'alice'\tALICE GATE VoIP 2 Plus Wi-Fi Business"); 
    380                 fprintf(stderr, "\n----------------------------------------\n"); 
    381                 return 0; 
    382         } 
    383  
    384         /* If the profile increase should found another way of testing the validity */ 
    385         if (profile && !(strcmp(profile, "alice") == 0)) { 
    386                 fprintf(stderr, "You specified an inexistent profile %s, see the list of availables options\n", profile); 
    387                 return 1; 
    388         } 
     521        tagidfound = 0; 
     522        if (!tagid) { 
     523          fprintf(stderr, "You must specify a tagid (-t)\n"); 
     524        } else { 
     525          if (strncmp(tagid, "list", 4) == 0) { 
     526            fprintf(stderr, "\n----------------------------------------\n"); 
     527            fprintf(stderr, "\tAvailable tagId:"); 
     528            fprintf(stderr, "\n\n"); 
     529            for (i = 0; i < NUM_TAGID; i++) { 
     530              fprintf(stderr, "\t%s\t%s", tagidtab[i].tagid, tagidtab[i].tagiddesc);     
     531            } 
     532            fprintf(stderr, "\n----------------------------------------\n"); 
     533            return 0;        
     534          } 
     535        } 
     536 
     537        if (tagid) { 
     538          for(i = 0; i < NUM_TAGID; i++) { 
     539            if (strncmp(tagid, tagidtab[i].tagid, TAGID_LEN) == 0) { 
     540              tagidfound = 1; 
     541              break; 
     542            } 
     543          } 
     544          if (!tagidfound) { 
     545            if (tagid) { 
     546              fprintf(stderr, "The tagid you selected '%s' does't exist.\n", tagid); 
     547            } 
     548            fprintf(stderr, "Use -t list to see the list of available ids");   
     549            return 1; 
     550          } 
     551        } 
    389552 
    390553        /* Fallback to defaults */ 
     
    411574                 
    412575 
    413         return tagfile(kernel, rootfs, bin, boardid, chipid, fwaddr, loadaddr, entry, ver, magic2, flash_bs, profile); 
     576        return tagfile(kernel, rootfs, bin, boardid, chipid, fwaddr, loadaddr, entry, ver, magic2, flash_bs, tagid, information); 
    414577} 
Note: See TracChangeset for help on using the changeset viewer.