linux/arch/cris/arch-v32/drivers/axisflashmap.c
<<
>>
Prefs
   1/*
   2 * Physical mapping layer for MTD using the Axis partitiontable format
   3 *
   4 * Copyright (c) 2001-2007 Axis Communications AB
   5 *
   6 * This file is under the GPL.
   7 *
   8 * First partition is always sector 0 regardless of if we find a partitiontable
   9 * or not. In the start of the next sector, there can be a partitiontable that
  10 * tells us what other partitions to define. If there isn't, we use a default
  11 * partition split defined below.
  12 *
  13 */
  14
  15#include <linux/module.h>
  16#include <linux/types.h>
  17#include <linux/kernel.h>
  18#include <linux/init.h>
  19#include <linux/slab.h>
  20
  21#include <linux/mtd/concat.h>
  22#include <linux/mtd/map.h>
  23#include <linux/mtd/mtd.h>
  24#include <linux/mtd/mtdram.h>
  25#include <linux/mtd/partitions.h>
  26
  27#include <linux/cramfs_fs.h>
  28
  29#include <asm/axisflashmap.h>
  30#include <asm/mmu.h>
  31
  32#define MEM_CSE0_SIZE (0x04000000)
  33#define MEM_CSE1_SIZE (0x04000000)
  34
  35#define FLASH_UNCACHED_ADDR  KSEG_E
  36#define FLASH_CACHED_ADDR    KSEG_F
  37
  38#define PAGESIZE (512)
  39
  40#if CONFIG_ETRAX_FLASH_BUSWIDTH==1
  41#define flash_data __u8
  42#elif CONFIG_ETRAX_FLASH_BUSWIDTH==2
  43#define flash_data __u16
  44#elif CONFIG_ETRAX_FLASH_BUSWIDTH==4
  45#define flash_data __u32
  46#endif
  47
  48/* From head.S */
  49extern unsigned long romfs_in_flash; /* 1 when romfs_start, _length in flash */
  50extern unsigned long romfs_start, romfs_length;
  51extern unsigned long nand_boot; /* 1 when booted from nand flash */
  52
  53struct partition_name {
  54        char name[6];
  55};
  56
  57/* The master mtd for the entire flash. */
  58struct mtd_info* axisflash_mtd = NULL;
  59
  60/* Map driver functions. */
  61
  62static map_word flash_read(struct map_info *map, unsigned long ofs)
  63{
  64        map_word tmp;
  65        tmp.x[0] = *(flash_data *)(map->map_priv_1 + ofs);
  66        return tmp;
  67}
  68
  69static void flash_copy_from(struct map_info *map, void *to,
  70                            unsigned long from, ssize_t len)
  71{
  72        memcpy(to, (void *)(map->map_priv_1 + from), len);
  73}
  74
  75static void flash_write(struct map_info *map, map_word d, unsigned long adr)
  76{
  77        *(flash_data *)(map->map_priv_1 + adr) = (flash_data)d.x[0];
  78}
  79
  80/*
  81 * The map for chip select e0.
  82 *
  83 * We run into tricky coherence situations if we mix cached with uncached
  84 * accesses to we only use the uncached version here.
  85 *
  86 * The size field is the total size where the flash chips may be mapped on the
  87 * chip select. MTD probes should find all devices there and it does not matter
  88 * if there are unmapped gaps or aliases (mirrors of flash devices). The MTD
  89 * probes will ignore them.
  90 *
  91 * The start address in map_priv_1 is in virtual memory so we cannot use
  92 * MEM_CSE0_START but must rely on that FLASH_UNCACHED_ADDR is the start
  93 * address of cse0.
  94 */
  95static struct map_info map_cse0 = {
  96        .name = "cse0",
  97        .size = MEM_CSE0_SIZE,
  98        .bankwidth = CONFIG_ETRAX_FLASH_BUSWIDTH,
  99        .read = flash_read,
 100        .copy_from = flash_copy_from,
 101        .write = flash_write,
 102        .map_priv_1 = FLASH_UNCACHED_ADDR
 103};
 104
 105/*
 106 * The map for chip select e1.
 107 *
 108 * If there was a gap between cse0 and cse1, map_priv_1 would get the wrong
 109 * address, but there isn't.
 110 */
 111static struct map_info map_cse1 = {
 112        .name = "cse1",
 113        .size = MEM_CSE1_SIZE,
 114        .bankwidth = CONFIG_ETRAX_FLASH_BUSWIDTH,
 115        .read = flash_read,
 116        .copy_from = flash_copy_from,
 117        .write = flash_write,
 118        .map_priv_1 = FLASH_UNCACHED_ADDR + MEM_CSE0_SIZE
 119};
 120
 121#define MAX_PARTITIONS                  7
 122#ifdef CONFIG_ETRAX_NANDBOOT
 123#define NUM_DEFAULT_PARTITIONS          4
 124#define DEFAULT_ROOTFS_PARTITION_NO     2
 125#define DEFAULT_MEDIA_SIZE              0x2000000 /* 32 megs */
 126#else
 127#define NUM_DEFAULT_PARTITIONS          3
 128#define DEFAULT_ROOTFS_PARTITION_NO     (-1)
 129#define DEFAULT_MEDIA_SIZE              0x800000 /* 8 megs */
 130#endif
 131
 132#if (MAX_PARTITIONS < NUM_DEFAULT_PARTITIONS)
 133#error MAX_PARTITIONS must be >= than NUM_DEFAULT_PARTITIONS
 134#endif
 135
 136/* Initialize the ones normally used. */
 137static struct mtd_partition axis_partitions[MAX_PARTITIONS] = {
 138        {
 139                .name = "part0",
 140                .size = CONFIG_ETRAX_PTABLE_SECTOR,
 141                .offset = 0
 142        },
 143        {
 144                .name = "part1",
 145                .size = 0,
 146                .offset = 0
 147        },
 148        {
 149                .name = "part2",
 150                .size = 0,
 151                .offset = 0
 152        },
 153        {
 154                .name = "part3",
 155                .size = 0,
 156                .offset = 0
 157        },
 158        {
 159                .name = "part4",
 160                .size = 0,
 161                .offset = 0
 162        },
 163        {
 164                .name = "part5",
 165                .size = 0,
 166                .offset = 0
 167        },
 168        {
 169                .name = "part6",
 170                .size = 0,
 171                .offset = 0
 172        },
 173};
 174
 175
 176/* If no partition-table was found, we use this default-set.
 177 * Default flash size is 8MB (NOR). CONFIG_ETRAX_PTABLE_SECTOR is most
 178 * likely the size of one flash block and "filesystem"-partition needs
 179 * to be >=5 blocks to be able to use JFFS.
 180 */
 181static struct mtd_partition axis_default_partitions[NUM_DEFAULT_PARTITIONS] = {
 182        {
 183                .name = "boot firmware",
 184                .size = CONFIG_ETRAX_PTABLE_SECTOR,
 185                .offset = 0
 186        },
 187        {
 188                .name = "kernel",
 189                .size = 10 * CONFIG_ETRAX_PTABLE_SECTOR,
 190                .offset = CONFIG_ETRAX_PTABLE_SECTOR
 191        },
 192#define FILESYSTEM_SECTOR (11 * CONFIG_ETRAX_PTABLE_SECTOR)
 193#ifdef CONFIG_ETRAX_NANDBOOT
 194        {
 195                .name = "rootfs",
 196                .size = 10 * CONFIG_ETRAX_PTABLE_SECTOR,
 197                .offset = FILESYSTEM_SECTOR
 198        },
 199#undef FILESYSTEM_SECTOR
 200#define FILESYSTEM_SECTOR (21 * CONFIG_ETRAX_PTABLE_SECTOR)
 201#endif
 202        {
 203                .name = "rwfs",
 204                .size = DEFAULT_MEDIA_SIZE - FILESYSTEM_SECTOR,
 205                .offset = FILESYSTEM_SECTOR
 206        }
 207};
 208
 209#ifdef CONFIG_ETRAX_AXISFLASHMAP_MTD0WHOLE
 210/* Main flash device */
 211static struct mtd_partition main_partition = {
 212        .name = "main",
 213        .size = 0,
 214        .offset = 0
 215};
 216#endif
 217
 218/* Auxiliary partition if we find another flash */
 219static struct mtd_partition aux_partition = {
 220        .name = "aux",
 221        .size = 0,
 222        .offset = 0
 223};
 224
 225/*
 226 * Probe a chip select for AMD-compatible (JEDEC) or CFI-compatible flash
 227 * chips in that order (because the amd_flash-driver is faster).
 228 */
 229static struct mtd_info *probe_cs(struct map_info *map_cs)
 230{
 231        struct mtd_info *mtd_cs = NULL;
 232
 233        printk(KERN_INFO
 234               "%s: Probing a 0x%08lx bytes large window at 0x%08lx.\n",
 235               map_cs->name, map_cs->size, map_cs->map_priv_1);
 236
 237#ifdef CONFIG_MTD_CFI
 238        mtd_cs = do_map_probe("cfi_probe", map_cs);
 239#endif
 240#ifdef CONFIG_MTD_JEDECPROBE
 241        if (!mtd_cs)
 242                mtd_cs = do_map_probe("jedec_probe", map_cs);
 243#endif
 244
 245        return mtd_cs;
 246}
 247
 248/*
 249 * Probe each chip select individually for flash chips. If there are chips on
 250 * both cse0 and cse1, the mtd_info structs will be concatenated to one struct
 251 * so that MTD partitions can cross chip boundries.
 252 *
 253 * The only known restriction to how you can mount your chips is that each
 254 * chip select must hold similar flash chips. But you need external hardware
 255 * to do that anyway and you can put totally different chips on cse0 and cse1
 256 * so it isn't really much of a restriction.
 257 */
 258extern struct mtd_info* __init crisv32_nand_flash_probe (void);
 259static struct mtd_info *flash_probe(void)
 260{
 261        struct mtd_info *mtd_cse0;
 262        struct mtd_info *mtd_cse1;
 263        struct mtd_info *mtd_total;
 264        struct mtd_info *mtds[2];
 265        int count = 0;
 266
 267        if ((mtd_cse0 = probe_cs(&map_cse0)) != NULL)
 268                mtds[count++] = mtd_cse0;
 269        if ((mtd_cse1 = probe_cs(&map_cse1)) != NULL)
 270                mtds[count++] = mtd_cse1;
 271
 272        if (!mtd_cse0 && !mtd_cse1) {
 273                /* No chip found. */
 274                return NULL;
 275        }
 276
 277        if (count > 1) {
 278                /* Since the concatenation layer adds a small overhead we
 279                 * could try to figure out if the chips in cse0 and cse1 are
 280                 * identical and reprobe the whole cse0+cse1 window. But since
 281                 * flash chips are slow, the overhead is relatively small.
 282                 * So we use the MTD concatenation layer instead of further
 283                 * complicating the probing procedure.
 284                 */
 285                mtd_total = mtd_concat_create(mtds, count, "cse0+cse1");
 286                if (!mtd_total) {
 287                        printk(KERN_ERR "%s and %s: Concatenation failed!\n",
 288                                map_cse0.name, map_cse1.name);
 289
 290                        /* The best we can do now is to only use what we found
 291                         * at cse0. */
 292                        mtd_total = mtd_cse0;
 293                        map_destroy(mtd_cse1);
 294                }
 295        } else
 296                mtd_total = mtd_cse0 ? mtd_cse0 : mtd_cse1;
 297
 298        return mtd_total;
 299}
 300
 301/*
 302 * Probe the flash chip(s) and, if it succeeds, read the partition-table
 303 * and register the partitions with MTD.
 304 */
 305static int __init init_axis_flash(void)
 306{
 307        struct mtd_info *main_mtd;
 308        struct mtd_info *aux_mtd = NULL;
 309        int err = 0;
 310        int pidx = 0;
 311        struct partitiontable_head *ptable_head = NULL;
 312        struct partitiontable_entry *ptable;
 313        int ptable_ok = 0;
 314        static char page[PAGESIZE];
 315        size_t len;
 316        int ram_rootfs_partition = -1; /* -1 => no RAM rootfs partition */
 317        int part;
 318
 319        /* We need a root fs. If it resides in RAM, we need to use an
 320         * MTDRAM device, so it must be enabled in the kernel config,
 321         * but its size must be configured as 0 so as not to conflict
 322         * with our usage.
 323         */
 324#if !defined(CONFIG_MTD_MTDRAM) || (CONFIG_MTDRAM_TOTAL_SIZE != 0) || (CONFIG_MTDRAM_ABS_POS != 0)
 325        if (!romfs_in_flash && !nand_boot) {
 326                printk(KERN_EMERG "axisflashmap: Cannot create an MTD RAM "
 327                       "device; configure CONFIG_MTD_MTDRAM with size = 0!\n");
 328                panic("This kernel cannot boot from RAM!\n");
 329        }
 330#endif
 331
 332        main_mtd = flash_probe();
 333        if (main_mtd)
 334                printk(KERN_INFO "%s: 0x%08x bytes of NOR flash memory.\n",
 335                       main_mtd->name, main_mtd->size);
 336
 337#ifdef CONFIG_ETRAX_NANDFLASH
 338        aux_mtd = crisv32_nand_flash_probe();
 339        if (aux_mtd)
 340                printk(KERN_INFO "%s: 0x%08x bytes of NAND flash memory.\n",
 341                        aux_mtd->name, aux_mtd->size);
 342
 343#ifdef CONFIG_ETRAX_NANDBOOT
 344        {
 345                struct mtd_info *tmp_mtd;
 346
 347                printk(KERN_INFO "axisflashmap: Set to boot from NAND flash, "
 348                       "making NAND flash primary device.\n");
 349                tmp_mtd = main_mtd;
 350                main_mtd = aux_mtd;
 351                aux_mtd = tmp_mtd;
 352        }
 353#endif /* CONFIG_ETRAX_NANDBOOT */
 354#endif /* CONFIG_ETRAX_NANDFLASH */
 355
 356        if (!main_mtd && !aux_mtd) {
 357                /* There's no reason to use this module if no flash chip can
 358                 * be identified. Make sure that's understood.
 359                 */
 360                printk(KERN_INFO "axisflashmap: Found no flash chip.\n");
 361        }
 362
 363#if 0 /* Dump flash memory so we can see what is going on */
 364        if (main_mtd) {
 365                int sectoraddr, i;
 366                for (sectoraddr = 0; sectoraddr < 2*65536+4096;
 367                                sectoraddr += PAGESIZE) {
 368                        main_mtd->read(main_mtd, sectoraddr, PAGESIZE, &len,
 369                                page);
 370                        printk(KERN_INFO
 371                               "Sector at %d (length %d):\n",
 372                               sectoraddr, len);
 373                        for (i = 0; i < PAGESIZE; i += 16) {
 374                                printk(KERN_INFO
 375                                       "%02x %02x %02x %02x "
 376                                       "%02x %02x %02x %02x "
 377                                       "%02x %02x %02x %02x "
 378                                       "%02x %02x %02x %02x\n",
 379                                       page[i] & 255, page[i+1] & 255,
 380                                       page[i+2] & 255, page[i+3] & 255,
 381                                       page[i+4] & 255, page[i+5] & 255,
 382                                       page[i+6] & 255, page[i+7] & 255,
 383                                       page[i+8] & 255, page[i+9] & 255,
 384                                       page[i+10] & 255, page[i+11] & 255,
 385                                       page[i+12] & 255, page[i+13] & 255,
 386                                       page[i+14] & 255, page[i+15] & 255);
 387                        }
 388                }
 389        }
 390#endif
 391
 392        if (main_mtd) {
 393                main_mtd->owner = THIS_MODULE;
 394                axisflash_mtd = main_mtd;
 395
 396                loff_t ptable_sector = CONFIG_ETRAX_PTABLE_SECTOR;
 397
 398                /* First partition (rescue) is always set to the default. */
 399                pidx++;
 400#ifdef CONFIG_ETRAX_NANDBOOT
 401                /* We know where the partition table should be located,
 402                 * it will be in first good block after that.
 403                 */
 404                int blockstat;
 405                do {
 406                        blockstat = mtd_block_isbad(main_mtd, ptable_sector);
 407                        if (blockstat < 0)
 408                                ptable_sector = 0; /* read error */
 409                        else if (blockstat)
 410                                ptable_sector += main_mtd->erasesize;
 411                } while (blockstat && ptable_sector);
 412#endif
 413                if (ptable_sector) {
 414                        mtd_read(main_mtd, ptable_sector, PAGESIZE, &len,
 415                                 page);
 416                        ptable_head = &((struct partitiontable *) page)->head;
 417                }
 418
 419#if 0 /* Dump partition table so we can see what is going on */
 420                printk(KERN_INFO
 421                       "axisflashmap: flash read %d bytes at 0x%08x, data: "
 422                       "%02x %02x %02x %02x %02x %02x %02x %02x\n",
 423                       len, CONFIG_ETRAX_PTABLE_SECTOR,
 424                       page[0] & 255, page[1] & 255,
 425                       page[2] & 255, page[3] & 255,
 426                       page[4] & 255, page[5] & 255,
 427                       page[6] & 255, page[7] & 255);
 428                printk(KERN_INFO
 429                       "axisflashmap: partition table offset %d, data: "
 430                       "%02x %02x %02x %02x %02x %02x %02x %02x\n",
 431                       PARTITION_TABLE_OFFSET,
 432                       page[PARTITION_TABLE_OFFSET+0] & 255,
 433                       page[PARTITION_TABLE_OFFSET+1] & 255,
 434                       page[PARTITION_TABLE_OFFSET+2] & 255,
 435                       page[PARTITION_TABLE_OFFSET+3] & 255,
 436                       page[PARTITION_TABLE_OFFSET+4] & 255,
 437                       page[PARTITION_TABLE_OFFSET+5] & 255,
 438                       page[PARTITION_TABLE_OFFSET+6] & 255,
 439                       page[PARTITION_TABLE_OFFSET+7] & 255);
 440#endif
 441        }
 442
 443        if (ptable_head && (ptable_head->magic == PARTITION_TABLE_MAGIC)
 444            && (ptable_head->size <
 445                (MAX_PARTITIONS * sizeof(struct partitiontable_entry) +
 446                PARTITIONTABLE_END_MARKER_SIZE))
 447            && (*(unsigned long*)((void*)ptable_head + sizeof(*ptable_head) +
 448                                  ptable_head->size -
 449                                  PARTITIONTABLE_END_MARKER_SIZE)
 450                == PARTITIONTABLE_END_MARKER)) {
 451                /* Looks like a start, sane length and end of a
 452                 * partition table, lets check csum etc.
 453                 */
 454                struct partitiontable_entry *max_addr =
 455                        (struct partitiontable_entry *)
 456                        ((unsigned long)ptable_head + sizeof(*ptable_head) +
 457                         ptable_head->size);
 458                unsigned long offset = CONFIG_ETRAX_PTABLE_SECTOR;
 459                unsigned char *p;
 460                unsigned long csum = 0;
 461
 462                ptable = (struct partitiontable_entry *)
 463                        ((unsigned long)ptable_head + sizeof(*ptable_head));
 464
 465                /* Lets be PARANOID, and check the checksum. */
 466                p = (unsigned char*) ptable;
 467
 468                while (p <= (unsigned char*)max_addr) {
 469                        csum += *p++;
 470                        csum += *p++;
 471                        csum += *p++;
 472                        csum += *p++;
 473                }
 474                ptable_ok = (csum == ptable_head->checksum);
 475
 476                /* Read the entries and use/show the info.  */
 477                printk(KERN_INFO "axisflashmap: "
 478                       "Found a%s partition table at 0x%p-0x%p.\n",
 479                       (ptable_ok ? " valid" : "n invalid"), ptable_head,
 480                       max_addr);
 481
 482                /* We have found a working bootblock.  Now read the
 483                 * partition table.  Scan the table.  It ends with 0xffffffff.
 484                 */
 485                while (ptable_ok
 486                       && ptable->offset != PARTITIONTABLE_END_MARKER
 487                       && ptable < max_addr
 488                       && pidx < MAX_PARTITIONS - 1) {
 489
 490                        axis_partitions[pidx].offset = offset + ptable->offset;
 491#ifdef CONFIG_ETRAX_NANDFLASH
 492                        if (main_mtd->type == MTD_NANDFLASH) {
 493                                axis_partitions[pidx].size =
 494                                        (((ptable+1)->offset ==
 495                                          PARTITIONTABLE_END_MARKER) ?
 496                                          main_mtd->size :
 497                                          ((ptable+1)->offset + offset)) -
 498                                        (ptable->offset + offset);
 499
 500                        } else
 501#endif /* CONFIG_ETRAX_NANDFLASH */
 502                                axis_partitions[pidx].size = ptable->size;
 503#ifdef CONFIG_ETRAX_NANDBOOT
 504                        /* Save partition number of jffs2 ro partition.
 505                         * Needed if RAM booting or root file system in RAM.
 506                         */
 507                        if (!nand_boot &&
 508                            ram_rootfs_partition < 0 && /* not already set */
 509                            ptable->type == PARTITION_TYPE_JFFS2 &&
 510                            (ptable->flags & PARTITION_FLAGS_READONLY_MASK) ==
 511                                PARTITION_FLAGS_READONLY)
 512                                ram_rootfs_partition = pidx;
 513#endif /* CONFIG_ETRAX_NANDBOOT */
 514                        pidx++;
 515                        ptable++;
 516                }
 517        }
 518
 519        /* Decide whether to use default partition table. */
 520        /* Only use default table if we actually have a device (main_mtd) */
 521
 522        struct mtd_partition *partition = &axis_partitions[0];
 523        if (main_mtd && !ptable_ok) {
 524                memcpy(axis_partitions, axis_default_partitions,
 525                       sizeof(axis_default_partitions));
 526                pidx = NUM_DEFAULT_PARTITIONS;
 527                ram_rootfs_partition = DEFAULT_ROOTFS_PARTITION_NO;
 528        }
 529
 530        /* Add artificial partitions for rootfs if necessary */
 531        if (romfs_in_flash) {
 532                /* rootfs is in directly accessible flash memory = NOR flash.
 533                   Add an overlapping device for the rootfs partition. */
 534                printk(KERN_INFO "axisflashmap: Adding partition for "
 535                       "overlapping root file system image\n");
 536                axis_partitions[pidx].size = romfs_length;
 537                axis_partitions[pidx].offset = romfs_start - FLASH_CACHED_ADDR;
 538                axis_partitions[pidx].name = "romfs";
 539                axis_partitions[pidx].mask_flags |= MTD_WRITEABLE;
 540                ram_rootfs_partition = -1;
 541                pidx++;
 542        } else if (romfs_length && !nand_boot) {
 543                /* romfs exists in memory, but not in flash, so must be in RAM.
 544                 * Configure an MTDRAM partition. */
 545                if (ram_rootfs_partition < 0) {
 546                        /* None set yet, put it at the end */
 547                        ram_rootfs_partition = pidx;
 548                        pidx++;
 549                }
 550                printk(KERN_INFO "axisflashmap: Adding partition for "
 551                       "root file system image in RAM\n");
 552                axis_partitions[ram_rootfs_partition].size = romfs_length;
 553                axis_partitions[ram_rootfs_partition].offset = romfs_start;
 554                axis_partitions[ram_rootfs_partition].name = "romfs";
 555                axis_partitions[ram_rootfs_partition].mask_flags |=
 556                        MTD_WRITEABLE;
 557        }
 558
 559#ifdef CONFIG_ETRAX_AXISFLASHMAP_MTD0WHOLE
 560        if (main_mtd) {
 561                main_partition.size = main_mtd->size;
 562                err = mtd_device_register(main_mtd, &main_partition, 1);
 563                if (err)
 564                        panic("axisflashmap: Could not initialize "
 565                              "partition for whole main mtd device!\n");
 566        }
 567#endif
 568
 569        /* Now, register all partitions with mtd.
 570         * We do this one at a time so we can slip in an MTDRAM device
 571         * in the proper place if required. */
 572
 573        for (part = 0; part < pidx; part++) {
 574                if (part == ram_rootfs_partition) {
 575                        /* add MTDRAM partition here */
 576                        struct mtd_info *mtd_ram;
 577
 578                        mtd_ram = kmalloc(sizeof(struct mtd_info), GFP_KERNEL);
 579                        if (!mtd_ram)
 580                                panic("axisflashmap: Couldn't allocate memory "
 581                                      "for mtd_info!\n");
 582                        printk(KERN_INFO "axisflashmap: Adding RAM partition "
 583                               "for rootfs image.\n");
 584                        err = mtdram_init_device(mtd_ram,
 585                                                 (void *)partition[part].offset,
 586                                                 partition[part].size,
 587                                                 partition[part].name);
 588                        if (err)
 589                                panic("axisflashmap: Could not initialize "
 590                                      "MTD RAM device!\n");
 591                        /* JFFS2 likes to have an erasesize. Keep potential
 592                         * JFFS2 rootfs happy by providing one. Since image
 593                         * was most likely created for main mtd, use that
 594                         * erasesize, if available. Otherwise, make a guess. */
 595                        mtd_ram->erasesize = (main_mtd ? main_mtd->erasesize :
 596                                CONFIG_ETRAX_PTABLE_SECTOR);
 597                } else {
 598                        err = mtd_device_register(main_mtd, &partition[part],
 599                                                  1);
 600                        if (err)
 601                                panic("axisflashmap: Could not add mtd "
 602                                        "partition %d\n", part);
 603                }
 604        }
 605
 606        if (aux_mtd) {
 607                aux_partition.size = aux_mtd->size;
 608                err = mtd_device_register(aux_mtd, &aux_partition, 1);
 609                if (err)
 610                        panic("axisflashmap: Could not initialize "
 611                              "aux mtd device!\n");
 612
 613        }
 614
 615        return err;
 616}
 617
 618/* This adds the above to the kernels init-call chain. */
 619module_init(init_axis_flash);
 620
 621EXPORT_SYMBOL(axisflash_mtd);
 622