MDM9x25 Flashless boot(Power Manager)
设置的device tree和相关的platform初始化函数，主要设置HOST_WAKE, DEVICE_RDY, HOST_RDY 三个GPIO和设置
HOST_WAKE和DEVICE_RDY的中断函数。并设置PM和HSIC的power manager相关的notifier call函数。
mdmpm_pdata {
compatible = "qcom,mdm-hsic-pm";
qcom,ap2mdm-hostrdy-gpio = <&gpf5 0 0x1>;
qcom,mdm2ap-devicerdy-gpio = <&gpa1 2 0x0>;
qcom,mdm2ap-hostwake-gpio = <&gpa3 1 0xf>;
reg = <0x15510000 0x100>, /* EHCI */
<0x15530000 0x100>, /* PHY */
<0x105C0704 0xC>, /* PMU */
<0x156E0204 0xC>; /* USB phy clk */
};
static int mdm_hsic_pm_probe(struct platform_device *pdev)
{
int ret;
struct mdm_hsic_pm_data *pm_data = pdev->dev.platform_data;;
pr_info("%s for %s\n", __func__, pdev->name);
if (pdev->dev.of_node) {
pm_data = mdm_pm_parse_dt_pdata(&pdev->dev);
if (IS_ERR(pm_data)) {
pr_err("MDM DT parse error!\n");
goto err_gpio_init_fail;
}
#ifdef EHCI_REG_DUMP
ehci_port_reg_init(pdev);
#endif
} else {
if (!pm_data) {
pr_err("MDM Non-DT, incorrect pdata!\n");
return -EINVAL;
}
}
memcpy(pm_data->name, pdev->name, strlen(pdev->name));
/* request irq for host wake interrupt */
ret = request_irq(pm_data->irq, mdm_hsic_irq_handler,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_DISABLED,
"mdm_hsic_pm", (void *)pm_data);
if (ret < 0) {
pr_err("%s: fail to request mdm_hsic_pm irq(%d)\n", __func__, ret);
goto err_request_irq;
}
ret = enable_irq_wake(pm_data->irq);
if (ret < 0) {
pr_err("%s: fail to set wake irq(%d)\n", __func__, ret);
goto err_set_wake_irq;
}
ret = request_irq(pm_data->dev_rdy_irq, mdm_device_ready_irq_handler,
IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_DISABLED,
"mdm_device_ready", (void *)pm_data);
if (ret < 0) {
pr_err("%s: fail to request mdm_device_ready irq(%d)\n", __func__, ret);
goto err_request_irq;
}
pm_data->wq = create_singlethread_workqueue("hsicrpmd");
if (!pm_data->wq) {
pr_err("%s: fail to create wq\n", __func__);
goto err_create_wq;
}
if (sysfs_create_group(&pdev->dev.kobj, &mdm_hsic_attrgroup) < 0) {
pr_err("%s: fail to create sysfs\n", __func__);
goto err_create_sys_file;
}
pm_data->mdm_pdata =
(struct mdm_hsic_pm_platform_data *)pdev->dev.platform_data;
INIT_DELAYED_WORK(&pm_data->auto_rpm_start_work, mdm_hsic_rpm_start);
INIT_DELAYED_WORK(&pm_data->auto_rpm_restart_work,
mdm_hsic_rpm_restart);
INIT_DELAYED_WORK(&pm_data->request_resume_work, mdm_hsic_rpm_check);
INIT_DELAYED_WORK(&pm_data->fast_dormancy_work, fast_dormancy_func);
/* register notifier call */
pm_data->pm_notifier.notifier_call = mdm_hsic_pm_notify_event;
register_pm_notifier(&pm_data->pm_notifier);
blocking_notifier_chain_register(&mdm_reset_notifier_list,
&mdm_reset_main_block);
#ifdef CONFIG_CPU_FREQ_TETHERING
pm_data->netdev_notifier.notifier_call = link_pm_netdev_event;
register_netdevice_notifier(&pm_data->netdev_notifier);
pm_data->usb_composite_notifier.notifier_call =
usb_composite_notifier_event;
register_usb_composite_notifier(&pm_data->usb_composite_notifier);
#endif
#if defined(CONFIG_OF)
pm_data->phy_nfb.notifier_call = mdm_hsic_pm_phy_notify;
phy_register_notifier(&pm_data->phy_nfb);
#endif
wake_lock_init(&pm_data->l2_wake, WAKE_LOCK_SUSPEND, pm_data->name);
wake_lock_init(&pm_data->boot_wake, WAKE_LOCK_SUSPEND, "mdm_boot");
wake_lock_init(&pm_data->fd_wake, WAKE_LOCK_SUSPEND, "fast_dormancy");
pm_data->fd_wake_time = DEFAULT_RAW_WAKE_TIME;
pm_data->qmicm_mode = false;
print_pm_dev_info(pm_data);
list_add(&pm_data->list, &hsic_pm_dev_list);
platform_set_drvdata(pdev, pm_data);
pr_info("%s for %s has done\n", __func__, pdev->name);
debug_ehci_reg_dump();
return 0;
err_create_sys_file:
destroy_workqueue(pm_data->wq);
err_create_wq:
disable_irq_wake(pm_data->irq);
err_set_wake_irq:
free_irq(pm_data->irq, (void *)pm_data);
err_request_irq:
err_gpio_init_fail:
mdm_hsic_pm_gpio_free(pm_data);
kfree(pm_data);
return -ENXIO;
}HS-USB/HSIC PM 状态有四种，分别表示成L0,L1,L2,L3。
但无论高通还是三星平台都没有实现L1状态，所以都只在L0,L1,L3状态下循环。
(1) L0 (Data Active)
HSIC 发送和接收数据的状态
(2) L1(LPM)
在很短时间里(T1)，HSIC如果没有数据发送或接收的时候进入省电模式的状态(stand alone operation)。
这个状态由于相对省电效果不是很明显而且实现起来比较麻烦，所以无论三星或者高通平台目前都没有实现
(3) L2(SUSPEND)
100~300ms 时间里(T2) 如果没有数据发送接收，则进入L2状态(PHY SUSPEND mode)进行power save
(4) L3(SLEEP)
T3时间没有数据发送接收则进入Sleep状态。
这个状态关闭EHCI以节省电流消耗，但缺点是需要re-enumeration，所以wakeup时间较长。
HSIC bus被 floating。关于HSIC的状态，以后再说。
Samsung AP和Qualcomm APQ的HSIC PM差异：
Qualcomm APQ进入L2状态的时候会把HSIC PHY off掉然后拉低STROBE / DATA line，所以在XO Sleep的时候也可以通过MPM Interrupt来唤醒系统，所以不必实现L3状态也可以得到满意的睡眠电流。
但Samsung AP在进入L2状态的时候，没有实现通过STROBE Line进行唤醒的功能，所以需要增加一个host_wakeup gpio来实现了L2状态下的AP唤醒。而且HSIC PHY/LINK Controller的电源和其他的h/w block相连，所以实现了L3状态，在XO sleep的时候需要把HSIC PHY电源关掉(DATA/STROBE line不能由软件控制)。
高通平台的状态转换图：
三星平台的状态转换图：
状态转换的说明：
1) L0 -> L2 : suspend signaling by AP
2) L2 -> L0 :
AP init : resume signaling
CP init : (AP cannot recognize remote wakeup) CP request resume by Trigger
HOST_WAKE GPIO
3) L2 -> L3 : AP notify entering L3 with HOST_RDY GPIO Low, after CP response via DEVICE_RDY
GPIO Low to AP, After receiving DEVICE_RADY GPIO Low, AP triggers L3 and every
hsic related HOST power goes off.
4) L3 -> L0 :
AP init : AP wakes up CP via HOST_RDY GPIO high, CP acks by DEVICE_RDY GPIO high,
HOST do reset_resume for fast detect for last attached device.
CP init : CP wakes up AP through HOST_WAKE GPIO, followed seq same as AP init. 下面来根据代码看一下状态转换的实现
在mdm_hsic_pm.c文件的probe函数里，注册了两个notifier call函数。这两个函数会分别查看系统状态和hsic状态。
pm_data->pm_notifier.notifier_call = mdm_hsic_pm_notify_event;
register_pm_notifier(&pm_data->pm_notifier);
pm_data->phy_nfb.notifier_call = mdm_hsic_pm_phy_notify;
phy_register_notifier(&pm_data->phy_nfb); //这个函数就是对/drivers/usb/host/ehci-5p.c文件中hsic的电源状态做处理的
//前面说的T1,T2,T3时间怎么设置的，在什么时间点发状态，需要看hsic驱动，后面再说
//ehci-5p.c在L2状态下只是wake_unlock了pm_data->l2_wake，没有发送notifier event，只是做hsic相关
//的处理。（s5p_ehci_runtime_suspend()->request_active_lock_release()->wake_unlock()）
//所以以下函数里处理的都是L0<->L3之前的转换
static int mdm_hsic_pm_phy_notify(struct notifier_block *nfb,
unsigned long event, void *arg)
{
struct mdm_hsic_pm_data *pm_data =
container_of(nfb, struct mdm_hsic_pm_data, phy_nfb);
int ret = 0;
/* in shutdown(including modem fatal) do not need to wait dev ready */
if (pm_data->shutdown)
return 0;
switch (event) {
case STATE_HSIC_RESUME://L3状态状态转到L0状态，和前面说的一样，拉低host_ready端口，等待
//device_ready也被拉低
set_host_stat(pm_data, POWER_ON);
ret = wait_dev_pwr_stat(pm_data, POWER_ON);
break;
//STATE_HSIC_SUSPEND在s5p_ehci_suspend()里发送这个函数是suspend，
//所以应该是已经要power off的时候才调用的。
//static const struct dev_pm_ops s5p_ehci_pm_ops = {
// .suspend = s5p_ehci_suspend,
// .resume = s5p_ehci_resume,
// .runtime_suspend = s5p_ehci_runtime_suspend,
// .runtime_resume = s5p_ehci_runtime_resume,
//};
case STATE_HSIC_SUSPEND://L2转到L3状态！！
case STATE_HSIC_LPA_ENTER:
set_host_stat(pm_data, POWER_OFF);
ret = wait_dev_pwr_stat(pm_data, POWER_OFF);
if (ret) {
set_host_stat(pm_data, POWER_ON);
/* pm_runtime_resume(pm_data->udev->dev.parent->parent); */
return ret;
}
break;
case STATE_HSIC_LPA_WAKE:
lpa_handling = true;
pr_info("%s: set lpa handling to true\n", __func__);
request_active_lock_set("15510000.mdmpm_pdata");
pr_info("set hsic lpa wake\n");
break;
case STATE_HSIC_LPA_PHY_INIT:
pr_info("set hsic lpa phy init\n");
break;
case STATE_HSIC_LPA_CHECK:
#if 0
if (lpcharge)
return 0;
else
#endif
if (!get_pm_data_by_dev_name("15510000.mdmpm_pdata"))
return 1;
else
return 0;
case STATE_HSIC_LPA_ENABLE:
#if 0
if (lpcharge)
return 0;
else
#endif
if (pm_data)
return pm_data->shutdown;
else
return 1;
default:
pr_info("unknown lpa state\n");
break;
}
return NOTIFY_DONE;
}看完上面这个函数，就可以知道L0 <-> L2之间的状态转换，只是HISC驱动做的事情，不需要做上面说的三个gpio管脚的控制。只是在s5p_ehci_runtime_suspend()和s5p_ehci_runtime_resume()函数中添加wake_lock和wake_unlock操作就可以。
上面也说了L3->L0的状态转换，那CP唤醒AP的时候的操作是怎么样的？
host_wake gpio已经设定成了enable_irq_wake()。
static irqreturn_t mdm_hsic_irq_handler(int irq, void *data)
{
int irq_level;
struct mdm_hsic_pm_data *pm_data = data;
if (!pm_data || !pm_data->intf_cnt || !pm_data->udev)
return IRQ_HANDLED;
if (pm_data->shutdown)
return IRQ_HANDLED;
/** * host wake up handler, takes both edge * in rising, isr triggers L2 -> L0 resume */
//注释应该是写错了，应该是从L3 -> L0
irq_level = gpio_get_value(pm_data->gpio_host_wake);
pr_info("%s: detect %s edge\n", __func__,
irq_level ? "Rising" : "Falling");
if (irq_level != HSIC_RESUME_TRIGGER_LEVEL)
return IRQ_HANDLED;
//pm_data->block_request在mdm_hsic_pm_notify_event()里
//PM_SUSPEND_PREPARE的时候设置成了true。PM_POST_SUSPEND的时候设置成了false。
//所以只有在PM_SUSPEND时候才进入下面的if语句。由于已经使能了host_wake管脚的
//wakeup功能(enable_irq_wake)。所以系统应该开始启动。跑到这里如果发现block_request还是1
//表示还没有启动完毕，就只需要在这里设置wake_lock即可，不需要做其他操作。
//如果启动完毕，在mdm_hsic_pm_notify_event()函数的PM_POST_SUSPEND里block_request为0
//也就不会进入这个以下的if语句。
if (pm_data->block_request) {
pr_info("%s: request blocked by kernel suspending\n", __func__);
pm_data->state_busy = true;
/* for blocked request, set wakelock to return at dpm suspend */
wake_lock(&pm_data->l2_wake);
return IRQ_HANDLED;
}
#if 0
if (pm_request_resume(&pm_data->udev->dev) < 0)
pr_err("%s: unable to add pm work for rpm\n", __func__);
/* check runtime pm runs in Active state, after 100ms */
queue_delayed_work(pm_data->wq, &pm_data->request_resume_work,
msecs_to_jiffies(200));
#else
queue_delayed_work(pm_data->wq, &pm_data->request_resume_work, 0);
#endif
return IRQ_HANDLED;
}在系统醒来的时候状态下，也就是在L0状态下如果发生host_wake中断，就会调用request_resume_work对应的workqueue函数mdm_hsic_rpm_check().
这个函数用了两个函数pm_runtime_resume和pm_runtime_suspended。
int pm_runtime_resume(struct device *dev);
对设备执行子系统级的恢复回调;返回0表示成功；如果设备的运行时PM状态已经是“活跃的(active)”就返回1；或失败时错误代码，其中-EAGAIN意味着在未来试图恢复设备可能是安全的；但应附加对‘power.runtime_error’进行检查
int pm_runtime_suspend(struct device *dev);
对设备执行子系统级的挂起回调;返回0表示成功；如果设备的运行时PM状态已经是“挂起”则返回1；或失败时返回错误代码，其中，-EAGAIN或-EBUSY意味着企图在未来再次挂起设备是安全的。
static void mdm_hsic_rpm_check(struct work_struct *work)
{
struct mdm_hsic_pm_data *pm_data =
container_of(work, struct mdm_hsic_pm_data,
request_resume_work.work);
struct device *dev;
if (pm_data->shutdown)
return;
pr_info("%s\n", __func__);
if (!pm_data->udev)
return;
if (lpa_handling) {
pr_info("ignore resume req, lpa handling\n");
return;
}
dev = &pm_data->udev->dev;
if (pm_runtime_resume(dev) < 0)
//看上面说明，小于0表示设备resume失败，需要delay 20ms重新调用
queue_delayed_work(pm_data->wq, &pm_data->request_resume_work,
msecs_to_jiffies(20));
if (pm_runtime_suspended(dev))
//pm_runtime_suspended返回1表示设备已经挂起，则和上面一样，
//delay 20ms在调用resume函数
queue_delayed_work(pm_data->wq, &pm_data->request_resume_work,
msecs_to_jiffies(20));
}