source: src/linux/universal/linux-3.5/arch/mips/brcm-boards/bcm947xx/setup.c @ 31672

Last change on this file since 31672 was 31672, checked in by brainslayer, 6 weeks ago

fix fs detection

File size: 16.2 KB
Line 
1/*
2 * HND MIPS boards setup routines
3 *
4 * Copyright (C) 2012, Broadcom Corporation. All Rights Reserved.
5 *
6 * Permission to use, copy, modify, and/or distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
13 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
15 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
16 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 *
18 * $Id: setup.c,v 1.23 2010-10-20 08:26:12 $
19 */
20
21#include <linux/types.h>
22#include <linux/version.h>
23#include <linux/init.h>
24#include <linux/kernel.h>
25#include <linux/serial.h>
26#include <linux/serialP.h>
27#include <linux/serial_core.h>
28#include <linux/serial_8250.h>  /* for early_serial_setup */
29#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
30#include <linux/config.h>
31#endif
32#if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
33#include <linux/blkdev.h>
34#include <linux/ide.h>
35#endif
36#include <asm/bootinfo.h>
37#include <asm/cpu.h>
38#include <asm/time.h>
39#include <asm/reboot.h>
40#include <linux/squashfs_fs.h>
41
42#ifdef CONFIG_MTD
43#include <linux/mtd/mtd.h>
44#include <linux/mtd/nand.h>
45#include <linux/mtd/partitions.h>
46#include <linux/romfs_fs.h>
47#include <linux/cramfs_fs.h>
48#endif
49#ifdef CONFIG_BLK_DEV_INITRD
50#include <linux/initrd.h>
51#endif
52#include <typedefs.h>
53#include <osl.h>
54#include <bcmutils.h>
55#include <bcmnvram.h>
56#include <siutils.h>
57#include <hndsoc.h>
58#include <hndcpu.h>
59#include <mips33_core.h>
60#include <mips74k_core.h>
61#include <sbchipc.h>
62#include <hndchipc.h>
63#include <hndpci.h>
64#include <trxhdr.h>
65#ifdef HNDCTF
66#include <ctf/hndctf.h>
67#endif /* HNDCTF */
68#include "bcm947xx.h"
69#ifdef CONFIG_MTD_NFLASH
70#include "nflash.h"
71#endif
72#include "bcmdevs.h"
73
74extern void bcm947xx_time_init(void);
75extern void bcm947xx_timer_setup(struct irqaction *irq);
76
77#ifdef CONFIG_KGDB
78extern void set_debug_traps(void);
79extern void rs_kgdb_hook(struct uart_port *);
80extern void breakpoint(void);
81#endif
82
83#if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
84extern struct ide_ops std_ide_ops;
85#endif
86
87struct dummy_super_block {
88        u32     s_magic ;
89};
90
91#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
92/* Enable CPU wait or not */
93extern int cpu_wait_enable;
94#else
95int coherentio;   /* init to 0 => no DMA cache coherency (may be set by user) */
96int hw_coherentio;/* init to 0 => no HW DMA cache coherency (reflects real HW) */
97#endif
98
99/* Global SB handle */
100si_t *bcm947xx_sih = NULL;
101DEFINE_SPINLOCK(bcm947xx_sih_lock);
102EXPORT_SYMBOL(bcm947xx_sih);
103EXPORT_SYMBOL(bcm947xx_sih_lock);
104
105/* Convenience */
106#define sih bcm947xx_sih
107#define sih_lock bcm947xx_sih_lock
108
109#ifdef HNDCTF
110ctf_t *kcih = NULL;
111EXPORT_SYMBOL(kcih);
112ctf_attach_t ctf_attach_fn = NULL;
113EXPORT_SYMBOL(ctf_attach_fn);
114#endif /* HNDCTF */
115
116/* Kernel command line */
117#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
118extern char arcs_cmdline[CL_SIZE];
119#endif
120static int lanports_enable = 0;
121
122
123EXPORT_SYMBOL( si_router_coma );        /* for loadable modules */
124EXPORT_SYMBOL( hnd_jtagm_init );
125EXPORT_SYMBOL( hnd_jtagm_disable );
126EXPORT_SYMBOL( jtag_scan );
127
128static void
129bcm947xx_reboot_handler(void)
130{
131#ifndef BCMDBG
132        int wombo_reset;
133#endif /* BCMDBG */
134
135        /* Reset the PCI(e) interfaces */
136        if (CHIPID(sih->chip) == BCM4706_CHIP_ID)
137                hndpci_deinit(sih);
138
139        if (lanports_enable) {
140                uint lp = 1 << lanports_enable;
141
142                si_gpioout(sih, lp, 0, GPIO_DRV_PRIORITY);
143                si_gpioouten(sih, lp, lp, GPIO_DRV_PRIORITY);
144                bcm_mdelay(1);
145        }
146
147#ifndef BCMDBG
148        /* gpio 0 is also valid wombo_reset */
149        if ((wombo_reset = getgpiopin(NULL, "wombo_reset", GPIO_PIN_NOTDEFINED)) !=
150            GPIO_PIN_NOTDEFINED) {
151                int reset = 1 << wombo_reset;
152
153                si_gpioout(sih, reset, 0, GPIO_DRV_PRIORITY);
154                si_gpioouten(sih, reset, reset, GPIO_DRV_PRIORITY);
155                bcm_mdelay(10);
156        }
157#endif /* BCMDBG */
158}
159
160void
161bcm947xx_machine_restart(char *command)
162{
163        printk("Please stand by while rebooting the system...\n");
164
165        /* Set the watchdog timer to reset immediately */
166        local_irq_disable();
167        bcm947xx_reboot_handler();
168        hnd_cpu_reset(sih);
169}
170
171void
172bcm947xx_machine_halt(void)
173{
174        printk("System halted\n");
175
176        /* Disable interrupts and watchdog and spin forever */
177        local_irq_disable();
178        si_watchdog(sih, 0);
179        bcm947xx_reboot_handler();
180        while (1);
181}
182
183#ifdef CONFIG_SERIAL_CORE
184
185static struct uart_port rs = {
186        line: 0,
187        flags: ASYNC_BOOT_AUTOCONF,
188        iotype: SERIAL_IO_MEM,
189};
190
191static void __init
192serial_add(void *regs, uint irq, uint baud_base, uint reg_shift)
193{
194        rs.membase = regs;
195        rs.irq = irq + 2;
196        rs.uartclk = baud_base;
197        rs.regshift = reg_shift;
198
199        early_serial_setup(&rs);
200
201        rs.line++;
202}
203
204static void __init
205serial_setup(si_t *sih)
206{
207        si_serial_init(sih, serial_add);
208
209#ifdef CONFIG_KGDB
210        /* Use the last port for kernel debugging */
211        if (rs.membase)
212                rs_kgdb_hook(&rs);
213#endif
214}
215
216#endif /* CONFIG_SERIAL_CORE */
217
218
219
220int boot_flags(void)
221{
222        int bootflags = 0;
223        char *val;
224
225        /* Only support chipcommon revision == 38 or BCM4706 for now */
226        if ((CHIPID(sih->chip) == BCM4706_CHIP_ID) || sih->ccrev == 38) {
227                if (sih->ccrev == 38 && (sih->chipst & (1 << 4)) != 0) {
228                        /* This is NANDBOOT */
229                        bootflags = FLASH_BOOT_NFLASH | FLASH_KERNEL_NFLASH;
230                }
231                else if ((val = nvram_get("bootflags"))) {
232                        bootflags = simple_strtol(val, NULL, 0);
233                        bootflags &= FLASH_KERNEL_NFLASH;
234                }
235        }
236
237        return bootflags;
238}
239
240static int rootfs_mtdblock(void)
241{
242        int bootflags;
243        int block = 0;
244
245        bootflags = boot_flags();
246
247        /* NANDBOOT */
248        if ((bootflags & (FLASH_BOOT_NFLASH | FLASH_KERNEL_NFLASH)) ==
249                (FLASH_BOOT_NFLASH | FLASH_KERNEL_NFLASH))
250                return 3;
251
252        /* SFLASH/PFLASH only */
253        if ((bootflags & (FLASH_BOOT_NFLASH | FLASH_KERNEL_NFLASH)) == 0)
254                return 2;
255
256#ifdef BCMCONFMTD
257        block++;
258#endif
259        /* Boot from norflash and kernel in nandflash */
260        return block+3;
261}
262int iswrt350n=0;
263int iswrt300n11=0;
264EXPORT_SYMBOL (iswrt350n);
265EXPORT_SYMBOL (iswrt300n11);
266
267void __init
268brcm_setup(void)
269{
270        char *value;
271
272        /* Get global SB handle */
273        sih = si_kattach(SI_OSH);
274
275        /* Initialize clocks and interrupts */
276        si_mips_init(sih, SBMIPS_VIRTIRQ_BASE);
277
278        if (BCM330X(current_cpu_data.processor_id) &&
279                (read_c0_diag() & BRCM_PFC_AVAIL)) {
280                /*
281                 * Now that the sih is inited set the  proper PFC value
282                 */     
283                printk("Setting the PFC to its default value\n");
284                enable_pfc(PFC_AUTO);
285        }
286
287
288#ifdef CONFIG_SERIAL_CORE
289        /* Initialize UARTs */
290        serial_setup(sih);
291#endif /* CONFIG_SERIAL_CORE */
292
293iswrt350n=1;
294iswrt300n11=1;
295char *boardtype = nvram_get("boardtype");
296char *boothwmodel = nvram_get("boot_hw_model");
297char *boothwver = nvram_get("boot_hw_ver");
298char *cardbus = nvram_get("cardbus");
299if (boardtype==NULL || strcmp(boardtype,"0x478"))iswrt350n=0;
300if (cardbus!=NULL && !strcmp(cardbus, "0") && boardtype!=NULL && !strcmp(boardtype,"0x478"))
301    {
302    iswrt350n=0;
303    iswrt300n11=0;
304    }
305if (boothwmodel==NULL || strcmp(boothwmodel,"WRT300N"))iswrt300n11=0;
306if (boothwmodel!=NULL && !strcmp(boothwmodel,"WRT610N"))
307    {
308    iswrt300n11=0;
309    iswrt350n=0;
310    }
311if (boothwver==NULL || strcmp(boothwver,"1.1"))iswrt300n11=0;
312if (iswrt300n11)
313    iswrt350n=0;
314
315#if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
316        ide_ops = &std_ide_ops;
317#endif
318
319        sprintf(arcs_cmdline, "root=/dev/mtdblock%d console=ttyS0,115200 init=/sbin/preinit", rootfs_mtdblock());
320
321        /* Override default command line arguments */
322        value = nvram_get("kernel_args");
323        if (value && strlen(value) && strncmp(value, "empty", 5))
324                strncpy(arcs_cmdline, value, sizeof(arcs_cmdline));
325
326
327        if ((lanports_enable = getgpiopin(NULL, "lanports_enable", GPIO_PIN_NOTDEFINED)) ==
328                GPIO_PIN_NOTDEFINED)
329                lanports_enable = 0;
330
331
332#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
333        /* Check if we want to enable cpu wait */
334        if (nvram_match("wait", "1"))
335                cpu_wait_enable = 1;
336#endif
337
338        /* Generic setup */
339        _machine_restart = bcm947xx_machine_restart;
340        _machine_halt = bcm947xx_machine_halt;
341        pm_power_off = bcm947xx_machine_halt;
342
343#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36)
344        board_time_init = bcm947xx_time_init;
345#endif
346}
347
348const char *
349get_system_type(void)
350{
351        static char s[32];
352
353        if (bcm947xx_sih) {
354                sprintf(s, "Broadcom BCM%X chip rev %d", bcm947xx_sih->chip,
355                        bcm947xx_sih->chiprev);
356                return s;
357        }
358        else
359                return "Broadcom BCM947XX";
360}
361
362void __init
363bus_error_init(void)
364{
365}
366
367void __init memory_setup(void);
368void __init
369plat_mem_setup(void)
370{
371        memory_setup();
372        brcm_setup();
373        return;
374}
375
376#ifdef CONFIG_MTD
377
378static spinlock_t *bcm_mtd_lock = NULL;
379
380spinlock_t *partitions_lock_init(void)
381{
382        if (!bcm_mtd_lock) {
383                bcm_mtd_lock = (spinlock_t *)kzalloc(sizeof(spinlock_t), GFP_KERNEL);
384                if (!bcm_mtd_lock)
385                        return NULL;
386
387                spin_lock_init( bcm_mtd_lock );
388        }
389        return bcm_mtd_lock;
390}
391EXPORT_SYMBOL(partitions_lock_init);
392
393static struct nand_hw_control *nand_hwcontrol = NULL;
394struct nand_hw_control *nand_hwcontrol_lock_init(void)
395{
396        if (!nand_hwcontrol) {
397                nand_hwcontrol = (struct nand_hw_control *)kzalloc(sizeof(struct nand_hw_control), GFP_KERNEL);
398                if (!nand_hwcontrol)
399                        return NULL;
400
401                spin_lock_init(&nand_hwcontrol->lock);
402                init_waitqueue_head(&nand_hwcontrol->wq);
403        }
404        return nand_hwcontrol;
405}
406EXPORT_SYMBOL(nand_hwcontrol_lock_init);
407
408/* Find out prom size */
409static uint32 boot_partition_size(uint32 flash_phys) {
410        uint32 bootsz, *bisz;
411
412        /* Default is 256K boot partition */
413        bootsz = 256 * 1024;
414
415        /* Do we have a self-describing binary image? */
416        bisz = (uint32 *)KSEG1ADDR(flash_phys + BISZ_OFFSET);
417        if (bisz[BISZ_MAGIC_IDX] == BISZ_MAGIC) {
418                int isz = bisz[BISZ_DATAEND_IDX] - bisz[BISZ_TXTST_IDX];
419
420                if (isz > (1024 * 1024))
421                        bootsz = 2048 * 1024;
422                else if (isz > (512 * 1024))
423                        bootsz = 1024 * 1024;
424                else if (isz > (256 * 1024))
425                        bootsz = 512 * 1024;
426                else if (isz <= (128 * 1024))
427                        bootsz = 128 * 1024;
428        }
429        return bootsz;
430}
431
432#if defined(BCMCONFMTD) && defined(PLC)
433#define FLASH_PARTS_NUM 7
434#elif defined(BCMCONFMTD) || defined(PLC)
435#define FLASH_PARTS_NUM 6
436#else
437#define FLASH_PARTS_NUM 5 /* boot;nvram;kernel;rootfs;empty */
438#endif
439
440
441#ifdef CONFIG_MTD_NFLASH
442#define NFLASH_PARTS_NUM        7
443static struct mtd_partition bcm947xx_nflash_parts[NFLASH_PARTS_NUM] = {{0}};
444int ddwrtoffset;
445int ddwrtsize;
446
447static uint lookup_nflash_rootfs_offset(hndnand_t *nfl, struct mtd_info *mtd, int offset, size_t size)
448{
449        struct romfs_super_block *romfsb;
450        struct cramfs_super *cramfsb;
451        struct squashfs_super_block *squashfsb;
452        struct trx_header *trx;
453        unsigned char buf[NFL_SECTOR_SIZE];
454        uint blocksize, mask, blk_offset, off, shift = 0;
455        int ret;
456       
457        romfsb = (struct romfs_super_block *) buf;
458        cramfsb = (struct cramfs_super *) buf;
459        squashfsb = (struct squashfs_super_block *) buf;
460        trx = (struct trx_header *) buf;
461
462
463        /* Look at every block boundary till 16MB; higher space is reserved for application data. */
464        blocksize = mtd->erasesize;
465        printk("lookup_nflash_rootfs_offset: offset = 0x%x\n", offset);
466        for (off = offset; off < NFL_BOOT_OS_SIZE; off += 4096) {
467                mask = blocksize - 1;
468                blk_offset = off & ~mask;
469                if (hndnand_checkbadb(nfl, blk_offset) != 0)
470                        continue;
471                memset(buf, 0xe5, sizeof(buf));
472                if ((ret = hndnand_read(nfl, off, sizeof(buf), buf)) != sizeof(buf)) {
473                        printk(KERN_NOTICE
474                               "%s: nflash_read return %d\n", mtd->name, ret);
475                        continue;
476                }
477                       
478                if (le32_to_cpu(trx->magic) == TRX_MAGIC)
479                {
480               
481                printk(KERN_NOTICE "found trx at %X, len =%d\n",off,trx->len);
482                int offset = le32_to_cpu(trx->offsets[2]) ? : le32_to_cpu(trx->offsets[1]);
483                offset+=off;
484                printk(KERN_NOTICE "scan filesys at %X\n",offset);
485
486                if ((ret = hndnand_read(nfl, offset, sizeof(buf), buf)) != sizeof(buf)) {
487                        printk(KERN_NOTICE
488                               "%s: nflash_read return %d\n", mtd->name, ret);
489                        continue;
490                }
491               
492                if (*((__u32 *) buf) == SQUASHFS_MAGIC) {
493                        printk(KERN_NOTICE
494                               "%s: squash filesystem with lzma found at offset %d\n",
495                               mtd->name, off );
496                int size = le64_to_cpu(squashfsb->bytes_used);
497                //part->size = part->size + 1024; /* uncomment for belkin v2000 ! */
498                int len = offset + size;
499                len +=  (mtd->erasesize - 1);
500                len &= ~(mtd->erasesize - 1);
501                ddwrtoffset = len;
502                ddwrtsize = mtd->size - ddwrtoffset;
503                return offset;
504                }
505                }
506
507        }
508        return shift + off;
509}
510
511struct mtd_partition *
512init_nflash_mtd_partitions(hndnand_t *nfl, struct mtd_info *mtd, size_t size)
513{
514        int bootflags;
515        int nparts = 0;
516        uint32 offset = 0;
517        uint shift = 0;
518        uint32 top = 0;
519        uint32 bootsz;
520#ifdef CONFIG_FAILSAFE_UPGRADE
521        char *img_boot = nvram_get(BOOTPARTITION);
522        char *imag_1st_offset = nvram_get(IMAGE_FIRST_OFFSET);
523        char *imag_2nd_offset = nvram_get(IMAGE_SECOND_OFFSET);
524        unsigned int image_first_offset=0;
525        unsigned int image_second_offset=0;
526        char dual_image_on = 0;
527
528        /* The image_1st_size and image_2nd_size are necessary if the Flash does not have any
529         * image
530         */
531        dual_image_on = (img_boot != NULL && imag_1st_offset != NULL && imag_2nd_offset != NULL);
532
533        if (dual_image_on) {
534                image_first_offset = simple_strtol(imag_1st_offset, NULL, 10);
535                image_second_offset = simple_strtol(imag_2nd_offset, NULL, 10);
536                printk("The first offset=%x, 2nd offset=%x\n", image_first_offset,
537                        image_second_offset);
538
539        }
540#endif
541       
542        bootflags = boot_flags();
543        if ((bootflags & FLASH_BOOT_NFLASH) == FLASH_BOOT_NFLASH) {
544                bootsz = boot_partition_size(SI_FLASH1);
545                if (bootsz > mtd->erasesize) {
546                        /* Prepare double space in case of bad blocks */
547                        bootsz = (bootsz << 1);
548                } else {
549                        /* CFE occupies at least one block */
550                        bootsz = mtd->erasesize;
551                }
552                printk("Boot partition size = %d(0x%x)\n", bootsz, bootsz);
553
554                /* Size pmon */
555                bcm947xx_nflash_parts[nparts].name = "boot";
556                bcm947xx_nflash_parts[nparts].size = bootsz;
557                bcm947xx_nflash_parts[nparts].offset = top;
558                bcm947xx_nflash_parts[nparts].mask_flags = MTD_WRITEABLE; /* forces on read only */
559                offset = bcm947xx_nflash_parts[nparts].size;
560                nparts++;
561
562                /* Setup NVRAM MTD partition */
563                bcm947xx_nflash_parts[nparts].name = "nvram";
564                bcm947xx_nflash_parts[nparts].size = NFL_BOOT_SIZE - offset;
565                bcm947xx_nflash_parts[nparts].offset = offset;
566                       
567                offset = NFL_BOOT_SIZE;
568                nparts++;
569        }
570
571        if ((bootflags & FLASH_KERNEL_NFLASH) == FLASH_KERNEL_NFLASH) {
572                /* Setup kernel MTD partition */
573                bcm947xx_nflash_parts[nparts].name = "nandimage";
574#ifdef CONFIG_FAILSAFE_UPGRADE
575                if (dual_image_on)
576                        bcm947xx_nflash_parts[nparts].size = image_second_offset - image_first_offset;
577                else
578#endif
579                bcm947xx_nflash_parts[nparts].size = nparts ? (NFL_BOOT_OS_SIZE - NFL_BOOT_SIZE) : NFL_BOOT_OS_SIZE;
580                bcm947xx_nflash_parts[nparts].offset = offset;
581                       
582                shift = lookup_nflash_rootfs_offset(nfl, mtd, offset, bcm947xx_nflash_parts[nparts].size);
583
584#ifdef CONFIG_FAILSAFE_UPGRADE
585                if (dual_image_on)
586                        offset = image_second_offset;
587                else
588#endif
589                offset = NFL_BOOT_OS_SIZE;
590                nparts++;
591               
592                /* Setup rootfs MTD partition */
593                bcm947xx_nflash_parts[nparts].name = "rootfs";
594#ifdef CONFIG_FAILSAFE_UPGRADE
595                if (dual_image_on)
596                        bcm947xx_nflash_parts[nparts].size = image_second_offset - shift;
597                else
598#endif
599                bcm947xx_nflash_parts[nparts].size = NFL_BOOT_OS_SIZE - shift;
600                bcm947xx_nflash_parts[nparts].offset = shift;
601                bcm947xx_nflash_parts[nparts].mask_flags = MTD_WRITEABLE;
602                nparts++;
603
604//              bcm947xx_nflash_parts[nparts].name = "ddwrt";
605
606//              bcm947xx_nflash_parts[nparts].size = ddwrtsize-0x100000;
607//              bcm947xx_nflash_parts[nparts].offset = ddwrtoffset;
608               
609//              nparts++;
610
611#ifdef CONFIG_FAILSAFE_UPGRADE
612                /* Setup 2nd kernel MTD partition */
613                if (dual_image_on) {
614                        printf ("2nd offset %x \n",image_second_offset);
615                        bcm947xx_nflash_parts[nparts].name = "linux2";
616                        bcm947xx_nflash_parts[nparts].size = NFL_BOOT_OS_SIZE - image_second_offset;
617                        bcm947xx_nflash_parts[nparts].offset = image_second_offset;
618                        shift = lookup_nflash_rootfs_offset(nfl, mtd, image_second_offset,
619                                                            bcm947xx_nflash_parts[nparts].size);
620                        nparts++;
621                        /* Setup rootfs MTD partition */
622                        bcm947xx_nflash_parts[nparts].name = "rootfs2";
623                        bcm947xx_nflash_parts[nparts].size = NFL_BOOT_OS_SIZE - shift;
624                        bcm947xx_nflash_parts[nparts].offset = shift;
625                        bcm947xx_nflash_parts[nparts].mask_flags = MTD_WRITEABLE;
626                        nparts++;
627                }
628#endif
629
630        }
631
632        return bcm947xx_nflash_parts;
633}
634
635EXPORT_SYMBOL(init_nflash_mtd_partitions);
636#endif /* CONFIG_MTD_NFLASH */
637
638#endif
Note: See TracBrowser for help on using the repository browser.