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