1 // SPDX-License-Identifier: GPL-2.0
3 // Driver for AT91 USART Controllers as SPI
5 // Copyright (C) 2018 Microchip Technology Inc.
7 // Author: Radu Pirea <radu.pirea@microchip.com>
10 #include <linux/delay.h>
11 #include <linux/interrupt.h>
12 #include <linux/kernel.h>
13 #include <linux/module.h>
14 #include <linux/of_gpio.h>
15 #include <linux/pinctrl/consumer.h>
16 #include <linux/platform_device.h>
17 #include <linux/pm_runtime.h>
19 #include <linux/spi/spi.h>
29 #define US_VERSION 0xFC
31 #define US_CR_RSTRX BIT(2)
32 #define US_CR_RSTTX BIT(3)
33 #define US_CR_RXEN BIT(4)
34 #define US_CR_RXDIS BIT(5)
35 #define US_CR_TXEN BIT(6)
36 #define US_CR_TXDIS BIT(7)
38 #define US_MR_SPI_MASTER 0x0E
39 #define US_MR_CHRL GENMASK(7, 6)
40 #define US_MR_CPHA BIT(8)
41 #define US_MR_CPOL BIT(16)
42 #define US_MR_CLKO BIT(18)
43 #define US_MR_WRDBT BIT(20)
44 #define US_MR_LOOP BIT(15)
46 #define US_IR_RXRDY BIT(0)
47 #define US_IR_TXRDY BIT(1)
48 #define US_IR_OVRE BIT(5)
50 #define US_BRGR_SIZE BIT(16)
52 #define US_MIN_CLK_DIV 0x06
53 #define US_MAX_CLK_DIV BIT(16)
55 #define US_RESET (US_CR_RSTRX | US_CR_RSTTX)
56 #define US_DISABLE (US_CR_RXDIS | US_CR_TXDIS)
57 #define US_ENABLE (US_CR_RXEN | US_CR_TXEN)
58 #define US_OVRE_RXRDY_IRQS (US_IR_OVRE | US_IR_RXRDY)
61 (US_MR_SPI_MASTER | US_MR_CHRL | US_MR_CLKO | US_MR_WRDBT)
63 /* Register access macros */
64 #define at91_usart_spi_readl(port, reg) \
65 readl_relaxed((port)->regs + US_##reg)
66 #define at91_usart_spi_writel(port, reg, value) \
67 writel_relaxed((value), (port)->regs + US_##reg)
69 #define at91_usart_spi_readb(port, reg) \
70 readb_relaxed((port)->regs + US_##reg)
71 #define at91_usart_spi_writeb(port, reg, value) \
72 writeb_relaxed((value), (port)->regs + US_##reg)
74 struct at91_usart_spi {
75 struct spi_transfer *current_transfer;
80 /*used in interrupt to protect data reading*/
84 unsigned int current_tx_remaining_bytes;
85 unsigned int current_rx_remaining_bytes;
93 static inline u32 at91_usart_spi_tx_ready(struct at91_usart_spi *aus)
95 return aus->status & US_IR_TXRDY;
98 static inline u32 at91_usart_spi_rx_ready(struct at91_usart_spi *aus)
100 return aus->status & US_IR_RXRDY;
103 static inline u32 at91_usart_spi_check_overrun(struct at91_usart_spi *aus)
105 return aus->status & US_IR_OVRE;
108 static inline u32 at91_usart_spi_read_status(struct at91_usart_spi *aus)
110 aus->status = at91_usart_spi_readl(aus, CSR);
114 static inline void at91_usart_spi_tx(struct at91_usart_spi *aus)
116 unsigned int len = aus->current_transfer->len;
117 unsigned int remaining = aus->current_tx_remaining_bytes;
118 const u8 *tx_buf = aus->current_transfer->tx_buf;
123 if (at91_usart_spi_tx_ready(aus)) {
124 at91_usart_spi_writeb(aus, THR, tx_buf[len - remaining]);
125 aus->current_tx_remaining_bytes--;
129 static inline void at91_usart_spi_rx(struct at91_usart_spi *aus)
131 int len = aus->current_transfer->len;
132 int remaining = aus->current_rx_remaining_bytes;
133 u8 *rx_buf = aus->current_transfer->rx_buf;
138 rx_buf[len - remaining] = at91_usart_spi_readb(aus, RHR);
139 aus->current_rx_remaining_bytes--;
143 at91_usart_spi_set_xfer_speed(struct at91_usart_spi *aus,
144 struct spi_transfer *xfer)
146 at91_usart_spi_writel(aus, BRGR,
147 DIV_ROUND_UP(aus->spi_clk, xfer->speed_hz));
150 static irqreturn_t at91_usart_spi_interrupt(int irq, void *dev_id)
152 struct spi_controller *controller = dev_id;
153 struct at91_usart_spi *aus = spi_master_get_devdata(controller);
155 spin_lock(&aus->lock);
156 at91_usart_spi_read_status(aus);
158 if (at91_usart_spi_check_overrun(aus)) {
159 aus->xfer_failed = true;
160 at91_usart_spi_writel(aus, IDR, US_IR_OVRE | US_IR_RXRDY);
161 spin_unlock(&aus->lock);
165 if (at91_usart_spi_rx_ready(aus)) {
166 at91_usart_spi_rx(aus);
167 spin_unlock(&aus->lock);
171 spin_unlock(&aus->lock);
176 static int at91_usart_spi_setup(struct spi_device *spi)
178 struct at91_usart_spi *aus = spi_master_get_devdata(spi->controller);
179 u32 *ausd = spi->controller_state;
180 unsigned int mr = at91_usart_spi_readl(aus, MR);
182 if (spi->mode & SPI_CPOL)
187 if (spi->mode & SPI_CPHA)
192 if (spi->mode & SPI_LOOP)
198 ausd = kzalloc(sizeof(*ausd), GFP_KERNEL);
202 spi->controller_state = ausd;
208 "setup: bpw %u mode 0x%x -> mr %d %08x\n",
209 spi->bits_per_word, spi->mode, spi->chip_select, mr);
214 static int at91_usart_spi_transfer_one(struct spi_controller *ctlr,
215 struct spi_device *spi,
216 struct spi_transfer *xfer)
218 struct at91_usart_spi *aus = spi_master_get_devdata(ctlr);
220 at91_usart_spi_set_xfer_speed(aus, xfer);
221 aus->xfer_failed = false;
222 aus->current_transfer = xfer;
223 aus->current_tx_remaining_bytes = xfer->len;
224 aus->current_rx_remaining_bytes = xfer->len;
226 while ((aus->current_tx_remaining_bytes ||
227 aus->current_rx_remaining_bytes) && !aus->xfer_failed) {
228 at91_usart_spi_read_status(aus);
229 at91_usart_spi_tx(aus);
233 if (aus->xfer_failed) {
234 dev_err(aus->dev, "Overrun!\n");
241 static int at91_usart_spi_prepare_message(struct spi_controller *ctlr,
242 struct spi_message *message)
244 struct at91_usart_spi *aus = spi_master_get_devdata(ctlr);
245 struct spi_device *spi = message->spi;
246 u32 *ausd = spi->controller_state;
248 at91_usart_spi_writel(aus, CR, US_ENABLE);
249 at91_usart_spi_writel(aus, IER, US_OVRE_RXRDY_IRQS);
250 at91_usart_spi_writel(aus, MR, *ausd);
255 static int at91_usart_spi_unprepare_message(struct spi_controller *ctlr,
256 struct spi_message *message)
258 struct at91_usart_spi *aus = spi_master_get_devdata(ctlr);
260 at91_usart_spi_writel(aus, CR, US_RESET | US_DISABLE);
261 at91_usart_spi_writel(aus, IDR, US_OVRE_RXRDY_IRQS);
266 static void at91_usart_spi_cleanup(struct spi_device *spi)
268 struct at91_usart_spi_device *ausd = spi->controller_state;
270 spi->controller_state = NULL;
274 static void at91_usart_spi_init(struct at91_usart_spi *aus)
276 at91_usart_spi_writel(aus, MR, US_INIT);
277 at91_usart_spi_writel(aus, CR, US_RESET | US_DISABLE);
280 static int at91_usart_gpio_setup(struct platform_device *pdev)
282 struct device_node *np = pdev->dev.parent->of_node;
290 nb = of_gpio_named_count(np, "cs-gpios");
291 for (i = 0; i < nb; i++) {
292 int cs_gpio = of_get_named_gpio(np, "cs-gpios", i);
297 if (gpio_is_valid(cs_gpio)) {
298 ret = devm_gpio_request_one(&pdev->dev, cs_gpio,
300 dev_name(&pdev->dev));
309 static int at91_usart_spi_probe(struct platform_device *pdev)
311 struct resource *regs;
312 struct spi_controller *controller;
313 struct at91_usart_spi *aus;
318 regs = platform_get_resource(to_platform_device(pdev->dev.parent),
323 irq = platform_get_irq(to_platform_device(pdev->dev.parent), 0);
327 clk = devm_clk_get(pdev->dev.parent, "usart");
332 controller = spi_alloc_master(&pdev->dev, sizeof(*aus));
334 goto at91_usart_spi_probe_fail;
336 ret = at91_usart_gpio_setup(pdev);
338 goto at91_usart_spi_probe_fail;
340 controller->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LOOP | SPI_CS_HIGH;
341 controller->dev.of_node = pdev->dev.parent->of_node;
342 controller->bits_per_word_mask = SPI_BPW_MASK(8);
343 controller->setup = at91_usart_spi_setup;
344 controller->flags = SPI_MASTER_MUST_RX | SPI_MASTER_MUST_TX;
345 controller->transfer_one = at91_usart_spi_transfer_one;
346 controller->prepare_message = at91_usart_spi_prepare_message;
347 controller->unprepare_message = at91_usart_spi_unprepare_message;
348 controller->cleanup = at91_usart_spi_cleanup;
349 controller->max_speed_hz = DIV_ROUND_UP(clk_get_rate(clk),
351 controller->min_speed_hz = DIV_ROUND_UP(clk_get_rate(clk),
353 platform_set_drvdata(pdev, controller);
355 aus = spi_master_get_devdata(controller);
357 aus->dev = &pdev->dev;
358 aus->regs = devm_ioremap_resource(&pdev->dev, regs);
359 if (IS_ERR(aus->regs)) {
360 ret = PTR_ERR(aus->regs);
361 goto at91_usart_spi_probe_fail;
367 ret = devm_request_irq(&pdev->dev, irq, at91_usart_spi_interrupt, 0,
368 dev_name(&pdev->dev), controller);
370 goto at91_usart_spi_probe_fail;
372 ret = clk_prepare_enable(clk);
374 goto at91_usart_spi_probe_fail;
376 aus->spi_clk = clk_get_rate(clk);
377 at91_usart_spi_init(aus);
379 spin_lock_init(&aus->lock);
380 ret = devm_spi_register_master(&pdev->dev, controller);
382 goto at91_usart_fail_register_master;
385 "AT91 USART SPI Controller version 0x%x at %pa (irq %d)\n",
386 at91_usart_spi_readl(aus, VERSION),
391 at91_usart_fail_register_master:
392 clk_disable_unprepare(clk);
393 at91_usart_spi_probe_fail:
394 spi_master_put(controller);
398 __maybe_unused static int at91_usart_spi_runtime_suspend(struct device *dev)
400 struct spi_controller *ctlr = dev_get_drvdata(dev);
401 struct at91_usart_spi *aus = spi_master_get_devdata(ctlr);
403 clk_disable_unprepare(aus->clk);
404 pinctrl_pm_select_sleep_state(dev);
409 __maybe_unused static int at91_usart_spi_runtime_resume(struct device *dev)
411 struct spi_controller *ctrl = dev_get_drvdata(dev);
412 struct at91_usart_spi *aus = spi_master_get_devdata(ctrl);
414 pinctrl_pm_select_default_state(dev);
416 return clk_prepare_enable(aus->clk);
419 __maybe_unused static int at91_usart_spi_suspend(struct device *dev)
421 struct spi_controller *ctrl = dev_get_drvdata(dev);
424 ret = spi_controller_suspend(ctrl);
428 if (!pm_runtime_suspended(dev))
429 at91_usart_spi_runtime_suspend(dev);
434 __maybe_unused static int at91_usart_spi_resume(struct device *dev)
436 struct spi_controller *ctrl = dev_get_drvdata(dev);
437 struct at91_usart_spi *aus = spi_master_get_devdata(ctrl);
440 if (!pm_runtime_suspended(dev)) {
441 ret = at91_usart_spi_runtime_resume(dev);
446 at91_usart_spi_init(aus);
448 return spi_controller_resume(ctrl);
451 static int at91_usart_spi_remove(struct platform_device *pdev)
453 struct spi_controller *ctlr = platform_get_drvdata(pdev);
454 struct at91_usart_spi *aus = spi_master_get_devdata(ctlr);
456 clk_disable_unprepare(aus->clk);
461 static const struct dev_pm_ops at91_usart_spi_pm_ops = {
462 SET_SYSTEM_SLEEP_PM_OPS(at91_usart_spi_suspend, at91_usart_spi_resume)
463 SET_RUNTIME_PM_OPS(at91_usart_spi_runtime_suspend,
464 at91_usart_spi_runtime_resume, NULL)
467 static const struct of_device_id at91_usart_spi_dt_ids[] = {
468 { .compatible = "microchip,at91sam9g45-usart-spi"},
472 MODULE_DEVICE_TABLE(of, at91_usart_spi_dt_ids);
474 static struct platform_driver at91_usart_spi_driver = {
476 .name = "at91_usart_spi",
477 .pm = &at91_usart_spi_pm_ops,
479 .probe = at91_usart_spi_probe,
480 .remove = at91_usart_spi_remove,
483 module_platform_driver(at91_usart_spi_driver);
485 MODULE_DESCRIPTION("Microchip AT91 USART SPI Controller driver");
486 MODULE_AUTHOR("Radu Pirea <radu.pirea@microchip.com>");
487 MODULE_LICENSE("GPL v2");
488 MODULE_ALIAS("platform:at91_usart_spi");