The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/cam/scsi/scsi_da.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: 483accc9ba32224b06c92588db7e97de


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.