1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/kernel.h>
20#include <linux/module.h>
21
22#include <linux/i2c.h>
23#include <linux/init.h>
24#include <linux/time.h>
25#include <linux/interrupt.h>
26#include <linux/delay.h>
27#include <linux/errno.h>
28#include <linux/err.h>
29#include <linux/platform_device.h>
30#include <linux/pm_runtime.h>
31#include <linux/clk.h>
32#include <linux/cpufreq.h>
33#include <linux/slab.h>
34#include <linux/io.h>
35#include <linux/of.h>
36#include <linux/of_gpio.h>
37#include <linux/pinctrl/consumer.h>
38#include <linux/mfd/syscon.h>
39#include <linux/regmap.h>
40
41#include <asm/irq.h>
42
43#include <linux/platform_data/i2c-s3c2410.h>
44
45
46
47#define S3C2410_IICCON 0x00
48#define S3C2410_IICSTAT 0x04
49#define S3C2410_IICADD 0x08
50#define S3C2410_IICDS 0x0C
51#define S3C2440_IICLC 0x10
52
53#define S3C2410_IICCON_ACKEN (1 << 7)
54#define S3C2410_IICCON_TXDIV_16 (0 << 6)
55#define S3C2410_IICCON_TXDIV_512 (1 << 6)
56#define S3C2410_IICCON_IRQEN (1 << 5)
57#define S3C2410_IICCON_IRQPEND (1 << 4)
58#define S3C2410_IICCON_SCALE(x) ((x) & 0xf)
59#define S3C2410_IICCON_SCALEMASK (0xf)
60
61#define S3C2410_IICSTAT_MASTER_RX (2 << 6)
62#define S3C2410_IICSTAT_MASTER_TX (3 << 6)
63#define S3C2410_IICSTAT_SLAVE_RX (0 << 6)
64#define S3C2410_IICSTAT_SLAVE_TX (1 << 6)
65#define S3C2410_IICSTAT_MODEMASK (3 << 6)
66
67#define S3C2410_IICSTAT_START (1 << 5)
68#define S3C2410_IICSTAT_BUSBUSY (1 << 5)
69#define S3C2410_IICSTAT_TXRXEN (1 << 4)
70#define S3C2410_IICSTAT_ARBITR (1 << 3)
71#define S3C2410_IICSTAT_ASSLAVE (1 << 2)
72#define S3C2410_IICSTAT_ADDR0 (1 << 1)
73#define S3C2410_IICSTAT_LASTBIT (1 << 0)
74
75#define S3C2410_IICLC_SDA_DELAY0 (0 << 0)
76#define S3C2410_IICLC_SDA_DELAY5 (1 << 0)
77#define S3C2410_IICLC_SDA_DELAY10 (2 << 0)
78#define S3C2410_IICLC_SDA_DELAY15 (3 << 0)
79#define S3C2410_IICLC_SDA_DELAY_MASK (3 << 0)
80
81#define S3C2410_IICLC_FILTER_ON (1 << 2)
82
83
84#define QUIRK_S3C2440 (1 << 0)
85#define QUIRK_HDMIPHY (1 << 1)
86#define QUIRK_NO_GPIO (1 << 2)
87#define QUIRK_POLL (1 << 3)
88
89
90#define S3C2410_IDLE_TIMEOUT 5000
91
92
93#define EXYNOS5_SYS_I2C_CFG 0x0234
94
95
96enum s3c24xx_i2c_state {
97 STATE_IDLE,
98 STATE_START,
99 STATE_READ,
100 STATE_WRITE,
101 STATE_STOP
102};
103
104struct s3c24xx_i2c {
105 wait_queue_head_t wait;
106 kernel_ulong_t quirks;
107 unsigned int suspended:1;
108
109 struct i2c_msg *msg;
110 unsigned int msg_num;
111 unsigned int msg_idx;
112 unsigned int msg_ptr;
113
114 unsigned int tx_setup;
115 unsigned int irq;
116
117 enum s3c24xx_i2c_state state;
118 unsigned long clkrate;
119
120 void __iomem *regs;
121 struct clk *clk;
122 struct device *dev;
123 struct i2c_adapter adap;
124
125 struct s3c2410_platform_i2c *pdata;
126 int gpios[2];
127 struct pinctrl *pctrl;
128#if defined(CONFIG_ARM_S3C24XX_CPUFREQ)
129 struct notifier_block freq_transition;
130#endif
131 struct regmap *sysreg;
132 unsigned int sys_i2c_cfg;
133};
134
135static const struct platform_device_id s3c24xx_driver_ids[] = {
136 {
137 .name = "s3c2410-i2c",
138 .driver_data = 0,
139 }, {
140 .name = "s3c2440-i2c",
141 .driver_data = QUIRK_S3C2440,
142 }, {
143 .name = "s3c2440-hdmiphy-i2c",
144 .driver_data = QUIRK_S3C2440 | QUIRK_HDMIPHY | QUIRK_NO_GPIO,
145 }, { },
146};
147MODULE_DEVICE_TABLE(platform, s3c24xx_driver_ids);
148
149static int i2c_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat);
150
151#ifdef CONFIG_OF
152static const struct of_device_id s3c24xx_i2c_match[] = {
153 { .compatible = "samsung,s3c2410-i2c", .data = (void *)0 },
154 { .compatible = "samsung,s3c2440-i2c", .data = (void *)QUIRK_S3C2440 },
155 { .compatible = "samsung,s3c2440-hdmiphy-i2c",
156 .data = (void *)(QUIRK_S3C2440 | QUIRK_HDMIPHY | QUIRK_NO_GPIO) },
157 { .compatible = "samsung,exynos5440-i2c",
158 .data = (void *)(QUIRK_S3C2440 | QUIRK_NO_GPIO) },
159 { .compatible = "samsung,exynos5-sata-phy-i2c",
160 .data = (void *)(QUIRK_S3C2440 | QUIRK_POLL | QUIRK_NO_GPIO) },
161 {},
162};
163MODULE_DEVICE_TABLE(of, s3c24xx_i2c_match);
164#endif
165
166
167
168
169
170
171static inline kernel_ulong_t s3c24xx_get_device_quirks(struct platform_device *pdev)
172{
173 if (pdev->dev.of_node) {
174 const struct of_device_id *match;
175 match = of_match_node(s3c24xx_i2c_match, pdev->dev.of_node);
176 return (kernel_ulong_t)match->data;
177 }
178
179 return platform_get_device_id(pdev)->driver_data;
180}
181
182
183
184
185
186
187
188static inline void s3c24xx_i2c_master_complete(struct s3c24xx_i2c *i2c, int ret)
189{
190 dev_dbg(i2c->dev, "master_complete %d\n", ret);
191
192 i2c->msg_ptr = 0;
193 i2c->msg = NULL;
194 i2c->msg_idx++;
195 i2c->msg_num = 0;
196 if (ret)
197 i2c->msg_idx = ret;
198
199 if (!(i2c->quirks & QUIRK_POLL))
200 wake_up(&i2c->wait);
201}
202
203static inline void s3c24xx_i2c_disable_ack(struct s3c24xx_i2c *i2c)
204{
205 unsigned long tmp;
206
207 tmp = readl(i2c->regs + S3C2410_IICCON);
208 writel(tmp & ~S3C2410_IICCON_ACKEN, i2c->regs + S3C2410_IICCON);
209}
210
211static inline void s3c24xx_i2c_enable_ack(struct s3c24xx_i2c *i2c)
212{
213 unsigned long tmp;
214
215 tmp = readl(i2c->regs + S3C2410_IICCON);
216 writel(tmp | S3C2410_IICCON_ACKEN, i2c->regs + S3C2410_IICCON);
217}
218
219
220
221static inline void s3c24xx_i2c_disable_irq(struct s3c24xx_i2c *i2c)
222{
223 unsigned long tmp;
224
225 tmp = readl(i2c->regs + S3C2410_IICCON);
226 writel(tmp & ~S3C2410_IICCON_IRQEN, i2c->regs + S3C2410_IICCON);
227}
228
229static inline void s3c24xx_i2c_enable_irq(struct s3c24xx_i2c *i2c)
230{
231 unsigned long tmp;
232
233 tmp = readl(i2c->regs + S3C2410_IICCON);
234 writel(tmp | S3C2410_IICCON_IRQEN, i2c->regs + S3C2410_IICCON);
235}
236
237static bool is_ack(struct s3c24xx_i2c *i2c)
238{
239 int tries;
240
241 for (tries = 50; tries; --tries) {
242 if (readl(i2c->regs + S3C2410_IICCON)
243 & S3C2410_IICCON_IRQPEND) {
244 if (!(readl(i2c->regs + S3C2410_IICSTAT)
245 & S3C2410_IICSTAT_LASTBIT))
246 return true;
247 }
248 usleep_range(1000, 2000);
249 }
250 dev_err(i2c->dev, "ack was not received\n");
251 return false;
252}
253
254
255
256
257
258
259static void s3c24xx_i2c_message_start(struct s3c24xx_i2c *i2c,
260 struct i2c_msg *msg)
261{
262 unsigned int addr = (msg->addr & 0x7f) << 1;
263 unsigned long stat;
264 unsigned long iiccon;
265
266 stat = 0;
267 stat |= S3C2410_IICSTAT_TXRXEN;
268
269 if (msg->flags & I2C_M_RD) {
270 stat |= S3C2410_IICSTAT_MASTER_RX;
271 addr |= 1;
272 } else
273 stat |= S3C2410_IICSTAT_MASTER_TX;
274
275 if (msg->flags & I2C_M_REV_DIR_ADDR)
276 addr ^= 1;
277
278
279 s3c24xx_i2c_enable_ack(i2c);
280
281 iiccon = readl(i2c->regs + S3C2410_IICCON);
282 writel(stat, i2c->regs + S3C2410_IICSTAT);
283
284 dev_dbg(i2c->dev, "START: %08lx to IICSTAT, %02x to DS\n", stat, addr);
285 writeb(addr, i2c->regs + S3C2410_IICDS);
286
287
288
289
290 ndelay(i2c->tx_setup);
291
292 dev_dbg(i2c->dev, "iiccon, %08lx\n", iiccon);
293 writel(iiccon, i2c->regs + S3C2410_IICCON);
294
295 stat |= S3C2410_IICSTAT_START;
296 writel(stat, i2c->regs + S3C2410_IICSTAT);
297
298 if (i2c->quirks & QUIRK_POLL) {
299 while ((i2c->msg_num != 0) && is_ack(i2c)) {
300 i2c_s3c_irq_nextbyte(i2c, stat);
301 stat = readl(i2c->regs + S3C2410_IICSTAT);
302
303 if (stat & S3C2410_IICSTAT_ARBITR)
304 dev_err(i2c->dev, "deal with arbitration loss\n");
305 }
306 }
307}
308
309static inline void s3c24xx_i2c_stop(struct s3c24xx_i2c *i2c, int ret)
310{
311 unsigned long iicstat = readl(i2c->regs + S3C2410_IICSTAT);
312
313 dev_dbg(i2c->dev, "STOP\n");
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349 if (i2c->quirks & QUIRK_HDMIPHY) {
350
351 iicstat &= ~S3C2410_IICSTAT_TXRXEN;
352 } else {
353
354 iicstat &= ~S3C2410_IICSTAT_START;
355 }
356 writel(iicstat, i2c->regs + S3C2410_IICSTAT);
357
358 i2c->state = STATE_STOP;
359
360 s3c24xx_i2c_master_complete(i2c, ret);
361 s3c24xx_i2c_disable_irq(i2c);
362}
363
364
365
366
367
368
369
370
371
372static inline int is_lastmsg(struct s3c24xx_i2c *i2c)
373{
374 return i2c->msg_idx >= (i2c->msg_num - 1);
375}
376
377
378
379
380
381
382static inline int is_msglast(struct s3c24xx_i2c *i2c)
383{
384
385
386
387 if (i2c->msg->flags & I2C_M_RECV_LEN && i2c->msg->len == 1)
388 return 0;
389
390 return i2c->msg_ptr == i2c->msg->len-1;
391}
392
393
394
395
396
397
398static inline int is_msgend(struct s3c24xx_i2c *i2c)
399{
400 return i2c->msg_ptr >= i2c->msg->len;
401}
402
403
404
405
406
407
408static int i2c_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat)
409{
410 unsigned long tmp;
411 unsigned char byte;
412 int ret = 0;
413
414 switch (i2c->state) {
415
416 case STATE_IDLE:
417 dev_err(i2c->dev, "%s: called in STATE_IDLE\n", __func__);
418 goto out;
419
420 case STATE_STOP:
421 dev_err(i2c->dev, "%s: called in STATE_STOP\n", __func__);
422 s3c24xx_i2c_disable_irq(i2c);
423 goto out_ack;
424
425 case STATE_START:
426
427
428
429
430 if (iicstat & S3C2410_IICSTAT_LASTBIT &&
431 !(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
432
433
434 dev_dbg(i2c->dev, "ack was not received\n");
435 s3c24xx_i2c_stop(i2c, -ENXIO);
436 goto out_ack;
437 }
438
439 if (i2c->msg->flags & I2C_M_RD)
440 i2c->state = STATE_READ;
441 else
442 i2c->state = STATE_WRITE;
443
444
445
446
447 if (is_lastmsg(i2c) && i2c->msg->len == 0) {
448 s3c24xx_i2c_stop(i2c, 0);
449 goto out_ack;
450 }
451
452 if (i2c->state == STATE_READ)
453 goto prepare_read;
454
455
456
457
458 case STATE_WRITE:
459
460
461
462
463 if (!(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
464 if (iicstat & S3C2410_IICSTAT_LASTBIT) {
465 dev_dbg(i2c->dev, "WRITE: No Ack\n");
466
467 s3c24xx_i2c_stop(i2c, -ECONNREFUSED);
468 goto out_ack;
469 }
470 }
471
472 retry_write:
473
474 if (!is_msgend(i2c)) {
475 byte = i2c->msg->buf[i2c->msg_ptr++];
476 writeb(byte, i2c->regs + S3C2410_IICDS);
477
478
479
480
481
482
483
484 ndelay(i2c->tx_setup);
485
486 } else if (!is_lastmsg(i2c)) {
487
488
489 dev_dbg(i2c->dev, "WRITE: Next Message\n");
490
491 i2c->msg_ptr = 0;
492 i2c->msg_idx++;
493 i2c->msg++;
494
495
496 if (i2c->msg->flags & I2C_M_NOSTART) {
497
498 if (i2c->msg->flags & I2C_M_RD) {
499
500
501
502
503 s3c24xx_i2c_stop(i2c, -EINVAL);
504 }
505
506 goto retry_write;
507 } else {
508
509 s3c24xx_i2c_message_start(i2c, i2c->msg);
510 i2c->state = STATE_START;
511 }
512
513 } else {
514
515
516 s3c24xx_i2c_stop(i2c, 0);
517 }
518 break;
519
520 case STATE_READ:
521
522
523
524
525
526 byte = readb(i2c->regs + S3C2410_IICDS);
527 i2c->msg->buf[i2c->msg_ptr++] = byte;
528
529
530 if (i2c->msg->flags & I2C_M_RECV_LEN && i2c->msg->len == 1)
531 i2c->msg->len += byte;
532 prepare_read:
533 if (is_msglast(i2c)) {
534
535
536 if (is_lastmsg(i2c))
537 s3c24xx_i2c_disable_ack(i2c);
538
539 } else if (is_msgend(i2c)) {
540
541
542
543 if (is_lastmsg(i2c)) {
544
545 dev_dbg(i2c->dev, "READ: Send Stop\n");
546
547 s3c24xx_i2c_stop(i2c, 0);
548 } else {
549
550 dev_dbg(i2c->dev, "READ: Next Transfer\n");
551
552 i2c->msg_ptr = 0;
553 i2c->msg_idx++;
554 i2c->msg++;
555 }
556 }
557
558 break;
559 }
560
561
562
563 out_ack:
564 tmp = readl(i2c->regs + S3C2410_IICCON);
565 tmp &= ~S3C2410_IICCON_IRQPEND;
566 writel(tmp, i2c->regs + S3C2410_IICCON);
567 out:
568 return ret;
569}
570
571
572
573
574
575
576static irqreturn_t s3c24xx_i2c_irq(int irqno, void *dev_id)
577{
578 struct s3c24xx_i2c *i2c = dev_id;
579 unsigned long status;
580 unsigned long tmp;
581
582 status = readl(i2c->regs + S3C2410_IICSTAT);
583
584 if (status & S3C2410_IICSTAT_ARBITR) {
585
586 dev_err(i2c->dev, "deal with arbitration loss\n");
587 }
588
589 if (i2c->state == STATE_IDLE) {
590 dev_dbg(i2c->dev, "IRQ: error i2c->state == IDLE\n");
591
592 tmp = readl(i2c->regs + S3C2410_IICCON);
593 tmp &= ~S3C2410_IICCON_IRQPEND;
594 writel(tmp, i2c->regs + S3C2410_IICCON);
595 goto out;
596 }
597
598
599
600
601 i2c_s3c_irq_nextbyte(i2c, status);
602
603 out:
604 return IRQ_HANDLED;
605}
606
607
608
609
610
611
612
613
614
615
616static inline void s3c24xx_i2c_disable_bus(struct s3c24xx_i2c *i2c)
617{
618 unsigned long tmp;
619
620
621 tmp = readl(i2c->regs + S3C2410_IICSTAT);
622 tmp &= ~S3C2410_IICSTAT_TXRXEN;
623 writel(tmp, i2c->regs + S3C2410_IICSTAT);
624
625
626 tmp = readl(i2c->regs + S3C2410_IICCON);
627 tmp &= ~(S3C2410_IICCON_IRQEN | S3C2410_IICCON_IRQPEND |
628 S3C2410_IICCON_ACKEN);
629 writel(tmp, i2c->regs + S3C2410_IICCON);
630}
631
632
633
634
635
636
637
638static int s3c24xx_i2c_set_master(struct s3c24xx_i2c *i2c)
639{
640 unsigned long iicstat;
641 int timeout = 400;
642
643 while (timeout-- > 0) {
644 iicstat = readl(i2c->regs + S3C2410_IICSTAT);
645
646 if (!(iicstat & S3C2410_IICSTAT_BUSBUSY))
647 return 0;
648
649 msleep(1);
650 }
651
652 return -ETIMEDOUT;
653}
654
655
656
657
658
659
660static void s3c24xx_i2c_wait_idle(struct s3c24xx_i2c *i2c)
661{
662 unsigned long iicstat;
663 ktime_t start, now;
664 unsigned long delay;
665 int spins;
666
667
668
669 dev_dbg(i2c->dev, "waiting for bus idle\n");
670
671 start = now = ktime_get();
672
673
674
675
676
677
678
679
680
681 spins = 3;
682 iicstat = readl(i2c->regs + S3C2410_IICSTAT);
683 while ((iicstat & S3C2410_IICSTAT_START) && --spins) {
684 cpu_relax();
685 iicstat = readl(i2c->regs + S3C2410_IICSTAT);
686 }
687
688
689
690
691
692
693
694
695 delay = 1;
696 while ((iicstat & S3C2410_IICSTAT_START) &&
697 ktime_us_delta(now, start) < S3C2410_IDLE_TIMEOUT) {
698 usleep_range(delay, 2 * delay);
699 if (delay < S3C2410_IDLE_TIMEOUT / 10)
700 delay <<= 1;
701 now = ktime_get();
702 iicstat = readl(i2c->regs + S3C2410_IICSTAT);
703 }
704
705 if (iicstat & S3C2410_IICSTAT_START)
706 dev_warn(i2c->dev, "timeout waiting for bus idle\n");
707}
708
709
710
711
712
713
714static int s3c24xx_i2c_doxfer(struct s3c24xx_i2c *i2c,
715 struct i2c_msg *msgs, int num)
716{
717 unsigned long timeout;
718 int ret;
719
720 if (i2c->suspended)
721 return -EIO;
722
723 ret = s3c24xx_i2c_set_master(i2c);
724 if (ret != 0) {
725 dev_err(i2c->dev, "cannot get bus (error %d)\n", ret);
726 ret = -EAGAIN;
727 goto out;
728 }
729
730 i2c->msg = msgs;
731 i2c->msg_num = num;
732 i2c->msg_ptr = 0;
733 i2c->msg_idx = 0;
734 i2c->state = STATE_START;
735
736 s3c24xx_i2c_enable_irq(i2c);
737 s3c24xx_i2c_message_start(i2c, msgs);
738
739 if (i2c->quirks & QUIRK_POLL) {
740 ret = i2c->msg_idx;
741
742 if (ret != num)
743 dev_dbg(i2c->dev, "incomplete xfer (%d)\n", ret);
744
745 goto out;
746 }
747
748 timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 5);
749
750 ret = i2c->msg_idx;
751
752
753
754
755 if (timeout == 0)
756 dev_dbg(i2c->dev, "timeout\n");
757 else if (ret != num)
758 dev_dbg(i2c->dev, "incomplete xfer (%d)\n", ret);
759
760
761 if (i2c->quirks & QUIRK_HDMIPHY)
762 goto out;
763
764 s3c24xx_i2c_wait_idle(i2c);
765
766 s3c24xx_i2c_disable_bus(i2c);
767
768 out:
769 i2c->state = STATE_IDLE;
770
771 return ret;
772}
773
774
775
776
777
778
779
780static int s3c24xx_i2c_xfer(struct i2c_adapter *adap,
781 struct i2c_msg *msgs, int num)
782{
783 struct s3c24xx_i2c *i2c = (struct s3c24xx_i2c *)adap->algo_data;
784 int retry;
785 int ret;
786
787 ret = clk_enable(i2c->clk);
788 if (ret)
789 return ret;
790
791 for (retry = 0; retry < adap->retries; retry++) {
792
793 ret = s3c24xx_i2c_doxfer(i2c, msgs, num);
794
795 if (ret != -EAGAIN) {
796 clk_disable(i2c->clk);
797 return ret;
798 }
799
800 dev_dbg(i2c->dev, "Retrying transmission (%d)\n", retry);
801
802 udelay(100);
803 }
804
805 clk_disable(i2c->clk);
806 return -EREMOTEIO;
807}
808
809
810static u32 s3c24xx_i2c_func(struct i2c_adapter *adap)
811{
812 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_NOSTART |
813 I2C_FUNC_PROTOCOL_MANGLING;
814}
815
816
817
818static const struct i2c_algorithm s3c24xx_i2c_algorithm = {
819 .master_xfer = s3c24xx_i2c_xfer,
820 .functionality = s3c24xx_i2c_func,
821};
822
823
824
825
826
827
828static int s3c24xx_i2c_calcdivisor(unsigned long clkin, unsigned int wanted,
829 unsigned int *div1, unsigned int *divs)
830{
831 unsigned int calc_divs = clkin / wanted;
832 unsigned int calc_div1;
833
834 if (calc_divs > (16*16))
835 calc_div1 = 512;
836 else
837 calc_div1 = 16;
838
839 calc_divs += calc_div1-1;
840 calc_divs /= calc_div1;
841
842 if (calc_divs == 0)
843 calc_divs = 1;
844 if (calc_divs > 17)
845 calc_divs = 17;
846
847 *divs = calc_divs;
848 *div1 = calc_div1;
849
850 return clkin / (calc_divs * calc_div1);
851}
852
853
854
855
856
857
858
859
860static int s3c24xx_i2c_clockrate(struct s3c24xx_i2c *i2c, unsigned int *got)
861{
862 struct s3c2410_platform_i2c *pdata = i2c->pdata;
863 unsigned long clkin = clk_get_rate(i2c->clk);
864 unsigned int divs, div1;
865 unsigned long target_frequency;
866 u32 iiccon;
867 int freq;
868
869 i2c->clkrate = clkin;
870 clkin /= 1000;
871
872 dev_dbg(i2c->dev, "pdata desired frequency %lu\n", pdata->frequency);
873
874 target_frequency = pdata->frequency ? pdata->frequency : 100000;
875
876 target_frequency /= 1000;
877
878 freq = s3c24xx_i2c_calcdivisor(clkin, target_frequency, &div1, &divs);
879
880 if (freq > target_frequency) {
881 dev_err(i2c->dev,
882 "Unable to achieve desired frequency %luKHz." \
883 " Lowest achievable %dKHz\n", target_frequency, freq);
884 return -EINVAL;
885 }
886
887 *got = freq;
888
889 iiccon = readl(i2c->regs + S3C2410_IICCON);
890 iiccon &= ~(S3C2410_IICCON_SCALEMASK | S3C2410_IICCON_TXDIV_512);
891 iiccon |= (divs-1);
892
893 if (div1 == 512)
894 iiccon |= S3C2410_IICCON_TXDIV_512;
895
896 if (i2c->quirks & QUIRK_POLL)
897 iiccon |= S3C2410_IICCON_SCALE(2);
898
899 writel(iiccon, i2c->regs + S3C2410_IICCON);
900
901 if (i2c->quirks & QUIRK_S3C2440) {
902 unsigned long sda_delay;
903
904 if (pdata->sda_delay) {
905 sda_delay = clkin * pdata->sda_delay;
906 sda_delay = DIV_ROUND_UP(sda_delay, 1000000);
907 sda_delay = DIV_ROUND_UP(sda_delay, 5);
908 if (sda_delay > 3)
909 sda_delay = 3;
910 sda_delay |= S3C2410_IICLC_FILTER_ON;
911 } else
912 sda_delay = 0;
913
914 dev_dbg(i2c->dev, "IICLC=%08lx\n", sda_delay);
915 writel(sda_delay, i2c->regs + S3C2440_IICLC);
916 }
917
918 return 0;
919}
920
921#if defined(CONFIG_ARM_S3C24XX_CPUFREQ)
922
923#define freq_to_i2c(_n) container_of(_n, struct s3c24xx_i2c, freq_transition)
924
925static int s3c24xx_i2c_cpufreq_transition(struct notifier_block *nb,
926 unsigned long val, void *data)
927{
928 struct s3c24xx_i2c *i2c = freq_to_i2c(nb);
929 unsigned int got;
930 int delta_f;
931 int ret;
932
933 delta_f = clk_get_rate(i2c->clk) - i2c->clkrate;
934
935
936
937
938
939
940 if ((val == CPUFREQ_POSTCHANGE && delta_f < 0) ||
941 (val == CPUFREQ_PRECHANGE && delta_f > 0)) {
942 i2c_lock_adapter(&i2c->adap);
943 ret = s3c24xx_i2c_clockrate(i2c, &got);
944 i2c_unlock_adapter(&i2c->adap);
945
946 if (ret < 0)
947 dev_err(i2c->dev, "cannot find frequency\n");
948 else
949 dev_info(i2c->dev, "setting freq %d\n", got);
950 }
951
952 return 0;
953}
954
955static inline int s3c24xx_i2c_register_cpufreq(struct s3c24xx_i2c *i2c)
956{
957 i2c->freq_transition.notifier_call = s3c24xx_i2c_cpufreq_transition;
958
959 return cpufreq_register_notifier(&i2c->freq_transition,
960 CPUFREQ_TRANSITION_NOTIFIER);
961}
962
963static inline void s3c24xx_i2c_deregister_cpufreq(struct s3c24xx_i2c *i2c)
964{
965 cpufreq_unregister_notifier(&i2c->freq_transition,
966 CPUFREQ_TRANSITION_NOTIFIER);
967}
968
969#else
970static inline int s3c24xx_i2c_register_cpufreq(struct s3c24xx_i2c *i2c)
971{
972 return 0;
973}
974
975static inline void s3c24xx_i2c_deregister_cpufreq(struct s3c24xx_i2c *i2c)
976{
977}
978#endif
979
980#ifdef CONFIG_OF
981static int s3c24xx_i2c_parse_dt_gpio(struct s3c24xx_i2c *i2c)
982{
983 int idx, gpio, ret;
984
985 if (i2c->quirks & QUIRK_NO_GPIO)
986 return 0;
987
988 for (idx = 0; idx < 2; idx++) {
989 gpio = of_get_gpio(i2c->dev->of_node, idx);
990 if (!gpio_is_valid(gpio)) {
991 dev_err(i2c->dev, "invalid gpio[%d]: %d\n", idx, gpio);
992 goto free_gpio;
993 }
994 i2c->gpios[idx] = gpio;
995
996 ret = gpio_request(gpio, "i2c-bus");
997 if (ret) {
998 dev_err(i2c->dev, "gpio [%d] request failed\n", gpio);
999 goto free_gpio;
1000 }
1001 }
1002 return 0;
1003
1004free_gpio:
1005 while (--idx >= 0)
1006 gpio_free(i2c->gpios[idx]);
1007 return -EINVAL;
1008}
1009
1010static void s3c24xx_i2c_dt_gpio_free(struct s3c24xx_i2c *i2c)
1011{
1012 unsigned int idx;
1013
1014 if (i2c->quirks & QUIRK_NO_GPIO)
1015 return;
1016
1017 for (idx = 0; idx < 2; idx++)
1018 gpio_free(i2c->gpios[idx]);
1019}
1020#else
1021static int s3c24xx_i2c_parse_dt_gpio(struct s3c24xx_i2c *i2c)
1022{
1023 return 0;
1024}
1025
1026static void s3c24xx_i2c_dt_gpio_free(struct s3c24xx_i2c *i2c)
1027{
1028}
1029#endif
1030
1031
1032
1033
1034
1035
1036static int s3c24xx_i2c_init(struct s3c24xx_i2c *i2c)
1037{
1038 struct s3c2410_platform_i2c *pdata;
1039 unsigned int freq;
1040
1041
1042
1043 pdata = i2c->pdata;
1044
1045
1046
1047 writeb(pdata->slave_addr, i2c->regs + S3C2410_IICADD);
1048
1049 dev_info(i2c->dev, "slave address 0x%02x\n", pdata->slave_addr);
1050
1051 writel(0, i2c->regs + S3C2410_IICCON);
1052 writel(0, i2c->regs + S3C2410_IICSTAT);
1053
1054
1055
1056 if (s3c24xx_i2c_clockrate(i2c, &freq) != 0) {
1057 dev_err(i2c->dev, "cannot meet bus frequency required\n");
1058 return -EINVAL;
1059 }
1060
1061
1062
1063 dev_info(i2c->dev, "bus frequency set to %d KHz\n", freq);
1064 dev_dbg(i2c->dev, "S3C2410_IICCON=0x%02x\n",
1065 readl(i2c->regs + S3C2410_IICCON));
1066
1067 return 0;
1068}
1069
1070#ifdef CONFIG_OF
1071
1072
1073
1074
1075
1076static void
1077s3c24xx_i2c_parse_dt(struct device_node *np, struct s3c24xx_i2c *i2c)
1078{
1079 struct s3c2410_platform_i2c *pdata = i2c->pdata;
1080 int id;
1081
1082 if (!np)
1083 return;
1084
1085 pdata->bus_num = -1;
1086 of_property_read_u32(np, "samsung,i2c-sda-delay", &pdata->sda_delay);
1087 of_property_read_u32(np, "samsung,i2c-slave-addr", &pdata->slave_addr);
1088 of_property_read_u32(np, "samsung,i2c-max-bus-freq",
1089 (u32 *)&pdata->frequency);
1090
1091
1092
1093
1094
1095
1096
1097
1098 id = of_alias_get_id(np, "i2c");
1099 i2c->sysreg = syscon_regmap_lookup_by_phandle(np,
1100 "samsung,sysreg-phandle");
1101 if (IS_ERR(i2c->sysreg))
1102 return;
1103
1104 regmap_update_bits(i2c->sysreg, EXYNOS5_SYS_I2C_CFG, BIT(id), 0);
1105}
1106#else
1107static void
1108s3c24xx_i2c_parse_dt(struct device_node *np, struct s3c24xx_i2c *i2c)
1109{
1110 return;
1111}
1112#endif
1113
1114
1115
1116
1117
1118
1119static int s3c24xx_i2c_probe(struct platform_device *pdev)
1120{
1121 struct s3c24xx_i2c *i2c;
1122 struct s3c2410_platform_i2c *pdata = NULL;
1123 struct resource *res;
1124 int ret;
1125
1126 if (!pdev->dev.of_node) {
1127 pdata = dev_get_platdata(&pdev->dev);
1128 if (!pdata) {
1129 dev_err(&pdev->dev, "no platform data\n");
1130 return -EINVAL;
1131 }
1132 }
1133
1134 i2c = devm_kzalloc(&pdev->dev, sizeof(struct s3c24xx_i2c), GFP_KERNEL);
1135 if (!i2c)
1136 return -ENOMEM;
1137
1138 i2c->pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
1139 if (!i2c->pdata)
1140 return -ENOMEM;
1141
1142 i2c->quirks = s3c24xx_get_device_quirks(pdev);
1143 i2c->sysreg = ERR_PTR(-ENOENT);
1144 if (pdata)
1145 memcpy(i2c->pdata, pdata, sizeof(*pdata));
1146 else
1147 s3c24xx_i2c_parse_dt(pdev->dev.of_node, i2c);
1148
1149 strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));
1150 i2c->adap.owner = THIS_MODULE;
1151 i2c->adap.algo = &s3c24xx_i2c_algorithm;
1152 i2c->adap.retries = 2;
1153 i2c->adap.class = I2C_CLASS_DEPRECATED;
1154 i2c->tx_setup = 50;
1155
1156 init_waitqueue_head(&i2c->wait);
1157
1158
1159
1160 i2c->dev = &pdev->dev;
1161 i2c->clk = devm_clk_get(&pdev->dev, "i2c");
1162 if (IS_ERR(i2c->clk)) {
1163 dev_err(&pdev->dev, "cannot get clock\n");
1164 return -ENOENT;
1165 }
1166
1167 dev_dbg(&pdev->dev, "clock source %p\n", i2c->clk);
1168
1169
1170
1171
1172 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1173 i2c->regs = devm_ioremap_resource(&pdev->dev, res);
1174
1175 if (IS_ERR(i2c->regs))
1176 return PTR_ERR(i2c->regs);
1177
1178 dev_dbg(&pdev->dev, "registers %p (%p)\n",
1179 i2c->regs, res);
1180
1181
1182
1183 i2c->adap.algo_data = i2c;
1184 i2c->adap.dev.parent = &pdev->dev;
1185
1186 i2c->pctrl = devm_pinctrl_get_select_default(i2c->dev);
1187
1188
1189
1190 if (i2c->pdata->cfg_gpio) {
1191 i2c->pdata->cfg_gpio(to_platform_device(i2c->dev));
1192 } else if (IS_ERR(i2c->pctrl) && s3c24xx_i2c_parse_dt_gpio(i2c)) {
1193 return -EINVAL;
1194 }
1195
1196
1197
1198 clk_prepare_enable(i2c->clk);
1199 ret = s3c24xx_i2c_init(i2c);
1200 clk_disable(i2c->clk);
1201 if (ret != 0) {
1202 dev_err(&pdev->dev, "I2C controller init failed\n");
1203 return ret;
1204 }
1205
1206
1207
1208
1209 if (!(i2c->quirks & QUIRK_POLL)) {
1210 i2c->irq = ret = platform_get_irq(pdev, 0);
1211 if (ret <= 0) {
1212 dev_err(&pdev->dev, "cannot find IRQ\n");
1213 clk_unprepare(i2c->clk);
1214 return ret;
1215 }
1216
1217 ret = devm_request_irq(&pdev->dev, i2c->irq, s3c24xx_i2c_irq, 0,
1218 dev_name(&pdev->dev), i2c);
1219
1220 if (ret != 0) {
1221 dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);
1222 clk_unprepare(i2c->clk);
1223 return ret;
1224 }
1225 }
1226
1227 ret = s3c24xx_i2c_register_cpufreq(i2c);
1228 if (ret < 0) {
1229 dev_err(&pdev->dev, "failed to register cpufreq notifier\n");
1230 clk_unprepare(i2c->clk);
1231 return ret;
1232 }
1233
1234
1235
1236
1237
1238
1239
1240 i2c->adap.nr = i2c->pdata->bus_num;
1241 i2c->adap.dev.of_node = pdev->dev.of_node;
1242
1243 platform_set_drvdata(pdev, i2c);
1244
1245 pm_runtime_enable(&pdev->dev);
1246
1247 ret = i2c_add_numbered_adapter(&i2c->adap);
1248 if (ret < 0) {
1249 dev_err(&pdev->dev, "failed to add bus to i2c core\n");
1250 pm_runtime_disable(&pdev->dev);
1251 s3c24xx_i2c_deregister_cpufreq(i2c);
1252 clk_unprepare(i2c->clk);
1253 return ret;
1254 }
1255
1256 dev_info(&pdev->dev, "%s: S3C I2C adapter\n", dev_name(&i2c->adap.dev));
1257 return 0;
1258}
1259
1260
1261
1262
1263
1264
1265static int s3c24xx_i2c_remove(struct platform_device *pdev)
1266{
1267 struct s3c24xx_i2c *i2c = platform_get_drvdata(pdev);
1268
1269 clk_unprepare(i2c->clk);
1270
1271 pm_runtime_disable(&pdev->dev);
1272
1273 s3c24xx_i2c_deregister_cpufreq(i2c);
1274
1275 i2c_del_adapter(&i2c->adap);
1276
1277 if (pdev->dev.of_node && IS_ERR(i2c->pctrl))
1278 s3c24xx_i2c_dt_gpio_free(i2c);
1279
1280 return 0;
1281}
1282
1283#ifdef CONFIG_PM_SLEEP
1284static int s3c24xx_i2c_suspend_noirq(struct device *dev)
1285{
1286 struct platform_device *pdev = to_platform_device(dev);
1287 struct s3c24xx_i2c *i2c = platform_get_drvdata(pdev);
1288
1289 i2c->suspended = 1;
1290
1291 if (!IS_ERR(i2c->sysreg))
1292 regmap_read(i2c->sysreg, EXYNOS5_SYS_I2C_CFG, &i2c->sys_i2c_cfg);
1293
1294 return 0;
1295}
1296
1297static int s3c24xx_i2c_resume_noirq(struct device *dev)
1298{
1299 struct platform_device *pdev = to_platform_device(dev);
1300 struct s3c24xx_i2c *i2c = platform_get_drvdata(pdev);
1301 int ret;
1302
1303 if (!IS_ERR(i2c->sysreg))
1304 regmap_write(i2c->sysreg, EXYNOS5_SYS_I2C_CFG, i2c->sys_i2c_cfg);
1305
1306 ret = clk_enable(i2c->clk);
1307 if (ret)
1308 return ret;
1309 s3c24xx_i2c_init(i2c);
1310 clk_disable(i2c->clk);
1311 i2c->suspended = 0;
1312
1313 return 0;
1314}
1315#endif
1316
1317#ifdef CONFIG_PM
1318static const struct dev_pm_ops s3c24xx_i2c_dev_pm_ops = {
1319#ifdef CONFIG_PM_SLEEP
1320 .suspend_noirq = s3c24xx_i2c_suspend_noirq,
1321 .resume_noirq = s3c24xx_i2c_resume_noirq,
1322 .freeze_noirq = s3c24xx_i2c_suspend_noirq,
1323 .thaw_noirq = s3c24xx_i2c_resume_noirq,
1324 .poweroff_noirq = s3c24xx_i2c_suspend_noirq,
1325 .restore_noirq = s3c24xx_i2c_resume_noirq,
1326#endif
1327};
1328
1329#define S3C24XX_DEV_PM_OPS (&s3c24xx_i2c_dev_pm_ops)
1330#else
1331#define S3C24XX_DEV_PM_OPS NULL
1332#endif
1333
1334
1335
1336static struct platform_driver s3c24xx_i2c_driver = {
1337 .probe = s3c24xx_i2c_probe,
1338 .remove = s3c24xx_i2c_remove,
1339 .id_table = s3c24xx_driver_ids,
1340 .driver = {
1341 .name = "s3c-i2c",
1342 .pm = S3C24XX_DEV_PM_OPS,
1343 .of_match_table = of_match_ptr(s3c24xx_i2c_match),
1344 },
1345};
1346
1347static int __init i2c_adap_s3c_init(void)
1348{
1349 return platform_driver_register(&s3c24xx_i2c_driver);
1350}
1351subsys_initcall(i2c_adap_s3c_init);
1352
1353static void __exit i2c_adap_s3c_exit(void)
1354{
1355 platform_driver_unregister(&s3c24xx_i2c_driver);
1356}
1357module_exit(i2c_adap_s3c_exit);
1358
1359MODULE_DESCRIPTION("S3C24XX I2C Bus driver");
1360MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
1361MODULE_LICENSE("GPL");
1362