mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
844 lines
19 KiB
844 lines
19 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* otg_fsm.c - ChipIdea USB IP core OTG FSM driver |
|
* |
|
* Copyright (C) 2014 Freescale Semiconductor, Inc. |
|
* |
|
* Author: Jun Li |
|
*/ |
|
|
|
/* |
|
* This file mainly handles OTG fsm, it includes OTG fsm operations |
|
* for HNP and SRP. |
|
* |
|
* TODO List |
|
* - ADP |
|
* - OTG test device |
|
*/ |
|
|
|
#include <linux/usb/otg.h> |
|
#include <linux/usb/gadget.h> |
|
#include <linux/usb/hcd.h> |
|
#include <linux/usb/chipidea.h> |
|
#include <linux/regulator/consumer.h> |
|
|
|
#include "ci.h" |
|
#include "bits.h" |
|
#include "otg.h" |
|
#include "otg_fsm.h" |
|
|
|
/* Add for otg: interact with user space app */ |
|
static ssize_t |
|
a_bus_req_show(struct device *dev, struct device_attribute *attr, char *buf) |
|
{ |
|
char *next; |
|
unsigned size, t; |
|
struct ci_hdrc *ci = dev_get_drvdata(dev); |
|
|
|
next = buf; |
|
size = PAGE_SIZE; |
|
t = scnprintf(next, size, "%d\n", ci->fsm.a_bus_req); |
|
size -= t; |
|
next += t; |
|
|
|
return PAGE_SIZE - size; |
|
} |
|
|
|
static ssize_t |
|
a_bus_req_store(struct device *dev, struct device_attribute *attr, |
|
const char *buf, size_t count) |
|
{ |
|
struct ci_hdrc *ci = dev_get_drvdata(dev); |
|
|
|
if (count > 2) |
|
return -1; |
|
|
|
mutex_lock(&ci->fsm.lock); |
|
if (buf[0] == '0') { |
|
ci->fsm.a_bus_req = 0; |
|
} else if (buf[0] == '1') { |
|
/* If a_bus_drop is TRUE, a_bus_req can't be set */ |
|
if (ci->fsm.a_bus_drop) { |
|
mutex_unlock(&ci->fsm.lock); |
|
return count; |
|
} |
|
ci->fsm.a_bus_req = 1; |
|
if (ci->fsm.otg->state == OTG_STATE_A_PERIPHERAL) { |
|
ci->gadget.host_request_flag = 1; |
|
mutex_unlock(&ci->fsm.lock); |
|
return count; |
|
} |
|
} |
|
|
|
ci_otg_queue_work(ci); |
|
mutex_unlock(&ci->fsm.lock); |
|
|
|
return count; |
|
} |
|
static DEVICE_ATTR_RW(a_bus_req); |
|
|
|
static ssize_t |
|
a_bus_drop_show(struct device *dev, struct device_attribute *attr, char *buf) |
|
{ |
|
char *next; |
|
unsigned size, t; |
|
struct ci_hdrc *ci = dev_get_drvdata(dev); |
|
|
|
next = buf; |
|
size = PAGE_SIZE; |
|
t = scnprintf(next, size, "%d\n", ci->fsm.a_bus_drop); |
|
size -= t; |
|
next += t; |
|
|
|
return PAGE_SIZE - size; |
|
} |
|
|
|
static ssize_t |
|
a_bus_drop_store(struct device *dev, struct device_attribute *attr, |
|
const char *buf, size_t count) |
|
{ |
|
struct ci_hdrc *ci = dev_get_drvdata(dev); |
|
|
|
if (count > 2) |
|
return -1; |
|
|
|
mutex_lock(&ci->fsm.lock); |
|
if (buf[0] == '0') { |
|
ci->fsm.a_bus_drop = 0; |
|
} else if (buf[0] == '1') { |
|
ci->fsm.a_bus_drop = 1; |
|
ci->fsm.a_bus_req = 0; |
|
} |
|
|
|
ci_otg_queue_work(ci); |
|
mutex_unlock(&ci->fsm.lock); |
|
|
|
return count; |
|
} |
|
static DEVICE_ATTR_RW(a_bus_drop); |
|
|
|
static ssize_t |
|
b_bus_req_show(struct device *dev, struct device_attribute *attr, char *buf) |
|
{ |
|
char *next; |
|
unsigned size, t; |
|
struct ci_hdrc *ci = dev_get_drvdata(dev); |
|
|
|
next = buf; |
|
size = PAGE_SIZE; |
|
t = scnprintf(next, size, "%d\n", ci->fsm.b_bus_req); |
|
size -= t; |
|
next += t; |
|
|
|
return PAGE_SIZE - size; |
|
} |
|
|
|
static ssize_t |
|
b_bus_req_store(struct device *dev, struct device_attribute *attr, |
|
const char *buf, size_t count) |
|
{ |
|
struct ci_hdrc *ci = dev_get_drvdata(dev); |
|
|
|
if (count > 2) |
|
return -1; |
|
|
|
mutex_lock(&ci->fsm.lock); |
|
if (buf[0] == '0') |
|
ci->fsm.b_bus_req = 0; |
|
else if (buf[0] == '1') { |
|
ci->fsm.b_bus_req = 1; |
|
if (ci->fsm.otg->state == OTG_STATE_B_PERIPHERAL) { |
|
ci->gadget.host_request_flag = 1; |
|
mutex_unlock(&ci->fsm.lock); |
|
return count; |
|
} |
|
} |
|
|
|
ci_otg_queue_work(ci); |
|
mutex_unlock(&ci->fsm.lock); |
|
|
|
return count; |
|
} |
|
static DEVICE_ATTR_RW(b_bus_req); |
|
|
|
static ssize_t |
|
a_clr_err_store(struct device *dev, struct device_attribute *attr, |
|
const char *buf, size_t count) |
|
{ |
|
struct ci_hdrc *ci = dev_get_drvdata(dev); |
|
|
|
if (count > 2) |
|
return -1; |
|
|
|
mutex_lock(&ci->fsm.lock); |
|
if (buf[0] == '1') |
|
ci->fsm.a_clr_err = 1; |
|
|
|
ci_otg_queue_work(ci); |
|
mutex_unlock(&ci->fsm.lock); |
|
|
|
return count; |
|
} |
|
static DEVICE_ATTR_WO(a_clr_err); |
|
|
|
static struct attribute *inputs_attrs[] = { |
|
&dev_attr_a_bus_req.attr, |
|
&dev_attr_a_bus_drop.attr, |
|
&dev_attr_b_bus_req.attr, |
|
&dev_attr_a_clr_err.attr, |
|
NULL, |
|
}; |
|
|
|
static const struct attribute_group inputs_attr_group = { |
|
.name = "inputs", |
|
.attrs = inputs_attrs, |
|
}; |
|
|
|
/* |
|
* Keep this list in the same order as timers indexed |
|
* by enum otg_fsm_timer in include/linux/usb/otg-fsm.h |
|
*/ |
|
static unsigned otg_timer_ms[] = { |
|
TA_WAIT_VRISE, |
|
TA_WAIT_VFALL, |
|
TA_WAIT_BCON, |
|
TA_AIDL_BDIS, |
|
TB_ASE0_BRST, |
|
TA_BIDL_ADIS, |
|
TB_AIDL_BDIS, |
|
TB_SE0_SRP, |
|
TB_SRP_FAIL, |
|
0, |
|
TB_DATA_PLS, |
|
TB_SSEND_SRP, |
|
}; |
|
|
|
/* |
|
* Add timer to active timer list |
|
*/ |
|
static void ci_otg_add_timer(struct ci_hdrc *ci, enum otg_fsm_timer t) |
|
{ |
|
unsigned long flags, timer_sec, timer_nsec; |
|
|
|
if (t >= NUM_OTG_FSM_TIMERS) |
|
return; |
|
|
|
spin_lock_irqsave(&ci->lock, flags); |
|
timer_sec = otg_timer_ms[t] / MSEC_PER_SEC; |
|
timer_nsec = (otg_timer_ms[t] % MSEC_PER_SEC) * NSEC_PER_MSEC; |
|
ci->hr_timeouts[t] = ktime_add(ktime_get(), |
|
ktime_set(timer_sec, timer_nsec)); |
|
ci->enabled_otg_timer_bits |= (1 << t); |
|
if ((ci->next_otg_timer == NUM_OTG_FSM_TIMERS) || |
|
ktime_after(ci->hr_timeouts[ci->next_otg_timer], |
|
ci->hr_timeouts[t])) { |
|
ci->next_otg_timer = t; |
|
hrtimer_start_range_ns(&ci->otg_fsm_hrtimer, |
|
ci->hr_timeouts[t], NSEC_PER_MSEC, |
|
HRTIMER_MODE_ABS); |
|
} |
|
spin_unlock_irqrestore(&ci->lock, flags); |
|
} |
|
|
|
/* |
|
* Remove timer from active timer list |
|
*/ |
|
static void ci_otg_del_timer(struct ci_hdrc *ci, enum otg_fsm_timer t) |
|
{ |
|
unsigned long flags, enabled_timer_bits; |
|
enum otg_fsm_timer cur_timer, next_timer = NUM_OTG_FSM_TIMERS; |
|
|
|
if ((t >= NUM_OTG_FSM_TIMERS) || |
|
!(ci->enabled_otg_timer_bits & (1 << t))) |
|
return; |
|
|
|
spin_lock_irqsave(&ci->lock, flags); |
|
ci->enabled_otg_timer_bits &= ~(1 << t); |
|
if (ci->next_otg_timer == t) { |
|
if (ci->enabled_otg_timer_bits == 0) { |
|
/* No enabled timers after delete it */ |
|
hrtimer_cancel(&ci->otg_fsm_hrtimer); |
|
ci->next_otg_timer = NUM_OTG_FSM_TIMERS; |
|
} else { |
|
/* Find the next timer */ |
|
enabled_timer_bits = ci->enabled_otg_timer_bits; |
|
for_each_set_bit(cur_timer, &enabled_timer_bits, |
|
NUM_OTG_FSM_TIMERS) { |
|
if ((next_timer == NUM_OTG_FSM_TIMERS) || |
|
ktime_before(ci->hr_timeouts[next_timer], |
|
ci->hr_timeouts[cur_timer])) |
|
next_timer = cur_timer; |
|
} |
|
} |
|
} |
|
if (next_timer != NUM_OTG_FSM_TIMERS) { |
|
ci->next_otg_timer = next_timer; |
|
hrtimer_start_range_ns(&ci->otg_fsm_hrtimer, |
|
ci->hr_timeouts[next_timer], NSEC_PER_MSEC, |
|
HRTIMER_MODE_ABS); |
|
} |
|
spin_unlock_irqrestore(&ci->lock, flags); |
|
} |
|
|
|
/* OTG FSM timer handlers */ |
|
static int a_wait_vrise_tmout(struct ci_hdrc *ci) |
|
{ |
|
ci->fsm.a_wait_vrise_tmout = 1; |
|
return 0; |
|
} |
|
|
|
static int a_wait_vfall_tmout(struct ci_hdrc *ci) |
|
{ |
|
ci->fsm.a_wait_vfall_tmout = 1; |
|
return 0; |
|
} |
|
|
|
static int a_wait_bcon_tmout(struct ci_hdrc *ci) |
|
{ |
|
ci->fsm.a_wait_bcon_tmout = 1; |
|
return 0; |
|
} |
|
|
|
static int a_aidl_bdis_tmout(struct ci_hdrc *ci) |
|
{ |
|
ci->fsm.a_aidl_bdis_tmout = 1; |
|
return 0; |
|
} |
|
|
|
static int b_ase0_brst_tmout(struct ci_hdrc *ci) |
|
{ |
|
ci->fsm.b_ase0_brst_tmout = 1; |
|
return 0; |
|
} |
|
|
|
static int a_bidl_adis_tmout(struct ci_hdrc *ci) |
|
{ |
|
ci->fsm.a_bidl_adis_tmout = 1; |
|
return 0; |
|
} |
|
|
|
static int b_aidl_bdis_tmout(struct ci_hdrc *ci) |
|
{ |
|
ci->fsm.a_bus_suspend = 1; |
|
return 0; |
|
} |
|
|
|
static int b_se0_srp_tmout(struct ci_hdrc *ci) |
|
{ |
|
ci->fsm.b_se0_srp = 1; |
|
return 0; |
|
} |
|
|
|
static int b_srp_fail_tmout(struct ci_hdrc *ci) |
|
{ |
|
ci->fsm.b_srp_done = 1; |
|
return 1; |
|
} |
|
|
|
static int b_data_pls_tmout(struct ci_hdrc *ci) |
|
{ |
|
ci->fsm.b_srp_done = 1; |
|
ci->fsm.b_bus_req = 0; |
|
if (ci->fsm.power_up) |
|
ci->fsm.power_up = 0; |
|
hw_write_otgsc(ci, OTGSC_HABA, 0); |
|
pm_runtime_put(ci->dev); |
|
return 0; |
|
} |
|
|
|
static int b_ssend_srp_tmout(struct ci_hdrc *ci) |
|
{ |
|
ci->fsm.b_ssend_srp = 1; |
|
/* only vbus fall below B_sess_vld in b_idle state */ |
|
if (ci->fsm.otg->state == OTG_STATE_B_IDLE) |
|
return 0; |
|
else |
|
return 1; |
|
} |
|
|
|
/* |
|
* Keep this list in the same order as timers indexed |
|
* by enum otg_fsm_timer in include/linux/usb/otg-fsm.h |
|
*/ |
|
static int (*otg_timer_handlers[])(struct ci_hdrc *) = { |
|
a_wait_vrise_tmout, /* A_WAIT_VRISE */ |
|
a_wait_vfall_tmout, /* A_WAIT_VFALL */ |
|
a_wait_bcon_tmout, /* A_WAIT_BCON */ |
|
a_aidl_bdis_tmout, /* A_AIDL_BDIS */ |
|
b_ase0_brst_tmout, /* B_ASE0_BRST */ |
|
a_bidl_adis_tmout, /* A_BIDL_ADIS */ |
|
b_aidl_bdis_tmout, /* B_AIDL_BDIS */ |
|
b_se0_srp_tmout, /* B_SE0_SRP */ |
|
b_srp_fail_tmout, /* B_SRP_FAIL */ |
|
NULL, /* A_WAIT_ENUM */ |
|
b_data_pls_tmout, /* B_DATA_PLS */ |
|
b_ssend_srp_tmout, /* B_SSEND_SRP */ |
|
}; |
|
|
|
/* |
|
* Enable the next nearest enabled timer if have |
|
*/ |
|
static enum hrtimer_restart ci_otg_hrtimer_func(struct hrtimer *t) |
|
{ |
|
struct ci_hdrc *ci = container_of(t, struct ci_hdrc, otg_fsm_hrtimer); |
|
ktime_t now, *timeout; |
|
unsigned long enabled_timer_bits; |
|
unsigned long flags; |
|
enum otg_fsm_timer cur_timer, next_timer = NUM_OTG_FSM_TIMERS; |
|
int ret = -EINVAL; |
|
|
|
spin_lock_irqsave(&ci->lock, flags); |
|
enabled_timer_bits = ci->enabled_otg_timer_bits; |
|
ci->next_otg_timer = NUM_OTG_FSM_TIMERS; |
|
|
|
now = ktime_get(); |
|
for_each_set_bit(cur_timer, &enabled_timer_bits, NUM_OTG_FSM_TIMERS) { |
|
if (ktime_compare(now, ci->hr_timeouts[cur_timer]) >= 0) { |
|
ci->enabled_otg_timer_bits &= ~(1 << cur_timer); |
|
if (otg_timer_handlers[cur_timer]) |
|
ret = otg_timer_handlers[cur_timer](ci); |
|
} else { |
|
if ((next_timer == NUM_OTG_FSM_TIMERS) || |
|
ktime_before(ci->hr_timeouts[cur_timer], |
|
ci->hr_timeouts[next_timer])) |
|
next_timer = cur_timer; |
|
} |
|
} |
|
/* Enable the next nearest timer */ |
|
if (next_timer < NUM_OTG_FSM_TIMERS) { |
|
timeout = &ci->hr_timeouts[next_timer]; |
|
hrtimer_start_range_ns(&ci->otg_fsm_hrtimer, *timeout, |
|
NSEC_PER_MSEC, HRTIMER_MODE_ABS); |
|
ci->next_otg_timer = next_timer; |
|
} |
|
spin_unlock_irqrestore(&ci->lock, flags); |
|
|
|
if (!ret) |
|
ci_otg_queue_work(ci); |
|
|
|
return HRTIMER_NORESTART; |
|
} |
|
|
|
/* Initialize timers */ |
|
static int ci_otg_init_timers(struct ci_hdrc *ci) |
|
{ |
|
hrtimer_init(&ci->otg_fsm_hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS); |
|
ci->otg_fsm_hrtimer.function = ci_otg_hrtimer_func; |
|
|
|
return 0; |
|
} |
|
|
|
/* -------------------------------------------------------------*/ |
|
/* Operations that will be called from OTG Finite State Machine */ |
|
/* -------------------------------------------------------------*/ |
|
static void ci_otg_fsm_add_timer(struct otg_fsm *fsm, enum otg_fsm_timer t) |
|
{ |
|
struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); |
|
|
|
if (t < NUM_OTG_FSM_TIMERS) |
|
ci_otg_add_timer(ci, t); |
|
return; |
|
} |
|
|
|
static void ci_otg_fsm_del_timer(struct otg_fsm *fsm, enum otg_fsm_timer t) |
|
{ |
|
struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); |
|
|
|
if (t < NUM_OTG_FSM_TIMERS) |
|
ci_otg_del_timer(ci, t); |
|
return; |
|
} |
|
|
|
/* |
|
* A-device drive vbus: turn on vbus regulator and enable port power |
|
* Data pulse irq should be disabled while vbus is on. |
|
*/ |
|
static void ci_otg_drv_vbus(struct otg_fsm *fsm, int on) |
|
{ |
|
int ret; |
|
struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); |
|
|
|
if (on) { |
|
/* Enable power power */ |
|
hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_PP, |
|
PORTSC_PP); |
|
if (ci->platdata->reg_vbus) { |
|
ret = regulator_enable(ci->platdata->reg_vbus); |
|
if (ret) { |
|
dev_err(ci->dev, |
|
"Failed to enable vbus regulator, ret=%d\n", |
|
ret); |
|
return; |
|
} |
|
} |
|
/* Disable data pulse irq */ |
|
hw_write_otgsc(ci, OTGSC_DPIE, 0); |
|
|
|
fsm->a_srp_det = 0; |
|
fsm->power_up = 0; |
|
} else { |
|
if (ci->platdata->reg_vbus) |
|
regulator_disable(ci->platdata->reg_vbus); |
|
|
|
fsm->a_bus_drop = 1; |
|
fsm->a_bus_req = 0; |
|
} |
|
} |
|
|
|
/* |
|
* Control data line by Run Stop bit. |
|
*/ |
|
static void ci_otg_loc_conn(struct otg_fsm *fsm, int on) |
|
{ |
|
struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); |
|
|
|
if (on) |
|
hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS); |
|
else |
|
hw_write(ci, OP_USBCMD, USBCMD_RS, 0); |
|
} |
|
|
|
/* |
|
* Generate SOF by host. |
|
* In host mode, controller will automatically send SOF. |
|
* Suspend will block the data on the port. |
|
* |
|
* This is controlled through usbcore by usb autosuspend, |
|
* so the usb device class driver need support autosuspend, |
|
* otherwise the bus suspend will not happen. |
|
*/ |
|
static void ci_otg_loc_sof(struct otg_fsm *fsm, int on) |
|
{ |
|
struct usb_device *udev; |
|
|
|
if (!fsm->otg->host) |
|
return; |
|
|
|
udev = usb_hub_find_child(fsm->otg->host->root_hub, 1); |
|
if (!udev) |
|
return; |
|
|
|
if (on) { |
|
usb_disable_autosuspend(udev); |
|
} else { |
|
pm_runtime_set_autosuspend_delay(&udev->dev, 0); |
|
usb_enable_autosuspend(udev); |
|
} |
|
} |
|
|
|
/* |
|
* Start SRP pulsing by data-line pulsing, |
|
* no v-bus pulsing followed |
|
*/ |
|
static void ci_otg_start_pulse(struct otg_fsm *fsm) |
|
{ |
|
struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); |
|
|
|
/* Hardware Assistant Data pulse */ |
|
hw_write_otgsc(ci, OTGSC_HADP, OTGSC_HADP); |
|
|
|
pm_runtime_get(ci->dev); |
|
ci_otg_add_timer(ci, B_DATA_PLS); |
|
} |
|
|
|
static int ci_otg_start_host(struct otg_fsm *fsm, int on) |
|
{ |
|
struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); |
|
|
|
if (on) { |
|
ci_role_stop(ci); |
|
ci_role_start(ci, CI_ROLE_HOST); |
|
} else { |
|
ci_role_stop(ci); |
|
ci_role_start(ci, CI_ROLE_GADGET); |
|
} |
|
return 0; |
|
} |
|
|
|
static int ci_otg_start_gadget(struct otg_fsm *fsm, int on) |
|
{ |
|
struct ci_hdrc *ci = container_of(fsm, struct ci_hdrc, fsm); |
|
|
|
if (on) |
|
usb_gadget_vbus_connect(&ci->gadget); |
|
else |
|
usb_gadget_vbus_disconnect(&ci->gadget); |
|
|
|
return 0; |
|
} |
|
|
|
static struct otg_fsm_ops ci_otg_ops = { |
|
.drv_vbus = ci_otg_drv_vbus, |
|
.loc_conn = ci_otg_loc_conn, |
|
.loc_sof = ci_otg_loc_sof, |
|
.start_pulse = ci_otg_start_pulse, |
|
.add_timer = ci_otg_fsm_add_timer, |
|
.del_timer = ci_otg_fsm_del_timer, |
|
.start_host = ci_otg_start_host, |
|
.start_gadget = ci_otg_start_gadget, |
|
}; |
|
|
|
int ci_otg_fsm_work(struct ci_hdrc *ci) |
|
{ |
|
/* |
|
* Don't do fsm transition for B device |
|
* when there is no gadget class driver |
|
*/ |
|
if (ci->fsm.id && !(ci->driver) && |
|
ci->fsm.otg->state < OTG_STATE_A_IDLE) |
|
return 0; |
|
|
|
pm_runtime_get_sync(ci->dev); |
|
if (otg_statemachine(&ci->fsm)) { |
|
if (ci->fsm.otg->state == OTG_STATE_A_IDLE) { |
|
/* |
|
* Further state change for cases: |
|
* a_idle to b_idle; or |
|
* a_idle to a_wait_vrise due to ID change(1->0), so |
|
* B-dev becomes A-dev can try to start new session |
|
* consequently; or |
|
* a_idle to a_wait_vrise when power up |
|
*/ |
|
if ((ci->fsm.id) || (ci->id_event) || |
|
(ci->fsm.power_up)) { |
|
ci_otg_queue_work(ci); |
|
} else { |
|
/* Enable data pulse irq */ |
|
hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | |
|
PORTSC_PP, 0); |
|
hw_write_otgsc(ci, OTGSC_DPIS, OTGSC_DPIS); |
|
hw_write_otgsc(ci, OTGSC_DPIE, OTGSC_DPIE); |
|
} |
|
if (ci->id_event) |
|
ci->id_event = false; |
|
} else if (ci->fsm.otg->state == OTG_STATE_B_IDLE) { |
|
if (ci->fsm.b_sess_vld) { |
|
ci->fsm.power_up = 0; |
|
/* |
|
* Further transite to b_periphearl state |
|
* when register gadget driver with vbus on |
|
*/ |
|
ci_otg_queue_work(ci); |
|
} |
|
} else if (ci->fsm.otg->state == OTG_STATE_A_HOST) { |
|
pm_runtime_mark_last_busy(ci->dev); |
|
pm_runtime_put_autosuspend(ci->dev); |
|
return 0; |
|
} |
|
} |
|
pm_runtime_put_sync(ci->dev); |
|
return 0; |
|
} |
|
|
|
/* |
|
* Update fsm variables in each state if catching expected interrupts, |
|
* called by otg fsm isr. |
|
*/ |
|
static void ci_otg_fsm_event(struct ci_hdrc *ci) |
|
{ |
|
u32 intr_sts, otg_bsess_vld, port_conn; |
|
struct otg_fsm *fsm = &ci->fsm; |
|
|
|
intr_sts = hw_read_intr_status(ci); |
|
otg_bsess_vld = hw_read_otgsc(ci, OTGSC_BSV); |
|
port_conn = hw_read(ci, OP_PORTSC, PORTSC_CCS); |
|
|
|
switch (ci->fsm.otg->state) { |
|
case OTG_STATE_A_WAIT_BCON: |
|
if (port_conn) { |
|
fsm->b_conn = 1; |
|
fsm->a_bus_req = 1; |
|
ci_otg_queue_work(ci); |
|
} |
|
break; |
|
case OTG_STATE_B_IDLE: |
|
if (otg_bsess_vld && (intr_sts & USBi_PCI) && port_conn) { |
|
fsm->b_sess_vld = 1; |
|
ci_otg_queue_work(ci); |
|
} |
|
break; |
|
case OTG_STATE_B_PERIPHERAL: |
|
if ((intr_sts & USBi_SLI) && port_conn && otg_bsess_vld) { |
|
ci_otg_add_timer(ci, B_AIDL_BDIS); |
|
} else if (intr_sts & USBi_PCI) { |
|
ci_otg_del_timer(ci, B_AIDL_BDIS); |
|
if (fsm->a_bus_suspend == 1) |
|
fsm->a_bus_suspend = 0; |
|
} |
|
break; |
|
case OTG_STATE_B_HOST: |
|
if ((intr_sts & USBi_PCI) && !port_conn) { |
|
fsm->a_conn = 0; |
|
fsm->b_bus_req = 0; |
|
ci_otg_queue_work(ci); |
|
} |
|
break; |
|
case OTG_STATE_A_PERIPHERAL: |
|
if (intr_sts & USBi_SLI) { |
|
fsm->b_bus_suspend = 1; |
|
/* |
|
* Init a timer to know how long this suspend |
|
* will continue, if time out, indicates B no longer |
|
* wants to be host role |
|
*/ |
|
ci_otg_add_timer(ci, A_BIDL_ADIS); |
|
} |
|
|
|
if (intr_sts & USBi_URI) |
|
ci_otg_del_timer(ci, A_BIDL_ADIS); |
|
|
|
if (intr_sts & USBi_PCI) { |
|
if (fsm->b_bus_suspend == 1) { |
|
ci_otg_del_timer(ci, A_BIDL_ADIS); |
|
fsm->b_bus_suspend = 0; |
|
} |
|
} |
|
break; |
|
case OTG_STATE_A_SUSPEND: |
|
if ((intr_sts & USBi_PCI) && !port_conn) { |
|
fsm->b_conn = 0; |
|
|
|
/* if gadget driver is binded */ |
|
if (ci->driver) { |
|
/* A device to be peripheral mode */ |
|
ci->gadget.is_a_peripheral = 1; |
|
} |
|
ci_otg_queue_work(ci); |
|
} |
|
break; |
|
case OTG_STATE_A_HOST: |
|
if ((intr_sts & USBi_PCI) && !port_conn) { |
|
fsm->b_conn = 0; |
|
ci_otg_queue_work(ci); |
|
} |
|
break; |
|
case OTG_STATE_B_WAIT_ACON: |
|
if ((intr_sts & USBi_PCI) && port_conn) { |
|
fsm->a_conn = 1; |
|
ci_otg_queue_work(ci); |
|
} |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
|
|
/* |
|
* ci_otg_irq - otg fsm related irq handling |
|
* and also update otg fsm variable by monitoring usb host and udc |
|
* state change interrupts. |
|
* @ci: ci_hdrc |
|
*/ |
|
irqreturn_t ci_otg_fsm_irq(struct ci_hdrc *ci) |
|
{ |
|
irqreturn_t retval = IRQ_NONE; |
|
u32 otgsc, otg_int_src = 0; |
|
struct otg_fsm *fsm = &ci->fsm; |
|
|
|
otgsc = hw_read_otgsc(ci, ~0); |
|
otg_int_src = otgsc & OTGSC_INT_STATUS_BITS & (otgsc >> 8); |
|
fsm->id = (otgsc & OTGSC_ID) ? 1 : 0; |
|
|
|
if (otg_int_src) { |
|
if (otg_int_src & OTGSC_DPIS) { |
|
hw_write_otgsc(ci, OTGSC_DPIS, OTGSC_DPIS); |
|
fsm->a_srp_det = 1; |
|
fsm->a_bus_drop = 0; |
|
} else if (otg_int_src & OTGSC_IDIS) { |
|
hw_write_otgsc(ci, OTGSC_IDIS, OTGSC_IDIS); |
|
if (fsm->id == 0) { |
|
fsm->a_bus_drop = 0; |
|
fsm->a_bus_req = 1; |
|
ci->id_event = true; |
|
} |
|
} else if (otg_int_src & OTGSC_BSVIS) { |
|
hw_write_otgsc(ci, OTGSC_BSVIS, OTGSC_BSVIS); |
|
if (otgsc & OTGSC_BSV) { |
|
fsm->b_sess_vld = 1; |
|
ci_otg_del_timer(ci, B_SSEND_SRP); |
|
ci_otg_del_timer(ci, B_SRP_FAIL); |
|
fsm->b_ssend_srp = 0; |
|
} else { |
|
fsm->b_sess_vld = 0; |
|
if (fsm->id) |
|
ci_otg_add_timer(ci, B_SSEND_SRP); |
|
} |
|
} else if (otg_int_src & OTGSC_AVVIS) { |
|
hw_write_otgsc(ci, OTGSC_AVVIS, OTGSC_AVVIS); |
|
if (otgsc & OTGSC_AVV) { |
|
fsm->a_vbus_vld = 1; |
|
} else { |
|
fsm->a_vbus_vld = 0; |
|
fsm->b_conn = 0; |
|
} |
|
} |
|
ci_otg_queue_work(ci); |
|
return IRQ_HANDLED; |
|
} |
|
|
|
ci_otg_fsm_event(ci); |
|
|
|
return retval; |
|
} |
|
|
|
void ci_hdrc_otg_fsm_start(struct ci_hdrc *ci) |
|
{ |
|
ci_otg_queue_work(ci); |
|
} |
|
|
|
int ci_hdrc_otg_fsm_init(struct ci_hdrc *ci) |
|
{ |
|
int retval = 0; |
|
|
|
if (ci->phy) |
|
ci->otg.phy = ci->phy; |
|
else |
|
ci->otg.usb_phy = ci->usb_phy; |
|
|
|
ci->otg.gadget = &ci->gadget; |
|
ci->fsm.otg = &ci->otg; |
|
ci->fsm.power_up = 1; |
|
ci->fsm.id = hw_read_otgsc(ci, OTGSC_ID) ? 1 : 0; |
|
ci->fsm.otg->state = OTG_STATE_UNDEFINED; |
|
ci->fsm.ops = &ci_otg_ops; |
|
ci->gadget.hnp_polling_support = 1; |
|
ci->fsm.host_req_flag = devm_kzalloc(ci->dev, 1, GFP_KERNEL); |
|
if (!ci->fsm.host_req_flag) |
|
return -ENOMEM; |
|
|
|
mutex_init(&ci->fsm.lock); |
|
|
|
retval = ci_otg_init_timers(ci); |
|
if (retval) { |
|
dev_err(ci->dev, "Couldn't init OTG timers\n"); |
|
return retval; |
|
} |
|
ci->enabled_otg_timer_bits = 0; |
|
ci->next_otg_timer = NUM_OTG_FSM_TIMERS; |
|
|
|
retval = sysfs_create_group(&ci->dev->kobj, &inputs_attr_group); |
|
if (retval < 0) { |
|
dev_dbg(ci->dev, |
|
"Can't register sysfs attr group: %d\n", retval); |
|
return retval; |
|
} |
|
|
|
/* Enable A vbus valid irq */ |
|
hw_write_otgsc(ci, OTGSC_AVVIE, OTGSC_AVVIE); |
|
|
|
if (ci->fsm.id) { |
|
ci->fsm.b_ssend_srp = |
|
hw_read_otgsc(ci, OTGSC_BSV) ? 0 : 1; |
|
ci->fsm.b_sess_vld = |
|
hw_read_otgsc(ci, OTGSC_BSV) ? 1 : 0; |
|
/* Enable BSV irq */ |
|
hw_write_otgsc(ci, OTGSC_BSVIE, OTGSC_BSVIE); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
void ci_hdrc_otg_fsm_remove(struct ci_hdrc *ci) |
|
{ |
|
sysfs_remove_group(&ci->dev->kobj, &inputs_attr_group); |
|
}
|
|
|