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