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/twa_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) 2003-04 3ware, Inc. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD: releng/5.4/sys/dev/twa/twa_cam.c 141821 2005-02-13 18:34:27Z vkashyap $ 27 */ 28 29 /* 30 * 3ware driver for 9000 series storage controllers. 31 * 32 * Author: Vinod Kashyap 33 */ 34 35 36 #include <dev/twa/twa_includes.h> 37 38 #include <cam/cam.h> 39 #include <cam/cam_ccb.h> 40 #include <cam/cam_sim.h> 41 #include <cam/cam_xpt_sim.h> 42 #include <cam/cam_xpt_periph.h> 43 #include <cam/cam_debug.h> 44 #include <cam/cam_periph.h> 45 46 #include <cam/scsi/scsi_all.h> 47 #include <cam/scsi/scsi_message.h> 48 49 static int twa_execute_scsi(struct twa_request *tr, union ccb *ccb); 50 static void twa_action(struct cam_sim *sim, union ccb *ccb); 51 static void twa_poll(struct cam_sim *sim); 52 static void twa_async(void *callback_arg, u_int32_t code, struct cam_path *path, void *arg); 53 static void twa_timeout(void *arg); 54 static void twa_bus_scan_cb(struct cam_periph *periph, union ccb *ccb); 55 56 57 58 /* 59 * Function name: twa_cam_setup 60 * Description: Attaches the driver to CAM. 61 * 62 * Input: sc -- ptr to per ctlr structure 63 * Output: None 64 * Return value: 0 -- success 65 * non-zero-- failure 66 */ 67 int 68 twa_cam_setup(struct twa_softc *sc) 69 { 70 struct cam_devq *devq; 71 struct ccb_setasync csa; 72 73 twa_dbg_dprint(3, sc, "sc = %p", sc); 74 /* 75 * Create the device queue for our SIM. 76 */ 77 devq = cam_simq_alloc(TWA_Q_LENGTH); 78 if (devq == NULL) 79 return(ENOMEM); 80 81 /* 82 * Create a SIM entry. Though we can support TWA_Q_LENGTH simultaneous 83 * requests, we claim to be able to handle only (TWA_Q_LENGTH - 1), so 84 * that we always have a request packet available to service attention 85 * interrupts. 86 */ 87 twa_dbg_dprint(3, sc, "Calling cam_sim_alloc"); 88 sc->twa_sim = cam_sim_alloc(twa_action, twa_poll, "twa", sc, 89 device_get_unit(sc->twa_bus_dev), 90 TWA_Q_LENGTH - 1, 1, devq); 91 if (sc->twa_sim == NULL) { 92 cam_simq_free(devq); 93 return(ENOMEM); 94 } 95 96 /* 97 * Register the bus. 98 */ 99 twa_dbg_dprint(3, sc, "Calling xpt_bus_register"); 100 if (xpt_bus_register(sc->twa_sim, 0) != CAM_SUCCESS) { 101 cam_sim_free(sc->twa_sim, TRUE); 102 sc->twa_sim = NULL; /* so twa_cam_detach will not try to free it */ 103 return(ENXIO); 104 } 105 106 twa_dbg_dprint(3, sc, "Calling xpt_create_path"); 107 if (xpt_create_path(&sc->twa_path, NULL, 108 cam_sim_path(sc->twa_sim), 109 CAM_TARGET_WILDCARD, 110 CAM_LUN_WILDCARD) != CAM_REQ_CMP) { 111 xpt_bus_deregister(cam_sim_path (sc->twa_sim)); 112 cam_sim_free(sc->twa_sim, TRUE); /* passing TRUE will free the devq as well */ 113 return(ENXIO); 114 } 115 116 twa_dbg_dprint(3, sc, "Calling xpt_setup_ccb"); 117 xpt_setup_ccb(&csa.ccb_h, sc->twa_path, 5); 118 csa.ccb_h.func_code = XPT_SASYNC_CB; 119 csa.event_enable = AC_FOUND_DEVICE | AC_LOST_DEVICE; 120 csa.callback = twa_async; 121 csa.callback_arg = sc; 122 xpt_action((union ccb *)&csa); 123 124 twa_dbg_dprint(3, sc, "Calling twa_request_bus_scan"); 125 /* 126 * Request a bus scan, so that CAM gets to know of 127 * the logical units that we control. 128 */ 129 twa_request_bus_scan(sc); 130 twa_dbg_dprint(3, sc, "Exiting"); 131 return(0); 132 } 133 134 135 136 /* 137 * Function name: twa_cam_detach 138 * Description: Detaches the driver from CAM. 139 * 140 * Input: sc -- ptr to per ctlr structure 141 * Output: None 142 * Return value: None 143 */ 144 void 145 twa_cam_detach(struct twa_softc *sc) 146 { 147 if (sc->twa_path) 148 xpt_free_path(sc->twa_path); 149 if (sc->twa_sim) { 150 xpt_bus_deregister(cam_sim_path(sc->twa_sim)); 151 cam_sim_free(sc->twa_sim, TRUE); /* passing TRUE will free the devq as well */ 152 } 153 } 154 155 156 157 /* 158 * Function name: twa_send_scsi_cmd 159 * Description: Sends down a scsi cmd to fw. 160 * 161 * Input: tr -- ptr to request pkt 162 * cmd -- opcode of scsi cmd to send 163 * Output: None 164 * Return value: 0 -- success 165 * non-zero-- failure 166 */ 167 int 168 twa_send_scsi_cmd(struct twa_request *tr, int cmd) 169 { 170 union ccb ccb; 171 172 bzero(&ccb, sizeof(union ccb)); 173 ccb.csio.cdb_io.cdb_bytes[0] = (u_int8_t)cmd; 174 ccb.csio.cdb_io.cdb_bytes[4] = 128; 175 ccb.csio.cdb_len = 16; 176 if ((ccb.csio.data_ptr = malloc(TWA_SECTOR_SIZE, M_DEVBUF, M_NOWAIT)) 177 == NULL) 178 return(ENOMEM); 179 bzero(ccb.csio.data_ptr, TWA_SECTOR_SIZE); 180 ccb.csio.dxfer_len = TWA_SECTOR_SIZE; 181 182 ccb.ccb_h.target_id = 0; 183 ccb.ccb_h.flags |= CAM_DIR_IN; 184 185 if (twa_execute_scsi(tr, &ccb)) 186 return(EIO); 187 return(0); 188 } 189 190 191 192 /* 193 * Function name: twa_execute_scsi 194 * Description: Build a fw cmd, based on a CAM style ccb, and 195 * send it down. 196 * 197 * Input: tr -- ptr to request pkt 198 * ccb -- ptr to CAM style ccb 199 * Output: None 200 * Return value: 0 -- success 201 * non-zero-- failure 202 */ 203 int 204 twa_execute_scsi(struct twa_request *tr, union ccb *ccb) 205 { 206 struct twa_softc *sc = tr->tr_sc; 207 struct twa_command_packet *cmdpkt; 208 struct twa_command_9k *cmd9k; 209 struct ccb_hdr *ccb_h = &(ccb->ccb_h); 210 struct ccb_scsiio *csio = &(ccb->csio); 211 int error; 212 213 twa_dbg_dprint(3, sc, "SCSI I/O request 0x%x", 214 csio->cdb_io.cdb_bytes[0]); 215 216 if (ccb_h->target_id >= TWA_MAX_UNITS) { 217 twa_dbg_dprint(3, sc, "Invalid target. PTL = %x %x %x", 218 ccb_h->path_id, ccb_h->target_id, ccb_h->target_lun); 219 ccb_h->status |= CAM_TID_INVALID; 220 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) 221 xpt_done(ccb); 222 return(1); 223 } 224 if (ccb_h->target_lun != 0) { 225 twa_dbg_dprint(3, sc, "Invalid lun. PTL = %x %x %x", 226 ccb_h->path_id, ccb_h->target_id, ccb_h->target_lun); 227 ccb_h->status |= CAM_LUN_INVALID; 228 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) 229 xpt_done(ccb); 230 return(1); 231 } 232 233 if(ccb_h->flags & CAM_CDB_PHYS) { 234 twa_printf(sc, "Physical CDB address!\n"); 235 ccb_h->status = CAM_REQ_CMP_ERR; 236 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) 237 xpt_done(ccb); 238 return(1); 239 } 240 241 /* 242 * We are going to work on this request. Mark it as enqueued (though 243 * we don't actually queue it...) 244 */ 245 ccb_h->status |= CAM_SIM_QUEUED; 246 247 if((ccb_h->flags & CAM_DIR_MASK) != CAM_DIR_NONE) { 248 if(ccb_h->flags & CAM_DIR_IN) 249 tr->tr_flags |= TWA_CMD_DATA_IN; 250 else 251 tr->tr_flags |= TWA_CMD_DATA_OUT; 252 } 253 254 cmdpkt = tr->tr_command; 255 256 cmdpkt->cmd_hdr.header_desc.size_header = 128; 257 258 cmd9k = &(cmdpkt->command.cmd_pkt_9k); 259 cmd9k->command.opcode = TWA_OP_EXECUTE_SCSI_COMMAND; 260 cmd9k->unit = ccb_h->target_id; 261 cmd9k->request_id = tr->tr_request_id; 262 cmd9k->status = 0; 263 cmd9k->sgl_offset = 16; /* offset from end of hdr = max cdb len */ 264 265 if(ccb_h->flags & CAM_CDB_POINTER) 266 bcopy(csio->cdb_io.cdb_ptr, cmd9k->cdb, csio->cdb_len); 267 else 268 bcopy(csio->cdb_io.cdb_bytes, cmd9k->cdb, csio->cdb_len); 269 270 if (!(ccb_h->flags & CAM_DATA_PHYS)) { 271 /* Virtual data addresses. Need to convert them... */ 272 twa_dbg_dprint(3, sc, "XPT_SCSI_IO: Single virtual address!"); 273 if (!(ccb_h->flags & CAM_SCATTER_VALID)) { 274 if (csio->dxfer_len > TWA_MAX_IO_SIZE) { 275 twa_printf(sc, "I/O size %d too big.\n", 276 csio->dxfer_len); 277 ccb_h->status = CAM_REQ_TOO_BIG; 278 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) 279 xpt_done(ccb); 280 return(1); 281 } 282 283 if ((tr->tr_length = csio->dxfer_len)) { 284 tr->tr_data = csio->data_ptr; 285 cmd9k->sgl_entries = 1; 286 } 287 } else { 288 twa_printf(sc, "twa_execute_scsi: XPT_SCSI_IO: Got SGList!\n"); 289 ccb_h->status = CAM_REQ_CMP_ERR; 290 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) { 291 xpt_done(ccb); 292 } 293 return(1); 294 } 295 } else { 296 /* Data addresses are physical. */ 297 twa_printf(sc, "twa_execute_scsi: XPT_SCSI_IO: Physical data addresses!\n"); 298 ccb_h->status = CAM_REQ_CMP_ERR; 299 if (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_EXTERNAL) { 300 ccb_h->status |= CAM_RELEASE_SIMQ; 301 ccb_h->status &= ~CAM_SIM_QUEUED; 302 xpt_done(ccb); 303 } 304 return(1); 305 } 306 307 tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_9K; 308 309 twa_set_timer(tr); 310 311 /* twa_setup_data_dmamap will fill in the SGL, and submit the I/O. */ 312 error = twa_map_request(tr); 313 return(error); 314 } 315 316 317 318 /* 319 * Function name: twa_action 320 * Description: Driver entry point for CAM's use. 321 * 322 * Input: sim -- sim corresponding to the ctlr 323 * ccb -- ptr to CAM request 324 * Output: None 325 * Return value: None 326 */ 327 void 328 twa_action(struct cam_sim *sim, union ccb *ccb) 329 { 330 struct twa_softc *sc = (struct twa_softc *)cam_sim_softc(sim); 331 struct ccb_hdr *ccb_h = &(ccb->ccb_h); 332 333 switch (ccb_h->func_code) { 334 case XPT_SCSI_IO: /* SCSI I/O */ 335 { 336 struct twa_request *tr; 337 338 if ((sc->twa_state & TWA_STATE_SIMQ_FROZEN) || 339 ((tr = twa_get_request(sc)) == NULL)) { 340 twa_dbg_dprint(2, sc, "simq frozen/Cannot get request pkt."); 341 /* 342 * Freeze the simq to maintain ccb ordering. The next 343 * ccb that gets completed will unfreeze the simq. 344 */ 345 twa_disallow_new_requests(sc); 346 ccb_h->status |= CAM_REQUEUE_REQ; 347 xpt_done(ccb); 348 break; 349 } 350 tr->tr_cmd_pkt_type |= TWA_CMD_PKT_TYPE_EXTERNAL; 351 tr->tr_private = ccb; 352 tr->tr_callback = twa_complete_io; 353 if (twa_execute_scsi(tr, ccb)) 354 twa_release_request(tr); 355 break; 356 } 357 358 case XPT_ABORT: 359 twa_dbg_dprint(2, sc, "Abort request"); 360 ccb_h->status = CAM_UA_ABORT; 361 xpt_done(ccb); 362 break; 363 364 case XPT_RESET_BUS: 365 twa_printf(sc, "Reset Bus request from CAM...\n"); 366 if (twa_reset(sc)) { 367 twa_printf(sc, "Reset Bus failed!\n"); 368 ccb_h->status = CAM_REQ_CMP_ERR; 369 } 370 else 371 ccb_h->status = CAM_REQ_CMP; 372 373 xpt_done(ccb); 374 break; 375 376 case XPT_SET_TRAN_SETTINGS: 377 twa_dbg_dprint(3, sc, "XPT_SET_TRAN_SETTINGS"); 378 379 /* 380 * This command is not supported, since it's very specific 381 * to SCSI, and we are doing ATA. 382 */ 383 ccb_h->status = CAM_FUNC_NOTAVAIL; 384 xpt_done(ccb); 385 break; 386 387 case XPT_GET_TRAN_SETTINGS: 388 { 389 struct ccb_trans_settings *cts = &ccb->cts; 390 391 twa_dbg_dprint(3, sc, "XPT_GET_TRAN_SETTINGS"); 392 cts->valid = (CCB_TRANS_DISC_VALID | CCB_TRANS_TQ_VALID); 393 cts->flags &= ~(CCB_TRANS_DISC_ENB | CCB_TRANS_TAG_ENB); 394 ccb_h->status = CAM_REQ_CMP; 395 xpt_done(ccb); 396 break; 397 } 398 399 case XPT_CALC_GEOMETRY: 400 twa_dbg_dprint(3, sc, "XPT_CALC_GEOMETRY request"); 401 cam_calc_geometry(&ccb->ccg, 1/* extended */); 402 xpt_done(ccb); 403 break; 404 405 case XPT_PATH_INQ: /* Path inquiry -- get twa properties */ 406 { 407 struct ccb_pathinq *path_inq = &ccb->cpi; 408 409 twa_dbg_dprint(3, sc, "XPT_PATH_INQ request"); 410 411 path_inq->version_num = 1; 412 path_inq->hba_inquiry = 0; 413 path_inq->target_sprt = 0; 414 path_inq->hba_misc = 0; 415 path_inq->hba_eng_cnt = 0; 416 path_inq->max_target = TWA_MAX_UNITS; 417 path_inq->max_lun = 0; 418 path_inq->unit_number = cam_sim_unit(sim); 419 path_inq->bus_id = cam_sim_bus(sim); 420 path_inq->initiator_id = 12; 421 path_inq->base_transfer_speed = 100000; 422 strncpy(path_inq->sim_vid, "FreeBSD", SIM_IDLEN); 423 strncpy(path_inq->hba_vid, "3ware", HBA_IDLEN); 424 strncpy(path_inq->dev_name, cam_sim_name(sim), DEV_IDLEN); 425 ccb_h->status = CAM_REQ_CMP; 426 xpt_done(ccb); 427 break; 428 } 429 430 default: 431 twa_dbg_dprint(3, sc, "func_code = %x", ccb_h->func_code); 432 ccb_h->status = CAM_REQ_INVALID; 433 xpt_done(ccb); 434 break; 435 } 436 } 437 438 439 440 /* 441 * Function name: twa_poll 442 * Description: Driver entry point called when interrupts are not available. 443 * 444 * Input: sim -- sim corresponding to the controller 445 * Output: None 446 * Return value: None 447 */ 448 void 449 twa_poll(struct cam_sim *sim) 450 { 451 #ifdef TWA_DEBUG 452 struct twa_softc *sc = (struct twa_softc *)cam_sim_softc(sim); 453 #endif /* TWA_DEBUG */ 454 455 twa_dbg_dprint(3, sc, "Entering sc = %p", sc); 456 twa_interrupt(cam_sim_softc(sim)); 457 twa_dbg_dprint(3, sc, "Exiting sc = %p", sc); 458 } 459 460 461 462 /* 463 * Function name: twa_async 464 * Description: Driver entry point for CAM to notify driver of special 465 * events. We don't use this for now. 466 * 467 * Input: callback_arg -- ptr to per ctlr structure 468 * code -- code associated with the event 469 * path -- cam path 470 * arg -- 471 * Output: None 472 * Return value: 0 -- success 473 * non-zero-- failure 474 */ 475 void 476 twa_async(void *callback_arg, u_int32_t code, 477 struct cam_path *path, void *arg) 478 { 479 #ifdef TWA_DEBUG 480 struct twa_softc *sc = (struct twa_softc *)callback_arg; 481 #endif /* TWA_DEBUG */ 482 483 twa_dbg_dprint(3, sc, "sc = %p, code = %x, path = %p, arg = %p", 484 sc, code, path, arg); 485 } 486 487 488 489 /* 490 * Function name: twa_timeout 491 * Description: Driver entry point for being alerted on a request 492 * timing out. 493 * 494 * Input: arg -- ptr to timed out request 495 * Output: None 496 * Return value: None 497 */ 498 static void 499 twa_timeout(void *arg) 500 { 501 struct twa_request *tr = (struct twa_request *)arg; 502 struct twa_softc *sc = (struct twa_softc *)(tr->tr_sc); 503 504 twa_printf(sc, "Request timed out! tr = %p\n", tr); 505 506 twa_reset(sc); 507 } 508 509 510 511 /* 512 * Function name: twa_request_bus_scan 513 * Description: Requests CAM for a scan of the bus. 514 * 515 * Input: sc -- ptr to per ctlr structure 516 * Output: None 517 * Return value: None 518 */ 519 void 520 twa_request_bus_scan(struct twa_softc *sc) 521 { 522 struct cam_path *path; 523 union ccb *ccb; 524 525 if ((ccb = malloc(sizeof(union ccb), M_TEMP, M_WAITOK)) == NULL) 526 return; 527 bzero(ccb, sizeof(union ccb)); 528 if (xpt_create_path(&path, xpt_periph, cam_sim_path(sc->twa_sim), 529 CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) 530 return; 531 532 xpt_setup_ccb(&ccb->ccb_h, path, 5); 533 ccb->ccb_h.func_code = XPT_SCAN_BUS; 534 ccb->ccb_h.cbfcnp = twa_bus_scan_cb; 535 ccb->crcn.flags = CAM_FLAG_NONE; 536 xpt_action(ccb); 537 } 538 539 540 541 /* 542 * Function name: twa_bus_scan_cb 543 * Description: Callback from CAM on a bus scan request. 544 * 545 * Input: periph -- we don't use this 546 * ccb -- bus scan request ccb that we sent to CAM 547 * Output: None 548 * Return value: None 549 */ 550 static void 551 twa_bus_scan_cb(struct cam_periph *periph, union ccb *ccb) 552 { 553 twa_dbg_print(3, "ccb = %p\n", ccb); 554 if (ccb->ccb_h.status != CAM_REQ_CMP) 555 printf("cam_scan_callback: failure status = %x\n", 556 ccb->ccb_h.status); 557 else 558 twa_dbg_print(3, "success"); 559 560 xpt_free_path(ccb->ccb_h.path); 561 free(ccb, M_TEMP); 562 } 563 564 565 566 /* 567 * Function name: twa_scsi_complete 568 * Description: Called to complete CAM scsi requests. 569 * 570 * Input: tr -- ptr to request pkt to be completed 571 * Output: None 572 * Return value: None 573 */ 574 void 575 twa_scsi_complete(struct twa_request *tr) 576 { 577 struct twa_softc *sc = tr->tr_sc; 578 struct twa_command_header *cmd_hdr = &(tr->tr_command->cmd_hdr); 579 struct twa_command_9k *cmd = &(tr->tr_command->command.cmd_pkt_9k); 580 union ccb *ccb = (union ccb *)(tr->tr_private); 581 u_int16_t error; 582 u_int8_t *cdb; 583 584 twa_unset_timer(tr); 585 586 if (tr->tr_error) { 587 if (tr->tr_error == EBUSY) 588 ccb->ccb_h.status |= CAM_REQUEUE_REQ; 589 else if (tr->tr_error == EFBIG) 590 ccb->ccb_h.status = CAM_REQ_TOO_BIG; 591 else 592 ccb->ccb_h.status = CAM_REQ_CMP_ERR; 593 } else { 594 if (cmd->status) { 595 twa_dbg_dprint(1, sc, "req_id = 0x%x, status = 0x%x", 596 cmd->request_id, 597 cmd->status); 598 599 error = cmd_hdr->status_block.error; 600 if ((error == TWA_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) || 601 (error == TWA_ERROR_UNIT_OFFLINE)) { 602 twa_dbg_dprint(3, sc, "Unsupported unit. PTL = %x %x %x", 603 ccb->ccb_h.path_id, 604 ccb->ccb_h.target_id, 605 ccb->ccb_h.target_lun); 606 ccb->ccb_h.status |= CAM_TID_INVALID; 607 } else { 608 twa_dbg_dprint(2, sc, "cmd = %x %x %x %x %x %x %x", 609 cmd->command.opcode, 610 cmd->command.reserved, 611 cmd->unit, 612 cmd->request_id, 613 cmd->status, 614 cmd->sgl_offset, 615 cmd->sgl_entries); 616 617 cdb = (u_int8_t *)(cmd->cdb); 618 twa_dbg_dprint(2, sc, "cdb = %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x", 619 cdb[0], cdb[1], cdb[2], cdb[3], cdb[4], cdb[5], cdb[6], cdb[7], 620 cdb[8], cdb[9], cdb[10], cdb[11], cdb[12], cdb[13], cdb[14], cdb[15]); 621 622 /* 623 * Print the error. Firmware doesn't yet support 624 * the 'Mode Sense' cmd. Don't print if the cmd 625 * is 'Mode Sense', and the error is 'Invalid field 626 * in CDB'. 627 */ 628 if (! ((cdb[0] == 0x1A) && (error == 0x10D))) { 629 u_int8_t *error_str = 630 &(cmd_hdr->err_desc[strlen(cmd_hdr->err_desc) + 1]); 631 632 if (error_str[0] == '\0') 633 error_str = 634 twa_find_msg_string(twa_error_table, error); 635 636 twa_printf(sc, "SCSI cmd = 0x%x: ERROR: (0x%02X: 0x%04X): %s: %s\n", 637 cdb[0], 638 TWA_MESSAGE_SOURCE_CONTROLLER_ERROR, 639 error, 640 error_str, 641 cmd_hdr->err_desc); 642 } 643 } 644 645 bcopy(cmd_hdr->sense_data, &(ccb->csio.sense_data), 646 TWA_SENSE_DATA_LENGTH); 647 ccb->csio.sense_len = TWA_SENSE_DATA_LENGTH; 648 ccb->ccb_h.status |= CAM_SCSI_STATUS_ERROR | CAM_AUTOSNS_VALID; 649 } else 650 ccb->ccb_h.status = CAM_REQ_CMP; 651 652 ccb->csio.scsi_status = cmd->status; 653 /* If simq is frozen, unfreeze it. */ 654 if (sc->twa_state & TWA_STATE_SIMQ_FROZEN) 655 twa_allow_new_requests(sc, (void *)ccb); 656 } 657 658 ccb->ccb_h.status &= ~CAM_SIM_QUEUED; 659 xpt_done(ccb); 660 } 661 662 663 664 /* 665 * Function name: twa_drain_busy_queue 666 * Description: This function gets called after a controller reset. 667 * It errors back to CAM, all those requests that were 668 * pending with the firmware, at the time of the reset. 669 * 670 * Input: sc -- ptr to per ctlr structure 671 * Output: None 672 * Return value: None 673 */ 674 void 675 twa_drain_busy_queue(struct twa_softc *sc) 676 { 677 struct twa_request *tr; 678 union ccb *ccb; 679 680 /* Walk the busy queue. */ 681 while ((tr = twa_dequeue_busy(sc))) { 682 twa_unmap_request(tr); 683 if ((tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_INTERNAL) || 684 (tr->tr_cmd_pkt_type & TWA_CMD_PKT_TYPE_IOCTL)) { 685 /* 686 * It's an internal/ioctl request. The callback/ 687 * originator should do the clean-up (except unmapping). 688 */ 689 tr->tr_error = EIO; 690 if (tr->tr_flags & TWA_CMD_SLEEP_ON_REQUEST) { 691 tr->tr_flags &= ~TWA_CMD_SLEEP_ON_REQUEST; 692 wakeup_one(tr);/* let the caller know */ 693 } 694 else 695 if (tr->tr_callback) 696 tr->tr_callback(tr); 697 } else { 698 if ((ccb = tr->tr_private)) { 699 twa_unset_timer(tr); 700 /* It's a SCSI request. Complete it. */ 701 ccb->ccb_h.status = CAM_SCSI_BUS_RESET; 702 twa_allow_new_requests(sc, ccb); 703 ccb->ccb_h.status &= ~CAM_SIM_QUEUED; 704 xpt_done(ccb); 705 } 706 twa_release_request(tr); 707 } 708 } 709 } 710 711 712 713 /* 714 * Function name: twa_allow_new_requests 715 * Description: Sets the appropriate status bits in a ccb such that, 716 * when the ccb is completed by a call to xpt_done, 717 * CAM knows that it's ok to unfreeze the flow of new 718 * requests to this controller, if the flow is frozen. 719 * 720 * Input: sc -- ptr to per ctlr structure 721 * ccb -- ptr to CAM request 722 * Output: None 723 * Return value: None 724 */ 725 void 726 twa_allow_new_requests(struct twa_softc *sc, void *ccb) 727 { 728 ((union ccb *)(ccb))->ccb_h.status |= CAM_RELEASE_SIMQ; 729 sc->twa_state &= ~TWA_STATE_SIMQ_FROZEN; 730 } 731 732 733 734 /* 735 * Function name: twa_disallow_new_requests 736 * Description: Calls the appropriate CAM function, so as to freeze 737 * the flow of new requests from CAM to this controller. 738 * 739 * Input: sc -- ptr to per ctlr structure 740 * Output: None 741 * Return value: None 742 */ 743 void 744 twa_disallow_new_requests(struct twa_softc *sc) 745 { 746 xpt_freeze_simq(sc->twa_sim, 1); 747 sc->twa_state |= TWA_STATE_SIMQ_FROZEN; 748 } 749 750 751 752 /* 753 * Function name: twa_set_timer 754 * Description: Set a timer to time a given request. 755 * 756 * Input: tr -- ptr to request pkt 757 * Output: None 758 * Return value: None 759 */ 760 void 761 twa_set_timer(struct twa_request *tr) 762 { 763 union ccb *ccb = (union ccb *)(tr->tr_private); 764 765 /* Set the timer only if external (CAM) request. */ 766 if (ccb) { 767 tr->tr_flags |= TWA_CMD_TIMER_SET; 768 ccb->ccb_h.timeout_ch = timeout(twa_timeout, tr, 769 (ccb->ccb_h.timeout * hz) / 1000); 770 } 771 } 772 773 774 775 /* 776 * Function name: twa_unset_timer 777 * Description: Unset a previously set timer. 778 * 779 * Input: tr -- ptr to request pkt 780 * Output: None 781 * Return value: None 782 */ 783 void 784 twa_unset_timer(struct twa_request *tr) 785 { 786 union ccb *ccb = (union ccb *)(tr->tr_private); 787 788 if (tr->tr_flags & TWA_CMD_TIMER_SET) { 789 untimeout(twa_timeout, tr, ccb->ccb_h.timeout_ch); 790 tr->tr_flags &= ~TWA_CMD_TIMER_SET; 791 } 792 }
Cache object: b0faab1dce813f2fa573befe204825c3
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]