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