2 * SPI bus driver for CSR SiRFprimaII
4 * Copyright (c) 2011 Cambridge Silicon Radio Limited, a CSR plc group company.
6 * Licensed under GPLv2 or later.
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/slab.h>
12 #include <linux/clk.h>
13 #include <linux/interrupt.h>
16 #include <linux/bitops.h>
17 #include <linux/err.h>
18 #include <linux/platform_device.h>
19 #include <linux/of_gpio.h>
20 #include <linux/spi/spi.h>
21 #include <linux/spi/spi_bitbang.h>
23 #define DRIVER_NAME "sirfsoc_spi"
25 #define SIRFSOC_SPI_CTRL 0x0000
26 #define SIRFSOC_SPI_CMD 0x0004
27 #define SIRFSOC_SPI_TX_RX_EN 0x0008
28 #define SIRFSOC_SPI_INT_EN 0x000C
29 #define SIRFSOC_SPI_INT_STATUS 0x0010
30 #define SIRFSOC_SPI_TX_DMA_IO_CTRL 0x0100
31 #define SIRFSOC_SPI_TX_DMA_IO_LEN 0x0104
32 #define SIRFSOC_SPI_TXFIFO_CTRL 0x0108
33 #define SIRFSOC_SPI_TXFIFO_LEVEL_CHK 0x010C
34 #define SIRFSOC_SPI_TXFIFO_OP 0x0110
35 #define SIRFSOC_SPI_TXFIFO_STATUS 0x0114
36 #define SIRFSOC_SPI_TXFIFO_DATA 0x0118
37 #define SIRFSOC_SPI_RX_DMA_IO_CTRL 0x0120
38 #define SIRFSOC_SPI_RX_DMA_IO_LEN 0x0124
39 #define SIRFSOC_SPI_RXFIFO_CTRL 0x0128
40 #define SIRFSOC_SPI_RXFIFO_LEVEL_CHK 0x012C
41 #define SIRFSOC_SPI_RXFIFO_OP 0x0130
42 #define SIRFSOC_SPI_RXFIFO_STATUS 0x0134
43 #define SIRFSOC_SPI_RXFIFO_DATA 0x0138
44 #define SIRFSOC_SPI_DUMMY_DELAY_CTL 0x0144
46 /* SPI CTRL register defines */
47 #define SIRFSOC_SPI_SLV_MODE BIT(16)
48 #define SIRFSOC_SPI_CMD_MODE BIT(17)
49 #define SIRFSOC_SPI_CS_IO_OUT BIT(18)
50 #define SIRFSOC_SPI_CS_IO_MODE BIT(19)
51 #define SIRFSOC_SPI_CLK_IDLE_STAT BIT(20)
52 #define SIRFSOC_SPI_CS_IDLE_STAT BIT(21)
53 #define SIRFSOC_SPI_TRAN_MSB BIT(22)
54 #define SIRFSOC_SPI_DRV_POS_EDGE BIT(23)
55 #define SIRFSOC_SPI_CS_HOLD_TIME BIT(24)
56 #define SIRFSOC_SPI_CLK_SAMPLE_MODE BIT(25)
57 #define SIRFSOC_SPI_TRAN_DAT_FORMAT_8 (0 << 26)
58 #define SIRFSOC_SPI_TRAN_DAT_FORMAT_12 (1 << 26)
59 #define SIRFSOC_SPI_TRAN_DAT_FORMAT_16 (2 << 26)
60 #define SIRFSOC_SPI_TRAN_DAT_FORMAT_32 (3 << 26)
61 #define SIRFSOC_SPI_CMD_BYTE_NUM(x) ((x & 3) << 28)
62 #define SIRFSOC_SPI_ENA_AUTO_CLR BIT(30)
63 #define SIRFSOC_SPI_MUL_DAT_MODE BIT(31)
65 /* Interrupt Enable */
66 #define SIRFSOC_SPI_RX_DONE_INT_EN BIT(0)
67 #define SIRFSOC_SPI_TX_DONE_INT_EN BIT(1)
68 #define SIRFSOC_SPI_RX_OFLOW_INT_EN BIT(2)
69 #define SIRFSOC_SPI_TX_UFLOW_INT_EN BIT(3)
70 #define SIRFSOC_SPI_RX_IO_DMA_INT_EN BIT(4)
71 #define SIRFSOC_SPI_TX_IO_DMA_INT_EN BIT(5)
72 #define SIRFSOC_SPI_RXFIFO_FULL_INT_EN BIT(6)
73 #define SIRFSOC_SPI_TXFIFO_EMPTY_INT_EN BIT(7)
74 #define SIRFSOC_SPI_RXFIFO_THD_INT_EN BIT(8)
75 #define SIRFSOC_SPI_TXFIFO_THD_INT_EN BIT(9)
76 #define SIRFSOC_SPI_FRM_END_INT_EN BIT(10)
78 #define SIRFSOC_SPI_INT_MASK_ALL 0x1FFF
80 /* Interrupt status */
81 #define SIRFSOC_SPI_RX_DONE BIT(0)
82 #define SIRFSOC_SPI_TX_DONE BIT(1)
83 #define SIRFSOC_SPI_RX_OFLOW BIT(2)
84 #define SIRFSOC_SPI_TX_UFLOW BIT(3)
85 #define SIRFSOC_SPI_RX_FIFO_FULL BIT(6)
86 #define SIRFSOC_SPI_TXFIFO_EMPTY BIT(7)
87 #define SIRFSOC_SPI_RXFIFO_THD_REACH BIT(8)
88 #define SIRFSOC_SPI_TXFIFO_THD_REACH BIT(9)
89 #define SIRFSOC_SPI_FRM_END BIT(10)
92 #define SIRFSOC_SPI_RX_EN BIT(0)
93 #define SIRFSOC_SPI_TX_EN BIT(1)
94 #define SIRFSOC_SPI_CMD_TX_EN BIT(2)
96 #define SIRFSOC_SPI_IO_MODE_SEL BIT(0)
97 #define SIRFSOC_SPI_RX_DMA_FLUSH BIT(2)
100 #define SIRFSOC_SPI_FIFO_RESET BIT(0)
101 #define SIRFSOC_SPI_FIFO_START BIT(1)
104 #define SIRFSOC_SPI_FIFO_WIDTH_BYTE (0 << 0)
105 #define SIRFSOC_SPI_FIFO_WIDTH_WORD (1 << 0)
106 #define SIRFSOC_SPI_FIFO_WIDTH_DWORD (2 << 0)
109 #define SIRFSOC_SPI_FIFO_LEVEL_MASK 0xFF
110 #define SIRFSOC_SPI_FIFO_FULL BIT(8)
111 #define SIRFSOC_SPI_FIFO_EMPTY BIT(9)
113 /* 256 bytes rx/tx FIFO */
114 #define SIRFSOC_SPI_FIFO_SIZE 256
115 #define SIRFSOC_SPI_DAT_FRM_LEN_MAX (64 * 1024)
117 #define SIRFSOC_SPI_FIFO_SC(x) ((x) & 0x3F)
118 #define SIRFSOC_SPI_FIFO_LC(x) (((x) & 0x3F) << 10)
119 #define SIRFSOC_SPI_FIFO_HC(x) (((x) & 0x3F) << 20)
120 #define SIRFSOC_SPI_FIFO_THD(x) (((x) & 0xFF) << 2)
123 struct spi_bitbang bitbang;
124 struct completion done;
127 u32 ctrl_freq; /* SPI controller clock speed */
130 /* rx & tx bufs from the spi_transfer */
134 /* place received word into rx buffer */
135 void (*rx_word) (struct sirfsoc_spi *);
136 /* get word from tx buffer for sending */
137 void (*tx_word) (struct sirfsoc_spi *);
139 /* number of words left to be tranmitted/received */
140 unsigned int left_tx_cnt;
141 unsigned int left_rx_cnt;
143 /* tasklet to push tx msg into FIFO */
144 struct tasklet_struct tasklet_tx;
149 static void spi_sirfsoc_rx_word_u8(struct sirfsoc_spi *sspi)
154 data = readl(sspi->base + SIRFSOC_SPI_RXFIFO_DATA);
164 static void spi_sirfsoc_tx_word_u8(struct sirfsoc_spi *sspi)
167 const u8 *tx = sspi->tx;
174 writel(data, sspi->base + SIRFSOC_SPI_TXFIFO_DATA);
178 static void spi_sirfsoc_rx_word_u16(struct sirfsoc_spi *sspi)
183 data = readl(sspi->base + SIRFSOC_SPI_RXFIFO_DATA);
193 static void spi_sirfsoc_tx_word_u16(struct sirfsoc_spi *sspi)
196 const u16 *tx = sspi->tx;
203 writel(data, sspi->base + SIRFSOC_SPI_TXFIFO_DATA);
207 static void spi_sirfsoc_rx_word_u32(struct sirfsoc_spi *sspi)
212 data = readl(sspi->base + SIRFSOC_SPI_RXFIFO_DATA);
223 static void spi_sirfsoc_tx_word_u32(struct sirfsoc_spi *sspi)
226 const u32 *tx = sspi->tx;
233 writel(data, sspi->base + SIRFSOC_SPI_TXFIFO_DATA);
237 static void spi_sirfsoc_tasklet_tx(unsigned long arg)
239 struct sirfsoc_spi *sspi = (struct sirfsoc_spi *)arg;
241 /* Fill Tx FIFO while there are left words to be transmitted */
242 while (!((readl(sspi->base + SIRFSOC_SPI_TXFIFO_STATUS) &
243 SIRFSOC_SPI_FIFO_FULL)) &&
248 static irqreturn_t spi_sirfsoc_irq(int irq, void *dev_id)
250 struct sirfsoc_spi *sspi = dev_id;
251 u32 spi_stat = readl(sspi->base + SIRFSOC_SPI_INT_STATUS);
253 writel(spi_stat, sspi->base + SIRFSOC_SPI_INT_STATUS);
255 /* Error Conditions */
256 if (spi_stat & SIRFSOC_SPI_RX_OFLOW ||
257 spi_stat & SIRFSOC_SPI_TX_UFLOW) {
258 complete(&sspi->done);
259 writel(0x0, sspi->base + SIRFSOC_SPI_INT_EN);
262 if (spi_stat & SIRFSOC_SPI_FRM_END) {
263 while (!((readl(sspi->base + SIRFSOC_SPI_RXFIFO_STATUS)
264 & SIRFSOC_SPI_FIFO_EMPTY)) &&
268 /* Received all words */
269 if ((sspi->left_rx_cnt == 0) && (sspi->left_tx_cnt == 0)) {
270 complete(&sspi->done);
271 writel(0x0, sspi->base + SIRFSOC_SPI_INT_EN);
275 if (spi_stat & SIRFSOC_SPI_RXFIFO_THD_REACH ||
276 spi_stat & SIRFSOC_SPI_TXFIFO_THD_REACH ||
277 spi_stat & SIRFSOC_SPI_RX_FIFO_FULL ||
278 spi_stat & SIRFSOC_SPI_TXFIFO_EMPTY)
279 tasklet_schedule(&sspi->tasklet_tx);
284 static int spi_sirfsoc_transfer(struct spi_device *spi, struct spi_transfer *t)
286 struct sirfsoc_spi *sspi;
287 int timeout = t->len * 10;
288 sspi = spi_master_get_devdata(spi->master);
290 sspi->tx = t->tx_buf;
291 sspi->rx = t->rx_buf;
292 sspi->left_tx_cnt = sspi->left_rx_cnt = t->len;
293 INIT_COMPLETION(sspi->done);
295 writel(SIRFSOC_SPI_INT_MASK_ALL, sspi->base + SIRFSOC_SPI_INT_STATUS);
298 writel(readl(sspi->base + SIRFSOC_SPI_CTRL) |
299 SIRFSOC_SPI_ENA_AUTO_CLR,
300 sspi->base + SIRFSOC_SPI_CTRL);
301 writel(0, sspi->base + SIRFSOC_SPI_TX_DMA_IO_LEN);
302 writel(0, sspi->base + SIRFSOC_SPI_RX_DMA_IO_LEN);
303 } else if ((t->len > 1) && (t->len < SIRFSOC_SPI_DAT_FRM_LEN_MAX)) {
304 writel(readl(sspi->base + SIRFSOC_SPI_CTRL) |
305 SIRFSOC_SPI_MUL_DAT_MODE |
306 SIRFSOC_SPI_ENA_AUTO_CLR,
307 sspi->base + SIRFSOC_SPI_CTRL);
308 writel(t->len - 1, sspi->base + SIRFSOC_SPI_TX_DMA_IO_LEN);
309 writel(t->len - 1, sspi->base + SIRFSOC_SPI_RX_DMA_IO_LEN);
311 writel(readl(sspi->base + SIRFSOC_SPI_CTRL),
312 sspi->base + SIRFSOC_SPI_CTRL);
313 writel(0, sspi->base + SIRFSOC_SPI_TX_DMA_IO_LEN);
314 writel(0, sspi->base + SIRFSOC_SPI_RX_DMA_IO_LEN);
317 writel(SIRFSOC_SPI_FIFO_RESET, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
318 writel(SIRFSOC_SPI_FIFO_RESET, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
319 writel(SIRFSOC_SPI_FIFO_START, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
320 writel(SIRFSOC_SPI_FIFO_START, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
322 /* Send the first word to trigger the whole tx/rx process */
325 writel(SIRFSOC_SPI_RX_OFLOW_INT_EN | SIRFSOC_SPI_TX_UFLOW_INT_EN |
326 SIRFSOC_SPI_RXFIFO_THD_INT_EN | SIRFSOC_SPI_TXFIFO_THD_INT_EN |
327 SIRFSOC_SPI_FRM_END_INT_EN | SIRFSOC_SPI_RXFIFO_FULL_INT_EN |
328 SIRFSOC_SPI_TXFIFO_EMPTY_INT_EN, sspi->base + SIRFSOC_SPI_INT_EN);
329 writel(SIRFSOC_SPI_RX_EN | SIRFSOC_SPI_TX_EN, sspi->base + SIRFSOC_SPI_TX_RX_EN);
331 if (wait_for_completion_timeout(&sspi->done, timeout) == 0)
332 dev_err(&spi->dev, "transfer timeout\n");
334 /* TX, RX FIFO stop */
335 writel(0, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
336 writel(0, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
337 writel(0, sspi->base + SIRFSOC_SPI_TX_RX_EN);
338 writel(0, sspi->base + SIRFSOC_SPI_INT_EN);
340 return t->len - sspi->left_rx_cnt;
343 static void spi_sirfsoc_chipselect(struct spi_device *spi, int value)
345 struct sirfsoc_spi *sspi = spi_master_get_devdata(spi->master);
347 if (sspi->chipselect[spi->chip_select] == 0) {
348 u32 regval = readl(sspi->base + SIRFSOC_SPI_CTRL);
349 regval |= SIRFSOC_SPI_CS_IO_OUT;
351 case BITBANG_CS_ACTIVE:
352 if (spi->mode & SPI_CS_HIGH)
353 regval |= SIRFSOC_SPI_CS_IO_OUT;
355 regval &= ~SIRFSOC_SPI_CS_IO_OUT;
357 case BITBANG_CS_INACTIVE:
358 if (spi->mode & SPI_CS_HIGH)
359 regval &= ~SIRFSOC_SPI_CS_IO_OUT;
361 regval |= SIRFSOC_SPI_CS_IO_OUT;
364 writel(regval, sspi->base + SIRFSOC_SPI_CTRL);
366 int gpio = sspi->chipselect[spi->chip_select];
367 gpio_direction_output(gpio, spi->mode & SPI_CS_HIGH ? 0 : 1);
372 spi_sirfsoc_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
374 struct sirfsoc_spi *sspi;
375 u8 bits_per_word = 0;
378 u32 txfifo_ctrl, rxfifo_ctrl;
379 u32 fifo_size = SIRFSOC_SPI_FIFO_SIZE / 4;
381 sspi = spi_master_get_devdata(spi->master);
383 bits_per_word = (t) ? t->bits_per_word : spi->bits_per_word;
384 hz = t && t->speed_hz ? t->speed_hz : spi->max_speed_hz;
386 /* Enable IO mode for RX, TX */
387 writel(SIRFSOC_SPI_IO_MODE_SEL, sspi->base + SIRFSOC_SPI_TX_DMA_IO_CTRL);
388 writel(SIRFSOC_SPI_IO_MODE_SEL, sspi->base + SIRFSOC_SPI_RX_DMA_IO_CTRL);
389 regval = (sspi->ctrl_freq / (2 * hz)) - 1;
391 if (regval > 0xFFFF || regval < 0) {
392 dev_err(&spi->dev, "Speed %d not supported\n", hz);
396 switch (bits_per_word) {
398 regval |= SIRFSOC_SPI_TRAN_DAT_FORMAT_8;
399 sspi->rx_word = spi_sirfsoc_rx_word_u8;
400 sspi->tx_word = spi_sirfsoc_tx_word_u8;
401 txfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
402 SIRFSOC_SPI_FIFO_WIDTH_BYTE;
403 rxfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
404 SIRFSOC_SPI_FIFO_WIDTH_BYTE;
408 regval |= (bits_per_word == 12) ? SIRFSOC_SPI_TRAN_DAT_FORMAT_12 :
409 SIRFSOC_SPI_TRAN_DAT_FORMAT_16;
410 sspi->rx_word = spi_sirfsoc_rx_word_u16;
411 sspi->tx_word = spi_sirfsoc_tx_word_u16;
412 txfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
413 SIRFSOC_SPI_FIFO_WIDTH_WORD;
414 rxfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
415 SIRFSOC_SPI_FIFO_WIDTH_WORD;
418 regval |= SIRFSOC_SPI_TRAN_DAT_FORMAT_32;
419 sspi->rx_word = spi_sirfsoc_rx_word_u32;
420 sspi->tx_word = spi_sirfsoc_tx_word_u32;
421 txfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
422 SIRFSOC_SPI_FIFO_WIDTH_DWORD;
423 rxfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
424 SIRFSOC_SPI_FIFO_WIDTH_DWORD;
427 dev_err(&spi->dev, "Bits per word %d not supported\n",
432 if (!(spi->mode & SPI_CS_HIGH))
433 regval |= SIRFSOC_SPI_CS_IDLE_STAT;
434 if (!(spi->mode & SPI_LSB_FIRST))
435 regval |= SIRFSOC_SPI_TRAN_MSB;
436 if (spi->mode & SPI_CPOL)
437 regval |= SIRFSOC_SPI_CLK_IDLE_STAT;
440 * Data should be driven at least 1/2 cycle before the fetch edge to make
441 * sure that data gets stable at the fetch edge.
443 if (((spi->mode & SPI_CPOL) && (spi->mode & SPI_CPHA)) ||
444 (!(spi->mode & SPI_CPOL) && !(spi->mode & SPI_CPHA)))
445 regval &= ~SIRFSOC_SPI_DRV_POS_EDGE;
447 regval |= SIRFSOC_SPI_DRV_POS_EDGE;
449 writel(SIRFSOC_SPI_FIFO_SC(fifo_size - 2) |
450 SIRFSOC_SPI_FIFO_LC(fifo_size / 2) |
451 SIRFSOC_SPI_FIFO_HC(2),
452 sspi->base + SIRFSOC_SPI_TXFIFO_LEVEL_CHK);
453 writel(SIRFSOC_SPI_FIFO_SC(2) |
454 SIRFSOC_SPI_FIFO_LC(fifo_size / 2) |
455 SIRFSOC_SPI_FIFO_HC(fifo_size - 2),
456 sspi->base + SIRFSOC_SPI_RXFIFO_LEVEL_CHK);
457 writel(txfifo_ctrl, sspi->base + SIRFSOC_SPI_TXFIFO_CTRL);
458 writel(rxfifo_ctrl, sspi->base + SIRFSOC_SPI_RXFIFO_CTRL);
460 writel(regval, sspi->base + SIRFSOC_SPI_CTRL);
464 static int spi_sirfsoc_setup(struct spi_device *spi)
466 struct sirfsoc_spi *sspi;
468 if (!spi->max_speed_hz)
471 sspi = spi_master_get_devdata(spi->master);
473 if (!spi->bits_per_word)
474 spi->bits_per_word = 8;
476 return spi_sirfsoc_setup_transfer(spi, NULL);
479 static int spi_sirfsoc_probe(struct platform_device *pdev)
481 struct sirfsoc_spi *sspi;
482 struct spi_master *master;
483 struct resource *mem_res;
484 int num_cs, cs_gpio, irq;
488 ret = of_property_read_u32(pdev->dev.of_node,
489 "sirf,spi-num-chipselects", &num_cs);
491 dev_err(&pdev->dev, "Unable to get chip select number\n");
495 master = spi_alloc_master(&pdev->dev, sizeof(*sspi) + sizeof(int) * num_cs);
497 dev_err(&pdev->dev, "Unable to allocate SPI master\n");
500 platform_set_drvdata(pdev, master);
501 sspi = spi_master_get_devdata(master);
503 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
505 dev_err(&pdev->dev, "Unable to get IO resource\n");
509 master->num_chipselect = num_cs;
511 for (i = 0; i < master->num_chipselect; i++) {
512 cs_gpio = of_get_named_gpio(pdev->dev.of_node, "cs-gpios", i);
514 dev_err(&pdev->dev, "can't get cs gpio from DT\n");
519 sspi->chipselect[i] = cs_gpio;
521 continue; /* use cs from spi controller */
523 ret = gpio_request(cs_gpio, DRIVER_NAME);
527 if (sspi->chipselect[i] > 0)
528 gpio_free(sspi->chipselect[i]);
530 dev_err(&pdev->dev, "fail to request cs gpios\n");
535 sspi->base = devm_ioremap_resource(&pdev->dev, mem_res);
536 if (IS_ERR(sspi->base)) {
537 ret = PTR_ERR(sspi->base);
541 irq = platform_get_irq(pdev, 0);
546 ret = devm_request_irq(&pdev->dev, irq, spi_sirfsoc_irq, 0,
551 sspi->bitbang.master = spi_master_get(master);
552 sspi->bitbang.chipselect = spi_sirfsoc_chipselect;
553 sspi->bitbang.setup_transfer = spi_sirfsoc_setup_transfer;
554 sspi->bitbang.txrx_bufs = spi_sirfsoc_transfer;
555 sspi->bitbang.master->setup = spi_sirfsoc_setup;
556 master->bus_num = pdev->id;
557 sspi->bitbang.master->dev.of_node = pdev->dev.of_node;
559 sspi->clk = clk_get(&pdev->dev, NULL);
560 if (IS_ERR(sspi->clk)) {
564 clk_prepare_enable(sspi->clk);
565 sspi->ctrl_freq = clk_get_rate(sspi->clk);
567 init_completion(&sspi->done);
569 tasklet_init(&sspi->tasklet_tx, spi_sirfsoc_tasklet_tx,
570 (unsigned long)sspi);
572 writel(SIRFSOC_SPI_FIFO_RESET, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
573 writel(SIRFSOC_SPI_FIFO_RESET, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
574 writel(SIRFSOC_SPI_FIFO_START, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
575 writel(SIRFSOC_SPI_FIFO_START, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
576 /* We are not using dummy delay between command and data */
577 writel(0, sspi->base + SIRFSOC_SPI_DUMMY_DELAY_CTL);
579 ret = spi_bitbang_start(&sspi->bitbang);
583 dev_info(&pdev->dev, "registerred, bus number = %d\n", master->bus_num);
588 clk_disable_unprepare(sspi->clk);
591 spi_master_put(master);
596 static int spi_sirfsoc_remove(struct platform_device *pdev)
598 struct spi_master *master;
599 struct sirfsoc_spi *sspi;
602 master = platform_get_drvdata(pdev);
603 sspi = spi_master_get_devdata(master);
605 spi_bitbang_stop(&sspi->bitbang);
606 for (i = 0; i < master->num_chipselect; i++) {
607 if (sspi->chipselect[i] > 0)
608 gpio_free(sspi->chipselect[i]);
610 clk_disable_unprepare(sspi->clk);
612 spi_master_put(master);
617 static int spi_sirfsoc_suspend(struct device *dev)
619 struct platform_device *pdev = to_platform_device(dev);
620 struct spi_master *master = platform_get_drvdata(pdev);
621 struct sirfsoc_spi *sspi = spi_master_get_devdata(master);
623 clk_disable(sspi->clk);
627 static int spi_sirfsoc_resume(struct device *dev)
629 struct platform_device *pdev = to_platform_device(dev);
630 struct spi_master *master = platform_get_drvdata(pdev);
631 struct sirfsoc_spi *sspi = spi_master_get_devdata(master);
633 clk_enable(sspi->clk);
634 writel(SIRFSOC_SPI_FIFO_RESET, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
635 writel(SIRFSOC_SPI_FIFO_RESET, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
636 writel(SIRFSOC_SPI_FIFO_START, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
637 writel(SIRFSOC_SPI_FIFO_START, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
642 static const struct dev_pm_ops spi_sirfsoc_pm_ops = {
643 .suspend = spi_sirfsoc_suspend,
644 .resume = spi_sirfsoc_resume,
648 static const struct of_device_id spi_sirfsoc_of_match[] = {
649 { .compatible = "sirf,prima2-spi", },
650 { .compatible = "sirf,marco-spi", },
653 MODULE_DEVICE_TABLE(of, spi_sirfsoc_of_match);
655 static struct platform_driver spi_sirfsoc_driver = {
658 .owner = THIS_MODULE,
660 .pm = &spi_sirfsoc_pm_ops,
662 .of_match_table = spi_sirfsoc_of_match,
664 .probe = spi_sirfsoc_probe,
665 .remove = spi_sirfsoc_remove,
667 module_platform_driver(spi_sirfsoc_driver);
669 MODULE_DESCRIPTION("SiRF SoC SPI master driver");
670 MODULE_AUTHOR("Zhiwu Song <Zhiwu.Song@csr.com>, "
671 "Barry Song <Baohua.Song@csr.com>");
672 MODULE_LICENSE("GPL v2");