drivers/spi/exynos_spi.c

   1 /*
   2  * (C) Copyright 2012 SAMSUNG Electronics
   3  * Padmavathi Venna <padma.v@samsung.com>
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <common.h>
   9 #include <dm.h>
  10 #include <errno.h>
  11 #include <malloc.h>
  12 #include <spi.h>
  13 #include <fdtdec.h>
  14 #include <asm/arch/clk.h>
  15 #include <asm/arch/clock.h>
  16 #include <asm/arch/cpu.h>
  17 #include <asm/arch/gpio.h>
  18 #include <asm/arch/pinmux.h>
  19 #include <asm/arch-exynos/spi.h>
  20 #include <asm/io.h>
  21
  22 DECLARE_GLOBAL_DATA_PTR;
  23
  24 struct exynos_spi_platdata {
  25         enum periph_id periph_id;
  26         s32 frequency;          /* Default clock frequency, -1 for none */
  27         struct exynos_spi *regs;
  28         uint deactivate_delay_us;       /* Delay to wait after deactivate */
  29 };
  30
  31 struct exynos_spi_priv {
  32         struct exynos_spi *regs;
  33         unsigned int freq;              /* Default frequency */
  34         unsigned int mode;
  35         enum periph_id periph_id;       /* Peripheral ID for this device */
  36         unsigned int fifo_size;
  37         int skip_preamble;
  38         ulong last_transaction_us;      /* Time of last transaction end */
  39 };
  40
  41 /**
  42  * Flush spi tx, rx fifos and reset the SPI controller
  43  *
  44  * @param regs  Pointer to SPI registers
  45  */
  46 static void spi_flush_fifo(struct exynos_spi *regs)
  47 {
  48         clrsetbits_le32(&regs->ch_cfg, SPI_CH_HS_EN, SPI_CH_RST);
  49         clrbits_le32(&regs->ch_cfg, SPI_CH_RST);
  50         setbits_le32(&regs->ch_cfg, SPI_TX_CH_ON | SPI_RX_CH_ON);
  51 }
  52
  53 static void spi_get_fifo_levels(struct exynos_spi *regs,
  54         int *rx_lvl, int *tx_lvl)
  55 {
  56         uint32_t spi_sts = readl(&regs->spi_sts);
  57
  58         *rx_lvl = (spi_sts >> SPI_RX_LVL_OFFSET) & SPI_FIFO_LVL_MASK;
  59         *tx_lvl = (spi_sts >> SPI_TX_LVL_OFFSET) & SPI_FIFO_LVL_MASK;
  60 }
  61
  62 /**
  63  * If there's something to transfer, do a software reset and set a
  64  * transaction size.
  65  *
  66  * @param regs  SPI peripheral registers
  67  * @param count Number of bytes to transfer
  68  * @param step  Number of bytes to transfer in each packet (1 or 4)
  69  */
  70 static void spi_request_bytes(struct exynos_spi *regs, int count, int step)
  71 {
  72         debug("%s: regs=%p, count=%d, step=%d\n", __func__, regs, count, step);
  73
  74         /* For word address we need to swap bytes */
  75         if (step == 4) {
  76                 setbits_le32(&regs->mode_cfg,
  77                              SPI_MODE_CH_WIDTH_WORD | SPI_MODE_BUS_WIDTH_WORD);
  78                 count /= 4;
  79                 setbits_le32(&regs->swap_cfg, SPI_TX_SWAP_EN | SPI_RX_SWAP_EN |
  80                         SPI_TX_BYTE_SWAP | SPI_RX_BYTE_SWAP |
  81                         SPI_TX_HWORD_SWAP | SPI_RX_HWORD_SWAP);
  82         } else {
  83                 /* Select byte access and clear the swap configuration */
  84                 clrbits_le32(&regs->mode_cfg,
  85                              SPI_MODE_CH_WIDTH_WORD | SPI_MODE_BUS_WIDTH_WORD);
  86                 writel(0, &regs->swap_cfg);
  87         }
  88
  89         assert(count && count < (1 << 16));
  90         setbits_le32(&regs->ch_cfg, SPI_CH_RST);
  91         clrbits_le32(&regs->ch_cfg, SPI_CH_RST);
  92
  93         writel(count | SPI_PACKET_CNT_EN, &regs->pkt_cnt);
  94 }
  95
  96 static int spi_rx_tx(struct exynos_spi_priv *priv, int todo,
  97                         void **dinp, void const **doutp, unsigned long flags)
  98 {
  99         struct exynos_spi *regs = priv->regs;
 100         uchar *rxp = *dinp;
 101         const uchar *txp = *doutp;
 102         int rx_lvl, tx_lvl;
 103         uint out_bytes, in_bytes;
 104         int toread;
 105         unsigned start = get_timer(0);
 106         int stopping;
 107         int step;
 108
 109         out_bytes = in_bytes = todo;
 110
 111         stopping = priv->skip_preamble && (flags & SPI_XFER_END) &&
 112                                         !(priv->mode & SPI_SLAVE);
 113
 114         /*
 115          * Try to transfer words if we can. This helps read performance at
 116          * SPI clock speeds above about 20MHz.
 117          */
 118         step = 1;
 119         if (!((todo | (uintptr_t)rxp | (uintptr_t)txp) & 3) &&
 120             !priv->skip_preamble)
 121                 step = 4;
 122
 123         /*
 124          * If there's something to send, do a software reset and set a
 125          * transaction size.
 126          */
 127         spi_request_bytes(regs, todo, step);
 128
 129         /*
 130          * Bytes are transmitted/received in pairs. Wait to receive all the
 131          * data because then transmission will be done as well.
 132          */
 133         toread = in_bytes;
 134
 135         while (in_bytes) {
 136                 int temp;
 137
 138                 /* Keep the fifos full/empty. */
 139                 spi_get_fifo_levels(regs, &rx_lvl, &tx_lvl);
 140
 141                 /*
 142                  * Don't completely fill the txfifo, since we don't want our
 143                  * rxfifo to overflow, and it may already contain data.
 144                  */
 145                 while (tx_lvl < priv->fifo_size/2 && out_bytes) {
 146                         if (!txp)
 147                                 temp = -1;
 148                         else if (step == 4)
 149                                 temp = *(uint32_t *)txp;
 150                         else
 151                                 temp = *txp;
 152                         writel(temp, &regs->tx_data);
 153                         out_bytes -= step;
 154                         if (txp)
 155                                 txp += step;
 156                         tx_lvl += step;
 157                 }
 158                 if (rx_lvl >= step) {
 159                         while (rx_lvl >= step) {
 160                                 temp = readl(&regs->rx_data);
 161                                 if (priv->skip_preamble) {
 162                                         if (temp == SPI_PREAMBLE_END_BYTE) {
 163                                                 priv->skip_preamble = 0;
 164                                                 stopping = 0;
 165                                         }
 166                                 } else {
 167                                         if (rxp || stopping) {
 168                                                 if (step == 4)
 169                                                         *(uint32_t *)rxp = temp;
 170                                                 else
 171                                                         *rxp = temp;
 172                                                 rxp += step;
 173                                         }
 174                                         in_bytes -= step;
 175                                 }
 176                                 toread -= step;
 177                                 rx_lvl -= step;
 178                         }
 179                 } else if (!toread) {
 180                         /*
 181                          * We have run out of input data, but haven't read
 182                          * enough bytes after the preamble yet. Read some more,
 183                          * and make sure that we transmit dummy bytes too, to
 184                          * keep things going.
 185                          */
 186                         assert(!out_bytes);
 187                         out_bytes = in_bytes;
 188                         toread = in_bytes;
 189                         txp = NULL;
 190                         spi_request_bytes(regs, toread, step);
 191                 }
 192                 if (priv->skip_preamble && get_timer(start) > 100) {
 193                         printf("SPI timeout: in_bytes=%d, out_bytes=%d, ",
 194                                in_bytes, out_bytes);
 195                         return -1;
 196                 }
 197         }
 198
 199         *dinp = rxp;
 200         *doutp = txp;
 201
 202         return 0;
 203 }
 204
 205 /**
 206  * Activate the CS by driving it LOW
 207  *
 208  * @param slave Pointer to spi_slave to which controller has to
 209  *              communicate with
 210  */
 211 static void spi_cs_activate(struct udevice *dev)
 212 {
 213         struct udevice *bus = dev->parent;
 214         struct exynos_spi_platdata *pdata = dev_get_platdata(bus);
 215         struct exynos_spi_priv *priv = dev_get_priv(bus);
 216
 217         /* If it's too soon to do another transaction, wait */
 218         if (pdata->deactivate_delay_us &&
 219             priv->last_transaction_us) {
 220                 ulong delay_us;         /* The delay completed so far */
 221                 delay_us = timer_get_us() - priv->last_transaction_us;
 222                 if (delay_us < pdata->deactivate_delay_us)
 223                         udelay(pdata->deactivate_delay_us - delay_us);
 224         }
 225
 226         clrbits_le32(&priv->regs->cs_reg, SPI_SLAVE_SIG_INACT);
 227         debug("Activate CS, bus '%s'\n", bus->name);
 228         priv->skip_preamble = priv->mode & SPI_PREAMBLE;
 229 }
 230
 231 /**
 232  * Deactivate the CS by driving it HIGH
 233  *
 234  * @param slave Pointer to spi_slave to which controller has to
 235  *              communicate with
 236  */
 237 static void spi_cs_deactivate(struct udevice *dev)
 238 {
 239         struct udevice *bus = dev->parent;
 240         struct exynos_spi_platdata *pdata = dev_get_platdata(bus);
 241         struct exynos_spi_priv *priv = dev_get_priv(bus);
 242
 243         setbits_le32(&priv->regs->cs_reg, SPI_SLAVE_SIG_INACT);
 244
 245         /* Remember time of this transaction so we can honour the bus delay */
 246         if (pdata->deactivate_delay_us)
 247                 priv->last_transaction_us = timer_get_us();
 248
 249         debug("Deactivate CS, bus '%s'\n", bus->name);
 250 }
 251
 252 static int exynos_spi_ofdata_to_platdata(struct udevice *bus)
 253 {
 254         struct exynos_spi_platdata *plat = bus->platdata;
 255         const void *blob = gd->fdt_blob;
 256         int node = bus->of_offset;
 257
 258         plat->regs = (struct exynos_spi *)fdtdec_get_addr(blob, node, "reg");
 259         plat->periph_id = pinmux_decode_periph_id(blob, node);
 260
 261         if (plat->periph_id == PERIPH_ID_NONE) {
 262                 debug("%s: Invalid peripheral ID %d\n", __func__,
 263                         plat->periph_id);
 264                 return -FDT_ERR_NOTFOUND;
 265         }
 266
 267         /* Use 500KHz as a suitable default */
 268         plat->frequency = fdtdec_get_int(blob, node, "spi-max-frequency",
 269                                         500000);
 270         plat->deactivate_delay_us = fdtdec_get_int(blob, node,
 271                                         "spi-deactivate-delay", 0);
 272         debug("%s: regs=%p, periph_id=%d, max-frequency=%d, deactivate_delay=%d\n",
 273               __func__, plat->regs, plat->periph_id, plat->frequency,
 274               plat->deactivate_delay_us);
 275
 276         return 0;
 277 }
 278
 279 static int exynos_spi_probe(struct udevice *bus)
 280 {
 281         struct exynos_spi_platdata *plat = dev_get_platdata(bus);
 282         struct exynos_spi_priv *priv = dev_get_priv(bus);
 283
 284         priv->regs = plat->regs;
 285         if (plat->periph_id == PERIPH_ID_SPI1 ||
 286             plat->periph_id == PERIPH_ID_SPI2)
 287                 priv->fifo_size = 64;
 288         else
 289                 priv->fifo_size = 256;
 290
 291         priv->skip_preamble = 0;
 292         priv->last_transaction_us = timer_get_us();
 293         priv->freq = plat->frequency;
 294         priv->periph_id = plat->periph_id;
 295
 296         return 0;
 297 }
 298
 299 static int exynos_spi_claim_bus(struct udevice *bus)
 300 {
 301         struct exynos_spi_priv *priv = dev_get_priv(bus);
 302
 303         exynos_pinmux_config(priv->periph_id, PINMUX_FLAG_NONE);
 304         spi_flush_fifo(priv->regs);
 305
 306         writel(SPI_FB_DELAY_180, &priv->regs->fb_clk);
 307
 308         return 0;
 309 }
 310
 311 static int exynos_spi_release_bus(struct udevice *bus)
 312 {
 313         struct exynos_spi_priv *priv = dev_get_priv(bus);
 314
 315         spi_flush_fifo(priv->regs);
 316
 317         return 0;
 318 }
 319
 320 static int exynos_spi_xfer(struct udevice *dev, unsigned int bitlen,
 321                            const void *dout, void *din, unsigned long flags)
 322 {
 323         struct udevice *bus = dev->parent;
 324         struct exynos_spi_priv *priv = dev_get_priv(bus);
 325         int upto, todo;
 326         int bytelen;
 327         int ret = 0;
 328
 329         /* spi core configured to do 8 bit transfers */
 330         if (bitlen % 8) {
 331                 debug("Non byte aligned SPI transfer.\n");
 332                 return -1;
 333         }
 334
 335         /* Start the transaction, if necessary. */
 336         if ((flags & SPI_XFER_BEGIN))
 337                 spi_cs_activate(dev);
 338
 339         /*
 340          * Exynos SPI limits each transfer to 65535 transfers. To keep
 341          * things simple, allow a maximum of 65532 bytes. We could allow
 342          * more in word mode, but the performance difference is small.
 343          */
 344         bytelen = bitlen / 8;
 345         for (upto = 0; !ret && upto < bytelen; upto += todo) {
 346                 todo = min(bytelen - upto, (1 << 16) - 4);
 347                 ret = spi_rx_tx(priv, todo, &din, &dout, flags);
 348                 if (ret)
 349                         break;
 350         }
 351
 352         /* Stop the transaction, if necessary. */
 353         if ((flags & SPI_XFER_END) && !(priv->mode & SPI_SLAVE)) {
 354                 spi_cs_deactivate(dev);
 355                 if (priv->skip_preamble) {
 356                         assert(!priv->skip_preamble);
 357                         debug("Failed to complete premable transaction\n");
 358                         ret = -1;
 359                 }
 360         }
 361
 362         return ret;
 363 }
 364
 365 static int exynos_spi_set_speed(struct udevice *bus, uint speed)
 366 {
 367         struct exynos_spi_platdata *plat = bus->platdata;
 368         struct exynos_spi_priv *priv = dev_get_priv(bus);
 369         int ret;
 370
 371         if (speed > plat->frequency)
 372                 speed = plat->frequency;
 373         ret = set_spi_clk(priv->periph_id, speed);
 374         if (ret)
 375                 return ret;
 376         priv->freq = speed;
 377         debug("%s: regs=%p, speed=%d\n", __func__, priv->regs, priv->freq);
 378
 379         return 0;
 380 }
 381
 382 static int exynos_spi_set_mode(struct udevice *bus, uint mode)
 383 {
 384         struct exynos_spi_priv *priv = dev_get_priv(bus);
 385         uint32_t reg;
 386
 387         reg = readl(&priv->regs->ch_cfg);
 388         reg &= ~(SPI_CH_CPHA_B | SPI_CH_CPOL_L);
 389
 390         if (mode & SPI_CPHA)
 391                 reg |= SPI_CH_CPHA_B;
 392
 393         if (mode & SPI_CPOL)
 394                 reg |= SPI_CH_CPOL_L;
 395
 396         writel(reg, &priv->regs->ch_cfg);
 397         priv->mode = mode;
 398         debug("%s: regs=%p, mode=%d\n", __func__, priv->regs, priv->mode);
 399
 400         return 0;
 401 }
 402
 403 static const struct dm_spi_ops exynos_spi_ops = {
 404         .claim_bus      = exynos_spi_claim_bus,
 405         .release_bus    = exynos_spi_release_bus,
 406         .xfer           = exynos_spi_xfer,
 407         .set_speed      = exynos_spi_set_speed,
 408         .set_mode       = exynos_spi_set_mode,
 409         /*
 410          * cs_info is not needed, since we require all chip selects to be
 411          * in the device tree explicitly
 412          */
 413 };
 414
 415 static const struct udevice_id exynos_spi_ids[] = {
 416         { .compatible = "samsung,exynos-spi" },
 417         { }
 418 };
 419
 420 U_BOOT_DRIVER(exynos_spi) = {
 421         .name   = "exynos_spi",
 422         .id     = UCLASS_SPI,
 423         .of_match = exynos_spi_ids,
 424         .ops    = &exynos_spi_ops,
 425         .ofdata_to_platdata = exynos_spi_ofdata_to_platdata,
 426         .platdata_auto_alloc_size = sizeof(struct exynos_spi_platdata),
 427         .priv_auto_alloc_size = sizeof(struct exynos_spi_priv),
 428         .per_child_auto_alloc_size      = sizeof(struct spi_slave),
 429         .probe  = exynos_spi_probe,
 430 };