1
2
3
4
5
6
7
8#include <linux/init.h>
9#include <linux/module.h>
10#include <linux/platform_device.h>
11#include <linux/delay.h>
12#include <linux/i2c.h>
13#include <linux/spinlock.h>
14#include <linux/completion.h>
15#include <linux/err.h>
16#include <linux/interrupt.h>
17#include <linux/clk.h>
18#include <linux/io.h>
19
20
21#define NAME "stu300"
22
23
24#define I2C_CR (0x00000000)
25#define I2C_CR_RESET_VALUE (0x00)
26#define I2C_CR_RESET_UMASK (0x00)
27#define I2C_CR_DDC1_ENABLE (0x80)
28#define I2C_CR_TRANS_ENABLE (0x40)
29#define I2C_CR_PERIPHERAL_ENABLE (0x20)
30#define I2C_CR_DDC2B_ENABLE (0x10)
31#define I2C_CR_START_ENABLE (0x08)
32#define I2C_CR_ACK_ENABLE (0x04)
33#define I2C_CR_STOP_ENABLE (0x02)
34#define I2C_CR_INTERRUPT_ENABLE (0x01)
35
36#define I2C_SR1 (0x00000004)
37#define I2C_SR1_RESET_VALUE (0x00)
38#define I2C_SR1_RESET_UMASK (0x00)
39#define I2C_SR1_EVF_IND (0x80)
40#define I2C_SR1_ADD10_IND (0x40)
41#define I2C_SR1_TRA_IND (0x20)
42#define I2C_SR1_BUSY_IND (0x10)
43#define I2C_SR1_BTF_IND (0x08)
44#define I2C_SR1_ADSL_IND (0x04)
45#define I2C_SR1_MSL_IND (0x02)
46#define I2C_SR1_SB_IND (0x01)
47
48#define I2C_SR2 (0x00000008)
49#define I2C_SR2_RESET_VALUE (0x00)
50#define I2C_SR2_RESET_UMASK (0x40)
51#define I2C_SR2_MASK (0xBF)
52#define I2C_SR2_SCLFAL_IND (0x80)
53#define I2C_SR2_ENDAD_IND (0x20)
54#define I2C_SR2_AF_IND (0x10)
55#define I2C_SR2_STOPF_IND (0x08)
56#define I2C_SR2_ARLO_IND (0x04)
57#define I2C_SR2_BERR_IND (0x02)
58#define I2C_SR2_DDC2BF_IND (0x01)
59
60#define I2C_CCR (0x0000000C)
61#define I2C_CCR_RESET_VALUE (0x00)
62#define I2C_CCR_RESET_UMASK (0x00)
63#define I2C_CCR_MASK (0xFF)
64#define I2C_CCR_FMSM (0x80)
65#define I2C_CCR_CC_MASK (0x7F)
66
67#define I2C_OAR1 (0x00000010)
68#define I2C_OAR1_RESET_VALUE (0x00)
69#define I2C_OAR1_RESET_UMASK (0x00)
70#define I2C_OAR1_ADD_MASK (0xFF)
71
72#define I2C_OAR2 (0x00000014)
73#define I2C_OAR2_RESET_VALUE (0x40)
74#define I2C_OAR2_RESET_UMASK (0x19)
75#define I2C_OAR2_MASK (0xE6)
76#define I2C_OAR2_FR_25_10MHZ (0x00)
77#define I2C_OAR2_FR_10_1667MHZ (0x20)
78#define I2C_OAR2_FR_1667_2667MHZ (0x40)
79#define I2C_OAR2_FR_2667_40MHZ (0x60)
80#define I2C_OAR2_FR_40_5333MHZ (0x80)
81#define I2C_OAR2_FR_5333_66MHZ (0xA0)
82#define I2C_OAR2_FR_66_80MHZ (0xC0)
83#define I2C_OAR2_FR_80_100MHZ (0xE0)
84#define I2C_OAR2_FR_MASK (0xE0)
85#define I2C_OAR2_ADD_MASK (0x06)
86
87#define I2C_DR (0x00000018)
88#define I2C_DR_RESET_VALUE (0x00)
89#define I2C_DR_RESET_UMASK (0xFF)
90#define I2C_DR_D_MASK (0xFF)
91
92#define I2C_ECCR (0x0000001C)
93#define I2C_ECCR_RESET_VALUE (0x00)
94#define I2C_ECCR_RESET_UMASK (0xE0)
95#define I2C_ECCR_MASK (0x1F)
96#define I2C_ECCR_CC_MASK (0x1F)
97
98
99
100
101
102
103enum stu300_event {
104 STU300_EVENT_NONE = 0,
105 STU300_EVENT_1,
106 STU300_EVENT_2,
107 STU300_EVENT_3,
108 STU300_EVENT_4,
109 STU300_EVENT_5,
110 STU300_EVENT_6,
111 STU300_EVENT_7,
112 STU300_EVENT_8,
113 STU300_EVENT_9
114};
115
116enum stu300_error {
117 STU300_ERROR_NONE = 0,
118 STU300_ERROR_ACKNOWLEDGE_FAILURE,
119 STU300_ERROR_BUS_ERROR,
120 STU300_ERROR_ARBITRATION_LOST,
121 STU300_ERROR_UNKNOWN
122};
123
124
125#define STU300_TIMEOUT (msecs_to_jiffies(1000))
126
127
128
129
130
131#define NUM_ADDR_RESEND_ATTEMPTS 12
132
133
134static unsigned int scl_frequency = 100000;
135module_param(scl_frequency, uint, 0644);
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154struct stu300_dev {
155 struct platform_device *pdev;
156 struct i2c_adapter adapter;
157 resource_size_t phybase;
158 resource_size_t physize;
159 void __iomem *virtbase;
160 struct clk *clk;
161 int irq;
162 spinlock_t cmd_issue_lock;
163 struct completion cmd_complete;
164 enum stu300_event cmd_event;
165 enum stu300_error cmd_err;
166 unsigned int speed;
167 int msg_index;
168 int msg_len;
169};
170
171
172static int stu300_init_hw(struct stu300_dev *dev);
173
174
175
176
177
178static inline void stu300_wr8(u32 value, void __iomem *address)
179{
180 writel((value << 16) | value, address);
181}
182
183
184
185
186
187
188static inline u32 stu300_r8(void __iomem *address)
189{
190 return readl(address) & 0x000000FFU;
191}
192
193static void stu300_irq_enable(struct stu300_dev *dev)
194{
195 u32 val;
196 val = stu300_r8(dev->virtbase + I2C_CR);
197 val |= I2C_CR_INTERRUPT_ENABLE;
198
199 stu300_wr8(val, dev->virtbase + I2C_CR);
200 stu300_wr8(val, dev->virtbase + I2C_CR);
201}
202
203static void stu300_irq_disable(struct stu300_dev *dev)
204{
205 u32 val;
206 val = stu300_r8(dev->virtbase + I2C_CR);
207 val &= ~I2C_CR_INTERRUPT_ENABLE;
208
209 stu300_wr8(val, dev->virtbase + I2C_CR);
210 stu300_wr8(val, dev->virtbase + I2C_CR);
211}
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226static int stu300_event_occurred(struct stu300_dev *dev,
227 enum stu300_event mr_event) {
228 u32 status1;
229 u32 status2;
230
231
232 status1 = stu300_r8(dev->virtbase + I2C_SR1);
233
234 if (!(status1 & I2C_SR1_EVF_IND))
235
236 return 0;
237
238 status2 = stu300_r8(dev->virtbase + I2C_SR2);
239
240
241 stu300_irq_disable(dev);
242
243
244 if (status2 & I2C_SR2_AF_IND) {
245 dev->cmd_err = STU300_ERROR_ACKNOWLEDGE_FAILURE;
246 return 1;
247 } else if (status2 & I2C_SR2_BERR_IND) {
248 dev->cmd_err = STU300_ERROR_BUS_ERROR;
249 return 1;
250 } else if (status2 & I2C_SR2_ARLO_IND) {
251 dev->cmd_err = STU300_ERROR_ARBITRATION_LOST;
252 return 1;
253 }
254
255 switch (mr_event) {
256 case STU300_EVENT_1:
257 if (status1 & I2C_SR1_ADSL_IND)
258 return 1;
259 break;
260 case STU300_EVENT_2:
261 case STU300_EVENT_3:
262 case STU300_EVENT_7:
263 case STU300_EVENT_8:
264 if (status1 & I2C_SR1_BTF_IND) {
265 return 1;
266 }
267 break;
268 case STU300_EVENT_4:
269 if (status2 & I2C_SR2_STOPF_IND)
270 return 1;
271 break;
272 case STU300_EVENT_5:
273 if (status1 & I2C_SR1_SB_IND)
274
275 return 1;
276 break;
277 case STU300_EVENT_6:
278 if (status2 & I2C_SR2_ENDAD_IND) {
279
280 return 1;
281 }
282 break;
283 case STU300_EVENT_9:
284 if (status1 & I2C_SR1_ADD10_IND)
285 return 1;
286 break;
287 default:
288 break;
289 }
290
291
292
293
294
295 dev->cmd_err = STU300_ERROR_UNKNOWN;
296 dev_err(&dev->pdev->dev,
297 "Unhandled interrupt! %d sr1: 0x%x sr2: 0x%x\n",
298 mr_event, status1, status2);
299 return 0;
300}
301
302static irqreturn_t stu300_irh(int irq, void *data)
303{
304 struct stu300_dev *dev = data;
305 int res;
306
307
308 clk_enable(dev->clk);
309
310
311 spin_lock(&dev->cmd_issue_lock);
312
313 res = stu300_event_occurred(dev, dev->cmd_event);
314 if (res || dev->cmd_err != STU300_ERROR_NONE)
315 complete(&dev->cmd_complete);
316
317 spin_unlock(&dev->cmd_issue_lock);
318
319 clk_disable(dev->clk);
320
321 return IRQ_HANDLED;
322}
323
324
325
326
327
328static int stu300_start_and_await_event(struct stu300_dev *dev,
329 u8 cr_value,
330 enum stu300_event mr_event)
331{
332 int ret;
333
334 if (unlikely(irqs_disabled())) {
335
336 WARN(1, "irqs are disabled, cannot poll for event\n");
337 return -EIO;
338 }
339
340
341 spin_lock_irq(&dev->cmd_issue_lock);
342 init_completion(&dev->cmd_complete);
343 dev->cmd_err = STU300_ERROR_NONE;
344 dev->cmd_event = mr_event;
345 spin_unlock_irq(&dev->cmd_issue_lock);
346
347
348 cr_value |= I2C_CR_INTERRUPT_ENABLE;
349 stu300_wr8(cr_value, dev->virtbase + I2C_CR);
350 ret = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
351 STU300_TIMEOUT);
352 if (ret < 0) {
353 dev_err(&dev->pdev->dev,
354 "wait_for_completion_interruptible_timeout() "
355 "returned %d waiting for event %04x\n", ret, mr_event);
356 return ret;
357 }
358
359 if (ret == 0) {
360 dev_err(&dev->pdev->dev, "controller timed out "
361 "waiting for event %d, reinit hardware\n", mr_event);
362 (void) stu300_init_hw(dev);
363 return -ETIMEDOUT;
364 }
365
366 if (dev->cmd_err != STU300_ERROR_NONE) {
367 dev_err(&dev->pdev->dev, "controller (start) "
368 "error %d waiting for event %d, reinit hardware\n",
369 dev->cmd_err, mr_event);
370 (void) stu300_init_hw(dev);
371 return -EIO;
372 }
373
374 return 0;
375}
376
377
378
379
380
381static int stu300_await_event(struct stu300_dev *dev,
382 enum stu300_event mr_event)
383{
384 int ret;
385
386 if (unlikely(irqs_disabled())) {
387
388 dev_err(&dev->pdev->dev, "irqs are disabled on this "
389 "system!\n");
390 return -EIO;
391 }
392
393
394 spin_lock_irq(&dev->cmd_issue_lock);
395 dev->cmd_err = STU300_ERROR_NONE;
396 dev->cmd_event = mr_event;
397
398 init_completion(&dev->cmd_complete);
399
400
401 stu300_irq_enable(dev);
402
403
404 spin_unlock_irq(&dev->cmd_issue_lock);
405
406 ret = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
407 STU300_TIMEOUT);
408 if (ret < 0) {
409 dev_err(&dev->pdev->dev,
410 "wait_for_completion_interruptible_timeout()"
411 "returned %d waiting for event %04x\n", ret, mr_event);
412 return ret;
413 }
414
415 if (ret == 0) {
416 if (mr_event != STU300_EVENT_6) {
417 dev_err(&dev->pdev->dev, "controller "
418 "timed out waiting for event %d, reinit "
419 "hardware\n", mr_event);
420 (void) stu300_init_hw(dev);
421 }
422 return -ETIMEDOUT;
423 }
424
425 if (dev->cmd_err != STU300_ERROR_NONE) {
426 if (mr_event != STU300_EVENT_6) {
427 dev_err(&dev->pdev->dev, "controller "
428 "error (await_event) %d waiting for event %d, "
429 "reinit hardware\n", dev->cmd_err, mr_event);
430 (void) stu300_init_hw(dev);
431 }
432 return -EIO;
433 }
434
435 return 0;
436}
437
438
439
440
441#define BUSY_RELEASE_ATTEMPTS 10
442static int stu300_wait_while_busy(struct stu300_dev *dev)
443{
444 unsigned long timeout;
445 int i;
446
447 for (i = 0; i < BUSY_RELEASE_ATTEMPTS; i++) {
448 timeout = jiffies + STU300_TIMEOUT;
449
450 while (!time_after(jiffies, timeout)) {
451
452 if ((stu300_r8(dev->virtbase + I2C_SR1) &
453 I2C_SR1_BUSY_IND) == 0)
454 return 0;
455 msleep(1);
456 }
457
458 dev_err(&dev->pdev->dev, "transaction timed out "
459 "waiting for device to be free (not busy). "
460 "Attempt: %d\n", i+1);
461
462 dev_err(&dev->pdev->dev, "base address = "
463 "0x%08x, reinit hardware\n", (u32) dev->virtbase);
464
465 (void) stu300_init_hw(dev);
466 }
467
468 dev_err(&dev->pdev->dev, "giving up after %d attempts "
469 "to reset the bus.\n", BUSY_RELEASE_ATTEMPTS);
470
471 return -ETIMEDOUT;
472}
473
474struct stu300_clkset {
475 unsigned long rate;
476 u32 setting;
477};
478
479static const struct stu300_clkset stu300_clktable[] = {
480 { 0, 0xFFU },
481 { 2500000, I2C_OAR2_FR_25_10MHZ },
482 { 10000000, I2C_OAR2_FR_10_1667MHZ },
483 { 16670000, I2C_OAR2_FR_1667_2667MHZ },
484 { 26670000, I2C_OAR2_FR_2667_40MHZ },
485 { 40000000, I2C_OAR2_FR_40_5333MHZ },
486 { 53330000, I2C_OAR2_FR_5333_66MHZ },
487 { 66000000, I2C_OAR2_FR_66_80MHZ },
488 { 80000000, I2C_OAR2_FR_80_100MHZ },
489 { 100000000, 0xFFU },
490};
491
492
493static int stu300_set_clk(struct stu300_dev *dev, unsigned long clkrate)
494{
495
496 u32 val;
497 int i = 0;
498
499
500 while (i < ARRAY_SIZE(stu300_clktable) &&
501 stu300_clktable[i].rate < clkrate)
502 i++;
503
504 if (stu300_clktable[i].setting == 0xFFU) {
505 dev_err(&dev->pdev->dev, "too %s clock rate requested "
506 "(%lu Hz).\n", i ? "high" : "low", clkrate);
507 return -EINVAL;
508 }
509
510 stu300_wr8(stu300_clktable[i].setting,
511 dev->virtbase + I2C_OAR2);
512
513 dev_dbg(&dev->pdev->dev, "Clock rate %lu Hz, I2C bus speed %d Hz "
514 "virtbase %p\n", clkrate, dev->speed, dev->virtbase);
515
516 if (dev->speed > 100000)
517
518 val = ((clkrate/dev->speed) - 9)/3 + 1;
519 else
520
521 val = ((clkrate/dev->speed) - 7)/2 + 1;
522
523
524 if (val < 0x002) {
525 dev_err(&dev->pdev->dev, "too low clock rate (%lu Hz).\n",
526 clkrate);
527 return -EINVAL;
528 }
529
530
531 if (val & 0xFFFFF000U) {
532 dev_err(&dev->pdev->dev, "too high clock rate (%lu Hz).\n",
533 clkrate);
534 return -EINVAL;
535 }
536
537 if (dev->speed > 100000) {
538
539 stu300_wr8((val & I2C_CCR_CC_MASK) | I2C_CCR_FMSM,
540 dev->virtbase + I2C_CCR);
541 dev_dbg(&dev->pdev->dev, "set clock divider to 0x%08x, "
542 "Fast Mode I2C\n", val);
543 } else {
544
545 stu300_wr8((val & I2C_CCR_CC_MASK),
546 dev->virtbase + I2C_CCR);
547 dev_dbg(&dev->pdev->dev, "set clock divider to "
548 "0x%08x, Standard Mode I2C\n", val);
549 }
550
551
552 stu300_wr8(((val >> 7) & 0x1F),
553 dev->virtbase + I2C_ECCR);
554
555 return 0;
556}
557
558
559static int stu300_init_hw(struct stu300_dev *dev)
560{
561 u32 dummy;
562 unsigned long clkrate;
563 int ret;
564
565
566 stu300_wr8(0x00, dev->virtbase + I2C_CR);
567
568
569
570
571 stu300_wr8(0x00, dev->virtbase + I2C_OAR1);
572
573
574
575
576
577
578
579 clkrate = clk_get_rate(dev->clk);
580 ret = stu300_set_clk(dev, clkrate);
581
582 if (ret)
583 return ret;
584
585
586
587
588 stu300_wr8(I2C_CR_PERIPHERAL_ENABLE,
589 dev->virtbase + I2C_CR);
590 stu300_wr8(I2C_CR_PERIPHERAL_ENABLE,
591 dev->virtbase + I2C_CR);
592
593 dummy = stu300_r8(dev->virtbase + I2C_SR2);
594 dummy = stu300_r8(dev->virtbase + I2C_SR1);
595
596 return 0;
597}
598
599
600
601
602static int stu300_send_address(struct stu300_dev *dev,
603 struct i2c_msg *msg, int resend)
604{
605 u32 val;
606 int ret;
607
608 if (msg->flags & I2C_M_TEN)
609
610 val = (0xf0 | (((u32) msg->addr & 0x300) >> 7)) &
611 I2C_DR_D_MASK;
612 else
613 val = ((msg->addr << 1) & I2C_DR_D_MASK);
614
615 if (msg->flags & I2C_M_RD) {
616
617 val |= 0x01;
618 if (resend)
619 dev_dbg(&dev->pdev->dev, "read resend\n");
620 } else if (resend)
621 dev_dbg(&dev->pdev->dev, "write resend\n");
622 stu300_wr8(val, dev->virtbase + I2C_DR);
623
624
625 if (msg->flags & I2C_M_TEN) {
626 ret = stu300_await_event(dev, STU300_EVENT_9);
627
628
629
630
631 val = msg->addr & I2C_DR_D_MASK;
632
633 stu300_wr8(val, dev->virtbase + I2C_DR);
634 if (ret != 0)
635 return ret;
636 }
637
638
639
640
641 if (resend)
642 dev_dbg(&dev->pdev->dev, "await event 6\n");
643 ret = stu300_await_event(dev, STU300_EVENT_6);
644
645
646
647
648
649 val = stu300_r8(dev->virtbase + I2C_CR);
650 val |= I2C_CR_PERIPHERAL_ENABLE;
651 stu300_wr8(val, dev->virtbase + I2C_CR);
652
653 return ret;
654}
655
656static int stu300_xfer_msg(struct i2c_adapter *adap,
657 struct i2c_msg *msg, int stop)
658{
659 u32 cr;
660 u32 val;
661 u32 i;
662 int ret;
663 int attempts = 0;
664 struct stu300_dev *dev = i2c_get_adapdata(adap);
665
666 clk_enable(dev->clk);
667
668
669 if (0) {
670 dev_dbg(&dev->pdev->dev, "I2C message to: 0x%04x, len: %d, "
671 "flags: 0x%04x, stop: %d\n",
672 msg->addr, msg->len, msg->flags, stop);
673 }
674
675
676 if (msg->len == 0) {
677 ret = -EINVAL;
678 goto exit_disable;
679 }
680
681
682
683
684
685
686
687 do {
688 if (attempts)
689 dev_dbg(&dev->pdev->dev, "wait while busy\n");
690
691 ret = stu300_wait_while_busy(dev);
692 if (ret != 0)
693 goto exit_disable;
694
695 if (attempts)
696 dev_dbg(&dev->pdev->dev, "re-int hw\n");
697
698
699
700
701 ret = stu300_init_hw(dev);
702 if (ret)
703 goto exit_disable;
704
705
706 cr = I2C_CR_PERIPHERAL_ENABLE;
707
708 if (!(msg->flags & I2C_M_NOSTART))
709 cr |= I2C_CR_START_ENABLE;
710 if ((msg->flags & I2C_M_RD) && (msg->len > 1))
711
712 cr |= I2C_CR_ACK_ENABLE;
713
714 if (!(msg->flags & I2C_M_NOSTART)) {
715 if (attempts)
716 dev_dbg(&dev->pdev->dev, "send start event\n");
717 ret = stu300_start_and_await_event(dev, cr,
718 STU300_EVENT_5);
719 }
720
721 if (attempts)
722 dev_dbg(&dev->pdev->dev, "send address\n");
723
724 if (ret == 0)
725
726 ret = stu300_send_address(dev, msg, attempts != 0);
727
728 if (ret != 0) {
729 attempts++;
730 dev_dbg(&dev->pdev->dev, "failed sending address, "
731 "retrying. Attempt: %d msg_index: %d/%d\n",
732 attempts, dev->msg_index, dev->msg_len);
733 }
734
735 } while (ret != 0 && attempts < NUM_ADDR_RESEND_ATTEMPTS);
736
737 if (attempts < NUM_ADDR_RESEND_ATTEMPTS && attempts > 0) {
738 dev_dbg(&dev->pdev->dev, "managed to get address "
739 "through after %d attempts\n", attempts);
740 } else if (attempts == NUM_ADDR_RESEND_ATTEMPTS) {
741 dev_dbg(&dev->pdev->dev, "I give up, tried %d times "
742 "to resend address.\n",
743 NUM_ADDR_RESEND_ATTEMPTS);
744 goto exit_disable;
745 }
746
747
748 if (msg->flags & I2C_M_RD) {
749
750 for (i = 0; i < msg->len; i++) {
751 if (i == msg->len-1) {
752
753
754
755
756 val = I2C_CR_PERIPHERAL_ENABLE;
757
758 if (stop)
759 val |= I2C_CR_STOP_ENABLE;
760
761 stu300_wr8(val,
762 dev->virtbase + I2C_CR);
763 }
764
765 ret = stu300_await_event(dev, STU300_EVENT_7);
766 if (ret != 0)
767 goto exit_disable;
768
769 msg->buf[i] = (u8) stu300_r8(dev->virtbase + I2C_DR);
770 }
771 } else {
772
773 for (i = 0; i < msg->len; i++) {
774
775 stu300_wr8(msg->buf[i],
776 dev->virtbase + I2C_DR);
777
778 ret = stu300_await_event(dev, STU300_EVENT_8);
779
780 if (ret != 0) {
781 dev_err(&dev->pdev->dev, "error awaiting "
782 "event 8 (%d)\n", ret);
783 goto exit_disable;
784 }
785 }
786
787 if (!(msg->flags & I2C_M_IGNORE_NAK)) {
788 if (stu300_r8(dev->virtbase + I2C_SR2) &
789 I2C_SR2_AF_IND) {
790 dev_err(&dev->pdev->dev, "I2C payload "
791 "send returned NAK!\n");
792 ret = -EIO;
793 goto exit_disable;
794 }
795 }
796 if (stop) {
797
798 val = I2C_CR_PERIPHERAL_ENABLE;
799 val |= I2C_CR_STOP_ENABLE;
800 stu300_wr8(val, dev->virtbase + I2C_CR);
801 }
802 }
803
804
805 ret = stu300_wait_while_busy(dev);
806 if (ret != 0) {
807 dev_err(&dev->pdev->dev, "timout waiting for transfer "
808 "to commence.\n");
809 goto exit_disable;
810 }
811
812
813 val = stu300_r8(dev->virtbase + I2C_SR2);
814 val = stu300_r8(dev->virtbase + I2C_SR1);
815 ret = 0;
816
817 exit_disable:
818
819 stu300_wr8(0x00, dev->virtbase + I2C_CR);
820 clk_disable(dev->clk);
821 return ret;
822}
823
824static int stu300_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
825 int num)
826{
827 int ret = -1;
828 int i;
829
830 struct stu300_dev *dev = i2c_get_adapdata(adap);
831 dev->msg_len = num;
832
833 for (i = 0; i < num; i++) {
834
835
836
837
838
839
840
841 dev->msg_index = i;
842
843 ret = stu300_xfer_msg(adap, &msgs[i], (i == (num - 1)));
844
845 if (ret != 0) {
846 num = ret;
847 break;
848 }
849 }
850
851 return num;
852}
853
854static u32 stu300_func(struct i2c_adapter *adap)
855{
856
857 return I2C_FUNC_I2C | I2C_FUNC_10BIT_ADDR;
858}
859
860static const struct i2c_algorithm stu300_algo = {
861 .master_xfer = stu300_xfer,
862 .functionality = stu300_func,
863};
864
865static int __init
866stu300_probe(struct platform_device *pdev)
867{
868 struct stu300_dev *dev;
869 struct i2c_adapter *adap;
870 struct resource *res;
871 int bus_nr;
872 int ret = 0;
873 char clk_name[] = "I2C0";
874
875 dev = kzalloc(sizeof(struct stu300_dev), GFP_KERNEL);
876 if (!dev) {
877 dev_err(&pdev->dev, "could not allocate device struct\n");
878 ret = -ENOMEM;
879 goto err_no_devmem;
880 }
881
882 bus_nr = pdev->id;
883 clk_name[3] += (char)bus_nr;
884 dev->clk = clk_get(&pdev->dev, clk_name);
885 if (IS_ERR(dev->clk)) {
886 ret = PTR_ERR(dev->clk);
887 dev_err(&pdev->dev, "could not retrieve i2c bus clock\n");
888 goto err_no_clk;
889 }
890
891 dev->pdev = pdev;
892 platform_set_drvdata(pdev, dev);
893
894 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
895 if (!res) {
896 ret = -ENOENT;
897 goto err_no_resource;
898 }
899
900 dev->phybase = res->start;
901 dev->physize = resource_size(res);
902
903 if (request_mem_region(dev->phybase, dev->physize,
904 NAME " I/O Area") == NULL) {
905 ret = -EBUSY;
906 goto err_no_ioregion;
907 }
908
909 dev->virtbase = ioremap(dev->phybase, dev->physize);
910 dev_dbg(&pdev->dev, "initialize bus device I2C%d on virtual "
911 "base %p\n", bus_nr, dev->virtbase);
912 if (!dev->virtbase) {
913 ret = -ENOMEM;
914 goto err_no_ioremap;
915 }
916
917 dev->irq = platform_get_irq(pdev, 0);
918 if (request_irq(dev->irq, stu300_irh, IRQF_DISABLED,
919 NAME, dev)) {
920 ret = -EIO;
921 goto err_no_irq;
922 }
923
924 dev->speed = scl_frequency;
925
926 clk_enable(dev->clk);
927 ret = stu300_init_hw(dev);
928 clk_disable(dev->clk);
929
930 if (ret != 0) {
931 dev_err(&dev->pdev->dev, "error initializing hardware.\n");
932 goto err_init_hw;
933 }
934
935
936 spin_lock_init(&dev->cmd_issue_lock);
937 dev->cmd_event = STU300_EVENT_NONE;
938 dev->cmd_err = STU300_ERROR_NONE;
939
940 adap = &dev->adapter;
941 adap->owner = THIS_MODULE;
942
943 adap->class = I2C_CLASS_DDC;
944 strncpy(adap->name, "ST Microelectronics DDC I2C adapter",
945 sizeof(adap->name));
946 adap->nr = bus_nr;
947 adap->algo = &stu300_algo;
948 adap->dev.parent = &pdev->dev;
949 i2c_set_adapdata(adap, dev);
950
951
952 ret = i2c_add_numbered_adapter(adap);
953 if (ret) {
954 dev_err(&dev->pdev->dev, "failure adding ST Micro DDC "
955 "I2C adapter\n");
956 goto err_add_adapter;
957 }
958 return 0;
959
960 err_add_adapter:
961 err_init_hw:
962 free_irq(dev->irq, dev);
963 err_no_irq:
964 iounmap(dev->virtbase);
965 err_no_ioremap:
966 release_mem_region(dev->phybase, dev->physize);
967 err_no_ioregion:
968 platform_set_drvdata(pdev, NULL);
969 err_no_resource:
970 clk_put(dev->clk);
971 err_no_clk:
972 kfree(dev);
973 err_no_devmem:
974 dev_err(&pdev->dev, "failed to add " NAME " adapter: %d\n",
975 pdev->id);
976 return ret;
977}
978
979#ifdef CONFIG_PM
980static int stu300_suspend(struct platform_device *pdev, pm_message_t state)
981{
982 struct stu300_dev *dev = platform_get_drvdata(pdev);
983
984
985 stu300_wr8(0x00, dev->virtbase + I2C_CR);
986 return 0;
987}
988
989static int stu300_resume(struct platform_device *pdev)
990{
991 int ret = 0;
992 struct stu300_dev *dev = platform_get_drvdata(pdev);
993
994 clk_enable(dev->clk);
995 ret = stu300_init_hw(dev);
996 clk_disable(dev->clk);
997
998 if (ret != 0)
999 dev_err(&pdev->dev, "error re-initializing hardware.\n");
1000 return ret;
1001}
1002#else
1003#define stu300_suspend NULL
1004#define stu300_resume NULL
1005#endif
1006
1007static int __exit
1008stu300_remove(struct platform_device *pdev)
1009{
1010 struct stu300_dev *dev = platform_get_drvdata(pdev);
1011
1012 i2c_del_adapter(&dev->adapter);
1013
1014 stu300_wr8(0x00, dev->virtbase + I2C_CR);
1015 free_irq(dev->irq, dev);
1016 iounmap(dev->virtbase);
1017 release_mem_region(dev->phybase, dev->physize);
1018 clk_put(dev->clk);
1019 platform_set_drvdata(pdev, NULL);
1020 kfree(dev);
1021 return 0;
1022}
1023
1024static struct platform_driver stu300_i2c_driver = {
1025 .driver = {
1026 .name = NAME,
1027 .owner = THIS_MODULE,
1028 },
1029 .remove = __exit_p(stu300_remove),
1030 .suspend = stu300_suspend,
1031 .resume = stu300_resume,
1032
1033};
1034
1035static int __init stu300_init(void)
1036{
1037 return platform_driver_probe(&stu300_i2c_driver, stu300_probe);
1038}
1039
1040static void __exit stu300_exit(void)
1041{
1042 platform_driver_unregister(&stu300_i2c_driver);
1043}
1044
1045
1046
1047
1048
1049
1050subsys_initcall(stu300_init);
1051module_exit(stu300_exit);
1052
1053MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
1054MODULE_DESCRIPTION("ST Micro DDC I2C adapter (" NAME ")");
1055MODULE_LICENSE("GPL");
1056MODULE_ALIAS("platform:" NAME);
1057