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