sys/cam/nvme/nvme_xpt.c

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