通过OTG接口进入Android系统,Android4.0.3 USB OTG底层插入上报过程分析(1)

下面的两个宏是PM8058的MMP11(R15)，MMP12(P15)管脚。

#define EXT_CHG_VALID_MPP 10

#define EXT_CHG_VALID_MPP_2 11

static struct pm8xxx_mpp_init_info isl_mpp[] = {

PM8058_MPP_INIT(EXT_CHG_VALID_MPP, D_INPUT,

PM8058_MPP_DIG_LEVEL_S3, DIN_TO_INT),

PM8058_MPP_INIT(EXT_CHG_VALID_MPP_2, D_BI_DIR,

PM8058_MPP_DIG_LEVEL_S3, BI_PULLUP_10KOHM),

};

//配置管脚功能函数

#if defined(CONFIG_SMB137B_CHARGER) || defined(CONFIG_SMB137B_CHARGER_MODULE)

static int smb137b_detection_setup(void)

{

int ret = 0, i;

for (i = 0; i < ARRAY_SIZE(isl_mpp); i++) {

ret = pm8xxx_mpp_config(isl_mpp[i].mpp,&isl_mpp[i].config);

}

return ret;

}

static struct smb137b_platform_data smb137b_data __initdata = {

.chg_detection_config = smb137b_detection_setup,

.valid_n_gpio = PM8058_MPP_PM_TO_SYS(10),

.batt_mah_rating = 950,

};

static struct i2c_board_info smb137b_charger_i2c_info[] __initdata = {

{

I2C_BOARD_INFO("smb137b", 0x08),

.irq = PM8058_IRQ_BASE + PM8058_CBLPWR_IRQ,//计算后的irq值＝464

.platform_data = &smb137b_data,

},

};

#endif

static int __devinit smb137b_probe(struct i2c_client *client,const struct i2c_device_id *id)

｛

/*配置usb检测管脚*/

if (pdata->chg_detection_config)

ret = pdata->chg_detection_config();

/*用该检测gpio引脚前，申请该GPIO*/

ret = gpio_request(pdata->valid_n_gpio, "smb137b_charger_valid");

/*申请中断，该中断号码为464*/

ret = request_threaded_irq(client->irq, NULL,smb137b_valid_handler,

IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,

"smb137b_charger_valid", client);

/*先读取一次检测管脚值*/

ret = gpio_get_value_cansleep(smb137b_chg->valid_n_gpio);

if (!ret) {

/*上报usb的插入状态*/

msm_charger_notify_event(smb137b_chg->adapter_hw_chg[0],CHG_INSERTED_EVENT);

smb137b_chg->usb_status = SMB137B_PRESENT;

}

｝

/*以后的处理都是在中断中进行处理*/

static irqreturn_t smb137b_valid_handler(int irq, void *dev_id)

