1 // SPDX-License-Identifier: GPL-2.0+
3 * (C) Copyright 2013 Xilinx, Inc.
4 * (C) Copyright 2015 Jagan Teki <jteki@openedev.com>
6 * Xilinx Zynq Quad-SPI(QSPI) controller driver (master mode only)
12 #include <dm/device_compat.h>
16 #include <asm/global_data.h>
18 #include <linux/bitops.h>
20 DECLARE_GLOBAL_DATA_PTR;
22 /* zynq qspi register bit masks ZYNQ_QSPI_<REG>_<BIT>_MASK */
23 #define ZYNQ_QSPI_CR_IFMODE_MASK BIT(31) /* Flash intrface mode*/
24 #define ZYNQ_QSPI_CR_MSA_MASK BIT(15) /* Manual start enb */
25 #define ZYNQ_QSPI_CR_MCS_MASK BIT(14) /* Manual chip select */
26 #define ZYNQ_QSPI_CR_PCS_MASK BIT(10) /* Peri chip select */
27 #define ZYNQ_QSPI_CR_FW_MASK GENMASK(7, 6) /* FIFO width */
28 #define ZYNQ_QSPI_CR_SS_MASK GENMASK(13, 10) /* Slave Select */
29 #define ZYNQ_QSPI_CR_BAUD_MASK GENMASK(5, 3) /* Baud rate div */
30 #define ZYNQ_QSPI_CR_CPHA_MASK BIT(2) /* Clock phase */
31 #define ZYNQ_QSPI_CR_CPOL_MASK BIT(1) /* Clock polarity */
32 #define ZYNQ_QSPI_CR_MSTREN_MASK BIT(0) /* Mode select */
33 #define ZYNQ_QSPI_IXR_RXNEMPTY_MASK BIT(4) /* RX_FIFO_not_empty */
34 #define ZYNQ_QSPI_IXR_TXOW_MASK BIT(2) /* TX_FIFO_not_full */
35 #define ZYNQ_QSPI_IXR_ALL_MASK GENMASK(6, 0) /* All IXR bits */
36 #define ZYNQ_QSPI_ENR_SPI_EN_MASK BIT(0) /* SPI Enable */
37 #define ZYNQ_QSPI_LQSPICFG_LQMODE_MASK BIT(31) /* Linear QSPI Mode */
39 /* zynq qspi Transmit Data Register */
40 #define ZYNQ_QSPI_TXD_00_00_OFFSET 0x1C /* Transmit 4-byte inst */
41 #define ZYNQ_QSPI_TXD_00_01_OFFSET 0x80 /* Transmit 1-byte inst */
42 #define ZYNQ_QSPI_TXD_00_10_OFFSET 0x84 /* Transmit 2-byte inst */
43 #define ZYNQ_QSPI_TXD_00_11_OFFSET 0x88 /* Transmit 3-byte inst */
45 #define ZYNQ_QSPI_TXFIFO_THRESHOLD 1 /* Tx FIFO threshold level*/
46 #define ZYNQ_QSPI_RXFIFO_THRESHOLD 32 /* Rx FIFO threshold level */
48 #define ZYNQ_QSPI_CR_BAUD_MAX 8 /* Baud rate divisor max val */
49 #define ZYNQ_QSPI_CR_BAUD_SHIFT 3 /* Baud rate divisor shift */
50 #define ZYNQ_QSPI_CR_SS_SHIFT 10 /* Slave select shift */
52 #define ZYNQ_QSPI_FIFO_DEPTH 63
53 #define ZYNQ_QSPI_WAIT (CONFIG_SYS_HZ / 100) /* 10 ms */
55 /* zynq qspi register set */
56 struct zynq_qspi_regs {
75 u32 lqspicfg; /* 0xA0 */
76 u32 lqspists; /* 0xA4 */
79 /* zynq qspi platform data */
80 struct zynq_qspi_plat {
81 struct zynq_qspi_regs *regs;
82 u32 frequency; /* input frequency */
87 struct zynq_qspi_priv {
88 struct zynq_qspi_regs *regs;
92 u32 freq; /* required frequency */
96 int bytes_to_transfer;
102 static int zynq_qspi_of_to_plat(struct udevice *bus)
104 struct zynq_qspi_plat *plat = dev_get_plat(bus);
105 const void *blob = gd->fdt_blob;
106 int node = dev_of_offset(bus);
108 plat->regs = (struct zynq_qspi_regs *)fdtdec_get_addr(blob,
115 * zynq_qspi_init_hw - Initialize the hardware
116 * @priv: Pointer to the zynq_qspi_priv structure
118 * The default settings of the QSPI controller's configurable parameters on
121 * - Baud rate divisor is set to 2
122 * - Threshold value for TX FIFO not full interrupt is set to 1
123 * - Flash memory interface mode enabled
124 * - Size of the word to be transferred as 8 bit
125 * This function performs the following actions
126 * - Disable and clear all the interrupts
127 * - Enable manual slave select
128 * - Enable auto start
129 * - Deselect all the chip select lines
130 * - Set the size of the word to be transferred as 32 bit
131 * - Set the little endian mode of TX FIFO and
132 * - Enable the QSPI controller
134 static void zynq_qspi_init_hw(struct zynq_qspi_priv *priv)
136 struct zynq_qspi_regs *regs = priv->regs;
140 writel(~ZYNQ_QSPI_ENR_SPI_EN_MASK, ®s->enr);
142 /* Disable Interrupts */
143 writel(ZYNQ_QSPI_IXR_ALL_MASK, ®s->idr);
145 /* Clear the TX and RX threshold reg */
146 writel(ZYNQ_QSPI_TXFIFO_THRESHOLD, ®s->txftr);
147 writel(ZYNQ_QSPI_RXFIFO_THRESHOLD, ®s->rxftr);
149 /* Clear the RX FIFO */
150 while (readl(®s->isr) & ZYNQ_QSPI_IXR_RXNEMPTY_MASK)
153 /* Clear Interrupts */
154 writel(ZYNQ_QSPI_IXR_ALL_MASK, ®s->isr);
156 /* Manual slave select and Auto start */
157 confr = readl(®s->cr);
158 confr &= ~ZYNQ_QSPI_CR_MSA_MASK;
159 confr |= ZYNQ_QSPI_CR_IFMODE_MASK | ZYNQ_QSPI_CR_MCS_MASK |
160 ZYNQ_QSPI_CR_PCS_MASK | ZYNQ_QSPI_CR_FW_MASK |
161 ZYNQ_QSPI_CR_MSTREN_MASK;
162 writel(confr, ®s->cr);
164 /* Disable the LQSPI feature */
165 confr = readl(®s->lqspicfg);
166 confr &= ~ZYNQ_QSPI_LQSPICFG_LQMODE_MASK;
167 writel(confr, ®s->lqspicfg);
170 writel(ZYNQ_QSPI_ENR_SPI_EN_MASK, ®s->enr);
173 static int zynq_qspi_probe(struct udevice *bus)
175 struct zynq_qspi_plat *plat = dev_get_plat(bus);
176 struct zynq_qspi_priv *priv = dev_get_priv(bus);
181 priv->regs = plat->regs;
182 priv->fifo_depth = ZYNQ_QSPI_FIFO_DEPTH;
184 ret = clk_get_by_name(bus, "ref_clk", &clk);
186 dev_err(bus, "failed to get clock\n");
190 clock = clk_get_rate(&clk);
191 if (IS_ERR_VALUE(clock)) {
192 dev_err(bus, "failed to get rate\n");
196 ret = clk_enable(&clk);
198 dev_err(bus, "failed to enable clock\n");
202 /* init the zynq spi hw */
203 zynq_qspi_init_hw(priv);
205 plat->frequency = clock;
206 plat->speed_hz = plat->frequency / 2;
208 debug("%s: max-frequency=%d\n", __func__, plat->speed_hz);
214 * zynq_qspi_read_data - Copy data to RX buffer
215 * @priv: Pointer to the zynq_qspi_priv structure
216 * @data: The 32 bit variable where data is stored
217 * @size: Number of bytes to be copied from data to RX buffer
219 static void zynq_qspi_read_data(struct zynq_qspi_priv *priv, u32 data, u8 size)
223 debug("%s: data 0x%04x rx_buf addr: 0x%08x size %d\n", __func__ ,
224 data, (unsigned)(priv->rx_buf), size);
229 *((u8 *)priv->rx_buf) = data;
233 *((u8 *)priv->rx_buf) = data;
235 *((u8 *)priv->rx_buf) = (u8)(data >> 8);
239 *((u8 *)priv->rx_buf) = data;
241 *((u8 *)priv->rx_buf) = (u8)(data >> 8);
243 byte3 = (u8)(data >> 16);
244 *((u8 *)priv->rx_buf) = byte3;
248 /* Can not assume word aligned buffer */
249 memcpy(priv->rx_buf, &data, size);
253 /* This will never execute */
257 priv->bytes_to_receive -= size;
258 if (priv->bytes_to_receive < 0)
259 priv->bytes_to_receive = 0;
263 * zynq_qspi_write_data - Copy data from TX buffer
264 * @priv: Pointer to the zynq_qspi_priv structure
265 * @data: Pointer to the 32 bit variable where data is to be copied
266 * @size: Number of bytes to be copied from TX buffer to data
268 static void zynq_qspi_write_data(struct zynq_qspi_priv *priv,
274 *data = *((u8 *)priv->tx_buf);
279 *data = *((u16 *)priv->tx_buf);
284 *data = *((u16 *)priv->tx_buf);
286 *data |= (*((u8 *)priv->tx_buf) << 16);
291 /* Can not assume word aligned buffer */
292 memcpy(data, priv->tx_buf, size);
296 /* This will never execute */
303 debug("%s: data 0x%08x tx_buf addr: 0x%08x size %d\n", __func__,
304 *data, (u32)priv->tx_buf, size);
306 priv->bytes_to_transfer -= size;
307 if (priv->bytes_to_transfer < 0)
308 priv->bytes_to_transfer = 0;
312 * zynq_qspi_chipselect - Select or deselect the chip select line
313 * @priv: Pointer to the zynq_qspi_priv structure
314 * @is_on: Select(1) or deselect (0) the chip select line
316 static void zynq_qspi_chipselect(struct zynq_qspi_priv *priv, int is_on)
319 struct zynq_qspi_regs *regs = priv->regs;
321 confr = readl(®s->cr);
324 /* Select the slave */
325 confr &= ~ZYNQ_QSPI_CR_SS_MASK;
326 confr |= (~(1 << priv->cs) << ZYNQ_QSPI_CR_SS_SHIFT) &
327 ZYNQ_QSPI_CR_SS_MASK;
329 /* Deselect the slave */
330 confr |= ZYNQ_QSPI_CR_SS_MASK;
332 writel(confr, ®s->cr);
336 * zynq_qspi_fill_tx_fifo - Fills the TX FIFO with as many bytes as possible
337 * @priv: Pointer to the zynq_qspi_priv structure
338 * @size: Number of bytes to be copied to fifo
340 static void zynq_qspi_fill_tx_fifo(struct zynq_qspi_priv *priv, u32 size)
344 unsigned len, offset;
345 struct zynq_qspi_regs *regs = priv->regs;
346 static const unsigned offsets[4] = {
347 ZYNQ_QSPI_TXD_00_00_OFFSET, ZYNQ_QSPI_TXD_00_01_OFFSET,
348 ZYNQ_QSPI_TXD_00_10_OFFSET, ZYNQ_QSPI_TXD_00_11_OFFSET };
350 while ((fifocount < size) &&
351 (priv->bytes_to_transfer > 0)) {
352 if (priv->bytes_to_transfer >= 4) {
354 memcpy(&data, priv->tx_buf, 4);
359 writel(data, ®s->txd0r);
360 priv->bytes_to_transfer -= 4;
363 /* Write TXD1, TXD2, TXD3 only if TxFIFO is empty. */
364 if (!(readl(®s->isr)
365 & ZYNQ_QSPI_IXR_TXOW_MASK) &&
368 len = priv->bytes_to_transfer;
369 zynq_qspi_write_data(priv, &data, len);
370 offset = (priv->rx_buf) ? offsets[0] : offsets[len];
371 writel(data, ®s->cr + (offset / 4));
377 * zynq_qspi_irq_poll - Interrupt service routine of the QSPI controller
378 * @priv: Pointer to the zynq_qspi structure
380 * This function handles TX empty and Mode Fault interrupts only.
381 * On TX empty interrupt this function reads the received data from RX FIFO and
382 * fills the TX FIFO if there is any data remaining to be transferred.
383 * On Mode Fault interrupt this function indicates that transfer is completed,
384 * the SPI subsystem will identify the error as the remaining bytes to be
385 * transferred is non-zero.
387 * returns: 0 for poll timeout
388 * 1 transfer operation complete
390 static int zynq_qspi_irq_poll(struct zynq_qspi_priv *priv)
392 struct zynq_qspi_regs *regs = priv->regs;
397 /* Poll until any of the interrupt status bits are set */
398 timeout = get_timer(0);
400 status = readl(®s->isr);
401 } while ((status == 0) &&
402 (get_timer(timeout) < ZYNQ_QSPI_WAIT));
405 printf("zynq_qspi_irq_poll: Timeout!\n");
409 writel(status, ®s->isr);
411 /* Disable all interrupts */
412 writel(ZYNQ_QSPI_IXR_ALL_MASK, ®s->idr);
413 if ((status & ZYNQ_QSPI_IXR_TXOW_MASK) ||
414 (status & ZYNQ_QSPI_IXR_RXNEMPTY_MASK)) {
416 * This bit is set when Tx FIFO has < THRESHOLD entries. We have
417 * the THRESHOLD value set to 1, so this bit indicates Tx FIFO
420 rxcount = priv->bytes_to_receive - priv->bytes_to_transfer;
421 rxcount = (rxcount % 4) ? ((rxcount/4)+1) : (rxcount/4);
422 while ((rxindex < rxcount) &&
423 (rxindex < ZYNQ_QSPI_RXFIFO_THRESHOLD)) {
424 /* Read out the data from the RX FIFO */
426 data = readl(®s->drxr);
428 if (priv->bytes_to_receive >= 4) {
430 memcpy(priv->rx_buf, &data, 4);
433 priv->bytes_to_receive -= 4;
435 zynq_qspi_read_data(priv, data,
436 priv->bytes_to_receive);
441 if (priv->bytes_to_transfer) {
442 /* There is more data to send */
443 zynq_qspi_fill_tx_fifo(priv,
444 ZYNQ_QSPI_RXFIFO_THRESHOLD);
446 writel(ZYNQ_QSPI_IXR_ALL_MASK, ®s->ier);
449 * If transfer and receive is completed then only send
452 if (!priv->bytes_to_receive) {
453 /* return operation complete */
454 writel(ZYNQ_QSPI_IXR_ALL_MASK,
465 * zynq_qspi_start_transfer - Initiates the QSPI transfer
466 * @priv: Pointer to the zynq_qspi_priv structure
468 * This function fills the TX FIFO, starts the QSPI transfer, and waits for the
469 * transfer to be completed.
471 * returns: Number of bytes transferred in the last transfer
473 static int zynq_qspi_start_transfer(struct zynq_qspi_priv *priv)
476 struct zynq_qspi_regs *regs = priv->regs;
478 debug("%s: qspi: 0x%08x transfer: 0x%08x len: %d\n", __func__,
479 (u32)priv, (u32)priv, priv->len);
481 priv->bytes_to_transfer = priv->len;
482 priv->bytes_to_receive = priv->len;
485 zynq_qspi_fill_tx_fifo(priv, priv->len);
487 zynq_qspi_fill_tx_fifo(priv, priv->fifo_depth);
489 writel(ZYNQ_QSPI_IXR_ALL_MASK, ®s->ier);
491 /* wait for completion */
493 data = zynq_qspi_irq_poll(priv);
496 return (priv->len) - (priv->bytes_to_transfer);
499 static int zynq_qspi_transfer(struct zynq_qspi_priv *priv)
501 unsigned cs_change = 1;
505 /* Select the chip if required */
507 zynq_qspi_chipselect(priv, 1);
509 cs_change = priv->cs_change;
511 if (!priv->tx_buf && !priv->rx_buf && priv->len) {
516 /* Request the transfer */
518 status = zynq_qspi_start_transfer(priv);
522 if (status != priv->len) {
525 debug("zynq_qspi_transfer:%d len:%d\n",
532 /* Deselect the chip */
533 zynq_qspi_chipselect(priv, 0);
541 static int zynq_qspi_claim_bus(struct udevice *dev)
543 struct udevice *bus = dev->parent;
544 struct zynq_qspi_priv *priv = dev_get_priv(bus);
545 struct zynq_qspi_regs *regs = priv->regs;
547 writel(ZYNQ_QSPI_ENR_SPI_EN_MASK, ®s->enr);
552 static int zynq_qspi_release_bus(struct udevice *dev)
554 struct udevice *bus = dev->parent;
555 struct zynq_qspi_priv *priv = dev_get_priv(bus);
556 struct zynq_qspi_regs *regs = priv->regs;
558 writel(~ZYNQ_QSPI_ENR_SPI_EN_MASK, ®s->enr);
563 static int zynq_qspi_xfer(struct udevice *dev, unsigned int bitlen,
564 const void *dout, void *din, unsigned long flags)
566 struct udevice *bus = dev->parent;
567 struct zynq_qspi_priv *priv = dev_get_priv(bus);
568 struct dm_spi_slave_plat *slave_plat = dev_get_parent_plat(dev);
570 priv->cs = slave_plat->cs;
573 priv->len = bitlen / 8;
575 debug("zynq_qspi_xfer: bus:%i cs:%i bitlen:%i len:%i flags:%lx\n",
576 dev_seq(bus), slave_plat->cs, bitlen, priv->len, flags);
580 * Assume that the beginning of a transfer with bits to
581 * transmit must contain a device command.
583 if (dout && flags & SPI_XFER_BEGIN)
588 if (flags & SPI_XFER_END)
593 zynq_qspi_transfer(priv);
598 static int zynq_qspi_set_speed(struct udevice *bus, uint speed)
600 struct zynq_qspi_plat *plat = dev_get_plat(bus);
601 struct zynq_qspi_priv *priv = dev_get_priv(bus);
602 struct zynq_qspi_regs *regs = priv->regs;
604 u8 baud_rate_val = 0;
606 if (speed > plat->frequency)
607 speed = plat->frequency;
609 /* Set the clock frequency */
610 confr = readl(®s->cr);
612 /* Set baudrate x8, if the freq is 0 */
614 } else if (plat->speed_hz != speed) {
615 while ((baud_rate_val < ZYNQ_QSPI_CR_BAUD_MAX) &&
617 (2 << baud_rate_val)) > speed))
620 plat->speed_hz = speed / (2 << baud_rate_val);
622 confr &= ~ZYNQ_QSPI_CR_BAUD_MASK;
623 confr |= (baud_rate_val << ZYNQ_QSPI_CR_BAUD_SHIFT);
625 writel(confr, ®s->cr);
628 debug("%s: regs=%p, speed=%d\n", __func__, priv->regs, priv->freq);
633 static int zynq_qspi_set_mode(struct udevice *bus, uint mode)
635 struct zynq_qspi_priv *priv = dev_get_priv(bus);
636 struct zynq_qspi_regs *regs = priv->regs;
639 /* Set the SPI Clock phase and polarities */
640 confr = readl(®s->cr);
641 confr &= ~(ZYNQ_QSPI_CR_CPHA_MASK | ZYNQ_QSPI_CR_CPOL_MASK);
644 confr |= ZYNQ_QSPI_CR_CPHA_MASK;
646 confr |= ZYNQ_QSPI_CR_CPOL_MASK;
648 writel(confr, ®s->cr);
651 debug("%s: regs=%p, mode=%d\n", __func__, priv->regs, priv->mode);
656 static const struct dm_spi_ops zynq_qspi_ops = {
657 .claim_bus = zynq_qspi_claim_bus,
658 .release_bus = zynq_qspi_release_bus,
659 .xfer = zynq_qspi_xfer,
660 .set_speed = zynq_qspi_set_speed,
661 .set_mode = zynq_qspi_set_mode,
664 static const struct udevice_id zynq_qspi_ids[] = {
665 { .compatible = "xlnx,zynq-qspi-1.0" },
669 U_BOOT_DRIVER(zynq_qspi) = {
672 .of_match = zynq_qspi_ids,
673 .ops = &zynq_qspi_ops,
674 .of_to_plat = zynq_qspi_of_to_plat,
675 .plat_auto = sizeof(struct zynq_qspi_plat),
676 .priv_auto = sizeof(struct zynq_qspi_priv),
677 .probe = zynq_qspi_probe,