diff options
author | Sebastian Andrzej Siewior <sebastian@breakpoint.cc> | 2012-02-04 12:55:25 -0500 |
---|---|---|
committer | Felipe Balbi <balbi@ti.com> | 2012-05-04 08:53:01 -0400 |
commit | d77c1198666d87a9b21e9594ca29ac7e42011623 (patch) | |
tree | a21334bdffcb83780a06cb308293f082bec51eda /drivers/usb/gadget/fsl_qe_udc.c | |
parent | d809f78f81fc1c7e9d8afaaa51ec4813612aff94 (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.c | 310 |
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() */ | ||
75 | static 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 | ||
701 | static inline void qe_usb_enable(void) | 698 | static 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 | ||
706 | static inline void qe_usb_disable(void) | 703 | static 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 */ |
1880 | static int qe_get_frame(struct usb_gadget *gadget) | 1877 | static 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 | ||
1930 | static int fsl_qe_start(struct usb_gadget_driver *driver, | 1928 | static int fsl_qe_start(struct usb_gadget *gadget, |
1931 | int (*bind)(struct usb_gadget *)); | 1929 | struct usb_gadget_driver *driver); |
1932 | static int fsl_qe_stop(struct usb_gadget_driver *driver); | 1930 | static 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 */ |
1935 | static struct usb_gadget_ops qe_gadget_ops = { | 1934 | static 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 | --------------------------------------------------------------------------*/ |
2329 | static int fsl_qe_start(struct usb_gadget_driver *driver, | 2328 | static 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 | ||
2378 | static int fsl_qe_stop(struct usb_gadget_driver *driver) | 2359 | static 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 | *----------------------------------------------------------------------*/ |
2531 | static void qe_udc_release(struct device *dev) | 2503 | static 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 */ |
2545 | static const struct of_device_id qe_udc_match[]; | 2517 | static const struct of_device_id qe_udc_match[]; |
2546 | static int __devinit qe_udc_probe(struct platform_device *ofdev) | 2518 | static 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 | ||
2677 | err7: | 2651 | err7: |
2678 | device_unregister(&udc_controller->gadget.dev); | 2652 | device_unregister(&udc->gadget.dev); |
2679 | err6: | 2653 | err6: |
2680 | free_irq(udc_controller->usb_irq, udc_controller); | 2654 | free_irq(udc->usb_irq, udc); |
2681 | err5: | 2655 | err5: |
2682 | irq_dispose_mapping(udc_controller->usb_irq); | 2656 | irq_dispose_mapping(udc->usb_irq); |
2683 | err_noirq: | 2657 | err_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); |
2695 | err4: | 2669 | err4: |
2696 | kfree(udc_controller->nullbuf); | 2670 | kfree(udc->nullbuf); |
2697 | err3: | 2671 | err3: |
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); |
2703 | err2: | 2677 | err2: |
2704 | iounmap(udc_controller->usb_regs); | 2678 | iounmap(udc->usb_regs); |
2705 | err1: | 2679 | err1: |
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 | ||
2723 | static int __devexit qe_udc_remove(struct platform_device *ofdev) | 2696 | static 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 | ||