drivers/spi/spi-octeon.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 2011, 2012 Cavium, Inc.
   7  */
   8
   9 #include <linux/platform_device.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/spi/spi.h>
  12 #include <linux/module.h>
  13 #include <linux/delay.h>
  14 #include <linux/init.h>
  15 #include <linux/io.h>
  16 #include <linux/of.h>
  17
  18 #include <asm/octeon/octeon.h>
  19 #include <asm/octeon/cvmx-mpi-defs.h>
  20
  21 #define OCTEON_SPI_CFG 0
  22 #define OCTEON_SPI_STS 0x08
  23 #define OCTEON_SPI_TX 0x10
  24 #define OCTEON_SPI_DAT0 0x80
  25
  26 #define OCTEON_SPI_MAX_BYTES 9
  27
  28 #define OCTEON_SPI_MAX_CLOCK_HZ 16000000
  29
  30 struct octeon_spi {
  31         u64 register_base;
  32         u64 last_cfg;
  33         u64 cs_enax;
  34 };
  35
  36 static void octeon_spi_wait_ready(struct octeon_spi *p)
  37 {
  38         union cvmx_mpi_sts mpi_sts;
  39         unsigned int loops = 0;
  40
  41         do {
  42                 if (loops++)
  43                         __delay(500);
  44                 mpi_sts.u64 = cvmx_read_csr(p->register_base + OCTEON_SPI_STS);
  45         } while (mpi_sts.s.busy);
  46 }
  47
  48 static int octeon_spi_do_transfer(struct octeon_spi *p,
  49                                   struct spi_message *msg,
  50                                   struct spi_transfer *xfer,
  51                                   bool last_xfer)
  52 {
  53         struct spi_device *spi = msg->spi;
  54         union cvmx_mpi_cfg mpi_cfg;
  55         union cvmx_mpi_tx mpi_tx;
  56         unsigned int clkdiv;
  57         unsigned int speed_hz;
  58         int mode;
  59         bool cpha, cpol;
  60         const u8 *tx_buf;
  61         u8 *rx_buf;
  62         int len;
  63         int i;
  64
  65         mode = spi->mode;
  66         cpha = mode & SPI_CPHA;
  67         cpol = mode & SPI_CPOL;
  68
  69         speed_hz = xfer->speed_hz ? : spi->max_speed_hz;
  70         if (speed_hz > OCTEON_SPI_MAX_CLOCK_HZ)
  71                 speed_hz = OCTEON_SPI_MAX_CLOCK_HZ;
  72
  73         clkdiv = octeon_get_io_clock_rate() / (2 * speed_hz);
  74
  75         mpi_cfg.u64 = 0;
  76
  77         mpi_cfg.s.clkdiv = clkdiv;
  78         mpi_cfg.s.cshi = (mode & SPI_CS_HIGH) ? 1 : 0;
  79         mpi_cfg.s.lsbfirst = (mode & SPI_LSB_FIRST) ? 1 : 0;
  80         mpi_cfg.s.wireor = (mode & SPI_3WIRE) ? 1 : 0;
  81         mpi_cfg.s.idlelo = cpha != cpol;
  82         mpi_cfg.s.cslate = cpha ? 1 : 0;
  83         mpi_cfg.s.enable = 1;
  84
  85         if (spi->chip_select < 4)
  86                 p->cs_enax |= 1ull << (12 + spi->chip_select);
  87         mpi_cfg.u64 |= p->cs_enax;
  88
  89         if (mpi_cfg.u64 != p->last_cfg) {
  90                 p->last_cfg = mpi_cfg.u64;
  91                 cvmx_write_csr(p->register_base + OCTEON_SPI_CFG, mpi_cfg.u64);
  92         }
  93         tx_buf = xfer->tx_buf;
  94         rx_buf = xfer->rx_buf;
  95         len = xfer->len;
  96         while (len > OCTEON_SPI_MAX_BYTES) {
  97                 for (i = 0; i < OCTEON_SPI_MAX_BYTES; i++) {
  98                         u8 d;
  99                         if (tx_buf)
 100                                 d = *tx_buf++;
 101                         else
 102                                 d = 0;
 103                         cvmx_write_csr(p->register_base + OCTEON_SPI_DAT0 + (8 * i), d);
 104                 }
 105                 mpi_tx.u64 = 0;
 106                 mpi_tx.s.csid = spi->chip_select;
 107                 mpi_tx.s.leavecs = 1;
 108                 mpi_tx.s.txnum = tx_buf ? OCTEON_SPI_MAX_BYTES : 0;
 109                 mpi_tx.s.totnum = OCTEON_SPI_MAX_BYTES;
 110                 cvmx_write_csr(p->register_base + OCTEON_SPI_TX, mpi_tx.u64);
 111
 112                 octeon_spi_wait_ready(p);
 113                 if (rx_buf)
 114                         for (i = 0; i < OCTEON_SPI_MAX_BYTES; i++) {
 115                                 u64 v = cvmx_read_csr(p->register_base + OCTEON_SPI_DAT0 + (8 * i));
 116                                 *rx_buf++ = (u8)v;
 117                         }
 118                 len -= OCTEON_SPI_MAX_BYTES;
 119         }
 120
 121         for (i = 0; i < len; i++) {
 122                 u8 d;
 123                 if (tx_buf)
 124                         d = *tx_buf++;
 125                 else
 126                         d = 0;
 127                 cvmx_write_csr(p->register_base + OCTEON_SPI_DAT0 + (8 * i), d);
 128         }
 129
 130         mpi_tx.u64 = 0;
 131         mpi_tx.s.csid = spi->chip_select;
 132         if (last_xfer)
 133                 mpi_tx.s.leavecs = xfer->cs_change;
 134         else
 135                 mpi_tx.s.leavecs = !xfer->cs_change;
 136         mpi_tx.s.txnum = tx_buf ? len : 0;
 137         mpi_tx.s.totnum = len;
 138         cvmx_write_csr(p->register_base + OCTEON_SPI_TX, mpi_tx.u64);
 139
 140         octeon_spi_wait_ready(p);
 141         if (rx_buf)
 142                 for (i = 0; i < len; i++) {
 143                         u64 v = cvmx_read_csr(p->register_base + OCTEON_SPI_DAT0 + (8 * i));
 144                         *rx_buf++ = (u8)v;
 145                 }
 146
 147         if (xfer->delay_usecs)
 148                 udelay(xfer->delay_usecs);
 149
 150         return xfer->len;
 151 }
 152
 153 static int octeon_spi_transfer_one_message(struct spi_master *master,
 154                                            struct spi_message *msg)
 155 {
 156         struct octeon_spi *p = spi_master_get_devdata(master);
 157         unsigned int total_len = 0;
 158         int status = 0;
 159         struct spi_transfer *xfer;
 160
 161         list_for_each_entry(xfer, &msg->transfers, transfer_list) {
 162                 bool last_xfer = list_is_last(&xfer->transfer_list,
 163                                               &msg->transfers);
 164                 int r = octeon_spi_do_transfer(p, msg, xfer, last_xfer);
 165                 if (r < 0) {
 166                         status = r;
 167                         goto err;
 168                 }
 169                 total_len += r;
 170         }
 171 err:
 172         msg->status = status;
 173         msg->actual_length = total_len;
 174         spi_finalize_current_message(master);
 175         return status;
 176 }
 177
 178 static int octeon_spi_probe(struct platform_device *pdev)
 179 {
 180         struct resource *res_mem;
 181         struct spi_master *master;
 182         struct octeon_spi *p;
 183         int err = -ENOENT;
 184
 185         master = spi_alloc_master(&pdev->dev, sizeof(struct octeon_spi));
 186         if (!master)
 187                 return -ENOMEM;
 188         p = spi_master_get_devdata(master);
 189         platform_set_drvdata(pdev, master);
 190
 191         res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 192
 193         if (res_mem == NULL) {
 194                 dev_err(&pdev->dev, "found no memory resource\n");
 195                 err = -ENXIO;
 196                 goto fail;
 197         }
 198         if (!devm_request_mem_region(&pdev->dev, res_mem->start,
 199                                      resource_size(res_mem), res_mem->name)) {
 200                 dev_err(&pdev->dev, "request_mem_region failed\n");
 201                 goto fail;
 202         }
 203         p->register_base = (u64)devm_ioremap(&pdev->dev, res_mem->start,
 204                                              resource_size(res_mem));
 205
 206         /* Dynamic bus numbering */
 207         master->bus_num = -1;
 208         master->num_chipselect = 4;
 209         master->mode_bits = SPI_CPHA |
 210                             SPI_CPOL |
 211                             SPI_CS_HIGH |
 212                             SPI_LSB_FIRST |
 213                             SPI_3WIRE;
 214
 215         master->transfer_one_message = octeon_spi_transfer_one_message;
 216         master->bits_per_word_mask = SPI_BPW_MASK(8);
 217
 218         master->dev.of_node = pdev->dev.of_node;
 219         err = devm_spi_register_master(&pdev->dev, master);
 220         if (err) {
 221                 dev_err(&pdev->dev, "register master failed: %d\n", err);
 222                 goto fail;
 223         }
 224
 225         dev_info(&pdev->dev, "OCTEON SPI bus driver\n");
 226
 227         return 0;
 228 fail:
 229         spi_master_put(master);
 230         return err;
 231 }
 232
 233 static int octeon_spi_remove(struct platform_device *pdev)
 234 {
 235         struct spi_master *master = platform_get_drvdata(pdev);
 236         struct octeon_spi *p = spi_master_get_devdata(master);
 237         u64 register_base = p->register_base;
 238
 239         /* Clear the CSENA* and put everything in a known state. */
 240         cvmx_write_csr(register_base + OCTEON_SPI_CFG, 0);
 241
 242         return 0;
 243 }
 244
 245 static struct of_device_id octeon_spi_match[] = {
 246         { .compatible = "cavium,octeon-3010-spi", },
 247         {},
 248 };
 249 MODULE_DEVICE_TABLE(of, octeon_spi_match);
 250
 251 static struct platform_driver octeon_spi_driver = {
 252         .driver = {
 253                 .name           = "spi-octeon",
 254                 .owner          = THIS_MODULE,
 255                 .of_match_table = octeon_spi_match,
 256         },
 257         .probe          = octeon_spi_probe,
 258         .remove         = octeon_spi_remove,
 259 };
 260
 261 module_platform_driver(octeon_spi_driver);
 262
 263 MODULE_DESCRIPTION("Cavium, Inc. OCTEON SPI bus driver");
 264 MODULE_AUTHOR("David Daney");
 265 MODULE_LICENSE("GPL");