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