Merge branch 'iu-boot/master' into 'u-boot-arm/master'
[platform/kernel/u-boot.git] / drivers / usb / gadget / mpc8xx_udc.c
1 /*
2  * Copyright (C) 2006 by Bryan O'Donoghue, CodeHermit
3  * bodonoghue@CodeHermit.ie
4  *
5  * References
6  * DasUBoot/drivers/usb/gadget/omap1510_udc.c, for design and implementation
7  * ideas.
8  *
9  * SPDX-License-Identifier:     GPL-2.0+
10  */
11
12 /*
13  * Notes :
14  * 1.   #define __SIMULATE_ERROR__ to inject a CRC error into every 2nd TX
15  *              packet to force the USB re-transmit protocol.
16  *
17  * 2.   #define __DEBUG_UDC__ to switch on debug tracing to serial console
18  *      be careful that tracing doesn't create Hiesen-bugs with respect to
19  *      response timeouts to control requests.
20  *
21  * 3.   This driver should be able to support any higher level driver that
22  *      that wants to do either of the two standard UDC implementations
23  *      Control-Bulk-Interrupt or  Bulk-IN/Bulk-Out standards. Hence
24  *      gserial and cdc_acm should work with this code.
25  *
26  * 4.   NAK events never actually get raised at all, the documentation
27  *      is just wrong !
28  *
29  * 5.   For some reason, cbd_datlen is *always* +2 the value it should be.
30  *      this means that having an RX cbd of 16 bytes is not possible, since
31  *      the same size is reported for 14 bytes received as 16 bytes received
32  *      until we can find out why this happens, RX cbds must be limited to 8
33  *      bytes. TODO: check errata for this behaviour.
34  *
35  * 6.   Right now this code doesn't support properly powering up with the USB
36  *      cable attached to the USB host my development board the Adder87x doesn't
37  *      have a pull-up fitted to allow this, so it is necessary to power the
38  *      board and *then* attached the USB cable to the host. However somebody
39  *      with a different design in their board may be able to keep the cable
40  *      constantly connected and simply enable/disable a pull-up  re
41  *      figure 31.1 in MPC885RM.pdf instead of having to power up the board and
42  *      then attach the cable !
43  *
44  */
45 #include <common.h>
46 #include <config.h>
47 #include <commproc.h>
48 #include <usbdevice.h>
49 #include <usb/mpc8xx_udc.h>
50 #include <usb/udc.h>
51
52 #include "ep0.h"
53
54 DECLARE_GLOBAL_DATA_PTR;
55
56 #define ERR(fmt, args...)\
57         serial_printf("ERROR : [%s] %s:%d: "fmt,\
58                                 __FILE__,__FUNCTION__,__LINE__, ##args)
59 #ifdef __DEBUG_UDC__
60 #define DBG(fmt,args...)\
61                 serial_printf("[%s] %s:%d: "fmt,\
62                                 __FILE__,__FUNCTION__,__LINE__, ##args)
63 #else
64 #define DBG(fmt,args...)
65 #endif
66
67 /* Static Data */
68 #ifdef __SIMULATE_ERROR__
69 static char err_poison_test = 0;
70 #endif
71 static struct mpc8xx_ep ep_ref[MAX_ENDPOINTS];
72 static u32 address_base = STATE_NOT_READY;
73 static mpc8xx_udc_state_t udc_state = 0;
74 static struct usb_device_instance *udc_device = 0;
75 static volatile usb_epb_t *endpoints[MAX_ENDPOINTS];
76 static volatile cbd_t *tx_cbd[TX_RING_SIZE];
77 static volatile cbd_t *rx_cbd[RX_RING_SIZE];
78 static volatile immap_t *immr = 0;
79 static volatile cpm8xx_t *cp = 0;
80 static volatile usb_pram_t *usb_paramp = 0;
81 static volatile usb_t *usbp = 0;
82 static int rx_ct = 0;
83 static int tx_ct = 0;
84
85 /* Static Function Declarations */
86 static void mpc8xx_udc_state_transition_up (usb_device_state_t initial,
87                                             usb_device_state_t final);
88 static void mpc8xx_udc_state_transition_down (usb_device_state_t initial,
89                                               usb_device_state_t final);
90 static void mpc8xx_udc_stall (unsigned int ep);
91 static void mpc8xx_udc_flush_tx_fifo (int epid);
92 static void mpc8xx_udc_flush_rx_fifo (void);
93 static void mpc8xx_udc_clear_rxbd (volatile cbd_t * rx_cbdp);
94 static void mpc8xx_udc_init_tx (struct usb_endpoint_instance *epi,
95                                 struct urb *tx_urb);
96 static void mpc8xx_udc_dump_request (struct usb_device_request *request);
97 static void mpc8xx_udc_clock_init (volatile immap_t * immr,
98                                    volatile cpm8xx_t * cp);
99 static int mpc8xx_udc_ep_tx (struct usb_endpoint_instance *epi);
100 static int mpc8xx_udc_epn_rx (unsigned int epid, volatile cbd_t * rx_cbdp);
101 static void mpc8xx_udc_ep0_rx (volatile cbd_t * rx_cbdp);
102 static void mpc8xx_udc_cbd_init (void);
103 static void mpc8xx_udc_endpoint_init (void);
104 static void mpc8xx_udc_cbd_attach (int ep, uchar tx_size, uchar rx_size);
105 static u32 mpc8xx_udc_alloc (u32 data_size, u32 alignment);
106 static int mpc8xx_udc_ep0_rx_setup (volatile cbd_t * rx_cbdp);
107 static void mpc8xx_udc_set_nak (unsigned int ep);
108 static short mpc8xx_udc_handle_txerr (void);
109 static void mpc8xx_udc_advance_rx (volatile cbd_t ** rx_cbdp, int epid);
110
111 /******************************************************************************
112                                Global Linkage
113  *****************************************************************************/
114
115 /* udc_init
116  *
117  * Do initial bus gluing
118  */
119 int udc_init (void)
120 {
121         /* Init various pointers */
122         immr = (immap_t *) CONFIG_SYS_IMMR;
123         cp = (cpm8xx_t *) & (immr->im_cpm);
124         usb_paramp = (usb_pram_t *) & (cp->cp_dparam[PROFF_USB]);
125         usbp = (usb_t *) & (cp->cp_scc[0]);
126
127         memset (ep_ref, 0x00, (sizeof (struct mpc8xx_ep) * MAX_ENDPOINTS));
128
129         udc_device = 0;
130         udc_state = STATE_NOT_READY;
131
132         usbp->usmod = 0x00;
133         usbp->uscom = 0;
134
135         /* Set USB Frame #0, Respond at Address & Get a clock source  */
136         usbp->usaddr = 0x00;
137         mpc8xx_udc_clock_init (immr, cp);
138
139         /* PA15, PA14 as perhiperal USBRXD and USBOE */
140         immr->im_ioport.iop_padir &= ~0x0003;
141         immr->im_ioport.iop_papar |= 0x0003;
142
143         /* PC11/PC10 as peripheral USBRXP USBRXN */
144         immr->im_ioport.iop_pcso |= 0x0030;
145
146         /* PC7/PC6 as perhiperal USBTXP and USBTXN */
147         immr->im_ioport.iop_pcdir |= 0x0300;
148         immr->im_ioport.iop_pcpar |= 0x0300;
149
150         /* Set the base address */
151         address_base = (u32) (cp->cp_dpmem + CPM_USB_BASE);
152
153         /* Initialise endpoints and circular buffers */
154         mpc8xx_udc_endpoint_init ();
155         mpc8xx_udc_cbd_init ();
156
157         /* Assign allocated Dual Port Endpoint descriptors */
158         usb_paramp->ep0ptr = (u32) endpoints[0];
159         usb_paramp->ep1ptr = (u32) endpoints[1];
160         usb_paramp->ep2ptr = (u32) endpoints[2];
161         usb_paramp->ep3ptr = (u32) endpoints[3];
162         usb_paramp->frame_n = 0;
163
164         DBG ("ep0ptr=0x%08x ep1ptr=0x%08x ep2ptr=0x%08x ep3ptr=0x%08x\n",
165              usb_paramp->ep0ptr, usb_paramp->ep1ptr, usb_paramp->ep2ptr,
166              usb_paramp->ep3ptr);
167
168         return 0;
169 }
170
171 /* udc_irq
172  *
173  * Poll for whatever events may have occured
174  */
175 void udc_irq (void)
176 {
177         int epid = 0;
178         volatile cbd_t *rx_cbdp = 0;
179         volatile cbd_t *rx_cbdp_base = 0;
180
181         if (udc_state != STATE_READY) {
182                 return;
183         }
184
185         if (usbp->usber & USB_E_BSY) {
186                 /* This shouldn't happen. If it does then it's a bug ! */
187                 usbp->usber |= USB_E_BSY;
188                 mpc8xx_udc_flush_rx_fifo ();
189         }
190
191         /* Scan all RX/Bidirectional Endpoints for RX data. */
192         for (epid = 0; epid < MAX_ENDPOINTS; epid++) {
193                 if (!ep_ref[epid].prx) {
194                         continue;
195                 }
196                 rx_cbdp = rx_cbdp_base = ep_ref[epid].prx;
197
198                 do {
199                         if (!(rx_cbdp->cbd_sc & RX_BD_E)) {
200
201                                 if (rx_cbdp->cbd_sc & 0x1F) {
202                                         /* Corrupt data discard it.
203                                          * Controller has NAK'd this packet.
204                                          */
205                                         mpc8xx_udc_clear_rxbd (rx_cbdp);
206
207                                 } else {
208                                         if (!epid) {
209                                                 mpc8xx_udc_ep0_rx (rx_cbdp);
210
211                                         } else {
212                                                 /* Process data */
213                                                 mpc8xx_udc_set_nak (epid);
214                                                 mpc8xx_udc_epn_rx (epid, rx_cbdp);
215                                                 mpc8xx_udc_clear_rxbd (rx_cbdp);
216                                         }
217                                 }
218
219                                 /* Advance RX CBD pointer */
220                                 mpc8xx_udc_advance_rx (&rx_cbdp, epid);
221                                 ep_ref[epid].prx = rx_cbdp;
222                         } else {
223                                 /* Advance RX CBD pointer */
224                                 mpc8xx_udc_advance_rx (&rx_cbdp, epid);
225                         }
226
227                 } while (rx_cbdp != rx_cbdp_base);
228         }
229
230         /* Handle TX events as appropiate, the correct place to do this is
231          * in a tx routine. Perhaps TX on epn was pre-empted by ep0
232          */
233
234         if (usbp->usber & USB_E_TXB) {
235                 usbp->usber |= USB_E_TXB;
236         }
237
238         if (usbp->usber & (USB_TX_ERRMASK)) {
239                 mpc8xx_udc_handle_txerr ();
240         }
241
242         /* Switch to the default state, respond at the default address */
243         if (usbp->usber & USB_E_RESET) {
244                 usbp->usber |= USB_E_RESET;
245                 usbp->usaddr = 0x00;
246                 udc_device->device_state = STATE_DEFAULT;
247         }
248
249         /* if(usbp->usber&USB_E_IDLE){
250            We could suspend here !
251            usbp->usber|=USB_E_IDLE;
252            DBG("idle state change\n");
253            }
254            if(usbp->usbs){
255            We could resume here when IDLE is deasserted !
256            Not worth doing, so long as we are self powered though.
257            }
258         */
259
260         return;
261 }
262
263 /* udc_endpoint_write
264  *
265  * Write some data to an endpoint
266  */
267 int udc_endpoint_write (struct usb_endpoint_instance *epi)
268 {
269         int ep = 0;
270         short epid = 1, unnak = 0, ret = 0;
271
272         if (udc_state != STATE_READY) {
273                 ERR ("invalid udc_state != STATE_READY!\n");
274                 return -1;
275         }
276
277         if (!udc_device || !epi) {
278                 return -1;
279         }
280
281         if (udc_device->device_state != STATE_CONFIGURED) {
282                 return -1;
283         }
284
285         ep = epi->endpoint_address & 0x03;
286         if (ep >= MAX_ENDPOINTS) {
287                 return -1;
288         }
289
290         /* Set NAK for all RX endpoints during TX */
291         for (epid = 1; epid < MAX_ENDPOINTS; epid++) {
292
293                 /* Don't set NAK on DATA IN/CONTROL endpoints */
294                 if (ep_ref[epid].sc & USB_DIR_IN) {
295                         continue;
296                 }
297
298                 if (!(usbp->usep[epid] & (USEP_THS_NAK | USEP_RHS_NAK))) {
299                         unnak |= 1 << epid;
300                 }
301
302                 mpc8xx_udc_set_nak (epid);
303         }
304
305         mpc8xx_udc_init_tx (&udc_device->bus->endpoint_array[ep],
306                             epi->tx_urb);
307         ret = mpc8xx_udc_ep_tx (&udc_device->bus->endpoint_array[ep]);
308
309         /* Remove temporary NAK */
310         for (epid = 1; epid < MAX_ENDPOINTS; epid++) {
311                 if (unnak & (1 << epid)) {
312                         udc_unset_nak (epid);
313                 }
314         }
315
316         return ret;
317 }
318
319 /* mpc8xx_udc_assign_urb
320  *
321  * Associate a given urb to an endpoint TX or RX transmit/receive buffers
322  */
323 static int mpc8xx_udc_assign_urb (int ep, char direction)
324 {
325         struct usb_endpoint_instance *epi = 0;
326
327         if (ep >= MAX_ENDPOINTS) {
328                 goto err;
329         }
330         epi = &udc_device->bus->endpoint_array[ep];
331         if (!epi) {
332                 goto err;
333         }
334
335         if (!ep_ref[ep].urb) {
336                 ep_ref[ep].urb = usbd_alloc_urb (udc_device, udc_device->bus->endpoint_array);
337                 if (!ep_ref[ep].urb) {
338                         goto err;
339                 }
340         } else {
341                 ep_ref[ep].urb->actual_length = 0;
342         }
343
344         switch (direction) {
345         case USB_DIR_IN:
346                 epi->tx_urb = ep_ref[ep].urb;
347                 break;
348         case USB_DIR_OUT:
349                 epi->rcv_urb = ep_ref[ep].urb;
350                 break;
351         default:
352                 goto err;
353         }
354         return 0;
355
356       err:
357         udc_state = STATE_ERROR;
358         return -1;
359 }
360
361 /* udc_setup_ep
362  *
363  * Associate U-Boot software endpoints to mpc8xx endpoint parameter ram
364  * Isochronous endpoints aren't yet supported!
365  */
366 void udc_setup_ep (struct usb_device_instance *device, unsigned int ep,
367                    struct usb_endpoint_instance *epi)
368 {
369         uchar direction = 0;
370         int ep_attrib = 0;
371
372         if (epi && (ep < MAX_ENDPOINTS)) {
373
374                 if (ep == 0) {
375                         if (epi->rcv_attributes != USB_ENDPOINT_XFER_CONTROL
376                             || epi->tx_attributes !=
377                             USB_ENDPOINT_XFER_CONTROL) {
378
379                                 /* ep0 must be a control endpoint */
380                                 udc_state = STATE_ERROR;
381                                 return;
382
383                         }
384                         if (!(ep_ref[ep].sc & EP_ATTACHED)) {
385                                 mpc8xx_udc_cbd_attach (ep, epi->tx_packetSize,
386                                                        epi->rcv_packetSize);
387                         }
388                         usbp->usep[ep] = 0x0000;
389                         return;
390                 }
391
392                 if ((epi->endpoint_address & USB_ENDPOINT_DIR_MASK)
393                     == USB_DIR_IN) {
394
395                         direction = 1;
396                         ep_attrib = epi->tx_attributes;
397                         epi->rcv_packetSize = 0;
398                         ep_ref[ep].sc |= USB_DIR_IN;
399                 } else {
400
401                         direction = 0;
402                         ep_attrib = epi->rcv_attributes;
403                         epi->tx_packetSize = 0;
404                         ep_ref[ep].sc &= ~USB_DIR_IN;
405                 }
406
407                 if (mpc8xx_udc_assign_urb (ep, epi->endpoint_address
408                                            & USB_ENDPOINT_DIR_MASK)) {
409                         return;
410                 }
411
412                 switch (ep_attrib) {
413                 case USB_ENDPOINT_XFER_CONTROL:
414                         if (!(ep_ref[ep].sc & EP_ATTACHED)) {
415                                 mpc8xx_udc_cbd_attach (ep,
416                                                        epi->tx_packetSize,
417                                                        epi->rcv_packetSize);
418                         }
419                         usbp->usep[ep] = ep << 12;
420                         epi->rcv_urb = epi->tx_urb = ep_ref[ep].urb;
421
422                         break;
423                 case USB_ENDPOINT_XFER_BULK:
424                 case USB_ENDPOINT_XFER_INT:
425                         if (!(ep_ref[ep].sc & EP_ATTACHED)) {
426                                 if (direction) {
427                                         mpc8xx_udc_cbd_attach (ep,
428                                                                epi->tx_packetSize,
429                                                                0);
430                                 } else {
431                                         mpc8xx_udc_cbd_attach (ep,
432                                                                0,
433                                                                epi->rcv_packetSize);
434                                 }
435                         }
436                         usbp->usep[ep] = (ep << 12) | ((ep_attrib) << 8);
437
438                         break;
439                 case USB_ENDPOINT_XFER_ISOC:
440                 default:
441                         serial_printf ("Error endpoint attrib %d>3\n", ep_attrib);
442                         udc_state = STATE_ERROR;
443                         break;
444                 }
445         }
446
447 }
448
449 /* udc_connect
450  *
451  * Move state, switch on the USB
452  */
453 void udc_connect (void)
454 {
455         /* Enable pull-up resistor on D+
456          * TODO: fit a pull-up resistor to drive SE0 for > 2.5us
457          */
458
459         if (udc_state != STATE_ERROR) {
460                 udc_state = STATE_READY;
461                 usbp->usmod |= USMOD_EN;
462         }
463 }
464
465 /* udc_disconnect
466  *
467  * Disconnect is not used but, is included for completeness
468  */
469 void udc_disconnect (void)
470 {
471         /* Disable pull-up resistor on D-
472          * TODO: fix a pullup resistor to control this
473          */
474
475         if (udc_state != STATE_ERROR) {
476                 udc_state = STATE_NOT_READY;
477         }
478         usbp->usmod &= ~USMOD_EN;
479 }
480
481 /* udc_enable
482  *
483  * Grab an EP0 URB, register interest in a subset of USB events
484  */
485 void udc_enable (struct usb_device_instance *device)
486 {
487         if (udc_state == STATE_ERROR) {
488                 return;
489         }
490
491         udc_device = device;
492
493         if (!ep_ref[0].urb) {
494                 ep_ref[0].urb = usbd_alloc_urb (device, device->bus->endpoint_array);
495         }
496
497         /* Register interest in all events except SOF, enable transceiver */
498         usbp->usber = 0x03FF;
499         usbp->usbmr = 0x02F7;
500
501         return;
502 }
503
504 /* udc_disable
505  *
506  * disable the currently hooked device
507  */
508 void udc_disable (void)
509 {
510         int i = 0;
511
512         if (udc_state == STATE_ERROR) {
513                 DBG ("Won't disable UDC. udc_state==STATE_ERROR !\n");
514                 return;
515         }
516
517         udc_device = 0;
518
519         for (; i < MAX_ENDPOINTS; i++) {
520                 if (ep_ref[i].urb) {
521                         usbd_dealloc_urb (ep_ref[i].urb);
522                         ep_ref[i].urb = 0;
523                 }
524         }
525
526         usbp->usbmr = 0x00;
527         usbp->usmod = ~USMOD_EN;
528         udc_state = STATE_NOT_READY;
529 }
530
531 /* udc_startup_events
532  *
533  * Enable the specified device
534  */
535 void udc_startup_events (struct usb_device_instance *device)
536 {
537         udc_enable (device);
538         if (udc_state == STATE_READY) {
539                 usbd_device_event_irq (device, DEVICE_CREATE, 0);
540         }
541 }
542
543 /* udc_set_nak
544  *
545  * Allow upper layers to signal lower layers should not accept more RX data
546  *
547  */
548 void udc_set_nak (int epid)
549 {
550         if (epid) {
551                 mpc8xx_udc_set_nak (epid);
552         }
553 }
554
555 /* udc_unset_nak
556  *
557  * Suspend sending of NAK tokens for DATA OUT tokens on a given endpoint.
558  * Switch off NAKing on this endpoint to accept more data output from host.
559  *
560  */
561 void udc_unset_nak (int epid)
562 {
563         if (epid > MAX_ENDPOINTS) {
564                 return;
565         }
566
567         if (usbp->usep[epid] & (USEP_THS_NAK | USEP_RHS_NAK)) {
568                 usbp->usep[epid] &= ~(USEP_THS_NAK | USEP_RHS_NAK);
569                 __asm__ ("eieio");
570         }
571 }
572
573 /******************************************************************************
574                               Static Linkage
575 ******************************************************************************/
576
577 /* udc_state_transition_up
578  * udc_state_transition_down
579  *
580  * Helper functions to implement device state changes.  The device states and
581  * the events that transition between them are:
582  *
583  *                              STATE_ATTACHED
584  *                              ||      /\
585  *                              \/      ||
586  *      DEVICE_HUB_CONFIGURED                   DEVICE_HUB_RESET
587  *                              ||      /\
588  *                              \/      ||
589  *                              STATE_POWERED
590  *                              ||      /\
591  *                              \/      ||
592  *      DEVICE_RESET                            DEVICE_POWER_INTERRUPTION
593  *                              ||      /\
594  *                              \/      ||
595  *                              STATE_DEFAULT
596  *                              ||      /\
597  *                              \/      ||
598  *      DEVICE_ADDRESS_ASSIGNED                 DEVICE_RESET
599  *                              ||      /\
600  *                              \/      ||
601  *                              STATE_ADDRESSED
602  *                              ||      /\
603  *                              \/      ||
604  *      DEVICE_CONFIGURED                       DEVICE_DE_CONFIGURED
605  *                              ||      /\
606  *                              \/      ||
607  *                              STATE_CONFIGURED
608  *
609  * udc_state_transition_up transitions up (in the direction from STATE_ATTACHED
610  * to STATE_CONFIGURED) from the specified initial state to the specified final
611  * state, passing through each intermediate state on the way.  If the initial
612  * state is at or above (i.e. nearer to STATE_CONFIGURED) the final state, then
613  * no state transitions will take place.
614  *
615  * udc_state_transition_down transitions down (in the direction from
616  * STATE_CONFIGURED to STATE_ATTACHED) from the specified initial state to the
617  * specified final state, passing through each intermediate state on the way.
618  * If the initial state is at or below (i.e. nearer to STATE_ATTACHED) the final
619  * state, then no state transitions will take place.
620  *
621  */
622
623 static void mpc8xx_udc_state_transition_up (usb_device_state_t initial,
624                                             usb_device_state_t final)
625 {
626         if (initial < final) {
627                 switch (initial) {
628                 case STATE_ATTACHED:
629                         usbd_device_event_irq (udc_device,
630                                                DEVICE_HUB_CONFIGURED, 0);
631                         if (final == STATE_POWERED)
632                                 break;
633                 case STATE_POWERED:
634                         usbd_device_event_irq (udc_device, DEVICE_RESET, 0);
635                         if (final == STATE_DEFAULT)
636                                 break;
637                 case STATE_DEFAULT:
638                         usbd_device_event_irq (udc_device,
639                                                DEVICE_ADDRESS_ASSIGNED, 0);
640                         if (final == STATE_ADDRESSED)
641                                 break;
642                 case STATE_ADDRESSED:
643                         usbd_device_event_irq (udc_device, DEVICE_CONFIGURED,
644                                                0);
645                 case STATE_CONFIGURED:
646                         break;
647                 default:
648                         break;
649                 }
650         }
651 }
652
653 static void mpc8xx_udc_state_transition_down (usb_device_state_t initial,
654                                               usb_device_state_t final)
655 {
656         if (initial > final) {
657                 switch (initial) {
658                 case STATE_CONFIGURED:
659                         usbd_device_event_irq (udc_device,
660                                                DEVICE_DE_CONFIGURED, 0);
661                         if (final == STATE_ADDRESSED)
662                                 break;
663                 case STATE_ADDRESSED:
664                         usbd_device_event_irq (udc_device, DEVICE_RESET, 0);
665                         if (final == STATE_DEFAULT)
666                                 break;
667                 case STATE_DEFAULT:
668                         usbd_device_event_irq (udc_device,
669                                                DEVICE_POWER_INTERRUPTION, 0);
670                         if (final == STATE_POWERED)
671                                 break;
672                 case STATE_POWERED:
673                         usbd_device_event_irq (udc_device, DEVICE_HUB_RESET,
674                                                0);
675                 case STATE_ATTACHED:
676                         break;
677                 default:
678                         break;
679                 }
680         }
681 }
682
683 /* mpc8xx_udc_stall
684  *
685  * Force returning of STALL tokens on the given endpoint. Protocol or function
686  * STALL conditions are permissable here
687  */
688 static void mpc8xx_udc_stall (unsigned int ep)
689 {
690         usbp->usep[ep] |= STALL_BITMASK;
691 }
692
693 /* mpc8xx_udc_set_nak
694  *
695  * Force returning of NAK responses for the given endpoint as a kind of very
696  * simple flow control
697  */
698 static void mpc8xx_udc_set_nak (unsigned int ep)
699 {
700         usbp->usep[ep] |= NAK_BITMASK;
701         __asm__ ("eieio");
702 }
703
704 /* mpc8xx_udc_handle_txerr
705  *
706  * Handle errors relevant to TX. Return a status code to allow calling
707  * indicative of what if anything happened
708  */
709 static short mpc8xx_udc_handle_txerr ()
710 {
711         short ep = 0, ret = 0;
712
713         for (; ep < TX_RING_SIZE; ep++) {
714                 if (usbp->usber & (0x10 << ep)) {
715
716                         /* Timeout or underrun */
717                         if (tx_cbd[ep]->cbd_sc & 0x06) {
718                                 ret = 1;
719                                 mpc8xx_udc_flush_tx_fifo (ep);
720
721                         } else {
722                                 if (usbp->usep[ep] & STALL_BITMASK) {
723                                         if (!ep) {
724                                                 usbp->usep[ep] &= ~STALL_BITMASK;
725                                         }
726                                 }       /* else NAK */
727                         }
728                         usbp->usber |= (0x10 << ep);
729                 }
730         }
731         return ret;
732 }
733
734 /* mpc8xx_udc_advance_rx
735  *
736  * Advance cbd rx
737  */
738 static void mpc8xx_udc_advance_rx (volatile cbd_t ** rx_cbdp, int epid)
739 {
740         if ((*rx_cbdp)->cbd_sc & RX_BD_W) {
741                 *rx_cbdp = (volatile cbd_t *) (endpoints[epid]->rbase + CONFIG_SYS_IMMR);
742
743         } else {
744                 (*rx_cbdp)++;
745         }
746 }
747
748
749 /* mpc8xx_udc_flush_tx_fifo
750  *
751  * Flush a given TX fifo. Assumes one tx cbd per endpoint
752  */
753 static void mpc8xx_udc_flush_tx_fifo (int epid)
754 {
755         volatile cbd_t *tx_cbdp = 0;
756
757         if (epid > MAX_ENDPOINTS) {
758                 return;
759         }
760
761         /* TX stop */
762         immr->im_cpm.cp_cpcr = ((epid << 2) | 0x1D01);
763         __asm__ ("eieio");
764         while (immr->im_cpm.cp_cpcr & 0x01);
765
766         usbp->uscom = 0x40 | 0;
767
768         /* reset ring */
769         tx_cbdp = (cbd_t *) (endpoints[epid]->tbptr + CONFIG_SYS_IMMR);
770         tx_cbdp->cbd_sc = (TX_BD_I | TX_BD_W);
771
772
773         endpoints[epid]->tptr = endpoints[epid]->tbase;
774         endpoints[epid]->tstate = 0x00;
775         endpoints[epid]->tbcnt = 0x00;
776
777         /* TX start */
778         immr->im_cpm.cp_cpcr = ((epid << 2) | 0x2D01);
779         __asm__ ("eieio");
780         while (immr->im_cpm.cp_cpcr & 0x01);
781
782         return;
783 }
784
785 /* mpc8xx_udc_flush_rx_fifo
786  *
787  * For the sake of completeness of the namespace, it seems like
788  * a good-design-decision (tm) to include mpc8xx_udc_flush_rx_fifo();
789  * If RX_BD_E is true => a driver bug either here or in an upper layer
790  * not polling frequently enough. If RX_BD_E is true we have told the host
791  * we have accepted data but, the CPM found it had no-where to put that data
792  * which needless to say would be a bad thing.
793  */
794 static void mpc8xx_udc_flush_rx_fifo ()
795 {
796         int i = 0;
797
798         for (i = 0; i < RX_RING_SIZE; i++) {
799                 if (!(rx_cbd[i]->cbd_sc & RX_BD_E)) {
800                         ERR ("buf %p used rx data len = 0x%x sc=0x%x!\n",
801                              rx_cbd[i], rx_cbd[i]->cbd_datlen,
802                              rx_cbd[i]->cbd_sc);
803
804                 }
805         }
806         ERR ("BUG : Input over-run\n");
807 }
808
809 /* mpc8xx_udc_clear_rxbd
810  *
811  * Release control of RX CBD to CP.
812  */
813 static void mpc8xx_udc_clear_rxbd (volatile cbd_t * rx_cbdp)
814 {
815         rx_cbdp->cbd_datlen = 0x0000;
816         rx_cbdp->cbd_sc = ((rx_cbdp->cbd_sc & RX_BD_W) | (RX_BD_E | RX_BD_I));
817         __asm__ ("eieio");
818 }
819
820 /* mpc8xx_udc_tx_irq
821  *
822  * Parse for tx timeout, control RX or USB reset/busy conditions
823  * Return -1 on timeout, -2 on fatal error, else return zero
824  */
825 static int mpc8xx_udc_tx_irq (int ep)
826 {
827         int i = 0;
828
829         if (usbp->usber & (USB_TX_ERRMASK)) {
830                 if (mpc8xx_udc_handle_txerr ()) {
831                         /* Timeout, controlling function must retry send */
832                         return -1;
833                 }
834         }
835
836         if (usbp->usber & (USB_E_RESET | USB_E_BSY)) {
837                 /* Fatal, abandon TX transaction */
838                 return -2;
839         }
840
841         if (usbp->usber & USB_E_RXB) {
842                 for (i = 0; i < RX_RING_SIZE; i++) {
843                         if (!(rx_cbd[i]->cbd_sc & RX_BD_E)) {
844                                 if ((rx_cbd[i] == ep_ref[0].prx) || ep) {
845                                         return -2;
846                                 }
847                         }
848                 }
849         }
850
851         return 0;
852 }
853
854 /* mpc8xx_udc_ep_tx
855  *
856  * Transmit in a re-entrant fashion outbound USB packets.
857  * Implement retry/timeout mechanism described in USB specification
858  * Toggle DATA0/DATA1 pids as necessary
859  * Introduces non-standard tx_retry. The USB standard has no scope for slave
860  * devices to give up TX, however tx_retry stops us getting stuck in an endless
861  * TX loop.
862  */
863 static int mpc8xx_udc_ep_tx (struct usb_endpoint_instance *epi)
864 {
865         struct urb *urb = epi->tx_urb;
866         volatile cbd_t *tx_cbdp = 0;
867         unsigned int ep = 0, pkt_len = 0, x = 0, tx_retry = 0;
868         int ret = 0;
869
870         if (!epi || (epi->endpoint_address & 0x03) >= MAX_ENDPOINTS || !urb) {
871                 return -1;
872         }
873
874         ep = epi->endpoint_address & 0x03;
875         tx_cbdp = (cbd_t *) (endpoints[ep]->tbptr + CONFIG_SYS_IMMR);
876
877         if (tx_cbdp->cbd_sc & TX_BD_R || usbp->usber & USB_E_TXB) {
878                 mpc8xx_udc_flush_tx_fifo (ep);
879                 usbp->usber |= USB_E_TXB;
880         };
881
882         while (tx_retry++ < 100) {
883                 ret = mpc8xx_udc_tx_irq (ep);
884                 if (ret == -1) {
885                         /* ignore timeout here */
886                 } else if (ret == -2) {
887                         /* Abandon TX */
888                         mpc8xx_udc_flush_tx_fifo (ep);
889                         return -1;
890                 }
891
892                 tx_cbdp = (cbd_t *) (endpoints[ep]->tbptr + CONFIG_SYS_IMMR);
893                 while (tx_cbdp->cbd_sc & TX_BD_R) {
894                 };
895                 tx_cbdp->cbd_sc = (tx_cbdp->cbd_sc & TX_BD_W);
896
897                 pkt_len = urb->actual_length - epi->sent;
898
899                 if (pkt_len > epi->tx_packetSize || pkt_len > EP_MAX_PKT) {
900                         pkt_len = MIN (epi->tx_packetSize, EP_MAX_PKT);
901                 }
902
903                 for (x = 0; x < pkt_len; x++) {
904                         *((unsigned char *) (tx_cbdp->cbd_bufaddr + x)) =
905                                 urb->buffer[epi->sent + x];
906                 }
907                 tx_cbdp->cbd_datlen = pkt_len;
908                 tx_cbdp->cbd_sc |= (CBD_TX_BITMASK | ep_ref[ep].pid);
909                 __asm__ ("eieio");
910
911 #ifdef __SIMULATE_ERROR__
912                 if (++err_poison_test == 2) {
913                         err_poison_test = 0;
914                         tx_cbdp->cbd_sc &= ~TX_BD_TC;
915                 }
916 #endif
917
918                 usbp->uscom = (USCOM_STR | ep);
919
920                 while (!(usbp->usber & USB_E_TXB)) {
921                         ret = mpc8xx_udc_tx_irq (ep);
922                         if (ret == -1) {
923                                 /* TX timeout */
924                                 break;
925                         } else if (ret == -2) {
926                                 if (usbp->usber & USB_E_TXB) {
927                                         usbp->usber |= USB_E_TXB;
928                                 }
929                                 mpc8xx_udc_flush_tx_fifo (ep);
930                                 return -1;
931                         }
932                 };
933
934                 if (usbp->usber & USB_E_TXB) {
935                         usbp->usber |= USB_E_TXB;
936                 }
937
938                 /* ACK must be present <= 18bit times from TX */
939                 if (ret == -1) {
940                         continue;
941                 }
942
943                 /* TX ACK : USB 2.0 8.7.2, Toggle PID, Advance TX */
944                 epi->sent += pkt_len;
945                 epi->last = MIN (urb->actual_length - epi->sent, epi->tx_packetSize);
946                 TOGGLE_TX_PID (ep_ref[ep].pid);
947
948                 if (epi->sent >= epi->tx_urb->actual_length) {
949
950                         epi->tx_urb->actual_length = 0;
951                         epi->sent = 0;
952
953                         if (ep_ref[ep].sc & EP_SEND_ZLP) {
954                                 ep_ref[ep].sc &= ~EP_SEND_ZLP;
955                         } else {
956                                 return 0;
957                         }
958                 }
959         }
960
961         ERR ("TX fail, endpoint 0x%x tx bytes 0x%x/0x%x\n", ep, epi->sent,
962              epi->tx_urb->actual_length);
963
964         return -1;
965 }
966
967 /* mpc8xx_udc_dump_request
968  *
969  * Dump a control request to console
970  */
971 static void mpc8xx_udc_dump_request (struct usb_device_request *request)
972 {
973         DBG ("bmRequestType:%02x bRequest:%02x wValue:%04x "
974              "wIndex:%04x wLength:%04x ?\n",
975              request->bmRequestType,
976              request->bRequest,
977              request->wValue, request->wIndex, request->wLength);
978
979         return;
980 }
981
982 /* mpc8xx_udc_ep0_rx_setup
983  *
984  * Decode received ep0 SETUP packet. return non-zero on error
985  */
986 static int mpc8xx_udc_ep0_rx_setup (volatile cbd_t * rx_cbdp)
987 {
988         unsigned int x = 0;
989         struct urb *purb = ep_ref[0].urb;
990         struct usb_endpoint_instance *epi =
991                 &udc_device->bus->endpoint_array[0];
992
993         for (; x < rx_cbdp->cbd_datlen; x++) {
994                 *(((unsigned char *) &ep_ref[0].urb->device_request) + x) =
995                         *((unsigned char *) (rx_cbdp->cbd_bufaddr + x));
996         }
997
998         mpc8xx_udc_clear_rxbd (rx_cbdp);
999
1000         if (ep0_recv_setup (purb)) {
1001                 mpc8xx_udc_dump_request (&purb->device_request);
1002                 return -1;
1003         }
1004
1005         if ((purb->device_request.bmRequestType & USB_REQ_DIRECTION_MASK)
1006             == USB_REQ_HOST2DEVICE) {
1007
1008                 switch (purb->device_request.bRequest) {
1009                 case USB_REQ_SET_ADDRESS:
1010                         /* Send the Status OUT ZLP */
1011                         ep_ref[0].pid = TX_BD_PID_DATA1;
1012                         purb->actual_length = 0;
1013                         mpc8xx_udc_init_tx (epi, purb);
1014                         mpc8xx_udc_ep_tx (epi);
1015
1016                         /* Move to the addressed state */
1017                         usbp->usaddr = udc_device->address;
1018                         mpc8xx_udc_state_transition_up (udc_device->device_state,
1019                                                         STATE_ADDRESSED);
1020                         return 0;
1021
1022                 case USB_REQ_SET_CONFIGURATION:
1023                         if (!purb->device_request.wValue) {
1024                                 /* Respond at default address */
1025                                 usbp->usaddr = 0x00;
1026                                 mpc8xx_udc_state_transition_down (udc_device->device_state,
1027                                                                   STATE_ADDRESSED);
1028                         } else {
1029                                 /* TODO: Support multiple configurations */
1030                                 mpc8xx_udc_state_transition_up (udc_device->device_state,
1031                                                                 STATE_CONFIGURED);
1032                                 for (x = 1; x < MAX_ENDPOINTS; x++) {
1033                                         if ((udc_device->bus->endpoint_array[x].endpoint_address & USB_ENDPOINT_DIR_MASK)
1034                                             == USB_DIR_IN) {
1035                                                 ep_ref[x].pid = TX_BD_PID_DATA0;
1036                                         } else {
1037                                                 ep_ref[x].pid = RX_BD_PID_DATA0;
1038                                         }
1039                                         /* Set configuration must unstall endpoints */
1040                                         usbp->usep[x] &= ~STALL_BITMASK;
1041                                 }
1042                         }
1043                         break;
1044                 default:
1045                         /* CDC/Vendor specific */
1046                         break;
1047                 }
1048
1049                 /* Send ZLP as ACK in Status OUT phase */
1050                 ep_ref[0].pid = TX_BD_PID_DATA1;
1051                 purb->actual_length = 0;
1052                 mpc8xx_udc_init_tx (epi, purb);
1053                 mpc8xx_udc_ep_tx (epi);
1054
1055         } else {
1056
1057                 if (purb->actual_length) {
1058                         ep_ref[0].pid = TX_BD_PID_DATA1;
1059                         mpc8xx_udc_init_tx (epi, purb);
1060
1061                         if (!(purb->actual_length % EP0_MAX_PACKET_SIZE)) {
1062                                 ep_ref[0].sc |= EP_SEND_ZLP;
1063                         }
1064
1065                         if (purb->device_request.wValue ==
1066                             USB_DESCRIPTOR_TYPE_DEVICE) {
1067                                 if (le16_to_cpu (purb->device_request.wLength)
1068                                     > purb->actual_length) {
1069                                         /* Send EP0_MAX_PACKET_SIZE bytes
1070                                          * unless correct size requested.
1071                                          */
1072                                         if (purb->actual_length > epi->tx_packetSize) {
1073                                                 purb->actual_length = epi->tx_packetSize;
1074                                         }
1075                                 }
1076                         }
1077                         mpc8xx_udc_ep_tx (epi);
1078
1079                 } else {
1080                         /* Corrupt SETUP packet? */
1081                         ERR ("Zero length data or SETUP with DATA-IN phase ?\n");
1082                         return 1;
1083                 }
1084         }
1085         return 0;
1086 }
1087
1088 /* mpc8xx_udc_init_tx
1089  *
1090  * Setup some basic parameters for a TX transaction
1091  */
1092 static void mpc8xx_udc_init_tx (struct usb_endpoint_instance *epi,
1093                                 struct urb *tx_urb)
1094 {
1095         epi->sent = 0;
1096         epi->last = 0;
1097         epi->tx_urb = tx_urb;
1098 }
1099
1100 /* mpc8xx_udc_ep0_rx
1101  *
1102  * Receive ep0/control USB data. Parse and possibly send a response.
1103  */
1104 static void mpc8xx_udc_ep0_rx (volatile cbd_t * rx_cbdp)
1105 {
1106         if (rx_cbdp->cbd_sc & RX_BD_PID_SETUP) {
1107
1108                 /* Unconditionally accept SETUP packets */
1109                 if (mpc8xx_udc_ep0_rx_setup (rx_cbdp)) {
1110                         mpc8xx_udc_stall (0);
1111                 }
1112
1113         } else {
1114
1115                 mpc8xx_udc_clear_rxbd (rx_cbdp);
1116
1117                 if ((rx_cbdp->cbd_datlen - 2)) {
1118                         /* SETUP with a DATA phase
1119                          * outside of SETUP packet.
1120                          * Reply with STALL.
1121                          */
1122                         mpc8xx_udc_stall (0);
1123                 }
1124         }
1125 }
1126
1127 /* mpc8xx_udc_epn_rx
1128  *
1129  * Receive some data from cbd into USB system urb data abstraction
1130  * Upper layers should NAK if there is insufficient RX data space
1131  */
1132 static int mpc8xx_udc_epn_rx (unsigned int epid, volatile cbd_t * rx_cbdp)
1133 {
1134         struct usb_endpoint_instance *epi = 0;
1135         struct urb *urb = 0;
1136         unsigned int x = 0;
1137
1138         if (epid >= MAX_ENDPOINTS || !rx_cbdp->cbd_datlen) {
1139                 return 0;
1140         }
1141
1142         /* USB 2.0 PDF section 8.6.4
1143          * Discard data with invalid PID it is a resend.
1144          */
1145         if (ep_ref[epid].pid != (rx_cbdp->cbd_sc & 0xC0)) {
1146                 return 1;
1147         }
1148         TOGGLE_RX_PID (ep_ref[epid].pid);
1149
1150         epi = &udc_device->bus->endpoint_array[epid];
1151         urb = epi->rcv_urb;
1152
1153         for (; x < (rx_cbdp->cbd_datlen - 2); x++) {
1154                 *((unsigned char *) (urb->buffer + urb->actual_length + x)) =
1155                         *((unsigned char *) (rx_cbdp->cbd_bufaddr + x));
1156         }
1157
1158         if (x) {
1159                 usbd_rcv_complete (epi, x, 0);
1160                 if (ep_ref[epid].urb->status == RECV_ERROR) {
1161                         DBG ("RX error unset NAK\n");
1162                         udc_unset_nak (epid);
1163                 }
1164         }
1165         return x;
1166 }
1167
1168 /* mpc8xx_udc_clock_init
1169  *
1170  * Obtain a clock reference for Full Speed Signaling
1171  */
1172 static void mpc8xx_udc_clock_init (volatile immap_t * immr,
1173                                    volatile cpm8xx_t * cp)
1174 {
1175
1176 #if defined(CONFIG_SYS_USB_EXTC_CLK)
1177
1178         /* This has been tested with a 48MHz crystal on CLK6 */
1179         switch (CONFIG_SYS_USB_EXTC_CLK) {
1180         case 1:
1181                 immr->im_ioport.iop_papar |= 0x0100;
1182                 immr->im_ioport.iop_padir &= ~0x0100;
1183                 cp->cp_sicr |= 0x24;
1184                 break;
1185         case 2:
1186                 immr->im_ioport.iop_papar |= 0x0200;
1187                 immr->im_ioport.iop_padir &= ~0x0200;
1188                 cp->cp_sicr |= 0x2D;
1189                 break;
1190         case 3:
1191                 immr->im_ioport.iop_papar |= 0x0400;
1192                 immr->im_ioport.iop_padir &= ~0x0400;
1193                 cp->cp_sicr |= 0x36;
1194                 break;
1195         case 4:
1196                 immr->im_ioport.iop_papar |= 0x0800;
1197                 immr->im_ioport.iop_padir &= ~0x0800;
1198                 cp->cp_sicr |= 0x3F;
1199                 break;
1200         default:
1201                 udc_state = STATE_ERROR;
1202                 break;
1203         }
1204
1205 #elif defined(CONFIG_SYS_USB_BRGCLK)
1206
1207         /* This has been tested with brgclk == 50MHz */
1208         int divisor = 0;
1209
1210         if (gd->cpu_clk < 48000000L) {
1211                 ERR ("brgclk is too slow for full-speed USB!\n");
1212                 udc_state = STATE_ERROR;
1213                 return;
1214         }
1215
1216         /* Assume the brgclk is 'good enough', we want !(gd->cpu_clk%48MHz)
1217          * but, can /probably/ live with close-ish alternative rates.
1218          */
1219         divisor = (gd->cpu_clk / 48000000L) - 1;
1220         cp->cp_sicr &= ~0x0000003F;
1221
1222         switch (CONFIG_SYS_USB_BRGCLK) {
1223         case 1:
1224                 cp->cp_brgc1 |= (divisor | CPM_BRG_EN);
1225                 cp->cp_sicr &= ~0x2F;
1226                 break;
1227         case 2:
1228                 cp->cp_brgc2 |= (divisor | CPM_BRG_EN);
1229                 cp->cp_sicr |= 0x00000009;
1230                 break;
1231         case 3:
1232                 cp->cp_brgc3 |= (divisor | CPM_BRG_EN);
1233                 cp->cp_sicr |= 0x00000012;
1234                 break;
1235         case 4:
1236                 cp->cp_brgc4 = (divisor | CPM_BRG_EN);
1237                 cp->cp_sicr |= 0x0000001B;
1238                 break;
1239         default:
1240                 udc_state = STATE_ERROR;
1241                 break;
1242         }
1243
1244 #else
1245 #error "CONFIG_SYS_USB_EXTC_CLK or CONFIG_SYS_USB_BRGCLK must be defined"
1246 #endif
1247
1248 }
1249
1250 /* mpc8xx_udc_cbd_attach
1251  *
1252  * attach a cbd to and endpoint
1253  */
1254 static void mpc8xx_udc_cbd_attach (int ep, uchar tx_size, uchar rx_size)
1255 {
1256
1257         if (!tx_cbd[ep] || !rx_cbd[ep] || ep >= MAX_ENDPOINTS) {
1258                 udc_state = STATE_ERROR;
1259                 return;
1260         }
1261
1262         if (tx_size > USB_MAX_PKT || rx_size > USB_MAX_PKT ||
1263             (!tx_size && !rx_size)) {
1264                 udc_state = STATE_ERROR;
1265                 return;
1266         }
1267
1268         /* Attach CBD to appropiate Parameter RAM Endpoint data structure */
1269         if (rx_size) {
1270                 endpoints[ep]->rbase = (u32) rx_cbd[rx_ct];
1271                 endpoints[ep]->rbptr = (u32) rx_cbd[rx_ct];
1272                 rx_ct++;
1273
1274                 if (!ep) {
1275
1276                         endpoints[ep]->rbptr = (u32) rx_cbd[rx_ct];
1277                         rx_cbd[rx_ct]->cbd_sc |= RX_BD_W;
1278                         rx_ct++;
1279
1280                 } else {
1281                         rx_ct += 2;
1282                         endpoints[ep]->rbptr = (u32) rx_cbd[rx_ct];
1283                         rx_cbd[rx_ct]->cbd_sc |= RX_BD_W;
1284                         rx_ct++;
1285                 }
1286
1287                 /* Where we expect to RX data on this endpoint */
1288                 ep_ref[ep].prx = rx_cbd[rx_ct - 1];
1289         } else {
1290
1291                 ep_ref[ep].prx = 0;
1292                 endpoints[ep]->rbase = 0;
1293                 endpoints[ep]->rbptr = 0;
1294         }
1295
1296         if (tx_size) {
1297                 endpoints[ep]->tbase = (u32) tx_cbd[tx_ct];
1298                 endpoints[ep]->tbptr = (u32) tx_cbd[tx_ct];
1299                 tx_ct++;
1300         } else {
1301                 endpoints[ep]->tbase = 0;
1302                 endpoints[ep]->tbptr = 0;
1303         }
1304
1305         endpoints[ep]->tstate = 0;
1306         endpoints[ep]->tbcnt = 0;
1307         endpoints[ep]->mrblr = EP_MAX_PKT;
1308         endpoints[ep]->rfcr = 0x18;
1309         endpoints[ep]->tfcr = 0x18;
1310         ep_ref[ep].sc |= EP_ATTACHED;
1311
1312         DBG ("ep %d rbase 0x%08x rbptr 0x%08x tbase 0x%08x tbptr 0x%08x prx = %p\n",
1313                 ep, endpoints[ep]->rbase, endpoints[ep]->rbptr,
1314                 endpoints[ep]->tbase, endpoints[ep]->tbptr,
1315                 ep_ref[ep].prx);
1316
1317         return;
1318 }
1319
1320 /* mpc8xx_udc_cbd_init
1321  *
1322  * Allocate space for a cbd and allocate TX/RX data space
1323  */
1324 static void mpc8xx_udc_cbd_init (void)
1325 {
1326         int i = 0;
1327
1328         for (; i < TX_RING_SIZE; i++) {
1329                 tx_cbd[i] = (cbd_t *)
1330                         mpc8xx_udc_alloc (sizeof (cbd_t), sizeof (int));
1331         }
1332
1333         for (i = 0; i < RX_RING_SIZE; i++) {
1334                 rx_cbd[i] = (cbd_t *)
1335                         mpc8xx_udc_alloc (sizeof (cbd_t), sizeof (int));
1336         }
1337
1338         for (i = 0; i < TX_RING_SIZE; i++) {
1339                 tx_cbd[i]->cbd_bufaddr =
1340                         mpc8xx_udc_alloc (EP_MAX_PKT, sizeof (int));
1341
1342                 tx_cbd[i]->cbd_sc = (TX_BD_I | TX_BD_W);
1343                 tx_cbd[i]->cbd_datlen = 0x0000;
1344         }
1345
1346
1347         for (i = 0; i < RX_RING_SIZE; i++) {
1348                 rx_cbd[i]->cbd_bufaddr =
1349                         mpc8xx_udc_alloc (EP_MAX_PKT, sizeof (int));
1350                 rx_cbd[i]->cbd_sc = (RX_BD_I | RX_BD_E);
1351                 rx_cbd[i]->cbd_datlen = 0x0000;
1352
1353         }
1354
1355         return;
1356 }
1357
1358 /* mpc8xx_udc_endpoint_init
1359  *
1360  * Attach an endpoint to some dpram
1361  */
1362 static void mpc8xx_udc_endpoint_init (void)
1363 {
1364         int i = 0;
1365
1366         for (; i < MAX_ENDPOINTS; i++) {
1367                 endpoints[i] = (usb_epb_t *)
1368                         mpc8xx_udc_alloc (sizeof (usb_epb_t), 32);
1369         }
1370 }
1371
1372 /* mpc8xx_udc_alloc
1373  *
1374  * Grab the address of some dpram
1375  */
1376 static u32 mpc8xx_udc_alloc (u32 data_size, u32 alignment)
1377 {
1378         u32 retaddr = address_base;
1379
1380         while (retaddr % alignment) {
1381                 retaddr++;
1382         }
1383         address_base += data_size;
1384
1385         return retaddr;
1386 }