/*
* Init
*/
static int __init usb_init(void)
{
int retval;
if (nousb) {
pr_info("%s: USB support disabled\n", usbcore_name);
return 0;
}
retval = usb_debugfs_init();
if (retval)
goto out;
retval = ksuspend_usb_init();
if (retval)
goto out;
retval = bus_register(&usb_bus_type);
if (retval)
goto bus_register_failed;
retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);
if (retval)
goto bus_notifier_failed;
retval = usb_major_init();
if (retval)
goto major_init_failed;
retval = usb_register(&usbfs_driver);
if (retval)
goto driver_register_failed;
retval = usb_devio_init();
if (retval)
goto usb_devio_init_failed;
retval = usbfs_init();
if (retval)
goto fs_init_failed;
retval = usb_hub_init();
if (retval)
goto hub_init_failed;
retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);
if (!retval)
goto out;
usb_hub_cleanup();
hub_init_failed:
usbfs_cleanup();
fs_init_failed:
usb_devio_cleanup();
usb_devio_init_failed:
usb_deregister(&usbfs_driver);
driver_register_failed:
usb_major_cleanup();
major_init_failed:
bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
bus_notifier_failed:
bus_unregister(&usb_bus_type);
bus_register_failed:
ksuspend_usb_cleanup();
out:
return retval;
}
/**
* gserial_setup - initialize TTY driver for one or more ports
* @g: gadget to associate with these ports
* @count: how many ports to support
* Context: may sleep
*
* The TTY stack needs to know in advance how many devices it should
* plan to manage. Use this call to set up the ports you will be
* exporting through USB. Later, connect them to functions based
* on what configuration is activated by the USB host; and disconnect
* them as appropriate.
*
* An example would be a two-configuration device in which both
* configurations expose port 0, but through different functions.
* One configuration could even expose port 1 while the other
* one doesn't.
*
* Returns negative errno or zero.
*/
int gserial_setup(struct usb_gadget *g, unsigned count)
{
unsigned i;
struct usb_cdc_line_coding coding;
int status;
if (count == 0 || count > N_PORTS)
return -EINVAL;
gs_tty_driver = alloc_tty_driver(count);
if (!gs_tty_driver)
return -ENOMEM;
gs_tty_driver->driver_name = "g_serial";
gs_tty_driver->name = PREFIX;
/* uses dynamically assigned dev_t values */
gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
| TTY_DRIVER_RESET_TERMIOS;
gs_tty_driver->init_termios = tty_std_termios;
/* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
* MS-Windows. Otherwise, most of these flags shouldn't affect
* anything unless we were to actually hook up to a serial line.
*/
gs_tty_driver->init_termios.c_cflag =
B9600 | CS8 | CREAD | HUPCL | CLOCAL;
gs_tty_driver->init_termios.c_ispeed = 9600;
gs_tty_driver->init_termios.c_ospeed = 9600;
coding.dwDTERate = cpu_to_le32(9600);
coding.bCharFormat = 8;
coding.bParityType = USB_CDC_NO_PARITY;
coding.bDataBits = USB_CDC_1_STOP_BITS;
tty_set_operations(gs_tty_driver, &gs_tty_ops);
gserial_wq = create_singlethread_workqueue("k_gserial");
if (!gserial_wq) {
status = -ENOMEM;
goto fail;
}
/* make devices be openable */
for (i = 0; i < count; i++) {
mutex_init(&ports[i].lock);
status = gs_port_alloc(i, &coding);
if (status) {
count = i;
goto fail;
}
}
n_ports = count;
/* export the driver ... */
status = tty_register_driver(gs_tty_driver);
if (status) {
pr_err("%s: cannot register, err %d\n",
__func__, status);
goto fail;
}
/* ... and sysfs class devices, so mdev/udev make /dev/ttyGS* */
for (i = 0; i < count; i++) {
struct device *tty_dev;
tty_dev = tty_register_device(gs_tty_driver, i, &g->dev);
if (IS_ERR(tty_dev))
pr_warning("%s: no classdev for port %d, err %ld\n",
__func__, i, PTR_ERR(tty_dev));
}
for (i = 0; i < count; i++)
usb_debugfs_init(ports[i].port, i);
pr_debug("%s: registered %d ttyGS* device%s\n", __func__,
count, (count == 1) ? "" : "s");
return status;
fail:
while (count--)
kfree(ports[count].port);
if (gserial_wq)
destroy_workqueue(gserial_wq);
put_tty_driver(gs_tty_driver);
gs_tty_driver = NULL;
return status;
}
static int userial_init(void)
{
unsigned i;
int status;
gs_tty_driver = alloc_tty_driver(MAX_U_SERIAL_PORTS);
if (!gs_tty_driver)
return -ENOMEM;
gs_tty_driver->driver_name = "g_serial";
gs_tty_driver->name = PREFIX;
/* uses dynamically assigned dev_t values */
gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
| TTY_DRIVER_RESET_TERMIOS;
gs_tty_driver->init_termios = tty_std_termios;
/* 9600-8-N-1 ... matches defaults expected by "usbser.sys" on
* MS-Windows. Otherwise, most of these flags shouldn't affect
* anything unless we were to actually hook up to a serial line.
*/
gs_tty_driver->init_termios.c_cflag =
B9600 | CS8 | CREAD | HUPCL | CLOCAL;
gs_tty_driver->init_termios.c_ispeed = 9600;
gs_tty_driver->init_termios.c_ospeed = 9600;
tty_set_operations(gs_tty_driver, &gs_tty_ops);
for (i = 0; i < MAX_U_SERIAL_PORTS; i++)
mutex_init(&ports[i].lock);
gserial_wq = create_singlethread_workqueue("k_gserial");
if (!gserial_wq) {
status = -ENOMEM;
goto fail;
}
/* export the driver ... */
status = tty_register_driver(gs_tty_driver);
if (status) {
pr_err("%s: cannot register, err %d\n",
__func__, status);
goto fail;
}
for (i = 0; i < MAX_U_SERIAL_PORTS; i++)
usb_debugfs_init(ports[i].port, i);
pr_debug("%s: registered %d ttyGS* device%s\n", __func__,
MAX_U_SERIAL_PORTS,
(MAX_U_SERIAL_PORTS == 1) ? "" : "s");
return status;
fail:
put_tty_driver(gs_tty_driver);
if (gserial_wq)
destroy_workqueue(gserial_wq);
gs_tty_driver = NULL;
return status;
}
static int msm72k_probe(struct platform_device *pdev)
{
struct resource *res;
struct usb_info *ui;
int irq;
int ret;
INFO("msm72k_probe\n");
ui = kzalloc(sizeof(struct usb_info), GFP_KERNEL);
if (!ui)
return -ENOMEM;
spin_lock_init(&ui->lock);
ui->pdev = pdev;
if (pdev->dev.platform_data) {
struct msm_hsusb_platform_data *pdata = pdev->dev.platform_data;
ui->phy_reset = pdata->phy_reset;
ui->phy_init_seq = pdata->phy_init_seq;
ui->usb_connected = pdata->usb_connected;
}
irq = platform_get_irq(pdev, 0);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res || (irq < 0))
return usb_free(ui, -ENODEV);
ui->addr = ioremap(res->start, 4096);
if (!ui->addr)
return usb_free(ui, -ENOMEM);
ui->buf = dma_alloc_coherent(&pdev->dev, 4096, &ui->dma, GFP_KERNEL);
if (!ui->buf)
return usb_free(ui, -ENOMEM);
ui->pool = dma_pool_create("msm72k_udc", NULL, 32, 32, 0);
if (!ui->pool)
return usb_free(ui, -ENOMEM);
INFO("msm72k_probe() io=%p, irq=%d, dma=%p(%x)\n",
ui->addr, irq, ui->buf, ui->dma);
ui->clk = clk_get(&pdev->dev, "usb_hs_clk");
if (IS_ERR(ui->clk))
return usb_free(ui, PTR_ERR(ui->clk));
ui->pclk = clk_get(&pdev->dev, "usb_hs_pclk");
if (IS_ERR(ui->pclk))
return usb_free(ui, PTR_ERR(ui->pclk));
ui->otgclk = clk_get(&pdev->dev, "usb_otg_clk");
if (IS_ERR(ui->otgclk))
ui->otgclk = NULL;
ui->coreclk = clk_get(&pdev->dev, "usb_hs_core_clk");
if (IS_ERR(ui->coreclk))
ui->coreclk = NULL;
ui->ebi1clk = clk_get(NULL, "ebi1_clk");
if (IS_ERR(ui->ebi1clk))
return usb_free(ui, PTR_ERR(ui->ebi1clk));
/* clear interrupts before requesting irq */
if (ui->coreclk)
clk_enable(ui->coreclk);
clk_enable(ui->clk);
clk_enable(ui->pclk);
if (ui->otgclk)
clk_enable(ui->otgclk);
writel(0, USB_USBINTR);
writel(0, USB_OTGSC);
if (ui->coreclk)
clk_disable(ui->coreclk);
if (ui->otgclk)
clk_disable(ui->otgclk);
clk_disable(ui->pclk);
clk_disable(ui->clk);
ret = request_irq(irq, usb_interrupt, 0, pdev->name, ui);
if (ret)
return usb_free(ui, ret);
enable_irq_wake(irq);
ui->irq = irq;
ui->gadget.ops = &msm72k_ops;
ui->gadget.is_dualspeed = 1;
device_initialize(&ui->gadget.dev);
dev_set_name(&ui->gadget.dev, "gadget");
ui->gadget.dev.parent = &pdev->dev;
ui->gadget.dev.dma_mask = pdev->dev.dma_mask;
the_usb_info = ui;
usb_debugfs_init(ui);
usb_prepare(ui);
return 0;
}
int gserial_setup(struct usb_gadget *g, unsigned count)
{
unsigned i;
struct usb_cdc_line_coding coding;
int status;
if (count == 0 || count > N_PORTS)
return -EINVAL;
gs_tty_driver = alloc_tty_driver(count);
if (!gs_tty_driver)
return -ENOMEM;
gs_tty_driver->owner = THIS_MODULE;
gs_tty_driver->driver_name = "g_serial";
gs_tty_driver->name = PREFIX;
gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
| TTY_DRIVER_RESET_TERMIOS;
gs_tty_driver->init_termios = tty_std_termios;
gs_tty_driver->init_termios.c_cflag =
B9600 | CS8 | CREAD | HUPCL | CLOCAL;
gs_tty_driver->init_termios.c_ispeed = 9600;
gs_tty_driver->init_termios.c_ospeed = 9600;
gs_tty_driver->init_termios.c_lflag = 0;
gs_tty_driver->init_termios.c_iflag = 0;
gs_tty_driver->init_termios.c_oflag = 0;
coding.dwDTERate = cpu_to_le32(9600);
coding.bCharFormat = 8;
coding.bParityType = USB_CDC_NO_PARITY;
coding.bDataBits = USB_CDC_1_STOP_BITS;
tty_set_operations(gs_tty_driver, &gs_tty_ops);
gserial_wq = create_singlethread_workqueue("k_gserial");
if (!gserial_wq) {
status = -ENOMEM;
goto fail;
}
for (i = 0; i < count; i++) {
mutex_init(&ports[i].lock);
status = gs_port_alloc(i, &coding);
if (status) {
count = i;
goto fail;
}
}
n_ports = count;
gs_tty_driver->need_rcv_lock = 1;
status = tty_register_driver(gs_tty_driver);
if (status) {
put_tty_driver(gs_tty_driver);
pr_err("%s: cannot register, err %d\n",
__func__, status);
goto fail;
}
for (i = 0; i < count; i++) {
struct device *tty_dev;
tty_dev = tty_register_device(gs_tty_driver, i, &g->dev);
if (IS_ERR(tty_dev))
pr_warning("%s: no classdev for port %d, err %ld\n",
__func__, i, PTR_ERR(tty_dev));
}
for (i = 0; i < count; i++)
usb_debugfs_init(ports[i].port, i);
pr_debug("%s: registered %d ttyGS* device%s\n", __func__,
count, (count == 1) ? "" : "s");
return status;
fail:
while (count--)
kfree(ports[count].port);
if (gserial_wq)
destroy_workqueue(gserial_wq);
put_tty_driver(gs_tty_driver);
gs_tty_driver = NULL;
return status;
}
static int msm72k_probe(struct platform_device *pdev)
{
struct usb_info *ui;
struct msm_hsusb_gadget_platform_data *pdata;
struct msm_otg *otg;
int retval;
INFO("msm72k_probe\n");
ui = kzalloc(sizeof(struct usb_info), GFP_KERNEL);
if (!ui)
return -ENOMEM;
ui->pdev = pdev;
if (pdev->dev.platform_data) {
pdata = pdev->dev.platform_data;
ui->phy_reset = pdata->phy_reset;
ui->phy_init_seq = pdata->phy_init_seq;
ui->chg_init = pdata->chg_init;
ui->chg_connected = pdata->chg_connected;
ui->chg_vbus_draw = pdata->chg_vbus_draw;
ui->usb_connected = pdata->usb_connected;
}
if (ui->chg_init)
ui->chg_init(1);
ui->buf = dma_alloc_coherent(&pdev->dev, 4096, &ui->dma, GFP_KERNEL);
if (!ui->buf)
return usb_free(ui, -ENOMEM);
ui->pool = dma_pool_create("msm72k_udc", NULL, 32, 32, 0);
if (!ui->pool)
return usb_free(ui, -ENOMEM);
/* FIXME: dmb cannot be called from interrupt context
* for the first time; Need to verify on how it needs
* to be fixed
*/
dmb();
ui->xceiv = otg_get_transceiver();
if (!ui->xceiv)
return usb_free(ui, -ENODEV);
otg = to_msm_otg(ui->xceiv);
ui->addr = otg->regs;
ui->gadget.ops = &msm72k_ops;
ui->gadget.is_dualspeed = 1;
device_initialize(&ui->gadget.dev);
strcpy(ui->gadget.dev.bus_id, "gadget");
ui->gadget.dev.parent = &pdev->dev;
ui->gadget.dev.dma_mask = pdev->dev.dma_mask;
the_usb_info = ui;
pm_qos_add_requirement(PM_QOS_CPU_DMA_LATENCY, DRIVER_NAME,
PM_QOS_DEFAULT_VALUE);
pm_qos_add_requirement(PM_QOS_SYSTEM_BUS_FREQ, DRIVER_NAME,
PM_QOS_DEFAULT_VALUE);
usb_debugfs_init(ui);
usb_prepare(ui);
retval = otg_set_peripheral(ui->xceiv, &ui->gadget);
if (retval) {
pr_err("%s: Cannot bind the transceiver, retval:(%d)\n",
__func__, retval);
return usb_free(ui, retval);
}
return 0;
}
static int msm72k_probe(struct platform_device *pdev)
{
struct resource *res;
struct usb_info *ui;
int irq;
int ret;
INFO("msm72k_probe\n");
ui = kzalloc(sizeof(struct usb_info), GFP_KERNEL);
if (!ui)
return -ENOMEM;
ui->pdev = pdev;
if (pdev->dev.platform_data) {
struct msm_hsusb_platform_data *pdata = pdev->dev.platform_data;
ui->phy_reset = pdata->phy_reset;
ui->phy_init_seq = pdata->phy_init_seq;
}
irq = platform_get_irq(pdev, 0);
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!res || (irq < 0))
return usb_free(ui, -ENODEV);
ui->addr = ioremap(res->start, 4096);
if (!ui->addr)
return usb_free(ui, -ENOMEM);
ui->buf = dma_alloc_coherent(&pdev->dev, 4096, &ui->dma, GFP_KERNEL);
if (!ui->buf)
return usb_free(ui, -ENOMEM);
ui->pool = dma_pool_create("msm72k_udc", NULL, 32, 32, 0);
if (!ui->pool)
return usb_free(ui, -ENOMEM);
INFO("msm72k_probe() io=%p, irq=%d, dma=%p(%x)\n",
ui->addr, irq, ui->buf, ui->dma);
ui->clk = clk_get(&pdev->dev, "usb_hs_clk");
if (IS_ERR(ui->clk))
return usb_free(ui, PTR_ERR(ui->clk));
ui->pclk = clk_get(&pdev->dev, "usb_hs_pclk");
if (IS_ERR(ui->pclk))
return usb_free(ui, PTR_ERR(ui->pclk));
/* FIXME: dmb cannot be called from interrupt context
* for the first time; Need to verify on how it needs
* to be fixed
*/
dmb();
ret = request_irq(irq, usb_interrupt, 0, pdev->name, ui);
if (ret)
return usb_free(ui, ret);
enable_irq_wake(irq);
ui->irq = irq;
ui->gadget.ops = &msm72k_ops;
ui->gadget.is_dualspeed = 1;
device_initialize(&ui->gadget.dev);
strcpy(ui->gadget.dev.bus_id, "gadget");
ui->gadget.dev.parent = &pdev->dev;
ui->gadget.dev.dma_mask = pdev->dev.dma_mask;
the_usb_info = ui;
usb_debugfs_init(ui);
usb_prepare(ui);
return 0;
}