microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

usb: chipidea: use hrtimer for otg fsm timers 

Current otg fsm timers are using controller 1ms irq and count it, this patch
is to replace it with hrtimer solution, use one hrtimer for all otg timers.

Signed-off-by: Li Jun <jun.li@freescale.com>
Signed-off-by: Peter Chen <peter.chen@freescale.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Li Jun 2015-03-20 16:28:06 +08:00 коммит произвёл Greg Kroah-Hartman
Родитель 2f8a467a11
Коммит 3a316ec4c9
3 изменённых файлов: 193 добавлений и 200 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

10
drivers/usb/chipidea/ci.h
Просмотреть файл

@ -162,7 +162,10 @@ struct hw_bank {
* @role: current role
* @is_otg: if the device is otg-capable
* @fsm: otg finite state machine
* @fsm_timer: pointer to timer list of otg fsm
* @otg_fsm_hrtimer: hrtimer for otg fsm timers
* @hr_timeouts: time out list for active otg fsm timers
* @enabled_otg_timer_bits: bits of enabled otg timers
* @next_otg_timer: next nearest enabled timer to be expired
* @work: work for role changing
* @wq: workqueue thread
* @qh_pool: allocation pool for queue heads
@ -205,7 +208,10 @@ struct ci_hdrc {
bool is_otg;
struct usb_otg otg;
struct otg_fsm fsm;
struct ci_otg_fsm_timer_list *fsm_timer;
struct hrtimer otg_fsm_hrtimer;
ktime_t hr_timeouts[NUM_OTG_FSM_TIMERS];
unsigned enabled_otg_timer_bits;
enum otg_fsm_timer next_otg_timer;
struct work_struct work;
struct workqueue_struct *wq;

370
drivers/usb/chipidea/otg_fsm.c
Просмотреть файл

@ -30,22 +30,6 @@
#include "otg.h"
#include "otg_fsm.h"
static struct ci_otg_fsm_timer *otg_timer_initializer
(struct ci_hdrc *ci, void (*function)(void *, unsigned long),
unsigned long expires, unsigned long data)
{
struct ci_otg_fsm_timer *timer;
timer = devm_kzalloc(ci->dev, sizeof(struct ci_otg_fsm_timer),
GFP_KERNEL);
if (!timer)
return NULL;
timer->function = function;
timer->expires = expires;
timer->data = data;
return timer;
}
/* Add for otg: interact with user space app */
static ssize_t
get_a_bus_req(struct device *dev, struct device_attribute *attr, char *buf)
@ -203,37 +187,49 @@ static struct attribute_group inputs_attr_group = {
.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_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)
{
struct ci_otg_fsm_timer *tmp_timer;
struct ci_otg_fsm_timer *timer = ci->fsm_timer->timer_list[t];
struct list_head *active_timers = &ci->fsm_timer->active_timers;
unsigned long flags, timer_sec, timer_nsec;
if (t >= NUM_OTG_FSM_TIMERS)
return;
/*
* Check if the timer is already in the active list,
* if so update timer count
*/
list_for_each_entry(tmp_timer, active_timers, list)
if (tmp_timer == timer) {
timer->count = timer->expires;
return;
}
if (list_empty(active_timers))
pm_runtime_get(ci->dev);
timer->count = timer->expires;
list_add_tail(&timer->list, active_timers);
/* Enable 1ms irq */
if (!(hw_read_otgsc(ci, OTGSC_1MSIE)))
hw_write_otgsc(ci, OTGSC_1MSIE, OTGSC_1MSIE);
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) ||
(ci->hr_timeouts[ci->next_otg_timer].tv64 >
ci->hr_timeouts[t].tv64)) {
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);
}
/*
@ -241,174 +237,178 @@ static void ci_otg_add_timer(struct ci_hdrc *ci, enum otg_fsm_timer t)
*/
static void ci_otg_del_timer(struct ci_hdrc *ci, enum otg_fsm_timer t)
{
struct ci_otg_fsm_timer *tmp_timer, *del_tmp;
struct ci_otg_fsm_timer *timer = ci->fsm_timer->timer_list[t];
struct list_head *active_timers = &ci->fsm_timer->active_timers;
int flag = 0;
unsigned long flags, enabled_timer_bits;
enum otg_fsm_timer cur_timer, next_timer = NUM_OTG_FSM_TIMERS;
if (t >= NUM_OTG_FSM_TIMERS)
if ((t >= NUM_OTG_FSM_TIMERS) ||
!(ci->enabled_otg_timer_bits & (1 << t)))
return;
list_for_each_entry_safe(tmp_timer, del_tmp, active_timers, list)
if (tmp_timer == timer) {
list_del(&timer->list);
flag = 1;
}
/* Disable 1ms irq if there is no any active timer */
if (list_empty(active_timers) && (flag == 1)) {
hw_write_otgsc(ci, OTGSC_1MSIE, 0);
pm_runtime_put(ci->dev);
}
}
/*
* Reduce timer count by 1, and find timeout conditions.
* Called by otg 1ms timer interrupt
*/
static inline int ci_otg_tick_timer(struct ci_hdrc *ci)
{
struct ci_otg_fsm_timer *tmp_timer, *del_tmp;
struct list_head *active_timers = &ci->fsm_timer->active_timers;
int expired = 0;
list_for_each_entry_safe(tmp_timer, del_tmp, active_timers, list) {
tmp_timer->count--;
/* check if timer expires */
if (!tmp_timer->count) {
list_del(&tmp_timer->list);
tmp_timer->function(ci, tmp_timer->data);
expired = 1;
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) ||
(ci->hr_timeouts[next_timer].tv64 <
ci->hr_timeouts[cur_timer].tv64))
next_timer = cur_timer;
}
}
}
/* disable 1ms irq if there is no any timer active */
if ((expired == 1) && list_empty(active_timers)) {
hw_write_otgsc(ci, OTGSC_1MSIE, 0);
pm_runtime_put(ci->dev);
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);
}
return expired;
spin_unlock_irqrestore(&ci->lock, flags);
}
/* The timeout callback function to set time out bit */
static void set_tmout(void *ptr, unsigned long indicator)
/* OTG FSM timer handlers */
static int a_wait_vrise_tmout(struct ci_hdrc *ci)
{
*(int *)indicator = 1;
ci->fsm.a_wait_vrise_tmout = 1;
return 0;
}
static void set_tmout_and_fsm(void *ptr, unsigned long indicator)
static int a_wait_vfall_tmout(struct ci_hdrc *ci)
{
struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
set_tmout(ci, indicator);
ci_otg_queue_work(ci);
ci->fsm.a_wait_vfall_tmout = 1;
return 0;
}
static void a_wait_vfall_tmout_func(void *ptr, unsigned long indicator)
static int a_wait_bcon_tmout(struct ci_hdrc *ci)
{
struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
set_tmout(ci, indicator);
/* Disable port power */
hw_write(ci, OP_PORTSC, PORTSC_W1C_BITS | PORTSC_PP, 0);
/* Clear existing DP irq */
hw_write_otgsc(ci, OTGSC_DPIS, OTGSC_DPIS);
/* Enable data pulse irq */
hw_write_otgsc(ci, OTGSC_DPIE, OTGSC_DPIE);
ci_otg_queue_work(ci);
ci->fsm.a_wait_bcon_tmout = 1;
return 0;
}
static void b_ssend_srp_tmout_func(void *ptr, unsigned long indicator)
static int a_aidl_bdis_tmout(struct ci_hdrc *ci)
{
struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
set_tmout(ci, indicator);
/* only vbus fall below B_sess_vld in b_idle state */
if (ci->fsm.otg->state == OTG_STATE_B_IDLE)
ci_otg_queue_work(ci);
ci->fsm.a_aidl_bdis_tmout = 1;
return 0;
}
static void b_data_pulse_end(void *ptr, unsigned long indicator)
static int b_ase0_brst_tmout(struct ci_hdrc *ci)
{
struct ci_hdrc *ci = (struct ci_hdrc *)ptr;
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_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;
}
ci_otg_queue_work(ci);
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_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 (now.tv64 >= ci->hr_timeouts[cur_timer].tv64) {
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) ||
(ci->hr_timeouts[cur_timer].tv64 <
ci->hr_timeouts[next_timer].tv64))
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)
{
struct otg_fsm *fsm = &ci->fsm;
/* FSM used timers */
ci->fsm_timer->timer_list[A_WAIT_VRISE] =
otg_timer_initializer(ci, &set_tmout_and_fsm, TA_WAIT_VRISE,
(unsigned long)&fsm->a_wait_vrise_tmout);
if (ci->fsm_timer->timer_list[A_WAIT_VRISE] == NULL)
return -ENOMEM;
ci->fsm_timer->timer_list[A_WAIT_VFALL] =
otg_timer_initializer(ci, &a_wait_vfall_tmout_func,
TA_WAIT_VFALL, (unsigned long)&fsm->a_wait_vfall_tmout);
if (ci->fsm_timer->timer_list[A_WAIT_VFALL] == NULL)
return -ENOMEM;
ci->fsm_timer->timer_list[A_WAIT_BCON] =
otg_timer_initializer(ci, &set_tmout_and_fsm, TA_WAIT_BCON,
(unsigned long)&fsm->a_wait_bcon_tmout);
if (ci->fsm_timer->timer_list[A_WAIT_BCON] == NULL)
return -ENOMEM;
ci->fsm_timer->timer_list[A_AIDL_BDIS] =
otg_timer_initializer(ci, &set_tmout_and_fsm, TA_AIDL_BDIS,
(unsigned long)&fsm->a_aidl_bdis_tmout);
if (ci->fsm_timer->timer_list[A_AIDL_BDIS] == NULL)
return -ENOMEM;
ci->fsm_timer->timer_list[A_BIDL_ADIS] =
otg_timer_initializer(ci, &set_tmout_and_fsm, TA_BIDL_ADIS,
(unsigned long)&fsm->a_bidl_adis_tmout);
if (ci->fsm_timer->timer_list[A_BIDL_ADIS] == NULL)
return -ENOMEM;
ci->fsm_timer->timer_list[B_ASE0_BRST] =
otg_timer_initializer(ci, &set_tmout_and_fsm, TB_ASE0_BRST,
(unsigned long)&fsm->b_ase0_brst_tmout);
if (ci->fsm_timer->timer_list[B_ASE0_BRST] == NULL)
return -ENOMEM;
ci->fsm_timer->timer_list[B_SE0_SRP] =
otg_timer_initializer(ci, &set_tmout_and_fsm, TB_SE0_SRP,
(unsigned long)&fsm->b_se0_srp);
if (ci->fsm_timer->timer_list[B_SE0_SRP] == NULL)
return -ENOMEM;
ci->fsm_timer->timer_list[B_SSEND_SRP] =
otg_timer_initializer(ci, &b_ssend_srp_tmout_func, TB_SSEND_SRP,
(unsigned long)&fsm->b_ssend_srp);
if (ci->fsm_timer->timer_list[B_SSEND_SRP] == NULL)
return -ENOMEM;
ci->fsm_timer->timer_list[B_SRP_FAIL] =
otg_timer_initializer(ci, &set_tmout, TB_SRP_FAIL,
(unsigned long)&fsm->b_srp_done);
if (ci->fsm_timer->timer_list[B_SRP_FAIL] == NULL)
return -ENOMEM;
ci->fsm_timer->timer_list[B_DATA_PLS] =
otg_timer_initializer(ci, &b_data_pulse_end, TB_DATA_PLS, 0);
if (ci->fsm_timer->timer_list[B_DATA_PLS] == NULL)
return -ENOMEM;
hrtimer_init(&ci->otg_fsm_hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
ci->otg_fsm_hrtimer.function = ci_otg_hrtimer_func;
return 0;
}
@ -512,6 +512,7 @@ static void ci_otg_start_pulse(struct otg_fsm *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);
}
@ -579,8 +580,15 @@ int ci_otg_fsm_work(struct ci_hdrc *ci)
* a_idle to a_wait_vrise when power up
*/
if ((ci->fsm.id) || (ci->id_event) ||
(ci->fsm.power_up))
(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) {
@ -712,11 +720,7 @@ irqreturn_t ci_otg_fsm_irq(struct ci_hdrc *ci)
fsm->id = (otgsc & OTGSC_ID) ? 1 : 0;
if (otg_int_src) {
if (otg_int_src & OTGSC_1MSIS) {
hw_write_otgsc(ci, OTGSC_1MSIS, OTGSC_1MSIS);
retval = ci_otg_tick_timer(ci);
return IRQ_HANDLED;
} else if (otg_int_src & OTGSC_DPIS) {
if (otg_int_src & OTGSC_DPIS) {
hw_write_otgsc(ci, OTGSC_DPIS, OTGSC_DPIS);
fsm->a_srp_det = 1;
fsm->a_bus_drop = 0;
@ -780,17 +784,13 @@ int ci_hdrc_otg_fsm_init(struct ci_hdrc *ci)
mutex_init(&ci->fsm.lock);
ci->fsm_timer = devm_kzalloc(ci->dev,
sizeof(struct ci_otg_fsm_timer_list), GFP_KERNEL);
if (!ci->fsm_timer)
return -ENOMEM;
INIT_LIST_HEAD(&ci->fsm_timer->active_timers);
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) {

13
drivers/usb/chipidea/otg_fsm.h
Просмотреть файл

@ -62,19 +62,6 @@
/* SSEND time before SRP */
#define TB_SSEND_SRP (1500) /* minimum 1.5 sec, section:5.1.2 */
struct ci_otg_fsm_timer {
unsigned long expires; /* Number of count increase to timeout */
unsigned long count; /* Tick counter */
void (*function)(void *, unsigned long); /* Timeout function */
unsigned long data; /* Data passed to function */
struct list_head list;
};
struct ci_otg_fsm_timer_list {
struct ci_otg_fsm_timer *timer_list[NUM_OTG_FSM_TIMERS];
struct list_head active_timers;
};
#ifdef CONFIG_USB_OTG_FSM
int ci_hdrc_otg_fsm_init(struct ci_hdrc *ci);