{

struct smb137b_data *smb137b_chg;

smb137b_chg = i2c_get_clientdata(client);

smb137b_chg->current_hw_chg = smb137b_chg->adapter_hw_chg[0];

/*读出检测管脚的电平值*/

val = gpio_get_value_cansleep(smb137b_chg->valid_n_gpio);

if (val) {

if (smb137b_chg->usb_status != SMB137B_ABSENT) {

smb137b_chg->usb_status = SMB137B_ABSENT;

/*如果为高电平，通知usb移出*/

msm_charger_notify_event(smb137b_chg->current_hw_chg,CHG_REMOVED_EVENT);

}

} else if (smb137b_chg->usb_status == SMB137B_ABSENT) {

smb137b_chg->usb_status = SMB137B_PRESENT;

/*如果为高电平，通知usb插入*/

msm_charger_notify_event(smb137b_chg->current_hw_chg,CHG_INSERTED_EVENT);

}

｝

下面进入发通知流程继续跟踪

int msm_charger_notify_event(struct msm_hardware_charger *hw_chg,

enum msm_hardware_charger_event event)

{

/*把该消息加入循环队列中*/

msm_chg_enqueue_event(hw_chg, event);

/*调度work*/

queue_work(msm_chg.event_wq_thread, &msm_chg.queue_work);

return 0;

}

下面的两行是在static int __init msm_charger_init(void)函数中进行初始化的：

INIT_WORK(&msm_chg.queue_work, process_events);

msm_chg.event_wq_thread = create_workqueue("msm_charger_eventd");

该work的处理函数如下：

static void process_events(struct work_struct *work)

{

struct msm_charger_event *event;

int rc;

/*循环处理等待队列中的消息*/

do {

rc = msm_chg_dequeue_event(&event);

if (!rc)

/*对单个的event进行处理*/

handle_event(event->hw_chg, event->event);

} while (!rc);

}

下面进入具体的handle_event函数分析：

static void handle_event(struct msm_hardware_charger *hw_chg, int event)

{

struct msm_hardware_charger_priv *priv = NULL;

if (hw_chg)

priv = hw_chg->charger_private;

switch (event) {

case CHG_INSERTED_EVENT:

if (hw_chg->type == CHG_TYPE_USB) {

.................

priv->hw_chg_state = CHG_PRESENT_STATE;

/*上报usb插入事件*/

notify_usb_of_the_plugin_event(priv, 1);

.........................

break;

case CHG_REMOVED_EVENT:

if (hw_chg->type == CHG_TYPE_USB) {

...............

usb_chg_current = 0;

/*上报usb移出事件*/

notify_usb_of_the_plugin_event(priv, 0);

........................

}

break;

}

/*进入notify_usb_of_the_plugin_event函数继续跟踪*/

static void notify_usb_of_the_plugin_event(struct msm_hardware_charger_priv

*hw_chg, int plugin)

{

plugin = !!plugin;

if (plugin == 1 && usb_notified_of_insertion == 0) {

usb_notified_of_insertion = 1;

if (notify_vbus_state_func_ptr) {

/*调用回调函数*/

(*notify_vbus_state_func_ptr) (plugin);

}

if (plugin == 0 && usb_notified_of_insertion == 1) {

if (notify_vbus_state_func_ptr) {

(*notify_vbus_state_func_ptr) (plugin);

}

usb_notified_of_insertion = 0;

}

}

/*下面进入回调函数的跟踪*/

/*在板级初始化时定义了一个全局函数指针*/

notify_vbus_state notify_vbus_state_func_ptr;

/*该函数指针在该回调函数中赋值*/

static int msm_hsusb_pmic_vbus_notif_init(void (*callback)(int online),

int init)

{

int ret = -ENOTSUPP;

if (machine_is_msm8x60_s9000() || pmic_id_notif_supported)) {

if (init)

ret = msm_charger_register_vbus_sn(callback);

else {

msm_charger_unregister_vbus_sn(callback);

ret = 0;

}

}

}

int msm_charger_register_vbus_sn(void (*callback)(int))

{

notify_vbus_state_func_ptr = callback;

return 0;

}

/*该回调函数注册的时机如下*/

#if defined(CONFIG_USB_GADGET_MSM_72K) || defined(CONFIG_USB_EHCI_MSM_72K)

static struct msm_otg_platform_data msm_otg_pdata = {

................

#ifdef CONFIG_BATTERY_MSM8X60

.pmic_vbus_notif_init    = msm_hsusb_pmic_vbus_notif_init,

#endif

.........................

};

#endif

/*把该平台数据赋值给平台设备*/

msm_device_otg.dev.platform_data = &msm_otg_pdata;

/*注册该平台设备*/

static struct platform_device *surf_devices[] __initdata = {

#if defined(CONFIG_USB_GADGET_MSM_72K) || defined(CONFIG_USB_EHCI_HCD)

&msm_device_otg,

#endif

｝

static void __init msm8x60_init(struct msm_board_data *board_data)

｛

platform_add_devices(surf_devices,ARRAY_SIZE(surf_devices));

｝

static int __init msm_otg_probe(struct platform_device *pdev)

{

..............

/*初始化work工作队列*/

INIT_WORK(&dev->sm_work, msm_otg_sm_work);

dev->wq = alloc_workqueue("k_otg", WQ_NON_REENTRANT, 0);

..................

/*调用回调函数，为全局函数指针赋值*/

if (dev->pdata->pmic_vbus_notif_init) {

ret = dev->pdata->pmic_vbus_notif_init

(&msm_otg_set_vbus_state, 1);

if (!ret) {

dev->pmic_vbus_notif_supp = 1;

}

}

...............

.......................

}

/*然后用该函数上报plug的值*/

void msm_otg_set_vbus_state(int online)

{

struct msm_otg *dev = the_msm_otg;

/*如果上报插入事件，就设置B_SESS_VLD标志位*/

if (online)

set_bit(B_SESS_VLD, &dev->inputs);

/*如果上报移除事件，就清除B_SESS_VLD标志位*/

else

clear_bit(B_SESS_VLD, &dev->inputs);

/*获得wakelock锁*/

wake_lock(&dev->wlock);

/*调度工作队列中的work*/

queue_work(dev->wq, &dev->sm_work);

}

/*下面进入work继续跟踪*/

static void msm_otg_sm_work(struct work_struct *w)

｛

enum usb_otg_state state;

state = dev->otg.state;

switch (state) {

case OTG_STATE_UNDEFINED:

if (!dev->otg.host || !is_host())

{

set_bit(ID, &dev->inputs);

}

if (dev->otg.gadget && is_b_sess_vld())

{

set_bit(B_SESS_VLD, &dev->inputs);

}

if ((test_bit(ID, &dev->inputs)) && !test_bit(ID_A, &dev->inputs)) {

/*改变otg的状态机状态为OTG_STATE_B_IDLE*/

dev->otg.state = OTG_STATE_B_IDLE;

}

work = 1;

break;

case OTG_STATE_B_IDLE:

if (test_bit(B_SESS_VLD, &dev->inputs) && !test_bit(ID_B, &dev->inputs)) {

/*改变otg的状态机状态为OTG_STATE_B_PERIPHERAL*/

dev->otg.state = OTG_STATE_B_PERIPHERAL;

msm_otg_set_power(&dev->otg, 0);

/*启动外围设备*/

msm_otg_start_peripheral(&dev->otg, 1);

}

break;

/*如果work为1，则继续调度work*/

if (work)

queue_work(dev->wq, &dev->sm_work);

｝

/*上面的work牵涉到两个函数，通过寄存器的值判断，设置相应的位域*/

static int is_host(void)

{

struct msm_otg *dev = the_msm_otg;

if (dev->pdata->otg_mode == OTG_ID)

{

/*读出该寄存器的第8位，如果读出的为1，则返回0，即该设备为B device*/

return (OTGSC_ID & readl(USB_OTGSC)) ? 0 : 1;

}

}

static int is_b_sess_vld(void)

{

struct msm_otg *dev = the_msm_otg;

if (dev->pdata->otg_mode == OTG_ID)

{

/*读出该寄存器的第11位，如果为1，则返回1，该寄存器在spec中说明如下：Indicates that the Vbus is above the B session valid threshold.*/

return (OTGSC_BSV & readl(USB_OTGSC)) ? 1 : 0;

}

}

/*下面进入msm_otg_start_peripheral函数进行分析*/

static void msm_otg_start_peripheral(struct otg_transceiver *xceiv, int on)

{

struct msm_otg *dev = container_of(xceiv, struct msm_otg, otg);

if (on) {

usb_gadget_vbus_connect(xceiv->gadget);

}

}

/*设置gadget的vbus*/

static inline int usb_gadget_vbus_connect(struct usb_gadget *gadget)

{

if (!gadget->ops->vbus_session)

return -EOPNOTSUPP;

return gadget->ops->vbus_session(gadget, 1);

}

/*调用底层gadget的回调函数*/

gadget->ops->vbus_session(gadget, 1);

/*下面是该回调函数的结构体*/

static const struct usb_gadget_ops msm72k_ops = {

.get_frame    = msm72k_get_frame,

/*该回调函数*/

.vbus_session    = msm72k_udc_vbus_session,

.vbus_draw    = msm72k_udc_vbus_draw,

.pullup        = msm72k_pullup,

.wakeup        = msm72k_wakeup,

.set_selfpowered = msm72k_set_selfpowered,

};

/*回调函数的注册过程如下*/

static int msm72k_probe(struct platform_device *pdev)

{

ui = kzalloc(sizeof(struct usb_info), GFP_KERNEL);

ui->gadget.ops = &msm72k_ops;

}

/*看下vbus的回调函数*/

static int msm72k_udc_vbus_session(struct usb_gadget *_gadget, int is_active)

{

/*设置vbus的状态*/

msm_hsusb_set_vbus_state(is_active);

return 0;

}

/*继续跟踪设置vbus的状态*/

void msm_hsusb_set_vbus_state(int online)

{

struct usb_info *ui = the_usb_info;

/*根据传入的状态设置usb的状态位*/

if (online) {

ui->usb_state = USB_STATE_POWERED;

ui->flags |= USB_FLAG_VBUS_ONLINE;

} else {

ui->gadget.speed = USB_SPEED_UNKNOWN;

ui->usb_state = USB_STATE_NOTATTACHED;

ui->flags |= USB_FLAG_VBUS_OFFLINE;

}

/*调度usb的工作队列*/

if (in_interrupt()) {

schedule_work(&ui->work);

} else {

usb_do_work(&ui->work);

return;

}

}

/*在usb_do_work中会进入一个大的状态机循环*/

static void usb_do_work(struct work_struct *w)

{

struct usb_info *ui = container_of(w, struct usb_info, work);

struct msm_otg *otg = to_msm_otg(ui->xceiv);

unsigned long iflags;

unsigned flags, _vbus;

for (;;) {

spin_lock_irqsave(&ui->lock, iflags);

flags = ui->flags;

ui->flags = 0;

_vbus = is_usb_online(ui);

spin_unlock_irqrestore(&ui->lock, iflags);

/* give up if we have nothing to do */

if (flags == 0)

break;

switch (ui->state) {

case USB_STATE_IDLE:

if (flags & USB_FLAG_START) {

int ret;

/*重启设备控制器*/

usb_reset(ui);

/*申请中断处理函数*/

ret = request_irq(otg->irq, usb_interrupt,IRQF_SHARED,ui->pdev->name, ui);

ui->irq = otg->irq;

/*改变设备状态*/

ui->state = USB_STATE_ONLINE;

usb_do_work_check_vbus(ui);

/*使能D＋数据线上的上拉电阻*/

msm72k_pullup_internal(&ui->gadget, 1);

break;

case USB_STATE_ONLINE:

if (flags & USB_FLAG_SUSPEND) {

int maxpower = usb_get_max_power(ui);

otg_set_power(ui->xceiv, 0);

break;

}

if (flags & USB_FLAG_CONFIGURED) {

int maxpower = usb_get_max_power(ui);

switch_set_state(&ui->sdev,atomic_read(&ui->configured));

ui->chg_current = maxpower;

otg_set_power(ui->xceiv, maxpower);

break;

}

if (flags & USB_FLAG_RESET) {

msm72k_pullup_internal(&ui->gadget, 0);

usb_reset(ui);

msm72k_pullup_internal(&ui->gadget, 1);

break;

}

break;

case USB_STATE_OFFLINE:

if ((flags & USB_FLAG_VBUS_ONLINE) && _vbus) {

/*重启设备控制器*/

usb_reset(ui);

/*改变设备状态*/

ui->state = USB_STATE_ONLINE;

usb_do_work_check_vbus(ui);

/*申请中断处理函数*/

ret = request_irq(otg->irq, usb_interrupt,IRQF_SHARED,ui->pdev->name, ui);

ui->irq = otg->irq;

/*使能D＋数据线上的上拉电阻*/

msm72k_pullup_internal(&ui->gadget, 1);

}

break;

}

}

}

/*中断函数的实时处理*/

static irqreturn_t usb_interrupt(int irq, void *data)

{

struct usb_info *ui = data;

unsigned n;

unsigned long flags;

n = readl(USB_USBSTS);

writel(n, USB_USBSTS);

/*端口变化探测*/

if (n & STS_PCI) {

msm_hsusb_set_speed(ui);

if (atomic_read(&ui->configured)) {

ui->usb_state = USB_STATE_CONFIGURED;

ui->flags = USB_FLAG_CONFIGURED;

ui->driver->resume(&ui->gadget);

schedule_work(&ui->work);

} else {

msm_hsusb_set_state(USB_STATE_DEFAULT);

}

}

/*usb重启*/

if (n & STS_URI) {

dev_dbg(&ui->pdev->dev, "reset\n");

ui->gadget.speed = USB_SPEED_UNKNOWN;

msm_hsusb_set_state(USB_STATE_DEFAULT);

......................

}

/*usb挂起状态*/

if (n & STS_SLI) {

dev_dbg(&ui->pdev->dev, "suspend\n");

ui->usb_state = USB_STATE_SUSPENDED;

ui->flags = USB_FLAG_SUSPEND;

ui->driver->suspend(&ui->gadget);

schedule_work(&ui->work);

}

/*usb事务传输完成中断*/

if (n & STS_UI) {

n = readl(USB_ENDPTSETUPSTAT);

if (n & EPT_RX(0))

handle_setup(ui);

n = readl(USB_ENDPTCOMPLETE);

writel(n, USB_ENDPTCOMPLETE);

while (n) {

unsigned bit = __ffs(n);

handle_endpoint(ui, bit);

n = n & (~(1 << bit));

}

}

return IRQ_HANDLED;

}

阅读(11925) | 评论(0) | 转发(4) |