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