2 * Designware SPI core controller driver (refer pxa2xx_spi.c)
4 * Copyright (c) 2009, Intel Corporation.
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.
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
16 #include <linux/dma-mapping.h>
17 #include <linux/interrupt.h>
18 #include <linux/module.h>
19 #include <linux/highmem.h>
20 #include <linux/delay.h>
21 #include <linux/slab.h>
22 #include <linux/spi/spi.h>
23 #include <linux/gpio.h>
27 #ifdef CONFIG_DEBUG_FS
28 #include <linux/debugfs.h>
31 /* Slave spi_dev related */
33 u8 cs
; /* chip select pin */
34 u8 tmode
; /* TR/TO/RO/EEPROM */
35 u8 type
; /* SPI/SSP/MicroWire */
37 u8 poll_mode
; /* 1 means use poll mode */
42 u16 clk_div
; /* baud rate divider */
43 u32 speed_hz
; /* baud rate */
44 void (*cs_control
)(u32 command
);
47 #ifdef CONFIG_DEBUG_FS
48 #define SPI_REGS_BUFSIZE 1024
49 static ssize_t
dw_spi_show_regs(struct file
*file
, char __user
*user_buf
,
50 size_t count
, loff_t
*ppos
)
52 struct dw_spi
*dws
= file
->private_data
;
57 buf
= kzalloc(SPI_REGS_BUFSIZE
, GFP_KERNEL
);
61 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
62 "%s registers:\n", dev_name(&dws
->master
->dev
));
63 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
64 "=================================\n");
65 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
66 "CTRL0: \t\t0x%08x\n", dw_readl(dws
, DW_SPI_CTRL0
));
67 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
68 "CTRL1: \t\t0x%08x\n", dw_readl(dws
, DW_SPI_CTRL1
));
69 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
70 "SSIENR: \t0x%08x\n", dw_readl(dws
, DW_SPI_SSIENR
));
71 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
72 "SER: \t\t0x%08x\n", dw_readl(dws
, DW_SPI_SER
));
73 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
74 "BAUDR: \t\t0x%08x\n", dw_readl(dws
, DW_SPI_BAUDR
));
75 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
76 "TXFTLR: \t0x%08x\n", dw_readl(dws
, DW_SPI_TXFLTR
));
77 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
78 "RXFTLR: \t0x%08x\n", dw_readl(dws
, DW_SPI_RXFLTR
));
79 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
80 "TXFLR: \t\t0x%08x\n", dw_readl(dws
, DW_SPI_TXFLR
));
81 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
82 "RXFLR: \t\t0x%08x\n", dw_readl(dws
, DW_SPI_RXFLR
));
83 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
84 "SR: \t\t0x%08x\n", dw_readl(dws
, DW_SPI_SR
));
85 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
86 "IMR: \t\t0x%08x\n", dw_readl(dws
, DW_SPI_IMR
));
87 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
88 "ISR: \t\t0x%08x\n", dw_readl(dws
, DW_SPI_ISR
));
89 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
90 "DMACR: \t\t0x%08x\n", dw_readl(dws
, DW_SPI_DMACR
));
91 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
92 "DMATDLR: \t0x%08x\n", dw_readl(dws
, DW_SPI_DMATDLR
));
93 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
94 "DMARDLR: \t0x%08x\n", dw_readl(dws
, DW_SPI_DMARDLR
));
95 len
+= snprintf(buf
+ len
, SPI_REGS_BUFSIZE
- len
,
96 "=================================\n");
98 ret
= simple_read_from_buffer(user_buf
, count
, ppos
, buf
, len
);
103 static const struct file_operations dw_spi_regs_ops
= {
104 .owner
= THIS_MODULE
,
106 .read
= dw_spi_show_regs
,
107 .llseek
= default_llseek
,
110 static int dw_spi_debugfs_init(struct dw_spi
*dws
)
112 dws
->debugfs
= debugfs_create_dir("dw_spi", NULL
);
116 debugfs_create_file("registers", S_IFREG
| S_IRUGO
,
117 dws
->debugfs
, (void *)dws
, &dw_spi_regs_ops
);
121 static void dw_spi_debugfs_remove(struct dw_spi
*dws
)
123 debugfs_remove_recursive(dws
->debugfs
);
127 static inline int dw_spi_debugfs_init(struct dw_spi
*dws
)
132 static inline void dw_spi_debugfs_remove(struct dw_spi
*dws
)
135 #endif /* CONFIG_DEBUG_FS */
137 static void dw_spi_set_cs(struct spi_device
*spi
, bool enable
)
139 struct dw_spi
*dws
= spi_master_get_devdata(spi
->master
);
140 struct chip_data
*chip
= spi_get_ctldata(spi
);
142 /* Chip select logic is inverted from spi_set_cs() */
143 if (chip
&& chip
->cs_control
)
144 chip
->cs_control(!enable
);
147 dw_writel(dws
, DW_SPI_SER
, BIT(spi
->chip_select
));
150 /* Return the max entries we can fill into tx fifo */
151 static inline u32
tx_max(struct dw_spi
*dws
)
153 u32 tx_left
, tx_room
, rxtx_gap
;
155 tx_left
= (dws
->tx_end
- dws
->tx
) / dws
->n_bytes
;
156 tx_room
= dws
->fifo_len
- dw_readl(dws
, DW_SPI_TXFLR
);
159 * Another concern is about the tx/rx mismatch, we
160 * though to use (dws->fifo_len - rxflr - txflr) as
161 * one maximum value for tx, but it doesn't cover the
162 * data which is out of tx/rx fifo and inside the
163 * shift registers. So a control from sw point of
166 rxtx_gap
= ((dws
->rx_end
- dws
->rx
) - (dws
->tx_end
- dws
->tx
))
169 return min3(tx_left
, tx_room
, (u32
) (dws
->fifo_len
- rxtx_gap
));
172 /* Return the max entries we should read out of rx fifo */
173 static inline u32
rx_max(struct dw_spi
*dws
)
175 u32 rx_left
= (dws
->rx_end
- dws
->rx
) / dws
->n_bytes
;
177 return min_t(u32
, rx_left
, dw_readl(dws
, DW_SPI_RXFLR
));
180 static void dw_writer(struct dw_spi
*dws
)
182 u32 max
= tx_max(dws
);
186 /* Set the tx word if the transfer's original "tx" is not null */
187 if (dws
->tx_end
- dws
->len
) {
188 if (dws
->n_bytes
== 1)
189 txw
= *(u8
*)(dws
->tx
);
191 txw
= *(u16
*)(dws
->tx
);
193 dw_write_io_reg(dws
, DW_SPI_DR
, txw
);
194 dws
->tx
+= dws
->n_bytes
;
198 static void dw_reader(struct dw_spi
*dws
)
200 u32 max
= rx_max(dws
);
204 rxw
= dw_read_io_reg(dws
, DW_SPI_DR
);
205 /* Care rx only if the transfer's original "rx" is not null */
206 if (dws
->rx_end
- dws
->len
) {
207 if (dws
->n_bytes
== 1)
208 *(u8
*)(dws
->rx
) = rxw
;
210 *(u16
*)(dws
->rx
) = rxw
;
212 dws
->rx
+= dws
->n_bytes
;
216 static void int_error_stop(struct dw_spi
*dws
, const char *msg
)
220 dev_err(&dws
->master
->dev
, "%s\n", msg
);
221 dws
->master
->cur_msg
->status
= -EIO
;
222 spi_finalize_current_transfer(dws
->master
);
225 static irqreturn_t
interrupt_transfer(struct dw_spi
*dws
)
227 u16 irq_status
= dw_readl(dws
, DW_SPI_ISR
);
230 if (irq_status
& (SPI_INT_TXOI
| SPI_INT_RXOI
| SPI_INT_RXUI
)) {
231 dw_readl(dws
, DW_SPI_ICR
);
232 int_error_stop(dws
, "interrupt_transfer: fifo overrun/underrun");
237 if (dws
->rx_end
== dws
->rx
) {
238 spi_mask_intr(dws
, SPI_INT_TXEI
);
239 spi_finalize_current_transfer(dws
->master
);
242 if (irq_status
& SPI_INT_TXEI
) {
243 spi_mask_intr(dws
, SPI_INT_TXEI
);
245 /* Enable TX irq always, it will be disabled when RX finished */
246 spi_umask_intr(dws
, SPI_INT_TXEI
);
252 static irqreturn_t
dw_spi_irq(int irq
, void *dev_id
)
254 struct spi_master
*master
= dev_id
;
255 struct dw_spi
*dws
= spi_master_get_devdata(master
);
256 u16 irq_status
= dw_readl(dws
, DW_SPI_ISR
) & 0x3f;
261 if (!master
->cur_msg
) {
262 spi_mask_intr(dws
, SPI_INT_TXEI
);
266 return dws
->transfer_handler(dws
);
269 /* Must be called inside pump_transfers() */
270 static int poll_transfer(struct dw_spi
*dws
)
276 } while (dws
->rx_end
> dws
->rx
);
281 static int dw_spi_transfer_one(struct spi_master
*master
,
282 struct spi_device
*spi
, struct spi_transfer
*transfer
)
284 struct dw_spi
*dws
= spi_master_get_devdata(master
);
285 struct chip_data
*chip
= spi_get_ctldata(spi
);
295 dws
->tx
= (void *)transfer
->tx_buf
;
296 dws
->tx_end
= dws
->tx
+ transfer
->len
;
297 dws
->rx
= transfer
->rx_buf
;
298 dws
->rx_end
= dws
->rx
+ transfer
->len
;
299 dws
->len
= transfer
->len
;
301 spi_enable_chip(dws
, 0);
303 /* Handle per transfer options for bpw and speed */
304 speed
= chip
->speed_hz
;
305 if ((transfer
->speed_hz
!= speed
) || !chip
->clk_div
) {
306 speed
= transfer
->speed_hz
;
308 /* clk_div doesn't support odd number */
309 clk_div
= (dws
->max_freq
/ speed
+ 1) & 0xfffe;
311 chip
->speed_hz
= speed
;
312 chip
->clk_div
= clk_div
;
314 spi_set_clk(dws
, chip
->clk_div
);
316 if (transfer
->bits_per_word
== 8) {
319 } else if (transfer
->bits_per_word
== 16) {
325 /* Default SPI mode is SCPOL = 0, SCPH = 0 */
326 cr0
= (transfer
->bits_per_word
- 1)
327 | (chip
->type
<< SPI_FRF_OFFSET
)
328 | (spi
->mode
<< SPI_MODE_OFFSET
)
329 | (chip
->tmode
<< SPI_TMOD_OFFSET
);
332 * Adjust transfer mode if necessary. Requires platform dependent
333 * chipselect mechanism.
335 if (chip
->cs_control
) {
336 if (dws
->rx
&& dws
->tx
)
337 chip
->tmode
= SPI_TMOD_TR
;
339 chip
->tmode
= SPI_TMOD_RO
;
341 chip
->tmode
= SPI_TMOD_TO
;
343 cr0
&= ~SPI_TMOD_MASK
;
344 cr0
|= (chip
->tmode
<< SPI_TMOD_OFFSET
);
347 dw_writel(dws
, DW_SPI_CTRL0
, cr0
);
349 /* Check if current transfer is a DMA transaction */
350 if (master
->can_dma
&& master
->can_dma(master
, spi
, transfer
))
351 dws
->dma_mapped
= master
->cur_msg_mapped
;
353 /* For poll mode just disable all interrupts */
354 spi_mask_intr(dws
, 0xff);
358 * we only need set the TXEI IRQ, as TX/RX always happen syncronizely
360 if (dws
->dma_mapped
) {
361 ret
= dws
->dma_ops
->dma_setup(dws
, transfer
);
363 spi_enable_chip(dws
, 1);
366 } else if (!chip
->poll_mode
) {
367 txlevel
= min_t(u16
, dws
->fifo_len
/ 2, dws
->len
/ dws
->n_bytes
);
368 dw_writel(dws
, DW_SPI_TXFLTR
, txlevel
);
370 /* Set the interrupt mask */
371 imask
|= SPI_INT_TXEI
| SPI_INT_TXOI
|
372 SPI_INT_RXUI
| SPI_INT_RXOI
;
373 spi_umask_intr(dws
, imask
);
375 dws
->transfer_handler
= interrupt_transfer
;
378 spi_enable_chip(dws
, 1);
380 if (dws
->dma_mapped
) {
381 ret
= dws
->dma_ops
->dma_transfer(dws
, transfer
);
387 return poll_transfer(dws
);
392 static void dw_spi_handle_err(struct spi_master
*master
,
393 struct spi_message
*msg
)
395 struct dw_spi
*dws
= spi_master_get_devdata(master
);
398 dws
->dma_ops
->dma_stop(dws
);
403 /* This may be called twice for each spi dev */
404 static int dw_spi_setup(struct spi_device
*spi
)
406 struct dw_spi_chip
*chip_info
= NULL
;
407 struct chip_data
*chip
;
410 /* Only alloc on first setup */
411 chip
= spi_get_ctldata(spi
);
413 chip
= kzalloc(sizeof(struct chip_data
), GFP_KERNEL
);
416 spi_set_ctldata(spi
, chip
);
420 * Protocol drivers may change the chip settings, so...
421 * if chip_info exists, use it
423 chip_info
= spi
->controller_data
;
425 /* chip_info doesn't always exist */
427 if (chip_info
->cs_control
)
428 chip
->cs_control
= chip_info
->cs_control
;
430 chip
->poll_mode
= chip_info
->poll_mode
;
431 chip
->type
= chip_info
->type
;
433 chip
->rx_threshold
= 0;
434 chip
->tx_threshold
= 0;
437 chip
->tmode
= 0; /* Tx & Rx */
439 if (gpio_is_valid(spi
->cs_gpio
)) {
440 ret
= gpio_direction_output(spi
->cs_gpio
,
441 !(spi
->mode
& SPI_CS_HIGH
));
449 static void dw_spi_cleanup(struct spi_device
*spi
)
451 struct chip_data
*chip
= spi_get_ctldata(spi
);
454 spi_set_ctldata(spi
, NULL
);
457 /* Restart the controller, disable all interrupts, clean rx fifo */
458 static void spi_hw_init(struct device
*dev
, struct dw_spi
*dws
)
463 * Try to detect the FIFO depth if not set by interface driver,
464 * the depth could be from 2 to 256 from HW spec
466 if (!dws
->fifo_len
) {
469 for (fifo
= 1; fifo
< 256; fifo
++) {
470 dw_writel(dws
, DW_SPI_TXFLTR
, fifo
);
471 if (fifo
!= dw_readl(dws
, DW_SPI_TXFLTR
))
474 dw_writel(dws
, DW_SPI_TXFLTR
, 0);
476 dws
->fifo_len
= (fifo
== 1) ? 0 : fifo
;
477 dev_dbg(dev
, "Detected FIFO size: %u bytes\n", dws
->fifo_len
);
481 int dw_spi_add_host(struct device
*dev
, struct dw_spi
*dws
)
483 struct spi_master
*master
;
488 master
= spi_alloc_master(dev
, 0);
492 dws
->master
= master
;
493 dws
->type
= SSI_MOTO_SPI
;
495 dws
->dma_addr
= (dma_addr_t
)(dws
->paddr
+ 0x60);
496 snprintf(dws
->name
, sizeof(dws
->name
), "dw_spi%d", dws
->bus_num
);
498 ret
= devm_request_irq(dev
, dws
->irq
, dw_spi_irq
, IRQF_SHARED
,
501 dev_err(dev
, "can not get IRQ\n");
502 goto err_free_master
;
505 master
->mode_bits
= SPI_CPOL
| SPI_CPHA
| SPI_LOOP
;
506 master
->bits_per_word_mask
= SPI_BPW_MASK(8) | SPI_BPW_MASK(16);
507 master
->bus_num
= dws
->bus_num
;
508 master
->num_chipselect
= dws
->num_cs
;
509 master
->setup
= dw_spi_setup
;
510 master
->cleanup
= dw_spi_cleanup
;
511 master
->set_cs
= dw_spi_set_cs
;
512 master
->transfer_one
= dw_spi_transfer_one
;
513 master
->handle_err
= dw_spi_handle_err
;
514 master
->max_speed_hz
= dws
->max_freq
;
515 master
->dev
.of_node
= dev
->of_node
;
518 spi_hw_init(dev
, dws
);
520 if (dws
->dma_ops
&& dws
->dma_ops
->dma_init
) {
521 ret
= dws
->dma_ops
->dma_init(dws
);
523 dev_warn(dev
, "DMA init failed\n");
526 master
->can_dma
= dws
->dma_ops
->can_dma
;
530 spi_master_set_devdata(master
, dws
);
531 ret
= devm_spi_register_master(dev
, master
);
533 dev_err(&master
->dev
, "problem registering spi master\n");
537 dw_spi_debugfs_init(dws
);
541 if (dws
->dma_ops
&& dws
->dma_ops
->dma_exit
)
542 dws
->dma_ops
->dma_exit(dws
);
543 spi_enable_chip(dws
, 0);
545 spi_master_put(master
);
548 EXPORT_SYMBOL_GPL(dw_spi_add_host
);
550 void dw_spi_remove_host(struct dw_spi
*dws
)
554 dw_spi_debugfs_remove(dws
);
556 if (dws
->dma_ops
&& dws
->dma_ops
->dma_exit
)
557 dws
->dma_ops
->dma_exit(dws
);
558 spi_enable_chip(dws
, 0);
562 EXPORT_SYMBOL_GPL(dw_spi_remove_host
);
564 int dw_spi_suspend_host(struct dw_spi
*dws
)
568 ret
= spi_master_suspend(dws
->master
);
571 spi_enable_chip(dws
, 0);
575 EXPORT_SYMBOL_GPL(dw_spi_suspend_host
);
577 int dw_spi_resume_host(struct dw_spi
*dws
)
581 spi_hw_init(&dws
->master
->dev
, dws
);
582 ret
= spi_master_resume(dws
->master
);
584 dev_err(&dws
->master
->dev
, "fail to start queue (%d)\n", ret
);
587 EXPORT_SYMBOL_GPL(dw_spi_resume_host
);
589 MODULE_AUTHOR("Feng Tang <feng.tang@intel.com>");
590 MODULE_DESCRIPTION("Driver for DesignWare SPI controller core");
591 MODULE_LICENSE("GPL v2");