drivers/usb/chipidea/otg_fsm.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * otg_fsm.c - ChipIdea USB IP core OTG FSM driver
   4  *
   5  * Copyright (C) 2014 Freescale Semiconductor, Inc.
   6  *
   7  * Author: Jun Li
   8  */
   9
  10 /*
  11  * This file mainly handles OTG fsm, it includes OTG fsm operations
  12  * for HNP and SRP.
  13  *
  14  * TODO List
  15  * - ADP
  16  * - OTG test device
  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 /* Add for otg: interact with user space app */
  31 static ssize_t
  32 get_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
  47 static ssize_t
  48 set_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                 /* If a_bus_drop is TRUE, a_bus_req can't be set */
  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 }
  78 static DEVICE_ATTR(a_bus_req, S_IRUGO | S_IWUSR, get_a_bus_req, set_a_bus_req);
  79
  80 static ssize_t
  81 get_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
  96 static ssize_t
  97 set_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 }
 118 static DEVICE_ATTR(a_bus_drop, S_IRUGO | S_IWUSR, get_a_bus_drop,
 119                                                 set_a_bus_drop);
 120
 121 static ssize_t
 122 get_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
 137 static ssize_t
 138 set_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 }
 163 static DEVICE_ATTR(b_bus_req, S_IRUGO | S_IWUSR, get_b_bus_req, set_b_bus_req);
 164
 165 static ssize_t
 166 set_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 }
 183 static DEVICE_ATTR(a_clr_err, S_IWUSR, NULL, set_a_clr_err);
 184
 185 static 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
 193 static const struct attribute_group inputs_attr_group = {
 194         .name = "inputs",
 195         .attrs = inputs_attrs,
 196 };
 197
 198 /*
 199  * Keep this list in the same order as timers indexed
 200  * by enum otg_fsm_timer in include/linux/usb/otg-fsm.h
 201  */
 202 static 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  * Add timer to active timer list
 219  */
 220 static 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  * Remove timer from active timer list
 246  */
 247 static 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                         /* No enabled timers after delete it */
 261                         hrtimer_cancel(&ci->otg_fsm_hrtimer);
 262                         ci->next_otg_timer = NUM_OTG_FSM_TIMERS;
 263                 } else {
 264                         /* Find the next timer */
 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 /* OTG FSM timer handlers */
 285 static int a_wait_vrise_tmout(struct ci_hdrc *ci)
 286 {
 287         ci->fsm.a_wait_vrise_tmout = 1;
 288         return 0;
 289 }
 290
 291 static int a_wait_vfall_tmout(struct ci_hdrc *ci)
 292 {
 293         ci->fsm.a_wait_vfall_tmout = 1;
 294         return 0;
 295 }
 296
 297 static int a_wait_bcon_tmout(struct ci_hdrc *ci)
 298 {
 299         ci->fsm.a_wait_bcon_tmout = 1;
 300         return 0;
 301 }
 302
 303 static int a_aidl_bdis_tmout(struct ci_hdrc *ci)
 304 {
 305         ci->fsm.a_aidl_bdis_tmout = 1;
 306         return 0;
 307 }
 308
 309 static int b_ase0_brst_tmout(struct ci_hdrc *ci)
 310 {
 311         ci->fsm.b_ase0_brst_tmout = 1;
 312         return 0;
 313 }
 314
 315 static int a_bidl_adis_tmout(struct ci_hdrc *ci)
 316 {
 317         ci->fsm.a_bidl_adis_tmout = 1;
 318         return 0;
 319 }
 320
 321 static int b_aidl_bdis_tmout(struct ci_hdrc *ci)
 322 {
 323         ci->fsm.a_bus_suspend = 1;
 324         return 0;
 325 }
 326
 327 static int b_se0_srp_tmout(struct ci_hdrc *ci)
 328 {
 329         ci->fsm.b_se0_srp = 1;
 330         return 0;
 331 }
 332
 333 static int b_srp_fail_tmout(struct ci_hdrc *ci)
 334 {
 335         ci->fsm.b_srp_done = 1;
 336         return 1;
 337 }
 338
 339 static 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
 350 static int b_ssend_srp_tmout(struct ci_hdrc *ci)
 351 {
 352         ci->fsm.b_ssend_srp = 1;
 353         /* only vbus fall below B_sess_vld in b_idle state */
 354         if (ci->fsm.otg->state == OTG_STATE_B_IDLE)
 355                 return 0;
 356         else
 357                 return 1;
 358 }
 359
 360 /*
 361  * Keep this list in the same order as timers indexed
 362  * by enum otg_fsm_timer in include/linux/usb/otg-fsm.h
 363  */
 364 static int (*otg_timer_handlers[])(struct ci_hdrc *) = {
 365         a_wait_vrise_tmout,     /* A_WAIT_VRISE */
 366         a_wait_vfall_tmout,     /* A_WAIT_VFALL */
 367         a_wait_bcon_tmout,      /* A_WAIT_BCON */
 368         a_aidl_bdis_tmout,      /* A_AIDL_BDIS */
 369         b_ase0_brst_tmout,      /* B_ASE0_BRST */
 370         a_bidl_adis_tmout,      /* A_BIDL_ADIS */
 371         b_aidl_bdis_tmout,      /* B_AIDL_BDIS */
 372         b_se0_srp_tmout,        /* B_SE0_SRP */
 373         b_srp_fail_tmout,       /* B_SRP_FAIL */
 374         NULL,                   /* A_WAIT_ENUM */
 375         b_data_pls_tmout,       /* B_DATA_PLS */
 376         b_ssend_srp_tmout,      /* B_SSEND_SRP */
 377 };
 378
 379 /*
 380  * Enable the next nearest enabled timer if have
 381  */
 382 static 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         /* Enable the next nearest timer */
 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 /* Initialize timers */
 424 static 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 /* Operations that will be called from OTG Finite State Machine */
 434 /* -------------------------------------------------------------*/
 435 static 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
 444 static 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  * A-device drive vbus: turn on vbus regulator and enable port power
 455  * Data pulse irq should be disabled while vbus is on.
 456  */
 457 static 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                 /* Enable power power */
 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                 /* Disable data pulse irq */
 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  * Control data line by Run Stop bit.
 491  */
 492 static 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  * Generate SOF by host.
 504  * In host mode, controller will automatically send SOF.
 505  * Suspend will block the data on the port.
 506  *
 507  * This is controlled through usbcore by usb autosuspend,
 508  * so the usb device class driver need support autosuspend,
 509  * otherwise the bus suspend will not happen.
 510  */
 511 static 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  * Start SRP pulsing by data-line pulsing,
 532  * no v-bus pulsing followed
 533  */
 534 static void ci_otg_start_pulse(struct otg_fsm *fsm)
 535 {
 536         struct ci_hdrc  *ci = container_of(fsm, struct ci_hdrc, fsm);
 537
 538         /* Hardware Assistant Data pulse */
 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
 545 static 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
 559 static 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
 571 static 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
 582 int ci_otg_fsm_work(struct ci_hdrc *ci)
 583 {
 584         /*
 585          * Don't do fsm transition for B device
 586          * when there is no gadget class driver
 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                          * Further state change for cases:
 597                          * a_idle to b_idle; or
 598                          * a_idle to a_wait_vrise due to ID change(1->0), so
 599                          * B-dev becomes A-dev can try to start new session
 600                          * consequently; or
 601                          * a_idle to a_wait_vrise when power up
 602                          */
 603                         if ((ci->fsm.id) || (ci->id_event) ||
 604                                                 (ci->fsm.power_up)) {
 605                                 ci_otg_queue_work(ci);
 606                         } else {
 607                                 /* Enable data pulse irq */
 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                                  * Further transite to b_periphearl state
 620                                  * when register gadget driver with vbus on
 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  * Update fsm variables in each state if catching expected interrupts,
 636  * called by otg fsm isr.
 637  */
 638 static 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                          * Init a timer to know how long this suspend
 682                          * will continue, if time out, indicates B no longer
 683                          * wants to be host role
 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                         /* if gadget driver is binded */
 703                         if (ci->driver) {
 704                                 /* A device to be peripheral mode */
 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  * ci_otg_irq - otg fsm related irq handling
 729  * and also update otg fsm variable by monitoring usb host and udc
 730  * state change interrupts.
 731  * @ci: ci_hdrc
 732  */
 733 irqreturn_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
 785 void ci_hdrc_otg_fsm_start(struct ci_hdrc *ci)
 786 {
 787         ci_otg_queue_work(ci);
 788 }
 789
 790 int 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         /* Enable A vbus valid irq */
 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                 /* Enable BSV irq */
 836                 hw_write_otgsc(ci, OTGSC_BSVIE, OTGSC_BSVIE);
 837         }
 838
 839         return 0;
 840 }
 841
 842 void ci_hdrc_otg_fsm_remove(struct ci_hdrc *ci)
 843 {
 844         sysfs_remove_group(&ci->dev->kobj, &inputs_attr_group);
 845 }