sys/cam/ata/ata_xpt.c

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