aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/gadget/fsl_qe_udc.c
diff options
context:
space:
mode:
authorSebastian Andrzej Siewior <sebastian@breakpoint.cc>2012-02-04 12:55:25 -0500
committerFelipe Balbi <balbi@ti.com>2012-05-04 08:53:01 -0400
commitd77c1198666d87a9b21e9594ca29ac7e42011623 (patch)
treea21334bdffcb83780a06cb308293f082bec51eda /drivers/usb/gadget/fsl_qe_udc.c
parentd809f78f81fc1c7e9d8afaaa51ec4813612aff94 (diff)
usb: gadget: fsl_qe_udc: convert to new style start/stop
This patches converts the driver into the new style start/stop interface. As a result the driver no longer uses the static global udc_conroller variable. Compile tested only. Cc: Li Yang <leoli@freescale.com> Signed-off-by: Sebastian Andrzej Siewior <sebastian@breakpoint.cc> Signed-off-by: Felipe Balbi <balbi@ti.com>
Diffstat (limited to 'drivers/usb/gadget/fsl_qe_udc.c')
-rw-r--r--drivers/usb/gadget/fsl_qe_udc.c310
1 files changed, 140 insertions, 170 deletions
diff --git a/drivers/usb/gadget/fsl_qe_udc.c b/drivers/usb/gadget/fsl_qe_udc.c
index 26cf99320188..aae6e98594c9 100644
--- a/drivers/usb/gadget/fsl_qe_udc.c
+++ b/drivers/usb/gadget/fsl_qe_udc.c
@@ -71,9 +71,6 @@ static struct usb_endpoint_descriptor qe_ep0_desc = {
71 .wMaxPacketSize = USB_MAX_CTRL_PAYLOAD, 71 .wMaxPacketSize = USB_MAX_CTRL_PAYLOAD,
72}; 72};
73 73
74/* it is initialized in probe() */
75static struct qe_udc *udc_controller;
76
77/******************************************************************** 74/********************************************************************
78 * Internal Used Function Start 75 * Internal Used Function Start
79********************************************************************/ 76********************************************************************/
@@ -188,8 +185,8 @@ static int qe_ep0_stall(struct qe_udc *udc)
188{ 185{
189 qe_eptx_stall_change(&udc->eps[0], 1); 186 qe_eptx_stall_change(&udc->eps[0], 1);
190 qe_eprx_stall_change(&udc->eps[0], 1); 187 qe_eprx_stall_change(&udc->eps[0], 1);
191 udc_controller->ep0_state = WAIT_FOR_SETUP; 188 udc->ep0_state = WAIT_FOR_SETUP;
192 udc_controller->ep0_dir = 0; 189 udc->ep0_dir = 0;
193 return 0; 190 return 0;
194} 191}
195 192
@@ -450,13 +447,13 @@ static int qe_ep_rxbd_update(struct qe_ep *ep)
450 447
451 ep->rxbuf_d = virt_to_phys((void *)ep->rxbuffer); 448 ep->rxbuf_d = virt_to_phys((void *)ep->rxbuffer);
452 if (ep->rxbuf_d == DMA_ADDR_INVALID) { 449 if (ep->rxbuf_d == DMA_ADDR_INVALID) {
453 ep->rxbuf_d = dma_map_single(udc_controller->gadget.dev.parent, 450 ep->rxbuf_d = dma_map_single(ep->udc->gadget.dev.parent,
454 ep->rxbuffer, 451 ep->rxbuffer,
455 size, 452 size,
456 DMA_FROM_DEVICE); 453 DMA_FROM_DEVICE);
457 ep->rxbufmap = 1; 454 ep->rxbufmap = 1;
458 } else { 455 } else {
459 dma_sync_single_for_device(udc_controller->gadget.dev.parent, 456 dma_sync_single_for_device(ep->udc->gadget.dev.parent,
460 ep->rxbuf_d, size, 457 ep->rxbuf_d, size,
461 DMA_FROM_DEVICE); 458 DMA_FROM_DEVICE);
462 ep->rxbufmap = 0; 459 ep->rxbufmap = 0;
@@ -698,14 +695,14 @@ en_done:
698 return -ENODEV; 695 return -ENODEV;
699} 696}
700 697
701static inline void qe_usb_enable(void) 698static inline void qe_usb_enable(struct qe_udc *udc)
702{ 699{
703 setbits8(&udc_controller->usb_regs->usb_usmod, USB_MODE_EN); 700 setbits8(&udc->usb_regs->usb_usmod, USB_MODE_EN);
704} 701}
705 702
706static inline void qe_usb_disable(void) 703static inline void qe_usb_disable(struct qe_udc *udc)
707{ 704{
708 clrbits8(&udc_controller->usb_regs->usb_usmod, USB_MODE_EN); 705 clrbits8(&udc->usb_regs->usb_usmod, USB_MODE_EN);
709} 706}
710 707
711/*----------------------------------------------------------------------------* 708/*----------------------------------------------------------------------------*
@@ -1655,13 +1652,13 @@ static int qe_ep_disable(struct usb_ep *_ep)
1655 if (ep->dir != USB_DIR_IN) { 1652 if (ep->dir != USB_DIR_IN) {
1656 kfree(ep->rxframe); 1653 kfree(ep->rxframe);
1657 if (ep->rxbufmap) { 1654 if (ep->rxbufmap) {
1658 dma_unmap_single(udc_controller->gadget.dev.parent, 1655 dma_unmap_single(udc->gadget.dev.parent,
1659 ep->rxbuf_d, size, 1656 ep->rxbuf_d, size,
1660 DMA_FROM_DEVICE); 1657 DMA_FROM_DEVICE);
1661 ep->rxbuf_d = DMA_ADDR_INVALID; 1658 ep->rxbuf_d = DMA_ADDR_INVALID;
1662 } else { 1659 } else {
1663 dma_sync_single_for_cpu( 1660 dma_sync_single_for_cpu(
1664 udc_controller->gadget.dev.parent, 1661 udc->gadget.dev.parent,
1665 ep->rxbuf_d, size, 1662 ep->rxbuf_d, size,
1666 DMA_FROM_DEVICE); 1663 DMA_FROM_DEVICE);
1667 } 1664 }
@@ -1879,9 +1876,10 @@ static struct usb_ep_ops qe_ep_ops = {
1879/* Get the current frame number */ 1876/* Get the current frame number */
1880static int qe_get_frame(struct usb_gadget *gadget) 1877static int qe_get_frame(struct usb_gadget *gadget)
1881{ 1878{
1879 struct qe_udc *udc = container_of(gadget, struct qe_udc, gadget);
1882 u16 tmp; 1880 u16 tmp;
1883 1881
1884 tmp = in_be16(&udc_controller->usb_param->frame_n); 1882 tmp = in_be16(&udc->usb_param->frame_n);
1885 if (tmp & 0x8000) 1883 if (tmp & 0x8000)
1886 tmp = tmp & 0x07ff; 1884 tmp = tmp & 0x07ff;
1887 else 1885 else
@@ -1927,9 +1925,10 @@ static int qe_pullup(struct usb_gadget *gadget, int is_on)
1927 return -ENOTSUPP; 1925 return -ENOTSUPP;
1928} 1926}
1929 1927
1930static int fsl_qe_start(struct usb_gadget_driver *driver, 1928static int fsl_qe_start(struct usb_gadget *gadget,
1931 int (*bind)(struct usb_gadget *)); 1929 struct usb_gadget_driver *driver);
1932static int fsl_qe_stop(struct usb_gadget_driver *driver); 1930static int fsl_qe_stop(struct usb_gadget *gadget,
1931 struct usb_gadget_driver *driver);
1933 1932
1934/* defined in usb_gadget.h */ 1933/* defined in usb_gadget.h */
1935static struct usb_gadget_ops qe_gadget_ops = { 1934static struct usb_gadget_ops qe_gadget_ops = {
@@ -1939,8 +1938,8 @@ static struct usb_gadget_ops qe_gadget_ops = {
1939 .vbus_session = qe_vbus_session, 1938 .vbus_session = qe_vbus_session,
1940 .vbus_draw = qe_vbus_draw, 1939 .vbus_draw = qe_vbus_draw,
1941 .pullup = qe_pullup, 1940 .pullup = qe_pullup,
1942 .start = fsl_qe_start, 1941 .udc_start = fsl_qe_start,
1943 .stop = fsl_qe_stop, 1942 .udc_stop = fsl_qe_stop,
1944}; 1943};
1945 1944
1946/*------------------------------------------------------------------------- 1945/*-------------------------------------------------------------------------
@@ -2189,7 +2188,7 @@ static int reset_irq(struct qe_udc *udc)
2189 if (udc->usb_state == USB_STATE_DEFAULT) 2188 if (udc->usb_state == USB_STATE_DEFAULT)
2190 return 0; 2189 return 0;
2191 2190
2192 qe_usb_disable(); 2191 qe_usb_disable(udc);
2193 out_8(&udc->usb_regs->usb_usadr, 0); 2192 out_8(&udc->usb_regs->usb_usadr, 0);
2194 2193
2195 for (i = 0; i < USB_MAX_ENDPOINTS; i++) { 2194 for (i = 0; i < USB_MAX_ENDPOINTS; i++) {
@@ -2201,7 +2200,7 @@ static int reset_irq(struct qe_udc *udc)
2201 udc->usb_state = USB_STATE_DEFAULT; 2200 udc->usb_state = USB_STATE_DEFAULT;
2202 udc->ep0_state = WAIT_FOR_SETUP; 2201 udc->ep0_state = WAIT_FOR_SETUP;
2203 udc->ep0_dir = USB_DIR_OUT; 2202 udc->ep0_dir = USB_DIR_OUT;
2204 qe_usb_enable(); 2203 qe_usb_enable(udc);
2205 return 0; 2204 return 0;
2206} 2205}
2207 2206
@@ -2326,92 +2325,65 @@ static irqreturn_t qe_udc_irq(int irq, void *_udc)
2326/*------------------------------------------------------------------------- 2325/*-------------------------------------------------------------------------
2327 Gadget driver probe and unregister. 2326 Gadget driver probe and unregister.
2328 --------------------------------------------------------------------------*/ 2327 --------------------------------------------------------------------------*/
2329static int fsl_qe_start(struct usb_gadget_driver *driver, 2328static int fsl_qe_start(struct usb_gadget *gadget,
2330 int (*bind)(struct usb_gadget *)) 2329 struct usb_gadget_driver *driver)
2331{ 2330{
2332 int retval; 2331 struct qe_udc *udc;
2333 unsigned long flags = 0; 2332 unsigned long flags;
2334
2335 /* standard operations */
2336 if (!udc_controller)
2337 return -ENODEV;
2338
2339 if (!driver || driver->max_speed < USB_SPEED_FULL
2340 || !bind || !driver->disconnect || !driver->setup)
2341 return -EINVAL;
2342
2343 if (udc_controller->driver)
2344 return -EBUSY;
2345 2333
2334 udc = container_of(gadget, struct qe_udc, gadget);
2346 /* lock is needed but whether should use this lock or another */ 2335 /* lock is needed but whether should use this lock or another */
2347 spin_lock_irqsave(&udc_controller->lock, flags); 2336 spin_lock_irqsave(&udc->lock, flags);
2348 2337
2349 driver->driver.bus = NULL; 2338 driver->driver.bus = NULL;
2350 /* hook up the driver */ 2339 /* hook up the driver */
2351 udc_controller->driver = driver; 2340 udc->driver = driver;
2352 udc_controller->gadget.dev.driver = &driver->driver; 2341 udc->gadget.dev.driver = &driver->driver;
2353 udc_controller->gadget.speed = driver->max_speed; 2342 udc->gadget.speed = driver->max_speed;
2354 spin_unlock_irqrestore(&udc_controller->lock, flags);
2355
2356 retval = bind(&udc_controller->gadget);
2357 if (retval) {
2358 dev_err(udc_controller->dev, "bind to %s --> %d",
2359 driver->driver.name, retval);
2360 udc_controller->gadget.dev.driver = NULL;
2361 udc_controller->driver = NULL;
2362 return retval;
2363 }
2364 2343
2365 /* Enable IRQ reg and Set usbcmd reg EN bit */ 2344 /* Enable IRQ reg and Set usbcmd reg EN bit */
2366 qe_usb_enable(); 2345 qe_usb_enable(udc);
2367 2346
2368 out_be16(&udc_controller->usb_regs->usb_usber, 0xffff); 2347 out_be16(&udc->usb_regs->usb_usber, 0xffff);
2369 out_be16(&udc_controller->usb_regs->usb_usbmr, USB_E_DEFAULT_DEVICE); 2348 out_be16(&udc->usb_regs->usb_usbmr, USB_E_DEFAULT_DEVICE);
2370 udc_controller->usb_state = USB_STATE_ATTACHED; 2349 udc->usb_state = USB_STATE_ATTACHED;
2371 udc_controller->ep0_state = WAIT_FOR_SETUP; 2350 udc->ep0_state = WAIT_FOR_SETUP;
2372 udc_controller->ep0_dir = USB_DIR_OUT; 2351 udc->ep0_dir = USB_DIR_OUT;
2373 dev_info(udc_controller->dev, "%s bind to driver %s \n", 2352 spin_unlock_irqrestore(&udc->lock, flags);
2374 udc_controller->gadget.name, driver->driver.name); 2353
2354 dev_info(udc->dev, "%s bind to driver %s\n", udc->gadget.name,
2355 driver->driver.name);
2375 return 0; 2356 return 0;
2376} 2357}
2377 2358
2378static int fsl_qe_stop(struct usb_gadget_driver *driver) 2359static int fsl_qe_stop(struct usb_gadget *gadget,
2360 struct usb_gadget_driver *driver)
2379{ 2361{
2362 struct qe_udc *udc;
2380 struct qe_ep *loop_ep; 2363 struct qe_ep *loop_ep;
2381 unsigned long flags; 2364 unsigned long flags;
2382 2365
2383 if (!udc_controller) 2366 udc = container_of(gadget, struct qe_udc, gadget);
2384 return -ENODEV;
2385
2386 if (!driver || driver != udc_controller->driver)
2387 return -EINVAL;
2388
2389 /* stop usb controller, disable intr */ 2367 /* stop usb controller, disable intr */
2390 qe_usb_disable(); 2368 qe_usb_disable(udc);
2391 2369
2392 /* in fact, no needed */ 2370 /* in fact, no needed */
2393 udc_controller->usb_state = USB_STATE_ATTACHED; 2371 udc->usb_state = USB_STATE_ATTACHED;
2394 udc_controller->ep0_state = WAIT_FOR_SETUP; 2372 udc->ep0_state = WAIT_FOR_SETUP;
2395 udc_controller->ep0_dir = 0; 2373 udc->ep0_dir = 0;
2396 2374
2397 /* stand operation */ 2375 /* stand operation */
2398 spin_lock_irqsave(&udc_controller->lock, flags); 2376 spin_lock_irqsave(&udc->lock, flags);
2399 udc_controller->gadget.speed = USB_SPEED_UNKNOWN; 2377 udc->gadget.speed = USB_SPEED_UNKNOWN;
2400 nuke(&udc_controller->eps[0], -ESHUTDOWN); 2378 nuke(&udc->eps[0], -ESHUTDOWN);
2401 list_for_each_entry(loop_ep, &udc_controller->gadget.ep_list, 2379 list_for_each_entry(loop_ep, &udc->gadget.ep_list, ep.ep_list)
2402 ep.ep_list)
2403 nuke(loop_ep, -ESHUTDOWN); 2380 nuke(loop_ep, -ESHUTDOWN);
2404 spin_unlock_irqrestore(&udc_controller->lock, flags); 2381 spin_unlock_irqrestore(&udc->lock, flags);
2405
2406 /* report disconnect; the controller is already quiesced */
2407 driver->disconnect(&udc_controller->gadget);
2408 2382
2409 /* unbind gadget and unhook driver. */ 2383 udc->gadget.dev.driver = NULL;
2410 driver->unbind(&udc_controller->gadget); 2384 udc->driver = NULL;
2411 udc_controller->gadget.dev.driver = NULL;
2412 udc_controller->driver = NULL;
2413 2385
2414 dev_info(udc_controller->dev, "unregistered gadget driver '%s'\r\n", 2386 dev_info(udc->dev, "unregistered gadget driver '%s'\r\n",
2415 driver->driver.name); 2387 driver->driver.name);
2416 return 0; 2388 return 0;
2417} 2389}
@@ -2530,21 +2502,22 @@ static int __devinit qe_ep_config(struct qe_udc *udc, unsigned char pipe_num)
2530 *----------------------------------------------------------------------*/ 2502 *----------------------------------------------------------------------*/
2531static void qe_udc_release(struct device *dev) 2503static void qe_udc_release(struct device *dev)
2532{ 2504{
2533 int i = 0; 2505 struct qe_udc *udc = container_of(dev, struct qe_udc, gadget.dev);
2506 int i;
2534 2507
2535 complete(udc_controller->done); 2508 complete(udc->done);
2536 cpm_muram_free(cpm_muram_offset(udc_controller->ep_param[0])); 2509 cpm_muram_free(cpm_muram_offset(udc->ep_param[0]));
2537 for (i = 0; i < USB_MAX_ENDPOINTS; i++) 2510 for (i = 0; i < USB_MAX_ENDPOINTS; i++)
2538 udc_controller->ep_param[i] = NULL; 2511 udc->ep_param[i] = NULL;
2539 2512
2540 kfree(udc_controller); 2513 kfree(udc);
2541 udc_controller = NULL;
2542} 2514}
2543 2515
2544/* Driver probe functions */ 2516/* Driver probe functions */
2545static const struct of_device_id qe_udc_match[]; 2517static const struct of_device_id qe_udc_match[];
2546static int __devinit qe_udc_probe(struct platform_device *ofdev) 2518static int __devinit qe_udc_probe(struct platform_device *ofdev)
2547{ 2519{
2520 struct qe_udc *udc;
2548 const struct of_device_id *match; 2521 const struct of_device_id *match;
2549 struct device_node *np = ofdev->dev.of_node; 2522 struct device_node *np = ofdev->dev.of_node;
2550 struct qe_ep *ep; 2523 struct qe_ep *ep;
@@ -2561,44 +2534,44 @@ static int __devinit qe_udc_probe(struct platform_device *ofdev)
2561 return -ENODEV; 2534 return -ENODEV;
2562 2535
2563 /* Initialize the udc structure including QH member and other member */ 2536 /* Initialize the udc structure including QH member and other member */
2564 udc_controller = qe_udc_config(ofdev); 2537 udc = qe_udc_config(ofdev);
2565 if (!udc_controller) { 2538 if (!udc) {
2566 dev_err(&ofdev->dev, "failed to initialize\n"); 2539 dev_err(&ofdev->dev, "failed to initialize\n");
2567 return -ENOMEM; 2540 return -ENOMEM;
2568 } 2541 }
2569 2542
2570 udc_controller->soc_type = (unsigned long)match->data; 2543 udc->soc_type = (unsigned long)match->data;
2571 udc_controller->usb_regs = of_iomap(np, 0); 2544 udc->usb_regs = of_iomap(np, 0);
2572 if (!udc_controller->usb_regs) { 2545 if (!udc->usb_regs) {
2573 ret = -ENOMEM; 2546 ret = -ENOMEM;
2574 goto err1; 2547 goto err1;
2575 } 2548 }
2576 2549
2577 /* initialize usb hw reg except for regs for EP, 2550 /* initialize usb hw reg except for regs for EP,
2578 * leave usbintr reg untouched*/ 2551 * leave usbintr reg untouched*/
2579 qe_udc_reg_init(udc_controller); 2552 qe_udc_reg_init(udc);
2580 2553
2581 /* here comes the stand operations for probe 2554 /* here comes the stand operations for probe
2582 * set the qe_udc->gadget.xxx */ 2555 * set the qe_udc->gadget.xxx */
2583 udc_controller->gadget.ops = &qe_gadget_ops; 2556 udc->gadget.ops = &qe_gadget_ops;
2584 2557
2585 /* gadget.ep0 is a pointer */ 2558 /* gadget.ep0 is a pointer */
2586 udc_controller->gadget.ep0 = &udc_controller->eps[0].ep; 2559 udc->gadget.ep0 = &udc->eps[0].ep;
2587 2560
2588 INIT_LIST_HEAD(&udc_controller->gadget.ep_list); 2561 INIT_LIST_HEAD(&udc->gadget.ep_list);
2589 2562
2590 /* modify in register gadget process */ 2563 /* modify in register gadget process */
2591 udc_controller->gadget.speed = USB_SPEED_UNKNOWN; 2564 udc->gadget.speed = USB_SPEED_UNKNOWN;
2592 2565
2593 /* name: Identifies the controller hardware type. */ 2566 /* name: Identifies the controller hardware type. */
2594 udc_controller->gadget.name = driver_name; 2567 udc->gadget.name = driver_name;
2595 2568
2596 device_initialize(&udc_controller->gadget.dev); 2569 device_initialize(&udc->gadget.dev);
2597 2570
2598 dev_set_name(&udc_controller->gadget.dev, "gadget"); 2571 dev_set_name(&udc->gadget.dev, "gadget");
2599 2572
2600 udc_controller->gadget.dev.release = qe_udc_release; 2573 udc->gadget.dev.release = qe_udc_release;
2601 udc_controller->gadget.dev.parent = &ofdev->dev; 2574 udc->gadget.dev.parent = &ofdev->dev;
2602 2575
2603 /* initialize qe_ep struct */ 2576 /* initialize qe_ep struct */
2604 for (i = 0; i < USB_MAX_ENDPOINTS ; i++) { 2577 for (i = 0; i < USB_MAX_ENDPOINTS ; i++) {
@@ -2607,104 +2580,104 @@ static int __devinit qe_udc_probe(struct platform_device *ofdev)
2607 2580
2608 /* setup the qe_ep struct and link ep.ep.list 2581 /* setup the qe_ep struct and link ep.ep.list
2609 * into gadget.ep_list */ 2582 * into gadget.ep_list */
2610 qe_ep_config(udc_controller, (unsigned char)i); 2583 qe_ep_config(udc, (unsigned char)i);
2611 } 2584 }
2612 2585
2613 /* ep0 initialization in here */ 2586 /* ep0 initialization in here */
2614 ret = qe_ep_init(udc_controller, 0, &qe_ep0_desc); 2587 ret = qe_ep_init(udc, 0, &qe_ep0_desc);
2615 if (ret) 2588 if (ret)
2616 goto err2; 2589 goto err2;
2617 2590
2618 /* create a buf for ZLP send, need to remain zeroed */ 2591 /* create a buf for ZLP send, need to remain zeroed */
2619 udc_controller->nullbuf = kzalloc(256, GFP_KERNEL); 2592 udc->nullbuf = kzalloc(256, GFP_KERNEL);
2620 if (udc_controller->nullbuf == NULL) { 2593 if (udc->nullbuf == NULL) {
2621 dev_err(udc_controller->dev, "cannot alloc nullbuf\n"); 2594 dev_err(udc->dev, "cannot alloc nullbuf\n");
2622 ret = -ENOMEM; 2595 ret = -ENOMEM;
2623 goto err3; 2596 goto err3;
2624 } 2597 }
2625 2598
2626 /* buffer for data of get_status request */ 2599 /* buffer for data of get_status request */
2627 udc_controller->statusbuf = kzalloc(2, GFP_KERNEL); 2600 udc->statusbuf = kzalloc(2, GFP_KERNEL);
2628 if (udc_controller->statusbuf == NULL) { 2601 if (udc->statusbuf == NULL) {
2629 ret = -ENOMEM; 2602 ret = -ENOMEM;
2630 goto err4; 2603 goto err4;
2631 } 2604 }
2632 2605
2633 udc_controller->nullp = virt_to_phys((void *)udc_controller->nullbuf); 2606 udc->nullp = virt_to_phys((void *)udc->nullbuf);
2634 if (udc_controller->nullp == DMA_ADDR_INVALID) { 2607 if (udc->nullp == DMA_ADDR_INVALID) {
2635 udc_controller->nullp = dma_map_single( 2608 udc->nullp = dma_map_single(
2636 udc_controller->gadget.dev.parent, 2609 udc->gadget.dev.parent,
2637 udc_controller->nullbuf, 2610 udc->nullbuf,
2638 256, 2611 256,
2639 DMA_TO_DEVICE); 2612 DMA_TO_DEVICE);
2640 udc_controller->nullmap = 1; 2613 udc->nullmap = 1;
2641 } else { 2614 } else {
2642 dma_sync_single_for_device(udc_controller->gadget.dev.parent, 2615 dma_sync_single_for_device(udc->gadget.dev.parent,
2643 udc_controller->nullp, 256, 2616 udc->nullp, 256,
2644 DMA_TO_DEVICE); 2617 DMA_TO_DEVICE);
2645 } 2618 }
2646 2619
2647 tasklet_init(&udc_controller->rx_tasklet, ep_rx_tasklet, 2620 tasklet_init(&udc->rx_tasklet, ep_rx_tasklet,
2648 (unsigned long)udc_controller); 2621 (unsigned long)udc);
2649 /* request irq and disable DR */ 2622 /* request irq and disable DR */
2650 udc_controller->usb_irq = irq_of_parse_and_map(np, 0); 2623 udc->usb_irq = irq_of_parse_and_map(np, 0);
2651 if (!udc_controller->usb_irq) { 2624 if (!udc->usb_irq) {
2652 ret = -EINVAL; 2625 ret = -EINVAL;
2653 goto err_noirq; 2626 goto err_noirq;
2654 } 2627 }
2655 2628
2656 ret = request_irq(udc_controller->usb_irq, qe_udc_irq, 0, 2629 ret = request_irq(udc->usb_irq, qe_udc_irq, 0,
2657 driver_name, udc_controller); 2630 driver_name, udc);
2658 if (ret) { 2631 if (ret) {
2659 dev_err(udc_controller->dev, "cannot request irq %d err %d \n", 2632 dev_err(udc->dev, "cannot request irq %d err %d\n",
2660 udc_controller->usb_irq, ret); 2633 udc->usb_irq, ret);
2661 goto err5; 2634 goto err5;
2662 } 2635 }
2663 2636
2664 ret = device_add(&udc_controller->gadget.dev); 2637 ret = device_add(&udc->gadget.dev);
2665 if (ret) 2638 if (ret)
2666 goto err6; 2639 goto err6;
2667 2640
2668 ret = usb_add_gadget_udc(&ofdev->dev, &udc_controller->gadget); 2641 ret = usb_add_gadget_udc(&ofdev->dev, &udc->gadget);
2669 if (ret) 2642 if (ret)
2670 goto err7; 2643 goto err7;
2671 2644
2672 dev_info(udc_controller->dev, 2645 dev_set_drvdata(&ofdev->dev, udc);
2646 dev_info(udc->dev,
2673 "%s USB controller initialized as device\n", 2647 "%s USB controller initialized as device\n",
2674 (udc_controller->soc_type == PORT_QE) ? "QE" : "CPM"); 2648 (udc->soc_type == PORT_QE) ? "QE" : "CPM");
2675 return 0; 2649 return 0;
2676 2650
2677err7: 2651err7:
2678 device_unregister(&udc_controller->gadget.dev); 2652 device_unregister(&udc->gadget.dev);
2679err6: 2653err6:
2680 free_irq(udc_controller->usb_irq, udc_controller); 2654 free_irq(udc->usb_irq, udc);
2681err5: 2655err5:
2682 irq_dispose_mapping(udc_controller->usb_irq); 2656 irq_dispose_mapping(udc->usb_irq);
2683err_noirq: 2657err_noirq:
2684 if (udc_controller->nullmap) { 2658 if (udc->nullmap) {
2685 dma_unmap_single(udc_controller->gadget.dev.parent, 2659 dma_unmap_single(udc->gadget.dev.parent,
2686 udc_controller->nullp, 256, 2660 udc->nullp, 256,
2687 DMA_TO_DEVICE); 2661 DMA_TO_DEVICE);
2688 udc_controller->nullp = DMA_ADDR_INVALID; 2662 udc->nullp = DMA_ADDR_INVALID;
2689 } else { 2663 } else {
2690 dma_sync_single_for_cpu(udc_controller->gadget.dev.parent, 2664 dma_sync_single_for_cpu(udc->gadget.dev.parent,
2691 udc_controller->nullp, 256, 2665 udc->nullp, 256,
2692 DMA_TO_DEVICE); 2666 DMA_TO_DEVICE);
2693 } 2667 }
2694 kfree(udc_controller->statusbuf); 2668 kfree(udc->statusbuf);
2695err4: 2669err4:
2696 kfree(udc_controller->nullbuf); 2670 kfree(udc->nullbuf);
2697err3: 2671err3:
2698 ep = &udc_controller->eps[0]; 2672 ep = &udc->eps[0];
2699 cpm_muram_free(cpm_muram_offset(ep->rxbase)); 2673 cpm_muram_free(cpm_muram_offset(ep->rxbase));
2700 kfree(ep->rxframe); 2674 kfree(ep->rxframe);
2701 kfree(ep->rxbuffer); 2675 kfree(ep->rxbuffer);
2702 kfree(ep->txframe); 2676 kfree(ep->txframe);
2703err2: 2677err2:
2704 iounmap(udc_controller->usb_regs); 2678 iounmap(udc->usb_regs);
2705err1: 2679err1:
2706 kfree(udc_controller); 2680 kfree(udc);
2707 udc_controller = NULL;
2708 return ret; 2681 return ret;
2709} 2682}
2710 2683
@@ -2722,44 +2695,41 @@ static int qe_udc_resume(struct platform_device *dev)
2722 2695
2723static int __devexit qe_udc_remove(struct platform_device *ofdev) 2696static int __devexit qe_udc_remove(struct platform_device *ofdev)
2724{ 2697{
2698 struct qe_udc *udc = dev_get_drvdata(&ofdev->dev);
2725 struct qe_ep *ep; 2699 struct qe_ep *ep;
2726 unsigned int size; 2700 unsigned int size;
2727
2728 DECLARE_COMPLETION(done); 2701 DECLARE_COMPLETION(done);
2729 2702
2730 if (!udc_controller) 2703 usb_del_gadget_udc(&udc->gadget);
2731 return -ENODEV;
2732
2733 usb_del_gadget_udc(&udc_controller->gadget);
2734 2704
2735 udc_controller->done = &done; 2705 udc->done = &done;
2736 tasklet_disable(&udc_controller->rx_tasklet); 2706 tasklet_disable(&udc->rx_tasklet);
2737 2707
2738 if (udc_controller->nullmap) { 2708 if (udc->nullmap) {
2739 dma_unmap_single(udc_controller->gadget.dev.parent, 2709 dma_unmap_single(udc->gadget.dev.parent,
2740 udc_controller->nullp, 256, 2710 udc->nullp, 256,
2741 DMA_TO_DEVICE); 2711 DMA_TO_DEVICE);
2742 udc_controller->nullp = DMA_ADDR_INVALID; 2712 udc->nullp = DMA_ADDR_INVALID;
2743 } else { 2713 } else {
2744 dma_sync_single_for_cpu(udc_controller->gadget.dev.parent, 2714 dma_sync_single_for_cpu(udc->gadget.dev.parent,
2745 udc_controller->nullp, 256, 2715 udc->nullp, 256,
2746 DMA_TO_DEVICE); 2716 DMA_TO_DEVICE);
2747 } 2717 }
2748 kfree(udc_controller->statusbuf); 2718 kfree(udc->statusbuf);
2749 kfree(udc_controller->nullbuf); 2719 kfree(udc->nullbuf);
2750 2720
2751 ep = &udc_controller->eps[0]; 2721 ep = &udc->eps[0];
2752 cpm_muram_free(cpm_muram_offset(ep->rxbase)); 2722 cpm_muram_free(cpm_muram_offset(ep->rxbase));
2753 size = (ep->ep.maxpacket + USB_CRC_SIZE + 2) * (USB_BDRING_LEN + 1); 2723 size = (ep->ep.maxpacket + USB_CRC_SIZE + 2) * (USB_BDRING_LEN + 1);
2754 2724
2755 kfree(ep->rxframe); 2725 kfree(ep->rxframe);
2756 if (ep->rxbufmap) { 2726 if (ep->rxbufmap) {
2757 dma_unmap_single(udc_controller->gadget.dev.parent, 2727 dma_unmap_single(udc->gadget.dev.parent,
2758 ep->rxbuf_d, size, 2728 ep->rxbuf_d, size,
2759 DMA_FROM_DEVICE); 2729 DMA_FROM_DEVICE);
2760 ep->rxbuf_d = DMA_ADDR_INVALID; 2730 ep->rxbuf_d = DMA_ADDR_INVALID;
2761 } else { 2731 } else {
2762 dma_sync_single_for_cpu(udc_controller->gadget.dev.parent, 2732 dma_sync_single_for_cpu(udc->gadget.dev.parent,
2763 ep->rxbuf_d, size, 2733 ep->rxbuf_d, size,
2764 DMA_FROM_DEVICE); 2734 DMA_FROM_DEVICE);
2765 } 2735 }
@@ -2767,14 +2737,14 @@ static int __devexit qe_udc_remove(struct platform_device *ofdev)
2767 kfree(ep->rxbuffer); 2737 kfree(ep->rxbuffer);
2768 kfree(ep->txframe); 2738 kfree(ep->txframe);
2769 2739
2770 free_irq(udc_controller->usb_irq, udc_controller); 2740 free_irq(udc->usb_irq, udc);
2771 irq_dispose_mapping(udc_controller->usb_irq); 2741 irq_dispose_mapping(udc->usb_irq);
2772 2742
2773 tasklet_kill(&udc_controller->rx_tasklet); 2743 tasklet_kill(&udc->rx_tasklet);
2774 2744
2775 iounmap(udc_controller->usb_regs); 2745 iounmap(udc->usb_regs);
2776 2746
2777 device_unregister(&udc_controller->gadget.dev); 2747 device_unregister(&udc->gadget.dev);
2778 /* wait for release() of gadget.dev to free udc */ 2748 /* wait for release() of gadget.dev to free udc */
2779 wait_for_completion(&done); 2749 wait_for_completion(&done);
2780 2750