1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 27 /* 28 * EHCI Host Controller Driver (EHCI) 29 * 30 * The EHCI driver is a software driver which interfaces to the Universal 31 * Serial Bus layer (USBA) and the Host Controller (HC). The interface to 32 * the Host Controller is defined by the EHCI Host Controller Interface. 33 * 34 * This module contains the EHCI driver interrupt code, which handles all 35 * Checking of status of USB transfers, error recovery and callbacks. 36 */ 37 38 #include <sys/usb/hcd/ehci/ehcid.h> 39 #include <sys/usb/hcd/ehci/ehci_xfer.h> 40 #include <sys/usb/hcd/ehci/ehci_util.h> 41 42 /* 43 * EHCI Interrupt Handling functions. 44 */ 45 void ehci_handle_ue(ehci_state_t *ehcip); 46 void ehci_handle_frame_list_rollover( 47 ehci_state_t *ehcip); 48 void ehci_handle_endpoint_reclaimation( 49 ehci_state_t *ehcip); 50 void ehci_traverse_active_qtd_list( 51 ehci_state_t *ehcip); 52 static ehci_qtd_t *ehci_create_done_qtd_list( 53 ehci_state_t *ehcip); 54 static usb_cr_t ehci_parse_error( 55 ehci_state_t *ehcip, 56 ehci_qtd_t *qtd); 57 usb_cr_t ehci_check_for_error( 58 ehci_state_t *ehcip, 59 ehci_pipe_private_t *pp, 60 ehci_trans_wrapper_t *tw, 61 ehci_qtd_t *qtd, 62 uint_t ctrl); 63 static usb_cr_t ehci_check_for_short_xfer( 64 ehci_state_t *ehcip, 65 ehci_pipe_private_t *pp, 66 ehci_trans_wrapper_t *tw, 67 ehci_qtd_t *qtd); 68 void ehci_handle_error( 69 ehci_state_t *ehcip, 70 ehci_qtd_t *qtd, 71 usb_cr_t error); 72 static void ehci_cleanup_data_underrun( 73 ehci_state_t *ehcip, 74 ehci_trans_wrapper_t *tw, 75 ehci_qtd_t *qtd); 76 static void ehci_handle_normal_qtd( 77 ehci_state_t *ehcip, 78 ehci_qtd_t *qtd, 79 ehci_trans_wrapper_t *tw); 80 void ehci_handle_ctrl_qtd( 81 ehci_state_t *ehcip, 82 ehci_pipe_private_t *pp, 83 ehci_trans_wrapper_t *tw, 84 ehci_qtd_t *qtd, 85 void *); 86 void ehci_handle_bulk_qtd( 87 ehci_state_t *ehcip, 88 ehci_pipe_private_t *pp, 89 ehci_trans_wrapper_t *tw, 90 ehci_qtd_t *qtd, 91 void *); 92 void ehci_handle_intr_qtd( 93 ehci_state_t *ehcip, 94 ehci_pipe_private_t *pp, 95 ehci_trans_wrapper_t *tw, 96 ehci_qtd_t *qtd, 97 void *); 98 static void ehci_handle_one_xfer_completion( 99 ehci_state_t *ehcip, 100 ehci_trans_wrapper_t *tw); 101 static void ehci_sendup_qtd_message( 102 ehci_state_t *ehcip, 103 ehci_pipe_private_t *pp, 104 ehci_trans_wrapper_t *tw, 105 ehci_qtd_t *qtd, 106 usb_cr_t error); 107 108 109 /* 110 * Interrupt Handling functions 111 */ 112 113 /* 114 * ehci_handle_ue: 115 * 116 * Handling of Unrecoverable Error interrupt (UE). 117 */ 118 void 119 ehci_handle_ue(ehci_state_t *ehcip) 120 { 121 usb_frame_number_t before_frame_number, after_frame_number; 122 123 ASSERT(mutex_owned(&ehcip->ehci_int_mutex)); 124 125 USB_DPRINTF_L3(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 126 "ehci_handle_ue: Handling of UE interrupt"); 127 128 /* 129 * First check whether current UE error occurred due to USB or 130 * due to some other subsystem. This can be verified by reading 131 * usb frame numbers before & after a delay of few milliseconds. 132 * If usb frame number read after delay is greater than the one 133 * read before delay, then, USB subsystem is fine. In this case, 134 * disable UE error interrupt and return without shutdowning the 135 * USB subsystem. 136 * 137 * Otherwise, if usb frame number read after delay is less than 138 * or equal to one read before the delay, then, current UE error 139 * occurred from USB subsystem. In this case,go ahead with actual 140 * UE error recovery procedure. 141 * 142 * Get the current usb frame number before waiting for few 143 * milliseconds. 144 */ 145 before_frame_number = ehci_get_current_frame_number(ehcip); 146 147 /* Wait for few milliseconds */ 148 drv_usecwait(EHCI_TIMEWAIT); 149 150 /* 151 * Get the current usb frame number after waiting for 152 * milliseconds. 153 */ 154 after_frame_number = ehci_get_current_frame_number(ehcip); 155 156 USB_DPRINTF_L3(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 157 "ehci_handle_ue: Before Frame Number 0x%llx " 158 "After Frame Number 0x%llx", 159 (unsigned long long)before_frame_number, 160 (unsigned long long)after_frame_number); 161 162 if (after_frame_number > before_frame_number) { 163 164 /* Disable UE interrupt */ 165 Set_OpReg(ehci_interrupt, (Get_OpReg(ehci_interrupt) & 166 ~EHCI_INTR_HOST_SYSTEM_ERROR)); 167 168 return; 169 } 170 171 /* 172 * This UE is due to USB hardware error. Reset ehci controller 173 * and reprogram to bring it back to functional state. 174 */ 175 if ((ehci_do_soft_reset(ehcip)) != USB_SUCCESS) { 176 177 USB_DPRINTF_L0(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 178 "Unrecoverable USB Hardware Error"); 179 180 /* Disable UE interrupt */ 181 Set_OpReg(ehci_interrupt, (Get_OpReg(ehci_interrupt) & 182 ~EHCI_INTR_HOST_SYSTEM_ERROR)); 183 184 /* Route all Root hub ports to Classic host controller */ 185 Set_OpReg(ehci_config_flag, EHCI_CONFIG_FLAG_CLASSIC); 186 187 /* Set host controller soft state to error */ 188 ehcip->ehci_hc_soft_state = EHCI_CTLR_ERROR_STATE; 189 } 190 } 191 192 193 /* 194 * ehci_handle_frame_list_rollover: 195 * 196 * Update software based usb frame number part on every frame number 197 * overflow interrupt. 198 * 199 * Refer ehci spec 1.0, section 2.3.2, page 21 for more details. 200 * 201 * NOTE: This function is also called from POLLED MODE. 202 */ 203 void 204 ehci_handle_frame_list_rollover(ehci_state_t *ehcip) 205 { 206 ehcip->ehci_fno += (0x4000 - 207 (((Get_OpReg(ehci_frame_index) & 0x3FFF) ^ 208 ehcip->ehci_fno) & 0x2000)); 209 210 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 211 "ehci_handle_frame_list_rollover:" 212 "Frame Number Higher Part 0x%llx\n", 213 (unsigned long long)(ehcip->ehci_fno)); 214 } 215 216 217 /* 218 * ehci_handle_endpoint_reclamation: 219 * 220 * Reclamation of Host Controller (HC) Endpoint Descriptors (QH). 221 */ 222 void 223 ehci_handle_endpoint_reclaimation(ehci_state_t *ehcip) 224 { 225 usb_frame_number_t current_frame_number; 226 usb_frame_number_t endpoint_frame_number; 227 ehci_qh_t *reclaim_qh; 228 229 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 230 "ehci_handle_endpoint_reclamation:"); 231 232 ASSERT(mutex_owned(&ehcip->ehci_int_mutex)); 233 234 current_frame_number = ehci_get_current_frame_number(ehcip); 235 236 /* 237 * Deallocate all Endpoint Descriptors (QH) which are on the 238 * reclamation list. These QH's are already removed from the 239 * interrupt lattice tree. 240 */ 241 while (ehcip->ehci_reclaim_list) { 242 243 reclaim_qh = ehcip->ehci_reclaim_list; 244 245 endpoint_frame_number = (usb_frame_number_t)(uintptr_t) 246 (EHCI_LOOKUP_ID(Get_QH(reclaim_qh->qh_reclaim_frame))); 247 248 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 249 "ehci_handle_endpoint_reclamation:" 250 "current frame number 0x%llx endpoint frame number 0x%llx", 251 (unsigned long long)current_frame_number, 252 (unsigned long long)endpoint_frame_number); 253 254 /* 255 * Deallocate current endpoint only if endpoint's usb frame 256 * number is less than or equal to current usb frame number. 257 * 258 * If endpoint's usb frame number is greater than the current 259 * usb frame number, ignore rest of the endpoints in the list 260 * since rest of the endpoints are inserted into the reclaim 261 * list later than the current reclaim endpoint. 262 */ 263 if (endpoint_frame_number > current_frame_number) { 264 break; 265 } 266 267 /* Get the next endpoint from the rec. list */ 268 ehcip->ehci_reclaim_list = ehci_qh_iommu_to_cpu( 269 ehcip, Get_QH(reclaim_qh->qh_reclaim_next)); 270 271 /* Free 32bit ID */ 272 EHCI_FREE_ID((uint32_t)Get_QH(reclaim_qh->qh_reclaim_frame)); 273 274 /* Deallocate the endpoint */ 275 ehci_deallocate_qh(ehcip, reclaim_qh); 276 } 277 } 278 279 280 /* 281 * ehci_traverse_active_qtd_list: 282 */ 283 void 284 ehci_traverse_active_qtd_list( 285 ehci_state_t *ehcip) 286 { 287 uint_t state; /* QTD state */ 288 ehci_qtd_t *curr_qtd = NULL; /* QTD pointers */ 289 ehci_qtd_t *next_qtd = NULL; /* QTD pointers */ 290 usb_cr_t error; /* Error from QTD */ 291 ehci_trans_wrapper_t *tw = NULL; /* Transfer wrapper */ 292 ehci_pipe_private_t *pp = NULL; /* Pipe private field */ 293 294 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 295 "ehci_traverse_active_qtd_list:"); 296 297 ASSERT(mutex_owned(&ehcip->ehci_int_mutex)); 298 299 /* Sync QH and QTD pool */ 300 Sync_QH_QTD_Pool(ehcip); 301 302 /* Create done qtd list */ 303 curr_qtd = ehci_create_done_qtd_list(ehcip); 304 305 /* Traverse the list of transfer descriptors */ 306 while (curr_qtd) { 307 /* Get next qtd from the active qtd list */ 308 next_qtd = ehci_qtd_iommu_to_cpu(ehcip, 309 Get_QTD(curr_qtd->qtd_active_qtd_next)); 310 311 /* Check for QTD state */ 312 state = Get_QTD(curr_qtd->qtd_state); 313 314 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 315 "ehci_traverse_active_qtd_list:\n\t" 316 "curr_qtd = 0x%p state = 0x%x", (void *)curr_qtd, state); 317 318 /* Obtain the transfer wrapper for this QTD */ 319 tw = (ehci_trans_wrapper_t *)EHCI_LOOKUP_ID( 320 (uint32_t)Get_QTD(curr_qtd->qtd_trans_wrapper)); 321 322 ASSERT(tw != NULL); 323 324 pp = tw->tw_pipe_private; 325 326 USB_DPRINTF_L3(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 327 "ehci_traverse_active_qtd_list: " 328 "PP = 0x%p TW = 0x%p", (void *)pp, (void *)tw); 329 330 /* 331 * A QTD that is marked as RECLAIM has already been 332 * processed by QTD timeout handler & client driver 333 * has been informed through exception callback. 334 */ 335 if (state != EHCI_QTD_RECLAIM) { 336 /* Look at the error status */ 337 error = ehci_parse_error(ehcip, curr_qtd); 338 339 if (error == USB_CR_OK) { 340 ehci_handle_normal_qtd(ehcip, curr_qtd, tw); 341 } else { 342 /* handle the error condition */ 343 ehci_handle_error(ehcip, curr_qtd, error); 344 } 345 } else { 346 USB_DPRINTF_L3(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 347 "ehci_traverse_active_qtd_list: " 348 "QTD State = %d", state); 349 } 350 351 /* Deallocate this transfer descriptor */ 352 ehci_deallocate_qtd(ehcip, curr_qtd); 353 354 /* 355 * Deallocate the transfer wrapper if there are no more 356 * QTD's for the transfer wrapper. ehci_deallocate_tw() 357 * will not deallocate the tw for a periodic endpoint 358 * since it will always have a QTD attached to it. 359 */ 360 ehci_deallocate_tw(ehcip, pp, tw); 361 362 curr_qtd = next_qtd; 363 } 364 } 365 366 367 /* 368 * ehci_create_done_qtd_list: 369 * 370 * Create done qtd list from active qtd list. 371 */ 372 ehci_qtd_t * 373 ehci_create_done_qtd_list( 374 ehci_state_t *ehcip) 375 { 376 ehci_qtd_t *curr_qtd = NULL, *next_qtd = NULL; 377 ehci_qtd_t *done_qtd_list = NULL, *last_done_qtd = NULL; 378 379 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 380 "ehci_create_done_qtd_list:"); 381 382 ASSERT(mutex_owned(&ehcip->ehci_int_mutex)); 383 384 curr_qtd = ehcip->ehci_active_qtd_list; 385 386 while (curr_qtd) { 387 388 /* Get next qtd from the active qtd list */ 389 next_qtd = ehci_qtd_iommu_to_cpu(ehcip, 390 Get_QTD(curr_qtd->qtd_active_qtd_next)); 391 392 /* Check this QTD has been processed by Host Controller */ 393 if (!(Get_QTD(curr_qtd->qtd_ctrl) & 394 EHCI_QTD_CTRL_ACTIVE_XACT)) { 395 396 /* Remove this QTD from active QTD list */ 397 ehci_remove_qtd_from_active_qtd_list(ehcip, curr_qtd); 398 399 Set_QTD(curr_qtd->qtd_active_qtd_next, NULL); 400 401 if (done_qtd_list) { 402 Set_QTD(last_done_qtd->qtd_active_qtd_next, 403 ehci_qtd_cpu_to_iommu(ehcip, curr_qtd)); 404 405 last_done_qtd = curr_qtd; 406 } else { 407 done_qtd_list = curr_qtd; 408 last_done_qtd = curr_qtd; 409 } 410 } 411 412 curr_qtd = next_qtd; 413 } 414 415 return (done_qtd_list); 416 } 417 418 419 /* 420 * ehci_parse_error: 421 * 422 * Parse the result for any errors. 423 */ 424 static usb_cr_t 425 ehci_parse_error( 426 ehci_state_t *ehcip, 427 ehci_qtd_t *qtd) 428 { 429 uint_t ctrl; 430 ehci_trans_wrapper_t *tw; 431 ehci_pipe_private_t *pp; 432 uint_t flag; 433 usb_cr_t error; 434 435 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 436 "ehci_parse_error:"); 437 438 ASSERT(mutex_owned(&ehcip->ehci_int_mutex)); 439 440 ASSERT(qtd != NULL); 441 442 /* Obtain the transfer wrapper from the QTD */ 443 tw = (ehci_trans_wrapper_t *) 444 EHCI_LOOKUP_ID((uint32_t)Get_QTD(qtd->qtd_trans_wrapper)); 445 446 ASSERT(tw != NULL); 447 448 /* Obtain the pipe private structure */ 449 pp = tw->tw_pipe_private; 450 451 USB_DPRINTF_L3(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 452 "ehci_parse_error: PP 0x%p TW 0x%p", (void *)pp, (void *)tw); 453 454 ctrl = (uint_t)Get_QTD(qtd->qtd_ctrl); 455 456 /* 457 * Check the condition code of completed QTD and report errors 458 * if any. This checking will be done both for the general and 459 * the isochronous QTDs. 460 */ 461 if ((error = ehci_check_for_error(ehcip, pp, tw, qtd, ctrl)) != 462 USB_CR_OK) { 463 flag = EHCI_REMOVE_XFER_ALWAYS; 464 } else { 465 flag = EHCI_REMOVE_XFER_IFLAST; 466 } 467 468 /* Stop the transfer timer */ 469 ehci_stop_xfer_timer(ehcip, tw, flag); 470 471 return (error); 472 } 473 474 475 /* 476 * ehci_check_for_error: 477 * 478 * Check for any errors. 479 * 480 * NOTE: This function is also called from POLLED MODE. 481 */ 482 usb_cr_t 483 ehci_check_for_error( 484 ehci_state_t *ehcip, 485 ehci_pipe_private_t *pp, 486 ehci_trans_wrapper_t *tw, 487 ehci_qtd_t *qtd, 488 uint_t ctrl) 489 { 490 usb_cr_t error = USB_CR_OK; 491 uint_t status, speed, mask; 492 493 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 494 "ehci_check_for_error: qtd = 0x%p ctrl = 0x%x", 495 (void *)qtd, ctrl); 496 497 /* 498 * Find the usb device speed and get the corresponding 499 * error status mask. 500 */ 501 speed = Get_QH(pp->pp_qh->qh_ctrl) & EHCI_QH_CTRL_ED_SPEED; 502 mask = (speed == EHCI_QH_CTRL_ED_HIGH_SPEED)? 503 EHCI_QTD_CTRL_HS_XACT_STATUS : EHCI_QTD_CTRL_NON_HS_XACT_STATUS; 504 505 /* Exclude halted transaction error condition */ 506 status = ctrl & EHCI_QTD_CTRL_XACT_STATUS & ~EHCI_QTD_CTRL_HALTED_XACT; 507 508 switch (status & mask) { 509 case EHCI_QTD_CTRL_NO_ERROR: 510 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 511 "ehci_check_for_error: No Error"); 512 error = USB_CR_OK; 513 break; 514 case EHCI_QTD_CTRL_ACTIVE_XACT: 515 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 516 "ehci_check_for_error: Not accessed"); 517 error = USB_CR_NOT_ACCESSED; 518 break; 519 case EHCI_QTD_CTRL_HALTED_XACT: 520 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 521 "ehci_check_for_error: Halted"); 522 error = USB_CR_STALL; 523 break; 524 case EHCI_QTD_CTRL_BABBLE_DETECTED: 525 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 526 "ehci_check_for_error: Babble Detected"); 527 error = USB_CR_DATA_OVERRUN; 528 break; 529 case EHCI_QTD_CTRL_XACT_ERROR: 530 /* 531 * An xacterr bit of one is not necessarily an error, 532 * the transaction might have completed successfully 533 * after some retries. 534 * 535 * Try to detect the case when the queue is halted, 536 * because the error counter was decremented from one 537 * down to zero after a transaction error. 538 */ 539 if (ctrl & EHCI_QTD_CTRL_HALTED_XACT && (ctrl & 540 EHCI_QTD_CTRL_ERR_COUNT_MASK) == 0) { 541 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 542 "ehci_check_for_error: Transaction Error"); 543 error = USB_CR_DEV_NOT_RESP; 544 } else { 545 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 546 "ehci_check_for_error: No Error"); 547 error = USB_CR_OK; 548 } 549 break; 550 case EHCI_QTD_CTRL_DATA_BUFFER_ERROR: 551 /* 552 * Data buffer error is not necessarily an error, 553 * the transaction might have completed successfully 554 * after some retries. It can be ignored if the 555 * queue is not halted. 556 */ 557 if (!(ctrl & EHCI_QTD_CTRL_HALTED_XACT)) { 558 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 559 "ehci_check_for_error: Data buffer overrun or " 560 "underrun ignored"); 561 error = USB_CR_OK; 562 break; 563 } 564 565 if (tw->tw_direction == EHCI_QTD_CTRL_IN_PID) { 566 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 567 "ehci_check_for_error: Buffer Overrun"); 568 error = USB_CR_BUFFER_OVERRUN; 569 } else { 570 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 571 "ehci_check_for_error: Buffer Underrun"); 572 error = USB_CR_BUFFER_UNDERRUN; 573 } 574 break; 575 case EHCI_QTD_CTRL_MISSED_uFRAME: 576 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 577 "ehci_check_for_error: Missed uFrame"); 578 error = USB_CR_NOT_ACCESSED; 579 break; 580 case EHCI_QTD_CTRL_PRD_SPLIT_XACT_ERR: 581 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 582 "ehci_check_for_error: Periodic split-transaction " 583 "receives an error handshake"); 584 error = USB_CR_UNSPECIFIED_ERR; 585 break; 586 default: 587 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 588 "ehci_check_for_error: Unspecified Error"); 589 error = USB_CR_UNSPECIFIED_ERR; 590 break; 591 } 592 593 /* 594 * Check for halted transaction error condition. 595 * Under short xfer conditions, EHCI HC will not return an error 596 * or halt the QH. This is done manually later in 597 * ehci_check_for_short_xfer. 598 */ 599 if ((ctrl & EHCI_QTD_CTRL_HALTED_XACT) && (error == USB_CR_OK)) { 600 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 601 "ehci_check_for_error: Halted"); 602 error = USB_CR_STALL; 603 } 604 605 if (error == USB_CR_OK) { 606 error = ehci_check_for_short_xfer(ehcip, pp, tw, qtd); 607 } 608 609 if (error) { 610 uint_t qh_ctrl = Get_QH(pp->pp_qh->qh_ctrl); 611 612 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 613 "ehci_check_for_error: Error %d Device address %d " 614 "Endpoint number %d", error, 615 (qh_ctrl & EHCI_QH_CTRL_DEVICE_ADDRESS), 616 ((qh_ctrl & EHCI_QH_CTRL_ED_NUMBER) >> 617 EHCI_QH_CTRL_ED_NUMBER_SHIFT)); 618 } 619 620 return (error); 621 } 622 623 /* 624 * ehci_check_for_short_xfer: 625 * 626 * Check to see if there was a short xfer condition. 627 * 628 * NOTE: This function is also called from POLLED MODE. 629 * But it doesn't do anything. 630 */ 631 static usb_cr_t 632 ehci_check_for_short_xfer( 633 ehci_state_t *ehcip, 634 ehci_pipe_private_t *pp, 635 ehci_trans_wrapper_t *tw, 636 ehci_qtd_t *qtd) 637 { 638 usb_cr_t error = USB_CR_OK; 639 usb_ep_descr_t *eptd; 640 uchar_t attributes; 641 uint32_t residue = 0; 642 usb_req_attrs_t xfer_attrs; 643 size_t length; 644 mblk_t *mp = NULL; 645 usb_opaque_t xfer_reqp; 646 647 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 648 "ehci_check_for_short_xfer:"); 649 650 if (pp->pp_flag == EHCI_POLLED_MODE_FLAG) { 651 652 return (error); 653 } 654 655 /* 656 * Check for short xfer error. If this is a control pipe, only check 657 * if it is in the data phase. 658 */ 659 eptd = &pp->pp_pipe_handle->p_ep; 660 attributes = eptd->bmAttributes & USB_EP_ATTR_MASK; 661 662 switch (attributes) { 663 case USB_EP_ATTR_CONTROL: 664 if (Get_QTD(qtd->qtd_ctrl_phase) != 665 EHCI_CTRL_DATA_PHASE) { 666 667 break; 668 } 669 /* FALLTHROUGH */ 670 case USB_EP_ATTR_BULK: 671 case USB_EP_ATTR_INTR: 672 /* 673 * If "Total bytes of xfer" in control field of 674 * Transfer Descriptor (QTD) is not equal to zero, 675 * then, we sent/received less data from the usb 676 * device than requested. In that case, get the 677 * actual received data size. 678 */ 679 residue = (Get_QTD(qtd->qtd_ctrl) & 680 EHCI_QTD_CTRL_BYTES_TO_XFER) >> 681 EHCI_QTD_CTRL_BYTES_TO_XFER_SHIFT; 682 683 break; 684 case USB_EP_ATTR_ISOCH: 685 686 break; 687 } 688 689 if (residue) { 690 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 691 "ehci_check_for_short_xfer: residue=%d direction=0x%x", 692 residue, tw->tw_direction); 693 694 length = Get_QTD(qtd->qtd_xfer_offs) + 695 Get_QTD(qtd->qtd_xfer_len) - residue; 696 697 if (tw->tw_direction == EHCI_QTD_CTRL_IN_PID) { 698 xfer_attrs = ehci_get_xfer_attrs(ehcip, pp, tw); 699 700 if (xfer_attrs & USB_ATTRS_SHORT_XFER_OK) { 701 ehci_cleanup_data_underrun(ehcip, tw, qtd); 702 } else { 703 /* Halt the pipe to mirror OHCI behavior */ 704 Set_QH(pp->pp_qh->qh_status, 705 ((Get_QH(pp->pp_qh->qh_status) & 706 ~EHCI_QH_STS_ACTIVE) | 707 EHCI_QH_STS_HALTED)); 708 error = USB_CR_DATA_UNDERRUN; 709 } 710 711 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 712 "ehci_check_for_short_xfer: requested data=%lu " 713 "received data=%lu", tw->tw_length, length); 714 715 switch (attributes) { 716 case USB_EP_ATTR_CONTROL: 717 case USB_EP_ATTR_BULK: 718 case USB_EP_ATTR_INTR: 719 /* Save the actual received length */ 720 tw->tw_length = length; 721 722 break; 723 case USB_EP_ATTR_ISOCH: 724 default: 725 726 break; 727 } 728 } else { 729 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 730 "ehci_check_for_short_xfer: requested data=%lu " 731 "sent data=%lu", tw->tw_length, length); 732 733 xfer_reqp = tw->tw_curr_xfer_reqp; 734 735 switch (attributes) { 736 case USB_EP_ATTR_CONTROL: 737 738 break; 739 case USB_EP_ATTR_BULK: 740 mp = (mblk_t *)((usb_bulk_req_t *) 741 (xfer_reqp))->bulk_data; 742 743 /* Increment the read pointer */ 744 mp->b_rptr = mp->b_rptr + length; 745 746 break; 747 case USB_EP_ATTR_INTR: 748 mp = (mblk_t *)((usb_intr_req_t *) 749 (xfer_reqp))->intr_data; 750 751 /* Increment the read pointer */ 752 mp->b_rptr = mp->b_rptr + length; 753 754 break; 755 case USB_EP_ATTR_ISOCH: 756 default: 757 758 break; 759 } 760 } 761 } 762 763 return (error); 764 } 765 766 /* 767 * ehci_handle_error: 768 * 769 * Inform USBA about occurred transaction errors by calling the USBA callback 770 * routine. 771 */ 772 void 773 ehci_handle_error( 774 ehci_state_t *ehcip, 775 ehci_qtd_t *qtd, 776 usb_cr_t error) 777 { 778 ehci_trans_wrapper_t *tw; 779 usba_pipe_handle_data_t *ph; 780 ehci_pipe_private_t *pp; 781 ehci_qtd_t *tw_qtd = qtd; 782 uchar_t attributes; 783 usb_intr_req_t *curr_intr_reqp; 784 785 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 786 "ehci_handle_error: error = 0x%x", error); 787 788 ASSERT(mutex_owned(&ehcip->ehci_int_mutex)); 789 790 ASSERT(qtd != NULL); 791 792 /* Print the values in the qtd */ 793 ehci_print_qtd(ehcip, qtd); 794 795 /* Obtain the transfer wrapper from the QTD */ 796 tw = (ehci_trans_wrapper_t *) 797 EHCI_LOOKUP_ID((uint32_t)Get_QTD(qtd->qtd_trans_wrapper)); 798 799 ASSERT(tw != NULL); 800 801 /* Obtain the pipe private structure */ 802 pp = tw->tw_pipe_private; 803 804 ph = tw->tw_pipe_private->pp_pipe_handle; 805 attributes = ph->p_ep.bmAttributes & USB_EP_ATTR_MASK; 806 807 /* 808 * Mark all QTDs belongs to this TW as RECLAIM 809 * so that we don't process them by mistake. 810 */ 811 while (tw_qtd) { 812 /* Set QTD state to RECLAIM */ 813 Set_QTD(tw_qtd->qtd_state, EHCI_QTD_RECLAIM); 814 815 /* Get the next QTD from the wrapper */ 816 tw_qtd = ehci_qtd_iommu_to_cpu(ehcip, 817 Get_QTD(tw_qtd->qtd_tw_next_qtd)); 818 } 819 820 /* 821 * Special error handling 822 */ 823 if (tw->tw_direction == EHCI_QTD_CTRL_IN_PID) { 824 825 switch (attributes) { 826 case USB_EP_ATTR_CONTROL: 827 if (((ph->p_ep.bmAttributes & 828 USB_EP_ATTR_MASK) == 829 USB_EP_ATTR_CONTROL) && 830 (Get_QTD(qtd->qtd_ctrl_phase) == 831 EHCI_CTRL_SETUP_PHASE)) { 832 833 break; 834 } 835 /* FALLTHROUGH */ 836 case USB_EP_ATTR_BULK: 837 /* 838 * Call ehci_sendup_qtd_message 839 * to send message to upstream. 840 */ 841 ehci_sendup_qtd_message(ehcip, pp, tw, qtd, error); 842 843 return; 844 case USB_EP_ATTR_INTR: 845 curr_intr_reqp = 846 (usb_intr_req_t *)tw->tw_curr_xfer_reqp; 847 848 if (curr_intr_reqp->intr_attributes & 849 USB_ATTRS_ONE_XFER) { 850 851 ehci_handle_one_xfer_completion(ehcip, tw); 852 } 853 854 /* Decrement periodic in request count */ 855 pp->pp_cur_periodic_req_cnt--; 856 break; 857 case USB_EP_ATTR_ISOCH: 858 break; 859 } 860 } 861 862 ehci_hcdi_callback(ph, tw, error); 863 864 /* Check anybody is waiting for transfers completion event */ 865 ehci_check_for_transfers_completion(ehcip, pp); 866 } 867 868 /* 869 * ehci_cleanup_data_underrun: 870 * 871 * Cleans up resources when a short xfer occurs. Will only do cleanup if 872 * this pipe supports alternate_qtds. 873 * 874 * NOTE: This function is also called from POLLED MODE. 875 */ 876 static void 877 ehci_cleanup_data_underrun( 878 ehci_state_t *ehcip, 879 ehci_trans_wrapper_t *tw, 880 ehci_qtd_t *qtd) 881 { 882 ehci_qtd_t *next_qtd, *temp_qtd; 883 884 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 885 "ehci_cleanup_data_underrun: qtd=0x%p, tw=0x%p", 886 (void *)qtd, (void *)tw); 887 888 /* 889 * Check if this transfer doesn't supports short_xfer or 890 * if this QTD is the last qtd in the tw. If so there is 891 * no need for cleanup. 892 */ 893 if ((tw->tw_alt_qtd == NULL) || (qtd == tw->tw_qtd_tail)) { 894 /* There is no need for cleanup */ 895 return; 896 } 897 898 /* Start removing all the unused QTDs from the TW */ 899 next_qtd = (ehci_qtd_t *)ehci_qtd_iommu_to_cpu(ehcip, 900 Get_QTD(qtd->qtd_tw_next_qtd)); 901 902 while (next_qtd) { 903 tw->tw_num_qtds--; 904 905 ehci_remove_qtd_from_active_qtd_list(ehcip, next_qtd); 906 907 temp_qtd = next_qtd; 908 909 next_qtd = ehci_qtd_iommu_to_cpu(ehcip, 910 Get_QTD(next_qtd->qtd_tw_next_qtd)); 911 912 ehci_deallocate_qtd(ehcip, temp_qtd); 913 } 914 915 ASSERT(tw->tw_num_qtds == 1); 916 } 917 918 /* 919 * ehci_handle_normal_qtd: 920 */ 921 static void 922 ehci_handle_normal_qtd( 923 ehci_state_t *ehcip, 924 ehci_qtd_t *qtd, 925 ehci_trans_wrapper_t *tw) 926 { 927 ehci_pipe_private_t *pp; /* Pipe private field */ 928 929 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 930 "ehci_handle_normal_qtd:"); 931 932 ASSERT(mutex_owned(&ehcip->ehci_int_mutex)); 933 ASSERT(tw != NULL); 934 935 /* Obtain the pipe private structure */ 936 pp = tw->tw_pipe_private; 937 938 (*tw->tw_handle_qtd)(ehcip, pp, tw, 939 qtd, tw->tw_handle_callback_value); 940 941 /* Check anybody is waiting for transfers completion event */ 942 ehci_check_for_transfers_completion(ehcip, pp); 943 } 944 945 946 /* 947 * ehci_handle_ctrl_qtd: 948 * 949 * Handle a control Transfer Descriptor (QTD). 950 */ 951 /* ARGSUSED */ 952 void 953 ehci_handle_ctrl_qtd( 954 ehci_state_t *ehcip, 955 ehci_pipe_private_t *pp, 956 ehci_trans_wrapper_t *tw, 957 ehci_qtd_t *qtd, 958 void *tw_handle_callback_value) 959 { 960 usba_pipe_handle_data_t *ph = pp->pp_pipe_handle; 961 962 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 963 "ehci_handle_ctrl_qtd: pp = 0x%p tw = 0x%p qtd = 0x%p state = 0x%x", 964 (void *)pp, (void *)tw, (void *)qtd, Get_QTD(qtd->qtd_ctrl_phase)); 965 966 ASSERT(mutex_owned(&ehcip->ehci_int_mutex)); 967 968 /* 969 * A control transfer consists of three phases: 970 * 971 * Setup 972 * Data (optional) 973 * Status 974 * 975 * There is a QTD per phase. A QTD for a given phase isn't 976 * enqueued until the previous phase is finished. EHCI 977 * spec allows more than one control transfer on a pipe 978 * within a frame. However, we've found that some devices 979 * can't handle this. 980 */ 981 tw->tw_num_qtds--; 982 switch (Get_QTD(qtd->qtd_ctrl_phase)) { 983 case EHCI_CTRL_SETUP_PHASE: 984 USB_DPRINTF_L3(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 985 "Setup complete: pp 0x%p qtd 0x%p", 986 (void *)pp, (void *)qtd); 987 988 break; 989 case EHCI_CTRL_DATA_PHASE: 990 USB_DPRINTF_L3(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 991 "Data complete: pp 0x%p qtd 0x%p", 992 (void *)pp, (void *)qtd); 993 994 break; 995 case EHCI_CTRL_STATUS_PHASE: 996 /* 997 * On some particular hardware, status phase is seen to 998 * finish before data phase gets timeouted. Don't handle 999 * the transfer result here if not all qtds are finished. 1000 * Let the timeout handler handle it. 1001 */ 1002 if (tw->tw_num_qtds != 0) { 1003 USB_DPRINTF_L2(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 1004 "Status complete, but the transfer is not done: " 1005 "tw 0x%p, qtd 0x%p, tw_num_qtd 0x%d", 1006 (void *)tw, (void *)qtd, tw->tw_num_qtds); 1007 1008 ehci_print_qh(ehcip, pp->pp_qh); 1009 ehci_print_qtd(ehcip, qtd); 1010 1011 break; 1012 } 1013 1014 if ((tw->tw_length) && 1015 (tw->tw_direction == EHCI_QTD_CTRL_IN_PID)) { 1016 /* 1017 * Call ehci_sendup_qtd_message 1018 * to send message to upstream. 1019 */ 1020 ehci_sendup_qtd_message(ehcip, 1021 pp, tw, qtd, USB_CR_OK); 1022 } else { 1023 ehci_hcdi_callback(ph, tw, USB_CR_OK); 1024 } 1025 1026 USB_DPRINTF_L3(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 1027 "Status complete: pp 0x%p qtd 0x%p", 1028 (void *)pp, (void *)qtd); 1029 1030 break; 1031 } 1032 } 1033 1034 1035 /* 1036 * ehci_handle_bulk_qtd: 1037 * 1038 * Handle a bulk Transfer Descriptor (QTD). 1039 */ 1040 /* ARGSUSED */ 1041 void 1042 ehci_handle_bulk_qtd( 1043 ehci_state_t *ehcip, 1044 ehci_pipe_private_t *pp, 1045 ehci_trans_wrapper_t *tw, 1046 ehci_qtd_t *qtd, 1047 void *tw_handle_callback_value) 1048 { 1049 usba_pipe_handle_data_t *ph = pp->pp_pipe_handle; 1050 usb_ep_descr_t *eptd = &ph->p_ep; 1051 1052 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 1053 "ehci_handle_bulk_qtd:"); 1054 1055 ASSERT(mutex_owned(&ehcip->ehci_int_mutex)); 1056 1057 /* 1058 * Decrement the QTDs counter and check whether all the bulk 1059 * data has been send or received. If QTDs counter reaches 1060 * zero then inform client driver about completion current 1061 * bulk request. Other wise wait for completion of other bulk 1062 * QTDs or transactions on this pipe. 1063 */ 1064 if (--tw->tw_num_qtds != 0) { 1065 1066 USB_DPRINTF_L3(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 1067 "ehci_handle_bulk_qtd: Number of QTDs %d", tw->tw_num_qtds); 1068 1069 return; 1070 } 1071 1072 /* 1073 * If this is a bulk in pipe, return the data to the client. 1074 * For a bulk out pipe, there is no need to do anything. 1075 */ 1076 if ((eptd->bEndpointAddress & 1077 USB_EP_DIR_MASK) == USB_EP_DIR_OUT) { 1078 1079 USB_DPRINTF_L3(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 1080 "ehci_handle_bulk_qtd: Bulk out pipe"); 1081 1082 /* Do the callback */ 1083 ehci_hcdi_callback(ph, tw, USB_CR_OK); 1084 1085 return; 1086 } 1087 1088 /* Call ehci_sendup_qtd_message to send message to upstream */ 1089 ehci_sendup_qtd_message(ehcip, pp, tw, qtd, USB_CR_OK); 1090 } 1091 1092 1093 /* 1094 * ehci_handle_intr_qtd: 1095 * 1096 * Handle a interrupt Transfer Descriptor (QTD). 1097 */ 1098 /* ARGSUSED */ 1099 void 1100 ehci_handle_intr_qtd( 1101 ehci_state_t *ehcip, 1102 ehci_pipe_private_t *pp, 1103 ehci_trans_wrapper_t *tw, 1104 ehci_qtd_t *qtd, 1105 void *tw_handle_callback_value) 1106 { 1107 usb_intr_req_t *curr_intr_reqp = 1108 (usb_intr_req_t *)tw->tw_curr_xfer_reqp; 1109 usba_pipe_handle_data_t *ph = pp->pp_pipe_handle; 1110 usb_ep_descr_t *eptd = &ph->p_ep; 1111 usb_req_attrs_t attrs; 1112 int error = USB_SUCCESS; 1113 1114 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 1115 "ehci_handle_intr_qtd:"); 1116 1117 ASSERT(mutex_owned(&ehcip->ehci_int_mutex)); 1118 1119 /* Get the interrupt xfer attributes */ 1120 attrs = curr_intr_reqp->intr_attributes; 1121 1122 /* 1123 * For a Interrupt OUT pipe, we just callback and we are done 1124 */ 1125 if ((eptd->bEndpointAddress & USB_EP_DIR_MASK) == USB_EP_DIR_OUT) { 1126 1127 USB_DPRINTF_L3(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 1128 "ehci_handle_intr_qtd: Intr out pipe, intr_reqp=0x%p," 1129 "data=0x%p", (void *)curr_intr_reqp, 1130 (void *)curr_intr_reqp->intr_data); 1131 1132 /* Do the callback */ 1133 ehci_hcdi_callback(ph, tw, USB_CR_OK); 1134 1135 return; 1136 } 1137 1138 /* Decrement number of interrupt request count */ 1139 pp->pp_cur_periodic_req_cnt--; 1140 1141 /* 1142 * Check usb flag whether USB_FLAGS_ONE_XFER flag is set 1143 * and if so, free duplicate request. 1144 */ 1145 if (attrs & USB_ATTRS_ONE_XFER) { 1146 ehci_handle_one_xfer_completion(ehcip, tw); 1147 } 1148 1149 /* Call ehci_sendup_qtd_message to callback into client */ 1150 ehci_sendup_qtd_message(ehcip, pp, tw, qtd, USB_CR_OK); 1151 1152 /* 1153 * If interrupt pipe state is still active, insert next Interrupt 1154 * request into the Host Controller's Interrupt list. Otherwise 1155 * you are done. 1156 */ 1157 if ((pp->pp_state != EHCI_PIPE_STATE_ACTIVE) || 1158 (ehci_state_is_operational(ehcip) != USB_SUCCESS)) { 1159 1160 return; 1161 } 1162 1163 if ((error = ehci_allocate_intr_in_resource(ehcip, pp, tw, 0)) == 1164 USB_SUCCESS) { 1165 curr_intr_reqp = (usb_intr_req_t *)tw->tw_curr_xfer_reqp; 1166 1167 ASSERT(curr_intr_reqp != NULL); 1168 1169 tw->tw_num_qtds = 1; 1170 1171 if (ehci_allocate_tds_for_tw(ehcip, pp, tw, tw->tw_num_qtds) != 1172 USB_SUCCESS) { 1173 ehci_deallocate_intr_in_resource(ehcip, pp, tw); 1174 error = USB_FAILURE; 1175 } 1176 } 1177 1178 if (error != USB_SUCCESS) { 1179 /* 1180 * Set pipe state to stop polling and error to no 1181 * resource. Don't insert any more interrupt polling 1182 * requests. 1183 */ 1184 pp->pp_state = EHCI_PIPE_STATE_STOP_POLLING; 1185 pp->pp_error = USB_CR_NO_RESOURCES; 1186 } else { 1187 ehci_insert_intr_req(ehcip, pp, tw, 0); 1188 1189 /* Increment number of interrupt request count */ 1190 pp->pp_cur_periodic_req_cnt++; 1191 1192 ASSERT(pp->pp_cur_periodic_req_cnt == 1193 pp->pp_max_periodic_req_cnt); 1194 } 1195 } 1196 1197 1198 /* 1199 * ehci_handle_one_xfer_completion: 1200 */ 1201 static void 1202 ehci_handle_one_xfer_completion( 1203 ehci_state_t *ehcip, 1204 ehci_trans_wrapper_t *tw) 1205 { 1206 usba_pipe_handle_data_t *ph = tw->tw_pipe_private->pp_pipe_handle; 1207 ehci_pipe_private_t *pp = tw->tw_pipe_private; 1208 usb_intr_req_t *curr_intr_reqp = 1209 (usb_intr_req_t *)tw->tw_curr_xfer_reqp; 1210 1211 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 1212 "ehci_handle_one_xfer_completion: tw = 0x%p", (void *)tw); 1213 1214 ASSERT(mutex_owned(&ehcip->ehci_int_mutex)); 1215 ASSERT(curr_intr_reqp->intr_attributes & USB_ATTRS_ONE_XFER); 1216 1217 pp->pp_state = EHCI_PIPE_STATE_IDLE; 1218 1219 /* 1220 * For one xfer, we need to copy back data ptr 1221 * and free current request 1222 */ 1223 ((usb_intr_req_t *)(pp->pp_client_periodic_in_reqp))-> 1224 intr_data = ((usb_intr_req_t *) 1225 (tw->tw_curr_xfer_reqp))->intr_data; 1226 1227 ((usb_intr_req_t *)tw->tw_curr_xfer_reqp)->intr_data = NULL; 1228 1229 /* Now free duplicate current request */ 1230 usb_free_intr_req((usb_intr_req_t *)tw-> tw_curr_xfer_reqp); 1231 1232 mutex_enter(&ph->p_mutex); 1233 ph->p_req_count--; 1234 mutex_exit(&ph->p_mutex); 1235 1236 /* Make client's request the current request */ 1237 tw->tw_curr_xfer_reqp = pp->pp_client_periodic_in_reqp; 1238 pp->pp_client_periodic_in_reqp = NULL; 1239 } 1240 1241 1242 /* 1243 * ehci_sendup_qtd_message: 1244 * copy data, if necessary and do callback 1245 */ 1246 /* ARGSUSED */ 1247 static void 1248 ehci_sendup_qtd_message( 1249 ehci_state_t *ehcip, 1250 ehci_pipe_private_t *pp, 1251 ehci_trans_wrapper_t *tw, 1252 ehci_qtd_t *qtd, 1253 usb_cr_t error) 1254 { 1255 usb_ep_descr_t *eptd = &pp->pp_pipe_handle->p_ep; 1256 usba_pipe_handle_data_t *ph = pp->pp_pipe_handle; 1257 usb_opaque_t curr_xfer_reqp = tw->tw_curr_xfer_reqp; 1258 size_t skip_len = 0; 1259 size_t length; 1260 uchar_t *buf; 1261 mblk_t *mp; 1262 1263 ASSERT(mutex_owned(&ehcip->ehci_int_mutex)); 1264 1265 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 1266 "ehci_sendup_qtd_message:"); 1267 1268 ASSERT(tw != NULL); 1269 1270 length = tw->tw_length; 1271 1272 if ((eptd->bmAttributes & USB_EP_ATTR_MASK) == USB_EP_ATTR_CONTROL) { 1273 /* Get the correct length */ 1274 if (((usb_ctrl_req_t *)curr_xfer_reqp)->ctrl_wLength) 1275 length = length - EHCI_MAX_QTD_BUF_SIZE; 1276 else 1277 length = length - SETUP_SIZE; 1278 1279 /* Set the length of the buffer to skip */ 1280 skip_len = EHCI_MAX_QTD_BUF_SIZE; 1281 } 1282 1283 /* Copy the data into the mblk_t */ 1284 buf = (uchar_t *)tw->tw_buf + skip_len; 1285 1286 USB_DPRINTF_L4(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 1287 "ehci_sendup_qtd_message: length %ld error %d", length, error); 1288 1289 /* Get the message block */ 1290 switch (eptd->bmAttributes & USB_EP_ATTR_MASK) { 1291 case USB_EP_ATTR_CONTROL: 1292 mp = ((usb_ctrl_req_t *)curr_xfer_reqp)->ctrl_data; 1293 break; 1294 case USB_EP_ATTR_BULK: 1295 mp = ((usb_bulk_req_t *)curr_xfer_reqp)->bulk_data; 1296 break; 1297 case USB_EP_ATTR_INTR: 1298 mp = ((usb_intr_req_t *)curr_xfer_reqp)->intr_data; 1299 break; 1300 case USB_EP_ATTR_ISOCH: 1301 /* Isoc messages must not go through this path */ 1302 mp = NULL; 1303 break; 1304 } 1305 1306 ASSERT(mp != NULL); 1307 1308 if (length) { 1309 /* 1310 * Update kstat byte counts 1311 * The control endpoints don't have direction bits so in 1312 * order for control stats to be counted correctly an in 1313 * bit must be faked on a control read. 1314 */ 1315 if ((eptd->bmAttributes & USB_EP_ATTR_MASK) == 1316 USB_EP_ATTR_CONTROL) { 1317 ehci_do_byte_stats(ehcip, length, 1318 eptd->bmAttributes, USB_EP_DIR_IN); 1319 } else { 1320 ehci_do_byte_stats(ehcip, length, 1321 eptd->bmAttributes, eptd->bEndpointAddress); 1322 } 1323 1324 /* Sync IO buffer */ 1325 Sync_IO_Buffer(tw->tw_dmahandle, (skip_len + length)); 1326 1327 /* since we specified NEVERSWAP, we can just use bcopy */ 1328 bcopy(buf, mp->b_rptr, length); 1329 1330 /* Increment the write pointer */ 1331 mp->b_wptr = mp->b_wptr + length; 1332 } else { 1333 USB_DPRINTF_L3(PRINT_MASK_INTR, ehcip->ehci_log_hdl, 1334 "ehci_sendup_qtd_message: Zero length packet"); 1335 } 1336 1337 ehci_hcdi_callback(ph, tw, error); 1338 } 1339