drivers/mtd/devices/st_spi_fsm.c

   1 /*
   2  * st_spi_fsm.c - ST Fast Sequence Mode (FSM) Serial Flash Controller
   3  *
   4  * Author: Angus Clark <angus.clark@st.com>
   5  *
   6  * Copyright (C) 2010-2014 STicroelectronics Limited
   7  *
   8  * JEDEC probe based on drivers/mtd/devices/m25p80.c
   9  *
  10  * This code is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  *
  14  */
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/mtd/mtd.h>
  19 #include <linux/sched.h>
  20 #include <linux/delay.h>
  21 #include <linux/io.h>
  22 #include <linux/of.h>
  23
  24 /*
  25  * FSM SPI Controller Registers
  26  */
  27 #define SPI_CLOCKDIV                    0x0010
  28 #define SPI_MODESELECT                  0x0018
  29 #define SPI_CONFIGDATA                  0x0020
  30 #define SPI_STA_MODE_CHANGE             0x0028
  31 #define SPI_FAST_SEQ_TRANSFER_SIZE      0x0100
  32 #define SPI_FAST_SEQ_ADD1               0x0104
  33 #define SPI_FAST_SEQ_ADD2               0x0108
  34 #define SPI_FAST_SEQ_ADD_CFG            0x010c
  35 #define SPI_FAST_SEQ_OPC1               0x0110
  36 #define SPI_FAST_SEQ_OPC2               0x0114
  37 #define SPI_FAST_SEQ_OPC3               0x0118
  38 #define SPI_FAST_SEQ_OPC4               0x011c
  39 #define SPI_FAST_SEQ_OPC5               0x0120
  40 #define SPI_MODE_BITS                   0x0124
  41 #define SPI_DUMMY_BITS                  0x0128
  42 #define SPI_FAST_SEQ_FLASH_STA_DATA     0x012c
  43 #define SPI_FAST_SEQ_1                  0x0130
  44 #define SPI_FAST_SEQ_2                  0x0134
  45 #define SPI_FAST_SEQ_3                  0x0138
  46 #define SPI_FAST_SEQ_4                  0x013c
  47 #define SPI_FAST_SEQ_CFG                0x0140
  48 #define SPI_FAST_SEQ_STA                0x0144
  49 #define SPI_QUAD_BOOT_SEQ_INIT_1        0x0148
  50 #define SPI_QUAD_BOOT_SEQ_INIT_2        0x014c
  51 #define SPI_QUAD_BOOT_READ_SEQ_1        0x0150
  52 #define SPI_QUAD_BOOT_READ_SEQ_2        0x0154
  53 #define SPI_PROGRAM_ERASE_TIME          0x0158
  54 #define SPI_MULT_PAGE_REPEAT_SEQ_1      0x015c
  55 #define SPI_MULT_PAGE_REPEAT_SEQ_2      0x0160
  56 #define SPI_STATUS_WR_TIME_REG          0x0164
  57 #define SPI_FAST_SEQ_DATA_REG           0x0300
  58
  59 /*
  60  * Register: SPI_MODESELECT
  61  */
  62 #define SPI_MODESELECT_CONTIG           0x01
  63 #define SPI_MODESELECT_FASTREAD         0x02
  64 #define SPI_MODESELECT_DUALIO           0x04
  65 #define SPI_MODESELECT_FSM              0x08
  66 #define SPI_MODESELECT_QUADBOOT         0x10
  67
  68 /*
  69  * Register: SPI_CONFIGDATA
  70  */
  71 #define SPI_CFG_DEVICE_ST               0x1
  72 #define SPI_CFG_DEVICE_ATMEL            0x4
  73 #define SPI_CFG_MIN_CS_HIGH(x)          (((x) & 0xfff) << 4)
  74 #define SPI_CFG_CS_SETUPHOLD(x)         (((x) & 0xff) << 16)
  75 #define SPI_CFG_DATA_HOLD(x)            (((x) & 0xff) << 24)
  76
  77 #define SPI_CFG_DEFAULT_MIN_CS_HIGH    SPI_CFG_MIN_CS_HIGH(0x0AA)
  78 #define SPI_CFG_DEFAULT_CS_SETUPHOLD   SPI_CFG_CS_SETUPHOLD(0xA0)
  79 #define SPI_CFG_DEFAULT_DATA_HOLD      SPI_CFG_DATA_HOLD(0x00)
  80
  81 /*
  82  * Register: SPI_FAST_SEQ_TRANSFER_SIZE
  83  */
  84 #define TRANSFER_SIZE(x)                ((x) * 8)
  85
  86 /*
  87  * Register: SPI_FAST_SEQ_ADD_CFG
  88  */
  89 #define ADR_CFG_CYCLES_ADD1(x)          ((x) << 0)
  90 #define ADR_CFG_PADS_1_ADD1             (0x0 << 6)
  91 #define ADR_CFG_PADS_2_ADD1             (0x1 << 6)
  92 #define ADR_CFG_PADS_4_ADD1             (0x3 << 6)
  93 #define ADR_CFG_CSDEASSERT_ADD1         (1   << 8)
  94 #define ADR_CFG_CYCLES_ADD2(x)          ((x) << (0+16))
  95 #define ADR_CFG_PADS_1_ADD2             (0x0 << (6+16))
  96 #define ADR_CFG_PADS_2_ADD2             (0x1 << (6+16))
  97 #define ADR_CFG_PADS_4_ADD2             (0x3 << (6+16))
  98 #define ADR_CFG_CSDEASSERT_ADD2         (1   << (8+16))
  99
 100 /*
 101  * Register: SPI_FAST_SEQ_n
 102  */
 103 #define SEQ_OPC_OPCODE(x)               ((x) << 0)
 104 #define SEQ_OPC_CYCLES(x)               ((x) << 8)
 105 #define SEQ_OPC_PADS_1                  (0x0 << 14)
 106 #define SEQ_OPC_PADS_2                  (0x1 << 14)
 107 #define SEQ_OPC_PADS_4                  (0x3 << 14)
 108 #define SEQ_OPC_CSDEASSERT              (1   << 16)
 109
 110 /*
 111  * Register: SPI_FAST_SEQ_CFG
 112  */
 113 #define SEQ_CFG_STARTSEQ                (1 << 0)
 114 #define SEQ_CFG_SWRESET                 (1 << 5)
 115 #define SEQ_CFG_CSDEASSERT              (1 << 6)
 116 #define SEQ_CFG_READNOTWRITE            (1 << 7)
 117 #define SEQ_CFG_ERASE                   (1 << 8)
 118 #define SEQ_CFG_PADS_1                  (0x0 << 16)
 119 #define SEQ_CFG_PADS_2                  (0x1 << 16)
 120 #define SEQ_CFG_PADS_4                  (0x3 << 16)
 121
 122 /*
 123  * Register: SPI_MODE_BITS
 124  */
 125 #define MODE_DATA(x)                    (x & 0xff)
 126 #define MODE_CYCLES(x)                  ((x & 0x3f) << 16)
 127 #define MODE_PADS_1                     (0x0 << 22)
 128 #define MODE_PADS_2                     (0x1 << 22)
 129 #define MODE_PADS_4                     (0x3 << 22)
 130 #define DUMMY_CSDEASSERT                (1   << 24)
 131
 132 /*
 133  * Register: SPI_DUMMY_BITS
 134  */
 135 #define DUMMY_CYCLES(x)                 ((x & 0x3f) << 16)
 136 #define DUMMY_PADS_1                    (0x0 << 22)
 137 #define DUMMY_PADS_2                    (0x1 << 22)
 138 #define DUMMY_PADS_4                    (0x3 << 22)
 139 #define DUMMY_CSDEASSERT                (1   << 24)
 140
 141 /*
 142  * Register: SPI_FAST_SEQ_FLASH_STA_DATA
 143  */
 144 #define STA_DATA_BYTE1(x)               ((x & 0xff) << 0)
 145 #define STA_DATA_BYTE2(x)               ((x & 0xff) << 8)
 146 #define STA_PADS_1                      (0x0 << 16)
 147 #define STA_PADS_2                      (0x1 << 16)
 148 #define STA_PADS_4                      (0x3 << 16)
 149 #define STA_CSDEASSERT                  (0x1 << 20)
 150 #define STA_RDNOTWR                     (0x1 << 21)
 151
 152 /*
 153  * FSM SPI Instruction Opcodes
 154  */
 155 #define STFSM_OPC_CMD                   0x1
 156 #define STFSM_OPC_ADD                   0x2
 157 #define STFSM_OPC_STA                   0x3
 158 #define STFSM_OPC_MODE                  0x4
 159 #define STFSM_OPC_DUMMY         0x5
 160 #define STFSM_OPC_DATA                  0x6
 161 #define STFSM_OPC_WAIT                  0x7
 162 #define STFSM_OPC_JUMP                  0x8
 163 #define STFSM_OPC_GOTO                  0x9
 164 #define STFSM_OPC_STOP                  0xF
 165
 166 /*
 167  * FSM SPI Instructions (== opcode + operand).
 168  */
 169 #define STFSM_INSTR(cmd, op)            ((cmd) | ((op) << 4))
 170
 171 #define STFSM_INST_CMD1                 STFSM_INSTR(STFSM_OPC_CMD,      1)
 172 #define STFSM_INST_CMD2                 STFSM_INSTR(STFSM_OPC_CMD,      2)
 173 #define STFSM_INST_CMD3                 STFSM_INSTR(STFSM_OPC_CMD,      3)
 174 #define STFSM_INST_CMD4                 STFSM_INSTR(STFSM_OPC_CMD,      4)
 175 #define STFSM_INST_CMD5                 STFSM_INSTR(STFSM_OPC_CMD,      5)
 176 #define STFSM_INST_ADD1                 STFSM_INSTR(STFSM_OPC_ADD,      1)
 177 #define STFSM_INST_ADD2                 STFSM_INSTR(STFSM_OPC_ADD,      2)
 178
 179 #define STFSM_INST_DATA_WRITE           STFSM_INSTR(STFSM_OPC_DATA,     1)
 180 #define STFSM_INST_DATA_READ            STFSM_INSTR(STFSM_OPC_DATA,     2)
 181
 182 #define STFSM_INST_STA_RD1              STFSM_INSTR(STFSM_OPC_STA,      0x1)
 183 #define STFSM_INST_STA_WR1              STFSM_INSTR(STFSM_OPC_STA,      0x1)
 184 #define STFSM_INST_STA_RD2              STFSM_INSTR(STFSM_OPC_STA,      0x2)
 185 #define STFSM_INST_STA_WR1_2            STFSM_INSTR(STFSM_OPC_STA,      0x3)
 186
 187 #define STFSM_INST_MODE                 STFSM_INSTR(STFSM_OPC_MODE,     0)
 188 #define STFSM_INST_DUMMY                STFSM_INSTR(STFSM_OPC_DUMMY,    0)
 189 #define STFSM_INST_WAIT                 STFSM_INSTR(STFSM_OPC_WAIT,     0)
 190 #define STFSM_INST_STOP                 STFSM_INSTR(STFSM_OPC_STOP,     0)
 191
 192 #define STFSM_DEFAULT_EMI_FREQ 100000000UL                        /* 100 MHz */
 193 #define STFSM_DEFAULT_WR_TIME  (STFSM_DEFAULT_EMI_FREQ * (15/1000)) /* 15ms */
 194
 195 #define STFSM_FLASH_SAFE_FREQ  10000000UL                         /* 10 MHz */
 196
 197 #define STFSM_MAX_WAIT_SEQ_MS  1000     /* FSM execution time */
 198
 199 struct stfsm {
 200         struct device           *dev;
 201         void __iomem            *base;
 202         struct resource         *region;
 203         struct mtd_info         mtd;
 204         struct mutex            lock;
 205
 206         uint32_t                fifo_dir_delay;
 207 };
 208
 209 struct stfsm_seq {
 210         uint32_t data_size;
 211         uint32_t addr1;
 212         uint32_t addr2;
 213         uint32_t addr_cfg;
 214         uint32_t seq_opc[5];
 215         uint32_t mode;
 216         uint32_t dummy;
 217         uint32_t status;
 218         uint8_t  seq[16];
 219         uint32_t seq_cfg;
 220 } __packed __aligned(4);
 221
 222 static inline int stfsm_is_idle(struct stfsm *fsm)
 223 {
 224         return readl(fsm->base + SPI_FAST_SEQ_STA) & 0x10;
 225 }
 226
 227 static inline uint32_t stfsm_fifo_available(struct stfsm *fsm)
 228 {
 229         return (readl(fsm->base + SPI_FAST_SEQ_STA) >> 5) & 0x7f;
 230 }
 231
 232 static void stfsm_clear_fifo(struct stfsm *fsm)
 233 {
 234         uint32_t avail;
 235
 236         for (;;) {
 237                 avail = stfsm_fifo_available(fsm);
 238                 if (!avail)
 239                         break;
 240
 241                 while (avail) {
 242                         readl(fsm->base + SPI_FAST_SEQ_DATA_REG);
 243                         avail--;
 244                 }
 245         }
 246 }
 247
 248 static inline void stfsm_load_seq(struct stfsm *fsm,
 249                                   const struct stfsm_seq *seq)
 250 {
 251         void __iomem *dst = fsm->base + SPI_FAST_SEQ_TRANSFER_SIZE;
 252         const uint32_t *src = (const uint32_t *)seq;
 253         int words = sizeof(*seq) / sizeof(*src);
 254
 255         BUG_ON(!stfsm_is_idle(fsm));
 256
 257         while (words--) {
 258                 writel(*src, dst);
 259                 src++;
 260                 dst += 4;
 261         }
 262 }
 263
 264 static void stfsm_wait_seq(struct stfsm *fsm)
 265 {
 266         unsigned long deadline;
 267         int timeout = 0;
 268
 269         deadline = jiffies + msecs_to_jiffies(STFSM_MAX_WAIT_SEQ_MS);
 270
 271         while (!timeout) {
 272                 if (time_after_eq(jiffies, deadline))
 273                         timeout = 1;
 274
 275                 if (stfsm_is_idle(fsm))
 276                         return;
 277
 278                 cond_resched();
 279         }
 280
 281         dev_err(fsm->dev, "timeout on sequence completion\n");
 282 }
 283
 284 static void stfsm_read_fifo(struct stfsm *fsm, uint32_t *buf,
 285                             const uint32_t size)
 286 {
 287         uint32_t remaining = size >> 2;
 288         uint32_t avail;
 289         uint32_t words;
 290
 291         dev_dbg(fsm->dev, "Reading %d bytes from FIFO\n", size);
 292
 293         BUG_ON((((uint32_t)buf) & 0x3) || (size & 0x3));
 294
 295         while (remaining) {
 296                 for (;;) {
 297                         avail = stfsm_fifo_available(fsm);
 298                         if (avail)
 299                                 break;
 300                         udelay(1);
 301                 }
 302                 words = min(avail, remaining);
 303                 remaining -= words;
 304
 305                 readsl(fsm->base + SPI_FAST_SEQ_DATA_REG, buf, words);
 306                 buf += words;
 307         }
 308 }
 309
 310 static int stfsm_set_mode(struct stfsm *fsm, uint32_t mode)
 311 {
 312         int ret, timeout = 10;
 313
 314         /* Wait for controller to accept mode change */
 315         while (--timeout) {
 316                 ret = readl(fsm->base + SPI_STA_MODE_CHANGE);
 317                 if (ret & 0x1)
 318                         break;
 319                 udelay(1);
 320         }
 321
 322         if (!timeout)
 323                 return -EBUSY;
 324
 325         writel(mode, fsm->base + SPI_MODESELECT);
 326
 327         return 0;
 328 }
 329
 330 static void stfsm_set_freq(struct stfsm *fsm, uint32_t spi_freq)
 331 {
 332         uint32_t emi_freq;
 333         uint32_t clk_div;
 334
 335         /* TODO: Make this dynamic */
 336         emi_freq = STFSM_DEFAULT_EMI_FREQ;
 337
 338         /*
 339          * Calculate clk_div - values between 2 and 128
 340          * Multiple of 2, rounded up
 341          */
 342         clk_div = 2 * DIV_ROUND_UP(emi_freq, 2 * spi_freq);
 343         if (clk_div < 2)
 344                 clk_div = 2;
 345         else if (clk_div > 128)
 346                 clk_div = 128;
 347
 348         /*
 349          * Determine a suitable delay for the IP to complete a change of
 350          * direction of the FIFO. The required delay is related to the clock
 351          * divider used. The following heuristics are based on empirical tests,
 352          * using a 100MHz EMI clock.
 353          */
 354         if (clk_div <= 4)
 355                 fsm->fifo_dir_delay = 0;
 356         else if (clk_div <= 10)
 357                 fsm->fifo_dir_delay = 1;
 358         else
 359                 fsm->fifo_dir_delay = DIV_ROUND_UP(clk_div, 10);
 360
 361         dev_dbg(fsm->dev, "emi_clk = %uHZ, spi_freq = %uHZ, clk_div = %u\n",
 362                 emi_freq, spi_freq, clk_div);
 363
 364         writel(clk_div, fsm->base + SPI_CLOCKDIV);
 365 }
 366
 367 static int stfsm_init(struct stfsm *fsm)
 368 {
 369         int ret;
 370
 371         /* Perform a soft reset of the FSM controller */
 372         writel(SEQ_CFG_SWRESET, fsm->base + SPI_FAST_SEQ_CFG);
 373         udelay(1);
 374         writel(0, fsm->base + SPI_FAST_SEQ_CFG);
 375
 376         /* Set clock to 'safe' frequency initially */
 377         stfsm_set_freq(fsm, STFSM_FLASH_SAFE_FREQ);
 378
 379         /* Switch to FSM */
 380         ret = stfsm_set_mode(fsm, SPI_MODESELECT_FSM);
 381         if (ret)
 382                 return ret;
 383
 384         /* Set timing parameters */
 385         writel(SPI_CFG_DEVICE_ST            |
 386                SPI_CFG_DEFAULT_MIN_CS_HIGH  |
 387                SPI_CFG_DEFAULT_CS_SETUPHOLD |
 388                SPI_CFG_DEFAULT_DATA_HOLD,
 389                fsm->base + SPI_CONFIGDATA);
 390         writel(STFSM_DEFAULT_WR_TIME, fsm->base + SPI_STATUS_WR_TIME_REG);
 391
 392         /* Clear FIFO, just in case */
 393         stfsm_clear_fifo(fsm);
 394
 395         return 0;
 396 }
 397
 398 static int stfsm_probe(struct platform_device *pdev)
 399 {
 400         struct device_node *np = pdev->dev.of_node;
 401         struct resource *res;
 402         struct stfsm *fsm;
 403         int ret;
 404
 405         if (!np) {
 406                 dev_err(&pdev->dev, "No DT found\n");
 407                 return -EINVAL;
 408         }
 409
 410         fsm = devm_kzalloc(&pdev->dev, sizeof(*fsm), GFP_KERNEL);
 411         if (!fsm)
 412                 return -ENOMEM;
 413
 414         fsm->dev = &pdev->dev;
 415
 416         platform_set_drvdata(pdev, fsm);
 417
 418         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 419         if (!res) {
 420                 dev_err(&pdev->dev, "Resource not found\n");
 421                 return -ENODEV;
 422         }
 423
 424         fsm->base = devm_ioremap_resource(&pdev->dev, res);
 425         if (IS_ERR(fsm->base)) {
 426                 dev_err(&pdev->dev,
 427                         "Failed to reserve memory region %pR\n", res);
 428                 return PTR_ERR(fsm->base);
 429         }
 430
 431         mutex_init(&fsm->lock);
 432
 433         ret = stfsm_init(fsm);
 434         if (ret) {
 435                 dev_err(&pdev->dev, "Failed to initialise FSM Controller\n");
 436                 return ret;
 437         }
 438
 439         fsm->mtd.dev.parent     = &pdev->dev;
 440         fsm->mtd.type           = MTD_NORFLASH;
 441         fsm->mtd.writesize      = 4;
 442         fsm->mtd.writebufsize   = fsm->mtd.writesize;
 443         fsm->mtd.flags          = MTD_CAP_NORFLASH;
 444
 445         return mtd_device_parse_register(&fsm->mtd, NULL, NULL, NULL, 0);
 446 }
 447
 448 static int stfsm_remove(struct platform_device *pdev)
 449 {
 450         struct stfsm *fsm = platform_get_drvdata(pdev);
 451         int err;
 452
 453         err = mtd_device_unregister(&fsm->mtd);
 454         if (err)
 455                 return err;
 456
 457         return 0;
 458 }
 459
 460 static struct of_device_id stfsm_match[] = {
 461         { .compatible = "st,spi-fsm", },
 462         {},
 463 };
 464 MODULE_DEVICE_TABLE(of, stfsm_match);
 465
 466 static struct platform_driver stfsm_driver = {
 467         .probe          = stfsm_probe,
 468         .remove         = stfsm_remove,
 469         .driver         = {
 470                 .name   = "st-spi-fsm",
 471                 .owner  = THIS_MODULE,
 472                 .of_match_table = stfsm_match,
 473         },
 474 };
 475 module_platform_driver(stfsm_driver);
 476
 477 MODULE_AUTHOR("Angus Clark <angus.clark@st.com>");
 478 MODULE_DESCRIPTION("ST SPI FSM driver");
 479 MODULE_LICENSE("GPL");