Changeset 31126


Ignore:
Timestamp:
2012-03-28T19:03:18+02:00 (4 years ago)
Author:
hauke
Message:

brcm47xx: update flash drivers

Location:
trunk/target/linux/brcm47xx/patches-3.2
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/brcm47xx/patches-3.2/020-bcma-move-parallel-flash-into-a-union.patch

    r30942 r31126  
    1 From b7d9f9cd6a8e463c1061ea29ed3e614403625024 Mon Sep 17 00:00:00 2001 
    2 From: Hauke Mehrtens <hauke@hauke-m.de> 
    3 Date: Sun, 17 Jul 2011 14:51:47 +0200 
    4 Subject: [PATCH 12/26] bcma: move parallel flash into a union 
    5  
    6  
    7 Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de> 
    8 --- 
    9  arch/mips/bcm47xx/nvram.c                   |    3 + 
    10  drivers/bcma/driver_mips.c                  |    1 + 
    11  include/linux/bcma/bcma_driver_chipcommon.h |   73 ++++++++++++++++++++++++++- 
    12  3 files changed, 76 insertions(+), 1 deletions(-) 
    13  
    141--- a/arch/mips/bcm47xx/nvram.c 
    152+++ b/arch/mips/bcm47xx/nvram.c 
  • trunk/target/linux/brcm47xx/patches-3.2/021-bcma-add-serial-flash-support-to-bcma.patch

    r30942 r31126  
    1 From a62940e988526c881966a8c72cc28c95fca89f3c Mon Sep 17 00:00:00 2001 
    2 From: Hauke Mehrtens <hauke@hauke-m.de> 
    3 Date: Sun, 17 Jul 2011 14:53:07 +0200 
    4 Subject: [PATCH 13/26] bcma: add serial flash support to bcma 
    5  
    6  
    7 Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de> 
    8 --- 
    9  drivers/bcma/Kconfig                        |    5 + 
    10  drivers/bcma/Makefile                       |    1 + 
    11  drivers/bcma/bcma_private.h                 |    5 + 
    12  drivers/bcma/driver_chipcommon_sflash.c     |  555 +++++++++++++++++++++++++++ 
    13  drivers/bcma/driver_mips.c                  |    8 +- 
    14  include/linux/bcma/bcma_driver_chipcommon.h |   24 ++ 
    15  6 files changed, 597 insertions(+), 1 deletions(-) 
    16  create mode 100644 drivers/bcma/driver_chipcommon_sflash.c 
    17  
    181--- a/drivers/bcma/Kconfig 
    192+++ b/drivers/bcma/Kconfig 
     
    5538--- /dev/null 
    5639+++ b/drivers/bcma/driver_chipcommon_sflash.c 
    57 @@ -0,0 +1,555 @@ 
     40@@ -0,0 +1,398 @@ 
    5841+/* 
    5942+ * Broadcom SiliconBackplane chipcommon serial flash interface 
    6043+ * 
    6144+ * Copyright 2011, Jonas Gorski <jonas.gorski@gmail.com> 
     45+ * Copyright 2011, 2012, Hauke Mehrtens <hauke@hauke-m.de> 
    6246+ * Copyright 2010, Broadcom Corporation 
    6347+ * 
     
    8569+ 
    8670+static inline void bcma_sflash_write_u8(struct bcma_drv_cc *cc, 
    87 +                                             u32 offset, u8 byte) 
     71+                                       u32 offset, u8 byte) 
    8872+{ 
    8973+       bcma_cc_write32(cc, BCMA_CC_FLASHADDR, offset); 
     
    245229+ 
    246230+/* Read len bytes starting at offset into buf. Returns number of bytes read. */ 
    247 +int bcma_sflash_read(struct bcma_drv_cc *cc, u32 offset, u32 len, 
    248 +                          u8 *buf) 
     231+int bcma_sflash_read(struct bcma_drv_cc *cc, u32 offset, u32 len, u8 *buf) 
    249232+{ 
    250233+       u8 *from, *to; 
     
    264247+               cnt = len; 
    265248+ 
    266 + 
    267 +       if (cc->core->id.rev == 12) 
    268 +               from = (u8 *)KSEG1ADDR(BCMA_FLASH2 + offset); 
    269 +       else 
    270 +               from = (u8 *)KSEG0ADDR(BCMA_FLASH2 + offset); 
     249+       from = (u8 *)KSEG0ADDR(BCMA_FLASH2 + offset); 
    271250+ 
    272251+       to = (u8 *)buf; 
     
    317296+                          const u8 *buf) 
    318297+{ 
    319 +       struct bcma_bus *bus = cc->core->bus; 
    320 +       int ret = 0; 
    321 +       bool is4712b0 = (bus->chipinfo.id == 0x4712) && (bus->chipinfo.rev == 3); 
    322 +       u32 mask; 
    323 + 
     298+       int written = 1; 
    324299+ 
    325300+       /* Enable writes */ 
    326301+       bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_WREN); 
    327 +       if (is4712b0) { 
    328 +               mask = 1 << 14; 
    329 +               bcma_sflash_write_u8(cc, offset, *buf++); 
    330 +               /* Set chip select */ 
    331 +               bcma_cc_set32(cc, BCMA_CC_GPIOOUT, mask); 
    332 +               /* Issue a page program with the first byte */ 
    333 +               bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_PP); 
    334 +               ret = 1; 
     302+       bcma_sflash_write_u8(cc, offset, *buf++); 
     303+       /* Issue a page program with CSA bit set */ 
     304+       bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_CSA | BCMA_CC_FLASHCTL_ST_PP); 
     305+       offset++; 
     306+       len--; 
     307+       while (len > 0) { 
     308+               if ((offset & 255) == 0) { 
     309+                       /* Page boundary, poll droping cs and return */ 
     310+                       bcma_cc_write32(cc, BCMA_CC_FLASHCTL, 0); 
     311+                       udelay(1); 
     312+                       if (!bcma_sflash_poll(cc, offset)) { 
     313+                               /* Flash rejected command */ 
     314+                               return -EAGAIN; 
     315+                       } 
     316+                       return written; 
     317+               } else { 
     318+                       /* Write single byte */ 
     319+                       bcma_sflash_cmd(cc, 
     320+                                       BCMA_CC_FLASHCTL_ST_CSA | 
     321+                                       *buf++); 
     322+               } 
     323+               written++; 
    335324+               offset++; 
    336325+               len--; 
    337 +               while (len > 0) { 
    338 +                       if ((offset & 255) == 0) { 
    339 +                               /* Page boundary, drop cs and return */ 
    340 +                               bcma_cc_mask32(cc, BCMA_CC_GPIOOUT, ~mask); 
    341 +                               udelay(1); 
    342 +                               if (!bcma_sflash_poll(cc, offset)) { 
    343 +                                       /* Flash rejected command */ 
    344 +                                       return -EAGAIN; 
    345 +                               } 
    346 +                               return ret; 
    347 +                       } else { 
    348 +                               /* Write single byte */ 
    349 +                               bcma_sflash_cmd(cc, *buf++); 
    350 +                       } 
    351 +                       ret++; 
    352 +                       offset++; 
    353 +                       len--; 
    354 +               } 
    355 +               /* All done, drop cs */ 
    356 +               bcma_cc_mask32(cc, BCMA_CC_GPIOOUT, ~mask); 
    357 +               udelay(1); 
    358 +               if (!bcma_sflash_poll(cc, offset)) { 
    359 +                       /* Flash rejected command */ 
    360 +                       return -EAGAIN; 
    361 +               } 
    362 +       } else if (cc->core->id.rev >= 20) { 
    363 +               bcma_sflash_write_u8(cc, offset, *buf++); 
    364 +               /* Issue a page program with CSA bit set */ 
    365 +               bcma_sflash_cmd(cc, 
    366 +                               BCMA_CC_FLASHCTL_ST_CSA | 
    367 +                               BCMA_CC_FLASHCTL_ST_PP); 
    368 +               ret = 1; 
    369 +               offset++; 
    370 +               len--; 
    371 +               while (len > 0) { 
    372 +                       if ((offset & 255) == 0) { 
    373 +                               /* Page boundary, poll droping cs and return */ 
    374 +                               bcma_cc_write32(cc, BCMA_CC_FLASHCTL, 0); 
    375 +                               udelay(1); 
    376 +                               if (!bcma_sflash_poll(cc, offset)) { 
    377 +                                       /* Flash rejected command */ 
    378 +                                       return -EAGAIN; 
    379 +                               } 
    380 +                               return ret; 
    381 +                       } else { 
    382 +                               /* Write single byte */ 
    383 +                               bcma_sflash_cmd(cc, 
    384 +                                               BCMA_CC_FLASHCTL_ST_CSA | 
    385 +                                               *buf++); 
    386 +                       } 
    387 +                       ret++; 
    388 +                       offset++; 
    389 +                       len--; 
    390 +               } 
    391 +               /* All done, drop cs & poll */ 
    392 +               bcma_cc_write32(cc, BCMA_CC_FLASHCTL, 0); 
    393 +               udelay(1); 
    394 +               if (!bcma_sflash_poll(cc, offset)) { 
    395 +                       /* Flash rejected command */ 
    396 +                       return -EAGAIN; 
    397 +               } 
    398 +       } else { 
    399 +               ret = 1; 
    400 +               bcma_sflash_write_u8(cc, offset, *buf); 
    401 +               /* Page program */ 
    402 +               bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_PP); 
    403 +       } 
    404 +       return ret; 
     326+       } 
     327+       /* All done, drop cs & poll */ 
     328+       bcma_cc_write32(cc, BCMA_CC_FLASHCTL, 0); 
     329+       udelay(1); 
     330+       if (!bcma_sflash_poll(cc, offset)) { 
     331+               /* Flash rejected command */ 
     332+               return -EAGAIN; 
     333+       } 
     334+       return written; 
    405335+} 
    406336+ 
     
    411341+       u32 page, byte, mask; 
    412342+       int ret = 0; 
     343+ 
    413344+       mask = sfl->blocksize - 1; 
    414345+       page = (offset & ~mask) << 1; 
     
    429360+       for (ret = 0; (ret < (int)len) && (byte < sfl->blocksize); ret++) { 
    430361+               bcma_sflash_write_u8(cc, byte++, *buf++); 
    431 +               bcma_sflash_cmd(cc, 
    432 +                               BCMA_CC_FLASHCTL_AT_BUF1_WRITE); 
     362+               bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_AT_BUF1_WRITE); 
    433363+       } 
    434364+       /* Write buffer 1 into main memory page */ 
     
    443373+ */ 
    444374+int bcma_sflash_write(struct bcma_drv_cc *cc, u32 offset, u32 len, 
    445 +                           const u8 *buf) 
     375+                     const u8 *buf) 
    446376+{ 
    447377+       struct bcma_sflash *sfl; 
     
    494424+                * before. 
    495425+                */ 
    496 +               bcma_sflash_cmd(cc, (sfl->blocksize < (64 * 1024)) ? BCMA_CC_FLASHCTL_ST_SSE : BCMA_CC_FLASHCTL_ST_SE); 
     426+               if (sfl->blocksize < (64 * 1024)) 
     427+                       bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_SSE); 
     428+               else 
     429+                       bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_SE); 
    497430+               return sfl->blocksize; 
    498431+       case BCMA_CC_FLASHT_ATSER: 
     
    503436+ 
    504437+       return 0; 
    505 +} 
    506 + 
    507 +/* 
    508 + * writes the appropriate range of flash, a NULL buf simply erases 
    509 + * the region of flash 
    510 + */ 
    511 +int bcma_sflash_commit(struct bcma_drv_cc *cc, u32 offset, u32 len, 
    512 +                            const u8 *buf) 
    513 +{ 
    514 +       struct bcma_sflash *sfl; 
    515 +       u8 *block = NULL, *cur_ptr, *blk_ptr; 
    516 +       u32 blocksize = 0, mask, cur_offset, cur_length, cur_retlen, remainder; 
    517 +       u32 blk_offset, blk_len, copied; 
    518 +       int bytes, ret = 0; 
    519 + 
    520 +       /* Check address range */ 
    521 +       if (len <= 0) 
    522 +               return 0; 
    523 + 
    524 +       sfl = &cc->sflash; 
    525 +       if ((offset + len) > sfl->size) 
    526 +               return -EINVAL; 
    527 + 
    528 +       blocksize = sfl->blocksize; 
    529 +       mask = blocksize - 1; 
    530 + 
    531 +       /* Allocate a block of mem */ 
    532 +       block = kmalloc(blocksize, GFP_KERNEL); 
    533 +       if (!block) 
    534 +               return -ENOMEM; 
    535 + 
    536 +       while (len) { 
    537 +               /* Align offset */ 
    538 +               cur_offset = offset & ~mask; 
    539 +               cur_length = blocksize; 
    540 +               cur_ptr = block; 
    541 + 
    542 +               remainder = blocksize - (offset & mask); 
    543 +               if (len < remainder) 
    544 +                       cur_retlen = len; 
    545 +               else 
    546 +                       cur_retlen = remainder; 
    547 + 
    548 +               /* buf == NULL means erase only */ 
    549 +               if (buf) { 
    550 +                       /* Copy existing data into holding block if necessary */ 
    551 +                       if ((offset & mask) || (len < blocksize)) { 
    552 +                               blk_offset = cur_offset; 
    553 +                               blk_len = cur_length; 
    554 +                               blk_ptr = cur_ptr; 
    555 + 
    556 +                               /* Copy entire block */ 
    557 +                               while (blk_len) { 
    558 +                                       copied = bcma_sflash_read(cc, 
    559 +                                                       blk_offset, 
    560 +                                                       blk_len, blk_ptr); 
    561 +                                       blk_offset += copied; 
    562 +                                       blk_len -= copied; 
    563 +                                       blk_ptr += copied; 
    564 +                               } 
    565 +                       } 
    566 + 
    567 +                       /* Copy input data into holding block */ 
    568 +                       memcpy(cur_ptr + (offset & mask), buf, cur_retlen); 
    569 +               } 
    570 + 
    571 +               /* Erase block */ 
    572 +               ret = bcma_sflash_erase(cc, cur_offset); 
    573 +               if (ret < 0) 
    574 +                       goto done; 
    575 + 
    576 +               while (bcma_sflash_poll(cc, cur_offset)); 
    577 + 
    578 +               /* buf == NULL means erase only */ 
    579 +               if (!buf) { 
    580 +                       offset += cur_retlen; 
    581 +                       len -= cur_retlen; 
    582 +                       continue; 
    583 +               } 
    584 + 
    585 +               /* Write holding block */ 
    586 +               while (cur_length > 0) { 
    587 +                       bytes = bcma_sflash_write(cc, cur_offset, 
    588 +                                       cur_length, cur_ptr); 
    589 + 
    590 +                       if (bytes < 0) { 
    591 +                               ret = bytes; 
    592 +                               goto done; 
    593 +                       } 
    594 + 
    595 +                       while (bcma_sflash_poll(cc, cur_offset)) 
    596 +                               ; 
    597 + 
    598 +                       cur_offset += bytes; 
    599 +                       cur_length -= bytes; 
    600 +                       cur_ptr += bytes; 
    601 +               } 
    602 + 
    603 +               offset += cur_retlen; 
    604 +               len -= cur_retlen; 
    605 +               buf += cur_retlen; 
    606 +       } 
    607 + 
    608 +       ret = len; 
    609 +done: 
    610 +       kfree(block); 
    611 +       return ret; 
    612438+} 
    613439--- a/drivers/bcma/driver_mips.c 
     
    663489  
    664490        int nr_serial_ports; 
    665 @@ -459,4 +471,16 @@ extern void bcma_chipco_chipctl_maskset( 
     491@@ -459,4 +471,14 @@ extern void bcma_chipco_chipctl_maskset( 
    666492 extern void bcma_chipco_regctl_maskset(struct bcma_drv_cc *cc, 
    667493                                       u32 offset, u32 mask, u32 set); 
     
    675501+                           const u8 *buf); 
    676502+int bcma_sflash_erase(struct bcma_drv_cc *cc, u32 offset); 
    677 +int bcma_sflash_commit(struct bcma_drv_cc *cc, u32 offset, u32 len, 
    678 +                            const u8 *buf); 
    679503+#endif /* CONFIG_BCMA_SFLASH */ 
    680504+ 
  • trunk/target/linux/brcm47xx/patches-3.2/022-ssb-move-flash-to-chipcommon.patch

    r30942 r31126  
    1 From e8afde87ecf56beff67c7d5371cabaa4fc018541 Mon Sep 17 00:00:00 2001 
    2 From: Hauke Mehrtens <hauke@hauke-m.de> 
    3 Date: Sat, 23 Jul 2011 23:57:06 +0200 
    4 Subject: [PATCH 14/26] ssb: move flash to chipcommon 
    5  
    6  
    7 Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de> 
    8 --- 
    9  arch/mips/bcm47xx/nvram.c                 |    8 +++--- 
    10  arch/mips/bcm47xx/wgt634u.c               |    8 +++--- 
    11  drivers/ssb/driver_mipscore.c             |   36 +++++++++++++++++++++------- 
    12  include/linux/ssb/ssb_driver_chipcommon.h |   18 ++++++++++++++ 
    13  include/linux/ssb/ssb_driver_mips.h       |    4 --- 
    14  5 files changed, 53 insertions(+), 21 deletions(-) 
    15  
    161--- a/arch/mips/bcm47xx/nvram.c 
    172+++ b/arch/mips/bcm47xx/nvram.c 
  • trunk/target/linux/brcm47xx/patches-3.2/023-ssb-add-serial-flash-support.patch

    r30942 r31126  
    1 From 980da78179592a3f5f99168bc5af415835aa8c13 Mon Sep 17 00:00:00 2001 
    2 From: Hauke Mehrtens <hauke@hauke-m.de> 
    3 Date: Sun, 24 Jul 2011 20:20:36 +0200 
    4 Subject: [PATCH 15/26] ssb: add serial flash support 
    5  
    6  
    7 Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de> 
    8 --- 
    9  drivers/ssb/Kconfig                       |    6 + 
    10  drivers/ssb/Makefile                      |    1 + 
    11  drivers/ssb/driver_chipcommon_sflash.c    |  556 +++++++++++++++++++++++++++++ 
    12  drivers/ssb/driver_mipscore.c             |    6 + 
    13  drivers/ssb/ssb_private.h                 |    4 + 
    14  include/linux/ssb/ssb_driver_chipcommon.h |   30 ++- 
    15  6 files changed, 601 insertions(+), 2 deletions(-) 
    16  create mode 100644 drivers/ssb/driver_chipcommon_sflash.c 
    17  
    181--- a/drivers/ssb/Kconfig 
    192+++ b/drivers/ssb/Kconfig 
     
    4326--- /dev/null 
    4427+++ b/drivers/ssb/driver_chipcommon_sflash.c 
    45 @@ -0,0 +1,556 @@ 
     28@@ -0,0 +1,451 @@ 
    4629+/* 
    4730+ * Broadcom SiliconBackplane chipcommon serial flash interface 
    4831+ * 
    4932+ * Copyright 2011, Jonas Gorski <jonas.gorski@gmail.com> 
     33+ * Copyright 2011, 2012, Hauke Mehrtens <hauke@hauke-m.de> 
    5034+ * Copyright 2010, Broadcom Corporation 
    5135+ * 
     
    7458+ 
    7559+static inline void ssb_sflash_write_u8(struct ssb_chipcommon *cc, 
    76 +                                             u32 offset, u8 byte) 
     60+                                      u32 offset, u8 byte) 
    7761+{ 
    7862+       chipco_write32(cc, SSB_CHIPCO_FLASHADDR, offset); 
     
    234218+ 
    235219+/* Read len bytes starting at offset into buf. Returns number of bytes read. */ 
    236 +int ssb_sflash_read(struct ssb_chipcommon *cc, u32 offset, u32 len, 
    237 +                          u8 *buf) 
     220+int ssb_sflash_read(struct ssb_chipcommon *cc, u32 offset, u32 len, u8 *buf) 
    238221+{ 
    239222+       u8 *from, *to; 
     
    310293+       bool is4712b0 = (bus->chip_id == 0x4712) && (bus->chip_rev == 3); 
    311294+       u32 mask; 
    312 + 
    313295+ 
    314296+       /* Enable writes */ 
     
    479461+               ssb_sflash_cmd(cc, SSB_CHIPCO_FLASHCTL_ST_WREN); 
    480462+               chipco_write32(cc, SSB_CHIPCO_FLASHADDR, offset); 
    481 +               /* Newer flashes have "sub-sectors" which can be erased independently 
    482 +                * with a new command: ST_SSE. The ST_SE command erases 64KB just as 
    483 +                * before. 
     463+               /* Newer flashes have "sub-sectors" which can be erased 
     464+                * independently with a new command: ST_SSE. The ST_SE command 
     465+                * erases 64KB just as before. 
    484466+                */ 
    485 +               ssb_sflash_cmd(cc, (sfl->blocksize < (64 * 1024)) ? SSB_CHIPCO_FLASHCTL_ST_SSE : SSB_CHIPCO_FLASHCTL_ST_SE); 
     467+               if (sfl->blocksize < (64 * 1024)) 
     468+                       ssb_sflash_cmd(cc, SSB_CHIPCO_FLASHCTL_ST_SSE); 
     469+               else 
     470+                       ssb_sflash_cmd(cc, SSB_CHIPCO_FLASHCTL_ST_SE); 
    486471+               return sfl->blocksize; 
    487472+       case SSB_CHIPCO_FLASHT_ATSER: 
     
    492477+ 
    493478+       return 0; 
    494 +} 
    495 + 
    496 +/* 
    497 + * writes the appropriate range of flash, a NULL buf simply erases 
    498 + * the region of flash 
    499 + */ 
    500 +int ssb_sflash_commit(struct ssb_chipcommon *cc, u32 offset, u32 len, 
    501 +                            const u8 *buf) 
    502 +{ 
    503 +       struct ssb_sflash *sfl; 
    504 +       u8 *block = NULL, *cur_ptr, *blk_ptr; 
    505 +       u32 blocksize = 0, mask, cur_offset, cur_length, cur_retlen, remainder; 
    506 +       u32 blk_offset, blk_len, copied; 
    507 +       int bytes, ret = 0; 
    508 + 
    509 +       /* Check address range */ 
    510 +       if (len <= 0) 
    511 +               return 0; 
    512 + 
    513 +       sfl = &cc->sflash; 
    514 +       if ((offset + len) > sfl->size) 
    515 +               return -EINVAL; 
    516 + 
    517 +       blocksize = sfl->blocksize; 
    518 +       mask = blocksize - 1; 
    519 + 
    520 +       /* Allocate a block of mem */ 
    521 +       block = kmalloc(blocksize, GFP_KERNEL); 
    522 +       if (!block) 
    523 +               return -ENOMEM; 
    524 + 
    525 +       while (len) { 
    526 +               /* Align offset */ 
    527 +               cur_offset = offset & ~mask; 
    528 +               cur_length = blocksize; 
    529 +               cur_ptr = block; 
    530 + 
    531 +               remainder = blocksize - (offset & mask); 
    532 +               if (len < remainder) 
    533 +                       cur_retlen = len; 
    534 +               else 
    535 +                       cur_retlen = remainder; 
    536 + 
    537 +               /* buf == NULL means erase only */ 
    538 +               if (buf) { 
    539 +                       /* Copy existing data into holding block if necessary */ 
    540 +                       if ((offset & mask) || (len < blocksize)) { 
    541 +                               blk_offset = cur_offset; 
    542 +                               blk_len = cur_length; 
    543 +                               blk_ptr = cur_ptr; 
    544 + 
    545 +                               /* Copy entire block */ 
    546 +                               while (blk_len) { 
    547 +                                       copied = ssb_sflash_read(cc, 
    548 +                                                       blk_offset, 
    549 +                                                       blk_len, blk_ptr); 
    550 +                                       blk_offset += copied; 
    551 +                                       blk_len -= copied; 
    552 +                                       blk_ptr += copied; 
    553 +                               } 
    554 +                       } 
    555 + 
    556 +                       /* Copy input data into holding block */ 
    557 +                       memcpy(cur_ptr + (offset & mask), buf, cur_retlen); 
    558 +               } 
    559 + 
    560 +               /* Erase block */ 
    561 +               ret = ssb_sflash_erase(cc, cur_offset); 
    562 +               if (ret < 0) 
    563 +                       goto done; 
    564 + 
    565 +               while (ssb_sflash_poll(cc, cur_offset)); 
    566 + 
    567 +               /* buf == NULL means erase only */ 
    568 +               if (!buf) { 
    569 +                       offset += cur_retlen; 
    570 +                       len -= cur_retlen; 
    571 +                       continue; 
    572 +               } 
    573 + 
    574 +               /* Write holding block */ 
    575 +               while (cur_length > 0) { 
    576 +                       bytes = ssb_sflash_write(cc, cur_offset, 
    577 +                                       cur_length, cur_ptr); 
    578 + 
    579 +                       if (bytes < 0) { 
    580 +                               ret = bytes; 
    581 +                               goto done; 
    582 +                       } 
    583 + 
    584 +                       while (ssb_sflash_poll(cc, cur_offset)) 
    585 +                               ; 
    586 + 
    587 +                       cur_offset += bytes; 
    588 +                       cur_length -= bytes; 
    589 +                       cur_ptr += bytes; 
    590 +               } 
    591 + 
    592 +               offset += cur_retlen; 
    593 +               len -= cur_retlen; 
    594 +               buf += cur_retlen; 
    595 +       } 
    596 + 
    597 +       ret = len; 
    598 +done: 
    599 +       kfree(block); 
    600 +       return ret; 
    601479+} 
    602480--- a/drivers/ssb/driver_mipscore.c 
     
    677555 #endif /* CONFIG_SSB_DRIVER_MIPS */ 
    678556 }; 
    679 @@ -666,6 +680,18 @@ extern int ssb_chipco_serial_init(struct 
     557@@ -666,6 +680,16 @@ extern int ssb_chipco_serial_init(struct 
    680558                                  struct ssb_serial_port *ports); 
    681559 #endif /* CONFIG_SSB_SERIAL */ 
     
    689567+                           const u8 *buf); 
    690568+int ssb_sflash_erase(struct ssb_chipcommon *cc, u32 offset); 
    691 +int ssb_sflash_commit(struct ssb_chipcommon *cc, u32 offset, u32 len, 
    692 +                            const u8 *buf); 
    693569+#endif /* CONFIG_SSB_SFLASH */ 
    694570+ 
  • trunk/target/linux/brcm47xx/patches-3.2/024-brcm47xx-add-common-interface-for-sflash.patch

    r30942 r31126  
    1 From 4f314ac9edbc80897f158fdb4e1b1de8a2d0d432 Mon Sep 17 00:00:00 2001 
    2 From: Hauke Mehrtens <hauke@hauke-m.de> 
    3 Date: Sun, 24 Jul 2011 21:10:49 +0200 
    4 Subject: [PATCH 16/26] brcm47xx: add common interface for sflash 
    5  
    6  
    7 Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de> 
    8 --- 
    9  arch/mips/bcm47xx/Makefile               |    2 +- 
    10  arch/mips/bcm47xx/bus.c                  |   94 ++++++++++++++++++++++++++++++ 
    11  arch/mips/bcm47xx/setup.c                |    8 +++ 
    12  arch/mips/include/asm/mach-bcm47xx/bus.h |   37 ++++++++++++ 
    13  4 files changed, 140 insertions(+), 1 deletions(-) 
    14  create mode 100644 arch/mips/bcm47xx/bus.c 
    15  create mode 100644 arch/mips/include/asm/mach-bcm47xx/bus.h 
    16  
    171--- a/arch/mips/bcm47xx/Makefile 
    182+++ b/arch/mips/bcm47xx/Makefile 
     
    2610--- /dev/null 
    2711+++ b/arch/mips/bcm47xx/bus.c 
    28 @@ -0,0 +1,94 @@ 
     12@@ -0,0 +1,82 @@ 
    2913+/* 
    3014+ * BCM947xx nvram variable access 
     
    6044+} 
    6145+ 
    62 +static int bcm47xx_sflash_bcma_commit(struct bcm47xx_sflash *dev, u32 offset, u32 len, const u8 *buf) 
    63 +{ 
    64 +       return bcma_sflash_commit(dev->bcc, offset, len, buf); 
    65 +} 
    66 + 
    6746+void bcm47xx_sflash_struct_bcma_init(struct bcm47xx_sflash *sflash, struct bcma_drv_cc *bcc) 
    6847+{ 
     
    7453+       sflash->write = bcm47xx_sflash_bcma_write; 
    7554+       sflash->erase = bcm47xx_sflash_bcma_erase; 
    76 +       sflash->commit = bcm47xx_sflash_bcma_commit; 
    7755+ 
    7856+       sflash->blocksize = bcc->sflash.blocksize; 
     
    10179+} 
    10280+ 
    103 +static int bcm47xx_sflash_ssb_commit(struct bcm47xx_sflash *dev, u32 offset, u32 len, const u8 *buf) 
    104 +{ 
    105 +       return ssb_sflash_commit(dev->scc, offset, len, buf); 
    106 +} 
    107 + 
    10881+void bcm47xx_sflash_struct_ssb_init(struct bcm47xx_sflash *sflash, struct ssb_chipcommon *scc) 
    10982+{ 
     
    11588+       sflash->write = bcm47xx_sflash_ssb_write; 
    11689+       sflash->erase = bcm47xx_sflash_ssb_erase; 
    117 +       sflash->commit = bcm47xx_sflash_ssb_commit; 
    11890+ 
    11991+       sflash->blocksize = scc->sflash.blocksize; 
     
    154126--- /dev/null 
    155127+++ b/arch/mips/include/asm/mach-bcm47xx/bus.h 
    156 @@ -0,0 +1,37 @@ 
     128@@ -0,0 +1,36 @@ 
    157129+/* 
    158130+ * BCM947xx nvram variable access 
     
    181153+       int (*write)(struct bcm47xx_sflash *dev, u32 offset, u32 len, const u8 *buf); 
    182154+       int (*erase)(struct bcm47xx_sflash *dev, u32 offset); 
    183 +       int (*commit)(struct bcm47xx_sflash *dev, u32 offset, u32 len, const u8 *buf); 
    184155+ 
    185156+       u32 blocksize;          /* Block size */ 
  • trunk/target/linux/brcm47xx/patches-3.2/025-mtd-bcm47xx-add-bcm47xx-part-parser.patch

    r30942 r31126  
    1 From d50d2d8e3ab5446f791deff0cb78820989ed93e7 Mon Sep 17 00:00:00 2001 
    2 From: Hauke Mehrtens <hauke@hauke-m.de> 
    3 Date: Sun, 17 Jul 2011 14:54:11 +0200 
    4 Subject: [PATCH 06/19] mtd: bcm47xx: add bcm47xx part parser 
    5  
    6  
    7 Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de> 
    8 --- 
    9  drivers/mtd/Kconfig       |    7 + 
    10  drivers/mtd/Makefile      |    1 + 
    11  drivers/mtd/bcm47xxpart.c |  542 +++++++++++++++++++++++++++++++++++++++++++++ 
    12  3 files changed, 550 insertions(+), 0 deletions(-) 
    13  create mode 100644 drivers/mtd/bcm47xxpart.c 
    14  
    151--- a/drivers/mtd/Kconfig 
    162+++ b/drivers/mtd/Kconfig 
     
    501487+                       bcm47xx_parts[4].name = "board_data"; 
    502488+                       bcm47xx_parts[4].offset = bcm47xx_parts[3].offset - custom_data_size; 
    503 +                       bcm47xx_parts[4].size   =  custom_data_size; 
     489+                       bcm47xx_parts[4].size   = custom_data_size; 
    504490+                       break; 
    505491+ 
  • trunk/target/linux/brcm47xx/patches-3.2/026-mtd-bcm47xx-add-parallel-flash-driver.patch

    r30942 r31126  
    1 From 36f8b899174a445a98fe02ed8d1db177525f0c52 Mon Sep 17 00:00:00 2001 
    2 From: Hauke Mehrtens <hauke@hauke-m.de> 
    3 Date: Sun, 17 Jul 2011 14:55:18 +0200 
    4 Subject: [PATCH 07/15] mtd: bcm47xx: add parallel flash driver 
    5  
    6  
    7 Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de> 
    8 --- 
    9  drivers/mtd/maps/Kconfig          |    9 ++ 
    10  drivers/mtd/maps/Makefile         |    1 + 
    11  drivers/mtd/maps/bcm47xx-pflash.c |  188 +++++++++++++++++++++++++++++++++++++ 
    12  3 files changed, 198 insertions(+), 0 deletions(-) 
    13  create mode 100644 drivers/mtd/maps/bcm47xx-pflash.c 
    14  
    151--- a/drivers/mtd/maps/Kconfig 
    162+++ b/drivers/mtd/maps/Kconfig 
  • trunk/target/linux/brcm47xx/patches-3.2/027-mtd-bcm47xx-add-serial-flash-driver.patch

    r30942 r31126  
    1 From 2e2951220bf63e05449c03a95453680da1029e44 Mon Sep 17 00:00:00 2001 
    2 From: Hauke Mehrtens <hauke@hauke-m.de> 
    3 Date: Sun, 17 Jul 2011 14:55:45 +0200 
    4 Subject: [PATCH 08/15] mtd: bcm47xx: add serial flash driver 
    5  
    6 sflash get the sflash ops from platform device 
    7  
    8 Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de> 
    9 --- 
    10  arch/mips/include/asm/mach-bcm47xx/bus.h |    3 + 
    11  drivers/mtd/maps/Kconfig                 |    9 + 
    12  drivers/mtd/maps/Makefile                |    1 + 
    13  drivers/mtd/maps/bcm47xx-sflash.c        |  252 ++++++++++++++++++++++++++++++ 
    14  4 files changed, 265 insertions(+), 0 deletions(-) 
    15  create mode 100644 drivers/mtd/maps/bcm47xx-sflash.c 
    16  
    171--- a/arch/mips/include/asm/mach-bcm47xx/bus.h 
    182+++ b/arch/mips/include/asm/mach-bcm47xx/bus.h 
     
    259  
    2610 struct bcm47xx_sflash { 
    27 @@ -29,6 +30,8 @@ struct bcm47xx_sflash { 
     11@@ -28,6 +29,8 @@ struct bcm47xx_sflash { 
    2812        u32 blocksize;          /* Block size */ 
    2913        u32 numblocks;          /* Number of blocks */ 
     
    6145--- /dev/null 
    6246+++ b/drivers/mtd/maps/bcm47xx-sflash.c 
    63 @@ -0,0 +1,252 @@ 
     47@@ -0,0 +1,263 @@ 
    6448+/* 
    6549+ * Broadcom SiliconBackplane chipcommon serial flash interface 
    6650+ * 
     51+ * Copyright 2011, 2012, Hauke Mehrtens <hauke@hauke-m.de> 
    6752+ * Copyright 2006, Broadcom Corporation 
    6853+ * All Rights Reserved. 
    6954+ * 
    70 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY 
    71 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM 
    72 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS 
    73 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE. 
    74 + * 
    75 + * $Id$ 
     55+ * Licensed under the GNU/GPL. See COPYING for details. 
    7656+ */ 
    7757+ 
     
    9474+{ 
    9575+       unsigned long now = jiffies; 
    96 +       int ret = 0; 
    9776+ 
    9877+       for (;;) { 
    9978+               if (!sflash->poll(sflash, offset)) { 
    100 +                       ret = 0; 
    10179+                       break; 
    10280+               } 
    10381+               if (time_after(jiffies, now + timeout)) { 
    10482+                       pr_err("timeout while polling\n"); 
    105 +                       ret = -ETIMEDOUT; 
    106 +                       break; 
     83+                       return -ETIMEDOUT; 
     84+ 
    10785+               } 
     86+               cpu_relax(); 
    10887+               udelay(1); 
    10988+       } 
    11089+ 
    111 +       return ret; 
     90+       return 0; 
    11291+} 
    11392+ 
     
    11594+sflash_mtd_read(struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf) 
    11695+{ 
    117 +       struct bcm47xx_sflash *sflash = (struct bcm47xx_sflash *) mtd->priv; 
     96+       struct bcm47xx_sflash *sflash = (struct bcm47xx_sflash *)mtd->priv; 
    11897+ 
    11998+       /* Check address range */ 
     
    125104+ 
    126105+       *retlen = 0; 
    127 + 
    128106+       while (len) { 
    129107+               int ret = sflash->read(sflash, from, len, buf); 
     
    143121+sflash_mtd_write(struct mtd_info *mtd, loff_t to, size_t len, size_t *retlen, const u_char *buf) 
    144122+{ 
    145 +       struct bcm47xx_sflash *sflash = (struct bcm47xx_sflash *) mtd->priv; 
     123+       int bytes; 
     124+       int ret; 
     125+       struct bcm47xx_sflash *sflash = (struct bcm47xx_sflash *)mtd->priv; 
    146126+ 
    147127+       /* Check address range */ 
     
    154134+       *retlen = 0; 
    155135+       while (len) { 
    156 +               int bytes; 
    157 +               int ret = sflash->write(sflash, to, len, buf); 
     136+               ret = sflash->write(sflash, to, len, buf); 
    158137+               if (ret < 0) 
    159138+                       return ret; 
     
    229208+       struct bcm47xx_sflash *sflash = dev_get_platdata(&pdev->dev); 
    230209+       struct mtd_info *mtd; 
    231 +       struct mtd_erase_region_info *regions; 
     210+       struct mtd_erase_region_info *eraseregions; 
    232211+       int ret = 0; 
    233212+ 
    234213+       mtd = kzalloc(sizeof(struct mtd_info), GFP_KERNEL); 
    235 +       if (!mtd) 
    236 +               return -ENOMEM; 
    237 + 
    238 +       regions = kzalloc(sizeof(struct mtd_erase_region_info), GFP_KERNEL); 
    239 +       if (!mtd) 
    240 +               return -ENOMEM; 
     214+       if (!mtd){ 
     215+               ret =  -ENOMEM; 
     216+               goto err_out; 
     217+       } 
     218+ 
     219+       eraseregions = kzalloc(sizeof(struct mtd_erase_region_info), GFP_KERNEL); 
     220+       if (!eraseregions) { 
     221+               ret =  -ENOMEM; 
     222+               goto err_free_mtd; 
     223+       } 
    241224+ 
    242225+       pr_info("found serial flash: blocksize=%dKB, numblocks=%d, size=%dKB\n", 
    243 +               sflash->blocksize/1024, sflash->numblocks, sflash->size / 1024); 
     226+               sflash->blocksize / 1024, sflash->numblocks, sflash->size / 1024); 
    244227+ 
    245228+       /* Setup region info */ 
    246 +       regions->offset = 0; 
    247 +       regions->erasesize = sflash->blocksize; 
    248 +       regions->numblocks = sflash->numblocks; 
    249 +       if (regions->erasesize > mtd->erasesize) 
    250 +               mtd->erasesize = regions->erasesize; 
     229+       eraseregions->offset = 0; 
     230+       eraseregions->erasesize = sflash->blocksize; 
     231+       eraseregions->numblocks = sflash->numblocks; 
     232+       if (eraseregions->erasesize > mtd->erasesize) 
     233+               mtd->erasesize = eraseregions->erasesize; 
    251234+       mtd->size = sflash->size; 
    252235+       mtd->numeraseregions = 1; 
     
    256239+       mtd->type = MTD_NORFLASH; 
    257240+       mtd->flags = MTD_CAP_NORFLASH; 
    258 +       mtd->eraseregions = regions; 
     241+       mtd->eraseregions = eraseregions; 
    259242+       mtd->erase = sflash_mtd_erase; 
    260243+       mtd->read = sflash_mtd_read; 
     
    262245+       mtd->writesize = 1; 
    263246+       mtd->priv = sflash; 
     247+       ret = dev_set_drvdata(&pdev->dev, mtd); 
    264248+       mtd->owner = THIS_MODULE; 
     249+       if (ret) { 
     250+               pr_err("adding private data failed\n"); 
     251+               goto err_free_eraseregions; 
     252+       } 
    265253+ 
    266254+       ret = mtd_device_parse_register(mtd, probes, NULL, NULL, 0); 
     
    268256+       if (ret) { 
    269257+               pr_err("mtd_device_register failed\n"); 
    270 +               return ret; 
    271 +       } 
    272 +       sflash->mtd = mtd; 
    273 +       return 0; 
     258+               goto err_free_eraseregions; 
     259+       } 
     260+       return 0; 
     261+ 
     262+err_free_eraseregions: 
     263+       kfree(eraseregions); 
     264+err_free_mtd: 
     265+       kfree(mtd); 
     266+err_out: 
     267+       return ret; 
    274268+} 
    275269+ 
    276270+static int __devexit bcm47xx_sflash_remove(struct platform_device *pdev) 
    277271+{ 
    278 +       struct bcm47xx_sflash *sflash = dev_get_platdata(&pdev->dev); 
    279 + 
    280 +       if (sflash) { 
    281 +               mtd_device_unregister(sflash->mtd); 
    282 +               map_destroy(sflash->mtd); 
    283 +               kfree(sflash->mtd->eraseregions); 
    284 +               kfree(sflash->mtd); 
     272+       struct mtd_info *mtd = dev_get_drvdata(&pdev->dev); 
     273+ 
     274+       if (mtd) { 
     275+               mtd_device_unregister(mtd); 
     276+               map_destroy(mtd); 
     277+               kfree(mtd->eraseregions); 
     278+               kfree(mtd); 
     279+               dev_set_drvdata(&pdev->dev, NULL); 
    285280+       } 
    286281+       return 0; 
  • trunk/target/linux/brcm47xx/patches-3.2/028-bcm47xx-register-flash-drivers.patch

    r30942 r31126  
    1 From 64f3d068654589d6114048ac5933cd4498706cfc Mon Sep 17 00:00:00 2001 
    2 From: Hauke Mehrtens <hauke@hauke-m.de> 
    3 Date: Sun, 17 Jul 2011 15:02:10 +0200 
    4 Subject: [PATCH 20/26] bcm47xx: register flash drivers 
    5  
    6  
    7 Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de> 
    8 --- 
    9  arch/mips/bcm47xx/setup.c |   72 +++++++++++++++++++++++++++++++++++++++++++++ 
    10  1 files changed, 72 insertions(+), 0 deletions(-) 
    11  
     1--- a/arch/mips/bcm47xx/Kconfig 
     2+++ b/arch/mips/bcm47xx/Kconfig 
     3@@ -9,6 +9,7 @@ config BCM47XX_SSB 
     4        select SSB_EMBEDDED 
     5        select SSB_B43_PCI_BRIDGE if PCI 
     6        select SSB_PCICORE_HOSTMODE if PCI 
     7+       select SSB_SFLASH 
     8        default y 
     9        help 
     10         Add support for old Broadcom BCM47xx boards with Sonics Silicon Backplane support. 
     11@@ -22,6 +23,7 @@ config BCM47XX_BCMA 
     12        select BCMA_HOST_SOC 
     13        select BCMA_DRIVER_MIPS 
     14        select BCMA_DRIVER_PCI_HOSTMODE if PCI 
     15+       select BCMA_SFLASH 
     16        default y 
     17        help 
     18         Add support for new Broadcom BCM47xx boards with Broadcom specific Advanced Microcontroller Bus. 
    1219--- a/arch/mips/bcm47xx/setup.c 
    1320+++ b/arch/mips/bcm47xx/setup.c 
     
    2532  
    2633 union bcm47xx_bus bcm47xx_bus; 
    27 @@ -366,3 +368,73 @@ static int __init bcm47xx_register_bus_c 
    28         return 0; 
    29  } 
    30  device_initcall(bcm47xx_register_bus_complete); 
    31 + 
     34@@ -45,6 +47,32 @@ EXPORT_SYMBOL(bcm47xx_bus_type); 
     35  
     36 struct bcm47xx_sflash bcm47xx_sflash; 
     37  
    3238+static struct resource bcm47xx_pflash_resource = { 
    3339+       .name   = "bcm47xx_pflash", 
     
    5662+}; 
    5763+ 
     64 static void bcm47xx_machine_restart(char *command) 
     65 { 
     66        printk(KERN_ALERT "Please stand by while rebooting the system...\n"); 
     67@@ -310,6 +338,24 @@ static void __init bcm47xx_register_ssb( 
     68                } 
     69        } 
     70 } 
     71+ 
     72+static int __init bcm47xx_register_flash_ssb(void) 
     73+{ 
     74+       struct ssb_chipcommon *chipco = &bcm47xx_bus.ssb.chipco; 
     75+ 
     76+       switch (chipco->flash_type) { 
     77+       case SSB_PFLASH: 
     78+               bcm47xx_pflash_resource.start = chipco->pflash.window; 
     79+               bcm47xx_pflash_resource.end = chipco->pflash.window + chipco->pflash.window_size; 
     80+               return platform_device_register(&bcm47xx_pflash_dev); 
     81+       case SSB_SFLASH: 
     82+               bcm47xx_sflash_dev.dev.platform_data = &bcm47xx_sflash; 
     83+               return platform_device_register(&bcm47xx_sflash_dev); 
     84+       default: 
     85+               printk(KERN_ERR "No flash device found\n"); 
     86+               return -1; 
     87+       } 
     88+} 
     89 #endif 
     90  
     91 #ifdef CONFIG_BCM47XX_BCMA 
     92@@ -324,6 +370,24 @@ static void __init bcm47xx_register_bcma 
     93        if (bcm47xx_bus.bcma.bus.drv_cc.flash_type == BCMA_SFLASH) 
     94                bcm47xx_sflash_struct_bcma_init(&bcm47xx_sflash, &bcm47xx_bus.bcma.bus.drv_cc); 
     95 } 
     96+ 
     97+static int __init bcm47xx_register_flash_bcma(void) 
     98+{ 
     99+       struct bcma_drv_cc *drv_cc = &bcm47xx_bus.bcma.bus.drv_cc; 
     100+ 
     101+       switch (drv_cc->flash_type) { 
     102+       case BCMA_PFLASH: 
     103+               bcm47xx_pflash_resource.start = drv_cc->pflash.window; 
     104+               bcm47xx_pflash_resource.end = drv_cc->pflash.window + drv_cc->pflash.window_size; 
     105+               return platform_device_register(&bcm47xx_pflash_dev); 
     106+       case BCMA_SFLASH: 
     107+               bcm47xx_sflash_dev.dev.platform_data = &bcm47xx_sflash; 
     108+               return platform_device_register(&bcm47xx_sflash_dev); 
     109+       default: 
     110+               printk(KERN_ERR "No flash device found\n"); 
     111+               return -1; 
     112+       } 
     113+} 
     114 #endif 
     115  
     116 void __init plat_mem_setup(void) 
     117@@ -366,3 +430,19 @@ static int __init bcm47xx_register_bus_c 
     118        return 0; 
     119 } 
     120 device_initcall(bcm47xx_register_bus_complete); 
     121+ 
    58122+static int __init bcm47xx_register_flash(void) 
    59123+{ 
    60 +#ifdef CONFIG_BCM47XX_SSB 
    61 +       struct ssb_chipcommon *chipco; 
    62 +#endif 
    63 +#ifdef CONFIG_BCM47XX_BCMA 
    64 +       struct bcma_drv_cc *drv_cc; 
    65 +#endif 
    66124+       switch (bcm47xx_bus_type) { 
    67125+#ifdef CONFIG_BCM47XX_SSB 
    68126+       case BCM47XX_BUS_TYPE_SSB: 
    69 +               chipco = &bcm47xx_bus.ssb.chipco; 
    70 +               if (chipco->flash_type == SSB_PFLASH) { 
    71 +                       bcm47xx_pflash_resource.start = chipco->pflash.window; 
    72 +                       bcm47xx_pflash_resource.end = chipco->pflash.window + chipco->pflash.window_size; 
    73 +                       return platform_device_register(&bcm47xx_pflash_dev); 
    74 +               } else if (chipco->flash_type == SSB_SFLASH) { 
    75 +                       bcm47xx_sflash_dev.dev.platform_data = &bcm47xx_sflash; 
    76 +                       return platform_device_register(&bcm47xx_sflash_dev); 
    77 +               } else { 
    78 +                       printk(KERN_ERR "No flash device found\n"); 
    79 +                       return -1; 
    80 +               } 
     127+               return bcm47xx_register_flash_ssb(); 
    81128+#endif 
    82129+#ifdef CONFIG_BCM47XX_BCMA 
    83130+       case BCM47XX_BUS_TYPE_BCMA: 
    84 +               drv_cc = &bcm47xx_bus.bcma.bus.drv_cc; 
    85 +               if (drv_cc->flash_type == BCMA_PFLASH) { 
    86 +                       bcm47xx_pflash_resource.start = drv_cc->pflash.window; 
    87 +                       bcm47xx_pflash_resource.end = drv_cc->pflash.window + drv_cc->pflash.window_size; 
    88 +                       return platform_device_register(&bcm47xx_pflash_dev); 
    89 +               } else if (drv_cc->flash_type == BCMA_SFLASH) { 
    90 +                       bcm47xx_sflash_dev.dev.platform_data = &bcm47xx_sflash; 
    91 +                       return platform_device_register(&bcm47xx_sflash_dev); 
    92 +               } else { 
    93 +                       printk(KERN_ERR "No flash device found\n"); 
    94 +                       return -1; 
    95 +               } 
     131+               return bcm47xx_register_flash_bcma(); 
    96132+#endif 
    97133+       } 
  • trunk/target/linux/brcm47xx/patches-3.2/029-bcm47xx-read-nvram-from-sflash.patch

    r30942 r31126  
    1 From 1d693b2c9d5943cbe938f879041b837cd004737f Mon Sep 17 00:00:00 2001 
    2 From: Hauke Mehrtens <hauke@hauke-m.de> 
    3 Date: Sat, 23 Jul 2011 18:29:38 +0200 
    4 Subject: [PATCH 25/26] bcm47xx: read nvram from sflash 
    5  
    6 bcm47xx: add sflash support to nvram 
    7  
    8 Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de> 
    9 --- 
    10  arch/mips/bcm47xx/nvram.c |   86 +++++++++++++++++++++++++++++++++++++++++++- 
    11  1 files changed, 84 insertions(+), 2 deletions(-) 
    12  
    131--- a/arch/mips/bcm47xx/nvram.c 
    142+++ b/arch/mips/bcm47xx/nvram.c 
     
    2715 #ifdef CONFIG_BCM47XX_SSB 
    2816        struct ssb_chipcommon *ssb_cc; 
    29 @@ -86,7 +87,88 @@ found: 
     17@@ -50,9 +51,6 @@ static void early_nvram_init(void) 
     18 #ifdef CONFIG_BCM47XX_BCMA 
     19        case BCM47XX_BUS_TYPE_BCMA: 
     20                bcma_cc = &bcm47xx_bus.bcma.bus.drv_cc; 
     21-               if (bcma_cc->flash_type != BCMA_PFLASH) 
     22-                       return; 
     23- 
     24                base = bcma_cc->pflash.window; 
     25                lim = bcma_cc->pflash.window_size; 
     26                break; 
     27@@ -86,7 +84,106 @@ found: 
    3028        for (i = 0; i < sizeof(struct nvram_header); i += 4) 
    3129                *dst++ = *src++; 
     
    8280+} 
    8381+ 
     82+#ifdef CONFIG_BCM47XX_SSB 
     83+static void early_nvram_init_ssb(void) 
     84+{ 
     85+       int err; 
     86+ 
     87+       switch (bcm47xx_bus.ssb.chipco.flash_type) { 
     88+       case SSB_PFLASH: 
     89+               early_nvram_init_pflash(); 
     90+       case SSB_SFLASH: 
     91+               err = early_nvram_init_sflash(); 
     92+               if (err < 0) 
     93+                       printk(KERN_WARNING "can not read from flash: %i\n", err); 
     94+       default: 
     95+               printk(KERN_WARNING "unknow flash type\n"); 
     96+       } 
     97+} 
     98+#endif 
     99+ 
     100+#ifdef CONFIG_BCM47XX_BCMA 
     101+static void early_nvram_init_bcma(void) 
     102+{ 
     103+       int err; 
     104+ 
     105+       switch (bcm47xx_bus.bcma.bus.drv_cc.flash_type) { 
     106+       case BCMA_PFLASH: 
     107+               early_nvram_init_pflash(); 
     108+       case BCMA_SFLASH: 
     109+               err = early_nvram_init_sflash(); 
     110+               if (err < 0) 
     111+                       printk(KERN_WARNING "can not read from flash: %i\n", err); 
     112+       default: 
     113+               printk(KERN_WARNING "unknow flash type\n"); 
     114+       } 
     115+} 
     116+#endif 
     117+ 
    84118+static void early_nvram_init(void) 
    85119+{ 
    86 +       int err = 0; 
    87 + 
    88120+       switch (bcm47xx_bus_type) { 
    89121+#ifdef CONFIG_BCM47XX_SSB 
    90122+       case BCM47XX_BUS_TYPE_SSB: 
    91 +               if (bcm47xx_bus.ssb.chipco.flash_type == SSB_PFLASH) { 
    92 +                       early_nvram_init_pflash(); 
    93 +               } else if (bcm47xx_bus.ssb.chipco.flash_type == SSB_SFLASH) { 
    94 +                       err = early_nvram_init_sflash(); 
    95 +                       if (err < 0) 
    96 +                               printk(KERN_WARNING "can not read from flash: %i\n", err); 
    97 +               } else { 
    98 +                       printk(KERN_WARNING "unknow flash type\n"); 
    99 +               } 
     123+               early_nvram_init_ssb(); 
    100124+               break; 
    101125+#endif 
    102126+#ifdef CONFIG_BCM47XX_BCMA 
    103127+       case BCM47XX_BUS_TYPE_BCMA: 
    104 +               if (bcm47xx_bus.bcma.bus.drv_cc.flash_type == BCMA_PFLASH) { 
    105 +                       early_nvram_init_pflash(); 
    106 +               } else if (bcm47xx_bus.bcma.bus.drv_cc.flash_type == BCMA_SFLASH) { 
    107 +                       err = early_nvram_init_sflash(); 
    108 +                       if (err < 0) 
    109 +                               printk(KERN_WARNING "can not read from flash: %i\n", err); 
    110 +               } else { 
    111 +                       printk(KERN_WARNING "unknow flash type\n"); 
    112 +               } 
     128+               early_nvram_init_bcma(); 
    113129+               break; 
    114130+#endif 
  • trunk/target/linux/brcm47xx/patches-3.2/030-bcm47xx-bcma-nandflash.patch

    r30943 r31126  
     1--- a/arch/mips/bcm47xx/Kconfig 
     2+++ b/arch/mips/bcm47xx/Kconfig 
     3@@ -24,6 +24,7 @@ config BCM47XX_BCMA 
     4        select BCMA_DRIVER_MIPS 
     5        select BCMA_DRIVER_PCI_HOSTMODE if PCI 
     6        select BCMA_SFLASH 
     7+       select BCMA_NFLASH 
     8        default y 
     9        help 
     10         Add support for new Broadcom BCM47xx boards with Broadcom specific Advanced Microcontroller Bus. 
    111--- a/arch/mips/bcm47xx/bus.c 
    212+++ b/arch/mips/bcm47xx/bus.c 
     
    919  * This program is free software; you can redistribute  it and/or modify it 
    1020  * under  the terms of  the GNU General  Public License as published by the 
    11 @@ -92,3 +93,9 @@ void bcm47xx_sflash_struct_ssb_init(stru 
     21@@ -80,3 +81,9 @@ void bcm47xx_sflash_struct_ssb_init(stru 
    1222        sflash->numblocks = scc->sflash.numblocks; 
    1323        sflash->size = scc->sflash.size; 
     
    3747 static char nvram_buf[NVRAM_SPACE]; 
    3848  
    39 @@ -137,6 +139,51 @@ found: 
     49@@ -134,6 +136,51 @@ found: 
    4050        return 0; 
    4151 } 
     
    8696+} 
    8797+ 
    88  static void early_nvram_init(void) 
     98 #ifdef CONFIG_BCM47XX_SSB 
     99 static void early_nvram_init_ssb(void) 
    89100 { 
    90         int err = 0; 
    91 @@ -163,6 +210,10 @@ static void early_nvram_init(void) 
    92                         err = early_nvram_init_sflash(); 
    93                         if (err < 0) 
    94                                 printk(KERN_WARNING "can not read from flash: %i\n", err); 
    95 +               } else if (bcm47xx_bus.bcma.bus.drv_cc.flash_type == BCMA_NFLASH) { 
    96 +                       err = early_nvram_init_nflash(); 
    97 +                       if (err < 0) 
    98 +                               printk(KERN_WARNING "can not read from nflash: %i\n", err); 
    99                 } else { 
    100                         printk(KERN_WARNING "unknow flash type\n"); 
    101                 } 
     101@@ -164,6 +211,10 @@ static void early_nvram_init_bcma(void) 
     102                err = early_nvram_init_sflash(); 
     103                if (err < 0) 
     104                        printk(KERN_WARNING "can not read from flash: %i\n", err); 
     105+       case BCMA_NFLASH: 
     106+               err = early_nvram_init_nflash(); 
     107+               if (err < 0) 
     108+                       printk(KERN_WARNING "can not read from nflash: %i\n", err); 
     109        default: 
     110                printk(KERN_WARNING "unknow flash type\n"); 
     111        } 
    102112--- a/arch/mips/bcm47xx/setup.c 
    103113+++ b/arch/mips/bcm47xx/setup.c 
     
    116126+struct bcm47xx_nflash bcm47xx_nflash; 
    117127  
     128 static struct resource bcm47xx_pflash_resource = { 
     129        .name   = "bcm47xx_pflash", 
     130@@ -73,6 +75,19 @@ static struct platform_device bcm47xx_sf 
     131        .num_resources  = 1, 
     132 }; 
     133  
     134+static struct resource bcm47xx_nflash_resource = { 
     135+       .name   = "bcm47xx_nflash", 
     136+       .start  = 0, 
     137+       .end    = 0, 
     138+       .flags  = 0, 
     139+}; 
     140+ 
     141+static struct platform_device bcm47xx_nflash_dev = { 
     142+       .name           = "bcm47xx_nflash", 
     143+       .resource       = &bcm47xx_nflash_resource, 
     144+       .num_resources  = 1, 
     145+}; 
     146+ 
    118147 static void bcm47xx_machine_restart(char *command) 
    119148 { 
    120 @@ -325,6 +327,9 @@ static void __init bcm47xx_register_bcma 
     149        printk(KERN_ALERT "Please stand by while rebooting the system...\n"); 
     150@@ -369,6 +384,9 @@ static void __init bcm47xx_register_bcma 
    121151  
    122152        if (bcm47xx_bus.bcma.bus.drv_cc.flash_type == BCMA_SFLASH) 
     
    126156+               bcm47xx_nflash_struct_bcma_init(&bcm47xx_nflash, &bcm47xx_bus.bcma.bus.drv_cc); 
    127157 } 
    128  #endif 
    129   
    130 @@ -395,6 +400,19 @@ static struct platform_device bcm47xx_sf 
    131         .num_resources  = 1, 
    132  }; 
    133   
    134 +static struct resource bcm47xx_nflash_resource = { 
    135 +       .name   = "bcm47xx_nflash", 
    136 +       .start  = 0, 
    137 +       .end    = 0, 
    138 +       .flags  = 0, 
    139 +}; 
    140 + 
    141 +static struct platform_device bcm47xx_nflash_dev = { 
    142 +       .name           = "bcm47xx_nflash", 
    143 +       .resource       = &bcm47xx_nflash_resource, 
    144 +       .num_resources  = 1, 
    145 +}; 
    146 + 
    147  static int __init bcm47xx_register_flash(void) 
    148  { 
    149  #ifdef CONFIG_BCM47XX_SSB 
    150 @@ -429,6 +447,9 @@ static int __init bcm47xx_register_flash 
    151                 } else if (drv_cc->flash_type == BCMA_SFLASH) { 
    152                         bcm47xx_sflash_dev.dev.platform_data = &bcm47xx_sflash; 
    153                         return platform_device_register(&bcm47xx_sflash_dev); 
    154 +               } else if (drv_cc->flash_type == BCMA_NFLASH) { 
    155 +                       bcm47xx_nflash_dev.dev.platform_data = &bcm47xx_nflash; 
    156 +                       return platform_device_register(&bcm47xx_nflash_dev); 
    157                 } else { 
    158                         printk(KERN_ERR "No flash device found\n"); 
    159                         return -1; 
     158  
     159 static int __init bcm47xx_register_flash_bcma(void) 
     160@@ -383,6 +401,9 @@ static int __init bcm47xx_register_flash 
     161        case BCMA_SFLASH: 
     162                bcm47xx_sflash_dev.dev.platform_data = &bcm47xx_sflash; 
     163                return platform_device_register(&bcm47xx_sflash_dev); 
     164+       case BCMA_NFLASH: 
     165+               bcm47xx_nflash_dev.dev.platform_data = &bcm47xx_nflash; 
     166+               return platform_device_register(&bcm47xx_nflash_dev); 
     167        default: 
     168                printk(KERN_ERR "No flash device found\n"); 
     169                return -1; 
    160170--- a/arch/mips/include/asm/mach-bcm47xx/bus.h 
    161171+++ b/arch/mips/include/asm/mach-bcm47xx/bus.h 
     
    176186 struct bcm47xx_sflash { 
    177187        enum bcm47xx_bus_type sflash_type; 
    178 @@ -38,3 +40,18 @@ void bcm47xx_sflash_struct_bcma_init(str 
     188@@ -29,11 +31,24 @@ struct bcm47xx_sflash { 
     189        u32 blocksize;          /* Block size */ 
     190        u32 numblocks;          /* Number of blocks */ 
     191        u32 size;               /* Total size in bytes */ 
     192- 
     193-       struct mtd_info *mtd; 
     194 }; 
     195  
     196 void bcm47xx_sflash_struct_bcma_init(struct bcm47xx_sflash *sflash, struct bcma_drv_cc *bcc); 
    179197 void bcm47xx_sflash_struct_ssb_init(struct bcm47xx_sflash *sflash, struct ssb_chipcommon *scc); 
    180198  
     
    195213+ 
    196214+extern struct bcm47xx_nflash bcm47xx_nflash; 
     215--- a/drivers/bcma/Kconfig 
     216+++ b/drivers/bcma/Kconfig 
     217@@ -43,6 +43,11 @@ config BCMA_SFLASH 
     218        depends on BCMA_DRIVER_MIPS 
     219        default y 
     220  
     221+config BCMA_NFLASH 
     222+       bool 
     223+       depends on BCMA_DRIVER_MIPS 
     224+       default y 
     225+ 
     226 config BCMA_DRIVER_MIPS 
     227        bool "BCMA Broadcom MIPS core driver" 
     228        depends on BCMA && MIPS 
     229--- a/drivers/bcma/Makefile 
     230+++ b/drivers/bcma/Makefile 
     231@@ -1,6 +1,7 @@ 
     232 bcma-y                                 += main.o scan.o core.o sprom.o 
     233 bcma-y                                 += driver_chipcommon.o driver_chipcommon_pmu.o 
     234 bcma-$(CONFIG_BCMA_SFLASH)             += driver_chipcommon_sflash.o 
     235+bcma-$(CONFIG_BCMA_NFLASH)             += driver_chipcommon_nflash.o 
     236 bcma-y                                 += driver_pci.o 
     237 bcma-$(CONFIG_BCMA_DRIVER_PCI_HOSTMODE)        += driver_pci_host.o 
     238 bcma-$(CONFIG_BCMA_DRIVER_MIPS)                += driver_mips.o 
    197239--- a/drivers/bcma/bcma_private.h 
    198240+++ b/drivers/bcma/bcma_private.h 
     
    321363+       if (bcma_nflash_offset_is_valid(cc, offset, len, mask)) 
    322364+               return 1; 
    323 +        
     365+ 
    324366+       /* disable partial page enable */ 
    325367+       reg = bcma_cc_read32(cc, NAND_ACC_CONTROL); 
     
    350392+} 
    351393+ 
    352 +/* Erase a region. Returns success (0) or failure (-1).  
     394+/* Erase a region. Returns success (0) or failure (-1). 
    353395+ * Poll for completion. 
    354396+ */ 
     
    394436        case BCMA_CC_FLASHT_STSER: 
    395437        case BCMA_CC_FLASHT_ATSER: 
    396 --- a/drivers/bcma/Kconfig 
    397 +++ b/drivers/bcma/Kconfig 
    398 @@ -43,6 +43,11 @@ config BCMA_SFLASH 
    399         depends on BCMA_DRIVER_MIPS 
    400         default y 
    401   
    402 +config BCMA_NFLASH 
    403 +       bool 
    404 +       depends on BCMA_DRIVER_MIPS 
     438--- a/drivers/mtd/nand/Kconfig 
     439+++ b/drivers/mtd/nand/Kconfig 
     440@@ -537,4 +537,12 @@ config MTD_NAND_FSMC 
     441          Enables support for NAND Flash chips on the ST Microelectronics 
     442          Flexible Static Memory Controller (FSMC) 
     443  
     444+config MTD_NAND_BCM47XX 
     445+       tristate "bcm47xx nand flash support" 
    405446+       default y 
    406 + 
    407  config BCMA_DRIVER_MIPS 
    408         bool "BCMA Broadcom MIPS core driver" 
    409         depends on BCMA && MIPS 
    410 --- a/drivers/bcma/Makefile 
    411 +++ b/drivers/bcma/Makefile 
    412 @@ -1,6 +1,7 @@ 
    413  bcma-y                                 += main.o scan.o core.o sprom.o 
    414  bcma-y                                 += driver_chipcommon.o driver_chipcommon_pmu.o 
    415  bcma-$(CONFIG_BCMA_SFLASH)             += driver_chipcommon_sflash.o 
    416 +bcma-$(CONFIG_BCMA_NFLASH)             += driver_chipcommon_nflash.o 
    417  bcma-y                                 += driver_pci.o 
    418  bcma-$(CONFIG_BCMA_DRIVER_PCI_HOSTMODE)        += driver_pci_host.o 
    419  bcma-$(CONFIG_BCMA_DRIVER_MIPS)                += driver_mips.o 
     447+       depends on BCM47XX 
     448+       select MTD_PARTITIONS 
     449+       help 
     450+         Support for bcm47xx nand flash 
     451+ 
     452 endif # MTD_NAND 
     453--- a/drivers/mtd/nand/Makefile 
     454+++ b/drivers/mtd/nand/Makefile 
     455@@ -49,5 +49,6 @@ obj-$(CONFIG_MTD_NAND_MPC5121_NFC)    += mp 
     456 obj-$(CONFIG_MTD_NAND_RICOH)           += r852.o 
     457 obj-$(CONFIG_MTD_NAND_JZ4740)          += jz4740_nand.o 
     458 obj-$(CONFIG_MTD_NAND_GPMI_NAND)       += gpmi-nand/ 
     459+obj-$(CONFIG_MTD_NAND_BCM47XX)         += bcm47xx_nand.o 
     460  
     461 nand-objs := nand_base.o nand_bbt.o 
    420462--- /dev/null 
    421463+++ b/drivers/mtd/nand/bcm47xx_nand.c 
     
    591633+                       } 
    592634+               } 
    593 +        
     635+ 
    594636+               /* Copy input data into holding block */ 
    595637+               copy_len = min(len, blocksize - (offset & mask)); 
     
    640682+               return 1; 
    641683+       } 
    642 +        
     684+ 
    643685+       return 0; 
    644686+} 
     
    705747+               bcm47xx_erase(mtd, page_addr*pagesize, pagesize); 
    706748+               break; 
    707 +        
     749+ 
    708750+       case NAND_CMD_ERASE2: 
    709751+               break; 
     
    712754+               if (column > mtd->writesize) 
    713755+                       read_offset += (column - mtd->writesize); 
    714 +               else  
     756+               else 
    715757+                       read_offset += column; 
    716758+               break; 
     
    741783+ 
    742784+       if (nflash->next_opcode == NAND_CMD_STATUS) 
    743 +               return NAND_STATUS_WP;  
     785+               return NAND_STATUS_WP; 
    744786+ 
    745787+       id = bcma_cc_read32(nflash->bcc, nflash->next_opcode); 
     
    880922+               return ret; 
    881923+       } 
    882 +        
     924+ 
    883925+       return 0; 
    884926+ 
     
    927969+MODULE_LICENSE("GPL"); 
    928970+MODULE_DESCRIPTION("BCM47XX NAND flash driver"); 
    929 --- a/drivers/mtd/nand/Kconfig 
    930 +++ b/drivers/mtd/nand/Kconfig 
    931 @@ -537,4 +537,12 @@ config MTD_NAND_FSMC 
    932           Enables support for NAND Flash chips on the ST Microelectronics 
    933           Flexible Static Memory Controller (FSMC) 
    934   
    935 +config MTD_NAND_BCM47XX 
    936 +       tristate "bcm47xx nand flash support" 
    937 +       default y 
    938 +       depends on BCM47XX 
    939 +       select MTD_PARTITIONS 
    940 +       help 
    941 +         Support for bcm47xx nand flash 
    942 + 
    943  endif # MTD_NAND 
    944 --- a/drivers/mtd/nand/Makefile 
    945 +++ b/drivers/mtd/nand/Makefile 
    946 @@ -49,5 +49,6 @@ obj-$(CONFIG_MTD_NAND_MPC5121_NFC)    += mp 
    947  obj-$(CONFIG_MTD_NAND_RICOH)           += r852.o 
    948  obj-$(CONFIG_MTD_NAND_JZ4740)          += jz4740_nand.o 
    949  obj-$(CONFIG_MTD_NAND_GPMI_NAND)       += gpmi-nand/ 
    950 +obj-$(CONFIG_MTD_NAND_BCM47XX)         += bcm47xx_nand.o 
    951   
    952  nand-objs := nand_base.o nand_bbt.o 
    953971--- a/include/linux/bcma/bcma_driver_chipcommon.h 
    954972+++ b/include/linux/bcma/bcma_driver_chipcommon.h 
     
    9861004  
    9871005        int nr_serial_ports; 
    988 @@ -483,4 +495,13 @@ int bcma_sflash_commit(struct bcma_drv_c 
    989                              const u8 *buf); 
     1006@@ -481,4 +493,13 @@ int bcma_sflash_write(struct bcma_drv_cc 
     1007 int bcma_sflash_erase(struct bcma_drv_cc *cc, u32 offset); 
    9901008 #endif /* CONFIG_BCMA_SFLASH */ 
    9911009  
     
    10091027+ * Copyright (C) 2009, Broadcom Corporation 
    10101028+ * All Rights Reserved. 
    1011 + *  
     1029+ * 
    10121030+ * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY 
    10131031+ * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM 
  • trunk/target/linux/brcm47xx/patches-3.2/114-MIPS-BCM47xx-Setup-and-register-serial-early.patch

    r30943 r31126  
    2525 #include <asm/reboot.h> 
    2626 #include <asm/time.h> 
    27 @@ -281,6 +283,31 @@ static int bcm47xx_get_invariants(struct 
     27@@ -320,6 +322,31 @@ static int bcm47xx_get_invariants(struct 
    2828        return 0; 
    2929 } 
     
    5757 { 
    5858        int err; 
    59 @@ -313,6 +340,10 @@ static void __init bcm47xx_register_ssb( 
     59@@ -352,6 +379,10 @@ static void __init bcm47xx_register_ssb( 
    6060                        memcpy(&mcore->serial_ports[1], &port, sizeof(port)); 
    6161                } 
     
    6666+#endif 
    6767 } 
    68  #endif 
    6968  
     69 static int __init bcm47xx_register_flash_ssb(void) 
  • trunk/target/linux/brcm47xx/patches-3.2/197-MIPS-BCM47XX-return-number-of-written-bytes-in-nvram.patch

    r31093 r31126  
    22--- a/arch/mips/bcm47xx/nvram.c 
    33+++ b/arch/mips/bcm47xx/nvram.c 
    4 @@ -243,8 +243,7 @@ int nvram_getenv(char *name, char *val, 
     4@@ -258,8 +258,7 @@ int nvram_getenv(char *name, char *val, 
    55                value = eq + 1; 
    66                if ((eq - var) == strlen(name) && 
  • trunk/target/linux/brcm47xx/patches-3.2/199-MIPS-BCM47XX-move-and-extend-sprom-parsing.patch

    r31093 r31126  
    1010--- a/arch/mips/bcm47xx/setup.c 
    1111+++ b/arch/mips/bcm47xx/setup.c 
    12 @@ -93,156 +93,7 @@ static void bcm47xx_machine_halt(void) 
     12@@ -132,156 +132,7 @@ static void bcm47xx_machine_halt(void) 
    1313 } 
    1414  
  • trunk/target/linux/brcm47xx/patches-3.2/200-MIPS-BCM47XX-provide-sprom-to-bcma-bus.patch

    r31093 r31126  
    1010  * 
    1111  *  This program is free software; you can redistribute  it and/or modify it 
    12 @@ -93,7 +93,7 @@ static void bcm47xx_machine_halt(void) 
     12@@ -132,7 +132,7 @@ static void bcm47xx_machine_halt(void) 
    1313 } 
    1414  
     
    1919        char prefix[10]; 
    2020  
    21 @@ -110,7 +110,7 @@ static int bcm47xx_get_sprom(struct ssb_ 
     21@@ -149,7 +149,7 @@ static int bcm47xx_get_sprom(struct ssb_ 
    2222 } 
    2323  
     
    2828        char buf[20]; 
    2929  
    30 @@ -165,7 +165,7 @@ static void __init bcm47xx_register_ssb( 
     30@@ -204,7 +204,7 @@ static void __init bcm47xx_register_ssb( 
    3131        char buf[100]; 
    3232        struct ssb_mipscore *mcore; 
     
    3737                printk(KERN_WARNING "bcm47xx: someone else already registered" 
    3838                        " a ssb SPROM callback handler (err %d)\n", err); 
    39 @@ -199,10 +199,41 @@ static void __init bcm47xx_register_ssb( 
     39@@ -256,10 +256,41 @@ static int __init bcm47xx_register_flash 
    4040 #endif 
    4141  
  • trunk/target/linux/brcm47xx/patches-3.2/231-bcma_reorder_sprom_fill.patch

    r31093 r31126  
    11--- a/arch/mips/bcm47xx/setup.c 
    22+++ b/arch/mips/bcm47xx/setup.c 
    3 @@ -98,6 +98,7 @@ static int bcm47xx_get_sprom_ssb(struct 
     3@@ -137,6 +137,7 @@ static int bcm47xx_get_sprom_ssb(struct 
    44        char prefix[10]; 
    55  
     
    99                         bus->host_pci->bus->number + 1, 
    1010                         PCI_SLOT(bus->host_pci->devfn)); 
    11 @@ -126,6 +127,7 @@ static int bcm47xx_get_invariants(struct 
     11@@ -165,6 +166,7 @@ static int bcm47xx_get_invariants(struct 
    1212        if (nvram_getenv("boardrev", buf, sizeof(buf)) >= 0) 
    1313                iv->boardinfo.rev = (u16)simple_strtoul(buf, NULL, 0); 
     
    1717  
    1818        if (nvram_getenv("cardbus", buf, sizeof(buf)) >= 0) 
    19 @@ -206,12 +208,14 @@ static int bcm47xx_get_sprom_bcma(struct 
     19@@ -263,12 +265,14 @@ static int bcm47xx_get_sprom_bcma(struct 
    2020  
    2121        switch (bus->hosttype) { 
  • trunk/target/linux/brcm47xx/patches-3.2/400-arch-bcm47xx.patch

    r30943 r31126  
    11--- a/arch/mips/bcm47xx/nvram.c 
    22+++ b/arch/mips/bcm47xx/nvram.c 
    3 @@ -249,3 +249,30 @@ int nvram_getenv(char *name, char *val, 
     3@@ -264,3 +264,30 @@ int nvram_getenv(char *name, char *val, 
    44        return NVRAM_ERR_ENVNOTFOUND; 
    55 } 
     
    3434--- a/arch/mips/bcm47xx/setup.c 
    3535+++ b/arch/mips/bcm47xx/setup.c 
    36 @@ -376,3 +376,20 @@ static int __init bcm47xx_register_flash 
     36@@ -384,3 +384,20 @@ static int __init bcm47xx_register_flash 
    3737        return -1; 
    3838 } 
  • trunk/target/linux/brcm47xx/patches-3.2/820-wgt634u-nvram-fix.patch

    r30943 r31126  
    255255 /* Probe for NVRAM header */ 
    256256 static void early_nvram_init_pflash(void) 
    257 @@ -61,6 +63,25 @@ static void early_nvram_init_pflash(void 
     257@@ -58,6 +60,25 @@ static void early_nvram_init_pflash(void 
    258258                break; 
    259259 #endif 
     
    281281        off = FLASH_MIN; 
    282282        while (off <= lim) { 
    283 @@ -232,6 +253,12 @@ int nvram_getenv(char *name, char *val, 
     283@@ -247,6 +268,12 @@ int nvram_getenv(char *name, char *val, 
    284284        if (!nvram_buf[0]) 
    285285                early_nvram_init(); 
     
    294294        var = &nvram_buf[sizeof(struct nvram_header)]; 
    295295        end = nvram_buf + sizeof(nvram_buf) - 2; 
    296 @@ -260,6 +287,9 @@ char *nvram_get(const char *name) 
     296@@ -275,6 +302,9 @@ char *nvram_get(const char *name) 
    297297        if (!nvram_buf[0]) 
    298298                early_nvram_init(); 
  • trunk/target/linux/brcm47xx/patches-3.2/980-wnr834b_no_cardbus_invariant.patch

    r30943 r31126  
    11--- a/arch/mips/bcm47xx/setup.c 
    22+++ b/arch/mips/bcm47xx/setup.c 
    3 @@ -133,6 +133,10 @@ static int bcm47xx_get_invariants(struct 
     3@@ -172,6 +172,10 @@ static int bcm47xx_get_invariants(struct 
    44        if (nvram_getenv("cardbus", buf, sizeof(buf)) >= 0) 
    55                iv->has_cardbus_slot = !!simple_strtoul(buf, NULL, 10); 
Note: See TracChangeset for help on using the changeset viewer.