Changeset 42170


Ignore:
Timestamp:
2014-08-16T20:09:31+02:00 (3 years ago)
Author:
florian
Message:

adm8668: revert changeset 34554

The conversion was not 100% correct and leads to u-boot failing to
verify the CRC, revert that change for now.

Signed-off-by: Florian Fainelli <florian@…>

Location:
trunk/target/linux/adm8668
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/adm8668/config-3.3

    r34564 r42170  
    6868# CONFIG_MIPS_MACHINE is not set 
    6969CONFIG_MIPS_MT_DISABLED=y 
    70 CONFIG_MTD_ADM8668_PARTS=y 
    71 CONFIG_MTD_PHYSMAP=y 
     70CONFIG_MTD_ADM8668_NOR=y 
    7271CONFIG_NEED_DMA_MAP_STATE=y 
    7372CONFIG_NEED_PER_CPU_KM=y 
  • trunk/target/linux/adm8668/files/arch/mips/adm8668/platform.c

    r34566 r42170  
    11/* 
    2  * Infineon/ADMTek 8668 (WildPass) platform devices support 
    3  * 
    42 * Copyright (C) 2010 Scott Nicholas <neutronscott@scottn.us> 
    53 * Copyright (C) 2012 Florian Fainelli <florian@openwrt.org> 
     
    1614#include <linux/usb/ehci_pdriver.h> 
    1715#include <linux/mtd/physmap.h> 
    18 #include <linux/mtd/partitions.h> 
    1916#include <linux/pci.h> 
    2017#include <linux/slab.h> 
     
    109106}; 
    110107 
    111 static const char *nor_probe_types[] = { "adm8668part", NULL }; 
    112  
    113 static struct physmap_flash_data nor_flash_data = { 
    114         .width                  = 2, 
    115         .part_probe_types       = nor_probe_types, 
    116 }; 
    117  
    118 static struct resource nor_resources[] = { 
    119         { 
    120                 .start  = ADM8668_SMEM1_BASE, 
    121                 .end    = ADM8668_SMEM1_BASE + 0x800000 - 1, 
    122                 .flags  = IORESOURCE_MEM, 
    123         }, 
    124 }; 
    125  
    126 static struct platform_device adm8668_nor_device = { 
    127         .name           = "physmap-flash", 
    128         .id             = -1, 
    129         .resource       = nor_resources, 
    130         .num_resources  = ARRAY_SIZE(nor_resources), 
    131         .dev.platform_data = &nor_flash_data, 
    132 }; 
    133  
    134108static struct resource usb_resources[] = { 
    135109        { 
     
    162136        &adm8668_eth0_device, 
    163137        &adm8668_eth1_device, 
    164         &adm8668_nor_device, 
    165138        &adm8668_usb_device, 
    166139}; 
  • trunk/target/linux/adm8668/files/drivers/mtd/maps/adm8668.c

    r40732 r42170  
    11/* 
    2  * Infineon/ADMTek ADM8668 (WildPass) partition parser support 
    3  * 
    4  * Copyright (C) 2010 Scott Nicholas <neutronscott@scottn.us> 
    5  * Copyright (C) 2012 Florian Fainelli <florian@openwrt.org> 
    6  * 
    7  * original functions for finding root filesystem from Mike Baker 
    8  * 
    9  * This program is free software; you can redistribute  it and/or modify it 
    10  * under  the terms of  the GNU General  Public License as published by the 
    11  * Free Software Foundation;  either version 2 of the  License, or (at your 
    12  * option) any later version. 
    13  * 
    14  * THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED 
    15  * WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF 
    16  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN 
    17  * NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT, 
    18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
    19  * NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF 
    20  * USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
    21  * ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT 
    22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 
    23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
    24  * 
    25  * You should have received a copy of the  GNU General Public License along 
    26  * with this program; if not, write  to the Free Software Foundation, Inc., 
    27  * 675 Mass Ave, Cambridge, MA 02139, USA. 
     2 *  Copyright (C) 2010 Scott Nicholas <neutronscott@scottn.us> 
     3 *  Copyright (C) 2006 Felix Fietkau <nbd@openwrt.org> 
     4 *  Copyright (C) 2005 Waldemar Brodkorb <wbx@openwrt.org> 
     5 *  Copyright (C) 2004 Florian Schirmer (jolt@tuxbox.org) 
     6 * 
     7 *  original functions for finding root filesystem from Mike Baker 
     8 * 
     9 *  This program is free software; you can redistribute  it and/or modify it 
     10 *  under  the terms of  the GNU General  Public License as published by the 
     11 *  Free Software Foundation;  either version 2 of the  License, or (at your 
     12 *  option) any later version. 
     13 * 
     14 *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED 
     15 *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF 
     16 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN 
     17 *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT, 
     18 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
     19 *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF 
     20 *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
     21 *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT 
     22 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 
     23 *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
     24 * 
     25 *  You should have received a copy of the  GNU General Public License along 
     26 *  with this program; if not, write  to the Free Software Foundation, Inc., 
     27 *  675 Mass Ave, Cambridge, MA 02139, USA. 
    2828 * 
    2929 * 
     
    3535 * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS 
    3636 * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE. 
     37 * 
     38 * Flash mapping for adm8668 boards 
     39 * 
    3740 */ 
    3841 
     
    4346#include <linux/wait.h> 
    4447#include <linux/mtd/mtd.h> 
     48#include <linux/mtd/map.h> 
     49#include <linux/slab.h> 
    4550#include <linux/mtd/partitions.h> 
    46 #include <linux/vmalloc.h> 
    47 #include <linux/slab.h> 
    4851#include <linux/crc32.h> 
    4952#include <linux/magic.h> 
    50  
    51 #define PFX     "adm8668-part: " 
     53#include <asm/io.h> 
     54 
     55#define WINDOW_ADDR     0x10000000 
     56#define WINDOW_SIZE     0x800000 
     57#define BANKWIDTH       2 
    5258 
    5359/* first a little bit about the headers i need.. */ 
     
    7682}; 
    7783 
     84/************************************************/ 
     85 
     86static struct mtd_info *adm8668_mtd; 
     87 
     88struct map_info adm8668_map = { 
     89        name: "adm8668-nor", 
     90        size: WINDOW_SIZE, 
     91        phys: WINDOW_ADDR, 
     92        bankwidth: BANKWIDTH, 
     93}; 
     94 
     95/* 
     96 * Copied from mtdblock.c 
     97 * 
     98 * Cache stuff... 
     99 * 
     100 * Since typical flash erasable sectors are much larger than what Linux's 
     101 * buffer cache can handle, we must implement read-modify-write on flash 
     102 * sectors for each block write requests.  To avoid over-erasing flash sectors 
     103 * and to speed things up, we locally cache a whole flash sector while it is 
     104 * being written to until a different sector is required. 
     105 */ 
     106 
     107static void erase_callback(struct erase_info *done) 
     108{ 
     109        wait_queue_head_t *wait_q = (wait_queue_head_t *)done->priv; 
     110        wake_up(wait_q); 
     111} 
     112 
     113static int erase_write (struct mtd_info *mtd, unsigned long pos, 
     114                        int len, const char *buf) 
     115{ 
     116        struct erase_info erase; 
     117        DECLARE_WAITQUEUE(wait, current); 
     118        wait_queue_head_t wait_q; 
     119        size_t retlen; 
     120        int ret; 
     121 
     122        /* 
     123         * First, let's erase the flash block. 
     124         */ 
     125 
     126        init_waitqueue_head(&wait_q); 
     127        erase.mtd = mtd; 
     128        erase.callback = erase_callback; 
     129        erase.addr = pos; 
     130        erase.len = len; 
     131        erase.priv = (u_long)&wait_q; 
     132 
     133        set_current_state(TASK_INTERRUPTIBLE); 
     134        add_wait_queue(&wait_q, &wait); 
     135 
     136        ret = mtd->erase(mtd, &erase); 
     137        if (ret) { 
     138                set_current_state(TASK_RUNNING); 
     139                remove_wait_queue(&wait_q, &wait); 
     140                printk (KERN_WARNING "erase of region [0x%lx, 0x%x] " 
     141                                     "on \"%s\" failed\n", 
     142                        pos, len, mtd->name); 
     143                return ret; 
     144        } 
     145 
     146        schedule();  /* Wait for erase to finish. */ 
     147        remove_wait_queue(&wait_q, &wait); 
     148 
     149        /* 
     150         * Next, write data to flash. 
     151         */ 
     152 
     153        ret = mtd->write (mtd, pos, len, &retlen, buf); 
     154        if (ret) 
     155                return ret; 
     156        if (retlen != len) 
     157                return -EIO; 
     158        return 0; 
     159} 
     160 
     161/* decent defaults in case... shrug */ 
     162static struct mtd_partition adm8668_parts[] = { 
     163        { name: "linux",        offset: 0x40000,        size: WINDOW_SIZE-0x40000, }, 
     164        { name: "rootfs",       offset: 0xe0000,        size: 0x140000, }, 
     165        { name: "uboot_env",    offset: 0x20000,        size: 0x20000, }, 
     166        { name: NULL, }, 
     167}; 
     168 
    78169/* in case i wanna change stuff later, and to clarify the math section... */ 
    79170#define PART_LINUX      0 
    80171#define PART_ROOTFS     1 
    81 #define PART_UBOOT_ENV  2 
    82172#define NR_PARTS        3 
    83173 
    84 static int adm8668_parse_partitions(struct mtd_info *master, 
    85                                     struct mtd_partition **pparts, 
    86                                     struct mtd_part_parser_data *data) 
    87 { 
    88         int ret; 
     174static int __init 
     175init_mtd_partitions(struct mtd_info *mtd, size_t size) 
     176{ 
    89177        struct uboot_header uhdr; 
    90178        int off, blocksize; 
    91179        size_t len, linux_len; 
    92180        struct squashfs_super_block shdr; 
    93         struct erase_info erase_info; 
    94         struct mtd_partition *adm8668_parts; 
    95  
    96         memset(&erase_info, 0, sizeof(erase_info)); 
    97  
    98         blocksize = master->erasesize; 
    99  
     181 
     182        blocksize = mtd->erasesize; 
    100183        if (blocksize < 0x10000) 
    101184                blocksize = 0x10000; 
    102185 
    103         adm8668_parts = kzalloc(sizeof(*adm8668_parts) * NR_PARTS, GFP_KERNEL); 
    104         if (!adm8668_parts) 
    105                 return -ENOMEM; 
    106  
    107         adm8668_parts[PART_LINUX].name = kstrdup("linux", GFP_KERNEL); 
    108         adm8668_parts[PART_LINUX].offset = 0x40000; 
    109         adm8668_parts[PART_LINUX].size = master->size - 0x40000; 
    110         adm8668_parts[PART_ROOTFS].name = kstrdup("rootfs", GFP_KERNEL); 
    111         adm8668_parts[PART_ROOTFS].offset = 0xe0000; 
    112         adm8668_parts[PART_ROOTFS].size = 0x140000; 
    113         adm8668_parts[PART_UBOOT_ENV].name = kstrdup("uboot_env", GFP_KERNEL); 
    114         adm8668_parts[PART_UBOOT_ENV].offset = 0x20000; 
    115         adm8668_parts[PART_UBOOT_ENV].size = 0x20000; 
    116  
    117186        /* now find squashfs */ 
    118187        memset(&shdr, 0xe5, sizeof(shdr)); 
    119  
    120         for (off = 0x40000; off < master->size; off += blocksize) { 
     188        for (off = adm8668_parts[PART_LINUX].offset; off < size; off += blocksize) { 
    121189                /* 
    122190                 * Read into buffer 
    123191                 */ 
    124                 if (mtd_read(master, off, sizeof(shdr), &len, (char *)&shdr) || 
     192                if (mtd->read(mtd, off, sizeof(shdr), &len, (char *)&shdr) || 
    125193                    len != sizeof(shdr)) 
    126194                        continue; 
     
    129197                        uint32_t fs_size = (uint32_t)shdr.bytes_used; 
    130198 
    131                         pr_info(PFX "filesystem type: squashfs, size=%dkB\n", 
    132                                 fs_size >> 10); 
    133  
    134                         /* 
    135                          * Update rootfs based on the superblock info, and 
    136                          * stretch to end of MTD. rootfs_split will split it 
    137                          */ 
     199                        printk(KERN_INFO "%s: Filesystem type: squashfs, size=%dkB\n", 
     200                                mtd->name, fs_size>>10); 
     201 
     202                        /* Update rootfs based on the superblock info, and 
     203                         * stretch to end of MTD. rootfs_split will split it */ 
    138204                        adm8668_parts[PART_ROOTFS].offset = off; 
    139                         adm8668_parts[PART_ROOTFS].size = master->size - 
     205                        adm8668_parts[PART_ROOTFS].size = mtd->size - 
    140206                                adm8668_parts[PART_ROOTFS].offset; 
    141207 
    142                         /* 
    143                          * kernel ends where rootfs starts 
    144                          * but we'll keep it full-length for upgrades 
    145                          */ 
    146                         linux_len = adm8668_parts[PART_LINUX + 1].offset - 
     208                        /* kernel ends where rootfs starts 
     209                         * but we'll keep it full-length for upgrades */ 
     210                        linux_len = adm8668_parts[PART_LINUX+1].offset - 
    147211                                adm8668_parts[PART_LINUX].offset; 
    148  
    149                         adm8668_parts[PART_LINUX].size = master->size - 
     212#if 1 
     213                        adm8668_parts[PART_LINUX].size = mtd->size - 
    150214                                adm8668_parts[PART_LINUX].offset; 
     215#else 
     216                        adm8668_parts[PART_LINUX].size = linux_len; 
     217#endif 
    151218                        goto found; 
    152219                } 
    153220        } 
    154221 
    155         pr_err(PFX "could't find root filesystem\n"); 
     222        printk(KERN_NOTICE 
     223               "%s: Couldn't find root filesystem\n", 
     224               mtd->name); 
    156225        return NR_PARTS; 
    157226 
    158 found: 
    159         if (mtd_read(master, adm8668_parts[PART_LINUX].offset, sizeof(uhdr), &len, (char *)&uhdr) || 
    160             len != sizeof(uhdr)) { 
    161                 pr_err(PFX "failed to read u-boot header\n"); 
     227 found: 
     228        if (mtd->read(mtd, adm8668_parts[PART_LINUX].offset, sizeof(uhdr), &len, (char *)&uhdr) || 
     229            len != sizeof(uhdr)) 
    162230                return NR_PARTS; 
    163         } 
    164  
    165         if (uhdr.ih_magic != IH_MAGIC) { 
    166                 pr_info(PFX "invalid u-boot magic detected?!?!\n"); 
     231 
     232        /* that's odd. how'd ya boot it then */ 
     233        if (uhdr.ih_magic != IH_MAGIC) 
    167234                return NR_PARTS; 
    168         } 
    169235 
    170236        if (be32_to_cpu(uhdr.ih_size) != (linux_len - sizeof(uhdr))) { 
    171                 u32 data; 
    172                 size_t data_len = 0; 
    173                 unsigned char *block; 
     237                unsigned char *block, *data; 
    174238                unsigned int offset; 
    175239 
    176240                offset = adm8668_parts[PART_LINUX].offset + 
    177241                         sizeof(struct uboot_header); 
    178  
    179                 pr_info(PFX "Updating U-boot image:\n"); 
    180                 pr_info(PFX "  old: [size: %8d crc32: 0x%08x]\n", 
     242                data = (unsigned char *)(WINDOW_ADDR | 0xA0000000 | offset); 
     243 
     244                printk(KERN_NOTICE "Updating U-boot image:\n"); 
     245                printk(KERN_NOTICE "  old: [size: %8d crc32: 0x%08x]\n", 
    181246                        be32_to_cpu(uhdr.ih_size), be32_to_cpu(uhdr.ih_dcrc)); 
    182  
    183                 if (mtd_read(master, offset, sizeof(data), &data_len, (char *)&data)) { 
    184                         pr_err(PFX "failed to read data\n"); 
    185                         goto out; 
    186                 } 
    187247 
    188248                /* Update the data length & crc32 */ 
    189249                uhdr.ih_size = cpu_to_be32(linux_len - sizeof(uhdr)); 
    190                 uhdr.ih_dcrc = crc32_le(~0, (char *)&data, linux_len - sizeof(uhdr)) ^ (~0); 
     250                uhdr.ih_dcrc = crc32_le(~0, data, linux_len - sizeof(uhdr)) ^ (~0); 
    191251                uhdr.ih_dcrc = cpu_to_be32(uhdr.ih_dcrc); 
    192252 
    193                 pr_info(PFX "  new: [size: %8d crc32: 0x%08x]\n", 
     253                printk(KERN_NOTICE "  new: [size: %8d crc32: 0x%08x]\n", 
    194254                        be32_to_cpu(uhdr.ih_size), be32_to_cpu(uhdr.ih_dcrc)); 
    195255 
     
    201261 
    202262                /* read first eraseblock from the image */ 
    203                 block = vmalloc(master->erasesize); 
    204                 if (!block) 
    205                         return -ENOMEM; 
    206  
    207                 if (mtd_read(master, adm8668_parts[PART_LINUX].offset, master->erasesize, &len, block) 
    208                                 || len != master->erasesize) { 
    209                         pr_err(PFX "error copying first eraseblock\n"); 
     263                block = kmalloc(mtd->erasesize, GFP_KERNEL); 
     264                if (mtd->read(mtd, adm8668_parts[PART_LINUX].offset, mtd->erasesize, &len, block) || len != mtd->erasesize) { 
     265                        printk("Error copying first eraseblock\n"); 
    210266                        return 0; 
    211267                } 
     
    213269                /* Write updated header to the flash */ 
    214270                memcpy(block, &uhdr, sizeof(uhdr)); 
    215                 if (master->unlock) 
    216                         master->unlock(master, off, master->erasesize); 
    217  
    218                 erase_info.mtd = master; 
    219                 erase_info.addr = (uint64_t)adm8668_parts[PART_LINUX].offset; 
    220                 erase_info.len = master->erasesize; 
    221                 ret = mtd_erase(master, &erase_info); 
    222                 if (!ret) { 
    223                         if (mtd_write(master, adm8668_parts[PART_LINUX].offset, master->erasesize, 
    224                                         &len, block)) 
    225                                 pr_err(PFX "write failed"); 
    226                 } else 
    227                         pr_err(PFX "erase failed"); 
    228  
    229                 mtd_sync(master); 
    230 out: 
    231                 if (block) 
    232                         vfree(block); 
    233                 pr_info(PFX "done\n"); 
    234         } 
    235  
    236         *pparts = adm8668_parts; 
     271                if (mtd->unlock) 
     272                        mtd->unlock(mtd, off, mtd->erasesize); 
     273                erase_write(mtd, adm8668_parts[PART_LINUX].offset, mtd->erasesize, block); 
     274                if (mtd->sync) 
     275                        mtd->sync(mtd); 
     276                kfree(block); 
     277                printk(KERN_NOTICE "Done\n"); 
     278        } 
    237279 
    238280        return NR_PARTS; 
    239281} 
    240282 
    241 static struct mtd_part_parser adm8668_parser = { 
    242         .owner  = THIS_MODULE, 
    243         .parse_fn = adm8668_parse_partitions, 
    244         .name = "adm8668part", 
    245 }; 
    246  
    247 static int __init adm8668_parser_init(void) 
    248 { 
    249         register_mtd_parser(&adm8668_parser); 
     283int __init init_adm8668_map(void) 
     284{ 
     285        int nr_parts, ret; 
     286 
     287        adm8668_map.virt = ioremap(WINDOW_ADDR, WINDOW_SIZE); 
     288 
     289        if (!adm8668_map.virt) { 
     290                printk(KERN_ERR "Failed to ioremap\n"); 
     291                return -EIO; 
     292        } 
     293 
     294        simple_map_init(&adm8668_map); 
     295        if (!(adm8668_mtd = do_map_probe("cfi_probe", &adm8668_map))) { 
     296                printk(KERN_ERR "cfi_probe failed\n"); 
     297                iounmap((void *)adm8668_map.virt); 
     298                return -ENXIO; 
     299        } 
     300 
     301        adm8668_mtd->owner = THIS_MODULE; 
     302 
     303        nr_parts = init_mtd_partitions(adm8668_mtd, adm8668_mtd->size); 
     304        ret = mtd_device_register(adm8668_mtd, adm8668_parts, nr_parts); 
     305        if (ret) { 
     306                printk(KERN_ERR "Flash: mtd_device_register failed\n"); 
     307                goto fail; 
     308        } 
    250309 
    251310        return 0; 
    252 } 
    253  
    254 static void __exit adm8668_parser_exit(void) 
    255 { 
    256         deregister_mtd_parser(&adm8668_parser); 
    257 } 
    258  
    259 module_init(adm8668_parser_init); 
    260 module_exit(adm8668_parser_exit); 
     311 
     312 fail: 
     313        if (adm8668_mtd) 
     314                map_destroy(adm8668_mtd); 
     315        if (adm8668_map.virt) 
     316                iounmap((void *) adm8668_map.virt); 
     317        adm8668_map.virt = 0; 
     318        return ret; 
     319} 
     320 
     321void __exit cleanup_adm8668_map(void) 
     322{ 
     323        mtd_device_unregister(adm8668_mtd); 
     324        map_destroy(adm8668_mtd); 
     325        iounmap((void *) adm8668_map.virt); 
     326        adm8668_map.virt = 0; 
     327} 
     328 
     329module_init(init_adm8668_map); 
     330module_exit(cleanup_adm8668_map); 
    261331 
    262332MODULE_LICENSE("GPL"); 
    263333MODULE_AUTHOR("Scott Nicholas <neutronscott@scottn.us>"); 
    264 MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>"); 
    265 MODULE_DESCRIPTION("MTD partition parser for ADM8668"); 
     334MODULE_DESCRIPTION("MTD map driver for ADM8668 NOR Flash"); 
  • trunk/target/linux/adm8668/patches-3.3/003-adm8668_nor_map.patch

    r34554 r42170  
    55        depends on MSP_FLASH_MAP_LIMIT_32M 
    66  
    7 +config MTD_ADM8668_PARTS 
    8 +       tristate "ADM8668 partition parser" 
    9 +       depends on ADM8668 
     7+config MTD_ADM8668_NOR 
     8+       tristate "ADM8668 NOR mapping" 
     9+       depends on ADM8668 && MTD_CFI 
    1010+       help 
    11 +         Partition parser for the Infineon/ADMTek ADM8668 (WildPass). 
     11+         mapping driver for ADM8668 NOR 
    1212+ 
    1313 config MTD_SUN_UFLASH 
     
    2020  
    2121 # Chip mappings 
    22 +obj-$(CONFIG_MTD_ADM8668_PARTS)        += adm8668.o 
     22+obj-$(CONFIG_MTD_ADM8668_NOR)  += adm8668.o 
    2323 obj-$(CONFIG_MTD_CDB89712)     += cdb89712.o 
    2424 obj-$(CONFIG_MTD_CFI_FLAGADM)  += cfi_flagadm.o 
Note: See TracChangeset for help on using the changeset viewer.