Ignore:
Timestamp:
2010-08-31T22:13:47+02:00 (6 years ago)
Author:
juhosg
Message:

ar71xx: rewrite SPI drivers for the RB4xx boards

  • add a new SPI controller driver
  • add SPI driver for the CPLD chip
  • convert the NAND driver
  • enable the mikroSD slot
  • enable more LEDs
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/ar71xx/files/drivers/mtd/nand/rb4xx_nand.c

    r21736 r22863  
    22 *  NAND flash driver for the MikroTik RouterBoard 4xx series 
    33 * 
    4  *  Copyright (C) 2008 Gabor Juhos <juhosg@openwrt.org> 
     4 *  Copyright (C) 2008-2010 Gabor Juhos <juhosg@openwrt.org> 
    55 *  Copyright (C) 2008 Imre Kaloz <kaloz@openwrt.org> 
    66 * 
     
    2424 
    2525#include <asm/mach-ar71xx/ar71xx.h> 
     26#include <asm/mach-ar71xx/rb4xx_cpld.h> 
    2627 
    2728#define DRV_NAME        "rb4xx-nand" 
    28 #define DRV_VERSION     "0.1.10" 
     29#define DRV_VERSION     "0.2.0" 
    2930#define DRV_DESC        "NAND flash driver for RouterBoard 4xx series" 
    3031 
    31 #define USE_FAST_READ   1 
    32 #define USE_FAST_WRITE  1 
    33 #undef RB4XX_NAND_DEBUG 
    34  
    35 #ifdef RB4XX_NAND_DEBUG 
    36 #define DBG(fmt, arg...)        printk(KERN_DEBUG DRV_NAME ": " fmt, ## arg) 
    37 #else 
    38 #define DBG(fmt, arg...)        do {} while (0) 
    39 #endif 
    40  
    41 #define RB4XX_NAND_GPIO_RDY     5 
    42 #define RB4XX_FLASH_HZ          33333334 
    43 #define RB4XX_NAND_HZ           33333334 
    44  
    45 #define SPI_CTRL_FASTEST        0x40 
    46 #define SPI_CTRL_SAFE           0x43    /* 25 MHz for AHB 200 MHz */ 
    47 #define SBIT_IOC_BASE           SPI_IOC_CS1 
    48 #define SBIT_IOC_DO_SHIFT       0 
    49 #define SBIT_IOC_DO             (1u << SBIT_IOC_DO_SHIFT) 
    50 #define SBIT_IOC_DO2_SHIFT      18 
    51 #define SBIT_IOC_DO2            (1u << SBIT_IOC_DO2_SHIFT) 
    52  
    53 #define CPLD_CMD_WRITE_MULT     0x08    /* send cmd, n x send data, read data */ 
    54 #define CPLD_CMD_WRITE_CFG      0x09    /* send cmd, n x send cfg */ 
    55 #define CPLD_CMD_READ_MULT      0x0a    /* send cmd, send idle, n x read data */ 
    56 #define CPLD_CMD_READ_FAST      0x0b    /* send cmd, 4 x idle, n x read data */ 
    57  
    58 #define CFG_BIT_nCE     0x80 
    59 #define CFG_BIT_CLE     0x40 
    60 #define CFG_BIT_ALE     0x20 
    61 #define CFG_BIT_FAN     0x10 
    62 #define CFG_BIT_nLED4   0x08 
    63 #define CFG_BIT_nLED3   0x04 
    64 #define CFG_BIT_nLED2   0x02 
    65 #define CFG_BIT_nLED1   0x01 
    66  
    67 #define CFG_BIT_nLEDS \ 
    68         (CFG_BIT_nLED1 | CFG_BIT_nLED2 | CFG_BIT_nLED3 | CFG_BIT_nLED4) 
     32#define RB4XX_NAND_GPIO_READY   5 
     33#define RB4XX_NAND_GPIO_ALE     37 
     34#define RB4XX_NAND_GPIO_CLE     38 
     35#define RB4XX_NAND_GPIO_NCE     39 
    6936 
    7037struct rb4xx_nand_info { 
     
    10370}; 
    10471 
    105 #if USE_FAST_READ 
    106 #define SPI_NDATA_BASE  0x00800000 
    107 static unsigned spi_ctrl_fread = SPI_CTRL_SAFE; 
    108 static unsigned spi_ctrl_flash = SPI_CTRL_SAFE; 
    109 extern unsigned mips_hpt_frequency; 
    110 #endif 
    111  
    112 static inline unsigned rb4xx_spi_rreg(unsigned r) 
    113 { 
    114         return __raw_readl((void * __iomem)(KSEG1ADDR(AR71XX_SPI_BASE) + r)); 
    115 } 
    116  
    117 static inline void rb4xx_spi_wreg(unsigned r, unsigned v) 
    118 { 
    119         __raw_writel(v, (void * __iomem)(KSEG1ADDR(AR71XX_SPI_BASE) + r)); 
    120 } 
    121  
    122 static inline void do_spi_clk(int bit) 
    123 { 
    124         unsigned bval = SBIT_IOC_BASE | (bit & 1); 
    125  
    126         rb4xx_spi_wreg(SPI_REG_IOC, bval); 
    127         rb4xx_spi_wreg(SPI_REG_IOC, bval | SPI_IOC_CLK); 
    128 } 
    129  
    130 static void do_spi_byte(uint8_t byte) 
    131 { 
    132         do_spi_clk(byte >> 7); 
    133         do_spi_clk(byte >> 6); 
    134         do_spi_clk(byte >> 5); 
    135         do_spi_clk(byte >> 4); 
    136         do_spi_clk(byte >> 3); 
    137         do_spi_clk(byte >> 2); 
    138         do_spi_clk(byte >> 1); 
    139         do_spi_clk(byte); 
    140  
    141         DBG("spi_byte sent 0x%02x got 0x%x\n", 
    142                                         byte, rb4xx_spi_rreg(SPI_REG_RDS)); 
    143 } 
    144  
    145 #if USE_FAST_WRITE 
    146 static inline void do_spi_clk_fast(int bit1, int bit2) 
    147 { 
    148         unsigned bval = (SBIT_IOC_BASE | 
    149                         ((bit1 << SBIT_IOC_DO_SHIFT) & SBIT_IOC_DO) | 
    150                         ((bit2 << SBIT_IOC_DO2_SHIFT) & SBIT_IOC_DO2)); 
    151  
    152         rb4xx_spi_wreg(SPI_REG_IOC, bval); 
    153         rb4xx_spi_wreg(SPI_REG_IOC, bval | SPI_IOC_CLK); 
    154 } 
    155  
    156 static inline void do_spi_byte_fast(uint8_t byte) 
    157 { 
    158         do_spi_clk_fast(byte >> 7, byte >> 6); 
    159         do_spi_clk_fast(byte >> 5, byte >> 4); 
    160         do_spi_clk_fast(byte >> 3, byte >> 2); 
    161         do_spi_clk_fast(byte >> 1, byte >> 0); 
    162  
    163         DBG("spi_byte_fast sent 0x%02x got 0x%x\n", 
    164                                         byte, rb4xx_spi_rreg(SPI_REG_RDS)); 
    165 } 
    166 #else 
    167 static inline void do_spi_byte_fast(uint8_t byte) 
    168 { 
    169         do_spi_byte(byte); 
    170 } 
    171 #endif /* USE_FAST_WRITE */ 
    172  
    173 static int do_spi_cmd(unsigned cmd, unsigned sendCnt, const uint8_t *sendData, 
    174                 unsigned recvCnt, uint8_t *recvData, 
    175                 const uint8_t *verifyData, int fastWrite) 
    176 { 
    177         unsigned i; 
    178  
    179         DBG("SPI cmd 0x%x send %u recv %u\n", cmd, sendCnt, recvCnt); 
    180  
    181         rb4xx_spi_wreg(SPI_REG_FS, SPI_FS_GPIO); 
    182         rb4xx_spi_wreg(SPI_REG_CTRL, SPI_CTRL_FASTEST); 
    183  
    184         do_spi_byte(cmd); 
    185 #if 0 
    186         if (cmd == CPLD_CMD_READ_FAST) { 
    187                 do_spi_byte(0x80); 
    188                 do_spi_byte(0); 
    189                 do_spi_byte(0); 
    190         } 
    191 #endif 
    192         for (i = 0; i < sendCnt; ++i) { 
    193                 if (fastWrite) 
    194                         do_spi_byte_fast(sendData[i]); 
    195                 else 
    196                         do_spi_byte(sendData[i]); 
    197         } 
    198  
    199         for (i = 0; i < recvCnt; ++i) { 
    200                 if (fastWrite) 
    201                         do_spi_byte_fast(0); 
    202                 else 
    203                         do_spi_byte(0); 
    204  
    205                 if (recvData) { 
    206                         recvData[i] = rb4xx_spi_rreg(SPI_REG_RDS) & 0xff; 
    207                 } else if (verifyData) { 
    208                         if (verifyData[i] != (rb4xx_spi_rreg(SPI_REG_RDS) 
    209                                                          & 0xff)) 
    210                                 break; 
    211                 } 
    212         } 
    213  
    214         rb4xx_spi_wreg(SPI_REG_IOC, SBIT_IOC_BASE | SPI_IOC_CS0); 
    215         rb4xx_spi_wreg(SPI_REG_CTRL, spi_ctrl_flash); 
    216         rb4xx_spi_wreg(SPI_REG_FS, 0); 
    217  
    218         return i == recvCnt; 
    219 } 
    220  
    221 static int got_write = 1; 
    222  
    223 static void rb4xx_nand_write_data(const uint8_t *byte, unsigned cnt) 
    224 { 
    225         do_spi_cmd(CPLD_CMD_WRITE_MULT, cnt, byte, 1, NULL, NULL, 1); 
    226         got_write = 1; 
    227 } 
    228  
    229 static void rb4xx_nand_write_byte(uint8_t byte) 
    230 { 
    231         rb4xx_nand_write_data(&byte, 1); 
    232 } 
    233  
    234 #if USE_FAST_READ 
    235 static uint8_t *rb4xx_nand_read_getaddr(unsigned cnt) 
    236 { 
    237         static unsigned nboffset = 0x100000; 
    238         unsigned addr; 
    239  
    240         if (got_write) { 
    241                 nboffset = (nboffset + 31) & ~31; 
    242                 if (nboffset >= 0x100000)       /* 1MB */ 
    243                         nboffset = 0; 
    244  
    245                 got_write = 0; 
    246                 rb4xx_spi_wreg(SPI_REG_FS, SPI_FS_GPIO); 
    247                 rb4xx_spi_wreg(SPI_REG_CTRL, spi_ctrl_fread); 
    248                 rb4xx_spi_wreg(SPI_REG_FS, 0); 
    249         } 
    250  
    251         addr = KSEG1ADDR(AR71XX_SPI_BASE + SPI_NDATA_BASE) + nboffset; 
    252         DBG("rb4xx_nand_read_getaddr 0x%x cnt 0x%x\n", addr, cnt); 
    253  
    254         nboffset += cnt; 
    255         return (uint8_t *)addr; 
    256 } 
    257  
    258 static void rb4xx_nand_read_data(uint8_t *buf, unsigned cnt) 
    259 { 
    260         unsigned size32 = cnt & ~31; 
    261         unsigned remain = cnt & 31; 
    262  
    263         if (size32) { 
    264                 uint8_t *addr = rb4xx_nand_read_getaddr(size32); 
    265                 memcpy(buf, (void *)addr, size32); 
    266         } 
    267  
    268         if (remain) { 
    269                 do_spi_cmd(CPLD_CMD_READ_MULT, 1, buf, remain, 
    270                            buf + size32, NULL, 0); 
    271         } 
    272 } 
    273  
    274 static int rb4xx_nand_verify_data(const uint8_t *buf, unsigned cnt) 
    275 { 
    276         unsigned size32 = cnt & ~31; 
    277         unsigned remain = cnt & 31; 
    278  
    279         if (size32) { 
    280                 uint8_t *addr = rb4xx_nand_read_getaddr(size32); 
    281                 if (memcmp(buf, (void *)addr, size32) != 0) 
    282                         return 0; 
    283         } 
    284  
    285         if (remain) { 
    286                 return do_spi_cmd(CPLD_CMD_READ_MULT, 1, buf, remain, 
    287                                   NULL, buf + size32, 0); 
    288         } 
    289         return 1; 
    290 } 
    291 #else /* USE_FAST_READ */ 
    292 static void rb4xx_nand_read_data(uint8_t *buf, unsigned cnt) 
    293 { 
    294         do_spi_cmd(CPLD_CMD_READ_MULT, 1, buf, cnt, buf, NULL, 0); 
    295 } 
    296  
    297 static int rb4xx_nand_verify_data(const uint8_t *buf, unsigned cnt) 
    298 { 
    299         return do_spi_cmd(CPLD_CMD_READ_MULT, 1, buf, cnt, NULL, buf, 0); 
    300 } 
    301 #endif /* USE_FAST_READ */ 
    302  
    303 static void rb4xx_nand_write_cfg(uint8_t byte) 
    304 { 
    305         do_spi_cmd(CPLD_CMD_WRITE_CFG, 1, &byte, 0, NULL, NULL, 0); 
    306         got_write = 1; 
    307 } 
    308  
    30972static int rb4xx_nand_dev_ready(struct mtd_info *mtd) 
    31073{ 
    311         return gpio_get_value(RB4XX_NAND_GPIO_RDY); 
     74        return gpio_get_value(RB4XX_NAND_GPIO_READY); 
     75} 
     76 
     77static void rb4xx_nand_write_cmd(unsigned char cmd) 
     78{ 
     79        unsigned char data = cmd; 
     80        int err; 
     81 
     82        err = rb4xx_cpld_write(&data, 1); 
     83        if (err) 
     84                pr_err("rb4xx_nand: write cmd failed, err=%d\n", err); 
    31285} 
    31386 
     
    31689{ 
    31790        if (ctrl & NAND_CTRL_CHANGE) { 
    318                 uint8_t cfg = CFG_BIT_nLEDS; 
    319  
    320                 cfg |= (ctrl & NAND_CLE) ? CFG_BIT_CLE : 0; 
    321                 cfg |= (ctrl & NAND_ALE) ? CFG_BIT_ALE : 0; 
    322                 cfg |= (ctrl & NAND_NCE) ? 0 : CFG_BIT_nCE; 
    323  
    324                 rb4xx_nand_write_cfg(cfg); 
     91                gpio_set_value(RB4XX_NAND_GPIO_CLE, (ctrl & NAND_CLE) ? 1 : 0); 
     92                gpio_set_value(RB4XX_NAND_GPIO_ALE, (ctrl & NAND_ALE) ? 1 : 0); 
     93                gpio_set_value(RB4XX_NAND_GPIO_NCE, (ctrl & NAND_NCE) ? 0 : 1); 
    32594        } 
    32695 
    32796        if (cmd != NAND_CMD_NONE) 
    328                 rb4xx_nand_write_byte(cmd); 
    329 } 
    330  
    331 static uint8_t rb4xx_nand_read_byte(struct mtd_info *mtd) 
    332 { 
    333         uint8_t byte = 0; 
    334  
    335         rb4xx_nand_read_data(&byte, 1); 
    336         return byte; 
    337 } 
    338  
    339 static void rb4xx_nand_write_buf(struct mtd_info *mtd, const uint8_t *buf, 
     97                rb4xx_nand_write_cmd(cmd); 
     98} 
     99 
     100static unsigned char rb4xx_nand_read_byte(struct mtd_info *mtd) 
     101{ 
     102        unsigned char data = 0; 
     103        int err; 
     104 
     105        err = rb4xx_cpld_read(&data, NULL, 1); 
     106        if (err) { 
     107                pr_err("rb4xx_nand: read data failed, err=%d\n", err); 
     108                data = 0xff; 
     109        } 
     110 
     111        return data; 
     112} 
     113 
     114static void rb4xx_nand_write_buf(struct mtd_info *mtd, const unsigned char *buf, 
     115                                 int len) 
     116{ 
     117        int err; 
     118 
     119        err = rb4xx_cpld_write(buf, len); 
     120        if (err) 
     121                pr_err("rb4xx_nand: write buf failed, err=%d\n", err); 
     122} 
     123 
     124static void rb4xx_nand_read_buf(struct mtd_info *mtd, unsigned char *buf, 
    340125                                int len) 
    341126{ 
    342         rb4xx_nand_write_data(buf, len); 
    343 } 
    344  
    345 static void rb4xx_nand_read_buf(struct mtd_info *mtd, uint8_t *buf, 
    346                                 int len) 
    347 { 
    348         rb4xx_nand_read_data(buf, len); 
    349 } 
    350  
    351 static int rb4xx_nand_verify_buf(struct mtd_info *mtd, const uint8_t *buf, 
    352                                 int len) 
    353 { 
    354         if (!rb4xx_nand_verify_data(buf, len)) 
    355                 return -EFAULT; 
    356  
    357         return 0; 
    358 } 
    359  
    360 static unsigned get_spi_ctrl(unsigned hz_max, const char *name) 
    361 { 
    362         unsigned div; 
    363  
    364         div = (ar71xx_ahb_freq - 1) / (2 * hz_max); 
    365         /* 
    366          * CPU has a bug at (div == 0) - first bit read is random 
    367          */ 
    368         if (div == 0) 
    369                 ++div; 
    370  
    371         if (name) { 
    372                 unsigned ahb_khz = (ar71xx_ahb_freq + 500) / 1000; 
    373                 unsigned div_real = 2 * (div + 1); 
    374                 printk(KERN_INFO "%s SPI clock %u kHz (AHB %u kHz / %u)\n", 
    375                        name, 
    376                        ahb_khz / div_real, 
    377                        ahb_khz, div_real); 
    378         } 
    379  
    380         return SPI_CTRL_FASTEST + div; 
     127        int err; 
     128 
     129        err = rb4xx_cpld_read(buf, NULL, len); 
     130        if (err) 
     131                pr_err("rb4xx_nand: read buf failed, err=%d\n", err); 
    381132} 
    382133 
     
    388139        printk(KERN_INFO DRV_DESC " version " DRV_VERSION "\n"); 
    389140 
    390         ret = gpio_request(RB4XX_NAND_GPIO_RDY, "NAND RDY"); 
    391         if (ret) { 
    392                 printk(KERN_ERR "rb4xx-nand: gpio request failed\n"); 
    393                 return ret; 
    394         } 
    395  
    396         ret = gpio_direction_input(RB4XX_NAND_GPIO_RDY); 
    397         if (ret) { 
    398                 printk(KERN_ERR "rb4xx-nand: unable to set input mode " 
    399                                         "on gpio%d\n", RB4XX_NAND_GPIO_RDY); 
    400                 goto err_free_gpio; 
     141        ret = gpio_request(RB4XX_NAND_GPIO_READY, "NAND RDY"); 
     142        if (ret) { 
     143                dev_err(&pdev->dev, "unable to request gpio %d\n", 
     144                        RB4XX_NAND_GPIO_READY); 
     145                goto err; 
     146        } 
     147 
     148        ret = gpio_direction_input(RB4XX_NAND_GPIO_READY); 
     149        if (ret) { 
     150                dev_err(&pdev->dev, "unable to set input mode on gpio %d\n", 
     151                        RB4XX_NAND_GPIO_READY); 
     152                goto err_free_gpio_ready; 
     153        } 
     154 
     155        ret = gpio_request(RB4XX_NAND_GPIO_ALE, "NAND ALE"); 
     156        if (ret) { 
     157                dev_err(&pdev->dev, "unable to request gpio %d\n", 
     158                        RB4XX_NAND_GPIO_ALE); 
     159                goto err_free_gpio_ready; 
     160        } 
     161 
     162        ret = gpio_direction_output(RB4XX_NAND_GPIO_ALE, 0); 
     163        if (ret) { 
     164                dev_err(&pdev->dev, "unable to set output mode on gpio %d\n", 
     165                        RB4XX_NAND_GPIO_ALE); 
     166                goto err_free_gpio_ale; 
     167        } 
     168 
     169        ret = gpio_request(RB4XX_NAND_GPIO_CLE, "NAND CLE"); 
     170        if (ret) { 
     171                dev_err(&pdev->dev, "unable to request gpio %d\n", 
     172                        RB4XX_NAND_GPIO_CLE); 
     173                goto err_free_gpio_ale; 
     174        } 
     175 
     176        ret = gpio_direction_output(RB4XX_NAND_GPIO_CLE, 0); 
     177        if (ret) { 
     178                dev_err(&pdev->dev, "unable to set output mode on gpio %d\n", 
     179                        RB4XX_NAND_GPIO_CLE); 
     180                goto err_free_gpio_cle; 
     181        } 
     182 
     183        ret = gpio_request(RB4XX_NAND_GPIO_NCE, "NAND NCE"); 
     184        if (ret) { 
     185                dev_err(&pdev->dev, "unable to request gpio %d\n", 
     186                        RB4XX_NAND_GPIO_NCE); 
     187                goto err_free_gpio_cle; 
     188        } 
     189 
     190        ret = gpio_direction_output(RB4XX_NAND_GPIO_NCE, 1); 
     191        if (ret) { 
     192                dev_err(&pdev->dev, "unable to set output mode on gpio %d\n", 
     193                        RB4XX_NAND_GPIO_ALE); 
     194                goto err_free_gpio_nce; 
    401195        } 
    402196 
    403197        info = kzalloc(sizeof(*info), GFP_KERNEL); 
    404198        if (!info) { 
    405                 printk(KERN_ERR "rb4xx-nand: no memory for private data\n"); 
     199                dev_err(&pdev->dev, "rb4xx-nand: no memory for private data\n"); 
    406200                ret = -ENOMEM; 
    407                 goto err_free_gpio; 
    408         } 
    409  
    410 #if USE_FAST_READ 
    411         spi_ctrl_fread = get_spi_ctrl(RB4XX_NAND_HZ, "NAND"); 
    412 #endif 
    413         spi_ctrl_flash = get_spi_ctrl(RB4XX_FLASH_HZ, "FLASH"); 
    414  
    415         rb4xx_nand_write_cfg(CFG_BIT_nLEDS | CFG_BIT_nCE); 
     201                goto err_free_gpio_nce; 
     202        } 
    416203 
    417204        info->chip.priv = &info; 
     
    424211        info->chip.write_buf    = rb4xx_nand_write_buf; 
    425212        info->chip.read_buf     = rb4xx_nand_read_buf; 
    426         info->chip.verify_buf   = rb4xx_nand_verify_buf; 
     213//      info->chip.verify_buf   = rb4xx_nand_verify_buf; 
    427214 
    428215        info->chip.chip_delay   = 25; 
     
    458245        return 0; 
    459246 
    460 err_release_nand: 
     247 err_release_nand: 
    461248        nand_release(&info->mtd); 
    462 err_set_drvdata: 
     249 err_set_drvdata: 
    463250        platform_set_drvdata(pdev, NULL); 
    464 err_free_info: 
     251 err_free_info: 
    465252        kfree(info); 
    466 err_free_gpio: 
    467         gpio_free(RB4XX_NAND_GPIO_RDY); 
     253 err_free_gpio_nce: 
     254        gpio_free(RB4XX_NAND_GPIO_NCE); 
     255 err_free_gpio_cle: 
     256        gpio_free(RB4XX_NAND_GPIO_CLE); 
     257 err_free_gpio_ale: 
     258        gpio_free(RB4XX_NAND_GPIO_ALE); 
     259 err_free_gpio_ready: 
     260        gpio_free(RB4XX_NAND_GPIO_READY); 
     261 err: 
    468262        return ret; 
    469263} 
     
    476270        platform_set_drvdata(pdev, NULL); 
    477271        kfree(info); 
     272        gpio_free(RB4XX_NAND_GPIO_NCE); 
     273        gpio_free(RB4XX_NAND_GPIO_CLE); 
     274        gpio_free(RB4XX_NAND_GPIO_ALE); 
     275        gpio_free(RB4XX_NAND_GPIO_READY); 
    478276 
    479277        return 0; 
Note: See TracChangeset for help on using the changeset viewer.