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/sbuf.h>
  44
  45 #include <sys/lock.h>
  46 #include <sys/mutex.h>
  47 #include <sys/sysctl.h>
  48
  49 #include <cam/cam.h>
  50 #include <cam/cam_ccb.h>
  51 #include <cam/cam_queue.h>
  52 #include <cam/cam_periph.h>
  53 #include <cam/cam_sim.h>
  54 #include <cam/cam_xpt.h>
  55 #include <cam/cam_xpt_sim.h>
  56 #include <cam/cam_xpt_periph.h>
  57 #include <cam/cam_xpt_internal.h>
  58 #include <cam/cam_debug.h>
  59
  60 #include <cam/scsi/scsi_all.h>
  61 #include <cam/scsi/scsi_message.h>
  62 #include <cam/nvme/nvme_all.h>
  63 #include <machine/stdarg.h>     /* for xpt_print below */
  64 #include "opt_cam.h"
  65
  66 struct nvme_quirk_entry {
  67         u_int quirks;
  68 #define CAM_QUIRK_MAXTAGS 1
  69         u_int mintags;
  70         u_int maxtags;
  71 };
  72
  73 /* Not even sure why we need this */
  74 static periph_init_t nvme_probe_periph_init;
  75
  76 static struct periph_driver nvme_probe_driver =
  77 {
  78         nvme_probe_periph_init, "nvme_probe",
  79         TAILQ_HEAD_INITIALIZER(nvme_probe_driver.units), /* generation */ 0,
  80         CAM_PERIPH_DRV_EARLY
  81 };
  82
  83 PERIPHDRIVER_DECLARE(nvme_probe, nvme_probe_driver);
  84
  85 typedef enum {
  86         NVME_PROBE_IDENTIFY_CD,
  87         NVME_PROBE_IDENTIFY_NS,
  88         NVME_PROBE_DONE,
  89         NVME_PROBE_INVALID
  90 } nvme_probe_action;
  91
  92 static char *nvme_probe_action_text[] = {
  93         "NVME_PROBE_IDENTIFY_CD",
  94         "NVME_PROBE_IDENTIFY_NS",
  95         "NVME_PROBE_DONE",
  96         "NVME_PROBE_INVALID"
  97 };
  98
  99 #define NVME_PROBE_SET_ACTION(softc, newaction) \
 100 do {                                                                    \
 101         char **text;                                                    \
 102         text = nvme_probe_action_text;                                  \
 103         CAM_DEBUG((softc)->periph->path, CAM_DEBUG_PROBE,               \
 104             ("Probe %s to %s\n", text[(softc)->action],                 \
 105             text[(newaction)]));                                        \
 106         (softc)->action = (newaction);                                  \
 107 } while(0)
 108
 109 typedef enum {
 110         NVME_PROBE_NO_ANNOUNCE  = 0x04
 111 } nvme_probe_flags;
 112
 113 typedef struct {
 114         TAILQ_HEAD(, ccb_hdr) request_ccbs;
 115         union {
 116                 struct nvme_controller_data     cd;
 117                 struct nvme_namespace_data      ns;
 118         };
 119         nvme_probe_action       action;
 120         nvme_probe_flags        flags;
 121         int             restart;
 122         struct cam_periph *periph;
 123 } nvme_probe_softc;
 124
 125 static struct nvme_quirk_entry nvme_quirk_table[] =
 126 {
 127         {
 128 //              {
 129 //                T_ANY, SIP_MEDIA_REMOVABLE|SIP_MEDIA_FIXED,
 130 //                /*vendor*/"*", /*product*/"*", /*revision*/"*"
 131 //              },
 132                 .quirks = 0, .mintags = 0, .maxtags = 0
 133         },
 134 };
 135
 136 static const int nvme_quirk_table_size =
 137         sizeof(nvme_quirk_table) / sizeof(*nvme_quirk_table);
 138
 139 static cam_status       nvme_probe_register(struct cam_periph *periph,
 140                                       void *arg);
 141 static void      nvme_probe_schedule(struct cam_periph *nvme_probe_periph);
 142 static void      nvme_probe_start(struct cam_periph *periph, union ccb *start_ccb);
 143 static void      nvme_probe_done(struct cam_periph *periph, union ccb *done_ccb);
 144 static void      nvme_probe_cleanup(struct cam_periph *periph);
 145 //static void    nvme_find_quirk(struct cam_ed *device);
 146 static void      nvme_scan_lun(struct cam_periph *periph,
 147                                struct cam_path *path, cam_flags flags,
 148                                union ccb *ccb);
 149 static struct cam_ed *
 150                  nvme_alloc_device(struct cam_eb *bus, struct cam_et *target,
 151                                    lun_id_t lun_id);
 152 static void      nvme_device_transport(struct cam_path *path);
 153 static void      nvme_dev_async(u_int32_t async_code,
 154                                 struct cam_eb *bus,
 155                                 struct cam_et *target,
 156                                 struct cam_ed *device,
 157                                 void *async_arg);
 158 static void      nvme_action(union ccb *start_ccb);
 159 static void      nvme_announce_periph(struct cam_periph *periph);
 160 static void      nvme_proto_announce(struct cam_ed *device);
 161 static void      nvme_proto_denounce(struct cam_ed *device);
 162 static void      nvme_proto_debug_out(union ccb *ccb);
 163
 164 static struct xpt_xport_ops nvme_xport_ops = {
 165         .alloc_device = nvme_alloc_device,
 166         .action = nvme_action,
 167         .async = nvme_dev_async,
 168         .announce = nvme_announce_periph,
 169 };
 170 #define NVME_XPT_XPORT(x, X)                    \
 171 static struct xpt_xport nvme_xport_ ## x = {    \
 172         .xport = XPORT_ ## X,                   \
 173         .name = #x,                             \
 174         .ops = &nvme_xport_ops,                 \
 175 };                                              \
 176 CAM_XPT_XPORT(nvme_xport_ ## x);
 177
 178 NVME_XPT_XPORT(nvme, NVME);
 179
 180 #undef NVME_XPT_XPORT
 181
 182 static struct xpt_proto_ops nvme_proto_ops = {
 183         .announce = nvme_proto_announce,
 184         .denounce = nvme_proto_denounce,
 185         .debug_out = nvme_proto_debug_out,
 186 };
 187 static struct xpt_proto nvme_proto = {
 188         .proto = PROTO_NVME,
 189         .name = "nvme",
 190         .ops = &nvme_proto_ops,
 191 };
 192 CAM_XPT_PROTO(nvme_proto);
 193
 194 static void
 195 nvme_probe_periph_init(void)
 196 {
 197 }
 198
 199 static cam_status
 200 nvme_probe_register(struct cam_periph *periph, void *arg)
 201 {
 202         union ccb *request_ccb; /* CCB representing the probe request */
 203         nvme_probe_softc *softc;
 204
 205         request_ccb = (union ccb *)arg;
 206         if (request_ccb == NULL) {
 207                 printf("nvme_probe_register: no probe CCB, "
 208                        "can't register device\n");
 209                 return(CAM_REQ_CMP_ERR);
 210         }
 211
 212         softc = (nvme_probe_softc *)malloc(sizeof(*softc), M_CAMXPT, M_ZERO | M_NOWAIT);
 213
 214         if (softc == NULL) {
 215                 printf("nvme_probe_register: Unable to probe new device. "
 216                        "Unable to allocate softc\n");
 217                 return(CAM_REQ_CMP_ERR);
 218         }
 219         TAILQ_INIT(&softc->request_ccbs);
 220         TAILQ_INSERT_TAIL(&softc->request_ccbs, &request_ccb->ccb_h,
 221                           periph_links.tqe);
 222         softc->flags = 0;
 223         periph->softc = softc;
 224         softc->periph = periph;
 225         softc->action = NVME_PROBE_INVALID;
 226         if (cam_periph_acquire(periph) != 0)
 227                 return (CAM_REQ_CMP_ERR);
 228
 229         CAM_DEBUG(periph->path, CAM_DEBUG_PROBE, ("Probe started\n"));
 230
 231 //      nvme_device_transport(periph->path);
 232         nvme_probe_schedule(periph);
 233
 234         return(CAM_REQ_CMP);
 235 }
 236
 237 static void
 238 nvme_probe_schedule(struct cam_periph *periph)
 239 {
 240         union ccb *ccb;
 241         nvme_probe_softc *softc;
 242
 243         softc = (nvme_probe_softc *)periph->softc;
 244         ccb = (union ccb *)TAILQ_FIRST(&softc->request_ccbs);
 245
 246         NVME_PROBE_SET_ACTION(softc, NVME_PROBE_IDENTIFY_CD);
 247
 248         if (ccb->crcn.flags & CAM_EXPECT_INQ_CHANGE)
 249                 softc->flags |= NVME_PROBE_NO_ANNOUNCE;
 250         else
 251                 softc->flags &= ~NVME_PROBE_NO_ANNOUNCE;
 252
 253         xpt_schedule(periph, CAM_PRIORITY_XPT);
 254 }
 255
 256 static void
 257 nvme_probe_start(struct cam_periph *periph, union ccb *start_ccb)
 258 {
 259         struct ccb_nvmeio *nvmeio;
 260         nvme_probe_softc *softc;
 261         struct cam_path *path;
 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         lun = xpt_path_lun_id(periph->path);
 270
 271         if (softc->restart) {
 272                 softc->restart = 0;
 273                 NVME_PROBE_SET_ACTION(softc, NVME_PROBE_IDENTIFY_CD);
 274         }
 275
 276         switch (softc->action) {
 277         case NVME_PROBE_IDENTIFY_CD:
 278                 cam_fill_nvmeadmin(nvmeio,
 279                     0,                  /* retries */
 280                     nvme_probe_done,    /* cbfcnp */
 281                     CAM_DIR_IN,         /* flags */
 282                     (uint8_t *)&softc->cd,      /* data_ptr */
 283                     sizeof(softc->cd),          /* dxfer_len */
 284                     30 * 1000); /* timeout 30s */
 285                 nvme_ns_cmd(nvmeio, NVME_OPC_IDENTIFY, 0,
 286                     1, 0, 0, 0, 0, 0);
 287                 break;
 288         case NVME_PROBE_IDENTIFY_NS:
 289                 cam_fill_nvmeadmin(nvmeio,
 290                     0,                  /* retries */
 291                     nvme_probe_done,    /* cbfcnp */
 292                     CAM_DIR_IN,         /* flags */
 293                     (uint8_t *)&softc->ns,      /* data_ptr */
 294                     sizeof(softc->ns),          /* dxfer_len */
 295                     30 * 1000); /* timeout 30s */
 296                 nvme_ns_cmd(nvmeio, NVME_OPC_IDENTIFY, lun,
 297                     0, 0, 0, 0, 0, 0);
 298                 break;
 299         default:
 300                 panic("nvme_probe_start: invalid action state 0x%x\n", softc->action);
 301         }
 302         start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
 303         xpt_action(start_ccb);
 304 }
 305
 306 static void
 307 nvme_probe_done(struct cam_periph *periph, union ccb *done_ccb)
 308 {
 309         struct nvme_namespace_data *nvme_data;
 310         struct nvme_controller_data *nvme_cdata;
 311         nvme_probe_softc *softc;
 312         struct cam_path *path;
 313         cam_status status;
 314         u_int32_t  priority;
 315         int found = 1;
 316
 317         CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_TRACE, ("nvme_probe_done\n"));
 318
 319         softc = (nvme_probe_softc *)periph->softc;
 320         path = done_ccb->ccb_h.path;
 321         priority = done_ccb->ccb_h.pinfo.priority;
 322
 323         if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
 324                 if (cam_periph_error(done_ccb,
 325                         0, softc->restart ? (SF_NO_RECOVERY | SF_NO_RETRY) : 0
 326                     ) == ERESTART) {
 327 out:
 328                         /* Drop freeze taken due to CAM_DEV_QFREEZE flag set. */
 329                         cam_release_devq(path, 0, 0, 0, FALSE);
 330                         return;
 331                 }
 332                 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
 333                         /* Don't wedge the queue */
 334                         xpt_release_devq(path, /*count*/1, /*run_queue*/TRUE);
 335                 }
 336                 status = done_ccb->ccb_h.status & CAM_STATUS_MASK;
 337
 338                 /*
 339                  * If we get to this point, we got an error status back
 340                  * from the inquiry and the error status doesn't require
 341                  * automatically retrying the command.  Therefore, the
 342                  * inquiry failed.  If we had inquiry information before
 343                  * for this device, but this latest inquiry command failed,
 344                  * the device has probably gone away.  If this device isn't
 345                  * already marked unconfigured, notify the peripheral
 346                  * drivers that this device is no more.
 347                  */
 348 device_fail:    if ((path->device->flags & CAM_DEV_UNCONFIGURED) == 0)
 349                         xpt_async(AC_LOST_DEVICE, path, NULL);
 350                 NVME_PROBE_SET_ACTION(softc, NVME_PROBE_INVALID);
 351                 found = 0;
 352                 goto done;
 353         }
 354         if (softc->restart)
 355                 goto done;
 356         switch (softc->action) {
 357         case NVME_PROBE_IDENTIFY_CD:
 358                 nvme_controller_data_swapbytes(&softc->cd);
 359
 360                 nvme_cdata = path->device->nvme_cdata;
 361                 if (nvme_cdata == NULL) {
 362                         nvme_cdata = malloc(sizeof(*nvme_cdata), M_CAMXPT,
 363                             M_NOWAIT);
 364                         if (nvme_cdata == NULL) {
 365                                 xpt_print(path, "Can't allocate memory");
 366                                 goto device_fail;
 367                         }
 368                 }
 369                 bcopy(&softc->cd, nvme_cdata, sizeof(*nvme_cdata));
 370                 path->device->nvme_cdata = nvme_cdata;
 371
 372 //              nvme_find_quirk(path->device);
 373                 nvme_device_transport(path);
 374                 NVME_PROBE_SET_ACTION(softc, NVME_PROBE_IDENTIFY_NS);
 375                 xpt_release_ccb(done_ccb);
 376                 xpt_schedule(periph, priority);
 377                 goto out;
 378         case NVME_PROBE_IDENTIFY_NS:
 379                 nvme_namespace_data_swapbytes(&softc->ns);
 380
 381                 /* Check that the namespace exists. */
 382                 if (softc->ns.nsze == 0)
 383                         goto device_fail;
 384
 385                 nvme_data = path->device->nvme_data;
 386                 if (nvme_data == NULL) {
 387                         nvme_data = malloc(sizeof(*nvme_data), M_CAMXPT,
 388                             M_NOWAIT);
 389                         if (nvme_data == NULL) {
 390                                 xpt_print(path, "Can't allocate memory");
 391                                 goto device_fail;
 392                         }
 393                 }
 394                 bcopy(&softc->ns, nvme_data, sizeof(*nvme_data));
 395                 path->device->nvme_data = nvme_data;
 396
 397                 if (periph->path->device->flags & CAM_DEV_UNCONFIGURED) {
 398                         path->device->flags &= ~CAM_DEV_UNCONFIGURED;
 399                         xpt_acquire_device(path->device);
 400                         done_ccb->ccb_h.func_code = XPT_GDEV_TYPE;
 401                         xpt_action(done_ccb);
 402                         xpt_async(AC_FOUND_DEVICE, path, done_ccb);
 403                 }
 404                 NVME_PROBE_SET_ACTION(softc, NVME_PROBE_DONE);
 405                 break;
 406         default:
 407                 panic("nvme_probe_done: invalid action state 0x%x\n", softc->action);
 408         }
 409 done:
 410         if (softc->restart) {
 411                 softc->restart = 0;
 412                 xpt_release_ccb(done_ccb);
 413                 nvme_probe_schedule(periph);
 414                 goto out;
 415         }
 416         xpt_release_ccb(done_ccb);
 417         CAM_DEBUG(periph->path, CAM_DEBUG_PROBE, ("Probe completed\n"));
 418         while ((done_ccb = (union ccb *)TAILQ_FIRST(&softc->request_ccbs))) {
 419                 TAILQ_REMOVE(&softc->request_ccbs,
 420                     &done_ccb->ccb_h, periph_links.tqe);
 421                 done_ccb->ccb_h.status = found ? CAM_REQ_CMP : CAM_REQ_CMP_ERR;
 422                 xpt_done(done_ccb);
 423         }
 424         /* Drop freeze taken due to CAM_DEV_QFREEZE flag set. */
 425         cam_release_devq(path, 0, 0, 0, FALSE);
 426         cam_periph_invalidate(periph);
 427         cam_periph_release_locked(periph);
 428 }
 429
 430 static void
 431 nvme_probe_cleanup(struct cam_periph *periph)
 432 {
 433
 434         free(periph->softc, M_CAMXPT);
 435 }
 436
 437 #if 0
 438 /* XXX should be used, don't delete */
 439 static void
 440 nvme_find_quirk(struct cam_ed *device)
 441 {
 442         struct nvme_quirk_entry *quirk;
 443         caddr_t match;
 444
 445         match = cam_quirkmatch((caddr_t)&device->nvme_data,
 446                                (caddr_t)nvme_quirk_table,
 447                                nvme_quirk_table_size,
 448                                sizeof(*nvme_quirk_table), nvme_identify_match);
 449
 450         if (match == NULL)
 451                 panic("xpt_find_quirk: device didn't match wildcard entry!!");
 452
 453         quirk = (struct nvme_quirk_entry *)match;
 454         device->quirk = quirk;
 455         if (quirk->quirks & CAM_QUIRK_MAXTAGS) {
 456                 device->mintags = quirk->mintags;
 457                 device->maxtags = quirk->maxtags;
 458         }
 459 }
 460 #endif
 461
 462 static void
 463 nvme_scan_lun(struct cam_periph *periph, struct cam_path *path,
 464              cam_flags flags, union ccb *request_ccb)
 465 {
 466         struct ccb_pathinq cpi;
 467         cam_status status;
 468         struct cam_periph *old_periph;
 469         int lock;
 470
 471         CAM_DEBUG(path, CAM_DEBUG_TRACE, ("nvme_scan_lun\n"));
 472
 473         xpt_path_inq(&cpi, path);
 474
 475         if (cpi.ccb_h.status != CAM_REQ_CMP) {
 476                 if (request_ccb != NULL) {
 477                         request_ccb->ccb_h.status = cpi.ccb_h.status;
 478                         xpt_done(request_ccb);
 479                 }
 480                 return;
 481         }
 482
 483         if (xpt_path_lun_id(path) == CAM_LUN_WILDCARD) {
 484                 CAM_DEBUG(path, CAM_DEBUG_TRACE, ("nvme_scan_lun ignoring bus\n"));
 485                 request_ccb->ccb_h.status = CAM_REQ_CMP;        /* XXX signal error ? */
 486                 xpt_done(request_ccb);
 487                 return;
 488         }
 489
 490         lock = (xpt_path_owned(path) == 0);
 491         if (lock)
 492                 xpt_path_lock(path);
 493         if ((old_periph = cam_periph_find(path, "nvme_probe")) != NULL) {
 494                 if ((old_periph->flags & CAM_PERIPH_INVALID) == 0) {
 495                         nvme_probe_softc *softc;
 496
 497                         softc = (nvme_probe_softc *)old_periph->softc;
 498                         TAILQ_INSERT_TAIL(&softc->request_ccbs,
 499                                 &request_ccb->ccb_h, periph_links.tqe);
 500                         softc->restart = 1;
 501                         CAM_DEBUG(path, CAM_DEBUG_TRACE,
 502                             ("restarting nvme_probe device\n"));
 503                 } else {
 504                         request_ccb->ccb_h.status = CAM_REQ_CMP_ERR;
 505                         CAM_DEBUG(path, CAM_DEBUG_TRACE,
 506                             ("Failing to restart nvme_probe device\n"));
 507                         xpt_done(request_ccb);
 508                 }
 509         } else {
 510                 CAM_DEBUG(path, CAM_DEBUG_TRACE,
 511                     ("Adding nvme_probe device\n"));
 512                 status = cam_periph_alloc(nvme_probe_register, NULL, nvme_probe_cleanup,
 513                                           nvme_probe_start, "nvme_probe",
 514                                           CAM_PERIPH_BIO,
 515                                           request_ccb->ccb_h.path, NULL, 0,
 516                                           request_ccb);
 517
 518                 if (status != CAM_REQ_CMP) {
 519                         xpt_print(path, "xpt_scan_lun: cam_alloc_periph "
 520                             "returned an error, can't continue probe\n");
 521                         request_ccb->ccb_h.status = status;
 522                         xpt_done(request_ccb);
 523                 }
 524         }
 525         if (lock)
 526                 xpt_path_unlock(path);
 527 }
 528
 529 static struct cam_ed *
 530 nvme_alloc_device(struct cam_eb *bus, struct cam_et *target, lun_id_t lun_id)
 531 {
 532         struct nvme_quirk_entry *quirk;
 533         struct cam_ed *device;
 534
 535         device = xpt_alloc_device(bus, target, lun_id);
 536         if (device == NULL)
 537                 return (NULL);
 538
 539         /*
 540          * Take the default quirk entry until we have inquiry
 541          * data from nvme and can determine a better quirk to use.
 542          */
 543         quirk = &nvme_quirk_table[nvme_quirk_table_size - 1];
 544         device->quirk = (void *)quirk;
 545         device->mintags = 0;
 546         device->maxtags = 0;
 547         device->inq_flags = 0;
 548         device->queue_flags = 0;
 549         device->device_id = NULL;       /* XXX Need to set this somewhere */
 550         device->device_id_len = 0;
 551         device->serial_num = NULL;      /* XXX Need to set this somewhere */
 552         device->serial_num_len = 0;
 553         return (device);
 554 }
 555
 556 static void
 557 nvme_device_transport(struct cam_path *path)
 558 {
 559         struct ccb_pathinq cpi;
 560         struct ccb_trans_settings cts;
 561         /* XXX get data from nvme namespace and other info ??? */
 562
 563         /* Get transport information from the SIM */
 564         xpt_path_inq(&cpi, path);
 565
 566         path->device->transport = cpi.transport;
 567         path->device->transport_version = cpi.transport_version;
 568
 569         path->device->protocol = cpi.protocol;
 570         path->device->protocol_version = cpi.protocol_version;
 571
 572         /* Tell the controller what we think */
 573         xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NONE);
 574         cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
 575         cts.type = CTS_TYPE_CURRENT_SETTINGS;
 576         cts.transport = path->device->transport;
 577         cts.transport_version = path->device->transport_version;
 578         cts.protocol = path->device->protocol;
 579         cts.protocol_version = path->device->protocol_version;
 580         cts.proto_specific.valid = 0;
 581         cts.xport_specific.valid = 0;
 582         xpt_action((union ccb *)&cts);
 583 }
 584
 585 static void
 586 nvme_dev_advinfo(union ccb *start_ccb)
 587 {
 588         struct cam_ed *device;
 589         struct ccb_dev_advinfo *cdai;
 590         off_t amt;
 591
 592         xpt_path_assert(start_ccb->ccb_h.path, MA_OWNED);
 593         start_ccb->ccb_h.status = CAM_REQ_INVALID;
 594         device = start_ccb->ccb_h.path->device;
 595         cdai = &start_ccb->cdai;
 596         switch(cdai->buftype) {
 597         case CDAI_TYPE_SCSI_DEVID:
 598                 if (cdai->flags & CDAI_FLAG_STORE)
 599                         return;
 600                 cdai->provsiz = device->device_id_len;
 601                 if (device->device_id_len == 0)
 602                         break;
 603                 amt = device->device_id_len;
 604                 if (cdai->provsiz > cdai->bufsiz)
 605                         amt = cdai->bufsiz;
 606                 memcpy(cdai->buf, device->device_id, amt);
 607                 break;
 608         case CDAI_TYPE_SERIAL_NUM:
 609                 if (cdai->flags & CDAI_FLAG_STORE)
 610                         return;
 611                 cdai->provsiz = device->serial_num_len;
 612                 if (device->serial_num_len == 0)
 613                         break;
 614                 amt = device->serial_num_len;
 615                 if (cdai->provsiz > cdai->bufsiz)
 616                         amt = cdai->bufsiz;
 617                 memcpy(cdai->buf, device->serial_num, amt);
 618                 break;
 619         case CDAI_TYPE_PHYS_PATH:
 620                 if (cdai->flags & CDAI_FLAG_STORE) {
 621                         if (device->physpath != NULL)
 622                                 free(device->physpath, M_CAMXPT);
 623                         device->physpath_len = cdai->bufsiz;
 624                         /* Clear existing buffer if zero length */
 625                         if (cdai->bufsiz == 0)
 626                                 break;
 627                         device->physpath = malloc(cdai->bufsiz, M_CAMXPT, M_NOWAIT);
 628                         if (device->physpath == NULL) {
 629                                 start_ccb->ccb_h.status = CAM_REQ_ABORTED;
 630                                 return;
 631                         }
 632                         memcpy(device->physpath, cdai->buf, cdai->bufsiz);
 633                 } else {
 634                         cdai->provsiz = device->physpath_len;
 635                         if (device->physpath_len == 0)
 636                                 break;
 637                         amt = device->physpath_len;
 638                         if (cdai->provsiz > cdai->bufsiz)
 639                                 amt = cdai->bufsiz;
 640                         memcpy(cdai->buf, device->physpath, amt);
 641                 }
 642                 break;
 643         case CDAI_TYPE_NVME_CNTRL:
 644                 if (cdai->flags & CDAI_FLAG_STORE)
 645                         return;
 646                 amt = sizeof(struct nvme_controller_data);
 647                 cdai->provsiz = amt;
 648                 if (amt > cdai->bufsiz)
 649                         amt = cdai->bufsiz;
 650                 memcpy(cdai->buf, device->nvme_cdata, amt);
 651                 break;
 652         case CDAI_TYPE_NVME_NS:
 653                 if (cdai->flags & CDAI_FLAG_STORE)
 654                         return;
 655                 amt = sizeof(struct nvme_namespace_data);
 656                 cdai->provsiz = amt;
 657                 if (amt > cdai->bufsiz)
 658                         amt = cdai->bufsiz;
 659                 memcpy(cdai->buf, device->nvme_data, amt);
 660                 break;
 661         default:
 662                 return;
 663         }
 664         start_ccb->ccb_h.status = CAM_REQ_CMP;
 665
 666         if (cdai->flags & CDAI_FLAG_STORE) {
 667                 xpt_async(AC_ADVINFO_CHANGED, start_ccb->ccb_h.path,
 668                           (void *)(uintptr_t)cdai->buftype);
 669         }
 670 }
 671
 672 static void
 673 nvme_action(union ccb *start_ccb)
 674 {
 675         CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_TRACE,
 676             ("nvme_action: func= %#x\n", start_ccb->ccb_h.func_code));
 677
 678         switch (start_ccb->ccb_h.func_code) {
 679         case XPT_SCAN_BUS:
 680         case XPT_SCAN_TGT:
 681         case XPT_SCAN_LUN:
 682                 nvme_scan_lun(start_ccb->ccb_h.path->periph,
 683                               start_ccb->ccb_h.path, start_ccb->crcn.flags,
 684                               start_ccb);
 685                 break;
 686         case XPT_DEV_ADVINFO:
 687                 nvme_dev_advinfo(start_ccb);
 688                 break;
 689
 690         default:
 691                 xpt_action_default(start_ccb);
 692                 break;
 693         }
 694 }
 695
 696 /*
 697  * Handle any per-device event notifications that require action by the XPT.
 698  */
 699 static void
 700 nvme_dev_async(u_int32_t async_code, struct cam_eb *bus, struct cam_et *target,
 701               struct cam_ed *device, void *async_arg)
 702 {
 703
 704         /*
 705          * We only need to handle events for real devices.
 706          */
 707         if (target->target_id == CAM_TARGET_WILDCARD
 708          || device->lun_id == CAM_LUN_WILDCARD)
 709                 return;
 710
 711         if (async_code == AC_LOST_DEVICE &&
 712             (device->flags & CAM_DEV_UNCONFIGURED) == 0) {
 713                 device->flags |= CAM_DEV_UNCONFIGURED;
 714                 xpt_release_device(device);
 715         }
 716 }
 717
 718 static void
 719 nvme_announce_periph(struct cam_periph *periph)
 720 {
 721         struct  ccb_pathinq cpi;
 722         struct  ccb_trans_settings cts;
 723         struct  cam_path *path = periph->path;
 724         struct ccb_trans_settings_nvme  *nvmex;
 725         struct sbuf     sb;
 726         char            buffer[120];
 727
 728         cam_periph_assert(periph, MA_OWNED);
 729
 730         /* Ask the SIM for connection details */
 731         xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NORMAL);
 732         cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
 733         cts.type = CTS_TYPE_CURRENT_SETTINGS;
 734         xpt_action((union ccb*)&cts);
 735         if ((cts.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)
 736                 return;
 737         nvmex = &cts.xport_specific.nvme;
 738
 739         /* Ask the SIM for its base transfer speed */
 740         xpt_path_inq(&cpi, periph->path);
 741         sbuf_new(&sb, buffer, sizeof(buffer), SBUF_FIXEDLEN);
 742         sbuf_printf(&sb, "%s%d: nvme version %d.%d",
 743             periph->periph_name, periph->unit_number,
 744             NVME_MAJOR(nvmex->spec),
 745             NVME_MINOR(nvmex->spec));
 746         if (nvmex->valid & CTS_NVME_VALID_LINK)
 747                 sbuf_printf(&sb, " x%d (max x%d) lanes PCIe Gen%d (max Gen%d) link",
 748                     nvmex->lanes, nvmex->max_lanes,
 749                     nvmex->speed, nvmex->max_speed);
 750         sbuf_printf(&sb, "\n");
 751         sbuf_finish(&sb);
 752         sbuf_putbuf(&sb);
 753 }
 754
 755 static void
 756 nvme_proto_announce(struct cam_ed *device)
 757 {
 758         struct sbuf     sb;
 759         char            buffer[120];
 760
 761         sbuf_new(&sb, buffer, sizeof(buffer), SBUF_FIXEDLEN);
 762         nvme_print_ident(device->nvme_cdata, device->nvme_data, &sb);
 763         sbuf_finish(&sb);
 764         sbuf_putbuf(&sb);
 765 }
 766
 767 static void
 768 nvme_proto_denounce(struct cam_ed *device)
 769 {
 770
 771         nvme_proto_announce(device);
 772 }
 773
 774 static void
 775 nvme_proto_debug_out(union ccb *ccb)
 776 {
 777         char cdb_str[(sizeof(struct nvme_command) * 3) + 1];
 778
 779         if (ccb->ccb_h.func_code != XPT_NVME_IO &&
 780             ccb->ccb_h.func_code != XPT_NVME_ADMIN)
 781                 return;
 782
 783         CAM_DEBUG(ccb->ccb_h.path,
 784             CAM_DEBUG_CDB,("%s. NCB: %s\n", nvme_op_string(&ccb->nvmeio.cmd,
 785                 ccb->ccb_h.func_code == XPT_NVME_ADMIN),
 786                 nvme_cmd_string(&ccb->nvmeio.cmd, cdb_str, sizeof(cdb_str))));
 787 }
 788