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

Last change on this file since 31672 was 31672, checked in by brainslayer, 4 months ago

fix fs detection

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