drivers/spi/spi-jcore.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * J-Core SPI controller driver
   4  *
   5  * Copyright (C) 2012-2016 Smart Energy Instruments, Inc.
   6  *
   7  * Current version by Rich Felker
   8  * Based loosely on initial version by Oleksandr G Zhadan
   9  *
  10  */
  11 #include <linux/init.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/errno.h>
  14 #include <linux/module.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/spi/spi.h>
  17 #include <linux/clk.h>
  18 #include <linux/err.h>
  19 #include <linux/io.h>
  20 #include <linux/of.h>
  21 #include <linux/delay.h>
  22
  23 #define DRV_NAME        "jcore_spi"
  24
  25 #define CTRL_REG        0x0
  26 #define DATA_REG        0x4
  27
  28 #define JCORE_SPI_CTRL_XMIT             0x02
  29 #define JCORE_SPI_STAT_BUSY             0x02
  30 #define JCORE_SPI_CTRL_LOOP             0x08
  31 #define JCORE_SPI_CTRL_CS_BITS          0x15
  32
  33 #define JCORE_SPI_WAIT_RDY_MAX_LOOP     2000000
  34
  35 struct jcore_spi {
  36         struct spi_controller *host;
  37         void __iomem *base;
  38         unsigned int cs_reg;
  39         unsigned int speed_reg;
  40         unsigned int speed_hz;
  41         unsigned int clock_freq;
  42 };
  43
  44 static int jcore_spi_wait(void __iomem *ctrl_reg)
  45 {
  46         unsigned timeout = JCORE_SPI_WAIT_RDY_MAX_LOOP;
  47
  48         do {
  49                 if (!(readl(ctrl_reg) & JCORE_SPI_STAT_BUSY))
  50                         return 0;
  51                 cpu_relax();
  52         } while (--timeout);
  53
  54         return -EBUSY;
  55 }
  56
  57 static void jcore_spi_program(struct jcore_spi *hw)
  58 {
  59         void __iomem *ctrl_reg = hw->base + CTRL_REG;
  60
  61         if (jcore_spi_wait(ctrl_reg))
  62                 dev_err(hw->host->dev.parent,
  63                         "timeout waiting to program ctrl reg.\n");
  64
  65         writel(hw->cs_reg | hw->speed_reg, ctrl_reg);
  66 }
  67
  68 static void jcore_spi_chipsel(struct spi_device *spi, bool value)
  69 {
  70         struct jcore_spi *hw = spi_controller_get_devdata(spi->controller);
  71         u32 csbit = 1U << (2 * spi_get_chipselect(spi, 0));
  72
  73         dev_dbg(hw->host->dev.parent, "chipselect %d\n", spi_get_chipselect(spi, 0));
  74
  75         if (value)
  76                 hw->cs_reg |= csbit;
  77         else
  78                 hw->cs_reg &= ~csbit;
  79
  80         jcore_spi_program(hw);
  81 }
  82
  83 static void jcore_spi_baudrate(struct jcore_spi *hw, int speed)
  84 {
  85         if (speed == hw->speed_hz)
  86                 return;
  87         hw->speed_hz = speed;
  88         if (speed >= hw->clock_freq / 2)
  89                 hw->speed_reg = 0;
  90         else
  91                 hw->speed_reg = ((hw->clock_freq / 2 / speed) - 1) << 27;
  92         jcore_spi_program(hw);
  93         dev_dbg(hw->host->dev.parent, "speed=%d reg=0x%x\n",
  94                 speed, hw->speed_reg);
  95 }
  96
  97 static int jcore_spi_txrx(struct spi_controller *host, struct spi_device *spi,
  98                           struct spi_transfer *t)
  99 {
 100         struct jcore_spi *hw = spi_controller_get_devdata(host);
 101
 102         void __iomem *ctrl_reg = hw->base + CTRL_REG;
 103         void __iomem *data_reg = hw->base + DATA_REG;
 104         u32 xmit;
 105
 106         /* data buffers */
 107         const unsigned char *tx;
 108         unsigned char *rx;
 109         unsigned int len;
 110         unsigned int count;
 111
 112         jcore_spi_baudrate(hw, t->speed_hz);
 113
 114         xmit = hw->cs_reg | hw->speed_reg | JCORE_SPI_CTRL_XMIT;
 115         tx = t->tx_buf;
 116         rx = t->rx_buf;
 117         len = t->len;
 118
 119         for (count = 0; count < len; count++) {
 120                 if (jcore_spi_wait(ctrl_reg))
 121                         break;
 122
 123                 writel(tx ? *tx++ : 0, data_reg);
 124                 writel(xmit, ctrl_reg);
 125
 126                 if (jcore_spi_wait(ctrl_reg))
 127                         break;
 128
 129                 if (rx)
 130                         *rx++ = readl(data_reg);
 131         }
 132
 133         spi_finalize_current_transfer(host);
 134
 135         if (count < len)
 136                 return -EREMOTEIO;
 137
 138         return 0;
 139 }
 140
 141 static int jcore_spi_probe(struct platform_device *pdev)
 142 {
 143         struct device_node *node = pdev->dev.of_node;
 144         struct jcore_spi *hw;
 145         struct spi_controller *host;
 146         struct resource *res;
 147         u32 clock_freq;
 148         struct clk *clk;
 149         int err = -ENODEV;
 150
 151         host = spi_alloc_host(&pdev->dev, sizeof(struct jcore_spi));
 152         if (!host)
 153                 return err;
 154
 155         /* Setup the host state. */
 156         host->num_chipselect = 3;
 157         host->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
 158         host->transfer_one = jcore_spi_txrx;
 159         host->set_cs = jcore_spi_chipsel;
 160         host->dev.of_node = node;
 161         host->bus_num = pdev->id;
 162
 163         hw = spi_controller_get_devdata(host);
 164         hw->host = host;
 165         platform_set_drvdata(pdev, hw);
 166
 167         /* Find and map our resources */
 168         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 169         if (!res)
 170                 goto exit_busy;
 171         if (!devm_request_mem_region(&pdev->dev, res->start,
 172                                      resource_size(res), pdev->name))
 173                 goto exit_busy;
 174         hw->base = devm_ioremap(&pdev->dev, res->start,
 175                                         resource_size(res));
 176         if (!hw->base)
 177                 goto exit_busy;
 178
 179         /*
 180          * The SPI clock rate controlled via a configurable clock divider
 181          * which is applied to the reference clock. A 50 MHz reference is
 182          * most suitable for obtaining standard SPI clock rates, but some
 183          * designs may have a different reference clock, and the DT must
 184          * make the driver aware so that it can properly program the
 185          * requested rate. If the clock is omitted, 50 MHz is assumed.
 186          */
 187         clock_freq = 50000000;
 188         clk = devm_clk_get(&pdev->dev, "ref_clk");
 189         if (!IS_ERR(clk)) {
 190                 if (clk_prepare_enable(clk) == 0) {
 191                         clock_freq = clk_get_rate(clk);
 192                         clk_disable_unprepare(clk);
 193                 } else
 194                         dev_warn(&pdev->dev, "could not enable ref_clk\n");
 195         }
 196         hw->clock_freq = clock_freq;
 197
 198         /* Initialize all CS bits to high. */
 199         hw->cs_reg = JCORE_SPI_CTRL_CS_BITS;
 200         jcore_spi_baudrate(hw, 400000);
 201
 202         /* Register our spi controller */
 203         err = devm_spi_register_controller(&pdev->dev, host);
 204         if (err)
 205                 goto exit;
 206
 207         return 0;
 208
 209 exit_busy:
 210         err = -EBUSY;
 211 exit:
 212         spi_controller_put(host);
 213         return err;
 214 }
 215
 216 static const struct of_device_id jcore_spi_of_match[] = {
 217         { .compatible = "jcore,spi2" },
 218         {},
 219 };
 220 MODULE_DEVICE_TABLE(of, jcore_spi_of_match);
 221
 222 static struct platform_driver jcore_spi_driver = {
 223         .probe = jcore_spi_probe,
 224         .driver = {
 225                 .name = DRV_NAME,
 226                 .of_match_table = jcore_spi_of_match,
 227         },
 228 };
 229
 230 module_platform_driver(jcore_spi_driver);
 231
 232 MODULE_DESCRIPTION("J-Core SPI driver");
 233 MODULE_AUTHOR("Rich Felker <dalias@libc.org>");
 234 MODULE_LICENSE("GPL");
 235 MODULE_ALIAS("platform:" DRV_NAME);