1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/clk.h>
21#include <linux/completion.h>
22#include <linux/dma-mapping.h>
23#include <linux/dmaengine.h>
24#include <linux/err.h>
25#include <linux/i2c.h>
26#include <linux/interrupt.h>
27#include <linux/io.h>
28#include <linux/module.h>
29#include <linux/of.h>
30#include <linux/of_device.h>
31#include <linux/platform_device.h>
32#include <linux/slab.h>
33#include <linux/platform_data/dma-atmel.h>
34#include <linux/pm_runtime.h>
35#include <linux/pinctrl/consumer.h>
36
37#define DEFAULT_TWI_CLK_HZ 100000
38#define AT91_I2C_TIMEOUT msecs_to_jiffies(100)
39#define AT91_I2C_DMA_THRESHOLD 8
40#define AUTOSUSPEND_TIMEOUT 2000
41#define AT91_I2C_MAX_ALT_CMD_DATA_SIZE 256
42
43
44#define AT91_TWI_CR 0x0000
45#define AT91_TWI_START BIT(0)
46#define AT91_TWI_STOP BIT(1)
47#define AT91_TWI_MSEN BIT(2)
48#define AT91_TWI_MSDIS BIT(3)
49#define AT91_TWI_SVEN BIT(4)
50#define AT91_TWI_SVDIS BIT(5)
51#define AT91_TWI_QUICK BIT(6)
52#define AT91_TWI_SWRST BIT(7)
53#define AT91_TWI_ACMEN BIT(16)
54#define AT91_TWI_ACMDIS BIT(17)
55#define AT91_TWI_THRCLR BIT(24)
56#define AT91_TWI_RHRCLR BIT(25)
57#define AT91_TWI_LOCKCLR BIT(26)
58#define AT91_TWI_FIFOEN BIT(28)
59#define AT91_TWI_FIFODIS BIT(29)
60
61#define AT91_TWI_MMR 0x0004
62#define AT91_TWI_IADRSZ_1 0x0100
63#define AT91_TWI_MREAD BIT(12)
64
65#define AT91_TWI_IADR 0x000c
66
67#define AT91_TWI_CWGR 0x0010
68#define AT91_TWI_CWGR_HOLD_MAX 0x1f
69#define AT91_TWI_CWGR_HOLD(x) (((x) & AT91_TWI_CWGR_HOLD_MAX) << 24)
70
71#define AT91_TWI_SR 0x0020
72#define AT91_TWI_TXCOMP BIT(0)
73#define AT91_TWI_RXRDY BIT(1)
74#define AT91_TWI_TXRDY BIT(2)
75#define AT91_TWI_OVRE BIT(6)
76#define AT91_TWI_UNRE BIT(7)
77#define AT91_TWI_NACK BIT(8)
78#define AT91_TWI_LOCK BIT(23)
79
80#define AT91_TWI_INT_MASK \
81 (AT91_TWI_TXCOMP | AT91_TWI_RXRDY | AT91_TWI_TXRDY | AT91_TWI_NACK)
82
83#define AT91_TWI_IER 0x0024
84#define AT91_TWI_IDR 0x0028
85#define AT91_TWI_IMR 0x002c
86#define AT91_TWI_RHR 0x0030
87#define AT91_TWI_THR 0x0034
88
89#define AT91_TWI_ACR 0x0040
90#define AT91_TWI_ACR_DATAL(len) ((len) & 0xff)
91#define AT91_TWI_ACR_DIR BIT(8)
92
93#define AT91_TWI_FMR 0x0050
94#define AT91_TWI_FMR_TXRDYM(mode) (((mode) & 0x3) << 0)
95#define AT91_TWI_FMR_TXRDYM_MASK (0x3 << 0)
96#define AT91_TWI_FMR_RXRDYM(mode) (((mode) & 0x3) << 4)
97#define AT91_TWI_FMR_RXRDYM_MASK (0x3 << 4)
98#define AT91_TWI_ONE_DATA 0x0
99#define AT91_TWI_TWO_DATA 0x1
100#define AT91_TWI_FOUR_DATA 0x2
101
102#define AT91_TWI_FLR 0x0054
103
104#define AT91_TWI_FSR 0x0060
105#define AT91_TWI_FIER 0x0064
106#define AT91_TWI_FIDR 0x0068
107#define AT91_TWI_FIMR 0x006c
108
109#define AT91_TWI_VER 0x00fc
110
111struct at91_twi_pdata {
112 unsigned clk_max_div;
113 unsigned clk_offset;
114 bool has_unre_flag;
115 bool has_alt_cmd;
116 bool has_hold_field;
117 struct at_dma_slave dma_slave;
118};
119
120struct at91_twi_dma {
121 struct dma_chan *chan_rx;
122 struct dma_chan *chan_tx;
123 struct scatterlist sg[2];
124 struct dma_async_tx_descriptor *data_desc;
125 enum dma_data_direction direction;
126 bool buf_mapped;
127 bool xfer_in_progress;
128};
129
130struct at91_twi_dev {
131 struct device *dev;
132 void __iomem *base;
133 struct completion cmd_complete;
134 struct clk *clk;
135 u8 *buf;
136 size_t buf_len;
137 struct i2c_msg *msg;
138 int irq;
139 unsigned imr;
140 unsigned transfer_status;
141 struct i2c_adapter adapter;
142 unsigned twi_cwgr_reg;
143 struct at91_twi_pdata *pdata;
144 bool use_dma;
145 bool use_alt_cmd;
146 bool recv_len_abort;
147 u32 fifo_size;
148 struct at91_twi_dma dma;
149};
150
151static unsigned at91_twi_read(struct at91_twi_dev *dev, unsigned reg)
152{
153 return readl_relaxed(dev->base + reg);
154}
155
156static void at91_twi_write(struct at91_twi_dev *dev, unsigned reg, unsigned val)
157{
158 writel_relaxed(val, dev->base + reg);
159}
160
161static void at91_disable_twi_interrupts(struct at91_twi_dev *dev)
162{
163 at91_twi_write(dev, AT91_TWI_IDR, AT91_TWI_INT_MASK);
164}
165
166static void at91_twi_irq_save(struct at91_twi_dev *dev)
167{
168 dev->imr = at91_twi_read(dev, AT91_TWI_IMR) & AT91_TWI_INT_MASK;
169 at91_disable_twi_interrupts(dev);
170}
171
172static void at91_twi_irq_restore(struct at91_twi_dev *dev)
173{
174 at91_twi_write(dev, AT91_TWI_IER, dev->imr);
175}
176
177static void at91_init_twi_bus(struct at91_twi_dev *dev)
178{
179 at91_disable_twi_interrupts(dev);
180 at91_twi_write(dev, AT91_TWI_CR, AT91_TWI_SWRST);
181
182 if (dev->fifo_size)
183 at91_twi_write(dev, AT91_TWI_CR, AT91_TWI_FIFOEN);
184 at91_twi_write(dev, AT91_TWI_CR, AT91_TWI_MSEN);
185 at91_twi_write(dev, AT91_TWI_CR, AT91_TWI_SVDIS);
186 at91_twi_write(dev, AT91_TWI_CWGR, dev->twi_cwgr_reg);
187}
188
189
190
191
192
193static void at91_calc_twi_clock(struct at91_twi_dev *dev, int twi_clk)
194{
195 int ckdiv, cdiv, div, hold = 0;
196 struct at91_twi_pdata *pdata = dev->pdata;
197 int offset = pdata->clk_offset;
198 int max_ckdiv = pdata->clk_max_div;
199 u32 twd_hold_time_ns = 0;
200
201 div = max(0, (int)DIV_ROUND_UP(clk_get_rate(dev->clk),
202 2 * twi_clk) - offset);
203 ckdiv = fls(div >> 8);
204 cdiv = div >> ckdiv;
205
206 if (ckdiv > max_ckdiv) {
207 dev_warn(dev->dev, "%d exceeds ckdiv max value which is %d.\n",
208 ckdiv, max_ckdiv);
209 ckdiv = max_ckdiv;
210 cdiv = 255;
211 }
212
213 if (pdata->has_hold_field) {
214 of_property_read_u32(dev->dev->of_node, "i2c-sda-hold-time-ns",
215 &twd_hold_time_ns);
216
217
218
219
220
221
222 hold = DIV_ROUND_UP(twd_hold_time_ns
223 * (clk_get_rate(dev->clk) / 1000), 1000000);
224 hold -= 3;
225 if (hold < 0)
226 hold = 0;
227 if (hold > AT91_TWI_CWGR_HOLD_MAX) {
228 dev_warn(dev->dev,
229 "HOLD field set to its maximum value (%d instead of %d)\n",
230 AT91_TWI_CWGR_HOLD_MAX, hold);
231 hold = AT91_TWI_CWGR_HOLD_MAX;
232 }
233 }
234
235 dev->twi_cwgr_reg = (ckdiv << 16) | (cdiv << 8) | cdiv
236 | AT91_TWI_CWGR_HOLD(hold);
237
238 dev_dbg(dev->dev, "cdiv %d ckdiv %d hold %d (%d ns)\n",
239 cdiv, ckdiv, hold, twd_hold_time_ns);
240}
241
242static void at91_twi_dma_cleanup(struct at91_twi_dev *dev)
243{
244 struct at91_twi_dma *dma = &dev->dma;
245
246 at91_twi_irq_save(dev);
247
248 if (dma->xfer_in_progress) {
249 if (dma->direction == DMA_FROM_DEVICE)
250 dmaengine_terminate_all(dma->chan_rx);
251 else
252 dmaengine_terminate_all(dma->chan_tx);
253 dma->xfer_in_progress = false;
254 }
255 if (dma->buf_mapped) {
256 dma_unmap_single(dev->dev, sg_dma_address(&dma->sg[0]),
257 dev->buf_len, dma->direction);
258 dma->buf_mapped = false;
259 }
260
261 at91_twi_irq_restore(dev);
262}
263
264static void at91_twi_write_next_byte(struct at91_twi_dev *dev)
265{
266 if (!dev->buf_len)
267 return;
268
269
270 writeb_relaxed(*dev->buf, dev->base + AT91_TWI_THR);
271
272
273 if (--dev->buf_len == 0)
274 if (!dev->use_alt_cmd)
275 at91_twi_write(dev, AT91_TWI_CR, AT91_TWI_STOP);
276
277 dev_dbg(dev->dev, "wrote 0x%x, to go %d\n", *dev->buf, dev->buf_len);
278
279 ++dev->buf;
280}
281
282static void at91_twi_write_data_dma_callback(void *data)
283{
284 struct at91_twi_dev *dev = (struct at91_twi_dev *)data;
285
286 dma_unmap_single(dev->dev, sg_dma_address(&dev->dma.sg[0]),
287 dev->buf_len, DMA_TO_DEVICE);
288
289
290
291
292
293
294
295
296 at91_twi_write(dev, AT91_TWI_IER, AT91_TWI_TXCOMP);
297 if (!dev->use_alt_cmd)
298 at91_twi_write(dev, AT91_TWI_CR, AT91_TWI_STOP);
299}
300
301static void at91_twi_write_data_dma(struct at91_twi_dev *dev)
302{
303 dma_addr_t dma_addr;
304 struct dma_async_tx_descriptor *txdesc;
305 struct at91_twi_dma *dma = &dev->dma;
306 struct dma_chan *chan_tx = dma->chan_tx;
307 unsigned int sg_len = 1;
308
309 if (!dev->buf_len)
310 return;
311
312 dma->direction = DMA_TO_DEVICE;
313
314 at91_twi_irq_save(dev);
315 dma_addr = dma_map_single(dev->dev, dev->buf, dev->buf_len,
316 DMA_TO_DEVICE);
317 if (dma_mapping_error(dev->dev, dma_addr)) {
318 dev_err(dev->dev, "dma map failed\n");
319 return;
320 }
321 dma->buf_mapped = true;
322 at91_twi_irq_restore(dev);
323
324 if (dev->fifo_size) {
325 size_t part1_len, part2_len;
326 struct scatterlist *sg;
327 unsigned fifo_mr;
328
329 sg_len = 0;
330
331 part1_len = dev->buf_len & ~0x3;
332 if (part1_len) {
333 sg = &dma->sg[sg_len++];
334 sg_dma_len(sg) = part1_len;
335 sg_dma_address(sg) = dma_addr;
336 }
337
338 part2_len = dev->buf_len & 0x3;
339 if (part2_len) {
340 sg = &dma->sg[sg_len++];
341 sg_dma_len(sg) = part2_len;
342 sg_dma_address(sg) = dma_addr + part1_len;
343 }
344
345
346
347
348
349 fifo_mr = at91_twi_read(dev, AT91_TWI_FMR);
350 fifo_mr &= ~AT91_TWI_FMR_TXRDYM_MASK;
351 fifo_mr |= AT91_TWI_FMR_TXRDYM(AT91_TWI_FOUR_DATA);
352 at91_twi_write(dev, AT91_TWI_FMR, fifo_mr);
353 } else {
354 sg_dma_len(&dma->sg[0]) = dev->buf_len;
355 sg_dma_address(&dma->sg[0]) = dma_addr;
356 }
357
358 txdesc = dmaengine_prep_slave_sg(chan_tx, dma->sg, sg_len,
359 DMA_MEM_TO_DEV,
360 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
361 if (!txdesc) {
362 dev_err(dev->dev, "dma prep slave sg failed\n");
363 goto error;
364 }
365
366 txdesc->callback = at91_twi_write_data_dma_callback;
367 txdesc->callback_param = dev;
368
369 dma->xfer_in_progress = true;
370 dmaengine_submit(txdesc);
371 dma_async_issue_pending(chan_tx);
372
373 return;
374
375error:
376 at91_twi_dma_cleanup(dev);
377}
378
379static void at91_twi_read_next_byte(struct at91_twi_dev *dev)
380{
381
382
383
384
385 if (!dev->buf_len) {
386 at91_twi_read(dev, AT91_TWI_RHR);
387 return;
388 }
389
390
391 *dev->buf = readb_relaxed(dev->base + AT91_TWI_RHR);
392 --dev->buf_len;
393
394
395 if (dev->recv_len_abort)
396 return;
397
398
399 if (unlikely(dev->msg->flags & I2C_M_RECV_LEN)) {
400
401 if (*dev->buf <= I2C_SMBUS_BLOCK_MAX && *dev->buf > 0) {
402 dev->msg->flags &= ~I2C_M_RECV_LEN;
403 dev->buf_len += *dev->buf;
404 dev->msg->len = dev->buf_len + 1;
405 dev_dbg(dev->dev, "received block length %d\n",
406 dev->buf_len);
407 } else {
408
409 dev->recv_len_abort = true;
410 dev->buf_len = 1;
411 }
412 }
413
414
415 if (!dev->use_alt_cmd && dev->buf_len == 1)
416 at91_twi_write(dev, AT91_TWI_CR, AT91_TWI_STOP);
417
418 dev_dbg(dev->dev, "read 0x%x, to go %d\n", *dev->buf, dev->buf_len);
419
420 ++dev->buf;
421}
422
423static void at91_twi_read_data_dma_callback(void *data)
424{
425 struct at91_twi_dev *dev = (struct at91_twi_dev *)data;
426 unsigned ier = AT91_TWI_TXCOMP;
427
428 dma_unmap_single(dev->dev, sg_dma_address(&dev->dma.sg[0]),
429 dev->buf_len, DMA_FROM_DEVICE);
430
431 if (!dev->use_alt_cmd) {
432
433 dev->buf += dev->buf_len - 2;
434 dev->buf_len = 2;
435 ier |= AT91_TWI_RXRDY;
436 }
437 at91_twi_write(dev, AT91_TWI_IER, ier);
438}
439
440static void at91_twi_read_data_dma(struct at91_twi_dev *dev)
441{
442 dma_addr_t dma_addr;
443 struct dma_async_tx_descriptor *rxdesc;
444 struct at91_twi_dma *dma = &dev->dma;
445 struct dma_chan *chan_rx = dma->chan_rx;
446 size_t buf_len;
447
448 buf_len = (dev->use_alt_cmd) ? dev->buf_len : dev->buf_len - 2;
449 dma->direction = DMA_FROM_DEVICE;
450
451
452 at91_twi_irq_save(dev);
453 dma_addr = dma_map_single(dev->dev, dev->buf, buf_len, DMA_FROM_DEVICE);
454 if (dma_mapping_error(dev->dev, dma_addr)) {
455 dev_err(dev->dev, "dma map failed\n");
456 return;
457 }
458 dma->buf_mapped = true;
459 at91_twi_irq_restore(dev);
460
461 if (dev->fifo_size && IS_ALIGNED(buf_len, 4)) {
462 unsigned fifo_mr;
463
464
465
466
467
468 fifo_mr = at91_twi_read(dev, AT91_TWI_FMR);
469 fifo_mr &= ~AT91_TWI_FMR_RXRDYM_MASK;
470 fifo_mr |= AT91_TWI_FMR_RXRDYM(AT91_TWI_FOUR_DATA);
471 at91_twi_write(dev, AT91_TWI_FMR, fifo_mr);
472 }
473
474 sg_dma_len(&dma->sg[0]) = buf_len;
475 sg_dma_address(&dma->sg[0]) = dma_addr;
476
477 rxdesc = dmaengine_prep_slave_sg(chan_rx, dma->sg, 1, DMA_DEV_TO_MEM,
478 DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
479 if (!rxdesc) {
480 dev_err(dev->dev, "dma prep slave sg failed\n");
481 goto error;
482 }
483
484 rxdesc->callback = at91_twi_read_data_dma_callback;
485 rxdesc->callback_param = dev;
486
487 dma->xfer_in_progress = true;
488 dmaengine_submit(rxdesc);
489 dma_async_issue_pending(dma->chan_rx);
490
491 return;
492
493error:
494 at91_twi_dma_cleanup(dev);
495}
496
497static irqreturn_t atmel_twi_interrupt(int irq, void *dev_id)
498{
499 struct at91_twi_dev *dev = dev_id;
500 const unsigned status = at91_twi_read(dev, AT91_TWI_SR);
501 const unsigned irqstatus = status & at91_twi_read(dev, AT91_TWI_IMR);
502
503 if (!irqstatus)
504 return IRQ_NONE;
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521 if (irqstatus & AT91_TWI_RXRDY)
522 at91_twi_read_next_byte(dev);
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562 if (irqstatus & (AT91_TWI_TXCOMP | AT91_TWI_NACK)) {
563 at91_disable_twi_interrupts(dev);
564 complete(&dev->cmd_complete);
565 } else if (irqstatus & AT91_TWI_TXRDY) {
566 at91_twi_write_next_byte(dev);
567 }
568
569
570 dev->transfer_status |= status;
571
572 return IRQ_HANDLED;
573}
574
575static int at91_do_twi_transfer(struct at91_twi_dev *dev)
576{
577 int ret;
578 unsigned long time_left;
579 bool has_unre_flag = dev->pdata->has_unre_flag;
580 bool has_alt_cmd = dev->pdata->has_alt_cmd;
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625 dev_dbg(dev->dev, "transfer: %s %d bytes.\n",
626 (dev->msg->flags & I2C_M_RD) ? "read" : "write", dev->buf_len);
627
628 reinit_completion(&dev->cmd_complete);
629 dev->transfer_status = 0;
630
631
632 at91_twi_read(dev, AT91_TWI_SR);
633
634 if (dev->fifo_size) {
635 unsigned fifo_mr = at91_twi_read(dev, AT91_TWI_FMR);
636
637
638 fifo_mr &= ~(AT91_TWI_FMR_TXRDYM_MASK |
639 AT91_TWI_FMR_RXRDYM_MASK);
640 fifo_mr |= AT91_TWI_FMR_TXRDYM(AT91_TWI_ONE_DATA);
641 fifo_mr |= AT91_TWI_FMR_RXRDYM(AT91_TWI_ONE_DATA);
642 at91_twi_write(dev, AT91_TWI_FMR, fifo_mr);
643
644
645 at91_twi_write(dev, AT91_TWI_CR,
646 AT91_TWI_THRCLR | AT91_TWI_RHRCLR);
647 }
648
649 if (!dev->buf_len) {
650 at91_twi_write(dev, AT91_TWI_CR, AT91_TWI_QUICK);
651 at91_twi_write(dev, AT91_TWI_IER, AT91_TWI_TXCOMP);
652 } else if (dev->msg->flags & I2C_M_RD) {
653 unsigned start_flags = AT91_TWI_START;
654
655
656 if (!dev->use_alt_cmd && dev->buf_len <= 1 &&
657 !(dev->msg->flags & I2C_M_RECV_LEN))
658 start_flags |= AT91_TWI_STOP;
659 at91_twi_write(dev, AT91_TWI_CR, start_flags);
660
661
662
663
664
665
666
667
668
669 if (dev->use_dma && (dev->buf_len > AT91_I2C_DMA_THRESHOLD)) {
670 at91_twi_write(dev, AT91_TWI_IER, AT91_TWI_NACK);
671 at91_twi_read_data_dma(dev);
672 } else {
673 at91_twi_write(dev, AT91_TWI_IER,
674 AT91_TWI_TXCOMP |
675 AT91_TWI_NACK |
676 AT91_TWI_RXRDY);
677 }
678 } else {
679 if (dev->use_dma && (dev->buf_len > AT91_I2C_DMA_THRESHOLD)) {
680 at91_twi_write(dev, AT91_TWI_IER, AT91_TWI_NACK);
681 at91_twi_write_data_dma(dev);
682 } else {
683 at91_twi_write_next_byte(dev);
684 at91_twi_write(dev, AT91_TWI_IER,
685 AT91_TWI_TXCOMP |
686 AT91_TWI_NACK |
687 AT91_TWI_TXRDY);
688 }
689 }
690
691 time_left = wait_for_completion_timeout(&dev->cmd_complete,
692 dev->adapter.timeout);
693 if (time_left == 0) {
694 dev->transfer_status |= at91_twi_read(dev, AT91_TWI_SR);
695 dev_err(dev->dev, "controller timed out\n");
696 at91_init_twi_bus(dev);
697 ret = -ETIMEDOUT;
698 goto error;
699 }
700 if (dev->transfer_status & AT91_TWI_NACK) {
701 dev_dbg(dev->dev, "received nack\n");
702 ret = -EREMOTEIO;
703 goto error;
704 }
705 if (dev->transfer_status & AT91_TWI_OVRE) {
706 dev_err(dev->dev, "overrun while reading\n");
707 ret = -EIO;
708 goto error;
709 }
710 if (has_unre_flag && dev->transfer_status & AT91_TWI_UNRE) {
711 dev_err(dev->dev, "underrun while writing\n");
712 ret = -EIO;
713 goto error;
714 }
715 if ((has_alt_cmd || dev->fifo_size) &&
716 (dev->transfer_status & AT91_TWI_LOCK)) {
717 dev_err(dev->dev, "tx locked\n");
718 ret = -EIO;
719 goto error;
720 }
721 if (dev->recv_len_abort) {
722 dev_err(dev->dev, "invalid smbus block length recvd\n");
723 ret = -EPROTO;
724 goto error;
725 }
726
727 dev_dbg(dev->dev, "transfer complete\n");
728
729 return 0;
730
731error:
732
733 at91_twi_dma_cleanup(dev);
734
735 if ((has_alt_cmd || dev->fifo_size) &&
736 (dev->transfer_status & AT91_TWI_LOCK)) {
737 dev_dbg(dev->dev, "unlock tx\n");
738 at91_twi_write(dev, AT91_TWI_CR,
739 AT91_TWI_THRCLR | AT91_TWI_LOCKCLR);
740 }
741 return ret;
742}
743
744static int at91_twi_xfer(struct i2c_adapter *adap, struct i2c_msg *msg, int num)
745{
746 struct at91_twi_dev *dev = i2c_get_adapdata(adap);
747 int ret;
748 unsigned int_addr_flag = 0;
749 struct i2c_msg *m_start = msg;
750 bool is_read;
751
752 dev_dbg(&adap->dev, "at91_xfer: processing %d messages:\n", num);
753
754 ret = pm_runtime_get_sync(dev->dev);
755 if (ret < 0)
756 goto out;
757
758 if (num == 2) {
759 int internal_address = 0;
760 int i;
761
762
763 m_start = &msg[1];
764 for (i = 0; i < msg->len; ++i) {
765 const unsigned addr = msg->buf[msg->len - 1 - i];
766
767 internal_address |= addr << (8 * i);
768 int_addr_flag += AT91_TWI_IADRSZ_1;
769 }
770 at91_twi_write(dev, AT91_TWI_IADR, internal_address);
771 }
772
773 dev->use_alt_cmd = false;
774 is_read = (m_start->flags & I2C_M_RD);
775 if (dev->pdata->has_alt_cmd) {
776 if (m_start->len > 0 &&
777 m_start->len < AT91_I2C_MAX_ALT_CMD_DATA_SIZE) {
778 at91_twi_write(dev, AT91_TWI_CR, AT91_TWI_ACMEN);
779 at91_twi_write(dev, AT91_TWI_ACR,
780 AT91_TWI_ACR_DATAL(m_start->len) |
781 ((is_read) ? AT91_TWI_ACR_DIR : 0));
782 dev->use_alt_cmd = true;
783 } else {
784 at91_twi_write(dev, AT91_TWI_CR, AT91_TWI_ACMDIS);
785 }
786 }
787
788 at91_twi_write(dev, AT91_TWI_MMR,
789 (m_start->addr << 16) |
790 int_addr_flag |
791 ((!dev->use_alt_cmd && is_read) ? AT91_TWI_MREAD : 0));
792
793 dev->buf_len = m_start->len;
794 dev->buf = m_start->buf;
795 dev->msg = m_start;
796 dev->recv_len_abort = false;
797
798 ret = at91_do_twi_transfer(dev);
799
800 ret = (ret < 0) ? ret : num;
801out:
802 pm_runtime_mark_last_busy(dev->dev);
803 pm_runtime_put_autosuspend(dev->dev);
804
805 return ret;
806}
807
808
809
810
811
812static struct i2c_adapter_quirks at91_twi_quirks = {
813 .flags = I2C_AQ_COMB | I2C_AQ_COMB_WRITE_FIRST | I2C_AQ_COMB_SAME_ADDR,
814 .max_comb_1st_msg_len = 3,
815};
816
817static u32 at91_twi_func(struct i2c_adapter *adapter)
818{
819 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL
820 | I2C_FUNC_SMBUS_READ_BLOCK_DATA;
821}
822
823static struct i2c_algorithm at91_twi_algorithm = {
824 .master_xfer = at91_twi_xfer,
825 .functionality = at91_twi_func,
826};
827
828static struct at91_twi_pdata at91rm9200_config = {
829 .clk_max_div = 5,
830 .clk_offset = 3,
831 .has_unre_flag = true,
832 .has_alt_cmd = false,
833 .has_hold_field = false,
834};
835
836static struct at91_twi_pdata at91sam9261_config = {
837 .clk_max_div = 5,
838 .clk_offset = 4,
839 .has_unre_flag = false,
840 .has_alt_cmd = false,
841 .has_hold_field = false,
842};
843
844static struct at91_twi_pdata at91sam9260_config = {
845 .clk_max_div = 7,
846 .clk_offset = 4,
847 .has_unre_flag = false,
848 .has_alt_cmd = false,
849 .has_hold_field = false,
850};
851
852static struct at91_twi_pdata at91sam9g20_config = {
853 .clk_max_div = 7,
854 .clk_offset = 4,
855 .has_unre_flag = false,
856 .has_alt_cmd = false,
857 .has_hold_field = false,
858};
859
860static struct at91_twi_pdata at91sam9g10_config = {
861 .clk_max_div = 7,
862 .clk_offset = 4,
863 .has_unre_flag = false,
864 .has_alt_cmd = false,
865 .has_hold_field = false,
866};
867
868static const struct platform_device_id at91_twi_devtypes[] = {
869 {
870 .name = "i2c-at91rm9200",
871 .driver_data = (unsigned long) &at91rm9200_config,
872 }, {
873 .name = "i2c-at91sam9261",
874 .driver_data = (unsigned long) &at91sam9261_config,
875 }, {
876 .name = "i2c-at91sam9260",
877 .driver_data = (unsigned long) &at91sam9260_config,
878 }, {
879 .name = "i2c-at91sam9g20",
880 .driver_data = (unsigned long) &at91sam9g20_config,
881 }, {
882 .name = "i2c-at91sam9g10",
883 .driver_data = (unsigned long) &at91sam9g10_config,
884 }, {
885
886 }
887};
888
889#if defined(CONFIG_OF)
890static struct at91_twi_pdata at91sam9x5_config = {
891 .clk_max_div = 7,
892 .clk_offset = 4,
893 .has_unre_flag = false,
894 .has_alt_cmd = false,
895 .has_hold_field = false,
896};
897
898static struct at91_twi_pdata sama5d4_config = {
899 .clk_max_div = 7,
900 .clk_offset = 4,
901 .has_unre_flag = false,
902 .has_alt_cmd = false,
903 .has_hold_field = true,
904};
905
906static struct at91_twi_pdata sama5d2_config = {
907 .clk_max_div = 7,
908 .clk_offset = 4,
909 .has_unre_flag = true,
910 .has_alt_cmd = true,
911 .has_hold_field = true,
912};
913
914static const struct of_device_id atmel_twi_dt_ids[] = {
915 {
916 .compatible = "atmel,at91rm9200-i2c",
917 .data = &at91rm9200_config,
918 } , {
919 .compatible = "atmel,at91sam9260-i2c",
920 .data = &at91sam9260_config,
921 } , {
922 .compatible = "atmel,at91sam9261-i2c",
923 .data = &at91sam9261_config,
924 } , {
925 .compatible = "atmel,at91sam9g20-i2c",
926 .data = &at91sam9g20_config,
927 } , {
928 .compatible = "atmel,at91sam9g10-i2c",
929 .data = &at91sam9g10_config,
930 }, {
931 .compatible = "atmel,at91sam9x5-i2c",
932 .data = &at91sam9x5_config,
933 }, {
934 .compatible = "atmel,sama5d4-i2c",
935 .data = &sama5d4_config,
936 }, {
937 .compatible = "atmel,sama5d2-i2c",
938 .data = &sama5d2_config,
939 }, {
940
941 }
942};
943MODULE_DEVICE_TABLE(of, atmel_twi_dt_ids);
944#endif
945
946static int at91_twi_configure_dma(struct at91_twi_dev *dev, u32 phy_addr)
947{
948 int ret = 0;
949 struct dma_slave_config slave_config;
950 struct at91_twi_dma *dma = &dev->dma;
951 enum dma_slave_buswidth addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968 if (dev->fifo_size)
969 addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
970
971 memset(&slave_config, 0, sizeof(slave_config));
972 slave_config.src_addr = (dma_addr_t)phy_addr + AT91_TWI_RHR;
973 slave_config.src_addr_width = addr_width;
974 slave_config.src_maxburst = 1;
975 slave_config.dst_addr = (dma_addr_t)phy_addr + AT91_TWI_THR;
976 slave_config.dst_addr_width = addr_width;
977 slave_config.dst_maxburst = 1;
978 slave_config.device_fc = false;
979
980 dma->chan_tx = dma_request_slave_channel_reason(dev->dev, "tx");
981 if (IS_ERR(dma->chan_tx)) {
982 ret = PTR_ERR(dma->chan_tx);
983 dma->chan_tx = NULL;
984 goto error;
985 }
986
987 dma->chan_rx = dma_request_slave_channel_reason(dev->dev, "rx");
988 if (IS_ERR(dma->chan_rx)) {
989 ret = PTR_ERR(dma->chan_rx);
990 dma->chan_rx = NULL;
991 goto error;
992 }
993
994 slave_config.direction = DMA_MEM_TO_DEV;
995 if (dmaengine_slave_config(dma->chan_tx, &slave_config)) {
996 dev_err(dev->dev, "failed to configure tx channel\n");
997 ret = -EINVAL;
998 goto error;
999 }
1000
1001 slave_config.direction = DMA_DEV_TO_MEM;
1002 if (dmaengine_slave_config(dma->chan_rx, &slave_config)) {
1003 dev_err(dev->dev, "failed to configure rx channel\n");
1004 ret = -EINVAL;
1005 goto error;
1006 }
1007
1008 sg_init_table(dma->sg, 2);
1009 dma->buf_mapped = false;
1010 dma->xfer_in_progress = false;
1011 dev->use_dma = true;
1012
1013 dev_info(dev->dev, "using %s (tx) and %s (rx) for DMA transfers\n",
1014 dma_chan_name(dma->chan_tx), dma_chan_name(dma->chan_rx));
1015
1016 return ret;
1017
1018error:
1019 if (ret != -EPROBE_DEFER)
1020 dev_info(dev->dev, "can't get DMA channel, continue without DMA support\n");
1021 if (dma->chan_rx)
1022 dma_release_channel(dma->chan_rx);
1023 if (dma->chan_tx)
1024 dma_release_channel(dma->chan_tx);
1025 return ret;
1026}
1027
1028static struct at91_twi_pdata *at91_twi_get_driver_data(
1029 struct platform_device *pdev)
1030{
1031 if (pdev->dev.of_node) {
1032 const struct of_device_id *match;
1033 match = of_match_node(atmel_twi_dt_ids, pdev->dev.of_node);
1034 if (!match)
1035 return NULL;
1036 return (struct at91_twi_pdata *)match->data;
1037 }
1038 return (struct at91_twi_pdata *) platform_get_device_id(pdev)->driver_data;
1039}
1040
1041static int at91_twi_probe(struct platform_device *pdev)
1042{
1043 struct at91_twi_dev *dev;
1044 struct resource *mem;
1045 int rc;
1046 u32 phy_addr;
1047 u32 bus_clk_rate;
1048
1049 dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL);
1050 if (!dev)
1051 return -ENOMEM;
1052 init_completion(&dev->cmd_complete);
1053 dev->dev = &pdev->dev;
1054
1055 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1056 if (!mem)
1057 return -ENODEV;
1058 phy_addr = mem->start;
1059
1060 dev->pdata = at91_twi_get_driver_data(pdev);
1061 if (!dev->pdata)
1062 return -ENODEV;
1063
1064 dev->base = devm_ioremap_resource(&pdev->dev, mem);
1065 if (IS_ERR(dev->base))
1066 return PTR_ERR(dev->base);
1067
1068 dev->irq = platform_get_irq(pdev, 0);
1069 if (dev->irq < 0)
1070 return dev->irq;
1071
1072 rc = devm_request_irq(&pdev->dev, dev->irq, atmel_twi_interrupt, 0,
1073 dev_name(dev->dev), dev);
1074 if (rc) {
1075 dev_err(dev->dev, "Cannot get irq %d: %d\n", dev->irq, rc);
1076 return rc;
1077 }
1078
1079 platform_set_drvdata(pdev, dev);
1080
1081 dev->clk = devm_clk_get(dev->dev, NULL);
1082 if (IS_ERR(dev->clk)) {
1083 dev_err(dev->dev, "no clock defined\n");
1084 return -ENODEV;
1085 }
1086 clk_prepare_enable(dev->clk);
1087
1088 if (dev->dev->of_node) {
1089 rc = at91_twi_configure_dma(dev, phy_addr);
1090 if (rc == -EPROBE_DEFER)
1091 return rc;
1092 }
1093
1094 if (!of_property_read_u32(pdev->dev.of_node, "atmel,fifo-size",
1095 &dev->fifo_size)) {
1096 dev_info(dev->dev, "Using FIFO (%u data)\n", dev->fifo_size);
1097 }
1098
1099 rc = of_property_read_u32(dev->dev->of_node, "clock-frequency",
1100 &bus_clk_rate);
1101 if (rc)
1102 bus_clk_rate = DEFAULT_TWI_CLK_HZ;
1103
1104 at91_calc_twi_clock(dev, bus_clk_rate);
1105 at91_init_twi_bus(dev);
1106
1107 snprintf(dev->adapter.name, sizeof(dev->adapter.name), "AT91");
1108 i2c_set_adapdata(&dev->adapter, dev);
1109 dev->adapter.owner = THIS_MODULE;
1110 dev->adapter.class = I2C_CLASS_DEPRECATED;
1111 dev->adapter.algo = &at91_twi_algorithm;
1112 dev->adapter.quirks = &at91_twi_quirks;
1113 dev->adapter.dev.parent = dev->dev;
1114 dev->adapter.nr = pdev->id;
1115 dev->adapter.timeout = AT91_I2C_TIMEOUT;
1116 dev->adapter.dev.of_node = pdev->dev.of_node;
1117
1118 pm_runtime_set_autosuspend_delay(dev->dev, AUTOSUSPEND_TIMEOUT);
1119 pm_runtime_use_autosuspend(dev->dev);
1120 pm_runtime_set_active(dev->dev);
1121 pm_runtime_enable(dev->dev);
1122
1123 rc = i2c_add_numbered_adapter(&dev->adapter);
1124 if (rc) {
1125 clk_disable_unprepare(dev->clk);
1126
1127 pm_runtime_disable(dev->dev);
1128 pm_runtime_set_suspended(dev->dev);
1129
1130 return rc;
1131 }
1132
1133 dev_info(dev->dev, "AT91 i2c bus driver (hw version: %#x).\n",
1134 at91_twi_read(dev, AT91_TWI_VER));
1135 return 0;
1136}
1137
1138static int at91_twi_remove(struct platform_device *pdev)
1139{
1140 struct at91_twi_dev *dev = platform_get_drvdata(pdev);
1141
1142 i2c_del_adapter(&dev->adapter);
1143 clk_disable_unprepare(dev->clk);
1144
1145 pm_runtime_disable(dev->dev);
1146 pm_runtime_set_suspended(dev->dev);
1147
1148 return 0;
1149}
1150
1151#ifdef CONFIG_PM
1152
1153static int at91_twi_runtime_suspend(struct device *dev)
1154{
1155 struct at91_twi_dev *twi_dev = dev_get_drvdata(dev);
1156
1157 clk_disable_unprepare(twi_dev->clk);
1158
1159 pinctrl_pm_select_sleep_state(dev);
1160
1161 return 0;
1162}
1163
1164static int at91_twi_runtime_resume(struct device *dev)
1165{
1166 struct at91_twi_dev *twi_dev = dev_get_drvdata(dev);
1167
1168 pinctrl_pm_select_default_state(dev);
1169
1170 return clk_prepare_enable(twi_dev->clk);
1171}
1172
1173static int at91_twi_suspend_noirq(struct device *dev)
1174{
1175 if (!pm_runtime_status_suspended(dev))
1176 at91_twi_runtime_suspend(dev);
1177
1178 return 0;
1179}
1180
1181static int at91_twi_resume_noirq(struct device *dev)
1182{
1183 int ret;
1184
1185 if (!pm_runtime_status_suspended(dev)) {
1186 ret = at91_twi_runtime_resume(dev);
1187 if (ret)
1188 return ret;
1189 }
1190
1191 pm_runtime_mark_last_busy(dev);
1192 pm_request_autosuspend(dev);
1193
1194 return 0;
1195}
1196
1197static const struct dev_pm_ops at91_twi_pm = {
1198 .suspend_noirq = at91_twi_suspend_noirq,
1199 .resume_noirq = at91_twi_resume_noirq,
1200 .runtime_suspend = at91_twi_runtime_suspend,
1201 .runtime_resume = at91_twi_runtime_resume,
1202};
1203
1204#define at91_twi_pm_ops (&at91_twi_pm)
1205#else
1206#define at91_twi_pm_ops NULL
1207#endif
1208
1209static struct platform_driver at91_twi_driver = {
1210 .probe = at91_twi_probe,
1211 .remove = at91_twi_remove,
1212 .id_table = at91_twi_devtypes,
1213 .driver = {
1214 .name = "at91_i2c",
1215 .of_match_table = of_match_ptr(atmel_twi_dt_ids),
1216 .pm = at91_twi_pm_ops,
1217 },
1218};
1219
1220static int __init at91_twi_init(void)
1221{
1222 return platform_driver_register(&at91_twi_driver);
1223}
1224
1225static void __exit at91_twi_exit(void)
1226{
1227 platform_driver_unregister(&at91_twi_driver);
1228}
1229
1230subsys_initcall(at91_twi_init);
1231module_exit(at91_twi_exit);
1232
1233MODULE_AUTHOR("Nikolaus Voss <n.voss@weinmann.de>");
1234MODULE_DESCRIPTION("I2C (TWI) driver for Atmel AT91");
1235MODULE_LICENSE("GPL");
1236MODULE_ALIAS("platform:at91_i2c");
1237