drivers/mtd/spi-nor/stm32-quadspi.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for stm32 quadspi controller
   4  *
   5  * Copyright (C) 2017, STMicroelectronics - All Rights Reserved
   6  * Author(s): Ludovic Barre author <ludovic.barre@st.com>.
   7  */
   8 #include <linux/clk.h>
   9 #include <linux/errno.h>
  10 #include <linux/io.h>
  11 #include <linux/iopoll.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/module.h>
  14 #include <linux/mtd/mtd.h>
  15 #include <linux/mtd/partitions.h>
  16 #include <linux/mtd/spi-nor.h>
  17 #include <linux/mutex.h>
  18 #include <linux/of.h>
  19 #include <linux/of_device.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/reset.h>
  22 #include <linux/sizes.h>
  23
  24 #define QUADSPI_CR              0x00
  25 #define CR_EN                   BIT(0)
  26 #define CR_ABORT                BIT(1)
  27 #define CR_DMAEN                BIT(2)
  28 #define CR_TCEN                 BIT(3)
  29 #define CR_SSHIFT               BIT(4)
  30 #define CR_DFM                  BIT(6)
  31 #define CR_FSEL                 BIT(7)
  32 #define CR_FTHRES_SHIFT         8
  33 #define CR_FTHRES_MASK          GENMASK(12, 8)
  34 #define CR_FTHRES(n)            (((n) << CR_FTHRES_SHIFT) & CR_FTHRES_MASK)
  35 #define CR_TEIE                 BIT(16)
  36 #define CR_TCIE                 BIT(17)
  37 #define CR_FTIE                 BIT(18)
  38 #define CR_SMIE                 BIT(19)
  39 #define CR_TOIE                 BIT(20)
  40 #define CR_PRESC_SHIFT          24
  41 #define CR_PRESC_MASK           GENMASK(31, 24)
  42 #define CR_PRESC(n)             (((n) << CR_PRESC_SHIFT) & CR_PRESC_MASK)
  43
  44 #define QUADSPI_DCR             0x04
  45 #define DCR_CSHT_SHIFT          8
  46 #define DCR_CSHT_MASK           GENMASK(10, 8)
  47 #define DCR_CSHT(n)             (((n) << DCR_CSHT_SHIFT) & DCR_CSHT_MASK)
  48 #define DCR_FSIZE_SHIFT         16
  49 #define DCR_FSIZE_MASK          GENMASK(20, 16)
  50 #define DCR_FSIZE(n)            (((n) << DCR_FSIZE_SHIFT) & DCR_FSIZE_MASK)
  51
  52 #define QUADSPI_SR              0x08
  53 #define SR_TEF                  BIT(0)
  54 #define SR_TCF                  BIT(1)
  55 #define SR_FTF                  BIT(2)
  56 #define SR_SMF                  BIT(3)
  57 #define SR_TOF                  BIT(4)
  58 #define SR_BUSY                 BIT(5)
  59 #define SR_FLEVEL_SHIFT         8
  60 #define SR_FLEVEL_MASK          GENMASK(13, 8)
  61
  62 #define QUADSPI_FCR             0x0c
  63 #define FCR_CTCF                BIT(1)
  64
  65 #define QUADSPI_DLR             0x10
  66
  67 #define QUADSPI_CCR             0x14
  68 #define CCR_INST_SHIFT          0
  69 #define CCR_INST_MASK           GENMASK(7, 0)
  70 #define CCR_INST(n)             (((n) << CCR_INST_SHIFT) & CCR_INST_MASK)
  71 #define CCR_IMODE_NONE          (0U << 8)
  72 #define CCR_IMODE_1             (1U << 8)
  73 #define CCR_IMODE_2             (2U << 8)
  74 #define CCR_IMODE_4             (3U << 8)
  75 #define CCR_ADMODE_NONE         (0U << 10)
  76 #define CCR_ADMODE_1            (1U << 10)
  77 #define CCR_ADMODE_2            (2U << 10)
  78 #define CCR_ADMODE_4            (3U << 10)
  79 #define CCR_ADSIZE_SHIFT        12
  80 #define CCR_ADSIZE_MASK         GENMASK(13, 12)
  81 #define CCR_ADSIZE(n)           (((n) << CCR_ADSIZE_SHIFT) & CCR_ADSIZE_MASK)
  82 #define CCR_ABMODE_NONE         (0U << 14)
  83 #define CCR_ABMODE_1            (1U << 14)
  84 #define CCR_ABMODE_2            (2U << 14)
  85 #define CCR_ABMODE_4            (3U << 14)
  86 #define CCR_ABSIZE_8            (0U << 16)
  87 #define CCR_ABSIZE_16           (1U << 16)
  88 #define CCR_ABSIZE_24           (2U << 16)
  89 #define CCR_ABSIZE_32           (3U << 16)
  90 #define CCR_DCYC_SHIFT          18
  91 #define CCR_DCYC_MASK           GENMASK(22, 18)
  92 #define CCR_DCYC(n)             (((n) << CCR_DCYC_SHIFT) & CCR_DCYC_MASK)
  93 #define CCR_DMODE_NONE          (0U << 24)
  94 #define CCR_DMODE_1             (1U << 24)
  95 #define CCR_DMODE_2             (2U << 24)
  96 #define CCR_DMODE_4             (3U << 24)
  97 #define CCR_FMODE_INDW          (0U << 26)
  98 #define CCR_FMODE_INDR          (1U << 26)
  99 #define CCR_FMODE_APM           (2U << 26)
 100 #define CCR_FMODE_MM            (3U << 26)
 101
 102 #define QUADSPI_AR              0x18
 103 #define QUADSPI_ABR             0x1c
 104 #define QUADSPI_DR              0x20
 105 #define QUADSPI_PSMKR           0x24
 106 #define QUADSPI_PSMAR           0x28
 107 #define QUADSPI_PIR             0x2c
 108 #define QUADSPI_LPTR            0x30
 109 #define LPTR_DFT_TIMEOUT        0x10
 110
 111 #define FSIZE_VAL(size)         (__fls(size) - 1)
 112
 113 #define STM32_MAX_MMAP_SZ       SZ_256M
 114 #define STM32_MAX_NORCHIP       2
 115
 116 #define STM32_QSPI_FIFO_SZ      32
 117 #define STM32_QSPI_FIFO_TIMEOUT_US 30000
 118 #define STM32_QSPI_BUSY_TIMEOUT_US 100000
 119
 120 struct stm32_qspi_flash {
 121         struct spi_nor nor;
 122         struct stm32_qspi *qspi;
 123         u32 cs;
 124         u32 fsize;
 125         u32 presc;
 126         u32 read_mode;
 127         bool registered;
 128         u32 prefetch_limit;
 129 };
 130
 131 struct stm32_qspi {
 132         struct device *dev;
 133         void __iomem *io_base;
 134         void __iomem *mm_base;
 135         resource_size_t mm_size;
 136         u32 nor_num;
 137         struct clk *clk;
 138         u32 clk_rate;
 139         struct stm32_qspi_flash flash[STM32_MAX_NORCHIP];
 140         struct completion cmd_completion;
 141
 142         /*
 143          * to protect device configuration, could be different between
 144          * 2 flash access (bk1, bk2)
 145          */
 146         struct mutex lock;
 147 };
 148
 149 struct stm32_qspi_cmd {
 150         u8 addr_width;
 151         u8 dummy;
 152         bool tx_data;
 153         u8 opcode;
 154         u32 framemode;
 155         u32 qspimode;
 156         u32 addr;
 157         size_t len;
 158         void *buf;
 159 };
 160
 161 static int stm32_qspi_wait_cmd(struct stm32_qspi *qspi)
 162 {
 163         u32 cr;
 164         int err = 0;
 165
 166         if (readl_relaxed(qspi->io_base + QUADSPI_SR) & SR_TCF)
 167                 return 0;
 168
 169         reinit_completion(&qspi->cmd_completion);
 170         cr = readl_relaxed(qspi->io_base + QUADSPI_CR);
 171         writel_relaxed(cr | CR_TCIE, qspi->io_base + QUADSPI_CR);
 172
 173         if (!wait_for_completion_interruptible_timeout(&qspi->cmd_completion,
 174                                                        msecs_to_jiffies(1000)))
 175                 err = -ETIMEDOUT;
 176
 177         writel_relaxed(cr, qspi->io_base + QUADSPI_CR);
 178         return err;
 179 }
 180
 181 static int stm32_qspi_wait_nobusy(struct stm32_qspi *qspi)
 182 {
 183         u32 sr;
 184
 185         return readl_relaxed_poll_timeout(qspi->io_base + QUADSPI_SR, sr,
 186                                           !(sr & SR_BUSY), 10,
 187                                           STM32_QSPI_BUSY_TIMEOUT_US);
 188 }
 189
 190 static void stm32_qspi_set_framemode(struct spi_nor *nor,
 191                                      struct stm32_qspi_cmd *cmd, bool read)
 192 {
 193         u32 dmode = CCR_DMODE_1;
 194
 195         cmd->framemode = CCR_IMODE_1;
 196
 197         if (read) {
 198                 switch (nor->read_proto) {
 199                 default:
 200                 case SNOR_PROTO_1_1_1:
 201                         dmode = CCR_DMODE_1;
 202                         break;
 203                 case SNOR_PROTO_1_1_2:
 204                         dmode = CCR_DMODE_2;
 205                         break;
 206                 case SNOR_PROTO_1_1_4:
 207                         dmode = CCR_DMODE_4;
 208                         break;
 209                 }
 210         }
 211
 212         cmd->framemode |= cmd->tx_data ? dmode : 0;
 213         cmd->framemode |= cmd->addr_width ? CCR_ADMODE_1 : 0;
 214 }
 215
 216 static void stm32_qspi_read_fifo(u8 *val, void __iomem *addr)
 217 {
 218         *val = readb_relaxed(addr);
 219 }
 220
 221 static void stm32_qspi_write_fifo(u8 *val, void __iomem *addr)
 222 {
 223         writeb_relaxed(*val, addr);
 224 }
 225
 226 static int stm32_qspi_tx_poll(struct stm32_qspi *qspi,
 227                               const struct stm32_qspi_cmd *cmd)
 228 {
 229         void (*tx_fifo)(u8 *, void __iomem *);
 230         u32 len = cmd->len, sr;
 231         u8 *buf = cmd->buf;
 232         int ret;
 233
 234         if (cmd->qspimode == CCR_FMODE_INDW)
 235                 tx_fifo = stm32_qspi_write_fifo;
 236         else
 237                 tx_fifo = stm32_qspi_read_fifo;
 238
 239         while (len--) {
 240                 ret = readl_relaxed_poll_timeout(qspi->io_base + QUADSPI_SR,
 241                                                  sr, (sr & SR_FTF), 10,
 242                                                  STM32_QSPI_FIFO_TIMEOUT_US);
 243                 if (ret) {
 244                         dev_err(qspi->dev, "fifo timeout (stat:%#x)\n", sr);
 245                         return ret;
 246                 }
 247                 tx_fifo(buf++, qspi->io_base + QUADSPI_DR);
 248         }
 249
 250         return 0;
 251 }
 252
 253 static int stm32_qspi_tx_mm(struct stm32_qspi *qspi,
 254                             const struct stm32_qspi_cmd *cmd)
 255 {
 256         memcpy_fromio(cmd->buf, qspi->mm_base + cmd->addr, cmd->len);
 257         return 0;
 258 }
 259
 260 static int stm32_qspi_tx(struct stm32_qspi *qspi,
 261                          const struct stm32_qspi_cmd *cmd)
 262 {
 263         if (!cmd->tx_data)
 264                 return 0;
 265
 266         if (cmd->qspimode == CCR_FMODE_MM)
 267                 return stm32_qspi_tx_mm(qspi, cmd);
 268
 269         return stm32_qspi_tx_poll(qspi, cmd);
 270 }
 271
 272 static int stm32_qspi_send(struct stm32_qspi_flash *flash,
 273                            const struct stm32_qspi_cmd *cmd)
 274 {
 275         struct stm32_qspi *qspi = flash->qspi;
 276         u32 ccr, dcr, cr;
 277         u32 last_byte;
 278         int err;
 279
 280         err = stm32_qspi_wait_nobusy(qspi);
 281         if (err)
 282                 goto abort;
 283
 284         dcr = readl_relaxed(qspi->io_base + QUADSPI_DCR) & ~DCR_FSIZE_MASK;
 285         dcr |= DCR_FSIZE(flash->fsize);
 286         writel_relaxed(dcr, qspi->io_base + QUADSPI_DCR);
 287
 288         cr = readl_relaxed(qspi->io_base + QUADSPI_CR);
 289         cr &= ~CR_PRESC_MASK & ~CR_FSEL;
 290         cr |= CR_PRESC(flash->presc);
 291         cr |= flash->cs ? CR_FSEL : 0;
 292         writel_relaxed(cr, qspi->io_base + QUADSPI_CR);
 293
 294         if (cmd->tx_data)
 295                 writel_relaxed(cmd->len - 1, qspi->io_base + QUADSPI_DLR);
 296
 297         ccr = cmd->framemode | cmd->qspimode;
 298
 299         if (cmd->dummy)
 300                 ccr |= CCR_DCYC(cmd->dummy);
 301
 302         if (cmd->addr_width)
 303                 ccr |= CCR_ADSIZE(cmd->addr_width - 1);
 304
 305         ccr |= CCR_INST(cmd->opcode);
 306         writel_relaxed(ccr, qspi->io_base + QUADSPI_CCR);
 307
 308         if (cmd->addr_width && cmd->qspimode != CCR_FMODE_MM)
 309                 writel_relaxed(cmd->addr, qspi->io_base + QUADSPI_AR);
 310
 311         err = stm32_qspi_tx(qspi, cmd);
 312         if (err)
 313                 goto abort;
 314
 315         if (cmd->qspimode != CCR_FMODE_MM) {
 316                 err = stm32_qspi_wait_cmd(qspi);
 317                 if (err)
 318                         goto abort;
 319                 writel_relaxed(FCR_CTCF, qspi->io_base + QUADSPI_FCR);
 320         } else {
 321                 last_byte = cmd->addr + cmd->len;
 322                 if (last_byte > flash->prefetch_limit)
 323                         goto abort;
 324         }
 325
 326         return err;
 327
 328 abort:
 329         cr = readl_relaxed(qspi->io_base + QUADSPI_CR) | CR_ABORT;
 330         writel_relaxed(cr, qspi->io_base + QUADSPI_CR);
 331
 332         if (err)
 333                 dev_err(qspi->dev, "%s abort err:%d\n", __func__, err);
 334
 335         return err;
 336 }
 337
 338 static int stm32_qspi_read_reg(struct spi_nor *nor,
 339                                u8 opcode, u8 *buf, int len)
 340 {
 341         struct stm32_qspi_flash *flash = nor->priv;
 342         struct device *dev = flash->qspi->dev;
 343         struct stm32_qspi_cmd cmd;
 344
 345         dev_dbg(dev, "read_reg: cmd:%#.2x buf:%pK len:%#x\n", opcode, buf, len);
 346
 347         memset(&cmd, 0, sizeof(cmd));
 348         cmd.opcode = opcode;
 349         cmd.tx_data = true;
 350         cmd.len = len;
 351         cmd.buf = buf;
 352         cmd.qspimode = CCR_FMODE_INDR;
 353
 354         stm32_qspi_set_framemode(nor, &cmd, false);
 355
 356         return stm32_qspi_send(flash, &cmd);
 357 }
 358
 359 static int stm32_qspi_write_reg(struct spi_nor *nor, u8 opcode,
 360                                 u8 *buf, int len)
 361 {
 362         struct stm32_qspi_flash *flash = nor->priv;
 363         struct device *dev = flash->qspi->dev;
 364         struct stm32_qspi_cmd cmd;
 365
 366         dev_dbg(dev, "write_reg: cmd:%#.2x buf:%pK len:%#x\n", opcode, buf, len);
 367
 368         memset(&cmd, 0, sizeof(cmd));
 369         cmd.opcode = opcode;
 370         cmd.tx_data = !!(buf && len > 0);
 371         cmd.len = len;
 372         cmd.buf = buf;
 373         cmd.qspimode = CCR_FMODE_INDW;
 374
 375         stm32_qspi_set_framemode(nor, &cmd, false);
 376
 377         return stm32_qspi_send(flash, &cmd);
 378 }
 379
 380 static ssize_t stm32_qspi_read(struct spi_nor *nor, loff_t from, size_t len,
 381                                u_char *buf)
 382 {
 383         struct stm32_qspi_flash *flash = nor->priv;
 384         struct stm32_qspi *qspi = flash->qspi;
 385         struct stm32_qspi_cmd cmd;
 386         int err;
 387
 388         dev_dbg(qspi->dev, "read(%#.2x): buf:%pK from:%#.8x len:%#zx\n",
 389                 nor->read_opcode, buf, (u32)from, len);
 390
 391         memset(&cmd, 0, sizeof(cmd));
 392         cmd.opcode = nor->read_opcode;
 393         cmd.addr_width = nor->addr_width;
 394         cmd.addr = (u32)from;
 395         cmd.tx_data = true;
 396         cmd.dummy = nor->read_dummy;
 397         cmd.len = len;
 398         cmd.buf = buf;
 399         cmd.qspimode = flash->read_mode;
 400
 401         stm32_qspi_set_framemode(nor, &cmd, true);
 402         err = stm32_qspi_send(flash, &cmd);
 403
 404         return err ? err : len;
 405 }
 406
 407 static ssize_t stm32_qspi_write(struct spi_nor *nor, loff_t to, size_t len,
 408                                 const u_char *buf)
 409 {
 410         struct stm32_qspi_flash *flash = nor->priv;
 411         struct device *dev = flash->qspi->dev;
 412         struct stm32_qspi_cmd cmd;
 413         int err;
 414
 415         dev_dbg(dev, "write(%#.2x): buf:%p to:%#.8x len:%#zx\n",
 416                 nor->program_opcode, buf, (u32)to, len);
 417
 418         memset(&cmd, 0, sizeof(cmd));
 419         cmd.opcode = nor->program_opcode;
 420         cmd.addr_width = nor->addr_width;
 421         cmd.addr = (u32)to;
 422         cmd.tx_data = true;
 423         cmd.len = len;
 424         cmd.buf = (void *)buf;
 425         cmd.qspimode = CCR_FMODE_INDW;
 426
 427         stm32_qspi_set_framemode(nor, &cmd, false);
 428         err = stm32_qspi_send(flash, &cmd);
 429
 430         return err ? err : len;
 431 }
 432
 433 static int stm32_qspi_erase(struct spi_nor *nor, loff_t offs)
 434 {
 435         struct stm32_qspi_flash *flash = nor->priv;
 436         struct device *dev = flash->qspi->dev;
 437         struct stm32_qspi_cmd cmd;
 438
 439         dev_dbg(dev, "erase(%#.2x):offs:%#x\n", nor->erase_opcode, (u32)offs);
 440
 441         memset(&cmd, 0, sizeof(cmd));
 442         cmd.opcode = nor->erase_opcode;
 443         cmd.addr_width = nor->addr_width;
 444         cmd.addr = (u32)offs;
 445         cmd.qspimode = CCR_FMODE_INDW;
 446
 447         stm32_qspi_set_framemode(nor, &cmd, false);
 448
 449         return stm32_qspi_send(flash, &cmd);
 450 }
 451
 452 static irqreturn_t stm32_qspi_irq(int irq, void *dev_id)
 453 {
 454         struct stm32_qspi *qspi = (struct stm32_qspi *)dev_id;
 455         u32 cr, sr, fcr = 0;
 456
 457         cr = readl_relaxed(qspi->io_base + QUADSPI_CR);
 458         sr = readl_relaxed(qspi->io_base + QUADSPI_SR);
 459
 460         if ((cr & CR_TCIE) && (sr & SR_TCF)) {
 461                 /* tx complete */
 462                 fcr |= FCR_CTCF;
 463                 complete(&qspi->cmd_completion);
 464         } else {
 465                 dev_info_ratelimited(qspi->dev, "spurious interrupt\n");
 466         }
 467
 468         writel_relaxed(fcr, qspi->io_base + QUADSPI_FCR);
 469
 470         return IRQ_HANDLED;
 471 }
 472
 473 static int stm32_qspi_prep(struct spi_nor *nor, enum spi_nor_ops ops)
 474 {
 475         struct stm32_qspi_flash *flash = nor->priv;
 476         struct stm32_qspi *qspi = flash->qspi;
 477
 478         mutex_lock(&qspi->lock);
 479         return 0;
 480 }
 481
 482 static void stm32_qspi_unprep(struct spi_nor *nor, enum spi_nor_ops ops)
 483 {
 484         struct stm32_qspi_flash *flash = nor->priv;
 485         struct stm32_qspi *qspi = flash->qspi;
 486
 487         mutex_unlock(&qspi->lock);
 488 }
 489
 490 static int stm32_qspi_flash_setup(struct stm32_qspi *qspi,
 491                                   struct device_node *np)
 492 {
 493         struct spi_nor_hwcaps hwcaps = {
 494                 .mask = SNOR_HWCAPS_READ |
 495                         SNOR_HWCAPS_READ_FAST |
 496                         SNOR_HWCAPS_PP,
 497         };
 498         u32 width, presc, cs_num, max_rate = 0;
 499         struct stm32_qspi_flash *flash;
 500         struct mtd_info *mtd;
 501         int ret;
 502
 503         of_property_read_u32(np, "reg", &cs_num);
 504         if (cs_num >= STM32_MAX_NORCHIP)
 505                 return -EINVAL;
 506
 507         of_property_read_u32(np, "spi-max-frequency", &max_rate);
 508         if (!max_rate)
 509                 return -EINVAL;
 510
 511         presc = DIV_ROUND_UP(qspi->clk_rate, max_rate) - 1;
 512
 513         if (of_property_read_u32(np, "spi-rx-bus-width", &width))
 514                 width = 1;
 515
 516         if (width == 4)
 517                 hwcaps.mask |= SNOR_HWCAPS_READ_1_1_4;
 518         else if (width == 2)
 519                 hwcaps.mask |= SNOR_HWCAPS_READ_1_1_2;
 520         else if (width != 1)
 521                 return -EINVAL;
 522
 523         flash = &qspi->flash[cs_num];
 524         flash->qspi = qspi;
 525         flash->cs = cs_num;
 526         flash->presc = presc;
 527
 528         flash->nor.dev = qspi->dev;
 529         spi_nor_set_flash_node(&flash->nor, np);
 530         flash->nor.priv = flash;
 531         mtd = &flash->nor.mtd;
 532
 533         flash->nor.read = stm32_qspi_read;
 534         flash->nor.write = stm32_qspi_write;
 535         flash->nor.erase = stm32_qspi_erase;
 536         flash->nor.read_reg = stm32_qspi_read_reg;
 537         flash->nor.write_reg = stm32_qspi_write_reg;
 538         flash->nor.prepare = stm32_qspi_prep;
 539         flash->nor.unprepare = stm32_qspi_unprep;
 540
 541         writel_relaxed(LPTR_DFT_TIMEOUT, qspi->io_base + QUADSPI_LPTR);
 542
 543         writel_relaxed(CR_PRESC(presc) | CR_FTHRES(3) | CR_TCEN | CR_SSHIFT
 544                        | CR_EN, qspi->io_base + QUADSPI_CR);
 545
 546         /*
 547          * in stm32 qspi controller, QUADSPI_DCR register has a fsize field
 548          * which define the size of nor flash.
 549          * if fsize is NULL, the controller can't sent spi-nor command.
 550          * set a temporary value just to discover the nor flash with
 551          * "spi_nor_scan". After, the right value (mtd->size) can be set.
 552          */
 553         flash->fsize = FSIZE_VAL(SZ_1K);
 554
 555         ret = spi_nor_scan(&flash->nor, NULL, &hwcaps);
 556         if (ret) {
 557                 dev_err(qspi->dev, "device scan failed\n");
 558                 return ret;
 559         }
 560
 561         flash->fsize = FSIZE_VAL(mtd->size);
 562         flash->prefetch_limit = mtd->size - STM32_QSPI_FIFO_SZ;
 563
 564         flash->read_mode = CCR_FMODE_MM;
 565         if (mtd->size > qspi->mm_size)
 566                 flash->read_mode = CCR_FMODE_INDR;
 567
 568         writel_relaxed(DCR_CSHT(1), qspi->io_base + QUADSPI_DCR);
 569
 570         ret = mtd_device_register(mtd, NULL, 0);
 571         if (ret) {
 572                 dev_err(qspi->dev, "mtd device parse failed\n");
 573                 return ret;
 574         }
 575
 576         flash->registered = true;
 577
 578         dev_dbg(qspi->dev, "read mm:%s cs:%d bus:%d\n",
 579                 flash->read_mode == CCR_FMODE_MM ? "yes" : "no", cs_num, width);
 580
 581         return 0;
 582 }
 583
 584 static void stm32_qspi_mtd_free(struct stm32_qspi *qspi)
 585 {
 586         int i;
 587
 588         for (i = 0; i < STM32_MAX_NORCHIP; i++)
 589                 if (qspi->flash[i].registered)
 590                         mtd_device_unregister(&qspi->flash[i].nor.mtd);
 591 }
 592
 593 static int stm32_qspi_probe(struct platform_device *pdev)
 594 {
 595         struct device *dev = &pdev->dev;
 596         struct device_node *flash_np;
 597         struct reset_control *rstc;
 598         struct stm32_qspi *qspi;
 599         struct resource *res;
 600         int ret, irq;
 601
 602         qspi = devm_kzalloc(dev, sizeof(*qspi), GFP_KERNEL);
 603         if (!qspi)
 604                 return -ENOMEM;
 605
 606         qspi->nor_num = of_get_child_count(dev->of_node);
 607         if (!qspi->nor_num || qspi->nor_num > STM32_MAX_NORCHIP)
 608                 return -ENODEV;
 609
 610         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "qspi");
 611         qspi->io_base = devm_ioremap_resource(dev, res);
 612         if (IS_ERR(qspi->io_base))
 613                 return PTR_ERR(qspi->io_base);
 614
 615         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "qspi_mm");
 616         qspi->mm_base = devm_ioremap_resource(dev, res);
 617         if (IS_ERR(qspi->mm_base))
 618                 return PTR_ERR(qspi->mm_base);
 619
 620         qspi->mm_size = resource_size(res);
 621
 622         irq = platform_get_irq(pdev, 0);
 623         ret = devm_request_irq(dev, irq, stm32_qspi_irq, 0,
 624                                dev_name(dev), qspi);
 625         if (ret) {
 626                 dev_err(dev, "failed to request irq\n");
 627                 return ret;
 628         }
 629
 630         init_completion(&qspi->cmd_completion);
 631
 632         qspi->clk = devm_clk_get(dev, NULL);
 633         if (IS_ERR(qspi->clk))
 634                 return PTR_ERR(qspi->clk);
 635
 636         qspi->clk_rate = clk_get_rate(qspi->clk);
 637         if (!qspi->clk_rate)
 638                 return -EINVAL;
 639
 640         ret = clk_prepare_enable(qspi->clk);
 641         if (ret) {
 642                 dev_err(dev, "can not enable the clock\n");
 643                 return ret;
 644         }
 645
 646         rstc = devm_reset_control_get_exclusive(dev, NULL);
 647         if (!IS_ERR(rstc)) {
 648                 reset_control_assert(rstc);
 649                 udelay(2);
 650                 reset_control_deassert(rstc);
 651         }
 652
 653         qspi->dev = dev;
 654         platform_set_drvdata(pdev, qspi);
 655         mutex_init(&qspi->lock);
 656
 657         for_each_available_child_of_node(dev->of_node, flash_np) {
 658                 ret = stm32_qspi_flash_setup(qspi, flash_np);
 659                 if (ret) {
 660                         dev_err(dev, "unable to setup flash chip\n");
 661                         goto err_flash;
 662                 }
 663         }
 664
 665         return 0;
 666
 667 err_flash:
 668         mutex_destroy(&qspi->lock);
 669         stm32_qspi_mtd_free(qspi);
 670
 671         clk_disable_unprepare(qspi->clk);
 672         return ret;
 673 }
 674
 675 static int stm32_qspi_remove(struct platform_device *pdev)
 676 {
 677         struct stm32_qspi *qspi = platform_get_drvdata(pdev);
 678
 679         /* disable qspi */
 680         writel_relaxed(0, qspi->io_base + QUADSPI_CR);
 681
 682         stm32_qspi_mtd_free(qspi);
 683         mutex_destroy(&qspi->lock);
 684
 685         clk_disable_unprepare(qspi->clk);
 686         return 0;
 687 }
 688
 689 static const struct of_device_id stm32_qspi_match[] = {
 690         {.compatible = "st,stm32f469-qspi"},
 691         {}
 692 };
 693 MODULE_DEVICE_TABLE(of, stm32_qspi_match);
 694
 695 static struct platform_driver stm32_qspi_driver = {
 696         .probe  = stm32_qspi_probe,
 697         .remove = stm32_qspi_remove,
 698         .driver = {
 699                 .name = "stm32-quadspi",
 700                 .of_match_table = stm32_qspi_match,
 701         },
 702 };
 703 module_platform_driver(stm32_qspi_driver);
 704
 705 MODULE_AUTHOR("Ludovic Barre <ludovic.barre@st.com>");
 706 MODULE_DESCRIPTION("STMicroelectronics STM32 quad spi driver");
 707 MODULE_LICENSE("GPL v2");