sys/cam/ata/ata_xpt.c

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