int set_otg_notify(struct otg_notify *n)
{
int ret = 0;
pr_info("%s\n",__func__);
if (!u_notify) {
ret = create_usb_notify();
if (ret) {
pr_err("unable create_usb_notify\n");
goto err;
}
}
if (u_notify->o_notify && n) {
pr_err("error : already set o_notify\n");
goto err;
}
pr_info("registered otg_notify +\n");
if (!n) {
pr_err("otg notify structure is null\n");
ret = -EFAULT;
goto err1;
}
u_notify->o_notify = n;
ATOMIC_INIT_NOTIFIER_HEAD(&u_notify->o_notify->otg_notifier);
u_notify->otg_nb.notifier_call = otg_notifier_callback;
ret = atomic_notifier_chain_register(&u_notify->o_notify->otg_notifier,
&u_notify->otg_nb);
if (ret < 0) {
pr_err("atomic_notifier_chain_register failed\n");
goto err1;
}
BLOCKING_INIT_NOTIFIER_HEAD(&u_notify->o_notify->extra_notifier);
u_notify->extra_nb.notifier_call = extra_notifier_callback;
ret = blocking_notifier_chain_register
(&u_notify->o_notify->extra_notifier, &u_notify->extra_nb);
if (ret < 0) {
pr_err("blocking_notifier_chain_register failed\n");
goto err2;
}
if (!n->unsupport_host) {
u_notify->ndev.name = "usb_otg";
u_notify->ndev.set_booster = n->vbus_drive;
ret = host_notify_dev_register(&u_notify->ndev);
if (ret < 0) {
pr_err("host_notify_dev_register is failed\n");
goto err3;
}
if (!n->vbus_drive) {
pr_err("vbus_drive is null\n");
goto err4;
}
}
if (gpio_is_valid(n->vbus_detect_gpio) ||
gpio_is_valid(n->redriver_en_gpio)) {
ret = register_gpios(n);
if (ret < 0) {
pr_err("register_gpios is failed\n");
goto err4;
}
}
if (n->is_wakelock)
wake_lock_init(&u_notify->wlock,
WAKE_LOCK_SUSPEND, "usb_notify");
if (n->booting_delay_sec) {
INIT_DELAYED_WORK(&u_notify->b_delay.booting_work,
reserve_state_check);
schedule_delayed_work(&u_notify->b_delay.booting_work,
n->booting_delay_sec*HZ);
}
register_usbdev_notify();
pr_info("registered otg_notify -\n");
return 0;
err4:
if (!n->unsupport_host)
host_notify_dev_unregister(&u_notify->ndev);
err3:
blocking_notifier_chain_unregister(&u_notify->o_notify->extra_notifier,
&u_notify->extra_nb);
err2:
atomic_notifier_chain_unregister(&u_notify->o_notify->otg_notifier,
&u_notify->otg_nb);
err1:
u_notify->o_notify = NULL;
err:
return ret;
}
static int s5pc110_start_otg(u32 regs)
{
int ret_val = 0;
u32 reg_val = 0;
struct platform_device *pdev = g_pdev;
struct sec_otghost *otghost = NULL;
struct sec_otghost_data *otg_data = dev_get_platdata(&pdev->dev);
otg_dbg(OTG_DBG_OTGHCDI_DRIVER, "s3c_otg_drv_probe\n");
pr_info("otg probe start : 0x%x\n", regs);
/*init for host mode*/
/**
Allocate memory for the base HCD & Initialize the base HCD.
*/
g_pUsbHcd = usb_create_hcd(&s5pc110_otg_hc_driver, &pdev->dev,
"s3cotg");/*pdev->dev.bus_id*/
if (g_pUsbHcd == NULL) {
ret_val = -ENOMEM;
otg_err(OTG_DBG_OTGHCDI_DRIVER,
"failed to usb_create_hcd\n");
goto err_out_clk;
}
#if 1
pr_info("otg probe regs : 0x%p\n", otg_data->regs);
if (!regs) {
pr_info("otg mapping hcd resource\n");
/* mapping hcd resource & device resource*/
g_pUsbHcd->rsrc_start = pdev->resource[0].start;
g_pUsbHcd->rsrc_len = pdev->resource[0].end -
pdev->resource[0].start + 1;
if (!request_mem_region(g_pUsbHcd->rsrc_start,
g_pUsbHcd->rsrc_len, gHcdName)) {
otg_err(OTG_DBG_OTGHCDI_DRIVER,
"failed to request_mem_region\n");
ret_val = -EBUSY;
goto err_out_create_hcd;
}
pr_info("otg rsrc_start %llu, ren %llu\n",
g_pUsbHcd->rsrc_start,
g_pUsbHcd->rsrc_len);
pr_info("otg regs : %p\n", S3C_VA_HSOTG);
/* Physical address => Virtual address */
g_pUsbHcd->regs = S3C_VA_HSOTG;
g_pUDCBase = (u8 *)g_pUsbHcd->regs;
} else
g_pUDCBase = (u8 *)regs;
#endif
pr_info("otg g_pUDCBase 0x%p\n", g_pUDCBase);
g_pUsbHcd->self.otg_port = 1;
otghost = hcd_to_sec_otghost(g_pUsbHcd);
if (otghost == NULL) {
otg_err(true, "failed to get otghost hcd\n");
ret_val = USB_ERR_FAIL;
goto err_out_create_hcd;
}
otghost->otg_data = otg_data;
INIT_WORK(&otghost->work, otg_power_work);
otghost->wq = create_singlethread_workqueue("sec_otghostd");
/* call others' init() */
ret_val = otg_hcd_init_modules(otghost);
if (ret_val != USB_ERR_SUCCESS) {
otg_err(OTG_DBG_OTGHCDI_DRIVER,
"failed to otg_hcd_init_modules\n");
ret_val = USB_ERR_FAIL;
goto err_out_create_hcd;
}
/**
* Attempt to ensure this device is really a s5pc110 USB-OTG Controller.
* Read and verify the SNPSID register contents. The value should be
* 0x45F42XXX, which corresponds to "OT2", as in "OTG version 2.XX".
*/
reg_val = read_reg_32(0x40);
pr_info("otg reg 0x40 = %x\n", reg_val);
if ((reg_val & 0xFFFFF000) != 0x4F542000) {
otg_err(OTG_DBG_OTGHCDI_DRIVER,
"Bad value for SNPSID: 0x%x\n", reg_val);
ret_val = -EINVAL;
goto err_out_create_hcd_init;
}
#ifdef CONFIG_USB_HOST_NOTIFY
if (otg_data->host_notify) {
g_pUsbHcd->host_notify = otg_data->host_notify;
g_pUsbHcd->ndev.name = dev_name(&pdev->dev);
ret_val = host_notify_dev_register(&g_pUsbHcd->ndev);
if (ret_val) {
otg_err(OTG_DBG_OTGHCDI_DRIVER,
"Failed to host_notify_dev_register\n");
goto err_out_create_hcd_init;
}
}
#endif
#ifdef CONFIG_USB_SEC_WHITELIST
if (otg_data->sec_whlist_table_num)
g_pUsbHcd->sec_whlist_table_num =
otg_data->sec_whlist_table_num;
#endif
/*
* Finish generic HCD initialization and start the HCD. This function
* allocates the DMA buffer pool, registers the USB bus, requests the
* IRQ line, and calls s5pc110_otghcd_start method.
*/
ret_val = usb_add_hcd(g_pUsbHcd,
pdev->resource[1].start, IRQF_DISABLED);
if (ret_val < 0) {
otg_err(OTG_DBG_OTGHCDI_DRIVER,
"Failed to add hcd driver\n");
goto err_out_host_notify_register;
}
otg_dbg(OTG_DBG_OTGHCDI_DRIVER,
"OTG HCD Initialized HCD, bus=%s, usbbus=%d\n",
"C110 OTG Controller", g_pUsbHcd->self.busnum);
/* otg_print_registers(); */
wake_lock_init(&otghost->wake_lock, WAKE_LOCK_SUSPEND, "usb_otg");
wake_lock(&otghost->wake_lock);
return USB_ERR_SUCCESS;
err_out_host_notify_register:
#ifdef CONFIG_USB_HOST_NOTIFY
host_notify_dev_unregister(&g_pUsbHcd->ndev);
#endif
err_out_create_hcd_init:
otg_hcd_deinit_modules(otghost);
if (!regs)
release_mem_region(g_pUsbHcd->rsrc_start, g_pUsbHcd->rsrc_len);
err_out_create_hcd:
usb_put_hcd(g_pUsbHcd);
err_out_clk:
return ret_val;
}
