aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/chipidea/udc.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/usb/chipidea/udc.c')
-rw-r--r--drivers/usb/chipidea/udc.c628
1 files changed, 314 insertions, 314 deletions
diff --git a/drivers/usb/chipidea/udc.c b/drivers/usb/chipidea/udc.c
index 3094c85dc0b5..ba8284e2a237 100644
--- a/drivers/usb/chipidea/udc.c
+++ b/drivers/usb/chipidea/udc.c
@@ -67,11 +67,11 @@ static inline int hw_ep_bit(int num, int dir)
67 return num + (dir ? 16 : 0); 67 return num + (dir ? 16 : 0);
68} 68}
69 69
70static inline int ep_to_bit(struct ci13xxx *udc, int n) 70static inline int ep_to_bit(struct ci13xxx *ci, int n)
71{ 71{
72 int fill = 16 - udc->hw_ep_max / 2; 72 int fill = 16 - ci->hw_ep_max / 2;
73 73
74 if (n >= udc->hw_ep_max / 2) 74 if (n >= ci->hw_ep_max / 2)
75 n += fill; 75 n += fill;
76 76
77 return n; 77 return n;
@@ -84,17 +84,17 @@ static inline int ep_to_bit(struct ci13xxx *udc, int n)
84 * 84 *
85 * This function returns an error code 85 * This function returns an error code
86 */ 86 */
87static int hw_device_state(struct ci13xxx *udc, u32 dma) 87static int hw_device_state(struct ci13xxx *ci, u32 dma)
88{ 88{
89 if (dma) { 89 if (dma) {
90 hw_write(udc, OP_ENDPTLISTADDR, ~0, dma); 90 hw_write(ci, OP_ENDPTLISTADDR, ~0, dma);
91 /* interrupt, error, port change, reset, sleep/suspend */ 91 /* interrupt, error, port change, reset, sleep/suspend */
92 hw_write(udc, OP_USBINTR, ~0, 92 hw_write(ci, OP_USBINTR, ~0,
93 USBi_UI|USBi_UEI|USBi_PCI|USBi_URI|USBi_SLI); 93 USBi_UI|USBi_UEI|USBi_PCI|USBi_URI|USBi_SLI);
94 hw_write(udc, OP_USBCMD, USBCMD_RS, USBCMD_RS); 94 hw_write(ci, OP_USBCMD, USBCMD_RS, USBCMD_RS);
95 } else { 95 } else {
96 hw_write(udc, OP_USBCMD, USBCMD_RS, 0); 96 hw_write(ci, OP_USBCMD, USBCMD_RS, 0);
97 hw_write(udc, OP_USBINTR, ~0, 0); 97 hw_write(ci, OP_USBINTR, ~0, 0);
98 } 98 }
99 return 0; 99 return 0;
100} 100}
@@ -106,16 +106,16 @@ static int hw_device_state(struct ci13xxx *udc, u32 dma)
106 * 106 *
107 * This function returns an error code 107 * This function returns an error code
108 */ 108 */
109static int hw_ep_flush(struct ci13xxx *udc, int num, int dir) 109static int hw_ep_flush(struct ci13xxx *ci, int num, int dir)
110{ 110{
111 int n = hw_ep_bit(num, dir); 111 int n = hw_ep_bit(num, dir);
112 112
113 do { 113 do {
114 /* flush any pending transfer */ 114 /* flush any pending transfer */
115 hw_write(udc, OP_ENDPTFLUSH, BIT(n), BIT(n)); 115 hw_write(ci, OP_ENDPTFLUSH, BIT(n), BIT(n));
116 while (hw_read(udc, OP_ENDPTFLUSH, BIT(n))) 116 while (hw_read(ci, OP_ENDPTFLUSH, BIT(n)))
117 cpu_relax(); 117 cpu_relax();
118 } while (hw_read(udc, OP_ENDPTSTAT, BIT(n))); 118 } while (hw_read(ci, OP_ENDPTSTAT, BIT(n)));
119 119
120 return 0; 120 return 0;
121} 121}
@@ -127,10 +127,10 @@ static int hw_ep_flush(struct ci13xxx *udc, int num, int dir)
127 * 127 *
128 * This function returns an error code 128 * This function returns an error code
129 */ 129 */
130static int hw_ep_disable(struct ci13xxx *udc, int num, int dir) 130static int hw_ep_disable(struct ci13xxx *ci, int num, int dir)
131{ 131{
132 hw_ep_flush(udc, num, dir); 132 hw_ep_flush(ci, num, dir);
133 hw_write(udc, OP_ENDPTCTRL + num, 133 hw_write(ci, OP_ENDPTCTRL + num,
134 dir ? ENDPTCTRL_TXE : ENDPTCTRL_RXE, 0); 134 dir ? ENDPTCTRL_TXE : ENDPTCTRL_RXE, 0);
135 return 0; 135 return 0;
136} 136}
@@ -143,7 +143,7 @@ static int hw_ep_disable(struct ci13xxx *udc, int num, int dir)
143 * 143 *
144 * This function returns an error code 144 * This function returns an error code
145 */ 145 */
146static int hw_ep_enable(struct ci13xxx *udc, int num, int dir, int type) 146static int hw_ep_enable(struct ci13xxx *ci, int num, int dir, int type)
147{ 147{
148 u32 mask, data; 148 u32 mask, data;
149 149
@@ -166,7 +166,7 @@ static int hw_ep_enable(struct ci13xxx *udc, int num, int dir, int type)
166 mask |= ENDPTCTRL_RXE; /* enable */ 166 mask |= ENDPTCTRL_RXE; /* enable */
167 data |= ENDPTCTRL_RXE; 167 data |= ENDPTCTRL_RXE;
168 } 168 }
169 hw_write(udc, OP_ENDPTCTRL + num, mask, data); 169 hw_write(ci, OP_ENDPTCTRL + num, mask, data);
170 return 0; 170 return 0;
171} 171}
172 172
@@ -177,11 +177,11 @@ static int hw_ep_enable(struct ci13xxx *udc, int num, int dir, int type)
177 * 177 *
178 * This function returns 1 if endpoint halted 178 * This function returns 1 if endpoint halted
179 */ 179 */
180static int hw_ep_get_halt(struct ci13xxx *udc, int num, int dir) 180static int hw_ep_get_halt(struct ci13xxx *ci, int num, int dir)
181{ 181{
182 u32 mask = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS; 182 u32 mask = dir ? ENDPTCTRL_TXS : ENDPTCTRL_RXS;
183 183
184 return hw_read(udc, OP_ENDPTCTRL + num, mask) ? 1 : 0; 184 return hw_read(ci, OP_ENDPTCTRL + num, mask) ? 1 : 0;
185} 185}
186 186
187/** 187/**
@@ -191,10 +191,10 @@ static int hw_ep_get_halt(struct ci13xxx *udc, int num, int dir)
191 * 191 *
192 * This function returns setup status 192 * This function returns setup status
193 */ 193 */
194static int hw_test_and_clear_setup_status(struct ci13xxx *udc, int n) 194static int hw_test_and_clear_setup_status(struct ci13xxx *ci, int n)
195{ 195{
196 n = ep_to_bit(udc, n); 196 n = ep_to_bit(ci, n);
197 return hw_test_and_clear(udc, OP_ENDPTSETUPSTAT, BIT(n)); 197 return hw_test_and_clear(ci, OP_ENDPTSETUPSTAT, BIT(n));
198} 198}
199 199
200/** 200/**
@@ -205,18 +205,18 @@ static int hw_test_and_clear_setup_status(struct ci13xxx *udc, int n)
205 * 205 *
206 * This function returns an error code 206 * This function returns an error code
207 */ 207 */
208static int hw_ep_prime(struct ci13xxx *udc, int num, int dir, int is_ctrl) 208static int hw_ep_prime(struct ci13xxx *ci, int num, int dir, int is_ctrl)
209{ 209{
210 int n = hw_ep_bit(num, dir); 210 int n = hw_ep_bit(num, dir);
211 211
212 if (is_ctrl && dir == RX && hw_read(udc, OP_ENDPTSETUPSTAT, BIT(num))) 212 if (is_ctrl && dir == RX && hw_read(ci, OP_ENDPTSETUPSTAT, BIT(num)))
213 return -EAGAIN; 213 return -EAGAIN;
214 214
215 hw_write(udc, OP_ENDPTPRIME, BIT(n), BIT(n)); 215 hw_write(ci, OP_ENDPTPRIME, BIT(n), BIT(n));
216 216
217 while (hw_read(udc, OP_ENDPTPRIME, BIT(n))) 217 while (hw_read(ci, OP_ENDPTPRIME, BIT(n)))
218 cpu_relax(); 218 cpu_relax();
219 if (is_ctrl && dir == RX && hw_read(udc, OP_ENDPTSETUPSTAT, BIT(num))) 219 if (is_ctrl && dir == RX && hw_read(ci, OP_ENDPTSETUPSTAT, BIT(num)))
220 return -EAGAIN; 220 return -EAGAIN;
221 221
222 /* status shoult be tested according with manual but it doesn't work */ 222 /* status shoult be tested according with manual but it doesn't work */
@@ -232,7 +232,7 @@ static int hw_ep_prime(struct ci13xxx *udc, int num, int dir, int is_ctrl)
232 * 232 *
233 * This function returns an error code 233 * This function returns an error code
234 */ 234 */
235static int hw_ep_set_halt(struct ci13xxx *udc, int num, int dir, int value) 235static int hw_ep_set_halt(struct ci13xxx *ci, int num, int dir, int value)
236{ 236{
237 if (value != 0 && value != 1) 237 if (value != 0 && value != 1)
238 return -EINVAL; 238 return -EINVAL;
@@ -243,9 +243,9 @@ static int hw_ep_set_halt(struct ci13xxx *udc, int num, int dir, int value)
243 u32 mask_xr = dir ? ENDPTCTRL_TXR : ENDPTCTRL_RXR; 243 u32 mask_xr = dir ? ENDPTCTRL_TXR : ENDPTCTRL_RXR;
244 244
245 /* data toggle - reserved for EP0 but it's in ESS */ 245 /* data toggle - reserved for EP0 but it's in ESS */
246 hw_write(udc, reg, mask_xs|mask_xr, 246 hw_write(ci, reg, mask_xs|mask_xr,
247 value ? mask_xs : mask_xr); 247 value ? mask_xs : mask_xr);
248 } while (value != hw_ep_get_halt(udc, num, dir)); 248 } while (value != hw_ep_get_halt(ci, num, dir));
249 249
250 return 0; 250 return 0;
251} 251}
@@ -255,10 +255,10 @@ static int hw_ep_set_halt(struct ci13xxx *udc, int num, int dir, int value)
255 * 255 *
256 * This function returns true if high speed port 256 * This function returns true if high speed port
257 */ 257 */
258static int hw_port_is_high_speed(struct ci13xxx *udc) 258static int hw_port_is_high_speed(struct ci13xxx *ci)
259{ 259{
260 return udc->hw_bank.lpm ? hw_read(udc, OP_DEVLC, DEVLC_PSPD) : 260 return ci->hw_bank.lpm ? hw_read(ci, OP_DEVLC, DEVLC_PSPD) :
261 hw_read(udc, OP_PORTSC, PORTSC_HSP); 261 hw_read(ci, OP_PORTSC, PORTSC_HSP);
262} 262}
263 263
264/** 264/**
@@ -266,9 +266,9 @@ static int hw_port_is_high_speed(struct ci13xxx *udc)
266 * 266 *
267 * This function returns register data 267 * This function returns register data
268 */ 268 */
269static u32 hw_read_intr_enable(struct ci13xxx *udc) 269static u32 hw_read_intr_enable(struct ci13xxx *ci)
270{ 270{
271 return hw_read(udc, OP_USBINTR, ~0); 271 return hw_read(ci, OP_USBINTR, ~0);
272} 272}
273 273
274/** 274/**
@@ -276,9 +276,9 @@ static u32 hw_read_intr_enable(struct ci13xxx *udc)
276 * 276 *
277 * This function returns register data 277 * This function returns register data
278 */ 278 */
279static u32 hw_read_intr_status(struct ci13xxx *udc) 279static u32 hw_read_intr_status(struct ci13xxx *ci)
280{ 280{
281 return hw_read(udc, OP_USBSTS, ~0); 281 return hw_read(ci, OP_USBSTS, ~0);
282} 282}
283 283
284/** 284/**
@@ -288,10 +288,10 @@ static u32 hw_read_intr_status(struct ci13xxx *udc)
288 * 288 *
289 * This function returns complete status 289 * This function returns complete status
290 */ 290 */
291static int hw_test_and_clear_complete(struct ci13xxx *udc, int n) 291static int hw_test_and_clear_complete(struct ci13xxx *ci, int n)
292{ 292{
293 n = ep_to_bit(udc, n); 293 n = ep_to_bit(ci, n);
294 return hw_test_and_clear(udc, OP_ENDPTCOMPLETE, BIT(n)); 294 return hw_test_and_clear(ci, OP_ENDPTCOMPLETE, BIT(n));
295} 295}
296 296
297/** 297/**
@@ -300,11 +300,11 @@ static int hw_test_and_clear_complete(struct ci13xxx *udc, int n)
300 * 300 *
301 * This function returns active interrutps 301 * This function returns active interrutps
302 */ 302 */
303static u32 hw_test_and_clear_intr_active(struct ci13xxx *udc) 303static u32 hw_test_and_clear_intr_active(struct ci13xxx *ci)
304{ 304{
305 u32 reg = hw_read_intr_status(udc) & hw_read_intr_enable(udc); 305 u32 reg = hw_read_intr_status(ci) & hw_read_intr_enable(ci);
306 306
307 hw_write(udc, OP_USBSTS, ~0, reg); 307 hw_write(ci, OP_USBSTS, ~0, reg);
308 return reg; 308 return reg;
309} 309}
310 310
@@ -314,9 +314,9 @@ static u32 hw_test_and_clear_intr_active(struct ci13xxx *udc)
314 * 314 *
315 * This function returns guard value 315 * This function returns guard value
316 */ 316 */
317static int hw_test_and_clear_setup_guard(struct ci13xxx *udc) 317static int hw_test_and_clear_setup_guard(struct ci13xxx *ci)
318{ 318{
319 return hw_test_and_write(udc, OP_USBCMD, USBCMD_SUTW, 0); 319 return hw_test_and_write(ci, OP_USBCMD, USBCMD_SUTW, 0);
320} 320}
321 321
322/** 322/**
@@ -325,9 +325,9 @@ static int hw_test_and_clear_setup_guard(struct ci13xxx *udc)
325 * 325 *
326 * This function returns guard value 326 * This function returns guard value
327 */ 327 */
328static int hw_test_and_set_setup_guard(struct ci13xxx *udc) 328static int hw_test_and_set_setup_guard(struct ci13xxx *ci)
329{ 329{
330 return hw_test_and_write(udc, OP_USBCMD, USBCMD_SUTW, USBCMD_SUTW); 330 return hw_test_and_write(ci, OP_USBCMD, USBCMD_SUTW, USBCMD_SUTW);
331} 331}
332 332
333/** 333/**
@@ -337,9 +337,9 @@ static int hw_test_and_set_setup_guard(struct ci13xxx *udc)
337 * This function explicitly sets the address, without the "USBADRA" (advance) 337 * This function explicitly sets the address, without the "USBADRA" (advance)
338 * feature, which is not supported by older versions of the controller. 338 * feature, which is not supported by older versions of the controller.
339 */ 339 */
340static void hw_usb_set_address(struct ci13xxx *udc, u8 value) 340static void hw_usb_set_address(struct ci13xxx *ci, u8 value)
341{ 341{
342 hw_write(udc, OP_DEVICEADDR, DEVICEADDR_USBADR, 342 hw_write(ci, OP_DEVICEADDR, DEVICEADDR_USBADR,
343 value << ffs_nr(DEVICEADDR_USBADR)); 343 value << ffs_nr(DEVICEADDR_USBADR));
344} 344}
345 345
@@ -349,21 +349,21 @@ static void hw_usb_set_address(struct ci13xxx *udc, u8 value)
349 * 349 *
350 * This function returns an error code 350 * This function returns an error code
351 */ 351 */
352static int hw_usb_reset(struct ci13xxx *udc) 352static int hw_usb_reset(struct ci13xxx *ci)
353{ 353{
354 hw_usb_set_address(udc, 0); 354 hw_usb_set_address(ci, 0);
355 355
356 /* ESS flushes only at end?!? */ 356 /* ESS flushes only at end?!? */
357 hw_write(udc, OP_ENDPTFLUSH, ~0, ~0); 357 hw_write(ci, OP_ENDPTFLUSH, ~0, ~0);
358 358
359 /* clear setup token semaphores */ 359 /* clear setup token semaphores */
360 hw_write(udc, OP_ENDPTSETUPSTAT, 0, 0); 360 hw_write(ci, OP_ENDPTSETUPSTAT, 0, 0);
361 361
362 /* clear complete status */ 362 /* clear complete status */
363 hw_write(udc, OP_ENDPTCOMPLETE, 0, 0); 363 hw_write(ci, OP_ENDPTCOMPLETE, 0, 0);
364 364
365 /* wait until all bits cleared */ 365 /* wait until all bits cleared */
366 while (hw_read(udc, OP_ENDPTPRIME, ~0)) 366 while (hw_read(ci, OP_ENDPTPRIME, ~0))
367 udelay(10); /* not RTOS friendly */ 367 udelay(10); /* not RTOS friendly */
368 368
369 /* reset all endpoints ? */ 369 /* reset all endpoints ? */
@@ -395,7 +395,7 @@ static inline u8 _usb_addr(struct ci13xxx_ep *ep)
395 */ 395 */
396static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq) 396static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
397{ 397{
398 struct ci13xxx *udc = mEp->udc; 398 struct ci13xxx *ci = mEp->ci;
399 unsigned i; 399 unsigned i;
400 int ret = 0; 400 int ret = 0;
401 unsigned length = mReq->req.length; 401 unsigned length = mReq->req.length;
@@ -418,7 +418,7 @@ static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
418 if (!mReq->req.no_interrupt) 418 if (!mReq->req.no_interrupt)
419 mReq->zptr->token |= TD_IOC; 419 mReq->zptr->token |= TD_IOC;
420 } 420 }
421 ret = usb_gadget_map_request(&udc->gadget, &mReq->req, mEp->dir); 421 ret = usb_gadget_map_request(&ci->gadget, &mReq->req, mEp->dir);
422 if (ret) 422 if (ret)
423 return ret; 423 return ret;
424 424
@@ -454,13 +454,13 @@ static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
454 else 454 else
455 mReqPrev->ptr->next = mReq->dma & TD_ADDR_MASK; 455 mReqPrev->ptr->next = mReq->dma & TD_ADDR_MASK;
456 wmb(); 456 wmb();
457 if (hw_read(udc, OP_ENDPTPRIME, BIT(n))) 457 if (hw_read(ci, OP_ENDPTPRIME, BIT(n)))
458 goto done; 458 goto done;
459 do { 459 do {
460 hw_write(udc, OP_USBCMD, USBCMD_ATDTW, USBCMD_ATDTW); 460 hw_write(ci, OP_USBCMD, USBCMD_ATDTW, USBCMD_ATDTW);
461 tmp_stat = hw_read(udc, OP_ENDPTSTAT, BIT(n)); 461 tmp_stat = hw_read(ci, OP_ENDPTSTAT, BIT(n));
462 } while (!hw_read(udc, OP_USBCMD, USBCMD_ATDTW)); 462 } while (!hw_read(ci, OP_USBCMD, USBCMD_ATDTW));
463 hw_write(udc, OP_USBCMD, USBCMD_ATDTW, 0); 463 hw_write(ci, OP_USBCMD, USBCMD_ATDTW, 0);
464 if (tmp_stat) 464 if (tmp_stat)
465 goto done; 465 goto done;
466 } 466 }
@@ -472,7 +472,7 @@ static int _hardware_enqueue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
472 472
473 wmb(); /* synchronize before ep prime */ 473 wmb(); /* synchronize before ep prime */
474 474
475 ret = hw_ep_prime(udc, mEp->num, mEp->dir, 475 ret = hw_ep_prime(ci, mEp->num, mEp->dir,
476 mEp->type == USB_ENDPOINT_XFER_CONTROL); 476 mEp->type == USB_ENDPOINT_XFER_CONTROL);
477done: 477done:
478 return ret; 478 return ret;
@@ -502,7 +502,7 @@ static int _hardware_dequeue(struct ci13xxx_ep *mEp, struct ci13xxx_req *mReq)
502 502
503 mReq->req.status = 0; 503 mReq->req.status = 0;
504 504
505 usb_gadget_unmap_request(&mEp->udc->gadget, &mReq->req, mEp->dir); 505 usb_gadget_unmap_request(&mEp->ci->gadget, &mReq->req, mEp->dir);
506 506
507 mReq->req.status = mReq->ptr->token & TD_STATUS; 507 mReq->req.status = mReq->ptr->token & TD_STATUS;
508 if ((TD_STATUS_HALTED & mReq->req.status) != 0) 508 if ((TD_STATUS_HALTED & mReq->req.status) != 0)
@@ -534,7 +534,7 @@ __acquires(mEp->lock)
534 if (mEp == NULL) 534 if (mEp == NULL)
535 return -EINVAL; 535 return -EINVAL;
536 536
537 hw_ep_flush(mEp->udc, mEp->num, mEp->dir); 537 hw_ep_flush(mEp->ci, mEp->num, mEp->dir);
538 538
539 while (!list_empty(&mEp->qh.queue)) { 539 while (!list_empty(&mEp->qh.queue)) {
540 540
@@ -563,33 +563,33 @@ __acquires(mEp->lock)
563static int _gadget_stop_activity(struct usb_gadget *gadget) 563static int _gadget_stop_activity(struct usb_gadget *gadget)
564{ 564{
565 struct usb_ep *ep; 565 struct usb_ep *ep;
566 struct ci13xxx *udc = container_of(gadget, struct ci13xxx, gadget); 566 struct ci13xxx *ci = container_of(gadget, struct ci13xxx, gadget);
567 unsigned long flags; 567 unsigned long flags;
568 568
569 spin_lock_irqsave(&udc->lock, flags); 569 spin_lock_irqsave(&ci->lock, flags);
570 udc->gadget.speed = USB_SPEED_UNKNOWN; 570 ci->gadget.speed = USB_SPEED_UNKNOWN;
571 udc->remote_wakeup = 0; 571 ci->remote_wakeup = 0;
572 udc->suspended = 0; 572 ci->suspended = 0;
573 spin_unlock_irqrestore(&udc->lock, flags); 573 spin_unlock_irqrestore(&ci->lock, flags);
574 574
575 /* flush all endpoints */ 575 /* flush all endpoints */
576 gadget_for_each_ep(ep, gadget) { 576 gadget_for_each_ep(ep, gadget) {
577 usb_ep_fifo_flush(ep); 577 usb_ep_fifo_flush(ep);
578 } 578 }
579 usb_ep_fifo_flush(&udc->ep0out->ep); 579 usb_ep_fifo_flush(&ci->ep0out->ep);
580 usb_ep_fifo_flush(&udc->ep0in->ep); 580 usb_ep_fifo_flush(&ci->ep0in->ep);
581 581
582 if (udc->driver) 582 if (ci->driver)
583 udc->driver->disconnect(gadget); 583 ci->driver->disconnect(gadget);
584 584
585 /* make sure to disable all endpoints */ 585 /* make sure to disable all endpoints */
586 gadget_for_each_ep(ep, gadget) { 586 gadget_for_each_ep(ep, gadget) {
587 usb_ep_disable(ep); 587 usb_ep_disable(ep);
588 } 588 }
589 589
590 if (udc->status != NULL) { 590 if (ci->status != NULL) {
591 usb_ep_free_request(&udc->ep0in->ep, udc->status); 591 usb_ep_free_request(&ci->ep0in->ep, ci->status);
592 udc->status = NULL; 592 ci->status = NULL;
593 } 593 }
594 594
595 return 0; 595 return 0;
@@ -600,36 +600,36 @@ static int _gadget_stop_activity(struct usb_gadget *gadget)
600 *****************************************************************************/ 600 *****************************************************************************/
601/** 601/**
602 * isr_reset_handler: USB reset interrupt handler 602 * isr_reset_handler: USB reset interrupt handler
603 * @udc: UDC device 603 * @ci: UDC device
604 * 604 *
605 * This function resets USB engine after a bus reset occurred 605 * This function resets USB engine after a bus reset occurred
606 */ 606 */
607static void isr_reset_handler(struct ci13xxx *udc) 607static void isr_reset_handler(struct ci13xxx *ci)
608__releases(udc->lock) 608__releases(ci->lock)
609__acquires(udc->lock) 609__acquires(ci->lock)
610{ 610{
611 int retval; 611 int retval;
612 612
613 dbg_event(0xFF, "BUS RST", 0); 613 dbg_event(0xFF, "BUS RST", 0);
614 614
615 spin_unlock(&udc->lock); 615 spin_unlock(&ci->lock);
616 retval = _gadget_stop_activity(&udc->gadget); 616 retval = _gadget_stop_activity(&ci->gadget);
617 if (retval) 617 if (retval)
618 goto done; 618 goto done;
619 619
620 retval = hw_usb_reset(udc); 620 retval = hw_usb_reset(ci);
621 if (retval) 621 if (retval)
622 goto done; 622 goto done;
623 623
624 udc->status = usb_ep_alloc_request(&udc->ep0in->ep, GFP_ATOMIC); 624 ci->status = usb_ep_alloc_request(&ci->ep0in->ep, GFP_ATOMIC);
625 if (udc->status == NULL) 625 if (ci->status == NULL)
626 retval = -ENOMEM; 626 retval = -ENOMEM;
627 627
628done: 628done:
629 spin_lock(&udc->lock); 629 spin_lock(&ci->lock);
630 630
631 if (retval) 631 if (retval)
632 dev_err(udc->dev, "error: %i\n", retval); 632 dev_err(ci->dev, "error: %i\n", retval);
633} 633}
634 634
635/** 635/**
@@ -650,17 +650,17 @@ static void isr_get_status_complete(struct usb_ep *ep, struct usb_request *req)
650 650
651/** 651/**
652 * isr_get_status_response: get_status request response 652 * isr_get_status_response: get_status request response
653 * @udc: udc struct 653 * @ci: ci struct
654 * @setup: setup request packet 654 * @setup: setup request packet
655 * 655 *
656 * This function returns an error code 656 * This function returns an error code
657 */ 657 */
658static int isr_get_status_response(struct ci13xxx *udc, 658static int isr_get_status_response(struct ci13xxx *ci,
659 struct usb_ctrlrequest *setup) 659 struct usb_ctrlrequest *setup)
660__releases(mEp->lock) 660__releases(mEp->lock)
661__acquires(mEp->lock) 661__acquires(mEp->lock)
662{ 662{
663 struct ci13xxx_ep *mEp = udc->ep0in; 663 struct ci13xxx_ep *mEp = ci->ep0in;
664 struct usb_request *req = NULL; 664 struct usb_request *req = NULL;
665 gfp_t gfp_flags = GFP_ATOMIC; 665 gfp_t gfp_flags = GFP_ATOMIC;
666 int dir, num, retval; 666 int dir, num, retval;
@@ -684,14 +684,14 @@ __acquires(mEp->lock)
684 684
685 if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) { 685 if ((setup->bRequestType & USB_RECIP_MASK) == USB_RECIP_DEVICE) {
686 /* Assume that device is bus powered for now. */ 686 /* Assume that device is bus powered for now. */
687 *(u16 *)req->buf = udc->remote_wakeup << 1; 687 *(u16 *)req->buf = ci->remote_wakeup << 1;
688 retval = 0; 688 retval = 0;
689 } else if ((setup->bRequestType & USB_RECIP_MASK) \ 689 } else if ((setup->bRequestType & USB_RECIP_MASK) \
690 == USB_RECIP_ENDPOINT) { 690 == USB_RECIP_ENDPOINT) {
691 dir = (le16_to_cpu(setup->wIndex) & USB_ENDPOINT_DIR_MASK) ? 691 dir = (le16_to_cpu(setup->wIndex) & USB_ENDPOINT_DIR_MASK) ?
692 TX : RX; 692 TX : RX;
693 num = le16_to_cpu(setup->wIndex) & USB_ENDPOINT_NUMBER_MASK; 693 num = le16_to_cpu(setup->wIndex) & USB_ENDPOINT_NUMBER_MASK;
694 *(u16 *)req->buf = hw_ep_get_halt(udc, num, dir); 694 *(u16 *)req->buf = hw_ep_get_halt(ci, num, dir);
695 } 695 }
696 /* else do nothing; reserved for future use */ 696 /* else do nothing; reserved for future use */
697 697
@@ -723,39 +723,39 @@ __acquires(mEp->lock)
723static void 723static void
724isr_setup_status_complete(struct usb_ep *ep, struct usb_request *req) 724isr_setup_status_complete(struct usb_ep *ep, struct usb_request *req)
725{ 725{
726 struct ci13xxx *udc = req->context; 726 struct ci13xxx *ci = req->context;
727 unsigned long flags; 727 unsigned long flags;
728 728
729 if (udc->setaddr) { 729 if (ci->setaddr) {
730 hw_usb_set_address(udc, udc->address); 730 hw_usb_set_address(ci, ci->address);
731 udc->setaddr = false; 731 ci->setaddr = false;
732 } 732 }
733 733
734 spin_lock_irqsave(&udc->lock, flags); 734 spin_lock_irqsave(&ci->lock, flags);
735 if (udc->test_mode) 735 if (ci->test_mode)
736 hw_port_test_set(udc, udc->test_mode); 736 hw_port_test_set(ci, ci->test_mode);
737 spin_unlock_irqrestore(&udc->lock, flags); 737 spin_unlock_irqrestore(&ci->lock, flags);
738} 738}
739 739
740/** 740/**
741 * isr_setup_status_phase: queues the status phase of a setup transation 741 * isr_setup_status_phase: queues the status phase of a setup transation
742 * @udc: udc struct 742 * @ci: ci struct
743 * 743 *
744 * This function returns an error code 744 * This function returns an error code
745 */ 745 */
746static int isr_setup_status_phase(struct ci13xxx *udc) 746static int isr_setup_status_phase(struct ci13xxx *ci)
747__releases(mEp->lock) 747__releases(mEp->lock)
748__acquires(mEp->lock) 748__acquires(mEp->lock)
749{ 749{
750 int retval; 750 int retval;
751 struct ci13xxx_ep *mEp; 751 struct ci13xxx_ep *mEp;
752 752
753 mEp = (udc->ep0_dir == TX) ? udc->ep0out : udc->ep0in; 753 mEp = (ci->ep0_dir == TX) ? ci->ep0out : ci->ep0in;
754 udc->status->context = udc; 754 ci->status->context = ci;
755 udc->status->complete = isr_setup_status_complete; 755 ci->status->complete = isr_setup_status_complete;
756 756
757 spin_unlock(mEp->lock); 757 spin_unlock(mEp->lock);
758 retval = usb_ep_queue(&mEp->ep, udc->status, GFP_ATOMIC); 758 retval = usb_ep_queue(&mEp->ep, ci->status, GFP_ATOMIC);
759 spin_lock(mEp->lock); 759 spin_lock(mEp->lock);
760 760
761 return retval; 761 return retval;
@@ -790,7 +790,7 @@ __acquires(mEp->lock)
790 spin_unlock(mEp->lock); 790 spin_unlock(mEp->lock);
791 if ((mEp->type == USB_ENDPOINT_XFER_CONTROL) && 791 if ((mEp->type == USB_ENDPOINT_XFER_CONTROL) &&
792 mReq->req.length) 792 mReq->req.length)
793 mEpTemp = mEp->udc->ep0in; 793 mEpTemp = mEp->ci->ep0in;
794 mReq->req.complete(&mEpTemp->ep, &mReq->req); 794 mReq->req.complete(&mEpTemp->ep, &mReq->req);
795 spin_lock(mEp->lock); 795 spin_lock(mEp->lock);
796 } 796 }
@@ -806,48 +806,48 @@ __acquires(mEp->lock)
806 806
807/** 807/**
808 * isr_tr_complete_handler: transaction complete interrupt handler 808 * isr_tr_complete_handler: transaction complete interrupt handler
809 * @udc: UDC descriptor 809 * @ci: UDC descriptor
810 * 810 *
811 * This function handles traffic events 811 * This function handles traffic events
812 */ 812 */
813static void isr_tr_complete_handler(struct ci13xxx *udc) 813static void isr_tr_complete_handler(struct ci13xxx *ci)
814__releases(udc->lock) 814__releases(ci->lock)
815__acquires(udc->lock) 815__acquires(ci->lock)
816{ 816{
817 unsigned i; 817 unsigned i;
818 u8 tmode = 0; 818 u8 tmode = 0;
819 819
820 for (i = 0; i < udc->hw_ep_max; i++) { 820 for (i = 0; i < ci->hw_ep_max; i++) {
821 struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i]; 821 struct ci13xxx_ep *mEp = &ci->ci13xxx_ep[i];
822 int type, num, dir, err = -EINVAL; 822 int type, num, dir, err = -EINVAL;
823 struct usb_ctrlrequest req; 823 struct usb_ctrlrequest req;
824 824
825 if (mEp->ep.desc == NULL) 825 if (mEp->ep.desc == NULL)
826 continue; /* not configured */ 826 continue; /* not configured */
827 827
828 if (hw_test_and_clear_complete(udc, i)) { 828 if (hw_test_and_clear_complete(ci, i)) {
829 err = isr_tr_complete_low(mEp); 829 err = isr_tr_complete_low(mEp);
830 if (mEp->type == USB_ENDPOINT_XFER_CONTROL) { 830 if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
831 if (err > 0) /* needs status phase */ 831 if (err > 0) /* needs status phase */
832 err = isr_setup_status_phase(udc); 832 err = isr_setup_status_phase(ci);
833 if (err < 0) { 833 if (err < 0) {
834 dbg_event(_usb_addr(mEp), 834 dbg_event(_usb_addr(mEp),
835 "ERROR", err); 835 "ERROR", err);
836 spin_unlock(&udc->lock); 836 spin_unlock(&ci->lock);
837 if (usb_ep_set_halt(&mEp->ep)) 837 if (usb_ep_set_halt(&mEp->ep))
838 dev_err(udc->dev, 838 dev_err(ci->dev,
839 "error: ep_set_halt\n"); 839 "error: ep_set_halt\n");
840 spin_lock(&udc->lock); 840 spin_lock(&ci->lock);
841 } 841 }
842 } 842 }
843 } 843 }
844 844
845 if (mEp->type != USB_ENDPOINT_XFER_CONTROL || 845 if (mEp->type != USB_ENDPOINT_XFER_CONTROL ||
846 !hw_test_and_clear_setup_status(udc, i)) 846 !hw_test_and_clear_setup_status(ci, i))
847 continue; 847 continue;
848 848
849 if (i != 0) { 849 if (i != 0) {
850 dev_warn(udc->dev, "ctrl traffic at endpoint %d\n", i); 850 dev_warn(ci->dev, "ctrl traffic at endpoint %d\n", i);
851 continue; 851 continue;
852 } 852 }
853 853
@@ -855,18 +855,18 @@ __acquires(udc->lock)
855 * Flush data and handshake transactions of previous 855 * Flush data and handshake transactions of previous
856 * setup packet. 856 * setup packet.
857 */ 857 */
858 _ep_nuke(udc->ep0out); 858 _ep_nuke(ci->ep0out);
859 _ep_nuke(udc->ep0in); 859 _ep_nuke(ci->ep0in);
860 860
861 /* read_setup_packet */ 861 /* read_setup_packet */
862 do { 862 do {
863 hw_test_and_set_setup_guard(udc); 863 hw_test_and_set_setup_guard(ci);
864 memcpy(&req, &mEp->qh.ptr->setup, sizeof(req)); 864 memcpy(&req, &mEp->qh.ptr->setup, sizeof(req));
865 } while (!hw_test_and_clear_setup_guard(udc)); 865 } while (!hw_test_and_clear_setup_guard(ci));
866 866
867 type = req.bRequestType; 867 type = req.bRequestType;
868 868
869 udc->ep0_dir = (type & USB_DIR_IN) ? TX : RX; 869 ci->ep0_dir = (type & USB_DIR_IN) ? TX : RX;
870 870
871 dbg_setup(_usb_addr(mEp), &req); 871 dbg_setup(_usb_addr(mEp), &req);
872 872
@@ -881,23 +881,23 @@ __acquires(udc->lock)
881 dir = num & USB_ENDPOINT_DIR_MASK; 881 dir = num & USB_ENDPOINT_DIR_MASK;
882 num &= USB_ENDPOINT_NUMBER_MASK; 882 num &= USB_ENDPOINT_NUMBER_MASK;
883 if (dir) /* TX */ 883 if (dir) /* TX */
884 num += udc->hw_ep_max/2; 884 num += ci->hw_ep_max/2;
885 if (!udc->ci13xxx_ep[num].wedge) { 885 if (!ci->ci13xxx_ep[num].wedge) {
886 spin_unlock(&udc->lock); 886 spin_unlock(&ci->lock);
887 err = usb_ep_clear_halt( 887 err = usb_ep_clear_halt(
888 &udc->ci13xxx_ep[num].ep); 888 &ci->ci13xxx_ep[num].ep);
889 spin_lock(&udc->lock); 889 spin_lock(&ci->lock);
890 if (err) 890 if (err)
891 break; 891 break;
892 } 892 }
893 err = isr_setup_status_phase(udc); 893 err = isr_setup_status_phase(ci);
894 } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE) && 894 } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE) &&
895 le16_to_cpu(req.wValue) == 895 le16_to_cpu(req.wValue) ==
896 USB_DEVICE_REMOTE_WAKEUP) { 896 USB_DEVICE_REMOTE_WAKEUP) {
897 if (req.wLength != 0) 897 if (req.wLength != 0)
898 break; 898 break;
899 udc->remote_wakeup = 0; 899 ci->remote_wakeup = 0;
900 err = isr_setup_status_phase(udc); 900 err = isr_setup_status_phase(ci);
901 } else { 901 } else {
902 goto delegate; 902 goto delegate;
903 } 903 }
@@ -910,7 +910,7 @@ __acquires(udc->lock)
910 if (le16_to_cpu(req.wLength) != 2 || 910 if (le16_to_cpu(req.wLength) != 2 ||
911 le16_to_cpu(req.wValue) != 0) 911 le16_to_cpu(req.wValue) != 0)
912 break; 912 break;
913 err = isr_get_status_response(udc, &req); 913 err = isr_get_status_response(ci, &req);
914 break; 914 break;
915 case USB_REQ_SET_ADDRESS: 915 case USB_REQ_SET_ADDRESS:
916 if (type != (USB_DIR_OUT|USB_RECIP_DEVICE)) 916 if (type != (USB_DIR_OUT|USB_RECIP_DEVICE))
@@ -918,9 +918,9 @@ __acquires(udc->lock)
918 if (le16_to_cpu(req.wLength) != 0 || 918 if (le16_to_cpu(req.wLength) != 0 ||
919 le16_to_cpu(req.wIndex) != 0) 919 le16_to_cpu(req.wIndex) != 0)
920 break; 920 break;
921 udc->address = (u8)le16_to_cpu(req.wValue); 921 ci->address = (u8)le16_to_cpu(req.wValue);
922 udc->setaddr = true; 922 ci->setaddr = true;
923 err = isr_setup_status_phase(udc); 923 err = isr_setup_status_phase(ci);
924 break; 924 break;
925 case USB_REQ_SET_FEATURE: 925 case USB_REQ_SET_FEATURE:
926 if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) && 926 if (type == (USB_DIR_OUT|USB_RECIP_ENDPOINT) &&
@@ -932,20 +932,20 @@ __acquires(udc->lock)
932 dir = num & USB_ENDPOINT_DIR_MASK; 932 dir = num & USB_ENDPOINT_DIR_MASK;
933 num &= USB_ENDPOINT_NUMBER_MASK; 933 num &= USB_ENDPOINT_NUMBER_MASK;
934 if (dir) /* TX */ 934 if (dir) /* TX */
935 num += udc->hw_ep_max/2; 935 num += ci->hw_ep_max/2;
936 936
937 spin_unlock(&udc->lock); 937 spin_unlock(&ci->lock);
938 err = usb_ep_set_halt(&udc->ci13xxx_ep[num].ep); 938 err = usb_ep_set_halt(&ci->ci13xxx_ep[num].ep);
939 spin_lock(&udc->lock); 939 spin_lock(&ci->lock);
940 if (!err) 940 if (!err)
941 isr_setup_status_phase(udc); 941 isr_setup_status_phase(ci);
942 } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE)) { 942 } else if (type == (USB_DIR_OUT|USB_RECIP_DEVICE)) {
943 if (req.wLength != 0) 943 if (req.wLength != 0)
944 break; 944 break;
945 switch (le16_to_cpu(req.wValue)) { 945 switch (le16_to_cpu(req.wValue)) {
946 case USB_DEVICE_REMOTE_WAKEUP: 946 case USB_DEVICE_REMOTE_WAKEUP:
947 udc->remote_wakeup = 1; 947 ci->remote_wakeup = 1;
948 err = isr_setup_status_phase(udc); 948 err = isr_setup_status_phase(ci);
949 break; 949 break;
950 case USB_DEVICE_TEST_MODE: 950 case USB_DEVICE_TEST_MODE:
951 tmode = le16_to_cpu(req.wIndex) >> 8; 951 tmode = le16_to_cpu(req.wIndex) >> 8;
@@ -955,9 +955,9 @@ __acquires(udc->lock)
955 case TEST_SE0_NAK: 955 case TEST_SE0_NAK:
956 case TEST_PACKET: 956 case TEST_PACKET:
957 case TEST_FORCE_EN: 957 case TEST_FORCE_EN:
958 udc->test_mode = tmode; 958 ci->test_mode = tmode;
959 err = isr_setup_status_phase( 959 err = isr_setup_status_phase(
960 udc); 960 ci);
961 break; 961 break;
962 default: 962 default:
963 break; 963 break;
@@ -972,21 +972,21 @@ __acquires(udc->lock)
972 default: 972 default:
973delegate: 973delegate:
974 if (req.wLength == 0) /* no data phase */ 974 if (req.wLength == 0) /* no data phase */
975 udc->ep0_dir = TX; 975 ci->ep0_dir = TX;
976 976
977 spin_unlock(&udc->lock); 977 spin_unlock(&ci->lock);
978 err = udc->driver->setup(&udc->gadget, &req); 978 err = ci->driver->setup(&ci->gadget, &req);
979 spin_lock(&udc->lock); 979 spin_lock(&ci->lock);
980 break; 980 break;
981 } 981 }
982 982
983 if (err < 0) { 983 if (err < 0) {
984 dbg_event(_usb_addr(mEp), "ERROR", err); 984 dbg_event(_usb_addr(mEp), "ERROR", err);
985 985
986 spin_unlock(&udc->lock); 986 spin_unlock(&ci->lock);
987 if (usb_ep_set_halt(&mEp->ep)) 987 if (usb_ep_set_halt(&mEp->ep))
988 dev_err(udc->dev, "error: ep_set_halt\n"); 988 dev_err(ci->dev, "error: ep_set_halt\n");
989 spin_lock(&udc->lock); 989 spin_lock(&ci->lock);
990 } 990 }
991 } 991 }
992} 992}
@@ -1016,7 +1016,7 @@ static int ep_enable(struct usb_ep *ep,
1016 mEp->ep.desc = desc; 1016 mEp->ep.desc = desc;
1017 1017
1018 if (!list_empty(&mEp->qh.queue)) 1018 if (!list_empty(&mEp->qh.queue))
1019 dev_warn(mEp->udc->dev, "enabling a non-empty endpoint!\n"); 1019 dev_warn(mEp->ci->dev, "enabling a non-empty endpoint!\n");
1020 1020
1021 mEp->dir = usb_endpoint_dir_in(desc) ? TX : RX; 1021 mEp->dir = usb_endpoint_dir_in(desc) ? TX : RX;
1022 mEp->num = usb_endpoint_num(desc); 1022 mEp->num = usb_endpoint_num(desc);
@@ -1044,7 +1044,7 @@ static int ep_enable(struct usb_ep *ep,
1044 * is always enabled 1044 * is always enabled
1045 */ 1045 */
1046 if (mEp->num) 1046 if (mEp->num)
1047 retval |= hw_ep_enable(mEp->udc, mEp->num, mEp->dir, mEp->type); 1047 retval |= hw_ep_enable(mEp->ci, mEp->num, mEp->dir, mEp->type);
1048 1048
1049 spin_unlock_irqrestore(mEp->lock, flags); 1049 spin_unlock_irqrestore(mEp->lock, flags);
1050 return retval; 1050 return retval;
@@ -1075,7 +1075,7 @@ static int ep_disable(struct usb_ep *ep)
1075 dbg_event(_usb_addr(mEp), "DISABLE", 0); 1075 dbg_event(_usb_addr(mEp), "DISABLE", 0);
1076 1076
1077 retval |= _ep_nuke(mEp); 1077 retval |= _ep_nuke(mEp);
1078 retval |= hw_ep_disable(mEp->udc, mEp->num, mEp->dir); 1078 retval |= hw_ep_disable(mEp->ci, mEp->num, mEp->dir);
1079 1079
1080 if (mEp->type == USB_ENDPOINT_XFER_CONTROL) 1080 if (mEp->type == USB_ENDPOINT_XFER_CONTROL)
1081 mEp->dir = (mEp->dir == TX) ? RX : TX; 1081 mEp->dir = (mEp->dir == TX) ? RX : TX;
@@ -1132,7 +1132,7 @@ static void ep_free_request(struct usb_ep *ep, struct usb_request *req)
1132 if (ep == NULL || req == NULL) { 1132 if (ep == NULL || req == NULL) {
1133 return; 1133 return;
1134 } else if (!list_empty(&mReq->queue)) { 1134 } else if (!list_empty(&mReq->queue)) {
1135 dev_err(mEp->udc->dev, "freeing queued request\n"); 1135 dev_err(mEp->ci->dev, "freeing queued request\n");
1136 return; 1136 return;
1137 } 1137 }
1138 1138
@@ -1157,7 +1157,7 @@ static int ep_queue(struct usb_ep *ep, struct usb_request *req,
1157{ 1157{
1158 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep); 1158 struct ci13xxx_ep *mEp = container_of(ep, struct ci13xxx_ep, ep);
1159 struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req); 1159 struct ci13xxx_req *mReq = container_of(req, struct ci13xxx_req, req);
1160 struct ci13xxx *udc = mEp->udc; 1160 struct ci13xxx *ci = mEp->ci;
1161 int retval = 0; 1161 int retval = 0;
1162 unsigned long flags; 1162 unsigned long flags;
1163 1163
@@ -1168,12 +1168,12 @@ static int ep_queue(struct usb_ep *ep, struct usb_request *req,
1168 1168
1169 if (mEp->type == USB_ENDPOINT_XFER_CONTROL) { 1169 if (mEp->type == USB_ENDPOINT_XFER_CONTROL) {
1170 if (req->length) 1170 if (req->length)
1171 mEp = (udc->ep0_dir == RX) ? 1171 mEp = (ci->ep0_dir == RX) ?
1172 udc->ep0out : udc->ep0in; 1172 ci->ep0out : ci->ep0in;
1173 if (!list_empty(&mEp->qh.queue)) { 1173 if (!list_empty(&mEp->qh.queue)) {
1174 _ep_nuke(mEp); 1174 _ep_nuke(mEp);
1175 retval = -EOVERFLOW; 1175 retval = -EOVERFLOW;
1176 dev_warn(mEp->udc->dev, "endpoint ctrl %X nuked\n", 1176 dev_warn(mEp->ci->dev, "endpoint ctrl %X nuked\n",
1177 _usb_addr(mEp)); 1177 _usb_addr(mEp));
1178 } 1178 }
1179 } 1179 }
@@ -1181,14 +1181,14 @@ static int ep_queue(struct usb_ep *ep, struct usb_request *req,
1181 /* first nuke then test link, e.g. previous status has not sent */ 1181 /* first nuke then test link, e.g. previous status has not sent */
1182 if (!list_empty(&mReq->queue)) { 1182 if (!list_empty(&mReq->queue)) {
1183 retval = -EBUSY; 1183 retval = -EBUSY;
1184 dev_err(mEp->udc->dev, "request already in queue\n"); 1184 dev_err(mEp->ci->dev, "request already in queue\n");
1185 goto done; 1185 goto done;
1186 } 1186 }
1187 1187
1188 if (req->length > 4 * CI13XXX_PAGE_SIZE) { 1188 if (req->length > 4 * CI13XXX_PAGE_SIZE) {
1189 req->length = 4 * CI13XXX_PAGE_SIZE; 1189 req->length = 4 * CI13XXX_PAGE_SIZE;
1190 retval = -EMSGSIZE; 1190 retval = -EMSGSIZE;
1191 dev_warn(mEp->udc->dev, "request length truncated\n"); 1191 dev_warn(mEp->ci->dev, "request length truncated\n");
1192 } 1192 }
1193 1193
1194 dbg_queue(_usb_addr(mEp), req, retval); 1194 dbg_queue(_usb_addr(mEp), req, retval);
@@ -1231,12 +1231,12 @@ static int ep_dequeue(struct usb_ep *ep, struct usb_request *req)
1231 1231
1232 dbg_event(_usb_addr(mEp), "DEQUEUE", 0); 1232 dbg_event(_usb_addr(mEp), "DEQUEUE", 0);
1233 1233
1234 hw_ep_flush(mEp->udc, mEp->num, mEp->dir); 1234 hw_ep_flush(mEp->ci, mEp->num, mEp->dir);
1235 1235
1236 /* pop request */ 1236 /* pop request */
1237 list_del_init(&mReq->queue); 1237 list_del_init(&mReq->queue);
1238 1238
1239 usb_gadget_unmap_request(&mEp->udc->gadget, req, mEp->dir); 1239 usb_gadget_unmap_request(&mEp->ci->gadget, req, mEp->dir);
1240 1240
1241 req->status = -ECONNRESET; 1241 req->status = -ECONNRESET;
1242 1242
@@ -1278,7 +1278,7 @@ static int ep_set_halt(struct usb_ep *ep, int value)
1278 direction = mEp->dir; 1278 direction = mEp->dir;
1279 do { 1279 do {
1280 dbg_event(_usb_addr(mEp), "HALT", value); 1280 dbg_event(_usb_addr(mEp), "HALT", value);
1281 retval |= hw_ep_set_halt(mEp->udc, mEp->num, mEp->dir, value); 1281 retval |= hw_ep_set_halt(mEp->ci, mEp->num, mEp->dir, value);
1282 1282
1283 if (!value) 1283 if (!value)
1284 mEp->wedge = 0; 1284 mEp->wedge = 0;
@@ -1326,14 +1326,14 @@ static void ep_fifo_flush(struct usb_ep *ep)
1326 unsigned long flags; 1326 unsigned long flags;
1327 1327
1328 if (ep == NULL) { 1328 if (ep == NULL) {
1329 dev_err(mEp->udc->dev, "%02X: -EINVAL\n", _usb_addr(mEp)); 1329 dev_err(mEp->ci->dev, "%02X: -EINVAL\n", _usb_addr(mEp));
1330 return; 1330 return;
1331 } 1331 }
1332 1332
1333 spin_lock_irqsave(mEp->lock, flags); 1333 spin_lock_irqsave(mEp->lock, flags);
1334 1334
1335 dbg_event(_usb_addr(mEp), "FFLUSH", 0); 1335 dbg_event(_usb_addr(mEp), "FFLUSH", 0);
1336 hw_ep_flush(mEp->udc, mEp->num, mEp->dir); 1336 hw_ep_flush(mEp->ci, mEp->num, mEp->dir);
1337 1337
1338 spin_unlock_irqrestore(mEp->lock, flags); 1338 spin_unlock_irqrestore(mEp->lock, flags);
1339} 1339}
@@ -1359,30 +1359,30 @@ static const struct usb_ep_ops usb_ep_ops = {
1359 *****************************************************************************/ 1359 *****************************************************************************/
1360static int ci13xxx_vbus_session(struct usb_gadget *_gadget, int is_active) 1360static int ci13xxx_vbus_session(struct usb_gadget *_gadget, int is_active)
1361{ 1361{
1362 struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget); 1362 struct ci13xxx *ci = container_of(_gadget, struct ci13xxx, gadget);
1363 unsigned long flags; 1363 unsigned long flags;
1364 int gadget_ready = 0; 1364 int gadget_ready = 0;
1365 1365
1366 if (!(udc->platdata->flags & CI13XXX_PULLUP_ON_VBUS)) 1366 if (!(ci->platdata->flags & CI13XXX_PULLUP_ON_VBUS))
1367 return -EOPNOTSUPP; 1367 return -EOPNOTSUPP;
1368 1368
1369 spin_lock_irqsave(&udc->lock, flags); 1369 spin_lock_irqsave(&ci->lock, flags);
1370 udc->vbus_active = is_active; 1370 ci->vbus_active = is_active;
1371 if (udc->driver) 1371 if (ci->driver)
1372 gadget_ready = 1; 1372 gadget_ready = 1;
1373 spin_unlock_irqrestore(&udc->lock, flags); 1373 spin_unlock_irqrestore(&ci->lock, flags);
1374 1374
1375 if (gadget_ready) { 1375 if (gadget_ready) {
1376 if (is_active) { 1376 if (is_active) {
1377 pm_runtime_get_sync(&_gadget->dev); 1377 pm_runtime_get_sync(&_gadget->dev);
1378 hw_device_reset(udc, USBMODE_CM_DC); 1378 hw_device_reset(ci, USBMODE_CM_DC);
1379 hw_device_state(udc, udc->ep0out->qh.dma); 1379 hw_device_state(ci, ci->ep0out->qh.dma);
1380 } else { 1380 } else {
1381 hw_device_state(udc, 0); 1381 hw_device_state(ci, 0);
1382 if (udc->platdata->notify_event) 1382 if (ci->platdata->notify_event)
1383 udc->platdata->notify_event(udc, 1383 ci->platdata->notify_event(ci,
1384 CI13XXX_CONTROLLER_STOPPED_EVENT); 1384 CI13XXX_CONTROLLER_STOPPED_EVENT);
1385 _gadget_stop_activity(&udc->gadget); 1385 _gadget_stop_activity(&ci->gadget);
1386 pm_runtime_put_sync(&_gadget->dev); 1386 pm_runtime_put_sync(&_gadget->dev);
1387 } 1387 }
1388 } 1388 }
@@ -1392,31 +1392,31 @@ static int ci13xxx_vbus_session(struct usb_gadget *_gadget, int is_active)
1392 1392
1393static int ci13xxx_wakeup(struct usb_gadget *_gadget) 1393static int ci13xxx_wakeup(struct usb_gadget *_gadget)
1394{ 1394{
1395 struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget); 1395 struct ci13xxx *ci = container_of(_gadget, struct ci13xxx, gadget);
1396 unsigned long flags; 1396 unsigned long flags;
1397 int ret = 0; 1397 int ret = 0;
1398 1398
1399 spin_lock_irqsave(&udc->lock, flags); 1399 spin_lock_irqsave(&ci->lock, flags);
1400 if (!udc->remote_wakeup) { 1400 if (!ci->remote_wakeup) {
1401 ret = -EOPNOTSUPP; 1401 ret = -EOPNOTSUPP;
1402 goto out; 1402 goto out;
1403 } 1403 }
1404 if (!hw_read(udc, OP_PORTSC, PORTSC_SUSP)) { 1404 if (!hw_read(ci, OP_PORTSC, PORTSC_SUSP)) {
1405 ret = -EINVAL; 1405 ret = -EINVAL;
1406 goto out; 1406 goto out;
1407 } 1407 }
1408 hw_write(udc, OP_PORTSC, PORTSC_FPR, PORTSC_FPR); 1408 hw_write(ci, OP_PORTSC, PORTSC_FPR, PORTSC_FPR);
1409out: 1409out:
1410 spin_unlock_irqrestore(&udc->lock, flags); 1410 spin_unlock_irqrestore(&ci->lock, flags);
1411 return ret; 1411 return ret;
1412} 1412}
1413 1413
1414static int ci13xxx_vbus_draw(struct usb_gadget *_gadget, unsigned mA) 1414static int ci13xxx_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
1415{ 1415{
1416 struct ci13xxx *udc = container_of(_gadget, struct ci13xxx, gadget); 1416 struct ci13xxx *ci = container_of(_gadget, struct ci13xxx, gadget);
1417 1417
1418 if (udc->transceiver) 1418 if (ci->transceiver)
1419 return usb_phy_set_power(udc->transceiver, mA); 1419 return usb_phy_set_power(ci->transceiver, mA);
1420 return -ENOTSUPP; 1420 return -ENOTSUPP;
1421} 1421}
1422 1422
@@ -1437,28 +1437,28 @@ static const struct usb_gadget_ops usb_gadget_ops = {
1437 .udc_stop = ci13xxx_stop, 1437 .udc_stop = ci13xxx_stop,
1438}; 1438};
1439 1439
1440static int init_eps(struct ci13xxx *udc) 1440static int init_eps(struct ci13xxx *ci)
1441{ 1441{
1442 int retval = 0, i, j; 1442 int retval = 0, i, j;
1443 1443
1444 for (i = 0; i < udc->hw_ep_max/2; i++) 1444 for (i = 0; i < ci->hw_ep_max/2; i++)
1445 for (j = RX; j <= TX; j++) { 1445 for (j = RX; j <= TX; j++) {
1446 int k = i + j * udc->hw_ep_max/2; 1446 int k = i + j * ci->hw_ep_max/2;
1447 struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[k]; 1447 struct ci13xxx_ep *mEp = &ci->ci13xxx_ep[k];
1448 1448
1449 scnprintf(mEp->name, sizeof(mEp->name), "ep%i%s", i, 1449 scnprintf(mEp->name, sizeof(mEp->name), "ep%i%s", i,
1450 (j == TX) ? "in" : "out"); 1450 (j == TX) ? "in" : "out");
1451 1451
1452 mEp->udc = udc; 1452 mEp->ci = ci;
1453 mEp->lock = &udc->lock; 1453 mEp->lock = &ci->lock;
1454 mEp->td_pool = udc->td_pool; 1454 mEp->td_pool = ci->td_pool;
1455 1455
1456 mEp->ep.name = mEp->name; 1456 mEp->ep.name = mEp->name;
1457 mEp->ep.ops = &usb_ep_ops; 1457 mEp->ep.ops = &usb_ep_ops;
1458 mEp->ep.maxpacket = CTRL_PAYLOAD_MAX; 1458 mEp->ep.maxpacket = CTRL_PAYLOAD_MAX;
1459 1459
1460 INIT_LIST_HEAD(&mEp->qh.queue); 1460 INIT_LIST_HEAD(&mEp->qh.queue);
1461 mEp->qh.ptr = dma_pool_alloc(udc->qh_pool, GFP_KERNEL, 1461 mEp->qh.ptr = dma_pool_alloc(ci->qh_pool, GFP_KERNEL,
1462 &mEp->qh.dma); 1462 &mEp->qh.dma);
1463 if (mEp->qh.ptr == NULL) 1463 if (mEp->qh.ptr == NULL)
1464 retval = -ENOMEM; 1464 retval = -ENOMEM;
@@ -1471,14 +1471,14 @@ static int init_eps(struct ci13xxx *udc)
1471 */ 1471 */
1472 if (i == 0) { 1472 if (i == 0) {
1473 if (j == RX) 1473 if (j == RX)
1474 udc->ep0out = mEp; 1474 ci->ep0out = mEp;
1475 else 1475 else
1476 udc->ep0in = mEp; 1476 ci->ep0in = mEp;
1477 1477
1478 continue; 1478 continue;
1479 } 1479 }
1480 1480
1481 list_add_tail(&mEp->ep.ep_list, &udc->gadget.ep_list); 1481 list_add_tail(&mEp->ep.ep_list, &ci->gadget.ep_list);
1482 } 1482 }
1483 1483
1484 return retval; 1484 return retval;
@@ -1494,7 +1494,7 @@ static int init_eps(struct ci13xxx *udc)
1494static int ci13xxx_start(struct usb_gadget *gadget, 1494static int ci13xxx_start(struct usb_gadget *gadget,
1495 struct usb_gadget_driver *driver) 1495 struct usb_gadget_driver *driver)
1496{ 1496{
1497 struct ci13xxx *udc = container_of(gadget, struct ci13xxx, gadget); 1497 struct ci13xxx *ci = container_of(gadget, struct ci13xxx, gadget);
1498 unsigned long flags; 1498 unsigned long flags;
1499 int retval = -ENOMEM; 1499 int retval = -ENOMEM;
1500 1500
@@ -1502,35 +1502,35 @@ static int ci13xxx_start(struct usb_gadget *gadget,
1502 return -EINVAL; 1502 return -EINVAL;
1503 1503
1504 1504
1505 udc->ep0out->ep.desc = &ctrl_endpt_out_desc; 1505 ci->ep0out->ep.desc = &ctrl_endpt_out_desc;
1506 retval = usb_ep_enable(&udc->ep0out->ep); 1506 retval = usb_ep_enable(&ci->ep0out->ep);
1507 if (retval) 1507 if (retval)
1508 return retval; 1508 return retval;
1509 1509
1510 udc->ep0in->ep.desc = &ctrl_endpt_in_desc; 1510 ci->ep0in->ep.desc = &ctrl_endpt_in_desc;
1511 retval = usb_ep_enable(&udc->ep0in->ep); 1511 retval = usb_ep_enable(&ci->ep0in->ep);
1512 if (retval) 1512 if (retval)
1513 return retval; 1513 return retval;
1514 spin_lock_irqsave(&udc->lock, flags); 1514 spin_lock_irqsave(&ci->lock, flags);
1515 1515
1516 udc->driver = driver; 1516 ci->driver = driver;
1517 pm_runtime_get_sync(&udc->gadget.dev); 1517 pm_runtime_get_sync(&ci->gadget.dev);
1518 if (udc->platdata->flags & CI13XXX_PULLUP_ON_VBUS) { 1518 if (ci->platdata->flags & CI13XXX_PULLUP_ON_VBUS) {
1519 if (udc->vbus_active) { 1519 if (ci->vbus_active) {
1520 if (udc->platdata->flags & CI13XXX_REGS_SHARED) 1520 if (ci->platdata->flags & CI13XXX_REGS_SHARED)
1521 hw_device_reset(udc, USBMODE_CM_DC); 1521 hw_device_reset(ci, USBMODE_CM_DC);
1522 } else { 1522 } else {
1523 pm_runtime_put_sync(&udc->gadget.dev); 1523 pm_runtime_put_sync(&ci->gadget.dev);
1524 goto done; 1524 goto done;
1525 } 1525 }
1526 } 1526 }
1527 1527
1528 retval = hw_device_state(udc, udc->ep0out->qh.dma); 1528 retval = hw_device_state(ci, ci->ep0out->qh.dma);
1529 if (retval) 1529 if (retval)
1530 pm_runtime_put_sync(&udc->gadget.dev); 1530 pm_runtime_put_sync(&ci->gadget.dev);
1531 1531
1532 done: 1532 done:
1533 spin_unlock_irqrestore(&udc->lock, flags); 1533 spin_unlock_irqrestore(&ci->lock, flags);
1534 return retval; 1534 return retval;
1535} 1535}
1536 1536
@@ -1540,25 +1540,25 @@ static int ci13xxx_start(struct usb_gadget *gadget,
1540static int ci13xxx_stop(struct usb_gadget *gadget, 1540static int ci13xxx_stop(struct usb_gadget *gadget,
1541 struct usb_gadget_driver *driver) 1541 struct usb_gadget_driver *driver)
1542{ 1542{
1543 struct ci13xxx *udc = container_of(gadget, struct ci13xxx, gadget); 1543 struct ci13xxx *ci = container_of(gadget, struct ci13xxx, gadget);
1544 unsigned long flags; 1544 unsigned long flags;
1545 1545
1546 spin_lock_irqsave(&udc->lock, flags); 1546 spin_lock_irqsave(&ci->lock, flags);
1547 1547
1548 if (!(udc->platdata->flags & CI13XXX_PULLUP_ON_VBUS) || 1548 if (!(ci->platdata->flags & CI13XXX_PULLUP_ON_VBUS) ||
1549 udc->vbus_active) { 1549 ci->vbus_active) {
1550 hw_device_state(udc, 0); 1550 hw_device_state(ci, 0);
1551 if (udc->platdata->notify_event) 1551 if (ci->platdata->notify_event)
1552 udc->platdata->notify_event(udc, 1552 ci->platdata->notify_event(ci,
1553 CI13XXX_CONTROLLER_STOPPED_EVENT); 1553 CI13XXX_CONTROLLER_STOPPED_EVENT);
1554 udc->driver = NULL; 1554 ci->driver = NULL;
1555 spin_unlock_irqrestore(&udc->lock, flags); 1555 spin_unlock_irqrestore(&ci->lock, flags);
1556 _gadget_stop_activity(&udc->gadget); 1556 _gadget_stop_activity(&ci->gadget);
1557 spin_lock_irqsave(&udc->lock, flags); 1557 spin_lock_irqsave(&ci->lock, flags);
1558 pm_runtime_put(&udc->gadget.dev); 1558 pm_runtime_put(&ci->gadget.dev);
1559 } 1559 }
1560 1560
1561 spin_unlock_irqrestore(&udc->lock, flags); 1561 spin_unlock_irqrestore(&ci->lock, flags);
1562 1562
1563 return 0; 1563 return 0;
1564} 1564}
@@ -1567,64 +1567,64 @@ static int ci13xxx_stop(struct usb_gadget *gadget,
1567 * BUS block 1567 * BUS block
1568 *****************************************************************************/ 1568 *****************************************************************************/
1569/** 1569/**
1570 * udc_irq: udc interrupt handler 1570 * udc_irq: ci interrupt handler
1571 * 1571 *
1572 * This function returns IRQ_HANDLED if the IRQ has been handled 1572 * This function returns IRQ_HANDLED if the IRQ has been handled
1573 * It locks access to registers 1573 * It locks access to registers
1574 */ 1574 */
1575static irqreturn_t udc_irq(struct ci13xxx *udc) 1575static irqreturn_t udc_irq(struct ci13xxx *ci)
1576{ 1576{
1577 irqreturn_t retval; 1577 irqreturn_t retval;
1578 u32 intr; 1578 u32 intr;
1579 1579
1580 if (udc == NULL) 1580 if (ci == NULL)
1581 return IRQ_HANDLED; 1581 return IRQ_HANDLED;
1582 1582
1583 spin_lock(&udc->lock); 1583 spin_lock(&ci->lock);
1584 1584
1585 if (udc->platdata->flags & CI13XXX_REGS_SHARED) { 1585 if (ci->platdata->flags & CI13XXX_REGS_SHARED) {
1586 if (hw_read(udc, OP_USBMODE, USBMODE_CM) != 1586 if (hw_read(ci, OP_USBMODE, USBMODE_CM) !=
1587 USBMODE_CM_DC) { 1587 USBMODE_CM_DC) {
1588 spin_unlock(&udc->lock); 1588 spin_unlock(&ci->lock);
1589 return IRQ_NONE; 1589 return IRQ_NONE;
1590 } 1590 }
1591 } 1591 }
1592 intr = hw_test_and_clear_intr_active(udc); 1592 intr = hw_test_and_clear_intr_active(ci);
1593 dbg_interrupt(intr); 1593 dbg_interrupt(intr);
1594 1594
1595 if (intr) { 1595 if (intr) {
1596 /* order defines priority - do NOT change it */ 1596 /* order defines priority - do NOT change it */
1597 if (USBi_URI & intr) 1597 if (USBi_URI & intr)
1598 isr_reset_handler(udc); 1598 isr_reset_handler(ci);
1599 1599
1600 if (USBi_PCI & intr) { 1600 if (USBi_PCI & intr) {
1601 udc->gadget.speed = hw_port_is_high_speed(udc) ? 1601 ci->gadget.speed = hw_port_is_high_speed(ci) ?
1602 USB_SPEED_HIGH : USB_SPEED_FULL; 1602 USB_SPEED_HIGH : USB_SPEED_FULL;
1603 if (udc->suspended && udc->driver->resume) { 1603 if (ci->suspended && ci->driver->resume) {
1604 spin_unlock(&udc->lock); 1604 spin_unlock(&ci->lock);
1605 udc->driver->resume(&udc->gadget); 1605 ci->driver->resume(&ci->gadget);
1606 spin_lock(&udc->lock); 1606 spin_lock(&ci->lock);
1607 udc->suspended = 0; 1607 ci->suspended = 0;
1608 } 1608 }
1609 } 1609 }
1610 1610
1611 if (USBi_UI & intr) 1611 if (USBi_UI & intr)
1612 isr_tr_complete_handler(udc); 1612 isr_tr_complete_handler(ci);
1613 1613
1614 if (USBi_SLI & intr) { 1614 if (USBi_SLI & intr) {
1615 if (udc->gadget.speed != USB_SPEED_UNKNOWN && 1615 if (ci->gadget.speed != USB_SPEED_UNKNOWN &&
1616 udc->driver->suspend) { 1616 ci->driver->suspend) {
1617 udc->suspended = 1; 1617 ci->suspended = 1;
1618 spin_unlock(&udc->lock); 1618 spin_unlock(&ci->lock);
1619 udc->driver->suspend(&udc->gadget); 1619 ci->driver->suspend(&ci->gadget);
1620 spin_lock(&udc->lock); 1620 spin_lock(&ci->lock);
1621 } 1621 }
1622 } 1622 }
1623 retval = IRQ_HANDLED; 1623 retval = IRQ_HANDLED;
1624 } else { 1624 } else {
1625 retval = IRQ_NONE; 1625 retval = IRQ_NONE;
1626 } 1626 }
1627 spin_unlock(&udc->lock); 1627 spin_unlock(&ci->lock);
1628 1628
1629 return retval; 1629 return retval;
1630} 1630}
@@ -1641,109 +1641,109 @@ static void udc_release(struct device *dev)
1641 1641
1642/** 1642/**
1643 * udc_start: initialize gadget role 1643 * udc_start: initialize gadget role
1644 * @udc: chipidea controller 1644 * @ci: chipidea controller
1645 */ 1645 */
1646static int udc_start(struct ci13xxx *udc) 1646static int udc_start(struct ci13xxx *ci)
1647{ 1647{
1648 struct device *dev = udc->dev; 1648 struct device *dev = ci->dev;
1649 int retval = 0; 1649 int retval = 0;
1650 1650
1651 spin_lock_init(&udc->lock); 1651 spin_lock_init(&ci->lock);
1652 1652
1653 udc->gadget.ops = &usb_gadget_ops; 1653 ci->gadget.ops = &usb_gadget_ops;
1654 udc->gadget.speed = USB_SPEED_UNKNOWN; 1654 ci->gadget.speed = USB_SPEED_UNKNOWN;
1655 udc->gadget.max_speed = USB_SPEED_HIGH; 1655 ci->gadget.max_speed = USB_SPEED_HIGH;
1656 udc->gadget.is_otg = 0; 1656 ci->gadget.is_otg = 0;
1657 udc->gadget.name = udc->platdata->name; 1657 ci->gadget.name = ci->platdata->name;
1658 1658
1659 INIT_LIST_HEAD(&udc->gadget.ep_list); 1659 INIT_LIST_HEAD(&ci->gadget.ep_list);
1660 1660
1661 dev_set_name(&udc->gadget.dev, "gadget"); 1661 dev_set_name(&ci->gadget.dev, "gadget");
1662 udc->gadget.dev.dma_mask = dev->dma_mask; 1662 ci->gadget.dev.dma_mask = dev->dma_mask;
1663 udc->gadget.dev.coherent_dma_mask = dev->coherent_dma_mask; 1663 ci->gadget.dev.coherent_dma_mask = dev->coherent_dma_mask;
1664 udc->gadget.dev.parent = dev; 1664 ci->gadget.dev.parent = dev;
1665 udc->gadget.dev.release = udc_release; 1665 ci->gadget.dev.release = udc_release;
1666 1666
1667 /* alloc resources */ 1667 /* alloc resources */
1668 udc->qh_pool = dma_pool_create("ci13xxx_qh", dev, 1668 ci->qh_pool = dma_pool_create("ci13xxx_qh", dev,
1669 sizeof(struct ci13xxx_qh), 1669 sizeof(struct ci13xxx_qh),
1670 64, CI13XXX_PAGE_SIZE); 1670 64, CI13XXX_PAGE_SIZE);
1671 if (udc->qh_pool == NULL) 1671 if (ci->qh_pool == NULL)
1672 return -ENOMEM; 1672 return -ENOMEM;
1673 1673
1674 udc->td_pool = dma_pool_create("ci13xxx_td", dev, 1674 ci->td_pool = dma_pool_create("ci13xxx_td", dev,
1675 sizeof(struct ci13xxx_td), 1675 sizeof(struct ci13xxx_td),
1676 64, CI13XXX_PAGE_SIZE); 1676 64, CI13XXX_PAGE_SIZE);
1677 if (udc->td_pool == NULL) { 1677 if (ci->td_pool == NULL) {
1678 retval = -ENOMEM; 1678 retval = -ENOMEM;
1679 goto free_qh_pool; 1679 goto free_qh_pool;
1680 } 1680 }
1681 1681
1682 retval = init_eps(udc); 1682 retval = init_eps(ci);
1683 if (retval) 1683 if (retval)
1684 goto free_pools; 1684 goto free_pools;
1685 1685
1686 udc->gadget.ep0 = &udc->ep0in->ep; 1686 ci->gadget.ep0 = &ci->ep0in->ep;
1687 1687
1688 udc->transceiver = usb_get_phy(USB_PHY_TYPE_USB2); 1688 ci->transceiver = usb_get_phy(USB_PHY_TYPE_USB2);
1689 1689
1690 if (udc->platdata->flags & CI13XXX_REQUIRE_TRANSCEIVER) { 1690 if (ci->platdata->flags & CI13XXX_REQUIRE_TRANSCEIVER) {
1691 if (udc->transceiver == NULL) { 1691 if (ci->transceiver == NULL) {
1692 retval = -ENODEV; 1692 retval = -ENODEV;
1693 goto free_pools; 1693 goto free_pools;
1694 } 1694 }
1695 } 1695 }
1696 1696
1697 if (!(udc->platdata->flags & CI13XXX_REGS_SHARED)) { 1697 if (!(ci->platdata->flags & CI13XXX_REGS_SHARED)) {
1698 retval = hw_device_reset(udc, USBMODE_CM_DC); 1698 retval = hw_device_reset(ci, USBMODE_CM_DC);
1699 if (retval) 1699 if (retval)
1700 goto put_transceiver; 1700 goto put_transceiver;
1701 } 1701 }
1702 1702
1703 retval = device_register(&udc->gadget.dev); 1703 retval = device_register(&ci->gadget.dev);
1704 if (retval) { 1704 if (retval) {
1705 put_device(&udc->gadget.dev); 1705 put_device(&ci->gadget.dev);
1706 goto put_transceiver; 1706 goto put_transceiver;
1707 } 1707 }
1708 1708
1709 retval = dbg_create_files(&udc->gadget.dev); 1709 retval = dbg_create_files(&ci->gadget.dev);
1710 if (retval) 1710 if (retval)
1711 goto unreg_device; 1711 goto unreg_device;
1712 1712
1713 if (!IS_ERR_OR_NULL(udc->transceiver)) { 1713 if (!IS_ERR_OR_NULL(ci->transceiver)) {
1714 retval = otg_set_peripheral(udc->transceiver->otg, 1714 retval = otg_set_peripheral(ci->transceiver->otg,
1715 &udc->gadget); 1715 &ci->gadget);
1716 if (retval) 1716 if (retval)
1717 goto remove_dbg; 1717 goto remove_dbg;
1718 } 1718 }
1719 1719
1720 retval = usb_add_gadget_udc(dev, &udc->gadget); 1720 retval = usb_add_gadget_udc(dev, &ci->gadget);
1721 if (retval) 1721 if (retval)
1722 goto remove_trans; 1722 goto remove_trans;
1723 1723
1724 pm_runtime_no_callbacks(&udc->gadget.dev); 1724 pm_runtime_no_callbacks(&ci->gadget.dev);
1725 pm_runtime_enable(&udc->gadget.dev); 1725 pm_runtime_enable(&ci->gadget.dev);
1726 1726
1727 return retval; 1727 return retval;
1728 1728
1729remove_trans: 1729remove_trans:
1730 if (!IS_ERR_OR_NULL(udc->transceiver)) { 1730 if (!IS_ERR_OR_NULL(ci->transceiver)) {
1731 otg_set_peripheral(udc->transceiver->otg, &udc->gadget); 1731 otg_set_peripheral(ci->transceiver->otg, &ci->gadget);
1732 usb_put_phy(udc->transceiver); 1732 usb_put_phy(ci->transceiver);
1733 } 1733 }
1734 1734
1735 dev_err(dev, "error = %i\n", retval); 1735 dev_err(dev, "error = %i\n", retval);
1736remove_dbg: 1736remove_dbg:
1737 dbg_remove_files(&udc->gadget.dev); 1737 dbg_remove_files(&ci->gadget.dev);
1738unreg_device: 1738unreg_device:
1739 device_unregister(&udc->gadget.dev); 1739 device_unregister(&ci->gadget.dev);
1740put_transceiver: 1740put_transceiver:
1741 if (!IS_ERR_OR_NULL(udc->transceiver)) 1741 if (!IS_ERR_OR_NULL(ci->transceiver))
1742 usb_put_phy(udc->transceiver); 1742 usb_put_phy(ci->transceiver);
1743free_pools: 1743free_pools:
1744 dma_pool_destroy(udc->td_pool); 1744 dma_pool_destroy(ci->td_pool);
1745free_qh_pool: 1745free_qh_pool:
1746 dma_pool_destroy(udc->qh_pool); 1746 dma_pool_destroy(ci->qh_pool);
1747 return retval; 1747 return retval;
1748} 1748}
1749 1749
@@ -1752,32 +1752,32 @@ free_qh_pool:
1752 * 1752 *
1753 * No interrupts active, the IRQ has been released 1753 * No interrupts active, the IRQ has been released
1754 */ 1754 */
1755static void udc_stop(struct ci13xxx *udc) 1755static void udc_stop(struct ci13xxx *ci)
1756{ 1756{
1757 int i; 1757 int i;
1758 1758
1759 if (udc == NULL) 1759 if (ci == NULL)
1760 return; 1760 return;
1761 1761
1762 usb_del_gadget_udc(&udc->gadget); 1762 usb_del_gadget_udc(&ci->gadget);
1763 1763
1764 for (i = 0; i < udc->hw_ep_max; i++) { 1764 for (i = 0; i < ci->hw_ep_max; i++) {
1765 struct ci13xxx_ep *mEp = &udc->ci13xxx_ep[i]; 1765 struct ci13xxx_ep *mEp = &ci->ci13xxx_ep[i];
1766 1766
1767 dma_pool_free(udc->qh_pool, mEp->qh.ptr, mEp->qh.dma); 1767 dma_pool_free(ci->qh_pool, mEp->qh.ptr, mEp->qh.dma);
1768 } 1768 }
1769 1769
1770 dma_pool_destroy(udc->td_pool); 1770 dma_pool_destroy(ci->td_pool);
1771 dma_pool_destroy(udc->qh_pool); 1771 dma_pool_destroy(ci->qh_pool);
1772 1772
1773 if (!IS_ERR_OR_NULL(udc->transceiver)) { 1773 if (!IS_ERR_OR_NULL(ci->transceiver)) {
1774 otg_set_peripheral(udc->transceiver->otg, NULL); 1774 otg_set_peripheral(ci->transceiver->otg, NULL);
1775 usb_put_phy(udc->transceiver); 1775 usb_put_phy(ci->transceiver);
1776 } 1776 }
1777 dbg_remove_files(&udc->gadget.dev); 1777 dbg_remove_files(&ci->gadget.dev);
1778 device_unregister(&udc->gadget.dev); 1778 device_unregister(&ci->gadget.dev);
1779 /* my kobject is dynamic, I swear! */ 1779 /* my kobject is dynamic, I swear! */
1780 memset(&udc->gadget, 0, sizeof(udc->gadget)); 1780 memset(&ci->gadget, 0, sizeof(ci->gadget));
1781} 1781}
1782 1782
1783/** 1783/**
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-03 11:50:41 -0500