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