drivers/spi/spi-img-spfi.c

   1 /*
   2  * IMG SPFI controller driver
   3  *
   4  * Copyright (C) 2007,2008,2013 Imagination Technologies Ltd.
   5  * Copyright (C) 2014 Google, Inc.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms and conditions of the GNU General Public License,
   9  * version 2, as published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/clk.h>
  13 #include <linux/delay.h>
  14 #include <linux/dmaengine.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/io.h>
  17 #include <linux/irq.h>
  18 #include <linux/module.h>
  19 #include <linux/of.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/pm_runtime.h>
  22 #include <linux/scatterlist.h>
  23 #include <linux/slab.h>
  24 #include <linux/spi/spi.h>
  25 #include <linux/spinlock.h>
  26
  27 #define SPFI_DEVICE_PARAMETER(x)                (0x00 + 0x4 * (x))
  28 #define SPFI_DEVICE_PARAMETER_BITCLK_SHIFT      24
  29 #define SPFI_DEVICE_PARAMETER_BITCLK_MASK       0xff
  30 #define SPFI_DEVICE_PARAMETER_CSSETUP_SHIFT     16
  31 #define SPFI_DEVICE_PARAMETER_CSSETUP_MASK      0xff
  32 #define SPFI_DEVICE_PARAMETER_CSHOLD_SHIFT      8
  33 #define SPFI_DEVICE_PARAMETER_CSHOLD_MASK       0xff
  34 #define SPFI_DEVICE_PARAMETER_CSDELAY_SHIFT     0
  35 #define SPFI_DEVICE_PARAMETER_CSDELAY_MASK      0xff
  36
  37 #define SPFI_CONTROL                            0x14
  38 #define SPFI_CONTROL_CONTINUE                   BIT(12)
  39 #define SPFI_CONTROL_SOFT_RESET                 BIT(11)
  40 #define SPFI_CONTROL_SEND_DMA                   BIT(10)
  41 #define SPFI_CONTROL_GET_DMA                    BIT(9)
  42 #define SPFI_CONTROL_TMODE_SHIFT                5
  43 #define SPFI_CONTROL_TMODE_MASK                 0x7
  44 #define SPFI_CONTROL_TMODE_SINGLE               0
  45 #define SPFI_CONTROL_TMODE_DUAL                 1
  46 #define SPFI_CONTROL_TMODE_QUAD                 2
  47 #define SPFI_CONTROL_SPFI_EN                    BIT(0)
  48
  49 #define SPFI_TRANSACTION                        0x18
  50 #define SPFI_TRANSACTION_TSIZE_SHIFT            16
  51 #define SPFI_TRANSACTION_TSIZE_MASK             0xffff
  52
  53 #define SPFI_PORT_STATE                         0x1c
  54 #define SPFI_PORT_STATE_DEV_SEL_SHIFT           20
  55 #define SPFI_PORT_STATE_DEV_SEL_MASK            0x7
  56 #define SPFI_PORT_STATE_CK_POL(x)               BIT(19 - (x))
  57 #define SPFI_PORT_STATE_CK_PHASE(x)             BIT(14 - (x))
  58
  59 #define SPFI_TX_32BIT_VALID_DATA                0x20
  60 #define SPFI_TX_8BIT_VALID_DATA                 0x24
  61 #define SPFI_RX_32BIT_VALID_DATA                0x28
  62 #define SPFI_RX_8BIT_VALID_DATA                 0x2c
  63
  64 #define SPFI_INTERRUPT_STATUS                   0x30
  65 #define SPFI_INTERRUPT_ENABLE                   0x34
  66 #define SPFI_INTERRUPT_CLEAR                    0x38
  67 #define SPFI_INTERRUPT_IACCESS                  BIT(12)
  68 #define SPFI_INTERRUPT_GDEX8BIT                 BIT(11)
  69 #define SPFI_INTERRUPT_ALLDONETRIG              BIT(9)
  70 #define SPFI_INTERRUPT_GDFUL                    BIT(8)
  71 #define SPFI_INTERRUPT_GDHF                     BIT(7)
  72 #define SPFI_INTERRUPT_GDEX32BIT                BIT(6)
  73 #define SPFI_INTERRUPT_GDTRIG                   BIT(5)
  74 #define SPFI_INTERRUPT_SDFUL                    BIT(3)
  75 #define SPFI_INTERRUPT_SDHF                     BIT(2)
  76 #define SPFI_INTERRUPT_SDE                      BIT(1)
  77 #define SPFI_INTERRUPT_SDTRIG                   BIT(0)
  78
  79 /*
  80  * There are four parallel FIFOs of 16 bytes each.  The word buffer
  81  * (*_32BIT_VALID_DATA) accesses all four FIFOs at once, resulting in an
  82  * effective FIFO size of 64 bytes.  The byte buffer (*_8BIT_VALID_DATA)
  83  * accesses only a single FIFO, resulting in an effective FIFO size of
  84  * 16 bytes.
  85  */
  86 #define SPFI_32BIT_FIFO_SIZE                    64
  87 #define SPFI_8BIT_FIFO_SIZE                     16
  88
  89 struct img_spfi {
  90         struct device *dev;
  91         struct spi_master *master;
  92         spinlock_t lock;
  93
  94         void __iomem *regs;
  95         phys_addr_t phys;
  96         int irq;
  97         struct clk *spfi_clk;
  98         struct clk *sys_clk;
  99
 100         struct dma_chan *rx_ch;
 101         struct dma_chan *tx_ch;
 102         bool tx_dma_busy;
 103         bool rx_dma_busy;
 104 };
 105
 106 static inline u32 spfi_readl(struct img_spfi *spfi, u32 reg)
 107 {
 108         return readl(spfi->regs + reg);
 109 }
 110
 111 static inline void spfi_writel(struct img_spfi *spfi, u32 val, u32 reg)
 112 {
 113         writel(val, spfi->regs + reg);
 114 }
 115
 116 static inline void spfi_start(struct img_spfi *spfi)
 117 {
 118         u32 val;
 119
 120         val = spfi_readl(spfi, SPFI_CONTROL);
 121         val |= SPFI_CONTROL_SPFI_EN;
 122         spfi_writel(spfi, val, SPFI_CONTROL);
 123 }
 124
 125 static inline void spfi_stop(struct img_spfi *spfi)
 126 {
 127         u32 val;
 128
 129         val = spfi_readl(spfi, SPFI_CONTROL);
 130         val &= ~SPFI_CONTROL_SPFI_EN;
 131         spfi_writel(spfi, val, SPFI_CONTROL);
 132 }
 133
 134 static inline void spfi_reset(struct img_spfi *spfi)
 135 {
 136         spfi_writel(spfi, SPFI_CONTROL_SOFT_RESET, SPFI_CONTROL);
 137         spfi_writel(spfi, 0, SPFI_CONTROL);
 138 }
 139
 140 static void spfi_flush_tx_fifo(struct img_spfi *spfi)
 141 {
 142         unsigned long timeout = jiffies + msecs_to_jiffies(10);
 143
 144         spfi_writel(spfi, SPFI_INTERRUPT_SDE, SPFI_INTERRUPT_CLEAR);
 145         while (time_before(jiffies, timeout)) {
 146                 if (spfi_readl(spfi, SPFI_INTERRUPT_STATUS) &
 147                     SPFI_INTERRUPT_SDE)
 148                         return;
 149                 cpu_relax();
 150         }
 151
 152         dev_err(spfi->dev, "Timed out waiting for FIFO to drain\n");
 153         spfi_reset(spfi);
 154 }
 155
 156 static unsigned int spfi_pio_write32(struct img_spfi *spfi, const u32 *buf,
 157                                      unsigned int max)
 158 {
 159         unsigned int count = 0;
 160         u32 status;
 161
 162         while (count < max / 4) {
 163                 spfi_writel(spfi, SPFI_INTERRUPT_SDFUL, SPFI_INTERRUPT_CLEAR);
 164                 status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
 165                 if (status & SPFI_INTERRUPT_SDFUL)
 166                         break;
 167                 spfi_writel(spfi, buf[count], SPFI_TX_32BIT_VALID_DATA);
 168                 count++;
 169         }
 170
 171         return count * 4;
 172 }
 173
 174 static unsigned int spfi_pio_write8(struct img_spfi *spfi, const u8 *buf,
 175                                     unsigned int max)
 176 {
 177         unsigned int count = 0;
 178         u32 status;
 179
 180         while (count < max) {
 181                 spfi_writel(spfi, SPFI_INTERRUPT_SDFUL, SPFI_INTERRUPT_CLEAR);
 182                 status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
 183                 if (status & SPFI_INTERRUPT_SDFUL)
 184                         break;
 185                 spfi_writel(spfi, buf[count], SPFI_TX_8BIT_VALID_DATA);
 186                 count++;
 187         }
 188
 189         return count;
 190 }
 191
 192 static unsigned int spfi_pio_read32(struct img_spfi *spfi, u32 *buf,
 193                                     unsigned int max)
 194 {
 195         unsigned int count = 0;
 196         u32 status;
 197
 198         while (count < max / 4) {
 199                 spfi_writel(spfi, SPFI_INTERRUPT_GDEX32BIT,
 200                             SPFI_INTERRUPT_CLEAR);
 201                 status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
 202                 if (!(status & SPFI_INTERRUPT_GDEX32BIT))
 203                         break;
 204                 buf[count] = spfi_readl(spfi, SPFI_RX_32BIT_VALID_DATA);
 205                 count++;
 206         }
 207
 208         return count * 4;
 209 }
 210
 211 static unsigned int spfi_pio_read8(struct img_spfi *spfi, u8 *buf,
 212                                    unsigned int max)
 213 {
 214         unsigned int count = 0;
 215         u32 status;
 216
 217         while (count < max) {
 218                 spfi_writel(spfi, SPFI_INTERRUPT_GDEX8BIT,
 219                             SPFI_INTERRUPT_CLEAR);
 220                 status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
 221                 if (!(status & SPFI_INTERRUPT_GDEX8BIT))
 222                         break;
 223                 buf[count] = spfi_readl(spfi, SPFI_RX_8BIT_VALID_DATA);
 224                 count++;
 225         }
 226
 227         return count;
 228 }
 229
 230 static int img_spfi_start_pio(struct spi_master *master,
 231                                struct spi_device *spi,
 232                                struct spi_transfer *xfer)
 233 {
 234         struct img_spfi *spfi = spi_master_get_devdata(spi->master);
 235         unsigned int tx_bytes = 0, rx_bytes = 0;
 236         const void *tx_buf = xfer->tx_buf;
 237         void *rx_buf = xfer->rx_buf;
 238         unsigned long timeout;
 239
 240         if (tx_buf)
 241                 tx_bytes = xfer->len;
 242         if (rx_buf)
 243                 rx_bytes = xfer->len;
 244
 245         spfi_start(spfi);
 246
 247         timeout = jiffies +
 248                 msecs_to_jiffies(xfer->len * 8 * 1000 / xfer->speed_hz + 100);
 249         while ((tx_bytes > 0 || rx_bytes > 0) &&
 250                time_before(jiffies, timeout)) {
 251                 unsigned int tx_count, rx_count;
 252
 253                 if (tx_bytes >= 4)
 254                         tx_count = spfi_pio_write32(spfi, tx_buf, tx_bytes);
 255                 else
 256                         tx_count = spfi_pio_write8(spfi, tx_buf, tx_bytes);
 257
 258                 if (rx_bytes >= 4)
 259                         rx_count = spfi_pio_read32(spfi, rx_buf, rx_bytes);
 260                 else
 261                         rx_count = spfi_pio_read8(spfi, rx_buf, rx_bytes);
 262
 263                 tx_buf += tx_count;
 264                 rx_buf += rx_count;
 265                 tx_bytes -= tx_count;
 266                 rx_bytes -= rx_count;
 267
 268                 cpu_relax();
 269         }
 270
 271         if (rx_bytes > 0 || tx_bytes > 0) {
 272                 dev_err(spfi->dev, "PIO transfer timed out\n");
 273                 return -ETIMEDOUT;
 274         }
 275
 276         if (tx_buf)
 277                 spfi_flush_tx_fifo(spfi);
 278         spfi_stop(spfi);
 279
 280         return 0;
 281 }
 282
 283 static void img_spfi_dma_rx_cb(void *data)
 284 {
 285         struct img_spfi *spfi = data;
 286         unsigned long flags;
 287
 288         spin_lock_irqsave(&spfi->lock, flags);
 289
 290         spfi->rx_dma_busy = false;
 291         if (!spfi->tx_dma_busy) {
 292                 spfi_stop(spfi);
 293                 spi_finalize_current_transfer(spfi->master);
 294         }
 295
 296         spin_unlock_irqrestore(&spfi->lock, flags);
 297 }
 298
 299 static void img_spfi_dma_tx_cb(void *data)
 300 {
 301         struct img_spfi *spfi = data;
 302         unsigned long flags;
 303
 304         spfi_flush_tx_fifo(spfi);
 305
 306         spin_lock_irqsave(&spfi->lock, flags);
 307
 308         spfi->tx_dma_busy = false;
 309         if (!spfi->rx_dma_busy) {
 310                 spfi_stop(spfi);
 311                 spi_finalize_current_transfer(spfi->master);
 312         }
 313
 314         spin_unlock_irqrestore(&spfi->lock, flags);
 315 }
 316
 317 static int img_spfi_start_dma(struct spi_master *master,
 318                               struct spi_device *spi,
 319                               struct spi_transfer *xfer)
 320 {
 321         struct img_spfi *spfi = spi_master_get_devdata(spi->master);
 322         struct dma_async_tx_descriptor *rxdesc = NULL, *txdesc = NULL;
 323         struct dma_slave_config rxconf, txconf;
 324
 325         spfi->rx_dma_busy = false;
 326         spfi->tx_dma_busy = false;
 327
 328         if (xfer->rx_buf) {
 329                 rxconf.direction = DMA_DEV_TO_MEM;
 330                 if (xfer->len % 4 == 0) {
 331                         rxconf.src_addr = spfi->phys + SPFI_RX_32BIT_VALID_DATA;
 332                         rxconf.src_addr_width = 4;
 333                         rxconf.src_maxburst = 4;
 334                 } else {
 335                         rxconf.src_addr = spfi->phys + SPFI_RX_8BIT_VALID_DATA;
 336                         rxconf.src_addr_width = 1;
 337                         rxconf.src_maxburst = 4;
 338                 }
 339                 dmaengine_slave_config(spfi->rx_ch, &rxconf);
 340
 341                 rxdesc = dmaengine_prep_slave_sg(spfi->rx_ch, xfer->rx_sg.sgl,
 342                                                  xfer->rx_sg.nents,
 343                                                  DMA_DEV_TO_MEM,
 344                                                  DMA_PREP_INTERRUPT);
 345                 if (!rxdesc)
 346                         goto stop_dma;
 347
 348                 rxdesc->callback = img_spfi_dma_rx_cb;
 349                 rxdesc->callback_param = spfi;
 350         }
 351
 352         if (xfer->tx_buf) {
 353                 txconf.direction = DMA_MEM_TO_DEV;
 354                 if (xfer->len % 4 == 0) {
 355                         txconf.dst_addr = spfi->phys + SPFI_TX_32BIT_VALID_DATA;
 356                         txconf.dst_addr_width = 4;
 357                         txconf.dst_maxburst = 4;
 358                 } else {
 359                         txconf.dst_addr = spfi->phys + SPFI_TX_8BIT_VALID_DATA;
 360                         txconf.dst_addr_width = 1;
 361                         txconf.dst_maxburst = 4;
 362                 }
 363                 dmaengine_slave_config(spfi->tx_ch, &txconf);
 364
 365                 txdesc = dmaengine_prep_slave_sg(spfi->tx_ch, xfer->tx_sg.sgl,
 366                                                  xfer->tx_sg.nents,
 367                                                  DMA_MEM_TO_DEV,
 368                                                  DMA_PREP_INTERRUPT);
 369                 if (!txdesc)
 370                         goto stop_dma;
 371
 372                 txdesc->callback = img_spfi_dma_tx_cb;
 373                 txdesc->callback_param = spfi;
 374         }
 375
 376         if (xfer->rx_buf) {
 377                 spfi->rx_dma_busy = true;
 378                 dmaengine_submit(rxdesc);
 379                 dma_async_issue_pending(spfi->rx_ch);
 380         }
 381
 382         spfi_start(spfi);
 383
 384         if (xfer->tx_buf) {
 385                 spfi->tx_dma_busy = true;
 386                 dmaengine_submit(txdesc);
 387                 dma_async_issue_pending(spfi->tx_ch);
 388         }
 389
 390         return 1;
 391
 392 stop_dma:
 393         dmaengine_terminate_all(spfi->rx_ch);
 394         dmaengine_terminate_all(spfi->tx_ch);
 395         return -EIO;
 396 }
 397
 398 static void img_spfi_handle_err(struct spi_master *master,
 399                                 struct spi_message *msg)
 400 {
 401         struct img_spfi *spfi = spi_master_get_devdata(master);
 402         unsigned long flags;
 403
 404         /*
 405          * Stop all DMA and reset the controller if the previous transaction
 406          * timed-out and never completed it's DMA.
 407          */
 408         spin_lock_irqsave(&spfi->lock, flags);
 409         if (spfi->tx_dma_busy || spfi->rx_dma_busy) {
 410                 spfi->tx_dma_busy = false;
 411                 spfi->rx_dma_busy = false;
 412
 413                 dmaengine_terminate_all(spfi->tx_ch);
 414                 dmaengine_terminate_all(spfi->rx_ch);
 415         }
 416         spin_unlock_irqrestore(&spfi->lock, flags);
 417 }
 418
 419 static int img_spfi_prepare(struct spi_master *master, struct spi_message *msg)
 420 {
 421         struct img_spfi *spfi = spi_master_get_devdata(master);
 422         u32 val;
 423
 424         val = spfi_readl(spfi, SPFI_PORT_STATE);
 425         if (msg->spi->mode & SPI_CPHA)
 426                 val |= SPFI_PORT_STATE_CK_PHASE(msg->spi->chip_select);
 427         else
 428                 val &= ~SPFI_PORT_STATE_CK_PHASE(msg->spi->chip_select);
 429         if (msg->spi->mode & SPI_CPOL)
 430                 val |= SPFI_PORT_STATE_CK_POL(msg->spi->chip_select);
 431         else
 432                 val &= ~SPFI_PORT_STATE_CK_POL(msg->spi->chip_select);
 433         spfi_writel(spfi, val, SPFI_PORT_STATE);
 434
 435         return 0;
 436 }
 437
 438 static int img_spfi_unprepare(struct spi_master *master,
 439                               struct spi_message *msg)
 440 {
 441         struct img_spfi *spfi = spi_master_get_devdata(master);
 442
 443         spfi_reset(spfi);
 444
 445         return 0;
 446 }
 447
 448 static void img_spfi_config(struct spi_master *master, struct spi_device *spi,
 449                             struct spi_transfer *xfer)
 450 {
 451         struct img_spfi *spfi = spi_master_get_devdata(spi->master);
 452         u32 val, div;
 453
 454         /*
 455          * output = spfi_clk * (BITCLK / 512), where BITCLK must be a
 456          * power of 2 up to 128
 457          */
 458         div = DIV_ROUND_UP(clk_get_rate(spfi->spfi_clk), xfer->speed_hz);
 459         div = clamp(512 / (1 << get_count_order(div)), 1, 128);
 460
 461         val = spfi_readl(spfi, SPFI_DEVICE_PARAMETER(spi->chip_select));
 462         val &= ~(SPFI_DEVICE_PARAMETER_BITCLK_MASK <<
 463                  SPFI_DEVICE_PARAMETER_BITCLK_SHIFT);
 464         val |= div << SPFI_DEVICE_PARAMETER_BITCLK_SHIFT;
 465         spfi_writel(spfi, val, SPFI_DEVICE_PARAMETER(spi->chip_select));
 466
 467         spfi_writel(spfi, xfer->len << SPFI_TRANSACTION_TSIZE_SHIFT,
 468                     SPFI_TRANSACTION);
 469
 470         val = spfi_readl(spfi, SPFI_CONTROL);
 471         val &= ~(SPFI_CONTROL_SEND_DMA | SPFI_CONTROL_GET_DMA);
 472         if (xfer->tx_buf)
 473                 val |= SPFI_CONTROL_SEND_DMA;
 474         if (xfer->rx_buf)
 475                 val |= SPFI_CONTROL_GET_DMA;
 476         val &= ~(SPFI_CONTROL_TMODE_MASK << SPFI_CONTROL_TMODE_SHIFT);
 477         if (xfer->tx_nbits == SPI_NBITS_DUAL &&
 478             xfer->rx_nbits == SPI_NBITS_DUAL)
 479                 val |= SPFI_CONTROL_TMODE_DUAL << SPFI_CONTROL_TMODE_SHIFT;
 480         else if (xfer->tx_nbits == SPI_NBITS_QUAD &&
 481                  xfer->rx_nbits == SPI_NBITS_QUAD)
 482                 val |= SPFI_CONTROL_TMODE_QUAD << SPFI_CONTROL_TMODE_SHIFT;
 483         val &= ~SPFI_CONTROL_CONTINUE;
 484         if (!xfer->cs_change && !list_is_last(&xfer->transfer_list,
 485                                               &master->cur_msg->transfers))
 486                 val |= SPFI_CONTROL_CONTINUE;
 487         spfi_writel(spfi, val, SPFI_CONTROL);
 488 }
 489
 490 static int img_spfi_transfer_one(struct spi_master *master,
 491                                  struct spi_device *spi,
 492                                  struct spi_transfer *xfer)
 493 {
 494         struct img_spfi *spfi = spi_master_get_devdata(spi->master);
 495         int ret;
 496
 497         if (xfer->len > SPFI_TRANSACTION_TSIZE_MASK) {
 498                 dev_err(spfi->dev,
 499                         "Transfer length (%d) is greater than the max supported (%d)",
 500                         xfer->len, SPFI_TRANSACTION_TSIZE_MASK);
 501                 return -EINVAL;
 502         }
 503
 504         img_spfi_config(master, spi, xfer);
 505         if (master->can_dma && master->can_dma(master, spi, xfer))
 506                 ret = img_spfi_start_dma(master, spi, xfer);
 507         else
 508                 ret = img_spfi_start_pio(master, spi, xfer);
 509
 510         return ret;
 511 }
 512
 513 static void img_spfi_set_cs(struct spi_device *spi, bool enable)
 514 {
 515         struct img_spfi *spfi = spi_master_get_devdata(spi->master);
 516         u32 val;
 517
 518         val = spfi_readl(spfi, SPFI_PORT_STATE);
 519         val &= ~(SPFI_PORT_STATE_DEV_SEL_MASK << SPFI_PORT_STATE_DEV_SEL_SHIFT);
 520         val |= spi->chip_select << SPFI_PORT_STATE_DEV_SEL_SHIFT;
 521         spfi_writel(spfi, val, SPFI_PORT_STATE);
 522 }
 523
 524 static bool img_spfi_can_dma(struct spi_master *master, struct spi_device *spi,
 525                              struct spi_transfer *xfer)
 526 {
 527         if (xfer->len > SPFI_32BIT_FIFO_SIZE)
 528                 return true;
 529         return false;
 530 }
 531
 532 static irqreturn_t img_spfi_irq(int irq, void *dev_id)
 533 {
 534         struct img_spfi *spfi = (struct img_spfi *)dev_id;
 535         u32 status;
 536
 537         status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
 538         if (status & SPFI_INTERRUPT_IACCESS) {
 539                 spfi_writel(spfi, SPFI_INTERRUPT_IACCESS, SPFI_INTERRUPT_CLEAR);
 540                 dev_err(spfi->dev, "Illegal access interrupt");
 541                 return IRQ_HANDLED;
 542         }
 543
 544         return IRQ_NONE;
 545 }
 546
 547 static int img_spfi_probe(struct platform_device *pdev)
 548 {
 549         struct spi_master *master;
 550         struct img_spfi *spfi;
 551         struct resource *res;
 552         int ret;
 553
 554         master = spi_alloc_master(&pdev->dev, sizeof(*spfi));
 555         if (!master)
 556                 return -ENOMEM;
 557         platform_set_drvdata(pdev, master);
 558
 559         spfi = spi_master_get_devdata(master);
 560         spfi->dev = &pdev->dev;
 561         spfi->master = master;
 562         spin_lock_init(&spfi->lock);
 563
 564         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 565         spfi->regs = devm_ioremap_resource(spfi->dev, res);
 566         if (IS_ERR(spfi->regs)) {
 567                 ret = PTR_ERR(spfi->regs);
 568                 goto put_spi;
 569         }
 570         spfi->phys = res->start;
 571
 572         spfi->irq = platform_get_irq(pdev, 0);
 573         if (spfi->irq < 0) {
 574                 ret = spfi->irq;
 575                 goto put_spi;
 576         }
 577         ret = devm_request_irq(spfi->dev, spfi->irq, img_spfi_irq,
 578                                IRQ_TYPE_LEVEL_HIGH, dev_name(spfi->dev), spfi);
 579         if (ret)
 580                 goto put_spi;
 581
 582         spfi->sys_clk = devm_clk_get(spfi->dev, "sys");
 583         if (IS_ERR(spfi->sys_clk)) {
 584                 ret = PTR_ERR(spfi->sys_clk);
 585                 goto put_spi;
 586         }
 587         spfi->spfi_clk = devm_clk_get(spfi->dev, "spfi");
 588         if (IS_ERR(spfi->spfi_clk)) {
 589                 ret = PTR_ERR(spfi->spfi_clk);
 590                 goto put_spi;
 591         }
 592
 593         ret = clk_prepare_enable(spfi->sys_clk);
 594         if (ret)
 595                 goto put_spi;
 596         ret = clk_prepare_enable(spfi->spfi_clk);
 597         if (ret)
 598                 goto disable_pclk;
 599
 600         spfi_reset(spfi);
 601         /*
 602          * Only enable the error (IACCESS) interrupt.  In PIO mode we'll
 603          * poll the status of the FIFOs.
 604          */
 605         spfi_writel(spfi, SPFI_INTERRUPT_IACCESS, SPFI_INTERRUPT_ENABLE);
 606
 607         master->auto_runtime_pm = true;
 608         master->bus_num = pdev->id;
 609         master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_TX_DUAL | SPI_RX_DUAL;
 610         if (of_property_read_bool(spfi->dev->of_node, "img,supports-quad-mode"))
 611                 master->mode_bits |= SPI_TX_QUAD | SPI_RX_QUAD;
 612         master->num_chipselect = 5;
 613         master->dev.of_node = pdev->dev.of_node;
 614         master->bits_per_word_mask = SPI_BPW_MASK(32) | SPI_BPW_MASK(8);
 615         master->max_speed_hz = clk_get_rate(spfi->spfi_clk) / 4;
 616         master->min_speed_hz = clk_get_rate(spfi->spfi_clk) / 512;
 617
 618         master->set_cs = img_spfi_set_cs;
 619         master->transfer_one = img_spfi_transfer_one;
 620         master->prepare_message = img_spfi_prepare;
 621         master->unprepare_message = img_spfi_unprepare;
 622         master->handle_err = img_spfi_handle_err;
 623
 624         spfi->tx_ch = dma_request_slave_channel(spfi->dev, "tx");
 625         spfi->rx_ch = dma_request_slave_channel(spfi->dev, "rx");
 626         if (!spfi->tx_ch || !spfi->rx_ch) {
 627                 if (spfi->tx_ch)
 628                         dma_release_channel(spfi->tx_ch);
 629                 if (spfi->rx_ch)
 630                         dma_release_channel(spfi->rx_ch);
 631                 dev_warn(spfi->dev, "Failed to get DMA channels, falling back to PIO mode\n");
 632         } else {
 633                 master->dma_tx = spfi->tx_ch;
 634                 master->dma_rx = spfi->rx_ch;
 635                 master->can_dma = img_spfi_can_dma;
 636         }
 637
 638         pm_runtime_set_active(spfi->dev);
 639         pm_runtime_enable(spfi->dev);
 640
 641         ret = devm_spi_register_master(spfi->dev, master);
 642         if (ret)
 643                 goto disable_pm;
 644
 645         return 0;
 646
 647 disable_pm:
 648         pm_runtime_disable(spfi->dev);
 649         if (spfi->rx_ch)
 650                 dma_release_channel(spfi->rx_ch);
 651         if (spfi->tx_ch)
 652                 dma_release_channel(spfi->tx_ch);
 653         clk_disable_unprepare(spfi->spfi_clk);
 654 disable_pclk:
 655         clk_disable_unprepare(spfi->sys_clk);
 656 put_spi:
 657         spi_master_put(master);
 658
 659         return ret;
 660 }
 661
 662 static int img_spfi_remove(struct platform_device *pdev)
 663 {
 664         struct spi_master *master = platform_get_drvdata(pdev);
 665         struct img_spfi *spfi = spi_master_get_devdata(master);
 666
 667         if (spfi->tx_ch)
 668                 dma_release_channel(spfi->tx_ch);
 669         if (spfi->rx_ch)
 670                 dma_release_channel(spfi->rx_ch);
 671
 672         pm_runtime_disable(spfi->dev);
 673         if (!pm_runtime_status_suspended(spfi->dev)) {
 674                 clk_disable_unprepare(spfi->spfi_clk);
 675                 clk_disable_unprepare(spfi->sys_clk);
 676         }
 677
 678         spi_master_put(master);
 679
 680         return 0;
 681 }
 682
 683 #ifdef CONFIG_PM
 684 static int img_spfi_runtime_suspend(struct device *dev)
 685 {
 686         struct spi_master *master = dev_get_drvdata(dev);
 687         struct img_spfi *spfi = spi_master_get_devdata(master);
 688
 689         clk_disable_unprepare(spfi->spfi_clk);
 690         clk_disable_unprepare(spfi->sys_clk);
 691
 692         return 0;
 693 }
 694
 695 static int img_spfi_runtime_resume(struct device *dev)
 696 {
 697         struct spi_master *master = dev_get_drvdata(dev);
 698         struct img_spfi *spfi = spi_master_get_devdata(master);
 699         int ret;
 700
 701         ret = clk_prepare_enable(spfi->sys_clk);
 702         if (ret)
 703                 return ret;
 704         ret = clk_prepare_enable(spfi->spfi_clk);
 705         if (ret) {
 706                 clk_disable_unprepare(spfi->sys_clk);
 707                 return ret;
 708         }
 709
 710         return 0;
 711 }
 712 #endif /* CONFIG_PM */
 713
 714 #ifdef CONFIG_PM_SLEEP
 715 static int img_spfi_suspend(struct device *dev)
 716 {
 717         struct spi_master *master = dev_get_drvdata(dev);
 718
 719         return spi_master_suspend(master);
 720 }
 721
 722 static int img_spfi_resume(struct device *dev)
 723 {
 724         struct spi_master *master = dev_get_drvdata(dev);
 725         struct img_spfi *spfi = spi_master_get_devdata(master);
 726         int ret;
 727
 728         ret = pm_runtime_get_sync(dev);
 729         if (ret)
 730                 return ret;
 731         spfi_reset(spfi);
 732         pm_runtime_put(dev);
 733
 734         return spi_master_resume(master);
 735 }
 736 #endif /* CONFIG_PM_SLEEP */
 737
 738 static const struct dev_pm_ops img_spfi_pm_ops = {
 739         SET_RUNTIME_PM_OPS(img_spfi_runtime_suspend, img_spfi_runtime_resume,
 740                            NULL)
 741         SET_SYSTEM_SLEEP_PM_OPS(img_spfi_suspend, img_spfi_resume)
 742 };
 743
 744 static const struct of_device_id img_spfi_of_match[] = {
 745         { .compatible = "img,spfi", },
 746         { },
 747 };
 748 MODULE_DEVICE_TABLE(of, img_spfi_of_match);
 749
 750 static struct platform_driver img_spfi_driver = {
 751         .driver = {
 752                 .name = "img-spfi",
 753                 .pm = &img_spfi_pm_ops,
 754                 .of_match_table = of_match_ptr(img_spfi_of_match),
 755         },
 756         .probe = img_spfi_probe,
 757         .remove = img_spfi_remove,
 758 };
 759 module_platform_driver(img_spfi_driver);
 760
 761 MODULE_DESCRIPTION("IMG SPFI controller driver");
 762 MODULE_AUTHOR("Andrew Bresticker <abrestic@chromium.org>");
 763 MODULE_LICENSE("GPL v2");