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