sys/cam/nvme/nvme_xpt.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2015 Netflix, Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer,
  12  *    without modification, immediately at the beginning of the file.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * derived from ata_xpt.c: Copyright (c) 2009 Alexander Motin <mav@FreeBSD.org>
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/param.h>
  35 #include <sys/bus.h>
  36 #include <sys/endian.h>
  37 #include <sys/systm.h>
  38 #include <sys/types.h>
  39 #include <sys/malloc.h>
  40 #include <sys/kernel.h>
  41 #include <sys/time.h>
  42 #include <sys/conf.h>
  43 #include <sys/fcntl.h>
  44 #include <sys/interrupt.h>
  45 #include <sys/sbuf.h>
  46
  47 #include <sys/lock.h>
  48 #include <sys/mutex.h>
  49 #include <sys/sysctl.h>
  50
  51 #include <cam/cam.h>
  52 #include <cam/cam_ccb.h>
  53 #include <cam/cam_queue.h>
  54 #include <cam/cam_periph.h>
  55 #include <cam/cam_sim.h>
  56 #include <cam/cam_xpt.h>
  57 #include <cam/cam_xpt_sim.h>
  58 #include <cam/cam_xpt_periph.h>
  59 #include <cam/cam_xpt_internal.h>
  60 #include <cam/cam_debug.h>
  61
  62 #include <cam/scsi/scsi_all.h>
  63 #include <cam/scsi/scsi_message.h>
  64 #include <cam/nvme/nvme_all.h>
  65 #include <machine/stdarg.h>     /* for xpt_print below */
  66 #include "opt_cam.h"
  67
  68 struct nvme_quirk_entry {
  69         u_int quirks;
  70 #define CAM_QUIRK_MAXTAGS 1
  71         u_int mintags;
  72         u_int maxtags;
  73 };
  74
  75 /* Not even sure why we need this */
  76 static periph_init_t nvme_probe_periph_init;
  77
  78 static struct periph_driver nvme_probe_driver =
  79 {
  80         nvme_probe_periph_init, "nvme_probe",
  81         TAILQ_HEAD_INITIALIZER(nvme_probe_driver.units), /* generation */ 0,
  82         CAM_PERIPH_DRV_EARLY
  83 };
  84
  85 PERIPHDRIVER_DECLARE(nvme_probe, nvme_probe_driver);
  86
  87 typedef enum {
  88         NVME_PROBE_IDENTIFY,
  89         NVME_PROBE_DONE,
  90         NVME_PROBE_INVALID,
  91         NVME_PROBE_RESET
  92 } nvme_probe_action;
  93
  94 static char *nvme_probe_action_text[] = {
  95         "NVME_PROBE_IDENTIFY",
  96         "NVME_PROBE_DONE",
  97         "NVME_PROBE_INVALID",
  98         "NVME_PROBE_RESET",
  99 };
 100
 101 #define NVME_PROBE_SET_ACTION(softc, newaction) \
 102 do {                                                                    \
 103         char **text;                                                    \
 104         text = nvme_probe_action_text;                                  \
 105         CAM_DEBUG((softc)->periph->path, CAM_DEBUG_PROBE,               \
 106             ("Probe %s to %s\n", text[(softc)->action],                 \
 107             text[(newaction)]));                                        \
 108         (softc)->action = (newaction);                                  \
 109 } while(0)
 110
 111 typedef enum {
 112         NVME_PROBE_NO_ANNOUNCE  = 0x04
 113 } nvme_probe_flags;
 114
 115 typedef struct {
 116         TAILQ_HEAD(, ccb_hdr) request_ccbs;
 117         nvme_probe_action       action;
 118         nvme_probe_flags        flags;
 119         int             restart;
 120         struct cam_periph *periph;
 121 } nvme_probe_softc;
 122
 123 static struct nvme_quirk_entry nvme_quirk_table[] =
 124 {
 125         {
 126 //              {
 127 //                T_ANY, SIP_MEDIA_REMOVABLE|SIP_MEDIA_FIXED,
 128 //                /*vendor*/"*", /*product*/"*", /*revision*/"*"
 129 //              },
 130                 .quirks = 0, .mintags = 0, .maxtags = 0
 131         },
 132 };
 133
 134 static const int nvme_quirk_table_size =
 135         sizeof(nvme_quirk_table) / sizeof(*nvme_quirk_table);
 136
 137 static cam_status       nvme_probe_register(struct cam_periph *periph,
 138                                       void *arg);
 139 static void      nvme_probe_schedule(struct cam_periph *nvme_probe_periph);
 140 static void      nvme_probe_start(struct cam_periph *periph, union ccb *start_ccb);
 141 static void      nvme_probe_cleanup(struct cam_periph *periph);
 142 //static void    nvme_find_quirk(struct cam_ed *device);
 143 static void      nvme_scan_lun(struct cam_periph *periph,
 144                                struct cam_path *path, cam_flags flags,
 145                                union ccb *ccb);
 146 static struct cam_ed *
 147                  nvme_alloc_device(struct cam_eb *bus, struct cam_et *target,
 148                                    lun_id_t lun_id);
 149 static void      nvme_device_transport(struct cam_path *path);
 150 static void      nvme_dev_async(u_int32_t async_code,
 151                                 struct cam_eb *bus,
 152                                 struct cam_et *target,
 153                                 struct cam_ed *device,
 154                                 void *async_arg);
 155 static void      nvme_action(union ccb *start_ccb);
 156 static void      nvme_announce_periph(struct cam_periph *periph);
 157 static void      nvme_proto_announce(struct cam_ed *device);
 158 static void      nvme_proto_denounce(struct cam_ed *device);
 159 static void      nvme_proto_debug_out(union ccb *ccb);
 160
 161 static struct xpt_xport_ops nvme_xport_ops = {
 162         .alloc_device = nvme_alloc_device,
 163         .action = nvme_action,
 164         .async = nvme_dev_async,
 165         .announce = nvme_announce_periph,
 166 };
 167 #define NVME_XPT_XPORT(x, X)                    \
 168 static struct xpt_xport nvme_xport_ ## x = {    \
 169         .xport = XPORT_ ## X,                   \
 170         .name = #x,                             \
 171         .ops = &nvme_xport_ops,                 \
 172 };                                              \
 173 CAM_XPT_XPORT(nvme_xport_ ## x);
 174
 175 NVME_XPT_XPORT(nvme, NVME);
 176
 177 #undef NVME_XPT_XPORT
 178
 179 static struct xpt_proto_ops nvme_proto_ops = {
 180         .announce = nvme_proto_announce,
 181         .denounce = nvme_proto_denounce,
 182         .debug_out = nvme_proto_debug_out,
 183 };
 184 static struct xpt_proto nvme_proto = {
 185         .proto = PROTO_NVME,
 186         .name = "nvme",
 187         .ops = &nvme_proto_ops,
 188 };
 189 CAM_XPT_PROTO(nvme_proto);
 190
 191 static void
 192 nvme_probe_periph_init()
 193 {
 194
 195 }
 196
 197 static cam_status
 198 nvme_probe_register(struct cam_periph *periph, void *arg)
 199 {
 200         union ccb *request_ccb; /* CCB representing the probe request */
 201         nvme_probe_softc *softc;
 202
 203         request_ccb = (union ccb *)arg;
 204         if (request_ccb == NULL) {
 205                 printf("nvme_probe_register: no probe CCB, "
 206                        "can't register device\n");
 207                 return(CAM_REQ_CMP_ERR);
 208         }
 209
 210         softc = (nvme_probe_softc *)malloc(sizeof(*softc), M_CAMXPT, M_ZERO | M_NOWAIT);
 211
 212         if (softc == NULL) {
 213                 printf("nvme_probe_register: Unable to probe new device. "
 214                        "Unable to allocate softc\n");
 215                 return(CAM_REQ_CMP_ERR);
 216         }
 217         TAILQ_INIT(&softc->request_ccbs);
 218         TAILQ_INSERT_TAIL(&softc->request_ccbs, &request_ccb->ccb_h,
 219                           periph_links.tqe);
 220         softc->flags = 0;
 221         periph->softc = softc;
 222         softc->periph = periph;
 223         softc->action = NVME_PROBE_INVALID;
 224         if (cam_periph_acquire(periph) != 0)
 225                 return (CAM_REQ_CMP_ERR);
 226
 227         CAM_DEBUG(periph->path, CAM_DEBUG_PROBE, ("Probe started\n"));
 228
 229 //      nvme_device_transport(periph->path);
 230         nvme_probe_schedule(periph);
 231
 232         return(CAM_REQ_CMP);
 233 }
 234
 235 static void
 236 nvme_probe_schedule(struct cam_periph *periph)
 237 {
 238         union ccb *ccb;
 239         nvme_probe_softc *softc;
 240
 241         softc = (nvme_probe_softc *)periph->softc;
 242         ccb = (union ccb *)TAILQ_FIRST(&softc->request_ccbs);
 243
 244         NVME_PROBE_SET_ACTION(softc, NVME_PROBE_IDENTIFY);
 245
 246         if (ccb->crcn.flags & CAM_EXPECT_INQ_CHANGE)
 247                 softc->flags |= NVME_PROBE_NO_ANNOUNCE;
 248         else
 249                 softc->flags &= ~NVME_PROBE_NO_ANNOUNCE;
 250
 251         xpt_schedule(periph, CAM_PRIORITY_XPT);
 252 }
 253
 254 static void
 255 nvme_probe_start(struct cam_periph *periph, union ccb *start_ccb)
 256 {
 257         struct ccb_nvmeio *nvmeio;
 258         struct ccb_scsiio *csio;
 259         nvme_probe_softc *softc;
 260         struct cam_path *path;
 261         const struct nvme_namespace_data *nvme_data;
 262         lun_id_t lun;
 263
 264         CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("nvme_probe_start\n"));
 265
 266         softc = (nvme_probe_softc *)periph->softc;
 267         path = start_ccb->ccb_h.path;
 268         nvmeio = &start_ccb->nvmeio;
 269         csio = &start_ccb->csio;
 270         nvme_data = periph->path->device->nvme_data;
 271
 272         if (softc->restart) {
 273                 softc->restart = 0;
 274                 if (periph->path->device->flags & CAM_DEV_UNCONFIGURED)
 275                         NVME_PROBE_SET_ACTION(softc, NVME_PROBE_RESET);
 276                 else
 277                         NVME_PROBE_SET_ACTION(softc, NVME_PROBE_IDENTIFY);
 278         }
 279
 280         /*
 281          * Other transports have to ask their SIM to do a lot of action.
 282          * NVMe doesn't, so don't do the dance. Just do things
 283          * directly.
 284          */
 285         switch (softc->action) {
 286         case NVME_PROBE_RESET:
 287                 /* FALLTHROUGH */
 288         case NVME_PROBE_IDENTIFY:
 289                 nvme_device_transport(path);
 290                 /*
 291                  * Test for lun == CAM_LUN_WILDCARD is lame, but
 292                  * appears to be necessary here. XXX
 293                  */
 294                 lun = xpt_path_lun_id(periph->path);
 295                 if (lun == CAM_LUN_WILDCARD ||
 296                     periph->path->device->flags & CAM_DEV_UNCONFIGURED) {
 297                         path->device->flags &= ~CAM_DEV_UNCONFIGURED;
 298                         xpt_acquire_device(path->device);
 299                         start_ccb->ccb_h.func_code = XPT_GDEV_TYPE;
 300                         xpt_action(start_ccb);
 301                         xpt_async(AC_FOUND_DEVICE, path, start_ccb);
 302                 }
 303                 NVME_PROBE_SET_ACTION(softc, NVME_PROBE_DONE);
 304                 break;
 305         default:
 306                 panic("nvme_probe_start: invalid action state 0x%x\n", softc->action);
 307         }
 308         /*
 309          * Probing is now done. We need to complete any lingering items
 310          * in the queue, though there shouldn't be any.
 311          */
 312         xpt_release_ccb(start_ccb);
 313         CAM_DEBUG(periph->path, CAM_DEBUG_PROBE, ("Probe completed\n"));
 314         while ((start_ccb = (union ccb *)TAILQ_FIRST(&softc->request_ccbs))) {
 315                 TAILQ_REMOVE(&softc->request_ccbs,
 316                     &start_ccb->ccb_h, periph_links.tqe);
 317                 start_ccb->ccb_h.status = CAM_REQ_CMP;
 318                 xpt_done(start_ccb);
 319         }
 320         cam_periph_invalidate(periph);
 321         cam_periph_release_locked(periph);
 322 }
 323
 324 static void
 325 nvme_probe_cleanup(struct cam_periph *periph)
 326 {
 327
 328         free(periph->softc, M_CAMXPT);
 329 }
 330
 331 #if 0
 332 /* XXX should be used, don't delete */
 333 static void
 334 nvme_find_quirk(struct cam_ed *device)
 335 {
 336         struct nvme_quirk_entry *quirk;
 337         caddr_t match;
 338
 339         match = cam_quirkmatch((caddr_t)&device->nvme_data,
 340                                (caddr_t)nvme_quirk_table,
 341                                nvme_quirk_table_size,
 342                                sizeof(*nvme_quirk_table), nvme_identify_match);
 343
 344         if (match == NULL)
 345                 panic("xpt_find_quirk: device didn't match wildcard entry!!");
 346
 347         quirk = (struct nvme_quirk_entry *)match;
 348         device->quirk = quirk;
 349         if (quirk->quirks & CAM_QUIRK_MAXTAGS) {
 350                 device->mintags = quirk->mintags;
 351                 device->maxtags = quirk->maxtags;
 352         }
 353 }
 354 #endif
 355
 356 static void
 357 nvme_scan_lun(struct cam_periph *periph, struct cam_path *path,
 358              cam_flags flags, union ccb *request_ccb)
 359 {
 360         struct ccb_pathinq cpi;
 361         cam_status status;
 362         struct cam_periph *old_periph;
 363         int lock;
 364
 365         CAM_DEBUG(path, CAM_DEBUG_TRACE, ("nvme_scan_lun\n"));
 366
 367         xpt_path_inq(&cpi, path);
 368
 369         if (cpi.ccb_h.status != CAM_REQ_CMP) {
 370                 if (request_ccb != NULL) {
 371                         request_ccb->ccb_h.status = cpi.ccb_h.status;
 372                         xpt_done(request_ccb);
 373                 }
 374                 return;
 375         }
 376
 377         if (xpt_path_lun_id(path) == CAM_LUN_WILDCARD) {
 378                 CAM_DEBUG(path, CAM_DEBUG_TRACE, ("nvme_scan_lun ignoring bus\n"));
 379                 request_ccb->ccb_h.status = CAM_REQ_CMP;        /* XXX signal error ? */
 380                 xpt_done(request_ccb);
 381                 return;
 382         }
 383
 384         lock = (xpt_path_owned(path) == 0);
 385         if (lock)
 386                 xpt_path_lock(path);
 387         if ((old_periph = cam_periph_find(path, "nvme_probe")) != NULL) {
 388                 if ((old_periph->flags & CAM_PERIPH_INVALID) == 0) {
 389                         nvme_probe_softc *softc;
 390
 391                         softc = (nvme_probe_softc *)old_periph->softc;
 392                         TAILQ_INSERT_TAIL(&softc->request_ccbs,
 393                                 &request_ccb->ccb_h, periph_links.tqe);
 394                         softc->restart = 1;
 395                         CAM_DEBUG(path, CAM_DEBUG_TRACE,
 396                             ("restarting nvme_probe device\n"));
 397                 } else {
 398                         request_ccb->ccb_h.status = CAM_REQ_CMP_ERR;
 399                         CAM_DEBUG(path, CAM_DEBUG_TRACE,
 400                             ("Failing to restart nvme_probe device\n"));
 401                         xpt_done(request_ccb);
 402                 }
 403         } else {
 404                 CAM_DEBUG(path, CAM_DEBUG_TRACE,
 405                     ("Adding nvme_probe device\n"));
 406                 status = cam_periph_alloc(nvme_probe_register, NULL, nvme_probe_cleanup,
 407                                           nvme_probe_start, "nvme_probe",
 408                                           CAM_PERIPH_BIO,
 409                                           request_ccb->ccb_h.path, NULL, 0,
 410                                           request_ccb);
 411
 412                 if (status != CAM_REQ_CMP) {
 413                         xpt_print(path, "xpt_scan_lun: cam_alloc_periph "
 414                             "returned an error, can't continue probe\n");
 415                         request_ccb->ccb_h.status = status;
 416                         xpt_done(request_ccb);
 417                 }
 418         }
 419         if (lock)
 420                 xpt_path_unlock(path);
 421 }
 422
 423 static struct cam_ed *
 424 nvme_alloc_device(struct cam_eb *bus, struct cam_et *target, lun_id_t lun_id)
 425 {
 426         struct nvme_quirk_entry *quirk;
 427         struct cam_ed *device;
 428
 429         device = xpt_alloc_device(bus, target, lun_id);
 430         if (device == NULL)
 431                 return (NULL);
 432
 433         /*
 434          * Take the default quirk entry until we have inquiry
 435          * data from nvme and can determine a better quirk to use.
 436          */
 437         quirk = &nvme_quirk_table[nvme_quirk_table_size - 1];
 438         device->quirk = (void *)quirk;
 439         device->mintags = 0;
 440         device->maxtags = 0;
 441         device->inq_flags = 0;
 442         device->queue_flags = 0;
 443         device->device_id = NULL;       /* XXX Need to set this somewhere */
 444         device->device_id_len = 0;
 445         device->serial_num = NULL;      /* XXX Need to set this somewhere */
 446         device->serial_num_len = 0;
 447         return (device);
 448 }
 449
 450 static void
 451 nvme_device_transport(struct cam_path *path)
 452 {
 453         struct ccb_pathinq cpi;
 454         struct ccb_trans_settings cts;
 455         /* XXX get data from nvme namespace and other info ??? */
 456
 457         /* Get transport information from the SIM */
 458         xpt_path_inq(&cpi, path);
 459
 460         path->device->transport = cpi.transport;
 461         path->device->transport_version = cpi.transport_version;
 462
 463         path->device->protocol = cpi.protocol;
 464         path->device->protocol_version = cpi.protocol_version;
 465
 466         /* Tell the controller what we think */
 467         xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE);
 468         cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
 469         cts.type = CTS_TYPE_CURRENT_SETTINGS;
 470         cts.transport = path->device->transport;
 471         cts.transport_version = path->device->transport_version;
 472         cts.protocol = path->device->protocol;
 473         cts.protocol_version = path->device->protocol_version;
 474         cts.proto_specific.valid = 0;
 475         cts.xport_specific.valid = 0;
 476         xpt_action((union ccb *)&cts);
 477 }
 478
 479 static void
 480 nvme_dev_advinfo(union ccb *start_ccb)
 481 {
 482         struct cam_ed *device;
 483         struct ccb_dev_advinfo *cdai;
 484         off_t amt;
 485
 486         start_ccb->ccb_h.status = CAM_REQ_INVALID;
 487         device = start_ccb->ccb_h.path->device;
 488         cdai = &start_ccb->cdai;
 489         switch(cdai->buftype) {
 490         case CDAI_TYPE_SCSI_DEVID:
 491                 if (cdai->flags & CDAI_FLAG_STORE)
 492                         return;
 493                 cdai->provsiz = device->device_id_len;
 494                 if (device->device_id_len == 0)
 495                         break;
 496                 amt = device->device_id_len;
 497                 if (cdai->provsiz > cdai->bufsiz)
 498                         amt = cdai->bufsiz;
 499                 memcpy(cdai->buf, device->device_id, amt);
 500                 break;
 501         case CDAI_TYPE_SERIAL_NUM:
 502                 if (cdai->flags & CDAI_FLAG_STORE)
 503                         return;
 504                 cdai->provsiz = device->serial_num_len;
 505                 if (device->serial_num_len == 0)
 506                         break;
 507                 amt = device->serial_num_len;
 508                 if (cdai->provsiz > cdai->bufsiz)
 509                         amt = cdai->bufsiz;
 510                 memcpy(cdai->buf, device->serial_num, amt);
 511                 break;
 512         case CDAI_TYPE_PHYS_PATH:
 513                 if (cdai->flags & CDAI_FLAG_STORE) {
 514                         if (device->physpath != NULL)
 515                                 free(device->physpath, M_CAMXPT);
 516                         device->physpath_len = cdai->bufsiz;
 517                         /* Clear existing buffer if zero length */
 518                         if (cdai->bufsiz == 0)
 519                                 break;
 520                         device->physpath = malloc(cdai->bufsiz, M_CAMXPT, M_NOWAIT);
 521                         if (device->physpath == NULL) {
 522                                 start_ccb->ccb_h.status = CAM_REQ_ABORTED;
 523                                 return;
 524                         }
 525                         memcpy(device->physpath, cdai->buf, cdai->bufsiz);
 526                 } else {
 527                         cdai->provsiz = device->physpath_len;
 528                         if (device->physpath_len == 0)
 529                                 break;
 530                         amt = device->physpath_len;
 531                         if (cdai->provsiz > cdai->bufsiz)
 532                                 amt = cdai->bufsiz;
 533                         memcpy(cdai->buf, device->physpath, amt);
 534                 }
 535                 break;
 536         case CDAI_TYPE_NVME_CNTRL:
 537                 if (cdai->flags & CDAI_FLAG_STORE)
 538                         return;
 539                 amt = sizeof(struct nvme_controller_data);
 540                 cdai->provsiz = amt;
 541                 if (amt > cdai->bufsiz)
 542                         amt = cdai->bufsiz;
 543                 memcpy(cdai->buf, device->nvme_cdata, amt);
 544                 break;
 545         case CDAI_TYPE_NVME_NS:
 546                 if (cdai->flags & CDAI_FLAG_STORE)
 547                         return;
 548                 amt = sizeof(struct nvme_namespace_data);
 549                 cdai->provsiz = amt;
 550                 if (amt > cdai->bufsiz)
 551                         amt = cdai->bufsiz;
 552                 memcpy(cdai->buf, device->nvme_data, amt);
 553                 break;
 554         default:
 555                 return;
 556         }
 557         start_ccb->ccb_h.status = CAM_REQ_CMP;
 558
 559         if (cdai->flags & CDAI_FLAG_STORE) {
 560                 xpt_async(AC_ADVINFO_CHANGED, start_ccb->ccb_h.path,
 561                           (void *)(uintptr_t)cdai->buftype);
 562         }
 563 }
 564
 565 static void
 566 nvme_action(union ccb *start_ccb)
 567 {
 568         CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_TRACE,
 569             ("nvme_action: func= %#x\n", start_ccb->ccb_h.func_code));
 570
 571         switch (start_ccb->ccb_h.func_code) {
 572         case XPT_SCAN_BUS:
 573         case XPT_SCAN_TGT:
 574         case XPT_SCAN_LUN:
 575                 nvme_scan_lun(start_ccb->ccb_h.path->periph,
 576                               start_ccb->ccb_h.path, start_ccb->crcn.flags,
 577                               start_ccb);
 578                 break;
 579         case XPT_DEV_ADVINFO:
 580                 nvme_dev_advinfo(start_ccb);
 581                 break;
 582
 583         default:
 584                 xpt_action_default(start_ccb);
 585                 break;
 586         }
 587 }
 588
 589 /*
 590  * Handle any per-device event notifications that require action by the XPT.
 591  */
 592 static void
 593 nvme_dev_async(u_int32_t async_code, struct cam_eb *bus, struct cam_et *target,
 594               struct cam_ed *device, void *async_arg)
 595 {
 596
 597         /*
 598          * We only need to handle events for real devices.
 599          */
 600         if (target->target_id == CAM_TARGET_WILDCARD
 601          || device->lun_id == CAM_LUN_WILDCARD)
 602                 return;
 603
 604         if (async_code == AC_LOST_DEVICE &&
 605             (device->flags & CAM_DEV_UNCONFIGURED) == 0) {
 606                 device->flags |= CAM_DEV_UNCONFIGURED;
 607                 xpt_release_device(device);
 608         }
 609 }
 610
 611 static void
 612 nvme_announce_periph(struct cam_periph *periph)
 613 {
 614         struct  ccb_pathinq cpi;
 615         struct  ccb_trans_settings cts;
 616         struct  cam_path *path = periph->path;
 617         struct ccb_trans_settings_nvme  *nvmex;
 618
 619         cam_periph_assert(periph, MA_OWNED);
 620
 621         /* Ask the SIM for connection details */
 622         xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NORMAL);
 623         cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 624         cts.type = CTS_TYPE_CURRENT_SETTINGS;
 625         xpt_action((union ccb*)&cts);
 626         if ((cts.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)
 627                 return;
 628         nvmex = &cts.xport_specific.nvme;
 629
 630         /* Ask the SIM for its base transfer speed */
 631         xpt_path_inq(&cpi, periph->path);
 632         printf("%s%d: nvme version %d.%d x%d (max x%d) lanes PCIe Gen%d (max Gen%d) link",
 633             periph->periph_name, periph->unit_number,
 634             NVME_MAJOR(nvmex->spec),
 635             NVME_MINOR(nvmex->spec),
 636             nvmex->lanes, nvmex->max_lanes,
 637             nvmex->speed, nvmex->max_speed);
 638         printf("\n");
 639 }
 640
 641 static void
 642 nvme_proto_announce(struct cam_ed *device)
 643 {
 644         struct sbuf     sb;
 645         char            buffer[120];
 646
 647         sbuf_new(&sb, buffer, sizeof(buffer), SBUF_FIXEDLEN);
 648         nvme_print_ident(device->nvme_cdata, device->nvme_data, &sb);
 649         sbuf_finish(&sb);
 650         sbuf_putbuf(&sb);
 651 }
 652
 653 static void
 654 nvme_proto_denounce(struct cam_ed *device)
 655 {
 656
 657         nvme_proto_announce(device);
 658 }
 659
 660 static void
 661 nvme_proto_debug_out(union ccb *ccb)
 662 {
 663         char cdb_str[(sizeof(struct nvme_command) * 3) + 1];
 664
 665         if (ccb->ccb_h.func_code != XPT_NVME_IO)
 666                 return;
 667
 668         CAM_DEBUG(ccb->ccb_h.path,
 669             CAM_DEBUG_CDB,("%s. NCB: %s\n", nvme_op_string(&ccb->nvmeio.cmd),
 670                 nvme_cmd_string(&ccb->nvmeio.cmd, cdb_str, sizeof(cdb_str))));
 671 }
 672