1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2009 Alexander Motin <mav@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer, 12 * without modification, immediately at the beginning of the file. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/param.h> 30 #include <sys/bus.h> 31 #include <sys/endian.h> 32 #include <sys/systm.h> 33 #include <sys/types.h> 34 #include <sys/malloc.h> 35 #include <sys/kernel.h> 36 #include <sys/time.h> 37 #include <sys/conf.h> 38 #include <sys/fcntl.h> 39 #include <sys/sbuf.h> 40 41 #include <sys/eventhandler.h> 42 #include <sys/lock.h> 43 #include <sys/mutex.h> 44 #include <sys/sysctl.h> 45 46 #include <cam/cam.h> 47 #include <cam/cam_ccb.h> 48 #include <cam/cam_queue.h> 49 #include <cam/cam_periph.h> 50 #include <cam/cam_sim.h> 51 #include <cam/cam_xpt.h> 52 #include <cam/cam_xpt_sim.h> 53 #include <cam/cam_xpt_periph.h> 54 #include <cam/cam_xpt_internal.h> 55 #include <cam/cam_debug.h> 56 57 #include <cam/scsi/scsi_all.h> 58 #include <cam/scsi/scsi_message.h> 59 #include <cam/ata/ata_all.h> 60 #include <machine/stdarg.h> /* for xpt_print below */ 61 62 struct ata_quirk_entry { 63 struct scsi_inquiry_pattern inq_pat; 64 uint8_t quirks; 65 #define CAM_QUIRK_MAXTAGS 0x01 66 u_int mintags; 67 u_int maxtags; 68 }; 69 70 static periph_init_t aprobe_periph_init; 71 72 static struct periph_driver aprobe_driver = 73 { 74 aprobe_periph_init, "aprobe", 75 TAILQ_HEAD_INITIALIZER(aprobe_driver.units), /* generation */ 0, 76 CAM_PERIPH_DRV_EARLY 77 }; 78 79 PERIPHDRIVER_DECLARE(aprobe, aprobe_driver); 80 81 typedef enum { 82 PROBE_RESET, 83 PROBE_IDENTIFY, 84 PROBE_SPINUP, 85 PROBE_SETMODE, 86 PROBE_SETPM, 87 PROBE_SETAPST, 88 PROBE_SETDMAAA, 89 PROBE_SETAN, 90 PROBE_SET_MULTI, 91 PROBE_INQUIRY, 92 PROBE_FULL_INQUIRY, 93 PROBE_PM_PID, 94 PROBE_PM_PRV, 95 PROBE_IDENTIFY_SES, 96 PROBE_IDENTIFY_SAFTE, 97 PROBE_DONE, 98 PROBE_INVALID 99 } aprobe_action; 100 101 static char *probe_action_text[] = { 102 "PROBE_RESET", 103 "PROBE_IDENTIFY", 104 "PROBE_SPINUP", 105 "PROBE_SETMODE", 106 "PROBE_SETPM", 107 "PROBE_SETAPST", 108 "PROBE_SETDMAAA", 109 "PROBE_SETAN", 110 "PROBE_SET_MULTI", 111 "PROBE_INQUIRY", 112 "PROBE_FULL_INQUIRY", 113 "PROBE_PM_PID", 114 "PROBE_PM_PRV", 115 "PROBE_IDENTIFY_SES", 116 "PROBE_IDENTIFY_SAFTE", 117 "PROBE_DONE", 118 "PROBE_INVALID" 119 }; 120 121 #define PROBE_SET_ACTION(softc, newaction) \ 122 do { \ 123 char **text; \ 124 text = probe_action_text; \ 125 CAM_DEBUG((softc)->periph->path, CAM_DEBUG_PROBE, \ 126 ("Probe %s to %s\n", text[(softc)->action], \ 127 text[(newaction)])); \ 128 (softc)->action = (newaction); \ 129 } while(0) 130 131 typedef enum { 132 PROBE_NO_ANNOUNCE = 0x04 133 } aprobe_flags; 134 135 typedef struct { 136 TAILQ_HEAD(, ccb_hdr) request_ccbs; 137 struct ata_params ident_data; 138 aprobe_action action; 139 aprobe_flags flags; 140 uint32_t pm_pid; 141 uint32_t pm_prv; 142 int restart; 143 int spinup; 144 int faults; 145 u_int caps; 146 struct cam_periph *periph; 147 } aprobe_softc; 148 149 static struct ata_quirk_entry ata_quirk_table[] = 150 { 151 { 152 /* Default tagged queuing parameters for all devices */ 153 { 154 T_ANY, SIP_MEDIA_REMOVABLE|SIP_MEDIA_FIXED, 155 /*vendor*/"*", /*product*/"*", /*revision*/"*" 156 }, 157 /*quirks*/0, /*mintags*/0, /*maxtags*/0 158 }, 159 }; 160 161 static cam_status aproberegister(struct cam_periph *periph, void *arg); 162 static void aprobeschedule(struct cam_periph *probe_periph); 163 static void aprobestart(struct cam_periph *periph, union ccb *start_ccb); 164 static void aproberequestdefaultnegotiation(struct cam_periph *periph); 165 static void aprobedone(struct cam_periph *periph, union ccb *done_ccb); 166 static void aprobecleanup(struct cam_periph *periph); 167 static void ata_find_quirk(struct cam_ed *device); 168 static void ata_scan_bus(struct cam_periph *periph, union ccb *ccb); 169 static void ata_scan_lun(struct cam_periph *periph, 170 struct cam_path *path, cam_flags flags, 171 union ccb *ccb); 172 static void axptscandone(struct cam_periph *periph, union ccb *done_ccb); 173 static struct cam_ed * 174 ata_alloc_device(struct cam_eb *bus, struct cam_et *target, 175 lun_id_t lun_id); 176 static void ata_device_transport(struct cam_path *path); 177 static void ata_get_transfer_settings(struct ccb_trans_settings *cts); 178 static void ata_set_transfer_settings(struct ccb_trans_settings *cts, 179 struct cam_path *path, 180 int async_update); 181 static void ata_dev_async(uint32_t async_code, 182 struct cam_eb *bus, 183 struct cam_et *target, 184 struct cam_ed *device, 185 void *async_arg); 186 static void ata_action(union ccb *start_ccb); 187 static void ata_announce_periph_sbuf(struct cam_periph *periph, struct sbuf *sb); 188 static void ata_proto_announce_sbuf(struct cam_ed *device, struct sbuf *sb); 189 static void ata_proto_denounce_sbuf(struct cam_ed *device, struct sbuf *sb); 190 static void ata_proto_debug_out(union ccb *ccb); 191 static void semb_proto_announce_sbuf(struct cam_ed *device, struct sbuf *sb); 192 static void semb_proto_denounce_sbuf(struct cam_ed *device, struct sbuf *sb); 193 194 static int ata_dma = 1; 195 static int atapi_dma = 1; 196 197 TUNABLE_INT("hw.ata.ata_dma", &ata_dma); 198 TUNABLE_INT("hw.ata.atapi_dma", &atapi_dma); 199 200 static struct xpt_xport_ops ata_xport_ops = { 201 .alloc_device = ata_alloc_device, 202 .action = ata_action, 203 .async = ata_dev_async, 204 .announce_sbuf = ata_announce_periph_sbuf, 205 }; 206 #define ATA_XPT_XPORT(x, X) \ 207 static struct xpt_xport ata_xport_ ## x = { \ 208 .xport = XPORT_ ## X, \ 209 .name = #x, \ 210 .ops = &ata_xport_ops, \ 211 }; \ 212 CAM_XPT_XPORT(ata_xport_ ## x); 213 214 ATA_XPT_XPORT(ata, ATA); 215 ATA_XPT_XPORT(sata, SATA); 216 217 #undef ATA_XPORT_XPORT 218 219 static struct xpt_proto_ops ata_proto_ops_ata = { 220 .announce_sbuf = ata_proto_announce_sbuf, 221 .denounce_sbuf = ata_proto_denounce_sbuf, 222 .debug_out = ata_proto_debug_out, 223 }; 224 static struct xpt_proto ata_proto_ata = { 225 .proto = PROTO_ATA, 226 .name = "ata", 227 .ops = &ata_proto_ops_ata, 228 }; 229 230 static struct xpt_proto_ops ata_proto_ops_satapm = { 231 .announce_sbuf = ata_proto_announce_sbuf, 232 .denounce_sbuf = ata_proto_denounce_sbuf, 233 .debug_out = ata_proto_debug_out, 234 }; 235 static struct xpt_proto ata_proto_satapm = { 236 .proto = PROTO_SATAPM, 237 .name = "satapm", 238 .ops = &ata_proto_ops_satapm, 239 }; 240 241 static struct xpt_proto_ops ata_proto_ops_semb = { 242 .announce_sbuf = semb_proto_announce_sbuf, 243 .denounce_sbuf = semb_proto_denounce_sbuf, 244 .debug_out = ata_proto_debug_out, 245 }; 246 static struct xpt_proto ata_proto_semb = { 247 .proto = PROTO_SEMB, 248 .name = "semb", 249 .ops = &ata_proto_ops_semb, 250 }; 251 252 CAM_XPT_PROTO(ata_proto_ata); 253 CAM_XPT_PROTO(ata_proto_satapm); 254 CAM_XPT_PROTO(ata_proto_semb); 255 256 static void 257 aprobe_periph_init(void) 258 { 259 } 260 261 static cam_status 262 aproberegister(struct cam_periph *periph, void *arg) 263 { 264 union ccb *request_ccb; /* CCB representing the probe request */ 265 aprobe_softc *softc; 266 267 request_ccb = (union ccb *)arg; 268 if (request_ccb == NULL) { 269 printf("proberegister: no probe CCB, " 270 "can't register device\n"); 271 return(CAM_REQ_CMP_ERR); 272 } 273 274 softc = (aprobe_softc *)malloc(sizeof(*softc), M_CAMXPT, M_ZERO | M_NOWAIT); 275 276 if (softc == NULL) { 277 printf("proberegister: Unable to probe new device. " 278 "Unable to allocate softc\n"); 279 return(CAM_REQ_CMP_ERR); 280 } 281 TAILQ_INIT(&softc->request_ccbs); 282 TAILQ_INSERT_TAIL(&softc->request_ccbs, &request_ccb->ccb_h, 283 periph_links.tqe); 284 softc->flags = 0; 285 periph->softc = softc; 286 softc->periph = periph; 287 softc->action = PROBE_INVALID; 288 if (cam_periph_acquire(periph) != 0) 289 return (CAM_REQ_CMP_ERR); 290 291 CAM_DEBUG(periph->path, CAM_DEBUG_PROBE, ("Probe started\n")); 292 ata_device_transport(periph->path); 293 aprobeschedule(periph); 294 return(CAM_REQ_CMP); 295 } 296 297 static void 298 aprobeschedule(struct cam_periph *periph) 299 { 300 union ccb *ccb; 301 aprobe_softc *softc; 302 303 softc = (aprobe_softc *)periph->softc; 304 ccb = (union ccb *)TAILQ_FIRST(&softc->request_ccbs); 305 306 if ((periph->path->device->flags & CAM_DEV_UNCONFIGURED) || 307 periph->path->device->protocol == PROTO_SATAPM || 308 periph->path->device->protocol == PROTO_SEMB) 309 PROBE_SET_ACTION(softc, PROBE_RESET); 310 else 311 PROBE_SET_ACTION(softc, PROBE_IDENTIFY); 312 313 if (ccb->crcn.flags & CAM_EXPECT_INQ_CHANGE) 314 softc->flags |= PROBE_NO_ANNOUNCE; 315 else 316 softc->flags &= ~PROBE_NO_ANNOUNCE; 317 318 xpt_schedule(periph, CAM_PRIORITY_XPT); 319 } 320 321 static void 322 aprobestart(struct cam_periph *periph, union ccb *start_ccb) 323 { 324 struct ccb_trans_settings cts; 325 struct ccb_ataio *ataio; 326 struct ccb_scsiio *csio; 327 aprobe_softc *softc; 328 struct cam_path *path; 329 struct ata_params *ident_buf; 330 u_int oif; 331 332 CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("aprobestart\n")); 333 334 softc = (aprobe_softc *)periph->softc; 335 path = start_ccb->ccb_h.path; 336 ataio = &start_ccb->ataio; 337 csio = &start_ccb->csio; 338 ident_buf = &periph->path->device->ident_data; 339 340 if (softc->restart) { 341 softc->restart = 0; 342 if ((path->device->flags & CAM_DEV_UNCONFIGURED) || 343 path->device->protocol == PROTO_SATAPM || 344 path->device->protocol == PROTO_SEMB) 345 softc->action = PROBE_RESET; 346 else 347 softc->action = PROBE_IDENTIFY; 348 } 349 switch (softc->action) { 350 case PROBE_RESET: 351 cam_fill_ataio(ataio, 352 0, 353 aprobedone, 354 /*flags*/CAM_DIR_NONE, 355 0, 356 /*data_ptr*/NULL, 357 /*dxfer_len*/0, 358 15 * 1000); 359 ata_reset_cmd(ataio); 360 break; 361 case PROBE_IDENTIFY: 362 cam_fill_ataio(ataio, 363 1, 364 aprobedone, 365 /*flags*/CAM_DIR_IN, 366 0, 367 /*data_ptr*/(uint8_t *)&softc->ident_data, 368 /*dxfer_len*/sizeof(softc->ident_data), 369 30 * 1000); 370 if (path->device->protocol == PROTO_ATA) 371 ata_28bit_cmd(ataio, ATA_ATA_IDENTIFY, 0, 0, 0); 372 else 373 ata_28bit_cmd(ataio, ATA_ATAPI_IDENTIFY, 0, 0, 0); 374 break; 375 case PROBE_SPINUP: 376 if (bootverbose) 377 xpt_print(path, "Spinning up device\n"); 378 cam_fill_ataio(ataio, 379 1, 380 aprobedone, 381 /*flags*/CAM_DIR_NONE | CAM_HIGH_POWER, 382 0, 383 /*data_ptr*/NULL, 384 /*dxfer_len*/0, 385 30 * 1000); 386 ata_28bit_cmd(ataio, ATA_SETFEATURES, ATA_SF_PUIS_SPINUP, 0, 0); 387 break; 388 case PROBE_SETMODE: 389 { 390 int mode, wantmode; 391 392 mode = 0; 393 /* Fetch user modes from SIM. */ 394 bzero(&cts, sizeof(cts)); 395 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 396 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 397 cts.type = CTS_TYPE_USER_SETTINGS; 398 xpt_action((union ccb *)&cts); 399 if (path->device->transport == XPORT_ATA) { 400 if (cts.xport_specific.ata.valid & CTS_ATA_VALID_MODE) 401 mode = cts.xport_specific.ata.mode; 402 } else { 403 if (cts.xport_specific.sata.valid & CTS_SATA_VALID_MODE) 404 mode = cts.xport_specific.sata.mode; 405 } 406 if (path->device->protocol == PROTO_ATA) { 407 if (ata_dma == 0 && (mode == 0 || mode > ATA_PIO_MAX)) 408 mode = ATA_PIO_MAX; 409 } else { 410 if (atapi_dma == 0 && (mode == 0 || mode > ATA_PIO_MAX)) 411 mode = ATA_PIO_MAX; 412 } 413 negotiate: 414 /* Honor device capabilities. */ 415 wantmode = mode = ata_max_mode(ident_buf, mode); 416 /* Report modes to SIM. */ 417 bzero(&cts, sizeof(cts)); 418 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 419 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 420 cts.type = CTS_TYPE_CURRENT_SETTINGS; 421 if (path->device->transport == XPORT_ATA) { 422 cts.xport_specific.ata.mode = mode; 423 cts.xport_specific.ata.valid = CTS_ATA_VALID_MODE; 424 } else { 425 cts.xport_specific.sata.mode = mode; 426 cts.xport_specific.sata.valid = CTS_SATA_VALID_MODE; 427 } 428 xpt_action((union ccb *)&cts); 429 /* Fetch current modes from SIM. */ 430 bzero(&cts, sizeof(cts)); 431 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 432 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 433 cts.type = CTS_TYPE_CURRENT_SETTINGS; 434 xpt_action((union ccb *)&cts); 435 if (path->device->transport == XPORT_ATA) { 436 if (cts.xport_specific.ata.valid & CTS_ATA_VALID_MODE) 437 mode = cts.xport_specific.ata.mode; 438 } else { 439 if (cts.xport_specific.sata.valid & CTS_SATA_VALID_MODE) 440 mode = cts.xport_specific.sata.mode; 441 } 442 /* If SIM disagree - renegotiate. */ 443 if (mode != wantmode) 444 goto negotiate; 445 /* Remember what transport thinks about DMA. */ 446 oif = path->device->inq_flags; 447 if (mode < ATA_DMA) 448 path->device->inq_flags &= ~SID_DMA; 449 else 450 path->device->inq_flags |= SID_DMA; 451 if (path->device->inq_flags != oif) 452 xpt_async(AC_GETDEV_CHANGED, path, NULL); 453 cam_fill_ataio(ataio, 454 1, 455 aprobedone, 456 /*flags*/CAM_DIR_NONE, 457 0, 458 /*data_ptr*/NULL, 459 /*dxfer_len*/0, 460 30 * 1000); 461 ata_28bit_cmd(ataio, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode); 462 break; 463 } 464 case PROBE_SETPM: 465 cam_fill_ataio(ataio, 466 1, 467 aprobedone, 468 CAM_DIR_NONE, 469 0, 470 NULL, 471 0, 472 30*1000); 473 ata_28bit_cmd(ataio, ATA_SETFEATURES, 474 (softc->caps & CTS_SATA_CAPS_H_PMREQ) ? 0x10 : 0x90, 475 0, 0x03); 476 break; 477 case PROBE_SETAPST: 478 cam_fill_ataio(ataio, 479 1, 480 aprobedone, 481 CAM_DIR_NONE, 482 0, 483 NULL, 484 0, 485 30*1000); 486 ata_28bit_cmd(ataio, ATA_SETFEATURES, 487 (softc->caps & CTS_SATA_CAPS_H_APST) ? 0x10 : 0x90, 488 0, 0x07); 489 break; 490 case PROBE_SETDMAAA: 491 cam_fill_ataio(ataio, 492 1, 493 aprobedone, 494 CAM_DIR_NONE, 495 0, 496 NULL, 497 0, 498 30*1000); 499 ata_28bit_cmd(ataio, ATA_SETFEATURES, 500 (softc->caps & CTS_SATA_CAPS_H_DMAAA) ? 0x10 : 0x90, 501 0, 0x02); 502 break; 503 case PROBE_SETAN: 504 /* Remember what transport thinks about AEN. */ 505 oif = path->device->inq_flags; 506 if (softc->caps & CTS_SATA_CAPS_H_AN) 507 path->device->inq_flags |= SID_AEN; 508 else 509 path->device->inq_flags &= ~SID_AEN; 510 if (path->device->inq_flags != oif) 511 xpt_async(AC_GETDEV_CHANGED, path, NULL); 512 cam_fill_ataio(ataio, 513 1, 514 aprobedone, 515 CAM_DIR_NONE, 516 0, 517 NULL, 518 0, 519 30*1000); 520 ata_28bit_cmd(ataio, ATA_SETFEATURES, 521 (softc->caps & CTS_SATA_CAPS_H_AN) ? 0x10 : 0x90, 522 0, 0x05); 523 break; 524 case PROBE_SET_MULTI: 525 { 526 u_int sectors, bytecount; 527 528 bytecount = 8192; /* SATA maximum */ 529 /* Fetch user bytecount from SIM. */ 530 bzero(&cts, sizeof(cts)); 531 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 532 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 533 cts.type = CTS_TYPE_USER_SETTINGS; 534 xpt_action((union ccb *)&cts); 535 if (path->device->transport == XPORT_ATA) { 536 if (cts.xport_specific.ata.valid & CTS_ATA_VALID_BYTECOUNT) 537 bytecount = cts.xport_specific.ata.bytecount; 538 } else { 539 if (cts.xport_specific.sata.valid & CTS_SATA_VALID_BYTECOUNT) 540 bytecount = cts.xport_specific.sata.bytecount; 541 } 542 /* Honor device capabilities. */ 543 sectors = max(1, min(ident_buf->sectors_intr & 0xff, 544 bytecount / ata_logical_sector_size(ident_buf))); 545 /* Report bytecount to SIM. */ 546 bzero(&cts, sizeof(cts)); 547 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 548 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 549 cts.type = CTS_TYPE_CURRENT_SETTINGS; 550 if (path->device->transport == XPORT_ATA) { 551 cts.xport_specific.ata.bytecount = sectors * 552 ata_logical_sector_size(ident_buf); 553 cts.xport_specific.ata.valid = CTS_ATA_VALID_BYTECOUNT; 554 } else { 555 cts.xport_specific.sata.bytecount = sectors * 556 ata_logical_sector_size(ident_buf); 557 cts.xport_specific.sata.valid = CTS_SATA_VALID_BYTECOUNT; 558 } 559 xpt_action((union ccb *)&cts); 560 /* Fetch current bytecount from SIM. */ 561 bzero(&cts, sizeof(cts)); 562 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 563 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 564 cts.type = CTS_TYPE_CURRENT_SETTINGS; 565 xpt_action((union ccb *)&cts); 566 if (path->device->transport == XPORT_ATA) { 567 if (cts.xport_specific.ata.valid & CTS_ATA_VALID_BYTECOUNT) 568 bytecount = cts.xport_specific.ata.bytecount; 569 } else { 570 if (cts.xport_specific.sata.valid & CTS_SATA_VALID_BYTECOUNT) 571 bytecount = cts.xport_specific.sata.bytecount; 572 } 573 sectors = bytecount / ata_logical_sector_size(ident_buf); 574 575 cam_fill_ataio(ataio, 576 1, 577 aprobedone, 578 CAM_DIR_NONE, 579 0, 580 NULL, 581 0, 582 30*1000); 583 ata_28bit_cmd(ataio, ATA_SET_MULTI, 0, 0, sectors); 584 break; 585 } 586 case PROBE_INQUIRY: 587 { 588 u_int bytecount; 589 590 bytecount = 8192; /* SATA maximum */ 591 /* Fetch user bytecount from SIM. */ 592 bzero(&cts, sizeof(cts)); 593 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 594 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 595 cts.type = CTS_TYPE_USER_SETTINGS; 596 xpt_action((union ccb *)&cts); 597 if (path->device->transport == XPORT_ATA) { 598 if (cts.xport_specific.ata.valid & CTS_ATA_VALID_BYTECOUNT) 599 bytecount = cts.xport_specific.ata.bytecount; 600 } else { 601 if (cts.xport_specific.sata.valid & CTS_SATA_VALID_BYTECOUNT) 602 bytecount = cts.xport_specific.sata.bytecount; 603 } 604 /* Honor device capabilities. */ 605 bytecount &= ~1; 606 bytecount = max(2, min(65534, bytecount)); 607 if (ident_buf->satacapabilities != 0x0000 && 608 ident_buf->satacapabilities != 0xffff) { 609 bytecount = min(8192, bytecount); 610 } 611 /* Report bytecount to SIM. */ 612 bzero(&cts, sizeof(cts)); 613 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 614 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 615 cts.type = CTS_TYPE_CURRENT_SETTINGS; 616 if (path->device->transport == XPORT_ATA) { 617 cts.xport_specific.ata.bytecount = bytecount; 618 cts.xport_specific.ata.valid = CTS_ATA_VALID_BYTECOUNT; 619 } else { 620 cts.xport_specific.sata.bytecount = bytecount; 621 cts.xport_specific.sata.valid = CTS_SATA_VALID_BYTECOUNT; 622 } 623 xpt_action((union ccb *)&cts); 624 /* FALLTHROUGH */ 625 } 626 case PROBE_FULL_INQUIRY: 627 { 628 u_int inquiry_len; 629 struct scsi_inquiry_data *inq_buf = 630 &path->device->inq_data; 631 632 if (softc->action == PROBE_INQUIRY) 633 inquiry_len = SHORT_INQUIRY_LENGTH; 634 else 635 inquiry_len = SID_ADDITIONAL_LENGTH(inq_buf); 636 /* 637 * Some parallel SCSI devices fail to send an 638 * ignore wide residue message when dealing with 639 * odd length inquiry requests. Round up to be 640 * safe. 641 */ 642 inquiry_len = roundup2(inquiry_len, 2); 643 scsi_inquiry(csio, 644 /*retries*/1, 645 aprobedone, 646 MSG_SIMPLE_Q_TAG, 647 (uint8_t *)inq_buf, 648 inquiry_len, 649 /*evpd*/FALSE, 650 /*page_code*/0, 651 SSD_MIN_SIZE, 652 /*timeout*/60 * 1000); 653 break; 654 } 655 case PROBE_PM_PID: 656 cam_fill_ataio(ataio, 657 1, 658 aprobedone, 659 /*flags*/CAM_DIR_NONE, 660 0, 661 /*data_ptr*/NULL, 662 /*dxfer_len*/0, 663 10 * 1000); 664 ata_pm_read_cmd(ataio, 0, 15); 665 break; 666 case PROBE_PM_PRV: 667 cam_fill_ataio(ataio, 668 1, 669 aprobedone, 670 /*flags*/CAM_DIR_NONE, 671 0, 672 /*data_ptr*/NULL, 673 /*dxfer_len*/0, 674 10 * 1000); 675 ata_pm_read_cmd(ataio, 1, 15); 676 break; 677 case PROBE_IDENTIFY_SES: 678 cam_fill_ataio(ataio, 679 1, 680 aprobedone, 681 /*flags*/CAM_DIR_IN, 682 0, 683 /*data_ptr*/(uint8_t *)&softc->ident_data, 684 /*dxfer_len*/sizeof(softc->ident_data), 685 30 * 1000); 686 ata_28bit_cmd(ataio, ATA_SEP_ATTN, 0xEC, 0x02, 687 sizeof(softc->ident_data) / 4); 688 break; 689 case PROBE_IDENTIFY_SAFTE: 690 cam_fill_ataio(ataio, 691 1, 692 aprobedone, 693 /*flags*/CAM_DIR_IN, 694 0, 695 /*data_ptr*/(uint8_t *)&softc->ident_data, 696 /*dxfer_len*/sizeof(softc->ident_data), 697 30 * 1000); 698 ata_28bit_cmd(ataio, ATA_SEP_ATTN, 0xEC, 0x00, 699 sizeof(softc->ident_data) / 4); 700 break; 701 default: 702 panic("aprobestart: invalid action state 0x%x\n", softc->action); 703 } 704 start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE; 705 xpt_action(start_ccb); 706 } 707 708 static void 709 aproberequestdefaultnegotiation(struct cam_periph *periph) 710 { 711 struct ccb_trans_settings cts; 712 713 bzero(&cts, sizeof(cts)); 714 xpt_setup_ccb(&cts.ccb_h, periph->path, CAM_PRIORITY_NONE); 715 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 716 cts.type = CTS_TYPE_USER_SETTINGS; 717 xpt_action((union ccb *)&cts); 718 if ((cts.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) 719 return; 720 cts.xport_specific.valid = 0; 721 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 722 cts.type = CTS_TYPE_CURRENT_SETTINGS; 723 xpt_action((union ccb *)&cts); 724 } 725 726 static void 727 aprobedone(struct cam_periph *periph, union ccb *done_ccb) 728 { 729 struct ccb_trans_settings cts; 730 struct ata_params *ident_buf; 731 struct scsi_inquiry_data *inq_buf; 732 aprobe_softc *softc; 733 struct cam_path *path; 734 cam_status status; 735 uint32_t priority; 736 u_int caps, oif; 737 int changed, found = 1; 738 static const uint8_t fake_device_id_hdr[8] = 739 {0, SVPD_DEVICE_ID, 0, 12, 740 SVPD_ID_CODESET_BINARY, SVPD_ID_TYPE_NAA, 0, 8}; 741 742 CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("aprobedone\n")); 743 744 softc = (aprobe_softc *)periph->softc; 745 path = done_ccb->ccb_h.path; 746 priority = done_ccb->ccb_h.pinfo.priority; 747 ident_buf = &path->device->ident_data; 748 inq_buf = &path->device->inq_data; 749 750 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) { 751 if (cam_periph_error(done_ccb, 752 0, softc->restart ? (SF_NO_RECOVERY | SF_NO_RETRY) : 0 753 ) == ERESTART) { 754 out: 755 /* Drop freeze taken due to CAM_DEV_QFREEZE flag set. */ 756 cam_release_devq(path, 0, 0, 0, FALSE); 757 return; 758 } 759 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) { 760 /* Don't wedge the queue */ 761 xpt_release_devq(path, /*count*/1, /*run_queue*/TRUE); 762 } 763 status = done_ccb->ccb_h.status & CAM_STATUS_MASK; 764 if (softc->restart) { 765 softc->faults++; 766 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) == 767 CAM_CMD_TIMEOUT) 768 softc->faults += 4; 769 if (softc->faults < 10) 770 goto done; 771 else 772 softc->restart = 0; 773 774 /* Old PIO2 devices may not support mode setting. */ 775 } else if (softc->action == PROBE_SETMODE && 776 status == CAM_ATA_STATUS_ERROR && 777 ata_max_pmode(ident_buf) <= ATA_PIO2 && 778 (ident_buf->capabilities1 & ATA_SUPPORT_IORDY) == 0) { 779 goto noerror; 780 781 /* 782 * Some old WD SATA disks report supported and enabled 783 * device-initiated interface power management, but return 784 * ABORT on attempt to disable it. 785 */ 786 } else if (softc->action == PROBE_SETPM && 787 status == CAM_ATA_STATUS_ERROR) { 788 goto noerror; 789 790 /* 791 * Some old WD SATA disks have broken SPINUP handling. 792 * If we really fail to spin up the disk, then there will be 793 * some media access errors later on, but at least we will 794 * have a device to interact with for recovery attempts. 795 */ 796 } else if (softc->action == PROBE_SPINUP && 797 status == CAM_ATA_STATUS_ERROR) { 798 goto noerror; 799 800 /* 801 * Some HP SATA disks report supported DMA Auto-Activation, 802 * but return ABORT on attempt to enable it. 803 */ 804 } else if (softc->action == PROBE_SETDMAAA && 805 status == CAM_ATA_STATUS_ERROR) { 806 goto noerror; 807 808 /* 809 * SES and SAF-TE SEPs have different IDENTIFY commands, 810 * but SATA specification doesn't tell how to identify them. 811 * Until better way found, just try another if first fail. 812 */ 813 } else if (softc->action == PROBE_IDENTIFY_SES && 814 status == CAM_ATA_STATUS_ERROR) { 815 PROBE_SET_ACTION(softc, PROBE_IDENTIFY_SAFTE); 816 xpt_release_ccb(done_ccb); 817 xpt_schedule(periph, priority); 818 goto out; 819 } 820 821 /* 822 * If we get to this point, we got an error status back 823 * from the inquiry and the error status doesn't require 824 * automatically retrying the command. Therefore, the 825 * inquiry failed. If we had inquiry information before 826 * for this device, but this latest inquiry command failed, 827 * the device has probably gone away. If this device isn't 828 * already marked unconfigured, notify the peripheral 829 * drivers that this device is no more. 830 */ 831 device_fail: if ((path->device->flags & CAM_DEV_UNCONFIGURED) == 0) 832 xpt_async(AC_LOST_DEVICE, path, NULL); 833 PROBE_SET_ACTION(softc, PROBE_INVALID); 834 found = 0; 835 goto done; 836 } 837 noerror: 838 if (softc->restart) 839 goto done; 840 switch (softc->action) { 841 case PROBE_RESET: 842 { 843 int sign = (done_ccb->ataio.res.lba_high << 8) + 844 done_ccb->ataio.res.lba_mid; 845 CAM_DEBUG(path, CAM_DEBUG_PROBE, 846 ("SIGNATURE: %04x\n", sign)); 847 if (sign == 0x0000 && 848 done_ccb->ccb_h.target_id != 15) { 849 path->device->protocol = PROTO_ATA; 850 PROBE_SET_ACTION(softc, PROBE_IDENTIFY); 851 } else if (sign == 0x9669 && 852 done_ccb->ccb_h.target_id == 15) { 853 /* Report SIM that PM is present. */ 854 bzero(&cts, sizeof(cts)); 855 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 856 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 857 cts.type = CTS_TYPE_CURRENT_SETTINGS; 858 cts.xport_specific.sata.pm_present = 1; 859 cts.xport_specific.sata.valid = CTS_SATA_VALID_PM; 860 xpt_action((union ccb *)&cts); 861 path->device->protocol = PROTO_SATAPM; 862 PROBE_SET_ACTION(softc, PROBE_PM_PID); 863 } else if (sign == 0xc33c && 864 done_ccb->ccb_h.target_id != 15) { 865 path->device->protocol = PROTO_SEMB; 866 PROBE_SET_ACTION(softc, PROBE_IDENTIFY_SES); 867 } else if (sign == 0xeb14 && 868 done_ccb->ccb_h.target_id != 15) { 869 path->device->protocol = PROTO_SCSI; 870 PROBE_SET_ACTION(softc, PROBE_IDENTIFY); 871 } else { 872 if (done_ccb->ccb_h.target_id != 15) { 873 xpt_print(path, 874 "Unexpected signature 0x%04x\n", sign); 875 } 876 goto device_fail; 877 } 878 xpt_release_ccb(done_ccb); 879 xpt_schedule(periph, priority); 880 goto out; 881 } 882 case PROBE_IDENTIFY: 883 { 884 struct ccb_pathinq cpi; 885 int veto = 0; 886 887 /* 888 * Convert to host byte order, and fix the strings. 889 */ 890 ident_buf = &softc->ident_data; 891 ata_param_fixup(ident_buf); 892 893 /* 894 * Allow others to veto this ATA disk attachment. This 895 * is mainly used by VMs, whose disk controllers may 896 * share the disks with the simulated ATA controllers. 897 */ 898 EVENTHANDLER_INVOKE(ada_probe_veto, path, ident_buf, &veto); 899 if (veto) { 900 goto device_fail; 901 } 902 903 /* Device may need spin-up before IDENTIFY become valid. */ 904 if ((ident_buf->specconf == 0x37c8 || 905 ident_buf->specconf == 0x738c) && 906 ((ident_buf->config & ATA_RESP_INCOMPLETE) || 907 softc->spinup == 0)) { 908 PROBE_SET_ACTION(softc, PROBE_SPINUP); 909 xpt_release_ccb(done_ccb); 910 xpt_schedule(periph, priority); 911 goto out; 912 } 913 ident_buf = &path->device->ident_data; 914 915 /* Check that it is the same device as we know. */ 916 if ((periph->path->device->flags & CAM_DEV_UNCONFIGURED) == 0) { 917 if (bcmp(softc->ident_data.model, ident_buf->model, 918 sizeof(ident_buf->model)) || 919 bcmp(softc->ident_data.serial, ident_buf->serial, 920 sizeof(ident_buf->serial))) { 921 /* The device was replaced. */ 922 changed = 2; 923 xpt_async(AC_LOST_DEVICE, path, NULL); 924 } else if (bcmp(&softc->ident_data, ident_buf, 925 sizeof(*ident_buf))) { 926 /* The device is the same, but has changed. */ 927 changed = 1; 928 } else { 929 /* Nothing has changed. */ 930 changed = 0; 931 } 932 } else { 933 /* This is a new device. */ 934 changed = 2; 935 } 936 937 if (changed != 0) 938 bcopy(&softc->ident_data, ident_buf, sizeof(struct ata_params)); 939 if (changed == 2) { 940 /* Clean up from previous instance of this device */ 941 if (path->device->serial_num != NULL) { 942 free(path->device->serial_num, M_CAMXPT); 943 path->device->serial_num = NULL; 944 path->device->serial_num_len = 0; 945 } 946 if (path->device->device_id != NULL) { 947 free(path->device->device_id, M_CAMXPT); 948 path->device->device_id = NULL; 949 path->device->device_id_len = 0; 950 } 951 path->device->serial_num = 952 (uint8_t *)malloc((sizeof(ident_buf->serial) + 1), 953 M_CAMXPT, M_NOWAIT); 954 if (path->device->serial_num != NULL) { 955 bcopy(ident_buf->serial, 956 path->device->serial_num, 957 sizeof(ident_buf->serial)); 958 path->device->serial_num[sizeof(ident_buf->serial)] 959 = '\0'; 960 path->device->serial_num_len = 961 strlen(path->device->serial_num); 962 } 963 if (ident_buf->enabled.extension & 964 ATA_SUPPORT_64BITWWN) { 965 path->device->device_id = 966 malloc(16, M_CAMXPT, M_NOWAIT); 967 if (path->device->device_id != NULL) { 968 path->device->device_id_len = 16; 969 bcopy(&fake_device_id_hdr, 970 path->device->device_id, 8); 971 bcopy(ident_buf->wwn, 972 path->device->device_id + 8, 8); 973 ata_bswap(path->device->device_id + 8, 8); 974 } 975 } 976 path->device->flags |= CAM_DEV_IDENTIFY_DATA_VALID; 977 } 978 if (changed == 1) 979 xpt_async(AC_GETDEV_CHANGED, path, NULL); 980 if (ident_buf->satacapabilities & ATA_SUPPORT_NCQ) { 981 path->device->mintags = 2; 982 path->device->maxtags = 983 ATA_QUEUE_LEN(ident_buf->queue) + 1; 984 } 985 ata_find_quirk(path->device); 986 if (path->device->mintags != 0 && 987 path->bus->sim->max_tagged_dev_openings != 0) { 988 /* Check if the SIM does not want queued commands. */ 989 xpt_path_inq(&cpi, path); 990 if (cam_ccb_success((union ccb *)&cpi) && 991 (cpi.hba_inquiry & PI_TAG_ABLE)) { 992 /* Report SIM which tags are allowed. */ 993 bzero(&cts, sizeof(cts)); 994 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 995 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 996 cts.type = CTS_TYPE_CURRENT_SETTINGS; 997 cts.xport_specific.sata.tags = path->device->maxtags; 998 cts.xport_specific.sata.valid = CTS_SATA_VALID_TAGS; 999 xpt_action((union ccb *)&cts); 1000 } 1001 } 1002 ata_device_transport(path); 1003 if (changed == 2) 1004 aproberequestdefaultnegotiation(periph); 1005 PROBE_SET_ACTION(softc, PROBE_SETMODE); 1006 xpt_release_ccb(done_ccb); 1007 xpt_schedule(periph, priority); 1008 goto out; 1009 } 1010 case PROBE_SPINUP: 1011 if (bootverbose) 1012 xpt_print(path, "Spin-up done\n"); 1013 softc->spinup = 1; 1014 PROBE_SET_ACTION(softc, PROBE_IDENTIFY); 1015 xpt_release_ccb(done_ccb); 1016 xpt_schedule(periph, priority); 1017 goto out; 1018 case PROBE_SETMODE: 1019 /* Set supported bits. */ 1020 bzero(&cts, sizeof(cts)); 1021 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 1022 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 1023 cts.type = CTS_TYPE_CURRENT_SETTINGS; 1024 xpt_action((union ccb *)&cts); 1025 if (path->device->transport == XPORT_SATA && 1026 cts.xport_specific.sata.valid & CTS_SATA_VALID_CAPS) 1027 caps = cts.xport_specific.sata.caps & CTS_SATA_CAPS_H; 1028 else if (path->device->transport == XPORT_ATA && 1029 cts.xport_specific.ata.valid & CTS_ATA_VALID_CAPS) 1030 caps = cts.xport_specific.ata.caps & CTS_ATA_CAPS_H; 1031 else 1032 caps = 0; 1033 if (path->device->transport == XPORT_SATA && 1034 ident_buf->satacapabilities != 0xffff) { 1035 if (ident_buf->satacapabilities & ATA_SUPPORT_IFPWRMNGTRCV) 1036 caps |= CTS_SATA_CAPS_D_PMREQ; 1037 if (ident_buf->satacapabilities & ATA_SUPPORT_HAPST) 1038 caps |= CTS_SATA_CAPS_D_APST; 1039 } 1040 /* Mask unwanted bits. */ 1041 bzero(&cts, sizeof(cts)); 1042 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 1043 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 1044 cts.type = CTS_TYPE_USER_SETTINGS; 1045 xpt_action((union ccb *)&cts); 1046 if (path->device->transport == XPORT_SATA && 1047 cts.xport_specific.sata.valid & CTS_SATA_VALID_CAPS) 1048 caps &= cts.xport_specific.sata.caps; 1049 else if (path->device->transport == XPORT_ATA && 1050 cts.xport_specific.ata.valid & CTS_ATA_VALID_CAPS) 1051 caps &= cts.xport_specific.ata.caps; 1052 else 1053 caps = 0; 1054 /* 1055 * Remember what transport thinks about 48-bit DMA. If 1056 * capability information is not provided or transport is 1057 * SATA, we take support for granted. 1058 */ 1059 oif = path->device->inq_flags; 1060 if (!(path->device->inq_flags & SID_DMA) || 1061 (path->device->transport == XPORT_ATA && 1062 (cts.xport_specific.ata.valid & CTS_ATA_VALID_CAPS) && 1063 !(caps & CTS_ATA_CAPS_H_DMA48))) 1064 path->device->inq_flags &= ~SID_DMA48; 1065 else 1066 path->device->inq_flags |= SID_DMA48; 1067 if (path->device->inq_flags != oif) 1068 xpt_async(AC_GETDEV_CHANGED, path, NULL); 1069 /* Store result to SIM. */ 1070 bzero(&cts, sizeof(cts)); 1071 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 1072 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 1073 cts.type = CTS_TYPE_CURRENT_SETTINGS; 1074 if (path->device->transport == XPORT_SATA) { 1075 cts.xport_specific.sata.caps = caps; 1076 cts.xport_specific.sata.valid = CTS_SATA_VALID_CAPS; 1077 } else { 1078 cts.xport_specific.ata.caps = caps; 1079 cts.xport_specific.ata.valid = CTS_ATA_VALID_CAPS; 1080 } 1081 xpt_action((union ccb *)&cts); 1082 softc->caps = caps; 1083 if (path->device->transport != XPORT_SATA) 1084 goto notsata; 1085 if ((ident_buf->satasupport & ATA_SUPPORT_IFPWRMNGT) && 1086 (!(softc->caps & CTS_SATA_CAPS_H_PMREQ)) != 1087 (!(ident_buf->sataenabled & ATA_SUPPORT_IFPWRMNGT))) { 1088 PROBE_SET_ACTION(softc, PROBE_SETPM); 1089 xpt_release_ccb(done_ccb); 1090 xpt_schedule(periph, priority); 1091 goto out; 1092 } 1093 /* FALLTHROUGH */ 1094 case PROBE_SETPM: 1095 if (ident_buf->satacapabilities != 0xffff && 1096 (ident_buf->satacapabilities & ATA_SUPPORT_DAPST) && 1097 (!(softc->caps & CTS_SATA_CAPS_H_APST)) != 1098 (!(ident_buf->sataenabled & ATA_ENABLED_DAPST))) { 1099 PROBE_SET_ACTION(softc, PROBE_SETAPST); 1100 xpt_release_ccb(done_ccb); 1101 xpt_schedule(periph, priority); 1102 goto out; 1103 } 1104 /* FALLTHROUGH */ 1105 case PROBE_SETAPST: 1106 if ((ident_buf->satasupport & ATA_SUPPORT_AUTOACTIVATE) && 1107 (!(softc->caps & CTS_SATA_CAPS_H_DMAAA)) != 1108 (!(ident_buf->sataenabled & ATA_SUPPORT_AUTOACTIVATE))) { 1109 PROBE_SET_ACTION(softc, PROBE_SETDMAAA); 1110 xpt_release_ccb(done_ccb); 1111 xpt_schedule(periph, priority); 1112 goto out; 1113 } 1114 /* FALLTHROUGH */ 1115 case PROBE_SETDMAAA: 1116 if (path->device->protocol != PROTO_ATA && 1117 (ident_buf->satasupport & ATA_SUPPORT_ASYNCNOTIF) && 1118 (!(softc->caps & CTS_SATA_CAPS_H_AN)) != 1119 (!(ident_buf->sataenabled & ATA_SUPPORT_ASYNCNOTIF))) { 1120 PROBE_SET_ACTION(softc, PROBE_SETAN); 1121 xpt_release_ccb(done_ccb); 1122 xpt_schedule(periph, priority); 1123 goto out; 1124 } 1125 /* FALLTHROUGH */ 1126 case PROBE_SETAN: 1127 notsata: 1128 if (path->device->protocol == PROTO_ATA) { 1129 PROBE_SET_ACTION(softc, PROBE_SET_MULTI); 1130 } else { 1131 PROBE_SET_ACTION(softc, PROBE_INQUIRY); 1132 } 1133 xpt_release_ccb(done_ccb); 1134 xpt_schedule(periph, priority); 1135 goto out; 1136 case PROBE_SET_MULTI: 1137 if (periph->path->device->flags & CAM_DEV_UNCONFIGURED) { 1138 path->device->flags &= ~CAM_DEV_UNCONFIGURED; 1139 xpt_acquire_device(path->device); 1140 done_ccb->ccb_h.func_code = XPT_GDEV_TYPE; 1141 xpt_action(done_ccb); 1142 xpt_async(AC_FOUND_DEVICE, path, done_ccb); 1143 } 1144 PROBE_SET_ACTION(softc, PROBE_DONE); 1145 break; 1146 case PROBE_INQUIRY: 1147 case PROBE_FULL_INQUIRY: 1148 { 1149 uint8_t periph_qual, len; 1150 1151 path->device->flags |= CAM_DEV_INQUIRY_DATA_VALID; 1152 1153 periph_qual = SID_QUAL(inq_buf); 1154 1155 if (periph_qual != SID_QUAL_LU_CONNECTED && 1156 periph_qual != SID_QUAL_LU_OFFLINE) 1157 break; 1158 1159 /* 1160 * We conservatively request only 1161 * SHORT_INQUIRY_LEN bytes of inquiry 1162 * information during our first try 1163 * at sending an INQUIRY. If the device 1164 * has more information to give, 1165 * perform a second request specifying 1166 * the amount of information the device 1167 * is willing to give. 1168 */ 1169 len = inq_buf->additional_length 1170 + offsetof(struct scsi_inquiry_data, additional_length) + 1; 1171 if (softc->action == PROBE_INQUIRY 1172 && len > SHORT_INQUIRY_LENGTH) { 1173 PROBE_SET_ACTION(softc, PROBE_FULL_INQUIRY); 1174 xpt_release_ccb(done_ccb); 1175 xpt_schedule(periph, priority); 1176 goto out; 1177 } 1178 1179 ata_device_transport(path); 1180 if (periph->path->device->flags & CAM_DEV_UNCONFIGURED) { 1181 path->device->flags &= ~CAM_DEV_UNCONFIGURED; 1182 xpt_acquire_device(path->device); 1183 done_ccb->ccb_h.func_code = XPT_GDEV_TYPE; 1184 xpt_action(done_ccb); 1185 xpt_async(AC_FOUND_DEVICE, path, done_ccb); 1186 } 1187 PROBE_SET_ACTION(softc, PROBE_DONE); 1188 break; 1189 } 1190 case PROBE_PM_PID: 1191 if ((path->device->flags & CAM_DEV_IDENTIFY_DATA_VALID) == 0) 1192 bzero(ident_buf, sizeof(*ident_buf)); 1193 softc->pm_pid = (done_ccb->ataio.res.lba_high << 24) + 1194 (done_ccb->ataio.res.lba_mid << 16) + 1195 (done_ccb->ataio.res.lba_low << 8) + 1196 done_ccb->ataio.res.sector_count; 1197 ((uint32_t *)ident_buf)[0] = softc->pm_pid; 1198 snprintf(ident_buf->model, sizeof(ident_buf->model), 1199 "Port Multiplier %08x", softc->pm_pid); 1200 PROBE_SET_ACTION(softc, PROBE_PM_PRV); 1201 xpt_release_ccb(done_ccb); 1202 xpt_schedule(periph, priority); 1203 goto out; 1204 case PROBE_PM_PRV: 1205 softc->pm_prv = (done_ccb->ataio.res.lba_high << 24) + 1206 (done_ccb->ataio.res.lba_mid << 16) + 1207 (done_ccb->ataio.res.lba_low << 8) + 1208 done_ccb->ataio.res.sector_count; 1209 ((uint32_t *)ident_buf)[1] = softc->pm_prv; 1210 snprintf(ident_buf->revision, sizeof(ident_buf->revision), 1211 "%04x", softc->pm_prv); 1212 path->device->flags |= CAM_DEV_IDENTIFY_DATA_VALID; 1213 ata_device_transport(path); 1214 if (periph->path->device->flags & CAM_DEV_UNCONFIGURED) 1215 aproberequestdefaultnegotiation(periph); 1216 /* Set supported bits. */ 1217 bzero(&cts, sizeof(cts)); 1218 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 1219 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 1220 cts.type = CTS_TYPE_CURRENT_SETTINGS; 1221 xpt_action((union ccb *)&cts); 1222 if (cts.xport_specific.sata.valid & CTS_SATA_VALID_CAPS) 1223 caps = cts.xport_specific.sata.caps & CTS_SATA_CAPS_H; 1224 else 1225 caps = 0; 1226 /* All PMPs must support PM requests. */ 1227 caps |= CTS_SATA_CAPS_D_PMREQ; 1228 /* Mask unwanted bits. */ 1229 bzero(&cts, sizeof(cts)); 1230 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 1231 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 1232 cts.type = CTS_TYPE_USER_SETTINGS; 1233 xpt_action((union ccb *)&cts); 1234 if (cts.xport_specific.sata.valid & CTS_SATA_VALID_CAPS) 1235 caps &= cts.xport_specific.sata.caps; 1236 else 1237 caps = 0; 1238 /* Remember what transport thinks about AEN. */ 1239 oif = path->device->inq_flags; 1240 if ((caps & CTS_SATA_CAPS_H_AN) && path->device->protocol != PROTO_ATA) 1241 path->device->inq_flags |= SID_AEN; 1242 else 1243 path->device->inq_flags &= ~SID_AEN; 1244 /* Store result to SIM. */ 1245 bzero(&cts, sizeof(cts)); 1246 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 1247 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 1248 cts.type = CTS_TYPE_CURRENT_SETTINGS; 1249 cts.xport_specific.sata.caps = caps; 1250 cts.xport_specific.sata.valid = CTS_SATA_VALID_CAPS; 1251 xpt_action((union ccb *)&cts); 1252 softc->caps = caps; 1253 if (periph->path->device->flags & CAM_DEV_UNCONFIGURED) { 1254 path->device->flags &= ~CAM_DEV_UNCONFIGURED; 1255 xpt_acquire_device(path->device); 1256 done_ccb->ccb_h.func_code = XPT_GDEV_TYPE; 1257 xpt_action(done_ccb); 1258 xpt_async(AC_FOUND_DEVICE, path, done_ccb); 1259 } else { 1260 if (path->device->inq_flags != oif) 1261 xpt_async(AC_GETDEV_CHANGED, path, NULL); 1262 done_ccb->ccb_h.func_code = XPT_GDEV_TYPE; 1263 xpt_action(done_ccb); 1264 xpt_async(AC_SCSI_AEN, path, done_ccb); 1265 } 1266 PROBE_SET_ACTION(softc, PROBE_DONE); 1267 break; 1268 case PROBE_IDENTIFY_SES: 1269 case PROBE_IDENTIFY_SAFTE: 1270 if ((periph->path->device->flags & CAM_DEV_UNCONFIGURED) == 0) { 1271 /* Check that it is the same device. */ 1272 if (bcmp(&softc->ident_data, ident_buf, 53)) { 1273 /* Device changed. */ 1274 changed = 2; 1275 xpt_async(AC_LOST_DEVICE, path, NULL); 1276 } else { 1277 bcopy(&softc->ident_data, ident_buf, sizeof(struct ata_params)); 1278 changed = 0; 1279 } 1280 } else 1281 changed = 2; 1282 if (changed) { 1283 bcopy(&softc->ident_data, ident_buf, sizeof(struct ata_params)); 1284 /* Clean up from previous instance of this device */ 1285 if (path->device->device_id != NULL) { 1286 free(path->device->device_id, M_CAMXPT); 1287 path->device->device_id = NULL; 1288 path->device->device_id_len = 0; 1289 } 1290 path->device->device_id = 1291 malloc(16, M_CAMXPT, M_NOWAIT); 1292 if (path->device->device_id != NULL) { 1293 path->device->device_id_len = 16; 1294 bcopy(&fake_device_id_hdr, 1295 path->device->device_id, 8); 1296 bcopy(((uint8_t*)ident_buf) + 2, 1297 path->device->device_id + 8, 8); 1298 } 1299 1300 path->device->flags |= CAM_DEV_IDENTIFY_DATA_VALID; 1301 } 1302 ata_device_transport(path); 1303 if (changed) 1304 aproberequestdefaultnegotiation(periph); 1305 1306 if (periph->path->device->flags & CAM_DEV_UNCONFIGURED) { 1307 path->device->flags &= ~CAM_DEV_UNCONFIGURED; 1308 xpt_acquire_device(path->device); 1309 done_ccb->ccb_h.func_code = XPT_GDEV_TYPE; 1310 xpt_action(done_ccb); 1311 xpt_async(AC_FOUND_DEVICE, path, done_ccb); 1312 } 1313 PROBE_SET_ACTION(softc, PROBE_DONE); 1314 break; 1315 default: 1316 panic("aprobedone: invalid action state 0x%x\n", softc->action); 1317 } 1318 done: 1319 if (softc->restart) { 1320 softc->restart = 0; 1321 xpt_release_ccb(done_ccb); 1322 aprobeschedule(periph); 1323 goto out; 1324 } 1325 xpt_release_ccb(done_ccb); 1326 CAM_DEBUG(periph->path, CAM_DEBUG_PROBE, ("Probe completed\n")); 1327 while ((done_ccb = (union ccb *)TAILQ_FIRST(&softc->request_ccbs))) { 1328 TAILQ_REMOVE(&softc->request_ccbs, 1329 &done_ccb->ccb_h, periph_links.tqe); 1330 done_ccb->ccb_h.status = found ? CAM_REQ_CMP : CAM_REQ_CMP_ERR; 1331 xpt_done(done_ccb); 1332 } 1333 /* Drop freeze taken due to CAM_DEV_QFREEZE flag set. */ 1334 cam_release_devq(path, 0, 0, 0, FALSE); 1335 cam_periph_invalidate(periph); 1336 cam_periph_release_locked(periph); 1337 } 1338 1339 static void 1340 aprobecleanup(struct cam_periph *periph) 1341 { 1342 free(periph->softc, M_CAMXPT); 1343 } 1344 1345 static void 1346 ata_find_quirk(struct cam_ed *device) 1347 { 1348 struct ata_quirk_entry *quirk; 1349 caddr_t match; 1350 1351 match = cam_quirkmatch((caddr_t)&device->ident_data, 1352 (caddr_t)ata_quirk_table, 1353 nitems(ata_quirk_table), 1354 sizeof(*ata_quirk_table), ata_identify_match); 1355 1356 if (match == NULL) 1357 panic("xpt_find_quirk: device didn't match wildcard entry!!"); 1358 1359 quirk = (struct ata_quirk_entry *)match; 1360 device->quirk = quirk; 1361 if (quirk->quirks & CAM_QUIRK_MAXTAGS) { 1362 device->mintags = quirk->mintags; 1363 device->maxtags = quirk->maxtags; 1364 } 1365 } 1366 1367 typedef struct { 1368 union ccb *request_ccb; 1369 struct ccb_pathinq *cpi; 1370 int counter; 1371 } ata_scan_bus_info; 1372 1373 /* 1374 * To start a scan, request_ccb is an XPT_SCAN_BUS ccb. 1375 * As the scan progresses, xpt_scan_bus is used as the 1376 * callback on completion function. 1377 */ 1378 static void 1379 ata_scan_bus(struct cam_periph *periph, union ccb *request_ccb) 1380 { 1381 struct cam_path *path; 1382 ata_scan_bus_info *scan_info; 1383 union ccb *work_ccb, *reset_ccb; 1384 struct mtx *mtx; 1385 cam_status status; 1386 1387 CAM_DEBUG(request_ccb->ccb_h.path, CAM_DEBUG_TRACE, 1388 ("xpt_scan_bus\n")); 1389 switch (request_ccb->ccb_h.func_code) { 1390 case XPT_SCAN_BUS: 1391 case XPT_SCAN_TGT: 1392 /* Find out the characteristics of the bus */ 1393 work_ccb = xpt_alloc_ccb_nowait(); 1394 if (work_ccb == NULL) { 1395 request_ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 1396 xpt_done(request_ccb); 1397 return; 1398 } 1399 xpt_path_inq(&work_ccb->cpi, request_ccb->ccb_h.path); 1400 if (work_ccb->ccb_h.status != CAM_REQ_CMP) { 1401 request_ccb->ccb_h.status = work_ccb->ccb_h.status; 1402 xpt_free_ccb(work_ccb); 1403 xpt_done(request_ccb); 1404 return; 1405 } 1406 1407 /* We may need to reset bus first, if we haven't done it yet. */ 1408 if ((work_ccb->cpi.hba_inquiry & 1409 (PI_WIDE_32|PI_WIDE_16|PI_SDTR_ABLE)) && 1410 !(work_ccb->cpi.hba_misc & PIM_NOBUSRESET) && 1411 !timevalisset(&request_ccb->ccb_h.path->bus->last_reset)) { 1412 reset_ccb = xpt_alloc_ccb_nowait(); 1413 if (reset_ccb == NULL) { 1414 request_ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 1415 xpt_free_ccb(work_ccb); 1416 xpt_done(request_ccb); 1417 return; 1418 } 1419 xpt_setup_ccb(&reset_ccb->ccb_h, request_ccb->ccb_h.path, 1420 CAM_PRIORITY_NONE); 1421 reset_ccb->ccb_h.func_code = XPT_RESET_BUS; 1422 xpt_action(reset_ccb); 1423 if (reset_ccb->ccb_h.status != CAM_REQ_CMP) { 1424 request_ccb->ccb_h.status = reset_ccb->ccb_h.status; 1425 xpt_free_ccb(reset_ccb); 1426 xpt_free_ccb(work_ccb); 1427 xpt_done(request_ccb); 1428 return; 1429 } 1430 xpt_free_ccb(reset_ccb); 1431 } 1432 1433 /* Save some state for use while we probe for devices */ 1434 scan_info = (ata_scan_bus_info *) 1435 malloc(sizeof(ata_scan_bus_info), M_CAMXPT, M_NOWAIT); 1436 if (scan_info == NULL) { 1437 request_ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 1438 xpt_free_ccb(work_ccb); 1439 xpt_done(request_ccb); 1440 return; 1441 } 1442 scan_info->request_ccb = request_ccb; 1443 scan_info->cpi = &work_ccb->cpi; 1444 /* If PM supported, probe it first. */ 1445 if (scan_info->cpi->hba_inquiry & PI_SATAPM) 1446 scan_info->counter = scan_info->cpi->max_target; 1447 else 1448 scan_info->counter = 0; 1449 1450 work_ccb = xpt_alloc_ccb_nowait(); 1451 if (work_ccb == NULL) { 1452 free(scan_info, M_CAMXPT); 1453 request_ccb->ccb_h.status = CAM_RESRC_UNAVAIL; 1454 xpt_done(request_ccb); 1455 break; 1456 } 1457 mtx = xpt_path_mtx(scan_info->request_ccb->ccb_h.path); 1458 goto scan_next; 1459 case XPT_SCAN_LUN: 1460 work_ccb = request_ccb; 1461 /* Reuse the same CCB to query if a device was really found */ 1462 scan_info = (ata_scan_bus_info *)work_ccb->ccb_h.ppriv_ptr0; 1463 mtx = xpt_path_mtx(scan_info->request_ccb->ccb_h.path); 1464 mtx_lock(mtx); 1465 /* If there is PMP... */ 1466 if ((scan_info->cpi->hba_inquiry & PI_SATAPM) && 1467 (scan_info->counter == scan_info->cpi->max_target)) { 1468 if (cam_ccb_success(work_ccb)) { 1469 /* everything else will be probed by it */ 1470 /* Free the current request path- we're done with it. */ 1471 xpt_free_path(work_ccb->ccb_h.path); 1472 goto done; 1473 } else { 1474 struct ccb_trans_settings cts; 1475 1476 /* Report SIM that PM is absent. */ 1477 bzero(&cts, sizeof(cts)); 1478 xpt_setup_ccb(&cts.ccb_h, 1479 work_ccb->ccb_h.path, CAM_PRIORITY_NONE); 1480 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 1481 cts.type = CTS_TYPE_CURRENT_SETTINGS; 1482 cts.xport_specific.sata.pm_present = 0; 1483 cts.xport_specific.sata.valid = CTS_SATA_VALID_PM; 1484 xpt_action((union ccb *)&cts); 1485 } 1486 } 1487 /* Free the current request path- we're done with it. */ 1488 xpt_free_path(work_ccb->ccb_h.path); 1489 if (scan_info->counter == 1490 ((scan_info->cpi->hba_inquiry & PI_SATAPM) ? 1491 0 : scan_info->cpi->max_target)) { 1492 done: 1493 mtx_unlock(mtx); 1494 xpt_free_ccb(work_ccb); 1495 xpt_free_ccb((union ccb *)scan_info->cpi); 1496 request_ccb = scan_info->request_ccb; 1497 free(scan_info, M_CAMXPT); 1498 request_ccb->ccb_h.status = CAM_REQ_CMP; 1499 xpt_done(request_ccb); 1500 break; 1501 } 1502 /* Take next device. Wrap from max (PMP) to 0. */ 1503 scan_info->counter = (scan_info->counter + 1 ) % 1504 (scan_info->cpi->max_target + 1); 1505 scan_next: 1506 status = xpt_create_path(&path, NULL, 1507 scan_info->request_ccb->ccb_h.path_id, 1508 scan_info->counter, 0); 1509 if (status != CAM_REQ_CMP) { 1510 if (request_ccb->ccb_h.func_code == XPT_SCAN_LUN) 1511 mtx_unlock(mtx); 1512 printf("xpt_scan_bus: xpt_create_path failed" 1513 " with status %#x, bus scan halted\n", 1514 status); 1515 xpt_free_ccb(work_ccb); 1516 xpt_free_ccb((union ccb *)scan_info->cpi); 1517 request_ccb = scan_info->request_ccb; 1518 free(scan_info, M_CAMXPT); 1519 request_ccb->ccb_h.status = status; 1520 xpt_done(request_ccb); 1521 break; 1522 } 1523 xpt_setup_ccb(&work_ccb->ccb_h, path, 1524 scan_info->request_ccb->ccb_h.pinfo.priority); 1525 work_ccb->ccb_h.func_code = XPT_SCAN_LUN; 1526 work_ccb->ccb_h.cbfcnp = ata_scan_bus; 1527 work_ccb->ccb_h.flags |= CAM_UNLOCKED; 1528 work_ccb->ccb_h.ppriv_ptr0 = scan_info; 1529 work_ccb->crcn.flags = scan_info->request_ccb->crcn.flags; 1530 mtx_unlock(mtx); 1531 if (request_ccb->ccb_h.func_code == XPT_SCAN_LUN) 1532 mtx = NULL; 1533 xpt_action(work_ccb); 1534 if (mtx != NULL) 1535 mtx_lock(mtx); 1536 break; 1537 default: 1538 break; 1539 } 1540 } 1541 1542 static void 1543 ata_scan_lun(struct cam_periph *periph, struct cam_path *path, 1544 cam_flags flags, union ccb *request_ccb) 1545 { 1546 struct ccb_pathinq cpi; 1547 cam_status status; 1548 struct cam_path *new_path; 1549 struct cam_periph *old_periph; 1550 int lock; 1551 1552 CAM_DEBUG(path, CAM_DEBUG_TRACE, ("xpt_scan_lun\n")); 1553 1554 xpt_path_inq(&cpi, path); 1555 if (cpi.ccb_h.status != CAM_REQ_CMP) { 1556 if (request_ccb != NULL) { 1557 request_ccb->ccb_h.status = cpi.ccb_h.status; 1558 xpt_done(request_ccb); 1559 } 1560 return; 1561 } 1562 1563 if (request_ccb == NULL) { 1564 request_ccb = xpt_alloc_ccb_nowait(); 1565 if (request_ccb == NULL) { 1566 xpt_print(path, "xpt_scan_lun: can't allocate CCB, " 1567 "can't continue\n"); 1568 return; 1569 } 1570 status = xpt_create_path(&new_path, NULL, 1571 path->bus->path_id, 1572 path->target->target_id, 1573 path->device->lun_id); 1574 if (status != CAM_REQ_CMP) { 1575 xpt_print(path, "xpt_scan_lun: can't create path, " 1576 "can't continue\n"); 1577 xpt_free_ccb(request_ccb); 1578 return; 1579 } 1580 xpt_setup_ccb(&request_ccb->ccb_h, new_path, CAM_PRIORITY_XPT); 1581 request_ccb->ccb_h.cbfcnp = axptscandone; 1582 request_ccb->ccb_h.flags |= CAM_UNLOCKED; 1583 request_ccb->ccb_h.func_code = XPT_SCAN_LUN; 1584 request_ccb->crcn.flags = flags; 1585 } 1586 1587 lock = (xpt_path_owned(path) == 0); 1588 if (lock) 1589 xpt_path_lock(path); 1590 if ((old_periph = cam_periph_find(path, "aprobe")) != NULL) { 1591 if ((old_periph->flags & CAM_PERIPH_INVALID) == 0) { 1592 aprobe_softc *softc; 1593 1594 softc = (aprobe_softc *)old_periph->softc; 1595 TAILQ_INSERT_TAIL(&softc->request_ccbs, 1596 &request_ccb->ccb_h, periph_links.tqe); 1597 softc->restart = 1; 1598 } else { 1599 request_ccb->ccb_h.status = CAM_REQ_CMP_ERR; 1600 xpt_done(request_ccb); 1601 } 1602 } else { 1603 status = cam_periph_alloc(aproberegister, NULL, aprobecleanup, 1604 aprobestart, "aprobe", 1605 CAM_PERIPH_BIO, 1606 request_ccb->ccb_h.path, NULL, 0, 1607 request_ccb); 1608 1609 if (status != CAM_REQ_CMP) { 1610 xpt_print(path, "xpt_scan_lun: cam_alloc_periph " 1611 "returned an error, can't continue probe\n"); 1612 request_ccb->ccb_h.status = status; 1613 xpt_done(request_ccb); 1614 } 1615 } 1616 if (lock) 1617 xpt_path_unlock(path); 1618 } 1619 1620 static void 1621 axptscandone(struct cam_periph *periph, union ccb *done_ccb) 1622 { 1623 1624 xpt_free_path(done_ccb->ccb_h.path); 1625 xpt_free_ccb(done_ccb); 1626 } 1627 1628 static struct cam_ed * 1629 ata_alloc_device(struct cam_eb *bus, struct cam_et *target, lun_id_t lun_id) 1630 { 1631 struct ata_quirk_entry *quirk; 1632 struct cam_ed *device; 1633 1634 device = xpt_alloc_device(bus, target, lun_id); 1635 if (device == NULL) 1636 return (NULL); 1637 1638 /* 1639 * Take the default quirk entry until we have inquiry 1640 * data and can determine a better quirk to use. 1641 */ 1642 quirk = &ata_quirk_table[nitems(ata_quirk_table) - 1]; 1643 device->quirk = (void *)quirk; 1644 device->mintags = 0; 1645 device->maxtags = 0; 1646 bzero(&device->inq_data, sizeof(device->inq_data)); 1647 device->inq_flags = 0; 1648 device->queue_flags = 0; 1649 device->serial_num = NULL; 1650 device->serial_num_len = 0; 1651 return (device); 1652 } 1653 1654 static void 1655 ata_device_transport(struct cam_path *path) 1656 { 1657 struct ccb_pathinq cpi; 1658 struct ccb_trans_settings cts; 1659 struct scsi_inquiry_data *inq_buf = NULL; 1660 struct ata_params *ident_buf = NULL; 1661 1662 /* Get transport information from the SIM */ 1663 xpt_path_inq(&cpi, path); 1664 1665 path->device->transport = cpi.transport; 1666 if ((path->device->flags & CAM_DEV_INQUIRY_DATA_VALID) != 0) 1667 inq_buf = &path->device->inq_data; 1668 if ((path->device->flags & CAM_DEV_IDENTIFY_DATA_VALID) != 0) 1669 ident_buf = &path->device->ident_data; 1670 if (path->device->protocol == PROTO_ATA) { 1671 path->device->protocol_version = ident_buf ? 1672 ata_version(ident_buf->version_major) : cpi.protocol_version; 1673 } else if (path->device->protocol == PROTO_SCSI) { 1674 path->device->protocol_version = inq_buf ? 1675 SID_ANSI_REV(inq_buf) : cpi.protocol_version; 1676 } 1677 path->device->transport_version = ident_buf ? 1678 ata_version(ident_buf->version_major) : cpi.transport_version; 1679 1680 /* Tell the controller what we think */ 1681 bzero(&cts, sizeof(cts)); 1682 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE); 1683 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS; 1684 cts.type = CTS_TYPE_CURRENT_SETTINGS; 1685 cts.transport = path->device->transport; 1686 cts.transport_version = path->device->transport_version; 1687 cts.protocol = path->device->protocol; 1688 cts.protocol_version = path->device->protocol_version; 1689 cts.proto_specific.valid = 0; 1690 if (ident_buf) { 1691 if (path->device->transport == XPORT_ATA) { 1692 cts.xport_specific.ata.atapi = 1693 (ident_buf->config == ATA_PROTO_CFA) ? 0 : 1694 ((ident_buf->config & ATA_PROTO_MASK) == ATA_PROTO_ATAPI_16) ? 16 : 1695 ((ident_buf->config & ATA_PROTO_MASK) == ATA_PROTO_ATAPI_12) ? 12 : 0; 1696 cts.xport_specific.ata.valid = CTS_ATA_VALID_ATAPI; 1697 } else { 1698 cts.xport_specific.sata.atapi = 1699 (ident_buf->config == ATA_PROTO_CFA) ? 0 : 1700 ((ident_buf->config & ATA_PROTO_MASK) == ATA_PROTO_ATAPI_16) ? 16 : 1701 ((ident_buf->config & ATA_PROTO_MASK) == ATA_PROTO_ATAPI_12) ? 12 : 0; 1702 cts.xport_specific.sata.valid = CTS_SATA_VALID_ATAPI; 1703 } 1704 } else 1705 cts.xport_specific.valid = 0; 1706 xpt_action((union ccb *)&cts); 1707 } 1708 1709 static void 1710 ata_dev_advinfo(union ccb *start_ccb) 1711 { 1712 struct cam_ed *device; 1713 struct ccb_dev_advinfo *cdai; 1714 off_t amt; 1715 1716 xpt_path_assert(start_ccb->ccb_h.path, MA_OWNED); 1717 start_ccb->ccb_h.status = CAM_REQ_INVALID; 1718 device = start_ccb->ccb_h.path->device; 1719 cdai = &start_ccb->cdai; 1720 switch(cdai->buftype) { 1721 case CDAI_TYPE_SCSI_DEVID: 1722 if (cdai->flags & CDAI_FLAG_STORE) 1723 return; 1724 cdai->provsiz = device->device_id_len; 1725 if (device->device_id_len == 0) 1726 break; 1727 amt = device->device_id_len; 1728 if (cdai->provsiz > cdai->bufsiz) 1729 amt = cdai->bufsiz; 1730 memcpy(cdai->buf, device->device_id, amt); 1731 break; 1732 case CDAI_TYPE_SERIAL_NUM: 1733 if (cdai->flags & CDAI_FLAG_STORE) 1734 return; 1735 cdai->provsiz = device->serial_num_len; 1736 if (device->serial_num_len == 0) 1737 break; 1738 amt = device->serial_num_len; 1739 if (cdai->provsiz > cdai->bufsiz) 1740 amt = cdai->bufsiz; 1741 memcpy(cdai->buf, device->serial_num, amt); 1742 break; 1743 case CDAI_TYPE_PHYS_PATH: 1744 if (cdai->flags & CDAI_FLAG_STORE) { 1745 if (device->physpath != NULL) { 1746 free(device->physpath, M_CAMXPT); 1747 device->physpath = NULL; 1748 device->physpath_len = 0; 1749 } 1750 /* Clear existing buffer if zero length */ 1751 if (cdai->bufsiz == 0) 1752 break; 1753 device->physpath = malloc(cdai->bufsiz, M_CAMXPT, M_NOWAIT); 1754 if (device->physpath == NULL) { 1755 start_ccb->ccb_h.status = CAM_REQ_ABORTED; 1756 return; 1757 } 1758 device->physpath_len = cdai->bufsiz; 1759 memcpy(device->physpath, cdai->buf, cdai->bufsiz); 1760 } else { 1761 cdai->provsiz = device->physpath_len; 1762 if (device->physpath_len == 0) 1763 break; 1764 amt = device->physpath_len; 1765 if (cdai->provsiz > cdai->bufsiz) 1766 amt = cdai->bufsiz; 1767 memcpy(cdai->buf, device->physpath, amt); 1768 } 1769 break; 1770 default: 1771 return; 1772 } 1773 start_ccb->ccb_h.status = CAM_REQ_CMP; 1774 1775 if (cdai->flags & CDAI_FLAG_STORE) { 1776 xpt_async(AC_ADVINFO_CHANGED, start_ccb->ccb_h.path, 1777 (void *)(uintptr_t)cdai->buftype); 1778 } 1779 } 1780 1781 static void 1782 ata_action(union ccb *start_ccb) 1783 { 1784 1785 if (start_ccb->ccb_h.func_code != XPT_ATA_IO) { 1786 KASSERT((start_ccb->ccb_h.alloc_flags & CAM_CCB_FROM_UMA) == 0, 1787 ("%s: ccb %p, func_code %#x should not be allocated " 1788 "from UMA zone\n", 1789 __func__, start_ccb, start_ccb->ccb_h.func_code)); 1790 } 1791 1792 switch (start_ccb->ccb_h.func_code) { 1793 case XPT_SET_TRAN_SETTINGS: 1794 { 1795 ata_set_transfer_settings(&start_ccb->cts, 1796 start_ccb->ccb_h.path, 1797 /*async_update*/FALSE); 1798 break; 1799 } 1800 case XPT_SCAN_BUS: 1801 case XPT_SCAN_TGT: 1802 ata_scan_bus(start_ccb->ccb_h.path->periph, start_ccb); 1803 break; 1804 case XPT_SCAN_LUN: 1805 ata_scan_lun(start_ccb->ccb_h.path->periph, 1806 start_ccb->ccb_h.path, start_ccb->crcn.flags, 1807 start_ccb); 1808 break; 1809 case XPT_GET_TRAN_SETTINGS: 1810 { 1811 ata_get_transfer_settings(&start_ccb->cts); 1812 break; 1813 } 1814 case XPT_SCSI_IO: 1815 { 1816 struct cam_ed *device; 1817 u_int maxlen = 0; 1818 1819 device = start_ccb->ccb_h.path->device; 1820 if (device->protocol == PROTO_SCSI && 1821 (device->flags & CAM_DEV_IDENTIFY_DATA_VALID)) { 1822 uint16_t p = 1823 device->ident_data.config & ATA_PROTO_MASK; 1824 1825 maxlen = 1826 (device->ident_data.config == ATA_PROTO_CFA) ? 0 : 1827 (p == ATA_PROTO_ATAPI_16) ? 16 : 1828 (p == ATA_PROTO_ATAPI_12) ? 12 : 0; 1829 } 1830 if (start_ccb->csio.cdb_len > maxlen) { 1831 start_ccb->ccb_h.status = CAM_REQ_INVALID; 1832 xpt_done(start_ccb); 1833 break; 1834 } 1835 xpt_action_default(start_ccb); 1836 break; 1837 } 1838 case XPT_DEV_ADVINFO: 1839 { 1840 ata_dev_advinfo(start_ccb); 1841 break; 1842 } 1843 default: 1844 xpt_action_default(start_ccb); 1845 break; 1846 } 1847 } 1848 1849 static void 1850 ata_get_transfer_settings(struct ccb_trans_settings *cts) 1851 { 1852 struct ccb_trans_settings_ata *ata; 1853 struct ccb_trans_settings_scsi *scsi; 1854 struct cam_ed *device; 1855 1856 device = cts->ccb_h.path->device; 1857 xpt_action_default((union ccb *)cts); 1858 1859 if (cts->protocol == PROTO_UNKNOWN || 1860 cts->protocol == PROTO_UNSPECIFIED) { 1861 cts->protocol = device->protocol; 1862 cts->protocol_version = device->protocol_version; 1863 } 1864 1865 if (cts->protocol == PROTO_ATA) { 1866 ata = &cts->proto_specific.ata; 1867 if ((ata->valid & CTS_ATA_VALID_TQ) == 0) { 1868 ata->valid |= CTS_ATA_VALID_TQ; 1869 if (cts->type == CTS_TYPE_USER_SETTINGS || 1870 (device->flags & CAM_DEV_TAG_AFTER_COUNT) != 0 || 1871 (device->inq_flags & SID_CmdQue) != 0) 1872 ata->flags |= CTS_ATA_FLAGS_TAG_ENB; 1873 } 1874 } 1875 if (cts->protocol == PROTO_SCSI) { 1876 scsi = &cts->proto_specific.scsi; 1877 if ((scsi->valid & CTS_SCSI_VALID_TQ) == 0) { 1878 scsi->valid |= CTS_SCSI_VALID_TQ; 1879 if (cts->type == CTS_TYPE_USER_SETTINGS || 1880 (device->flags & CAM_DEV_TAG_AFTER_COUNT) != 0 || 1881 (device->inq_flags & SID_CmdQue) != 0) 1882 scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB; 1883 } 1884 } 1885 1886 if (cts->transport == XPORT_UNKNOWN || 1887 cts->transport == XPORT_UNSPECIFIED) { 1888 cts->transport = device->transport; 1889 cts->transport_version = device->transport_version; 1890 } 1891 } 1892 1893 static void 1894 ata_set_transfer_settings(struct ccb_trans_settings *cts, struct cam_path *path, 1895 int async_update) 1896 { 1897 struct ccb_pathinq cpi; 1898 struct ccb_trans_settings_ata *ata; 1899 struct ccb_trans_settings_scsi *scsi; 1900 struct ata_params *ident_data; 1901 struct scsi_inquiry_data *inq_data; 1902 struct cam_ed *device; 1903 1904 if (path == NULL || (device = path->device) == NULL) { 1905 cts->ccb_h.status = CAM_PATH_INVALID; 1906 xpt_done((union ccb *)cts); 1907 return; 1908 } 1909 1910 if (cts->protocol == PROTO_UNKNOWN 1911 || cts->protocol == PROTO_UNSPECIFIED) { 1912 cts->protocol = device->protocol; 1913 cts->protocol_version = device->protocol_version; 1914 } 1915 1916 if (cts->protocol_version == PROTO_VERSION_UNKNOWN 1917 || cts->protocol_version == PROTO_VERSION_UNSPECIFIED) 1918 cts->protocol_version = device->protocol_version; 1919 1920 if (cts->protocol != device->protocol) { 1921 xpt_print(path, "Uninitialized Protocol %x:%x?\n", 1922 cts->protocol, device->protocol); 1923 cts->protocol = device->protocol; 1924 } 1925 1926 if (cts->protocol_version > device->protocol_version) { 1927 if (bootverbose) { 1928 xpt_print(path, "Down reving Protocol " 1929 "Version from %d to %d?\n", cts->protocol_version, 1930 device->protocol_version); 1931 } 1932 cts->protocol_version = device->protocol_version; 1933 } 1934 1935 if (cts->transport == XPORT_UNKNOWN 1936 || cts->transport == XPORT_UNSPECIFIED) { 1937 cts->transport = device->transport; 1938 cts->transport_version = device->transport_version; 1939 } 1940 1941 if (cts->transport_version == XPORT_VERSION_UNKNOWN 1942 || cts->transport_version == XPORT_VERSION_UNSPECIFIED) 1943 cts->transport_version = device->transport_version; 1944 1945 if (cts->transport != device->transport) { 1946 xpt_print(path, "Uninitialized Transport %x:%x?\n", 1947 cts->transport, device->transport); 1948 cts->transport = device->transport; 1949 } 1950 1951 if (cts->transport_version > device->transport_version) { 1952 if (bootverbose) { 1953 xpt_print(path, "Down reving Transport " 1954 "Version from %d to %d?\n", cts->transport_version, 1955 device->transport_version); 1956 } 1957 cts->transport_version = device->transport_version; 1958 } 1959 1960 ident_data = &device->ident_data; 1961 inq_data = &device->inq_data; 1962 if (cts->protocol == PROTO_ATA) 1963 ata = &cts->proto_specific.ata; 1964 else 1965 ata = NULL; 1966 if (cts->protocol == PROTO_SCSI) 1967 scsi = &cts->proto_specific.scsi; 1968 else 1969 scsi = NULL; 1970 xpt_path_inq(&cpi, path); 1971 1972 /* Sanity checking */ 1973 if ((cpi.hba_inquiry & PI_TAG_ABLE) == 0 1974 || (ata && (ident_data->satacapabilities & ATA_SUPPORT_NCQ) == 0) 1975 || (scsi && (INQ_DATA_TQ_ENABLED(inq_data)) == 0) 1976 || (device->queue_flags & SCP_QUEUE_DQUE) != 0 1977 || (device->mintags == 0)) { 1978 /* 1979 * Can't tag on hardware that doesn't support tags, 1980 * doesn't have it enabled, or has broken tag support. 1981 */ 1982 if (ata) 1983 ata->flags &= ~CTS_ATA_FLAGS_TAG_ENB; 1984 if (scsi) 1985 scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB; 1986 } 1987 1988 /* Start/stop tags use. */ 1989 if (cts->type == CTS_TYPE_CURRENT_SETTINGS && 1990 ((ata && (ata->valid & CTS_ATA_VALID_TQ) != 0) || 1991 (scsi && (scsi->valid & CTS_SCSI_VALID_TQ) != 0))) { 1992 int nowt, newt = 0; 1993 1994 nowt = ((device->flags & CAM_DEV_TAG_AFTER_COUNT) != 0 || 1995 (device->inq_flags & SID_CmdQue) != 0); 1996 if (ata) 1997 newt = (ata->flags & CTS_ATA_FLAGS_TAG_ENB) != 0; 1998 if (scsi) 1999 newt = (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) != 0; 2000 2001 if (newt && !nowt) { 2002 /* 2003 * Delay change to use tags until after a 2004 * few commands have gone to this device so 2005 * the controller has time to perform transfer 2006 * negotiations without tagged messages getting 2007 * in the way. 2008 */ 2009 device->tag_delay_count = CAM_TAG_DELAY_COUNT; 2010 device->flags |= CAM_DEV_TAG_AFTER_COUNT; 2011 } else if (nowt && !newt) 2012 xpt_stop_tags(path); 2013 } 2014 2015 if (async_update == FALSE) 2016 xpt_action_default((union ccb *)cts); 2017 } 2018 2019 /* 2020 * Handle any per-device event notifications that require action by the XPT. 2021 */ 2022 static void 2023 ata_dev_async(uint32_t async_code, struct cam_eb *bus, struct cam_et *target, 2024 struct cam_ed *device, void *async_arg) 2025 { 2026 /* 2027 * We only need to handle events for real devices. 2028 */ 2029 if (target->target_id == CAM_TARGET_WILDCARD || 2030 device->lun_id == CAM_LUN_WILDCARD) 2031 return; 2032 2033 switch (async_code) { 2034 case AC_SENT_BDR: 2035 case AC_BUS_RESET: 2036 case AC_INQ_CHANGED: { 2037 cam_status status; 2038 struct cam_path newpath; 2039 cam_flags flags; 2040 2041 /* 2042 * We need our own path with wildcards expanded to handle these 2043 * events. 2044 */ 2045 status = xpt_compile_path(&newpath, NULL, 2046 bus->path_id, 2047 target->target_id, 2048 device->lun_id); 2049 if (status != CAM_REQ_CMP) 2050 break; /* fail safe and just drop it */ 2051 2052 /* 2053 * For AC_INQ_CHANGED, we've sent a start unit command, or 2054 * something similar to a device that may have caused its 2055 * inquiry data to change. So we re-scan the device to refresh 2056 * the inquiry data for it, allowing changes. Otherwise we rescan 2057 * without allowing changes to respond to the reset, not allowing 2058 * changes. 2059 */ 2060 flags = async_code == AC_INQ_CHANGED ? CAM_EXPECT_INQ_CHANGE : 0; 2061 ata_scan_lun(newpath.periph, &newpath, flags, NULL); 2062 xpt_release_path(&newpath); 2063 break; 2064 } 2065 case AC_TRANSFER_NEG: { 2066 struct ccb_trans_settings *settings; 2067 struct cam_path path; 2068 2069 settings = (struct ccb_trans_settings *)async_arg; 2070 xpt_compile_path(&path, NULL, bus->path_id, target->target_id, 2071 device->lun_id); 2072 ata_set_transfer_settings(settings, &path, 2073 /*async_update*/TRUE); 2074 xpt_release_path(&path); 2075 break; 2076 } 2077 case AC_LOST_DEVICE: 2078 if ((device->flags & CAM_DEV_UNCONFIGURED) == 0) { 2079 device->flags |= CAM_DEV_UNCONFIGURED; 2080 xpt_release_device(device); 2081 } 2082 break; 2083 } 2084 } 2085 2086 static void 2087 _ata_announce_periph(struct cam_periph *periph, struct ccb_trans_settings *cts, u_int *speed) 2088 { 2089 struct ccb_pathinq cpi; 2090 struct cam_path *path = periph->path; 2091 2092 cam_periph_assert(periph, MA_OWNED); 2093 2094 xpt_setup_ccb(&cts->ccb_h, path, CAM_PRIORITY_NORMAL); 2095 cts->ccb_h.func_code = XPT_GET_TRAN_SETTINGS; 2096 cts->type = CTS_TYPE_CURRENT_SETTINGS; 2097 xpt_action((union ccb*)cts); 2098 if ((cts->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) 2099 return; 2100 /* Ask the SIM for its base transfer speed */ 2101 xpt_path_inq(&cpi, path); 2102 /* Report connection speed */ 2103 *speed = cpi.base_transfer_speed; 2104 if (cts->transport == XPORT_ATA) { 2105 struct ccb_trans_settings_pata *pata = 2106 &cts->xport_specific.ata; 2107 2108 if (pata->valid & CTS_ATA_VALID_MODE) 2109 *speed = ata_mode2speed(pata->mode); 2110 } 2111 if (cts->transport == XPORT_SATA) { 2112 struct ccb_trans_settings_sata *sata = 2113 &cts->xport_specific.sata; 2114 2115 if (sata->valid & CTS_SATA_VALID_REVISION) 2116 *speed = ata_revision2speed(sata->revision); 2117 } 2118 } 2119 2120 static void 2121 ata_announce_periph_sbuf(struct cam_periph *periph, struct sbuf *sb) 2122 { 2123 struct ccb_trans_settings cts; 2124 u_int speed, mb; 2125 2126 bzero(&cts, sizeof(cts)); 2127 _ata_announce_periph(periph, &cts, &speed); 2128 if ((cts.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) 2129 return; 2130 2131 mb = speed / 1000; 2132 if (mb > 0) 2133 sbuf_printf(sb, "%s%d: %d.%03dMB/s transfers", 2134 periph->periph_name, periph->unit_number, 2135 mb, speed % 1000); 2136 else 2137 sbuf_printf(sb, "%s%d: %dKB/s transfers", periph->periph_name, 2138 periph->unit_number, speed); 2139 /* Report additional information about connection */ 2140 if (cts.transport == XPORT_ATA) { 2141 struct ccb_trans_settings_pata *pata = 2142 &cts.xport_specific.ata; 2143 2144 sbuf_cat(sb, " ("); 2145 if (pata->valid & CTS_ATA_VALID_MODE) 2146 sbuf_printf(sb, "%s, ", ata_mode2string(pata->mode)); 2147 if ((pata->valid & CTS_ATA_VALID_ATAPI) && pata->atapi != 0) 2148 sbuf_printf(sb, "ATAPI %dbytes, ", pata->atapi); 2149 if (pata->valid & CTS_ATA_VALID_BYTECOUNT) 2150 sbuf_printf(sb, "PIO %dbytes", pata->bytecount); 2151 sbuf_putc(sb, ')'); 2152 } 2153 if (cts.transport == XPORT_SATA) { 2154 struct ccb_trans_settings_sata *sata = 2155 &cts.xport_specific.sata; 2156 2157 sbuf_cat(sb, " ("); 2158 if (sata->valid & CTS_SATA_VALID_REVISION) 2159 sbuf_printf(sb, "SATA %d.x, ", sata->revision); 2160 else 2161 sbuf_cat(sb, "SATA, "); 2162 if (sata->valid & CTS_SATA_VALID_MODE) 2163 sbuf_printf(sb, "%s, ", ata_mode2string(sata->mode)); 2164 if ((sata->valid & CTS_ATA_VALID_ATAPI) && sata->atapi != 0) 2165 sbuf_printf(sb, "ATAPI %dbytes, ", sata->atapi); 2166 if (sata->valid & CTS_SATA_VALID_BYTECOUNT) 2167 sbuf_printf(sb, "PIO %dbytes", sata->bytecount); 2168 sbuf_putc(sb, ')'); 2169 } 2170 sbuf_putc(sb, '\n'); 2171 } 2172 2173 static void 2174 ata_proto_announce_sbuf(struct cam_ed *device, struct sbuf *sb) 2175 { 2176 ata_print_ident_sbuf(&device->ident_data, sb); 2177 } 2178 2179 static void 2180 ata_proto_denounce_sbuf(struct cam_ed *device, struct sbuf *sb) 2181 { 2182 ata_print_ident_short_sbuf(&device->ident_data, sb); 2183 } 2184 2185 static void 2186 semb_proto_announce_sbuf(struct cam_ed *device, struct sbuf *sb) 2187 { 2188 semb_print_ident_sbuf((struct sep_identify_data *)&device->ident_data, sb); 2189 } 2190 2191 static void 2192 semb_proto_denounce_sbuf(struct cam_ed *device, struct sbuf *sb) 2193 { 2194 semb_print_ident_short_sbuf((struct sep_identify_data *)&device->ident_data, sb); 2195 } 2196 2197 static void 2198 ata_proto_debug_out(union ccb *ccb) 2199 { 2200 char cdb_str[(sizeof(struct ata_cmd) * 3) + 1]; 2201 2202 if (ccb->ccb_h.func_code != XPT_ATA_IO) 2203 return; 2204 2205 CAM_DEBUG(ccb->ccb_h.path, 2206 CAM_DEBUG_CDB,("%s. ACB: %s\n", ata_op_string(&ccb->ataio.cmd), 2207 ata_cmd_string(&ccb->ataio.cmd, cdb_str, sizeof(cdb_str)))); 2208 } 2209