Changeset 11920


Ignore:
Timestamp:
2008-07-25T05:55:21+02:00 (10 years ago)
Author:
thepeople
Message:

Use mkfwimage from athero.openwrt.net with modification for XS2 devices. Add back in ubiquiti image generation.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/atheros/image/Makefile

    r11130 r11920  
    2323        $(call Image/Build/$(1)) 
    2424        dd if=$(KDIR)/root.$(1) of=$(BIN_DIR)/openwrt-$(BOARD)-root.$(1) bs=128k conv=sync 
     25 
     26        $(STAGING_DIR_HOST)/bin/mkfwimage -k $(BIN_DIR)/openwrt-$(BOARD)-vmlinux.lzma \ 
     27                -r $(BIN_DIR)/openwrt-$(BOARD)-root.$(1) \ 
     28                -v XS2.ar2316.OpenWRT \ 
     29                -o $(BIN_DIR)/openwrt-$(BOARD)-ubnt2-$(1).bin 
     30        $(STAGING_DIR_HOST)/bin/mkfwimage -k $(BIN_DIR)/openwrt-$(BOARD)-vmlinux.lzma \ 
     31                -r $(BIN_DIR)/openwrt-$(BOARD)-root.$(1) \ 
     32                -v XS5.ar2313.OpenWRT \ 
     33                -o $(BIN_DIR)/openwrt-$(BOARD)-ubnt5-$(1).bin \ 
     34                -s 0xBE030000 
    2535endef 
    2636 
  • trunk/tools/firmware-utils/src/mkfwimage.c

    r11061 r11920  
    11/* 
    22 * Copyright (C) 2007 Ubiquiti Networks, Inc. 
     3 * Copyright (C) 2008 Lukas Kuna <ValXdater@seznam.cz> 
    34 * 
    45 * This program is free software; you can redistribute it and/or 
     
    2829#include <stdio.h> 
    2930#include <stdlib.h> 
    30 #include <limits.h> 
    31  
     31#include <linux/limits.h> 
    3232#include "fw.h" 
    3333 
     
    3636        int     partition_index; 
    3737        u_int32_t       partition_baseaddr; 
     38        u_int32_t       partition_startaddr; 
    3839        u_int32_t       partition_memaddr; 
    3940        u_int32_t       partition_entryaddr; 
     
    4849#define DEFAULT_VERSION         "UNKNOWN" 
    4950 
    50 #define OPTIONS "hv:o:i:" 
    51  
     51#define OPTIONS "hv:o:r:k:" 
     52 
     53#define FIRMWARE_MAX_LENGTH     (0x390000) 
     54#define partition_startaddr     (0xBFC30000) 
    5255static int debug = 0; 
    5356 
     
    5659        char outputfile[PATH_MAX]; 
    5760        u_int32_t       part_count; 
    58         part_data_t parts[MAX_SECTIONS];  
     61        part_data_t parts[MAX_SECTIONS]; 
    5962} image_info_t; 
    6063 
     
    129132             "\t-v <version string>\t - firmware version information, default: %s\n" 
    130133             "\t-o <output file>\t - firmware output file, default: %s\n" 
    131              "\t-i <input file>\t\t - firmware layout file, default: none\n" 
     134             "\t-k <kernel file>\t\t - kernel file\n" 
     135             "\t-r <rootfs file>\t\t - rootfs file\n" 
    132136             "\t-h\t\t\t - this help\n", VERSION, 
    133137             progname, DEFAULT_VERSION, DEFAULT_OUTPUT_FILE); 
     
    155159 
    156160 
     161static u_int32_t filelength(const char* file) 
     162{ 
     163        FILE *p; 
     164        int ret = -1; 
     165 
     166        if ( (p = fopen(file, "rb") ) == NULL) return (-1); 
     167 
     168        fseek(p, 0, SEEK_END); 
     169        ret = ftell(p); 
     170 
     171        fclose (p); 
     172 
     173        return (ret); 
     174} 
     175 
     176static int create_image_layout(const char* kernelfile, const char* rootfsfile, image_info_t* im) 
     177{ 
     178        part_data_t* kernel = &im->parts[0]; 
     179        part_data_t* rootfs = &im->parts[1]; 
     180 
     181        strcpy(kernel->partition_name, "kernel"); 
     182        kernel->partition_index = 1; 
     183        kernel->partition_baseaddr = partition_startaddr; 
     184        if ( (kernel->partition_length = filelength(kernelfile)) < 0) return (-1); 
     185        kernel->partition_memaddr = 0x80041000; 
     186        kernel->partition_entryaddr = 0x80041000; 
     187        strncpy(kernel->filename, kernelfile, sizeof(kernel->filename)); 
     188 
     189        if (filelength(rootfsfile) + kernel->partition_length > FIRMWARE_MAX_LENGTH) 
     190                return (-2); 
     191 
     192        strcpy(rootfs->partition_name, "rootfs"); 
     193        rootfs->partition_index = 2; 
     194        rootfs->partition_baseaddr = partition_startaddr + kernel->partition_length; 
     195        rootfs->partition_length = FIRMWARE_MAX_LENGTH - kernel->partition_length; 
     196        rootfs->partition_memaddr = 0x00000000; 
     197        rootfs->partition_entryaddr = 0x00000000; 
     198        strncpy(rootfs->filename, rootfsfile, sizeof(rootfs->filename)); 
     199 
     200        im->part_count = 2; 
     201 
     202        return 0; 
     203} 
     204 
    157205/** 
    158  * Image layout file format: 
    159  * 
    160  * <partition name>\t<partition index>\t<partition size>\t<data file name> 
    161  * 
    162  */ 
    163 static int parse_image_layout(const char* layoutfile, image_info_t* im) 
    164 { 
    165         int fd = 0; 
    166         char line[1028]; 
    167         FILE* f; 
    168  
    169         im->part_count = 0; 
    170  
    171         fd = open(layoutfile, O_RDONLY); 
    172         if (fd < 0) { 
    173                 ERROR("Could not open file '%s'\n", layoutfile); 
    174                 return -1; 
    175         } 
    176  
    177         f = fdopen(fd, "r"); 
    178         if (f == NULL) { 
    179                 close(fd); 
    180                 return -2; 
    181         } 
    182  
    183         while (!feof(f)) 
    184         { 
    185                 char name[32]; 
    186                 u_int32_t index; 
    187                 u_int32_t baseaddr; 
    188                 u_int32_t size; 
    189                 u_int32_t memaddr; 
    190                 u_int32_t entryaddr; 
    191                 char file[PATH_MAX]; 
    192                 u_int32_t c; 
    193                 part_data_t* d; 
    194  
    195                 if (fgets(line, sizeof(line), f) == NULL) 
    196                         break; 
    197  
    198                 // TODO: very inconvenient format, use smarter parsing someday 
    199                 if ((c = sscanf(line, "%32[^\t]\t%X\t%X\t%X\t%X\t%X\t%128[^\t\n]", name, &index, &baseaddr, &size, &memaddr, &entryaddr, file)) != 7) 
    200                         continue; 
    201  
    202                 DEBUG("%s\t\t0x%02X\t0x%08X\t0x%08X\t0x%08X\t0x%08X\t%s\n", name, index, baseaddr, size, memaddr, entryaddr, file); 
    203  
    204                 c = im->part_count; 
    205                 if (c == MAX_SECTIONS) 
    206                         break; 
    207  
    208                 d = &im->parts[c]; 
    209                 strncpy(d->partition_name, name, sizeof(d->partition_name)); 
    210                 d->partition_index = index; 
    211                 d->partition_baseaddr = baseaddr; 
    212                 d->partition_length = size; 
    213                 d->partition_memaddr = memaddr; 
    214                 d->partition_entryaddr = entryaddr; 
    215                 strncpy(d->filename, file, sizeof(d->filename)); 
    216  
    217                 im->part_count++; 
    218         } 
    219  
    220         fclose(f); 
    221  
    222         return 0; 
    223 } 
    224  
    225 /** 
    226  * Checks the availability and validity of all image components.  
     206 * Checks the availability and validity of all image components. 
    227207 * Fills in stats member of the part_data structure. 
    228208 */ 
     
    261241                if (d->stats.st_size > d->partition_length) { 
    262242                        ERROR("File '%s' too big (%d) - max size: 0x%08X (exceeds %lu bytes)\n", 
    263                                         d->filename, i, d->partition_length,  
     243                                        d->filename, i, d->partition_length, 
    264244                                        d->stats.st_size - d->partition_length); 
    265245                        return -4; 
     
    319299        if (fwrite(mem, mem_size, 1, f) != 1) 
    320300        { 
    321                 ERROR("Could not write %d bytes into file: '%s'\n",  
     301                ERROR("Could not write %d bytes into file: '%s'\n", 
    322302                                mem_size, im->outputfile); 
    323303                return -11; 
     
    332312int main(int argc, char* argv[]) 
    333313{ 
    334         char inputfile[PATH_MAX]; 
     314        char kernelfile[PATH_MAX]; 
     315        char rootfsfile[PATH_MAX]; 
    335316        int o, rc; 
    336317        image_info_t im; 
    337318 
    338319        memset(&im, 0, sizeof(im)); 
    339         memset(inputfile, 0, sizeof(inputfile)); 
     320        memset(kernelfile, 0, sizeof(kernelfile)); 
     321        memset(rootfsfile, 0, sizeof(rootfsfile)); 
    340322 
    341323        strcpy(im.outputfile, DEFAULT_OUTPUT_FILE); 
     
    352334                        if (optarg) 
    353335                                strncpy(im.outputfile, optarg, sizeof(im.outputfile)); 
    354                         break; 
    355                 case 'i': 
    356                         if (optarg) 
    357                                 strncpy(inputfile, optarg, sizeof(inputfile)); 
    358336                        break; 
    359337                case 'h': 
    360338                        usage(argv[0]); 
    361339                        return -1; 
    362                 } 
    363         } 
    364  
    365         if (strlen(inputfile) == 0) 
    366         { 
    367                 ERROR("Input file is not specified, cannot continue\n"); 
     340                case 'k': 
     341                        if (optarg) 
     342                                strncpy(kernelfile, optarg, sizeof(kernelfile)); 
     343                        break; 
     344                case 'r': 
     345                        if (optarg) 
     346                                strncpy(rootfsfile, optarg, sizeof(rootfsfile)); 
     347                        break; 
     348                case 's': 
     349                        if (optarg) 
     350                                #undef partition_startaddr 
     351                                #define partition_startaddr     (optarg) 
     352                        break; 
     353                } 
     354        } 
     355 
     356        if (strlen(kernelfile) == 0) 
     357        { 
     358                ERROR("Kernel file is not specified, cannot continue\n"); 
    368359                usage(argv[0]); 
    369360                return -2; 
    370361        } 
    371362 
    372         if ((rc = parse_image_layout(inputfile, &im)) != 0) 
    373         { 
    374                 ERROR("Failed parsing firmware layout file '%s' - error code: %d\n",  
    375                         inputfile, rc); 
     363        if (strlen(rootfsfile) == 0) 
     364        { 
     365                ERROR("Root FS file is not specified, cannot continue\n"); 
     366                usage(argv[0]); 
     367                return -2; 
     368        } 
     369 
     370        if ((rc = create_image_layout(kernelfile, rootfsfile, &im)) != 0) 
     371        { 
     372                ERROR("Failed creating firmware layout description - error code: %d\n", rc); 
    376373                return -3; 
    377374        } 
Note: See TracChangeset for help on using the changeset viewer.