← Back to branch summary

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3

« back to all changes in this revision

Viewing changes to roms/u-boot/drivers/usb/gadget/mpc8xx_udc.c

  • Committer: Phil Dennis-Jordan
  • Date: 2017-07-21 08:03:43 UTC
  • mfrom: (1.1.1)
  • Revision ID: phil@philjordan.eu-20170721080343-2yr2vdj7713czahv
New upstream release 2.9.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
roms/u-boot/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
}