sys/cam/scsi/scsi_da.c

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