xref: /openbmc/u-boot/drivers/usb/gadget/pxa27x_udc.c (revision 04735e9c5578dd4f3584be5454b9779e8e5c2af9)
1 /*
2  * PXA27x USB device driver for u-boot.
3  *
4  * Copyright (C) 2007 Rodolfo Giometti <giometti@linux.it>
5  * Copyright (C) 2007 Eurotech S.p.A.  <info@eurotech.it>
6  * Copyright (C) 2008 Vivek Kutal      <vivek.kutal@azingo.com>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (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 Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
21  * MA 02111-1307 USA
22  *
23  */
24 
25 
26 #include <common.h>
27 #include <config.h>
28 #include <asm/byteorder.h>
29 #include <usbdevice.h>
30 #include <asm/arch/hardware.h>
31 #include <asm/io.h>
32 #include <usb/pxa27x_udc.h>
33 
34 #include "ep0.h"
35 
36 /* number of endpoints on this UDC */
37 #define UDC_MAX_ENDPOINTS	24
38 
39 static struct urb *ep0_urb;
40 static struct usb_device_instance *udc_device;
41 static int ep0state = EP0_IDLE;
42 
43 #ifdef USBDDBG
44 static void udc_dump_buffer(char *name, u8 *buf, int len)
45 {
46 	usbdbg("%s - buf %p, len %d", name, buf, len);
47 	print_buffer(0, buf, 1, len, 0);
48 }
49 #else
50 #define udc_dump_buffer(name, buf, len)		/* void */
51 #endif
52 
53 static inline void udc_ack_int_UDCCR(int mask)
54 {
55 	writel(readl(USIR1) | mask, USIR1);
56 }
57 
58 /*
59  * If the endpoint has an active tx_urb, then the next packet of data from the
60  * URB is written to the tx FIFO.
61  * The total amount of data in the urb is given by urb->actual_length.
62  * The maximum amount of data that can be sent in any one packet is given by
63  * endpoint->tx_packetSize.
64  * The number of data bytes from this URB that have already been transmitted
65  * is given by endpoint->sent.
66  * endpoint->last is updated by this routine with the number of data bytes
67  * transmitted in this packet.
68  */
69 static int udc_write_urb(struct usb_endpoint_instance *endpoint)
70 {
71 	struct urb *urb = endpoint->tx_urb;
72 	int ep_num = endpoint->endpoint_address & USB_ENDPOINT_NUMBER_MASK;
73 	u32 *data32 = (u32 *) urb->buffer;
74 	u8  *data8 = (u8 *) urb->buffer;
75 	unsigned int i, n, w, b, is_short;
76 	int timeout = 2000;	/* 2ms */
77 
78 	if (!urb || !urb->actual_length)
79 		return -1;
80 
81 	n = MIN(urb->actual_length - endpoint->sent, endpoint->tx_packetSize);
82 	if (n <= 0)
83 		return -1;
84 
85 	usbdbg("write urb on ep %d", ep_num);
86 #if defined(USBDDBG) && defined(USBDPARANOIA)
87 	usbdbg("urb: buf %p, buf_len %d, actual_len %d",
88 		urb->buffer, urb->buffer_length, urb->actual_length);
89 	usbdbg("endpoint: sent %d, tx_packetSize %d, last %d",
90 		endpoint->sent, endpoint->tx_packetSize, endpoint->last);
91 #endif
92 
93 	is_short = n != endpoint->tx_packetSize;
94 	w = n / 4;
95 	b = n % 4;
96 	usbdbg("n %d%s w %d b %d", n, is_short ? "-s" : "", w, b);
97 	udc_dump_buffer("urb write", data8 + endpoint->sent, n);
98 
99 	/* Prepare for data send */
100 	if (ep_num)
101 		writel(UDCCSR_PC ,UDCCSN(ep_num));
102 
103 	for (i = 0; i < w; i++)
104 		  writel(data32[endpoint->sent / 4 + i], UDCDN(ep_num));
105 
106 	for (i = 0; i < b; i++)
107 		  writeb(data8[endpoint->sent + w * 4 + i], UDCDN(ep_num));
108 
109 	/* Set "Packet Complete" if less data then tx_packetSize */
110 	if (is_short)
111 		writel(ep_num ? UDCCSR_SP : UDCCSR0_IPR, UDCCSN(ep_num));
112 
113 	/* Wait for data sent */
114 	if (ep_num) {
115 		while (!(readl(UDCCSN(ep_num)) & UDCCSR_PC)) {
116 			if (timeout-- == 0)
117 				return -1;
118 			else
119 				udelay(1);
120 		}
121 	}
122 
123 	endpoint->last = n;
124 
125 	if (ep_num) {
126 		usbd_tx_complete(endpoint);
127 	} else {
128 		endpoint->sent += n;
129 		endpoint->last -= n;
130 	}
131 
132 	if (endpoint->sent >= urb->actual_length) {
133 		urb->actual_length = 0;
134 		endpoint->sent = 0;
135 		endpoint->last = 0;
136 	}
137 
138 	if ((endpoint->sent >= urb->actual_length) && (!ep_num)) {
139 		usbdbg("ep0 IN stage done");
140 		if (is_short)
141 			ep0state = EP0_IDLE;
142 		else
143 			ep0state = EP0_XFER_COMPLETE;
144 	}
145 
146 	return 0;
147 }
148 
149 static int udc_read_urb(struct usb_endpoint_instance *endpoint)
150 {
151 	struct urb *urb = endpoint->rcv_urb;
152 	int ep_num = endpoint->endpoint_address & USB_ENDPOINT_NUMBER_MASK;
153 	u32 *data32 = (u32 *) urb->buffer;
154 	unsigned int i, n;
155 
156 	usbdbg("read urb on ep %d", ep_num);
157 #if defined(USBDDBG) && defined(USBDPARANOIA)
158 	usbdbg("urb: buf %p, buf_len %d, actual_len %d",
159 		urb->buffer, urb->buffer_length, urb->actual_length);
160 	usbdbg("endpoint: rcv_packetSize %d",
161 		endpoint->rcv_packetSize);
162 #endif
163 
164 	if (readl(UDCCSN(ep_num)) & UDCCSR_BNE)
165 		n = readl(UDCBCN(ep_num)) & 0x3ff;
166 	else /* zlp */
167 		n = 0;
168 
169 	usbdbg("n %d%s", n, n != endpoint->rcv_packetSize ? "-s" : "");
170 	for (i = 0; i < n; i += 4)
171 		data32[urb->actual_length / 4 + i / 4] = readl(UDCDN(ep_num));
172 
173 	udc_dump_buffer("urb read", (u8 *) data32, urb->actual_length + n);
174 	usbd_rcv_complete(endpoint, n, 0);
175 
176 	return 0;
177 }
178 
179 static int udc_read_urb_ep0(void)
180 {
181 	u32 *data32 = (u32 *) ep0_urb->buffer;
182 	u8 *data8 = (u8 *) ep0_urb->buffer;
183 	unsigned int i, n, w, b;
184 
185 	usbdbg("read urb on ep 0");
186 #if defined(USBDDBG) && defined(USBDPARANOIA)
187 	usbdbg("urb: buf %p, buf_len %d, actual_len %d",
188 		ep0_urb->buffer, ep0_urb->buffer_length, ep0_urb->actual_length);
189 #endif
190 
191 	n = readl(UDCBCR0);
192 	w = n / 4;
193 	b = n % 4;
194 
195 	for (i = 0; i < w; i++) {
196 		data32[ep0_urb->actual_length / 4 + i] = readl(UDCDN(0));
197 		/* ep0_urb->actual_length += 4; */
198 	}
199 
200 	for (i = 0; i < b; i++) {
201 		data8[ep0_urb->actual_length + w * 4 + i] = readb(UDCDN(0));
202 		/* ep0_urb->actual_length++; */
203 	}
204 
205 	ep0_urb->actual_length += n;
206 
207 	udc_dump_buffer("urb read", (u8 *) data32, ep0_urb->actual_length);
208 
209 	writel(UDCCSR0_OPC | UDCCSR0_IPR, UDCCSR0);
210 	if (ep0_urb->actual_length == ep0_urb->device_request.wLength)
211 		return 1;
212 
213 	return 0;
214 }
215 
216 static void udc_handle_ep0(struct usb_endpoint_instance *endpoint)
217 {
218 	u32 udccsr0 = readl(UDCCSR0);
219 	u32 *data = (u32 *) &ep0_urb->device_request;
220 	int i;
221 
222 	usbdbg("udccsr0 %x", udccsr0);
223 
224 	/* Clear stall status */
225 	if (udccsr0 & UDCCSR0_SST) {
226 		usberr("clear stall status");
227 		writel(UDCCSR0_SST, UDCCSR0);
228 		ep0state = EP0_IDLE;
229 	}
230 
231 	/* previous request unfinished?  non-error iff back-to-back ... */
232 	if ((udccsr0 & UDCCSR0_SA) != 0 && ep0state != EP0_IDLE)
233 		ep0state = EP0_IDLE;
234 
235 	switch (ep0state) {
236 
237 	case EP0_IDLE:
238 		udccsr0 = readl(UDCCSR0);
239 		/* Start control request? */
240 		if ((udccsr0 & (UDCCSR0_OPC | UDCCSR0_SA | UDCCSR0_RNE))
241 			== (UDCCSR0_OPC | UDCCSR0_SA | UDCCSR0_RNE)) {
242 
243 			/* Read SETUP packet.
244 			 * SETUP packet size is 8 bytes (aka 2 words)
245 			 */
246 			usbdbg("try reading SETUP packet");
247 			for (i = 0; i < 2; i++) {
248 				if ((readl(UDCCSR0) & UDCCSR0_RNE) == 0) {
249 					usberr("setup packet too short:%d", i);
250 					goto stall;
251 				}
252 				data[i] = readl(UDCDR0);
253 			}
254 
255 			writel(readl(UDCCSR0) | UDCCSR0_OPC | UDCCSR0_SA, UDCCSR0);
256 			if ((readl(UDCCSR0) & UDCCSR0_RNE) != 0) {
257 				usberr("setup packet too long");
258 				goto stall;
259 			}
260 
261 			udc_dump_buffer("ep0 setup read", (u8 *) data, 8);
262 
263 			if (ep0_urb->device_request.wLength == 0) {
264 				usbdbg("Zero Data control Packet\n");
265 				if (ep0_recv_setup(ep0_urb)) {
266 					usberr("Invalid Setup Packet\n");
267 					udc_dump_buffer("ep0 setup read",
268 								(u8 *)data, 8);
269 					goto stall;
270 				}
271 				writel(UDCCSR0_IPR, UDCCSR0);
272 				ep0state = EP0_IDLE;
273 			} else {
274 				/* Check direction */
275 				if ((ep0_urb->device_request.bmRequestType &
276 						USB_REQ_DIRECTION_MASK)
277 						== USB_REQ_HOST2DEVICE) {
278 					ep0state = EP0_OUT_DATA;
279 					ep0_urb->buffer =
280 						(u8 *)ep0_urb->buffer_data;
281 					ep0_urb->buffer_length =
282 						sizeof(ep0_urb->buffer_data);
283 					ep0_urb->actual_length = 0;
284 					writel(UDCCSR0_IPR, UDCCSR0);
285 				} else {
286 					/* The ep0_recv_setup function has
287 					 * already placed our response packet
288 					 * data in ep0_urb->buffer and the
289 					 * packet length in
290 					 * ep0_urb->actual_length.
291 					 */
292 					if (ep0_recv_setup(ep0_urb)) {
293 stall:
294 						usberr("Invalid setup packet");
295 						udc_dump_buffer("ep0 setup read"
296 							, (u8 *) data, 8);
297 						ep0state = EP0_IDLE;
298 
299 						writel(UDCCSR0_SA |
300 						UDCCSR0_OPC | UDCCSR0_FST |
301 						UDCCS0_FTF, UDCCSR0);
302 
303 						return;
304 					}
305 
306 					endpoint->tx_urb = ep0_urb;
307 					endpoint->sent = 0;
308 					usbdbg("EP0_IN_DATA");
309 					ep0state = EP0_IN_DATA;
310 					if (udc_write_urb(endpoint) < 0)
311 						goto stall;
312 
313 				}
314 			}
315 			return;
316 		} else if ((udccsr0 & (UDCCSR0_OPC | UDCCSR0_SA))
317 			== (UDCCSR0_OPC|UDCCSR0_SA)) {
318 			usberr("Setup Active but no data. Stalling ....\n");
319 			goto stall;
320 		} else {
321 			usbdbg("random early IRQs");
322 			/* Some random early IRQs:
323 			 * - we acked FST
324 			 * - IPR cleared
325 			 * - OPC got set, without SA (likely status stage)
326 			 */
327 			writel(udccsr0 & (UDCCSR0_SA | UDCCSR0_OPC), UDCCSR0);
328 		}
329 		break;
330 
331 	case EP0_OUT_DATA:
332 
333 		if ((udccsr0 & UDCCSR0_OPC) && !(udccsr0 & UDCCSR0_SA)) {
334 			if (udc_read_urb_ep0()) {
335 read_complete:
336 				ep0state = EP0_IDLE;
337 				if (ep0_recv_setup(ep0_urb)) {
338 					/* Not a setup packet, stall next
339 					 * EP0 transaction
340 					 */
341 					udc_dump_buffer("ep0 setup read",
342 							(u8 *) data, 8);
343 					usberr("can't parse setup packet\n");
344 					goto stall;
345 				}
346 			}
347 		} else if (!(udccsr0 & UDCCSR0_OPC) &&
348 				!(udccsr0 & UDCCSR0_IPR)) {
349 			if (ep0_urb->device_request.wLength ==
350 				ep0_urb->actual_length)
351 				goto read_complete;
352 
353 			usberr("Premature Status\n");
354 			ep0state = EP0_IDLE;
355 		}
356 		break;
357 
358 	case EP0_IN_DATA:
359 		/* GET_DESCRIPTOR etc */
360 		if (udccsr0 & UDCCSR0_OPC) {
361 			writel(UDCCSR0_OPC | UDCCSR0_FTF, UDCCSR0);
362 			usberr("ep0in premature status");
363 			ep0state = EP0_IDLE;
364 		} else {
365 			/* irq was IPR clearing */
366 			if (udc_write_urb(endpoint) < 0) {
367 				usberr("ep0_write_error\n");
368 				goto stall;
369 			}
370 		}
371 		break;
372 
373 	case EP0_XFER_COMPLETE:
374 		writel(UDCCSR0_IPR, UDCCSR0);
375 		ep0state = EP0_IDLE;
376 		break;
377 
378 	default:
379 		usbdbg("Default\n");
380 	}
381 	writel(USIR0_IR0, USIR0);
382 }
383 
384 static void udc_handle_ep(struct usb_endpoint_instance *endpoint)
385 {
386 	int ep_addr = endpoint->endpoint_address;
387 	int ep_num = ep_addr & USB_ENDPOINT_NUMBER_MASK;
388 	int ep_isout = (ep_addr & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT;
389 
390 	u32 flags = readl(UDCCSN(ep_num)) & (UDCCSR_SST | UDCCSR_TRN);
391 	if (flags)
392 		writel(flags, UDCCSN(ep_num));
393 
394 	if (ep_isout)
395 		udc_read_urb(endpoint);
396 	else
397 		udc_write_urb(endpoint);
398 
399 	writel(UDCCSR_PC, UDCCSN(ep_num));
400 }
401 
402 static void udc_state_changed(void)
403 {
404 
405 	writel(readl(UDCCR) | UDCCR_SMAC, UDCCR);
406 
407 	usbdbg("New UDC settings are: conf %d - inter %d - alter %d",
408 	       (readl(UDCCR) & UDCCR_ACN) >> UDCCR_ACN_S,
409 	       (readl(UDCCR) & UDCCR_AIN) >> UDCCR_AIN_S,
410 	       (readl(UDCCR) & UDCCR_AAISN) >> UDCCR_AAISN_S);
411 
412 	usbd_device_event_irq(udc_device, DEVICE_CONFIGURED, 0);
413 	writel(UDCISR1_IRCC, UDCISR1);
414 }
415 
416 void udc_irq(void)
417 {
418 	int handled;
419 	struct usb_endpoint_instance *endpoint;
420 	int ep_num, i;
421 	u32 udcisr0;
422 
423 	do {
424 		handled = 0;
425 		/* Suspend Interrupt Request */
426 		if (readl(USIR1) & UDCCR_SUSIR) {
427 			usbdbg("Suspend\n");
428 			udc_ack_int_UDCCR(UDCCR_SUSIR);
429 			handled = 1;
430 			ep0state = EP0_IDLE;
431 		}
432 
433 		/* Resume Interrupt Request */
434 		if (readl(USIR1) & UDCCR_RESIR) {
435 			udc_ack_int_UDCCR(UDCCR_RESIR);
436 			handled = 1;
437 			usbdbg("USB resume\n");
438 		}
439 
440 		if (readl(USIR1) & (1<<31)) {
441 			handled = 1;
442 			udc_state_changed();
443 		}
444 
445 		/* Reset Interrupt Request */
446 		if (readl(USIR1) & UDCCR_RSTIR) {
447 			udc_ack_int_UDCCR(UDCCR_RSTIR);
448 			handled = 1;
449 			usbdbg("Reset\n");
450 			usbd_device_event_irq(udc_device, DEVICE_RESET, 0);
451 		} else {
452 			if (readl(USIR0))
453 				usbdbg("UISR0: %x \n", readl(USIR0));
454 
455 			if (readl(USIR0) & 0x2)
456 				writel(0x2, USIR0);
457 
458 			/* Control traffic */
459 			if (readl(USIR0)  & USIR0_IR0) {
460 				handled = 1;
461 				writel(USIR0_IR0, USIR0);
462 				udc_handle_ep0(udc_device->bus->endpoint_array);
463 			}
464 
465 			endpoint = udc_device->bus->endpoint_array;
466 			for (i = 0; i < udc_device->bus->max_endpoints; i++) {
467 				ep_num = (endpoint[i].endpoint_address) &
468 						USB_ENDPOINT_NUMBER_MASK;
469 				if (!ep_num)
470 					continue;
471 				udcisr0 = readl(UDCISR0);
472 				if (udcisr0 &
473 					UDCISR_INT(ep_num, UDC_INT_PACKETCMP)) {
474 					writel(UDCISR_INT(ep_num, UDC_INT_PACKETCMP),
475 					       UDCISR0);
476 					udc_handle_ep(&endpoint[i]);
477 				}
478 			}
479 		}
480 
481 	} while (handled);
482 }
483 
484 /* The UDCCR reg contains mask and interrupt status bits,
485  * so using '|=' isn't safe as it may ack an interrupt.
486  */
487 #define UDCCR_OEN		(1 << 31)   /* On-the-Go Enable */
488 #define UDCCR_MASK_BITS     	(UDCCR_OEN | UDCCR_UDE)
489 
490 static inline void udc_set_mask_UDCCR(int mask)
491 {
492     writel((readl(UDCCR) & UDCCR_MASK_BITS) | (mask & UDCCR_MASK_BITS), UDCCR);
493 }
494 
495 static inline void udc_clear_mask_UDCCR(int mask)
496 {
497     writel((readl(UDCCR) & UDCCR_MASK_BITS) & ~(mask & UDCCR_MASK_BITS), UDCCR);
498 }
499 
500 static void pio_irq_enable(int ep_num)
501 {
502 	if (ep_num < 16)
503 		writel(readl(UDCICR0) | 3 << (ep_num * 2), UDCICR0);
504 	else {
505 		ep_num -= 16;
506 		writel(readl(UDCICR1) | 3 << (ep_num * 2), UDCICR1);
507 	}
508 }
509 
510 /*
511  * udc_set_nak
512  *
513  * Allow upper layers to signal lower layers should not accept more RX data
514  */
515 void udc_set_nak(int ep_num)
516 {
517 	/* TODO */
518 }
519 
520 /*
521  * udc_unset_nak
522  *
523  * Suspend sending of NAK tokens for DATA OUT tokens on a given endpoint.
524  * Switch off NAKing on this endpoint to accept more data output from host.
525  */
526 void udc_unset_nak(int ep_num)
527 {
528 	/* TODO */
529 }
530 
531 int udc_endpoint_write(struct usb_endpoint_instance *endpoint)
532 {
533 	return udc_write_urb(endpoint);
534 }
535 
536 /* Associate a physical endpoint with endpoint instance */
537 void udc_setup_ep(struct usb_device_instance *device, unsigned int id,
538 				struct usb_endpoint_instance *endpoint)
539 {
540 	int ep_num, ep_addr, ep_isout, ep_type, ep_size;
541 	int config, interface, alternate;
542 	u32 tmp;
543 
544 	usbdbg("setting up endpoint id %d", id);
545 
546 	if (!endpoint) {
547 		usberr("endpoint void!");
548 		return;
549 	}
550 
551 	ep_num = endpoint->endpoint_address & USB_ENDPOINT_NUMBER_MASK;
552 	if (ep_num >= UDC_MAX_ENDPOINTS) {
553 		usberr("unable to setup ep %d!", ep_num);
554 		return;
555 	}
556 
557 	pio_irq_enable(ep_num);
558 	if (ep_num == 0) {
559 		/* Done for ep0 */
560 		return;
561 	}
562 
563 	config = 1;
564 	interface = 0;
565 	alternate = 0;
566 
567 	usbdbg("config %d - interface %d - alternate %d",
568 		config, interface, alternate);
569 
570 	ep_addr = endpoint->endpoint_address;
571 	ep_num = ep_addr & USB_ENDPOINT_NUMBER_MASK;
572 	ep_isout = (ep_addr & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT;
573 	ep_type = ep_isout ? endpoint->rcv_attributes : endpoint->tx_attributes;
574 	ep_size = ep_isout ? endpoint->rcv_packetSize : endpoint->tx_packetSize;
575 
576 	usbdbg("addr %x, num %d, dir %s, type %s, packet size %d",
577 		ep_addr, ep_num,
578 		ep_isout ? "out" : "in",
579 		ep_type == USB_ENDPOINT_XFER_ISOC ? "isoc" :
580 		ep_type == USB_ENDPOINT_XFER_BULK ? "bulk" :
581 		ep_type == USB_ENDPOINT_XFER_INT ? "int" : "???",
582 		ep_size
583 		);
584 
585 	/* Configure UDCCRx */
586 	tmp = 0;
587 	tmp |= (config << UDCCONR_CN_S) & UDCCONR_CN;
588 	tmp |= (interface << UDCCONR_IN_S) & UDCCONR_IN;
589 	tmp |= (alternate << UDCCONR_AISN_S) & UDCCONR_AISN;
590 	tmp |= (ep_num << UDCCONR_EN_S) & UDCCONR_EN;
591 	tmp |= (ep_type << UDCCONR_ET_S) & UDCCONR_ET;
592 	tmp |= ep_isout ? 0 : UDCCONR_ED;
593 	tmp |= (ep_size << UDCCONR_MPS_S) & UDCCONR_MPS;
594 	tmp |= UDCCONR_EE;
595 
596 	writel(tmp, UDCCN(ep_num));
597 
598 	usbdbg("UDCCR%c = %x", 'A' + ep_num-1, readl(UDCCN(ep_num)));
599 	usbdbg("UDCCSR%c = %x", 'A' + ep_num-1, readl(UDCCSN(ep_num)));
600 }
601 
602 /* Connect the USB device to the bus */
603 void udc_connect(void)
604 {
605 	usbdbg("UDC connect");
606 
607 #ifdef CONFIG_USB_DEV_PULLUP_GPIO
608 	/* Turn on the USB connection by enabling the pullup resistor */
609 	writel(readl(GPDR(CONFIG_USB_DEV_PULLUP_GPIO))
610 		     | GPIO_bit(CONFIG_USB_DEV_PULLUP_GPIO),
611 	       GPDR(CONFIG_USB_DEV_PULLUP_GPIO));
612 	writel(GPIO_bit(CONFIG_USB_DEV_PULLUP_GPIO), GPSR(CONFIG_USB_DEV_PULLUP_GPIO));
613 #else
614 	/* Host port 2 transceiver D+ pull up enable */
615 	writel(readl(UP2OCR) | UP2OCR_DPPUE, UP2OCR);
616 #endif
617 }
618 
619 /* Disconnect the USB device to the bus */
620 void udc_disconnect(void)
621 {
622 	usbdbg("UDC disconnect");
623 
624 #ifdef CONFIG_USB_DEV_PULLUP_GPIO
625 	/* Turn off the USB connection by disabling the pullup resistor */
626 	writel(GPIO_bit(CONFIG_USB_DEV_PULLUP_GPIO), GPCR(CONFIG_USB_DEV_PULLUP_GPIO));
627 #else
628 	/* Host port 2 transceiver D+ pull up disable */
629 	writel(readl(UP2OCR) & ~UP2OCR_DPPUE, UP2OCR);
630 #endif
631 }
632 
633 /* Switch on the UDC */
634 void udc_enable(struct usb_device_instance *device)
635 {
636 
637 	ep0state = EP0_IDLE;
638 
639 	/* enable endpoint 0, A, B's Packet Complete Interrupt. */
640 	writel(0xffffffff, UDCICR0);
641 	writel(0xa8000000, UDCICR1);
642 
643 	/* clear the interrupt status/control registers */
644 	writel(0xffffffff, UDCISR0);
645 	writel(0xffffffff, UDCISR1);
646 
647 	/* set UDC-enable */
648 	udc_set_mask_UDCCR(UDCCR_UDE);
649 
650 	udc_device = device;
651 	if (!ep0_urb)
652 		ep0_urb = usbd_alloc_urb(udc_device,
653 				udc_device->bus->endpoint_array);
654 	else
655 		usbinfo("ep0_urb %p already allocated", ep0_urb);
656 
657 	usbdbg("UDC Enabled\n");
658 }
659 
660 /* Need to check this again */
661 void udc_disable(void)
662 {
663 	usbdbg("disable UDC");
664 
665 	udc_clear_mask_UDCCR(UDCCR_UDE);
666 
667 	/* Disable clock for USB device */
668 	writel(readl(CKEN) & ~CKEN11_USB, CKEN);
669 
670 	/* Free ep0 URB */
671 	if (ep0_urb) {
672 		usbd_dealloc_urb(ep0_urb);
673 		ep0_urb = NULL;
674 	}
675 
676 	/* Reset device pointer */
677 	udc_device = NULL;
678 }
679 
680 /* Allow udc code to do any additional startup */
681 void udc_startup_events(struct usb_device_instance *device)
682 {
683 	/* The DEVICE_INIT event puts the USB device in the state STATE_INIT */
684 	usbd_device_event_irq(device, DEVICE_INIT, 0);
685 
686 	/* The DEVICE_CREATE event puts the USB device in the state
687 	 * STATE_ATTACHED */
688 	usbd_device_event_irq(device, DEVICE_CREATE, 0);
689 
690 	/* Some USB controller driver implementations signal
691 	 * DEVICE_HUB_CONFIGURED and DEVICE_RESET events here.
692 	 * DEVICE_HUB_CONFIGURED causes a transition to the state
693 	 * STATE_POWERED, and DEVICE_RESET causes a transition to
694 	 * the state STATE_DEFAULT.
695 	 */
696 	udc_enable(device);
697 }
698 
699 /* Initialize h/w stuff */
700 int udc_init(void)
701 {
702 	udc_device = NULL;
703 	usbdbg("PXA27x usbd start");
704 
705 	/* Enable clock for USB device */
706 	writel(readl(CKEN) | CKEN11_USB, CKEN);
707 
708 	/* Disable the UDC */
709 	udc_clear_mask_UDCCR(UDCCR_UDE);
710 
711 	/* Disable IRQs: we don't use them */
712 	writel(0, UDCICR0);
713 	writel(0, UDCICR1);
714 
715 	return 0;
716 }
717