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, 10 days 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.