sys/cam/scsi/scsi_da.c

   1 /*-
   2  * Implementation of SCSI Direct Access Peripheral driver for CAM.
   3  *
   4  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   5  *
   6  * Copyright (c) 1997 Justin T. Gibbs.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions, and the following disclaimer,
  14  *    without modification, immediately at the beginning of the file.
  15  * 2. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  22  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <sys/param.h>
  35
  36 #ifdef _KERNEL
  37 #include "opt_da.h"
  38 #include <sys/systm.h>
  39 #include <sys/kernel.h>
  40 #include <sys/bio.h>
  41 #include <sys/sysctl.h>
  42 #include <sys/taskqueue.h>
  43 #include <sys/lock.h>
  44 #include <sys/mutex.h>
  45 #include <sys/conf.h>
  46 #include <sys/devicestat.h>
  47 #include <sys/eventhandler.h>
  48 #include <sys/malloc.h>
  49 #include <sys/cons.h>
  50 #include <sys/endian.h>
  51 #include <sys/proc.h>
  52 #include <sys/sbuf.h>
  53 #include <geom/geom.h>
  54 #include <geom/geom_disk.h>
  55 #include <machine/atomic.h>
  56 #endif /* _KERNEL */
  57
  58 #ifndef _KERNEL
  59 #include <stdio.h>
  60 #include <string.h>
  61 #endif /* _KERNEL */
  62
  63 #include <cam/cam.h>
  64 #include <cam/cam_ccb.h>
  65 #include <cam/cam_periph.h>
  66 #include <cam/cam_xpt_periph.h>
  67 #include <cam/cam_sim.h>
  68 #include <cam/cam_iosched.h>
  69
  70 #include <cam/scsi/scsi_message.h>
  71 #include <cam/scsi/scsi_da.h>
  72
  73 #ifdef _KERNEL
  74 /*
  75  * Note that there are probe ordering dependencies here.  The order isn't
  76  * controlled by this enumeration, but by explicit state transitions in
  77  * dastart() and dadone().  Here are some of the dependencies:
  78  *
  79  * 1. RC should come first, before RC16, unless there is evidence that RC16
  80  *    is supported.
  81  * 2. BDC needs to come before any of the ATA probes, or the ZONE probe.
  82  * 3. The ATA probes should go in this order:
  83  *    ATA -> LOGDIR -> IDDIR -> SUP -> ATA_ZONE
  84  */
  85 typedef enum {
  86         DA_STATE_PROBE_WP,
  87         DA_STATE_PROBE_RC,
  88         DA_STATE_PROBE_RC16,
  89         DA_STATE_PROBE_LBP,
  90         DA_STATE_PROBE_BLK_LIMITS,
  91         DA_STATE_PROBE_BDC,
  92         DA_STATE_PROBE_ATA,
  93         DA_STATE_PROBE_ATA_LOGDIR,
  94         DA_STATE_PROBE_ATA_IDDIR,
  95         DA_STATE_PROBE_ATA_SUP,
  96         DA_STATE_PROBE_ATA_ZONE,
  97         DA_STATE_PROBE_ZONE,
  98         DA_STATE_NORMAL
  99 } da_state;
 100
 101 typedef enum {
 102         DA_FLAG_PACK_INVALID    = 0x000001,
 103         DA_FLAG_NEW_PACK        = 0x000002,
 104         DA_FLAG_PACK_LOCKED     = 0x000004,
 105         DA_FLAG_PACK_REMOVABLE  = 0x000008,
 106         DA_FLAG_NEED_OTAG       = 0x000020,
 107         DA_FLAG_WAS_OTAG        = 0x000040,
 108         DA_FLAG_RETRY_UA        = 0x000080,
 109         DA_FLAG_OPEN            = 0x000100,
 110         DA_FLAG_SCTX_INIT       = 0x000200,
 111         DA_FLAG_CAN_RC16        = 0x000400,
 112         DA_FLAG_PROBED          = 0x000800,
 113         DA_FLAG_DIRTY           = 0x001000,
 114         DA_FLAG_ANNOUNCED       = 0x002000,
 115         DA_FLAG_CAN_ATA_DMA     = 0x004000,
 116         DA_FLAG_CAN_ATA_LOG     = 0x008000,
 117         DA_FLAG_CAN_ATA_IDLOG   = 0x010000,
 118         DA_FLAG_CAN_ATA_SUPCAP  = 0x020000,
 119         DA_FLAG_CAN_ATA_ZONE    = 0x040000,
 120         DA_FLAG_TUR_PENDING     = 0x080000
 121 } da_flags;
 122
 123 typedef enum {
 124         DA_Q_NONE               = 0x00,
 125         DA_Q_NO_SYNC_CACHE      = 0x01,
 126         DA_Q_NO_6_BYTE          = 0x02,
 127         DA_Q_NO_PREVENT         = 0x04,
 128         DA_Q_4K                 = 0x08,
 129         DA_Q_NO_RC16            = 0x10,
 130         DA_Q_NO_UNMAP           = 0x20,
 131         DA_Q_RETRY_BUSY         = 0x40,
 132         DA_Q_SMR_DM             = 0x80,
 133         DA_Q_STRICT_UNMAP       = 0x100
 134 } da_quirks;
 135
 136 #define DA_Q_BIT_STRING         \
 137         "\020"                  \
 138         "\001NO_SYNC_CACHE"     \
 139         "\002NO_6_BYTE"         \
 140         "\003NO_PREVENT"        \
 141         "\0044K"                \
 142         "\005NO_RC16"           \
 143         "\006NO_UNMAP"          \
 144         "\007RETRY_BUSY"        \
 145         "\010SMR_DM"            \
 146         "\011STRICT_UNMAP"
 147
 148 typedef enum {
 149         DA_CCB_PROBE_RC         = 0x01,
 150         DA_CCB_PROBE_RC16       = 0x02,
 151         DA_CCB_PROBE_LBP        = 0x03,
 152         DA_CCB_PROBE_BLK_LIMITS = 0x04,
 153         DA_CCB_PROBE_BDC        = 0x05,
 154         DA_CCB_PROBE_ATA        = 0x06,
 155         DA_CCB_BUFFER_IO        = 0x07,
 156         DA_CCB_DUMP             = 0x0A,
 157         DA_CCB_DELETE           = 0x0B,
 158         DA_CCB_TUR              = 0x0C,
 159         DA_CCB_PROBE_ZONE       = 0x0D,
 160         DA_CCB_PROBE_ATA_LOGDIR = 0x0E,
 161         DA_CCB_PROBE_ATA_IDDIR  = 0x0F,
 162         DA_CCB_PROBE_ATA_SUP    = 0x10,
 163         DA_CCB_PROBE_ATA_ZONE   = 0x11,
 164         DA_CCB_PROBE_WP         = 0x12,
 165         DA_CCB_TYPE_MASK        = 0x1F,
 166         DA_CCB_RETRY_UA         = 0x20
 167 } da_ccb_state;
 168
 169 /*
 170  * Order here is important for method choice
 171  *
 172  * We prefer ATA_TRIM as tests run against a Sandforce 2281 SSD attached to
 173  * LSI 2008 (mps) controller (FW: v12, Drv: v14) resulted 20% quicker deletes
 174  * using ATA_TRIM than the corresponding UNMAP results for a real world mysql
 175  * import taking 5mins.
 176  *
 177  */
 178 typedef enum {
 179         DA_DELETE_NONE,
 180         DA_DELETE_DISABLE,
 181         DA_DELETE_ATA_TRIM,
 182         DA_DELETE_UNMAP,
 183         DA_DELETE_WS16,
 184         DA_DELETE_WS10,
 185         DA_DELETE_ZERO,
 186         DA_DELETE_MIN = DA_DELETE_ATA_TRIM,
 187         DA_DELETE_MAX = DA_DELETE_ZERO
 188 } da_delete_methods;
 189
 190 /*
 191  * For SCSI, host managed drives show up as a separate device type.  For
 192  * ATA, host managed drives also have a different device signature.
 193  * XXX KDM figure out the ATA host managed signature.
 194  */
 195 typedef enum {
 196         DA_ZONE_NONE            = 0x00,
 197         DA_ZONE_DRIVE_MANAGED   = 0x01,
 198         DA_ZONE_HOST_AWARE      = 0x02,
 199         DA_ZONE_HOST_MANAGED    = 0x03
 200 } da_zone_mode;
 201
 202 /*
 203  * We distinguish between these interface cases in addition to the drive type:
 204  * o ATA drive behind a SCSI translation layer that knows about ZBC/ZAC
 205  * o ATA drive behind a SCSI translation layer that does not know about
 206  *   ZBC/ZAC, and so needs to be managed via ATA passthrough.  In this
 207  *   case, we would need to share the ATA code with the ada(4) driver.
 208  * o SCSI drive.
 209  */
 210 typedef enum {
 211         DA_ZONE_IF_SCSI,
 212         DA_ZONE_IF_ATA_PASS,
 213         DA_ZONE_IF_ATA_SAT,
 214 } da_zone_interface;
 215
 216 typedef enum {
 217         DA_ZONE_FLAG_RZ_SUP             = 0x0001,
 218         DA_ZONE_FLAG_OPEN_SUP           = 0x0002,
 219         DA_ZONE_FLAG_CLOSE_SUP          = 0x0004,
 220         DA_ZONE_FLAG_FINISH_SUP         = 0x0008,
 221         DA_ZONE_FLAG_RWP_SUP            = 0x0010,
 222         DA_ZONE_FLAG_SUP_MASK           = (DA_ZONE_FLAG_RZ_SUP |
 223                                            DA_ZONE_FLAG_OPEN_SUP |
 224                                            DA_ZONE_FLAG_CLOSE_SUP |
 225                                            DA_ZONE_FLAG_FINISH_SUP |
 226                                            DA_ZONE_FLAG_RWP_SUP),
 227         DA_ZONE_FLAG_URSWRZ             = 0x0020,
 228         DA_ZONE_FLAG_OPT_SEQ_SET        = 0x0040,
 229         DA_ZONE_FLAG_OPT_NONSEQ_SET     = 0x0080,
 230         DA_ZONE_FLAG_MAX_SEQ_SET        = 0x0100,
 231         DA_ZONE_FLAG_SET_MASK           = (DA_ZONE_FLAG_OPT_SEQ_SET |
 232                                            DA_ZONE_FLAG_OPT_NONSEQ_SET |
 233                                            DA_ZONE_FLAG_MAX_SEQ_SET)
 234 } da_zone_flags;
 235
 236 static struct da_zone_desc {
 237         da_zone_flags value;
 238         const char *desc;
 239 } da_zone_desc_table[] = {
 240         {DA_ZONE_FLAG_RZ_SUP, "Report Zones" },
 241         {DA_ZONE_FLAG_OPEN_SUP, "Open" },
 242         {DA_ZONE_FLAG_CLOSE_SUP, "Close" },
 243         {DA_ZONE_FLAG_FINISH_SUP, "Finish" },
 244         {DA_ZONE_FLAG_RWP_SUP, "Reset Write Pointer" },
 245 };
 246
 247 typedef void da_delete_func_t (struct cam_periph *periph, union ccb *ccb,
 248                               struct bio *bp);
 249 static da_delete_func_t da_delete_trim;
 250 static da_delete_func_t da_delete_unmap;
 251 static da_delete_func_t da_delete_ws;
 252
 253 static const void * da_delete_functions[] = {
 254         NULL,
 255         NULL,
 256         da_delete_trim,
 257         da_delete_unmap,
 258         da_delete_ws,
 259         da_delete_ws,
 260         da_delete_ws
 261 };
 262
 263 static const char *da_delete_method_names[] =
 264     { "NONE", "DISABLE", "ATA_TRIM", "UNMAP", "WS16", "WS10", "ZERO" };
 265 static const char *da_delete_method_desc[] =
 266     { "NONE", "DISABLED", "ATA TRIM", "UNMAP", "WRITE SAME(16) with UNMAP",
 267       "WRITE SAME(10) with UNMAP", "ZERO" };
 268
 269 /* Offsets into our private area for storing information */
 270 #define ccb_state       ppriv_field0
 271 #define ccb_bp          ppriv_ptr1
 272
 273 struct disk_params {
 274         u_int8_t  heads;
 275         u_int32_t cylinders;
 276         u_int8_t  secs_per_track;
 277         u_int32_t secsize;      /* Number of bytes/sector */
 278         u_int64_t sectors;      /* total number sectors */
 279         u_int     stripesize;
 280         u_int     stripeoffset;
 281 };
 282
 283 #define UNMAP_RANGE_MAX         0xffffffff
 284 #define UNMAP_HEAD_SIZE         8
 285 #define UNMAP_RANGE_SIZE        16
 286 #define UNMAP_MAX_RANGES        2048 /* Protocol Max is 4095 */
 287 #define UNMAP_BUF_SIZE          ((UNMAP_MAX_RANGES * UNMAP_RANGE_SIZE) + \
 288                                 UNMAP_HEAD_SIZE)
 289
 290 #define WS10_MAX_BLKS           0xffff
 291 #define WS16_MAX_BLKS           0xffffffff
 292 #define ATA_TRIM_MAX_RANGES     ((UNMAP_BUF_SIZE / \
 293         (ATA_DSM_RANGE_SIZE * ATA_DSM_BLK_SIZE)) * ATA_DSM_BLK_SIZE)
 294
 295 #define DA_WORK_TUR             (1 << 16)
 296
 297 typedef enum {
 298         DA_REF_OPEN = 1,
 299         DA_REF_OPEN_HOLD,
 300         DA_REF_CLOSE_HOLD,
 301         DA_REF_PROBE_HOLD,
 302         DA_REF_TUR,
 303         DA_REF_GEOM,
 304         DA_REF_SYSCTL,
 305         DA_REF_REPROBE,
 306         DA_REF_MAX              /* KEEP LAST */
 307 } da_ref_token;
 308
 309 struct da_softc {
 310         struct   cam_iosched_softc *cam_iosched;
 311         struct   bio_queue_head delete_run_queue;
 312         LIST_HEAD(, ccb_hdr) pending_ccbs;
 313         int      refcount;              /* Active xpt_action() calls */
 314         da_state state;
 315         da_flags flags;
 316         da_quirks quirks;
 317         int      minimum_cmd_size;
 318         int      error_inject;
 319         int      trim_max_ranges;
 320         int      delete_available;      /* Delete methods possibly available */
 321         da_zone_mode                    zone_mode;
 322         da_zone_interface               zone_interface;
 323         da_zone_flags                   zone_flags;
 324         struct ata_gp_log_dir           ata_logdir;
 325         int                             valid_logdir_len;
 326         struct ata_identify_log_pages   ata_iddir;
 327         int                             valid_iddir_len;
 328         uint64_t                        optimal_seq_zones;
 329         uint64_t                        optimal_nonseq_zones;
 330         uint64_t                        max_seq_zones;
 331         u_int                   maxio;
 332         uint32_t                unmap_max_ranges;
 333         uint32_t                unmap_max_lba; /* Max LBAs in UNMAP req */
 334         uint32_t                unmap_gran;
 335         uint32_t                unmap_gran_align;
 336         uint64_t                ws_max_blks;
 337         da_delete_methods       delete_method_pref;
 338         da_delete_methods       delete_method;
 339         da_delete_func_t        *delete_func;
 340         int                     unmappedio;
 341         int                     rotating;
 342         struct   disk_params params;
 343         struct   disk *disk;
 344         union    ccb saved_ccb;
 345         struct task             sysctl_task;
 346         struct sysctl_ctx_list  sysctl_ctx;
 347         struct sysctl_oid       *sysctl_tree;
 348         struct callout          sendordered_c;
 349         uint64_t wwpn;
 350         uint8_t  unmap_buf[UNMAP_BUF_SIZE];
 351         struct scsi_read_capacity_data_long rcaplong;
 352         struct callout          mediapoll_c;
 353         int                     ref_flags[DA_REF_MAX];
 354 #ifdef CAM_IO_STATS
 355         struct sysctl_ctx_list  sysctl_stats_ctx;
 356         struct sysctl_oid       *sysctl_stats_tree;
 357         u_int   errors;
 358         u_int   timeouts;
 359         u_int   invalidations;
 360 #endif
 361 #define DA_ANNOUNCETMP_SZ 160
 362         char                    announce_temp[DA_ANNOUNCETMP_SZ];
 363 #define DA_ANNOUNCE_SZ 400
 364         char                    announcebuf[DA_ANNOUNCE_SZ];
 365 };
 366
 367 #define dadeleteflag(softc, delete_method, enable)                      \
 368         if (enable) {                                                   \
 369                 softc->delete_available |= (1 << delete_method);        \
 370         } else {                                                        \
 371                 softc->delete_available &= ~(1 << delete_method);       \
 372         }
 373
 374 struct da_quirk_entry {
 375         struct scsi_inquiry_pattern inq_pat;
 376         da_quirks quirks;
 377 };
 378
 379 static const char quantum[] = "QUANTUM";
 380 static const char microp[] = "MICROP";
 381
 382 static struct da_quirk_entry da_quirk_table[] =
 383 {
 384         /* SPI, FC devices */
 385         {
 386                 /*
 387                  * Fujitsu M2513A MO drives.
 388                  * Tested devices: M2513A2 firmware versions 1200 & 1300.
 389                  * (dip switch selects whether T_DIRECT or T_OPTICAL device)
 390                  * Reported by: W.Scholten <whs@xs4all.nl>
 391                  */
 392                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "FUJITSU", "M2513A", "*"},
 393                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 394         },
 395         {
 396                 /* See above. */
 397                 {T_OPTICAL, SIP_MEDIA_REMOVABLE, "FUJITSU", "M2513A", "*"},
 398                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 399         },
 400         {
 401                 /*
 402                  * This particular Fujitsu drive doesn't like the
 403                  * synchronize cache command.
 404                  * Reported by: Tom Jackson <toj@gorilla.net>
 405                  */
 406                 {T_DIRECT, SIP_MEDIA_FIXED, "FUJITSU", "M2954*", "*"},
 407                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 408         },
 409         {
 410                 /*
 411                  * This drive doesn't like the synchronize cache command
 412                  * either.  Reported by: Matthew Jacob <mjacob@feral.com>
 413                  * in NetBSD PR kern/6027, August 24, 1998.
 414                  */
 415                 {T_DIRECT, SIP_MEDIA_FIXED, microp, "2217*", "*"},
 416                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 417         },
 418         {
 419                 /*
 420                  * This drive doesn't like the synchronize cache command
 421                  * either.  Reported by: Hellmuth Michaelis (hm@kts.org)
 422                  * (PR 8882).
 423                  */
 424                 {T_DIRECT, SIP_MEDIA_FIXED, microp, "2112*", "*"},
 425                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 426         },
 427         {
 428                 /*
 429                  * Doesn't like the synchronize cache command.
 430                  * Reported by: Blaz Zupan <blaz@gold.amis.net>
 431                  */
 432                 {T_DIRECT, SIP_MEDIA_FIXED, "NEC", "D3847*", "*"},
 433                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 434         },
 435         {
 436                 /*
 437                  * Doesn't like the synchronize cache command.
 438                  * Reported by: Blaz Zupan <blaz@gold.amis.net>
 439                  */
 440                 {T_DIRECT, SIP_MEDIA_FIXED, quantum, "MAVERICK 540S", "*"},
 441                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 442         },
 443         {
 444                 /*
 445                  * Doesn't like the synchronize cache command.
 446                  */
 447                 {T_DIRECT, SIP_MEDIA_FIXED, quantum, "LPS525S", "*"},
 448                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 449         },
 450         {
 451                 /*
 452                  * Doesn't like the synchronize cache command.
 453                  * Reported by: walter@pelissero.de
 454                  */
 455                 {T_DIRECT, SIP_MEDIA_FIXED, quantum, "LPS540S", "*"},
 456                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 457         },
 458         {
 459                 /*
 460                  * Doesn't work correctly with 6 byte reads/writes.
 461                  * Returns illegal request, and points to byte 9 of the
 462                  * 6-byte CDB.
 463                  * Reported by:  Adam McDougall <bsdx@spawnet.com>
 464                  */
 465                 {T_DIRECT, SIP_MEDIA_FIXED, quantum, "VIKING 4*", "*"},
 466                 /*quirks*/ DA_Q_NO_6_BYTE
 467         },
 468         {
 469                 /* See above. */
 470                 {T_DIRECT, SIP_MEDIA_FIXED, quantum, "VIKING 2*", "*"},
 471                 /*quirks*/ DA_Q_NO_6_BYTE
 472         },
 473         {
 474                 /*
 475                  * Doesn't like the synchronize cache command.
 476                  * Reported by: walter@pelissero.de
 477                  */
 478                 {T_DIRECT, SIP_MEDIA_FIXED, "CONNER", "CP3500*", "*"},
 479                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 480         },
 481         {
 482                 /*
 483                  * The CISS RAID controllers do not support SYNC_CACHE
 484                  */
 485                 {T_DIRECT, SIP_MEDIA_FIXED, "COMPAQ", "RAID*", "*"},
 486                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 487         },
 488         {
 489                 /*
 490                  * The STEC SSDs sometimes hang on UNMAP.
 491                  */
 492                 {T_DIRECT, SIP_MEDIA_FIXED, "STEC", "*", "*"},
 493                 /*quirks*/ DA_Q_NO_UNMAP
 494         },
 495         {
 496                 /*
 497                  * VMware returns BUSY status when storage has transient
 498                  * connectivity problems, so better wait.
 499                  * Also VMware returns odd errors on misaligned UNMAPs.
 500                  */
 501                 {T_DIRECT, SIP_MEDIA_FIXED, "VMware*", "*", "*"},
 502                 /*quirks*/ DA_Q_RETRY_BUSY | DA_Q_STRICT_UNMAP
 503         },
 504         /* USB mass storage devices supported by umass(4) */
 505         {
 506                 /*
 507                  * EXATELECOM (Sigmatel) i-Bead 100/105 USB Flash MP3 Player
 508                  * PR: kern/51675
 509                  */
 510                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "EXATEL", "i-BEAD10*", "*"},
 511                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 512         },
 513         {
 514                 /*
 515                  * Power Quotient Int. (PQI) USB flash key
 516                  * PR: kern/53067
 517                  */
 518                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "Generic*", "USB Flash Disk*",
 519                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 520         },
 521         {
 522                 /*
 523                  * Creative Nomad MUVO mp3 player (USB)
 524                  * PR: kern/53094
 525                  */
 526                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "CREATIVE", "NOMAD_MUVO", "*"},
 527                 /*quirks*/ DA_Q_NO_SYNC_CACHE|DA_Q_NO_PREVENT
 528         },
 529         {
 530                 /*
 531                  * Jungsoft NEXDISK USB flash key
 532                  * PR: kern/54737
 533                  */
 534                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "JUNGSOFT", "NEXDISK*", "*"},
 535                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 536         },
 537         {
 538                 /*
 539                  * FreeDik USB Mini Data Drive
 540                  * PR: kern/54786
 541                  */
 542                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "FreeDik*", "Mini Data Drive",
 543                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 544         },
 545         {
 546                 /*
 547                  * Sigmatel USB Flash MP3 Player
 548                  * PR: kern/57046
 549                  */
 550                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "SigmaTel", "MSCN", "*"},
 551                 /*quirks*/ DA_Q_NO_SYNC_CACHE|DA_Q_NO_PREVENT
 552         },
 553         {
 554                 /*
 555                  * Neuros USB Digital Audio Computer
 556                  * PR: kern/63645
 557                  */
 558                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "NEUROS", "dig. audio comp.",
 559                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 560         },
 561         {
 562                 /*
 563                  * SEAGRAND NP-900 MP3 Player
 564                  * PR: kern/64563
 565                  */
 566                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "SEAGRAND", "NP-900*", "*"},
 567                 /*quirks*/ DA_Q_NO_SYNC_CACHE|DA_Q_NO_PREVENT
 568         },
 569         {
 570                 /*
 571                  * iRiver iFP MP3 player (with UMS Firmware)
 572                  * PR: kern/54881, i386/63941, kern/66124
 573                  */
 574                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "iRiver", "iFP*", "*"},
 575                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 576         },
 577         {
 578                 /*
 579                  * Frontier Labs NEX IA+ Digital Audio Player, rev 1.10/0.01
 580                  * PR: kern/70158
 581                  */
 582                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "FL" , "Nex*", "*"},
 583                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 584         },
 585         {
 586                 /*
 587                  * ZICPlay USB MP3 Player with FM
 588                  * PR: kern/75057
 589                  */
 590                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "ACTIONS*" , "USB DISK*", "*"},
 591                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 592         },
 593         {
 594                 /*
 595                  * TEAC USB floppy mechanisms
 596                  */
 597                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "TEAC" , "FD-05*", "*"},
 598                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 599         },
 600         {
 601                 /*
 602                  * Kingston DataTraveler II+ USB Pen-Drive.
 603                  * Reported by: Pawel Jakub Dawidek <pjd@FreeBSD.org>
 604                  */
 605                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "Kingston" , "DataTraveler II+",
 606                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 607         },
 608         {
 609                 /*
 610                  * USB DISK Pro PMAP
 611                  * Reported by: jhs
 612                  * PR: usb/96381
 613                  */
 614                 {T_DIRECT, SIP_MEDIA_REMOVABLE, " ", "USB DISK Pro", "PMAP"},
 615                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 616         },
 617         {
 618                 /*
 619                  * Motorola E398 Mobile Phone (TransFlash memory card).
 620                  * Reported by: Wojciech A. Koszek <dunstan@FreeBSD.czest.pl>
 621                  * PR: usb/89889
 622                  */
 623                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "Motorola" , "Motorola Phone",
 624                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 625         },
 626         {
 627                 /*
 628                  * Qware BeatZkey! Pro
 629                  * PR: usb/79164
 630                  */
 631                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "GENERIC", "USB DISK DEVICE",
 632                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 633         },
 634         {
 635                 /*
 636                  * Time DPA20B 1GB MP3 Player
 637                  * PR: usb/81846
 638                  */
 639                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "USB2.0*", "(FS) FLASH DISK*",
 640                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 641         },
 642         {
 643                 /*
 644                  * Samsung USB key 128Mb
 645                  * PR: usb/90081
 646                  */
 647                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "USB-DISK", "FreeDik-FlashUsb",
 648                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 649         },
 650         {
 651                 /*
 652                  * Kingston DataTraveler 2.0 USB Flash memory.
 653                  * PR: usb/89196
 654                  */
 655                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "Kingston", "DataTraveler 2.0",
 656                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 657         },
 658         {
 659                 /*
 660                  * Creative MUVO Slim mp3 player (USB)
 661                  * PR: usb/86131
 662                  */
 663                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "CREATIVE", "MuVo Slim",
 664                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE|DA_Q_NO_PREVENT
 665                 },
 666         {
 667                 /*
 668                  * United MP5512 Portable MP3 Player (2-in-1 USB DISK/MP3)
 669                  * PR: usb/80487
 670                  */
 671                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "Generic*", "MUSIC DISK",
 672                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 673         },
 674         {
 675                 /*
 676                  * SanDisk Micro Cruzer 128MB
 677                  * PR: usb/75970
 678                  */
 679                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "SanDisk" , "Micro Cruzer",
 680                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 681         },
 682         {
 683                 /*
 684                  * TOSHIBA TransMemory USB sticks
 685                  * PR: kern/94660
 686                  */
 687                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "TOSHIBA", "TransMemory",
 688                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 689         },
 690         {
 691                 /*
 692                  * PNY USB 3.0 Flash Drives
 693                 */
 694                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "PNY", "USB 3.0 FD*",
 695                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE | DA_Q_NO_RC16
 696         },
 697         {
 698                 /*
 699                  * PNY USB Flash keys
 700                  * PR: usb/75578, usb/72344, usb/65436
 701                  */
 702                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "*" , "USB DISK*",
 703                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 704         },
 705         {
 706                 /*
 707                  * Genesys GL3224
 708                  */
 709                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "Generic*", "STORAGE DEVICE*",
 710                 "120?"}, /*quirks*/ DA_Q_NO_SYNC_CACHE | DA_Q_4K | DA_Q_NO_RC16
 711         },
 712         {
 713                 /*
 714                  * Genesys 6-in-1 Card Reader
 715                  * PR: usb/94647
 716                  */
 717                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "Generic*", "STORAGE DEVICE*",
 718                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 719         },
 720         {
 721                 /*
 722                  * Rekam Digital CAMERA
 723                  * PR: usb/98713
 724                  */
 725                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "CAMERA*", "4MP-9J6*",
 726                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 727         },
 728         {
 729                 /*
 730                  * iRiver H10 MP3 player
 731                  * PR: usb/102547
 732                  */
 733                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "iriver", "H10*",
 734                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 735         },
 736         {
 737                 /*
 738                  * iRiver U10 MP3 player
 739                  * PR: usb/92306
 740                  */
 741                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "iriver", "U10*",
 742                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 743         },
 744         {
 745                 /*
 746                  * X-Micro Flash Disk
 747                  * PR: usb/96901
 748                  */
 749                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "X-Micro", "Flash Disk",
 750                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 751         },
 752         {
 753                 /*
 754                  * EasyMP3 EM732X USB 2.0 Flash MP3 Player
 755                  * PR: usb/96546
 756                  */
 757                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "EM732X", "MP3 Player*",
 758                 "1.00"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 759         },
 760         {
 761                 /*
 762                  * Denver MP3 player
 763                  * PR: usb/107101
 764                  */
 765                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "DENVER", "MP3 PLAYER",
 766                  "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 767         },
 768         {
 769                 /*
 770                  * Philips USB Key Audio KEY013
 771                  * PR: usb/68412
 772                  */
 773                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "PHILIPS", "Key*", "*"},
 774                 /*quirks*/ DA_Q_NO_SYNC_CACHE | DA_Q_NO_PREVENT
 775         },
 776         {
 777                 /*
 778                  * JNC MP3 Player
 779                  * PR: usb/94439
 780                  */
 781                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "JNC*" , "MP3 Player*",
 782                  "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 783         },
 784         {
 785                 /*
 786                  * SAMSUNG MP0402H
 787                  * PR: usb/108427
 788                  */
 789                 {T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "MP0402H", "*"},
 790                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 791         },
 792         {
 793                 /*
 794                  * I/O Magic USB flash - Giga Bank
 795                  * PR: usb/108810
 796                  */
 797                 {T_DIRECT, SIP_MEDIA_FIXED, "GS-Magic", "stor*", "*"},
 798                 /*quirks*/ DA_Q_NO_SYNC_CACHE
 799         },
 800         {
 801                 /*
 802                  * JoyFly 128mb USB Flash Drive
 803                  * PR: 96133
 804                  */
 805                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "USB 2.0", "Flash Disk*",
 806                  "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 807         },
 808         {
 809                 /*
 810                  * ChipsBnk usb stick
 811                  * PR: 103702
 812                  */
 813                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "ChipsBnk", "USB*",
 814                  "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 815         },
 816         {
 817                 /*
 818                  * Storcase (Kingston) InfoStation IFS FC2/SATA-R 201A
 819                  * PR: 129858
 820                  */
 821                 {T_DIRECT, SIP_MEDIA_FIXED, "IFS", "FC2/SATA-R*",
 822                  "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 823         },
 824         {
 825                 /*
 826                  * Samsung YP-U3 mp3-player
 827                  * PR: 125398
 828                  */
 829                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "Samsung", "YP-U3",
 830                  "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 831         },
 832         {
 833                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "Netac", "OnlyDisk*",
 834                  "2000"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
 835         },
 836         {
 837                 /*
 838                  * Sony Cyber-Shot DSC cameras
 839                  * PR: usb/137035
 840                  */
 841                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "Sony", "Sony DSC", "*"},
 842                 /*quirks*/ DA_Q_NO_SYNC_CACHE | DA_Q_NO_PREVENT
 843         },
 844         {
 845                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "Kingston", "DataTraveler G3",
 846                  "1.00"}, /*quirks*/ DA_Q_NO_PREVENT
 847         },
 848         {
 849                 /* At least several Transcent USB sticks lie on RC16. */
 850                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "JetFlash", "Transcend*",
 851                  "*"}, /*quirks*/ DA_Q_NO_RC16
 852         },
 853         {
 854                 /*
 855                  * I-O Data USB Flash Disk
 856                  * PR: usb/211716
 857                  */
 858                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "I-O DATA", "USB Flash Disk*",
 859                  "*"}, /*quirks*/ DA_Q_NO_RC16
 860         },
 861         /* ATA/SATA devices over SAS/USB/... */
 862         {
 863                 /* Hitachi Advanced Format (4k) drives */
 864                 { T_DIRECT, SIP_MEDIA_FIXED, "Hitachi", "H??????????E3*", "*" },
 865                 /*quirks*/DA_Q_4K
 866         },
 867         {
 868                 /* Micron Advanced Format (4k) drives */
 869                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Micron 5100 MTFDDAK*", "*" },
 870                 /*quirks*/DA_Q_4K
 871         },
 872         {
 873                 /* Samsung Advanced Format (4k) drives */
 874                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG HD155UI*", "*" },
 875                 /*quirks*/DA_Q_4K
 876         },
 877         {
 878                 /* Samsung Advanced Format (4k) drives */
 879                 { T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "HD155UI*", "*" },
 880                 /*quirks*/DA_Q_4K
 881         },
 882         {
 883                 /* Samsung Advanced Format (4k) drives */
 884                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG HD204UI*", "*" },
 885                 /*quirks*/DA_Q_4K
 886         },
 887         {
 888                 /* Samsung Advanced Format (4k) drives */
 889                 { T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "HD204UI*", "*" },
 890                 /*quirks*/DA_Q_4K
 891         },
 892         {
 893                 /* Seagate Barracuda Green Advanced Format (4k) drives */
 894                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST????DL*", "*" },
 895                 /*quirks*/DA_Q_4K
 896         },
 897         {
 898                 /* Seagate Barracuda Green Advanced Format (4k) drives */
 899                 { T_DIRECT, SIP_MEDIA_FIXED, "ST????DL", "*", "*" },
 900                 /*quirks*/DA_Q_4K
 901         },
 902         {
 903                 /* Seagate Barracuda Green Advanced Format (4k) drives */
 904                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST???DM*", "*" },
 905                 /*quirks*/DA_Q_4K
 906         },
 907         {
 908                 /* Seagate Barracuda Green Advanced Format (4k) drives */
 909                 { T_DIRECT, SIP_MEDIA_FIXED, "ST???DM*", "*", "*" },
 910                 /*quirks*/DA_Q_4K
 911         },
 912         {
 913                 /* Seagate Barracuda Green Advanced Format (4k) drives */
 914                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST????DM*", "*" },
 915                 /*quirks*/DA_Q_4K
 916         },
 917         {
 918                 /* Seagate Barracuda Green Advanced Format (4k) drives */
 919                 { T_DIRECT, SIP_MEDIA_FIXED, "ST????DM", "*", "*" },
 920                 /*quirks*/DA_Q_4K
 921         },
 922         {
 923                 /* Seagate Momentus Advanced Format (4k) drives */
 924                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9500423AS*", "*" },
 925                 /*quirks*/DA_Q_4K
 926         },
 927         {
 928                 /* Seagate Momentus Advanced Format (4k) drives */
 929                 { T_DIRECT, SIP_MEDIA_FIXED, "ST950042", "3AS*", "*" },
 930                 /*quirks*/DA_Q_4K
 931         },
 932         {
 933                 /* Seagate Momentus Advanced Format (4k) drives */
 934                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9500424AS*", "*" },
 935                 /*quirks*/DA_Q_4K
 936         },
 937         {
 938                 /* Seagate Momentus Advanced Format (4k) drives */
 939                 { T_DIRECT, SIP_MEDIA_FIXED, "ST950042", "4AS*", "*" },
 940                 /*quirks*/DA_Q_4K
 941         },
 942         {
 943                 /* Seagate Momentus Advanced Format (4k) drives */
 944                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9640423AS*", "*" },
 945                 /*quirks*/DA_Q_4K
 946         },
 947         {
 948                 /* Seagate Momentus Advanced Format (4k) drives */
 949                 { T_DIRECT, SIP_MEDIA_FIXED, "ST964042", "3AS*", "*" },
 950                 /*quirks*/DA_Q_4K
 951         },
 952         {
 953                 /* Seagate Momentus Advanced Format (4k) drives */
 954                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9640424AS*", "*" },
 955                 /*quirks*/DA_Q_4K
 956         },
 957         {
 958                 /* Seagate Momentus Advanced Format (4k) drives */
 959                 { T_DIRECT, SIP_MEDIA_FIXED, "ST964042", "4AS*", "*" },
 960                 /*quirks*/DA_Q_4K
 961         },
 962         {
 963                 /* Seagate Momentus Advanced Format (4k) drives */
 964                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9750420AS*", "*" },
 965                 /*quirks*/DA_Q_4K
 966         },
 967         {
 968                 /* Seagate Momentus Advanced Format (4k) drives */
 969                 { T_DIRECT, SIP_MEDIA_FIXED, "ST975042", "0AS*", "*" },
 970                 /*quirks*/DA_Q_4K
 971         },
 972         {
 973                 /* Seagate Momentus Advanced Format (4k) drives */
 974                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9750422AS*", "*" },
 975                 /*quirks*/DA_Q_4K
 976         },
 977         {
 978                 /* Seagate Momentus Advanced Format (4k) drives */
 979                 { T_DIRECT, SIP_MEDIA_FIXED, "ST975042", "2AS*", "*" },
 980                 /*quirks*/DA_Q_4K
 981         },
 982         {
 983                 /* Seagate Momentus Advanced Format (4k) drives */
 984                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9750423AS*", "*" },
 985                 /*quirks*/DA_Q_4K
 986         },
 987         {
 988                 /* Seagate Momentus Advanced Format (4k) drives */
 989                 { T_DIRECT, SIP_MEDIA_FIXED, "ST975042", "3AS*", "*" },
 990                 /*quirks*/DA_Q_4K
 991         },
 992         {
 993                 /* Seagate Momentus Thin Advanced Format (4k) drives */
 994                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST???LT*", "*" },
 995                 /*quirks*/DA_Q_4K
 996         },
 997         {
 998                 /* Seagate Momentus Thin Advanced Format (4k) drives */
 999                 { T_DIRECT, SIP_MEDIA_FIXED, "ST???LT*", "*", "*" },
1000                 /*quirks*/DA_Q_4K
1001         },
1002         {
1003                 /* WDC Caviar Green Advanced Format (4k) drives */
1004                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD????RS*", "*" },
1005                 /*quirks*/DA_Q_4K
1006         },
1007         {
1008                 /* WDC Caviar Green Advanced Format (4k) drives */
1009                 { T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "??RS*", "*" },
1010                 /*quirks*/DA_Q_4K
1011         },
1012         {
1013                 /* WDC Caviar Green Advanced Format (4k) drives */
1014                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD????RX*", "*" },
1015                 /*quirks*/DA_Q_4K
1016         },
1017         {
1018                 /* WDC Caviar Green Advanced Format (4k) drives */
1019                 { T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "??RX*", "*" },
1020                 /*quirks*/DA_Q_4K
1021         },
1022         {
1023                 /* WDC Caviar Green Advanced Format (4k) drives */
1024                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD??????RS*", "*" },
1025                 /*quirks*/DA_Q_4K
1026         },
1027         {
1028                 /* WDC Caviar Green Advanced Format (4k) drives */
1029                 { T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "????RS*", "*" },
1030                 /*quirks*/DA_Q_4K
1031         },
1032         {
1033                 /* WDC Caviar Green Advanced Format (4k) drives */
1034                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD??????RX*", "*" },
1035                 /*quirks*/DA_Q_4K
1036         },
1037         {
1038                 /* WDC Caviar Green Advanced Format (4k) drives */
1039                 { T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "????RX*", "*" },
1040                 /*quirks*/DA_Q_4K
1041         },
1042         {
1043                 /* WDC Scorpio Black Advanced Format (4k) drives */
1044                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD???PKT*", "*" },
1045                 /*quirks*/DA_Q_4K
1046         },
1047         {
1048                 /* WDC Scorpio Black Advanced Format (4k) drives */
1049                 { T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "?PKT*", "*" },
1050                 /*quirks*/DA_Q_4K
1051         },
1052         {
1053                 /* WDC Scorpio Black Advanced Format (4k) drives */
1054                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD?????PKT*", "*" },
1055                 /*quirks*/DA_Q_4K
1056         },
1057         {
1058                 /* WDC Scorpio Black Advanced Format (4k) drives */
1059                 { T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "???PKT*", "*" },
1060                 /*quirks*/DA_Q_4K
1061         },
1062         {
1063                 /* WDC Scorpio Blue Advanced Format (4k) drives */
1064                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD???PVT*", "*" },
1065                 /*quirks*/DA_Q_4K
1066         },
1067         {
1068                 /* WDC Scorpio Blue Advanced Format (4k) drives */
1069                 { T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "?PVT*", "*" },
1070                 /*quirks*/DA_Q_4K
1071         },
1072         {
1073                 /* WDC Scorpio Blue Advanced Format (4k) drives */
1074                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD?????PVT*", "*" },
1075                 /*quirks*/DA_Q_4K
1076         },
1077         {
1078                 /* WDC Scorpio Blue Advanced Format (4k) drives */
1079                 { T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "???PVT*", "*" },
1080                 /*quirks*/DA_Q_4K
1081         },
1082         {
1083                 /*
1084                  * Olympus FE-210 camera
1085                  */
1086                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "OLYMPUS", "FE210*",
1087                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
1088         },
1089         {
1090                 /*
1091                  * LG UP3S MP3 player
1092                  */
1093                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "LG", "UP3S",
1094                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
1095         },
1096         {
1097                 /*
1098                  * Laser MP3-2GA13 MP3 player
1099                  */
1100                 {T_DIRECT, SIP_MEDIA_REMOVABLE, "USB 2.0", "(HS) Flash Disk",
1101                 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
1102         },
1103         {
1104                 /*
1105                  * LaCie external 250GB Hard drive des by Porsche
1106                  * Submitted by: Ben Stuyts <ben@altesco.nl>
1107                  * PR: 121474
1108                  */
1109                 {T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "HM250JI", "*"},
1110                 /*quirks*/ DA_Q_NO_SYNC_CACHE
1111         },
1112         /* SATA SSDs */
1113         {
1114                 /*
1115                  * Corsair Force 2 SSDs
1116                  * 4k optimised & trim only works in 4k requests + 4k aligned
1117                  */
1118                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Corsair CSSD-F*", "*" },
1119                 /*quirks*/DA_Q_4K
1120         },
1121         {
1122                 /*
1123                  * Corsair Force 3 SSDs
1124                  * 4k optimised & trim only works in 4k requests + 4k aligned
1125                  */
1126                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Corsair Force 3*", "*" },
1127                 /*quirks*/DA_Q_4K
1128         },
1129         {
1130                 /*
1131                  * Corsair Neutron GTX SSDs
1132                  * 4k optimised & trim only works in 4k requests + 4k aligned
1133                  */
1134                 { T_DIRECT, SIP_MEDIA_FIXED, "*", "Corsair Neutron GTX*", "*" },
1135                 /*quirks*/DA_Q_4K
1136         },
1137         {
1138                 /*
1139                  * Corsair Force GT & GS SSDs
1140                  * 4k optimised & trim only works in 4k requests + 4k aligned
1141                  */
1142                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Corsair Force G*", "*" },
1143                 /*quirks*/DA_Q_4K
1144         },
1145         {
1146                 /*
1147                  * Crucial M4 SSDs
1148                  * 4k optimised & trim only works in 4k requests + 4k aligned
1149                  */
1150                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "M4-CT???M4SSD2*", "*" },
1151                 /*quirks*/DA_Q_4K
1152         },
1153         {
1154                 /*
1155                  * Crucial RealSSD C300 SSDs
1156                  * 4k optimised
1157                  */
1158                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "C300-CTFDDAC???MAG*",
1159                 "*" }, /*quirks*/DA_Q_4K
1160         },
1161         {
1162                 /*
1163                  * Intel 320 Series SSDs
1164                  * 4k optimised & trim only works in 4k requests + 4k aligned
1165                  */
1166                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSA2CW*", "*" },
1167                 /*quirks*/DA_Q_4K
1168         },
1169         {
1170                 /*
1171                  * Intel 330 Series SSDs
1172                  * 4k optimised & trim only works in 4k requests + 4k aligned
1173                  */
1174                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSC2CT*", "*" },
1175                 /*quirks*/DA_Q_4K
1176         },
1177         {
1178                 /*
1179                  * Intel 510 Series SSDs
1180                  * 4k optimised & trim only works in 4k requests + 4k aligned
1181                  */
1182                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSC2MH*", "*" },
1183                 /*quirks*/DA_Q_4K
1184         },
1185         {
1186                 /*
1187                  * Intel 520 Series SSDs
1188                  * 4k optimised & trim only works in 4k requests + 4k aligned
1189                  */
1190                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSC2BW*", "*" },
1191                 /*quirks*/DA_Q_4K
1192         },
1193         {
1194                 /*
1195                  * Intel S3610 Series SSDs
1196                  * 4k optimised & trim only works in 4k requests + 4k aligned
1197                  */
1198                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSC2BX*", "*" },
1199                 /*quirks*/DA_Q_4K
1200         },
1201         {
1202                 /*
1203                  * Intel X25-M Series SSDs
1204                  * 4k optimised & trim only works in 4k requests + 4k aligned
1205                  */
1206                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSA2M*", "*" },
1207                 /*quirks*/DA_Q_4K
1208         },
1209         {
1210                 /*
1211                  * Kingston E100 Series SSDs
1212                  * 4k optimised & trim only works in 4k requests + 4k aligned
1213                  */
1214                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "KINGSTON SE100S3*", "*" },
1215                 /*quirks*/DA_Q_4K
1216         },
1217         {
1218                 /*
1219                  * Kingston HyperX 3k SSDs
1220                  * 4k optimised & trim only works in 4k requests + 4k aligned
1221                  */
1222                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "KINGSTON SH103S3*", "*" },
1223                 /*quirks*/DA_Q_4K
1224         },
1225         {
1226                 /*
1227                  * Marvell SSDs (entry taken from OpenSolaris)
1228                  * 4k optimised & trim only works in 4k requests + 4k aligned
1229                  */
1230                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "MARVELL SD88SA02*", "*" },
1231                 /*quirks*/DA_Q_4K
1232         },
1233         {
1234                 /*
1235                  * OCZ Agility 2 SSDs
1236                  * 4k optimised & trim only works in 4k requests + 4k aligned
1237                  */
1238                 { T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ-AGILITY2*", "*" },
1239                 /*quirks*/DA_Q_4K
1240         },
1241         {
1242                 /*
1243                  * OCZ Agility 3 SSDs
1244                  * 4k optimised & trim only works in 4k requests + 4k aligned
1245                  */
1246                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "OCZ-AGILITY3*", "*" },
1247                 /*quirks*/DA_Q_4K
1248         },
1249         {
1250                 /*
1251                  * OCZ Deneva R Series SSDs
1252                  * 4k optimised & trim only works in 4k requests + 4k aligned
1253                  */
1254                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "DENRSTE251M45*", "*" },
1255                 /*quirks*/DA_Q_4K
1256         },
1257         {
1258                 /*
1259                  * OCZ Vertex 2 SSDs (inc pro series)
1260                  * 4k optimised & trim only works in 4k requests + 4k aligned
1261                  */
1262                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "OCZ?VERTEX2*", "*" },
1263                 /*quirks*/DA_Q_4K
1264         },
1265         {
1266                 /*
1267                  * OCZ Vertex 3 SSDs
1268                  * 4k optimised & trim only works in 4k requests + 4k aligned
1269                  */
1270                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "OCZ-VERTEX3*", "*" },
1271                 /*quirks*/DA_Q_4K
1272         },
1273         {
1274                 /*
1275                  * OCZ Vertex 4 SSDs
1276                  * 4k optimised & trim only works in 4k requests + 4k aligned
1277                  */
1278                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "OCZ-VERTEX4*", "*" },
1279                 /*quirks*/DA_Q_4K
1280         },
1281         {
1282                 /*
1283                  * Samsung 750 Series SSDs
1284                  * 4k optimised & trim only works in 4k requests + 4k aligned
1285                  */
1286                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Samsung SSD 750*", "*" },
1287                 /*quirks*/DA_Q_4K
1288         },
1289         {
1290                 /*
1291                  * Samsung 830 Series SSDs
1292                  * 4k optimised & trim only works in 4k requests + 4k aligned
1293                  */
1294                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG SSD 830 Series*", "*" },
1295                 /*quirks*/DA_Q_4K
1296         },
1297         {
1298                 /*
1299                  * Samsung 840 SSDs
1300                  * 4k optimised & trim only works in 4k requests + 4k aligned
1301                  */
1302                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Samsung SSD 840*", "*" },
1303                 /*quirks*/DA_Q_4K
1304         },
1305         {
1306                 /*
1307                  * Samsung 845 SSDs
1308                  * 4k optimised & trim only works in 4k requests + 4k aligned
1309                  */
1310                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Samsung SSD 845*", "*" },
1311                 /*quirks*/DA_Q_4K
1312         },
1313         {
1314                 /*
1315                  * Samsung 850 SSDs
1316                  * 4k optimised & trim only works in 4k requests + 4k aligned
1317                  */
1318                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Samsung SSD 850*", "*" },
1319                 /*quirks*/DA_Q_4K
1320         },
1321         {
1322                 /*
1323                  * Samsung 843T Series SSDs (MZ7WD*)
1324                  * Samsung PM851 Series SSDs (MZ7TE*)
1325                  * Samsung PM853T Series SSDs (MZ7GE*)
1326                  * Samsung SM863 Series SSDs (MZ7KM*)
1327                  * 4k optimised
1328                  */
1329                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG MZ7*", "*" },
1330                 /*quirks*/DA_Q_4K
1331         },
1332         {
1333                 /*
1334                  * Same as for SAMSUNG MZ7* but enable the quirks for SSD
1335                  * starting with MZ7* too
1336                  */
1337                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "MZ7*", "*" },
1338                 /*quirks*/DA_Q_4K
1339         },
1340         {
1341                 /*
1342                  * SuperTalent TeraDrive CT SSDs
1343                  * 4k optimised & trim only works in 4k requests + 4k aligned
1344                  */
1345                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "FTM??CT25H*", "*" },
1346                 /*quirks*/DA_Q_4K
1347         },
1348         {
1349                 /*
1350                  * XceedIOPS SATA SSDs
1351                  * 4k optimised
1352                  */
1353                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SG9XCS2D*", "*" },
1354                 /*quirks*/DA_Q_4K
1355         },
1356         {
1357                 /*
1358                  * Hama Innostor USB-Stick
1359                  */
1360                 { T_DIRECT, SIP_MEDIA_REMOVABLE, "Innostor", "Innostor*", "*" },
1361                 /*quirks*/DA_Q_NO_RC16
1362         },
1363         {
1364                 /*
1365                  * Seagate Lamarr 8TB Shingled Magnetic Recording (SMR)
1366                  * Drive Managed SATA hard drive.  This drive doesn't report
1367                  * in firmware that it is a drive managed SMR drive.
1368                  */
1369                 { T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST8000AS000[23]*", "*" },
1370                 /*quirks*/DA_Q_SMR_DM
1371         },
1372         {
1373                 /*
1374                  * MX-ES USB Drive by Mach Xtreme
1375                  */
1376                 { T_DIRECT, SIP_MEDIA_REMOVABLE, "MX", "MXUB3*", "*"},
1377                 /*quirks*/DA_Q_NO_RC16
1378         },
1379 };
1380
1381 static  disk_strategy_t dastrategy;
1382 static  dumper_t        dadump;
1383 static  periph_init_t   dainit;
1384 static  void            daasync(void *callback_arg, u_int32_t code,
1385                                 struct cam_path *path, void *arg);
1386 static  void            dasysctlinit(void *context, int pending);
1387 static  int             dasysctlsofttimeout(SYSCTL_HANDLER_ARGS);
1388 static  int             dacmdsizesysctl(SYSCTL_HANDLER_ARGS);
1389 static  int             dadeletemethodsysctl(SYSCTL_HANDLER_ARGS);
1390 static  int             dazonemodesysctl(SYSCTL_HANDLER_ARGS);
1391 static  int             dazonesupsysctl(SYSCTL_HANDLER_ARGS);
1392 static  int             dadeletemaxsysctl(SYSCTL_HANDLER_ARGS);
1393 static  void            dadeletemethodset(struct da_softc *softc,
1394                                           da_delete_methods delete_method);
1395 static  off_t           dadeletemaxsize(struct da_softc *softc,
1396                                         da_delete_methods delete_method);
1397 static  void            dadeletemethodchoose(struct da_softc *softc,
1398                                              da_delete_methods default_method);
1399 static  void            daprobedone(struct cam_periph *periph, union ccb *ccb);
1400
1401 static  periph_ctor_t   daregister;
1402 static  periph_dtor_t   dacleanup;
1403 static  periph_start_t  dastart;
1404 static  periph_oninv_t  daoninvalidate;
1405 static  void            dazonedone(struct cam_periph *periph, union ccb *ccb);
1406 static  void            dadone(struct cam_periph *periph,
1407                                union ccb *done_ccb);
1408 static void             dadone_probewp(struct cam_periph *periph,
1409                                        union ccb *done_ccb);
1410 static void             dadone_proberc(struct cam_periph *periph,
1411                                        union ccb *done_ccb);
1412 static void             dadone_probelbp(struct cam_periph *periph,
1413                                         union ccb *done_ccb);
1414 static void             dadone_probeblklimits(struct cam_periph *periph,
1415                                               union ccb *done_ccb);
1416 static void             dadone_probebdc(struct cam_periph *periph,
1417                                         union ccb *done_ccb);
1418 static void             dadone_probeata(struct cam_periph *periph,
1419                                         union ccb *done_ccb);
1420 static void             dadone_probeatalogdir(struct cam_periph *periph,
1421                                               union ccb *done_ccb);
1422 static void             dadone_probeataiddir(struct cam_periph *periph,
1423                                              union ccb *done_ccb);
1424 static void             dadone_probeatasup(struct cam_periph *periph,
1425                                            union ccb *done_ccb);
1426 static void             dadone_probeatazone(struct cam_periph *periph,
1427                                             union ccb *done_ccb);
1428 static void             dadone_probezone(struct cam_periph *periph,
1429                                          union ccb *done_ccb);
1430 static void             dadone_tur(struct cam_periph *periph,
1431                                    union ccb *done_ccb);
1432 static  int             daerror(union ccb *ccb, u_int32_t cam_flags,
1433                                 u_int32_t sense_flags);
1434 static void             daprevent(struct cam_periph *periph, int action);
1435 static void             dareprobe(struct cam_periph *periph);
1436 static void             dasetgeom(struct cam_periph *periph, uint32_t block_len,
1437                                   uint64_t maxsector,
1438                                   struct scsi_read_capacity_data_long *rcaplong,
1439                                   size_t rcap_size);
1440 static timeout_t        dasendorderedtag;
1441 static void             dashutdown(void *arg, int howto);
1442 static timeout_t        damediapoll;
1443
1444 #ifndef DA_DEFAULT_POLL_PERIOD
1445 #define DA_DEFAULT_POLL_PERIOD  3
1446 #endif
1447
1448 #ifndef DA_DEFAULT_TIMEOUT
1449 #define DA_DEFAULT_TIMEOUT 60   /* Timeout in seconds */
1450 #endif
1451
1452 #ifndef DA_DEFAULT_SOFTTIMEOUT
1453 #define DA_DEFAULT_SOFTTIMEOUT  0
1454 #endif
1455
1456 #ifndef DA_DEFAULT_RETRY
1457 #define DA_DEFAULT_RETRY        4
1458 #endif
1459
1460 #ifndef DA_DEFAULT_SEND_ORDERED
1461 #define DA_DEFAULT_SEND_ORDERED 1
1462 #endif
1463
1464 static int da_poll_period = DA_DEFAULT_POLL_PERIOD;
1465 static int da_retry_count = DA_DEFAULT_RETRY;
1466 static int da_default_timeout = DA_DEFAULT_TIMEOUT;
1467 static sbintime_t da_default_softtimeout = DA_DEFAULT_SOFTTIMEOUT;
1468 static int da_send_ordered = DA_DEFAULT_SEND_ORDERED;
1469
1470 static SYSCTL_NODE(_kern_cam, OID_AUTO, da, CTLFLAG_RD, 0,
1471             "CAM Direct Access Disk driver");
1472 SYSCTL_INT(_kern_cam_da, OID_AUTO, poll_period, CTLFLAG_RWTUN,
1473            &da_poll_period, 0, "Media polling period in seconds");
1474 SYSCTL_INT(_kern_cam_da, OID_AUTO, retry_count, CTLFLAG_RWTUN,
1475            &da_retry_count, 0, "Normal I/O retry count");
1476 SYSCTL_INT(_kern_cam_da, OID_AUTO, default_timeout, CTLFLAG_RWTUN,
1477            &da_default_timeout, 0, "Normal I/O timeout (in seconds)");
1478 SYSCTL_INT(_kern_cam_da, OID_AUTO, send_ordered, CTLFLAG_RWTUN,
1479            &da_send_ordered, 0, "Send Ordered Tags");
1480
1481 SYSCTL_PROC(_kern_cam_da, OID_AUTO, default_softtimeout,
1482     CTLTYPE_UINT | CTLFLAG_RW, NULL, 0, dasysctlsofttimeout, "I",
1483     "Soft I/O timeout (ms)");
1484 TUNABLE_INT64("kern.cam.da.default_softtimeout", &da_default_softtimeout);
1485
1486 /*
1487  * DA_ORDEREDTAG_INTERVAL determines how often, relative
1488  * to the default timeout, we check to see whether an ordered
1489  * tagged transaction is appropriate to prevent simple tag
1490  * starvation.  Since we'd like to ensure that there is at least
1491  * 1/2 of the timeout length left for a starved transaction to
1492  * complete after we've sent an ordered tag, we must poll at least
1493  * four times in every timeout period.  This takes care of the worst
1494  * case where a starved transaction starts during an interval that
1495  * meets the requirement "don't send an ordered tag" test so it takes
1496  * us two intervals to determine that a tag must be sent.
1497  */
1498 #ifndef DA_ORDEREDTAG_INTERVAL
1499 #define DA_ORDEREDTAG_INTERVAL 4
1500 #endif
1501
1502 static struct periph_driver dadriver =
1503 {
1504         dainit, "da",
1505         TAILQ_HEAD_INITIALIZER(dadriver.units), /* generation */ 0
1506 };
1507
1508 PERIPHDRIVER_DECLARE(da, dadriver);
1509
1510 static MALLOC_DEFINE(M_SCSIDA, "scsi_da", "scsi_da buffers");
1511
1512 /*
1513  * This driver takes out references / holds in well defined pairs, never
1514  * recursively. These macros / inline functions enforce those rules. They
1515  * are only enabled with DA_TRACK_REFS or INVARIANTS. If DA_TRACK_REFS is
1516  * defined to be 2 or larger, the tracking also includes debug printfs.
1517  */
1518 #if defined(DA_TRACK_REFS) || defined(INVARIANTS)
1519
1520 #ifndef DA_TRACK_REFS
1521 #define DA_TRACK_REFS 1
1522 #endif
1523
1524 #if DA_TRACK_REFS > 1
1525 static const char *da_ref_text[] = {
1526         "bogus",
1527         "open",
1528         "open hold",
1529         "close hold",
1530         "reprobe hold",
1531         "Test Unit Ready",
1532         "Geom",
1533         "sysctl",
1534         "reprobe",
1535         "max -- also bogus"
1536 };
1537
1538 #define DA_PERIPH_PRINT(periph, msg, args...)           \
1539         CAM_PERIPH_PRINT(periph, msg, ##args)
1540 #else
1541 #define DA_PERIPH_PRINT(periph, msg, args...)
1542 #endif
1543
1544 static inline void
1545 token_sanity(da_ref_token token)
1546 {
1547         if ((unsigned)token >= DA_REF_MAX)
1548                 panic("Bad token value passed in %d\n", token);
1549 }
1550
1551 static inline int
1552 da_periph_hold(struct cam_periph *periph, int priority, da_ref_token token)
1553 {
1554         int err = cam_periph_hold(periph, priority);
1555
1556         token_sanity(token);
1557         DA_PERIPH_PRINT(periph, "Holding device %s (%d): %d\n",
1558             da_ref_text[token], token, err);
1559         if (err == 0) {
1560                 int cnt;
1561                 struct da_softc *softc = periph->softc;
1562
1563                 cnt = atomic_fetchadd_int(&softc->ref_flags[token], 1);
1564                 if (cnt != 0)
1565                         panic("Re-holding for reason %d, cnt = %d", token, cnt);
1566         }
1567         return (err);
1568 }
1569
1570 static inline void
1571 da_periph_unhold(struct cam_periph *periph, da_ref_token token)
1572 {
1573         int cnt;
1574         struct da_softc *softc = periph->softc;
1575
1576         token_sanity(token);
1577         DA_PERIPH_PRINT(periph, "Unholding device %s (%d)\n",
1578             da_ref_text[token], token);
1579         cnt = atomic_fetchadd_int(&softc->ref_flags[token], -1);
1580         if (cnt != 1)
1581                 panic("Unholding %d with cnt = %d", token, cnt);
1582         cam_periph_unhold(periph);
1583 }
1584
1585 static inline int
1586 da_periph_acquire(struct cam_periph *periph, da_ref_token token)
1587 {
1588         int err = cam_periph_acquire(periph);
1589
1590         token_sanity(token);
1591         DA_PERIPH_PRINT(periph, "acquiring device %s (%d): %d\n",
1592             da_ref_text[token], token, err);
1593         if (err == 0) {
1594                 int cnt;
1595                 struct da_softc *softc = periph->softc;
1596
1597                 cnt = atomic_fetchadd_int(&softc->ref_flags[token], 1);
1598                 if (cnt != 0)
1599                         panic("Re-refing for reason %d, cnt = %d", token, cnt);
1600         }
1601         return (err);
1602 }
1603
1604 static inline void
1605 da_periph_release(struct cam_periph *periph, da_ref_token token)
1606 {
1607         int cnt;
1608         struct da_softc *softc = periph->softc;
1609
1610         token_sanity(token);
1611         DA_PERIPH_PRINT(periph, "releasing device %s (%d)\n",
1612             da_ref_text[token], token);
1613         cnt = atomic_fetchadd_int(&softc->ref_flags[token], -1);
1614         if (cnt != 1)
1615                 panic("Releasing %d with cnt = %d", token, cnt);
1616         cam_periph_release(periph);
1617 }
1618
1619 static inline void
1620 da_periph_release_locked(struct cam_periph *periph, da_ref_token token)
1621 {
1622         int cnt;
1623         struct da_softc *softc = periph->softc;
1624
1625         token_sanity(token);
1626         DA_PERIPH_PRINT(periph, "releasing device (locked) %s (%d)\n",
1627             da_ref_text[token], token);
1628         cnt = atomic_fetchadd_int(&softc->ref_flags[token], -1);
1629         if (cnt != 1)
1630                 panic("Unholding %d with cnt = %d", token, cnt);
1631         cam_periph_release_locked(periph);
1632 }
1633
1634 #define cam_periph_hold POISON
1635 #define cam_periph_unhold POISON
1636 #define cam_periph_acquire POISON
1637 #define cam_periph_release POISON
1638 #define cam_periph_release_locked POISON
1639
1640 #else
1641 #define da_periph_hold(periph, prio, token)     cam_periph_hold((periph), (prio))
1642 #define da_periph_unhold(periph, token)         cam_periph_unhold((periph))
1643 #define da_periph_acquire(periph, token)        cam_periph_acquire((periph))
1644 #define da_periph_release(periph, token)        cam_periph_release((periph))
1645 #define da_periph_release_locked(periph, token) cam_periph_release_locked((periph))
1646 #endif
1647
1648 static int
1649 daopen(struct disk *dp)
1650 {
1651         struct cam_periph *periph;
1652         struct da_softc *softc;
1653         int error;
1654
1655         periph = (struct cam_periph *)dp->d_drv1;
1656         if (da_periph_acquire(periph, DA_REF_OPEN) != 0) {
1657                 return (ENXIO);
1658         }
1659
1660         cam_periph_lock(periph);
1661         if ((error = da_periph_hold(periph, PRIBIO|PCATCH, DA_REF_OPEN_HOLD)) != 0) {
1662                 cam_periph_unlock(periph);
1663                 da_periph_release(periph, DA_REF_OPEN);
1664                 return (error);
1665         }
1666
1667         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
1668             ("daopen\n"));
1669
1670         softc = (struct da_softc *)periph->softc;
1671         dareprobe(periph);
1672
1673         /* Wait for the disk size update.  */
1674         error = cam_periph_sleep(periph, &softc->disk->d_mediasize, PRIBIO,
1675             "dareprobe", 0);
1676         if (error != 0)
1677                 xpt_print(periph->path, "unable to retrieve capacity data\n");
1678
1679         if (periph->flags & CAM_PERIPH_INVALID)
1680                 error = ENXIO;
1681
1682         if (error == 0 && (softc->flags & DA_FLAG_PACK_REMOVABLE) != 0 &&
1683             (softc->quirks & DA_Q_NO_PREVENT) == 0)
1684                 daprevent(periph, PR_PREVENT);
1685
1686         if (error == 0) {
1687                 softc->flags &= ~DA_FLAG_PACK_INVALID;
1688                 softc->flags |= DA_FLAG_OPEN;
1689         }
1690
1691         da_periph_unhold(periph, DA_REF_OPEN_HOLD);
1692         cam_periph_unlock(periph);
1693
1694         if (error != 0)
1695                 da_periph_release(periph, DA_REF_OPEN);
1696
1697         return (error);
1698 }
1699
1700 static int
1701 daclose(struct disk *dp)
1702 {
1703         struct  cam_periph *periph;
1704         struct  da_softc *softc;
1705         union   ccb *ccb;
1706
1707         periph = (struct cam_periph *)dp->d_drv1;
1708         softc = (struct da_softc *)periph->softc;
1709         cam_periph_lock(periph);
1710         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
1711             ("daclose\n"));
1712
1713         if (da_periph_hold(periph, PRIBIO, DA_REF_CLOSE_HOLD) == 0) {
1714
1715                 /* Flush disk cache. */
1716                 if ((softc->flags & DA_FLAG_DIRTY) != 0 &&
1717                     (softc->quirks & DA_Q_NO_SYNC_CACHE) == 0 &&
1718                     (softc->flags & DA_FLAG_PACK_INVALID) == 0) {
1719                         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
1720                         scsi_synchronize_cache(&ccb->csio, /*retries*/1,
1721                             /*cbfcnp*/NULL, MSG_SIMPLE_Q_TAG,
1722                             /*begin_lba*/0, /*lb_count*/0, SSD_FULL_SIZE,
1723                             5 * 60 * 1000);
1724                         cam_periph_runccb(ccb, daerror, /*cam_flags*/0,
1725                             /*sense_flags*/SF_RETRY_UA | SF_QUIET_IR,
1726                             softc->disk->d_devstat);
1727                         softc->flags &= ~DA_FLAG_DIRTY;
1728                         xpt_release_ccb(ccb);
1729                 }
1730
1731                 /* Allow medium removal. */
1732                 if ((softc->flags & DA_FLAG_PACK_REMOVABLE) != 0 &&
1733                     (softc->quirks & DA_Q_NO_PREVENT) == 0)
1734                         daprevent(periph, PR_ALLOW);
1735
1736                 da_periph_unhold(periph, DA_REF_CLOSE_HOLD);
1737         }
1738
1739         /*
1740          * If we've got removeable media, mark the blocksize as
1741          * unavailable, since it could change when new media is
1742          * inserted.
1743          */
1744         if ((softc->flags & DA_FLAG_PACK_REMOVABLE) != 0)
1745                 softc->disk->d_devstat->flags |= DEVSTAT_BS_UNAVAILABLE;
1746
1747         softc->flags &= ~DA_FLAG_OPEN;
1748         while (softc->refcount != 0)
1749                 cam_periph_sleep(periph, &softc->refcount, PRIBIO, "daclose", 1);
1750         cam_periph_unlock(periph);
1751         da_periph_release(periph, DA_REF_OPEN);
1752         return (0);
1753 }
1754
1755 static void
1756 daschedule(struct cam_periph *periph)
1757 {
1758         struct da_softc *softc = (struct da_softc *)periph->softc;
1759
1760         if (softc->state != DA_STATE_NORMAL)
1761                 return;
1762
1763         cam_iosched_schedule(softc->cam_iosched, periph);
1764 }
1765
1766 /*
1767  * Actually translate the requested transfer into one the physical driver
1768  * can understand.  The transfer is described by a buf and will include
1769  * only one physical transfer.
1770  */
1771 static void
1772 dastrategy(struct bio *bp)
1773 {
1774         struct cam_periph *periph;
1775         struct da_softc *softc;
1776
1777         periph = (struct cam_periph *)bp->bio_disk->d_drv1;
1778         softc = (struct da_softc *)periph->softc;
1779
1780         cam_periph_lock(periph);
1781
1782         /*
1783          * If the device has been made invalid, error out
1784          */
1785         if ((softc->flags & DA_FLAG_PACK_INVALID)) {
1786                 cam_periph_unlock(periph);
1787                 biofinish(bp, NULL, ENXIO);
1788                 return;
1789         }
1790
1791         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dastrategy(%p)\n", bp));
1792
1793         /*
1794          * Zone commands must be ordered, because they can depend on the
1795          * effects of previously issued commands, and they may affect
1796          * commands after them.
1797          */
1798         if (bp->bio_cmd == BIO_ZONE)
1799                 bp->bio_flags |= BIO_ORDERED;
1800
1801         /*
1802          * Place it in the queue of disk activities for this disk
1803          */
1804         cam_iosched_queue_work(softc->cam_iosched, bp);
1805
1806         /*
1807          * Schedule ourselves for performing the work.
1808          */
1809         daschedule(periph);
1810         cam_periph_unlock(periph);
1811
1812         return;
1813 }
1814
1815 static int
1816 dadump(void *arg, void *virtual, vm_offset_t physical, off_t offset, size_t length)
1817 {
1818         struct      cam_periph *periph;
1819         struct      da_softc *softc;
1820         u_int       secsize;
1821         struct      ccb_scsiio csio;
1822         struct      disk *dp;
1823         int         error = 0;
1824
1825         dp = arg;
1826         periph = dp->d_drv1;
1827         softc = (struct da_softc *)periph->softc;
1828         secsize = softc->params.secsize;
1829
1830         if ((softc->flags & DA_FLAG_PACK_INVALID) != 0)
1831                 return (ENXIO);
1832
1833         memset(&csio, 0, sizeof(csio));
1834         if (length > 0) {
1835                 xpt_setup_ccb(&csio.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
1836                 csio.ccb_h.ccb_state = DA_CCB_DUMP;
1837                 scsi_read_write(&csio,
1838                                 /*retries*/0,
1839                                 /*cbfcnp*/NULL,
1840                                 MSG_ORDERED_Q_TAG,
1841                                 /*read*/SCSI_RW_WRITE,
1842                                 /*byte2*/0,
1843                                 /*minimum_cmd_size*/ softc->minimum_cmd_size,
1844                                 offset / secsize,
1845                                 length / secsize,
1846                                 /*data_ptr*/(u_int8_t *) virtual,
1847                                 /*dxfer_len*/length,
1848                                 /*sense_len*/SSD_FULL_SIZE,
1849                                 da_default_timeout * 1000);
1850                 error = cam_periph_runccb((union ccb *)&csio, cam_periph_error,
1851                     0, SF_NO_RECOVERY | SF_NO_RETRY, NULL);
1852                 if (error != 0)
1853                         printf("Aborting dump due to I/O error.\n");
1854                 return (error);
1855         }
1856
1857         /*
1858          * Sync the disk cache contents to the physical media.
1859          */
1860         if ((softc->quirks & DA_Q_NO_SYNC_CACHE) == 0) {
1861
1862                 xpt_setup_ccb(&csio.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
1863                 csio.ccb_h.ccb_state = DA_CCB_DUMP;
1864                 scsi_synchronize_cache(&csio,
1865                                        /*retries*/0,
1866                                        /*cbfcnp*/NULL,
1867                                        MSG_SIMPLE_Q_TAG,
1868                                        /*begin_lba*/0,/* Cover the whole disk */
1869                                        /*lb_count*/0,
1870                                        SSD_FULL_SIZE,
1871                                        5 * 1000);
1872                 error = cam_periph_runccb((union ccb *)&csio, cam_periph_error,
1873                     0, SF_NO_RECOVERY | SF_NO_RETRY, NULL);
1874                 if (error != 0)
1875                         xpt_print(periph->path, "Synchronize cache failed\n");
1876         }
1877         return (error);
1878 }
1879
1880 static int
1881 dagetattr(struct bio *bp)
1882 {
1883         int ret;
1884         struct cam_periph *periph;
1885
1886         periph = (struct cam_periph *)bp->bio_disk->d_drv1;
1887         cam_periph_lock(periph);
1888         ret = xpt_getattr(bp->bio_data, bp->bio_length, bp->bio_attribute,
1889             periph->path);
1890         cam_periph_unlock(periph);
1891         if (ret == 0)
1892                 bp->bio_completed = bp->bio_length;
1893         return ret;
1894 }
1895
1896 static void
1897 dainit(void)
1898 {
1899         cam_status status;
1900
1901         /*
1902          * Install a global async callback.  This callback will
1903          * receive async callbacks like "new device found".
1904          */
1905         status = xpt_register_async(AC_FOUND_DEVICE, daasync, NULL, NULL);
1906
1907         if (status != CAM_REQ_CMP) {
1908                 printf("da: Failed to attach master async callback "
1909                        "due to status 0x%x!\n", status);
1910         } else if (da_send_ordered) {
1911
1912                 /* Register our shutdown event handler */
1913                 if ((EVENTHANDLER_REGISTER(shutdown_post_sync, dashutdown,
1914                                            NULL, SHUTDOWN_PRI_DEFAULT)) == NULL)
1915                     printf("dainit: shutdown event registration failed!\n");
1916         }
1917 }
1918
1919 /*
1920  * Callback from GEOM, called when it has finished cleaning up its
1921  * resources.
1922  */
1923 static void
1924 dadiskgonecb(struct disk *dp)
1925 {
1926         struct cam_periph *periph;
1927
1928         periph = (struct cam_periph *)dp->d_drv1;
1929         da_periph_release(periph, DA_REF_GEOM);
1930 }
1931
1932 static void
1933 daoninvalidate(struct cam_periph *periph)
1934 {
1935         struct da_softc *softc;
1936
1937         cam_periph_assert(periph, MA_OWNED);
1938         softc = (struct da_softc *)periph->softc;
1939
1940         /*
1941          * De-register any async callbacks.
1942          */
1943         xpt_register_async(0, daasync, periph, periph->path);
1944
1945         softc->flags |= DA_FLAG_PACK_INVALID;
1946 #ifdef CAM_IO_STATS
1947         softc->invalidations++;
1948 #endif
1949
1950         /*
1951          * Return all queued I/O with ENXIO.
1952          * XXX Handle any transactions queued to the card
1953          *     with XPT_ABORT_CCB.
1954          */
1955         cam_iosched_flush(softc->cam_iosched, NULL, ENXIO);
1956
1957         /*
1958          * Tell GEOM that we've gone away, we'll get a callback when it is
1959          * done cleaning up its resources.
1960          */
1961         disk_gone(softc->disk);
1962 }
1963
1964 static void
1965 dacleanup(struct cam_periph *periph)
1966 {
1967         struct da_softc *softc;
1968
1969         softc = (struct da_softc *)periph->softc;
1970
1971         cam_periph_unlock(periph);
1972
1973         cam_iosched_fini(softc->cam_iosched);
1974
1975         /*
1976          * If we can't free the sysctl tree, oh well...
1977          */
1978         if ((softc->flags & DA_FLAG_SCTX_INIT) != 0) {
1979 #ifdef CAM_IO_STATS
1980                 if (sysctl_ctx_free(&softc->sysctl_stats_ctx) != 0)
1981                         xpt_print(periph->path,
1982                             "can't remove sysctl stats context\n");
1983 #endif
1984                 if (sysctl_ctx_free(&softc->sysctl_ctx) != 0)
1985                         xpt_print(periph->path,
1986                             "can't remove sysctl context\n");
1987         }
1988
1989         callout_drain(&softc->mediapoll_c);
1990         disk_destroy(softc->disk);
1991         callout_drain(&softc->sendordered_c);
1992         free(softc, M_DEVBUF);
1993         cam_periph_lock(periph);
1994 }
1995
1996 static void
1997 daasync(void *callback_arg, u_int32_t code,
1998         struct cam_path *path, void *arg)
1999 {
2000         struct cam_periph *periph;
2001         struct da_softc *softc;
2002
2003         periph = (struct cam_periph *)callback_arg;
2004         switch (code) {
2005         case AC_FOUND_DEVICE:
2006         {
2007                 struct ccb_getdev *cgd;
2008                 cam_status status;
2009
2010                 cgd = (struct ccb_getdev *)arg;
2011                 if (cgd == NULL)
2012                         break;
2013
2014                 if (cgd->protocol != PROTO_SCSI)
2015                         break;
2016                 if (SID_QUAL(&cgd->inq_data) != SID_QUAL_LU_CONNECTED)
2017                         break;
2018                 if (SID_TYPE(&cgd->inq_data) != T_DIRECT
2019                     && SID_TYPE(&cgd->inq_data) != T_RBC
2020                     && SID_TYPE(&cgd->inq_data) != T_OPTICAL
2021                     && SID_TYPE(&cgd->inq_data) != T_ZBC_HM)
2022                         break;
2023
2024                 /*
2025                  * Allocate a peripheral instance for
2026                  * this device and start the probe
2027                  * process.
2028                  */
2029                 status = cam_periph_alloc(daregister, daoninvalidate,
2030                                           dacleanup, dastart,
2031                                           "da", CAM_PERIPH_BIO,
2032                                           path, daasync,
2033                                           AC_FOUND_DEVICE, cgd);
2034
2035                 if (status != CAM_REQ_CMP
2036                  && status != CAM_REQ_INPROG)
2037                         printf("daasync: Unable to attach to new device "
2038                                 "due to status 0x%x\n", status);
2039                 return;
2040         }
2041         case AC_ADVINFO_CHANGED:
2042         {
2043                 uintptr_t buftype;
2044
2045                 buftype = (uintptr_t)arg;
2046                 if (buftype == CDAI_TYPE_PHYS_PATH) {
2047                         struct da_softc *softc;
2048
2049                         softc = periph->softc;
2050                         disk_attr_changed(softc->disk, "GEOM::physpath",
2051                                           M_NOWAIT);
2052                 }
2053                 break;
2054         }
2055         case AC_UNIT_ATTENTION:
2056         {
2057                 union ccb *ccb;
2058                 int error_code, sense_key, asc, ascq;
2059
2060                 softc = (struct da_softc *)periph->softc;
2061                 ccb = (union ccb *)arg;
2062
2063                 /*
2064                  * Handle all UNIT ATTENTIONs except our own,
2065                  * as they will be handled by daerror().
2066                  */
2067                 if (xpt_path_periph(ccb->ccb_h.path) != periph &&
2068                     scsi_extract_sense_ccb(ccb,
2069                      &error_code, &sense_key, &asc, &ascq)) {
2070                         if (asc == 0x2A && ascq == 0x09) {
2071                                 xpt_print(ccb->ccb_h.path,
2072                                     "Capacity data has changed\n");
2073                                 cam_periph_lock(periph);
2074                                 softc->flags &= ~DA_FLAG_PROBED;
2075                                 cam_periph_unlock(periph);
2076                                 dareprobe(periph);
2077                         } else if (asc == 0x28 && ascq == 0x00) {
2078                                 cam_periph_lock(periph);
2079                                 softc->flags &= ~DA_FLAG_PROBED;
2080                                 cam_periph_unlock(periph);
2081                                 disk_media_changed(softc->disk, M_NOWAIT);
2082                         } else if (asc == 0x3F && ascq == 0x03) {
2083                                 xpt_print(ccb->ccb_h.path,
2084                                     "INQUIRY data has changed\n");
2085                                 cam_periph_lock(periph);
2086                                 softc->flags &= ~DA_FLAG_PROBED;
2087                                 cam_periph_unlock(periph);
2088                                 dareprobe(periph);
2089                         }
2090                 }
2091                 break;
2092         }
2093         case AC_SCSI_AEN:
2094                 softc = (struct da_softc *)periph->softc;
2095                 cam_periph_lock(periph);
2096                 if (!cam_iosched_has_work_flags(softc->cam_iosched, DA_WORK_TUR) &&
2097                     (softc->flags & DA_FLAG_TUR_PENDING) == 0) {
2098                         if (da_periph_acquire(periph, DA_REF_TUR) == 0) {
2099                                 cam_iosched_set_work_flags(softc->cam_iosched, DA_WORK_TUR);
2100                                 daschedule(periph);
2101                         }
2102                 }
2103                 cam_periph_unlock(periph);
2104                 /* FALLTHROUGH */
2105         case AC_SENT_BDR:
2106         case AC_BUS_RESET:
2107         {
2108                 struct ccb_hdr *ccbh;
2109
2110                 softc = (struct da_softc *)periph->softc;
2111                 /*
2112                  * Don't fail on the expected unit attention
2113                  * that will occur.
2114                  */
2115                 cam_periph_lock(periph);
2116                 softc->flags |= DA_FLAG_RETRY_UA;
2117                 LIST_FOREACH(ccbh, &softc->pending_ccbs, periph_links.le)
2118                         ccbh->ccb_state |= DA_CCB_RETRY_UA;
2119                 cam_periph_unlock(periph);
2120                 break;
2121         }
2122         case AC_INQ_CHANGED:
2123                 cam_periph_lock(periph);
2124                 softc = (struct da_softc *)periph->softc;
2125                 softc->flags &= ~DA_FLAG_PROBED;
2126                 dareprobe(periph);
2127                 cam_periph_unlock(periph);
2128                 break;
2129         default:
2130                 break;
2131         }
2132         cam_periph_async(periph, code, path, arg);
2133 }
2134
2135 static void
2136 dasysctlinit(void *context, int pending)
2137 {
2138         struct cam_periph *periph;
2139         struct da_softc *softc;
2140         char tmpstr[32], tmpstr2[16];
2141         struct ccb_trans_settings cts;
2142
2143         periph = (struct cam_periph *)context;
2144         /*
2145          * periph was held for us when this task was enqueued
2146          */
2147         if (periph->flags & CAM_PERIPH_INVALID) {
2148                 da_periph_release(periph, DA_REF_SYSCTL);
2149                 return;
2150         }
2151
2152         softc = (struct da_softc *)periph->softc;
2153         snprintf(tmpstr, sizeof(tmpstr), "CAM DA unit %d", periph->unit_number);
2154         snprintf(tmpstr2, sizeof(tmpstr2), "%d", periph->unit_number);
2155
2156         sysctl_ctx_init(&softc->sysctl_ctx);
2157         cam_periph_lock(periph);
2158         softc->flags |= DA_FLAG_SCTX_INIT;
2159         cam_periph_unlock(periph);
2160         softc->sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&softc->sysctl_ctx,
2161                 SYSCTL_STATIC_CHILDREN(_kern_cam_da), OID_AUTO, tmpstr2,
2162                 CTLFLAG_RD, 0, tmpstr, "device_index");
2163         if (softc->sysctl_tree == NULL) {
2164                 printf("dasysctlinit: unable to allocate sysctl tree\n");
2165                 da_periph_release(periph, DA_REF_SYSCTL);
2166                 return;
2167         }
2168
2169         /*
2170          * Now register the sysctl handler, so the user can change the value on
2171          * the fly.
2172          */
2173         SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2174                 OID_AUTO, "delete_method", CTLTYPE_STRING | CTLFLAG_RWTUN,
2175                 softc, 0, dadeletemethodsysctl, "A",
2176                 "BIO_DELETE execution method");
2177         SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2178                 OID_AUTO, "delete_max", CTLTYPE_U64 | CTLFLAG_RW,
2179                 softc, 0, dadeletemaxsysctl, "Q",
2180                 "Maximum BIO_DELETE size");
2181         SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2182                 OID_AUTO, "minimum_cmd_size", CTLTYPE_INT | CTLFLAG_RW,
2183                 &softc->minimum_cmd_size, 0, dacmdsizesysctl, "I",
2184                 "Minimum CDB size");
2185
2186         SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2187                 OID_AUTO, "zone_mode", CTLTYPE_STRING | CTLFLAG_RD,
2188                 softc, 0, dazonemodesysctl, "A",
2189                 "Zone Mode");
2190         SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2191                 OID_AUTO, "zone_support", CTLTYPE_STRING | CTLFLAG_RD,
2192                 softc, 0, dazonesupsysctl, "A",
2193                 "Zone Support");
2194         SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2195                 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
2196                 "optimal_seq_zones", CTLFLAG_RD, &softc->optimal_seq_zones,
2197                 "Optimal Number of Open Sequential Write Preferred Zones");
2198         SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2199                 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
2200                 "optimal_nonseq_zones", CTLFLAG_RD,
2201                 &softc->optimal_nonseq_zones,
2202                 "Optimal Number of Non-Sequentially Written Sequential Write "
2203                 "Preferred Zones");
2204         SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2205                 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
2206                 "max_seq_zones", CTLFLAG_RD, &softc->max_seq_zones,
2207                 "Maximum Number of Open Sequential Write Required Zones");
2208
2209         SYSCTL_ADD_INT(&softc->sysctl_ctx,
2210                        SYSCTL_CHILDREN(softc->sysctl_tree),
2211                        OID_AUTO,
2212                        "error_inject",
2213                        CTLFLAG_RW,
2214                        &softc->error_inject,
2215                        0,
2216                        "error_inject leaf");
2217
2218         SYSCTL_ADD_INT(&softc->sysctl_ctx,
2219                        SYSCTL_CHILDREN(softc->sysctl_tree),
2220                        OID_AUTO,
2221                        "unmapped_io",
2222                        CTLFLAG_RD,
2223                        &softc->unmappedio,
2224                        0,
2225                        "Unmapped I/O leaf");
2226
2227         SYSCTL_ADD_INT(&softc->sysctl_ctx,
2228                        SYSCTL_CHILDREN(softc->sysctl_tree),
2229                        OID_AUTO,
2230                        "rotating",
2231                        CTLFLAG_RD,
2232                        &softc->rotating,
2233                        0,
2234                        "Rotating media");
2235
2236 #ifdef CAM_TEST_FAILURE
2237         SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2238                 OID_AUTO, "invalidate", CTLTYPE_U64 | CTLFLAG_RW | CTLFLAG_MPSAFE,
2239                 periph, 0, cam_periph_invalidate_sysctl, "I",
2240                 "Write 1 to invalidate the drive immediately");
2241 #endif
2242
2243         /*
2244          * Add some addressing info.
2245          */
2246         memset(&cts, 0, sizeof (cts));
2247         xpt_setup_ccb(&cts.ccb_h, periph->path, CAM_PRIORITY_NONE);
2248         cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
2249         cts.type = CTS_TYPE_CURRENT_SETTINGS;
2250         cam_periph_lock(periph);
2251         xpt_action((union ccb *)&cts);
2252         cam_periph_unlock(periph);
2253         if (cts.ccb_h.status != CAM_REQ_CMP) {
2254                 da_periph_release(periph, DA_REF_SYSCTL);
2255                 return;
2256         }
2257         if (cts.protocol == PROTO_SCSI && cts.transport == XPORT_FC) {
2258                 struct ccb_trans_settings_fc *fc = &cts.xport_specific.fc;
2259                 if (fc->valid & CTS_FC_VALID_WWPN) {
2260                         softc->wwpn = fc->wwpn;
2261                         SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2262                             SYSCTL_CHILDREN(softc->sysctl_tree),
2263                             OID_AUTO, "wwpn", CTLFLAG_RD,
2264                             &softc->wwpn, "World Wide Port Name");
2265                 }
2266         }
2267
2268 #ifdef CAM_IO_STATS
2269         /*
2270          * Now add some useful stats.
2271          * XXX These should live in cam_periph and be common to all periphs
2272          */
2273         softc->sysctl_stats_tree = SYSCTL_ADD_NODE(&softc->sysctl_stats_ctx,
2274             SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO, "stats",
2275             CTLFLAG_RD, 0, "Statistics");
2276         SYSCTL_ADD_INT(&softc->sysctl_stats_ctx,
2277                        SYSCTL_CHILDREN(softc->sysctl_stats_tree),
2278                        OID_AUTO,
2279                        "errors",
2280                        CTLFLAG_RD,
2281                        &softc->errors,
2282                        0,
2283                        "Transport errors reported by the SIM");
2284         SYSCTL_ADD_INT(&softc->sysctl_stats_ctx,
2285                        SYSCTL_CHILDREN(softc->sysctl_stats_tree),
2286                        OID_AUTO,
2287                        "timeouts",
2288                        CTLFLAG_RD,
2289                        &softc->timeouts,
2290                        0,
2291                        "Device timeouts reported by the SIM");
2292         SYSCTL_ADD_INT(&softc->sysctl_stats_ctx,
2293                        SYSCTL_CHILDREN(softc->sysctl_stats_tree),
2294                        OID_AUTO,
2295                        "pack_invalidations",
2296                        CTLFLAG_RD,
2297                        &softc->invalidations,
2298                        0,
2299                        "Device pack invalidations");
2300 #endif
2301
2302         cam_iosched_sysctl_init(softc->cam_iosched, &softc->sysctl_ctx,
2303             softc->sysctl_tree);
2304
2305         da_periph_release(periph, DA_REF_SYSCTL);
2306 }
2307
2308 static int
2309 dadeletemaxsysctl(SYSCTL_HANDLER_ARGS)
2310 {
2311         int error;
2312         uint64_t value;
2313         struct da_softc *softc;
2314
2315         softc = (struct da_softc *)arg1;
2316
2317         value = softc->disk->d_delmaxsize;
2318         error = sysctl_handle_64(oidp, &value, 0, req);
2319         if ((error != 0) || (req->newptr == NULL))
2320                 return (error);
2321
2322         /* only accept values smaller than the calculated value */
2323         if (value > dadeletemaxsize(softc, softc->delete_method)) {
2324                 return (EINVAL);
2325         }
2326         softc->disk->d_delmaxsize = value;
2327
2328         return (0);
2329 }
2330
2331 static int
2332 dacmdsizesysctl(SYSCTL_HANDLER_ARGS)
2333 {
2334         int error, value;
2335
2336         value = *(int *)arg1;
2337
2338         error = sysctl_handle_int(oidp, &value, 0, req);
2339
2340         if ((error != 0)
2341          || (req->newptr == NULL))
2342                 return (error);
2343
2344         /*
2345          * Acceptable values here are 6, 10, 12 or 16.
2346          */
2347         if (value < 6)
2348                 value = 6;
2349         else if ((value > 6)
2350               && (value <= 10))
2351                 value = 10;
2352         else if ((value > 10)
2353               && (value <= 12))
2354                 value = 12;
2355         else if (value > 12)
2356                 value = 16;
2357
2358         *(int *)arg1 = value;
2359
2360         return (0);
2361 }
2362
2363 static int
2364 dasysctlsofttimeout(SYSCTL_HANDLER_ARGS)
2365 {
2366         sbintime_t value;
2367         int error;
2368
2369         value = da_default_softtimeout / SBT_1MS;
2370
2371         error = sysctl_handle_int(oidp, (int *)&value, 0, req);
2372         if ((error != 0) || (req->newptr == NULL))
2373                 return (error);
2374
2375         /* XXX Should clip this to a reasonable level */
2376         if (value > da_default_timeout * 1000)
2377                 return (EINVAL);
2378
2379         da_default_softtimeout = value * SBT_1MS;
2380         return (0);
2381 }
2382
2383 static void
2384 dadeletemethodset(struct da_softc *softc, da_delete_methods delete_method)
2385 {
2386
2387         softc->delete_method = delete_method;
2388         softc->disk->d_delmaxsize = dadeletemaxsize(softc, delete_method);
2389         softc->delete_func = da_delete_functions[delete_method];
2390
2391         if (softc->delete_method > DA_DELETE_DISABLE)
2392                 softc->disk->d_flags |= DISKFLAG_CANDELETE;
2393         else
2394                 softc->disk->d_flags &= ~DISKFLAG_CANDELETE;
2395 }
2396
2397 static off_t
2398 dadeletemaxsize(struct da_softc *softc, da_delete_methods delete_method)
2399 {
2400         off_t sectors;
2401
2402         switch(delete_method) {
2403         case DA_DELETE_UNMAP:
2404                 sectors = (off_t)softc->unmap_max_lba;
2405                 break;
2406         case DA_DELETE_ATA_TRIM:
2407                 sectors = (off_t)ATA_DSM_RANGE_MAX * softc->trim_max_ranges;
2408                 break;
2409         case DA_DELETE_WS16:
2410                 sectors = omin(softc->ws_max_blks, WS16_MAX_BLKS);
2411                 break;
2412         case DA_DELETE_ZERO:
2413         case DA_DELETE_WS10:
2414                 sectors = omin(softc->ws_max_blks, WS10_MAX_BLKS);
2415                 break;
2416         default:
2417                 return 0;
2418         }
2419
2420         return (off_t)softc->params.secsize *
2421             omin(sectors, softc->params.sectors);
2422 }
2423
2424 static void
2425 daprobedone(struct cam_periph *periph, union ccb *ccb)
2426 {
2427         struct da_softc *softc;
2428
2429         softc = (struct da_softc *)periph->softc;
2430
2431         dadeletemethodchoose(softc, DA_DELETE_NONE);
2432
2433         if (bootverbose && (softc->flags & DA_FLAG_ANNOUNCED) == 0) {
2434                 char buf[80];
2435                 int i, sep;
2436
2437                 snprintf(buf, sizeof(buf), "Delete methods: <");
2438                 sep = 0;
2439                 for (i = 0; i <= DA_DELETE_MAX; i++) {
2440                         if ((softc->delete_available & (1 << i)) == 0 &&
2441                             i != softc->delete_method)
2442                                 continue;
2443                         if (sep)
2444                                 strlcat(buf, ",", sizeof(buf));
2445                         strlcat(buf, da_delete_method_names[i],
2446                             sizeof(buf));
2447                         if (i == softc->delete_method)
2448                                 strlcat(buf, "(*)", sizeof(buf));
2449                         sep = 1;
2450                 }
2451                 strlcat(buf, ">", sizeof(buf));
2452                 printf("%s%d: %s\n", periph->periph_name,
2453                     periph->unit_number, buf);
2454         }
2455
2456         /*
2457          * Since our peripheral may be invalidated by an error
2458          * above or an external event, we must release our CCB
2459          * before releasing the probe lock on the peripheral.
2460          * The peripheral will only go away once the last lock
2461          * is removed, and we need it around for the CCB release
2462          * operation.
2463          */
2464         xpt_release_ccb(ccb);
2465         softc->state = DA_STATE_NORMAL;
2466         softc->flags |= DA_FLAG_PROBED;
2467         daschedule(periph);
2468         wakeup(&softc->disk->d_mediasize);
2469         if ((softc->flags & DA_FLAG_ANNOUNCED) == 0) {
2470                 softc->flags |= DA_FLAG_ANNOUNCED;
2471                 da_periph_unhold(periph, DA_REF_PROBE_HOLD);
2472         } else
2473                 da_periph_release_locked(periph, DA_REF_REPROBE);
2474 }
2475
2476 static void
2477 dadeletemethodchoose(struct da_softc *softc, da_delete_methods default_method)
2478 {
2479         int i, methods;
2480
2481         /* If available, prefer the method requested by user. */
2482         i = softc->delete_method_pref;
2483         methods = softc->delete_available | (1 << DA_DELETE_DISABLE);
2484         if (methods & (1 << i)) {
2485                 dadeletemethodset(softc, i);
2486                 return;
2487         }
2488
2489         /* Use the pre-defined order to choose the best performing delete. */
2490         for (i = DA_DELETE_MIN; i <= DA_DELETE_MAX; i++) {
2491                 if (i == DA_DELETE_ZERO)
2492                         continue;
2493                 if (softc->delete_available & (1 << i)) {
2494                         dadeletemethodset(softc, i);
2495                         return;
2496                 }
2497         }
2498
2499         /* Fallback to default. */
2500         dadeletemethodset(softc, default_method);
2501 }
2502
2503 static int
2504 dadeletemethodsysctl(SYSCTL_HANDLER_ARGS)
2505 {
2506         char buf[16];
2507         const char *p;
2508         struct da_softc *softc;
2509         int i, error, value;
2510
2511         softc = (struct da_softc *)arg1;
2512
2513         value = softc->delete_method;
2514         if (value < 0 || value > DA_DELETE_MAX)
2515                 p = "UNKNOWN";
2516         else
2517                 p = da_delete_method_names[value];
2518         strncpy(buf, p, sizeof(buf));
2519         error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
2520         if (error != 0 || req->newptr == NULL)
2521                 return (error);
2522         for (i = 0; i <= DA_DELETE_MAX; i++) {
2523                 if (strcmp(buf, da_delete_method_names[i]) == 0)
2524                         break;
2525         }
2526         if (i > DA_DELETE_MAX)
2527                 return (EINVAL);
2528         softc->delete_method_pref = i;
2529         dadeletemethodchoose(softc, DA_DELETE_NONE);
2530         return (0);
2531 }
2532
2533 static int
2534 dazonemodesysctl(SYSCTL_HANDLER_ARGS)
2535 {
2536         char tmpbuf[40];
2537         struct da_softc *softc;
2538         int error;
2539
2540         softc = (struct da_softc *)arg1;
2541
2542         switch (softc->zone_mode) {
2543         case DA_ZONE_DRIVE_MANAGED:
2544                 snprintf(tmpbuf, sizeof(tmpbuf), "Drive Managed");
2545                 break;
2546         case DA_ZONE_HOST_AWARE:
2547                 snprintf(tmpbuf, sizeof(tmpbuf), "Host Aware");
2548                 break;
2549         case DA_ZONE_HOST_MANAGED:
2550                 snprintf(tmpbuf, sizeof(tmpbuf), "Host Managed");
2551                 break;
2552         case DA_ZONE_NONE:
2553         default:
2554                 snprintf(tmpbuf, sizeof(tmpbuf), "Not Zoned");
2555                 break;
2556         }
2557
2558         error = sysctl_handle_string(oidp, tmpbuf, sizeof(tmpbuf), req);
2559
2560         return (error);
2561 }
2562
2563 static int
2564 dazonesupsysctl(SYSCTL_HANDLER_ARGS)
2565 {
2566         char tmpbuf[180];
2567         struct da_softc *softc;
2568         struct sbuf sb;
2569         int error, first;
2570         unsigned int i;
2571
2572         softc = (struct da_softc *)arg1;
2573
2574         error = 0;
2575         first = 1;
2576         sbuf_new(&sb, tmpbuf, sizeof(tmpbuf), 0);
2577
2578         for (i = 0; i < sizeof(da_zone_desc_table) /
2579              sizeof(da_zone_desc_table[0]); i++) {
2580                 if (softc->zone_flags & da_zone_desc_table[i].value) {
2581                         if (first == 0)
2582                                 sbuf_printf(&sb, ", ");
2583                         else
2584                                 first = 0;
2585                         sbuf_cat(&sb, da_zone_desc_table[i].desc);
2586                 }
2587         }
2588
2589         if (first == 1)
2590                 sbuf_printf(&sb, "None");
2591
2592         sbuf_finish(&sb);
2593
2594         error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
2595
2596         return (error);
2597 }
2598
2599 static cam_status
2600 daregister(struct cam_periph *periph, void *arg)
2601 {
2602         struct da_softc *softc;
2603         struct ccb_pathinq cpi;
2604         struct ccb_getdev *cgd;
2605         char tmpstr[80];
2606         caddr_t match;
2607
2608         cgd = (struct ccb_getdev *)arg;
2609         if (cgd == NULL) {
2610                 printf("daregister: no getdev CCB, can't register device\n");
2611                 return(CAM_REQ_CMP_ERR);
2612         }
2613
2614         softc = (struct da_softc *)malloc(sizeof(*softc), M_DEVBUF,
2615             M_NOWAIT|M_ZERO);
2616
2617         if (softc == NULL) {
2618                 printf("daregister: Unable to probe new device. "
2619                        "Unable to allocate softc\n");
2620                 return(CAM_REQ_CMP_ERR);
2621         }
2622
2623         if (cam_iosched_init(&softc->cam_iosched, periph) != 0) {
2624                 printf("daregister: Unable to probe new device. "
2625                        "Unable to allocate iosched memory\n");
2626                 free(softc, M_DEVBUF);
2627                 return(CAM_REQ_CMP_ERR);
2628         }
2629
2630         LIST_INIT(&softc->pending_ccbs);
2631         softc->state = DA_STATE_PROBE_WP;
2632         bioq_init(&softc->delete_run_queue);
2633         if (SID_IS_REMOVABLE(&cgd->inq_data))
2634                 softc->flags |= DA_FLAG_PACK_REMOVABLE;
2635         softc->unmap_max_ranges = UNMAP_MAX_RANGES;
2636         softc->unmap_max_lba = UNMAP_RANGE_MAX;
2637         softc->unmap_gran = 0;
2638         softc->unmap_gran_align = 0;
2639         softc->ws_max_blks = WS16_MAX_BLKS;
2640         softc->trim_max_ranges = ATA_TRIM_MAX_RANGES;
2641         softc->rotating = 1;
2642
2643         periph->softc = softc;
2644
2645         /*
2646          * See if this device has any quirks.
2647          */
2648         match = cam_quirkmatch((caddr_t)&cgd->inq_data,
2649                                (caddr_t)da_quirk_table,
2650                                nitems(da_quirk_table),
2651                                sizeof(*da_quirk_table), scsi_inquiry_match);
2652
2653         if (match != NULL)
2654                 softc->quirks = ((struct da_quirk_entry *)match)->quirks;
2655         else
2656                 softc->quirks = DA_Q_NONE;
2657
2658         /* Check if the SIM does not want 6 byte commands */
2659         xpt_path_inq(&cpi, periph->path);
2660         if (cpi.ccb_h.status == CAM_REQ_CMP && (cpi.hba_misc & PIM_NO_6_BYTE))
2661                 softc->quirks |= DA_Q_NO_6_BYTE;
2662
2663         if (SID_TYPE(&cgd->inq_data) == T_ZBC_HM)
2664                 softc->zone_mode = DA_ZONE_HOST_MANAGED;
2665         else if (softc->quirks & DA_Q_SMR_DM)
2666                 softc->zone_mode = DA_ZONE_DRIVE_MANAGED;
2667         else
2668                 softc->zone_mode = DA_ZONE_NONE;
2669
2670         if (softc->zone_mode != DA_ZONE_NONE) {
2671                 if (scsi_vpd_supported_page(periph, SVPD_ATA_INFORMATION)) {
2672                         if (scsi_vpd_supported_page(periph, SVPD_ZONED_BDC))
2673                                 softc->zone_interface = DA_ZONE_IF_ATA_SAT;
2674                         else
2675                                 softc->zone_interface = DA_ZONE_IF_ATA_PASS;
2676                 } else
2677                         softc->zone_interface = DA_ZONE_IF_SCSI;
2678         }
2679
2680         TASK_INIT(&softc->sysctl_task, 0, dasysctlinit, periph);
2681
2682         /*
2683          * Take an exclusive refcount on the periph while dastart is called
2684          * to finish the probe.  The reference will be dropped in dadone at
2685          * the end of probe.
2686          *
2687          * XXX if cam_periph_hold returns an error, we don't hold a refcount.
2688          */
2689         (void)da_periph_hold(periph, PRIBIO, DA_REF_PROBE_HOLD);
2690
2691         /*
2692          * Schedule a periodic event to occasionally send an
2693          * ordered tag to a device.
2694          */
2695         callout_init_mtx(&softc->sendordered_c, cam_periph_mtx(periph), 0);
2696         callout_reset(&softc->sendordered_c,
2697             (da_default_timeout * hz) / DA_ORDEREDTAG_INTERVAL,
2698             dasendorderedtag, periph);
2699
2700         cam_periph_unlock(periph);
2701         /*
2702          * RBC devices don't have to support READ(6), only READ(10).
2703          */
2704         if (softc->quirks & DA_Q_NO_6_BYTE || SID_TYPE(&cgd->inq_data) == T_RBC)
2705                 softc->minimum_cmd_size = 10;
2706         else
2707                 softc->minimum_cmd_size = 6;
2708
2709         /*
2710          * Load the user's default, if any.
2711          */
2712         snprintf(tmpstr, sizeof(tmpstr), "kern.cam.da.%d.minimum_cmd_size",
2713                  periph->unit_number);
2714         TUNABLE_INT_FETCH(tmpstr, &softc->minimum_cmd_size);
2715
2716         /*
2717          * 6, 10, 12 and 16 are the currently permissible values.
2718          */
2719         if (softc->minimum_cmd_size > 12)
2720                 softc->minimum_cmd_size = 16;
2721         else if (softc->minimum_cmd_size > 10)
2722                 softc->minimum_cmd_size = 12;
2723         else if (softc->minimum_cmd_size > 6)
2724                 softc->minimum_cmd_size = 10;
2725         else
2726                 softc->minimum_cmd_size = 6;
2727
2728         /* Predict whether device may support READ CAPACITY(16). */
2729         if (SID_ANSI_REV(&cgd->inq_data) >= SCSI_REV_SPC3 &&
2730             (softc->quirks & DA_Q_NO_RC16) == 0) {
2731                 softc->flags |= DA_FLAG_CAN_RC16;
2732         }
2733
2734         /*
2735          * Register this media as a disk.
2736          */
2737         softc->disk = disk_alloc();
2738         softc->disk->d_devstat = devstat_new_entry(periph->periph_name,
2739                           periph->unit_number, 0,
2740                           DEVSTAT_BS_UNAVAILABLE,
2741                           SID_TYPE(&cgd->inq_data) |
2742                           XPORT_DEVSTAT_TYPE(cpi.transport),
2743                           DEVSTAT_PRIORITY_DISK);
2744         softc->disk->d_open = daopen;
2745         softc->disk->d_close = daclose;
2746         softc->disk->d_strategy = dastrategy;
2747         softc->disk->d_dump = dadump;
2748         softc->disk->d_getattr = dagetattr;
2749         softc->disk->d_gone = dadiskgonecb;
2750         softc->disk->d_name = "da";
2751         softc->disk->d_drv1 = periph;
2752         if (cpi.maxio == 0)
2753                 softc->maxio = DFLTPHYS;        /* traditional default */
2754         else if (cpi.maxio > MAXPHYS)
2755                 softc->maxio = MAXPHYS;         /* for safety */
2756         else
2757                 softc->maxio = cpi.maxio;
2758         softc->disk->d_maxsize = softc->maxio;
2759         softc->disk->d_unit = periph->unit_number;
2760         softc->disk->d_flags = DISKFLAG_DIRECT_COMPLETION | DISKFLAG_CANZONE;
2761         if ((softc->quirks & DA_Q_NO_SYNC_CACHE) == 0)
2762                 softc->disk->d_flags |= DISKFLAG_CANFLUSHCACHE;
2763         if ((cpi.hba_misc & PIM_UNMAPPED) != 0) {
2764                 softc->unmappedio = 1;
2765                 softc->disk->d_flags |= DISKFLAG_UNMAPPED_BIO;
2766         }
2767         cam_strvis(softc->disk->d_descr, cgd->inq_data.vendor,
2768             sizeof(cgd->inq_data.vendor), sizeof(softc->disk->d_descr));
2769         strlcat(softc->disk->d_descr, " ", sizeof(softc->disk->d_descr));
2770         cam_strvis(&softc->disk->d_descr[strlen(softc->disk->d_descr)],
2771             cgd->inq_data.product, sizeof(cgd->inq_data.product),
2772             sizeof(softc->disk->d_descr) - strlen(softc->disk->d_descr));
2773         softc->disk->d_hba_vendor = cpi.hba_vendor;
2774         softc->disk->d_hba_device = cpi.hba_device;
2775         softc->disk->d_hba_subvendor = cpi.hba_subvendor;
2776         softc->disk->d_hba_subdevice = cpi.hba_subdevice;
2777
2778         /*
2779          * Acquire a reference to the periph before we register with GEOM.
2780          * We'll release this reference once GEOM calls us back (via
2781          * dadiskgonecb()) telling us that our provider has been freed.
2782          */
2783         if (da_periph_acquire(periph, DA_REF_GEOM) != 0) {
2784                 xpt_print(periph->path, "%s: lost periph during "
2785                           "registration!\n", __func__);
2786                 cam_periph_lock(periph);
2787                 return (CAM_REQ_CMP_ERR);
2788         }
2789
2790         disk_create(softc->disk, DISK_VERSION);
2791         cam_periph_lock(periph);
2792
2793         /*
2794          * Add async callbacks for events of interest.
2795          * I don't bother checking if this fails as,
2796          * in most cases, the system will function just
2797          * fine without them and the only alternative
2798          * would be to not attach the device on failure.
2799          */
2800         xpt_register_async(AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE |
2801             AC_ADVINFO_CHANGED | AC_SCSI_AEN | AC_UNIT_ATTENTION |
2802             AC_INQ_CHANGED, daasync, periph, periph->path);
2803
2804         /*
2805          * Emit an attribute changed notification just in case
2806          * physical path information arrived before our async
2807          * event handler was registered, but after anyone attaching
2808          * to our disk device polled it.
2809          */
2810         disk_attr_changed(softc->disk, "GEOM::physpath", M_NOWAIT);
2811
2812         /*
2813          * Schedule a periodic media polling events.
2814          */
2815         callout_init_mtx(&softc->mediapoll_c, cam_periph_mtx(periph), 0);
2816         if ((softc->flags & DA_FLAG_PACK_REMOVABLE) &&
2817             (cgd->inq_flags & SID_AEN) == 0 &&
2818             da_poll_period != 0)
2819                 callout_reset(&softc->mediapoll_c, da_poll_period * hz,
2820                     damediapoll, periph);
2821
2822         xpt_schedule(periph, CAM_PRIORITY_DEV);
2823
2824         return(CAM_REQ_CMP);
2825 }
2826
2827 static int
2828 da_zone_bio_to_scsi(int disk_zone_cmd)
2829 {
2830         switch (disk_zone_cmd) {
2831         case DISK_ZONE_OPEN:
2832                 return ZBC_OUT_SA_OPEN;
2833         case DISK_ZONE_CLOSE:
2834                 return ZBC_OUT_SA_CLOSE;
2835         case DISK_ZONE_FINISH:
2836                 return ZBC_OUT_SA_FINISH;
2837         case DISK_ZONE_RWP:
2838                 return ZBC_OUT_SA_RWP;
2839         }
2840
2841         return -1;
2842 }
2843
2844 static int
2845 da_zone_cmd(struct cam_periph *periph, union ccb *ccb, struct bio *bp,
2846             int *queue_ccb)
2847 {
2848         struct da_softc *softc;
2849         int error;
2850
2851         error = 0;
2852
2853         if (bp->bio_cmd != BIO_ZONE) {
2854                 error = EINVAL;
2855                 goto bailout;
2856         }
2857
2858         softc = periph->softc;
2859
2860         switch (bp->bio_zone.zone_cmd) {
2861         case DISK_ZONE_OPEN:
2862         case DISK_ZONE_CLOSE:
2863         case DISK_ZONE_FINISH:
2864         case DISK_ZONE_RWP: {
2865                 int zone_flags;
2866                 int zone_sa;
2867                 uint64_t lba;
2868
2869                 zone_sa = da_zone_bio_to_scsi(bp->bio_zone.zone_cmd);
2870                 if (zone_sa == -1) {
2871                         xpt_print(periph->path, "Cannot translate zone "
2872                             "cmd %#x to SCSI\n", bp->bio_zone.zone_cmd);
2873                         error = EINVAL;
2874                         goto bailout;
2875                 }
2876
2877                 zone_flags = 0;
2878                 lba = bp->bio_zone.zone_params.rwp.id;
2879
2880                 if (bp->bio_zone.zone_params.rwp.flags &
2881                     DISK_ZONE_RWP_FLAG_ALL)
2882                         zone_flags |= ZBC_OUT_ALL;
2883
2884                 if (softc->zone_interface != DA_ZONE_IF_ATA_PASS) {
2885                         scsi_zbc_out(&ccb->csio,
2886                                      /*retries*/ da_retry_count,
2887                                      /*cbfcnp*/ dadone,
2888                                      /*tag_action*/ MSG_SIMPLE_Q_TAG,
2889                                      /*service_action*/ zone_sa,
2890                                      /*zone_id*/ lba,
2891                                      /*zone_flags*/ zone_flags,
2892                                      /*data_ptr*/ NULL,
2893                                      /*dxfer_len*/ 0,
2894                                      /*sense_len*/ SSD_FULL_SIZE,
2895                                      /*timeout*/ da_default_timeout * 1000);
2896                 } else {
2897                         /*
2898                          * Note that in this case, even though we can
2899                          * technically use NCQ, we don't bother for several
2900                          * reasons:
2901                          * 1. It hasn't been tested on a SAT layer that
2902                          *    supports it.  This is new as of SAT-4.
2903                          * 2. Even when there is a SAT layer that supports
2904                          *    it, that SAT layer will also probably support
2905                          *    ZBC -> ZAC translation, since they are both
2906                          *    in the SAT-4 spec.
2907                          * 3. Translation will likely be preferable to ATA
2908                          *    passthrough.  LSI / Avago at least single
2909                          *    steps ATA passthrough commands in the HBA,
2910                          *    regardless of protocol, so unless that
2911                          *    changes, there is a performance penalty for
2912                          *    doing ATA passthrough no matter whether
2913                          *    you're using NCQ/FPDMA, DMA or PIO.
2914                          * 4. It requires a 32-byte CDB, which at least at
2915                          *    this point in CAM requires a CDB pointer, which
2916                          *    would require us to allocate an additional bit
2917                          *    of storage separate from the CCB.
2918                          */
2919                         error = scsi_ata_zac_mgmt_out(&ccb->csio,
2920                             /*retries*/ da_retry_count,
2921                             /*cbfcnp*/ dadone,
2922                             /*tag_action*/ MSG_SIMPLE_Q_TAG,
2923                             /*use_ncq*/ 0,
2924                             /*zm_action*/ zone_sa,
2925                             /*zone_id*/ lba,
2926                             /*zone_flags*/ zone_flags,
2927                             /*data_ptr*/ NULL,
2928                             /*dxfer_len*/ 0,
2929                             /*cdb_storage*/ NULL,
2930                             /*cdb_storage_len*/ 0,
2931                             /*sense_len*/ SSD_FULL_SIZE,
2932                             /*timeout*/ da_default_timeout * 1000);
2933                         if (error != 0) {
2934                                 error = EINVAL;
2935                                 xpt_print(periph->path,
2936                                     "scsi_ata_zac_mgmt_out() returned an "
2937                                     "error!");
2938                                 goto bailout;
2939                         }
2940                 }
2941                 *queue_ccb = 1;
2942
2943                 break;
2944         }
2945         case DISK_ZONE_REPORT_ZONES: {
2946                 uint8_t *rz_ptr;
2947                 uint32_t num_entries, alloc_size;
2948                 struct disk_zone_report *rep;
2949
2950                 rep = &bp->bio_zone.zone_params.report;
2951
2952                 num_entries = rep->entries_allocated;
2953                 if (num_entries == 0) {
2954                         xpt_print(periph->path, "No entries allocated for "
2955                             "Report Zones request\n");
2956                         error = EINVAL;
2957                         goto bailout;
2958                 }
2959                 alloc_size = sizeof(struct scsi_report_zones_hdr) +
2960                     (sizeof(struct scsi_report_zones_desc) * num_entries);
2961                 alloc_size = min(alloc_size, softc->disk->d_maxsize);
2962                 rz_ptr = malloc(alloc_size, M_SCSIDA, M_NOWAIT | M_ZERO);
2963                 if (rz_ptr == NULL) {
2964                         xpt_print(periph->path, "Unable to allocate memory "
2965                            "for Report Zones request\n");
2966                         error = ENOMEM;
2967                         goto bailout;
2968                 }
2969
2970                 if (softc->zone_interface != DA_ZONE_IF_ATA_PASS) {
2971                         scsi_zbc_in(&ccb->csio,
2972                                     /*retries*/ da_retry_count,
2973                                     /*cbcfnp*/ dadone,
2974                                     /*tag_action*/ MSG_SIMPLE_Q_TAG,
2975                                     /*service_action*/ ZBC_IN_SA_REPORT_ZONES,
2976                                     /*zone_start_lba*/ rep->starting_id,
2977                                     /*zone_options*/ rep->rep_options,
2978                                     /*data_ptr*/ rz_ptr,
2979                                     /*dxfer_len*/ alloc_size,
2980                                     /*sense_len*/ SSD_FULL_SIZE,
2981                                     /*timeout*/ da_default_timeout * 1000);
2982                 } else {
2983                         /*
2984                          * Note that in this case, even though we can
2985                          * technically use NCQ, we don't bother for several
2986                          * reasons:
2987                          * 1. It hasn't been tested on a SAT layer that
2988                          *    supports it.  This is new as of SAT-4.
2989                          * 2. Even when there is a SAT layer that supports
2990                          *    it, that SAT layer will also probably support
2991                          *    ZBC -> ZAC translation, since they are both
2992                          *    in the SAT-4 spec.
2993                          * 3. Translation will likely be preferable to ATA
2994                          *    passthrough.  LSI / Avago at least single
2995                          *    steps ATA passthrough commands in the HBA,
2996                          *    regardless of protocol, so unless that
2997                          *    changes, there is a performance penalty for
2998                          *    doing ATA passthrough no matter whether
2999                          *    you're using NCQ/FPDMA, DMA or PIO.
3000                          * 4. It requires a 32-byte CDB, which at least at
3001                          *    this point in CAM requires a CDB pointer, which
3002                          *    would require us to allocate an additional bit
3003                          *    of storage separate from the CCB.
3004                          */
3005                         error = scsi_ata_zac_mgmt_in(&ccb->csio,
3006                             /*retries*/ da_retry_count,
3007                             /*cbcfnp*/ dadone,
3008                             /*tag_action*/ MSG_SIMPLE_Q_TAG,
3009                             /*use_ncq*/ 0,
3010                             /*zm_action*/ ATA_ZM_REPORT_ZONES,
3011                             /*zone_id*/ rep->starting_id,
3012                             /*zone_flags*/ rep->rep_options,
3013                             /*data_ptr*/ rz_ptr,
3014                             /*dxfer_len*/ alloc_size,
3015                             /*cdb_storage*/ NULL,
3016                             /*cdb_storage_len*/ 0,
3017                             /*sense_len*/ SSD_FULL_SIZE,
3018                             /*timeout*/ da_default_timeout * 1000);
3019                         if (error != 0) {
3020                                 error = EINVAL;
3021                                 xpt_print(periph->path,
3022                                     "scsi_ata_zac_mgmt_in() returned an "
3023                                     "error!");
3024                                 goto bailout;
3025                         }
3026                 }
3027
3028                 /*
3029                  * For BIO_ZONE, this isn't normally needed.  However, it
3030                  * is used by devstat_end_transaction_bio() to determine
3031                  * how much data was transferred.
3032                  */
3033                 /*
3034                  * XXX KDM we have a problem.  But I'm not sure how to fix
3035                  * it.  devstat uses bio_bcount - bio_resid to calculate
3036                  * the amount of data transferred.   The GEOM disk code
3037                  * uses bio_length - bio_resid to calculate the amount of
3038                  * data in bio_completed.  We have different structure
3039                  * sizes above and below the ada(4) driver.  So, if we
3040                  * use the sizes above, the amount transferred won't be
3041                  * quite accurate for devstat.  If we use different sizes
3042                  * for bio_bcount and bio_length (above and below
3043                  * respectively), then the residual needs to match one or
3044                  * the other.  Everything is calculated after the bio
3045                  * leaves the driver, so changing the values around isn't
3046                  * really an option.  For now, just set the count to the
3047                  * passed in length.  This means that the calculations
3048                  * above (e.g. bio_completed) will be correct, but the
3049                  * amount of data reported to devstat will be slightly
3050                  * under or overstated.
3051                  */
3052                 bp->bio_bcount = bp->bio_length;
3053
3054                 *queue_ccb = 1;
3055
3056                 break;
3057         }
3058         case DISK_ZONE_GET_PARAMS: {
3059                 struct disk_zone_disk_params *params;
3060
3061                 params = &bp->bio_zone.zone_params.disk_params;
3062                 bzero(params, sizeof(*params));
3063
3064                 switch (softc->zone_mode) {
3065                 case DA_ZONE_DRIVE_MANAGED:
3066                         params->zone_mode = DISK_ZONE_MODE_DRIVE_MANAGED;
3067                         break;
3068                 case DA_ZONE_HOST_AWARE:
3069                         params->zone_mode = DISK_ZONE_MODE_HOST_AWARE;
3070                         break;
3071                 case DA_ZONE_HOST_MANAGED:
3072                         params->zone_mode = DISK_ZONE_MODE_HOST_MANAGED;
3073                         break;
3074                 default:
3075                 case DA_ZONE_NONE:
3076                         params->zone_mode = DISK_ZONE_MODE_NONE;
3077                         break;
3078                 }
3079
3080                 if (softc->zone_flags & DA_ZONE_FLAG_URSWRZ)
3081                         params->flags |= DISK_ZONE_DISK_URSWRZ;
3082
3083                 if (softc->zone_flags & DA_ZONE_FLAG_OPT_SEQ_SET) {
3084                         params->optimal_seq_zones = softc->optimal_seq_zones;
3085                         params->flags |= DISK_ZONE_OPT_SEQ_SET;
3086                 }
3087
3088                 if (softc->zone_flags & DA_ZONE_FLAG_OPT_NONSEQ_SET) {
3089                         params->optimal_nonseq_zones =
3090                             softc->optimal_nonseq_zones;
3091                         params->flags |= DISK_ZONE_OPT_NONSEQ_SET;
3092                 }
3093
3094                 if (softc->zone_flags & DA_ZONE_FLAG_MAX_SEQ_SET) {
3095                         params->max_seq_zones = softc->max_seq_zones;
3096                         params->flags |= DISK_ZONE_MAX_SEQ_SET;
3097                 }
3098                 if (softc->zone_flags & DA_ZONE_FLAG_RZ_SUP)
3099                         params->flags |= DISK_ZONE_RZ_SUP;
3100
3101                 if (softc->zone_flags & DA_ZONE_FLAG_OPEN_SUP)
3102                         params->flags |= DISK_ZONE_OPEN_SUP;
3103
3104                 if (softc->zone_flags & DA_ZONE_FLAG_CLOSE_SUP)
3105                         params->flags |= DISK_ZONE_CLOSE_SUP;
3106
3107                 if (softc->zone_flags & DA_ZONE_FLAG_FINISH_SUP)
3108                         params->flags |= DISK_ZONE_FINISH_SUP;
3109
3110                 if (softc->zone_flags & DA_ZONE_FLAG_RWP_SUP)
3111                         params->flags |= DISK_ZONE_RWP_SUP;
3112                 break;
3113         }
3114         default:
3115                 break;
3116         }
3117 bailout:
3118         return (error);
3119 }
3120
3121 static void
3122 dastart(struct cam_periph *periph, union ccb *start_ccb)
3123 {
3124         struct da_softc *softc;
3125
3126         cam_periph_assert(periph, MA_OWNED);
3127         softc = (struct da_softc *)periph->softc;
3128
3129         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dastart\n"));
3130
3131 skipstate:
3132         switch (softc->state) {
3133         case DA_STATE_NORMAL:
3134         {
3135                 struct bio *bp;
3136                 uint8_t tag_code;
3137
3138 more:
3139                 bp = cam_iosched_next_bio(softc->cam_iosched);
3140                 if (bp == NULL) {
3141                         if (cam_iosched_has_work_flags(softc->cam_iosched,
3142                             DA_WORK_TUR)) {
3143                                 softc->flags |= DA_FLAG_TUR_PENDING;
3144                                 cam_iosched_clr_work_flags(softc->cam_iosched,
3145                                     DA_WORK_TUR);
3146                                 scsi_test_unit_ready(&start_ccb->csio,
3147                                      /*retries*/ da_retry_count,
3148                                      dadone_tur,
3149                                      MSG_SIMPLE_Q_TAG,
3150                                      SSD_FULL_SIZE,
3151                                      da_default_timeout * 1000);
3152                                 start_ccb->ccb_h.ccb_bp = NULL;
3153                                 start_ccb->ccb_h.ccb_state = DA_CCB_TUR;
3154                                 xpt_action(start_ccb);
3155                         } else
3156                                 xpt_release_ccb(start_ccb);
3157                         break;
3158                 }
3159
3160                 if (bp->bio_cmd == BIO_DELETE) {
3161                         if (softc->delete_func != NULL) {
3162                                 softc->delete_func(periph, start_ccb, bp);
3163                                 goto out;
3164                         } else {
3165                                 /*
3166                                  * Not sure this is possible, but failsafe by
3167                                  * lying and saying "sure, done."
3168                                  */
3169                                 biofinish(bp, NULL, 0);
3170                                 goto more;
3171                         }
3172                 }
3173
3174                 if (cam_iosched_has_work_flags(softc->cam_iosched,
3175                     DA_WORK_TUR)) {
3176                         cam_iosched_clr_work_flags(softc->cam_iosched,
3177                             DA_WORK_TUR);
3178                         da_periph_release_locked(periph, DA_REF_TUR);
3179                 }
3180
3181                 if ((bp->bio_flags & BIO_ORDERED) != 0 ||
3182                     (softc->flags & DA_FLAG_NEED_OTAG) != 0) {
3183                         softc->flags &= ~DA_FLAG_NEED_OTAG;
3184                         softc->flags |= DA_FLAG_WAS_OTAG;
3185                         tag_code = MSG_ORDERED_Q_TAG;
3186                 } else {
3187                         tag_code = MSG_SIMPLE_Q_TAG;
3188                 }
3189
3190                 switch (bp->bio_cmd) {
3191                 case BIO_WRITE:
3192                 case BIO_READ:
3193                 {
3194                         void *data_ptr;
3195                         int rw_op;
3196
3197                         biotrack(bp, __func__);
3198
3199                         if (bp->bio_cmd == BIO_WRITE) {
3200                                 softc->flags |= DA_FLAG_DIRTY;
3201                                 rw_op = SCSI_RW_WRITE;
3202                         } else {
3203                                 rw_op = SCSI_RW_READ;
3204                         }
3205
3206                         data_ptr = bp->bio_data;
3207                         if ((bp->bio_flags & (BIO_UNMAPPED|BIO_VLIST)) != 0) {
3208                                 rw_op |= SCSI_RW_BIO;
3209                                 data_ptr = bp;
3210                         }
3211
3212                         scsi_read_write(&start_ccb->csio,
3213                                         /*retries*/da_retry_count,
3214                                         /*cbfcnp*/dadone,
3215                                         /*tag_action*/tag_code,
3216                                         rw_op,
3217                                         /*byte2*/0,
3218                                         softc->minimum_cmd_size,
3219                                         /*lba*/bp->bio_pblkno,
3220                                         /*block_count*/bp->bio_bcount /
3221                                         softc->params.secsize,
3222                                         data_ptr,
3223                                         /*dxfer_len*/ bp->bio_bcount,
3224                                         /*sense_len*/SSD_FULL_SIZE,
3225                                         da_default_timeout * 1000);
3226 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
3227                         start_ccb->csio.bio = bp;
3228 #endif
3229                         break;
3230                 }
3231                 case BIO_FLUSH:
3232                         /*
3233                          * If we don't support sync cache, or the disk
3234                          * isn't dirty, FLUSH is a no-op.  Use the
3235                          * allocated CCB for the next bio if one is
3236                          * available.
3237                          */
3238                         if ((softc->quirks & DA_Q_NO_SYNC_CACHE) != 0 ||
3239                             (softc->flags & DA_FLAG_DIRTY) == 0) {
3240                                 biodone(bp);
3241                                 goto skipstate;
3242                         }
3243
3244                         /*
3245                          * BIO_FLUSH doesn't currently communicate
3246                          * range data, so we synchronize the cache
3247                          * over the whole disk.  We also force
3248                          * ordered tag semantics the flush applies
3249                          * to all previously queued I/O.
3250                          */
3251                         scsi_synchronize_cache(&start_ccb->csio,
3252                                                /*retries*/1,
3253                                                /*cbfcnp*/dadone,
3254                                                MSG_ORDERED_Q_TAG,
3255                                                /*begin_lba*/0,
3256                                                /*lb_count*/0,
3257                                                SSD_FULL_SIZE,
3258                                                da_default_timeout*1000);
3259                         /*
3260                          * Clear the dirty flag before sending the command.
3261                          * Either this sync cache will be successful, or it
3262                          * will fail after a retry.  If it fails, it is
3263                          * unlikely to be successful if retried later, so
3264                          * we'll save ourselves time by just marking the
3265                          * device clean.
3266                          */
3267                         softc->flags &= ~DA_FLAG_DIRTY;
3268                         break;
3269                 case BIO_ZONE: {
3270                         int error, queue_ccb;
3271
3272                         queue_ccb = 0;
3273
3274                         error = da_zone_cmd(periph, start_ccb, bp,&queue_ccb);
3275                         if ((error != 0)
3276                          || (queue_ccb == 0)) {
3277                                 biofinish(bp, NULL, error);
3278                                 xpt_release_ccb(start_ccb);
3279                                 return;
3280                         }
3281                         break;
3282                 }
3283                 }
3284                 start_ccb->ccb_h.ccb_state = DA_CCB_BUFFER_IO;
3285                 start_ccb->ccb_h.flags |= CAM_UNLOCKED;
3286                 start_ccb->ccb_h.softtimeout = sbttotv(da_default_softtimeout);
3287
3288 out:
3289                 LIST_INSERT_HEAD(&softc->pending_ccbs,
3290                                  &start_ccb->ccb_h, periph_links.le);
3291
3292                 /* We expect a unit attention from this device */
3293                 if ((softc->flags & DA_FLAG_RETRY_UA) != 0) {
3294                         start_ccb->ccb_h.ccb_state |= DA_CCB_RETRY_UA;
3295                         softc->flags &= ~DA_FLAG_RETRY_UA;
3296                 }
3297
3298                 start_ccb->ccb_h.ccb_bp = bp;
3299                 softc->refcount++;
3300                 cam_periph_unlock(periph);
3301                 xpt_action(start_ccb);
3302                 cam_periph_lock(periph);
3303
3304                 /* May have more work to do, so ensure we stay scheduled */
3305                 daschedule(periph);
3306                 break;
3307         }
3308         case DA_STATE_PROBE_WP:
3309         {
3310                 void  *mode_buf;
3311                 int    mode_buf_len;
3312
3313                 mode_buf_len = 192;
3314                 mode_buf = malloc(mode_buf_len, M_SCSIDA, M_NOWAIT);
3315                 if (mode_buf == NULL) {
3316                         xpt_print(periph->path, "Unable to send mode sense - "
3317                             "malloc failure\n");
3318                         softc->state = DA_STATE_PROBE_RC;
3319                         goto skipstate;
3320                 }
3321                 scsi_mode_sense_len(&start_ccb->csio,
3322                                     /*retries*/ da_retry_count,
3323                                     /*cbfcnp*/ dadone_probewp,
3324                                     /*tag_action*/ MSG_SIMPLE_Q_TAG,
3325                                     /*dbd*/ FALSE,
3326                                     /*pc*/ SMS_PAGE_CTRL_CURRENT,
3327                                     /*page*/ SMS_ALL_PAGES_PAGE,
3328                                     /*param_buf*/ mode_buf,
3329                                     /*param_len*/ mode_buf_len,
3330                                     /*minimum_cmd_size*/ softc->minimum_cmd_size,
3331                                     /*sense_len*/ SSD_FULL_SIZE,
3332                                     /*timeout*/ da_default_timeout * 1000);
3333                 start_ccb->ccb_h.ccb_bp = NULL;
3334                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_WP;
3335                 xpt_action(start_ccb);
3336                 break;
3337         }
3338         case DA_STATE_PROBE_RC:
3339         {
3340                 struct scsi_read_capacity_data *rcap;
3341
3342                 rcap = (struct scsi_read_capacity_data *)
3343                     malloc(sizeof(*rcap), M_SCSIDA, M_NOWAIT|M_ZERO);
3344                 if (rcap == NULL) {
3345                         printf("dastart: Couldn't malloc read_capacity data\n");
3346                         /* da_free_periph??? */
3347                         break;
3348                 }
3349                 scsi_read_capacity(&start_ccb->csio,
3350                                    /*retries*/da_retry_count,
3351                                    dadone_proberc,
3352                                    MSG_SIMPLE_Q_TAG,
3353                                    rcap,
3354                                    SSD_FULL_SIZE,
3355                                    /*timeout*/5000);
3356                 start_ccb->ccb_h.ccb_bp = NULL;
3357                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_RC;
3358                 xpt_action(start_ccb);
3359                 break;
3360         }
3361         case DA_STATE_PROBE_RC16:
3362         {
3363                 struct scsi_read_capacity_data_long *rcaplong;
3364
3365                 rcaplong = (struct scsi_read_capacity_data_long *)
3366                         malloc(sizeof(*rcaplong), M_SCSIDA, M_NOWAIT|M_ZERO);
3367                 if (rcaplong == NULL) {
3368                         printf("dastart: Couldn't malloc read_capacity data\n");
3369                         /* da_free_periph??? */
3370                         break;
3371                 }
3372                 scsi_read_capacity_16(&start_ccb->csio,
3373                                       /*retries*/ da_retry_count,
3374                                       /*cbfcnp*/ dadone_proberc,
3375                                       /*tag_action*/ MSG_SIMPLE_Q_TAG,
3376                                       /*lba*/ 0,
3377                                       /*reladr*/ 0,
3378                                       /*pmi*/ 0,
3379                                       /*rcap_buf*/ (uint8_t *)rcaplong,
3380                                       /*rcap_buf_len*/ sizeof(*rcaplong),
3381                                       /*sense_len*/ SSD_FULL_SIZE,
3382                                       /*timeout*/ da_default_timeout * 1000);
3383                 start_ccb->ccb_h.ccb_bp = NULL;
3384                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_RC16;
3385                 xpt_action(start_ccb);
3386                 break;
3387         }
3388         case DA_STATE_PROBE_LBP:
3389         {
3390                 struct scsi_vpd_logical_block_prov *lbp;
3391
3392                 if (!scsi_vpd_supported_page(periph, SVPD_LBP)) {
3393                         /*
3394                          * If we get here we don't support any SBC-3 delete
3395                          * methods with UNMAP as the Logical Block Provisioning
3396                          * VPD page support is required for devices which
3397                          * support it according to T10/1799-D Revision 31
3398                          * however older revisions of the spec don't mandate
3399                          * this so we currently don't remove these methods
3400                          * from the available set.
3401                          */
3402                         softc->state = DA_STATE_PROBE_BLK_LIMITS;
3403                         goto skipstate;
3404                 }
3405
3406                 lbp = (struct scsi_vpd_logical_block_prov *)
3407                         malloc(sizeof(*lbp), M_SCSIDA, M_NOWAIT|M_ZERO);
3408
3409                 if (lbp == NULL) {
3410                         printf("dastart: Couldn't malloc lbp data\n");
3411                         /* da_free_periph??? */
3412                         break;
3413                 }
3414
3415                 scsi_inquiry(&start_ccb->csio,
3416                              /*retries*/da_retry_count,
3417                              /*cbfcnp*/dadone_probelbp,
3418                              /*tag_action*/MSG_SIMPLE_Q_TAG,
3419                              /*inq_buf*/(u_int8_t *)lbp,
3420                              /*inq_len*/sizeof(*lbp),
3421                              /*evpd*/TRUE,
3422                              /*page_code*/SVPD_LBP,
3423                              /*sense_len*/SSD_MIN_SIZE,
3424                              /*timeout*/da_default_timeout * 1000);
3425                 start_ccb->ccb_h.ccb_bp = NULL;
3426                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_LBP;
3427                 xpt_action(start_ccb);
3428                 break;
3429         }
3430         case DA_STATE_PROBE_BLK_LIMITS:
3431         {
3432                 struct scsi_vpd_block_limits *block_limits;
3433
3434                 if (!scsi_vpd_supported_page(periph, SVPD_BLOCK_LIMITS)) {
3435                         /* Not supported skip to next probe */
3436                         softc->state = DA_STATE_PROBE_BDC;
3437                         goto skipstate;
3438                 }
3439
3440                 block_limits = (struct scsi_vpd_block_limits *)
3441                         malloc(sizeof(*block_limits), M_SCSIDA, M_NOWAIT|M_ZERO);
3442
3443                 if (block_limits == NULL) {
3444                         printf("dastart: Couldn't malloc block_limits data\n");
3445                         /* da_free_periph??? */
3446                         break;
3447                 }
3448
3449                 scsi_inquiry(&start_ccb->csio,
3450                              /*retries*/da_retry_count,
3451                              /*cbfcnp*/dadone_probeblklimits,
3452                              /*tag_action*/MSG_SIMPLE_Q_TAG,
3453                              /*inq_buf*/(u_int8_t *)block_limits,
3454                              /*inq_len*/sizeof(*block_limits),
3455                              /*evpd*/TRUE,
3456                              /*page_code*/SVPD_BLOCK_LIMITS,
3457                              /*sense_len*/SSD_MIN_SIZE,
3458                              /*timeout*/da_default_timeout * 1000);
3459                 start_ccb->ccb_h.ccb_bp = NULL;
3460                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_BLK_LIMITS;
3461                 xpt_action(start_ccb);
3462                 break;
3463         }
3464         case DA_STATE_PROBE_BDC:
3465         {
3466                 struct scsi_vpd_block_characteristics *bdc;
3467
3468                 if (!scsi_vpd_supported_page(periph, SVPD_BDC)) {
3469                         softc->state = DA_STATE_PROBE_ATA;
3470                         goto skipstate;
3471                 }
3472
3473                 bdc = (struct scsi_vpd_block_characteristics *)
3474                         malloc(sizeof(*bdc), M_SCSIDA, M_NOWAIT|M_ZERO);
3475
3476                 if (bdc == NULL) {
3477                         printf("dastart: Couldn't malloc bdc data\n");
3478                         /* da_free_periph??? */
3479                         break;
3480                 }
3481
3482                 scsi_inquiry(&start_ccb->csio,
3483                              /*retries*/da_retry_count,
3484                              /*cbfcnp*/dadone_probebdc,
3485                              /*tag_action*/MSG_SIMPLE_Q_TAG,
3486                              /*inq_buf*/(u_int8_t *)bdc,
3487                              /*inq_len*/sizeof(*bdc),
3488                              /*evpd*/TRUE,
3489                              /*page_code*/SVPD_BDC,
3490                              /*sense_len*/SSD_MIN_SIZE,
3491                              /*timeout*/da_default_timeout * 1000);
3492                 start_ccb->ccb_h.ccb_bp = NULL;
3493                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_BDC;
3494                 xpt_action(start_ccb);
3495                 break;
3496         }
3497         case DA_STATE_PROBE_ATA:
3498         {
3499                 struct ata_params *ata_params;
3500
3501                 if (!scsi_vpd_supported_page(periph, SVPD_ATA_INFORMATION)) {
3502                         if ((softc->zone_mode == DA_ZONE_HOST_AWARE)
3503                          || (softc->zone_mode == DA_ZONE_HOST_MANAGED)) {
3504                                 /*
3505                                  * Note that if the ATA VPD page isn't
3506                                  * supported, we aren't talking to an ATA
3507                                  * device anyway.  Support for that VPD
3508                                  * page is mandatory for SCSI to ATA (SAT)
3509                                  * translation layers.
3510                                  */
3511                                 softc->state = DA_STATE_PROBE_ZONE;
3512                                 goto skipstate;
3513                         }
3514                         daprobedone(periph, start_ccb);
3515                         break;
3516                 }
3517
3518                 ata_params = (struct ata_params*)
3519                         malloc(sizeof(*ata_params), M_SCSIDA,M_NOWAIT|M_ZERO);
3520
3521                 if (ata_params == NULL) {
3522                         xpt_print(periph->path, "Couldn't malloc ata_params "
3523                             "data\n");
3524                         /* da_free_periph??? */
3525                         break;
3526                 }
3527
3528                 scsi_ata_identify(&start_ccb->csio,
3529                                   /*retries*/da_retry_count,
3530                                   /*cbfcnp*/dadone_probeata,
3531                                   /*tag_action*/MSG_SIMPLE_Q_TAG,
3532                                   /*data_ptr*/(u_int8_t *)ata_params,
3533                                   /*dxfer_len*/sizeof(*ata_params),
3534                                   /*sense_len*/SSD_FULL_SIZE,
3535                                   /*timeout*/da_default_timeout * 1000);
3536                 start_ccb->ccb_h.ccb_bp = NULL;
3537                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA;
3538                 xpt_action(start_ccb);
3539                 break;
3540         }
3541         case DA_STATE_PROBE_ATA_LOGDIR:
3542         {
3543                 struct ata_gp_log_dir *log_dir;
3544                 int retval;
3545
3546                 retval = 0;
3547
3548                 if ((softc->flags & DA_FLAG_CAN_ATA_LOG) == 0) {
3549                         /*
3550                          * If we don't have log support, not much point in
3551                          * trying to probe zone support.
3552                          */
3553                         daprobedone(periph, start_ccb);
3554                         break;
3555                 }
3556
3557                 /*
3558                  * If we have an ATA device (the SCSI ATA Information VPD
3559                  * page should be present and the ATA identify should have
3560                  * succeeded) and it supports logs, ask for the log directory.
3561                  */
3562
3563                 log_dir = malloc(sizeof(*log_dir), M_SCSIDA, M_NOWAIT|M_ZERO);
3564                 if (log_dir == NULL) {
3565                         xpt_print(periph->path, "Couldn't malloc log_dir "
3566                             "data\n");
3567                         daprobedone(periph, start_ccb);
3568                         break;
3569                 }
3570
3571                 retval = scsi_ata_read_log(&start_ccb->csio,
3572                     /*retries*/ da_retry_count,
3573                     /*cbfcnp*/ dadone_probeatalogdir,
3574                     /*tag_action*/ MSG_SIMPLE_Q_TAG,
3575                     /*log_address*/ ATA_LOG_DIRECTORY,
3576                     /*page_number*/ 0,
3577                     /*block_count*/ 1,
3578                     /*protocol*/ softc->flags & DA_FLAG_CAN_ATA_DMA ?
3579                                  AP_PROTO_DMA : AP_PROTO_PIO_IN,
3580                     /*data_ptr*/ (uint8_t *)log_dir,
3581                     /*dxfer_len*/ sizeof(*log_dir),
3582                     /*sense_len*/ SSD_FULL_SIZE,
3583                     /*timeout*/ da_default_timeout * 1000);
3584
3585                 if (retval != 0) {
3586                         xpt_print(periph->path, "scsi_ata_read_log() failed!");
3587                         free(log_dir, M_SCSIDA);
3588                         daprobedone(periph, start_ccb);
3589                         break;
3590                 }
3591                 start_ccb->ccb_h.ccb_bp = NULL;
3592                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA_LOGDIR;
3593                 xpt_action(start_ccb);
3594                 break;
3595         }
3596         case DA_STATE_PROBE_ATA_IDDIR:
3597         {
3598                 struct ata_identify_log_pages *id_dir;
3599                 int retval;
3600
3601                 retval = 0;
3602
3603                 /*
3604                  * Check here to see whether the Identify Device log is
3605                  * supported in the directory of logs.  If so, continue
3606                  * with requesting the log of identify device pages.
3607                  */
3608                 if ((softc->flags & DA_FLAG_CAN_ATA_IDLOG) == 0) {
3609                         daprobedone(periph, start_ccb);
3610                         break;
3611                 }
3612
3613                 id_dir = malloc(sizeof(*id_dir), M_SCSIDA, M_NOWAIT | M_ZERO);
3614                 if (id_dir == NULL) {
3615                         xpt_print(periph->path, "Couldn't malloc id_dir "
3616                             "data\n");
3617                         daprobedone(periph, start_ccb);
3618                         break;
3619                 }
3620
3621                 retval = scsi_ata_read_log(&start_ccb->csio,
3622                     /*retries*/ da_retry_count,
3623                     /*cbfcnp*/ dadone_probeataiddir,
3624                     /*tag_action*/ MSG_SIMPLE_Q_TAG,
3625                     /*log_address*/ ATA_IDENTIFY_DATA_LOG,
3626                     /*page_number*/ ATA_IDL_PAGE_LIST,
3627                     /*block_count*/ 1,
3628                     /*protocol*/ softc->flags & DA_FLAG_CAN_ATA_DMA ?
3629                                  AP_PROTO_DMA : AP_PROTO_PIO_IN,
3630                     /*data_ptr*/ (uint8_t *)id_dir,
3631                     /*dxfer_len*/ sizeof(*id_dir),
3632                     /*sense_len*/ SSD_FULL_SIZE,
3633                     /*timeout*/ da_default_timeout * 1000);
3634
3635                 if (retval != 0) {
3636                         xpt_print(periph->path, "scsi_ata_read_log() failed!");
3637                         free(id_dir, M_SCSIDA);
3638                         daprobedone(periph, start_ccb);
3639                         break;
3640                 }
3641                 start_ccb->ccb_h.ccb_bp = NULL;
3642                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA_IDDIR;
3643                 xpt_action(start_ccb);
3644                 break;
3645         }
3646         case DA_STATE_PROBE_ATA_SUP:
3647         {
3648                 struct ata_identify_log_sup_cap *sup_cap;
3649                 int retval;
3650
3651                 retval = 0;
3652
3653                 /*
3654                  * Check here to see whether the Supported Capabilities log
3655                  * is in the list of Identify Device logs.
3656                  */
3657                 if ((softc->flags & DA_FLAG_CAN_ATA_SUPCAP) == 0) {
3658                         daprobedone(periph, start_ccb);
3659                         break;
3660                 }
3661
3662                 sup_cap = malloc(sizeof(*sup_cap), M_SCSIDA, M_NOWAIT|M_ZERO);
3663                 if (sup_cap == NULL) {
3664                         xpt_print(periph->path, "Couldn't malloc sup_cap "
3665                             "data\n");
3666                         daprobedone(periph, start_ccb);
3667                         break;
3668                 }
3669
3670                 retval = scsi_ata_read_log(&start_ccb->csio,
3671                     /*retries*/ da_retry_count,
3672                     /*cbfcnp*/ dadone_probeatasup,
3673                     /*tag_action*/ MSG_SIMPLE_Q_TAG,
3674                     /*log_address*/ ATA_IDENTIFY_DATA_LOG,
3675                     /*page_number*/ ATA_IDL_SUP_CAP,
3676                     /*block_count*/ 1,
3677                     /*protocol*/ softc->flags & DA_FLAG_CAN_ATA_DMA ?
3678                                  AP_PROTO_DMA : AP_PROTO_PIO_IN,
3679                     /*data_ptr*/ (uint8_t *)sup_cap,
3680                     /*dxfer_len*/ sizeof(*sup_cap),
3681                     /*sense_len*/ SSD_FULL_SIZE,
3682                     /*timeout*/ da_default_timeout * 1000);
3683
3684                 if (retval != 0) {
3685                         xpt_print(periph->path, "scsi_ata_read_log() failed!");
3686                         free(sup_cap, M_SCSIDA);
3687                         daprobedone(periph, start_ccb);
3688                         break;
3689
3690                 }
3691
3692                 start_ccb->ccb_h.ccb_bp = NULL;
3693                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA_SUP;
3694                 xpt_action(start_ccb);
3695                 break;
3696         }
3697         case DA_STATE_PROBE_ATA_ZONE:
3698         {
3699                 struct ata_zoned_info_log *ata_zone;
3700                 int retval;
3701
3702                 retval = 0;
3703
3704                 /*
3705                  * Check here to see whether the zoned device information
3706                  * page is supported.  If so, continue on to request it.
3707                  * If not, skip to DA_STATE_PROBE_LOG or done.
3708                  */
3709                 if ((softc->flags & DA_FLAG_CAN_ATA_ZONE) == 0) {
3710                         daprobedone(periph, start_ccb);
3711                         break;
3712                 }
3713                 ata_zone = malloc(sizeof(*ata_zone), M_SCSIDA,
3714                                   M_NOWAIT|M_ZERO);
3715                 if (ata_zone == NULL) {
3716                         xpt_print(periph->path, "Couldn't malloc ata_zone "
3717                             "data\n");
3718                         daprobedone(periph, start_ccb);
3719                         break;
3720                 }
3721
3722                 retval = scsi_ata_read_log(&start_ccb->csio,
3723                     /*retries*/ da_retry_count,
3724                     /*cbfcnp*/ dadone_probeatazone,
3725                     /*tag_action*/ MSG_SIMPLE_Q_TAG,
3726                     /*log_address*/ ATA_IDENTIFY_DATA_LOG,
3727                     /*page_number*/ ATA_IDL_ZDI,
3728                     /*block_count*/ 1,
3729                     /*protocol*/ softc->flags & DA_FLAG_CAN_ATA_DMA ?
3730                                  AP_PROTO_DMA : AP_PROTO_PIO_IN,
3731                     /*data_ptr*/ (uint8_t *)ata_zone,
3732                     /*dxfer_len*/ sizeof(*ata_zone),
3733                     /*sense_len*/ SSD_FULL_SIZE,
3734                     /*timeout*/ da_default_timeout * 1000);
3735
3736                 if (retval != 0) {
3737                         xpt_print(periph->path, "scsi_ata_read_log() failed!");
3738                         free(ata_zone, M_SCSIDA);
3739                         daprobedone(periph, start_ccb);
3740                         break;
3741                 }
3742                 start_ccb->ccb_h.ccb_bp = NULL;
3743                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA_ZONE;
3744                 xpt_action(start_ccb);
3745
3746                 break;
3747         }
3748         case DA_STATE_PROBE_ZONE:
3749         {
3750                 struct scsi_vpd_zoned_bdc *bdc;
3751
3752                 /*
3753                  * Note that this page will be supported for SCSI protocol
3754                  * devices that support ZBC (SMR devices), as well as ATA
3755                  * protocol devices that are behind a SAT (SCSI to ATA
3756                  * Translation) layer that supports converting ZBC commands
3757                  * to their ZAC equivalents.
3758                  */
3759                 if (!scsi_vpd_supported_page(periph, SVPD_ZONED_BDC)) {
3760                         daprobedone(periph, start_ccb);
3761                         break;
3762                 }
3763                 bdc = (struct scsi_vpd_zoned_bdc *)
3764                         malloc(sizeof(*bdc), M_SCSIDA, M_NOWAIT|M_ZERO);
3765
3766                 if (bdc == NULL) {
3767                         xpt_release_ccb(start_ccb);
3768                         xpt_print(periph->path, "Couldn't malloc zone VPD "
3769                             "data\n");
3770                         break;
3771                 }
3772                 scsi_inquiry(&start_ccb->csio,
3773                              /*retries*/da_retry_count,
3774                              /*cbfcnp*/dadone_probezone,
3775                              /*tag_action*/MSG_SIMPLE_Q_TAG,
3776                              /*inq_buf*/(u_int8_t *)bdc,
3777                              /*inq_len*/sizeof(*bdc),
3778                              /*evpd*/TRUE,
3779                              /*page_code*/SVPD_ZONED_BDC,
3780                              /*sense_len*/SSD_FULL_SIZE,
3781                              /*timeout*/da_default_timeout * 1000);
3782                 start_ccb->ccb_h.ccb_bp = NULL;
3783                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ZONE;
3784                 xpt_action(start_ccb);
3785                 break;
3786         }
3787         }
3788 }
3789
3790 /*
3791  * In each of the methods below, while its the caller's
3792  * responsibility to ensure the request will fit into a
3793  * single device request, we might have changed the delete
3794  * method due to the device incorrectly advertising either
3795  * its supported methods or limits.
3796  *
3797  * To prevent this causing further issues we validate the
3798  * against the methods limits, and warn which would
3799  * otherwise be unnecessary.
3800  */
3801 static void
3802 da_delete_unmap(struct cam_periph *periph, union ccb *ccb, struct bio *bp)
3803 {
3804         struct da_softc *softc = (struct da_softc *)periph->softc;;
3805         struct bio *bp1;
3806         uint8_t *buf = softc->unmap_buf;
3807         struct scsi_unmap_desc *d = (void *)&buf[UNMAP_HEAD_SIZE];
3808         uint64_t lba, lastlba = (uint64_t)-1;
3809         uint64_t totalcount = 0;
3810         uint64_t count;
3811         uint32_t c, lastcount = 0, ranges = 0;
3812
3813         /*
3814          * Currently this doesn't take the UNMAP
3815          * Granularity and Granularity Alignment
3816          * fields into account.
3817          *
3818          * This could result in both unoptimal unmap
3819          * requests as as well as UNMAP calls unmapping
3820          * fewer LBA's than requested.
3821          */
3822
3823         bzero(softc->unmap_buf, sizeof(softc->unmap_buf));
3824         bp1 = bp;
3825         do {
3826                 /*
3827                  * Note: ada and da are different in how they store the
3828                  * pending bp's in a trim. ada stores all of them in the
3829                  * trim_req.bps. da stores all but the first one in the
3830                  * delete_run_queue. ada then completes all the bps in
3831                  * its adadone() loop. da completes all the bps in the
3832                  * delete_run_queue in dadone, and relies on the biodone
3833                  * after to complete. This should be reconciled since there's
3834                  * no real reason to do it differently. XXX
3835                  */
3836                 if (bp1 != bp)
3837                         bioq_insert_tail(&softc->delete_run_queue, bp1);
3838                 lba = bp1->bio_pblkno;
3839                 count = bp1->bio_bcount / softc->params.secsize;
3840
3841                 /* Try to extend the previous range. */
3842                 if (lba == lastlba) {
3843                         c = omin(count, UNMAP_RANGE_MAX - lastcount);
3844                         lastlba += c;
3845                         lastcount += c;
3846                         scsi_ulto4b(lastcount, d[ranges - 1].length);
3847                         count -= c;
3848                         lba += c;
3849                         totalcount += c;
3850                 } else if ((softc->quirks & DA_Q_STRICT_UNMAP) &&
3851                     softc->unmap_gran != 0) {
3852                         /* Align length of the previous range. */
3853                         if ((c = lastcount % softc->unmap_gran) != 0) {
3854                                 if (lastcount <= c) {
3855                                         totalcount -= lastcount;
3856                                         lastlba = (uint64_t)-1;
3857                                         lastcount = 0;
3858                                         ranges--;
3859                                 } else {
3860                                         totalcount -= c;
3861                                         lastlba -= c;
3862                                         lastcount -= c;
3863                                         scsi_ulto4b(lastcount,
3864                                             d[ranges - 1].length);
3865                                 }
3866                         }
3867                         /* Align beginning of the new range. */
3868                         c = (lba - softc->unmap_gran_align) % softc->unmap_gran;
3869                         if (c != 0) {
3870                                 c = softc->unmap_gran - c;
3871                                 if (count <= c) {
3872                                         count = 0;
3873                                 } else {
3874                                         lba += c;
3875                                         count -= c;
3876                                 }
3877                         }
3878                 }
3879
3880                 while (count > 0) {
3881                         c = omin(count, UNMAP_RANGE_MAX);
3882                         if (totalcount + c > softc->unmap_max_lba ||
3883                             ranges >= softc->unmap_max_ranges) {
3884                                 xpt_print(periph->path,
3885                                     "%s issuing short delete %ld > %ld"
3886                                     "|| %d >= %d",
3887                                     da_delete_method_desc[softc->delete_method],
3888                                     totalcount + c, softc->unmap_max_lba,
3889                                     ranges, softc->unmap_max_ranges);
3890                                 break;
3891                         }
3892                         scsi_u64to8b(lba, d[ranges].lba);
3893                         scsi_ulto4b(c, d[ranges].length);
3894                         lba += c;
3895                         totalcount += c;
3896                         ranges++;
3897                         count -= c;
3898                         lastlba = lba;
3899                         lastcount = c;
3900                 }
3901                 bp1 = cam_iosched_next_trim(softc->cam_iosched);
3902                 if (bp1 == NULL)
3903                         break;
3904                 if (ranges >= softc->unmap_max_ranges ||
3905                     totalcount + bp1->bio_bcount /
3906                     softc->params.secsize > softc->unmap_max_lba) {
3907                         cam_iosched_put_back_trim(softc->cam_iosched, bp1);
3908                         break;
3909                 }
3910         } while (1);
3911
3912         /* Align length of the last range. */
3913         if ((softc->quirks & DA_Q_STRICT_UNMAP) && softc->unmap_gran != 0 &&
3914             (c = lastcount % softc->unmap_gran) != 0) {
3915                 if (lastcount <= c)
3916                         ranges--;
3917                 else
3918                         scsi_ulto4b(lastcount - c, d[ranges - 1].length);
3919         }
3920
3921         scsi_ulto2b(ranges * 16 + 6, &buf[0]);
3922         scsi_ulto2b(ranges * 16, &buf[2]);
3923
3924         scsi_unmap(&ccb->csio,
3925                    /*retries*/da_retry_count,
3926                    /*cbfcnp*/dadone,
3927                    /*tag_action*/MSG_SIMPLE_Q_TAG,
3928                    /*byte2*/0,
3929                    /*data_ptr*/ buf,
3930                    /*dxfer_len*/ ranges * 16 + 8,
3931                    /*sense_len*/SSD_FULL_SIZE,
3932                    da_default_timeout * 1000);
3933         ccb->ccb_h.ccb_state = DA_CCB_DELETE;
3934         ccb->ccb_h.flags |= CAM_UNLOCKED;
3935         cam_iosched_submit_trim(softc->cam_iosched);
3936 }
3937
3938 static void
3939 da_delete_trim(struct cam_periph *periph, union ccb *ccb, struct bio *bp)
3940 {
3941         struct da_softc *softc = (struct da_softc *)periph->softc;
3942         struct bio *bp1;
3943         uint8_t *buf = softc->unmap_buf;
3944         uint64_t lastlba = (uint64_t)-1;
3945         uint64_t count;
3946         uint64_t lba;
3947         uint32_t lastcount = 0, c, requestcount;
3948         int ranges = 0, off, block_count;
3949
3950         bzero(softc->unmap_buf, sizeof(softc->unmap_buf));
3951         bp1 = bp;
3952         do {
3953                 if (bp1 != bp)//XXX imp XXX
3954                         bioq_insert_tail(&softc->delete_run_queue, bp1);
3955                 lba = bp1->bio_pblkno;
3956                 count = bp1->bio_bcount / softc->params.secsize;
3957                 requestcount = count;
3958
3959                 /* Try to extend the previous range. */
3960                 if (lba == lastlba) {
3961                         c = omin(count, ATA_DSM_RANGE_MAX - lastcount);
3962                         lastcount += c;
3963                         off = (ranges - 1) * 8;
3964                         buf[off + 6] = lastcount & 0xff;
3965                         buf[off + 7] = (lastcount >> 8) & 0xff;
3966                         count -= c;
3967                         lba += c;
3968                 }
3969
3970                 while (count > 0) {
3971                         c = omin(count, ATA_DSM_RANGE_MAX);
3972                         off = ranges * 8;
3973
3974                         buf[off + 0] = lba & 0xff;
3975                         buf[off + 1] = (lba >> 8) & 0xff;
3976                         buf[off + 2] = (lba >> 16) & 0xff;
3977                         buf[off + 3] = (lba >> 24) & 0xff;
3978                         buf[off + 4] = (lba >> 32) & 0xff;
3979                         buf[off + 5] = (lba >> 40) & 0xff;
3980                         buf[off + 6] = c & 0xff;
3981                         buf[off + 7] = (c >> 8) & 0xff;
3982                         lba += c;
3983                         ranges++;
3984                         count -= c;
3985                         lastcount = c;
3986                         if (count != 0 && ranges == softc->trim_max_ranges) {
3987                                 xpt_print(periph->path,
3988                                     "%s issuing short delete %ld > %ld\n",
3989                                     da_delete_method_desc[softc->delete_method],
3990                                     requestcount,
3991                                     (softc->trim_max_ranges - ranges) *
3992                                     ATA_DSM_RANGE_MAX);
3993                                 break;
3994                         }
3995                 }
3996                 lastlba = lba;
3997                 bp1 = cam_iosched_next_trim(softc->cam_iosched);
3998                 if (bp1 == NULL)
3999                         break;
4000                 if (bp1->bio_bcount / softc->params.secsize >
4001                     (softc->trim_max_ranges - ranges) * ATA_DSM_RANGE_MAX) {
4002                         cam_iosched_put_back_trim(softc->cam_iosched, bp1);
4003                         break;
4004                 }
4005         } while (1);
4006
4007         block_count = howmany(ranges, ATA_DSM_BLK_RANGES);
4008         scsi_ata_trim(&ccb->csio,
4009                       /*retries*/da_retry_count,
4010                       /*cbfcnp*/dadone,
4011                       /*tag_action*/MSG_SIMPLE_Q_TAG,
4012                       block_count,
4013                       /*data_ptr*/buf,
4014                       /*dxfer_len*/block_count * ATA_DSM_BLK_SIZE,
4015                       /*sense_len*/SSD_FULL_SIZE,
4016                       da_default_timeout * 1000);
4017         ccb->ccb_h.ccb_state = DA_CCB_DELETE;
4018         ccb->ccb_h.flags |= CAM_UNLOCKED;
4019         cam_iosched_submit_trim(softc->cam_iosched);
4020 }
4021
4022 /*
4023  * We calculate ws_max_blks here based off d_delmaxsize instead
4024  * of using softc->ws_max_blks as it is absolute max for the
4025  * device not the protocol max which may well be lower.
4026  */
4027 static void
4028 da_delete_ws(struct cam_periph *periph, union ccb *ccb, struct bio *bp)
4029 {
4030         struct da_softc *softc;
4031         struct bio *bp1;
4032         uint64_t ws_max_blks;
4033         uint64_t lba;
4034         uint64_t count; /* forward compat with WS32 */
4035
4036         softc = (struct da_softc *)periph->softc;
4037         ws_max_blks = softc->disk->d_delmaxsize / softc->params.secsize;
4038         lba = bp->bio_pblkno;
4039         count = 0;
4040         bp1 = bp;
4041         do {
4042                 if (bp1 != bp)//XXX imp XXX
4043                         bioq_insert_tail(&softc->delete_run_queue, bp1);
4044                 count += bp1->bio_bcount / softc->params.secsize;
4045                 if (count > ws_max_blks) {
4046                         xpt_print(periph->path,
4047                             "%s issuing short delete %ld > %ld\n",
4048                             da_delete_method_desc[softc->delete_method],
4049                             count, ws_max_blks);
4050                         count = omin(count, ws_max_blks);
4051                         break;
4052                 }
4053                 bp1 = cam_iosched_next_trim(softc->cam_iosched);
4054                 if (bp1 == NULL)
4055                         break;
4056                 if (lba + count != bp1->bio_pblkno ||
4057                     count + bp1->bio_bcount /
4058                     softc->params.secsize > ws_max_blks) {
4059                         cam_iosched_put_back_trim(softc->cam_iosched, bp1);
4060                         break;
4061                 }
4062         } while (1);
4063
4064         scsi_write_same(&ccb->csio,
4065                         /*retries*/da_retry_count,
4066                         /*cbfcnp*/dadone,
4067                         /*tag_action*/MSG_SIMPLE_Q_TAG,
4068                         /*byte2*/softc->delete_method ==
4069                             DA_DELETE_ZERO ? 0 : SWS_UNMAP,
4070                         softc->delete_method == DA_DELETE_WS16 ? 16 : 10,
4071                         /*lba*/lba,
4072                         /*block_count*/count,
4073                         /*data_ptr*/ __DECONST(void *, zero_region),
4074                         /*dxfer_len*/ softc->params.secsize,
4075                         /*sense_len*/SSD_FULL_SIZE,
4076                         da_default_timeout * 1000);
4077         ccb->ccb_h.ccb_state = DA_CCB_DELETE;
4078         ccb->ccb_h.flags |= CAM_UNLOCKED;
4079         cam_iosched_submit_trim(softc->cam_iosched);
4080 }
4081
4082 static int
4083 cmd6workaround(union ccb *ccb)
4084 {
4085         struct scsi_rw_6 cmd6;
4086         struct scsi_rw_10 *cmd10;
4087         struct da_softc *softc;
4088         u_int8_t *cdb;
4089         struct bio *bp;
4090         int frozen;
4091
4092         cdb = ccb->csio.cdb_io.cdb_bytes;
4093         softc = (struct da_softc *)xpt_path_periph(ccb->ccb_h.path)->softc;
4094
4095         if (ccb->ccb_h.ccb_state == DA_CCB_DELETE) {
4096                 da_delete_methods old_method = softc->delete_method;
4097
4098                 /*
4099                  * Typically there are two reasons for failure here
4100                  * 1. Delete method was detected as supported but isn't
4101                  * 2. Delete failed due to invalid params e.g. too big
4102                  *
4103                  * While we will attempt to choose an alternative delete method
4104                  * this may result in short deletes if the existing delete
4105                  * requests from geom are big for the new method chosen.
4106                  *
4107                  * This method assumes that the error which triggered this
4108                  * will not retry the io otherwise a panic will occur
4109                  */
4110                 dadeleteflag(softc, old_method, 0);
4111                 dadeletemethodchoose(softc, DA_DELETE_DISABLE);
4112                 if (softc->delete_method == DA_DELETE_DISABLE)
4113                         xpt_print(ccb->ccb_h.path,
4114                                   "%s failed, disabling BIO_DELETE\n",
4115                                   da_delete_method_desc[old_method]);
4116                 else
4117                         xpt_print(ccb->ccb_h.path,
4118                                   "%s failed, switching to %s BIO_DELETE\n",
4119                                   da_delete_method_desc[old_method],
4120                                   da_delete_method_desc[softc->delete_method]);
4121
4122                 while ((bp = bioq_takefirst(&softc->delete_run_queue)) != NULL)
4123                         cam_iosched_queue_work(softc->cam_iosched, bp);
4124                 cam_iosched_queue_work(softc->cam_iosched,
4125                     (struct bio *)ccb->ccb_h.ccb_bp);
4126                 ccb->ccb_h.ccb_bp = NULL;
4127                 return (0);
4128         }
4129
4130         /* Detect unsupported PREVENT ALLOW MEDIUM REMOVAL. */
4131         if ((ccb->ccb_h.flags & CAM_CDB_POINTER) == 0 &&
4132             (*cdb == PREVENT_ALLOW) &&
4133             (softc->quirks & DA_Q_NO_PREVENT) == 0) {
4134                 if (bootverbose)
4135                         xpt_print(ccb->ccb_h.path,
4136                             "PREVENT ALLOW MEDIUM REMOVAL not supported.\n");
4137                 softc->quirks |= DA_Q_NO_PREVENT;
4138                 return (0);
4139         }
4140
4141         /* Detect unsupported SYNCHRONIZE CACHE(10). */
4142         if ((ccb->ccb_h.flags & CAM_CDB_POINTER) == 0 &&
4143             (*cdb == SYNCHRONIZE_CACHE) &&
4144             (softc->quirks & DA_Q_NO_SYNC_CACHE) == 0) {
4145                 if (bootverbose)
4146                         xpt_print(ccb->ccb_h.path,
4147                             "SYNCHRONIZE CACHE(10) not supported.\n");
4148                 softc->quirks |= DA_Q_NO_SYNC_CACHE;
4149                 softc->disk->d_flags &= ~DISKFLAG_CANFLUSHCACHE;
4150                 return (0);
4151         }
4152
4153         /* Translation only possible if CDB is an array and cmd is R/W6 */
4154         if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0 ||
4155             (*cdb != READ_6 && *cdb != WRITE_6))
4156                 return 0;
4157
4158         xpt_print(ccb->ccb_h.path, "READ(6)/WRITE(6) not supported, "
4159             "increasing minimum_cmd_size to 10.\n");
4160         softc->minimum_cmd_size = 10;
4161
4162         bcopy(cdb, &cmd6, sizeof(struct scsi_rw_6));
4163         cmd10 = (struct scsi_rw_10 *)cdb;
4164         cmd10->opcode = (cmd6.opcode == READ_6) ? READ_10 : WRITE_10;
4165         cmd10->byte2 = 0;
4166         scsi_ulto4b(scsi_3btoul(cmd6.addr), cmd10->addr);
4167         cmd10->reserved = 0;
4168         scsi_ulto2b(cmd6.length, cmd10->length);
4169         cmd10->control = cmd6.control;
4170         ccb->csio.cdb_len = sizeof(*cmd10);
4171
4172         /* Requeue request, unfreezing queue if necessary */
4173         frozen = (ccb->ccb_h.status & CAM_DEV_QFRZN) != 0;
4174         ccb->ccb_h.status = CAM_REQUEUE_REQ;
4175         xpt_action(ccb);
4176         if (frozen) {
4177                 cam_release_devq(ccb->ccb_h.path,
4178                                  /*relsim_flags*/0,
4179                                  /*reduction*/0,
4180                                  /*timeout*/0,
4181                                  /*getcount_only*/0);
4182         }
4183         return (ERESTART);
4184 }
4185
4186 static void
4187 dazonedone(struct cam_periph *periph, union ccb *ccb)
4188 {
4189         struct da_softc *softc;
4190         struct bio *bp;
4191
4192         softc = periph->softc;
4193         bp = (struct bio *)ccb->ccb_h.ccb_bp;
4194
4195         switch (bp->bio_zone.zone_cmd) {
4196         case DISK_ZONE_OPEN:
4197         case DISK_ZONE_CLOSE:
4198         case DISK_ZONE_FINISH:
4199         case DISK_ZONE_RWP:
4200                 break;
4201         case DISK_ZONE_REPORT_ZONES: {
4202                 uint32_t avail_len;
4203                 struct disk_zone_report *rep;
4204                 struct scsi_report_zones_hdr *hdr;
4205                 struct scsi_report_zones_desc *desc;
4206                 struct disk_zone_rep_entry *entry;
4207                 uint32_t hdr_len, num_avail;
4208                 uint32_t num_to_fill, i;
4209                 int ata;
4210
4211                 rep = &bp->bio_zone.zone_params.report;
4212                 avail_len = ccb->csio.dxfer_len - ccb->csio.resid;
4213                 /*
4214                  * Note that bio_resid isn't normally used for zone
4215                  * commands, but it is used by devstat_end_transaction_bio()
4216                  * to determine how much data was transferred.  Because
4217                  * the size of the SCSI/ATA data structures is different
4218                  * than the size of the BIO interface structures, the
4219                  * amount of data actually transferred from the drive will
4220                  * be different than the amount of data transferred to
4221                  * the user.
4222                  */
4223                 bp->bio_resid = ccb->csio.resid;
4224                 hdr = (struct scsi_report_zones_hdr *)ccb->csio.data_ptr;
4225                 if (avail_len < sizeof(*hdr)) {
4226                         /*
4227                          * Is there a better error than EIO here?  We asked
4228                          * for at least the header, and we got less than
4229                          * that.
4230                          */
4231                         bp->bio_error = EIO;
4232                         bp->bio_flags |= BIO_ERROR;
4233                         bp->bio_resid = bp->bio_bcount;
4234                         break;
4235                 }
4236
4237                 if (softc->zone_interface == DA_ZONE_IF_ATA_PASS)
4238                         ata = 1;
4239                 else
4240                         ata = 0;
4241
4242                 hdr_len = ata ? le32dec(hdr->length) :
4243                                 scsi_4btoul(hdr->length);
4244                 if (hdr_len > 0)
4245                         rep->entries_available = hdr_len / sizeof(*desc);
4246                 else
4247                         rep->entries_available = 0;
4248                 /*
4249                  * NOTE: using the same values for the BIO version of the
4250                  * same field as the SCSI/ATA values.  This means we could
4251                  * get some additional values that aren't defined in bio.h
4252                  * if more values of the same field are defined later.
4253                  */
4254                 rep->header.same = hdr->byte4 & SRZ_SAME_MASK;
4255                 rep->header.maximum_lba = ata ?  le64dec(hdr->maximum_lba) :
4256                                           scsi_8btou64(hdr->maximum_lba);
4257                 /*
4258                  * If the drive reports no entries that match the query,
4259                  * we're done.
4260                  */
4261                 if (hdr_len == 0) {
4262                         rep->entries_filled = 0;
4263                         break;
4264                 }
4265
4266                 num_avail = min((avail_len - sizeof(*hdr)) / sizeof(*desc),
4267                                 hdr_len / sizeof(*desc));
4268                 /*
4269                  * If the drive didn't return any data, then we're done.
4270                  */
4271                 if (num_avail == 0) {
4272                         rep->entries_filled = 0;
4273                         break;
4274                 }
4275
4276                 num_to_fill = min(num_avail, rep->entries_allocated);
4277                 /*
4278                  * If the user didn't allocate any entries for us to fill,
4279                  * we're done.
4280                  */
4281                 if (num_to_fill == 0) {
4282                         rep->entries_filled = 0;
4283                         break;
4284                 }
4285
4286                 for (i = 0, desc = &hdr->desc_list[0], entry=&rep->entries[0];
4287                      i < num_to_fill; i++, desc++, entry++) {
4288                         /*
4289                          * NOTE: we're mapping the values here directly
4290                          * from the SCSI/ATA bit definitions to the bio.h
4291                          * definitons.  There is also a warning in
4292                          * disk_zone.h, but the impact is that if
4293                          * additional values are added in the SCSI/ATA
4294                          * specs these will be visible to consumers of
4295                          * this interface.
4296                          */
4297                         entry->zone_type = desc->zone_type & SRZ_TYPE_MASK;
4298                         entry->zone_condition =
4299                             (desc->zone_flags & SRZ_ZONE_COND_MASK) >>
4300                             SRZ_ZONE_COND_SHIFT;
4301                         entry->zone_flags |= desc->zone_flags &
4302                             (SRZ_ZONE_NON_SEQ|SRZ_ZONE_RESET);
4303                         entry->zone_length =
4304                             ata ? le64dec(desc->zone_length) :
4305                                   scsi_8btou64(desc->zone_length);
4306                         entry->zone_start_lba =
4307                             ata ? le64dec(desc->zone_start_lba) :
4308                                   scsi_8btou64(desc->zone_start_lba);
4309                         entry->write_pointer_lba =
4310                             ata ? le64dec(desc->write_pointer_lba) :
4311                                   scsi_8btou64(desc->write_pointer_lba);
4312                 }
4313                 rep->entries_filled = num_to_fill;
4314                 break;
4315         }
4316         case DISK_ZONE_GET_PARAMS:
4317         default:
4318                 /*
4319                  * In theory we should not get a GET_PARAMS bio, since it
4320                  * should be handled without queueing the command to the
4321                  * drive.
4322                  */
4323                 panic("%s: Invalid zone command %d", __func__,
4324                     bp->bio_zone.zone_cmd);
4325                 break;
4326         }
4327
4328         if (bp->bio_zone.zone_cmd == DISK_ZONE_REPORT_ZONES)
4329                 free(ccb->csio.data_ptr, M_SCSIDA);
4330 }
4331
4332 static void
4333 dadone(struct cam_periph *periph, union ccb *done_ccb)
4334 {
4335         struct bio *bp, *bp1;
4336         struct da_softc *softc;
4337         struct ccb_scsiio *csio;
4338         u_int32_t  priority;
4339         da_ccb_state state;
4340
4341         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone\n"));
4342
4343         softc = (struct da_softc *)periph->softc;
4344         priority = done_ccb->ccb_h.pinfo.priority;
4345         csio = &done_ccb->csio;
4346
4347 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
4348         if (csio->bio != NULL)
4349                 biotrack(csio->bio, __func__);
4350 #endif
4351         state = csio->ccb_h.ccb_state & DA_CCB_TYPE_MASK;
4352
4353         cam_periph_lock(periph);
4354         bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
4355         if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4356                 int error;
4357                 int sf;
4358
4359                 if ((csio->ccb_h.ccb_state & DA_CCB_RETRY_UA) != 0)
4360                         sf = SF_RETRY_UA;
4361                 else
4362                         sf = 0;
4363
4364                 error = daerror(done_ccb, CAM_RETRY_SELTO, sf);
4365                 if (error == ERESTART) {
4366                         /* A retry was scheduled, so just return. */
4367                         cam_periph_unlock(periph);
4368                         return;
4369                 }
4370                 bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
4371                 if (error != 0) {
4372                         int queued_error;
4373
4374                         /*
4375                          * return all queued I/O with EIO, so that
4376                          * the client can retry these I/Os in the
4377                          * proper order should it attempt to recover.
4378                          */
4379                         queued_error = EIO;
4380
4381                         if (error == ENXIO
4382                          && (softc->flags & DA_FLAG_PACK_INVALID)== 0) {
4383                                 /*
4384                                  * Catastrophic error.  Mark our pack as
4385                                  * invalid.
4386                                  *
4387                                  * XXX See if this is really a media
4388                                  * XXX change first?
4389                                  */
4390                                 xpt_print(periph->path, "Invalidating pack\n");
4391                                 softc->flags |= DA_FLAG_PACK_INVALID;
4392 #ifdef CAM_IO_STATS
4393                                 softc->invalidations++;
4394 #endif
4395                                 queued_error = ENXIO;
4396                         }
4397                         cam_iosched_flush(softc->cam_iosched, NULL,
4398                            queued_error);
4399                         if (bp != NULL) {
4400                                 bp->bio_error = error;
4401                                 bp->bio_resid = bp->bio_bcount;
4402                                 bp->bio_flags |= BIO_ERROR;
4403                         }
4404                 } else if (bp != NULL) {
4405                         if (state == DA_CCB_DELETE)
4406                                 bp->bio_resid = 0;
4407                         else
4408                                 bp->bio_resid = csio->resid;
4409                         bp->bio_error = 0;
4410                         if (bp->bio_resid != 0)
4411                                 bp->bio_flags |= BIO_ERROR;
4412                 }
4413                 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
4414                         cam_release_devq(done_ccb->ccb_h.path,
4415                                          /*relsim_flags*/0,
4416                                          /*reduction*/0,
4417                                          /*timeout*/0,
4418                                          /*getcount_only*/0);
4419         } else if (bp != NULL) {
4420                 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
4421                         panic("REQ_CMP with QFRZN");
4422                 if (bp->bio_cmd == BIO_ZONE)
4423                         dazonedone(periph, done_ccb);
4424                 else if (state == DA_CCB_DELETE)
4425                         bp->bio_resid = 0;
4426                 else
4427                         bp->bio_resid = csio->resid;
4428                 if ((csio->resid > 0) && (bp->bio_cmd != BIO_ZONE))
4429                         bp->bio_flags |= BIO_ERROR;
4430                 if (softc->error_inject != 0) {
4431                         bp->bio_error = softc->error_inject;
4432                         bp->bio_resid = bp->bio_bcount;
4433                         bp->bio_flags |= BIO_ERROR;
4434                         softc->error_inject = 0;
4435                 }
4436         }
4437
4438         if (bp != NULL)
4439                 biotrack(bp, __func__);
4440         LIST_REMOVE(&done_ccb->ccb_h, periph_links.le);
4441         if (LIST_EMPTY(&softc->pending_ccbs))
4442                 softc->flags |= DA_FLAG_WAS_OTAG;
4443
4444         /*
4445          * We need to call cam_iosched before we call biodone so that we don't
4446          * measure any activity that happens in the completion routine, which in
4447          * the case of sendfile can be quite extensive. Release the periph
4448          * refcount taken in dastart() for each CCB.
4449          */
4450         cam_iosched_bio_complete(softc->cam_iosched, bp, done_ccb);
4451         xpt_release_ccb(done_ccb);
4452         KASSERT(softc->refcount >= 1, ("dadone softc %p refcount %d", softc, softc->refcount));
4453         softc->refcount--;
4454         if (state == DA_CCB_DELETE) {
4455                 TAILQ_HEAD(, bio) queue;
4456
4457                 TAILQ_INIT(&queue);
4458                 TAILQ_CONCAT(&queue, &softc->delete_run_queue.queue, bio_queue);
4459                 softc->delete_run_queue.insert_point = NULL;
4460                 /*
4461                  * Normally, the xpt_release_ccb() above would make sure
4462                  * that when we have more work to do, that work would
4463                  * get kicked off. However, we specifically keep
4464                  * delete_running set to 0 before the call above to
4465                  * allow other I/O to progress when many BIO_DELETE
4466                  * requests are pushed down. We set delete_running to 0
4467                  * and call daschedule again so that we don't stall if
4468                  * there are no other I/Os pending apart from BIO_DELETEs.
4469                  */
4470                 cam_iosched_trim_done(softc->cam_iosched);
4471                 daschedule(periph);
4472                 cam_periph_unlock(periph);
4473                 while ((bp1 = TAILQ_FIRST(&queue)) != NULL) {
4474                         TAILQ_REMOVE(&queue, bp1, bio_queue);
4475                         bp1->bio_error = bp->bio_error;
4476                         if (bp->bio_flags & BIO_ERROR) {
4477                                 bp1->bio_flags |= BIO_ERROR;
4478                                 bp1->bio_resid = bp1->bio_bcount;
4479                         } else
4480                                 bp1->bio_resid = 0;
4481                         biodone(bp1);
4482                 }
4483         } else {
4484                 daschedule(periph);
4485                 cam_periph_unlock(periph);
4486         }
4487         if (bp != NULL)
4488                 biodone(bp);
4489         return;
4490 }
4491
4492 static void
4493 dadone_probewp(struct cam_periph *periph, union ccb *done_ccb)
4494 {
4495         struct scsi_mode_header_6 *mode_hdr6;
4496         struct scsi_mode_header_10 *mode_hdr10;
4497         struct da_softc *softc;
4498         struct ccb_scsiio *csio;
4499         u_int32_t  priority;
4500         uint8_t dev_spec;
4501
4502         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probewp\n"));
4503
4504         softc = (struct da_softc *)periph->softc;
4505         priority = done_ccb->ccb_h.pinfo.priority;
4506         csio = &done_ccb->csio;
4507
4508         if (softc->minimum_cmd_size > 6) {
4509                 mode_hdr10 = (struct scsi_mode_header_10 *)csio->data_ptr;
4510                 dev_spec = mode_hdr10->dev_spec;
4511         } else {
4512                 mode_hdr6 = (struct scsi_mode_header_6 *)csio->data_ptr;
4513                 dev_spec = mode_hdr6->dev_spec;
4514         }
4515         if (cam_ccb_status(done_ccb) == CAM_REQ_CMP) {
4516                 if ((dev_spec & 0x80) != 0)
4517                         softc->disk->d_flags |= DISKFLAG_WRITE_PROTECT;
4518                 else
4519                         softc->disk->d_flags &= ~DISKFLAG_WRITE_PROTECT;
4520         } else {
4521                 int error;
4522
4523                 error = daerror(done_ccb, CAM_RETRY_SELTO,
4524                                 SF_RETRY_UA|SF_NO_PRINT);
4525                 if (error == ERESTART)
4526                         return;
4527                 else if (error != 0) {
4528                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
4529                                 /* Don't wedge this device's queue */
4530                                 cam_release_devq(done_ccb->ccb_h.path,
4531                                                  /*relsim_flags*/0,
4532                                                  /*reduction*/0,
4533                                                  /*timeout*/0,
4534                                                  /*getcount_only*/0);
4535                         }
4536                 }
4537         }
4538
4539         free(csio->data_ptr, M_SCSIDA);
4540         xpt_release_ccb(done_ccb);
4541         if ((softc->flags & DA_FLAG_CAN_RC16) != 0)
4542                 softc->state = DA_STATE_PROBE_RC16;
4543         else
4544                 softc->state = DA_STATE_PROBE_RC;
4545         xpt_schedule(periph, priority);
4546         return;
4547 }
4548
4549 static void
4550 dadone_proberc(struct cam_periph *periph, union ccb *done_ccb)
4551 {
4552         struct scsi_read_capacity_data *rdcap;
4553         struct scsi_read_capacity_data_long *rcaplong;
4554         struct da_softc *softc;
4555         struct ccb_scsiio *csio;
4556         da_ccb_state state;
4557         char *announce_buf;
4558         u_int32_t  priority;
4559         int lbp;
4560
4561         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_proberc\n"));
4562
4563         softc = (struct da_softc *)periph->softc;
4564         priority = done_ccb->ccb_h.pinfo.priority;
4565         csio = &done_ccb->csio;
4566         state = csio->ccb_h.ccb_state & DA_CCB_TYPE_MASK;
4567
4568         lbp = 0;
4569         rdcap = NULL;
4570         rcaplong = NULL;
4571         /* XXX TODO: can this be a malloc? */
4572         announce_buf = softc->announce_temp;
4573         bzero(announce_buf, DA_ANNOUNCETMP_SZ);
4574
4575         if (state == DA_CCB_PROBE_RC)
4576                 rdcap =(struct scsi_read_capacity_data *)csio->data_ptr;
4577         else
4578                 rcaplong = (struct scsi_read_capacity_data_long *)
4579                         csio->data_ptr;
4580
4581         if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4582                 struct disk_params *dp;
4583                 uint32_t block_size;
4584                 uint64_t maxsector;
4585                 u_int lalba;    /* Lowest aligned LBA. */
4586
4587                 if (state == DA_CCB_PROBE_RC) {
4588                         block_size = scsi_4btoul(rdcap->length);
4589                         maxsector = scsi_4btoul(rdcap->addr);
4590                         lalba = 0;
4591
4592                         /*
4593                          * According to SBC-2, if the standard 10
4594                          * byte READ CAPACITY command returns 2^32,
4595                          * we should issue the 16 byte version of
4596                          * the command, since the device in question
4597                          * has more sectors than can be represented
4598                          * with the short version of the command.
4599                          */
4600                         if (maxsector == 0xffffffff) {
4601                                 free(rdcap, M_SCSIDA);
4602                                 xpt_release_ccb(done_ccb);
4603                                 softc->state = DA_STATE_PROBE_RC16;
4604                                 xpt_schedule(periph, priority);
4605                                 return;
4606                         }
4607                 } else {
4608                         block_size = scsi_4btoul(rcaplong->length);
4609                         maxsector = scsi_8btou64(rcaplong->addr);
4610                         lalba = scsi_2btoul(rcaplong->lalba_lbp);
4611                 }
4612
4613                 /*
4614                  * Because GEOM code just will panic us if we
4615                  * give them an 'illegal' value we'll avoid that
4616                  * here.
4617                  */
4618                 if (block_size == 0) {
4619                         block_size = 512;
4620                         if (maxsector == 0)
4621                                 maxsector = -1;
4622                 }
4623                 if (block_size >= MAXPHYS) {
4624                         xpt_print(periph->path,
4625                             "unsupportable block size %ju\n",
4626                             (uintmax_t) block_size);
4627                         announce_buf = NULL;
4628                         cam_periph_invalidate(periph);
4629                 } else {
4630                         /*
4631                          * We pass rcaplong into dasetgeom(),
4632                          * because it will only use it if it is
4633                          * non-NULL.
4634                          */
4635                         dasetgeom(periph, block_size, maxsector,
4636                                   rcaplong, sizeof(*rcaplong));
4637                         lbp = (lalba & SRC16_LBPME_A);
4638                         dp = &softc->params;
4639                         snprintf(announce_buf, DA_ANNOUNCETMP_SZ,
4640                             "%juMB (%ju %u byte sectors)",
4641                             ((uintmax_t)dp->secsize * dp->sectors) /
4642                              (1024 * 1024),
4643                             (uintmax_t)dp->sectors, dp->secsize);
4644                 }
4645         } else {
4646                 int error;
4647
4648                 /*
4649                  * Retry any UNIT ATTENTION type errors.  They
4650                  * are expected at boot.
4651                  */
4652                 error = daerror(done_ccb, CAM_RETRY_SELTO,
4653                                 SF_RETRY_UA|SF_NO_PRINT);
4654                 if (error == ERESTART) {
4655                         /*
4656                          * A retry was scheuled, so
4657                          * just return.
4658                          */
4659                         return;
4660                 } else if (error != 0) {
4661                         int asc, ascq;
4662                         int sense_key, error_code;
4663                         int have_sense;
4664                         cam_status status;
4665                         struct ccb_getdev cgd;
4666
4667                         /* Don't wedge this device's queue */
4668                         status = done_ccb->ccb_h.status;
4669                         if ((status & CAM_DEV_QFRZN) != 0)
4670                                 cam_release_devq(done_ccb->ccb_h.path,
4671                                                  /*relsim_flags*/0,
4672                                                  /*reduction*/0,
4673                                                  /*timeout*/0,
4674                                                  /*getcount_only*/0);
4675
4676
4677                         xpt_setup_ccb(&cgd.ccb_h, done_ccb->ccb_h.path,
4678                                       CAM_PRIORITY_NORMAL);
4679                         cgd.ccb_h.func_code = XPT_GDEV_TYPE;
4680                         xpt_action((union ccb *)&cgd);
4681
4682                         if (scsi_extract_sense_ccb(done_ccb,
4683                             &error_code, &sense_key, &asc, &ascq))
4684                                 have_sense = TRUE;
4685                         else
4686                                 have_sense = FALSE;
4687
4688                         /*
4689                          * If we tried READ CAPACITY(16) and failed,
4690                          * fallback to READ CAPACITY(10).
4691                          */
4692                         if ((state == DA_CCB_PROBE_RC16) &&
4693                             (softc->flags & DA_FLAG_CAN_RC16) &&
4694                             (((csio->ccb_h.status & CAM_STATUS_MASK) ==
4695                                 CAM_REQ_INVALID) ||
4696                              ((have_sense) &&
4697                               (error_code == SSD_CURRENT_ERROR ||
4698                                error_code == SSD_DESC_CURRENT_ERROR) &&
4699                               (sense_key == SSD_KEY_ILLEGAL_REQUEST)))) {
4700                                 cam_periph_assert(periph, MA_OWNED);
4701                                 softc->flags &= ~DA_FLAG_CAN_RC16;
4702                                 free(rdcap, M_SCSIDA);
4703                                 xpt_release_ccb(done_ccb);
4704                                 softc->state = DA_STATE_PROBE_RC;
4705                                 xpt_schedule(periph, priority);
4706                                 return;
4707                         }
4708
4709                         /*
4710                          * Attach to anything that claims to be a
4711                          * direct access or optical disk device,
4712                          * as long as it doesn't return a "Logical
4713                          * unit not supported" (0x25) error.
4714                          * "Internal Target Failure" (0x44) is also
4715                          * special and typically means that the
4716                          * device is a SATA drive behind a SATL
4717                          * translation that's fallen into a
4718                          * terminally fatal state.
4719                          */
4720                         if ((have_sense)
4721                          && (asc != 0x25) && (asc != 0x44)
4722                          && (error_code == SSD_CURRENT_ERROR
4723                           || error_code == SSD_DESC_CURRENT_ERROR)) {
4724                                 const char *sense_key_desc;
4725                                 const char *asc_desc;
4726
4727                                 dasetgeom(periph, 512, -1, NULL, 0);
4728                                 scsi_sense_desc(sense_key, asc, ascq,
4729                                                 &cgd.inq_data, &sense_key_desc,
4730                                                 &asc_desc);
4731                                 snprintf(announce_buf, DA_ANNOUNCETMP_SZ,
4732                                     "Attempt to query device "
4733                                     "size failed: %s, %s",
4734                                     sense_key_desc, asc_desc);
4735                         } else {
4736                                 if (have_sense)
4737                                         scsi_sense_print(&done_ccb->csio);
4738                                 else {
4739                                         xpt_print(periph->path,
4740                                             "got CAM status %#x\n",
4741                                             done_ccb->ccb_h.status);
4742                                 }
4743
4744                                 xpt_print(periph->path, "fatal error, "
4745                                     "failed to attach to device\n");
4746
4747                                 announce_buf = NULL;
4748
4749                                 /*
4750                                  * Free up resources.
4751                                  */
4752                                 cam_periph_invalidate(periph);
4753                         }
4754                 }
4755         }
4756         free(csio->data_ptr, M_SCSIDA);
4757         if (announce_buf != NULL &&
4758             ((softc->flags & DA_FLAG_ANNOUNCED) == 0)) {
4759                 struct sbuf sb;
4760
4761                 sbuf_new(&sb, softc->announcebuf, DA_ANNOUNCE_SZ,
4762                     SBUF_FIXEDLEN);
4763                 xpt_announce_periph_sbuf(periph, &sb, announce_buf);
4764                 xpt_announce_quirks_sbuf(periph, &sb, softc->quirks,
4765                     DA_Q_BIT_STRING);
4766                 sbuf_finish(&sb);
4767                 sbuf_putbuf(&sb);
4768
4769                 /*
4770                  * Create our sysctl variables, now that we know
4771                  * we have successfully attached.
4772                  */
4773                 /* increase the refcount */
4774                 if (da_periph_acquire(periph, DA_REF_SYSCTL) == 0) {
4775                         taskqueue_enqueue(taskqueue_thread,
4776                                           &softc->sysctl_task);
4777                 } else {
4778                         /* XXX This message is useless! */
4779                         xpt_print(periph->path, "fatal error, "
4780                             "could not acquire reference count\n");
4781                 }
4782         }
4783
4784         /* We already probed the device. */
4785         if (softc->flags & DA_FLAG_PROBED) {
4786                 daprobedone(periph, done_ccb);
4787                 return;
4788         }
4789
4790         /* Ensure re-probe doesn't see old delete. */
4791         softc->delete_available = 0;
4792         dadeleteflag(softc, DA_DELETE_ZERO, 1);
4793         if (lbp && (softc->quirks & DA_Q_NO_UNMAP) == 0) {
4794                 /*
4795                  * Based on older SBC-3 spec revisions
4796                  * any of the UNMAP methods "may" be
4797                  * available via LBP given this flag so
4798                  * we flag all of them as available and
4799                  * then remove those which further
4800                  * probes confirm aren't available
4801                  * later.
4802                  *
4803                  * We could also check readcap(16) p_type
4804                  * flag to exclude one or more invalid
4805                  * write same (X) types here
4806                  */
4807                 dadeleteflag(softc, DA_DELETE_WS16, 1);
4808                 dadeleteflag(softc, DA_DELETE_WS10, 1);
4809                 dadeleteflag(softc, DA_DELETE_UNMAP, 1);
4810
4811                 xpt_release_ccb(done_ccb);
4812                 softc->state = DA_STATE_PROBE_LBP;
4813                 xpt_schedule(periph, priority);
4814                 return;
4815         }
4816
4817         xpt_release_ccb(done_ccb);
4818         softc->state = DA_STATE_PROBE_BDC;
4819         xpt_schedule(periph, priority);
4820         return;
4821 }
4822
4823 static void
4824 dadone_probelbp(struct cam_periph *periph, union ccb *done_ccb)
4825 {
4826         struct scsi_vpd_logical_block_prov *lbp;
4827         struct da_softc *softc;
4828         struct ccb_scsiio *csio;
4829         u_int32_t  priority;
4830
4831         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probelbp\n"));
4832
4833         softc = (struct da_softc *)periph->softc;
4834         priority = done_ccb->ccb_h.pinfo.priority;
4835         csio = &done_ccb->csio;
4836         lbp = (struct scsi_vpd_logical_block_prov *)csio->data_ptr;
4837
4838         if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4839                 /*
4840                  * T10/1799-D Revision 31 states at least one of these
4841                  * must be supported but we don't currently enforce this.
4842                  */
4843                 dadeleteflag(softc, DA_DELETE_WS16,
4844                      (lbp->flags & SVPD_LBP_WS16));
4845                 dadeleteflag(softc, DA_DELETE_WS10,
4846                              (lbp->flags & SVPD_LBP_WS10));
4847                 dadeleteflag(softc, DA_DELETE_UNMAP,
4848                              (lbp->flags & SVPD_LBP_UNMAP));
4849         } else {
4850                 int error;
4851                 error = daerror(done_ccb, CAM_RETRY_SELTO,
4852                                 SF_RETRY_UA|SF_NO_PRINT);
4853                 if (error == ERESTART)
4854                         return;
4855                 else if (error != 0) {
4856                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
4857                                 /* Don't wedge this device's queue */
4858                                 cam_release_devq(done_ccb->ccb_h.path,
4859                                                  /*relsim_flags*/0,
4860                                                  /*reduction*/0,
4861                                                  /*timeout*/0,
4862                                                  /*getcount_only*/0);
4863                         }
4864
4865                         /*
4866                          * Failure indicates we don't support any SBC-3
4867                          * delete methods with UNMAP
4868                          */
4869                 }
4870         }
4871
4872         free(lbp, M_SCSIDA);
4873         xpt_release_ccb(done_ccb);
4874         softc->state = DA_STATE_PROBE_BLK_LIMITS;
4875         xpt_schedule(periph, priority);
4876         return;
4877 }
4878
4879 static void
4880 dadone_probeblklimits(struct cam_periph *periph, union ccb *done_ccb)
4881 {
4882         struct scsi_vpd_block_limits *block_limits;
4883         struct da_softc *softc;
4884         struct ccb_scsiio *csio;
4885         u_int32_t  priority;
4886
4887         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probeblklimits\n"));
4888
4889         softc = (struct da_softc *)periph->softc;
4890         priority = done_ccb->ccb_h.pinfo.priority;
4891         csio = &done_ccb->csio;
4892         block_limits = (struct scsi_vpd_block_limits *)csio->data_ptr;
4893
4894         if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4895                 uint32_t max_txfer_len = scsi_4btoul(
4896                         block_limits->max_txfer_len);
4897                 uint32_t max_unmap_lba_cnt = scsi_4btoul(
4898                         block_limits->max_unmap_lba_cnt);
4899                 uint32_t max_unmap_blk_cnt = scsi_4btoul(
4900                         block_limits->max_unmap_blk_cnt);
4901                 uint32_t unmap_gran = scsi_4btoul(
4902                         block_limits->opt_unmap_grain);
4903                 uint32_t unmap_gran_align = scsi_4btoul(
4904                         block_limits->unmap_grain_align);
4905                 uint64_t ws_max_blks = scsi_8btou64(
4906                         block_limits->max_write_same_length);
4907
4908                 if (max_txfer_len != 0) {
4909                         softc->disk->d_maxsize = MIN(softc->maxio,
4910                             (off_t)max_txfer_len * softc->params.secsize);
4911                 }
4912
4913                 /*
4914                  * We should already support UNMAP but we check lba
4915                  * and block count to be sure
4916                  */
4917                 if (max_unmap_lba_cnt != 0x00L &&
4918                     max_unmap_blk_cnt != 0x00L) {
4919                         softc->unmap_max_lba = max_unmap_lba_cnt;
4920                         softc->unmap_max_ranges = min(max_unmap_blk_cnt,
4921                                 UNMAP_MAX_RANGES);
4922                         if (unmap_gran > 1) {
4923                                 softc->unmap_gran = unmap_gran;
4924                                 if (unmap_gran_align & 0x80000000) {
4925                                         softc->unmap_gran_align =
4926                                             unmap_gran_align & 0x7fffffff;
4927                                 }
4928                         }
4929                 } else {
4930                         /*
4931                          * Unexpected UNMAP limits which means the
4932                          * device doesn't actually support UNMAP
4933                          */
4934                         dadeleteflag(softc, DA_DELETE_UNMAP, 0);
4935                 }
4936
4937                 if (ws_max_blks != 0x00L)
4938                         softc->ws_max_blks = ws_max_blks;
4939         } else {
4940                 int error;
4941                 error = daerror(done_ccb, CAM_RETRY_SELTO,
4942                                 SF_RETRY_UA|SF_NO_PRINT);
4943                 if (error == ERESTART)
4944                         return;
4945                 else if (error != 0) {
4946                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
4947                                 /* Don't wedge this device's queue */
4948                                 cam_release_devq(done_ccb->ccb_h.path,
4949                                                  /*relsim_flags*/0,
4950                                                  /*reduction*/0,
4951                                                  /*timeout*/0,
4952                                                  /*getcount_only*/0);
4953                         }
4954
4955                         /*
4956                          * Failure here doesn't mean UNMAP is not
4957                          * supported as this is an optional page.
4958                          */
4959                         softc->unmap_max_lba = 1;
4960                         softc->unmap_max_ranges = 1;
4961                 }
4962         }
4963
4964         free(block_limits, M_SCSIDA);
4965         xpt_release_ccb(done_ccb);
4966         softc->state = DA_STATE_PROBE_BDC;
4967         xpt_schedule(periph, priority);
4968         return;
4969 }
4970
4971 static void
4972 dadone_probebdc(struct cam_periph *periph, union ccb *done_ccb)
4973 {
4974         struct scsi_vpd_block_device_characteristics *bdc;
4975         struct da_softc *softc;
4976         struct ccb_scsiio *csio;
4977         u_int32_t  priority;
4978
4979         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probebdc\n"));
4980
4981         softc = (struct da_softc *)periph->softc;
4982         priority = done_ccb->ccb_h.pinfo.priority;
4983         csio = &done_ccb->csio;
4984         bdc = (struct scsi_vpd_block_device_characteristics *)csio->data_ptr;
4985
4986         if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4987                 uint32_t valid_len;
4988
4989                 /*
4990                  * Disable queue sorting for non-rotational media
4991                  * by default.
4992                  */
4993                 u_int16_t old_rate = softc->disk->d_rotation_rate;
4994
4995                 valid_len = csio->dxfer_len - csio->resid;
4996                 if (SBDC_IS_PRESENT(bdc, valid_len,
4997                     medium_rotation_rate)) {
4998                         softc->disk->d_rotation_rate =
4999                                 scsi_2btoul(bdc->medium_rotation_rate);
5000                         if (softc->disk->d_rotation_rate ==
5001                             SVPD_BDC_RATE_NON_ROTATING) {
5002                                 cam_iosched_set_sort_queue(
5003                                     softc->cam_iosched, 0);
5004                                 softc->rotating = 0;
5005                         }
5006                         if (softc->disk->d_rotation_rate != old_rate) {
5007                                 disk_attr_changed(softc->disk,
5008                                     "GEOM::rotation_rate", M_NOWAIT);
5009                         }
5010                 }
5011                 if ((SBDC_IS_PRESENT(bdc, valid_len, flags))
5012                  && (softc->zone_mode == DA_ZONE_NONE)) {
5013                         int ata_proto;
5014
5015                         if (scsi_vpd_supported_page(periph,
5016                             SVPD_ATA_INFORMATION))
5017                                 ata_proto = 1;
5018                         else
5019                                 ata_proto = 0;
5020
5021                         /*
5022                          * The Zoned field will only be set for
5023                          * Drive Managed and Host Aware drives.  If
5024                          * they are Host Managed, the device type
5025                          * in the standard INQUIRY data should be
5026                          * set to T_ZBC_HM (0x14).
5027                          */
5028                         if ((bdc->flags & SVPD_ZBC_MASK) ==
5029                              SVPD_HAW_ZBC) {
5030                                 softc->zone_mode = DA_ZONE_HOST_AWARE;
5031                                 softc->zone_interface = (ata_proto) ?
5032                                    DA_ZONE_IF_ATA_SAT : DA_ZONE_IF_SCSI;
5033                         } else if ((bdc->flags & SVPD_ZBC_MASK) ==
5034                              SVPD_DM_ZBC) {
5035                                 softc->zone_mode =DA_ZONE_DRIVE_MANAGED;
5036                                 softc->zone_interface = (ata_proto) ?
5037                                    DA_ZONE_IF_ATA_SAT : DA_ZONE_IF_SCSI;
5038                         } else if ((bdc->flags & SVPD_ZBC_MASK) !=
5039                                   SVPD_ZBC_NR) {
5040                                 xpt_print(periph->path, "Unknown zoned "
5041                                     "type %#x",
5042                                     bdc->flags & SVPD_ZBC_MASK);
5043                         }
5044                 }
5045         } else {
5046                 int error;
5047                 error = daerror(done_ccb, CAM_RETRY_SELTO,
5048                                 SF_RETRY_UA|SF_NO_PRINT);
5049                 if (error == ERESTART)
5050                         return;
5051                 else if (error != 0) {
5052                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5053                                 /* Don't wedge this device's queue */
5054                                 cam_release_devq(done_ccb->ccb_h.path,
5055                                                  /*relsim_flags*/0,
5056                                                  /*reduction*/0,
5057                                                  /*timeout*/0,
5058                                                  /*getcount_only*/0);
5059                         }
5060                 }
5061         }
5062
5063         free(bdc, M_SCSIDA);
5064         xpt_release_ccb(done_ccb);
5065         softc->state = DA_STATE_PROBE_ATA;
5066         xpt_schedule(periph, priority);
5067         return;
5068 }
5069
5070 static void
5071 dadone_probeata(struct cam_periph *periph, union ccb *done_ccb)
5072 {
5073         struct ata_params *ata_params;
5074         struct ccb_scsiio *csio;
5075         struct da_softc *softc;
5076         u_int32_t  priority;
5077         int continue_probe;
5078         int error, i;
5079         int16_t *ptr;
5080
5081         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probeata\n"));
5082
5083         softc = (struct da_softc *)periph->softc;
5084         priority = done_ccb->ccb_h.pinfo.priority;
5085         csio = &done_ccb->csio;
5086         ata_params = (struct ata_params *)csio->data_ptr;
5087         ptr = (uint16_t *)ata_params;
5088         continue_probe = 0;
5089         error = 0;
5090
5091         if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5092                 uint16_t old_rate;
5093
5094                 for (i = 0; i < sizeof(*ata_params) / 2; i++)
5095                         ptr[i] = le16toh(ptr[i]);
5096                 if (ata_params->support_dsm & ATA_SUPPORT_DSM_TRIM &&
5097                     (softc->quirks & DA_Q_NO_UNMAP) == 0) {
5098                         dadeleteflag(softc, DA_DELETE_ATA_TRIM, 1);
5099                         if (ata_params->max_dsm_blocks != 0)
5100                                 softc->trim_max_ranges = min(
5101                                   softc->trim_max_ranges,
5102                                   ata_params->max_dsm_blocks *
5103                                   ATA_DSM_BLK_RANGES);
5104                 }
5105                 /*
5106                  * Disable queue sorting for non-rotational media
5107                  * by default.
5108                  */
5109                 old_rate = softc->disk->d_rotation_rate;
5110                 softc->disk->d_rotation_rate = ata_params->media_rotation_rate;
5111                 if (softc->disk->d_rotation_rate == ATA_RATE_NON_ROTATING) {
5112                         cam_iosched_set_sort_queue(softc->cam_iosched, 0);
5113                         softc->rotating = 0;
5114                 }
5115                 if (softc->disk->d_rotation_rate != old_rate) {
5116                         disk_attr_changed(softc->disk,
5117                             "GEOM::rotation_rate", M_NOWAIT);
5118                 }
5119
5120                 cam_periph_assert(periph, MA_OWNED);
5121                 if (ata_params->capabilities1 & ATA_SUPPORT_DMA)
5122                         softc->flags |= DA_FLAG_CAN_ATA_DMA;
5123
5124                 if (ata_params->support.extension & ATA_SUPPORT_GENLOG)
5125                         softc->flags |= DA_FLAG_CAN_ATA_LOG;
5126
5127                 /*
5128                  * At this point, if we have a SATA host aware drive,
5129                  * we communicate via ATA passthrough unless the
5130                  * SAT layer supports ZBC -> ZAC translation.  In
5131                  * that case,
5132                  *
5133                  * XXX KDM figure out how to detect a host managed
5134                  * SATA drive.
5135                  */
5136                 if (softc->zone_mode == DA_ZONE_NONE) {
5137                         /*
5138                          * Note that we don't override the zone
5139                          * mode or interface if it has already been
5140                          * set.  This is because it has either been
5141                          * set as a quirk, or when we probed the
5142                          * SCSI Block Device Characteristics page,
5143                          * the zoned field was set.  The latter
5144                          * means that the SAT layer supports ZBC to
5145                          * ZAC translation, and we would prefer to
5146                          * use that if it is available.
5147                          */
5148                         if ((ata_params->support3 &
5149                             ATA_SUPPORT_ZONE_MASK) ==
5150                             ATA_SUPPORT_ZONE_HOST_AWARE) {
5151                                 softc->zone_mode = DA_ZONE_HOST_AWARE;
5152                                 softc->zone_interface =
5153                                     DA_ZONE_IF_ATA_PASS;
5154                         } else if ((ata_params->support3 &
5155                                     ATA_SUPPORT_ZONE_MASK) ==
5156                                     ATA_SUPPORT_ZONE_DEV_MANAGED) {
5157                                 softc->zone_mode =DA_ZONE_DRIVE_MANAGED;
5158                                 softc->zone_interface = DA_ZONE_IF_ATA_PASS;
5159                         }
5160                 }
5161
5162         } else {
5163                 error = daerror(done_ccb, CAM_RETRY_SELTO,
5164                                 SF_RETRY_UA|SF_NO_PRINT);
5165                 if (error == ERESTART)
5166                         return;
5167                 else if (error != 0) {
5168                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5169                                 /* Don't wedge this device's queue */
5170                                 cam_release_devq(done_ccb->ccb_h.path,
5171                                                  /*relsim_flags*/0,
5172                                                  /*reduction*/0,
5173                                                  /*timeout*/0,
5174                                                  /*getcount_only*/0);
5175                         }
5176                 }
5177         }
5178
5179         free(ata_params, M_SCSIDA);
5180         if ((softc->zone_mode == DA_ZONE_HOST_AWARE)
5181          || (softc->zone_mode == DA_ZONE_HOST_MANAGED)) {
5182                 /*
5183                  * If the ATA IDENTIFY failed, we could be talking
5184                  * to a SCSI drive, although that seems unlikely,
5185                  * since the drive did report that it supported the
5186                  * ATA Information VPD page.  If the ATA IDENTIFY
5187                  * succeeded, and the SAT layer doesn't support
5188                  * ZBC -> ZAC translation, continue on to get the
5189                  * directory of ATA logs, and complete the rest of
5190                  * the ZAC probe.  If the SAT layer does support
5191                  * ZBC -> ZAC translation, we want to use that,
5192                  * and we'll probe the SCSI Zoned Block Device
5193                  * Characteristics VPD page next.
5194                  */
5195                 if ((error == 0)
5196                  && (softc->flags & DA_FLAG_CAN_ATA_LOG)
5197                  && (softc->zone_interface == DA_ZONE_IF_ATA_PASS))
5198                         softc->state = DA_STATE_PROBE_ATA_LOGDIR;
5199                 else
5200                         softc->state = DA_STATE_PROBE_ZONE;
5201                 continue_probe = 1;
5202         }
5203         if (continue_probe != 0) {
5204                 xpt_release_ccb(done_ccb);
5205                 xpt_schedule(periph, priority);
5206                 return;
5207         } else
5208                 daprobedone(periph, done_ccb);
5209         return;
5210 }
5211
5212 static void
5213 dadone_probeatalogdir(struct cam_periph *periph, union ccb *done_ccb)
5214 {
5215         struct da_softc *softc;
5216         struct ccb_scsiio *csio;
5217         u_int32_t  priority;
5218         int error;
5219
5220         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probeatalogdir\n"));
5221
5222         softc = (struct da_softc *)periph->softc;
5223         priority = done_ccb->ccb_h.pinfo.priority;
5224         csio = &done_ccb->csio;
5225
5226         cam_periph_lock(periph);
5227         if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5228                 error = 0;
5229                 softc->valid_logdir_len = 0;
5230                 bzero(&softc->ata_logdir, sizeof(softc->ata_logdir));
5231                 softc->valid_logdir_len = csio->dxfer_len - csio->resid;
5232                 if (softc->valid_logdir_len > 0)
5233                         bcopy(csio->data_ptr, &softc->ata_logdir,
5234                             min(softc->valid_logdir_len,
5235                                 sizeof(softc->ata_logdir)));
5236                 /*
5237                  * Figure out whether the Identify Device log is
5238                  * supported.  The General Purpose log directory
5239                  * has a header, and lists the number of pages
5240                  * available for each GP log identified by the
5241                  * offset into the list.
5242                  */
5243                 if ((softc->valid_logdir_len >=
5244                     ((ATA_IDENTIFY_DATA_LOG + 1) * sizeof(uint16_t)))
5245                  && (le16dec(softc->ata_logdir.header) ==
5246                      ATA_GP_LOG_DIR_VERSION)
5247                  && (le16dec(&softc->ata_logdir.num_pages[
5248                      (ATA_IDENTIFY_DATA_LOG *
5249                      sizeof(uint16_t)) - sizeof(uint16_t)]) > 0)){
5250                         softc->flags |= DA_FLAG_CAN_ATA_IDLOG;
5251                 } else {
5252                         softc->flags &= ~DA_FLAG_CAN_ATA_IDLOG;
5253                 }
5254         } else {
5255                 error = daerror(done_ccb, CAM_RETRY_SELTO,
5256                                 SF_RETRY_UA|SF_NO_PRINT);
5257                 if (error == ERESTART)
5258                         return;
5259                 else if (error != 0) {
5260                         /*
5261                          * If we can't get the ATA log directory,
5262                          * then ATA logs are effectively not
5263                          * supported even if the bit is set in the
5264                          * identify data.
5265                          */
5266                         softc->flags &= ~(DA_FLAG_CAN_ATA_LOG |
5267                                           DA_FLAG_CAN_ATA_IDLOG);
5268                         if ((done_ccb->ccb_h.status &
5269                              CAM_DEV_QFRZN) != 0) {
5270                                 /* Don't wedge this device's queue */
5271                                 cam_release_devq(done_ccb->ccb_h.path,
5272                                                  /*relsim_flags*/0,
5273                                                  /*reduction*/0,
5274                                                  /*timeout*/0,
5275                                                  /*getcount_only*/0);
5276                         }
5277                 }
5278         }
5279         cam_periph_unlock(periph);
5280
5281         free(csio->data_ptr, M_SCSIDA);
5282
5283         if ((error == 0)
5284          && (softc->flags & DA_FLAG_CAN_ATA_IDLOG)) {
5285                 softc->state = DA_STATE_PROBE_ATA_IDDIR;
5286                 xpt_release_ccb(done_ccb);
5287                 xpt_schedule(periph, priority);
5288                 return;
5289         }
5290         daprobedone(periph, done_ccb);
5291         return;
5292 }
5293
5294 static void
5295 dadone_probeataiddir(struct cam_periph *periph, union ccb *done_ccb)
5296 {
5297         struct da_softc *softc;
5298         struct ccb_scsiio *csio;
5299         u_int32_t  priority;
5300         int error;
5301
5302         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probeataiddir\n"));
5303
5304         softc = (struct da_softc *)periph->softc;
5305         priority = done_ccb->ccb_h.pinfo.priority;
5306         csio = &done_ccb->csio;
5307
5308         cam_periph_lock(periph);
5309         if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5310                 off_t entries_offset, max_entries;
5311                 error = 0;
5312
5313                 softc->valid_iddir_len = 0;
5314                 bzero(&softc->ata_iddir, sizeof(softc->ata_iddir));
5315                 softc->flags &= ~(DA_FLAG_CAN_ATA_SUPCAP |
5316                                   DA_FLAG_CAN_ATA_ZONE);
5317                 softc->valid_iddir_len = csio->dxfer_len - csio->resid;
5318                 if (softc->valid_iddir_len > 0)
5319                         bcopy(csio->data_ptr, &softc->ata_iddir,
5320                             min(softc->valid_iddir_len,
5321                                 sizeof(softc->ata_iddir)));
5322
5323                 entries_offset =
5324                     __offsetof(struct ata_identify_log_pages,entries);
5325                 max_entries = softc->valid_iddir_len - entries_offset;
5326                 if ((softc->valid_iddir_len > (entries_offset + 1))
5327                  && (le64dec(softc->ata_iddir.header) == ATA_IDLOG_REVISION)
5328                  && (softc->ata_iddir.entry_count > 0)) {
5329                         int num_entries, i;
5330
5331                         num_entries = softc->ata_iddir.entry_count;
5332                         num_entries = min(num_entries,
5333                            softc->valid_iddir_len - entries_offset);
5334                         for (i = 0; i < num_entries && i < max_entries; i++) {
5335                                 if (softc->ata_iddir.entries[i] ==
5336                                     ATA_IDL_SUP_CAP)
5337                                         softc->flags |= DA_FLAG_CAN_ATA_SUPCAP;
5338                                 else if (softc->ata_iddir.entries[i] ==
5339                                          ATA_IDL_ZDI)
5340                                         softc->flags |= DA_FLAG_CAN_ATA_ZONE;
5341
5342                                 if ((softc->flags & DA_FLAG_CAN_ATA_SUPCAP)
5343                                  && (softc->flags & DA_FLAG_CAN_ATA_ZONE))
5344                                         break;
5345                         }
5346                 }
5347         } else {
5348                 error = daerror(done_ccb, CAM_RETRY_SELTO,
5349                                 SF_RETRY_UA|SF_NO_PRINT);
5350                 if (error == ERESTART)
5351                         return;
5352                 else if (error != 0) {
5353                         /*
5354                          * If we can't get the ATA Identify Data log
5355                          * directory, then it effectively isn't
5356                          * supported even if the ATA Log directory
5357                          * a non-zero number of pages present for
5358                          * this log.
5359                          */
5360                         softc->flags &= ~DA_FLAG_CAN_ATA_IDLOG;
5361                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5362                                 /* Don't wedge this device's queue */
5363                                 cam_release_devq(done_ccb->ccb_h.path,
5364                                                  /*relsim_flags*/0,
5365                                                  /*reduction*/0,
5366                                                  /*timeout*/0,
5367                                                  /*getcount_only*/0);
5368                         }
5369                 }
5370         }
5371         cam_periph_unlock(periph);
5372
5373         free(csio->data_ptr, M_SCSIDA);
5374
5375         if ((error == 0) && (softc->flags & DA_FLAG_CAN_ATA_SUPCAP)) {
5376                 softc->state = DA_STATE_PROBE_ATA_SUP;
5377                 xpt_release_ccb(done_ccb);
5378                 xpt_schedule(periph, priority);
5379                 return;
5380         }
5381         daprobedone(periph, done_ccb);
5382         return;
5383 }
5384
5385 static void
5386 dadone_probeatasup(struct cam_periph *periph, union ccb *done_ccb)
5387 {
5388         struct da_softc *softc;
5389         struct ccb_scsiio *csio;
5390         u_int32_t  priority;
5391         int error;
5392
5393         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probeatasup\n"));
5394
5395         softc = (struct da_softc *)periph->softc;
5396         priority = done_ccb->ccb_h.pinfo.priority;
5397         csio = &done_ccb->csio;
5398
5399         if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5400                 uint32_t valid_len;
5401                 size_t needed_size;
5402                 struct ata_identify_log_sup_cap *sup_cap;
5403                 error = 0;
5404
5405                 sup_cap = (struct ata_identify_log_sup_cap *)csio->data_ptr;
5406                 valid_len = csio->dxfer_len - csio->resid;
5407                 needed_size = __offsetof(struct ata_identify_log_sup_cap,
5408                     sup_zac_cap) + 1 + sizeof(sup_cap->sup_zac_cap);
5409                 if (valid_len >= needed_size) {
5410                         uint64_t zoned, zac_cap;
5411
5412                         zoned = le64dec(sup_cap->zoned_cap);
5413                         if (zoned & ATA_ZONED_VALID) {
5414                                 /*
5415                                  * This should have already been
5416                                  * set, because this is also in the
5417                                  * ATA identify data.
5418                                  */
5419                                 if ((zoned & ATA_ZONED_MASK) ==
5420                                     ATA_SUPPORT_ZONE_HOST_AWARE)
5421                                         softc->zone_mode = DA_ZONE_HOST_AWARE;
5422                                 else if ((zoned & ATA_ZONED_MASK) ==
5423                                     ATA_SUPPORT_ZONE_DEV_MANAGED)
5424                                         softc->zone_mode =
5425                                             DA_ZONE_DRIVE_MANAGED;
5426                         }
5427
5428                         zac_cap = le64dec(sup_cap->sup_zac_cap);
5429                         if (zac_cap & ATA_SUP_ZAC_CAP_VALID) {
5430                                 if (zac_cap & ATA_REPORT_ZONES_SUP)
5431                                         softc->zone_flags |=
5432                                             DA_ZONE_FLAG_RZ_SUP;
5433                                 if (zac_cap & ATA_ND_OPEN_ZONE_SUP)
5434                                         softc->zone_flags |=
5435                                             DA_ZONE_FLAG_OPEN_SUP;
5436                                 if (zac_cap & ATA_ND_CLOSE_ZONE_SUP)
5437                                         softc->zone_flags |=
5438                                             DA_ZONE_FLAG_CLOSE_SUP;
5439                                 if (zac_cap & ATA_ND_FINISH_ZONE_SUP)
5440                                         softc->zone_flags |=
5441                                             DA_ZONE_FLAG_FINISH_SUP;
5442                                 if (zac_cap & ATA_ND_RWP_SUP)
5443                                         softc->zone_flags |=
5444                                             DA_ZONE_FLAG_RWP_SUP;
5445                         } else {
5446                                 /*
5447                                  * This field was introduced in
5448                                  * ACS-4, r08 on April 28th, 2015.
5449                                  * If the drive firmware was written
5450                                  * to an earlier spec, it won't have
5451                                  * the field.  So, assume all
5452                                  * commands are supported.
5453                                  */
5454                                 softc->zone_flags |= DA_ZONE_FLAG_SUP_MASK;
5455                         }
5456
5457                 }
5458         } else {
5459                 error = daerror(done_ccb, CAM_RETRY_SELTO,
5460                                 SF_RETRY_UA|SF_NO_PRINT);
5461                 if (error == ERESTART)
5462                         return;
5463                 else if (error != 0) {
5464                         /*
5465                          * If we can't get the ATA Identify Data
5466                          * Supported Capabilities page, clear the
5467                          * flag...
5468                          */
5469                         cam_periph_lock(periph);
5470                         softc->flags &= ~DA_FLAG_CAN_ATA_SUPCAP;
5471                         cam_periph_unlock(periph);
5472                         /*
5473                          * And clear zone capabilities.
5474                          */
5475                         softc->zone_flags &= ~DA_ZONE_FLAG_SUP_MASK;
5476                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5477                                 /* Don't wedge this device's queue */
5478                                 cam_release_devq(done_ccb->ccb_h.path,
5479                                                  /*relsim_flags*/0,
5480                                                  /*reduction*/0,
5481                                                  /*timeout*/0,
5482                                                  /*getcount_only*/0);
5483                         }
5484                 }
5485         }
5486
5487         free(csio->data_ptr, M_SCSIDA);
5488
5489         if ((error == 0) && (softc->flags & DA_FLAG_CAN_ATA_ZONE)) {
5490                 softc->state = DA_STATE_PROBE_ATA_ZONE;
5491                 xpt_release_ccb(done_ccb);
5492                 xpt_schedule(periph, priority);
5493                 return;
5494         }
5495         daprobedone(periph, done_ccb);
5496         return;
5497 }
5498
5499 static void
5500 dadone_probeatazone(struct cam_periph *periph, union ccb *done_ccb)
5501 {
5502         struct da_softc *softc;
5503         struct ccb_scsiio *csio;
5504         int error;
5505
5506         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probeatazone\n"));
5507
5508         softc = (struct da_softc *)periph->softc;
5509         csio = &done_ccb->csio;
5510
5511         if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5512                 struct ata_zoned_info_log *zi_log;
5513                 uint32_t valid_len;
5514                 size_t needed_size;
5515
5516                 zi_log = (struct ata_zoned_info_log *)csio->data_ptr;
5517
5518                 valid_len = csio->dxfer_len - csio->resid;
5519                 needed_size = __offsetof(struct ata_zoned_info_log,
5520                     version_info) + 1 + sizeof(zi_log->version_info);
5521                 if (valid_len >= needed_size) {
5522                         uint64_t tmpvar;
5523
5524                         tmpvar = le64dec(zi_log->zoned_cap);
5525                         if (tmpvar & ATA_ZDI_CAP_VALID) {
5526                                 if (tmpvar & ATA_ZDI_CAP_URSWRZ)
5527                                         softc->zone_flags |=
5528                                             DA_ZONE_FLAG_URSWRZ;
5529                                 else
5530                                         softc->zone_flags &=
5531                                             ~DA_ZONE_FLAG_URSWRZ;
5532                         }
5533                         tmpvar = le64dec(zi_log->optimal_seq_zones);
5534                         if (tmpvar & ATA_ZDI_OPT_SEQ_VALID) {
5535                                 softc->zone_flags |= DA_ZONE_FLAG_OPT_SEQ_SET;
5536                                 softc->optimal_seq_zones = (tmpvar &
5537                                     ATA_ZDI_OPT_SEQ_MASK);
5538                         } else {
5539                                 softc->zone_flags &= ~DA_ZONE_FLAG_OPT_SEQ_SET;
5540                                 softc->optimal_seq_zones = 0;
5541                         }
5542
5543                         tmpvar =le64dec(zi_log->optimal_nonseq_zones);
5544                         if (tmpvar & ATA_ZDI_OPT_NS_VALID) {
5545                                 softc->zone_flags |=
5546                                     DA_ZONE_FLAG_OPT_NONSEQ_SET;
5547                                 softc->optimal_nonseq_zones =
5548                                     (tmpvar & ATA_ZDI_OPT_NS_MASK);
5549                         } else {
5550                                 softc->zone_flags &=
5551                                     ~DA_ZONE_FLAG_OPT_NONSEQ_SET;
5552                                 softc->optimal_nonseq_zones = 0;
5553                         }
5554
5555                         tmpvar = le64dec(zi_log->max_seq_req_zones);
5556                         if (tmpvar & ATA_ZDI_MAX_SEQ_VALID) {
5557                                 softc->zone_flags |= DA_ZONE_FLAG_MAX_SEQ_SET;
5558                                 softc->max_seq_zones =
5559                                     (tmpvar & ATA_ZDI_MAX_SEQ_MASK);
5560                         } else {
5561                                 softc->zone_flags &= ~DA_ZONE_FLAG_MAX_SEQ_SET;
5562                                 softc->max_seq_zones = 0;
5563                         }
5564                 }
5565         } else {
5566                 error = daerror(done_ccb, CAM_RETRY_SELTO,
5567                                 SF_RETRY_UA|SF_NO_PRINT);
5568                 if (error == ERESTART)
5569                         return;
5570                 else if (error != 0) {
5571                         cam_periph_lock(periph);
5572                         softc->flags &= ~DA_FLAG_CAN_ATA_ZONE;
5573                         softc->flags &= ~DA_ZONE_FLAG_SET_MASK;
5574                         cam_periph_unlock(periph);
5575
5576                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5577                                 /* Don't wedge this device's queue */
5578                                 cam_release_devq(done_ccb->ccb_h.path,
5579                                                  /*relsim_flags*/0,
5580                                                  /*reduction*/0,
5581                                                  /*timeout*/0,
5582                                                  /*getcount_only*/0);
5583                         }
5584                 }
5585
5586         }
5587         free(csio->data_ptr, M_SCSIDA);
5588
5589         daprobedone(periph, done_ccb);
5590         return;
5591 }
5592
5593 static void
5594 dadone_probezone(struct cam_periph *periph, union ccb *done_ccb)
5595 {
5596         struct da_softc *softc;
5597         struct ccb_scsiio *csio;
5598         int error;
5599
5600         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probezone\n"));
5601
5602         softc = (struct da_softc *)periph->softc;
5603         csio = &done_ccb->csio;
5604
5605         if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5606                 uint32_t valid_len;
5607                 size_t needed_len;
5608                 struct scsi_vpd_zoned_bdc *zoned_bdc;
5609
5610                 error = 0;
5611                 zoned_bdc = (struct scsi_vpd_zoned_bdc *)csio->data_ptr;
5612                 valid_len = csio->dxfer_len - csio->resid;
5613                 needed_len = __offsetof(struct scsi_vpd_zoned_bdc,
5614                     max_seq_req_zones) + 1 +
5615                     sizeof(zoned_bdc->max_seq_req_zones);
5616                 if ((valid_len >= needed_len)
5617                  && (scsi_2btoul(zoned_bdc->page_length) >= SVPD_ZBDC_PL)) {
5618                         if (zoned_bdc->flags & SVPD_ZBDC_URSWRZ)
5619                                 softc->zone_flags |= DA_ZONE_FLAG_URSWRZ;
5620                         else
5621                                 softc->zone_flags &= ~DA_ZONE_FLAG_URSWRZ;
5622                         softc->optimal_seq_zones =
5623                             scsi_4btoul(zoned_bdc->optimal_seq_zones);
5624                         softc->zone_flags |= DA_ZONE_FLAG_OPT_SEQ_SET;
5625                         softc->optimal_nonseq_zones = scsi_4btoul(
5626                             zoned_bdc->optimal_nonseq_zones);
5627                         softc->zone_flags |= DA_ZONE_FLAG_OPT_NONSEQ_SET;
5628                         softc->max_seq_zones =
5629                             scsi_4btoul(zoned_bdc->max_seq_req_zones);
5630                         softc->zone_flags |= DA_ZONE_FLAG_MAX_SEQ_SET;
5631                 }
5632                 /*
5633                  * All of the zone commands are mandatory for SCSI
5634                  * devices.
5635                  *
5636                  * XXX KDM this is valid as of September 2015.
5637                  * Re-check this assumption once the SAT spec is
5638                  * updated to support SCSI ZBC to ATA ZAC mapping.
5639                  * Since ATA allows zone commands to be reported
5640                  * as supported or not, this may not necessarily
5641                  * be true for an ATA device behind a SAT (SCSI to
5642                  * ATA Translation) layer.
5643                  */
5644                 softc->zone_flags |= DA_ZONE_FLAG_SUP_MASK;
5645         } else {
5646                 error = daerror(done_ccb, CAM_RETRY_SELTO,
5647                                 SF_RETRY_UA|SF_NO_PRINT);
5648                 if (error == ERESTART)
5649                         return;
5650                 else if (error != 0) {
5651                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5652                                 /* Don't wedge this device's queue */
5653                                 cam_release_devq(done_ccb->ccb_h.path,
5654                                                  /*relsim_flags*/0,
5655                                                  /*reduction*/0,
5656                                                  /*timeout*/0,
5657                                                  /*getcount_only*/0);
5658                         }
5659                 }
5660         }
5661         daprobedone(periph, done_ccb);
5662         return;
5663 }
5664
5665 static void
5666 dadone_tur(struct cam_periph *periph, union ccb *done_ccb)
5667 {
5668         struct da_softc *softc;
5669         struct ccb_scsiio *csio;
5670
5671         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_tur\n"));
5672
5673         softc = (struct da_softc *)periph->softc;
5674         csio = &done_ccb->csio;
5675         if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5676
5677                 if (daerror(done_ccb, CAM_RETRY_SELTO,
5678                     SF_RETRY_UA | SF_NO_RECOVERY | SF_NO_PRINT) == ERESTART)
5679                         return; /* Will complete again, keep reference */
5680                 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
5681                         cam_release_devq(done_ccb->ccb_h.path,
5682                                          /*relsim_flags*/0,
5683                                          /*reduction*/0,
5684                                          /*timeout*/0,
5685                                          /*getcount_only*/0);
5686         }
5687         xpt_release_ccb(done_ccb);
5688         softc->flags &= ~DA_FLAG_TUR_PENDING;
5689         da_periph_release_locked(periph, DA_REF_TUR);
5690         return;
5691 }
5692
5693 static void
5694 dareprobe(struct cam_periph *periph)
5695 {
5696         struct da_softc   *softc;
5697         int status;
5698
5699         softc = (struct da_softc *)periph->softc;
5700
5701         /* Probe in progress; don't interfere. */
5702         if (softc->state != DA_STATE_NORMAL)
5703                 return;
5704
5705         status = da_periph_acquire(periph, DA_REF_REPROBE);
5706         KASSERT(status == 0, ("dareprobe: cam_periph_acquire failed"));
5707
5708         softc->state = DA_STATE_PROBE_WP;
5709         xpt_schedule(periph, CAM_PRIORITY_DEV);
5710 }
5711
5712 static int
5713 daerror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags)
5714 {
5715         struct da_softc   *softc;
5716         struct cam_periph *periph;
5717         int error, error_code, sense_key, asc, ascq;
5718
5719 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
5720         if (ccb->csio.bio != NULL)
5721                 biotrack(ccb->csio.bio, __func__);
5722 #endif
5723
5724         periph = xpt_path_periph(ccb->ccb_h.path);
5725         softc = (struct da_softc *)periph->softc;
5726
5727         cam_periph_assert(periph, MA_OWNED);
5728
5729         /*
5730          * Automatically detect devices that do not support
5731          * READ(6)/WRITE(6) and upgrade to using 10 byte cdbs.
5732          */
5733         error = 0;
5734         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INVALID) {
5735                 error = cmd6workaround(ccb);
5736         } else if (scsi_extract_sense_ccb(ccb,
5737             &error_code, &sense_key, &asc, &ascq)) {
5738                 if (sense_key == SSD_KEY_ILLEGAL_REQUEST)
5739                         error = cmd6workaround(ccb);
5740                 /*
5741                  * If the target replied with CAPACITY DATA HAS CHANGED UA,
5742                  * query the capacity and notify upper layers.
5743                  */
5744                 else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
5745                     asc == 0x2A && ascq == 0x09) {
5746                         xpt_print(periph->path, "Capacity data has changed\n");
5747                         softc->flags &= ~DA_FLAG_PROBED;
5748                         dareprobe(periph);
5749                         sense_flags |= SF_NO_PRINT;
5750                 } else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
5751                     asc == 0x28 && ascq == 0x00) {
5752                         softc->flags &= ~DA_FLAG_PROBED;
5753                         disk_media_changed(softc->disk, M_NOWAIT);
5754                 } else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
5755                     asc == 0x3F && ascq == 0x03) {
5756                         xpt_print(periph->path, "INQUIRY data has changed\n");
5757                         softc->flags &= ~DA_FLAG_PROBED;
5758                         dareprobe(periph);
5759                         sense_flags |= SF_NO_PRINT;
5760                 } else if (sense_key == SSD_KEY_NOT_READY &&
5761                     asc == 0x3a && (softc->flags & DA_FLAG_PACK_INVALID) == 0) {
5762                         softc->flags |= DA_FLAG_PACK_INVALID;
5763                         disk_media_gone(softc->disk, M_NOWAIT);
5764                 }
5765         }
5766         if (error == ERESTART)
5767                 return (ERESTART);
5768
5769 #ifdef CAM_IO_STATS
5770         switch (ccb->ccb_h.status & CAM_STATUS_MASK) {
5771         case CAM_CMD_TIMEOUT:
5772                 softc->timeouts++;
5773                 break;
5774         case CAM_REQ_ABORTED:
5775         case CAM_REQ_CMP_ERR:
5776         case CAM_REQ_TERMIO:
5777         case CAM_UNREC_HBA_ERROR:
5778         case CAM_DATA_RUN_ERR:
5779                 softc->errors++;
5780                 break;
5781         default:
5782                 break;
5783         }
5784 #endif
5785
5786         /*
5787          * XXX
5788          * Until we have a better way of doing pack validation,
5789          * don't treat UAs as errors.
5790          */
5791         sense_flags |= SF_RETRY_UA;
5792
5793         if (softc->quirks & DA_Q_RETRY_BUSY)
5794                 sense_flags |= SF_RETRY_BUSY;
5795         return(cam_periph_error(ccb, cam_flags, sense_flags));
5796 }
5797
5798 static void
5799 damediapoll(void *arg)
5800 {
5801         struct cam_periph *periph = arg;
5802         struct da_softc *softc = periph->softc;
5803
5804         if (!cam_iosched_has_work_flags(softc->cam_iosched, DA_WORK_TUR) &&
5805             (softc->flags & DA_FLAG_TUR_PENDING) == 0 &&
5806             LIST_EMPTY(&softc->pending_ccbs)) {
5807                 if (da_periph_acquire(periph, DA_REF_TUR) == 0) {
5808                         cam_iosched_set_work_flags(softc->cam_iosched, DA_WORK_TUR);
5809                         daschedule(periph);
5810                 }
5811         }
5812         /* Queue us up again */
5813         if (da_poll_period != 0)
5814                 callout_schedule(&softc->mediapoll_c, da_poll_period * hz);
5815 }
5816
5817 static void
5818 daprevent(struct cam_periph *periph, int action)
5819 {
5820         struct  da_softc *softc;
5821         union   ccb *ccb;
5822         int     error;
5823
5824         cam_periph_assert(periph, MA_OWNED);
5825         softc = (struct da_softc *)periph->softc;
5826
5827         if (((action == PR_ALLOW)
5828           && (softc->flags & DA_FLAG_PACK_LOCKED) == 0)
5829          || ((action == PR_PREVENT)
5830           && (softc->flags & DA_FLAG_PACK_LOCKED) != 0)) {
5831                 return;
5832         }
5833
5834         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
5835
5836         scsi_prevent(&ccb->csio,
5837                      /*retries*/1,
5838                      /*cbcfp*/NULL,
5839                      MSG_SIMPLE_Q_TAG,
5840                      action,
5841                      SSD_FULL_SIZE,
5842                      5000);
5843
5844         error = cam_periph_runccb(ccb, daerror, CAM_RETRY_SELTO,
5845             SF_RETRY_UA | SF_NO_PRINT, softc->disk->d_devstat);
5846
5847         if (error == 0) {
5848                 if (action == PR_ALLOW)
5849                         softc->flags &= ~DA_FLAG_PACK_LOCKED;
5850                 else
5851                         softc->flags |= DA_FLAG_PACK_LOCKED;
5852         }
5853
5854         xpt_release_ccb(ccb);
5855 }
5856
5857 static void
5858 dasetgeom(struct cam_periph *periph, uint32_t block_len, uint64_t maxsector,
5859           struct scsi_read_capacity_data_long *rcaplong, size_t rcap_len)
5860 {
5861         struct ccb_calc_geometry ccg;
5862         struct da_softc *softc;
5863         struct disk_params *dp;
5864         u_int lbppbe, lalba;
5865         int error;
5866
5867         softc = (struct da_softc *)periph->softc;
5868
5869         dp = &softc->params;
5870         dp->secsize = block_len;
5871         dp->sectors = maxsector + 1;
5872         if (rcaplong != NULL) {
5873                 lbppbe = rcaplong->prot_lbppbe & SRC16_LBPPBE;
5874                 lalba = scsi_2btoul(rcaplong->lalba_lbp);
5875                 lalba &= SRC16_LALBA_A;
5876         } else {
5877                 lbppbe = 0;
5878                 lalba = 0;
5879         }
5880
5881         if (lbppbe > 0) {
5882                 dp->stripesize = block_len << lbppbe;
5883                 dp->stripeoffset = (dp->stripesize - block_len * lalba) %
5884                     dp->stripesize;
5885         } else if (softc->quirks & DA_Q_4K) {
5886                 dp->stripesize = 4096;
5887                 dp->stripeoffset = 0;
5888         } else if (softc->unmap_gran != 0) {
5889                 dp->stripesize = block_len * softc->unmap_gran;
5890                 dp->stripeoffset = (dp->stripesize - block_len *
5891                     softc->unmap_gran_align) % dp->stripesize;
5892         } else {
5893                 dp->stripesize = 0;
5894                 dp->stripeoffset = 0;
5895         }
5896         /*
5897          * Have the controller provide us with a geometry
5898          * for this disk.  The only time the geometry
5899          * matters is when we boot and the controller
5900          * is the only one knowledgeable enough to come
5901          * up with something that will make this a bootable
5902          * device.
5903          */
5904         xpt_setup_ccb(&ccg.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
5905         ccg.ccb_h.func_code = XPT_CALC_GEOMETRY;
5906         ccg.block_size = dp->secsize;
5907         ccg.volume_size = dp->sectors;
5908         ccg.heads = 0;
5909         ccg.secs_per_track = 0;
5910         ccg.cylinders = 0;
5911         xpt_action((union ccb*)&ccg);
5912         if ((ccg.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5913                 /*
5914                  * We don't know what went wrong here- but just pick
5915                  * a geometry so we don't have nasty things like divide
5916                  * by zero.
5917                  */
5918                 dp->heads = 255;
5919                 dp->secs_per_track = 255;
5920                 dp->cylinders = dp->sectors / (255 * 255);
5921                 if (dp->cylinders == 0) {
5922                         dp->cylinders = 1;
5923                 }
5924         } else {
5925                 dp->heads = ccg.heads;
5926                 dp->secs_per_track = ccg.secs_per_track;
5927                 dp->cylinders = ccg.cylinders;
5928         }
5929
5930         /*
5931          * If the user supplied a read capacity buffer, and if it is
5932          * different than the previous buffer, update the data in the EDT.
5933          * If it's the same, we don't bother.  This avoids sending an
5934          * update every time someone opens this device.
5935          */
5936         if ((rcaplong != NULL)
5937          && (bcmp(rcaplong, &softc->rcaplong,
5938                   min(sizeof(softc->rcaplong), rcap_len)) != 0)) {
5939                 struct ccb_dev_advinfo cdai;
5940
5941                 xpt_setup_ccb(&cdai.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
5942                 cdai.ccb_h.func_code = XPT_DEV_ADVINFO;
5943                 cdai.buftype = CDAI_TYPE_RCAPLONG;
5944                 cdai.flags = CDAI_FLAG_STORE;
5945                 cdai.bufsiz = rcap_len;
5946                 cdai.buf = (uint8_t *)rcaplong;
5947                 xpt_action((union ccb *)&cdai);
5948                 if ((cdai.ccb_h.status & CAM_DEV_QFRZN) != 0)
5949                         cam_release_devq(cdai.ccb_h.path, 0, 0, 0, FALSE);
5950                 if (cdai.ccb_h.status != CAM_REQ_CMP) {
5951                         xpt_print(periph->path, "%s: failed to set read "
5952                                   "capacity advinfo\n", __func__);
5953                         /* Use cam_error_print() to decode the status */
5954                         cam_error_print((union ccb *)&cdai, CAM_ESF_CAM_STATUS,
5955                                         CAM_EPF_ALL);
5956                 } else {
5957                         bcopy(rcaplong, &softc->rcaplong,
5958                               min(sizeof(softc->rcaplong), rcap_len));
5959                 }
5960         }
5961
5962         softc->disk->d_sectorsize = softc->params.secsize;
5963         softc->disk->d_mediasize = softc->params.secsize * (off_t)softc->params.sectors;
5964         softc->disk->d_stripesize = softc->params.stripesize;
5965         softc->disk->d_stripeoffset = softc->params.stripeoffset;
5966         /* XXX: these are not actually "firmware" values, so they may be wrong */
5967         softc->disk->d_fwsectors = softc->params.secs_per_track;
5968         softc->disk->d_fwheads = softc->params.heads;
5969         softc->disk->d_devstat->block_size = softc->params.secsize;
5970         softc->disk->d_devstat->flags &= ~DEVSTAT_BS_UNAVAILABLE;
5971
5972         error = disk_resize(softc->disk, M_NOWAIT);
5973         if (error != 0)
5974                 xpt_print(periph->path, "disk_resize(9) failed, error = %d\n", error);
5975 }
5976
5977 static void
5978 dasendorderedtag(void *arg)
5979 {
5980         struct cam_periph *periph = arg;
5981         struct da_softc *softc = periph->softc;
5982
5983         cam_periph_assert(periph, MA_OWNED);
5984         if (da_send_ordered) {
5985                 if (!LIST_EMPTY(&softc->pending_ccbs)) {
5986                         if ((softc->flags & DA_FLAG_WAS_OTAG) == 0)
5987                                 softc->flags |= DA_FLAG_NEED_OTAG;
5988                         softc->flags &= ~DA_FLAG_WAS_OTAG;
5989                 }
5990         }
5991
5992         /* Queue us up again */
5993         callout_reset(&softc->sendordered_c,
5994             (da_default_timeout * hz) / DA_ORDEREDTAG_INTERVAL,
5995             dasendorderedtag, periph);
5996 }
5997
5998 /*
5999  * Step through all DA peripheral drivers, and if the device is still open,
6000  * sync the disk cache to physical media.
6001  */
6002 static void
6003 dashutdown(void * arg, int howto)
6004 {
6005         struct cam_periph *periph;
6006         struct da_softc *softc;
6007         union ccb *ccb;
6008         int error;
6009
6010         CAM_PERIPH_FOREACH(periph, &dadriver) {
6011                 softc = (struct da_softc *)periph->softc;
6012                 if (SCHEDULER_STOPPED()) {
6013                         /* If we paniced with the lock held, do not recurse. */
6014                         if (!cam_periph_owned(periph) &&
6015                             (softc->flags & DA_FLAG_OPEN)) {
6016                                 dadump(softc->disk, NULL, 0, 0, 0);
6017                         }
6018                         continue;
6019                 }
6020                 cam_periph_lock(periph);
6021
6022                 /*
6023                  * We only sync the cache if the drive is still open, and
6024                  * if the drive is capable of it..
6025                  */
6026                 if (((softc->flags & DA_FLAG_OPEN) == 0)
6027                  || (softc->quirks & DA_Q_NO_SYNC_CACHE)) {
6028                         cam_periph_unlock(periph);
6029                         continue;
6030                 }
6031
6032                 ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
6033                 scsi_synchronize_cache(&ccb->csio,
6034                                        /*retries*/0,
6035                                        /*cbfcnp*/NULL,
6036                                        MSG_SIMPLE_Q_TAG,
6037                                        /*begin_lba*/0, /* whole disk */
6038                                        /*lb_count*/0,
6039                                        SSD_FULL_SIZE,
6040                                        60 * 60 * 1000);
6041
6042                 error = cam_periph_runccb(ccb, daerror, /*cam_flags*/0,
6043                     /*sense_flags*/ SF_NO_RECOVERY | SF_NO_RETRY | SF_QUIET_IR,
6044                     softc->disk->d_devstat);
6045                 if (error != 0)
6046                         xpt_print(periph->path, "Synchronize cache failed\n");
6047                 xpt_release_ccb(ccb);
6048                 cam_periph_unlock(periph);
6049         }
6050 }
6051
6052 #else /* !_KERNEL */
6053
6054 /*
6055  * XXX These are only left out of the kernel build to silence warnings.  If,
6056  * for some reason these functions are used in the kernel, the ifdefs should
6057  * be moved so they are included both in the kernel and userland.
6058  */
6059 void
6060 scsi_format_unit(struct ccb_scsiio *csio, u_int32_t retries,
6061                  void (*cbfcnp)(struct cam_periph *, union ccb *),
6062                  u_int8_t tag_action, u_int8_t byte2, u_int16_t ileave,
6063                  u_int8_t *data_ptr, u_int32_t dxfer_len, u_int8_t sense_len,
6064                  u_int32_t timeout)
6065 {
6066         struct scsi_format_unit *scsi_cmd;
6067
6068         scsi_cmd = (struct scsi_format_unit *)&csio->cdb_io.cdb_bytes;
6069         scsi_cmd->opcode = FORMAT_UNIT;
6070         scsi_cmd->byte2 = byte2;
6071         scsi_ulto2b(ileave, scsi_cmd->interleave);
6072
6073         cam_fill_csio(csio,
6074                       retries,
6075                       cbfcnp,
6076                       /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
6077                       tag_action,
6078                       data_ptr,
6079                       dxfer_len,
6080                       sense_len,
6081                       sizeof(*scsi_cmd),
6082                       timeout);
6083 }
6084
6085 void
6086 scsi_read_defects(struct ccb_scsiio *csio, uint32_t retries,
6087                   void (*cbfcnp)(struct cam_periph *, union ccb *),
6088                   uint8_t tag_action, uint8_t list_format,
6089                   uint32_t addr_desc_index, uint8_t *data_ptr,
6090                   uint32_t dxfer_len, int minimum_cmd_size,
6091                   uint8_t sense_len, uint32_t timeout)
6092 {
6093         uint8_t cdb_len;
6094
6095         /*
6096          * These conditions allow using the 10 byte command.  Otherwise we
6097          * need to use the 12 byte command.
6098          */
6099         if ((minimum_cmd_size <= 10)
6100          && (addr_desc_index == 0)
6101          && (dxfer_len <= SRDD10_MAX_LENGTH)) {
6102                 struct scsi_read_defect_data_10 *cdb10;
6103
6104                 cdb10 = (struct scsi_read_defect_data_10 *)
6105                         &csio->cdb_io.cdb_bytes;
6106
6107                 cdb_len = sizeof(*cdb10);
6108                 bzero(cdb10, cdb_len);
6109                 cdb10->opcode = READ_DEFECT_DATA_10;
6110                 cdb10->format = list_format;
6111                 scsi_ulto2b(dxfer_len, cdb10->alloc_length);
6112         } else {
6113                 struct scsi_read_defect_data_12 *cdb12;
6114
6115                 cdb12 = (struct scsi_read_defect_data_12 *)
6116                         &csio->cdb_io.cdb_bytes;
6117
6118                 cdb_len = sizeof(*cdb12);
6119                 bzero(cdb12, cdb_len);
6120                 cdb12->opcode = READ_DEFECT_DATA_12;
6121                 cdb12->format = list_format;
6122                 scsi_ulto4b(dxfer_len, cdb12->alloc_length);
6123                 scsi_ulto4b(addr_desc_index, cdb12->address_descriptor_index);
6124         }
6125
6126         cam_fill_csio(csio,
6127                       retries,
6128                       cbfcnp,
6129                       /*flags*/ CAM_DIR_IN,
6130                       tag_action,
6131                       data_ptr,
6132                       dxfer_len,
6133                       sense_len,
6134                       cdb_len,
6135                       timeout);
6136 }
6137
6138 void
6139 scsi_sanitize(struct ccb_scsiio *csio, u_int32_t retries,
6140               void (*cbfcnp)(struct cam_periph *, union ccb *),
6141               u_int8_t tag_action, u_int8_t byte2, u_int16_t control,
6142               u_int8_t *data_ptr, u_int32_t dxfer_len, u_int8_t sense_len,
6143               u_int32_t timeout)
6144 {
6145         struct scsi_sanitize *scsi_cmd;
6146
6147         scsi_cmd = (struct scsi_sanitize *)&csio->cdb_io.cdb_bytes;
6148         scsi_cmd->opcode = SANITIZE;
6149         scsi_cmd->byte2 = byte2;
6150         scsi_cmd->control = control;
6151         scsi_ulto2b(dxfer_len, scsi_cmd->length);
6152
6153         cam_fill_csio(csio,
6154                       retries,
6155                       cbfcnp,
6156                       /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
6157                       tag_action,
6158                       data_ptr,
6159                       dxfer_len,
6160                       sense_len,
6161                       sizeof(*scsi_cmd),
6162                       timeout);
6163 }
6164
6165 #endif /* _KERNEL */
6166
6167 void
6168 scsi_zbc_out(struct ccb_scsiio *csio, uint32_t retries,
6169              void (*cbfcnp)(struct cam_periph *, union ccb *),
6170              uint8_t tag_action, uint8_t service_action, uint64_t zone_id,
6171              uint8_t zone_flags, uint8_t *data_ptr, uint32_t dxfer_len,
6172              uint8_t sense_len, uint32_t timeout)
6173 {
6174         struct scsi_zbc_out *scsi_cmd;
6175
6176         scsi_cmd = (struct scsi_zbc_out *)&csio->cdb_io.cdb_bytes;
6177         scsi_cmd->opcode = ZBC_OUT;
6178         scsi_cmd->service_action = service_action;
6179         scsi_u64to8b(zone_id, scsi_cmd->zone_id);
6180         scsi_cmd->zone_flags = zone_flags;
6181
6182         cam_fill_csio(csio,
6183                       retries,
6184                       cbfcnp,
6185                       /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
6186                       tag_action,
6187                       data_ptr,
6188                       dxfer_len,
6189                       sense_len,
6190                       sizeof(*scsi_cmd),
6191                       timeout);
6192 }
6193
6194 void
6195 scsi_zbc_in(struct ccb_scsiio *csio, uint32_t retries,
6196             void (*cbfcnp)(struct cam_periph *, union ccb *),
6197             uint8_t tag_action, uint8_t service_action, uint64_t zone_start_lba,
6198             uint8_t zone_options, uint8_t *data_ptr, uint32_t dxfer_len,
6199             uint8_t sense_len, uint32_t timeout)
6200 {
6201         struct scsi_zbc_in *scsi_cmd;
6202
6203         scsi_cmd = (struct scsi_zbc_in *)&csio->cdb_io.cdb_bytes;
6204         scsi_cmd->opcode = ZBC_IN;
6205         scsi_cmd->service_action = service_action;
6206         scsi_ulto4b(dxfer_len, scsi_cmd->length);
6207         scsi_u64to8b(zone_start_lba, scsi_cmd->zone_start_lba);
6208         scsi_cmd->zone_options = zone_options;
6209
6210         cam_fill_csio(csio,
6211                       retries,
6212                       cbfcnp,
6213                       /*flags*/ (dxfer_len > 0) ? CAM_DIR_IN : CAM_DIR_NONE,
6214                       tag_action,
6215                       data_ptr,
6216                       dxfer_len,
6217                       sense_len,
6218                       sizeof(*scsi_cmd),
6219                       timeout);
6220
6221 }
6222
6223 int
6224 scsi_ata_zac_mgmt_out(struct ccb_scsiio *csio, uint32_t retries,
6225                       void (*cbfcnp)(struct cam_periph *, union ccb *),
6226                       uint8_t tag_action, int use_ncq,
6227                       uint8_t zm_action, uint64_t zone_id, uint8_t zone_flags,
6228                       uint8_t *data_ptr, uint32_t dxfer_len,
6229                       uint8_t *cdb_storage, size_t cdb_storage_len,
6230                       uint8_t sense_len, uint32_t timeout)
6231 {
6232         uint8_t command_out, protocol, ata_flags;
6233         uint16_t features_out;
6234         uint32_t sectors_out, auxiliary;
6235         int retval;
6236
6237         retval = 0;
6238
6239         if (use_ncq == 0) {
6240                 command_out = ATA_ZAC_MANAGEMENT_OUT;
6241                 features_out = (zm_action & 0xf) | (zone_flags << 8);
6242                 ata_flags = AP_FLAG_BYT_BLOK_BLOCKS;
6243                 if (dxfer_len == 0) {
6244                         protocol = AP_PROTO_NON_DATA;
6245                         ata_flags |= AP_FLAG_TLEN_NO_DATA;
6246                         sectors_out = 0;
6247                 } else {
6248                         protocol = AP_PROTO_DMA;
6249                         ata_flags |= AP_FLAG_TLEN_SECT_CNT |
6250                                      AP_FLAG_TDIR_TO_DEV;
6251                         sectors_out = ((dxfer_len >> 9) & 0xffff);
6252                 }
6253                 auxiliary = 0;
6254         } else {
6255                 ata_flags = AP_FLAG_BYT_BLOK_BLOCKS;
6256                 if (dxfer_len == 0) {
6257                         command_out = ATA_NCQ_NON_DATA;
6258                         features_out = ATA_NCQ_ZAC_MGMT_OUT;
6259                         /*
6260                          * We're assuming the SCSI to ATA translation layer
6261                          * will set the NCQ tag number in the tag field.
6262                          * That isn't clear from the SAT-4 spec (as of rev 05).
6263                          */
6264                         sectors_out = 0;
6265                         ata_flags |= AP_FLAG_TLEN_NO_DATA;
6266                 } else {
6267                         command_out = ATA_SEND_FPDMA_QUEUED;
6268                         /*
6269                          * Note that we're defaulting to normal priority,
6270                          * and assuming that the SCSI to ATA translation
6271                          * layer will insert the NCQ tag number in the tag
6272                          * field.  That isn't clear in the SAT-4 spec (as
6273                          * of rev 05).
6274                          */
6275                         sectors_out = ATA_SFPDMA_ZAC_MGMT_OUT << 8;
6276
6277                         ata_flags |= AP_FLAG_TLEN_FEAT |
6278                                      AP_FLAG_TDIR_TO_DEV;
6279
6280                         /*
6281                          * For SEND FPDMA QUEUED, the transfer length is
6282                          * encoded in the FEATURE register, and 0 means
6283                          * that 65536 512 byte blocks are to be tranferred.
6284                          * In practice, it seems unlikely that we'll see
6285                          * a transfer that large, and it may confuse the
6286                          * the SAT layer, because generally that means that
6287                          * 0 bytes should be transferred.
6288                          */
6289                         if (dxfer_len == (65536 * 512)) {
6290                                 features_out = 0;
6291                         } else if (dxfer_len <= (65535 * 512)) {
6292                                 features_out = ((dxfer_len >> 9) & 0xffff);
6293                         } else {
6294                                 /* The transfer is too big. */
6295                                 retval = 1;
6296                                 goto bailout;
6297                         }
6298
6299                 }
6300
6301                 auxiliary = (zm_action & 0xf) | (zone_flags << 8);
6302                 protocol = AP_PROTO_FPDMA;
6303         }
6304
6305         protocol |= AP_EXTEND;
6306
6307         retval = scsi_ata_pass(csio,
6308             retries,
6309             cbfcnp,
6310             /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
6311             tag_action,
6312             /*protocol*/ protocol,
6313             /*ata_flags*/ ata_flags,
6314             /*features*/ features_out,
6315             /*sector_count*/ sectors_out,
6316             /*lba*/ zone_id,
6317             /*command*/ command_out,
6318             /*device*/ 0,
6319             /*icc*/ 0,
6320             /*auxiliary*/ auxiliary,
6321             /*control*/ 0,
6322             /*data_ptr*/ data_ptr,
6323             /*dxfer_len*/ dxfer_len,
6324             /*cdb_storage*/ cdb_storage,
6325             /*cdb_storage_len*/ cdb_storage_len,
6326             /*minimum_cmd_size*/ 0,
6327             /*sense_len*/ SSD_FULL_SIZE,
6328             /*timeout*/ timeout);
6329
6330 bailout:
6331
6332         return (retval);
6333 }
6334
6335 int
6336 scsi_ata_zac_mgmt_in(struct ccb_scsiio *csio, uint32_t retries,
6337                      void (*cbfcnp)(struct cam_periph *, union ccb *),
6338                      uint8_t tag_action, int use_ncq,
6339                      uint8_t zm_action, uint64_t zone_id, uint8_t zone_flags,
6340                      uint8_t *data_ptr, uint32_t dxfer_len,
6341                      uint8_t *cdb_storage, size_t cdb_storage_len,
6342                      uint8_t sense_len, uint32_t timeout)
6343 {
6344         uint8_t command_out, protocol;
6345         uint16_t features_out, sectors_out;
6346         uint32_t auxiliary;
6347         int ata_flags;
6348         int retval;
6349
6350         retval = 0;
6351         ata_flags = AP_FLAG_TDIR_FROM_DEV | AP_FLAG_BYT_BLOK_BLOCKS;
6352
6353         if (use_ncq == 0) {
6354                 command_out = ATA_ZAC_MANAGEMENT_IN;
6355                 /* XXX KDM put a macro here */
6356                 features_out = (zm_action & 0xf) | (zone_flags << 8);
6357                 sectors_out = dxfer_len >> 9; /* XXX KDM macro */
6358                 protocol = AP_PROTO_DMA;
6359                 ata_flags |= AP_FLAG_TLEN_SECT_CNT;
6360                 auxiliary = 0;
6361         } else {
6362                 ata_flags |= AP_FLAG_TLEN_FEAT;
6363
6364                 command_out = ATA_RECV_FPDMA_QUEUED;
6365                 sectors_out = ATA_RFPDMA_ZAC_MGMT_IN << 8;
6366
6367                 /*
6368                  * For RECEIVE FPDMA QUEUED, the transfer length is
6369                  * encoded in the FEATURE register, and 0 means
6370                  * that 65536 512 byte blocks are to be tranferred.
6371                  * In practice, it seems unlikely that we'll see
6372                  * a transfer that large, and it may confuse the
6373                  * the SAT layer, because generally that means that
6374                  * 0 bytes should be transferred.
6375                  */
6376                 if (dxfer_len == (65536 * 512)) {
6377                         features_out = 0;
6378                 } else if (dxfer_len <= (65535 * 512)) {
6379                         features_out = ((dxfer_len >> 9) & 0xffff);
6380                 } else {
6381                         /* The transfer is too big. */
6382                         retval = 1;
6383                         goto bailout;
6384                 }
6385                 auxiliary = (zm_action & 0xf) | (zone_flags << 8),
6386                 protocol = AP_PROTO_FPDMA;
6387         }
6388
6389         protocol |= AP_EXTEND;
6390
6391         retval = scsi_ata_pass(csio,
6392             retries,
6393             cbfcnp,
6394             /*flags*/ CAM_DIR_IN,
6395             tag_action,
6396             /*protocol*/ protocol,
6397             /*ata_flags*/ ata_flags,
6398             /*features*/ features_out,
6399             /*sector_count*/ sectors_out,
6400             /*lba*/ zone_id,
6401             /*command*/ command_out,
6402             /*device*/ 0,
6403             /*icc*/ 0,
6404             /*auxiliary*/ auxiliary,
6405             /*control*/ 0,
6406             /*data_ptr*/ data_ptr,
6407             /*dxfer_len*/ (dxfer_len >> 9) * 512, /* XXX KDM */
6408             /*cdb_storage*/ cdb_storage,
6409             /*cdb_storage_len*/ cdb_storage_len,
6410             /*minimum_cmd_size*/ 0,
6411             /*sense_len*/ SSD_FULL_SIZE,
6412             /*timeout*/ timeout);
6413
6414 bailout:
6415         return (retval);
6416 }