4 * Xilinx SPI controller driver (master mode only)
6 * Author: MontaVista Software, Inc.
9 * 2002-2007 (c) MontaVista Software, Inc. This file is licensed under the
10 * terms of the GNU General Public License version 2. This program is licensed
11 * "as is" without any warranty of any kind, whether express or implied.
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/interrupt.h>
18 #include <linux/spi/spi.h>
19 #include <linux/spi/spi_bitbang.h>
22 #include "xilinx_spi.h"
23 #include <linux/spi/xilinx_spi.h>
25 #define XILINX_SPI_NAME "xilinx_spi"
27 /* Register definitions as per "OPB Serial Peripheral Interface (SPI) (v1.00e)
28 * Product Specification", DS464
30 #define XSPI_CR_OFFSET 0x60 /* 16-bit Control Register */
32 #define XSPI_CR_ENABLE 0x02
33 #define XSPI_CR_MASTER_MODE 0x04
34 #define XSPI_CR_CPOL 0x08
35 #define XSPI_CR_CPHA 0x10
36 #define XSPI_CR_MODE_MASK (XSPI_CR_CPHA | XSPI_CR_CPOL)
37 #define XSPI_CR_TXFIFO_RESET 0x20
38 #define XSPI_CR_RXFIFO_RESET 0x40
39 #define XSPI_CR_MANUAL_SSELECT 0x80
40 #define XSPI_CR_TRANS_INHIBIT 0x100
42 #define XSPI_SR_OFFSET 0x64 /* 8-bit Status Register */
44 #define XSPI_SR_RX_EMPTY_MASK 0x01 /* Receive FIFO is empty */
45 #define XSPI_SR_RX_FULL_MASK 0x02 /* Receive FIFO is full */
46 #define XSPI_SR_TX_EMPTY_MASK 0x04 /* Transmit FIFO is empty */
47 #define XSPI_SR_TX_FULL_MASK 0x08 /* Transmit FIFO is full */
48 #define XSPI_SR_MODE_FAULT_MASK 0x10 /* Mode fault error */
50 #define XSPI_TXD_OFFSET 0x68 /* 8-bit Data Transmit Register */
51 #define XSPI_RXD_OFFSET 0x6c /* 8-bit Data Receive Register */
53 #define XSPI_SSR_OFFSET 0x70 /* 32-bit Slave Select Register */
55 /* Register definitions as per "OPB IPIF (v3.01c) Product Specification", DS414
56 * IPIF registers are 32 bit
58 #define XIPIF_V123B_DGIER_OFFSET 0x1c /* IPIF global int enable reg */
59 #define XIPIF_V123B_GINTR_ENABLE 0x80000000
61 #define XIPIF_V123B_IISR_OFFSET 0x20 /* IPIF interrupt status reg */
62 #define XIPIF_V123B_IIER_OFFSET 0x28 /* IPIF interrupt enable reg */
64 #define XSPI_INTR_MODE_FAULT 0x01 /* Mode fault error */
65 #define XSPI_INTR_SLAVE_MODE_FAULT 0x02 /* Selected as slave while
67 #define XSPI_INTR_TX_EMPTY 0x04 /* TxFIFO is empty */
68 #define XSPI_INTR_TX_UNDERRUN 0x08 /* TxFIFO was underrun */
69 #define XSPI_INTR_RX_FULL 0x10 /* RxFIFO is full */
70 #define XSPI_INTR_RX_OVERRUN 0x20 /* RxFIFO was overrun */
72 #define XIPIF_V123B_RESETR_OFFSET 0x40 /* IPIF reset register */
73 #define XIPIF_V123B_RESET_MASK 0x0a /* the value to write */
76 /* bitbang has to be first */
77 struct spi_bitbang bitbang;
78 struct completion done;
79 struct resource mem; /* phys mem */
80 void __iomem *regs; /* virt. address of the control registers */
84 u32 speed_hz; /* SCK has a fixed frequency of speed_hz Hz */
86 u8 *rx_ptr; /* pointer in the Tx buffer */
87 const u8 *tx_ptr; /* pointer in the Rx buffer */
88 int remaining_bytes; /* the number of bytes left to transfer */
89 unsigned int (*read_fn) (void __iomem *);
90 void (*write_fn) (u32, void __iomem *);
93 static void xspi_init_hw(struct xilinx_spi *xspi)
95 void __iomem *regs_base = xspi->regs;
97 /* Reset the SPI device */
98 xspi->write_fn(XIPIF_V123B_RESET_MASK,
99 regs_base + XIPIF_V123B_RESETR_OFFSET);
100 /* Disable all the interrupts just in case */
101 xspi->write_fn(0, regs_base + XIPIF_V123B_IIER_OFFSET);
102 /* Enable the global IPIF interrupt */
103 xspi->write_fn(XIPIF_V123B_GINTR_ENABLE,
104 regs_base + XIPIF_V123B_DGIER_OFFSET);
105 /* Deselect the slave on the SPI bus */
106 xspi->write_fn(0xffff, regs_base + XSPI_SSR_OFFSET);
107 /* Disable the transmitter, enable Manual Slave Select Assertion,
108 * put SPI controller into master mode, and enable it */
109 xspi->write_fn(XSPI_CR_TRANS_INHIBIT | XSPI_CR_MANUAL_SSELECT |
110 XSPI_CR_MASTER_MODE | XSPI_CR_ENABLE,
111 regs_base + XSPI_CR_OFFSET);
114 static void xilinx_spi_chipselect(struct spi_device *spi, int is_on)
116 struct xilinx_spi *xspi = spi_master_get_devdata(spi->master);
118 if (is_on == BITBANG_CS_INACTIVE) {
119 /* Deselect the slave on the SPI bus */
120 xspi->write_fn(0xffff, xspi->regs + XSPI_SSR_OFFSET);
121 } else if (is_on == BITBANG_CS_ACTIVE) {
122 /* Set the SPI clock phase and polarity */
123 u16 cr = xspi->read_fn(xspi->regs + XSPI_CR_OFFSET)
124 & ~XSPI_CR_MODE_MASK;
125 if (spi->mode & SPI_CPHA)
127 if (spi->mode & SPI_CPOL)
129 xspi->write_fn(cr, xspi->regs + XSPI_CR_OFFSET);
131 /* We do not check spi->max_speed_hz here as the SPI clock
132 * frequency is not software programmable (the IP block design
136 /* Activate the chip select */
137 xspi->write_fn(~(0x0001 << spi->chip_select),
138 xspi->regs + XSPI_SSR_OFFSET);
142 /* spi_bitbang requires custom setup_transfer() to be defined if there is a
143 * custom txrx_bufs(). We have nothing to setup here as the SPI IP block
144 * supports just 8 bits per word, and SPI clock can't be changed in software.
145 * Check for 8 bits per word. Chip select delay calculations could be
146 * added here as soon as bitbang_work() can be made aware of the delay value.
148 static int xilinx_spi_setup_transfer(struct spi_device *spi,
149 struct spi_transfer *t)
153 bits_per_word = (t && t->bits_per_word)
154 ? t->bits_per_word : spi->bits_per_word;
155 if (bits_per_word != 8) {
156 dev_err(&spi->dev, "%s, unsupported bits_per_word=%d\n",
157 __func__, bits_per_word);
164 static int xilinx_spi_setup(struct spi_device *spi)
166 struct spi_bitbang *bitbang;
167 struct xilinx_spi *xspi;
170 xspi = spi_master_get_devdata(spi->master);
171 bitbang = &xspi->bitbang;
173 retval = xilinx_spi_setup_transfer(spi, NULL);
180 static void xilinx_spi_fill_tx_fifo(struct xilinx_spi *xspi)
184 /* Fill the Tx FIFO with as many bytes as possible */
185 sr = xspi->read_fn(xspi->regs + XSPI_SR_OFFSET);
186 while ((sr & XSPI_SR_TX_FULL_MASK) == 0 && xspi->remaining_bytes > 0) {
188 xspi->write_fn(*xspi->tx_ptr++,
189 xspi->regs + XSPI_TXD_OFFSET);
191 xspi->write_fn(0, xspi->regs + XSPI_TXD_OFFSET);
192 xspi->remaining_bytes--;
193 sr = xspi->read_fn(xspi->regs + XSPI_SR_OFFSET);
197 static int xilinx_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t)
199 struct xilinx_spi *xspi = spi_master_get_devdata(spi->master);
203 /* We get here with transmitter inhibited */
205 xspi->tx_ptr = t->tx_buf;
206 xspi->rx_ptr = t->rx_buf;
207 xspi->remaining_bytes = t->len;
208 INIT_COMPLETION(xspi->done);
210 xilinx_spi_fill_tx_fifo(xspi);
212 /* Enable the transmit empty interrupt, which we use to determine
213 * progress on the transmission.
215 ipif_ier = xspi->read_fn(xspi->regs + XIPIF_V123B_IIER_OFFSET);
216 xspi->write_fn(ipif_ier | XSPI_INTR_TX_EMPTY,
217 xspi->regs + XIPIF_V123B_IIER_OFFSET);
219 /* Start the transfer by not inhibiting the transmitter any longer */
220 cr = xspi->read_fn(xspi->regs + XSPI_CR_OFFSET) &
221 ~XSPI_CR_TRANS_INHIBIT;
222 xspi->write_fn(cr, xspi->regs + XSPI_CR_OFFSET);
224 wait_for_completion(&xspi->done);
226 /* Disable the transmit empty interrupt */
227 xspi->write_fn(ipif_ier, xspi->regs + XIPIF_V123B_IIER_OFFSET);
229 return t->len - xspi->remaining_bytes;
233 /* This driver supports single master mode only. Hence Tx FIFO Empty
234 * is the only interrupt we care about.
235 * Receive FIFO Overrun, Transmit FIFO Underrun, Mode Fault, and Slave Mode
236 * Fault are not to happen.
238 static irqreturn_t xilinx_spi_irq(int irq, void *dev_id)
240 struct xilinx_spi *xspi = dev_id;
243 /* Get the IPIF interrupts, and clear them immediately */
244 ipif_isr = xspi->read_fn(xspi->regs + XIPIF_V123B_IISR_OFFSET);
245 xspi->write_fn(ipif_isr, xspi->regs + XIPIF_V123B_IISR_OFFSET);
247 if (ipif_isr & XSPI_INTR_TX_EMPTY) { /* Transmission completed */
251 /* A transmit has just completed. Process received data and
252 * check for more data to transmit. Always inhibit the
253 * transmitter while the Isr refills the transmit register/FIFO,
254 * or make sure it is stopped if we're done.
256 cr = xspi->read_fn(xspi->regs + XSPI_CR_OFFSET);
257 xspi->write_fn(cr | XSPI_CR_TRANS_INHIBIT,
258 xspi->regs + XSPI_CR_OFFSET);
260 /* Read out all the data from the Rx FIFO */
261 sr = xspi->read_fn(xspi->regs + XSPI_SR_OFFSET);
262 while ((sr & XSPI_SR_RX_EMPTY_MASK) == 0) {
265 data = xspi->read_fn(xspi->regs + XSPI_RXD_OFFSET);
267 *xspi->rx_ptr++ = data;
269 sr = xspi->read_fn(xspi->regs + XSPI_SR_OFFSET);
272 /* See if there is more data to send */
273 if (xspi->remaining_bytes > 0) {
274 xilinx_spi_fill_tx_fifo(xspi);
275 /* Start the transfer by not inhibiting the
276 * transmitter any longer
278 xspi->write_fn(cr, xspi->regs + XSPI_CR_OFFSET);
280 /* No more data to send.
281 * Indicate the transfer is completed.
283 complete(&xspi->done);
290 struct spi_master *xilinx_spi_init(struct device *dev, struct resource *mem,
291 u32 irq, s16 bus_num)
293 struct spi_master *master;
294 struct xilinx_spi *xspi;
295 struct xspi_platform_data *pdata = dev->platform_data;
299 dev_err(dev, "No platform data attached\n");
303 master = spi_alloc_master(dev, sizeof(struct xilinx_spi));
307 /* the spi->mode bits understood by this driver: */
308 master->mode_bits = SPI_CPOL | SPI_CPHA;
310 xspi = spi_master_get_devdata(master);
311 xspi->bitbang.master = spi_master_get(master);
312 xspi->bitbang.chipselect = xilinx_spi_chipselect;
313 xspi->bitbang.setup_transfer = xilinx_spi_setup_transfer;
314 xspi->bitbang.txrx_bufs = xilinx_spi_txrx_bufs;
315 xspi->bitbang.master->setup = xilinx_spi_setup;
316 init_completion(&xspi->done);
318 if (!request_mem_region(mem->start, resource_size(mem),
322 xspi->regs = ioremap(mem->start, resource_size(mem));
323 if (xspi->regs == NULL) {
324 dev_warn(dev, "ioremap failure\n");
328 master->bus_num = bus_num;
329 master->num_chipselect = pdata->num_chipselect;
333 if (pdata->little_endian) {
334 xspi->read_fn = ioread32;
335 xspi->write_fn = iowrite32;
337 xspi->read_fn = ioread32be;
338 xspi->write_fn = iowrite32be;
341 /* SPI controller initializations */
344 /* Register for SPI Interrupt */
345 ret = request_irq(xspi->irq, xilinx_spi_irq, 0, XILINX_SPI_NAME, xspi);
349 ret = spi_bitbang_start(&xspi->bitbang);
351 dev_err(dev, "spi_bitbang_start FAILED\n");
355 dev_info(dev, "at 0x%08X mapped to 0x%08X, irq=%d\n",
356 (u32)mem->start, (u32)xspi->regs, xspi->irq);
360 free_irq(xspi->irq, xspi);
364 release_mem_region(mem->start, resource_size(mem));
366 spi_master_put(master);
369 EXPORT_SYMBOL(xilinx_spi_init);
371 void xilinx_spi_deinit(struct spi_master *master)
373 struct xilinx_spi *xspi;
375 xspi = spi_master_get_devdata(master);
377 spi_bitbang_stop(&xspi->bitbang);
378 free_irq(xspi->irq, xspi);
381 release_mem_region(xspi->mem.start, resource_size(&xspi->mem));
382 spi_master_put(xspi->bitbang.master);
384 EXPORT_SYMBOL(xilinx_spi_deinit);
386 MODULE_AUTHOR("MontaVista Software, Inc. <source@mvista.com>");
387 MODULE_DESCRIPTION("Xilinx SPI driver");
388 MODULE_LICENSE("GPL");