1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/usb/otg.h>
20#include <linux/usb/gadget.h>
21#include <linux/usb/hcd.h>
22#include <linux/usb/chipidea.h>
23#include <linux/regulator/consumer.h>
24
25#include "ci.h"
26#include "bits.h"
27#include "otg.h"
28#include "otg_fsm.h"
29
30
31static ssize_t
32get_a_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
33{
34 char *next;
35 unsigned size, t;
36 struct ci_hdrc *ci = dev_get_drvdata(dev);
37
38 next = buf;
39 size = PAGE_SIZE;
40 t = scnprintf(next, size, "%d\n", ci->fsm.a_bus_req);
41 size -= t;
42 next += t;
43
44 return PAGE_SIZE - size;
45}
46
47static ssize_t
48set_a_bus_req(struct device *dev, struct device_attribute *attr,
49 const char *buf, size_t count)
50{
51 struct ci_hdrc *ci = dev_get_drvdata(dev);
52
53 if (count > 2)
54 return -1;
55
56 mutex_lock(&ci->fsm.lock);
57 if (buf[0] == '0') {
58 ci->fsm.a_bus_req = 0;
59 } else if (buf[0] == '1') {
60
61 if (ci->fsm.a_bus_drop) {
62 mutex_unlock(&ci->fsm.lock);
63 return count;
64 }
65 ci->fsm.a_bus_req = 1;
66 if (ci->fsm.otg->state == OTG_STATE_A_PERIPHERAL) {
67 ci->gadget.host_request_flag = 1;
68 mutex_unlock(&ci->fsm.lock);
69 return count;
70 }
71 }
72
73 ci_otg_queue_work(ci);
74 mutex_unlock(&ci->fsm.lock);
75
76 return count;
77}
78static DEVICE_ATTR(a_bus_req, S_IRUGO | S_IWUSR, get_a_bus_req, set_a_bus_req);
79
80static ssize_t
81get_a_bus_drop(struct device *dev, struct device_attribute *attr, char *buf)
82{
83 char *next;
84 unsigned size, t;
85 struct ci_hdrc *ci = dev_get_drvdata(dev);
86
87 next = buf;
88 size = PAGE_SIZE;
89 t = scnprintf(next, size, "%d\n", ci->fsm.a_bus_drop);
90 size -= t;
91 next += t;
92
93 return PAGE_SIZE - size;
94}
95
96static ssize_t
97set_a_bus_drop(struct device *dev, struct device_attribute *attr,
98 const char *buf, size_t count)
99{
100 struct ci_hdrc *ci = dev_get_drvdata(dev);
101
102 if (count > 2)
103 return -1;
104
105 mutex_lock(&ci->fsm.lock);
106 if (buf[0] == '0') {
107 ci->fsm.a_bus_drop = 0;
108 } else if (buf[0] == '1') {
109 ci->fsm.a_bus_drop = 1;
110 ci->fsm.a_bus_req = 0;
111 }
112
113 ci_otg_queue_work(ci);
114 mutex_unlock(&ci->fsm.lock);
115
116 return count;
117}
118static DEVICE_ATTR(a_bus_drop, S_IRUGO | S_IWUSR, get_a_bus_drop,
119 set_a_bus_drop);
120
121static ssize_t
122get_b_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
123{
124 char *next;
125 unsigned size, t;
126 struct ci_hdrc *ci = dev_get_drvdata(dev);
127
128 next = buf;
129 size = PAGE_SIZE;
130 t = scnprintf(next, size, "%d\n", ci->fsm.b_bus_req);
131 size -= t;
132 next += t;
133
134 return PAGE_SIZE - size;
135}
136
137static ssize_t
138set_b_bus_req(struct device *dev, struct device_attribute *attr,
139 const char *buf, size_t count)
140{
141 struct ci_hdrc *ci = dev_get_drvdata(dev);
142
143 if (count > 2)
144 return -1;
145
146 mutex_lock(&ci->fsm.lock);
147 if (buf[0] == '0')
148 ci->fsm.b_bus_req = 0;
149 else if (buf[0] == '1') {
150 ci->fsm.b_bus_req = 1;
151 if (ci->fsm.otg->state == OTG_STATE_B_PERIPHERAL) {
152 ci->gadget.host_request_flag = 1;
153 mutex_unlock(&ci->fsm.lock);
154 return count;
155 }
156 }
157
158 ci_otg_queue_work(ci);
159 mutex_unlock(&ci->fsm.lock);
160
161 return count;
162}
163static DEVICE_ATTR(b_bus_req, S_IRUGO | S_IWUSR, get_b_bus_req, set_b_bus_req);
164
165static ssize_t
166set_a_clr_err(struct device *dev, struct device_attribute *attr,
167 const char *buf, size_t count)
168{
169 struct ci_hdrc *ci = dev_get_drvdata(dev);
170
171 if (count > 2)
172 return -1;
173
174 mutex_lock(&ci->fsm.lock);
175 if (buf[0] == '1')
176 ci->fsm.a_clr_err = 1;
177
178 ci_otg_queue_work(ci);
179 mutex_unlock(&ci->fsm.lock);
180
181 return count;
182}
183static DEVICE_ATTR(a_clr_err, S_IWUSR, NULL, set_a_clr_err);
184
185static struct attribute *inputs_attrs[] = {
186 &dev_attr_a_bus_req.attr,
187 &dev_attr_a_bus_drop.attr,
188 &dev_attr_b_bus_req.attr,
189 &dev_attr_a_clr_err.attr,
190 NULL,
191};
192
193static const struct attribute_group inputs_attr_group = {
194 .name = "inputs",
195 .attrs = inputs_attrs,
196};
197
198
199
200
201
202static unsigned otg_timer_ms[] = {
203 TA_WAIT_VRISE,
204 TA_WAIT_VFALL,
205 TA_WAIT_BCON,
206 TA_AIDL_BDIS,
207 TB_ASE0_BRST,
208 TA_BIDL_ADIS,
209 TB_AIDL_BDIS,
210 TB_SE0_SRP,
211 TB_SRP_FAIL,
212 0,
213 TB_DATA_PLS,
214 TB_SSEND_SRP,
215};
216
217
218
219
220static void ci_otg_add_timer(struct ci_hdrc *ci, enum otg_fsm_timer t)
221{
222 unsigned long flags, timer_sec, timer_nsec;
223
224 if (t >= NUM_OTG_FSM_TIMERS)
225 return;
226
227 spin_lock_irqsave(&ci->lock, flags);
228 timer_sec = otg_timer_ms[t] / MSEC_PER_SEC;
229 timer_nsec = (otg_timer_ms[t] % MSEC_PER_SEC) * NSEC_PER_MSEC;
230 ci->hr_timeouts[t] = ktime_add(ktime_get(),
231 ktime_set(timer_sec, timer_nsec));
232 ci->enabled_otg_timer_bits |= (1 << t);
233 if ((ci->next_otg_timer == NUM_OTG_FSM_TIMERS) ||
234 ktime_after(ci->hr_timeouts[ci->next_otg_timer],
235 ci->hr_timeouts[t])) {
236 ci->next_otg_timer = t;
237 hrtimer_start_range_ns(&ci->otg_fsm_hrtimer,
238 ci->hr_timeouts[t], NSEC_PER_MSEC,
239 HRTIMER_MODE_ABS);
240 }
241 spin_unlock_irqrestore(&ci->lock, flags);
242}
243
244
245
246
247static void ci_otg_del_timer(struct ci_hdrc *ci, enum otg_fsm_timer t)
248{
249 unsigned long flags, enabled_timer_bits;
250 enum otg_fsm_timer cur_timer, next_timer = NUM_OTG_FSM_TIMERS;
251
252 if ((t >= NUM_OTG_FSM_TIMERS) ||
253 !(ci->enabled_otg_timer_bits & (1 << t)))
254 return;
255
256 spin_lock_irqsave(&ci->lock, flags);
257 ci->enabled_otg_timer_bits &= ~(1 << t);
258 if (ci->next_otg_timer == t) {
259 if (ci->enabled_otg_timer_bits == 0) {
260
261 hrtimer_cancel(&ci->otg_fsm_hrtimer);
262 ci->next_otg_timer = NUM_OTG_FSM_TIMERS;
263 } else {
264
265 enabled_timer_bits = ci->enabled_otg_timer_bits;
266 for_each_set_bit(cur_timer, &enabled_timer_bits,
267 NUM_OTG_FSM_TIMERS) {
268 if ((next_timer == NUM_OTG_FSM_TIMERS) ||
269 ktime_before(ci->hr_timeouts[next_timer],
270 ci->hr_timeouts[cur_timer]))
271 next_timer = cur_timer;
272 }
273 }
274 }
275 if (next_timer != NUM_OTG_FSM_TIMERS) {
276 ci->next_otg_timer = next_timer;
277 hrtimer_start_range_ns(&ci->otg_fsm_hrtimer,
278 ci->hr_timeouts[next_timer], NSEC_PER_MSEC,
279 HRTIMER_MODE_ABS);
280 }
281 spin_unlock_irqrestore(&ci->lock, flags);
282}
283
284
285static int a_wait_vrise_tmout(struct ci_hdrc *ci)
286{
287 ci->fsm.a_wait_vrise_tmout = 1;
288 return 0;
289}
290
291static int a_wait_vfall_tmout(struct ci_hdrc *ci)
292{
293 ci->fsm.a_wait_vfall_tmout = 1;
294 return 0;
295}
296
297static int a_wait_bcon_tmout(struct ci_hdrc *ci)
298{
299 ci->fsm.a_wait_bcon_tmout = 1;
300 return 0;
301}
302
303static int a_aidl_bdis_tmout(struct ci_hdrc *ci)
304{
305 ci->fsm.a_aidl_bdis_tmout = 1;
306 return 0;
307}
308
309static int b_ase0_brst_tmout(struct ci_hdrc *ci)
310{
311 ci->fsm.b_ase0_brst_tmout = 1;
312 return 0;
313}
314
315static int a_bidl_adis_tmout(struct ci_hdrc *ci)
316{
317 ci->fsm.a_bidl_adis_tmout = 1;
318 return 0;
319}
320
321static int b_aidl_bdis_tmout(struct ci_hdrc *ci)
322{
323 ci->fsm.a_bus_suspend = 1;
324 return 0;
325}
326
327static int b_se0_srp_tmout(struct ci_hdrc *ci)
328{
329 ci->fsm.b_se0_srp = 1;
330 return 0;
331}
332
333static int b_srp_fail_tmout(struct ci_hdrc *ci)
334{
335 ci->fsm.b_srp_done = 1;
336 return 1;
337}
338
339static int b_data_pls_tmout(struct ci_hdrc *ci)
340{
341 ci->fsm.b_srp_done = 1;
342 ci->fsm.b_bus_req = 0;
343 if (ci->fsm.power_up)
344 ci->fsm.power_up = 0;
345 hw_write_otgsc(ci, OTGSC_HABA, 0);
346 pm_runtime_put(ci->dev);
347 return 0;
348}
349
350static int b_ssend_srp_tmout(struct ci_hdrc *ci)
351{
352 ci->fsm.b_ssend_srp = 1;
353
354 if (ci->fsm.otg->state == OTG_STATE_B_IDLE)
355 return 0;
356 else
357 return 1;
358}
359
360
361
362
363
364static int (*otg_timer_handlers[])(struct ci_hdrc *) = {
365 a_wait_vrise_tmout,
366 a_wait_vfall_tmout,
367 a_wait_bcon_tmout,
368 a_aidl_bdis_tmout,
369 b_ase0_brst_tmout,
370 a_bidl_adis_tmout,
371 b_aidl_bdis_tmout,
372 b_se0_srp_tmout,
373 b_srp_fail_tmout,
374 NULL,
375 b_data_pls_tmout,
376 b_ssend_srp_tmout,
377};
378
379
380
381
382static enum hrtimer_restart ci_otg_hrtimer_func(struct hrtimer *t)
383{
384 struct ci_hdrc *ci = container_of(t, struct ci_hdrc, otg_fsm_hrtimer);
385 ktime_t now, *timeout;
386 unsigned long enabled_timer_bits;
387 unsigned long flags;
388 enum otg_fsm_timer cur_timer, next_timer = NUM_OTG_FSM_TIMERS;
389 int ret = -EINVAL;
390
391 spin_lock_irqsave(&ci->lock, flags);
392 enabled_timer_bits = ci->enabled_otg_timer_bits;
393 ci->next_otg_timer = NUM_OTG_FSM_TIMERS;
394
395 now = ktime_get();
396 for_each_set_bit(cur_timer, &enabled_timer_bits, NUM_OTG_FSM_TIMERS) {
397 if (ktime_compare(now, ci->hr_timeouts[cur_timer]) >= 0) {
398 ci->enabled_otg_timer_bits &= ~(1 << cur_timer);
399 if (otg_timer_handlers[cur_timer])
400 ret = otg_timer_handlers[cur_timer](ci);
401 } else {
402 if ((next_timer == NUM_OTG_FSM_TIMERS) ||
403 ktime_before(ci->hr_timeouts[cur_timer],
404 ci->hr_timeouts[next_timer]))
405 next_timer = cur_timer;
406 }
407 }
408
409 if (next_timer < NUM_OTG_FSM_TIMERS) {
410 timeout = &ci->hr_timeouts[next_timer];
411 hrtimer_start_range_ns(&ci->otg_fsm_hrtimer, *timeout,
412 NSEC_PER_MSEC, HRTIMER_MODE_ABS);
413 ci->next_otg_timer = next_timer;
414 }
415 spin_unlock_irqrestore(&ci->lock, flags);
416
417 if (!ret)
418 ci_otg_queue_work(ci);
419
420 return HRTIMER_NORESTART;
421}
422
423
424static int ci_otg_init_timers(struct ci_hdrc *ci)
425{
426 hrtimer_init(&ci->otg_fsm_hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
427 ci->otg_fsm_hrtimer.function = ci_otg_hrtimer_func;
428
429 return 0;
430}
431
432
433
434
435static void ci_otg_fsm_add_timer(struct otg_fsm *fsm, enum otg_fsm_timer t)
436{
437 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm);
438
439 if (t < NUM_OTG_FSM_TIMERS)
440 ci_otg_add_timer(ci, t);
441 return;
442}
443
444static void ci_otg_fsm_del_timer(struct otg_fsm *fsm, enum otg_fsm_timer t)
445{
446 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm);
447
448 if (t < NUM_OTG_FSM_TIMERS)
449 ci_otg_del_timer(ci, t);
450 return;
451}
452
453
454
455
456
457static void ci_otg_drv_vbus(struct otg_fsm *fsm, int on)
458{
459 int ret;
460 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm);
461
462 if (on) {
463
464 hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_PP,
465 PORTSC_PP);
466 if (ci->platdata->reg_vbus) {
467 ret = regulator_enable(ci->platdata->reg_vbus);
468 if (ret) {
469 dev_err(ci->dev,
470 "Failed to enable vbus regulator, ret=%d\n",
471 ret);
472 return;
473 }
474 }
475
476 hw_write_otgsc(ci, OTGSC_DPIE, 0);
477
478 fsm->a_srp_det = 0;
479 fsm->power_up = 0;
480 } else {
481 if (ci->platdata->reg_vbus)
482 regulator_disable(ci->platdata->reg_vbus);
483
484 fsm->a_bus_drop = 1;
485 fsm->a_bus_req = 0;
486 }
487}
488
489
490
491
492static void ci_otg_loc_conn(struct otg_fsm *fsm, int on)
493{
494 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm);
495
496 if (on)
497 hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
498 else
499 hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
500}
501
502
503
504
505
506
507
508
509
510
511static void ci_otg_loc_sof(struct otg_fsm *fsm, int on)
512{
513 struct usb_device *udev;
514
515 if (!fsm->otg->host)
516 return;
517
518 udev = usb_hub_find_child(fsm->otg->host->root_hub, 1);
519 if (!udev)
520 return;
521
522 if (on) {
523 usb_disable_autosuspend(udev);
524 } else {
525 pm_runtime_set_autosuspend_delay(&udev->dev, 0);
526 usb_enable_autosuspend(udev);
527 }
528}
529
530
531
532
533
534static void ci_otg_start_pulse(struct otg_fsm *fsm)
535{
536 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm);
537
538
539 hw_write_otgsc(ci, OTGSC_HADP, OTGSC_HADP);
540
541 pm_runtime_get(ci->dev);
542 ci_otg_add_timer(ci, B_DATA_PLS);
543}
544
545static int ci_otg_start_host(struct otg_fsm *fsm, int on)
546{
547 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm);
548
549 if (on) {
550 ci_role_stop(ci);
551 ci_role_start(ci, CI_ROLE_HOST);
552 } else {
553 ci_role_stop(ci);
554 ci_role_start(ci, CI_ROLE_GADGET);
555 }
556 return 0;
557}
558
559static int ci_otg_start_gadget(struct otg_fsm *fsm, int on)
560{
561 struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm);
562
563 if (on)
564 usb_gadget_vbus_connect(&ci->gadget);
565 else
566 usb_gadget_vbus_disconnect(&ci->gadget);
567
568 return 0;
569}
570
571static struct otg_fsm_ops ci_otg_ops = {
572 .drv_vbus = ci_otg_drv_vbus,
573 .loc_conn = ci_otg_loc_conn,
574 .loc_sof = ci_otg_loc_sof,
575 .start_pulse = ci_otg_start_pulse,
576 .add_timer = ci_otg_fsm_add_timer,
577 .del_timer = ci_otg_fsm_del_timer,
578 .start_host = ci_otg_start_host,
579 .start_gadget = ci_otg_start_gadget,
580};
581
582int ci_otg_fsm_work(struct ci_hdrc *ci)
583{
584
585
586
587
588 if (ci->fsm.id && !(ci->driver) &&
589 ci->fsm.otg->state < OTG_STATE_A_IDLE)
590 return 0;
591
592 pm_runtime_get_sync(ci->dev);
593 if (otg_statemachine(&ci->fsm)) {
594 if (ci->fsm.otg->state == OTG_STATE_A_IDLE) {
595
596
597
598
599
600
601
602
603 if ((ci->fsm.id) || (ci->id_event) ||
604 (ci->fsm.power_up)) {
605 ci_otg_queue_work(ci);
606 } else {
607
608 hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS |
609 PORTSC_PP, 0);
610 hw_write_otgsc(ci, OTGSC_DPIS, OTGSC_DPIS);
611 hw_write_otgsc(ci, OTGSC_DPIE, OTGSC_DPIE);
612 }
613 if (ci->id_event)
614 ci->id_event = false;
615 } else if (ci->fsm.otg->state == OTG_STATE_B_IDLE) {
616 if (ci->fsm.b_sess_vld) {
617 ci->fsm.power_up = 0;
618
619
620
621
622 ci_otg_queue_work(ci);
623 }
624 } else if (ci->fsm.otg->state == OTG_STATE_A_HOST) {
625 pm_runtime_mark_last_busy(ci->dev);
626 pm_runtime_put_autosuspend(ci->dev);
627 return 0;
628 }
629 }
630 pm_runtime_put_sync(ci->dev);
631 return 0;
632}
633
634
635
636
637
638static void ci_otg_fsm_event(struct ci_hdrc *ci)
639{
640 u32 intr_sts, otg_bsess_vld, port_conn;
641 struct otg_fsm *fsm = &ci->fsm;
642
643 intr_sts = hw_read_intr_status(ci);
644 otg_bsess_vld = hw_read_otgsc(ci, OTGSC_BSV);
645 port_conn = hw_read(ci, OP_PORTSC, PORTSC_CCS);
646
647 switch (ci->fsm.otg->state) {
648 case OTG_STATE_A_WAIT_BCON:
649 if (port_conn) {
650 fsm->b_conn = 1;
651 fsm->a_bus_req = 1;
652 ci_otg_queue_work(ci);
653 }
654 break;
655 case OTG_STATE_B_IDLE:
656 if (otg_bsess_vld && (intr_sts & USBi_PCI) && port_conn) {
657 fsm->b_sess_vld = 1;
658 ci_otg_queue_work(ci);
659 }
660 break;
661 case OTG_STATE_B_PERIPHERAL:
662 if ((intr_sts & USBi_SLI) && port_conn && otg_bsess_vld) {
663 ci_otg_add_timer(ci, B_AIDL_BDIS);
664 } else if (intr_sts & USBi_PCI) {
665 ci_otg_del_timer(ci, B_AIDL_BDIS);
666 if (fsm->a_bus_suspend == 1)
667 fsm->a_bus_suspend = 0;
668 }
669 break;
670 case OTG_STATE_B_HOST:
671 if ((intr_sts & USBi_PCI) && !port_conn) {
672 fsm->a_conn = 0;
673 fsm->b_bus_req = 0;
674 ci_otg_queue_work(ci);
675 }
676 break;
677 case OTG_STATE_A_PERIPHERAL:
678 if (intr_sts & USBi_SLI) {
679 fsm->b_bus_suspend = 1;
680
681
682
683
684
685 ci_otg_add_timer(ci, A_BIDL_ADIS);
686 }
687
688 if (intr_sts & USBi_URI)
689 ci_otg_del_timer(ci, A_BIDL_ADIS);
690
691 if (intr_sts & USBi_PCI) {
692 if (fsm->b_bus_suspend == 1) {
693 ci_otg_del_timer(ci, A_BIDL_ADIS);
694 fsm->b_bus_suspend = 0;
695 }
696 }
697 break;
698 case OTG_STATE_A_SUSPEND:
699 if ((intr_sts & USBi_PCI) && !port_conn) {
700 fsm->b_conn = 0;
701
702
703 if (ci->driver) {
704
705 ci->gadget.is_a_peripheral = 1;
706 }
707 ci_otg_queue_work(ci);
708 }
709 break;
710 case OTG_STATE_A_HOST:
711 if ((intr_sts & USBi_PCI) && !port_conn) {
712 fsm->b_conn = 0;
713 ci_otg_queue_work(ci);
714 }
715 break;
716 case OTG_STATE_B_WAIT_ACON:
717 if ((intr_sts & USBi_PCI) && port_conn) {
718 fsm->a_conn = 1;
719 ci_otg_queue_work(ci);
720 }
721 break;
722 default:
723 break;
724 }
725}
726
727
728
729
730
731
732
733irqreturn_t ci_otg_fsm_irq(struct ci_hdrc *ci)
734{
735 irqreturn_t retval = IRQ_NONE;
736 u32 otgsc, otg_int_src = 0;
737 struct otg_fsm *fsm = &ci->fsm;
738
739 otgsc = hw_read_otgsc(ci, ~0);
740 otg_int_src = otgsc & OTGSC_INT_STATUS_BITS & (otgsc >> 8);
741 fsm->id = (otgsc & OTGSC_ID) ? 1 : 0;
742
743 if (otg_int_src) {
744 if (otg_int_src & OTGSC_DPIS) {
745 hw_write_otgsc(ci, OTGSC_DPIS, OTGSC_DPIS);
746 fsm->a_srp_det = 1;
747 fsm->a_bus_drop = 0;
748 } else if (otg_int_src & OTGSC_IDIS) {
749 hw_write_otgsc(ci, OTGSC_IDIS, OTGSC_IDIS);
750 if (fsm->id == 0) {
751 fsm->a_bus_drop = 0;
752 fsm->a_bus_req = 1;
753 ci->id_event = true;
754 }
755 } else if (otg_int_src & OTGSC_BSVIS) {
756 hw_write_otgsc(ci, OTGSC_BSVIS, OTGSC_BSVIS);
757 if (otgsc & OTGSC_BSV) {
758 fsm->b_sess_vld = 1;
759 ci_otg_del_timer(ci, B_SSEND_SRP);
760 ci_otg_del_timer(ci, B_SRP_FAIL);
761 fsm->b_ssend_srp = 0;
762 } else {
763 fsm->b_sess_vld = 0;
764 if (fsm->id)
765 ci_otg_add_timer(ci, B_SSEND_SRP);
766 }
767 } else if (otg_int_src & OTGSC_AVVIS) {
768 hw_write_otgsc(ci, OTGSC_AVVIS, OTGSC_AVVIS);
769 if (otgsc & OTGSC_AVV) {
770 fsm->a_vbus_vld = 1;
771 } else {
772 fsm->a_vbus_vld = 0;
773 fsm->b_conn = 0;
774 }
775 }
776 ci_otg_queue_work(ci);
777 return IRQ_HANDLED;
778 }
779
780 ci_otg_fsm_event(ci);
781
782 return retval;
783}
784
785void ci_hdrc_otg_fsm_start(struct ci_hdrc *ci)
786{
787 ci_otg_queue_work(ci);
788}
789
790int ci_hdrc_otg_fsm_init(struct ci_hdrc *ci)
791{
792 int retval = 0;
793
794 if (ci->phy)
795 ci->otg.phy = ci->phy;
796 else
797 ci->otg.usb_phy = ci->usb_phy;
798
799 ci->otg.gadget = &ci->gadget;
800 ci->fsm.otg = &ci->otg;
801 ci->fsm.power_up = 1;
802 ci->fsm.id = hw_read_otgsc(ci, OTGSC_ID) ? 1 : 0;
803 ci->fsm.otg->state = OTG_STATE_UNDEFINED;
804 ci->fsm.ops = &ci_otg_ops;
805 ci->gadget.hnp_polling_support = 1;
806 ci->fsm.host_req_flag = devm_kzalloc(ci->dev, 1, GFP_KERNEL);
807 if (!ci->fsm.host_req_flag)
808 return -ENOMEM;
809
810 mutex_init(&ci->fsm.lock);
811
812 retval = ci_otg_init_timers(ci);
813 if (retval) {
814 dev_err(ci->dev, "Couldn't init OTG timers\n");
815 return retval;
816 }
817 ci->enabled_otg_timer_bits = 0;
818 ci->next_otg_timer = NUM_OTG_FSM_TIMERS;
819
820 retval = sysfs_create_group(&ci->dev->kobj, &inputs_attr_group);
821 if (retval < 0) {
822 dev_dbg(ci->dev,
823 "Can't register sysfs attr group: %d\n", retval);
824 return retval;
825 }
826
827
828 hw_write_otgsc(ci, OTGSC_AVVIE, OTGSC_AVVIE);
829
830 if (ci->fsm.id) {
831 ci->fsm.b_ssend_srp =
832 hw_read_otgsc(ci, OTGSC_BSV) ? 0 : 1;
833 ci->fsm.b_sess_vld =
834 hw_read_otgsc(ci, OTGSC_BSV) ? 1 : 0;
835
836 hw_write_otgsc(ci, OTGSC_BSVIE, OTGSC_BSVIE);
837 }
838
839 return 0;
840}
841
842void ci_hdrc_otg_fsm_remove(struct ci_hdrc *ci)
843{
844 sysfs_remove_group(&ci->dev->kobj, &inputs_attr_group);
845}
846
