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 aprobe_periph_init;
  75
  76 static struct periph_driver aprobe_driver =
  77 {
  78         aprobe_periph_init, "aprobe",
  79         TAILQ_HEAD_INITIALIZER(aprobe_driver.units), /* generation */ 0,
  80         CAM_PERIPH_DRV_EARLY
  81 };
  82
  83 PERIPHDRIVER_DECLARE(aprobe, aprobe_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 } aprobe_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 } aprobe_flags;
 138
 139 typedef struct {
 140         TAILQ_HEAD(, ccb_hdr) request_ccbs;
 141         struct ata_params       ident_data;
 142         aprobe_action   action;
 143         aprobe_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       aproberegister(struct cam_periph *periph, void *arg);
 166 static void      aprobeschedule(struct cam_periph *probe_periph);
 167 static void      aprobestart(struct cam_periph *periph, union ccb *start_ccb);
 168 static void      aproberequestdefaultnegotiation(struct cam_periph *periph);
 169 static void      aprobedone(struct cam_periph *periph, union ccb *done_ccb);
 170 static void      aprobecleanup(struct cam_periph *periph);
 171 static void      ata_find_quirk(struct cam_ed *device);
 172 static void      ata_scan_bus(struct cam_periph *periph, union ccb *ccb);
 173 static void      ata_scan_lun(struct cam_periph *periph,
 174                                struct cam_path *path, cam_flags flags,
 175                                union ccb *ccb);
 176 static void      axptscandone(struct cam_periph *periph, union ccb *done_ccb);
 177 static struct cam_ed *
 178                  ata_alloc_device(struct cam_eb *bus, struct cam_et *target,
 179                                    lun_id_t lun_id);
 180 static void      ata_device_transport(struct cam_path *path);
 181 static void      ata_get_transfer_settings(struct ccb_trans_settings *cts);
 182 static void      ata_set_transfer_settings(struct ccb_trans_settings *cts,
 183                                             struct cam_path *path,
 184                                             int async_update);
 185 static void      ata_dev_async(u_int32_t async_code,
 186                                 struct cam_eb *bus,
 187                                 struct cam_et *target,
 188                                 struct cam_ed *device,
 189                                 void *async_arg);
 190 static void      ata_action(union ccb *start_ccb);
 191 static void      ata_announce_periph(struct cam_periph *periph);
 192 static void      ata_announce_periph_sbuf(struct cam_periph *periph, struct sbuf *sb);
 193 static void      ata_proto_announce(struct cam_ed *device);
 194 static void      ata_proto_announce_sbuf(struct cam_ed *device, struct sbuf *sb);
 195 static void      ata_proto_denounce(struct cam_ed *device);
 196 static void      ata_proto_denounce_sbuf(struct cam_ed *device, struct sbuf *sb);
 197 static void      ata_proto_debug_out(union ccb *ccb);
 198 static void      semb_proto_announce(struct cam_ed *device);
 199 static void      semb_proto_announce_sbuf(struct cam_ed *device, struct sbuf *sb);
 200 static void      semb_proto_denounce(struct cam_ed *device);
 201 static void      semb_proto_denounce_sbuf(struct cam_ed *device, struct sbuf *sb);
 202
 203 static int ata_dma = 1;
 204 static int atapi_dma = 1;
 205
 206 TUNABLE_INT("hw.ata.ata_dma", &ata_dma);
 207 TUNABLE_INT("hw.ata.atapi_dma", &atapi_dma);
 208
 209 static struct xpt_xport_ops ata_xport_ops = {
 210         .alloc_device = ata_alloc_device,
 211         .action = ata_action,
 212         .async = ata_dev_async,
 213         .announce = ata_announce_periph,
 214         .announce_sbuf = ata_announce_periph_sbuf,
 215 };
 216 #define ATA_XPT_XPORT(x, X)                     \
 217 static struct xpt_xport ata_xport_ ## x = {     \
 218         .xport = XPORT_ ## X,                   \
 219         .name = #x,                             \
 220         .ops = &ata_xport_ops,                  \
 221 };                                              \
 222 CAM_XPT_XPORT(ata_xport_ ## x);
 223
 224 ATA_XPT_XPORT(ata, ATA);
 225 ATA_XPT_XPORT(sata, SATA);
 226
 227 #undef ATA_XPORT_XPORT
 228
 229 static struct xpt_proto_ops ata_proto_ops_ata = {
 230         .announce = ata_proto_announce,
 231         .announce_sbuf = ata_proto_announce_sbuf,
 232         .denounce = ata_proto_denounce,
 233         .denounce_sbuf = ata_proto_denounce_sbuf,
 234         .debug_out = ata_proto_debug_out,
 235 };
 236 static struct xpt_proto ata_proto_ata = {
 237         .proto = PROTO_ATA,
 238         .name = "ata",
 239         .ops = &ata_proto_ops_ata,
 240 };
 241
 242 static struct xpt_proto_ops ata_proto_ops_satapm = {
 243         .announce = ata_proto_announce,
 244         .announce_sbuf = ata_proto_announce_sbuf,
 245         .denounce = ata_proto_denounce,
 246         .denounce_sbuf = ata_proto_denounce_sbuf,
 247         .debug_out = ata_proto_debug_out,
 248 };
 249 static struct xpt_proto ata_proto_satapm = {
 250         .proto = PROTO_SATAPM,
 251         .name = "satapm",
 252         .ops = &ata_proto_ops_satapm,
 253 };
 254
 255 static struct xpt_proto_ops ata_proto_ops_semb = {
 256         .announce = semb_proto_announce,
 257         .announce_sbuf = semb_proto_announce_sbuf,
 258         .denounce = semb_proto_denounce,
 259         .denounce_sbuf = semb_proto_denounce_sbuf,
 260         .debug_out = ata_proto_debug_out,
 261 };
 262 static struct xpt_proto ata_proto_semb = {
 263         .proto = PROTO_SEMB,
 264         .name = "semb",
 265         .ops = &ata_proto_ops_semb,
 266 };
 267
 268 CAM_XPT_PROTO(ata_proto_ata);
 269 CAM_XPT_PROTO(ata_proto_satapm);
 270 CAM_XPT_PROTO(ata_proto_semb);
 271
 272 static void
 273 aprobe_periph_init(void)
 274 {
 275 }
 276
 277 static cam_status
 278 aproberegister(struct cam_periph *periph, void *arg)
 279 {
 280         union ccb *request_ccb; /* CCB representing the probe request */
 281         probe_softc *softc;
 282
 283         request_ccb = (union ccb *)arg;
 284         if (request_ccb == NULL) {
 285                 printf("proberegister: no probe CCB, "
 286                        "can't register device\n");
 287                 return(CAM_REQ_CMP_ERR);
 288         }
 289
 290         softc = (probe_softc *)malloc(sizeof(*softc), M_CAMXPT, M_ZERO | M_NOWAIT);
 291
 292         if (softc == NULL) {
 293                 printf("proberegister: Unable to probe new device. "
 294                        "Unable to allocate softc\n");
 295                 return(CAM_REQ_CMP_ERR);
 296         }
 297         TAILQ_INIT(&softc->request_ccbs);
 298         TAILQ_INSERT_TAIL(&softc->request_ccbs, &request_ccb->ccb_h,
 299                           periph_links.tqe);
 300         softc->flags = 0;
 301         periph->softc = softc;
 302         softc->periph = periph;
 303         softc->action = PROBE_INVALID;
 304         if (cam_periph_acquire(periph) != 0)
 305                 return (CAM_REQ_CMP_ERR);
 306
 307         CAM_DEBUG(periph->path, CAM_DEBUG_PROBE, ("Probe started\n"));
 308         ata_device_transport(periph->path);
 309         aprobeschedule(periph);
 310         return(CAM_REQ_CMP);
 311 }
 312
 313 static void
 314 aprobeschedule(struct cam_periph *periph)
 315 {
 316         union ccb *ccb;
 317         probe_softc *softc;
 318
 319         softc = (probe_softc *)periph->softc;
 320         ccb = (union ccb *)TAILQ_FIRST(&softc->request_ccbs);
 321
 322         if ((periph->path->device->flags & CAM_DEV_UNCONFIGURED) ||
 323             periph->path->device->protocol == PROTO_SATAPM ||
 324             periph->path->device->protocol == PROTO_SEMB)
 325                 PROBE_SET_ACTION(softc, PROBE_RESET);
 326         else
 327                 PROBE_SET_ACTION(softc, PROBE_IDENTIFY);
 328
 329         if (ccb->crcn.flags & CAM_EXPECT_INQ_CHANGE)
 330                 softc->flags |= PROBE_NO_ANNOUNCE;
 331         else
 332                 softc->flags &= ~PROBE_NO_ANNOUNCE;
 333
 334         xpt_schedule(periph, CAM_PRIORITY_XPT);
 335 }
 336
 337 static void
 338 aprobestart(struct cam_periph *periph, union ccb *start_ccb)
 339 {
 340         struct ccb_trans_settings cts;
 341         struct ccb_ataio *ataio;
 342         struct ccb_scsiio *csio;
 343         probe_softc *softc;
 344         struct cam_path *path;
 345         struct ata_params *ident_buf;
 346         u_int oif;
 347
 348         CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("aprobestart\n"));
 349
 350         softc = (probe_softc *)periph->softc;
 351         path = start_ccb->ccb_h.path;
 352         ataio = &start_ccb->ataio;
 353         csio = &start_ccb->csio;
 354         ident_buf = &periph->path->device->ident_data;
 355
 356         if (softc->restart) {
 357                 softc->restart = 0;
 358                 if ((path->device->flags & CAM_DEV_UNCONFIGURED) ||
 359                     path->device->protocol == PROTO_SATAPM ||
 360                     path->device->protocol == PROTO_SEMB)
 361                         softc->action = PROBE_RESET;
 362                 else
 363                         softc->action = PROBE_IDENTIFY;
 364         }
 365         switch (softc->action) {
 366         case PROBE_RESET:
 367                 cam_fill_ataio(ataio,
 368                       0,
 369                       aprobedone,
 370                       /*flags*/CAM_DIR_NONE,
 371                       0,
 372                       /*data_ptr*/NULL,
 373                       /*dxfer_len*/0,
 374                       15 * 1000);
 375                 ata_reset_cmd(ataio);
 376                 break;
 377         case PROBE_IDENTIFY:
 378                 cam_fill_ataio(ataio,
 379                       1,
 380                       aprobedone,
 381                       /*flags*/CAM_DIR_IN,
 382                       0,
 383                       /*data_ptr*/(u_int8_t *)&softc->ident_data,
 384                       /*dxfer_len*/sizeof(softc->ident_data),
 385                       30 * 1000);
 386                 if (path->device->protocol == PROTO_ATA)
 387                         ata_28bit_cmd(ataio, ATA_ATA_IDENTIFY, 0, 0, 0);
 388                 else
 389                         ata_28bit_cmd(ataio, ATA_ATAPI_IDENTIFY, 0, 0, 0);
 390                 break;
 391         case PROBE_SPINUP:
 392                 if (bootverbose)
 393                         xpt_print(path, "Spinning up device\n");
 394                 cam_fill_ataio(ataio,
 395                       1,
 396                       aprobedone,
 397                       /*flags*/CAM_DIR_NONE | CAM_HIGH_POWER,
 398                       0,
 399                       /*data_ptr*/NULL,
 400                       /*dxfer_len*/0,
 401                       30 * 1000);
 402                 ata_28bit_cmd(ataio, ATA_SETFEATURES, ATA_SF_PUIS_SPINUP, 0, 0);
 403                 break;
 404         case PROBE_SETMODE:
 405         {
 406                 int mode, wantmode;
 407
 408                 mode = 0;
 409                 /* Fetch user modes from SIM. */
 410                 bzero(&cts, sizeof(cts));
 411                 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE);
 412                 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 413                 cts.type = CTS_TYPE_USER_SETTINGS;
 414                 xpt_action((union ccb *)&cts);
 415                 if (path->device->transport == XPORT_ATA) {
 416                         if (cts.xport_specific.ata.valid & CTS_ATA_VALID_MODE)
 417                                 mode = cts.xport_specific.ata.mode;
 418                 } else {
 419                         if (cts.xport_specific.sata.valid & CTS_SATA_VALID_MODE)
 420                                 mode = cts.xport_specific.sata.mode;
 421                 }
 422                 if (path->device->protocol == PROTO_ATA) {
 423                         if (ata_dma == 0 && (mode == 0 || mode > ATA_PIO_MAX))
 424                                 mode = ATA_PIO_MAX;
 425                 } else {
 426                         if (atapi_dma == 0 && (mode == 0 || mode > ATA_PIO_MAX))
 427                                 mode = ATA_PIO_MAX;
 428                 }
 429 negotiate:
 430                 /* Honor device capabilities. */
 431                 wantmode = mode = ata_max_mode(ident_buf, mode);
 432                 /* Report modes to SIM. */
 433                 bzero(&cts, sizeof(cts));
 434                 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE);
 435                 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
 436                 cts.type = CTS_TYPE_CURRENT_SETTINGS;
 437                 if (path->device->transport == XPORT_ATA) {
 438                         cts.xport_specific.ata.mode = mode;
 439                         cts.xport_specific.ata.valid = CTS_ATA_VALID_MODE;
 440                 } else {
 441                         cts.xport_specific.sata.mode = mode;
 442                         cts.xport_specific.sata.valid = CTS_SATA_VALID_MODE;
 443                 }
 444                 xpt_action((union ccb *)&cts);
 445                 /* Fetch current modes from SIM. */
 446                 bzero(&cts, sizeof(cts));
 447                 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE);
 448                 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 449                 cts.type = CTS_TYPE_CURRENT_SETTINGS;
 450                 xpt_action((union ccb *)&cts);
 451                 if (path->device->transport == XPORT_ATA) {
 452                         if (cts.xport_specific.ata.valid & CTS_ATA_VALID_MODE)
 453                                 mode = cts.xport_specific.ata.mode;
 454                 } else {
 455                         if (cts.xport_specific.sata.valid & CTS_SATA_VALID_MODE)
 456                                 mode = cts.xport_specific.sata.mode;
 457                 }
 458                 /* If SIM disagree - renegotiate. */
 459                 if (mode != wantmode)
 460                         goto negotiate;
 461                 /* Remember what transport thinks about DMA. */
 462                 oif = path->device->inq_flags;
 463                 if (mode < ATA_DMA)
 464                         path->device->inq_flags &= ~SID_DMA;
 465                 else
 466                         path->device->inq_flags |= SID_DMA;
 467                 if (path->device->inq_flags != oif)
 468                         xpt_async(AC_GETDEV_CHANGED, path, NULL);
 469                 cam_fill_ataio(ataio,
 470                       1,
 471                       aprobedone,
 472                       /*flags*/CAM_DIR_NONE,
 473                       0,
 474                       /*data_ptr*/NULL,
 475                       /*dxfer_len*/0,
 476                       30 * 1000);
 477                 ata_28bit_cmd(ataio, ATA_SETFEATURES, ATA_SF_SETXFER, 0, mode);
 478                 break;
 479         }
 480         case PROBE_SETPM:
 481                 cam_fill_ataio(ataio,
 482                     1,
 483                     aprobedone,
 484                     CAM_DIR_NONE,
 485                     0,
 486                     NULL,
 487                     0,
 488                     30*1000);
 489                 ata_28bit_cmd(ataio, ATA_SETFEATURES,
 490                     (softc->caps & CTS_SATA_CAPS_H_PMREQ) ? 0x10 : 0x90,
 491                     0, 0x03);
 492                 break;
 493         case PROBE_SETAPST:
 494                 cam_fill_ataio(ataio,
 495                     1,
 496                     aprobedone,
 497                     CAM_DIR_NONE,
 498                     0,
 499                     NULL,
 500                     0,
 501                     30*1000);
 502                 ata_28bit_cmd(ataio, ATA_SETFEATURES,
 503                     (softc->caps & CTS_SATA_CAPS_H_APST) ? 0x10 : 0x90,
 504                     0, 0x07);
 505                 break;
 506         case PROBE_SETDMAAA:
 507                 cam_fill_ataio(ataio,
 508                     1,
 509                     aprobedone,
 510                     CAM_DIR_NONE,
 511                     0,
 512                     NULL,
 513                     0,
 514                     30*1000);
 515                 ata_28bit_cmd(ataio, ATA_SETFEATURES,
 516                     (softc->caps & CTS_SATA_CAPS_H_DMAAA) ? 0x10 : 0x90,
 517                     0, 0x02);
 518                 break;
 519         case PROBE_SETAN:
 520                 /* Remember what transport thinks about AEN. */
 521                 oif = path->device->inq_flags;
 522                 if (softc->caps & CTS_SATA_CAPS_H_AN)
 523                         path->device->inq_flags |= SID_AEN;
 524                 else
 525                         path->device->inq_flags &= ~SID_AEN;
 526                 if (path->device->inq_flags != oif)
 527                         xpt_async(AC_GETDEV_CHANGED, path, NULL);
 528                 cam_fill_ataio(ataio,
 529                     1,
 530                     aprobedone,
 531                     CAM_DIR_NONE,
 532                     0,
 533                     NULL,
 534                     0,
 535                     30*1000);
 536                 ata_28bit_cmd(ataio, ATA_SETFEATURES,
 537                     (softc->caps & CTS_SATA_CAPS_H_AN) ? 0x10 : 0x90,
 538                     0, 0x05);
 539                 break;
 540         case PROBE_SET_MULTI:
 541         {
 542                 u_int sectors, bytecount;
 543
 544                 bytecount = 8192;       /* SATA maximum */
 545                 /* Fetch user bytecount from SIM. */
 546                 bzero(&cts, sizeof(cts));
 547                 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE);
 548                 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 549                 cts.type = CTS_TYPE_USER_SETTINGS;
 550                 xpt_action((union ccb *)&cts);
 551                 if (path->device->transport == XPORT_ATA) {
 552                         if (cts.xport_specific.ata.valid & CTS_ATA_VALID_BYTECOUNT)
 553                                 bytecount = cts.xport_specific.ata.bytecount;
 554                 } else {
 555                         if (cts.xport_specific.sata.valid & CTS_SATA_VALID_BYTECOUNT)
 556                                 bytecount = cts.xport_specific.sata.bytecount;
 557                 }
 558                 /* Honor device capabilities. */
 559                 sectors = max(1, min(ident_buf->sectors_intr & 0xff,
 560                     bytecount / ata_logical_sector_size(ident_buf)));
 561                 /* Report bytecount to SIM. */
 562                 bzero(&cts, sizeof(cts));
 563                 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE);
 564                 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
 565                 cts.type = CTS_TYPE_CURRENT_SETTINGS;
 566                 if (path->device->transport == XPORT_ATA) {
 567                         cts.xport_specific.ata.bytecount = sectors *
 568                             ata_logical_sector_size(ident_buf);
 569                         cts.xport_specific.ata.valid = CTS_ATA_VALID_BYTECOUNT;
 570                 } else {
 571                         cts.xport_specific.sata.bytecount = sectors *
 572                             ata_logical_sector_size(ident_buf);
 573                         cts.xport_specific.sata.valid = CTS_SATA_VALID_BYTECOUNT;
 574                 }
 575                 xpt_action((union ccb *)&cts);
 576                 /* Fetch current bytecount from SIM. */
 577                 bzero(&cts, sizeof(cts));
 578                 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE);
 579                 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 580                 cts.type = CTS_TYPE_CURRENT_SETTINGS;
 581                 xpt_action((union ccb *)&cts);
 582                 if (path->device->transport == XPORT_ATA) {
 583                         if (cts.xport_specific.ata.valid & CTS_ATA_VALID_BYTECOUNT)
 584                                 bytecount = cts.xport_specific.ata.bytecount;
 585                 } else {
 586                         if (cts.xport_specific.sata.valid & CTS_SATA_VALID_BYTECOUNT)
 587                                 bytecount = cts.xport_specific.sata.bytecount;
 588                 }
 589                 sectors = bytecount / ata_logical_sector_size(ident_buf);
 590
 591                 cam_fill_ataio(ataio,
 592                     1,
 593                     aprobedone,
 594                     CAM_DIR_NONE,
 595                     0,
 596                     NULL,
 597                     0,
 598                     30*1000);
 599                 ata_28bit_cmd(ataio, ATA_SET_MULTI, 0, 0, sectors);
 600                 break;
 601         }
 602         case PROBE_INQUIRY:
 603         {
 604                 u_int bytecount;
 605
 606                 bytecount = 8192;       /* SATA maximum */
 607                 /* Fetch user bytecount from SIM. */
 608                 bzero(&cts, sizeof(cts));
 609                 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE);
 610                 cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 611                 cts.type = CTS_TYPE_USER_SETTINGS;
 612                 xpt_action((union ccb *)&cts);
 613                 if (path->device->transport == XPORT_ATA) {
 614                         if (cts.xport_specific.ata.valid & CTS_ATA_VALID_BYTECOUNT)
 615                                 bytecount = cts.xport_specific.ata.bytecount;
 616                 } else {
 617                         if (cts.xport_specific.sata.valid & CTS_SATA_VALID_BYTECOUNT)
 618                                 bytecount = cts.xport_specific.sata.bytecount;
 619                 }
 620                 /* Honor device capabilities. */
 621                 bytecount &= ~1;
 622                 bytecount = max(2, min(65534, bytecount));
 623                 if (ident_buf->satacapabilities != 0x0000 &&
 624                     ident_buf->satacapabilities != 0xffff) {
 625                         bytecount = min(8192, bytecount);
 626                 }
 627                 /* Report bytecount to SIM. */
 628                 bzero(&cts, sizeof(cts));
 629                 xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE);
 630                 cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
 631                 cts.type = CTS_TYPE_CURRENT_SETTINGS;
 632                 if (path->device->transport == XPORT_ATA) {
 633                         cts.xport_specific.ata.bytecount = bytecount;
 634                         cts.xport_specific.ata.valid = CTS_ATA_VALID_BYTECOUNT;
 635                 } else {
 636                         cts.xport_specific.sata.bytecount = bytecount;
 637                         cts.xport_specific.sata.valid = CTS_SATA_VALID_BYTECOUNT;
 638                 }
 639                 xpt_action((union ccb *)&cts);
 640                 /* FALLTHROUGH */
 641         }
 642         case PROBE_FULL_INQUIRY:
 643         {
 644                 u_int inquiry_len;
 645                 struct scsi_inquiry_data *inq_buf =
 646                     &path->device->inq_data;
 647
 648                 if (softc->action == PROBE_INQUIRY)
 649                         inquiry_len = SHORT_INQUIRY_LENGTH;
 650                 else
 651                         inquiry_len = SID_ADDITIONAL_LENGTH(inq_buf);
 652                 /*
 653                  * Some parallel SCSI devices fail to send an
 654                  * ignore wide residue message when dealing with
 655                  * odd length inquiry requests.  Round up to be
 656                  * safe.
 657                  */
 658                 inquiry_len = roundup2(inquiry_len, 2);
 659                 scsi_inquiry(csio,
 660                              /*retries*/1,
 661                              aprobedone,
 662                              MSG_SIMPLE_Q_TAG,
 663                              (u_int8_t *)inq_buf,
 664                              inquiry_len,
 665                              /*evpd*/FALSE,
 666                              /*page_code*/0,
 667                              SSD_MIN_SIZE,
 668                              /*timeout*/60 * 1000);
 669                 break;
 670         }
 671         case PROBE_PM_PID:
 672                 cam_fill_ataio(ataio,
 673                       1,
 674                       aprobedone,
 675                       /*flags*/CAM_DIR_NONE,
 676                       0,
 677                       /*data_ptr*/NULL,
 678                       /*dxfer_len*/0,
 679                       10 * 1000);
 680                 ata_pm_read_cmd(ataio, 0, 15);
 681                 break;
 682         case PROBE_PM_PRV:
 683                 cam_fill_ataio(ataio,
 684                       1,
 685                       aprobedone,
 686                       /*flags*/CAM_DIR_NONE,
 687                       0,
 688                       /*data_ptr*/NULL,
 689                       /*dxfer_len*/0,
 690                       10 * 1000);
 691                 ata_pm_read_cmd(ataio, 1, 15);
 692                 break;
 693         case PROBE_IDENTIFY_SES:
 694                 cam_fill_ataio(ataio,
 695                       1,
 696                       aprobedone,
 697                       /*flags*/CAM_DIR_IN,
 698                       0,
 699                       /*data_ptr*/(u_int8_t *)&softc->ident_data,
 700                       /*dxfer_len*/sizeof(softc->ident_data),
 701                       30 * 1000);
 702                 ata_28bit_cmd(ataio, ATA_SEP_ATTN, 0xEC, 0x02,
 703                     sizeof(softc->ident_data) / 4);
 704                 break;
 705         case PROBE_IDENTIFY_SAFTE:
 706                 cam_fill_ataio(ataio,
 707                       1,
 708                       aprobedone,
 709                       /*flags*/CAM_DIR_IN,
 710                       0,
 711                       /*data_ptr*/(u_int8_t *)&softc->ident_data,
 712                       /*dxfer_len*/sizeof(softc->ident_data),
 713                       30 * 1000);
 714                 ata_28bit_cmd(ataio, ATA_SEP_ATTN, 0xEC, 0x00,
 715                     sizeof(softc->ident_data) / 4);
 716                 break;
 717         default:
 718                 panic("aprobestart: invalid action state 0x%x\n", softc->action);
 719         }
 720         start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
 721         xpt_action(start_ccb);
 722 }
 723
 724 static void
 725 aproberequestdefaultnegotiation(struct cam_periph *periph)
 726 {
 727         struct ccb_trans_settings cts;
 728
 729         bzero(&cts, sizeof(cts));
 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 aprobedone(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, ("aprobedone\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                         aproberequestdefaultnegotiation(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                         aproberequestdefaultnegotiation(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                         aproberequestdefaultnegotiation(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("aprobedone: 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                 aprobeschedule(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 aprobecleanup(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 = axptscandone;
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(aproberegister, NULL, aprobecleanup,
1620                                           aprobestart, "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 axptscandone(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         bzero(&cts, sizeof(cts));
1698         xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE);
1699         cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
1700         cts.type = CTS_TYPE_CURRENT_SETTINGS;
1701         cts.transport = path->device->transport;
1702         cts.transport_version = path->device->transport_version;
1703         cts.protocol = path->device->protocol;
1704         cts.protocol_version = path->device->protocol_version;
1705         cts.proto_specific.valid = 0;
1706         if (ident_buf) {
1707                 if (path->device->transport == XPORT_ATA) {
1708                         cts.xport_specific.ata.atapi =
1709                             (ident_buf->config == ATA_PROTO_CFA) ? 0 :
1710                             ((ident_buf->config & ATA_PROTO_MASK) == ATA_PROTO_ATAPI_16) ? 16 :
1711                             ((ident_buf->config & ATA_PROTO_MASK) == ATA_PROTO_ATAPI_12) ? 12 : 0;
1712                         cts.xport_specific.ata.valid = CTS_ATA_VALID_ATAPI;
1713                 } else {
1714                         cts.xport_specific.sata.atapi =
1715                             (ident_buf->config == ATA_PROTO_CFA) ? 0 :
1716                             ((ident_buf->config & ATA_PROTO_MASK) == ATA_PROTO_ATAPI_16) ? 16 :
1717                             ((ident_buf->config & ATA_PROTO_MASK) == ATA_PROTO_ATAPI_12) ? 12 : 0;
1718                         cts.xport_specific.sata.valid = CTS_SATA_VALID_ATAPI;
1719                 }
1720         } else
1721                 cts.xport_specific.valid = 0;
1722         xpt_action((union ccb *)&cts);
1723 }
1724
1725 static void
1726 ata_dev_advinfo(union ccb *start_ccb)
1727 {
1728         struct cam_ed *device;
1729         struct ccb_dev_advinfo *cdai;
1730         off_t amt;
1731
1732         xpt_path_assert(start_ccb->ccb_h.path, MA_OWNED);
1733         start_ccb->ccb_h.status = CAM_REQ_INVALID;
1734         device = start_ccb->ccb_h.path->device;
1735         cdai = &start_ccb->cdai;
1736         switch(cdai->buftype) {
1737         case CDAI_TYPE_SCSI_DEVID:
1738                 if (cdai->flags & CDAI_FLAG_STORE)
1739                         return;
1740                 cdai->provsiz = device->device_id_len;
1741                 if (device->device_id_len == 0)
1742                         break;
1743                 amt = device->device_id_len;
1744                 if (cdai->provsiz > cdai->bufsiz)
1745                         amt = cdai->bufsiz;
1746                 memcpy(cdai->buf, device->device_id, amt);
1747                 break;
1748         case CDAI_TYPE_SERIAL_NUM:
1749                 if (cdai->flags & CDAI_FLAG_STORE)
1750                         return;
1751                 cdai->provsiz = device->serial_num_len;
1752                 if (device->serial_num_len == 0)
1753                         break;
1754                 amt = device->serial_num_len;
1755                 if (cdai->provsiz > cdai->bufsiz)
1756                         amt = cdai->bufsiz;
1757                 memcpy(cdai->buf, device->serial_num, amt);
1758                 break;
1759         case CDAI_TYPE_PHYS_PATH:
1760                 if (cdai->flags & CDAI_FLAG_STORE) {
1761                         if (device->physpath != NULL)
1762                                 free(device->physpath, M_CAMXPT);
1763                         device->physpath_len = cdai->bufsiz;
1764                         /* Clear existing buffer if zero length */
1765                         if (cdai->bufsiz == 0)
1766                                 break;
1767                         device->physpath = malloc(cdai->bufsiz, M_CAMXPT, M_NOWAIT);
1768                         if (device->physpath == NULL) {
1769                                 start_ccb->ccb_h.status = CAM_REQ_ABORTED;
1770                                 return;
1771                         }
1772                         memcpy(device->physpath, cdai->buf, cdai->bufsiz);
1773                 } else {
1774                         cdai->provsiz = device->physpath_len;
1775                         if (device->physpath_len == 0)
1776                                 break;
1777                         amt = device->physpath_len;
1778                         if (cdai->provsiz > cdai->bufsiz)
1779                                 amt = cdai->bufsiz;
1780                         memcpy(cdai->buf, device->physpath, amt);
1781                 }
1782                 break;
1783         default:
1784                 return;
1785         }
1786         start_ccb->ccb_h.status = CAM_REQ_CMP;
1787
1788         if (cdai->flags & CDAI_FLAG_STORE) {
1789                 xpt_async(AC_ADVINFO_CHANGED, start_ccb->ccb_h.path,
1790                           (void *)(uintptr_t)cdai->buftype);
1791         }
1792 }
1793
1794 static void
1795 ata_action(union ccb *start_ccb)
1796 {
1797
1798         if (start_ccb->ccb_h.func_code != XPT_ATA_IO) {
1799 #ifdef notyet
1800                 KASSERT((start_ccb->ccb_h.alloc_flags & CAM_CCB_FROM_UMA) == 0,
1801                     ("%s: ccb %p, func_code %#x should not be allocated "
1802                     "from UMA zone\n",
1803                     __func__, start_ccb, start_ccb->ccb_h.func_code));
1804 #else
1805                 if ((start_ccb->ccb_h.alloc_flags & CAM_CCB_FROM_UMA) != 0) {
1806                         printf("%s: ccb %p, func_code %#x should not be allocated "
1807                             "from UMA zone\n",
1808                             __func__, start_ccb, start_ccb->ccb_h.func_code);
1809                 }
1810 #endif
1811         }
1812
1813         switch (start_ccb->ccb_h.func_code) {
1814         case XPT_SET_TRAN_SETTINGS:
1815         {
1816                 ata_set_transfer_settings(&start_ccb->cts,
1817                                            start_ccb->ccb_h.path,
1818                                            /*async_update*/FALSE);
1819                 break;
1820         }
1821         case XPT_SCAN_BUS:
1822         case XPT_SCAN_TGT:
1823                 ata_scan_bus(start_ccb->ccb_h.path->periph, start_ccb);
1824                 break;
1825         case XPT_SCAN_LUN:
1826                 ata_scan_lun(start_ccb->ccb_h.path->periph,
1827                               start_ccb->ccb_h.path, start_ccb->crcn.flags,
1828                               start_ccb);
1829                 break;
1830         case XPT_GET_TRAN_SETTINGS:
1831         {
1832                 ata_get_transfer_settings(&start_ccb->cts);
1833                 break;
1834         }
1835         case XPT_SCSI_IO:
1836         {
1837                 struct cam_ed *device;
1838                 u_int   maxlen = 0;
1839
1840                 device = start_ccb->ccb_h.path->device;
1841                 if (device->protocol == PROTO_SCSI &&
1842                     (device->flags & CAM_DEV_IDENTIFY_DATA_VALID)) {
1843                         uint16_t p =
1844                             device->ident_data.config & ATA_PROTO_MASK;
1845
1846                         maxlen =
1847                             (device->ident_data.config == ATA_PROTO_CFA) ? 0 :
1848                             (p == ATA_PROTO_ATAPI_16) ? 16 :
1849                             (p == ATA_PROTO_ATAPI_12) ? 12 : 0;
1850                 }
1851                 if (start_ccb->csio.cdb_len > maxlen) {
1852                         start_ccb->ccb_h.status = CAM_REQ_INVALID;
1853                         xpt_done(start_ccb);
1854                         break;
1855                 }
1856                 xpt_action_default(start_ccb);
1857                 break;
1858         }
1859         case XPT_DEV_ADVINFO:
1860         {
1861                 ata_dev_advinfo(start_ccb);
1862                 break;
1863         }
1864         default:
1865                 xpt_action_default(start_ccb);
1866                 break;
1867         }
1868 }
1869
1870 static void
1871 ata_get_transfer_settings(struct ccb_trans_settings *cts)
1872 {
1873         struct  ccb_trans_settings_ata *ata;
1874         struct  ccb_trans_settings_scsi *scsi;
1875         struct  cam_ed *device;
1876
1877         device = cts->ccb_h.path->device;
1878         xpt_action_default((union ccb *)cts);
1879
1880         if (cts->protocol == PROTO_UNKNOWN ||
1881             cts->protocol == PROTO_UNSPECIFIED) {
1882                 cts->protocol = device->protocol;
1883                 cts->protocol_version = device->protocol_version;
1884         }
1885
1886         if (cts->protocol == PROTO_ATA) {
1887                 ata = &cts->proto_specific.ata;
1888                 if ((ata->valid & CTS_ATA_VALID_TQ) == 0) {
1889                         ata->valid |= CTS_ATA_VALID_TQ;
1890                         if (cts->type == CTS_TYPE_USER_SETTINGS ||
1891                             (device->flags & CAM_DEV_TAG_AFTER_COUNT) != 0 ||
1892                             (device->inq_flags & SID_CmdQue) != 0)
1893                                 ata->flags |= CTS_ATA_FLAGS_TAG_ENB;
1894                 }
1895         }
1896         if (cts->protocol == PROTO_SCSI) {
1897                 scsi = &cts->proto_specific.scsi;
1898                 if ((scsi->valid & CTS_SCSI_VALID_TQ) == 0) {
1899                         scsi->valid |= CTS_SCSI_VALID_TQ;
1900                         if (cts->type == CTS_TYPE_USER_SETTINGS ||
1901                             (device->flags & CAM_DEV_TAG_AFTER_COUNT) != 0 ||
1902                             (device->inq_flags & SID_CmdQue) != 0)
1903                                 scsi->flags |= CTS_SCSI_FLAGS_TAG_ENB;
1904                 }
1905         }
1906
1907         if (cts->transport == XPORT_UNKNOWN ||
1908             cts->transport == XPORT_UNSPECIFIED) {
1909                 cts->transport = device->transport;
1910                 cts->transport_version = device->transport_version;
1911         }
1912 }
1913
1914 static void
1915 ata_set_transfer_settings(struct ccb_trans_settings *cts, struct cam_path *path,
1916                            int async_update)
1917 {
1918         struct  ccb_pathinq cpi;
1919         struct  ccb_trans_settings_ata *ata;
1920         struct  ccb_trans_settings_scsi *scsi;
1921         struct  ata_params *ident_data;
1922         struct  scsi_inquiry_data *inq_data;
1923         struct  cam_ed *device;
1924
1925         if (path == NULL || (device = path->device) == NULL) {
1926                 cts->ccb_h.status = CAM_PATH_INVALID;
1927                 xpt_done((union ccb *)cts);
1928                 return;
1929         }
1930
1931         if (cts->protocol == PROTO_UNKNOWN
1932          || cts->protocol == PROTO_UNSPECIFIED) {
1933                 cts->protocol = device->protocol;
1934                 cts->protocol_version = device->protocol_version;
1935         }
1936
1937         if (cts->protocol_version == PROTO_VERSION_UNKNOWN
1938          || cts->protocol_version == PROTO_VERSION_UNSPECIFIED)
1939                 cts->protocol_version = device->protocol_version;
1940
1941         if (cts->protocol != device->protocol) {
1942                 xpt_print(path, "Uninitialized Protocol %x:%x?\n",
1943                        cts->protocol, device->protocol);
1944                 cts->protocol = device->protocol;
1945         }
1946
1947         if (cts->protocol_version > device->protocol_version) {
1948                 if (bootverbose) {
1949                         xpt_print(path, "Down reving Protocol "
1950                             "Version from %d to %d?\n", cts->protocol_version,
1951                             device->protocol_version);
1952                 }
1953                 cts->protocol_version = device->protocol_version;
1954         }
1955
1956         if (cts->transport == XPORT_UNKNOWN
1957          || cts->transport == XPORT_UNSPECIFIED) {
1958                 cts->transport = device->transport;
1959                 cts->transport_version = device->transport_version;
1960         }
1961
1962         if (cts->transport_version == XPORT_VERSION_UNKNOWN
1963          || cts->transport_version == XPORT_VERSION_UNSPECIFIED)
1964                 cts->transport_version = device->transport_version;
1965
1966         if (cts->transport != device->transport) {
1967                 xpt_print(path, "Uninitialized Transport %x:%x?\n",
1968                     cts->transport, device->transport);
1969                 cts->transport = device->transport;
1970         }
1971
1972         if (cts->transport_version > device->transport_version) {
1973                 if (bootverbose) {
1974                         xpt_print(path, "Down reving Transport "
1975                             "Version from %d to %d?\n", cts->transport_version,
1976                             device->transport_version);
1977                 }
1978                 cts->transport_version = device->transport_version;
1979         }
1980
1981         ident_data = &device->ident_data;
1982         inq_data = &device->inq_data;
1983         if (cts->protocol == PROTO_ATA)
1984                 ata = &cts->proto_specific.ata;
1985         else
1986                 ata = NULL;
1987         if (cts->protocol == PROTO_SCSI)
1988                 scsi = &cts->proto_specific.scsi;
1989         else
1990                 scsi = NULL;
1991         xpt_path_inq(&cpi, path);
1992
1993         /* Sanity checking */
1994         if ((cpi.hba_inquiry & PI_TAG_ABLE) == 0
1995          || (ata && (ident_data->satacapabilities & ATA_SUPPORT_NCQ) == 0)
1996          || (scsi && (INQ_DATA_TQ_ENABLED(inq_data)) == 0)
1997          || (device->queue_flags & SCP_QUEUE_DQUE) != 0
1998          || (device->mintags == 0)) {
1999                 /*
2000                  * Can't tag on hardware that doesn't support tags,
2001                  * doesn't have it enabled, or has broken tag support.
2002                  */
2003                 if (ata)
2004                         ata->flags &= ~CTS_ATA_FLAGS_TAG_ENB;
2005                 if (scsi)
2006                         scsi->flags &= ~CTS_SCSI_FLAGS_TAG_ENB;
2007         }
2008
2009         /* Start/stop tags use. */
2010         if (cts->type == CTS_TYPE_CURRENT_SETTINGS &&
2011             ((ata && (ata->valid & CTS_ATA_VALID_TQ) != 0) ||
2012              (scsi && (scsi->valid & CTS_SCSI_VALID_TQ) != 0))) {
2013                 int nowt, newt = 0;
2014
2015                 nowt = ((device->flags & CAM_DEV_TAG_AFTER_COUNT) != 0 ||
2016                         (device->inq_flags & SID_CmdQue) != 0);
2017                 if (ata)
2018                         newt = (ata->flags & CTS_ATA_FLAGS_TAG_ENB) != 0;
2019                 if (scsi)
2020                         newt = (scsi->flags & CTS_SCSI_FLAGS_TAG_ENB) != 0;
2021
2022                 if (newt && !nowt) {
2023                         /*
2024                          * Delay change to use tags until after a
2025                          * few commands have gone to this device so
2026                          * the controller has time to perform transfer
2027                          * negotiations without tagged messages getting
2028                          * in the way.
2029                          */
2030                         device->tag_delay_count = CAM_TAG_DELAY_COUNT;
2031                         device->flags |= CAM_DEV_TAG_AFTER_COUNT;
2032                 } else if (nowt && !newt)
2033                         xpt_stop_tags(path);
2034         }
2035
2036         if (async_update == FALSE)
2037                 xpt_action_default((union ccb *)cts);
2038 }
2039
2040 /*
2041  * Handle any per-device event notifications that require action by the XPT.
2042  */
2043 static void
2044 ata_dev_async(u_int32_t async_code, struct cam_eb *bus, struct cam_et *target,
2045               struct cam_ed *device, void *async_arg)
2046 {
2047         cam_status status;
2048         struct cam_path newpath;
2049
2050         /*
2051          * We only need to handle events for real devices.
2052          */
2053         if (target->target_id == CAM_TARGET_WILDCARD
2054          || device->lun_id == CAM_LUN_WILDCARD)
2055                 return;
2056
2057         /*
2058          * We need our own path with wildcards expanded to
2059          * handle certain types of events.
2060          */
2061         if ((async_code == AC_SENT_BDR)
2062          || (async_code == AC_BUS_RESET)
2063          || (async_code == AC_INQ_CHANGED))
2064                 status = xpt_compile_path(&newpath, NULL,
2065                                           bus->path_id,
2066                                           target->target_id,
2067                                           device->lun_id);
2068         else
2069                 status = CAM_REQ_CMP_ERR;
2070
2071         if (status == CAM_REQ_CMP) {
2072                 if (async_code == AC_INQ_CHANGED) {
2073                         /*
2074                          * We've sent a start unit command, or
2075                          * something similar to a device that
2076                          * may have caused its inquiry data to
2077                          * change. So we re-scan the device to
2078                          * refresh the inquiry data for it.
2079                          */
2080                         ata_scan_lun(newpath.periph, &newpath,
2081                                      CAM_EXPECT_INQ_CHANGE, NULL);
2082                 } else {
2083                         /* We need to reinitialize device after reset. */
2084                         ata_scan_lun(newpath.periph, &newpath,
2085                                      0, NULL);
2086                 }
2087                 xpt_release_path(&newpath);
2088         } else if (async_code == AC_LOST_DEVICE &&
2089             (device->flags & CAM_DEV_UNCONFIGURED) == 0) {
2090                 device->flags |= CAM_DEV_UNCONFIGURED;
2091                 xpt_release_device(device);
2092         } else if (async_code == AC_TRANSFER_NEG) {
2093                 struct ccb_trans_settings *settings;
2094                 struct cam_path path;
2095
2096                 settings = (struct ccb_trans_settings *)async_arg;
2097                 xpt_compile_path(&path, NULL, bus->path_id, target->target_id,
2098                                  device->lun_id);
2099                 ata_set_transfer_settings(settings, &path,
2100                                           /*async_update*/TRUE);
2101                 xpt_release_path(&path);
2102         }
2103 }
2104
2105 static void
2106 _ata_announce_periph(struct cam_periph *periph, struct ccb_trans_settings *cts, u_int *speed)
2107 {
2108         struct  ccb_pathinq cpi;
2109         struct  cam_path *path = periph->path;
2110
2111         cam_periph_assert(periph, MA_OWNED);
2112
2113         xpt_setup_ccb(&cts->ccb_h, path, CAM_PRIORITY_NORMAL);
2114         cts->ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
2115         cts->type = CTS_TYPE_CURRENT_SETTINGS;
2116         xpt_action((union ccb*)cts);
2117         if ((cts->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)
2118                 return;
2119         /* Ask the SIM for its base transfer speed */
2120         xpt_path_inq(&cpi, path);
2121         /* Report connection speed */
2122         *speed = cpi.base_transfer_speed;
2123         if (cts->transport == XPORT_ATA) {
2124                 struct  ccb_trans_settings_pata *pata =
2125                     &cts->xport_specific.ata;
2126
2127                 if (pata->valid & CTS_ATA_VALID_MODE)
2128                         *speed = ata_mode2speed(pata->mode);
2129         }
2130         if (cts->transport == XPORT_SATA) {
2131                 struct  ccb_trans_settings_sata *sata =
2132                     &cts->xport_specific.sata;
2133
2134                 if (sata->valid & CTS_SATA_VALID_REVISION)
2135                         *speed = ata_revision2speed(sata->revision);
2136         }
2137 }
2138
2139 static void
2140 ata_announce_periph(struct cam_periph *periph)
2141 {
2142         struct ccb_trans_settings cts;
2143         u_int speed, mb;
2144
2145         bzero(&cts, sizeof(cts));
2146         _ata_announce_periph(periph, &cts, &speed);
2147         if ((cts.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)
2148                 return;
2149
2150         mb = speed / 1000;
2151         if (mb > 0)
2152                 printf("%s%d: %d.%03dMB/s transfers",
2153                        periph->periph_name, periph->unit_number,
2154                        mb, speed % 1000);
2155         else
2156                 printf("%s%d: %dKB/s transfers", periph->periph_name,
2157                        periph->unit_number, speed);
2158         /* Report additional information about connection */
2159         if (cts.transport == XPORT_ATA) {
2160                 struct ccb_trans_settings_pata *pata =
2161                     &cts.xport_specific.ata;
2162
2163                 printf(" (");
2164                 if (pata->valid & CTS_ATA_VALID_MODE)
2165                         printf("%s, ", ata_mode2string(pata->mode));
2166                 if ((pata->valid & CTS_ATA_VALID_ATAPI) && pata->atapi != 0)
2167                         printf("ATAPI %dbytes, ", pata->atapi);
2168                 if (pata->valid & CTS_ATA_VALID_BYTECOUNT)
2169                         printf("PIO %dbytes", pata->bytecount);
2170                 printf(")");
2171         }
2172         if (cts.transport == XPORT_SATA) {
2173                 struct ccb_trans_settings_sata *sata =
2174                     &cts.xport_specific.sata;
2175
2176                 printf(" (");
2177                 if (sata->valid & CTS_SATA_VALID_REVISION)
2178                         printf("SATA %d.x, ", sata->revision);
2179                 else
2180                         printf("SATA, ");
2181                 if (sata->valid & CTS_SATA_VALID_MODE)
2182                         printf("%s, ", ata_mode2string(sata->mode));
2183                 if ((sata->valid & CTS_ATA_VALID_ATAPI) && sata->atapi != 0)
2184                         printf("ATAPI %dbytes, ", sata->atapi);
2185                 if (sata->valid & CTS_SATA_VALID_BYTECOUNT)
2186                         printf("PIO %dbytes", sata->bytecount);
2187                 printf(")");
2188         }
2189         printf("\n");
2190 }
2191
2192 static void
2193 ata_announce_periph_sbuf(struct cam_periph *periph, struct sbuf *sb)
2194 {
2195         struct ccb_trans_settings cts;
2196         u_int speed, mb;
2197
2198         bzero(&cts, sizeof(cts));
2199         _ata_announce_periph(periph, &cts, &speed);
2200         if ((cts.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)
2201                 return;
2202
2203         mb = speed / 1000;
2204         if (mb > 0)
2205                 sbuf_printf(sb, "%s%d: %d.%03dMB/s transfers",
2206                        periph->periph_name, periph->unit_number,
2207                        mb, speed % 1000);
2208         else
2209                 sbuf_printf(sb, "%s%d: %dKB/s transfers", periph->periph_name,
2210                        periph->unit_number, speed);
2211         /* Report additional information about connection */
2212         if (cts.transport == XPORT_ATA) {
2213                 struct ccb_trans_settings_pata *pata =
2214                     &cts.xport_specific.ata;
2215
2216                 sbuf_printf(sb, " (");
2217                 if (pata->valid & CTS_ATA_VALID_MODE)
2218                         sbuf_printf(sb, "%s, ", ata_mode2string(pata->mode));
2219                 if ((pata->valid & CTS_ATA_VALID_ATAPI) && pata->atapi != 0)
2220                         sbuf_printf(sb, "ATAPI %dbytes, ", pata->atapi);
2221                 if (pata->valid & CTS_ATA_VALID_BYTECOUNT)
2222                         sbuf_printf(sb, "PIO %dbytes", pata->bytecount);
2223                 sbuf_printf(sb, ")");
2224         }
2225         if (cts.transport == XPORT_SATA) {
2226                 struct ccb_trans_settings_sata *sata =
2227                     &cts.xport_specific.sata;
2228
2229                 sbuf_printf(sb, " (");
2230                 if (sata->valid & CTS_SATA_VALID_REVISION)
2231                         sbuf_printf(sb, "SATA %d.x, ", sata->revision);
2232                 else
2233                         sbuf_printf(sb, "SATA, ");
2234                 if (sata->valid & CTS_SATA_VALID_MODE)
2235                         sbuf_printf(sb, "%s, ", ata_mode2string(sata->mode));
2236                 if ((sata->valid & CTS_ATA_VALID_ATAPI) && sata->atapi != 0)
2237                         sbuf_printf(sb, "ATAPI %dbytes, ", sata->atapi);
2238                 if (sata->valid & CTS_SATA_VALID_BYTECOUNT)
2239                         sbuf_printf(sb, "PIO %dbytes", sata->bytecount);
2240                 sbuf_printf(sb, ")");
2241         }
2242         sbuf_printf(sb, "\n");
2243 }
2244
2245 static void
2246 ata_proto_announce_sbuf(struct cam_ed *device, struct sbuf *sb)
2247 {
2248         ata_print_ident_sbuf(&device->ident_data, sb);
2249 }
2250
2251 static void
2252 ata_proto_announce(struct cam_ed *device)
2253 {
2254         ata_print_ident(&device->ident_data);
2255 }
2256
2257 static void
2258 ata_proto_denounce(struct cam_ed *device)
2259 {
2260         ata_print_ident_short(&device->ident_data);
2261 }
2262
2263 static void
2264 ata_proto_denounce_sbuf(struct cam_ed *device, struct sbuf *sb)
2265 {
2266         ata_print_ident_short_sbuf(&device->ident_data, sb);
2267 }
2268
2269 static void
2270 semb_proto_announce_sbuf(struct cam_ed *device, struct sbuf *sb)
2271 {
2272         semb_print_ident_sbuf((struct sep_identify_data *)&device->ident_data, sb);
2273 }
2274
2275 static void
2276 semb_proto_announce(struct cam_ed *device)
2277 {
2278         semb_print_ident((struct sep_identify_data *)&device->ident_data);
2279 }
2280
2281 static void
2282 semb_proto_denounce(struct cam_ed *device)
2283 {
2284         semb_print_ident_short((struct sep_identify_data *)&device->ident_data);
2285 }
2286
2287 static void
2288 semb_proto_denounce_sbuf(struct cam_ed *device, struct sbuf *sb)
2289 {
2290         semb_print_ident_short_sbuf((struct sep_identify_data *)&device->ident_data, sb);
2291 }
2292
2293 static void
2294 ata_proto_debug_out(union ccb *ccb)
2295 {
2296         char cdb_str[(sizeof(struct ata_cmd) * 3) + 1];
2297
2298         if (ccb->ccb_h.func_code != XPT_ATA_IO)
2299                 return;
2300
2301         CAM_DEBUG(ccb->ccb_h.path,
2302             CAM_DEBUG_CDB,("%s. ACB: %s\n", ata_op_string(&ccb->ataio.cmd),
2303                 ata_cmd_string(&ccb->ataio.cmd, cdb_str, sizeof(cdb_str))));
2304 }