static void ventana_usb_init(void)
{
tegra_pm_irq_set_wake_type(INT_USB, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING);
enable_irq_wake(INT_USB);
tegra_usb_phy_init(tegra_usb_phy_pdata, ARRAY_SIZE(tegra_usb_phy_pdata));
/* OTG should be the first to be registered */
tegra_otg_device.dev.platform_data = &tegra_otg_pdata;
platform_device_register(&tegra_otg_device);
platform_device_register(&tegra_udc_device);
platform_device_register(&tegra_ehci2_device);
tegra_ehci3_device.dev.platform_data=&tegra_ehci_pdata[2];
platform_device_register(&tegra_ehci3_device);
}
static int tegra_set_type(struct irq_data *d, unsigned int flow_type)
{
int wake_size;
int wake_list[PMC_MAX_WAKE_COUNT];
int i;
int err = 0;
int ret;
tegra_irq_to_wake(d->irq, wake_list, &wake_size);
for (i = 0; i < wake_size; i++) {
ret = tegra_pm_irq_set_wake_type(wake_list[i], flow_type);
if (ret < 0) {
pr_err("Set lp0 wake type=%d fail for irq=%d, wake%d ret=%d\n",
flow_type, d->irq, wake_list[i], ret);
if (!err)
err = ret;
}
}
return err;
}
static int baseband_xmm_power_driver_probe(struct platform_device *device)
{
struct baseband_power_platform_data *data
= (struct baseband_power_platform_data *)
device->dev.platform_data;
struct device *dev = &device->dev;
unsigned long flags;
int err, i;
int ap_wake_irq;
pr_info("%s\n", __func__);
pr_info("[XMM] enum_delay_ms=%ld\n", enum_delay_ms);
/* check for platform data */
if (!data)
return -ENODEV;
/* check if supported modem */
if (data->baseband_type != BASEBAND_XMM) {
pr_err("unsuppported modem\n");
return -ENODEV;
}
/* save platform data */
baseband_power_driver_data = data;
/* create device file */
/*err = device_create_file(dev, &dev_attr_xmm_onoff);
if (err < 0) {
pr_err("%s - device_create_file failed\n", __func__);
return -ENODEV;
}*/
/* init wake lock */
wake_lock_init(&wakelock, WAKE_LOCK_SUSPEND, "baseband_xmm_power");
wake_lock_init(&modem_recovery_wakelock, WAKE_LOCK_SUSPEND, "modem_recovery");
/* init spin lock */
spin_lock_init(&xmm_lock);
/* request baseband gpio(s) */
tegra_baseband_gpios[0].gpio = baseband_power_driver_data
->modem.xmm.bb_rst;
tegra_baseband_gpios[1].gpio = baseband_power_driver_data
->modem.xmm.bb_on;
tegra_baseband_gpios[2].gpio = baseband_power_driver_data
->modem.xmm.ipc_bb_wake;
tegra_baseband_gpios[3].gpio = baseband_power_driver_data
->modem.xmm.ipc_ap_wake;
tegra_baseband_gpios[4].gpio = baseband_power_driver_data
->modem.xmm.ipc_hsic_active;
tegra_baseband_gpios[5].gpio = baseband_power_driver_data
->modem.xmm.ipc_hsic_sus_req;
tegra_baseband_gpios[6].gpio = baseband_power_driver_data
->modem.xmm.bb_vbat;
tegra_baseband_gpios[7].gpio = baseband_power_driver_data
->modem.xmm.ipc_bb_rst_ind;
tegra_baseband_gpios[8].gpio = baseband_power_driver_data
->modem.xmm.ipc_bb_force_crash;
err = gpio_request_array(tegra_baseband_gpios,
ARRAY_SIZE(tegra_baseband_gpios));
if (err < 0) {
pr_err("%s - request gpio(s) failed\n", __func__);
return -ENODEV;
}
/* location is at /sys/devices/platform/baseband_xmm_power */
for (i = 0; i < (ARRAY_SIZE(xmm_device_attr) - 1); i++) {
err = device_create_file(dev, &xmm_device_attr[i]);
if (err) {
pr_err("create file %d failed, err = %d\n", i, err);
goto failed_create_file;
}
}
/* get regulator LDO7 for hsic power */
if (!reg_grouper_hsic) {
reg_grouper_hsic = regulator_get(NULL, "vddio_hsic");
if (IS_ERR_OR_NULL(reg_grouper_hsic)) {
pr_err("grouper 3G HSIC power on LDO7 failed\n");
reg_grouper_hsic = NULL;
return PTR_ERR(reg_grouper_hsic);
}
regulator_set_voltage(reg_grouper_hsic, 1200000, 1200000);
}
/* request baseband irq(s) */
if (modem_flash && modem_pm) {
pr_debug("%s: request_irq IPC_AP_WAKE_IRQ\n", __func__);
ipc_ap_wake_state = IPC_AP_WAKE_UNINIT;
err = request_threaded_irq(
gpio_to_irq(data->modem.xmm.ipc_ap_wake),
NULL,
baseband_xmm_power_ipc_ap_wake_irq,
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
"IPC_AP_WAKE_IRQ",
NULL);
if (err < 0) {
pr_err("%s - request irq IPC_AP_WAKE_IRQ failed\n",
__func__);
return err;
}
ap_wake_irq = enable_irq_wake(gpio_to_irq(data->modem.xmm.ipc_ap_wake));
tegra_pm_irq_set_wake_type(ap_wake_irq, IRQF_TRIGGER_FALLING);
enable_irq_wake(ap_wake_irq);
if (err < 0)
pr_err("%s: enable_irq_wake error\n", __func__);
ipc_ap_wake_state = IPC_AP_WAKE_IRQ_READY;
if (modem_ver >= XMM_MODEM_VER_1130) {
pr_debug("%s: ver > 1130: AP_WAKE_INIT1\n", __func__);
/* ver 1130 or later starts in INIT1 state */
ipc_ap_wake_state = IPC_AP_WAKE_INIT1;
}
}
/* init work queue */
workqueue = create_singlethread_workqueue
("baseband_xmm_power_workqueue");
if (!workqueue) {
pr_err("cannot create workqueue\n");
return -1;
}
baseband_xmm_power_work = (struct baseband_xmm_power_work_t *)
kmalloc(sizeof(struct baseband_xmm_power_work_t), GFP_KERNEL);
if (!baseband_xmm_power_work) {
pr_err("cannot allocate baseband_xmm_power_work\n");
return -1;
}
INIT_WORK((struct work_struct *) baseband_xmm_power_work,
baseband_xmm_power_work_func);
baseband_xmm_power_work->state = BBXMM_WORK_INIT;
queue_work(workqueue,
(struct work_struct *) baseband_xmm_power_work);
/* init work objects */
INIT_WORK(&init1_work, baseband_xmm_power_init1_work);
INIT_WORK(&init2_work, baseband_xmm_power_init2_work);
INIT_WORK(&L2_resume_work, baseband_xmm_power_L2_resume_work);
INIT_WORK(&autopm_resume_work, baseband_xmm_power_autopm_resume);
/* init state variables */
register_hsic_device = true;
CP_initiated_L2toL0 = false;
spin_lock_irqsave(&xmm_lock, flags);
baseband_xmm_powerstate = BBXMM_PS_UNINIT;
wakeup_pending = false;
spin_unlock_irqrestore(&xmm_lock, flags);
usb_register_notify(&usb_xmm_nb);
pr_debug("%s }\n", __func__);
return 0;
failed_create_file:
while (i--)
device_remove_file(dev, &xmm_device_attr[i]);
return err;
}
static int tegra_set_type(struct irq_data *d, unsigned int flow_type)
{
int wake = tegra_irq_to_wake(d->irq);
return tegra_pm_irq_set_wake_type(wake, flow_type);
}
static int tegra_set_type(struct irq_data *d, unsigned int flow_type)
{
return tegra_pm_irq_set_wake_type(d->irq, flow_type);
}
