drivers/spi/spi-dw-mid.c

   1 /*
   2  * Special handling for DW core on Intel MID platform
   3  *
   4  * Copyright (c) 2009, 2014 Intel Corporation.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms and conditions of the GNU General Public License,
   8  * version 2, as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  */
  15
  16 #include <linux/dma-mapping.h>
  17 #include <linux/dmaengine.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/slab.h>
  20 #include <linux/spi/spi.h>
  21 #include <linux/types.h>
  22
  23 #include "spi-dw.h"
  24
  25 #ifdef CONFIG_SPI_DW_MID_DMA
  26 #include <linux/intel_mid_dma.h>
  27 #include <linux/pci.h>
  28
  29 #define RX_BUSY         0
  30 #define TX_BUSY         1
  31
  32 struct mid_dma {
  33         struct intel_mid_dma_slave      dmas_tx;
  34         struct intel_mid_dma_slave      dmas_rx;
  35 };
  36
  37 static bool mid_spi_dma_chan_filter(struct dma_chan *chan, void *param)
  38 {
  39         struct dw_spi *dws = param;
  40
  41         return dws->dma_dev == chan->device->dev;
  42 }
  43
  44 static int mid_spi_dma_init(struct dw_spi *dws)
  45 {
  46         struct mid_dma *dw_dma = dws->dma_priv;
  47         struct pci_dev *dma_dev;
  48         struct intel_mid_dma_slave *rxs, *txs;
  49         dma_cap_mask_t mask;
  50
  51         /*
  52          * Get pci device for DMA controller, currently it could only
  53          * be the DMA controller of Medfield
  54          */
  55         dma_dev = pci_get_device(PCI_VENDOR_ID_INTEL, 0x0827, NULL);
  56         if (!dma_dev)
  57                 return -ENODEV;
  58
  59         dws->dma_dev = &dma_dev->dev;
  60
  61         dma_cap_zero(mask);
  62         dma_cap_set(DMA_SLAVE, mask);
  63
  64         /* 1. Init rx channel */
  65         dws->rxchan = dma_request_channel(mask, mid_spi_dma_chan_filter, dws);
  66         if (!dws->rxchan)
  67                 goto err_exit;
  68         rxs = &dw_dma->dmas_rx;
  69         rxs->hs_mode = LNW_DMA_HW_HS;
  70         rxs->cfg_mode = LNW_DMA_PER_TO_MEM;
  71         dws->rxchan->private = rxs;
  72
  73         /* 2. Init tx channel */
  74         dws->txchan = dma_request_channel(mask, mid_spi_dma_chan_filter, dws);
  75         if (!dws->txchan)
  76                 goto free_rxchan;
  77         txs = &dw_dma->dmas_tx;
  78         txs->hs_mode = LNW_DMA_HW_HS;
  79         txs->cfg_mode = LNW_DMA_MEM_TO_PER;
  80         dws->txchan->private = txs;
  81
  82         dws->dma_inited = 1;
  83         return 0;
  84
  85 free_rxchan:
  86         dma_release_channel(dws->rxchan);
  87 err_exit:
  88         return -EBUSY;
  89 }
  90
  91 static void mid_spi_dma_exit(struct dw_spi *dws)
  92 {
  93         if (!dws->dma_inited)
  94                 return;
  95
  96         dmaengine_terminate_all(dws->txchan);
  97         dma_release_channel(dws->txchan);
  98
  99         dmaengine_terminate_all(dws->rxchan);
 100         dma_release_channel(dws->rxchan);
 101 }
 102
 103 /*
 104  * dws->dma_chan_busy is set before the dma transfer starts, callback for tx
 105  * channel will clear a corresponding bit.
 106  */
 107 static void dw_spi_dma_tx_done(void *arg)
 108 {
 109         struct dw_spi *dws = arg;
 110
 111         if (test_and_clear_bit(TX_BUSY, &dws->dma_chan_busy) & BIT(RX_BUSY))
 112                 return;
 113         dw_spi_xfer_done(dws);
 114 }
 115
 116 static struct dma_async_tx_descriptor *dw_spi_dma_prepare_tx(struct dw_spi *dws)
 117 {
 118         struct dma_slave_config txconf;
 119         struct dma_async_tx_descriptor *txdesc;
 120
 121         if (!dws->tx_dma)
 122                 return NULL;
 123
 124         txconf.direction = DMA_MEM_TO_DEV;
 125         txconf.dst_addr = dws->dma_addr;
 126         txconf.dst_maxburst = LNW_DMA_MSIZE_16;
 127         txconf.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
 128         txconf.dst_addr_width = dws->dma_width;
 129         txconf.device_fc = false;
 130
 131         dmaengine_slave_config(dws->txchan, &txconf);
 132
 133         memset(&dws->tx_sgl, 0, sizeof(dws->tx_sgl));
 134         dws->tx_sgl.dma_address = dws->tx_dma;
 135         dws->tx_sgl.length = dws->len;
 136
 137         txdesc = dmaengine_prep_slave_sg(dws->txchan,
 138                                 &dws->tx_sgl,
 139                                 1,
 140                                 DMA_MEM_TO_DEV,
 141                                 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
 142         if (!txdesc)
 143                 return NULL;
 144
 145         txdesc->callback = dw_spi_dma_tx_done;
 146         txdesc->callback_param = dws;
 147
 148         return txdesc;
 149 }
 150
 151 /*
 152  * dws->dma_chan_busy is set before the dma transfer starts, callback for rx
 153  * channel will clear a corresponding bit.
 154  */
 155 static void dw_spi_dma_rx_done(void *arg)
 156 {
 157         struct dw_spi *dws = arg;
 158
 159         if (test_and_clear_bit(RX_BUSY, &dws->dma_chan_busy) & BIT(TX_BUSY))
 160                 return;
 161         dw_spi_xfer_done(dws);
 162 }
 163
 164 static struct dma_async_tx_descriptor *dw_spi_dma_prepare_rx(struct dw_spi *dws)
 165 {
 166         struct dma_slave_config rxconf;
 167         struct dma_async_tx_descriptor *rxdesc;
 168
 169         if (!dws->rx_dma)
 170                 return NULL;
 171
 172         rxconf.direction = DMA_DEV_TO_MEM;
 173         rxconf.src_addr = dws->dma_addr;
 174         rxconf.src_maxburst = LNW_DMA_MSIZE_16;
 175         rxconf.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
 176         rxconf.src_addr_width = dws->dma_width;
 177         rxconf.device_fc = false;
 178
 179         dmaengine_slave_config(dws->rxchan, &rxconf);
 180
 181         memset(&dws->rx_sgl, 0, sizeof(dws->rx_sgl));
 182         dws->rx_sgl.dma_address = dws->rx_dma;
 183         dws->rx_sgl.length = dws->len;
 184
 185         rxdesc = dmaengine_prep_slave_sg(dws->rxchan,
 186                                 &dws->rx_sgl,
 187                                 1,
 188                                 DMA_DEV_TO_MEM,
 189                                 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
 190         if (!rxdesc)
 191                 return NULL;
 192
 193         rxdesc->callback = dw_spi_dma_rx_done;
 194         rxdesc->callback_param = dws;
 195
 196         return rxdesc;
 197 }
 198
 199 static void dw_spi_dma_setup(struct dw_spi *dws)
 200 {
 201         u16 dma_ctrl = 0;
 202
 203         spi_enable_chip(dws, 0);
 204
 205         dw_writew(dws, DW_SPI_DMARDLR, 0xf);
 206         dw_writew(dws, DW_SPI_DMATDLR, 0x10);
 207
 208         if (dws->tx_dma)
 209                 dma_ctrl |= SPI_DMA_TDMAE;
 210         if (dws->rx_dma)
 211                 dma_ctrl |= SPI_DMA_RDMAE;
 212         dw_writew(dws, DW_SPI_DMACR, dma_ctrl);
 213
 214         spi_enable_chip(dws, 1);
 215 }
 216
 217 static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
 218 {
 219         struct dma_async_tx_descriptor *txdesc, *rxdesc;
 220
 221         /* 1. setup DMA related registers */
 222         if (cs_change)
 223                 dw_spi_dma_setup(dws);
 224
 225         /* 2. Prepare the TX dma transfer */
 226         txdesc = dw_spi_dma_prepare_tx(dws);
 227
 228         /* 3. Prepare the RX dma transfer */
 229         rxdesc = dw_spi_dma_prepare_rx(dws);
 230
 231         /* rx must be started before tx due to spi instinct */
 232         if (rxdesc) {
 233                 set_bit(RX_BUSY, &dws->dma_chan_busy);
 234                 dmaengine_submit(rxdesc);
 235                 dma_async_issue_pending(dws->rxchan);
 236         }
 237
 238         if (txdesc) {
 239                 set_bit(TX_BUSY, &dws->dma_chan_busy);
 240                 dmaengine_submit(txdesc);
 241                 dma_async_issue_pending(dws->txchan);
 242         }
 243
 244         return 0;
 245 }
 246
 247 static struct dw_spi_dma_ops mid_dma_ops = {
 248         .dma_init       = mid_spi_dma_init,
 249         .dma_exit       = mid_spi_dma_exit,
 250         .dma_transfer   = mid_spi_dma_transfer,
 251 };
 252 #endif
 253
 254 /* Some specific info for SPI0 controller on Intel MID */
 255
 256 /* HW info for MRST Clk Control Unit, 32b reg per controller */
 257 #define MRST_SPI_CLK_BASE       100000000       /* 100m */
 258 #define MRST_CLK_SPI_REG        0xff11d86c
 259 #define CLK_SPI_BDIV_OFFSET     0
 260 #define CLK_SPI_BDIV_MASK       0x00000007
 261 #define CLK_SPI_CDIV_OFFSET     9
 262 #define CLK_SPI_CDIV_MASK       0x00000e00
 263 #define CLK_SPI_DISABLE_OFFSET  8
 264
 265 int dw_spi_mid_init(struct dw_spi *dws)
 266 {
 267         void __iomem *clk_reg;
 268         u32 clk_cdiv;
 269
 270         clk_reg = ioremap_nocache(MRST_CLK_SPI_REG, 16);
 271         if (!clk_reg)
 272                 return -ENOMEM;
 273
 274         /* Get SPI controller operating freq info */
 275         clk_cdiv = readl(clk_reg + dws->bus_num * sizeof(u32));
 276         clk_cdiv &= CLK_SPI_CDIV_MASK;
 277         clk_cdiv >>= CLK_SPI_CDIV_OFFSET;
 278         dws->max_freq = MRST_SPI_CLK_BASE / (clk_cdiv + 1);
 279
 280         iounmap(clk_reg);
 281
 282 #ifdef CONFIG_SPI_DW_MID_DMA
 283         dws->dma_priv = kzalloc(sizeof(struct mid_dma), GFP_KERNEL);
 284         if (!dws->dma_priv)
 285                 return -ENOMEM;
 286         dws->dma_ops = &mid_dma_ops;
 287 #endif
 288         return 0;
 289 }