Changeset 34554


Ignore:
Timestamp:
2012-12-06T23:40:17+01:00 (5 years ago)
Author:
florian
Message:

[adm8668] replace the custom mtd driver with a partition parser

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

    r34548 r34554  
    6161# CONFIG_MIPS_MACHINE is not set 
    6262CONFIG_MIPS_MT_DISABLED=y 
    63 CONFIG_MTD_ADM8668_NOR=y 
     63CONFIG_MTD_ADM8668_PARTS=y 
     64CONFIG_MTD_PHYSMAP=y 
    6465CONFIG_NEED_DMA_MAP_STATE=y 
    6566CONFIG_NEED_PER_CPU_KM=y 
  • trunk/target/linux/adm8668/files/arch/mips/adm8668/platform.c

    r34548 r34554  
    11/* 
     2 * Infineon/ADMTek 8668 (WildPass) platform devices support 
     3 * 
    24 * Copyright (C) 2010 Scott Nicholas <neutronscott@scottn.us> 
    35 * Copyright (C) 2012 Florian Fainelli <florian@openwrt.org> 
     
    1214#include <linux/platform_device.h> 
    1315#include <linux/mtd/physmap.h> 
     16#include <linux/mtd/partitions.h> 
    1417#include <linux/pci.h> 
    1518#include <linux/slab.h> 
     
    9093}; 
    9194 
     95static const char *nor_probe_types[] = { "adm8668part", NULL }; 
     96 
     97static struct physmap_flash_data nor_flash_data = { 
     98        .width                  = 2, 
     99        .part_probe_types       = nor_probe_types, 
     100}; 
     101 
     102static struct resource nor_resources[] = { 
     103        { 
     104                .start  = ADM8668_SMEM1_BASE, 
     105                .end    = ADM8668_SMEM1_BASE + 0x800000 - 1, 
     106                .flags  = IORESOURCE_MEM, 
     107        }, 
     108}; 
     109 
     110static struct platform_device adm8668_nor_device = { 
     111        .name           = "physmap-flash", 
     112        .id             = -1, 
     113        .resource       = nor_resources, 
     114        .num_resources  = ARRAY_SIZE(nor_resources), 
     115        .dev.platform_data = &nor_flash_data, 
     116}; 
     117 
    92118static struct platform_device *adm8668_devs[] = { 
    93119        &adm8668_eth0_device, 
    94120        &adm8668_eth1_device, 
     121        &adm8668_nor_device, 
    95122}; 
    96123 
  • trunk/target/linux/adm8668/files/drivers/mtd/maps/adm8668.c

    r31497 r34554  
    11/* 
    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. 
     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. 
    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  * 
    4037 */ 
    4138 
     
    4643#include <linux/wait.h> 
    4744#include <linux/mtd/mtd.h> 
    48 #include <linux/mtd/map.h> 
     45#include <linux/mtd/partitions.h> 
     46#include <linux/vmalloc.h> 
    4947#include <linux/slab.h> 
    50 #include <linux/mtd/partitions.h> 
    5148#include <linux/crc32.h> 
    5249#include <linux/magic.h> 
    53 #include <asm/io.h> 
    54  
    55 #define WINDOW_ADDR     0x10000000 
    56 #define WINDOW_SIZE     0x800000 
    57 #define BANKWIDTH       2 
     50 
     51#define PFX     "adm8668-part: " 
    5852 
    5953/* first a little bit about the headers i need.. */ 
     
    8276}; 
    8377 
    84 /************************************************/ 
    85  
    86 static struct mtd_info *adm8668_mtd; 
    87  
    88 struct 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  
    107 static 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  
    113 static 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 */ 
    162 static 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  
    16978/* in case i wanna change stuff later, and to clarify the math section... */ 
    17079#define PART_LINUX      0 
    17180#define PART_ROOTFS     1 
     81#define PART_UBOOT_ENV  2 
    17282#define NR_PARTS        3 
    17383 
    174 static int __init 
    175 init_mtd_partitions(struct mtd_info *mtd, size_t size) 
     84static int adm8668_parse_partitions(struct mtd_info *master, 
     85                                    struct mtd_partition **pparts, 
     86                                    struct mtd_part_parser_data *data) 
    17687{ 
     88        int ret; 
    17789        struct uboot_header uhdr; 
    17890        int off, blocksize; 
    17991        size_t len, linux_len; 
    18092        struct squashfs_super_block shdr; 
    181  
    182         blocksize = mtd->erasesize; 
     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 
    183100        if (blocksize < 0x10000) 
    184101                blocksize = 0x10000; 
    185102 
     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 
    186117        /* now find squashfs */ 
    187118        memset(&shdr, 0xe5, sizeof(shdr)); 
    188         for (off = adm8668_parts[PART_LINUX].offset; off < size; off += blocksize) { 
     119 
     120        for (off = 0x40000; off < master->size; off += blocksize) { 
    189121                /* 
    190122                 * Read into buffer 
    191123                 */ 
    192                 if (mtd->read(mtd, off, sizeof(shdr), &len, (char *)&shdr) || 
     124                if (mtd_read(master, off, sizeof(shdr), &len, (char *)&shdr) || 
    193125                    len != sizeof(shdr)) 
    194126                        continue; 
     
    197129                        uint32_t fs_size = (uint32_t)shdr.bytes_used; 
    198130 
    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 */ 
     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                         */ 
    204138                        adm8668_parts[PART_ROOTFS].offset = off; 
    205                         adm8668_parts[PART_ROOTFS].size = mtd->size - 
     139                        adm8668_parts[PART_ROOTFS].size = master->size - 
    206140                                adm8668_parts[PART_ROOTFS].offset; 
    207141 
    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 - 
     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 - 
    211147                                adm8668_parts[PART_LINUX].offset; 
    212 #if 1 
    213                         adm8668_parts[PART_LINUX].size = mtd->size - 
     148 
     149                        adm8668_parts[PART_LINUX].size = master->size - 
    214150                                adm8668_parts[PART_LINUX].offset; 
    215 #else 
    216                         adm8668_parts[PART_LINUX].size = linux_len; 
    217 #endif 
    218151                        goto found; 
    219152                } 
    220153        } 
    221154 
    222         printk(KERN_NOTICE 
    223                "%s: Couldn't find root filesystem\n", 
    224                mtd->name); 
     155        pr_err(PFX "could't find root filesystem\n"); 
    225156        return NR_PARTS; 
    226157 
    227  found: 
    228         if (mtd->read(mtd, adm8668_parts[PART_LINUX].offset, sizeof(uhdr), &len, (char *)&uhdr) || 
    229             len != sizeof(uhdr)) 
     158found: 
     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"); 
    230162                return NR_PARTS; 
    231  
    232         /* that's odd. how'd ya boot it then */ 
    233         if (uhdr.ih_magic != IH_MAGIC) 
     163        } 
     164 
     165        if (uhdr.ih_magic != IH_MAGIC) { 
     166                pr_info(PFX "invalid u-boot magic detected?!?!\n"); 
    234167                return NR_PARTS; 
     168        } 
    235169 
    236170        if (be32_to_cpu(uhdr.ih_size) != (linux_len - sizeof(uhdr))) { 
    237                 unsigned char *block, *data; 
     171                u32 data; 
     172                size_t data_len = 0; 
     173                unsigned char *block; 
    238174                unsigned int offset; 
    239175 
    240176                offset = adm8668_parts[PART_LINUX].offset + 
    241177                         sizeof(struct uboot_header); 
    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", 
     178 
     179                pr_info(PFX "Updating U-boot image:\n"); 
     180                pr_info(PFX "  old: [size: %8d crc32: 0x%08x]\n", 
    246181                        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                } 
    247187 
    248188                /* Update the data length & crc32 */ 
    249189                uhdr.ih_size = cpu_to_be32(linux_len - sizeof(uhdr)); 
    250                 uhdr.ih_dcrc = crc32_le(~0, data, linux_len - sizeof(uhdr)) ^ (~0); 
     190                uhdr.ih_dcrc = crc32_le(~0, (char *)&data, linux_len - sizeof(uhdr)) ^ (~0); 
    251191                uhdr.ih_dcrc = cpu_to_be32(uhdr.ih_dcrc); 
    252192 
    253                 printk(KERN_NOTICE "  new: [size: %8d crc32: 0x%08x]\n", 
     193                pr_info(PFX "  new: [size: %8d crc32: 0x%08x]\n", 
    254194                        be32_to_cpu(uhdr.ih_size), be32_to_cpu(uhdr.ih_dcrc)); 
    255195 
     
    261201 
    262202                /* read first eraseblock from the image */ 
    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"); 
     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"); 
    266210                        return 0; 
    267211                } 
     
    269213                /* Write updated header to the flash */ 
    270214                memcpy(block, &uhdr, sizeof(uhdr)); 
    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         } 
     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); 
     230out: 
     231                if (block) 
     232                        vfree(block); 
     233                pr_info(PFX "done\n"); 
     234        } 
     235 
     236        *pparts = adm8668_parts; 
    279237 
    280238        return NR_PARTS; 
    281239} 
    282240 
    283 int __init init_adm8668_map(void) 
     241static struct mtd_part_parser adm8668_parser = { 
     242        .owner  = THIS_MODULE, 
     243        .parse_fn = adm8668_parse_partitions, 
     244        .name = "adm8668part", 
     245}; 
     246 
     247static int __init adm8668_parser_init(void) 
    284248{ 
    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         } 
    309  
    310         return 0; 
    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; 
     249        return register_mtd_parser(&adm8668_parser); 
    319250} 
    320251 
    321 void __exit cleanup_adm8668_map(void) 
     252static void __exit adm8668_parser_exit(void) 
    322253{ 
    323         mtd_device_unregister(adm8668_mtd); 
    324         map_destroy(adm8668_mtd); 
    325         iounmap((void *) adm8668_map.virt); 
    326         adm8668_map.virt = 0; 
     254        deregister_mtd_parser(&adm8668_parser); 
    327255} 
    328256 
    329 module_init(init_adm8668_map); 
    330 module_exit(cleanup_adm8668_map); 
     257module_init(adm8668_parser_init); 
     258module_exit(adm8668_parser_exit); 
    331259 
    332260MODULE_LICENSE("GPL"); 
    333261MODULE_AUTHOR("Scott Nicholas <neutronscott@scottn.us>"); 
    334 MODULE_DESCRIPTION("MTD map driver for ADM8668 NOR Flash"); 
     262MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>"); 
     263MODULE_DESCRIPTION("MTD partition parser for ADM8668"); 
  • trunk/target/linux/adm8668/patches-3.3/003-adm8668_nor_map.patch

    r31480 r34554  
    55        depends on MSP_FLASH_MAP_LIMIT_32M 
    66  
    7 +config MTD_ADM8668_NOR 
    8 +       tristate "ADM8668 NOR mapping" 
    9 +       depends on ADM8668 && MTD_CFI 
     7+config MTD_ADM8668_PARTS 
     8+       tristate "ADM8668 partition parser" 
     9+       depends on ADM8668 
    1010+       help 
    11 +         mapping driver for ADM8668 NOR 
     11+         Partition parser for the Infineon/ADMTek ADM8668 (WildPass). 
    1212+ 
    1313 config MTD_SUN_UFLASH 
     
    2020  
    2121 # Chip mappings 
    22 +obj-$(CONFIG_MTD_ADM8668_NOR)  += adm8668.o 
     22+obj-$(CONFIG_MTD_ADM8668_PARTS)        += 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.