Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/dev/twa/tw_osl_cam.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /* 2 * Copyright (c) 2004-07 Applied Micro Circuits Corporation. 3 * Copyright (c) 2004-05 Vinod Kashyap. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 25 * SUCH DAMAGE. 26 * 27 * $FreeBSD: releng/8.1/sys/dev/twa/tw_osl_cam.c 203889 2010-02-14 19:38:27Z mav $ 28 */ 29 30 /* 31 * AMCC'S 3ware driver for 9000 series storage controllers. 32 * 33 * Author: Vinod Kashyap 34 * Modifications by: Adam Radford 35 * Modifications by: Manjunath Ranganathaiah 36 */ 37 38 39 /* 40 * FreeBSD CAM related functions. 41 */ 42 43 44 #include <dev/twa/tw_osl_includes.h> 45 46 #include <cam/cam.h> 47 #include <cam/cam_ccb.h> 48 #include <cam/cam_sim.h> 49 #include <cam/cam_xpt_sim.h> 50 #include <cam/cam_debug.h> 51 #include <cam/cam_periph.h> 52 53 #include <cam/scsi/scsi_all.h> 54 #include <cam/scsi/scsi_message.h> 55 56 static TW_VOID twa_action(struct cam_sim *sim, union ccb *ccb); 57 static TW_VOID twa_poll(struct cam_sim *sim); 58 static TW_VOID twa_timeout(TW_VOID *arg); 59 60 static TW_INT32 tw_osli_execute_scsi(struct tw_osli_req_context *req, 61 union ccb *ccb); 62 63 64 65 /* 66 * Function name: tw_osli_cam_attach 67 * Description: Attaches the driver to CAM. 68 * 69 * Input: sc -- ptr to OSL internal ctlr context 70 * Output: None 71 * Return value: 0 -- success 72 * non-zero-- failure 73 */ 74 TW_INT32 75 tw_osli_cam_attach(struct twa_softc *sc) 76 { 77 struct cam_devq *devq; 78 79 tw_osli_dbg_dprintf(3, sc, "entered"); 80 81 /* 82 * Create the device queue for our SIM. 83 */ 84 if ((devq = cam_simq_alloc(TW_OSLI_MAX_NUM_IOS)) == NULL) { 85 tw_osli_printf(sc, "error = %d", 86 TW_CL_SEVERITY_ERROR_STRING, 87 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 88 0x2100, 89 "Failed to create SIM device queue", 90 ENOMEM); 91 return(ENOMEM); 92 } 93 94 /* 95 * Create a SIM entry. Though we can support TW_OSLI_MAX_NUM_IOS 96 * simultaneous requests, we claim to be able to handle only 97 * (TW_OSLI_MAX_NUM_IOS - 1), so that we always have a request 98 * packet available to service ioctls. 99 */ 100 tw_osli_dbg_dprintf(3, sc, "Calling cam_sim_alloc"); 101 sc->sim = cam_sim_alloc(twa_action, twa_poll, "twa", sc, 102 device_get_unit(sc->bus_dev), sc->sim_lock, 103 TW_OSLI_MAX_NUM_IOS - 1, 1, devq); 104 if (sc->sim == NULL) { 105 cam_simq_free(devq); 106 tw_osli_printf(sc, "error = %d", 107 TW_CL_SEVERITY_ERROR_STRING, 108 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 109 0x2101, 110 "Failed to create a SIM entry", 111 ENOMEM); 112 return(ENOMEM); 113 } 114 115 /* 116 * Register the bus. 117 */ 118 tw_osli_dbg_dprintf(3, sc, "Calling xpt_bus_register"); 119 mtx_lock(sc->sim_lock); 120 if (xpt_bus_register(sc->sim, sc->bus_dev, 0) != CAM_SUCCESS) { 121 cam_sim_free(sc->sim, TRUE); 122 sc->sim = NULL; /* so cam_detach will not try to free it */ 123 tw_osli_printf(sc, "error = %d", 124 TW_CL_SEVERITY_ERROR_STRING, 125 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 126 0x2102, 127 "Failed to register the bus", 128 ENXIO); 129 mtx_unlock(sc->sim_lock); 130 return(ENXIO); 131 } 132 133 tw_osli_dbg_dprintf(3, sc, "Calling xpt_create_path"); 134 if (xpt_create_path(&sc->path, NULL, 135 cam_sim_path(sc->sim), 136 CAM_TARGET_WILDCARD, 137 CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 138 xpt_bus_deregister(cam_sim_path (sc->sim)); 139 /* Passing TRUE to cam_sim_free will free the devq as well. */ 140 cam_sim_free(sc->sim, TRUE); 141 tw_osli_printf(sc, "error = %d", 142 TW_CL_SEVERITY_ERROR_STRING, 143 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 144 0x2103, 145 "Failed to create path", 146 ENXIO); 147 mtx_unlock(sc->sim_lock); 148 return(ENXIO); 149 } 150 mtx_unlock(sc->sim_lock); 151 152 tw_osli_dbg_dprintf(3, sc, "exiting"); 153 return(0); 154 } 155 156 157 158 /* 159 * Function name: tw_osli_cam_detach 160 * Description: Detaches the driver from CAM. 161 * 162 * Input: sc -- ptr to OSL internal ctlr context 163 * Output: None 164 * Return value: None 165 */ 166 TW_VOID 167 tw_osli_cam_detach(struct twa_softc *sc) 168 { 169 tw_osli_dbg_dprintf(3, sc, "entered"); 170 171 #ifdef TW_OSLI_DEFERRED_INTR_USED 172 /* - drain the taskqueue 173 Ctrl is already went down so, no more enqueuetask will 174 happen . Don't hold any locks, that task might need. 175 */ 176 177 taskqueue_drain(taskqueue_fast, &(sc->deferred_intr_callback)); 178 #endif 179 mtx_lock(sc->sim_lock); 180 181 if (sc->path) 182 xpt_free_path(sc->path); 183 if (sc->sim) { 184 xpt_bus_deregister(cam_sim_path(sc->sim)); 185 /* Passing TRUE to cam_sim_free will free the devq as well. */ 186 cam_sim_free(sc->sim, TRUE); 187 } 188 /* It's ok have 1 hold count while destroying the mutex */ 189 mtx_destroy(sc->sim_lock); 190 } 191 192 193 194 /* 195 * Function name: tw_osli_execute_scsi 196 * Description: Build a fw cmd, based on a CAM style ccb, and 197 * send it down. 198 * 199 * Input: req -- ptr to OSL internal request context 200 * ccb -- ptr to CAM style ccb 201 * Output: None 202 * Return value: 0 -- success 203 * non-zero-- failure 204 */ 205 TW_INT32 206 tw_osli_execute_scsi(struct tw_osli_req_context *req, union ccb *ccb) 207 { 208 struct twa_softc *sc = req->ctlr; 209 struct tw_cl_req_packet *req_pkt; 210 struct tw_cl_scsi_req_packet *scsi_req; 211 struct ccb_hdr *ccb_h = &(ccb->ccb_h); 212 struct ccb_scsiio *csio = &(ccb->csio); 213 TW_INT32 error; 214 215 tw_osli_dbg_dprintf(10, sc, "SCSI I/O request 0x%x", 216 csio->cdb_io.cdb_bytes[0]); 217 218 if (ccb_h->target_id >= TW_CL_MAX_NUM_UNITS) { 219 tw_osli_dbg_dprintf(3, sc, "Invalid target. PTL = %x %x %x", 220 ccb_h->path_id, ccb_h->target_id, ccb_h->target_lun); 221 ccb_h->status |= CAM_TID_INVALID; 222 xpt_done(ccb); 223 return(1); 224 } 225 if (ccb_h->target_lun >= TW_CL_MAX_NUM_LUNS) { 226 tw_osli_dbg_dprintf(3, sc, "Invalid lun. PTL = %x %x %x", 227 ccb_h->path_id, ccb_h->target_id, ccb_h->target_lun); 228 ccb_h->status |= CAM_LUN_INVALID; 229 xpt_done(ccb); 230 return(1); 231 } 232 233 if(ccb_h->flags & CAM_CDB_PHYS) { 234 tw_osli_printf(sc, "", 235 TW_CL_SEVERITY_ERROR_STRING, 236 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 237 0x2105, 238 "Physical CDB address!"); 239 ccb_h->status = CAM_REQ_CMP_ERR; 240 xpt_done(ccb); 241 return(1); 242 } 243 244 /* 245 * We are going to work on this request. Mark it as enqueued (though 246 * we don't actually queue it...) 247 */ 248 ccb_h->status |= CAM_SIM_QUEUED; 249 250 if((ccb_h->flags & CAM_DIR_MASK) != CAM_DIR_NONE) { 251 if(ccb_h->flags & CAM_DIR_IN) 252 req->flags |= TW_OSLI_REQ_FLAGS_DATA_IN; 253 else 254 req->flags |= TW_OSLI_REQ_FLAGS_DATA_OUT; 255 } 256 257 /* Build the CL understood request packet for SCSI cmds. */ 258 req_pkt = &req->req_pkt; 259 req_pkt->status = 0; 260 req_pkt->tw_osl_callback = tw_osl_complete_io; 261 scsi_req = &(req_pkt->gen_req_pkt.scsi_req); 262 scsi_req->unit = ccb_h->target_id; 263 scsi_req->lun = ccb_h->target_lun; 264 scsi_req->sense_len = 0; 265 scsi_req->sense_data = (TW_UINT8 *)(&csio->sense_data); 266 scsi_req->scsi_status = 0; 267 if(ccb_h->flags & CAM_CDB_POINTER) 268 scsi_req->cdb = csio->cdb_io.cdb_ptr; 269 else 270 scsi_req->cdb = csio->cdb_io.cdb_bytes; 271 scsi_req->cdb_len = csio->cdb_len; 272 273 if (!(ccb_h->flags & CAM_DATA_PHYS)) { 274 /* Virtual data addresses. Need to convert them... */ 275 tw_osli_dbg_dprintf(3, sc, 276 "XPT_SCSI_IO: Single virtual address!"); 277 if (!(ccb_h->flags & CAM_SCATTER_VALID)) { 278 if (csio->dxfer_len > TW_CL_MAX_IO_SIZE) { 279 tw_osli_printf(sc, "size = %d", 280 TW_CL_SEVERITY_ERROR_STRING, 281 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 282 0x2106, 283 "I/O size too big", 284 csio->dxfer_len); 285 ccb_h->status = CAM_REQ_TOO_BIG; 286 xpt_done(ccb); 287 return(1); 288 } 289 290 if ((req->length = csio->dxfer_len)) { 291 req->data = csio->data_ptr; 292 scsi_req->sgl_entries = 1; 293 } 294 } else { 295 tw_osli_printf(sc, "", 296 TW_CL_SEVERITY_ERROR_STRING, 297 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 298 0x2107, 299 "XPT_SCSI_IO: Got SGList"); 300 ccb_h->status = CAM_REQ_CMP_ERR; 301 xpt_done(ccb); 302 return(1); 303 } 304 } else { 305 /* Data addresses are physical. */ 306 tw_osli_printf(sc, "", 307 TW_CL_SEVERITY_ERROR_STRING, 308 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 309 0x2108, 310 "XPT_SCSI_IO: Physical data addresses"); 311 ccb_h->status = CAM_REQ_CMP_ERR; 312 ccb_h->status |= CAM_RELEASE_SIMQ; 313 ccb_h->status &= ~CAM_SIM_QUEUED; 314 xpt_done(ccb); 315 return(1); 316 } 317 318 ccb_h->timeout_ch = timeout(twa_timeout, req, 319 (ccb_h->timeout * hz) / 1000); 320 /* 321 * twa_map_load_data_callback will fill in the SGL, 322 * and submit the I/O. 323 */ 324 error = tw_osli_map_request(req); 325 return(error); 326 } 327 328 329 330 /* 331 * Function name: twa_action 332 * Description: Driver entry point for CAM's use. 333 * 334 * Input: sim -- sim corresponding to the ctlr 335 * ccb -- ptr to CAM request 336 * Output: None 337 * Return value: None 338 */ 339 TW_VOID 340 twa_action(struct cam_sim *sim, union ccb *ccb) 341 { 342 struct twa_softc *sc = (struct twa_softc *)cam_sim_softc(sim); 343 struct ccb_hdr *ccb_h = &(ccb->ccb_h); 344 345 switch (ccb_h->func_code) { 346 case XPT_SCSI_IO: /* SCSI I/O */ 347 { 348 struct tw_osli_req_context *req; 349 350 if ((sc->state & TW_OSLI_CTLR_STATE_SIMQ_FROZEN) || 351 ((req = tw_osli_get_request(sc)) == NULL)) { 352 tw_osli_dbg_dprintf(2, sc, 353 "simq frozen/Cannot get request pkt."); 354 /* 355 * Freeze the simq to maintain ccb ordering. The next 356 * ccb that gets completed will unfreeze the simq. 357 */ 358 tw_osli_disallow_new_requests(sc); 359 ccb_h->status |= CAM_REQUEUE_REQ; 360 xpt_done(ccb); 361 break; 362 } 363 req->req_handle.osl_req_ctxt = req; 364 req->orig_req = ccb; 365 if (tw_osli_execute_scsi(req, ccb)) 366 tw_osli_req_q_insert_tail(req, TW_OSLI_FREE_Q); 367 break; 368 } 369 370 case XPT_ABORT: 371 tw_osli_dbg_dprintf(2, sc, "Abort request."); 372 ccb_h->status = CAM_UA_ABORT; 373 xpt_done(ccb); 374 break; 375 376 case XPT_RESET_BUS: 377 tw_cl_create_event(&(sc->ctlr_handle), TW_CL_TRUE, 378 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 379 0x2108, 0x3, TW_CL_SEVERITY_INFO_STRING, 380 "Received Reset Bus request from CAM", 381 " "); 382 383 mtx_unlock(sc->sim_lock); 384 if (tw_cl_reset_ctlr(&sc->ctlr_handle)) { 385 tw_cl_create_event(&(sc->ctlr_handle), TW_CL_TRUE, 386 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 387 0x2109, 0x1, TW_CL_SEVERITY_ERROR_STRING, 388 "Failed to reset bus", 389 " "); 390 ccb_h->status = CAM_REQ_CMP_ERR; 391 } 392 else 393 ccb_h->status = CAM_REQ_CMP; 394 395 mtx_lock(sc->sim_lock); 396 xpt_done(ccb); 397 break; 398 399 case XPT_SET_TRAN_SETTINGS: 400 tw_osli_dbg_dprintf(3, sc, "XPT_SET_TRAN_SETTINGS"); 401 402 /* 403 * This command is not supported, since it's very specific 404 * to SCSI, and we are doing ATA. 405 */ 406 ccb_h->status = CAM_FUNC_NOTAVAIL; 407 xpt_done(ccb); 408 break; 409 410 case XPT_GET_TRAN_SETTINGS: 411 { 412 struct ccb_trans_settings *cts = &ccb->cts; 413 struct ccb_trans_settings_scsi *scsi = 414 &cts->proto_specific.scsi; 415 struct ccb_trans_settings_spi *spi = 416 &cts->xport_specific.spi; 417 418 cts->protocol = PROTO_SCSI; 419 cts->protocol_version = SCSI_REV_2; 420 cts->transport = XPORT_SPI; 421 cts->transport_version = 2; 422 423 spi->valid = CTS_SPI_VALID_DISC; 424 spi->flags = CTS_SPI_FLAGS_DISC_ENB; 425 scsi->valid = CTS_SCSI_VALID_TQ; 426 scsi->flags = CTS_SCSI_FLAGS_TAG_ENB; 427 tw_osli_dbg_dprintf(3, sc, "XPT_GET_TRAN_SETTINGS"); 428 ccb_h->status = CAM_REQ_CMP; 429 xpt_done(ccb); 430 break; 431 } 432 433 case XPT_CALC_GEOMETRY: 434 tw_osli_dbg_dprintf(3, sc, "XPT_CALC_GEOMETRY"); 435 cam_calc_geometry(&ccb->ccg, 1/* extended */); 436 xpt_done(ccb); 437 break; 438 439 case XPT_PATH_INQ: /* Path inquiry -- get twa properties */ 440 { 441 struct ccb_pathinq *path_inq = &ccb->cpi; 442 443 tw_osli_dbg_dprintf(3, sc, "XPT_PATH_INQ request"); 444 445 path_inq->version_num = 1; 446 path_inq->hba_inquiry = 0; 447 path_inq->target_sprt = 0; 448 path_inq->hba_misc = 0; 449 path_inq->hba_eng_cnt = 0; 450 path_inq->max_target = TW_CL_MAX_NUM_UNITS; 451 path_inq->max_lun = TW_CL_MAX_NUM_LUNS - 1; 452 path_inq->unit_number = cam_sim_unit(sim); 453 path_inq->bus_id = cam_sim_bus(sim); 454 path_inq->initiator_id = TW_CL_MAX_NUM_UNITS; 455 path_inq->base_transfer_speed = 100000; 456 strncpy(path_inq->sim_vid, "FreeBSD", SIM_IDLEN); 457 strncpy(path_inq->hba_vid, "3ware", HBA_IDLEN); 458 strncpy(path_inq->dev_name, cam_sim_name(sim), DEV_IDLEN); 459 path_inq->transport = XPORT_SPI; 460 path_inq->transport_version = 2; 461 path_inq->protocol = PROTO_SCSI; 462 path_inq->protocol_version = SCSI_REV_2; 463 ccb_h->status = CAM_REQ_CMP; 464 xpt_done(ccb); 465 break; 466 } 467 468 default: 469 tw_osli_dbg_dprintf(3, sc, "func_code = %x", ccb_h->func_code); 470 ccb_h->status = CAM_REQ_INVALID; 471 xpt_done(ccb); 472 break; 473 } 474 } 475 476 477 478 /* 479 * Function name: twa_poll 480 * Description: Driver entry point called when interrupts are not 481 * available. 482 * 483 * Input: sim -- sim corresponding to the controller 484 * Output: None 485 * Return value: None 486 */ 487 TW_VOID 488 twa_poll(struct cam_sim *sim) 489 { 490 struct twa_softc *sc = (struct twa_softc *)(cam_sim_softc(sim)); 491 492 tw_osli_dbg_dprintf(3, sc, "entering; sc = %p", sc); 493 /* 494 * It's been observed that twa_poll can get called (from 495 * dashutdown --> xpt_polled_action) even when interrupts are 496 * active, in which case, the ISR might clear the interrupt, 497 * leaving the call to tw_cl_interrupt below, no way of determining 498 * that the response from firmware is ready, resulting in 499 * tw_cl_deferred_interrupt never getting called. To cover this case, 500 * we will make the call to tw_cl_deferred_interrupt not dependent 501 * on the return value from tw_cl_interrupt. 502 */ 503 tw_cl_interrupt(&(sc->ctlr_handle)); 504 tw_cl_deferred_interrupt(&(sc->ctlr_handle)); 505 tw_osli_dbg_dprintf(3, sc, "exiting; sc = %p", sc); 506 } 507 508 509 510 /* 511 * Function name: twa_timeout 512 * Description: Driver entry point for being alerted on a request 513 * timing out. 514 * 515 * Input: arg -- ptr to timed out request 516 * Output: None 517 * Return value: None 518 */ 519 static TW_VOID 520 twa_timeout(TW_VOID *arg) 521 { 522 struct tw_osli_req_context *req = 523 (struct tw_osli_req_context *)arg; 524 525 tw_cl_create_event(&(req->ctlr->ctlr_handle), TW_CL_TRUE, 526 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 527 0x210B, 0x1, TW_CL_SEVERITY_ERROR_STRING, 528 "Request timed out!", 529 "request = %p", req); 530 tw_cl_reset_ctlr(&(req->ctlr->ctlr_handle)); 531 } 532 533 534 535 /* 536 * Function name: tw_osli_request_bus_scan 537 * Description: Requests CAM for a scan of the bus. 538 * 539 * Input: sc -- ptr to per ctlr structure 540 * Output: None 541 * Return value: 0 -- success 542 * non-zero-- failure 543 */ 544 TW_INT32 545 tw_osli_request_bus_scan(struct twa_softc *sc) 546 { 547 union ccb *ccb; 548 549 tw_osli_dbg_dprintf(3, sc, "entering"); 550 551 /* If we get here before sc->sim is initialized, return an error. */ 552 if (!(sc->sim)) 553 return(ENXIO); 554 if ((ccb = xpt_alloc_ccb()) == NULL) 555 return(ENOMEM); 556 mtx_lock(sc->sim_lock); 557 if (xpt_create_path(&ccb->ccb_h.path, xpt_periph, cam_sim_path(sc->sim), 558 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 559 xpt_free_ccb(ccb); 560 mtx_unlock(sc->sim_lock); 561 return(EIO); 562 } 563 564 /* Release simq at the end of a reset */ 565 if (sc->state & TW_OSLI_CTLR_STATE_SIMQ_FROZEN) { 566 xpt_release_simq(sc->sim, 1); 567 sc->state &= ~TW_OSLI_CTLR_STATE_SIMQ_FROZEN; 568 } 569 570 xpt_rescan(ccb); 571 mtx_unlock(sc->sim_lock); 572 return(0); 573 } 574 575 576 577 /* 578 * Function name: tw_osli_allow_new_requests 579 * Description: Sets the appropriate status bits in a ccb such that, 580 * when the ccb is completed by a call to xpt_done, 581 * CAM knows that it's ok to unfreeze the flow of new 582 * requests to this controller, if the flow is frozen. 583 * 584 * Input: sc -- ptr to OSL internal ctlr context 585 * ccb -- ptr to CAM request 586 * Output: None 587 * Return value: None 588 */ 589 TW_VOID 590 tw_osli_allow_new_requests(struct twa_softc *sc, TW_VOID *ccb) 591 { 592 ((union ccb *)(ccb))->ccb_h.status |= CAM_RELEASE_SIMQ; 593 sc->state &= ~TW_OSLI_CTLR_STATE_SIMQ_FROZEN; 594 } 595 596 597 598 /* 599 * Function name: tw_osli_disallow_new_requests 600 * Description: Calls the appropriate CAM function, so as to freeze 601 * the flow of new requests from CAM to this controller. 602 * 603 * Input: sc -- ptr to OSL internal ctlr context 604 * Output: None 605 * Return value: None 606 */ 607 TW_VOID 608 tw_osli_disallow_new_requests(struct twa_softc *sc) 609 { 610 /* Don't double freeze if already frozen */ 611 if ((sc->state & TW_OSLI_CTLR_STATE_SIMQ_FROZEN) == 0) { 612 mtx_lock(sc->sim_lock); 613 xpt_freeze_simq(sc->sim, 1); 614 mtx_unlock(sc->sim_lock); 615 sc->state |= TW_OSLI_CTLR_STATE_SIMQ_FROZEN; 616 } 617 } 618 619 620 621 /* 622 * Function name: tw_osl_ctlr_busy 623 * Description: CL calls this function on cmd queue full or otherwise, 624 * when it is too busy to accept new requests. 625 * 626 * Input: ctlr_handle -- ptr to controller handle 627 * req_handle -- ptr to request handle sent by OSL. 628 * Output: None 629 * Return value: None 630 */ 631 TW_VOID 632 tw_osl_ctlr_busy(struct tw_cl_ctlr_handle *ctlr_handle, 633 struct tw_cl_req_handle *req_handle) 634 { 635 tw_osli_disallow_new_requests(ctlr_handle->osl_ctlr_ctxt); 636 } 637 638 639 640 /* 641 * Function name: tw_osl_scan_bus 642 * Description: CL calls this function to request for a bus scan. 643 * 644 * Input: ctlr_handle -- ptr to controller handle 645 * Output: None 646 * Return value: None 647 */ 648 TW_VOID 649 tw_osl_scan_bus(struct tw_cl_ctlr_handle *ctlr_handle) 650 { 651 struct twa_softc *sc = ctlr_handle->osl_ctlr_ctxt; 652 TW_INT32 error; 653 654 if ((error = tw_osli_request_bus_scan(sc))) 655 tw_osli_printf(sc, "error = %d", 656 TW_CL_SEVERITY_ERROR_STRING, 657 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 658 0x2109, 659 "Bus scan request to CAM failed", 660 error); 661 } 662 663 664 665 /* 666 * Function name: tw_osl_complete_io 667 * Description: Called to complete CAM scsi requests. 668 * 669 * Input: req_handle -- ptr to request handle 670 * Output: None 671 * Return value: None 672 */ 673 TW_VOID 674 tw_osl_complete_io(struct tw_cl_req_handle *req_handle) 675 { 676 struct tw_osli_req_context *req = req_handle->osl_req_ctxt; 677 struct tw_cl_req_packet *req_pkt = 678 (struct tw_cl_req_packet *)(&req->req_pkt); 679 struct tw_cl_scsi_req_packet *scsi_req; 680 struct twa_softc *sc = req->ctlr; 681 union ccb *ccb = (union ccb *)(req->orig_req); 682 683 tw_osli_dbg_dprintf(10, sc, "entering"); 684 685 if (req->state != TW_OSLI_REQ_STATE_BUSY) 686 tw_osli_printf(sc, "request = %p, status = %d", 687 TW_CL_SEVERITY_ERROR_STRING, 688 TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER, 689 0x210A, 690 "Unposted command completed!!", 691 req, req->state); 692 693 /* 694 * Remove request from the busy queue. Just mark it complete. 695 * There's no need to move it into the complete queue as we are 696 * going to be done with it right now. 697 */ 698 req->state = TW_OSLI_REQ_STATE_COMPLETE; 699 tw_osli_req_q_remove_item(req, TW_OSLI_BUSY_Q); 700 701 tw_osli_unmap_request(req); 702 703 untimeout(twa_timeout, req, ccb->ccb_h.timeout_ch); 704 if (req->error_code) { 705 /* This request never got submitted to the firmware. */ 706 if (req->error_code == EBUSY) { 707 /* 708 * Cmd queue is full, or the Common Layer is out of 709 * resources. The simq will already have been frozen 710 * by CL's call to tw_osl_ctlr_busy, and this will 711 * maintain ccb ordering. The next ccb that gets 712 * completed will unfreeze the simq. 713 */ 714 ccb->ccb_h.status |= CAM_REQUEUE_REQ; 715 } 716 else if (req->error_code == EFBIG) 717 ccb->ccb_h.status = CAM_REQ_TOO_BIG; 718 else 719 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 720 } else { 721 scsi_req = &(req_pkt->gen_req_pkt.scsi_req); 722 if (req_pkt->status == TW_CL_ERR_REQ_SUCCESS) 723 ccb->ccb_h.status = CAM_REQ_CMP; 724 else { 725 if (req_pkt->status & TW_CL_ERR_REQ_INVALID_TARGET) 726 ccb->ccb_h.status |= CAM_TID_INVALID; 727 else if (req_pkt->status & TW_CL_ERR_REQ_INVALID_LUN) 728 ccb->ccb_h.status |= CAM_LUN_INVALID; 729 else if (req_pkt->status & TW_CL_ERR_REQ_SCSI_ERROR) 730 ccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR; 731 else if (req_pkt->status & TW_CL_ERR_REQ_BUS_RESET) 732 ccb->ccb_h.status |= CAM_SCSI_BUS_RESET; 733 /* 734 * If none of the above errors occurred, simply 735 * mark completion error. 736 */ 737 if (ccb->ccb_h.status == 0) 738 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 739 740 if (req_pkt->status & TW_CL_ERR_REQ_AUTO_SENSE_VALID) { 741 ccb->csio.sense_len = scsi_req->sense_len; 742 ccb->ccb_h.status |= CAM_AUTOSNS_VALID; 743 } 744 } 745 746 ccb->csio.scsi_status = scsi_req->scsi_status; 747 /* If simq is frozen, unfreeze it. */ 748 if (sc->state & TW_OSLI_CTLR_STATE_SIMQ_FROZEN) 749 tw_osli_allow_new_requests(sc, (TW_VOID *)ccb); 750 } 751 752 ccb->ccb_h.status &= ~CAM_SIM_QUEUED; 753 mtx_lock(sc->sim_lock); 754 xpt_done(ccb); 755 mtx_unlock(sc->sim_lock); 756 if (! req->error_code) 757 /* twa_action will free the request otherwise */ 758 tw_osli_req_q_insert_tail(req, TW_OSLI_FREE_Q); 759 } 760
Cache object: d67bb8cd26429c02b27b87e17a1b3d10
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]