1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/clk.h>
15#include <linux/completion.h>
16#include <linux/delay.h>
17#include <linux/dma-mapping.h>
18#include <linux/dmaengine.h>
19#include <linux/err.h>
20#include <linux/interrupt.h>
21#include <linux/io.h>
22#include <linux/kernel.h>
23#include <linux/module.h>
24#include <linux/of.h>
25#include <linux/of_address.h>
26#include <linux/of_device.h>
27#include <linux/of_gpio.h>
28#include <linux/of_irq.h>
29#include <linux/spi/spi.h>
30
31
32#define BCM2835_SPI_CS 0x00
33#define BCM2835_SPI_FIFO 0x04
34#define BCM2835_SPI_CLK 0x08
35#define BCM2835_SPI_DLEN 0x0c
36#define BCM2835_SPI_LTOH 0x10
37#define BCM2835_SPI_DC 0x14
38
39
40#define BCM2835_SPI_CS_LEN_LONG 0x02000000
41#define BCM2835_SPI_CS_DMA_LEN 0x01000000
42#define BCM2835_SPI_CS_CSPOL2 0x00800000
43#define BCM2835_SPI_CS_CSPOL1 0x00400000
44#define BCM2835_SPI_CS_CSPOL0 0x00200000
45#define BCM2835_SPI_CS_RXF 0x00100000
46#define BCM2835_SPI_CS_RXR 0x00080000
47#define BCM2835_SPI_CS_TXD 0x00040000
48#define BCM2835_SPI_CS_RXD 0x00020000
49#define BCM2835_SPI_CS_DONE 0x00010000
50#define BCM2835_SPI_CS_LEN 0x00002000
51#define BCM2835_SPI_CS_REN 0x00001000
52#define BCM2835_SPI_CS_ADCS 0x00000800
53#define BCM2835_SPI_CS_INTR 0x00000400
54#define BCM2835_SPI_CS_INTD 0x00000200
55#define BCM2835_SPI_CS_DMAEN 0x00000100
56#define BCM2835_SPI_CS_TA 0x00000080
57#define BCM2835_SPI_CS_CSPOL 0x00000040
58#define BCM2835_SPI_CS_CLEAR_RX 0x00000020
59#define BCM2835_SPI_CS_CLEAR_TX 0x00000010
60#define BCM2835_SPI_CS_CPOL 0x00000008
61#define BCM2835_SPI_CS_CPHA 0x00000004
62#define BCM2835_SPI_CS_CS_10 0x00000002
63#define BCM2835_SPI_CS_CS_01 0x00000001
64
65#define BCM2835_SPI_FIFO_SIZE 64
66#define BCM2835_SPI_FIFO_SIZE_3_4 48
67#define BCM2835_SPI_POLLING_LIMIT_US 30
68#define BCM2835_SPI_POLLING_JIFFIES 2
69#define BCM2835_SPI_DMA_MIN_LENGTH 96
70#define BCM2835_SPI_MODE_BITS (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH \
71 | SPI_NO_CS | SPI_3WIRE)
72
73#define DRV_NAME "spi-bcm2835"
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92struct bcm2835_spi {
93 void __iomem *regs;
94 struct clk *clk;
95 int irq;
96 struct spi_transfer *tfr;
97 const u8 *tx_buf;
98 u8 *rx_buf;
99 int tx_len;
100 int rx_len;
101 int tx_prologue;
102 int rx_prologue;
103 unsigned int tx_spillover;
104 unsigned int dma_pending;
105};
106
107static inline u32 bcm2835_rd(struct bcm2835_spi *bs, unsigned reg)
108{
109 return readl(bs->regs + reg);
110}
111
112static inline void bcm2835_wr(struct bcm2835_spi *bs, unsigned reg, u32 val)
113{
114 writel(val, bs->regs + reg);
115}
116
117static inline void bcm2835_rd_fifo(struct bcm2835_spi *bs)
118{
119 u8 byte;
120
121 while ((bs->rx_len) &&
122 (bcm2835_rd(bs, BCM2835_SPI_CS) & BCM2835_SPI_CS_RXD)) {
123 byte = bcm2835_rd(bs, BCM2835_SPI_FIFO);
124 if (bs->rx_buf)
125 *bs->rx_buf++ = byte;
126 bs->rx_len--;
127 }
128}
129
130static inline void bcm2835_wr_fifo(struct bcm2835_spi *bs)
131{
132 u8 byte;
133
134 while ((bs->tx_len) &&
135 (bcm2835_rd(bs, BCM2835_SPI_CS) & BCM2835_SPI_CS_TXD)) {
136 byte = bs->tx_buf ? *bs->tx_buf++ : 0;
137 bcm2835_wr(bs, BCM2835_SPI_FIFO, byte);
138 bs->tx_len--;
139 }
140}
141
142
143
144
145
146
147
148
149
150
151
152static inline void bcm2835_rd_fifo_count(struct bcm2835_spi *bs, int count)
153{
154 u32 val;
155 int len;
156
157 bs->rx_len -= count;
158
159 while (count > 0) {
160 val = bcm2835_rd(bs, BCM2835_SPI_FIFO);
161 len = min(count, 4);
162 memcpy(bs->rx_buf, &val, len);
163 bs->rx_buf += len;
164 count -= 4;
165 }
166}
167
168
169
170
171
172
173
174
175
176
177
178static inline void bcm2835_wr_fifo_count(struct bcm2835_spi *bs, int count)
179{
180 u32 val;
181 int len;
182
183 bs->tx_len -= count;
184
185 while (count > 0) {
186 if (bs->tx_buf) {
187 len = min(count, 4);
188 memcpy(&val, bs->tx_buf, len);
189 bs->tx_buf += len;
190 } else {
191 val = 0;
192 }
193 bcm2835_wr(bs, BCM2835_SPI_FIFO, val);
194 count -= 4;
195 }
196}
197
198
199
200
201
202
203
204
205
206static inline void bcm2835_wait_tx_fifo_empty(struct bcm2835_spi *bs)
207{
208 while (!(bcm2835_rd(bs, BCM2835_SPI_CS) & BCM2835_SPI_CS_DONE))
209 cpu_relax();
210}
211
212
213
214
215
216
217static inline void bcm2835_rd_fifo_blind(struct bcm2835_spi *bs, int count)
218{
219 u8 val;
220
221 count = min(count, bs->rx_len);
222 bs->rx_len -= count;
223
224 while (count) {
225 val = bcm2835_rd(bs, BCM2835_SPI_FIFO);
226 if (bs->rx_buf)
227 *bs->rx_buf++ = val;
228 count--;
229 }
230}
231
232
233
234
235
236
237static inline void bcm2835_wr_fifo_blind(struct bcm2835_spi *bs, int count)
238{
239 u8 val;
240
241 count = min(count, bs->tx_len);
242 bs->tx_len -= count;
243
244 while (count) {
245 val = bs->tx_buf ? *bs->tx_buf++ : 0;
246 bcm2835_wr(bs, BCM2835_SPI_FIFO, val);
247 count--;
248 }
249}
250
251static void bcm2835_spi_reset_hw(struct spi_master *master)
252{
253 struct bcm2835_spi *bs = spi_master_get_devdata(master);
254 u32 cs = bcm2835_rd(bs, BCM2835_SPI_CS);
255
256
257 cs &= ~(BCM2835_SPI_CS_INTR |
258 BCM2835_SPI_CS_INTD |
259 BCM2835_SPI_CS_DMAEN |
260 BCM2835_SPI_CS_TA);
261
262 cs |= BCM2835_SPI_CS_CLEAR_RX | BCM2835_SPI_CS_CLEAR_TX;
263
264
265 bcm2835_wr(bs, BCM2835_SPI_CS, cs);
266
267 bcm2835_wr(bs, BCM2835_SPI_DLEN, 0);
268}
269
270static irqreturn_t bcm2835_spi_interrupt(int irq, void *dev_id)
271{
272 struct spi_master *master = dev_id;
273 struct bcm2835_spi *bs = spi_master_get_devdata(master);
274 u32 cs = bcm2835_rd(bs, BCM2835_SPI_CS);
275
276
277
278
279
280 if (cs & BCM2835_SPI_CS_RXF)
281 bcm2835_rd_fifo_blind(bs, BCM2835_SPI_FIFO_SIZE);
282 else if (cs & BCM2835_SPI_CS_RXR)
283 bcm2835_rd_fifo_blind(bs, BCM2835_SPI_FIFO_SIZE_3_4);
284
285 if (bs->tx_len && cs & BCM2835_SPI_CS_DONE)
286 bcm2835_wr_fifo_blind(bs, BCM2835_SPI_FIFO_SIZE);
287
288
289 bcm2835_rd_fifo(bs);
290
291 bcm2835_wr_fifo(bs);
292
293 if (!bs->rx_len) {
294
295 bcm2835_spi_reset_hw(master);
296
297 complete(&master->xfer_completion);
298 }
299
300 return IRQ_HANDLED;
301}
302
303static int bcm2835_spi_transfer_one_irq(struct spi_master *master,
304 struct spi_device *spi,
305 struct spi_transfer *tfr,
306 u32 cs, bool fifo_empty)
307{
308 struct bcm2835_spi *bs = spi_master_get_devdata(master);
309
310
311
312
313
314 bcm2835_wr(bs, BCM2835_SPI_CS, cs | BCM2835_SPI_CS_TA);
315
316
317 if (fifo_empty)
318 bcm2835_wr_fifo_blind(bs, BCM2835_SPI_FIFO_SIZE);
319 bcm2835_wr_fifo(bs);
320
321
322 cs |= BCM2835_SPI_CS_INTR | BCM2835_SPI_CS_INTD | BCM2835_SPI_CS_TA;
323 bcm2835_wr(bs, BCM2835_SPI_CS, cs);
324
325
326 return 1;
327}
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375static void bcm2835_spi_transfer_prologue(struct spi_master *master,
376 struct spi_transfer *tfr,
377 struct bcm2835_spi *bs,
378 u32 cs)
379{
380 int tx_remaining;
381
382 bs->tfr = tfr;
383 bs->tx_prologue = 0;
384 bs->rx_prologue = 0;
385 bs->tx_spillover = false;
386
387 if (!sg_is_last(&tfr->tx_sg.sgl[0]))
388 bs->tx_prologue = sg_dma_len(&tfr->tx_sg.sgl[0]) & 3;
389
390 if (!sg_is_last(&tfr->rx_sg.sgl[0])) {
391 bs->rx_prologue = sg_dma_len(&tfr->rx_sg.sgl[0]) & 3;
392
393 if (bs->rx_prologue > bs->tx_prologue) {
394 if (sg_is_last(&tfr->tx_sg.sgl[0])) {
395 bs->tx_prologue = bs->rx_prologue;
396 } else {
397 bs->tx_prologue += 4;
398 bs->tx_spillover =
399 !(sg_dma_len(&tfr->tx_sg.sgl[0]) & ~3);
400 }
401 }
402 }
403
404
405 if (!bs->tx_prologue)
406 return;
407
408
409 if (bs->rx_prologue) {
410 bcm2835_wr(bs, BCM2835_SPI_DLEN, bs->rx_prologue);
411 bcm2835_wr(bs, BCM2835_SPI_CS, cs | BCM2835_SPI_CS_TA
412 | BCM2835_SPI_CS_DMAEN);
413 bcm2835_wr_fifo_count(bs, bs->rx_prologue);
414 bcm2835_wait_tx_fifo_empty(bs);
415 bcm2835_rd_fifo_count(bs, bs->rx_prologue);
416 bcm2835_spi_reset_hw(master);
417
418 dma_sync_single_for_device(master->dma_rx->device->dev,
419 sg_dma_address(&tfr->rx_sg.sgl[0]),
420 bs->rx_prologue, DMA_FROM_DEVICE);
421
422 sg_dma_address(&tfr->rx_sg.sgl[0]) += bs->rx_prologue;
423 sg_dma_len(&tfr->rx_sg.sgl[0]) -= bs->rx_prologue;
424 }
425
426
427
428
429
430 tx_remaining = bs->tx_prologue - bs->rx_prologue;
431 if (tx_remaining) {
432 bcm2835_wr(bs, BCM2835_SPI_DLEN, tx_remaining);
433 bcm2835_wr(bs, BCM2835_SPI_CS, cs | BCM2835_SPI_CS_TA
434 | BCM2835_SPI_CS_DMAEN);
435 bcm2835_wr_fifo_count(bs, tx_remaining);
436 bcm2835_wait_tx_fifo_empty(bs);
437 bcm2835_wr(bs, BCM2835_SPI_CS, cs | BCM2835_SPI_CS_CLEAR_TX);
438 }
439
440 if (likely(!bs->tx_spillover)) {
441 sg_dma_address(&tfr->tx_sg.sgl[0]) += bs->tx_prologue;
442 sg_dma_len(&tfr->tx_sg.sgl[0]) -= bs->tx_prologue;
443 } else {
444 sg_dma_len(&tfr->tx_sg.sgl[0]) = 0;
445 sg_dma_address(&tfr->tx_sg.sgl[1]) += 4;
446 sg_dma_len(&tfr->tx_sg.sgl[1]) -= 4;
447 }
448}
449
450
451
452
453
454
455
456
457
458static void bcm2835_spi_undo_prologue(struct bcm2835_spi *bs)
459{
460 struct spi_transfer *tfr = bs->tfr;
461
462 if (!bs->tx_prologue)
463 return;
464
465 if (bs->rx_prologue) {
466 sg_dma_address(&tfr->rx_sg.sgl[0]) -= bs->rx_prologue;
467 sg_dma_len(&tfr->rx_sg.sgl[0]) += bs->rx_prologue;
468 }
469
470 if (likely(!bs->tx_spillover)) {
471 sg_dma_address(&tfr->tx_sg.sgl[0]) -= bs->tx_prologue;
472 sg_dma_len(&tfr->tx_sg.sgl[0]) += bs->tx_prologue;
473 } else {
474 sg_dma_len(&tfr->tx_sg.sgl[0]) = bs->tx_prologue - 4;
475 sg_dma_address(&tfr->tx_sg.sgl[1]) -= 4;
476 sg_dma_len(&tfr->tx_sg.sgl[1]) += 4;
477 }
478}
479
480static void bcm2835_spi_dma_done(void *data)
481{
482 struct spi_master *master = data;
483 struct bcm2835_spi *bs = spi_master_get_devdata(master);
484
485
486 bcm2835_spi_reset_hw(master);
487
488
489
490
491
492
493 if (cmpxchg(&bs->dma_pending, true, false)) {
494 dmaengine_terminate_async(master->dma_tx);
495 bcm2835_spi_undo_prologue(bs);
496 }
497
498 ;
499 complete(&master->xfer_completion);
500}
501
502static int bcm2835_spi_prepare_sg(struct spi_master *master,
503 struct spi_transfer *tfr,
504 bool is_tx)
505{
506 struct dma_chan *chan;
507 struct scatterlist *sgl;
508 unsigned int nents;
509 enum dma_transfer_direction dir;
510 unsigned long flags;
511
512 struct dma_async_tx_descriptor *desc;
513 dma_cookie_t cookie;
514
515 if (is_tx) {
516 dir = DMA_MEM_TO_DEV;
517 chan = master->dma_tx;
518 nents = tfr->tx_sg.nents;
519 sgl = tfr->tx_sg.sgl;
520 flags = 0 ;
521
522 } else {
523 dir = DMA_DEV_TO_MEM;
524 chan = master->dma_rx;
525 nents = tfr->rx_sg.nents;
526 sgl = tfr->rx_sg.sgl;
527 flags = DMA_PREP_INTERRUPT;
528 }
529
530 desc = dmaengine_prep_slave_sg(chan, sgl, nents, dir, flags);
531 if (!desc)
532 return -EINVAL;
533
534
535 if (!is_tx) {
536 desc->callback = bcm2835_spi_dma_done;
537 desc->callback_param = master;
538 }
539
540
541 cookie = dmaengine_submit(desc);
542
543 return dma_submit_error(cookie);
544}
545
546static int bcm2835_spi_transfer_one_dma(struct spi_master *master,
547 struct spi_device *spi,
548 struct spi_transfer *tfr,
549 u32 cs)
550{
551 struct bcm2835_spi *bs = spi_master_get_devdata(master);
552 int ret;
553
554
555
556
557
558 bcm2835_spi_transfer_prologue(master, tfr, bs, cs);
559
560
561 ret = bcm2835_spi_prepare_sg(master, tfr, true);
562 if (ret)
563 goto err_reset_hw;
564
565
566 dma_async_issue_pending(master->dma_tx);
567
568
569 bs->dma_pending = 1;
570
571
572 bcm2835_wr(bs, BCM2835_SPI_DLEN, bs->tx_len);
573
574
575 bcm2835_wr(bs, BCM2835_SPI_CS,
576 cs | BCM2835_SPI_CS_TA | BCM2835_SPI_CS_DMAEN);
577
578
579
580
581
582 ret = bcm2835_spi_prepare_sg(master, tfr, false);
583 if (ret) {
584
585 dmaengine_terminate_sync(master->dma_tx);
586 bs->dma_pending = false;
587 goto err_reset_hw;
588 }
589
590
591 dma_async_issue_pending(master->dma_rx);
592
593
594 return 1;
595
596err_reset_hw:
597 bcm2835_spi_reset_hw(master);
598 bcm2835_spi_undo_prologue(bs);
599 return ret;
600}
601
602static bool bcm2835_spi_can_dma(struct spi_master *master,
603 struct spi_device *spi,
604 struct spi_transfer *tfr)
605{
606
607 if (tfr->len < BCM2835_SPI_DMA_MIN_LENGTH)
608 return false;
609
610
611 return true;
612}
613
614static void bcm2835_dma_release(struct spi_master *master)
615{
616 if (master->dma_tx) {
617 dmaengine_terminate_sync(master->dma_tx);
618 dma_release_channel(master->dma_tx);
619 master->dma_tx = NULL;
620 }
621 if (master->dma_rx) {
622 dmaengine_terminate_sync(master->dma_rx);
623 dma_release_channel(master->dma_rx);
624 master->dma_rx = NULL;
625 }
626}
627
628static void bcm2835_dma_init(struct spi_master *master, struct device *dev)
629{
630 struct dma_slave_config slave_config;
631 const __be32 *addr;
632 dma_addr_t dma_reg_base;
633 int ret;
634
635
636 addr = of_get_address(master->dev.of_node, 0, NULL, NULL);
637 if (!addr) {
638 dev_err(dev, "could not get DMA-register address - not using dma mode\n");
639 goto err;
640 }
641 dma_reg_base = be32_to_cpup(addr);
642
643
644 master->dma_tx = dma_request_slave_channel(dev, "tx");
645 if (!master->dma_tx) {
646 dev_err(dev, "no tx-dma configuration found - not using dma mode\n");
647 goto err;
648 }
649 master->dma_rx = dma_request_slave_channel(dev, "rx");
650 if (!master->dma_rx) {
651 dev_err(dev, "no rx-dma configuration found - not using dma mode\n");
652 goto err_release;
653 }
654
655
656 slave_config.direction = DMA_MEM_TO_DEV;
657 slave_config.dst_addr = (u32)(dma_reg_base + BCM2835_SPI_FIFO);
658 slave_config.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
659
660 ret = dmaengine_slave_config(master->dma_tx, &slave_config);
661 if (ret)
662 goto err_config;
663
664 slave_config.direction = DMA_DEV_TO_MEM;
665 slave_config.src_addr = (u32)(dma_reg_base + BCM2835_SPI_FIFO);
666 slave_config.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
667
668 ret = dmaengine_slave_config(master->dma_rx, &slave_config);
669 if (ret)
670 goto err_config;
671
672
673 master->can_dma = bcm2835_spi_can_dma;
674
675 master->flags = SPI_MASTER_MUST_RX | SPI_MASTER_MUST_TX;
676
677 return;
678
679err_config:
680 dev_err(dev, "issue configuring dma: %d - not using DMA mode\n",
681 ret);
682err_release:
683 bcm2835_dma_release(master);
684err:
685 return;
686}
687
688static int bcm2835_spi_transfer_one_poll(struct spi_master *master,
689 struct spi_device *spi,
690 struct spi_transfer *tfr,
691 u32 cs,
692 unsigned long long xfer_time_us)
693{
694 struct bcm2835_spi *bs = spi_master_get_devdata(master);
695 unsigned long timeout;
696
697
698 bcm2835_wr(bs, BCM2835_SPI_CS, cs | BCM2835_SPI_CS_TA);
699
700
701
702
703
704 bcm2835_wr_fifo_blind(bs, BCM2835_SPI_FIFO_SIZE);
705
706
707 timeout = jiffies + BCM2835_SPI_POLLING_JIFFIES;
708
709
710 while (bs->rx_len) {
711
712 bcm2835_wr_fifo(bs);
713
714
715 bcm2835_rd_fifo(bs);
716
717
718
719
720 if (bs->rx_len && time_after(jiffies, timeout)) {
721 dev_dbg_ratelimited(&spi->dev,
722 "timeout period reached: jiffies: %lu remaining tx/rx: %d/%d - falling back to interrupt mode\n",
723 jiffies - timeout,
724 bs->tx_len, bs->rx_len);
725
726 return bcm2835_spi_transfer_one_irq(master, spi,
727 tfr, cs, false);
728 }
729 }
730
731
732 bcm2835_spi_reset_hw(master);
733
734 return 0;
735}
736
737static int bcm2835_spi_transfer_one(struct spi_master *master,
738 struct spi_device *spi,
739 struct spi_transfer *tfr)
740{
741 struct bcm2835_spi *bs = spi_master_get_devdata(master);
742 unsigned long spi_hz, clk_hz, cdiv;
743 unsigned long spi_used_hz;
744 unsigned long long xfer_time_us;
745 u32 cs = bcm2835_rd(bs, BCM2835_SPI_CS);
746
747
748 spi_hz = tfr->speed_hz;
749 clk_hz = clk_get_rate(bs->clk);
750
751 if (spi_hz >= clk_hz / 2) {
752 cdiv = 2;
753 } else if (spi_hz) {
754
755 cdiv = DIV_ROUND_UP(clk_hz, spi_hz);
756 cdiv += (cdiv % 2);
757
758 if (cdiv >= 65536)
759 cdiv = 0;
760 } else {
761 cdiv = 0;
762 }
763 spi_used_hz = cdiv ? (clk_hz / cdiv) : (clk_hz / 65536);
764 bcm2835_wr(bs, BCM2835_SPI_CLK, cdiv);
765
766
767 if ((spi->mode & SPI_3WIRE) && (tfr->rx_buf))
768 cs |= BCM2835_SPI_CS_REN;
769 else
770 cs &= ~BCM2835_SPI_CS_REN;
771
772
773
774
775
776
777 cs |= BCM2835_SPI_CS_CS_10 | BCM2835_SPI_CS_CS_01;
778
779
780 bs->tx_buf = tfr->tx_buf;
781 bs->rx_buf = tfr->rx_buf;
782 bs->tx_len = tfr->len;
783 bs->rx_len = tfr->len;
784
785
786 xfer_time_us = (unsigned long long)tfr->len
787 * 9
788 * 1000000;
789 do_div(xfer_time_us, spi_used_hz);
790
791
792 if (xfer_time_us <= BCM2835_SPI_POLLING_LIMIT_US)
793 return bcm2835_spi_transfer_one_poll(master, spi, tfr,
794 cs, xfer_time_us);
795
796
797 if (master->can_dma && bcm2835_spi_can_dma(master, spi, tfr))
798 return bcm2835_spi_transfer_one_dma(master, spi, tfr, cs);
799
800
801 return bcm2835_spi_transfer_one_irq(master, spi, tfr, cs, true);
802}
803
804static int bcm2835_spi_prepare_message(struct spi_master *master,
805 struct spi_message *msg)
806{
807 struct spi_device *spi = msg->spi;
808 struct bcm2835_spi *bs = spi_master_get_devdata(master);
809 u32 cs = bcm2835_rd(bs, BCM2835_SPI_CS);
810 int ret;
811
812
813
814
815
816
817 ret = spi_split_transfers_maxsize(master, msg, 65532,
818 GFP_KERNEL | GFP_DMA);
819 if (ret)
820 return ret;
821
822 cs &= ~(BCM2835_SPI_CS_CPOL | BCM2835_SPI_CS_CPHA);
823
824 if (spi->mode & SPI_CPOL)
825 cs |= BCM2835_SPI_CS_CPOL;
826 if (spi->mode & SPI_CPHA)
827 cs |= BCM2835_SPI_CS_CPHA;
828
829 bcm2835_wr(bs, BCM2835_SPI_CS, cs);
830
831 return 0;
832}
833
834static void bcm2835_spi_handle_err(struct spi_master *master,
835 struct spi_message *msg)
836{
837 struct bcm2835_spi *bs = spi_master_get_devdata(master);
838
839
840 if (cmpxchg(&bs->dma_pending, true, false)) {
841 dmaengine_terminate_sync(master->dma_tx);
842 dmaengine_terminate_sync(master->dma_rx);
843 bcm2835_spi_undo_prologue(bs);
844 }
845
846 bcm2835_spi_reset_hw(master);
847}
848
849static int chip_match_name(struct gpio_chip *chip, void *data)
850{
851 return !strcmp(chip->label, data);
852}
853
854static int bcm2835_spi_setup(struct spi_device *spi)
855{
856 int err;
857 struct gpio_chip *chip;
858
859
860
861 if (spi->mode & SPI_NO_CS)
862 return 0;
863 if (gpio_is_valid(spi->cs_gpio))
864 return 0;
865 if (spi->chip_select > 1) {
866
867
868
869
870 dev_err(&spi->dev,
871 "setup: only two native chip-selects are supported\n");
872 return -EINVAL;
873 }
874
875
876
877 chip = gpiochip_find("pinctrl-bcm2835", chip_match_name);
878 if (!chip)
879 return 0;
880
881
882 spi->cs_gpio = chip->base + 8 - spi->chip_select;
883
884
885 dev_info(&spi->dev, "setting up native-CS%i as GPIO %i\n",
886 spi->chip_select, spi->cs_gpio);
887
888
889 err = gpio_direction_output(spi->cs_gpio,
890 (spi->mode & SPI_CS_HIGH) ? 0 : 1);
891 if (err) {
892 dev_err(&spi->dev,
893 "could not set CS%i gpio %i as output: %i",
894 spi->chip_select, spi->cs_gpio, err);
895 return err;
896 }
897
898 return 0;
899}
900
901static int bcm2835_spi_probe(struct platform_device *pdev)
902{
903 struct spi_master *master;
904 struct bcm2835_spi *bs;
905 struct resource *res;
906 int err;
907
908 master = spi_alloc_master(&pdev->dev, sizeof(*bs));
909 if (!master) {
910 dev_err(&pdev->dev, "spi_alloc_master() failed\n");
911 return -ENOMEM;
912 }
913
914 platform_set_drvdata(pdev, master);
915
916 master->mode_bits = BCM2835_SPI_MODE_BITS;
917 master->bits_per_word_mask = SPI_BPW_MASK(8);
918 master->num_chipselect = 3;
919 master->setup = bcm2835_spi_setup;
920 master->transfer_one = bcm2835_spi_transfer_one;
921 master->handle_err = bcm2835_spi_handle_err;
922 master->prepare_message = bcm2835_spi_prepare_message;
923 master->dev.of_node = pdev->dev.of_node;
924
925 bs = spi_master_get_devdata(master);
926
927 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
928 bs->regs = devm_ioremap_resource(&pdev->dev, res);
929 if (IS_ERR(bs->regs)) {
930 err = PTR_ERR(bs->regs);
931 goto out_master_put;
932 }
933
934 bs->clk = devm_clk_get(&pdev->dev, NULL);
935 if (IS_ERR(bs->clk)) {
936 err = PTR_ERR(bs->clk);
937 dev_err(&pdev->dev, "could not get clk: %d\n", err);
938 goto out_master_put;
939 }
940
941 bs->irq = platform_get_irq(pdev, 0);
942 if (bs->irq <= 0) {
943 dev_err(&pdev->dev, "could not get IRQ: %d\n", bs->irq);
944 err = bs->irq ? bs->irq : -ENODEV;
945 goto out_master_put;
946 }
947
948 clk_prepare_enable(bs->clk);
949
950 bcm2835_dma_init(master, &pdev->dev);
951
952
953 bcm2835_wr(bs, BCM2835_SPI_CS,
954 BCM2835_SPI_CS_CLEAR_RX | BCM2835_SPI_CS_CLEAR_TX);
955
956 err = devm_request_irq(&pdev->dev, bs->irq, bcm2835_spi_interrupt, 0,
957 dev_name(&pdev->dev), master);
958 if (err) {
959 dev_err(&pdev->dev, "could not request IRQ: %d\n", err);
960 goto out_clk_disable;
961 }
962
963 err = devm_spi_register_master(&pdev->dev, master);
964 if (err) {
965 dev_err(&pdev->dev, "could not register SPI master: %d\n", err);
966 goto out_clk_disable;
967 }
968
969 return 0;
970
971out_clk_disable:
972 clk_disable_unprepare(bs->clk);
973out_master_put:
974 spi_master_put(master);
975 return err;
976}
977
978static int bcm2835_spi_remove(struct platform_device *pdev)
979{
980 struct spi_master *master = platform_get_drvdata(pdev);
981 struct bcm2835_spi *bs = spi_master_get_devdata(master);
982
983
984 bcm2835_wr(bs, BCM2835_SPI_CS,
985 BCM2835_SPI_CS_CLEAR_RX | BCM2835_SPI_CS_CLEAR_TX);
986
987 clk_disable_unprepare(bs->clk);
988
989 bcm2835_dma_release(master);
990
991 return 0;
992}
993
994static const struct of_device_id bcm2835_spi_match[] = {
995 { .compatible = "brcm,bcm2835-spi", },
996 {}
997};
998MODULE_DEVICE_TABLE(of, bcm2835_spi_match);
999
1000static struct platform_driver bcm2835_spi_driver = {
1001 .driver = {
1002 .name = DRV_NAME,
1003 .of_match_table = bcm2835_spi_match,
1004 },
1005 .probe = bcm2835_spi_probe,
1006 .remove = bcm2835_spi_remove,
1007};
1008module_platform_driver(bcm2835_spi_driver);
1009
1010MODULE_DESCRIPTION("SPI controller driver for Broadcom BCM2835");
1011MODULE_AUTHOR("Chris Boot <bootc@bootc.net>");
1012MODULE_LICENSE("GPL");
1013