drivers/spi/zynq_spi.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2013 Xilinx, Inc.
   4  * (C) Copyright 2015 Jagan Teki <jteki@openedev.com>
   5  *
   6  * Xilinx Zynq PS SPI controller driver (master mode only)
   7  */
   8
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <log.h>
  12 #include <malloc.h>
  13 #include <spi.h>
  14 #include <time.h>
  15 #include <asm/io.h>
  16 #include <linux/bitops.h>
  17 #include <linux/delay.h>
  18
  19 DECLARE_GLOBAL_DATA_PTR;
  20
  21 /* zynq spi register bit masks ZYNQ_SPI_<REG>_<BIT>_MASK */
  22 #define ZYNQ_SPI_CR_MSA_MASK            BIT(15) /* Manual start enb */
  23 #define ZYNQ_SPI_CR_MCS_MASK            BIT(14) /* Manual chip select */
  24 #define ZYNQ_SPI_CR_CS_MASK             GENMASK(13, 10) /* Chip select */
  25 #define ZYNQ_SPI_CR_BAUD_MASK           GENMASK(5, 3)   /* Baud rate div */
  26 #define ZYNQ_SPI_CR_CPHA_MASK           BIT(2)  /* Clock phase */
  27 #define ZYNQ_SPI_CR_CPOL_MASK           BIT(1)  /* Clock polarity */
  28 #define ZYNQ_SPI_CR_MSTREN_MASK         BIT(0)  /* Mode select */
  29 #define ZYNQ_SPI_IXR_RXNEMPTY_MASK      BIT(4)  /* RX_FIFO_not_empty */
  30 #define ZYNQ_SPI_IXR_TXOW_MASK          BIT(2)  /* TX_FIFO_not_full */
  31 #define ZYNQ_SPI_IXR_ALL_MASK           GENMASK(6, 0)   /* All IXR bits */
  32 #define ZYNQ_SPI_ENR_SPI_EN_MASK        BIT(0)  /* SPI Enable */
  33
  34 #define ZYNQ_SPI_CR_BAUD_MAX            8       /* Baud rate divisor max val */
  35 #define ZYNQ_SPI_CR_BAUD_SHIFT          3       /* Baud rate divisor shift */
  36 #define ZYNQ_SPI_CR_SS_SHIFT            10      /* Slave select shift */
  37
  38 #define ZYNQ_SPI_FIFO_DEPTH             128
  39 #define ZYNQ_SPI_WAIT                   (CONFIG_SYS_HZ / 100)   /* 10 ms */
  40
  41 /* zynq spi register set */
  42 struct zynq_spi_regs {
  43         u32 cr;         /* 0x00 */
  44         u32 isr;        /* 0x04 */
  45         u32 ier;        /* 0x08 */
  46         u32 idr;        /* 0x0C */
  47         u32 imr;        /* 0x10 */
  48         u32 enr;        /* 0x14 */
  49         u32 dr;         /* 0x18 */
  50         u32 txdr;       /* 0x1C */
  51         u32 rxdr;       /* 0x20 */
  52 };
  53
  54
  55 /* zynq spi platform data */
  56 struct zynq_spi_platdata {
  57         struct zynq_spi_regs *regs;
  58         u32 frequency;          /* input frequency */
  59         u32 speed_hz;
  60         uint deactivate_delay_us;       /* Delay to wait after deactivate */
  61         uint activate_delay_us;         /* Delay to wait after activate */
  62 };
  63
  64 /* zynq spi priv */
  65 struct zynq_spi_priv {
  66         struct zynq_spi_regs *regs;
  67         u8 cs;
  68         u8 mode;
  69         ulong last_transaction_us;      /* Time of last transaction end */
  70         u8 fifo_depth;
  71         u32 freq;               /* required frequency */
  72 };
  73
  74 static int zynq_spi_ofdata_to_platdata(struct udevice *bus)
  75 {
  76         struct zynq_spi_platdata *plat = bus->platdata;
  77         const void *blob = gd->fdt_blob;
  78         int node = dev_of_offset(bus);
  79
  80         plat->regs = (struct zynq_spi_regs *)devfdt_get_addr(bus);
  81
  82         /* FIXME: Use 250MHz as a suitable default */
  83         plat->frequency = fdtdec_get_int(blob, node, "spi-max-frequency",
  84                                         250000000);
  85         plat->deactivate_delay_us = fdtdec_get_int(blob, node,
  86                                         "spi-deactivate-delay", 0);
  87         plat->activate_delay_us = fdtdec_get_int(blob, node,
  88                                                  "spi-activate-delay", 0);
  89         plat->speed_hz = plat->frequency / 2;
  90
  91         debug("%s: regs=%p max-frequency=%d\n", __func__,
  92               plat->regs, plat->frequency);
  93
  94         return 0;
  95 }
  96
  97 static void zynq_spi_init_hw(struct zynq_spi_priv *priv)
  98 {
  99         struct zynq_spi_regs *regs = priv->regs;
 100         u32 confr;
 101
 102         /* Disable SPI */
 103         confr = ZYNQ_SPI_ENR_SPI_EN_MASK;
 104         writel(~confr, &regs->enr);
 105
 106         /* Disable Interrupts */
 107         writel(ZYNQ_SPI_IXR_ALL_MASK, &regs->idr);
 108
 109         /* Clear RX FIFO */
 110         while (readl(&regs->isr) &
 111                         ZYNQ_SPI_IXR_RXNEMPTY_MASK)
 112                 readl(&regs->rxdr);
 113
 114         /* Clear Interrupts */
 115         writel(ZYNQ_SPI_IXR_ALL_MASK, &regs->isr);
 116
 117         /* Manual slave select and Auto start */
 118         confr = ZYNQ_SPI_CR_MCS_MASK | ZYNQ_SPI_CR_CS_MASK |
 119                 ZYNQ_SPI_CR_MSTREN_MASK;
 120         confr &= ~ZYNQ_SPI_CR_MSA_MASK;
 121         writel(confr, &regs->cr);
 122
 123         /* Enable SPI */
 124         writel(ZYNQ_SPI_ENR_SPI_EN_MASK, &regs->enr);
 125 }
 126
 127 static int zynq_spi_probe(struct udevice *bus)
 128 {
 129         struct zynq_spi_platdata *plat = dev_get_platdata(bus);
 130         struct zynq_spi_priv *priv = dev_get_priv(bus);
 131
 132         priv->regs = plat->regs;
 133         priv->fifo_depth = ZYNQ_SPI_FIFO_DEPTH;
 134
 135         /* init the zynq spi hw */
 136         zynq_spi_init_hw(priv);
 137
 138         return 0;
 139 }
 140
 141 static void spi_cs_activate(struct udevice *dev)
 142 {
 143         struct udevice *bus = dev->parent;
 144         struct zynq_spi_platdata *plat = bus->platdata;
 145         struct zynq_spi_priv *priv = dev_get_priv(bus);
 146         struct zynq_spi_regs *regs = priv->regs;
 147         u32 cr;
 148
 149         /* If it's too soon to do another transaction, wait */
 150         if (plat->deactivate_delay_us && priv->last_transaction_us) {
 151                 ulong delay_us;         /* The delay completed so far */
 152                 delay_us = timer_get_us() - priv->last_transaction_us;
 153                 if (delay_us < plat->deactivate_delay_us)
 154                         udelay(plat->deactivate_delay_us - delay_us);
 155         }
 156
 157         clrbits_le32(&regs->cr, ZYNQ_SPI_CR_CS_MASK);
 158         cr = readl(&regs->cr);
 159         /*
 160          * CS cal logic: CS[13:10]
 161          * xxx0 - cs0
 162          * xx01 - cs1
 163          * x011 - cs2
 164          */
 165         cr |= (~(1 << priv->cs) << ZYNQ_SPI_CR_SS_SHIFT) & ZYNQ_SPI_CR_CS_MASK;
 166         writel(cr, &regs->cr);
 167
 168         if (plat->activate_delay_us)
 169                 udelay(plat->activate_delay_us);
 170 }
 171
 172 static void spi_cs_deactivate(struct udevice *dev)
 173 {
 174         struct udevice *bus = dev->parent;
 175         struct zynq_spi_platdata *plat = bus->platdata;
 176         struct zynq_spi_priv *priv = dev_get_priv(bus);
 177         struct zynq_spi_regs *regs = priv->regs;
 178
 179         setbits_le32(&regs->cr, ZYNQ_SPI_CR_CS_MASK);
 180
 181         /* Remember time of this transaction so we can honour the bus delay */
 182         if (plat->deactivate_delay_us)
 183                 priv->last_transaction_us = timer_get_us();
 184 }
 185
 186 static int zynq_spi_claim_bus(struct udevice *dev)
 187 {
 188         struct udevice *bus = dev->parent;
 189         struct zynq_spi_priv *priv = dev_get_priv(bus);
 190         struct zynq_spi_regs *regs = priv->regs;
 191
 192         writel(ZYNQ_SPI_ENR_SPI_EN_MASK, &regs->enr);
 193
 194         return 0;
 195 }
 196
 197 static int zynq_spi_release_bus(struct udevice *dev)
 198 {
 199         struct udevice *bus = dev->parent;
 200         struct zynq_spi_priv *priv = dev_get_priv(bus);
 201         struct zynq_spi_regs *regs = priv->regs;
 202         u32 confr;
 203
 204         confr = ZYNQ_SPI_ENR_SPI_EN_MASK;
 205         writel(~confr, &regs->enr);
 206
 207         return 0;
 208 }
 209
 210 static int zynq_spi_xfer(struct udevice *dev, unsigned int bitlen,
 211                             const void *dout, void *din, unsigned long flags)
 212 {
 213         struct udevice *bus = dev->parent;
 214         struct zynq_spi_priv *priv = dev_get_priv(bus);
 215         struct zynq_spi_regs *regs = priv->regs;
 216         struct dm_spi_slave_platdata *slave_plat = dev_get_parent_platdata(dev);
 217         u32 len = bitlen / 8;
 218         u32 tx_len = len, rx_len = len, tx_tvl;
 219         const u8 *tx_buf = dout;
 220         u8 *rx_buf = din, buf;
 221         u32 ts, status;
 222
 223         debug("spi_xfer: bus:%i cs:%i bitlen:%i len:%i flags:%lx\n",
 224               bus->seq, slave_plat->cs, bitlen, len, flags);
 225
 226         if (bitlen % 8) {
 227                 debug("spi_xfer: Non byte aligned SPI transfer\n");
 228                 return -1;
 229         }
 230
 231         priv->cs = slave_plat->cs;
 232         if (flags & SPI_XFER_BEGIN)
 233                 spi_cs_activate(dev);
 234
 235         while (rx_len > 0) {
 236                 /* Write the data into TX FIFO - tx threshold is fifo_depth */
 237                 tx_tvl = 0;
 238                 while ((tx_tvl < priv->fifo_depth) && tx_len) {
 239                         if (tx_buf)
 240                                 buf = *tx_buf++;
 241                         else
 242                                 buf = 0;
 243                         writel(buf, &regs->txdr);
 244                         tx_len--;
 245                         tx_tvl++;
 246                 }
 247
 248                 /* Check TX FIFO completion */
 249                 ts = get_timer(0);
 250                 status = readl(&regs->isr);
 251                 while (!(status & ZYNQ_SPI_IXR_TXOW_MASK)) {
 252                         if (get_timer(ts) > ZYNQ_SPI_WAIT) {
 253                                 printf("spi_xfer: Timeout! TX FIFO not full\n");
 254                                 return -1;
 255                         }
 256                         status = readl(&regs->isr);
 257                 }
 258
 259                 /* Read the data from RX FIFO */
 260                 status = readl(&regs->isr);
 261                 while ((status & ZYNQ_SPI_IXR_RXNEMPTY_MASK) && rx_len) {
 262                         buf = readl(&regs->rxdr);
 263                         if (rx_buf)
 264                                 *rx_buf++ = buf;
 265                         status = readl(&regs->isr);
 266                         rx_len--;
 267                 }
 268         }
 269
 270         if (flags & SPI_XFER_END)
 271                 spi_cs_deactivate(dev);
 272
 273         return 0;
 274 }
 275
 276 static int zynq_spi_set_speed(struct udevice *bus, uint speed)
 277 {
 278         struct zynq_spi_platdata *plat = bus->platdata;
 279         struct zynq_spi_priv *priv = dev_get_priv(bus);
 280         struct zynq_spi_regs *regs = priv->regs;
 281         uint32_t confr;
 282         u8 baud_rate_val = 0;
 283
 284         if (speed > plat->frequency)
 285                 speed = plat->frequency;
 286
 287         /* Set the clock frequency */
 288         confr = readl(&regs->cr);
 289         if (speed == 0) {
 290                 /* Set baudrate x8, if the freq is 0 */
 291                 baud_rate_val = 0x2;
 292         } else if (plat->speed_hz != speed) {
 293                 while ((baud_rate_val < ZYNQ_SPI_CR_BAUD_MAX) &&
 294                                 ((plat->frequency /
 295                                 (2 << baud_rate_val)) > speed))
 296                         baud_rate_val++;
 297                 plat->speed_hz = speed / (2 << baud_rate_val);
 298         }
 299         confr &= ~ZYNQ_SPI_CR_BAUD_MASK;
 300         confr |= (baud_rate_val << ZYNQ_SPI_CR_BAUD_SHIFT);
 301
 302         writel(confr, &regs->cr);
 303         priv->freq = speed;
 304
 305         debug("zynq_spi_set_speed: regs=%p, speed=%d\n",
 306               priv->regs, priv->freq);
 307
 308         return 0;
 309 }
 310
 311 static int zynq_spi_set_mode(struct udevice *bus, uint mode)
 312 {
 313         struct zynq_spi_priv *priv = dev_get_priv(bus);
 314         struct zynq_spi_regs *regs = priv->regs;
 315         uint32_t confr;
 316
 317         /* Set the SPI Clock phase and polarities */
 318         confr = readl(&regs->cr);
 319         confr &= ~(ZYNQ_SPI_CR_CPHA_MASK | ZYNQ_SPI_CR_CPOL_MASK);
 320
 321         if (mode & SPI_CPHA)
 322                 confr |= ZYNQ_SPI_CR_CPHA_MASK;
 323         if (mode & SPI_CPOL)
 324                 confr |= ZYNQ_SPI_CR_CPOL_MASK;
 325
 326         writel(confr, &regs->cr);
 327         priv->mode = mode;
 328
 329         debug("zynq_spi_set_mode: regs=%p, mode=%d\n", priv->regs, priv->mode);
 330
 331         return 0;
 332 }
 333
 334 static const struct dm_spi_ops zynq_spi_ops = {
 335         .claim_bus      = zynq_spi_claim_bus,
 336         .release_bus    = zynq_spi_release_bus,
 337         .xfer           = zynq_spi_xfer,
 338         .set_speed      = zynq_spi_set_speed,
 339         .set_mode       = zynq_spi_set_mode,
 340 };
 341
 342 static const struct udevice_id zynq_spi_ids[] = {
 343         { .compatible = "xlnx,zynq-spi-r1p6" },
 344         { .compatible = "cdns,spi-r1p6" },
 345         { }
 346 };
 347
 348 U_BOOT_DRIVER(zynq_spi) = {
 349         .name   = "zynq_spi",
 350         .id     = UCLASS_SPI,
 351         .of_match = zynq_spi_ids,
 352         .ops    = &zynq_spi_ops,
 353         .ofdata_to_platdata = zynq_spi_ofdata_to_platdata,
 354         .platdata_auto_alloc_size = sizeof(struct zynq_spi_platdata),
 355         .priv_auto_alloc_size = sizeof(struct zynq_spi_priv),
 356         .probe  = zynq_spi_probe,
 357 };