drivers/mtd/nand/raw/nuc900_nand.c

   1 /*
   2  * Copyright © 2009 Nuvoton technology corporation.
   3  *
   4  * Wan ZongShun <[email protected]>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation;version 2 of the License.
   9  *
  10  */
  11
  12 #include <linux/slab.h>
  13 #include <linux/module.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/io.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/delay.h>
  18 #include <linux/clk.h>
  19 #include <linux/err.h>
  20
  21 #include <linux/mtd/mtd.h>
  22 #include <linux/mtd/rawnand.h>
  23 #include <linux/mtd/partitions.h>
  24
  25 #define REG_FMICSR      0x00
  26 #define REG_SMCSR       0xa0
  27 #define REG_SMISR       0xac
  28 #define REG_SMCMD       0xb0
  29 #define REG_SMADDR      0xb4
  30 #define REG_SMDATA      0xb8
  31
  32 #define RESET_FMI       0x01
  33 #define NAND_EN         0x08
  34 #define READYBUSY       (0x01 << 18)
  35
  36 #define SWRST           0x01
  37 #define PSIZE           (0x01 << 3)
  38 #define DMARWEN         (0x03 << 1)
  39 #define BUSWID          (0x01 << 4)
  40 #define ECC4EN          (0x01 << 5)
  41 #define WP              (0x01 << 24)
  42 #define NANDCS          (0x01 << 25)
  43 #define ENDADDR         (0x01 << 31)
  44
  45 #define read_data_reg(dev)              \
  46         __raw_readl((dev)->reg + REG_SMDATA)
  47
  48 #define write_data_reg(dev, val)        \
  49         __raw_writel((val), (dev)->reg + REG_SMDATA)
  50
  51 #define write_cmd_reg(dev, val)         \
  52         __raw_writel((val), (dev)->reg + REG_SMCMD)
  53
  54 #define write_addr_reg(dev, val)        \
  55         __raw_writel((val), (dev)->reg + REG_SMADDR)
  56
  57 struct nuc900_nand {
  58         struct nand_chip chip;
  59         void __iomem *reg;
  60         struct clk *clk;
  61         spinlock_t lock;
  62 };
  63
  64 static inline struct nuc900_nand *mtd_to_nuc900(struct mtd_info *mtd)
  65 {
  66         return container_of(mtd_to_nand(mtd), struct nuc900_nand, chip);
  67 }
  68
  69 static const struct mtd_partition partitions[] = {
  70         {
  71          .name = "NAND FS 0",
  72          .offset = 0,
  73          .size = 8 * 1024 * 1024
  74         },
  75         {
  76          .name = "NAND FS 1",
  77          .offset = MTDPART_OFS_APPEND,
  78          .size = MTDPART_SIZ_FULL
  79         }
  80 };
  81
  82 static unsigned char nuc900_nand_read_byte(struct nand_chip *chip)
  83 {
  84         unsigned char ret;
  85         struct nuc900_nand *nand = mtd_to_nuc900(nand_to_mtd(chip));
  86
  87         ret = (unsigned char)read_data_reg(nand);
  88
  89         return ret;
  90 }
  91
  92 static void nuc900_nand_read_buf(struct nand_chip *chip,
  93                                  unsigned char *buf, int len)
  94 {
  95         int i;
  96         struct nuc900_nand *nand = mtd_to_nuc900(nand_to_mtd(chip));
  97
  98         for (i = 0; i < len; i++)
  99                 buf[i] = (unsigned char)read_data_reg(nand);
 100 }
 101
 102 static void nuc900_nand_write_buf(struct nand_chip *chip,
 103                                   const unsigned char *buf, int len)
 104 {
 105         int i;
 106         struct nuc900_nand *nand = mtd_to_nuc900(nand_to_mtd(chip));
 107
 108         for (i = 0; i < len; i++)
 109                 write_data_reg(nand, buf[i]);
 110 }
 111
 112 static int nuc900_check_rb(struct nuc900_nand *nand)
 113 {
 114         unsigned int val;
 115         spin_lock(&nand->lock);
 116         val = __raw_readl(nand->reg + REG_SMISR);
 117         val &= READYBUSY;
 118         spin_unlock(&nand->lock);
 119
 120         return val;
 121 }
 122
 123 static int nuc900_nand_devready(struct nand_chip *chip)
 124 {
 125         struct nuc900_nand *nand = mtd_to_nuc900(nand_to_mtd(chip));
 126         int ready;
 127
 128         ready = (nuc900_check_rb(nand)) ? 1 : 0;
 129         return ready;
 130 }
 131
 132 static void nuc900_nand_command_lp(struct nand_chip *chip,
 133                                    unsigned int command,
 134                                    int column, int page_addr)
 135 {
 136         struct mtd_info *mtd = nand_to_mtd(chip);
 137         struct nuc900_nand *nand = mtd_to_nuc900(mtd);
 138
 139         if (command == NAND_CMD_READOOB) {
 140                 column += mtd->writesize;
 141                 command = NAND_CMD_READ0;
 142         }
 143
 144         write_cmd_reg(nand, command & 0xff);
 145
 146         if (column != -1 || page_addr != -1) {
 147
 148                 if (column != -1) {
 149                         if (chip->options & NAND_BUSWIDTH_16 &&
 150                                         !nand_opcode_8bits(command))
 151                                 column >>= 1;
 152                         write_addr_reg(nand, column);
 153                         write_addr_reg(nand, column >> 8 | ENDADDR);
 154                 }
 155                 if (page_addr != -1) {
 156                         write_addr_reg(nand, page_addr);
 157
 158                         if (chip->options & NAND_ROW_ADDR_3) {
 159                                 write_addr_reg(nand, page_addr >> 8);
 160                                 write_addr_reg(nand, page_addr >> 16 | ENDADDR);
 161                         } else {
 162                                 write_addr_reg(nand, page_addr >> 8 | ENDADDR);
 163                         }
 164                 }
 165         }
 166
 167         switch (command) {
 168         case NAND_CMD_CACHEDPROG:
 169         case NAND_CMD_PAGEPROG:
 170         case NAND_CMD_ERASE1:
 171         case NAND_CMD_ERASE2:
 172         case NAND_CMD_SEQIN:
 173         case NAND_CMD_RNDIN:
 174         case NAND_CMD_STATUS:
 175                 return;
 176
 177         case NAND_CMD_RESET:
 178                 if (chip->legacy.dev_ready)
 179                         break;
 180                 udelay(chip->legacy.chip_delay);
 181
 182                 write_cmd_reg(nand, NAND_CMD_STATUS);
 183                 write_cmd_reg(nand, command);
 184
 185                 while (!nuc900_check_rb(nand))
 186                         ;
 187
 188                 return;
 189
 190         case NAND_CMD_RNDOUT:
 191                 write_cmd_reg(nand, NAND_CMD_RNDOUTSTART);
 192                 return;
 193
 194         case NAND_CMD_READ0:
 195                 write_cmd_reg(nand, NAND_CMD_READSTART);
 196                 /* fall through */
 197
 198         default:
 199
 200                 if (!chip->legacy.dev_ready) {
 201                         udelay(chip->legacy.chip_delay);
 202                         return;
 203                 }
 204         }
 205
 206         /* Apply this short delay always to ensure that we do wait tWB in
 207          * any case on any machine. */
 208         ndelay(100);
 209
 210         while (!chip->legacy.dev_ready(chip))
 211                 ;
 212 }
 213
 214
 215 static void nuc900_nand_enable(struct nuc900_nand *nand)
 216 {
 217         unsigned int val;
 218         spin_lock(&nand->lock);
 219         __raw_writel(RESET_FMI, (nand->reg + REG_FMICSR));
 220
 221         val = __raw_readl(nand->reg + REG_FMICSR);
 222
 223         if (!(val & NAND_EN))
 224                 __raw_writel(val | NAND_EN, nand->reg + REG_FMICSR);
 225
 226         val = __raw_readl(nand->reg + REG_SMCSR);
 227
 228         val &= ~(SWRST|PSIZE|DMARWEN|BUSWID|ECC4EN|NANDCS);
 229         val |= WP;
 230
 231         __raw_writel(val, nand->reg + REG_SMCSR);
 232
 233         spin_unlock(&nand->lock);
 234 }
 235
 236 static int nuc900_nand_probe(struct platform_device *pdev)
 237 {
 238         struct nuc900_nand *nuc900_nand;
 239         struct nand_chip *chip;
 240         struct mtd_info *mtd;
 241         struct resource *res;
 242
 243         nuc900_nand = devm_kzalloc(&pdev->dev, sizeof(struct nuc900_nand),
 244                                    GFP_KERNEL);
 245         if (!nuc900_nand)
 246                 return -ENOMEM;
 247         chip = &(nuc900_nand->chip);
 248         mtd = nand_to_mtd(chip);
 249
 250         mtd->dev.parent         = &pdev->dev;
 251         spin_lock_init(&nuc900_nand->lock);
 252
 253         nuc900_nand->clk = devm_clk_get(&pdev->dev, NULL);
 254         if (IS_ERR(nuc900_nand->clk))
 255                 return -ENOENT;
 256         clk_enable(nuc900_nand->clk);
 257
 258         chip->legacy.cmdfunc    = nuc900_nand_command_lp;
 259         chip->legacy.dev_ready  = nuc900_nand_devready;
 260         chip->legacy.read_byte  = nuc900_nand_read_byte;
 261         chip->legacy.write_buf  = nuc900_nand_write_buf;
 262         chip->legacy.read_buf   = nuc900_nand_read_buf;
 263         chip->legacy.chip_delay = 50;
 264         chip->options           = 0;
 265         chip->ecc.mode          = NAND_ECC_SOFT;
 266         chip->ecc.algo          = NAND_ECC_HAMMING;
 267
 268         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 269         nuc900_nand->reg = devm_ioremap_resource(&pdev->dev, res);
 270         if (IS_ERR(nuc900_nand->reg))
 271                 return PTR_ERR(nuc900_nand->reg);
 272
 273         nuc900_nand_enable(nuc900_nand);
 274
 275         if (nand_scan(chip, 1))
 276                 return -ENXIO;
 277
 278         mtd_device_register(mtd, partitions, ARRAY_SIZE(partitions));
 279
 280         platform_set_drvdata(pdev, nuc900_nand);
 281
 282         return 0;
 283 }
 284
 285 static int nuc900_nand_remove(struct platform_device *pdev)
 286 {
 287         struct nuc900_nand *nuc900_nand = platform_get_drvdata(pdev);
 288
 289         nand_release(&nuc900_nand->chip);
 290         clk_disable(nuc900_nand->clk);
 291
 292         return 0;
 293 }
 294
 295 static struct platform_driver nuc900_nand_driver = {
 296         .probe          = nuc900_nand_probe,
 297         .remove         = nuc900_nand_remove,
 298         .driver         = {
 299                 .name   = "nuc900-fmi",
 300         },
 301 };
 302
 303 module_platform_driver(nuc900_nand_driver);
 304
 305 MODULE_AUTHOR("Wan ZongShun <[email protected]>");
 306 MODULE_DESCRIPTION("w90p910/NUC9xx nand driver!");
 307 MODULE_LICENSE("GPL");
 308 MODULE_ALIAS("platform:nuc900-fmi");