Changeset 17662 for branches/8.09


Ignore:
Timestamp:
2009-09-21T14:38:22+02:00 (7 years ago)
Author:
nbd
Message:

merge mtd fis table changes from r17657-r17660 to 8.09 to provide a better upgrade path from 8.09 to trunk and back

Location:
branches/8.09
Files:
3 added
8 edited

Legend:

Unmodified
Added
Removed
  • branches/8.09/package/mtd/Makefile

    r17556 r17662  
    55# See /LICENSE for more information. 
    66# 
    7 # $Id$ 
    87 
    98include $(TOPDIR)/rules.mk 
     
    1110 
    1211PKG_NAME:=mtd 
    13 PKG_RELEASE:=8.1 
     12PKG_RELEASE:=8.2 
    1413 
    1514PKG_BUILD_DIR := $(KERNEL_BUILD_DIR)/$(PKG_NAME) 
     15STAMP_PREPARED := $(STAMP_PREPARED)_$(call confvar,CONFIG_MTD_REDBOOT_PARTS) 
    1616 
    1717include $(INCLUDE_DIR)/package.mk 
     
    3535target=$(firstword $(subst -, ,$(BOARD))) 
    3636 
    37 define Build/Compile 
    38         $(MAKE) -C $(PKG_BUILD_DIR) \ 
    39                 $(TARGET_CONFIGURE_OPTS) \ 
    40                 TARGET=$(target) \ 
    41                 CFLAGS="$(TARGET_CFLAGS) -Dtarget_$(target)=1 -Wall" 
    42 endef 
     37MAKE_FLAGS += TARGET="$(target)" 
     38TARGET_CFLAGS += -Dtarget_$(target)=1 -Wall 
     39 
     40ifdef CONFIG_MTD_REDBOOT_PARTS 
     41  MAKE_FLAGS += FIS_SUPPORT=1 
     42  TARGET_CFLAGS += -DFIS_SUPPORT=1 
     43endif 
    4344 
    4445define Package/mtd/install 
  • branches/8.09/package/mtd/src/Makefile

    r12655 r17662  
    66obj.brcm47xx = $(obj.brcm) 
    77 
     8ifdef FIS_SUPPORT 
     9  obj += fis.o 
     10endif 
     11 
    812mtd: $(obj) $(obj.$(TARGET)) 
    913clean: 
  • branches/8.09/package/mtd/src/jffs2.c

    r12707 r17662  
     1/* 
     2 * jffs2 on-disk structure generator for mtd 
     3 * 
     4 * Copyright (C) 2008 Felix Fietkau <nbd@openwrt.org> 
     5 * 
     6 * This program is free software; you can redistribute it and/or 
     7 * modify it under the terms of the GNU General Public License v2 
     8 * as published by the Free Software Foundation. 
     9 * 
     10 * This program is distributed in the hope that it will be useful, 
     11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
     12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
     13 * GNU General Public License for more details. 
     14 * Based on: 
     15 *   JFFS2 -- Journalling Flash File System, Version 2. 
     16 *   Copyright © 2001-2007 Red Hat, Inc. 
     17 *   Created by David Woodhouse <dwmw2@infradead.org> 
     18 */ 
    119#include <sys/types.h> 
    220#include <sys/stat.h> 
  • branches/8.09/package/mtd/src/jffs2.h

    r8444 r17662  
    99 * jffs2 directory. 
    1010 * 
    11  * $Id: jffs2.h,v 1.38 2005/09/26 11:37:23 havasi Exp $ 
    1211 * 
    1312 */ 
  • branches/8.09/package/mtd/src/mtd-api.h

    r8444 r17662  
    11 
    2 /* $Id: mtd.h,v 1.38 2003/01/12 16:30:19 spse Exp $ */ 
    32 
    43#ifndef __MTD_MTD_H__ 
  • branches/8.09/package/mtd/src/mtd.c

    r17523 r17662  
    22 * mtd - simple memory technology device manipulation tool 
    33 * 
    4  * Copyright (C) 2005 Waldemar Brodkorb <wbx@dass-it.de>, 
    5  *                        Felix Fietkau <nbd@openwrt.org> 
     4 * Copyright (C) 2005      Waldemar Brodkorb <wbx@dass-it.de>, 
     5 * Copyright (C) 2005-2009 Felix Fietkau <nbd@openwrt.org> 
    66 * 
    77 * This program is free software; you can redistribute it and/or 
    8  * modify it under the terms of the GNU General Public License 
    9  * as published by the Free Software Foundation; either version 2 
    10  * of the License, or (at your option) any later version. 
     8 * modify it under the terms of the GNU General Public License v2 
     9 * as published by the Free Software Foundation. 
    1110 * 
    1211 * This program is distributed in the hope that it will be useful, 
     
    1918 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
    2019 * 
    21  * $Id$ 
    2220 * 
    2321 * The code is based on the linux-mtd examples. 
     
    4543#include <linux/reboot.h> 
    4644#include "mtd-api.h" 
     45#include "fis.h" 
    4746#include "mtd.h" 
    4847 
     
    121120        mtdEraseInfo.length = erasesize; 
    122121        ioctl(fd, MEMUNLOCK, &mtdEraseInfo); 
    123         if (ioctl (fd, MEMERASE, &mtdEraseInfo) < 0) { 
    124                 fprintf(stderr, "Erasing mtd failed.\n"); 
    125                 exit(1); 
    126         } 
     122        if (ioctl (fd, MEMERASE, &mtdEraseInfo) < 0) 
     123                return -1; 
     124 
    127125        return 0; 
    128126} 
     
    148146static int mtd_check(const char *mtd) 
    149147{ 
     148        char *next = NULL; 
     149        char *str = NULL; 
    150150        int fd; 
    151151 
    152         fd = mtd_check_open(mtd); 
    153         if (!fd) 
    154                 return 0; 
    155  
    156         if (!buf) 
    157                 buf = malloc(erasesize); 
    158  
    159         close(fd); 
     152        if (strchr(mtd, ':')) { 
     153                str = strdup(mtd); 
     154                mtd = str; 
     155        } 
     156 
     157        do { 
     158                next = strchr(mtd, ':'); 
     159                if (next) { 
     160                        *next = 0; 
     161                        next++; 
     162                } 
     163 
     164                fd = mtd_check_open(mtd); 
     165                if (!fd) 
     166                        return 0; 
     167 
     168                if (!buf) 
     169                        buf = malloc(erasesize); 
     170 
     171                close(fd); 
     172                mtd = next; 
     173        } while (next); 
     174 
     175        if (str) 
     176                free(str); 
     177 
    160178        return 1; 
    161179} 
     
    164182mtd_unlock(const char *mtd) 
    165183{ 
     184        struct erase_info_user mtdLockInfo; 
     185        char *next = NULL; 
     186        char *str = NULL; 
    166187        int fd; 
    167         struct erase_info_user mtdLockInfo; 
     188 
     189        if (strchr(mtd, ':')) { 
     190                str = strdup(mtd); 
     191                mtd = str; 
     192        } 
     193 
     194        do { 
     195                next = strchr(mtd, ':'); 
     196                if (next) { 
     197                        *next = 0; 
     198                        next++; 
     199                } 
     200 
     201                fd = mtd_check_open(mtd); 
     202                if(fd <= 0) { 
     203                        fprintf(stderr, "Could not open mtd device: %s\n", mtd); 
     204                        exit(1); 
     205                } 
     206 
     207                if (quiet < 2) 
     208                        fprintf(stderr, "Unlocking %s ...\n", mtd); 
     209 
     210                mtdLockInfo.start = 0; 
     211                mtdLockInfo.length = mtdsize; 
     212                ioctl(fd, MEMUNLOCK, &mtdLockInfo); 
     213                close(fd); 
     214                mtd = next; 
     215        } while (next); 
     216 
     217        if (str) 
     218                free(str); 
     219 
     220        return 0; 
     221} 
     222 
     223static int 
     224mtd_erase(const char *mtd) 
     225{ 
     226        int fd; 
     227        struct erase_info_user mtdEraseInfo; 
     228 
     229        if (quiet < 2) 
     230                fprintf(stderr, "Erasing %s ...\n", mtd); 
    168231 
    169232        fd = mtd_check_open(mtd); 
     
    173236        } 
    174237 
    175         if (quiet < 2)  
    176                 fprintf(stderr, "Unlocking %s ...\n", mtd); 
    177  
    178         mtdLockInfo.start = 0; 
    179         mtdLockInfo.length = mtdsize; 
    180         if(ioctl(fd, MEMUNLOCK, &mtdLockInfo)) { 
    181                 close(fd); 
    182                 return 0; 
    183         } 
    184                  
     238        mtdEraseInfo.length = erasesize; 
     239 
     240        for (mtdEraseInfo.start = 0; 
     241                 mtdEraseInfo.start < mtdsize; 
     242                 mtdEraseInfo.start += erasesize) { 
     243 
     244                ioctl(fd, MEMUNLOCK, &mtdEraseInfo); 
     245                if(ioctl(fd, MEMERASE, &mtdEraseInfo)) 
     246                        fprintf(stderr, "Failed to erase block on %s at 0x%x\n", mtd, mtdEraseInfo.start); 
     247        } 
     248 
    185249        close(fd); 
    186250        return 0; 
     251 
    187252} 
    188253 
    189254static int 
    190 mtd_erase(const char *mtd) 
     255mtd_refresh(const char *mtd) 
    191256{ 
    192257        int fd; 
    193         struct erase_info_user mtdEraseInfo; 
    194258 
    195259        if (quiet < 2) 
    196                 fprintf(stderr, "Erasing %s ...\n", mtd); 
     260                fprintf(stderr, "Refreshing mtd partition %s ... ", mtd); 
    197261 
    198262        fd = mtd_check_open(mtd); 
     
    202266        } 
    203267 
    204         mtdEraseInfo.length = erasesize; 
    205  
    206         for (mtdEraseInfo.start = 0; 
    207                  mtdEraseInfo.start < mtdsize; 
    208                  mtdEraseInfo.start += erasesize) { 
    209                  
    210                 ioctl(fd, MEMUNLOCK, &mtdEraseInfo); 
    211                 if(ioctl(fd, MEMERASE, &mtdEraseInfo)) 
    212                         fprintf(stderr, "Failed to erase block on %s at 0x%x\n", mtd, mtdEraseInfo.start); 
    213         }                
    214  
    215         close(fd); 
    216         return 0; 
    217  
    218 } 
    219  
    220 static int 
    221 mtd_refresh(const char *mtd) 
    222 { 
    223         int fd; 
    224  
    225         if (quiet < 2) 
    226                 fprintf(stderr, "Refreshing mtd partition %s ... ", mtd); 
    227  
    228         fd = mtd_check_open(mtd); 
    229         if(fd <= 0) { 
    230                 fprintf(stderr, "Could not open mtd device: %s\n", mtd); 
    231                 exit(1); 
    232         } 
    233  
    234268        if (ioctl(fd, MTDREFRESH, NULL)) { 
    235269                fprintf(stderr, "Failed to refresh the MTD device\n"); 
     
    246280 
    247281static int 
    248 mtd_write(int imagefd, const char *mtd) 
    249 { 
     282mtd_write(int imagefd, const char *mtd, char *fis_layout) 
     283{ 
     284        char *next = NULL; 
     285        char *str = NULL; 
    250286        int fd, result; 
    251287        ssize_t r, w, e; 
     288        uint32_t offset = 0; 
     289 
     290#ifdef FIS_SUPPORT 
     291        static struct fis_part new_parts[MAX_ARGS]; 
     292        static struct fis_part old_parts[MAX_ARGS]; 
     293        int n_new = 0, n_old = 0; 
     294 
     295        if (fis_layout) { 
     296                const char *tmp = mtd; 
     297                char *word, *brkt; 
     298                int ret; 
     299 
     300                memset(&old_parts, 0, sizeof(old_parts)); 
     301                memset(&new_parts, 0, sizeof(new_parts)); 
     302 
     303                do { 
     304                        next = strchr(tmp, ':'); 
     305                        if (!next) 
     306                                next = (char *) tmp + strlen(tmp); 
     307 
     308                        memcpy(old_parts[n_old].name, tmp, next - tmp); 
     309 
     310                        n_old++; 
     311                        tmp = next + 1; 
     312                } while(*next); 
     313 
     314                for (word = strtok_r(fis_layout, ",", &brkt); 
     315                     word; 
     316                         word = strtok_r(NULL, ",", &brkt)) { 
     317 
     318                        tmp = strtok(word, ":"); 
     319                        strncpy((char *) new_parts[n_new].name, tmp, sizeof(new_parts[n_new].name) - 1); 
     320 
     321                        tmp = strtok(NULL, ":"); 
     322                        if (!tmp) 
     323                                goto next; 
     324 
     325                        new_parts[n_new].size = strtoul(tmp, NULL, 0); 
     326 
     327                        tmp = strtok(NULL, ":"); 
     328                        if (!tmp) 
     329                                goto next; 
     330 
     331                        new_parts[n_new].loadaddr = strtoul(tmp, NULL, 16); 
     332next: 
     333                        n_new++; 
     334                } 
     335                ret = fis_validate(old_parts, n_old, new_parts, n_new); 
     336                if (ret < 0) { 
     337                        fprintf(stderr, "Failed to validate the new FIS partition table\n"); 
     338                        exit(1); 
     339                } 
     340                if (ret == 0) 
     341                        fis_layout = NULL; 
     342        } 
     343#endif 
     344 
     345        if (strchr(mtd, ':')) { 
     346                str = strdup(mtd); 
     347                mtd = str; 
     348        } 
     349 
     350        r = 0; 
     351 
     352resume: 
     353        next = strchr(mtd, ':'); 
     354        if (next) { 
     355                *next = 0; 
     356                next++; 
     357        } 
    252358 
    253359        fd = mtd_check_open(mtd); 
     
    256362                exit(1); 
    257363        } 
    258                  
     364 
    259365        if (quiet < 2) 
    260366                fprintf(stderr, "Writing from %s to %s ... ", imagefile, mtd); 
    261367 
    262         r = w = e = 0; 
     368        w = e = 0; 
    263369        if (!quiet) 
    264370                fprintf(stderr, " [ ]"); 
    265371 
    266372        for (;;) { 
    267                 /* buffer may contain data already (from trx check) */ 
    268                 do { 
     373                /* buffer may contain data already (from trx check or last mtd partition write attempt) */ 
     374                while (buflen < erasesize) { 
    269375                        r = read(imagefd, buf + buflen, erasesize - buflen); 
    270376                        if (r < 0) { 
     
    281387 
    282388                        buflen += r; 
    283                 } while (buflen < erasesize); 
     389                } 
    284390 
    285391                if (buflen == 0) 
     
    306412                                fprintf(stderr, "\b\b\b[e]"); 
    307413 
    308                         mtd_erase_block(fd, e); 
     414 
     415                        if (mtd_erase_block(fd, e) < 0) { 
     416                                if (next) { 
     417                                        if (w < e) { 
     418                                                write(fd, buf + offset, e - w); 
     419                                                offset = e - w; 
     420                                        } 
     421                                        w = 0; 
     422                                        e = 0; 
     423                                        close(fd); 
     424                                        mtd = next; 
     425                                        fprintf(stderr, "\b\b\b   \n"); 
     426                                        goto resume; 
     427                                } else { 
     428                                        fprintf(stderr, "Failed to erase block\n"); 
     429                                        exit(1); 
     430                                } 
     431                        } 
    309432 
    310433                        /* erase the chunk */ 
    311434                        e += erasesize; 
    312435                } 
    313                  
     436 
    314437                if (!quiet) 
    315438                        fprintf(stderr, "\b\b\b[w]"); 
    316                  
    317                 if ((result = write(fd, buf, buflen)) < buflen) { 
     439 
     440                if ((result = write(fd, buf + offset, buflen)) < buflen) { 
    318441                        if (result < 0) { 
    319442                                fprintf(stderr, "Error writing image.\n"); 
     
    327450 
    328451                buflen = 0; 
    329         } 
     452                offset = 0; 
     453        } 
     454 
    330455        if (!quiet) 
    331                 fprintf(stderr, "\b\b\b\b"); 
     456                fprintf(stderr, "\b\b\b\b    "); 
    332457 
    333458done: 
     
    335460                fprintf(stderr, "\n"); 
    336461 
     462#ifdef FIS_SUPPORT 
     463        if (fis_layout) { 
     464                if (fis_remap(old_parts, n_old, new_parts, n_new) < 0) 
     465                        fprintf(stderr, "Failed to update the FIS partition table\n"); 
     466        } 
     467#endif 
     468 
    337469        close(fd); 
    338470        return 0; 
     
    341473static void usage(void) 
    342474{ 
    343         fprintf(stderr, "Usage: mtd [<options> ...] <command> [<arguments> ...] <device>\n\n" 
     475        fprintf(stderr, "Usage: mtd [<options> ...] <command> [<arguments> ...] <device>[:<device>...]\n\n" 
    344476        "The device is in the format of mtdX (eg: mtd4) or its label.\n" 
    345477        "mtd recognizes these commands:\n" 
     
    357489        "        -d <name>               directory for jffs2write, defaults to \"tmp\"\n" 
    358490        "        -j <name>               integrate <file> into jffs2 data when writing an image\n" 
     491#ifdef FIS_SUPPORT 
     492        "        -F <part>[:<size>[:<entrypoint>]][,<part>...]\n" 
     493        "                                alter the fis partition table to create new partitions replacing\n" 
     494        "                                the partitions provided as argument to the write command\n" 
     495        "                                (only valid together with the write command)\n" 
     496#endif 
    359497        "\n" 
    360498        "Example: To write linux.trx to mtd4 labeled as linux and reboot afterwards\n" 
     
    380518        int ch, i, boot, imagefd = 0, force, unlocked; 
    381519        char *erase[MAX_ARGS], *device = NULL; 
     520        char *fis_layout = NULL; 
    382521        enum { 
    383522                CMD_ERASE, 
     
    387526                CMD_JFFS2WRITE 
    388527        } cmd = -1; 
    389          
     528 
    390529        erase[0] = NULL; 
    391530        boot = 0; 
     
    394533        quiet = 0; 
    395534 
    396         while ((ch = getopt(argc, argv, "frqe:d:j:")) != -1) 
     535        while ((ch = getopt(argc, argv, 
     536#ifdef FIS_SUPPORT 
     537                        "F:" 
     538#endif 
     539                        "frqe:d:j:")) != -1) 
    397540                switch (ch) { 
    398541                        case 'f': 
     
    412555                                while ((erase[i] != NULL) && ((i + 1) < MAX_ARGS)) 
    413556                                        i++; 
    414                                          
     557 
    415558                                erase[i++] = optarg; 
    416559                                erase[i] = NULL; 
     
    419562                                jffs2dir = optarg; 
    420563                                break; 
     564#ifdef FIS_SUPPORT 
     565                        case 'F': 
     566                                fis_layout = optarg; 
     567                                break; 
     568#endif 
    421569                        case '?': 
    422570                        default: 
     
    425573        argc -= optind; 
    426574        argv += optind; 
    427          
     575 
    428576        if (argc < 2) 
    429577                usage(); 
     
    441589                cmd = CMD_WRITE; 
    442590                device = argv[2]; 
    443          
     591 
    444592                if (strcmp(argv[1], "-") == 0) { 
    445593                        imagefile = "<stdin>"; 
     
    452600                        } 
    453601                } 
    454          
     602 
    455603                if (!mtd_check(device)) { 
    456604                        fprintf(stderr, "Can't open device for writing!\n"); 
     
    465613                cmd = CMD_JFFS2WRITE; 
    466614                device = argv[2]; 
    467          
     615 
    468616                imagefile = argv[1]; 
    469617                if (!mtd_check(device)) { 
     
    476624 
    477625        sync(); 
    478          
     626 
    479627        i = 0; 
    480628        unlocked = 0; 
     
    486634                i++; 
    487635        } 
    488          
    489                  
     636 
    490637        switch (cmd) { 
    491638                case CMD_UNLOCK: 
     
    501648                        if (!unlocked) 
    502649                                mtd_unlock(device); 
    503                         mtd_write(imagefd, device); 
     650                        mtd_write(imagefd, device, fis_layout); 
    504651                        break; 
    505652                case CMD_JFFS2WRITE: 
     
    514661 
    515662        sync(); 
    516          
     663 
    517664        if (boot) 
    518665                do_reboot(); 
  • branches/8.09/target/linux/atheros/config-default

    r17382 r17662  
    162162CONFIG_MTD_REDBOOT_DIRECTORY_BLOCK=-3 
    163163CONFIG_MTD_REDBOOT_PARTS=y 
    164 CONFIG_MTD_REDBOOT_PARTS_READONLY=y 
     164# CONFIG_MTD_REDBOOT_PARTS_READONLY is not set 
    165165# CONFIG_MTD_ROM is not set 
    166166# CONFIG_MTD_SLRAM is not set 
  • branches/8.09/target/linux/atheros/files/drivers/mtd/devices/spiflash.c

    r10872 r17662  
    318318 
    319319        instr->state = MTD_ERASE_DONE; 
    320         if (instr->callback) instr->callback (instr); 
     320        mtd_erase_callback(instr); 
    321321 
    322322        return 0; 
Note: See TracChangeset for help on using the changeset viewer.