source: src/linux/universal/linux-3.18/arch/arm/mach-brcm-hnd/board_ns.c @ 28403

Last change on this file since 28403 was 28403, checked in by BrainSlayer, 16 months ago

bugfix for partition size and name

File size: 34.2 KB
Line 
1#include <linux/version.h>
2#include <linux/init.h>
3#include <linux/platform_device.h>
4
5#include <asm/setup.h>
6#include <asm/mach-types.h>
7#include <asm/mach/arch.h>
8#include <asm/mach/time.h>
9#include <asm/clkdev.h>
10
11#include <mach/clkdev.h>
12#include <mach/memory.h>
13#include <mach/io_map.h>
14
15#include <plat/bsp.h>
16#include <plat/mpcore.h>
17#include <plat/plat-bcm5301x.h>
18
19#ifdef CONFIG_MTD
20#include <linux/mtd/mtd.h>
21#include <linux/mtd/partitions.h>
22#include <linux/mtd/nand.h>
23#include <linux/romfs_fs.h>
24#include <linux/cramfs_fs.h>
25#include <linux/squashfs_fs.h>
26#endif
27
28#include <linux/memblock.h>
29#include <typedefs.h>
30#include <osl.h>
31#include <bcmutils.h>
32#include <bcmnvram.h>
33#include <bcmendian.h>
34#include <hndsoc.h>
35#include <siutils.h>
36#include <hndcpu.h>
37#include <hndpci.h>
38#include <pcicfg.h>
39#include <bcmdevs.h>
40#include <trxhdr.h>
41#ifdef HNDCTF
42#include <ctf/hndctf.h>
43#endif                          /* HNDCTF */
44#include <hndsflash.h>
45#ifdef CONFIG_MTD_NFLASH
46#include <hndnand.h>
47#endif
48
49extern char __initdata saved_root_name[];
50
51/* Global SB handle */
52si_t *bcm947xx_sih = NULL;
53DEFINE_SPINLOCK(bcm947xx_sih_lock);
54EXPORT_SYMBOL(bcm947xx_sih);
55EXPORT_SYMBOL(bcm947xx_sih_lock);
56
57extern int nvram_space;
58/* Convenience */
59#define sih bcm947xx_sih
60#define sih_lock bcm947xx_sih_lock
61
62#ifdef HNDCTF
63ctf_t *kcih = NULL;
64EXPORT_SYMBOL(kcih);
65ctf_attach_t ctf_attach_fn = NULL;
66EXPORT_SYMBOL(ctf_attach_fn);
67#endif                          /* HNDCTF */
68
69
70/* To store real PHYS_OFFSET value */
71unsigned int ddr_phys_offset_va = -1;
72EXPORT_SYMBOL(ddr_phys_offset_va);
73
74unsigned int ddr_phys_offset2_va = 0xa8000000;  /* Default value for NS */
75EXPORT_SYMBOL(ddr_phys_offset2_va);
76
77unsigned int coherence_win_sz = SZ_256M;
78EXPORT_SYMBOL(coherence_win_sz);
79
80/*
81 * Coherence flag:
82 * 0: arch is non-coherent with NS ACP or BCM53573 ACE (CCI-400) disabled.
83 * 1: arch is non-coherent with NS-Ax ACP enabled for ACP WAR.
84 * 2: arch is coherent with NS-Bx ACP enabled.
85 * 4: arch is coherent with BCM53573 ACE enabled.
86 * give non-zero initial value to let this global variable be stored in Data Segment
87 */
88unsigned int coherence_flag = ~(COHERENCE_MASK);
89EXPORT_SYMBOL(coherence_flag);
90
91
92/* This is the main reference clock 25MHz from external crystal */
93static struct clk clk_ref = {
94        .name = "Refclk",
95        .rate = 25 * 1000000,   /* run-time override */
96        .fixed = 1,
97        .type = CLK_XTAL,
98};
99
100static struct clk_lookup board_clk_lookups[] = {
101        {
102         .con_id = "refclk",
103         .clk = &clk_ref,
104         }
105};
106
107extern int _memsize;
108
109extern int _chipid;
110
111#if 0
112#include <mach/uncompress.h>
113
114void printch(int c)
115{
116        putc(c);
117        flush();
118}
119#endif
120void __init board_map_io(void)
121{
122        early_printk("board_map_io\n");
123
124        if (BCM53573_CHIP(_chipid)) {
125                /* Override the main reference clock to be 40 MHz */
126                clk_ref.rate = 40 * 1000000;
127        }
128        /* Install clock sources into the lookup table */
129        clkdev_add_table(board_clk_lookups, ARRAY_SIZE(board_clk_lookups));
130
131        /* Map SoC specific I/O */
132        soc_map_io(&clk_ref);
133}
134
135void __init board_init_irq(void)
136{
137        early_printk("board_init_irq\n");
138        soc_init_irq();
139
140        /* serial_setup(sih); */
141}
142
143void board_init_timer(void)
144{
145        /* Get global SB handle */
146        sih = si_kattach(SI_OSH);
147        early_printk("board_init_timer\n");
148        soc_init_timer();
149}
150
151static int __init rootfs_mtdblock(void)
152{
153        int bootdev;
154        int knldev;
155        int block = 0;
156#ifdef CONFIG_FAILSAFE_UPGRADE
157        char *img_boot = nvram_get(BOOTPARTITION);
158#endif
159
160        bootdev = soc_boot_dev((void *)sih);
161        knldev = soc_knl_dev((void *)sih);
162
163        /* NANDBOOT */
164        if (bootdev == SOC_BOOTDEV_NANDFLASH && knldev == SOC_KNLDEV_NANDFLASH) {
165#ifdef CONFIG_FAILSAFE_UPGRADE
166                if (img_boot && simple_strtol(img_boot, NULL, 10))
167                        return 5;
168                else
169                        return 3;
170#else
171                return 3;
172#endif
173        }
174
175        /* SFLASH/PFLASH only */
176        if (bootdev != SOC_BOOTDEV_NANDFLASH && knldev != SOC_KNLDEV_NANDFLASH) {
177#ifdef CONFIG_FAILSAFE_UPGRADE
178                if (img_boot && simple_strtol(img_boot, NULL, 10))
179                        return 4;
180                else
181                        return 2;
182#else
183                return 2;
184#endif
185        }
186#ifdef BCMCONFMTD
187        block++;
188#endif
189#ifdef CONFIG_FAILSAFE_UPGRADE
190        if (img_boot && simple_strtol(img_boot, NULL, 10))
191                block += 2;
192#endif
193        /* Boot from norflash and kernel in nandflash */
194        return block + 3;
195}
196
197#define WATCHDOG_MIN    3000    /* milliseconds */
198extern int panic_timeout;
199extern int panic_on_oops;
200static int watchdog = 0;
201
202static void __init brcm_setup(void)
203{
204
205        if (ACP_WAR_ENAB() && BCM4707_CHIP(CHIPID(sih->chip))) {
206                if (sih->chippkg == BCM4708_PKG_ID)
207                        coherence_win_sz = SZ_128M;
208                else if (sih->chippkg == BCM4707_PKG_ID)
209                        coherence_win_sz = SZ_32M;
210                else
211                        coherence_win_sz = SZ_256M;
212        } else if ((BCM4707_CHIP(CHIPID(sih->chip)) &&
213                (CHIPREV(sih->chiprev) == 4 || CHIPREV(sih->chiprev) == 6)) ||
214                (CHIPID(sih->chip) == BCM47094_CHIP_ID)) {
215                /* For NS-Bx and NS47094. Chiprev 4 for NS-B0 and chiprev 6 for NS-B1 */
216                coherence_win_sz = SZ_1G;
217        } else if (BCM53573_CHIP(sih->chip)) {
218                if (PHYS_OFFSET == PADDR_ACE1_BCM53573)
219                        coherence_win_sz = SZ_512M;
220                else
221                        coherence_win_sz = SZ_256M;
222        }
223       
224        printk(KERN_INFO "coherence_win_size = %X\n",coherence_win_sz);
225        printk(KERN_INFO "coherence_flag = %X\n", coherence_flag);
226        printk(KERN_INFO "ddr_phys_offset_va =%X\n", ddr_phys_offset_va);
227        printk(KERN_INFO "ddr_phys_offset2_va =%X\n", ddr_phys_offset2_va);
228
229//      if (strncmp(boot_command_line, "root=/dev/mtdblock", strlen("root=/dev/mtdblock")) == 0)
230//              sprintf(saved_root_name, "/dev/mtdblock%d", rootfs_mtdblock());
231        /* Set watchdog interval in ms */
232        watchdog = simple_strtoul(nvram_safe_get("watchdog"), NULL, 0);
233
234        /* Ensure at least WATCHDOG_MIN */
235        if ((watchdog > 0) && (watchdog < WATCHDOG_MIN))
236                watchdog = WATCHDOG_MIN;
237
238}
239
240void soc_watchdog(void)
241{
242        if (watchdog > 0)
243                si_watchdog_ms(sih, watchdog);
244}
245
246void __init board_init(void)
247{
248        early_printk("board_init\n");
249        brcm_setup();
250        /*
251         * Add common platform devices that do not have board dependent HW
252         * configurations
253         */
254        soc_add_devices();
255
256        return;
257}
258
259void __init board_fixup(struct tag *t, char **cmdline)
260{
261        early_printk("board_fixup\n");
262
263        u32 mem_size, lo_size;
264        early_printk("board_fixup\n");
265
266        /* Fuxup reference clock rate */
267//      if (desc->nr == MACH_TYPE_BRCM_NS_QT )
268//              clk_ref.rate = 17594;   /* Emulator ref clock rate */
269
270        mem_size = _memsize;
271
272        early_printk("board_fixup: mem=%uMiB\n", mem_size >> 20);
273
274        /* for NS-B0-ACP */
275#if 0
276        if (ACP_WAR_ENAB()) {
277                mi->bank[0].start = PHYS_OFFSET;
278                mi->bank[0].size = mem_size;
279                mi->nr_banks++;
280                return;
281        }
282#endif
283
284        lo_size = min(mem_size, DRAM_MEMORY_REGION_SIZE);
285
286        memblock_add(PHYS_OFFSET, lo_size);
287
288
289        if (lo_size == mem_size)
290                return;
291
292        memblock_add(DRAM_LARGE_REGION_BASE + lo_size, mem_size - lo_size);
293}
294
295#ifdef CONFIG_ZONE_DMA
296/*
297 * Adjust the zones if there are restrictions for DMA access.
298 */
299void __init bcm47xx_adjust_zones(unsigned long *size, unsigned long *hole)
300{
301        unsigned long dma_size = SZ_128M >> PAGE_SHIFT;
302
303        if (size[0] <= dma_size)
304                return;
305#if 0
306        if (ACP_WAR_ENAB())
307                return;
308#endif
309
310        size[ZONE_NORMAL] = size[0] - dma_size;
311        size[ZONE_DMA] = dma_size;
312        hole[ZONE_NORMAL] = hole[0];
313        hole[ZONE_DMA] = 0;
314}
315#endif                          /* CONFIG_ZONE_DMA */
316
317//#if (( (IO_BASE_VA >>18) & 0xfffc) != 0x3c40)
318//#error IO_BASE_VA
319//#endif
320
321void brcm_reset(char mode, const char *cmd)
322{
323#ifdef CONFIG_OUTER_CACHE_SYNC
324        outer_cache.sync = NULL;
325#endif
326        hnd_cpu_reset(sih);
327}
328
329MACHINE_START(BRCM_NS, "Northstar Prototype")
330//   .phys_io =                                         /* UART I/O mapping */
331//      IO_BASE_PA,
332//   .io_pg_offst =                             /* for early debug */
333//      (IO_BASE_VA >>18) & 0xfffc,
334    .smp = smp_ops(brcm_smp_ops),
335    .fixup = board_fixup,       /* Opt. early setup_arch() */
336    .map_io = board_map_io,     /* Opt. from setup_arch() */
337    .init_irq = board_init_irq, /* main.c after setup_arch() */
338    .init_time = board_init_timer,      /* main.c after IRQs */
339    .init_machine = board_init, /* Late archinitcall */
340    .atag_offset = CONFIG_BOARD_PARAMS_PHYS,.restart = brcm_reset,
341#ifdef CONFIG_ZONE_DMA
342    .dma_zone_size = SZ_128M,
343#endif
344    MACHINE_END
345#ifdef  CONFIG_MACH_BRCM_NS_QT
346MACHINE_START(BRCM_NS_QT, "Northstar Emulation Model")
347//   .phys_io =                                         /* UART I/O mapping */
348//      IO_BASE_PA,
349//   .io_pg_offst =                             /* for early debug */
350//      (IO_BASE_VA >>18) & 0xfffc,
351    .fixup = board_fixup,               /* Opt. early setup_arch() */
352    .map_io = board_map_io,     /* Opt. from setup_arch() */
353    .init_irq = board_init_irq, /* main.c after setup_arch() */
354    .init_time = board_init_timer,      /* main.c after IRQs */
355    .init_machine = board_init, /* Late archinitcall */
356    .atag_offset = CONFIG_BOARD_PARAMS_PHYS,.restart = brcm_reset,
357#ifdef CONFIG_ZONE_DMA
358    .dma_zone_size = SZ_128M,
359#endif
360    MACHINE_END
361#endif
362#ifdef CONFIG_MTD
363static spinlock_t *bcm_mtd_lock = NULL;
364
365spinlock_t *partitions_lock_init(void)
366{
367        if (!bcm_mtd_lock) {
368                bcm_mtd_lock = (spinlock_t *) kzalloc(sizeof(spinlock_t), GFP_KERNEL);
369                if (!bcm_mtd_lock)
370                        return NULL;
371
372                spin_lock_init(bcm_mtd_lock);
373        }
374        return bcm_mtd_lock;
375}
376
377EXPORT_SYMBOL(partitions_lock_init);
378
379static struct nand_hw_control *nand_hwcontrol = NULL;
380struct nand_hw_control *nand_hwcontrol_lock_init(void)
381{
382        if (!nand_hwcontrol) {
383                nand_hwcontrol = (struct nand_hw_control *)kzalloc(sizeof(struct nand_hw_control), GFP_KERNEL);
384                if (!nand_hwcontrol)
385                        return NULL;
386
387                spin_lock_init(&nand_hwcontrol->lock);
388                init_waitqueue_head(&nand_hwcontrol->wq);
389        }
390        return nand_hwcontrol;
391}
392
393EXPORT_SYMBOL(nand_hwcontrol_lock_init);
394
395/* Find out prom size */
396static uint32 boot_partition_size(uint32 flash_phys)
397{
398        uint32 bootsz, *bisz;
399
400        /* Default is 256K boot partition */
401        bootsz = 256 * 1024;
402
403        /* Do we have a self-describing binary image? */
404        bisz = (uint32 *) (flash_phys + BISZ_OFFSET);
405        if (bisz[BISZ_MAGIC_IDX] == BISZ_MAGIC) {
406                int isz = bisz[BISZ_DATAEND_IDX] - bisz[BISZ_TXTST_IDX];
407
408                if (isz > (1024 * 1024))
409                        bootsz = 2048 * 1024;
410                else if (isz > (512 * 1024))
411                        bootsz = 1024 * 1024;
412                else if (isz > (256 * 1024))
413                        bootsz = 512 * 1024;
414                else if (isz <= (128 * 1024))
415                        bootsz = 128 * 1024;
416        }
417        return bootsz;
418}
419
420size_t rootfssize = 0;
421
422#if defined(BCMCONFMTD)
423#define MTD_PARTS 1
424#else
425#define MTD_PARTS 0
426#endif
427#if defined(PLC)
428#define PLC_PARTS 1
429#else
430#define PLC_PARTS 0
431#endif
432#if defined(CONFIG_FAILSAFE_UPGRADE)
433#define FAILSAFE_PARTS 2
434#else
435#define FAILSAFE_PARTS 0
436#endif
437/* boot;nvram;kernel;rootfs;empty */
438#define FLASH_PARTS_NUM (6+MTD_PARTS+PLC_PARTS+FAILSAFE_PARTS)
439
440static struct mtd_partition bcm947xx_flash_parts[FLASH_PARTS_NUM + 1] = { {0} };
441
442static uint lookup_flash_rootfs_offset(struct mtd_info *mtd, int *trx_off, size_t size)
443{
444        struct romfs_super_block *romfsb;
445        struct cramfs_super *cramfsb;
446        struct squashfs_super_block *squashfsb;
447        struct trx_header *trx;
448        unsigned char buf[512];
449        int off;
450        size_t len;
451
452        romfsb = (struct romfs_super_block *)buf;
453        cramfsb = (struct cramfs_super *)buf;
454        squashfsb = (void *)buf;
455        trx = (struct trx_header *)buf;
456
457        /* Look at every 64 KB boundary */
458        for (off = 0; off < size; off += (64 * 1024)) {
459                memset(buf, 0xe5, sizeof(buf));
460
461                /*
462                 * Read block 0 to test for romfs and cramfs superblock
463                 */
464                if (mtd_read(mtd, off, sizeof(buf), &len, buf) || len != sizeof(buf))
465                        continue;
466
467                /* Try looking at TRX header for rootfs offset */
468                if (le32_to_cpu(trx->magic) == TRX_MAGIC) {
469                        *trx_off = off;
470                        if (trx->offsets[1] == 0)
471                                continue;
472                        /*
473                         * Read to test for romfs and cramfs superblock
474                         */
475                        off += le32_to_cpu(trx->offsets[1]);
476                        memset(buf, 0xe5, sizeof(buf));
477                        if (mtd_read(mtd, off, sizeof(buf), &len, buf) || len != sizeof(buf))
478                                continue;
479                }
480
481                /* romfs is at block zero too */
482                if (romfsb->word0 == ROMSB_WORD0 && romfsb->word1 == ROMSB_WORD1) {
483                        printk(KERN_NOTICE "%s: romfs filesystem found at block %d\n", mtd->name, off / mtd->erasesize);
484                        break;
485                }
486
487                /* so is cramfs */
488                if (cramfsb->magic == CRAMFS_MAGIC) {
489                        printk(KERN_NOTICE "%s: cramfs filesystem found at block %d\n", mtd->name, off / mtd->erasesize);
490                        break;
491                }
492
493                if (squashfsb->s_magic == SQUASHFS_MAGIC) {
494                        rootfssize = squashfsb->bytes_used;
495                        printk(KERN_NOTICE "%s: squash filesystem found at block %d\n", mtd->name, off / mtd->erasesize);
496                        break;
497                }
498        }
499
500        return off;
501}
502extern int __init root_dev_setup(char *line);
503
504struct mtd_partition *init_mtd_partitions(hndsflash_t * sfl_info, struct mtd_info *mtd, size_t size)
505{
506        int bootdev;
507        int knldev;
508        int nparts = 0;
509        uint32 offset = 0;
510        uint rfs_off = 0;
511        uint vmlz_off, knl_size;
512        uint32 top = 0;
513        uint32 bootsz;
514        uint32 maxsize = 0;
515        int is_ex6200 = 0;
516        int nobackup = 0;
517#ifdef CONFIG_FAILSAFE_UPGRADE
518        char *img_boot = nvram_get(BOOTPARTITION);
519        char *imag_1st_offset = nvram_get(IMAGE_FIRST_OFFSET);
520        char *imag_2nd_offset = nvram_get(IMAGE_SECOND_OFFSET);
521        unsigned int image_first_offset = 0;
522        unsigned int image_second_offset = 0;
523        char dual_image_on = 0;
524
525        /* The image_1st_size and image_2nd_size are necessary if the Flash does not have any
526         * image
527         */
528
529        dual_image_on = (img_boot != NULL && imag_1st_offset != NULL && imag_2nd_offset != NULL);
530
531        if (dual_image_on) {
532                image_first_offset = simple_strtol(imag_1st_offset, NULL, 10);
533                image_second_offset = simple_strtol(imag_2nd_offset, NULL, 10);
534                printk("The first offset=%x, 2nd offset=%x\n", image_first_offset, image_second_offset);
535
536        }
537#endif                          /* CONFIG_FAILSAFE_UPGRADE */
538
539        if (nvram_match("boardnum", "24") && nvram_match("boardtype", "0x0646")
540            && nvram_match("boardrev", "0x1110")
541            && nvram_match("gpio7", "wps_button") && !nvram_match("gpio6", "wps_led")) {
542                maxsize = 0x200000;
543                size = maxsize;
544        }
545
546        if (nvram_match("boardnum", "24") && nvram_match("boardtype", "0x0646")
547            && nvram_match("boardrev", "0x1110")
548            && nvram_match("gpio7", "wps_button") && nvram_match("gpio6", "wps_led")) {
549                bootsz = 0x200000;
550        }
551
552        if (nvram_match("boardnum", "24") && nvram_match("boardtype", "0x072F")
553            && nvram_match("boardrev", "0x1101")
554            && nvram_match("gpio7", "wps_button")) {
555                bootsz = 0x200000;
556        }
557
558        if (nvram_match("boardnum", "24") && nvram_match("boardtype", "0x0646")
559            && nvram_match("boardrev", "0x1101")) {
560                size = 0x200000;
561                bootsz = 0x200000;
562        }
563
564        if (nvram_match("boardnum", "1234") && nvram_match("boardtype", "0x072F")) {
565                nobackup = 1;
566        }
567        if (nvram_space == 0x20000)
568                nobackup = 1;
569
570        if (nvram_match("boardnum","679") && nvram_match("boardtype", "0x0646")
571            && (nvram_match("boardrev", "0x1110"))) {
572                maxsize = 0x200000;
573                if (nvram_match("board_id", "U12H269T00_NETGEAR")){
574                    maxsize = 0x800000;
575                    is_ex6200 = 1;
576                }
577                size = maxsize;
578        }
579
580        if (nvram_match("boardnum", "32") && nvram_match("boardtype", "0x0665")
581            && nvram_match("boardrev", "0x1301")) {
582                maxsize = 0x200000;
583                size = maxsize;
584        }
585
586        bootdev = soc_boot_dev((void *)sih);
587        knldev = soc_knl_dev((void *)sih);
588
589        if (bootdev == SOC_BOOTDEV_NANDFLASH) {
590                /* Do not init MTD partitions on NOR flash when NAND boot */
591                return NULL;
592        }
593
594        if (knldev != SOC_KNLDEV_NANDFLASH) {
595                rfs_off = lookup_flash_rootfs_offset(mtd, &vmlz_off, size);
596                root_dev_setup("1f02");
597
598                /* Size pmon */
599                bcm947xx_flash_parts[nparts].name = "boot";
600                bcm947xx_flash_parts[nparts].size = vmlz_off;
601                bcm947xx_flash_parts[nparts].offset = top;
602//              bcm947xx_flash_parts[nparts].mask_flags =  MTD_WRITEABLE; /* forces on read only */
603                nparts++;
604
605                /* Setup kernel MTD partition */
606                bcm947xx_flash_parts[nparts].name = "linux";
607#ifdef CONFIG_FAILSAFE_UPGRADE
608                if (dual_image_on) {
609                        bcm947xx_flash_parts[nparts].size = image_second_offset - image_first_offset;
610                } else {
611                        bcm947xx_flash_parts[nparts].size = mtd->size - vmlz_off;
612
613                        /* Reserve for NVRAM */
614                        bcm947xx_flash_parts[nparts].size -= ROUNDUP(nvram_space, mtd->erasesize);
615#ifdef PLC
616                        /* Reserve for PLC */
617                        bcm947xx_flash_parts[nparts].size -= ROUNDUP(0x1000, mtd->erasesize);
618#endif
619#ifdef BCMCONFMTD
620                        bcm947xx_flash_parts[nparts].size -= (mtd->erasesize * 4);
621#endif
622                }
623#else
624
625                bcm947xx_flash_parts[nparts].size = mtd->size - vmlz_off;
626                if(is_ex6200)
627                        bcm947xx_flash_parts[nparts].size -= 0x10000;
628
629#ifdef PLC
630                /* Reserve for PLC */
631                bcm947xx_flash_parts[nparts].size -= ROUNDUP(0x1000, mtd->erasesize);
632#endif
633                /* Reserve for NVRAM */
634                bcm947xx_flash_parts[nparts].size -= ROUNDUP(nvram_space, mtd->erasesize);
635
636#ifdef BCMCONFMTD
637                bcm947xx_flash_parts[nparts].size -= (mtd->erasesize * 4);
638#endif
639#endif                          /* CONFIG_FAILSAFE_UPGRADE */
640                bcm947xx_flash_parts[nparts].offset = vmlz_off;
641                knl_size = bcm947xx_flash_parts[nparts].size;
642                offset = bcm947xx_flash_parts[nparts].offset + knl_size;
643                nparts++;
644
645                /* Setup rootfs MTD partition */
646                bcm947xx_flash_parts[nparts].name = "rootfs";
647                bcm947xx_flash_parts[nparts].offset = rfs_off;
648                bcm947xx_flash_parts[nparts].size = rootfssize;
649                size_t offs = bcm947xx_flash_parts[nparts].offset + bcm947xx_flash_parts[nparts].size;
650                offs += (mtd->erasesize - 1);
651                offs &= ~(mtd->erasesize - 1);
652                offs -= bcm947xx_flash_parts[nparts].offset;
653                bcm947xx_flash_parts[nparts].size = offs;
654
655                bcm947xx_flash_parts[nparts].mask_flags = MTD_WRITEABLE;        /* forces on read only */
656                nparts++;
657#ifdef CONFIG_FAILSAFE_UPGRADE
658                if (dual_image_on) {
659                        offset = image_second_offset;
660                        rfs_off = lookup_flash_rootfs_offset(mtd, &offset, size);
661                        vmlz_off = offset;
662                        /* Setup kernel2 MTD partition */
663                        bcm947xx_flash_parts[nparts].name = "linux2";
664                        bcm947xx_flash_parts[nparts].size = mtd->size - image_second_offset;
665                        /* Reserve for NVRAM */
666                        bcm947xx_flash_parts[nparts].size -= ROUNDUP(nvram_space, mtd->erasesize);
667
668#ifdef BCMCONFMTD
669                        bcm947xx_flash_parts[nparts].size -= (mtd->erasesize * 4);
670#endif
671#ifdef PLC
672                        /* Reserve for PLC */
673                        bcm947xx_flash_parts[nparts].size -= ROUNDUP(0x1000, mtd->erasesize);
674#endif
675                        bcm947xx_flash_parts[nparts].offset = image_second_offset;
676                        knl_size = bcm947xx_flash_parts[nparts].size;
677                        offset = bcm947xx_flash_parts[nparts].offset + knl_size;
678                        nparts++;
679
680                        /* Setup rootfs MTD partition */
681                        bcm947xx_flash_parts[nparts].name = "rootfs2";
682                        bcm947xx_flash_parts[nparts].size = knl_size - (rfs_off - image_second_offset);
683                        bcm947xx_flash_parts[nparts].offset = rfs_off;
684                        /* forces on read only */
685                        bcm947xx_flash_parts[nparts].mask_flags = MTD_WRITEABLE;
686                        nparts++;
687                }
688#endif                          /* CONFIG_FAILSAFE_UPGRADE */
689
690        } else {
691                if (nobackup)
692                        root_dev_setup("1f03");
693                else
694                        root_dev_setup("1f04");
695                if (!bootsz)
696                        bootsz = boot_partition_size(sfl_info->base);
697                printk("Boot partition size = %d(0x%x)\n", bootsz, bootsz);
698                /* Size pmon */
699                if (maxsize)
700                        bootsz = maxsize;
701                bcm947xx_flash_parts[nparts].name = "boot";
702                bcm947xx_flash_parts[nparts].size = bootsz;
703                bcm947xx_flash_parts[nparts].offset = top;
704//              bcm947xx_flash_parts[nparts].mask_flags = MTD_WRITEABLE; /* forces on read only */
705                offset = bcm947xx_flash_parts[nparts].size;
706                nparts++;
707        }
708
709#ifdef BCMCONFMTD
710        /* Setup CONF MTD partition */
711        bcm947xx_flash_parts[nparts].name = "confmtd";
712        bcm947xx_flash_parts[nparts].size = mtd->erasesize * 4;
713        bcm947xx_flash_parts[nparts].offset = offset;
714        offset = bcm947xx_flash_parts[nparts].offset + bcm947xx_flash_parts[nparts].size;
715        nparts++;
716#endif                          /* BCMCONFMTD */
717
718#ifdef PLC
719        /* Setup plc MTD partition */
720        bcm947xx_flash_parts[nparts].name = "plc";
721        bcm947xx_flash_parts[nparts].size = ROUNDUP(0x1000, mtd->erasesize);
722        bcm947xx_flash_parts[nparts].offset = size - (ROUNDUP(nvram_space, mtd->erasesize) + ROUNDUP(0x1000, mtd->erasesize));
723        nparts++;
724#endif
725        if (rootfssize) {
726                bcm947xx_flash_parts[nparts].name = "ddwrt";
727                bcm947xx_flash_parts[nparts].offset = bcm947xx_flash_parts[2].offset + bcm947xx_flash_parts[2].size;
728                bcm947xx_flash_parts[nparts].offset += (mtd->erasesize - 1);
729                bcm947xx_flash_parts[nparts].offset &= ~(mtd->erasesize - 1);
730                bcm947xx_flash_parts[nparts].size = (size - bcm947xx_flash_parts[nparts].offset) - ROUNDUP(nvram_space, mtd->erasesize);
731                nparts++;
732        }
733       
734        if(is_ex6200){
735                bcm947xx_flash_parts[nparts].name = "board_data";
736                bcm947xx_flash_parts[nparts].size = ROUNDUP(nvram_space, mtd->erasesize);
737                bcm947xx_flash_parts[nparts].offset = (size - 0x10000) - bcm947xx_flash_parts[nparts].size;
738                nparts++;
739        }
740       
741        /* Setup nvram MTD partition */
742        bcm947xx_flash_parts[nparts].name = "nvram_cfe";
743        bcm947xx_flash_parts[nparts].size = ROUNDUP(nvram_space, mtd->erasesize);
744        if (maxsize)
745                bcm947xx_flash_parts[nparts].offset = (size - 0x10000) - bcm947xx_flash_parts[nparts].size;
746        else
747                bcm947xx_flash_parts[nparts].offset = size - bcm947xx_flash_parts[nparts].size;
748        if(!is_ex6200 && !nobackup)//skip on ex6200
749                nparts++;
750       
751
752        bcm947xx_flash_parts[nparts].name = "nvram";
753        bcm947xx_flash_parts[nparts].size = ROUNDUP(nvram_space, mtd->erasesize);
754        if (maxsize)
755                bcm947xx_flash_parts[nparts].offset = (size - 0x10000) - bcm947xx_flash_parts[nparts].size;
756                if(is_ex6200 || nobackup)
757                        bcm947xx_flash_parts[nparts].offset = size + 0x10000 - bcm947xx_flash_parts[nparts].size;
758        else
759                bcm947xx_flash_parts[nparts].offset = size - bcm947xx_flash_parts[nparts].size;
760        bcm947xx_flash_parts[nparts].offset-=bcm947xx_flash_parts[nparts].size;
761        nparts++;
762
763        return bcm947xx_flash_parts;
764}
765
766EXPORT_SYMBOL(init_mtd_partitions);
767
768#endif                          /* CONFIG_MTD_PARTITIONS */
769
770#ifdef CONFIG_MTD_NFLASH
771#define NFLASH_PARTS_NUM 7
772static struct mtd_partition bcm947xx_nflash_parts[NFLASH_PARTS_NUM] = { {0} };
773
774static uint lookup_nflash_rootfs_offset(hndnand_t * nfl, struct mtd_info *mtd, int offset, size_t size)
775{
776        struct romfs_super_block *romfsb;
777        struct cramfs_super *cramfsb;
778        struct squashfs_super_block *squashfsb;
779        struct squashfs_super_block *squashfsb2;
780        struct trx_header *trx;
781        unsigned char *buf;
782        uint blocksize, pagesize, mask, blk_offset, off, shift = 0;
783        uint rbsize;
784        int ret;
785
786        pagesize = nfl->pagesize;
787        buf = (unsigned char *)kmalloc(pagesize, GFP_KERNEL);
788        if (!buf) {
789                printk("lookup_nflash_rootfs_offset: kmalloc fail\n");
790                return 0;
791        }
792
793        romfsb = (struct romfs_super_block *)buf;
794        cramfsb = (struct cramfs_super *)buf;
795        squashfsb = (void *)buf;
796        squashfsb2 = (void *)&buf[0x60];
797        trx = (struct trx_header *)buf;
798
799        /* Look at every block boundary till 16MB; higher space is reserved for application data. */
800
801        rbsize = blocksize = mtd->erasesize;    //65536;
802
803        if (nvram_match("boardnum", "24") && nvram_match("boardtype", "0x0646")
804            && nvram_match("boardrev", "0x1110")
805            && nvram_match("gpio7", "wps_button")) {
806                printk(KERN_INFO "DIR-686L Hack for detecting filesystems\n");
807                blocksize = 65536;
808        }
809
810        if (nvram_match("boardnum", "24") && nvram_match("boardtype", "0x0646")
811            && nvram_match("boardrev", "0x1100")
812            && nvram_match("gpio8","wps_button")) {
813                printk(KERN_INFO "DIR-660L Hack for detecting filesystems\n");
814                blocksize = 65536;
815        }
816
817        if (nvram_match("boardnum", "24") && nvram_match("boardtype", "0x072F")
818            && nvram_match("boardrev", "0x1101")
819            && nvram_match("gpio7", "wps_button")) {
820                printk(KERN_INFO "DIR-890L Hack for detecting filesystems\n");
821                blocksize = 65536;
822        }
823
824        if (nvram_match("boardnum", "N/A") && nvram_match("boardtype", "0x072F")
825            && nvram_match("boardrev", "0x1101")
826            && nvram_match("gpio7", "wps_button")) {
827                printk(KERN_INFO "DIR-885/895L Hack for detecting filesystems\n");
828                blocksize = 65536;
829        }
830
831        if (nvram_match("boardnum", "24") && nvram_match("boardtype", "0x0646")
832            && nvram_match("boardrev", "0x1101")) {
833                printk(KERN_INFO "DIR-868LC Hack for detecting filesystems\n");
834                blocksize = 65536;
835        }
836
837
838        printk("lookup_nflash_rootfs_offset: offset = 0x%x size = 0x%x, 0x%x\n", offset, size, blocksize);
839        for (off = offset; off < offset + size; off += blocksize) {
840                mask = rbsize - 1;
841                blk_offset = off & ~mask;
842                if (hndnand_checkbadb(nfl, blk_offset) != 0)
843                        continue;
844                memset(buf, 0xe5, pagesize);
845                if ((ret = hndnand_read(nfl, off, pagesize, buf)) != pagesize) {
846                        printk(KERN_NOTICE "%s: nflash_read return %d\n", mtd->name, ret);
847                        continue;
848                }
849
850                /* Try looking at TRX header for rootfs offset */
851                if (le32_to_cpu(trx->magic) == TRX_MAGIC) {
852                        mask = pagesize - 1;
853                        off = offset + (le32_to_cpu(trx->offsets[1]) & ~mask) - blocksize;
854                        shift = (le32_to_cpu(trx->offsets[1]) & mask);
855                        romfsb = (struct romfs_super_block *)((unsigned char *)romfsb + shift);
856                        cramfsb = (struct cramfs_super *)((unsigned char *)cramfsb + shift);
857                        squashfsb = (struct squashfs_super_block *)
858                            ((unsigned char *)squashfsb + shift);
859                        squashfsb2 = NULL;
860                        printk(KERN_INFO "found TRX Header on nflash!\n");
861                        continue;
862                }
863
864                /* romfs is at block zero too */
865                if (romfsb->word0 == ROMSB_WORD0 && romfsb->word1 == ROMSB_WORD1) {
866                        printk(KERN_NOTICE "%s: romfs filesystem found at block %d\n", mtd->name, off / blocksize);
867                        break;
868                }
869
870                /* so is cramfs */
871                if (cramfsb->magic == CRAMFS_MAGIC) {
872                        printk(KERN_NOTICE "%s: cramfs filesystem found at block %d\n", mtd->name, off / blocksize);
873                        break;
874                }
875
876                if (squashfsb->s_magic == SQUASHFS_MAGIC) {
877                        rootfssize = squashfsb->bytes_used;
878                        printk(KERN_NOTICE "%s: squash filesystem with lzma found at block %d\n", mtd->name, off / blocksize);
879                        break;
880                }
881                if (squashfsb2 && squashfsb2->s_magic == SQUASHFS_MAGIC) {
882                        rootfssize = squashfsb2->bytes_used;
883                        off += 0x60;
884                        printk(KERN_NOTICE "%s: squash filesystem with lzma found at block %d\n", mtd->name, off / blocksize);
885                        break;
886                }
887
888        }
889
890        if (buf)
891                kfree(buf);
892
893        return shift + off;
894}
895
896struct mtd_partition *init_nflash_mtd_partitions(hndnand_t * nfl, struct mtd_info *mtd, size_t size)
897{
898        int bootdev;
899        int knldev;
900        int nparts = 0;
901        uint32 offset = 0;
902        uint shift = 0;
903        uint32 top = 0;
904        uint32 bootsz;
905        uint32 nvsz = 0;
906        uint32 bootossz = NFL_BOOT_OS_SIZE;
907        int isbufdual = 0;
908        int isbufvxdual = 0;
909        int istew = 0;
910        uint boardnum = bcm_strtoul(nvram_safe_get("boardnum"), NULL, 0);
911        if ((!strncmp(nvram_safe_get("boardnum"),"2013",4) || !strncmp(nvram_safe_get("boardnum"),"2014",4)) && nvram_match("boardtype", "0x0646")
912            && nvram_match("boardrev", "0x1110")) {
913                printk(KERN_EMERG "Buffalo WZR-900DHP dualboot\n");
914                isbufdual = 1;
915                bootossz = 0x4000000;
916        }
917
918        if (nvram_match("model","RT-AC87U")) {
919                printk(KERN_EMERG "Asus AC87U\n");
920                bootossz = 0x4000000;
921        }
922
923        if (nvram_match("boardnum", "1234") && nvram_match("boardtype", "0x072F")) {
924                bootossz = 0x2000000;
925                istew = 1;
926        }
927
928        if (boardnum == 00 && nvram_match("boardtype", "0x0665")
929            && nvram_match("boardrev", "0x1103")
930            && nvram_match("melco_id", "RD_BB13049")) {
931                printk(KERN_EMERG "Buffalo WXR-1900DHP dualboot\n");
932                isbufvxdual = 1;
933                bootossz = 0x6000000;
934        }
935
936        if (((boardnum == 1) || (nvram_get("boardnum") == NULL)) && nvram_match("boardtype","0xD646") && nvram_match("boardrev","0x1100")) {
937                bootossz = 0x4000000;   
938                nvsz = 0x100000;
939        }
940
941        if (((boardnum == 1) || (nvram_get("boardnum") == NULL)) && nvram_match("boardtype","0xF646") && nvram_match("boardrev","0x1100")) {
942                bootossz = 0x4000000;   
943                nvsz = 0x100000;
944        }
945
946//      if (boardnum == 20140309 && nvram_match("boardtype","0xE646") && nvram_match("boardrev","0x1200")) {
947//              bootossz = 0x1f00000;   
948//      }
949
950        if (((boardnum == 1) || (nvram_get("boardnum") == NULL)) && nvram_match("boardtype", "0x0646") && nvram_match("boardrev", "0x1100") && !strncmp(nvram_safe_get("modelNumber"),"EA6400",6)) {
951                bootossz = 0x3c00000;   
952                nvsz = 0x100000;
953        }
954
955        if (((boardnum == 1) || (nvram_get("boardnum") == NULL)) && nvram_match("boardtype", "0x0646") && nvram_match("boardrev", "0x1100") && !strncmp(nvram_safe_get("modelNumber"),"EA6300",6)) {
956                bootossz = 0x3c00000;   
957                nvsz = 0x100000;
958        }
959
960#ifdef CONFIG_FAILSAFE_UPGRADE
961        char *img_boot = nvram_get(BOOTPARTITION);
962        char *imag_1st_offset = nvram_get(IMAGE_FIRST_OFFSET);
963        char *imag_2nd_offset = nvram_get(IMAGE_SECOND_OFFSET);
964        unsigned int image_first_offset = 0;
965        unsigned int image_second_offset = 0;
966        char dual_image_on = 0;
967
968        /* The image_1st_size and image_2nd_size are necessary if the Flash does not have any
969         * image
970         */
971        if (isbufdual) {
972        if (imag_1st_offset == NULL)
973                imag_1st_offset = "2097152";
974        if (imag_2nd_offset == NULL)
975                imag_2nd_offset = "34603008";
976        }
977        if (isbufvxdual) {
978        if (!img_boot)
979            img_boot="0";
980        if (imag_1st_offset == NULL)
981                imag_1st_offset = "0";
982        if (imag_2nd_offset == NULL)
983                imag_2nd_offset = "50331648";
984        }
985        if (istew)
986                imag_2nd_offset = "16777216";
987        dual_image_on = (img_boot != NULL && imag_1st_offset != NULL && imag_2nd_offset != NULL);
988
989        if (dual_image_on) {
990                image_first_offset = simple_strtol(imag_1st_offset, NULL, 10);
991                image_second_offset = simple_strtol(imag_2nd_offset, NULL, 10);
992                printk("The first offset=%x, 2nd offset=%x\n", image_first_offset, image_second_offset);
993
994        }
995#endif                          /* CONFIG_FAILSAFE_UPGRADE */
996
997        bootdev = soc_boot_dev((void *)sih);
998        knldev = soc_knl_dev((void *)sih);
999
1000        if (bootdev == SOC_BOOTDEV_NANDFLASH) {
1001                bootsz = boot_partition_size(nfl->base);
1002                if (bootsz > mtd->erasesize) {
1003                        /* Prepare double space in case of bad blocks */
1004                        bootsz = (bootsz << 1);
1005                } else {
1006                        /* CFE occupies at least one block */
1007                        bootsz = mtd->erasesize;
1008                }
1009                printk("Boot partition size = %d(0x%x)\n", bootsz, bootsz);
1010
1011                /* Size pmon */
1012                bcm947xx_nflash_parts[nparts].name = "boot";
1013                bcm947xx_nflash_parts[nparts].size = bootsz;
1014                bcm947xx_nflash_parts[nparts].offset = top;
1015//              bcm947xx_nflash_parts[nparts].mask_flags = MTD_WRITEABLE; /* forces on read only */
1016                offset = bcm947xx_nflash_parts[nparts].size;
1017                nparts++;
1018                if (isbufdual)
1019                        offset += 128 * 1024;
1020                /* Setup NVRAM MTD partition */
1021                bcm947xx_nflash_parts[nparts].name = "nvram";
1022                if (nvsz)
1023                bcm947xx_nflash_parts[nparts].size = nvsz;
1024                else
1025                bcm947xx_nflash_parts[nparts].size = NFL_BOOT_SIZE - offset;
1026                bcm947xx_nflash_parts[nparts].offset = offset;
1027
1028                offset = NFL_BOOT_SIZE;
1029                nparts++;
1030        }
1031
1032        if (knldev == SOC_KNLDEV_NANDFLASH) {
1033                /* Setup kernel MTD partition */
1034#ifdef CONFIG_FAILSAFE_UPGRADE
1035                if (dual_image_on) {
1036                        if (!strcmp(img_boot, "1"))
1037                                bcm947xx_nflash_parts[nparts].name = "linux2";
1038                        else
1039                                bcm947xx_nflash_parts[nparts].name = "linux";
1040                        bcm947xx_nflash_parts[nparts].size = image_second_offset - image_first_offset;
1041                } else
1042#endif
1043                {
1044                        bcm947xx_nflash_parts[nparts].name = "linux";
1045                        bcm947xx_nflash_parts[nparts].size = nparts ? (bootossz - NFL_BOOT_SIZE) : bootossz;
1046                }
1047                /* fix linux offset for this unit */
1048                if (nvram_match("boardnum","679") && nvram_match("boardtype", "0x0646") && (nvram_match("boardrev", "0x1110"))) {
1049                        offset += 0x180000;
1050                        bcm947xx_nflash_parts[nparts].size -= 0x180000;
1051                }
1052               
1053                if (nvram_match("boardnum", "32") && nvram_match("boardtype", "0x0665") && nvram_match("boardrev", "0x1301")) {
1054                        bcm947xx_nflash_parts[nparts].size += 0x200000;
1055                }
1056               
1057                if (nvram_match("boardnum", "32") && nvram_match("boardtype", "0x0665") && nvram_match("boardrev", "0x1101")) {
1058                        bcm947xx_nflash_parts[nparts].size += 0x600000;
1059                }
1060               
1061                bcm947xx_nflash_parts[nparts].offset = offset;
1062
1063                shift = lookup_nflash_rootfs_offset(nfl, mtd, offset, bcm947xx_nflash_parts[nparts].size);
1064               
1065
1066
1067#ifdef CONFIG_FAILSAFE_UPGRADE
1068                if (dual_image_on)
1069                        offset = image_second_offset;
1070                else
1071#endif
1072                        offset = bootossz;
1073                nparts++;
1074
1075                /* Setup rootfs MTD partition */
1076#ifdef CONFIG_FAILSAFE_UPGRADE
1077                if (dual_image_on) {
1078                        if (!strcmp(img_boot, "1"))
1079                                bcm947xx_nflash_parts[nparts].name = "rootfs2";
1080                        else
1081                                bcm947xx_nflash_parts[nparts].name = "rootfs";
1082                        bcm947xx_nflash_parts[nparts].size = image_second_offset - shift;
1083                } else
1084#endif
1085                {
1086                        bcm947xx_nflash_parts[nparts].name = "rootfs";
1087                        bcm947xx_nflash_parts[nparts].size = bootossz - shift;
1088                }
1089                bcm947xx_nflash_parts[nparts].offset = shift;
1090                bcm947xx_nflash_parts[nparts].mask_flags = MTD_WRITEABLE;
1091               
1092                if (nvram_match("boardnum", "32") && nvram_match("boardtype", "0x0665") && nvram_match("boardrev", "0x1301")) {                 
1093                        bcm947xx_nflash_parts[nparts].size += 0x200000;
1094                }
1095               
1096                if (nvram_match("boardnum", "32") && nvram_match("boardtype", "0x0665") && nvram_match("boardrev", "0x1101")) {
1097                        bcm947xx_nflash_parts[nparts].size += 0x600000;
1098                }
1099
1100                nparts++;
1101               
1102                if (nvram_match("boardnum", "32") && nvram_match("boardtype", "0x0665") && nvram_match("boardrev", "0x1301")) {
1103                       
1104                        bcm947xx_nflash_parts[nparts].name = "board_data";
1105                        bcm947xx_nflash_parts[nparts].size = 0x40000;
1106                        bcm947xx_nflash_parts[nparts].offset = 0x2200000;
1107                        nparts++;
1108                }
1109               
1110                if (nvram_match("boardnum", "32") && nvram_match("boardtype", "0x0665") && nvram_match("boardrev", "0x1101")) {
1111                       
1112                        bcm947xx_nflash_parts[nparts].name = "board_data";
1113                        bcm947xx_nflash_parts[nparts].size = 0x80000;
1114                        bcm947xx_nflash_parts[nparts].offset = 0x2600000;
1115                        nparts++;
1116                }
1117               
1118                if ( nvram_match("boardnum","679") && nvram_match("boardtype", "0x0646")
1119                    && (nvram_match("boardrev", "0x1110")) ) {
1120                        bcm947xx_nflash_parts[nparts].name = "board_data";
1121                        bcm947xx_nflash_parts[nparts].size = 0x20000;
1122                        bcm947xx_nflash_parts[nparts].offset = 0x200000;
1123                        nparts++;
1124                }
1125
1126#ifdef CONFIG_FAILSAFE_UPGRADE
1127                /* Setup 2nd kernel MTD partition */
1128                if (dual_image_on) {
1129                        if (!strcmp(img_boot, "1"))
1130                                bcm947xx_nflash_parts[nparts].name = "linux";
1131                        else
1132                                bcm947xx_nflash_parts[nparts].name = "linux2";
1133
1134                        bcm947xx_nflash_parts[nparts].size = bootossz - image_second_offset;
1135
1136                        bcm947xx_nflash_parts[nparts].offset = image_second_offset;
1137                        shift = lookup_nflash_rootfs_offset(nfl, mtd, image_second_offset, bcm947xx_nflash_parts[nparts].size);
1138                        nparts++;
1139                        /* Setup rootfs MTD partition */
1140                        if (!strcmp(img_boot, "1"))
1141                                bcm947xx_nflash_parts[nparts].name = "rootfs";
1142                        else
1143                                bcm947xx_nflash_parts[nparts].name = "rootfs2";
1144
1145                        bcm947xx_nflash_parts[nparts].size = bootossz - shift;
1146
1147                        bcm947xx_nflash_parts[nparts].offset = shift;
1148                        bcm947xx_nflash_parts[nparts].mask_flags = MTD_WRITEABLE;
1149                        if (!strcmp(img_boot, "1")) {
1150                                // now lets swap the crap
1151                                struct mtd_partition temp;
1152                                // swap rootfs
1153                                memcpy(&temp, &bcm947xx_nflash_parts[nparts], sizeof(temp));
1154                                memcpy(&bcm947xx_nflash_parts[nparts], &bcm947xx_nflash_parts[nparts - 2], sizeof(temp));
1155                                memcpy(&bcm947xx_nflash_parts[nparts - 2], &temp, sizeof(temp));
1156                                // swap kernel enty
1157                                memcpy(&temp, &bcm947xx_nflash_parts[nparts - 1], sizeof(temp));
1158                                memcpy(&bcm947xx_nflash_parts[nparts - 1], &bcm947xx_nflash_parts[nparts - 3], sizeof(temp));
1159                                memcpy(&bcm947xx_nflash_parts[nparts - 3], &temp, sizeof(temp));
1160
1161                        }
1162                        nparts++;
1163
1164                }
1165#endif                          /* CONFIG_FAILSAFE_UPGRADE */
1166
1167
1168        }
1169#if 0
1170        if (rootfssize) {
1171                bcm947xx_nflash_parts[nparts].name = "ddwrt";
1172                bcm947xx_nflash_parts[nparts].offset = bcm947xx_nflash_parts[nparts - 1].offset + bcm947xx_nflash_parts[nparts - 1].size;
1173                bcm947xx_nflash_parts[nparts].offset += (mtd->erasesize - 1);
1174                bcm947xx_nflash_parts[nparts].offset &= ~(mtd->erasesize - 1);
1175                bcm947xx_nflash_parts[nparts].size = (size - bcm947xx_nflash_parts[nparts].offset) - ROUNDUP(NVRAM_SPACE, mtd->erasesize);
1176                nparts++;
1177        }
1178#endif
1179        return bcm947xx_nflash_parts;
1180}
1181
1182EXPORT_SYMBOL(init_nflash_mtd_partitions);
1183#endif                          /* CONFIG_MTD_NFLASH */
Note: See TracBrowser for help on using the repository browser.