1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Freescale QUICC Engine USB Host Controller Driver 4 * 5 * Copyright (c) Freescale Semicondutor, Inc. 2006, 2011. 6 * Shlomi Gridish <gridish@freescale.com> 7 * Jerry Huang <Chang-Ming.Huang@freescale.com> 8 * Copyright (c) Logic Product Development, Inc. 2007 9 * Peter Barada <peterb@logicpd.com> 10 * Copyright (c) MontaVista Software, Inc. 2008. 11 * Anton Vorontsov <avorontsov@ru.mvista.com> 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/types.h> 16 #include <linux/spinlock.h> 17 #include <linux/delay.h> 18 #include <linux/errno.h> 19 #include <linux/list.h> 20 #include <linux/interrupt.h> 21 #include <linux/io.h> 22 #include <linux/usb.h> 23 #include <linux/usb/hcd.h> 24 #include <soc/fsl/qe/qe.h> 25 #include <asm/fsl_gtm.h> 26 #include "fhci.h" 27 28 static void recycle_frame(struct fhci_usb *usb, struct packet *pkt) 29 { 30 pkt->data = NULL; 31 pkt->len = 0; 32 pkt->status = USB_TD_OK; 33 pkt->info = 0; 34 pkt->priv_data = NULL; 35 36 cq_put(&usb->ep0->empty_frame_Q, pkt); 37 } 38 39 /* confirm submitted packet */ 40 void fhci_transaction_confirm(struct fhci_usb *usb, struct packet *pkt) 41 { 42 struct td *td; 43 struct packet *td_pkt; 44 struct ed *ed; 45 u32 trans_len; 46 bool td_done = false; 47 48 td = fhci_remove_td_from_frame(usb->actual_frame); 49 td_pkt = td->pkt; 50 trans_len = pkt->len; 51 td->status = pkt->status; 52 if (td->type == FHCI_TA_IN && td_pkt->info & PKT_DUMMY_PACKET) { 53 if ((td->data + td->actual_len) && trans_len) 54 memcpy(td->data + td->actual_len, pkt->data, 55 trans_len); 56 cq_put(&usb->ep0->dummy_packets_Q, pkt->data); 57 } 58 59 recycle_frame(usb, pkt); 60 61 ed = td->ed; 62 if (ed->mode == FHCI_TF_ISO) { 63 if (ed->td_list.next->next != &ed->td_list) { 64 struct td *td_next = 65 list_entry(ed->td_list.next->next, struct td, 66 node); 67 68 td_next->start_frame = usb->actual_frame->frame_num; 69 } 70 td->actual_len = trans_len; 71 td_done = true; 72 } else if ((td->status & USB_TD_ERROR) && 73 !(td->status & USB_TD_TX_ER_NAK)) { 74 /* 75 * There was an error on the transaction (but not NAK). 76 * If it is fatal error (data underrun, stall, bad pid or 3 77 * errors exceeded), mark this TD as done. 78 */ 79 if ((td->status & USB_TD_RX_DATA_UNDERUN) || 80 (td->status & USB_TD_TX_ER_STALL) || 81 (td->status & USB_TD_RX_ER_PID) || 82 (++td->error_cnt >= 3)) { 83 ed->state = FHCI_ED_HALTED; 84 td_done = true; 85 86 if (td->status & USB_TD_RX_DATA_UNDERUN) { 87 fhci_dbg(usb->fhci, "td err fu\n"); 88 td->toggle = !td->toggle; 89 td->actual_len += trans_len; 90 } else { 91 fhci_dbg(usb->fhci, "td err f!u\n"); 92 } 93 } else { 94 fhci_dbg(usb->fhci, "td err !f\n"); 95 /* it is not a fatal error -retry this transaction */ 96 td->nak_cnt = 0; 97 td->error_cnt++; 98 td->status = USB_TD_OK; 99 } 100 } else if (td->status & USB_TD_TX_ER_NAK) { 101 /* there was a NAK response */ 102 fhci_vdbg(usb->fhci, "td nack\n"); 103 td->nak_cnt++; 104 td->error_cnt = 0; 105 td->status = USB_TD_OK; 106 } else { 107 /* there was no error on transaction */ 108 td->error_cnt = 0; 109 td->nak_cnt = 0; 110 td->toggle = !td->toggle; 111 td->actual_len += trans_len; 112 113 if (td->len == td->actual_len) 114 td_done = true; 115 } 116 117 if (td_done) 118 fhci_move_td_from_ed_to_done_list(usb, ed); 119 } 120 121 /* 122 * Flush all transmitted packets from BDs 123 * This routine is called when disabling the USB port to flush all 124 * transmissions that are already scheduled in the BDs 125 */ 126 void fhci_flush_all_transmissions(struct fhci_usb *usb) 127 { 128 u8 mode; 129 struct td *td; 130 131 mode = in_8(&usb->fhci->regs->usb_usmod); 132 clrbits8(&usb->fhci->regs->usb_usmod, USB_MODE_EN); 133 134 fhci_flush_bds(usb); 135 136 while ((td = fhci_peek_td_from_frame(usb->actual_frame)) != NULL) { 137 struct packet *pkt = td->pkt; 138 139 pkt->status = USB_TD_TX_ER_TIMEOUT; 140 fhci_transaction_confirm(usb, pkt); 141 } 142 143 usb->actual_frame->frame_status = FRAME_END_TRANSMISSION; 144 145 /* reset the event register */ 146 out_be16(&usb->fhci->regs->usb_usber, 0xffff); 147 /* enable the USB controller */ 148 out_8(&usb->fhci->regs->usb_usmod, mode | USB_MODE_EN); 149 } 150 151 /* 152 * This function forms the packet and transmit the packet. This function 153 * will handle all endpoint type:ISO,interrupt,control and bulk 154 */ 155 static int add_packet(struct fhci_usb *usb, struct ed *ed, struct td *td) 156 { 157 u32 fw_transaction_time, len = 0; 158 struct packet *pkt; 159 u8 *data = NULL; 160 161 /* calcalate data address,len and toggle and then add the transaction */ 162 if (td->toggle == USB_TD_TOGGLE_CARRY) 163 td->toggle = ed->toggle_carry; 164 165 switch (ed->mode) { 166 case FHCI_TF_ISO: 167 len = td->len; 168 if (td->type != FHCI_TA_IN) 169 data = td->data; 170 break; 171 case FHCI_TF_CTRL: 172 case FHCI_TF_BULK: 173 len = min(td->len - td->actual_len, ed->max_pkt_size); 174 if (!((td->type == FHCI_TA_IN) && 175 ((len + td->actual_len) == td->len))) 176 data = td->data + td->actual_len; 177 break; 178 case FHCI_TF_INTR: 179 len = min(td->len, ed->max_pkt_size); 180 if (!((td->type == FHCI_TA_IN) && 181 ((td->len + CRC_SIZE) >= ed->max_pkt_size))) 182 data = td->data; 183 break; 184 default: 185 break; 186 } 187 188 if (usb->port_status == FHCI_PORT_FULL) 189 fw_transaction_time = (((len + PROTOCOL_OVERHEAD) * 11) >> 4); 190 else 191 fw_transaction_time = ((len + PROTOCOL_OVERHEAD) * 6); 192 193 /* check if there's enough space in this frame to submit this TD */ 194 if (usb->actual_frame->total_bytes + len + PROTOCOL_OVERHEAD >= 195 usb->max_bytes_per_frame) { 196 fhci_vdbg(usb->fhci, "not enough space in this frame: " 197 "%d %d %d\n", usb->actual_frame->total_bytes, len, 198 usb->max_bytes_per_frame); 199 return -1; 200 } 201 202 /* check if there's enough time in this frame to submit this TD */ 203 if (usb->actual_frame->frame_status != FRAME_IS_PREPARED && 204 (usb->actual_frame->frame_status & FRAME_END_TRANSMISSION || 205 (fw_transaction_time + usb->sw_transaction_time >= 206 1000 - fhci_get_sof_timer_count(usb)))) { 207 fhci_dbg(usb->fhci, "not enough time in this frame\n"); 208 return -1; 209 } 210 211 /* update frame object fields before transmitting */ 212 pkt = cq_get(&usb->ep0->empty_frame_Q); 213 if (!pkt) { 214 fhci_dbg(usb->fhci, "there is no empty frame\n"); 215 return -1; 216 } 217 td->pkt = pkt; 218 219 pkt->info = 0; 220 if (data == NULL) { 221 data = cq_get(&usb->ep0->dummy_packets_Q); 222 BUG_ON(!data); 223 pkt->info = PKT_DUMMY_PACKET; 224 } 225 pkt->data = data; 226 pkt->len = len; 227 pkt->status = USB_TD_OK; 228 /* update TD status field before transmitting */ 229 td->status = USB_TD_INPROGRESS; 230 /* update actual frame time object with the actual transmission */ 231 usb->actual_frame->total_bytes += (len + PROTOCOL_OVERHEAD); 232 fhci_add_td_to_frame(usb->actual_frame, td); 233 234 if (usb->port_status != FHCI_PORT_FULL && 235 usb->port_status != FHCI_PORT_LOW) { 236 pkt->status = USB_TD_TX_ER_TIMEOUT; 237 pkt->len = 0; 238 fhci_transaction_confirm(usb, pkt); 239 } else if (fhci_host_transaction(usb, pkt, td->type, ed->dev_addr, 240 ed->ep_addr, ed->mode, ed->speed, td->toggle)) { 241 /* remove TD from actual frame */ 242 list_del_init(&td->frame_lh); 243 td->status = USB_TD_OK; 244 if (pkt->info & PKT_DUMMY_PACKET) 245 cq_put(&usb->ep0->dummy_packets_Q, pkt->data); 246 recycle_frame(usb, pkt); 247 usb->actual_frame->total_bytes -= (len + PROTOCOL_OVERHEAD); 248 fhci_err(usb->fhci, "host transaction failed\n"); 249 return -1; 250 } 251 252 return len; 253 } 254 255 static void move_head_to_tail(struct list_head *list) 256 { 257 struct list_head *node = list->next; 258 259 if (!list_empty(list)) { 260 list_move_tail(node, list); 261 } 262 } 263 264 /* 265 * This function goes through the endpoint list and schedules the 266 * transactions within this list 267 */ 268 static int scan_ed_list(struct fhci_usb *usb, 269 struct list_head *list, enum fhci_tf_mode list_type) 270 { 271 static const int frame_part[4] = { 272 [FHCI_TF_CTRL] = MAX_BYTES_PER_FRAME, 273 [FHCI_TF_ISO] = (MAX_BYTES_PER_FRAME * 274 MAX_PERIODIC_FRAME_USAGE) / 100, 275 [FHCI_TF_BULK] = MAX_BYTES_PER_FRAME, 276 [FHCI_TF_INTR] = (MAX_BYTES_PER_FRAME * 277 MAX_PERIODIC_FRAME_USAGE) / 100 278 }; 279 struct ed *ed; 280 struct td *td; 281 int ans = 1; 282 u32 save_transaction_time = usb->sw_transaction_time; 283 284 list_for_each_entry(ed, list, node) { 285 td = ed->td_head; 286 287 if (!td || td->status == USB_TD_INPROGRESS) 288 continue; 289 290 if (ed->state != FHCI_ED_OPER) { 291 if (ed->state == FHCI_ED_URB_DEL) { 292 td->status = USB_TD_OK; 293 fhci_move_td_from_ed_to_done_list(usb, ed); 294 ed->state = FHCI_ED_SKIP; 295 } 296 continue; 297 } 298 299 /* 300 * if it isn't interrupt pipe or it is not iso pipe and the 301 * interval time passed 302 */ 303 if ((list_type == FHCI_TF_INTR || list_type == FHCI_TF_ISO) && 304 (((usb->actual_frame->frame_num - 305 td->start_frame) & 0x7ff) < td->interval)) 306 continue; 307 308 if (add_packet(usb, ed, td) < 0) 309 continue; 310 311 /* update time stamps in the TD */ 312 td->start_frame = usb->actual_frame->frame_num; 313 usb->sw_transaction_time += save_transaction_time; 314 315 if (usb->actual_frame->total_bytes >= 316 usb->max_bytes_per_frame) { 317 usb->actual_frame->frame_status = 318 FRAME_DATA_END_TRANSMISSION; 319 fhci_push_dummy_bd(usb->ep0); 320 ans = 0; 321 break; 322 } 323 324 if (usb->actual_frame->total_bytes >= frame_part[list_type]) 325 break; 326 } 327 328 /* be fair to each ED(move list head around) */ 329 move_head_to_tail(list); 330 usb->sw_transaction_time = save_transaction_time; 331 332 return ans; 333 } 334 335 static u32 rotate_frames(struct fhci_usb *usb) 336 { 337 struct fhci_hcd *fhci = usb->fhci; 338 339 if (!list_empty(&usb->actual_frame->tds_list)) { 340 if ((((in_be16(&fhci->pram->frame_num) & 0x07ff) - 341 usb->actual_frame->frame_num) & 0x7ff) > 5) 342 fhci_flush_actual_frame(usb); 343 else 344 return -EINVAL; 345 } 346 347 usb->actual_frame->frame_status = FRAME_IS_PREPARED; 348 usb->actual_frame->frame_num = in_be16(&fhci->pram->frame_num) & 0x7ff; 349 usb->actual_frame->total_bytes = 0; 350 351 return 0; 352 } 353 354 /* 355 * This function schedule the USB transaction and will process the 356 * endpoint in the following order: iso, interrupt, control and bulk. 357 */ 358 void fhci_schedule_transactions(struct fhci_usb *usb) 359 { 360 int left = 1; 361 362 if (usb->actual_frame->frame_status & FRAME_END_TRANSMISSION) 363 if (rotate_frames(usb) != 0) 364 return; 365 366 if (usb->actual_frame->frame_status & FRAME_END_TRANSMISSION) 367 return; 368 369 if (usb->actual_frame->total_bytes == 0) { 370 /* 371 * schedule the next available ISO transfer 372 *or next stage of the ISO transfer 373 */ 374 scan_ed_list(usb, &usb->hc_list->iso_list, FHCI_TF_ISO); 375 376 /* 377 * schedule the next available interrupt transfer or 378 * the next stage of the interrupt transfer 379 */ 380 scan_ed_list(usb, &usb->hc_list->intr_list, FHCI_TF_INTR); 381 382 /* 383 * schedule the next available control transfer 384 * or the next stage of the control transfer 385 */ 386 left = scan_ed_list(usb, &usb->hc_list->ctrl_list, 387 FHCI_TF_CTRL); 388 } 389 390 /* 391 * schedule the next available bulk transfer or the next stage of the 392 * bulk transfer 393 */ 394 if (left > 0) 395 scan_ed_list(usb, &usb->hc_list->bulk_list, FHCI_TF_BULK); 396 } 397 398 /* Handles SOF interrupt */ 399 static void sof_interrupt(struct fhci_hcd *fhci) 400 { 401 struct fhci_usb *usb = fhci->usb_lld; 402 403 if ((usb->port_status == FHCI_PORT_DISABLED) && 404 (usb->vroot_hub->port.wPortStatus & USB_PORT_STAT_CONNECTION) && 405 !(usb->vroot_hub->port.wPortChange & USB_PORT_STAT_C_CONNECTION)) { 406 if (usb->vroot_hub->port.wPortStatus & USB_PORT_STAT_LOW_SPEED) 407 usb->port_status = FHCI_PORT_LOW; 408 else 409 usb->port_status = FHCI_PORT_FULL; 410 /* Disable IDLE */ 411 usb->saved_msk &= ~USB_E_IDLE_MASK; 412 out_be16(&usb->fhci->regs->usb_usbmr, usb->saved_msk); 413 } 414 415 gtm_set_exact_timer16(fhci->timer, usb->max_frame_usage, false); 416 417 fhci_host_transmit_actual_frame(usb); 418 usb->actual_frame->frame_status = FRAME_IS_TRANSMITTED; 419 420 fhci_schedule_transactions(usb); 421 } 422 423 /* Handles device disconnected interrupt on port */ 424 void fhci_device_disconnected_interrupt(struct fhci_hcd *fhci) 425 { 426 struct fhci_usb *usb = fhci->usb_lld; 427 428 fhci_dbg(fhci, "-> %s\n", __func__); 429 430 fhci_usb_disable_interrupt(usb); 431 clrbits8(&usb->fhci->regs->usb_usmod, USB_MODE_LSS); 432 usb->port_status = FHCI_PORT_DISABLED; 433 434 fhci_stop_sof_timer(fhci); 435 436 /* Enable IDLE since we want to know if something comes along */ 437 usb->saved_msk |= USB_E_IDLE_MASK; 438 out_be16(&usb->fhci->regs->usb_usbmr, usb->saved_msk); 439 440 usb->vroot_hub->port.wPortStatus &= ~USB_PORT_STAT_CONNECTION; 441 usb->vroot_hub->port.wPortChange |= USB_PORT_STAT_C_CONNECTION; 442 usb->max_bytes_per_frame = 0; 443 fhci_usb_enable_interrupt(usb); 444 445 fhci_dbg(fhci, "<- %s\n", __func__); 446 } 447 448 /* detect a new device connected on the USB port */ 449 void fhci_device_connected_interrupt(struct fhci_hcd *fhci) 450 { 451 452 struct fhci_usb *usb = fhci->usb_lld; 453 int state; 454 int ret; 455 456 fhci_dbg(fhci, "-> %s\n", __func__); 457 458 fhci_usb_disable_interrupt(usb); 459 state = fhci_ioports_check_bus_state(fhci); 460 461 /* low-speed device was connected to the USB port */ 462 if (state == 1) { 463 ret = qe_usb_clock_set(fhci->lowspeed_clk, USB_CLOCK >> 3); 464 if (ret) { 465 fhci_warn(fhci, "Low-Speed device is not supported, " 466 "try use BRGx\n"); 467 goto out; 468 } 469 470 usb->port_status = FHCI_PORT_LOW; 471 setbits8(&usb->fhci->regs->usb_usmod, USB_MODE_LSS); 472 usb->vroot_hub->port.wPortStatus |= 473 (USB_PORT_STAT_LOW_SPEED | 474 USB_PORT_STAT_CONNECTION); 475 usb->vroot_hub->port.wPortChange |= 476 USB_PORT_STAT_C_CONNECTION; 477 usb->max_bytes_per_frame = 478 (MAX_BYTES_PER_FRAME >> 3) - 7; 479 fhci_port_enable(usb); 480 } else if (state == 2) { 481 ret = qe_usb_clock_set(fhci->fullspeed_clk, USB_CLOCK); 482 if (ret) { 483 fhci_warn(fhci, "Full-Speed device is not supported, " 484 "try use CLKx\n"); 485 goto out; 486 } 487 488 usb->port_status = FHCI_PORT_FULL; 489 clrbits8(&usb->fhci->regs->usb_usmod, USB_MODE_LSS); 490 usb->vroot_hub->port.wPortStatus &= 491 ~USB_PORT_STAT_LOW_SPEED; 492 usb->vroot_hub->port.wPortStatus |= 493 USB_PORT_STAT_CONNECTION; 494 usb->vroot_hub->port.wPortChange |= 495 USB_PORT_STAT_C_CONNECTION; 496 usb->max_bytes_per_frame = (MAX_BYTES_PER_FRAME - 15); 497 fhci_port_enable(usb); 498 } 499 out: 500 fhci_usb_enable_interrupt(usb); 501 fhci_dbg(fhci, "<- %s\n", __func__); 502 } 503 504 irqreturn_t fhci_frame_limit_timer_irq(int irq, void *_hcd) 505 { 506 struct usb_hcd *hcd = _hcd; 507 struct fhci_hcd *fhci = hcd_to_fhci(hcd); 508 struct fhci_usb *usb = fhci->usb_lld; 509 510 spin_lock(&fhci->lock); 511 512 gtm_set_exact_timer16(fhci->timer, 1000, false); 513 514 if (usb->actual_frame->frame_status == FRAME_IS_TRANSMITTED) { 515 usb->actual_frame->frame_status = FRAME_TIMER_END_TRANSMISSION; 516 fhci_push_dummy_bd(usb->ep0); 517 } 518 519 fhci_schedule_transactions(usb); 520 521 spin_unlock(&fhci->lock); 522 523 return IRQ_HANDLED; 524 } 525 526 /* Cancel transmission on the USB endpoint */ 527 static void abort_transmission(struct fhci_usb *usb) 528 { 529 fhci_dbg(usb->fhci, "-> %s\n", __func__); 530 /* issue stop Tx command */ 531 qe_issue_cmd(QE_USB_STOP_TX, QE_CR_SUBBLOCK_USB, EP_ZERO, 0); 532 /* flush Tx FIFOs */ 533 out_8(&usb->fhci->regs->usb_uscom, USB_CMD_FLUSH_FIFO | EP_ZERO); 534 udelay(1000); 535 /* reset Tx BDs */ 536 fhci_flush_bds(usb); 537 /* issue restart Tx command */ 538 qe_issue_cmd(QE_USB_RESTART_TX, QE_CR_SUBBLOCK_USB, EP_ZERO, 0); 539 fhci_dbg(usb->fhci, "<- %s\n", __func__); 540 } 541 542 irqreturn_t fhci_irq(struct usb_hcd *hcd) 543 { 544 struct fhci_hcd *fhci = hcd_to_fhci(hcd); 545 struct fhci_usb *usb; 546 u16 usb_er = 0; 547 unsigned long flags; 548 549 spin_lock_irqsave(&fhci->lock, flags); 550 551 usb = fhci->usb_lld; 552 553 usb_er |= in_be16(&usb->fhci->regs->usb_usber) & 554 in_be16(&usb->fhci->regs->usb_usbmr); 555 556 /* clear event bits for next time */ 557 out_be16(&usb->fhci->regs->usb_usber, usb_er); 558 559 fhci_dbg_isr(fhci, usb_er); 560 561 if (usb_er & USB_E_RESET_MASK) { 562 if ((usb->port_status == FHCI_PORT_FULL) || 563 (usb->port_status == FHCI_PORT_LOW)) { 564 fhci_device_disconnected_interrupt(fhci); 565 usb_er &= ~USB_E_IDLE_MASK; 566 } else if (usb->port_status == FHCI_PORT_WAITING) { 567 usb->port_status = FHCI_PORT_DISCONNECTING; 568 569 /* Turn on IDLE since we want to disconnect */ 570 usb->saved_msk |= USB_E_IDLE_MASK; 571 out_be16(&usb->fhci->regs->usb_usber, 572 usb->saved_msk); 573 } else if (usb->port_status == FHCI_PORT_DISABLED) { 574 if (fhci_ioports_check_bus_state(fhci) == 1) 575 fhci_device_connected_interrupt(fhci); 576 } 577 usb_er &= ~USB_E_RESET_MASK; 578 } 579 580 if (usb_er & USB_E_MSF_MASK) { 581 abort_transmission(fhci->usb_lld); 582 usb_er &= ~USB_E_MSF_MASK; 583 } 584 585 if (usb_er & (USB_E_SOF_MASK | USB_E_SFT_MASK)) { 586 sof_interrupt(fhci); 587 usb_er &= ~(USB_E_SOF_MASK | USB_E_SFT_MASK); 588 } 589 590 if (usb_er & USB_E_TXB_MASK) { 591 fhci_tx_conf_interrupt(fhci->usb_lld); 592 usb_er &= ~USB_E_TXB_MASK; 593 } 594 595 if (usb_er & USB_E_TXE1_MASK) { 596 fhci_tx_conf_interrupt(fhci->usb_lld); 597 usb_er &= ~USB_E_TXE1_MASK; 598 } 599 600 if (usb_er & USB_E_IDLE_MASK) { 601 if (usb->port_status == FHCI_PORT_DISABLED) { 602 usb_er &= ~USB_E_RESET_MASK; 603 fhci_device_connected_interrupt(fhci); 604 } else if (usb->port_status == 605 FHCI_PORT_DISCONNECTING) { 606 /* XXX usb->port_status = FHCI_PORT_WAITING; */ 607 /* Disable IDLE */ 608 usb->saved_msk &= ~USB_E_IDLE_MASK; 609 out_be16(&usb->fhci->regs->usb_usbmr, 610 usb->saved_msk); 611 } else { 612 fhci_dbg_isr(fhci, -1); 613 } 614 615 usb_er &= ~USB_E_IDLE_MASK; 616 } 617 618 spin_unlock_irqrestore(&fhci->lock, flags); 619 620 return IRQ_HANDLED; 621 } 622 623 624 /* 625 * Process normal completions(error or success) and clean the schedule. 626 * 627 * This is the main path for handing urbs back to drivers. The only other patth 628 * is process_del_list(),which unlinks URBs by scanning EDs,instead of scanning 629 * the (re-reversed) done list as this does. 630 */ 631 static void process_done_list(unsigned long data) 632 { 633 struct urb *urb; 634 struct ed *ed; 635 struct td *td; 636 struct urb_priv *urb_priv; 637 struct fhci_hcd *fhci = (struct fhci_hcd *)data; 638 639 disable_irq(fhci->timer->irq); 640 disable_irq(fhci_to_hcd(fhci)->irq); 641 spin_lock(&fhci->lock); 642 643 td = fhci_remove_td_from_done_list(fhci->hc_list); 644 while (td != NULL) { 645 urb = td->urb; 646 urb_priv = urb->hcpriv; 647 ed = td->ed; 648 649 /* update URB's length and status from TD */ 650 fhci_done_td(urb, td); 651 urb_priv->tds_cnt++; 652 653 /* 654 * if all this urb's TDs are done, call complete() 655 * Interrupt transfers are the onley special case: 656 * they are reissued,until "deleted" by usb_unlink_urb 657 * (real work done in a SOF intr, by process_del_list) 658 */ 659 if (urb_priv->tds_cnt == urb_priv->num_of_tds) { 660 fhci_urb_complete_free(fhci, urb); 661 } else if (urb_priv->state == URB_DEL && 662 ed->state == FHCI_ED_SKIP) { 663 fhci_del_ed_list(fhci, ed); 664 ed->state = FHCI_ED_OPER; 665 } else if (ed->state == FHCI_ED_HALTED) { 666 urb_priv->state = URB_DEL; 667 ed->state = FHCI_ED_URB_DEL; 668 fhci_del_ed_list(fhci, ed); 669 ed->state = FHCI_ED_OPER; 670 } 671 672 td = fhci_remove_td_from_done_list(fhci->hc_list); 673 } 674 675 spin_unlock(&fhci->lock); 676 enable_irq(fhci->timer->irq); 677 enable_irq(fhci_to_hcd(fhci)->irq); 678 } 679 680 DECLARE_TASKLET(fhci_tasklet, process_done_list, 0); 681 682 /* transfer complted callback */ 683 u32 fhci_transfer_confirm_callback(struct fhci_hcd *fhci) 684 { 685 if (!fhci->process_done_task->state) 686 tasklet_schedule(fhci->process_done_task); 687 return 0; 688 } 689 690 /* 691 * adds urb to the endpoint descriptor list 692 * arguments: 693 * fhci data structure for the Low level host controller 694 * ep USB Host endpoint data structure 695 * urb USB request block data structure 696 */ 697 void fhci_queue_urb(struct fhci_hcd *fhci, struct urb *urb) 698 { 699 struct ed *ed = urb->ep->hcpriv; 700 struct urb_priv *urb_priv = urb->hcpriv; 701 u32 data_len = urb->transfer_buffer_length; 702 int urb_state = 0; 703 int toggle = 0; 704 struct td *td; 705 u8 *data; 706 u16 cnt = 0; 707 708 if (ed == NULL) { 709 ed = fhci_get_empty_ed(fhci); 710 ed->dev_addr = usb_pipedevice(urb->pipe); 711 ed->ep_addr = usb_pipeendpoint(urb->pipe); 712 switch (usb_pipetype(urb->pipe)) { 713 case PIPE_CONTROL: 714 ed->mode = FHCI_TF_CTRL; 715 break; 716 case PIPE_BULK: 717 ed->mode = FHCI_TF_BULK; 718 break; 719 case PIPE_INTERRUPT: 720 ed->mode = FHCI_TF_INTR; 721 break; 722 case PIPE_ISOCHRONOUS: 723 ed->mode = FHCI_TF_ISO; 724 break; 725 default: 726 break; 727 } 728 ed->speed = (urb->dev->speed == USB_SPEED_LOW) ? 729 FHCI_LOW_SPEED : FHCI_FULL_SPEED; 730 ed->max_pkt_size = usb_endpoint_maxp(&urb->ep->desc); 731 urb->ep->hcpriv = ed; 732 fhci_dbg(fhci, "new ep speed=%d max_pkt_size=%d\n", 733 ed->speed, ed->max_pkt_size); 734 } 735 736 /* for ISO transfer calculate start frame index */ 737 if (ed->mode == FHCI_TF_ISO) { 738 /* Ignore the possibility of underruns */ 739 urb->start_frame = ed->td_head ? ed->next_iso : 740 get_frame_num(fhci); 741 ed->next_iso = (urb->start_frame + urb->interval * 742 urb->number_of_packets) & 0x07ff; 743 } 744 745 /* 746 * OHCI handles the DATA toggle itself,we just use the USB 747 * toggle bits 748 */ 749 if (usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe), 750 usb_pipeout(urb->pipe))) 751 toggle = USB_TD_TOGGLE_CARRY; 752 else { 753 toggle = USB_TD_TOGGLE_DATA0; 754 usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe), 755 usb_pipeout(urb->pipe), 1); 756 } 757 758 urb_priv->tds_cnt = 0; 759 urb_priv->ed = ed; 760 if (data_len > 0) 761 data = urb->transfer_buffer; 762 else 763 data = NULL; 764 765 switch (ed->mode) { 766 case FHCI_TF_BULK: 767 if (urb->transfer_flags & URB_ZERO_PACKET && 768 urb->transfer_buffer_length > 0 && 769 ((urb->transfer_buffer_length % 770 usb_endpoint_maxp(&urb->ep->desc)) == 0)) 771 urb_state = US_BULK0; 772 while (data_len > 4096) { 773 td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt, 774 usb_pipeout(urb->pipe) ? FHCI_TA_OUT : 775 FHCI_TA_IN, 776 cnt ? USB_TD_TOGGLE_CARRY : 777 toggle, 778 data, 4096, 0, 0, true); 779 data += 4096; 780 data_len -= 4096; 781 cnt++; 782 } 783 784 td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt, 785 usb_pipeout(urb->pipe) ? FHCI_TA_OUT : FHCI_TA_IN, 786 cnt ? USB_TD_TOGGLE_CARRY : toggle, 787 data, data_len, 0, 0, true); 788 cnt++; 789 790 if (urb->transfer_flags & URB_ZERO_PACKET && 791 cnt < urb_priv->num_of_tds) { 792 td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt, 793 usb_pipeout(urb->pipe) ? FHCI_TA_OUT : 794 FHCI_TA_IN, 795 USB_TD_TOGGLE_CARRY, NULL, 0, 0, 0, true); 796 cnt++; 797 } 798 break; 799 case FHCI_TF_INTR: 800 urb->start_frame = get_frame_num(fhci) + 1; 801 td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++, 802 usb_pipeout(urb->pipe) ? FHCI_TA_OUT : FHCI_TA_IN, 803 USB_TD_TOGGLE_DATA0, data, data_len, 804 urb->interval, urb->start_frame, true); 805 break; 806 case FHCI_TF_CTRL: 807 ed->dev_addr = usb_pipedevice(urb->pipe); 808 ed->max_pkt_size = usb_endpoint_maxp(&urb->ep->desc); 809 810 /* setup stage */ 811 td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++, FHCI_TA_SETUP, 812 USB_TD_TOGGLE_DATA0, urb->setup_packet, 8, 0, 0, true); 813 814 /* data stage */ 815 if (data_len > 0) { 816 td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++, 817 usb_pipeout(urb->pipe) ? FHCI_TA_OUT : 818 FHCI_TA_IN, 819 USB_TD_TOGGLE_DATA1, data, data_len, 0, 0, 820 true); 821 } 822 823 /* status stage */ 824 if (data_len > 0) 825 td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++, 826 (usb_pipeout(urb->pipe) ? FHCI_TA_IN : 827 FHCI_TA_OUT), 828 USB_TD_TOGGLE_DATA1, data, 0, 0, 0, true); 829 else 830 td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt++, 831 FHCI_TA_IN, 832 USB_TD_TOGGLE_DATA1, data, 0, 0, 0, true); 833 834 urb_state = US_CTRL_SETUP; 835 break; 836 case FHCI_TF_ISO: 837 for (cnt = 0; cnt < urb->number_of_packets; cnt++) { 838 u16 frame = urb->start_frame; 839 840 /* 841 * FIXME scheduling should handle frame counter 842 * roll-around ... exotic case (and OHCI has 843 * a 2^16 iso range, vs other HCs max of 2^10) 844 */ 845 frame += cnt * urb->interval; 846 frame &= 0x07ff; 847 td = fhci_td_fill(fhci, urb, urb_priv, ed, cnt, 848 usb_pipeout(urb->pipe) ? FHCI_TA_OUT : 849 FHCI_TA_IN, 850 USB_TD_TOGGLE_DATA0, 851 data + urb->iso_frame_desc[cnt].offset, 852 urb->iso_frame_desc[cnt].length, 853 urb->interval, frame, true); 854 } 855 break; 856 default: 857 break; 858 } 859 860 /* 861 * set the state of URB 862 * control pipe:3 states -- setup,data,status 863 * interrupt and bulk pipe:1 state -- data 864 */ 865 urb->pipe &= ~0x1f; 866 urb->pipe |= urb_state & 0x1f; 867 868 urb_priv->state = URB_INPROGRESS; 869 870 if (!ed->td_head) { 871 ed->state = FHCI_ED_OPER; 872 switch (ed->mode) { 873 case FHCI_TF_CTRL: 874 list_add(&ed->node, &fhci->hc_list->ctrl_list); 875 break; 876 case FHCI_TF_BULK: 877 list_add(&ed->node, &fhci->hc_list->bulk_list); 878 break; 879 case FHCI_TF_INTR: 880 list_add(&ed->node, &fhci->hc_list->intr_list); 881 break; 882 case FHCI_TF_ISO: 883 list_add(&ed->node, &fhci->hc_list->iso_list); 884 break; 885 default: 886 break; 887 } 888 } 889 890 fhci_add_tds_to_ed(ed, urb_priv->tds, urb_priv->num_of_tds); 891 fhci->active_urbs++; 892 } 893