source: trunk/target/linux/brcm47xx/patches-3.2/021-bcma-add-serial-flash-support-to-bcma.patch @ 31126

Last change on this file since 31126 was 31126, checked in by hauke, 4 years ago

brcm47xx: update flash drivers

File size: 13.1 KB
  • drivers/bcma/Kconfig

    a b config BCMA_HOST_SOC 
    3838        bool 
    3939        depends on BCMA_DRIVER_MIPS 
    4040 
     41config BCMA_SFLASH 
     42        bool 
     43        depends on BCMA_DRIVER_MIPS 
     44        default y 
     45 
    4146config BCMA_DRIVER_MIPS 
    4247        bool "BCMA Broadcom MIPS core driver" 
    4348        depends on BCMA && MIPS 
  • drivers/bcma/Makefile

    a b  
    11bcma-y                                  += main.o scan.o core.o sprom.o 
    22bcma-y                                  += driver_chipcommon.o driver_chipcommon_pmu.o 
     3bcma-$(CONFIG_BCMA_SFLASH)              += driver_chipcommon_sflash.o 
    34bcma-y                                  += driver_pci.o 
    45bcma-$(CONFIG_BCMA_DRIVER_PCI_HOSTMODE) += driver_pci_host.o 
    56bcma-$(CONFIG_BCMA_DRIVER_MIPS)         += driver_mips.o 
  • drivers/bcma/bcma_private.h

    a b void bcma_chipco_serial_init(struct bcma 
    4141u32 bcma_pmu_alp_clock(struct bcma_drv_cc *cc); 
    4242u32 bcma_pmu_get_clockcpu(struct bcma_drv_cc *cc); 
    4343 
     44#ifdef CONFIG_BCMA_SFLASH 
     45/* driver_chipcommon_sflash.c */ 
     46int bcma_sflash_init(struct bcma_drv_cc *cc); 
     47#endif /* CONFIG_BCMA_SFLASH */ 
     48 
    4449#ifdef CONFIG_BCMA_HOST_PCI 
    4550/* host_pci.c */ 
    4651extern int __init bcma_host_pci_init(void); 
  • new file drivers/bcma/driver_chipcommon_sflash.c

    - +  
     1/* 
     2 * Broadcom SiliconBackplane chipcommon serial flash interface 
     3 * 
     4 * Copyright 2011, Jonas Gorski <jonas.gorski@gmail.com> 
     5 * Copyright 2011, 2012, Hauke Mehrtens <hauke@hauke-m.de> 
     6 * Copyright 2010, Broadcom Corporation 
     7 * 
     8 * Licensed under the GNU/GPL. See COPYING for details. 
     9 */ 
     10 
     11#include <linux/bcma/bcma.h> 
     12#include <linux/bcma/bcma_driver_chipcommon.h> 
     13#include <linux/delay.h> 
     14 
     15#include "bcma_private.h" 
     16 
     17#define NUM_RETRIES     3 
     18 
     19 
     20/* Issue a serial flash command */ 
     21static inline void bcma_sflash_cmd(struct bcma_drv_cc *cc, u32 opcode) 
     22{ 
     23        bcma_cc_write32(cc, BCMA_CC_FLASHCTL, 
     24                        BCMA_CC_FLASHCTL_START | opcode); 
     25        while (bcma_cc_read32(cc, BCMA_CC_FLASHCTL) & BCMA_CC_FLASHCTL_BUSY) 
     26                ; 
     27} 
     28 
     29 
     30static inline void bcma_sflash_write_u8(struct bcma_drv_cc *cc, 
     31                                        u32 offset, u8 byte) 
     32{ 
     33        bcma_cc_write32(cc, BCMA_CC_FLASHADDR, offset); 
     34        bcma_cc_write32(cc, BCMA_CC_FLASHDATA, byte); 
     35} 
     36 
     37/* Initialize serial flash access */ 
     38int bcma_sflash_init(struct bcma_drv_cc *cc) 
     39{ 
     40        u32 id, id2; 
     41 
     42        memset(&cc->sflash, 0, sizeof(struct bcma_sflash)); 
     43 
     44        switch (cc->capabilities & BCMA_CC_CAP_FLASHT) { 
     45        case BCMA_CC_FLASHT_STSER: 
     46                /* Probe for ST chips */ 
     47                bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_DP); 
     48                bcma_cc_write32(cc, BCMA_CC_FLASHADDR, 0); 
     49                bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_RES); 
     50                id = bcma_cc_read32(cc, BCMA_CC_FLASHDATA); 
     51                cc->sflash.blocksize = 64 * 1024; 
     52                switch (id) { 
     53                case 0x11: 
     54                        /* ST M25P20 2 Mbit Serial Flash */ 
     55                        cc->sflash.numblocks = 4; 
     56                        break; 
     57                case 0x12: 
     58                        /* ST M25P40 4 Mbit Serial Flash */ 
     59                        cc->sflash.numblocks = 8; 
     60                        break; 
     61                case 0x13: 
     62                        /* ST M25P80 8 Mbit Serial Flash */ 
     63                        cc->sflash.numblocks = 16; 
     64                        break; 
     65                case 0x14: 
     66                        /* ST M25P16 16 Mbit Serial Flash */ 
     67                        cc->sflash.numblocks = 32; 
     68                        break; 
     69                case 0x15: 
     70                        /* ST M25P32 32 Mbit Serial Flash */ 
     71                        cc->sflash.numblocks = 64; 
     72                        break; 
     73                case 0x16: 
     74                        /* ST M25P64 64 Mbit Serial Flash */ 
     75                        cc->sflash.numblocks = 128; 
     76                        break; 
     77                case 0x17: 
     78                        /* ST M25FL128 128 Mbit Serial Flash */ 
     79                        cc->sflash.numblocks = 256; 
     80                        break; 
     81                case 0xbf: 
     82                        /* All of the following flashes are SST with 
     83                         * 4KB subsectors. Others should be added but 
     84                         * We'll have to revamp the way we identify them 
     85                         * since RES is not eough to disambiguate them. 
     86                         */ 
     87                        cc->sflash.blocksize = 4 * 1024; 
     88                        bcma_cc_write32(cc, BCMA_CC_FLASHADDR, 1); 
     89                        bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_RES); 
     90                        id2 = bcma_cc_read32(cc, BCMA_CC_FLASHDATA); 
     91                        switch (id2) { 
     92                        case 1: 
     93                                /* SST25WF512 512 Kbit Serial Flash */ 
     94                        case 0x48: 
     95                                /* SST25VF512 512 Kbit Serial Flash */ 
     96                                cc->sflash.numblocks = 16; 
     97                                break; 
     98                        case 2: 
     99                                /* SST25WF010 1 Mbit Serial Flash */ 
     100                        case 0x49: 
     101                                /* SST25VF010 1 Mbit Serial Flash */ 
     102                                cc->sflash.numblocks = 32; 
     103                                break; 
     104                        case 3: 
     105                                /* SST25WF020 2 Mbit Serial Flash */ 
     106                        case 0x43: 
     107                                /* SST25VF020 2 Mbit Serial Flash */ 
     108                                cc->sflash.numblocks = 64; 
     109                                break; 
     110                        case 4: 
     111                                /* SST25WF040 4 Mbit Serial Flash */ 
     112                        case 0x44: 
     113                                /* SST25VF040 4 Mbit Serial Flash */ 
     114                        case 0x8d: 
     115                                /* SST25VF040B 4 Mbit Serial Flash */ 
     116                                cc->sflash.numblocks = 128; 
     117                                break; 
     118                        case 5: 
     119                                /* SST25WF080 8 Mbit Serial Flash */ 
     120                        case 0x8e: 
     121                                /* SST25VF080B 8 Mbit Serial Flash */ 
     122                                cc->sflash.numblocks = 256; 
     123                                break; 
     124                        case 0x41: 
     125                                /* SST25VF016 16 Mbit Serial Flash */ 
     126                                cc->sflash.numblocks = 512; 
     127                                break; 
     128                        case 0x4a: 
     129                                /* SST25VF032 32 Mbit Serial Flash */ 
     130                                cc->sflash.numblocks = 1024; 
     131                                break; 
     132                        case 0x4b: 
     133                                /* SST25VF064 64 Mbit Serial Flash */ 
     134                                cc->sflash.numblocks = 2048; 
     135                                break; 
     136                        } 
     137                        break; 
     138                } 
     139                break; 
     140 
     141        case BCMA_CC_FLASHT_ATSER: 
     142                /* Probe for Atmel chips */ 
     143                bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_AT_STATUS); 
     144                id = bcma_cc_read32(cc, BCMA_CC_FLASHDATA) & 0x3c; 
     145                switch (id) { 
     146                case 0xc: 
     147                        /* Atmel AT45DB011 1Mbit Serial Flash */ 
     148                        cc->sflash.blocksize = 256; 
     149                        cc->sflash.numblocks = 512; 
     150                        break; 
     151                case 0x14: 
     152                        /* Atmel AT45DB021 2Mbit Serial Flash */ 
     153                        cc->sflash.blocksize = 256; 
     154                        cc->sflash.numblocks = 1024; 
     155                        break; 
     156                case 0x1c: 
     157                        /* Atmel AT45DB041 4Mbit Serial Flash */ 
     158                        cc->sflash.blocksize = 256; 
     159                        cc->sflash.numblocks = 2048; 
     160                        break; 
     161                case 0x24: 
     162                        /* Atmel AT45DB081 8Mbit Serial Flash */ 
     163                        cc->sflash.blocksize = 256; 
     164                        cc->sflash.numblocks = 4096; 
     165                        break; 
     166                case 0x2c: 
     167                        /* Atmel AT45DB161 16Mbit Serial Flash */ 
     168                        cc->sflash.blocksize = 512; 
     169                        cc->sflash.numblocks = 4096; 
     170                        break; 
     171                case 0x34: 
     172                        /* Atmel AT45DB321 32Mbit Serial Flash */ 
     173                        cc->sflash.blocksize = 512; 
     174                        cc->sflash.numblocks = 8192; 
     175                        break; 
     176                case 0x3c: 
     177                        /* Atmel AT45DB642 64Mbit Serial Flash */ 
     178                        cc->sflash.blocksize = 1024; 
     179                        cc->sflash.numblocks = 8192; 
     180                        break; 
     181                } 
     182                break; 
     183        } 
     184 
     185        cc->sflash.size = cc->sflash.blocksize * cc->sflash.numblocks; 
     186 
     187        return cc->sflash.size ? 0 : -ENODEV; 
     188} 
     189 
     190/* Read len bytes starting at offset into buf. Returns number of bytes read. */ 
     191int bcma_sflash_read(struct bcma_drv_cc *cc, u32 offset, u32 len, u8 *buf) 
     192{ 
     193        u8 *from, *to; 
     194        u32 cnt, i; 
     195 
     196        if (!len) 
     197                return 0; 
     198 
     199        if ((offset + len) > cc->sflash.size) 
     200                return -EINVAL; 
     201 
     202        if ((len >= 4) && (offset & 3)) 
     203                cnt = 4 - (offset & 3); 
     204        else if ((len >= 4) && ((u32)buf & 3)) 
     205                cnt = 4 - ((u32)buf & 3); 
     206        else 
     207                cnt = len; 
     208 
     209        from = (u8 *)KSEG0ADDR(BCMA_FLASH2 + offset); 
     210 
     211        to = (u8 *)buf; 
     212 
     213        if (cnt < 4) { 
     214                for (i = 0; i < cnt; i++) { 
     215                        *to = readb(from); 
     216                        from++; 
     217                        to++; 
     218                } 
     219                return cnt; 
     220        } 
     221 
     222        while (cnt >= 4) { 
     223                *(u32 *)to = readl(from); 
     224                from += 4; 
     225                to += 4; 
     226                cnt -= 4; 
     227        } 
     228 
     229        return len - cnt; 
     230} 
     231 
     232/* Poll for command completion. Returns zero when complete. */ 
     233int bcma_sflash_poll(struct bcma_drv_cc *cc, u32 offset) 
     234{ 
     235        if (offset >= cc->sflash.size) 
     236                return -22; 
     237 
     238        switch (cc->capabilities & BCMA_CC_CAP_FLASHT) { 
     239        case BCMA_CC_FLASHT_STSER: 
     240                /* Check for ST Write In Progress bit */ 
     241                bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_RDSR); 
     242                return bcma_cc_read32(cc, BCMA_CC_FLASHDATA) 
     243                                & BCMA_CC_FLASHDATA_ST_WIP; 
     244        case BCMA_CC_FLASHT_ATSER: 
     245                /* Check for Atmel Ready bit */ 
     246                bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_AT_STATUS); 
     247                return !(bcma_cc_read32(cc, BCMA_CC_FLASHDATA) 
     248                                & BCMA_CC_FLASHDATA_AT_READY); 
     249        } 
     250 
     251        return 0; 
     252} 
     253 
     254 
     255static int sflash_st_write(struct bcma_drv_cc *cc, u32 offset, u32 len, 
     256                           const u8 *buf) 
     257{ 
     258        int written = 1; 
     259 
     260        /* Enable writes */ 
     261        bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_WREN); 
     262        bcma_sflash_write_u8(cc, offset, *buf++); 
     263        /* Issue a page program with CSA bit set */ 
     264        bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_CSA | BCMA_CC_FLASHCTL_ST_PP); 
     265        offset++; 
     266        len--; 
     267        while (len > 0) { 
     268                if ((offset & 255) == 0) { 
     269                        /* Page boundary, poll droping cs and return */ 
     270                        bcma_cc_write32(cc, BCMA_CC_FLASHCTL, 0); 
     271                        udelay(1); 
     272                        if (!bcma_sflash_poll(cc, offset)) { 
     273                                /* Flash rejected command */ 
     274                                return -EAGAIN; 
     275                        } 
     276                        return written; 
     277                } else { 
     278                        /* Write single byte */ 
     279                        bcma_sflash_cmd(cc, 
     280                                        BCMA_CC_FLASHCTL_ST_CSA | 
     281                                        *buf++); 
     282                } 
     283                written++; 
     284                offset++; 
     285                len--; 
     286        } 
     287        /* All done, drop cs & poll */ 
     288        bcma_cc_write32(cc, BCMA_CC_FLASHCTL, 0); 
     289        udelay(1); 
     290        if (!bcma_sflash_poll(cc, offset)) { 
     291                /* Flash rejected command */ 
     292                return -EAGAIN; 
     293        } 
     294        return written; 
     295} 
     296 
     297static int sflash_at_write(struct bcma_drv_cc *cc, u32 offset, u32 len, 
     298                           const u8 *buf) 
     299{ 
     300        struct bcma_sflash *sfl = &cc->sflash; 
     301        u32 page, byte, mask; 
     302        int ret = 0; 
     303 
     304        mask = sfl->blocksize - 1; 
     305        page = (offset & ~mask) << 1; 
     306        byte = offset & mask; 
     307        /* Read main memory page into buffer 1 */ 
     308        if (byte || (len < sfl->blocksize)) { 
     309                int i = 100; 
     310                bcma_cc_write32(cc, BCMA_CC_FLASHADDR, page); 
     311                bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_AT_BUF1_LOAD); 
     312                /* 250 us for AT45DB321B */ 
     313                while (i > 0 && bcma_sflash_poll(cc, offset)) { 
     314                        udelay(10); 
     315                        i--; 
     316                } 
     317                BUG_ON(!bcma_sflash_poll(cc, offset)); 
     318        } 
     319        /* Write into buffer 1 */ 
     320        for (ret = 0; (ret < (int)len) && (byte < sfl->blocksize); ret++) { 
     321                bcma_sflash_write_u8(cc, byte++, *buf++); 
     322                bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_AT_BUF1_WRITE); 
     323        } 
     324        /* Write buffer 1 into main memory page */ 
     325        bcma_cc_write32(cc, BCMA_CC_FLASHADDR, page); 
     326        bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_AT_BUF1_PROGRAM); 
     327 
     328        return ret; 
     329} 
     330 
     331/* Write len bytes starting at offset into buf. Returns number of bytes 
     332 * written. Caller should poll for completion. 
     333 */ 
     334int bcma_sflash_write(struct bcma_drv_cc *cc, u32 offset, u32 len, 
     335                      const u8 *buf) 
     336{ 
     337        struct bcma_sflash *sfl; 
     338        int ret = 0, tries = NUM_RETRIES; 
     339 
     340        if (!len) 
     341                return 0; 
     342 
     343        if ((offset + len) > cc->sflash.size) 
     344                return -EINVAL; 
     345 
     346        sfl = &cc->sflash; 
     347        switch (cc->capabilities & BCMA_CC_CAP_FLASHT) { 
     348        case BCMA_CC_FLASHT_STSER: 
     349                do { 
     350                        ret = sflash_st_write(cc, offset, len, buf); 
     351                        tries--; 
     352                } while (ret == -EAGAIN && tries > 0); 
     353 
     354                if (ret == -EAGAIN && tries == 0) { 
     355                        pr_info("ST Flash rejected write\n"); 
     356                        ret = -EIO; 
     357                } 
     358                break; 
     359        case BCMA_CC_FLASHT_ATSER: 
     360                ret = sflash_at_write(cc, offset, len, buf); 
     361                break; 
     362        } 
     363 
     364        return ret; 
     365} 
     366 
     367/* Erase a region. Returns number of bytes scheduled for erasure. 
     368 * Caller should poll for completion. 
     369 */ 
     370int bcma_sflash_erase(struct bcma_drv_cc *cc, u32 offset) 
     371{ 
     372        struct bcma_sflash *sfl; 
     373 
     374        if (offset >= cc->sflash.size) 
     375                return -EINVAL; 
     376 
     377        sfl = &cc->sflash; 
     378        switch (cc->capabilities & BCMA_CC_CAP_FLASHT) { 
     379        case BCMA_CC_FLASHT_STSER: 
     380                bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_WREN); 
     381                bcma_cc_write32(cc, BCMA_CC_FLASHADDR, offset); 
     382                /* Newer flashes have "sub-sectors" which can be erased independently 
     383                 * with a new command: ST_SSE. The ST_SE command erases 64KB just as 
     384                 * before. 
     385                 */ 
     386                if (sfl->blocksize < (64 * 1024)) 
     387                        bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_SSE); 
     388                else 
     389                        bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_ST_SE); 
     390                return sfl->blocksize; 
     391        case BCMA_CC_FLASHT_ATSER: 
     392                bcma_cc_write32(cc, BCMA_CC_FLASHADDR, offset << 1); 
     393                bcma_sflash_cmd(cc, BCMA_CC_FLASHCTL_AT_PAGE_ERASE); 
     394                return sfl->blocksize; 
     395        } 
     396 
     397        return 0; 
     398} 
  • drivers/bcma/driver_mips.c

    a b static void bcma_core_mips_flash_detect( 
    185185        switch (bus->drv_cc.capabilities & BCMA_CC_CAP_FLASHT) { 
    186186        case BCMA_CC_FLASHT_STSER: 
    187187        case BCMA_CC_FLASHT_ATSER: 
    188                 pr_err("Serial flash not supported.\n"); 
     188#ifdef CONFIG_BCMA_SFLASH 
     189                pr_info("found serial flash.\n"); 
     190                bus->drv_cc.flash_type = BCMA_SFLASH; 
     191                bcma_sflash_init(&bus->drv_cc); 
     192#else 
     193                pr_info("serial flash not supported.\n"); 
     194#endif /* CONFIG_BCMA_SFLASH */ 
    189195                break; 
    190196        case BCMA_CC_FLASHT_PARA: 
    191197                pr_info("found parallel flash.\n"); 
  • include/linux/bcma/bcma_driver_chipcommon.h

    a b struct bcma_chipcommon_pmu { 
    375375#ifdef CONFIG_BCMA_DRIVER_MIPS 
    376376enum bcma_flash_type { 
    377377        BCMA_PFLASH, 
     378        BCMA_SFLASH, 
    378379}; 
    379380 
    380381struct bcma_pflash { 
    struct bcma_pflash { 
    383384        u32 window_size; 
    384385}; 
    385386 
     387#ifdef CONFIG_BCMA_SFLASH 
     388struct bcma_sflash { 
     389        u32 blocksize;          /* Block size */ 
     390        u32 numblocks;          /* Number of blocks */ 
     391        u32 size;               /* Total size in bytes */ 
     392}; 
     393#endif /* CONFIG_BCMA_SFLASH */ 
     394 
    386395struct bcma_serial_port { 
    387396        void *regs; 
    388397        unsigned long clockspeed; 
    struct bcma_drv_cc { 
    405414        enum bcma_flash_type flash_type; 
    406415        union { 
    407416                struct bcma_pflash pflash; 
     417#ifdef CONFIG_BCMA_SFLASH 
     418                struct bcma_sflash sflash; 
     419#endif /* CONFIG_BCMA_SFLASH */ 
    408420        }; 
    409421 
    410422        int nr_serial_ports; 
    extern void bcma_chipco_chipctl_maskset( 
    459471extern void bcma_chipco_regctl_maskset(struct bcma_drv_cc *cc, 
    460472                                       u32 offset, u32 mask, u32 set); 
    461473 
     474#ifdef CONFIG_BCMA_SFLASH 
     475/* Chipcommon sflash support. */ 
     476int bcma_sflash_read(struct bcma_drv_cc *cc, u32 offset, u32 len, 
     477                           u8 *buf); 
     478int bcma_sflash_poll(struct bcma_drv_cc *cc, u32 offset); 
     479int bcma_sflash_write(struct bcma_drv_cc *cc, u32 offset, u32 len, 
     480                            const u8 *buf); 
     481int bcma_sflash_erase(struct bcma_drv_cc *cc, u32 offset); 
     482#endif /* CONFIG_BCMA_SFLASH */ 
     483 
    462484#endif /* LINUX_BCMA_DRIVER_CC_H_ */ 
Note: See TracBrowser for help on using the repository browser.