/* Allocates and init the pcd */
static int pcd_init(dwc_otg_device_t *otg_dev)
{
int retval = 0;
otg_dev->pcd = dwc_otg_pcd_init(otg_dev->core_if,
&static_data->static_pcd);
if (!otg_dev->pcd) {
__DWC_ERROR("dwc_otg_pcd_init failed\n");
return -DWC_E_NO_MEMORY;
}
dwc_otg_pcd_start(otg_dev->pcd, &fops);
return retval;
}
/**
* This function initialized the PCD portion of the driver.
*
*/
int pcd_init(
struct dwc_otg_device *_dev
)
{
//dwc_otg_device_t *otg_dev = platform_get_drvdata(_dev);
dwc_otg_device_t *otg_dev = _dev;
int retval = 0;
int irq;
DWC_DEBUGPL(DBG_PCDV, "%s(%p)\n", __func__, _dev);
otg_dev->pcd = dwc_otg_pcd_init(otg_dev->core_if);
if (!otg_dev->pcd) {
DWC_ERROR("dwc_otg_pcd_init failed\n");
return -ENOMEM;
}
gadget_wrapper = alloc_wrapper(_dev);
/*
* Initialize EP structures
*/
gadget_add_eps(gadget_wrapper);
/*
* Setup interupt handler
*/
#if 0
irq = platform_get_irq(_dev, 0);
DWC_DEBUGPL(DBG_ANY, "registering handler for irq%d\n", irq);
retval = request_irq(irq, dwc_otg_pcd_irq,
0, gadget_wrapper->gadget.name,
otg_dev->pcd);
//SA_SHIRQ, gadget_wrapper->gadget.name,
if (retval != 0) {
DWC_ERROR("request of irq%d failed\n", irq);
free_wrapper(gadget_wrapper);
return -EBUSY;
}
#endif
sprd_pcd = otg_dev->pcd;
dwc_otg_pcd_start(gadget_wrapper->pcd, &fops);
return retval;
}
/**
* This function initialized the PCD portion of the driver.
*
*/
int pcd_init(struct platform_device *_dev)
{
dwc_otg_device_t *otg_dev = platform_get_otgdata(_dev);
int irq;
int retval = 0;
DWC_DEBUGPL(DBG_PCDV, "%s(%p)\n", __func__, _dev);
otg_dev->pcd = dwc_otg_pcd_init(otg_dev->core_if);
pdev = otg_dev->core_if;
if (!otg_dev->pcd) {
DWC_ERROR("dwc_otg_pcd_init failed\n");
return -ENOMEM;
}
gadget_wrapper = alloc_wrapper(_dev);
gadget_wrapper->p = otg_dev;
/*
* Initialize EP structures
*/
gadget_add_eps(gadget_wrapper);
/*
* Setup interupt handler
*/
irq = platform_get_irq(_dev, 0);
if(irq < 0) {
DWC_ERROR("no irq? (irq=%d)\n", irq);
kfree(otg_dev->pcd);
return -ENODEV;
}
DWC_DEBUGPL(DBG_ANY, "registering handler for irq%d\n", irq);
retval = request_irq(irq, dwc_otg_pcd_irq,
IRQF_SHARED, gadget_wrapper->gadget.name,
otg_dev->pcd);
if (retval != 0) {
DWC_ERROR("request of irq%d failed\n", irq);
free_wrapper(gadget_wrapper);
return -EBUSY;
}
dwc_otg_pcd_start(gadget_wrapper->pcd, &fops);
return retval;
}
int dwc_core_init()
{
int32_t snpsid;
snpsid = dwc_read_reg32(DWC_REG_GSNPSID);
if ((snpsid & 0xFFFFF000) != 0x4F542000) {
ERR("Bad value for SNPSID: 0x%08x\n", snpsid);
return -1;
}
ERR("dwc core init is ok!\n");// show printf is ok.
/*
* Disable the global interrupt until all the interrupt
* handlers are installed.
*/
gahbcfg_data_t ahbcfg = {.d32 = 0 };
ahbcfg.b.glblintrmsk = 1; /* Enable interrupts bit */
dwc_modify_reg32(DWC_REG_GAHBCFG, ahbcfg.d32, 0);
/*
* Initialize the DWC_otg core.
*/
dwc_otg_core_init();
dwc_modify_reg32(DWC_REG_DCTL,0,2);// Disconnect data line
dwc_otg_pcd_init();
dwc_modify_reg32(DWC_REG_DCTL,2,0);// Connect data line
/*
* Enable the global interrupt after all the interrupt
* handlers are installed.
*/
dwc_otg_enable_global_interrupts();
return 0;
}
int
dwc_otg_irq()
{
dwc_common_irq();
dwc_pcd_irq();
return 0;
}
#elif defined(PCI_INTERFACE)
struct pci_dev *_dev
#endif
)
{
#ifdef LM_INTERFACE
dwc_otg_device_t *otg_dev = lm_get_drvdata(_dev);
#elif defined(PCI_INTERFACE)
dwc_otg_device_t *otg_dev = pci_get_drvdata(_dev);
#endif
int retval = 0;
DWC_DEBUGPL(DBG_PCDV, "%s(%p)\n", __func__, _dev);
otg_dev->pcd = dwc_otg_pcd_init(otg_dev->core_if);
if (!otg_dev->pcd) {
DWC_ERROR("dwc_otg_pcd_init failed\n");
return -ENOMEM;
}
otg_dev->pcd->otg_dev = otg_dev;
gadget_wrapper = alloc_wrapper(_dev);
/*
* Initialize EP structures
*/
gadget_add_eps(gadget_wrapper);
/*
* Setup interupt handler
/**
* This function initialized the PCD portion of the driver.
*
*/
int pcd_init(
struct platform_device *_dev
)
{
dwc_otg_device_t *otg_dev = platform_get_drvdata(_dev);
int retval = 0;
int irq;
DWC_DEBUGPL(DBG_PCDV, "%s(%p)\n", __func__, _dev);
wake_lock_init(&usb_wake_lock, WAKE_LOCK_SUSPEND, "usb_work");
otg_dev->pcd = dwc_otg_pcd_init(otg_dev->core_if);
if (!otg_dev->pcd) {
DWC_ERROR("dwc_otg_pcd_init failed\n");
return -ENOMEM;
}
gadget_wrapper = alloc_wrapper(_dev);
/*
* Initialize EP structures
*/
gadget_add_eps(gadget_wrapper);
/*
* Setup interupt handler
*/
irq = platform_get_irq(_dev, 0);
DWC_DEBUGPL(DBG_ANY, "registering handler for irq%d\n", irq);
retval = request_irq(irq, dwc_otg_pcd_irq,
0, gadget_wrapper->gadget.name,
otg_dev->pcd);
//SA_SHIRQ, gadget_wrapper->gadget.name,
if (retval != 0) {
DWC_ERROR("request of irq%d failed\n", irq);
free_wrapper(gadget_wrapper);
return -EBUSY;
}
/*
* initialize a timer for checking cable type.
*/
{
setup_timer(&setup_transfer_timer,setup_transfer_timer_fun,(unsigned long)gadget_wrapper);
setup_transfer_timer_start = 0;
}
setup_timer(&gadget_wrapper->cable_timer, cable_detect_handler,
(unsigned long)gadget_wrapper);
/*
* setup usb cable detect interupt
*/
{
int plug_irq;
plug_irq = usb_alloc_vbus_irq();
if (plug_irq < 0) {
pr_warning("cannot alloc vbus irq\n");
return -EBUSY;
}
usb_set_vbus_irq_type(plug_irq, VBUS_PLUG_IN);
gadget_wrapper->vbus = usb_get_vbus_state();
pr_info("now usb vbus is :%d\n", gadget_wrapper->vbus);
retval = request_irq(plug_irq, usb_detect_handler, IRQF_SHARED,
"usb detect", otg_dev->pcd);
}
spin_lock_init(&gadget_wrapper->lock);
INIT_WORK(&gadget_wrapper->detect_work, usb_detect_works);
gadget_wrapper->detect_wq = create_singlethread_workqueue("usb detect wq");
/*
* register a switch device for sending pnp message,
* for the user app need be notified immediately
* when plug in & plug out happen;
*/
gadget_wrapper->sdev.name = "charger_cable";
retval = switch_dev_register(&gadget_wrapper->sdev);
if (retval){
pr_warning("register switch dev error:%s\n", __func__);
}
dwc_otg_pcd_start(gadget_wrapper->pcd, &fops);
/*
* dwc driver is ok, check if the cable is insert, if no,
* shutdown udc for saving power.
*/
if (!gadget_wrapper->vbus){
pr_debug("vbus is not power now \n");
gadget_wrapper->udc_startup = 1;
__udc_shutdown();
}
gadget_wrapper->udc_startup = gadget_wrapper->vbus;
gadget_wrapper->enabled = 0;
return retval;
}
static int __devinit dwc_otg_driver_probe(struct platform_device *ofdev)
{
int retval;
struct dwc_otg_device *dwc_dev;
struct device *dev = &ofdev->dev;
struct resource res;
ulong gusbcfg_addr;
u32 usbcfg = 0;
struct resource *nres = 0;
#ifdef CONFIG_OF
u32 prop;
u32 prop_array[15];
#endif
dwc_dev = kzalloc(sizeof(*dwc_dev), GFP_KERNEL);
if (!dwc_dev) {
dev_err(dev, "kmalloc of dwc_otg_device failed\n");
retval = -ENOMEM;
goto fail_dwc_dev;
}
/* Retrieve the memory and IRQ resources. */
dwc_dev->irq = platform_get_irq(ofdev, 0);
if (dwc_dev->irq == NO_IRQ) {
dev_err(dev, "no device irq\n");
retval = -ENODEV;
goto fail_of_irq;
}
nres = platform_get_resource(ofdev, IORESOURCE_MEM, 0);
res = *nres;
if(nres == 0) {
dev_err(dev, "%s: Can't get USB-OTG register address\n",
__func__);
retval = -ENOMEM;
goto fail_of_irq;
}
dwc_dev->phys_addr = res.start;
dwc_dev->base_len = res.end - res.start + 1;
if (!request_mem_region(dwc_dev->phys_addr,
dwc_dev->base_len, dwc_driver_name)) {
dev_err(dev, "request_mem_region failed\n");
retval = -EBUSY;
goto fail_of_irq;
}
/* Map the DWC_otg Core memory into virtual address space. */
dwc_dev->base = ioremap(platform_get_resource(ofdev, IORESOURCE_MEM, 0)->start, SZ_256K);
if (!dwc_dev->base) {
dev_err(dev, "ioremap() failed\n");
retval = -ENOMEM;
goto fail_ioremap;
}
dev_dbg(dev, "mapped base=0x%08x\n", (__force u32)dwc_dev->base);
/*
* Initialize driver data to point to the global DWC_otg
* Device structure.
*/
dev_set_drvdata(dev, dwc_dev);//driver
dwc_dev->core_if =
dwc_otg_cil_init(dwc_dev->base, &dwc_otg_module_params);
if (!dwc_dev->core_if) {
dev_err(dev, "CIL initialization failed!\n");
retval = -ENOMEM;
goto fail_cil_init;
}
/*
* Set the wqfunc of this core_if as "not set"
*/
dwc_dev->core_if->wqfunc_setup_done = 0;
/*
* Validate parameter values after dwc_otg_cil_init.
*/
if (check_parameters(dwc_dev->core_if)) {
retval = -EINVAL;
goto fail_check_param;
}
#ifdef CONFIG_OF
if(!of_property_read_u32(ofdev->dev.of_node,
"dma-mask", (u32*)&dwc_otg_dma_mask)) {
dev->dma_mask = &dwc_otg_dma_mask;
}
else {
dev->dma_mask = NULL;
}
if(!of_property_read_u32(ofdev->dev.of_node,
"ulpi-ddr", &prop)) {
dwc_otg_module_params.phy_ulpi_ddr = prop;
}
if(!of_property_read_u32(ofdev->dev.of_node,
"host-rx-fifo-size", &prop)) {
dwc_otg_module_params.host_rx_fifo_size = prop;
}
if(!of_property_read_u32(ofdev->dev.of_node,
"dev-rx-fifo-size", &prop)) {
dwc_otg_module_params.dev_rx_fifo_size = prop;
}
if(!of_property_read_u32(ofdev->dev.of_node,
"host-nperio-tx-fifo-size", &prop)) {
dwc_otg_module_params.host_nperio_tx_fifo_size = prop;
}
if(!of_property_read_u32(ofdev->dev.of_node,
"dev-nperio-tx-fifo-size", &prop)) {
dwc_otg_module_params.dev_nperio_tx_fifo_size = prop;
}
if(!of_property_read_u32(ofdev->dev.of_node,
"host-perio-tx-fifo-size", &prop)) {
dwc_otg_module_params.host_perio_tx_fifo_size = prop;
}
if(!of_property_read_u32_array(ofdev->dev.of_node,
"dev-perio-tx-fifo-size", prop_array, MAX_PERIO_FIFOS)) {
int i;
for(i=0; i<MAX_PERIO_FIFOS; i++)
dwc_otg_module_params.dev_tx_fifo_size[i]
= prop_array[i];
}
if(!of_property_read_u32_array(ofdev->dev.of_node,
"dev-tx-fifo-size", prop_array, MAX_TX_FIFOS)) {
int i;
for(i=0; i<MAX_TX_FIFOS; i++)
dwc_otg_module_params.dev_perio_tx_fifo_size[i]
= prop_array[i];
}
#endif
usb_nop_xceiv_register();
dwc_dev->core_if->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
if (!dwc_dev->core_if->xceiv) {
retval = -ENODEV;
goto fail_xceiv;
}
dwc_set_feature(dwc_dev->core_if);
/* Initialize the DWC_otg core. */
dwc_otg_core_init(dwc_dev->core_if);
/*
* Disable the global interrupt until all the interrupt
* handlers are installed.
*/
spin_lock(&dwc_dev->lock);
dwc_otg_disable_global_interrupts(dwc_dev->core_if);
spin_unlock(&dwc_dev->lock);
/*
* Install the interrupt handler for the common interrupts before
* enabling common interrupts in core_init below.
*/
retval = request_irq(dwc_dev->irq, dwc_otg_common_irq,
IRQF_SHARED, "dwc_otg", dwc_dev);
if (retval) {
dev_err(dev, "request of irq%d failed retval: %d\n",
dwc_dev->irq, retval);
retval = -EBUSY;
goto fail_req_irq;
} else {
dwc_dev->common_irq_installed = 1;
}
if (!dwc_has_feature(dwc_dev->core_if, DWC_HOST_ONLY)) {
//if (dwc_has_feature(dwc_dev->core_if, DWC_DEVICE_ONLY)) {
/* Initialize the PCD */
retval = dwc_otg_pcd_init(dev);
if (retval) {
dev_err(dev, "dwc_otg_pcd_init failed\n");
dwc_dev->pcd = NULL;
goto fail_req_irq;
}
}
gusbcfg_addr = (ulong) (dwc_dev->core_if->core_global_regs)
+ DWC_GUSBCFG;
if (!dwc_has_feature(dwc_dev->core_if, DWC_DEVICE_ONLY)) {
//if (dwc_has_feature(dwc_dev->core_if, DWC_HOST_ONLY)) {
/* Initialize the HCD and force_host_mode */
usbcfg = dwc_reg_read(gusbcfg_addr, 0);
usbcfg |= DWC_USBCFG_FRC_HST_MODE;
dwc_reg_write(gusbcfg_addr, 0, usbcfg);
retval = dwc_otg_hcd_init(dev, dwc_dev);
if (retval) {
dev_err(dev, "dwc_otg_hcd_init failed\n");
dwc_dev->hcd = NULL;
goto fail_hcd;
}
/* configure chargepump interrupt */
dwc_dev->hcd->cp_irq = platform_get_irq_byname(ofdev, "chargepumpirq");
if(dwc_dev->hcd->cp_irq != -ENXIO) {
retval = request_irq(dwc_dev->hcd->cp_irq,
dwc_otg_externalchgpump_irq,
IRQF_SHARED,
"dwc_otg_ext_chg_pump", dwc_dev);
if (retval) {
dev_err(dev,
"request of irq failed retval: %d\n",
retval);
retval = -EBUSY;
goto fail_hcd;
} else {
dev_dbg(dev, "%s: ExtChgPump Detection "
"IRQ registered\n", dwc_driver_name);
}
}
}
/*
* Enable the global interrupt after all the interrupt
* handlers are installed.
*/
dwc_otg_enable_global_interrupts(dwc_dev->core_if);
#if 0
usbcfg = dwc_reg_read(gusbcfg_addr, 0);
usbcfg &= ~DWC_USBCFG_FRC_HST_MODE;
dwc_reg_write(gusbcfg_addr, 0, usbcfg);
#endif
return 0;
fail_hcd:
free_irq(dwc_dev->irq, dwc_dev);
if (!dwc_has_feature(dwc_dev->core_if, DWC_HOST_ONLY)) {
if (dwc_dev->pcd)
dwc_otg_pcd_remove(dev);
}
fail_req_irq:
usb_put_phy(dwc_dev->core_if->xceiv);
fail_xceiv:
usb_nop_xceiv_unregister();
fail_check_param:
dwc_otg_cil_remove(dwc_dev->core_if);
fail_cil_init:
dev_set_drvdata(dev, NULL);
iounmap(dwc_dev->base);
fail_ioremap:
release_mem_region(dwc_dev->phys_addr, dwc_dev->base_len);
fail_of_irq:
kfree(dwc_dev);
fail_dwc_dev:
return retval;
}
/**
* This function initialized the PCD portion of the driver.
*
*/
int pcd_init(
struct platform_device *_dev
)
{
dwc_otg_device_t *otg_dev = platform_get_drvdata(_dev);
struct sprd_usb_platform_data *pdata= _dev->dev.platform_data;
int retval = 0;
int irq;
int plug_irq;
DWC_DEBUGPL(DBG_PCDV, "%s(%p)\n", __func__, _dev);
device_dwc_otg = &(_dev->dev);
if (dwc_otg_is_dma_enable(otg_dev->core_if)) {
_dev->dev.dma_mask = &dwc_otg_pcd_dmamask;
_dev->dev.coherent_dma_mask = dwc_otg_pcd_dmamask;
} else {
_dev->dev.dma_mask = (void *)0;
_dev->dev.coherent_dma_mask = 0;
}
wake_lock_init(&usb_wake_lock, WAKE_LOCK_SUSPEND, "usb_work");
// wake_lock(&usb_wake_lock);
otg_dev->pcd = dwc_otg_pcd_init(otg_dev->core_if);
if (!otg_dev->pcd) {
DWC_ERROR("dwc_otg_pcd_init failed\n");
return -ENOMEM;
}
gadget_wrapper = alloc_wrapper(_dev);
/*
* Initialize EP structures
*/
gadget_add_eps(gadget_wrapper);
/*
* Setup interupt handler
*/
irq = platform_get_irq(_dev, 0);
DWC_DEBUGPL(DBG_ANY, "registering handler for irq%d\n", irq);
retval = request_irq(irq, dwc_otg_pcd_irq,
IRQF_SHARED, gadget_wrapper->gadget.name,
otg_dev->pcd);
//SA_SHIRQ, gadget_wrapper->gadget.name,
if (retval != 0) {
DWC_ERROR("request of irq%d failed\n", irq);
free_wrapper(gadget_wrapper);
return -EBUSY;
}
/*
* initialize a timer for checking cable type.
*/
#ifdef USB_SETUP_TIMEOUT_RESTART
{
setup_timer(&setup_transfer_timer,
setup_transfer_timer_fun,
(unsigned long)gadget_wrapper);
setup_transfer_timer_start = 0;
}
#endif
INIT_DELAYED_WORK(&gadget_wrapper->cable2pc, cable2pc_detect_works);
gadget_wrapper->cable2pc_wq = create_singlethread_workqueue("usb 2 pc wq");
#ifdef CONFIG_USB_EXTERNAL_DETECT
register_otg_func(NULL, dwc_peripheral_start, otg_dev);
#else
/*
* setup usb cable detect interupt
*/
#ifndef CONFIG_MFD_SM5504
{
plug_irq = usb_alloc_vbus_irq(pdata->gpio_chgdet);
if (plug_irq < 0) {
pr_warning("cannot alloc vbus irq\n");
return -EBUSY;
}
usb_set_vbus_irq_type(plug_irq, VBUS_PLUG_IN);
#ifdef CONFIG_SC_FPGA
gadget_wrapper->vbus = 1;
#else
gadget_wrapper->vbus = usb_get_vbus_state();
#endif
pr_info("now usb vbus is :%d\n", gadget_wrapper->vbus);
retval = request_irq(plug_irq, usb_detect_handler, IRQF_SHARED | IRQF_NO_SUSPEND,
"usb detect", otg_dev->pcd);
#ifndef CONFIG_MUIC_CABLE_DETECT
disable_irq(plug_irq);
#endif
}
//gadget_wrapper->vbus = 1;//used when debug in FPGA, which doesn't have vbus operation
#endif
spin_lock_init(&gadget_wrapper->lock);
#ifdef CONFIG_SC_FPGA
gadget_wrapper->vbus = 1;
#endif
INIT_WORK(&gadget_wrapper->detect_work, usb_detect_works);
gadget_wrapper->detect_wq = create_singlethread_workqueue("usb detect wq");
#endif
/*
* register a switch device for sending pnp message,
* for the user app need be notified immediately
* when plug in & plug out happen;
*/
gadget_wrapper->sdev.name = "charger_cable";
retval = switch_dev_register(&gadget_wrapper->sdev);
if (retval){
pr_warning("register switch dev error:%s\n", __func__);
}
dwc_otg_pcd_start(gadget_wrapper->pcd, &fops);
/*
* dwc driver is ok, check if the cable is insert, if no,
* shutdown udc for saving power.
*/
if (!gadget_wrapper->vbus){
pr_debug("vbus is not power now \n");
gadget_wrapper->udc_startup = 1;
__udc_shutdown();
}
gadget_wrapper->udc_startup = gadget_wrapper->vbus;
gadget_wrapper->enabled = 0;
retval = usb_add_gadget_udc(&_dev->dev, &gadget_wrapper->gadget);
if (!retval)
return retval;
return retval;
}
