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