Lines Matching refs:spfi
104 static inline u32 spfi_readl(struct img_spfi *spfi, u32 reg)
106 return readl(spfi->regs + reg);
109 static inline void spfi_writel(struct img_spfi *spfi, u32 val, u32 reg)
111 writel(val, spfi->regs + reg);
114 static inline void spfi_start(struct img_spfi *spfi)
118 val = spfi_readl(spfi, SPFI_CONTROL);
120 spfi_writel(spfi, val, SPFI_CONTROL);
123 static inline void spfi_reset(struct img_spfi *spfi)
125 spfi_writel(spfi, SPFI_CONTROL_SOFT_RESET, SPFI_CONTROL);
126 spfi_writel(spfi, 0, SPFI_CONTROL);
129 static int spfi_wait_all_done(struct img_spfi *spfi)
134 u32 status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
137 spfi_writel(spfi, SPFI_INTERRUPT_ALLDONETRIG,
144 dev_err(spfi->dev, "Timed out waiting for transaction to complete\n");
145 spfi_reset(spfi);
150 static unsigned int spfi_pio_write32(struct img_spfi *spfi, const u32 *buf,
157 spfi_writel(spfi, SPFI_INTERRUPT_SDFUL, SPFI_INTERRUPT_CLEAR);
158 status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
161 spfi_writel(spfi, buf[count], SPFI_TX_32BIT_VALID_DATA);
168 static unsigned int spfi_pio_write8(struct img_spfi *spfi, const u8 *buf,
175 spfi_writel(spfi, SPFI_INTERRUPT_SDFUL, SPFI_INTERRUPT_CLEAR);
176 status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
179 spfi_writel(spfi, buf[count], SPFI_TX_8BIT_VALID_DATA);
186 static unsigned int spfi_pio_read32(struct img_spfi *spfi, u32 *buf,
193 spfi_writel(spfi, SPFI_INTERRUPT_GDEX32BIT,
195 status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
198 buf[count] = spfi_readl(spfi, SPFI_RX_32BIT_VALID_DATA);
205 static unsigned int spfi_pio_read8(struct img_spfi *spfi, u8 *buf,
212 spfi_writel(spfi, SPFI_INTERRUPT_GDEX8BIT,
214 status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
217 buf[count] = spfi_readl(spfi, SPFI_RX_8BIT_VALID_DATA);
228 struct img_spfi *spfi = spi_controller_get_devdata(spi->controller);
240 spfi_start(spfi);
249 tx_count = spfi_pio_write32(spfi, tx_buf, tx_bytes);
251 tx_count = spfi_pio_write8(spfi, tx_buf, tx_bytes);
254 rx_count = spfi_pio_read32(spfi, rx_buf, rx_bytes);
256 rx_count = spfi_pio_read8(spfi, rx_buf, rx_bytes);
267 dev_err(spfi->dev, "PIO transfer timed out\n");
271 ret = spfi_wait_all_done(spfi);
280 struct img_spfi *spfi = data;
283 spfi_wait_all_done(spfi);
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);
294 struct img_spfi *spfi = data;
297 spfi_wait_all_done(spfi);
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);
310 struct img_spfi *spfi = spi_controller_get_devdata(spi->controller);
314 spfi->rx_dma_busy = false;
315 spfi->tx_dma_busy = false;
320 rxconf.src_addr = spfi->phys + SPFI_RX_32BIT_VALID_DATA;
324 rxconf.src_addr = spfi->phys + SPFI_RX_8BIT_VALID_DATA;
328 dmaengine_slave_config(spfi->rx_ch, &rxconf);
330 rxdesc = dmaengine_prep_slave_sg(spfi->rx_ch, xfer->rx_sg.sgl,
338 rxdesc->callback_param = spfi;
344 txconf.dst_addr = spfi->phys + SPFI_TX_32BIT_VALID_DATA;
348 txconf.dst_addr = spfi->phys + SPFI_TX_8BIT_VALID_DATA;
352 dmaengine_slave_config(spfi->tx_ch, &txconf);
354 txdesc = dmaengine_prep_slave_sg(spfi->tx_ch, xfer->tx_sg.sgl,
362 txdesc->callback_param = spfi;
366 spfi->rx_dma_busy = true;
368 dma_async_issue_pending(spfi->rx_ch);
371 spfi_start(spfi);
374 spfi->tx_dma_busy = true;
376 dma_async_issue_pending(spfi->tx_ch);
382 dmaengine_terminate_all(spfi->rx_ch);
383 dmaengine_terminate_all(spfi->tx_ch);
390 struct img_spfi *spfi = spi_controller_get_devdata(host);
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;
402 dmaengine_terminate_all(spfi->tx_ch);
403 dmaengine_terminate_all(spfi->rx_ch);
405 spin_unlock_irqrestore(&spfi->lock, flags);
410 struct img_spfi *spfi = spi_controller_get_devdata(host);
413 val = spfi_readl(spfi, SPFI_PORT_STATE);
425 spfi_writel(spfi, val, SPFI_PORT_STATE);
433 struct img_spfi *spfi = spi_controller_get_devdata(host);
435 spfi_reset(spfi);
443 struct img_spfi *spfi = spi_controller_get_devdata(spi->controller);
450 div = DIV_ROUND_UP(clk_get_rate(spfi->spfi_clk), xfer->speed_hz);
453 val = spfi_readl(spfi, SPFI_DEVICE_PARAMETER(spi_get_chipselect(spi, 0)));
457 spfi_writel(spfi, val, SPFI_DEVICE_PARAMETER(spi_get_chipselect(spi, 0)));
459 spfi_writel(spfi, xfer->len << SPFI_TRANSACTION_TSIZE_SHIFT,
462 val = spfi_readl(spfi, SPFI_CONTROL);
476 spfi_writel(spfi, val, SPFI_CONTROL);
483 struct img_spfi *spfi = spi_controller_get_devdata(spi->controller);
487 dev_err(spfi->dev,
512 struct img_spfi *spfi = (struct img_spfi *)dev_id;
515 status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
517 spfi_writel(spfi, SPFI_INTERRUPT_IACCESS, SPFI_INTERRUPT_CLEAR);
518 dev_err(spfi->dev, "Illegal access interrupt");
528 struct img_spfi *spfi;
533 host = spi_alloc_host(&pdev->dev, sizeof(*spfi));
538 spfi = spi_controller_get_devdata(host);
539 spfi->dev = &pdev->dev;
540 spfi->host = host;
541 spin_lock_init(&spfi->lock);
543 spfi->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
544 if (IS_ERR(spfi->regs)) {
545 ret = PTR_ERR(spfi->regs);
548 spfi->phys = res->start;
550 spfi->irq = platform_get_irq(pdev, 0);
551 if (spfi->irq < 0) {
552 ret = spfi->irq;
555 ret = devm_request_irq(spfi->dev, spfi->irq, img_spfi_irq,
556 IRQ_TYPE_LEVEL_HIGH, dev_name(spfi->dev), spfi);
560 spfi->sys_clk = devm_clk_get(spfi->dev, "sys");
561 if (IS_ERR(spfi->sys_clk)) {
562 ret = PTR_ERR(spfi->sys_clk);
565 spfi->spfi_clk = devm_clk_get(spfi->dev, "spfi");
566 if (IS_ERR(spfi->spfi_clk)) {
567 ret = PTR_ERR(spfi->spfi_clk);
571 ret = clk_prepare_enable(spfi->sys_clk);
574 ret = clk_prepare_enable(spfi->spfi_clk);
578 spfi_reset(spfi);
583 spfi_writel(spfi, SPFI_INTERRUPT_IACCESS, SPFI_INTERRUPT_ENABLE);
588 if (of_property_read_bool(spfi->dev->of_node, "img,supports-quad-mode"))
592 host->max_speed_hz = clk_get_rate(spfi->spfi_clk) / 4;
593 host->min_speed_hz = clk_get_rate(spfi->spfi_clk) / 512;
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"
602 if (!of_property_read_u32(spfi->dev->of_node, "spfi-max-frequency",
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;
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;
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");
639 host->dma_tx = spfi->tx_ch;
640 host->dma_rx = spfi->rx_ch;
644 pm_runtime_set_active(spfi->dev);
645 pm_runtime_enable(spfi->dev);
647 ret = devm_spi_register_controller(spfi->dev, host);
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);
661 clk_disable_unprepare(spfi->sys_clk);
671 struct img_spfi *spfi = spi_controller_get_devdata(host);
673 if (spfi->tx_ch)
674 dma_release_channel(spfi->tx_ch);
675 if (spfi->rx_ch)
676 dma_release_channel(spfi->rx_ch);
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);
689 struct img_spfi *spfi = spi_controller_get_devdata(host);
691 clk_disable_unprepare(spfi->spfi_clk);
692 clk_disable_unprepare(spfi->sys_clk);
700 struct img_spfi *spfi = spi_controller_get_devdata(host);
703 ret = clk_prepare_enable(spfi->sys_clk);
706 ret = clk_prepare_enable(spfi->spfi_clk);
708 clk_disable_unprepare(spfi->sys_clk);
727 struct img_spfi *spfi = spi_controller_get_devdata(host);
733 spfi_reset(spfi);
747 { .compatible = "img,spfi", },
754 .name = "img-spfi",