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

Last change on this file since 31707 was 31707, checked in by brainslayer, 3 months ago

compiles on northstar, but nand driver will likelly not work yet. still something todo

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