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

Last change on this file since 31630 was 31630, checked in by brainslayer, 5 months ago

new fs is compatible with standard squashfs, just smaller

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