drivers/spi/spi-fsl-qspi.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2
   3 /*
   4  * Freescale QuadSPI driver.
   5  *
   6  * Copyright (C) 2013 Freescale Semiconductor, Inc.
   7  * Copyright (C) 2018 Bootlin
   8  * Copyright (C) 2018 exceet electronics GmbH
   9  * Copyright (C) 2018 Kontron Electronics GmbH
  10  *
  11  * Transition to SPI MEM interface:
  12  * Authors:
  13  *     Boris Brezillon <[email protected]>
  14  *     Frieder Schrempf <[email protected]>
  15  *     Yogesh Gaur <[email protected]>
  16  *     Suresh Gupta <[email protected]>
  17  *
  18  * Based on the original fsl-quadspi.c spi-nor driver:
  19  * Author: Freescale Semiconductor, Inc.
  20  *
  21  */
  22
  23 #include <linux/bitops.h>
  24 #include <linux/clk.h>
  25 #include <linux/completion.h>
  26 #include <linux/delay.h>
  27 #include <linux/err.h>
  28 #include <linux/errno.h>
  29 #include <linux/interrupt.h>
  30 #include <linux/io.h>
  31 #include <linux/iopoll.h>
  32 #include <linux/jiffies.h>
  33 #include <linux/kernel.h>
  34 #include <linux/module.h>
  35 #include <linux/mutex.h>
  36 #include <linux/of.h>
  37 #include <linux/of_device.h>
  38 #include <linux/platform_device.h>
  39 #include <linux/pm_qos.h>
  40 #include <linux/sizes.h>
  41
  42 #include <linux/spi/spi.h>
  43 #include <linux/spi/spi-mem.h>
  44
  45 /*
  46  * The driver only uses one single LUT entry, that is updated on
  47  * each call of exec_op(). Index 0 is preset at boot with a basic
  48  * read operation, so let's use the last entry (15).
  49  */
  50 #define SEQID_LUT                       15
  51
  52 /* Registers used by the driver */
  53 #define QUADSPI_MCR                     0x00
  54 #define QUADSPI_MCR_RESERVED_MASK       GENMASK(19, 16)
  55 #define QUADSPI_MCR_MDIS_MASK           BIT(14)
  56 #define QUADSPI_MCR_CLR_TXF_MASK        BIT(11)
  57 #define QUADSPI_MCR_CLR_RXF_MASK        BIT(10)
  58 #define QUADSPI_MCR_DDR_EN_MASK         BIT(7)
  59 #define QUADSPI_MCR_END_CFG_MASK        GENMASK(3, 2)
  60 #define QUADSPI_MCR_SWRSTHD_MASK        BIT(1)
  61 #define QUADSPI_MCR_SWRSTSD_MASK        BIT(0)
  62
  63 #define QUADSPI_IPCR                    0x08
  64 #define QUADSPI_IPCR_SEQID(x)           ((x) << 24)
  65
  66 #define QUADSPI_BUF0CR                  0x10
  67 #define QUADSPI_BUF1CR                  0x14
  68 #define QUADSPI_BUF2CR                  0x18
  69 #define QUADSPI_BUFXCR_INVALID_MSTRID   0xe
  70
  71 #define QUADSPI_BUF3CR                  0x1c
  72 #define QUADSPI_BUF3CR_ALLMST_MASK      BIT(31)
  73 #define QUADSPI_BUF3CR_ADATSZ(x)        ((x) << 8)
  74 #define QUADSPI_BUF3CR_ADATSZ_MASK      GENMASK(15, 8)
  75
  76 #define QUADSPI_BFGENCR                 0x20
  77 #define QUADSPI_BFGENCR_SEQID(x)        ((x) << 12)
  78
  79 #define QUADSPI_BUF0IND                 0x30
  80 #define QUADSPI_BUF1IND                 0x34
  81 #define QUADSPI_BUF2IND                 0x38
  82 #define QUADSPI_SFAR                    0x100
  83
  84 #define QUADSPI_SMPR                    0x108
  85 #define QUADSPI_SMPR_DDRSMP_MASK        GENMASK(18, 16)
  86 #define QUADSPI_SMPR_FSDLY_MASK         BIT(6)
  87 #define QUADSPI_SMPR_FSPHS_MASK         BIT(5)
  88 #define QUADSPI_SMPR_HSENA_MASK         BIT(0)
  89
  90 #define QUADSPI_RBCT                    0x110
  91 #define QUADSPI_RBCT_WMRK_MASK          GENMASK(4, 0)
  92 #define QUADSPI_RBCT_RXBRD_USEIPS       BIT(8)
  93
  94 #define QUADSPI_TBDR                    0x154
  95
  96 #define QUADSPI_SR                      0x15c
  97 #define QUADSPI_SR_IP_ACC_MASK          BIT(1)
  98 #define QUADSPI_SR_AHB_ACC_MASK         BIT(2)
  99
 100 #define QUADSPI_FR                      0x160
 101 #define QUADSPI_FR_TFF_MASK             BIT(0)
 102
 103 #define QUADSPI_SPTRCLR                 0x16c
 104 #define QUADSPI_SPTRCLR_IPPTRC          BIT(8)
 105 #define QUADSPI_SPTRCLR_BFPTRC          BIT(0)
 106
 107 #define QUADSPI_SFA1AD                  0x180
 108 #define QUADSPI_SFA2AD                  0x184
 109 #define QUADSPI_SFB1AD                  0x188
 110 #define QUADSPI_SFB2AD                  0x18c
 111 #define QUADSPI_RBDR(x)                 (0x200 + ((x) * 4))
 112
 113 #define QUADSPI_LUTKEY                  0x300
 114 #define QUADSPI_LUTKEY_VALUE            0x5AF05AF0
 115
 116 #define QUADSPI_LCKCR                   0x304
 117 #define QUADSPI_LCKER_LOCK              BIT(0)
 118 #define QUADSPI_LCKER_UNLOCK            BIT(1)
 119
 120 #define QUADSPI_RSER                    0x164
 121 #define QUADSPI_RSER_TFIE               BIT(0)
 122
 123 #define QUADSPI_LUT_BASE                0x310
 124 #define QUADSPI_LUT_OFFSET              (SEQID_LUT * 4 * 4)
 125 #define QUADSPI_LUT_REG(idx) \
 126         (QUADSPI_LUT_BASE + QUADSPI_LUT_OFFSET + (idx) * 4)
 127
 128 /* Instruction set for the LUT register */
 129 #define LUT_STOP                0
 130 #define LUT_CMD                 1
 131 #define LUT_ADDR                2
 132 #define LUT_DUMMY               3
 133 #define LUT_MODE                4
 134 #define LUT_MODE2               5
 135 #define LUT_MODE4               6
 136 #define LUT_FSL_READ            7
 137 #define LUT_FSL_WRITE           8
 138 #define LUT_JMP_ON_CS           9
 139 #define LUT_ADDR_DDR            10
 140 #define LUT_MODE_DDR            11
 141 #define LUT_MODE2_DDR           12
 142 #define LUT_MODE4_DDR           13
 143 #define LUT_FSL_READ_DDR        14
 144 #define LUT_FSL_WRITE_DDR       15
 145 #define LUT_DATA_LEARN          16
 146
 147 /*
 148  * The PAD definitions for LUT register.
 149  *
 150  * The pad stands for the number of IO lines [0:3].
 151  * For example, the quad read needs four IO lines,
 152  * so you should use LUT_PAD(4).
 153  */
 154 #define LUT_PAD(x) (fls(x) - 1)
 155
 156 /*
 157  * Macro for constructing the LUT entries with the following
 158  * register layout:
 159  *
 160  *  ---------------------------------------------------
 161  *  | INSTR1 | PAD1 | OPRND1 | INSTR0 | PAD0 | OPRND0 |
 162  *  ---------------------------------------------------
 163  */
 164 #define LUT_DEF(idx, ins, pad, opr)                                     \
 165         ((((ins) << 10) | ((pad) << 8) | (opr)) << (((idx) % 2) * 16))
 166
 167 /* Controller needs driver to swap endianness */
 168 #define QUADSPI_QUIRK_SWAP_ENDIAN       BIT(0)
 169
 170 /* Controller needs 4x internal clock */
 171 #define QUADSPI_QUIRK_4X_INT_CLK        BIT(1)
 172
 173 /*
 174  * TKT253890, the controller needs the driver to fill the txfifo with
 175  * 16 bytes at least to trigger a data transfer, even though the extra
 176  * data won't be transferred.
 177  */
 178 #define QUADSPI_QUIRK_TKT253890         BIT(2)
 179
 180 /* TKT245618, the controller cannot wake up from wait mode */
 181 #define QUADSPI_QUIRK_TKT245618         BIT(3)
 182
 183 /*
 184  * Controller adds QSPI_AMBA_BASE (base address of the mapped memory)
 185  * internally. No need to add it when setting SFXXAD and SFAR registers
 186  */
 187 #define QUADSPI_QUIRK_BASE_INTERNAL     BIT(4)
 188
 189 struct fsl_qspi_devtype_data {
 190         unsigned int rxfifo;
 191         unsigned int txfifo;
 192         int invalid_mstrid;
 193         unsigned int ahb_buf_size;
 194         unsigned int quirks;
 195         bool little_endian;
 196 };
 197
 198 static const struct fsl_qspi_devtype_data vybrid_data = {
 199         .rxfifo = SZ_128,
 200         .txfifo = SZ_64,
 201         .invalid_mstrid = QUADSPI_BUFXCR_INVALID_MSTRID,
 202         .ahb_buf_size = SZ_1K,
 203         .quirks = QUADSPI_QUIRK_SWAP_ENDIAN,
 204         .little_endian = true,
 205 };
 206
 207 static const struct fsl_qspi_devtype_data imx6sx_data = {
 208         .rxfifo = SZ_128,
 209         .txfifo = SZ_512,
 210         .invalid_mstrid = QUADSPI_BUFXCR_INVALID_MSTRID,
 211         .ahb_buf_size = SZ_1K,
 212         .quirks = QUADSPI_QUIRK_4X_INT_CLK | QUADSPI_QUIRK_TKT245618,
 213         .little_endian = true,
 214 };
 215
 216 static const struct fsl_qspi_devtype_data imx7d_data = {
 217         .rxfifo = SZ_128,
 218         .txfifo = SZ_512,
 219         .invalid_mstrid = QUADSPI_BUFXCR_INVALID_MSTRID,
 220         .ahb_buf_size = SZ_1K,
 221         .quirks = QUADSPI_QUIRK_TKT253890 | QUADSPI_QUIRK_4X_INT_CLK,
 222         .little_endian = true,
 223 };
 224
 225 static const struct fsl_qspi_devtype_data imx6ul_data = {
 226         .rxfifo = SZ_128,
 227         .txfifo = SZ_512,
 228         .invalid_mstrid = QUADSPI_BUFXCR_INVALID_MSTRID,
 229         .ahb_buf_size = SZ_1K,
 230         .quirks = QUADSPI_QUIRK_TKT253890 | QUADSPI_QUIRK_4X_INT_CLK,
 231         .little_endian = true,
 232 };
 233
 234 static const struct fsl_qspi_devtype_data ls1021a_data = {
 235         .rxfifo = SZ_128,
 236         .txfifo = SZ_64,
 237         .invalid_mstrid = QUADSPI_BUFXCR_INVALID_MSTRID,
 238         .ahb_buf_size = SZ_1K,
 239         .quirks = 0,
 240         .little_endian = false,
 241 };
 242
 243 static const struct fsl_qspi_devtype_data ls2080a_data = {
 244         .rxfifo = SZ_128,
 245         .txfifo = SZ_64,
 246         .ahb_buf_size = SZ_1K,
 247         .invalid_mstrid = 0x0,
 248         .quirks = QUADSPI_QUIRK_TKT253890 | QUADSPI_QUIRK_BASE_INTERNAL,
 249         .little_endian = true,
 250 };
 251
 252 struct fsl_qspi {
 253         void __iomem *iobase;
 254         void __iomem *ahb_addr;
 255         u32 memmap_phy;
 256         struct clk *clk, *clk_en;
 257         struct device *dev;
 258         struct completion c;
 259         const struct fsl_qspi_devtype_data *devtype_data;
 260         struct mutex lock;
 261         struct pm_qos_request pm_qos_req;
 262         int selected;
 263 };
 264
 265 static inline int needs_swap_endian(struct fsl_qspi *q)
 266 {
 267         return q->devtype_data->quirks & QUADSPI_QUIRK_SWAP_ENDIAN;
 268 }
 269
 270 static inline int needs_4x_clock(struct fsl_qspi *q)
 271 {
 272         return q->devtype_data->quirks & QUADSPI_QUIRK_4X_INT_CLK;
 273 }
 274
 275 static inline int needs_fill_txfifo(struct fsl_qspi *q)
 276 {
 277         return q->devtype_data->quirks & QUADSPI_QUIRK_TKT253890;
 278 }
 279
 280 static inline int needs_wakeup_wait_mode(struct fsl_qspi *q)
 281 {
 282         return q->devtype_data->quirks & QUADSPI_QUIRK_TKT245618;
 283 }
 284
 285 static inline int needs_amba_base_offset(struct fsl_qspi *q)
 286 {
 287         return !(q->devtype_data->quirks & QUADSPI_QUIRK_BASE_INTERNAL);
 288 }
 289
 290 /*
 291  * An IC bug makes it necessary to rearrange the 32-bit data.
 292  * Later chips, such as IMX6SLX, have fixed this bug.
 293  */
 294 static inline u32 fsl_qspi_endian_xchg(struct fsl_qspi *q, u32 a)
 295 {
 296         return needs_swap_endian(q) ? __swab32(a) : a;
 297 }
 298
 299 /*
 300  * R/W functions for big- or little-endian registers:
 301  * The QSPI controller's endianness is independent of
 302  * the CPU core's endianness. So far, although the CPU
 303  * core is little-endian the QSPI controller can use
 304  * big-endian or little-endian.
 305  */
 306 static void qspi_writel(struct fsl_qspi *q, u32 val, void __iomem *addr)
 307 {
 308         if (q->devtype_data->little_endian)
 309                 iowrite32(val, addr);
 310         else
 311                 iowrite32be(val, addr);
 312 }
 313
 314 static u32 qspi_readl(struct fsl_qspi *q, void __iomem *addr)
 315 {
 316         if (q->devtype_data->little_endian)
 317                 return ioread32(addr);
 318
 319         return ioread32be(addr);
 320 }
 321
 322 static irqreturn_t fsl_qspi_irq_handler(int irq, void *dev_id)
 323 {
 324         struct fsl_qspi *q = dev_id;
 325         u32 reg;
 326
 327         /* clear interrupt */
 328         reg = qspi_readl(q, q->iobase + QUADSPI_FR);
 329         qspi_writel(q, reg, q->iobase + QUADSPI_FR);
 330
 331         if (reg & QUADSPI_FR_TFF_MASK)
 332                 complete(&q->c);
 333
 334         dev_dbg(q->dev, "QUADSPI_FR : 0x%.8x:0x%.8x\n", 0, reg);
 335         return IRQ_HANDLED;
 336 }
 337
 338 static int fsl_qspi_check_buswidth(struct fsl_qspi *q, u8 width)
 339 {
 340         switch (width) {
 341         case 1:
 342         case 2:
 343         case 4:
 344                 return 0;
 345         }
 346
 347         return -ENOTSUPP;
 348 }
 349
 350 static bool fsl_qspi_supports_op(struct spi_mem *mem,
 351                                  const struct spi_mem_op *op)
 352 {
 353         struct fsl_qspi *q = spi_controller_get_devdata(mem->spi->master);
 354         int ret;
 355
 356         ret = fsl_qspi_check_buswidth(q, op->cmd.buswidth);
 357
 358         if (op->addr.nbytes)
 359                 ret |= fsl_qspi_check_buswidth(q, op->addr.buswidth);
 360
 361         if (op->dummy.nbytes)
 362                 ret |= fsl_qspi_check_buswidth(q, op->dummy.buswidth);
 363
 364         if (op->data.nbytes)
 365                 ret |= fsl_qspi_check_buswidth(q, op->data.buswidth);
 366
 367         if (ret)
 368                 return false;
 369
 370         /*
 371          * The number of instructions needed for the op, needs
 372          * to fit into a single LUT entry.
 373          */
 374         if (op->addr.nbytes +
 375            (op->dummy.nbytes ? 1:0) +
 376            (op->data.nbytes ? 1:0) > 6)
 377                 return false;
 378
 379         /* Max 64 dummy clock cycles supported */
 380         if (op->dummy.nbytes &&
 381             (op->dummy.nbytes * 8 / op->dummy.buswidth > 64))
 382                 return false;
 383
 384         /* Max data length, check controller limits and alignment */
 385         if (op->data.dir == SPI_MEM_DATA_IN &&
 386             (op->data.nbytes > q->devtype_data->ahb_buf_size ||
 387              (op->data.nbytes > q->devtype_data->rxfifo - 4 &&
 388               !IS_ALIGNED(op->data.nbytes, 8))))
 389                 return false;
 390
 391         if (op->data.dir == SPI_MEM_DATA_OUT &&
 392             op->data.nbytes > q->devtype_data->txfifo)
 393                 return false;
 394
 395         return true;
 396 }
 397
 398 static void fsl_qspi_prepare_lut(struct fsl_qspi *q,
 399                                  const struct spi_mem_op *op)
 400 {
 401         void __iomem *base = q->iobase;
 402         u32 lutval[4] = {};
 403         int lutidx = 1, i;
 404
 405         lutval[0] |= LUT_DEF(0, LUT_CMD, LUT_PAD(op->cmd.buswidth),
 406                              op->cmd.opcode);
 407
 408         /*
 409          * For some unknown reason, using LUT_ADDR doesn't work in some
 410          * cases (at least with only one byte long addresses), so
 411          * let's use LUT_MODE to write the address bytes one by one
 412          */
 413         for (i = 0; i < op->addr.nbytes; i++) {
 414                 u8 addrbyte = op->addr.val >> (8 * (op->addr.nbytes - i - 1));
 415
 416                 lutval[lutidx / 2] |= LUT_DEF(lutidx, LUT_MODE,
 417                                               LUT_PAD(op->addr.buswidth),
 418                                               addrbyte);
 419                 lutidx++;
 420         }
 421
 422         if (op->dummy.nbytes) {
 423                 lutval[lutidx / 2] |= LUT_DEF(lutidx, LUT_DUMMY,
 424                                               LUT_PAD(op->dummy.buswidth),
 425                                               op->dummy.nbytes * 8 /
 426                                               op->dummy.buswidth);
 427                 lutidx++;
 428         }
 429
 430         if (op->data.nbytes) {
 431                 lutval[lutidx / 2] |= LUT_DEF(lutidx,
 432                                               op->data.dir == SPI_MEM_DATA_IN ?
 433                                               LUT_FSL_READ : LUT_FSL_WRITE,
 434                                               LUT_PAD(op->data.buswidth),
 435                                               0);
 436                 lutidx++;
 437         }
 438
 439         lutval[lutidx / 2] |= LUT_DEF(lutidx, LUT_STOP, 0, 0);
 440
 441         /* unlock LUT */
 442         qspi_writel(q, QUADSPI_LUTKEY_VALUE, q->iobase + QUADSPI_LUTKEY);
 443         qspi_writel(q, QUADSPI_LCKER_UNLOCK, q->iobase + QUADSPI_LCKCR);
 444
 445         /* fill LUT */
 446         for (i = 0; i < ARRAY_SIZE(lutval); i++)
 447                 qspi_writel(q, lutval[i], base + QUADSPI_LUT_REG(i));
 448
 449         /* lock LUT */
 450         qspi_writel(q, QUADSPI_LUTKEY_VALUE, q->iobase + QUADSPI_LUTKEY);
 451         qspi_writel(q, QUADSPI_LCKER_LOCK, q->iobase + QUADSPI_LCKCR);
 452 }
 453
 454 static int fsl_qspi_clk_prep_enable(struct fsl_qspi *q)
 455 {
 456         int ret;
 457
 458         ret = clk_prepare_enable(q->clk_en);
 459         if (ret)
 460                 return ret;
 461
 462         ret = clk_prepare_enable(q->clk);
 463         if (ret) {
 464                 clk_disable_unprepare(q->clk_en);
 465                 return ret;
 466         }
 467
 468         if (needs_wakeup_wait_mode(q))
 469                 pm_qos_add_request(&q->pm_qos_req, PM_QOS_CPU_DMA_LATENCY, 0);
 470
 471         return 0;
 472 }
 473
 474 static void fsl_qspi_clk_disable_unprep(struct fsl_qspi *q)
 475 {
 476         if (needs_wakeup_wait_mode(q))
 477                 pm_qos_remove_request(&q->pm_qos_req);
 478
 479         clk_disable_unprepare(q->clk);
 480         clk_disable_unprepare(q->clk_en);
 481 }
 482
 483 /*
 484  * If we have changed the content of the flash by writing or erasing, or if we
 485  * read from flash with a different offset into the page buffer, we need to
 486  * invalidate the AHB buffer. If we do not do so, we may read out the wrong
 487  * data. The spec tells us reset the AHB domain and Serial Flash domain at
 488  * the same time.
 489  */
 490 static void fsl_qspi_invalidate(struct fsl_qspi *q)
 491 {
 492         u32 reg;
 493
 494         reg = qspi_readl(q, q->iobase + QUADSPI_MCR);
 495         reg |= QUADSPI_MCR_SWRSTHD_MASK | QUADSPI_MCR_SWRSTSD_MASK;
 496         qspi_writel(q, reg, q->iobase + QUADSPI_MCR);
 497
 498         /*
 499          * The minimum delay : 1 AHB + 2 SFCK clocks.
 500          * Delay 1 us is enough.
 501          */
 502         udelay(1);
 503
 504         reg &= ~(QUADSPI_MCR_SWRSTHD_MASK | QUADSPI_MCR_SWRSTSD_MASK);
 505         qspi_writel(q, reg, q->iobase + QUADSPI_MCR);
 506 }
 507
 508 static void fsl_qspi_select_mem(struct fsl_qspi *q, struct spi_device *spi)
 509 {
 510         unsigned long rate = spi->max_speed_hz;
 511         int ret;
 512
 513         if (q->selected == spi->chip_select)
 514                 return;
 515
 516         if (needs_4x_clock(q))
 517                 rate *= 4;
 518
 519         fsl_qspi_clk_disable_unprep(q);
 520
 521         ret = clk_set_rate(q->clk, rate);
 522         if (ret)
 523                 return;
 524
 525         ret = fsl_qspi_clk_prep_enable(q);
 526         if (ret)
 527                 return;
 528
 529         q->selected = spi->chip_select;
 530
 531         fsl_qspi_invalidate(q);
 532 }
 533
 534 static void fsl_qspi_read_ahb(struct fsl_qspi *q, const struct spi_mem_op *op)
 535 {
 536         memcpy_fromio(op->data.buf.in,
 537                       q->ahb_addr + q->selected * q->devtype_data->ahb_buf_size,
 538                       op->data.nbytes);
 539 }
 540
 541 static void fsl_qspi_fill_txfifo(struct fsl_qspi *q,
 542                                  const struct spi_mem_op *op)
 543 {
 544         void __iomem *base = q->iobase;
 545         int i;
 546         u32 val;
 547
 548         for (i = 0; i < ALIGN_DOWN(op->data.nbytes, 4); i += 4) {
 549                 memcpy(&val, op->data.buf.out + i, 4);
 550                 val = fsl_qspi_endian_xchg(q, val);
 551                 qspi_writel(q, val, base + QUADSPI_TBDR);
 552         }
 553
 554         if (i < op->data.nbytes) {
 555                 memcpy(&val, op->data.buf.out + i, op->data.nbytes - i);
 556                 val = fsl_qspi_endian_xchg(q, val);
 557                 qspi_writel(q, val, base + QUADSPI_TBDR);
 558         }
 559
 560         if (needs_fill_txfifo(q)) {
 561                 for (i = op->data.nbytes; i < 16; i += 4)
 562                         qspi_writel(q, 0, base + QUADSPI_TBDR);
 563         }
 564 }
 565
 566 static void fsl_qspi_read_rxfifo(struct fsl_qspi *q,
 567                           const struct spi_mem_op *op)
 568 {
 569         void __iomem *base = q->iobase;
 570         int i;
 571         u8 *buf = op->data.buf.in;
 572         u32 val;
 573
 574         for (i = 0; i < ALIGN_DOWN(op->data.nbytes, 4); i += 4) {
 575                 val = qspi_readl(q, base + QUADSPI_RBDR(i / 4));
 576                 val = fsl_qspi_endian_xchg(q, val);
 577                 memcpy(buf + i, &val, 4);
 578         }
 579
 580         if (i < op->data.nbytes) {
 581                 val = qspi_readl(q, base + QUADSPI_RBDR(i / 4));
 582                 val = fsl_qspi_endian_xchg(q, val);
 583                 memcpy(buf + i, &val, op->data.nbytes - i);
 584         }
 585 }
 586
 587 static int fsl_qspi_do_op(struct fsl_qspi *q, const struct spi_mem_op *op)
 588 {
 589         void __iomem *base = q->iobase;
 590         int err = 0;
 591
 592         init_completion(&q->c);
 593
 594         /*
 595          * Always start the sequence at the same index since we update
 596          * the LUT at each exec_op() call. And also specify the DATA
 597          * length, since it's has not been specified in the LUT.
 598          */
 599         qspi_writel(q, op->data.nbytes | QUADSPI_IPCR_SEQID(SEQID_LUT),
 600                     base + QUADSPI_IPCR);
 601
 602         /* Wait for the interrupt. */
 603         if (!wait_for_completion_timeout(&q->c, msecs_to_jiffies(1000)))
 604                 err = -ETIMEDOUT;
 605
 606         if (!err && op->data.nbytes && op->data.dir == SPI_MEM_DATA_IN)
 607                 fsl_qspi_read_rxfifo(q, op);
 608
 609         return err;
 610 }
 611
 612 static int fsl_qspi_readl_poll_tout(struct fsl_qspi *q, void __iomem *base,
 613                                     u32 mask, u32 delay_us, u32 timeout_us)
 614 {
 615         u32 reg;
 616
 617         if (!q->devtype_data->little_endian)
 618                 mask = (u32)cpu_to_be32(mask);
 619
 620         return readl_poll_timeout(base, reg, !(reg & mask), delay_us,
 621                                   timeout_us);
 622 }
 623
 624 static int fsl_qspi_exec_op(struct spi_mem *mem, const struct spi_mem_op *op)
 625 {
 626         struct fsl_qspi *q = spi_controller_get_devdata(mem->spi->master);
 627         void __iomem *base = q->iobase;
 628         u32 addr_offset = 0;
 629         int err = 0;
 630         int invalid_mstrid = q->devtype_data->invalid_mstrid;
 631
 632         mutex_lock(&q->lock);
 633
 634         /* wait for the controller being ready */
 635         fsl_qspi_readl_poll_tout(q, base + QUADSPI_SR, (QUADSPI_SR_IP_ACC_MASK |
 636                                  QUADSPI_SR_AHB_ACC_MASK), 10, 1000);
 637
 638         fsl_qspi_select_mem(q, mem->spi);
 639
 640         if (needs_amba_base_offset(q))
 641                 addr_offset = q->memmap_phy;
 642
 643         qspi_writel(q,
 644                     q->selected * q->devtype_data->ahb_buf_size + addr_offset,
 645                     base + QUADSPI_SFAR);
 646
 647         qspi_writel(q, qspi_readl(q, base + QUADSPI_MCR) |
 648                     QUADSPI_MCR_CLR_RXF_MASK | QUADSPI_MCR_CLR_TXF_MASK,
 649                     base + QUADSPI_MCR);
 650
 651         qspi_writel(q, QUADSPI_SPTRCLR_BFPTRC | QUADSPI_SPTRCLR_IPPTRC,
 652                     base + QUADSPI_SPTRCLR);
 653
 654         qspi_writel(q, invalid_mstrid, base + QUADSPI_BUF0CR);
 655         qspi_writel(q, invalid_mstrid, base + QUADSPI_BUF1CR);
 656         qspi_writel(q, invalid_mstrid, base + QUADSPI_BUF2CR);
 657
 658         fsl_qspi_prepare_lut(q, op);
 659
 660         /*
 661          * If we have large chunks of data, we read them through the AHB bus
 662          * by accessing the mapped memory. In all other cases we use
 663          * IP commands to access the flash.
 664          */
 665         if (op->data.nbytes > (q->devtype_data->rxfifo - 4) &&
 666             op->data.dir == SPI_MEM_DATA_IN) {
 667                 fsl_qspi_read_ahb(q, op);
 668         } else {
 669                 qspi_writel(q, QUADSPI_RBCT_WMRK_MASK |
 670                             QUADSPI_RBCT_RXBRD_USEIPS, base + QUADSPI_RBCT);
 671
 672                 if (op->data.nbytes && op->data.dir == SPI_MEM_DATA_OUT)
 673                         fsl_qspi_fill_txfifo(q, op);
 674
 675                 err = fsl_qspi_do_op(q, op);
 676         }
 677
 678         /* Invalidate the data in the AHB buffer. */
 679         fsl_qspi_invalidate(q);
 680
 681         mutex_unlock(&q->lock);
 682
 683         return err;
 684 }
 685
 686 static int fsl_qspi_adjust_op_size(struct spi_mem *mem, struct spi_mem_op *op)
 687 {
 688         struct fsl_qspi *q = spi_controller_get_devdata(mem->spi->master);
 689
 690         if (op->data.dir == SPI_MEM_DATA_OUT) {
 691                 if (op->data.nbytes > q->devtype_data->txfifo)
 692                         op->data.nbytes = q->devtype_data->txfifo;
 693         } else {
 694                 if (op->data.nbytes > q->devtype_data->ahb_buf_size)
 695                         op->data.nbytes = q->devtype_data->ahb_buf_size;
 696                 else if (op->data.nbytes > (q->devtype_data->rxfifo - 4))
 697                         op->data.nbytes = ALIGN_DOWN(op->data.nbytes, 8);
 698         }
 699
 700         return 0;
 701 }
 702
 703 static int fsl_qspi_default_setup(struct fsl_qspi *q)
 704 {
 705         void __iomem *base = q->iobase;
 706         u32 reg, addr_offset = 0;
 707         int ret;
 708
 709         /* disable and unprepare clock to avoid glitch pass to controller */
 710         fsl_qspi_clk_disable_unprep(q);
 711
 712         /* the default frequency, we will change it later if necessary. */
 713         ret = clk_set_rate(q->clk, 66000000);
 714         if (ret)
 715                 return ret;
 716
 717         ret = fsl_qspi_clk_prep_enable(q);
 718         if (ret)
 719                 return ret;
 720
 721         /* Reset the module */
 722         qspi_writel(q, QUADSPI_MCR_SWRSTSD_MASK | QUADSPI_MCR_SWRSTHD_MASK,
 723                     base + QUADSPI_MCR);
 724         udelay(1);
 725
 726         /* Disable the module */
 727         qspi_writel(q, QUADSPI_MCR_MDIS_MASK | QUADSPI_MCR_RESERVED_MASK,
 728                     base + QUADSPI_MCR);
 729
 730         reg = qspi_readl(q, base + QUADSPI_SMPR);
 731         qspi_writel(q, reg & ~(QUADSPI_SMPR_FSDLY_MASK
 732                         | QUADSPI_SMPR_FSPHS_MASK
 733                         | QUADSPI_SMPR_HSENA_MASK
 734                         | QUADSPI_SMPR_DDRSMP_MASK), base + QUADSPI_SMPR);
 735
 736         /* We only use the buffer3 for AHB read */
 737         qspi_writel(q, 0, base + QUADSPI_BUF0IND);
 738         qspi_writel(q, 0, base + QUADSPI_BUF1IND);
 739         qspi_writel(q, 0, base + QUADSPI_BUF2IND);
 740
 741         qspi_writel(q, QUADSPI_BFGENCR_SEQID(SEQID_LUT),
 742                     q->iobase + QUADSPI_BFGENCR);
 743         qspi_writel(q, QUADSPI_RBCT_WMRK_MASK, base + QUADSPI_RBCT);
 744         qspi_writel(q, QUADSPI_BUF3CR_ALLMST_MASK |
 745                     QUADSPI_BUF3CR_ADATSZ(q->devtype_data->ahb_buf_size / 8),
 746                     base + QUADSPI_BUF3CR);
 747
 748         if (needs_amba_base_offset(q))
 749                 addr_offset = q->memmap_phy;
 750
 751         /*
 752          * In HW there can be a maximum of four chips on two buses with
 753          * two chip selects on each bus. We use four chip selects in SW
 754          * to differentiate between the four chips.
 755          * We use ahb_buf_size for each chip and set SFA1AD, SFA2AD, SFB1AD,
 756          * SFB2AD accordingly.
 757          */
 758         qspi_writel(q, q->devtype_data->ahb_buf_size + addr_offset,
 759                     base + QUADSPI_SFA1AD);
 760         qspi_writel(q, q->devtype_data->ahb_buf_size * 2 + addr_offset,
 761                     base + QUADSPI_SFA2AD);
 762         qspi_writel(q, q->devtype_data->ahb_buf_size * 3 + addr_offset,
 763                     base + QUADSPI_SFB1AD);
 764         qspi_writel(q, q->devtype_data->ahb_buf_size * 4 + addr_offset,
 765                     base + QUADSPI_SFB2AD);
 766
 767         q->selected = -1;
 768
 769         /* Enable the module */
 770         qspi_writel(q, QUADSPI_MCR_RESERVED_MASK | QUADSPI_MCR_END_CFG_MASK,
 771                     base + QUADSPI_MCR);
 772
 773         /* clear all interrupt status */
 774         qspi_writel(q, 0xffffffff, q->iobase + QUADSPI_FR);
 775
 776         /* enable the interrupt */
 777         qspi_writel(q, QUADSPI_RSER_TFIE, q->iobase + QUADSPI_RSER);
 778
 779         return 0;
 780 }
 781
 782 static const char *fsl_qspi_get_name(struct spi_mem *mem)
 783 {
 784         struct fsl_qspi *q = spi_controller_get_devdata(mem->spi->master);
 785         struct device *dev = &mem->spi->dev;
 786         const char *name;
 787
 788         /*
 789          * In order to keep mtdparts compatible with the old MTD driver at
 790          * mtd/spi-nor/fsl-quadspi.c, we set a custom name derived from the
 791          * platform_device of the controller.
 792          */
 793         if (of_get_available_child_count(q->dev->of_node) == 1)
 794                 return dev_name(q->dev);
 795
 796         name = devm_kasprintf(dev, GFP_KERNEL,
 797                               "%s-%d", dev_name(q->dev),
 798                               mem->spi->chip_select);
 799
 800         if (!name) {
 801                 dev_err(dev, "failed to get memory for custom flash name\n");
 802                 return ERR_PTR(-ENOMEM);
 803         }
 804
 805         return name;
 806 }
 807
 808 static const struct spi_controller_mem_ops fsl_qspi_mem_ops = {
 809         .adjust_op_size = fsl_qspi_adjust_op_size,
 810         .supports_op = fsl_qspi_supports_op,
 811         .exec_op = fsl_qspi_exec_op,
 812         .get_name = fsl_qspi_get_name,
 813 };
 814
 815 static int fsl_qspi_probe(struct platform_device *pdev)
 816 {
 817         struct spi_controller *ctlr;
 818         struct device *dev = &pdev->dev;
 819         struct device_node *np = dev->of_node;
 820         struct resource *res;
 821         struct fsl_qspi *q;
 822         int ret;
 823
 824         ctlr = spi_alloc_master(&pdev->dev, sizeof(*q));
 825         if (!ctlr)
 826                 return -ENOMEM;
 827
 828         ctlr->mode_bits = SPI_RX_DUAL | SPI_RX_QUAD |
 829                           SPI_TX_DUAL | SPI_TX_QUAD;
 830
 831         q = spi_controller_get_devdata(ctlr);
 832         q->dev = dev;
 833         q->devtype_data = of_device_get_match_data(dev);
 834         if (!q->devtype_data) {
 835                 ret = -ENODEV;
 836                 goto err_put_ctrl;
 837         }
 838
 839         platform_set_drvdata(pdev, q);
 840
 841         /* find the resources */
 842         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "QuadSPI");
 843         q->iobase = devm_ioremap_resource(dev, res);
 844         if (IS_ERR(q->iobase)) {
 845                 ret = PTR_ERR(q->iobase);
 846                 goto err_put_ctrl;
 847         }
 848
 849         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 850                                         "QuadSPI-memory");
 851         q->ahb_addr = devm_ioremap_resource(dev, res);
 852         if (IS_ERR(q->ahb_addr)) {
 853                 ret = PTR_ERR(q->ahb_addr);
 854                 goto err_put_ctrl;
 855         }
 856
 857         q->memmap_phy = res->start;
 858
 859         /* find the clocks */
 860         q->clk_en = devm_clk_get(dev, "qspi_en");
 861         if (IS_ERR(q->clk_en)) {
 862                 ret = PTR_ERR(q->clk_en);
 863                 goto err_put_ctrl;
 864         }
 865
 866         q->clk = devm_clk_get(dev, "qspi");
 867         if (IS_ERR(q->clk)) {
 868                 ret = PTR_ERR(q->clk);
 869                 goto err_put_ctrl;
 870         }
 871
 872         ret = fsl_qspi_clk_prep_enable(q);
 873         if (ret) {
 874                 dev_err(dev, "can not enable the clock\n");
 875                 goto err_put_ctrl;
 876         }
 877
 878         /* find the irq */
 879         ret = platform_get_irq(pdev, 0);
 880         if (ret < 0)
 881                 goto err_disable_clk;
 882
 883         ret = devm_request_irq(dev, ret,
 884                         fsl_qspi_irq_handler, 0, pdev->name, q);
 885         if (ret) {
 886                 dev_err(dev, "failed to request irq: %d\n", ret);
 887                 goto err_disable_clk;
 888         }
 889
 890         mutex_init(&q->lock);
 891
 892         ctlr->bus_num = -1;
 893         ctlr->num_chipselect = 4;
 894         ctlr->mem_ops = &fsl_qspi_mem_ops;
 895
 896         fsl_qspi_default_setup(q);
 897
 898         ctlr->dev.of_node = np;
 899
 900         ret = devm_spi_register_controller(dev, ctlr);
 901         if (ret)
 902                 goto err_destroy_mutex;
 903
 904         return 0;
 905
 906 err_destroy_mutex:
 907         mutex_destroy(&q->lock);
 908
 909 err_disable_clk:
 910         fsl_qspi_clk_disable_unprep(q);
 911
 912 err_put_ctrl:
 913         spi_controller_put(ctlr);
 914
 915         dev_err(dev, "Freescale QuadSPI probe failed\n");
 916         return ret;
 917 }
 918
 919 static int fsl_qspi_remove(struct platform_device *pdev)
 920 {
 921         struct fsl_qspi *q = platform_get_drvdata(pdev);
 922
 923         /* disable the hardware */
 924         qspi_writel(q, QUADSPI_MCR_MDIS_MASK, q->iobase + QUADSPI_MCR);
 925         qspi_writel(q, 0x0, q->iobase + QUADSPI_RSER);
 926
 927         fsl_qspi_clk_disable_unprep(q);
 928
 929         mutex_destroy(&q->lock);
 930
 931         return 0;
 932 }
 933
 934 static int fsl_qspi_suspend(struct device *dev)
 935 {
 936         return 0;
 937 }
 938
 939 static int fsl_qspi_resume(struct device *dev)
 940 {
 941         struct fsl_qspi *q = dev_get_drvdata(dev);
 942
 943         fsl_qspi_default_setup(q);
 944
 945         return 0;
 946 }
 947
 948 static const struct of_device_id fsl_qspi_dt_ids[] = {
 949         { .compatible = "fsl,vf610-qspi", .data = &vybrid_data, },
 950         { .compatible = "fsl,imx6sx-qspi", .data = &imx6sx_data, },
 951         { .compatible = "fsl,imx7d-qspi", .data = &imx7d_data, },
 952         { .compatible = "fsl,imx6ul-qspi", .data = &imx6ul_data, },
 953         { .compatible = "fsl,ls1021a-qspi", .data = &ls1021a_data, },
 954         { .compatible = "fsl,ls2080a-qspi", .data = &ls2080a_data, },
 955         { /* sentinel */ }
 956 };
 957 MODULE_DEVICE_TABLE(of, fsl_qspi_dt_ids);
 958
 959 static const struct dev_pm_ops fsl_qspi_pm_ops = {
 960         .suspend        = fsl_qspi_suspend,
 961         .resume         = fsl_qspi_resume,
 962 };
 963
 964 static struct platform_driver fsl_qspi_driver = {
 965         .driver = {
 966                 .name   = "fsl-quadspi",
 967                 .of_match_table = fsl_qspi_dt_ids,
 968                 .pm =   &fsl_qspi_pm_ops,
 969         },
 970         .probe          = fsl_qspi_probe,
 971         .remove         = fsl_qspi_remove,
 972 };
 973 module_platform_driver(fsl_qspi_driver);
 974
 975 MODULE_DESCRIPTION("Freescale QuadSPI Controller Driver");
 976 MODULE_AUTHOR("Freescale Semiconductor Inc.");
 977 MODULE_AUTHOR("Boris Brezillon <[email protected]>");
 978 MODULE_AUTHOR("Frieder Schrempf <[email protected]>");
 979 MODULE_AUTHOR("Yogesh Gaur <[email protected]>");
 980 MODULE_AUTHOR("Suresh Gupta <[email protected]>");
 981 MODULE_LICENSE("GPL v2");