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         int error;
1529
1530         periph = (struct cam_periph *)dp->d_drv1;
1531         softc = (struct da_softc *)periph->softc;
1532         cam_periph_lock(periph);
1533         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
1534             ("daclose\n"));
1535
1536         if (cam_periph_hold(periph, PRIBIO) == 0) {
1537
1538                 /* Flush disk cache. */
1539                 if ((softc->flags & DA_FLAG_DIRTY) != 0 &&
1540                     (softc->quirks & DA_Q_NO_SYNC_CACHE) == 0 &&
1541                     (softc->flags & DA_FLAG_PACK_INVALID) == 0) {
1542                         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
1543                         scsi_synchronize_cache(&ccb->csio, /*retries*/1,
1544                             /*cbfcnp*/dadone, MSG_SIMPLE_Q_TAG,
1545                             /*begin_lba*/0, /*lb_count*/0, SSD_FULL_SIZE,
1546                             5 * 60 * 1000);
1547                         error = cam_periph_runccb(ccb, daerror, /*cam_flags*/0,
1548                             /*sense_flags*/SF_RETRY_UA | SF_QUIET_IR,
1549                             softc->disk->d_devstat);
1550                         softc->flags &= ~DA_FLAG_DIRTY;
1551                         xpt_release_ccb(ccb);
1552                 }
1553
1554                 /* Allow medium removal. */
1555                 if ((softc->flags & DA_FLAG_PACK_REMOVABLE) != 0 &&
1556                     (softc->quirks & DA_Q_NO_PREVENT) == 0)
1557                         daprevent(periph, PR_ALLOW);
1558
1559                 cam_periph_unhold(periph);
1560         }
1561
1562         /*
1563          * If we've got removeable media, mark the blocksize as
1564          * unavailable, since it could change when new media is
1565          * inserted.
1566          */
1567         if ((softc->flags & DA_FLAG_PACK_REMOVABLE) != 0)
1568                 softc->disk->d_devstat->flags |= DEVSTAT_BS_UNAVAILABLE;
1569
1570         softc->flags &= ~DA_FLAG_OPEN;
1571         while (softc->refcount != 0)
1572                 cam_periph_sleep(periph, &softc->refcount, PRIBIO, "daclose", 1);
1573         cam_periph_unlock(periph);
1574         cam_periph_release(periph);
1575         return (0);
1576 }
1577
1578 static void
1579 daschedule(struct cam_periph *periph)
1580 {
1581         struct da_softc *softc = (struct da_softc *)periph->softc;
1582
1583         if (softc->state != DA_STATE_NORMAL)
1584                 return;
1585
1586         cam_iosched_schedule(softc->cam_iosched, periph);
1587 }
1588
1589 /*
1590  * Actually translate the requested transfer into one the physical driver
1591  * can understand.  The transfer is described by a buf and will include
1592  * only one physical transfer.
1593  */
1594 static void
1595 dastrategy(struct bio *bp)
1596 {
1597         struct cam_periph *periph;
1598         struct da_softc *softc;
1599
1600         periph = (struct cam_periph *)bp->bio_disk->d_drv1;
1601         softc = (struct da_softc *)periph->softc;
1602
1603         cam_periph_lock(periph);
1604
1605         /*
1606          * If the device has been made invalid, error out
1607          */
1608         if ((softc->flags & DA_FLAG_PACK_INVALID)) {
1609                 cam_periph_unlock(periph);
1610                 biofinish(bp, NULL, ENXIO);
1611                 return;
1612         }
1613
1614         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dastrategy(%p)\n", bp));
1615
1616         /*
1617          * Zone commands must be ordered, because they can depend on the
1618          * effects of previously issued commands, and they may affect
1619          * commands after them.
1620          */
1621         if (bp->bio_cmd == BIO_ZONE)
1622                 bp->bio_flags |= BIO_ORDERED;
1623
1624         /*
1625          * Place it in the queue of disk activities for this disk
1626          */
1627         cam_iosched_queue_work(softc->cam_iosched, bp);
1628
1629         /*
1630          * Schedule ourselves for performing the work.
1631          */
1632         daschedule(periph);
1633         cam_periph_unlock(periph);
1634
1635         return;
1636 }
1637
1638 static int
1639 dadump(void *arg, void *virtual, vm_offset_t physical, off_t offset, size_t length)
1640 {
1641         struct      cam_periph *periph;
1642         struct      da_softc *softc;
1643         u_int       secsize;
1644         struct      ccb_scsiio csio;
1645         struct      disk *dp;
1646         int         error = 0;
1647
1648         dp = arg;
1649         periph = dp->d_drv1;
1650         softc = (struct da_softc *)periph->softc;
1651         cam_periph_lock(periph);
1652         secsize = softc->params.secsize;
1653
1654         if ((softc->flags & DA_FLAG_PACK_INVALID) != 0) {
1655                 cam_periph_unlock(periph);
1656                 return (ENXIO);
1657         }
1658
1659         memset(&csio, 0, sizeof(csio));
1660         if (length > 0) {
1661                 xpt_setup_ccb(&csio.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
1662                 csio.ccb_h.ccb_state = DA_CCB_DUMP;
1663                 scsi_read_write(&csio,
1664                                 /*retries*/0,
1665                                 dadone,
1666                                 MSG_ORDERED_Q_TAG,
1667                                 /*read*/SCSI_RW_WRITE,
1668                                 /*byte2*/0,
1669                                 /*minimum_cmd_size*/ softc->minimum_cmd_size,
1670                                 offset / secsize,
1671                                 length / secsize,
1672                                 /*data_ptr*/(u_int8_t *) virtual,
1673                                 /*dxfer_len*/length,
1674                                 /*sense_len*/SSD_FULL_SIZE,
1675                                 da_default_timeout * 1000);
1676                 error = cam_periph_runccb((union ccb *)&csio, cam_periph_error,
1677                     0, SF_NO_RECOVERY | SF_NO_RETRY, NULL);
1678                 if (error != 0)
1679                         printf("Aborting dump due to I/O error.\n");
1680                 cam_periph_unlock(periph);
1681                 return (error);
1682         }
1683
1684         /*
1685          * Sync the disk cache contents to the physical media.
1686          */
1687         if ((softc->quirks & DA_Q_NO_SYNC_CACHE) == 0) {
1688
1689                 xpt_setup_ccb(&csio.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
1690                 csio.ccb_h.ccb_state = DA_CCB_DUMP;
1691                 scsi_synchronize_cache(&csio,
1692                                        /*retries*/0,
1693                                        /*cbfcnp*/dadone,
1694                                        MSG_SIMPLE_Q_TAG,
1695                                        /*begin_lba*/0,/* Cover the whole disk */
1696                                        /*lb_count*/0,
1697                                        SSD_FULL_SIZE,
1698                                        5 * 1000);
1699                 error = cam_periph_runccb((union ccb *)&csio, cam_periph_error,
1700                     0, SF_NO_RECOVERY | SF_NO_RETRY, NULL);
1701                 if (error != 0)
1702                         xpt_print(periph->path, "Synchronize cache failed\n");
1703         }
1704         cam_periph_unlock(periph);
1705         return (error);
1706 }
1707
1708 static int
1709 dagetattr(struct bio *bp)
1710 {
1711         int ret;
1712         struct cam_periph *periph;
1713
1714         periph = (struct cam_periph *)bp->bio_disk->d_drv1;
1715         cam_periph_lock(periph);
1716         ret = xpt_getattr(bp->bio_data, bp->bio_length, bp->bio_attribute,
1717             periph->path);
1718         cam_periph_unlock(periph);
1719         if (ret == 0)
1720                 bp->bio_completed = bp->bio_length;
1721         return ret;
1722 }
1723
1724 static void
1725 dainit(void)
1726 {
1727         cam_status status;
1728
1729         /*
1730          * Install a global async callback.  This callback will
1731          * receive async callbacks like "new device found".
1732          */
1733         status = xpt_register_async(AC_FOUND_DEVICE, daasync, NULL, NULL);
1734
1735         if (status != CAM_REQ_CMP) {
1736                 printf("da: Failed to attach master async callback "
1737                        "due to status 0x%x!\n", status);
1738         } else if (da_send_ordered) {
1739
1740                 /* Register our shutdown event handler */
1741                 if ((EVENTHANDLER_REGISTER(shutdown_post_sync, dashutdown,
1742                                            NULL, SHUTDOWN_PRI_DEFAULT)) == NULL)
1743                     printf("dainit: shutdown event registration failed!\n");
1744         }
1745 }
1746
1747 /*
1748  * Callback from GEOM, called when it has finished cleaning up its
1749  * resources.
1750  */
1751 static void
1752 dadiskgonecb(struct disk *dp)
1753 {
1754         struct cam_periph *periph;
1755
1756         periph = (struct cam_periph *)dp->d_drv1;
1757         cam_periph_release(periph);
1758 }
1759
1760 static void
1761 daoninvalidate(struct cam_periph *periph)
1762 {
1763         struct da_softc *softc;
1764
1765         softc = (struct da_softc *)periph->softc;
1766
1767         /*
1768          * De-register any async callbacks.
1769          */
1770         xpt_register_async(0, daasync, periph, periph->path);
1771
1772         softc->flags |= DA_FLAG_PACK_INVALID;
1773 #ifdef CAM_IO_STATS
1774         softc->invalidations++;
1775 #endif
1776
1777         /*
1778          * Return all queued I/O with ENXIO.
1779          * XXX Handle any transactions queued to the card
1780          *     with XPT_ABORT_CCB.
1781          */
1782         cam_iosched_flush(softc->cam_iosched, NULL, ENXIO);
1783
1784         /*
1785          * Tell GEOM that we've gone away, we'll get a callback when it is
1786          * done cleaning up its resources.
1787          */
1788         disk_gone(softc->disk);
1789 }
1790
1791 static void
1792 dacleanup(struct cam_periph *periph)
1793 {
1794         struct da_softc *softc;
1795
1796         softc = (struct da_softc *)periph->softc;
1797
1798         cam_periph_unlock(periph);
1799
1800         cam_iosched_fini(softc->cam_iosched);
1801
1802         /*
1803          * If we can't free the sysctl tree, oh well...
1804          */
1805         if ((softc->flags & DA_FLAG_SCTX_INIT) != 0) {
1806 #ifdef CAM_IO_STATS
1807                 if (sysctl_ctx_free(&softc->sysctl_stats_ctx) != 0)
1808                         xpt_print(periph->path,
1809                             "can't remove sysctl stats context\n");
1810 #endif
1811                 if (sysctl_ctx_free(&softc->sysctl_ctx) != 0)
1812                         xpt_print(periph->path,
1813                             "can't remove sysctl context\n");
1814         }
1815
1816         callout_drain(&softc->mediapoll_c);
1817         disk_destroy(softc->disk);
1818         callout_drain(&softc->sendordered_c);
1819         free(softc, M_DEVBUF);
1820         cam_periph_lock(periph);
1821 }
1822
1823 static void
1824 daasync(void *callback_arg, u_int32_t code,
1825         struct cam_path *path, void *arg)
1826 {
1827         struct cam_periph *periph;
1828         struct da_softc *softc;
1829
1830         periph = (struct cam_periph *)callback_arg;
1831         switch (code) {
1832         case AC_FOUND_DEVICE:
1833         {
1834                 struct ccb_getdev *cgd;
1835                 cam_status status;
1836
1837                 cgd = (struct ccb_getdev *)arg;
1838                 if (cgd == NULL)
1839                         break;
1840
1841                 if (cgd->protocol != PROTO_SCSI)
1842                         break;
1843                 if (SID_QUAL(&cgd->inq_data) != SID_QUAL_LU_CONNECTED)
1844                         break;
1845                 if (SID_TYPE(&cgd->inq_data) != T_DIRECT
1846                     && SID_TYPE(&cgd->inq_data) != T_RBC
1847                     && SID_TYPE(&cgd->inq_data) != T_OPTICAL
1848                     && SID_TYPE(&cgd->inq_data) != T_ZBC_HM)
1849                         break;
1850
1851                 /*
1852                  * Allocate a peripheral instance for
1853                  * this device and start the probe
1854                  * process.
1855                  */
1856                 status = cam_periph_alloc(daregister, daoninvalidate,
1857                                           dacleanup, dastart,
1858                                           "da", CAM_PERIPH_BIO,
1859                                           path, daasync,
1860                                           AC_FOUND_DEVICE, cgd);
1861
1862                 if (status != CAM_REQ_CMP
1863                  && status != CAM_REQ_INPROG)
1864                         printf("daasync: Unable to attach to new device "
1865                                 "due to status 0x%x\n", status);
1866                 return;
1867         }
1868         case AC_ADVINFO_CHANGED:
1869         {
1870                 uintptr_t buftype;
1871
1872                 buftype = (uintptr_t)arg;
1873                 if (buftype == CDAI_TYPE_PHYS_PATH) {
1874                         struct da_softc *softc;
1875
1876                         softc = periph->softc;
1877                         disk_attr_changed(softc->disk, "GEOM::physpath",
1878                                           M_NOWAIT);
1879                 }
1880                 break;
1881         }
1882         case AC_UNIT_ATTENTION:
1883         {
1884                 union ccb *ccb;
1885                 int error_code, sense_key, asc, ascq;
1886
1887                 softc = (struct da_softc *)periph->softc;
1888                 ccb = (union ccb *)arg;
1889
1890                 /*
1891                  * Handle all UNIT ATTENTIONs except our own,
1892                  * as they will be handled by daerror().
1893                  */
1894                 if (xpt_path_periph(ccb->ccb_h.path) != periph &&
1895                     scsi_extract_sense_ccb(ccb,
1896                      &error_code, &sense_key, &asc, &ascq)) {
1897                         if (asc == 0x2A && ascq == 0x09) {
1898                                 xpt_print(ccb->ccb_h.path,
1899                                     "Capacity data has changed\n");
1900                                 softc->flags &= ~DA_FLAG_PROBED;
1901                                 dareprobe(periph);
1902                         } else if (asc == 0x28 && ascq == 0x00) {
1903                                 softc->flags &= ~DA_FLAG_PROBED;
1904                                 disk_media_changed(softc->disk, M_NOWAIT);
1905                         } else if (asc == 0x3F && ascq == 0x03) {
1906                                 xpt_print(ccb->ccb_h.path,
1907                                     "INQUIRY data has changed\n");
1908                                 softc->flags &= ~DA_FLAG_PROBED;
1909                                 dareprobe(periph);
1910                         }
1911                 }
1912                 break;
1913         }
1914         case AC_SCSI_AEN:
1915                 softc = (struct da_softc *)periph->softc;
1916                 if (!cam_iosched_has_work_flags(softc->cam_iosched, DA_WORK_TUR)) {
1917                         if (cam_periph_acquire(periph) == CAM_REQ_CMP) {
1918                                 cam_iosched_set_work_flags(softc->cam_iosched, DA_WORK_TUR);
1919                                 daschedule(periph);
1920                         }
1921                 }
1922                 /* FALLTHROUGH */
1923         case AC_SENT_BDR:
1924         case AC_BUS_RESET:
1925         {
1926                 struct ccb_hdr *ccbh;
1927
1928                 softc = (struct da_softc *)periph->softc;
1929                 /*
1930                  * Don't fail on the expected unit attention
1931                  * that will occur.
1932                  */
1933                 softc->flags |= DA_FLAG_RETRY_UA;
1934                 LIST_FOREACH(ccbh, &softc->pending_ccbs, periph_links.le)
1935                         ccbh->ccb_state |= DA_CCB_RETRY_UA;
1936                 break;
1937         }
1938         case AC_INQ_CHANGED:
1939                 softc = (struct da_softc *)periph->softc;
1940                 softc->flags &= ~DA_FLAG_PROBED;
1941                 dareprobe(periph);
1942                 break;
1943         default:
1944                 break;
1945         }
1946         cam_periph_async(periph, code, path, arg);
1947 }
1948
1949 static void
1950 dasysctlinit(void *context, int pending)
1951 {
1952         struct cam_periph *periph;
1953         struct da_softc *softc;
1954         char tmpstr[32], tmpstr2[16];
1955         struct ccb_trans_settings cts;
1956
1957         periph = (struct cam_periph *)context;
1958         /*
1959          * periph was held for us when this task was enqueued
1960          */
1961         if (periph->flags & CAM_PERIPH_INVALID) {
1962                 cam_periph_release(periph);
1963                 return;
1964         }
1965
1966         softc = (struct da_softc *)periph->softc;
1967         snprintf(tmpstr, sizeof(tmpstr), "CAM DA unit %d", periph->unit_number);
1968         snprintf(tmpstr2, sizeof(tmpstr2), "%d", periph->unit_number);
1969
1970         sysctl_ctx_init(&softc->sysctl_ctx);
1971         softc->flags |= DA_FLAG_SCTX_INIT;
1972         softc->sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&softc->sysctl_ctx,
1973                 SYSCTL_STATIC_CHILDREN(_kern_cam_da), OID_AUTO, tmpstr2,
1974                 CTLFLAG_RD, 0, tmpstr, "device_index");
1975         if (softc->sysctl_tree == NULL) {
1976                 printf("dasysctlinit: unable to allocate sysctl tree\n");
1977                 cam_periph_release(periph);
1978                 return;
1979         }
1980
1981         /*
1982          * Now register the sysctl handler, so the user can change the value on
1983          * the fly.
1984          */
1985         SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1986                 OID_AUTO, "delete_method", CTLTYPE_STRING | CTLFLAG_RWTUN,
1987                 softc, 0, dadeletemethodsysctl, "A",
1988                 "BIO_DELETE execution method");
1989         SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1990                 OID_AUTO, "delete_max", CTLTYPE_U64 | CTLFLAG_RW,
1991                 softc, 0, dadeletemaxsysctl, "Q",
1992                 "Maximum BIO_DELETE size");
1993         SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1994                 OID_AUTO, "minimum_cmd_size", CTLTYPE_INT | CTLFLAG_RW,
1995                 &softc->minimum_cmd_size, 0, dacmdsizesysctl, "I",
1996                 "Minimum CDB size");
1997
1998         SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1999                 OID_AUTO, "zone_mode", CTLTYPE_STRING | CTLFLAG_RD,
2000                 softc, 0, dazonemodesysctl, "A",
2001                 "Zone Mode");
2002         SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2003                 OID_AUTO, "zone_support", CTLTYPE_STRING | CTLFLAG_RD,
2004                 softc, 0, dazonesupsysctl, "A",
2005                 "Zone Support");
2006         SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2007                 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
2008                 "optimal_seq_zones", CTLFLAG_RD, &softc->optimal_seq_zones,
2009                 "Optimal Number of Open Sequential Write Preferred Zones");
2010         SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2011                 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
2012                 "optimal_nonseq_zones", CTLFLAG_RD,
2013                 &softc->optimal_nonseq_zones,
2014                 "Optimal Number of Non-Sequentially Written Sequential Write "
2015                 "Preferred Zones");
2016         SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2017                 SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
2018                 "max_seq_zones", CTLFLAG_RD, &softc->max_seq_zones,
2019                 "Maximum Number of Open Sequential Write Required Zones");
2020
2021         SYSCTL_ADD_INT(&softc->sysctl_ctx,
2022                        SYSCTL_CHILDREN(softc->sysctl_tree),
2023                        OID_AUTO,
2024                        "error_inject",
2025                        CTLFLAG_RW,
2026                        &softc->error_inject,
2027                        0,
2028                        "error_inject leaf");
2029
2030         SYSCTL_ADD_INT(&softc->sysctl_ctx,
2031                        SYSCTL_CHILDREN(softc->sysctl_tree),
2032                        OID_AUTO,
2033                        "unmapped_io",
2034                        CTLFLAG_RD,
2035                        &softc->unmappedio,
2036                        0,
2037                        "Unmapped I/O leaf");
2038
2039         SYSCTL_ADD_INT(&softc->sysctl_ctx,
2040                        SYSCTL_CHILDREN(softc->sysctl_tree),
2041                        OID_AUTO,
2042                        "rotating",
2043                        CTLFLAG_RD,
2044                        &softc->rotating,
2045                        0,
2046                        "Rotating media");
2047
2048         /*
2049          * Add some addressing info.
2050          */
2051         memset(&cts, 0, sizeof (cts));
2052         xpt_setup_ccb(&cts.ccb_h, periph->path, CAM_PRIORITY_NONE);
2053         cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
2054         cts.type = CTS_TYPE_CURRENT_SETTINGS;
2055         cam_periph_lock(periph);
2056         xpt_action((union ccb *)&cts);
2057         cam_periph_unlock(periph);
2058         if (cts.ccb_h.status != CAM_REQ_CMP) {
2059                 cam_periph_release(periph);
2060                 return;
2061         }
2062         if (cts.protocol == PROTO_SCSI && cts.transport == XPORT_FC) {
2063                 struct ccb_trans_settings_fc *fc = &cts.xport_specific.fc;
2064                 if (fc->valid & CTS_FC_VALID_WWPN) {
2065                         softc->wwpn = fc->wwpn;
2066                         SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2067                             SYSCTL_CHILDREN(softc->sysctl_tree),
2068                             OID_AUTO, "wwpn", CTLFLAG_RD,
2069                             &softc->wwpn, "World Wide Port Name");
2070                 }
2071         }
2072
2073 #ifdef CAM_IO_STATS
2074         /*
2075          * Now add some useful stats.
2076          * XXX These should live in cam_periph and be common to all periphs
2077          */
2078         softc->sysctl_stats_tree = SYSCTL_ADD_NODE(&softc->sysctl_stats_ctx,
2079             SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO, "stats",
2080             CTLFLAG_RD, 0, "Statistics");
2081         SYSCTL_ADD_INT(&softc->sysctl_stats_ctx,
2082                        SYSCTL_CHILDREN(softc->sysctl_stats_tree),
2083                        OID_AUTO,
2084                        "errors",
2085                        CTLFLAG_RD,
2086                        &softc->errors,
2087                        0,
2088                        "Transport errors reported by the SIM");
2089         SYSCTL_ADD_INT(&softc->sysctl_stats_ctx,
2090                        SYSCTL_CHILDREN(softc->sysctl_stats_tree),
2091                        OID_AUTO,
2092                        "timeouts",
2093                        CTLFLAG_RD,
2094                        &softc->timeouts,
2095                        0,
2096                        "Device timeouts reported by the SIM");
2097         SYSCTL_ADD_INT(&softc->sysctl_stats_ctx,
2098                        SYSCTL_CHILDREN(softc->sysctl_stats_tree),
2099                        OID_AUTO,
2100                        "pack_invalidations",
2101                        CTLFLAG_RD,
2102                        &softc->invalidations,
2103                        0,
2104                        "Device pack invalidations");
2105 #endif
2106
2107         cam_iosched_sysctl_init(softc->cam_iosched, &softc->sysctl_ctx,
2108             softc->sysctl_tree);
2109
2110         cam_periph_release(periph);
2111 }
2112
2113 static int
2114 dadeletemaxsysctl(SYSCTL_HANDLER_ARGS)
2115 {
2116         int error;
2117         uint64_t value;
2118         struct da_softc *softc;
2119
2120         softc = (struct da_softc *)arg1;
2121
2122         value = softc->disk->d_delmaxsize;
2123         error = sysctl_handle_64(oidp, &value, 0, req);
2124         if ((error != 0) || (req->newptr == NULL))
2125                 return (error);
2126
2127         /* only accept values smaller than the calculated value */
2128         if (value > dadeletemaxsize(softc, softc->delete_method)) {
2129                 return (EINVAL);
2130         }
2131         softc->disk->d_delmaxsize = value;
2132
2133         return (0);
2134 }
2135
2136 static int
2137 dacmdsizesysctl(SYSCTL_HANDLER_ARGS)
2138 {
2139         int error, value;
2140
2141         value = *(int *)arg1;
2142
2143         error = sysctl_handle_int(oidp, &value, 0, req);
2144
2145         if ((error != 0)
2146          || (req->newptr == NULL))
2147                 return (error);
2148
2149         /*
2150          * Acceptable values here are 6, 10, 12 or 16.
2151          */
2152         if (value < 6)
2153                 value = 6;
2154         else if ((value > 6)
2155               && (value <= 10))
2156                 value = 10;
2157         else if ((value > 10)
2158               && (value <= 12))
2159                 value = 12;
2160         else if (value > 12)
2161                 value = 16;
2162
2163         *(int *)arg1 = value;
2164
2165         return (0);
2166 }
2167
2168 static int
2169 dasysctlsofttimeout(SYSCTL_HANDLER_ARGS)
2170 {
2171         sbintime_t value;
2172         int error;
2173
2174         value = da_default_softtimeout / SBT_1MS;
2175
2176         error = sysctl_handle_int(oidp, (int *)&value, 0, req);
2177         if ((error != 0) || (req->newptr == NULL))
2178                 return (error);
2179
2180         /* XXX Should clip this to a reasonable level */
2181         if (value > da_default_timeout * 1000)
2182                 return (EINVAL);
2183
2184         da_default_softtimeout = value * SBT_1MS;
2185         return (0);
2186 }
2187
2188 static void
2189 dadeletemethodset(struct da_softc *softc, da_delete_methods delete_method)
2190 {
2191
2192         softc->delete_method = delete_method;
2193         softc->disk->d_delmaxsize = dadeletemaxsize(softc, delete_method);
2194         softc->delete_func = da_delete_functions[delete_method];
2195
2196         if (softc->delete_method > DA_DELETE_DISABLE)
2197                 softc->disk->d_flags |= DISKFLAG_CANDELETE;
2198         else
2199                 softc->disk->d_flags &= ~DISKFLAG_CANDELETE;
2200 }
2201
2202 static off_t
2203 dadeletemaxsize(struct da_softc *softc, da_delete_methods delete_method)
2204 {
2205         off_t sectors;
2206
2207         switch(delete_method) {
2208         case DA_DELETE_UNMAP:
2209                 sectors = (off_t)softc->unmap_max_lba;
2210                 break;
2211         case DA_DELETE_ATA_TRIM:
2212                 sectors = (off_t)ATA_DSM_RANGE_MAX * softc->trim_max_ranges;
2213                 break;
2214         case DA_DELETE_WS16:
2215                 sectors = omin(softc->ws_max_blks, WS16_MAX_BLKS);
2216                 break;
2217         case DA_DELETE_ZERO:
2218         case DA_DELETE_WS10:
2219                 sectors = omin(softc->ws_max_blks, WS10_MAX_BLKS);
2220                 break;
2221         default:
2222                 return 0;
2223         }
2224
2225         return (off_t)softc->params.secsize *
2226             omin(sectors, softc->params.sectors);
2227 }
2228
2229 static void
2230 daprobedone(struct cam_periph *periph, union ccb *ccb)
2231 {
2232         struct da_softc *softc;
2233
2234         softc = (struct da_softc *)periph->softc;
2235
2236         dadeletemethodchoose(softc, DA_DELETE_NONE);
2237
2238         if (bootverbose && (softc->flags & DA_FLAG_ANNOUNCED) == 0) {
2239                 char buf[80];
2240                 int i, sep;
2241
2242                 snprintf(buf, sizeof(buf), "Delete methods: <");
2243                 sep = 0;
2244                 for (i = 0; i <= DA_DELETE_MAX; i++) {
2245                         if ((softc->delete_available & (1 << i)) == 0 &&
2246                             i != softc->delete_method)
2247                                 continue;
2248                         if (sep)
2249                                 strlcat(buf, ",", sizeof(buf));
2250                         strlcat(buf, da_delete_method_names[i],
2251                             sizeof(buf));
2252                         if (i == softc->delete_method)
2253                                 strlcat(buf, "(*)", sizeof(buf));
2254                         sep = 1;
2255                 }
2256                 strlcat(buf, ">", sizeof(buf));
2257                 printf("%s%d: %s\n", periph->periph_name,
2258                     periph->unit_number, buf);
2259         }
2260
2261         /*
2262          * Since our peripheral may be invalidated by an error
2263          * above or an external event, we must release our CCB
2264          * before releasing the probe lock on the peripheral.
2265          * The peripheral will only go away once the last lock
2266          * is removed, and we need it around for the CCB release
2267          * operation.
2268          */
2269         xpt_release_ccb(ccb);
2270         softc->state = DA_STATE_NORMAL;
2271         softc->flags |= DA_FLAG_PROBED;
2272         daschedule(periph);
2273         wakeup(&softc->disk->d_mediasize);
2274         if ((softc->flags & DA_FLAG_ANNOUNCED) == 0) {
2275                 softc->flags |= DA_FLAG_ANNOUNCED;
2276                 cam_periph_unhold(periph);
2277         } else
2278                 cam_periph_release_locked(periph);
2279 }
2280
2281 static void
2282 dadeletemethodchoose(struct da_softc *softc, da_delete_methods default_method)
2283 {
2284         int i, methods;
2285
2286         /* If available, prefer the method requested by user. */
2287         i = softc->delete_method_pref;
2288         methods = softc->delete_available | (1 << DA_DELETE_DISABLE);
2289         if (methods & (1 << i)) {
2290                 dadeletemethodset(softc, i);
2291                 return;
2292         }
2293
2294         /* Use the pre-defined order to choose the best performing delete. */
2295         for (i = DA_DELETE_MIN; i <= DA_DELETE_MAX; i++) {
2296                 if (i == DA_DELETE_ZERO)
2297                         continue;
2298                 if (softc->delete_available & (1 << i)) {
2299                         dadeletemethodset(softc, i);
2300                         return;
2301                 }
2302         }
2303
2304         /* Fallback to default. */
2305         dadeletemethodset(softc, default_method);
2306 }
2307
2308 static int
2309 dadeletemethodsysctl(SYSCTL_HANDLER_ARGS)
2310 {
2311         char buf[16];
2312         const char *p;
2313         struct da_softc *softc;
2314         int i, error, methods, value;
2315
2316         softc = (struct da_softc *)arg1;
2317
2318         value = softc->delete_method;
2319         if (value < 0 || value > DA_DELETE_MAX)
2320                 p = "UNKNOWN";
2321         else
2322                 p = da_delete_method_names[value];
2323         strncpy(buf, p, sizeof(buf));
2324         error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
2325         if (error != 0 || req->newptr == NULL)
2326                 return (error);
2327         methods = softc->delete_available | (1 << DA_DELETE_DISABLE);
2328         for (i = 0; i <= DA_DELETE_MAX; i++) {
2329                 if (strcmp(buf, da_delete_method_names[i]) == 0)
2330                         break;
2331         }
2332         if (i > DA_DELETE_MAX)
2333                 return (EINVAL);
2334         softc->delete_method_pref = i;
2335         dadeletemethodchoose(softc, DA_DELETE_NONE);
2336         return (0);
2337 }
2338
2339 static int
2340 dazonemodesysctl(SYSCTL_HANDLER_ARGS)
2341 {
2342         char tmpbuf[40];
2343         struct da_softc *softc;
2344         int error;
2345
2346         softc = (struct da_softc *)arg1;
2347
2348         switch (softc->zone_mode) {
2349         case DA_ZONE_DRIVE_MANAGED:
2350                 snprintf(tmpbuf, sizeof(tmpbuf), "Drive Managed");
2351                 break;
2352         case DA_ZONE_HOST_AWARE:
2353                 snprintf(tmpbuf, sizeof(tmpbuf), "Host Aware");
2354                 break;
2355         case DA_ZONE_HOST_MANAGED:
2356                 snprintf(tmpbuf, sizeof(tmpbuf), "Host Managed");
2357                 break;
2358         case DA_ZONE_NONE:
2359         default:
2360                 snprintf(tmpbuf, sizeof(tmpbuf), "Not Zoned");
2361                 break;
2362         }
2363
2364         error = sysctl_handle_string(oidp, tmpbuf, sizeof(tmpbuf), req);
2365
2366         return (error);
2367 }
2368
2369 static int
2370 dazonesupsysctl(SYSCTL_HANDLER_ARGS)
2371 {
2372         char tmpbuf[180];
2373         struct da_softc *softc;
2374         struct sbuf sb;
2375         int error, first;
2376         unsigned int i;
2377
2378         softc = (struct da_softc *)arg1;
2379
2380         error = 0;
2381         first = 1;
2382         sbuf_new(&sb, tmpbuf, sizeof(tmpbuf), 0);
2383
2384         for (i = 0; i < sizeof(da_zone_desc_table) /
2385              sizeof(da_zone_desc_table[0]); i++) {
2386                 if (softc->zone_flags & da_zone_desc_table[i].value) {
2387                         if (first == 0)
2388                                 sbuf_printf(&sb, ", ");
2389                         else
2390                                 first = 0;
2391                         sbuf_cat(&sb, da_zone_desc_table[i].desc);
2392                 }
2393         }
2394
2395         if (first == 1)
2396                 sbuf_printf(&sb, "None");
2397
2398         sbuf_finish(&sb);
2399
2400         error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
2401
2402         return (error);
2403 }
2404
2405 static cam_status
2406 daregister(struct cam_periph *periph, void *arg)
2407 {
2408         struct da_softc *softc;
2409         struct ccb_pathinq cpi;
2410         struct ccb_getdev *cgd;
2411         char tmpstr[80];
2412         caddr_t match;
2413
2414         cgd = (struct ccb_getdev *)arg;
2415         if (cgd == NULL) {
2416                 printf("daregister: no getdev CCB, can't register device\n");
2417                 return(CAM_REQ_CMP_ERR);
2418         }
2419
2420         softc = (struct da_softc *)malloc(sizeof(*softc), M_DEVBUF,
2421             M_NOWAIT|M_ZERO);
2422
2423         if (softc == NULL) {
2424                 printf("daregister: Unable to probe new device. "
2425                        "Unable to allocate softc\n");
2426                 return(CAM_REQ_CMP_ERR);
2427         }
2428
2429         if (cam_iosched_init(&softc->cam_iosched, periph) != 0) {
2430                 printf("daregister: Unable to probe new device. "
2431                        "Unable to allocate iosched memory\n");
2432                 free(softc, M_DEVBUF);
2433                 return(CAM_REQ_CMP_ERR);
2434         }
2435
2436         LIST_INIT(&softc->pending_ccbs);
2437         softc->state = DA_STATE_PROBE_RC;
2438         bioq_init(&softc->delete_run_queue);
2439         if (SID_IS_REMOVABLE(&cgd->inq_data))
2440                 softc->flags |= DA_FLAG_PACK_REMOVABLE;
2441         softc->unmap_max_ranges = UNMAP_MAX_RANGES;
2442         softc->unmap_max_lba = UNMAP_RANGE_MAX;
2443         softc->unmap_gran = 0;
2444         softc->unmap_gran_align = 0;
2445         softc->ws_max_blks = WS16_MAX_BLKS;
2446         softc->trim_max_ranges = ATA_TRIM_MAX_RANGES;
2447         softc->rotating = 1;
2448
2449         periph->softc = softc;
2450
2451         /*
2452          * See if this device has any quirks.
2453          */
2454         match = cam_quirkmatch((caddr_t)&cgd->inq_data,
2455                                (caddr_t)da_quirk_table,
2456                                nitems(da_quirk_table),
2457                                sizeof(*da_quirk_table), scsi_inquiry_match);
2458
2459         if (match != NULL)
2460                 softc->quirks = ((struct da_quirk_entry *)match)->quirks;
2461         else
2462                 softc->quirks = DA_Q_NONE;
2463
2464         /* Check if the SIM does not want 6 byte commands */
2465         xpt_path_inq(&cpi, periph->path);
2466         if (cpi.ccb_h.status == CAM_REQ_CMP && (cpi.hba_misc & PIM_NO_6_BYTE))
2467                 softc->quirks |= DA_Q_NO_6_BYTE;
2468
2469         if (SID_TYPE(&cgd->inq_data) == T_ZBC_HM)
2470                 softc->zone_mode = DA_ZONE_HOST_MANAGED;
2471         else if (softc->quirks & DA_Q_SMR_DM)
2472                 softc->zone_mode = DA_ZONE_DRIVE_MANAGED;
2473         else
2474                 softc->zone_mode = DA_ZONE_NONE;
2475
2476         if (softc->zone_mode != DA_ZONE_NONE) {
2477                 if (scsi_vpd_supported_page(periph, SVPD_ATA_INFORMATION)) {
2478                         if (scsi_vpd_supported_page(periph, SVPD_ZONED_BDC))
2479                                 softc->zone_interface = DA_ZONE_IF_ATA_SAT;
2480                         else
2481                                 softc->zone_interface = DA_ZONE_IF_ATA_PASS;
2482                 } else
2483                         softc->zone_interface = DA_ZONE_IF_SCSI;
2484         }
2485
2486         TASK_INIT(&softc->sysctl_task, 0, dasysctlinit, periph);
2487
2488         /*
2489          * Take an exclusive refcount on the periph while dastart is called
2490          * to finish the probe.  The reference will be dropped in dadone at
2491          * the end of probe.
2492          */
2493         (void)cam_periph_hold(periph, PRIBIO);
2494
2495         /*
2496          * Schedule a periodic event to occasionally send an
2497          * ordered tag to a device.
2498          */
2499         callout_init_mtx(&softc->sendordered_c, cam_periph_mtx(periph), 0);
2500         callout_reset(&softc->sendordered_c,
2501             (da_default_timeout * hz) / DA_ORDEREDTAG_INTERVAL,
2502             dasendorderedtag, softc);
2503
2504         cam_periph_unlock(periph);
2505         /*
2506          * RBC devices don't have to support READ(6), only READ(10).
2507          */
2508         if (softc->quirks & DA_Q_NO_6_BYTE || SID_TYPE(&cgd->inq_data) == T_RBC)
2509                 softc->minimum_cmd_size = 10;
2510         else
2511                 softc->minimum_cmd_size = 6;
2512
2513         /*
2514          * Load the user's default, if any.
2515          */
2516         snprintf(tmpstr, sizeof(tmpstr), "kern.cam.da.%d.minimum_cmd_size",
2517                  periph->unit_number);
2518         TUNABLE_INT_FETCH(tmpstr, &softc->minimum_cmd_size);
2519
2520         /*
2521          * 6, 10, 12 and 16 are the currently permissible values.
2522          */
2523         if (softc->minimum_cmd_size > 12)
2524                 softc->minimum_cmd_size = 16;
2525         else if (softc->minimum_cmd_size > 10)
2526                 softc->minimum_cmd_size = 12;
2527         else if (softc->minimum_cmd_size > 6)
2528                 softc->minimum_cmd_size = 10;
2529         else
2530                 softc->minimum_cmd_size = 6;
2531
2532         /* Predict whether device may support READ CAPACITY(16). */
2533         if (SID_ANSI_REV(&cgd->inq_data) >= SCSI_REV_SPC3 &&
2534             (softc->quirks & DA_Q_NO_RC16) == 0) {
2535                 softc->flags |= DA_FLAG_CAN_RC16;
2536                 softc->state = DA_STATE_PROBE_RC16;
2537         }
2538
2539         /*
2540          * Register this media as a disk.
2541          */
2542         softc->disk = disk_alloc();
2543         softc->disk->d_devstat = devstat_new_entry(periph->periph_name,
2544                           periph->unit_number, 0,
2545                           DEVSTAT_BS_UNAVAILABLE,
2546                           SID_TYPE(&cgd->inq_data) |
2547                           XPORT_DEVSTAT_TYPE(cpi.transport),
2548                           DEVSTAT_PRIORITY_DISK);
2549         softc->disk->d_open = daopen;
2550         softc->disk->d_close = daclose;
2551         softc->disk->d_strategy = dastrategy;
2552         softc->disk->d_dump = dadump;
2553         softc->disk->d_getattr = dagetattr;
2554         softc->disk->d_gone = dadiskgonecb;
2555         softc->disk->d_name = "da";
2556         softc->disk->d_drv1 = periph;
2557         if (cpi.maxio == 0)
2558                 softc->maxio = DFLTPHYS;        /* traditional default */
2559         else if (cpi.maxio > MAXPHYS)
2560                 softc->maxio = MAXPHYS;         /* for safety */
2561         else
2562                 softc->maxio = cpi.maxio;
2563         softc->disk->d_maxsize = softc->maxio;
2564         softc->disk->d_unit = periph->unit_number;
2565         softc->disk->d_flags = DISKFLAG_DIRECT_COMPLETION | DISKFLAG_CANZONE;
2566         if ((softc->quirks & DA_Q_NO_SYNC_CACHE) == 0)
2567                 softc->disk->d_flags |= DISKFLAG_CANFLUSHCACHE;
2568         if ((cpi.hba_misc & PIM_UNMAPPED) != 0) {
2569                 softc->unmappedio = 1;
2570                 softc->disk->d_flags |= DISKFLAG_UNMAPPED_BIO;
2571         }
2572         cam_strvis(softc->disk->d_descr, cgd->inq_data.vendor,
2573             sizeof(cgd->inq_data.vendor), sizeof(softc->disk->d_descr));
2574         strlcat(softc->disk->d_descr, " ", sizeof(softc->disk->d_descr));
2575         cam_strvis(&softc->disk->d_descr[strlen(softc->disk->d_descr)],
2576             cgd->inq_data.product, sizeof(cgd->inq_data.product),
2577             sizeof(softc->disk->d_descr) - strlen(softc->disk->d_descr));
2578         softc->disk->d_hba_vendor = cpi.hba_vendor;
2579         softc->disk->d_hba_device = cpi.hba_device;
2580         softc->disk->d_hba_subvendor = cpi.hba_subvendor;
2581         softc->disk->d_hba_subdevice = cpi.hba_subdevice;
2582
2583         /*
2584          * Acquire a reference to the periph before we register with GEOM.
2585          * We'll release this reference once GEOM calls us back (via
2586          * dadiskgonecb()) telling us that our provider has been freed.
2587          */
2588         if (cam_periph_acquire(periph) != CAM_REQ_CMP) {
2589                 xpt_print(periph->path, "%s: lost periph during "
2590                           "registration!\n", __func__);
2591                 cam_periph_lock(periph);
2592                 return (CAM_REQ_CMP_ERR);
2593         }
2594
2595         disk_create(softc->disk, DISK_VERSION);
2596         cam_periph_lock(periph);
2597
2598         /*
2599          * Add async callbacks for events of interest.
2600          * I don't bother checking if this fails as,
2601          * in most cases, the system will function just
2602          * fine without them and the only alternative
2603          * would be to not attach the device on failure.
2604          */
2605         xpt_register_async(AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE |
2606             AC_ADVINFO_CHANGED | AC_SCSI_AEN | AC_UNIT_ATTENTION |
2607             AC_INQ_CHANGED, daasync, periph, periph->path);
2608
2609         /*
2610          * Emit an attribute changed notification just in case
2611          * physical path information arrived before our async
2612          * event handler was registered, but after anyone attaching
2613          * to our disk device polled it.
2614          */
2615         disk_attr_changed(softc->disk, "GEOM::physpath", M_NOWAIT);
2616
2617         /*
2618          * Schedule a periodic media polling events.
2619          */
2620         callout_init_mtx(&softc->mediapoll_c, cam_periph_mtx(periph), 0);
2621         if ((softc->flags & DA_FLAG_PACK_REMOVABLE) &&
2622             (cgd->inq_flags & SID_AEN) == 0 &&
2623             da_poll_period != 0)
2624                 callout_reset(&softc->mediapoll_c, da_poll_period * hz,
2625                     damediapoll, periph);
2626
2627         xpt_schedule(periph, CAM_PRIORITY_DEV);
2628
2629         return(CAM_REQ_CMP);
2630 }
2631
2632 static int
2633 da_zone_bio_to_scsi(int disk_zone_cmd)
2634 {
2635         switch (disk_zone_cmd) {
2636         case DISK_ZONE_OPEN:
2637                 return ZBC_OUT_SA_OPEN;
2638         case DISK_ZONE_CLOSE:
2639                 return ZBC_OUT_SA_CLOSE;
2640         case DISK_ZONE_FINISH:
2641                 return ZBC_OUT_SA_FINISH;
2642         case DISK_ZONE_RWP:
2643                 return ZBC_OUT_SA_RWP;
2644         }
2645
2646         return -1;
2647 }
2648
2649 static int
2650 da_zone_cmd(struct cam_periph *periph, union ccb *ccb, struct bio *bp,
2651             int *queue_ccb)
2652 {
2653         struct da_softc *softc;
2654         int error;
2655
2656         error = 0;
2657
2658         if (bp->bio_cmd != BIO_ZONE) {
2659                 error = EINVAL;
2660                 goto bailout;
2661         }
2662
2663         softc = periph->softc;
2664
2665         switch (bp->bio_zone.zone_cmd) {
2666         case DISK_ZONE_OPEN:
2667         case DISK_ZONE_CLOSE:
2668         case DISK_ZONE_FINISH:
2669         case DISK_ZONE_RWP: {
2670                 int zone_flags;
2671                 int zone_sa;
2672                 uint64_t lba;
2673
2674                 zone_sa = da_zone_bio_to_scsi(bp->bio_zone.zone_cmd);
2675                 if (zone_sa == -1) {
2676                         xpt_print(periph->path, "Cannot translate zone "
2677                             "cmd %#x to SCSI\n", bp->bio_zone.zone_cmd);
2678                         error = EINVAL;
2679                         goto bailout;
2680                 }
2681
2682                 zone_flags = 0;
2683                 lba = bp->bio_zone.zone_params.rwp.id;
2684
2685                 if (bp->bio_zone.zone_params.rwp.flags &
2686                     DISK_ZONE_RWP_FLAG_ALL)
2687                         zone_flags |= ZBC_OUT_ALL;
2688
2689                 if (softc->zone_interface != DA_ZONE_IF_ATA_PASS) {
2690                         scsi_zbc_out(&ccb->csio,
2691                                      /*retries*/ da_retry_count,
2692                                      /*cbfcnp*/ dadone,
2693                                      /*tag_action*/ MSG_SIMPLE_Q_TAG,
2694                                      /*service_action*/ zone_sa,
2695                                      /*zone_id*/ lba,
2696                                      /*zone_flags*/ zone_flags,
2697                                      /*data_ptr*/ NULL,
2698                                      /*dxfer_len*/ 0,
2699                                      /*sense_len*/ SSD_FULL_SIZE,
2700                                      /*timeout*/ da_default_timeout * 1000);
2701                 } else {
2702                         /*
2703                          * Note that in this case, even though we can
2704                          * technically use NCQ, we don't bother for several
2705                          * reasons:
2706                          * 1. It hasn't been tested on a SAT layer that
2707                          *    supports it.  This is new as of SAT-4.
2708                          * 2. Even when there is a SAT layer that supports
2709                          *    it, that SAT layer will also probably support
2710                          *    ZBC -> ZAC translation, since they are both
2711                          *    in the SAT-4 spec.
2712                          * 3. Translation will likely be preferable to ATA
2713                          *    passthrough.  LSI / Avago at least single
2714                          *    steps ATA passthrough commands in the HBA,
2715                          *    regardless of protocol, so unless that
2716                          *    changes, there is a performance penalty for
2717                          *    doing ATA passthrough no matter whether
2718                          *    you're using NCQ/FPDMA, DMA or PIO.
2719                          * 4. It requires a 32-byte CDB, which at least at
2720                          *    this point in CAM requires a CDB pointer, which
2721                          *    would require us to allocate an additional bit
2722                          *    of storage separate from the CCB.
2723                          */
2724                         error = scsi_ata_zac_mgmt_out(&ccb->csio,
2725                             /*retries*/ da_retry_count,
2726                             /*cbfcnp*/ dadone,
2727                             /*tag_action*/ MSG_SIMPLE_Q_TAG,
2728                             /*use_ncq*/ 0,
2729                             /*zm_action*/ zone_sa,
2730                             /*zone_id*/ lba,
2731                             /*zone_flags*/ zone_flags,
2732                             /*data_ptr*/ NULL,
2733                             /*dxfer_len*/ 0,
2734                             /*cdb_storage*/ NULL,
2735                             /*cdb_storage_len*/ 0,
2736                             /*sense_len*/ SSD_FULL_SIZE,
2737                             /*timeout*/ da_default_timeout * 1000);
2738                         if (error != 0) {
2739                                 error = EINVAL;
2740                                 xpt_print(periph->path,
2741                                     "scsi_ata_zac_mgmt_out() returned an "
2742                                     "error!");
2743                                 goto bailout;
2744                         }
2745                 }
2746                 *queue_ccb = 1;
2747
2748                 break;
2749         }
2750         case DISK_ZONE_REPORT_ZONES: {
2751                 uint8_t *rz_ptr;
2752                 uint32_t num_entries, alloc_size;
2753                 struct disk_zone_report *rep;
2754
2755                 rep = &bp->bio_zone.zone_params.report;
2756
2757                 num_entries = rep->entries_allocated;
2758                 if (num_entries == 0) {
2759                         xpt_print(periph->path, "No entries allocated for "
2760                             "Report Zones request\n");
2761                         error = EINVAL;
2762                         goto bailout;
2763                 }
2764                 alloc_size = sizeof(struct scsi_report_zones_hdr) +
2765                     (sizeof(struct scsi_report_zones_desc) * num_entries);
2766                 alloc_size = min(alloc_size, softc->disk->d_maxsize);
2767                 rz_ptr = malloc(alloc_size, M_SCSIDA, M_NOWAIT | M_ZERO);
2768                 if (rz_ptr == NULL) {
2769                         xpt_print(periph->path, "Unable to allocate memory "
2770                            "for Report Zones request\n");
2771                         error = ENOMEM;
2772                         goto bailout;
2773                 }
2774
2775                 if (softc->zone_interface != DA_ZONE_IF_ATA_PASS) {
2776                         scsi_zbc_in(&ccb->csio,
2777                                     /*retries*/ da_retry_count,
2778                                     /*cbcfnp*/ dadone,
2779                                     /*tag_action*/ MSG_SIMPLE_Q_TAG,
2780                                     /*service_action*/ ZBC_IN_SA_REPORT_ZONES,
2781                                     /*zone_start_lba*/ rep->starting_id,
2782                                     /*zone_options*/ rep->rep_options,
2783                                     /*data_ptr*/ rz_ptr,
2784                                     /*dxfer_len*/ alloc_size,
2785                                     /*sense_len*/ SSD_FULL_SIZE,
2786                                     /*timeout*/ da_default_timeout * 1000);
2787                 } else {
2788                         /*
2789                          * Note that in this case, even though we can
2790                          * technically use NCQ, we don't bother for several
2791                          * reasons:
2792                          * 1. It hasn't been tested on a SAT layer that
2793                          *    supports it.  This is new as of SAT-4.
2794                          * 2. Even when there is a SAT layer that supports
2795                          *    it, that SAT layer will also probably support
2796                          *    ZBC -> ZAC translation, since they are both
2797                          *    in the SAT-4 spec.
2798                          * 3. Translation will likely be preferable to ATA
2799                          *    passthrough.  LSI / Avago at least single
2800                          *    steps ATA passthrough commands in the HBA,
2801                          *    regardless of protocol, so unless that
2802                          *    changes, there is a performance penalty for
2803                          *    doing ATA passthrough no matter whether
2804                          *    you're using NCQ/FPDMA, DMA or PIO.
2805                          * 4. It requires a 32-byte CDB, which at least at
2806                          *    this point in CAM requires a CDB pointer, which
2807                          *    would require us to allocate an additional bit
2808                          *    of storage separate from the CCB.
2809                          */
2810                         error = scsi_ata_zac_mgmt_in(&ccb->csio,
2811                             /*retries*/ da_retry_count,
2812                             /*cbcfnp*/ dadone,
2813                             /*tag_action*/ MSG_SIMPLE_Q_TAG,
2814                             /*use_ncq*/ 0,
2815                             /*zm_action*/ ATA_ZM_REPORT_ZONES,
2816                             /*zone_id*/ rep->starting_id,
2817                             /*zone_flags*/ rep->rep_options,
2818                             /*data_ptr*/ rz_ptr,
2819                             /*dxfer_len*/ alloc_size,
2820                             /*cdb_storage*/ NULL,
2821                             /*cdb_storage_len*/ 0,
2822                             /*sense_len*/ SSD_FULL_SIZE,
2823                             /*timeout*/ da_default_timeout * 1000);
2824                         if (error != 0) {
2825                                 error = EINVAL;
2826                                 xpt_print(periph->path,
2827                                     "scsi_ata_zac_mgmt_in() returned an "
2828                                     "error!");
2829                                 goto bailout;
2830                         }
2831                 }
2832
2833                 /*
2834                  * For BIO_ZONE, this isn't normally needed.  However, it
2835                  * is used by devstat_end_transaction_bio() to determine
2836                  * how much data was transferred.
2837                  */
2838                 /*
2839                  * XXX KDM we have a problem.  But I'm not sure how to fix
2840                  * it.  devstat uses bio_bcount - bio_resid to calculate
2841                  * the amount of data transferred.   The GEOM disk code
2842                  * uses bio_length - bio_resid to calculate the amount of
2843                  * data in bio_completed.  We have different structure
2844                  * sizes above and below the ada(4) driver.  So, if we
2845                  * use the sizes above, the amount transferred won't be
2846                  * quite accurate for devstat.  If we use different sizes
2847                  * for bio_bcount and bio_length (above and below
2848                  * respectively), then the residual needs to match one or
2849                  * the other.  Everything is calculated after the bio
2850                  * leaves the driver, so changing the values around isn't
2851                  * really an option.  For now, just set the count to the
2852                  * passed in length.  This means that the calculations
2853                  * above (e.g. bio_completed) will be correct, but the
2854                  * amount of data reported to devstat will be slightly
2855                  * under or overstated.
2856                  */
2857                 bp->bio_bcount = bp->bio_length;
2858
2859                 *queue_ccb = 1;
2860
2861                 break;
2862         }
2863         case DISK_ZONE_GET_PARAMS: {
2864                 struct disk_zone_disk_params *params;
2865
2866                 params = &bp->bio_zone.zone_params.disk_params;
2867                 bzero(params, sizeof(*params));
2868
2869                 switch (softc->zone_mode) {
2870                 case DA_ZONE_DRIVE_MANAGED:
2871                         params->zone_mode = DISK_ZONE_MODE_DRIVE_MANAGED;
2872                         break;
2873                 case DA_ZONE_HOST_AWARE:
2874                         params->zone_mode = DISK_ZONE_MODE_HOST_AWARE;
2875                         break;
2876                 case DA_ZONE_HOST_MANAGED:
2877                         params->zone_mode = DISK_ZONE_MODE_HOST_MANAGED;
2878                         break;
2879                 default:
2880                 case DA_ZONE_NONE:
2881                         params->zone_mode = DISK_ZONE_MODE_NONE;
2882                         break;
2883                 }
2884
2885                 if (softc->zone_flags & DA_ZONE_FLAG_URSWRZ)
2886                         params->flags |= DISK_ZONE_DISK_URSWRZ;
2887
2888                 if (softc->zone_flags & DA_ZONE_FLAG_OPT_SEQ_SET) {
2889                         params->optimal_seq_zones = softc->optimal_seq_zones;
2890                         params->flags |= DISK_ZONE_OPT_SEQ_SET;
2891                 }
2892
2893                 if (softc->zone_flags & DA_ZONE_FLAG_OPT_NONSEQ_SET) {
2894                         params->optimal_nonseq_zones =
2895                             softc->optimal_nonseq_zones;
2896                         params->flags |= DISK_ZONE_OPT_NONSEQ_SET;
2897                 }
2898
2899                 if (softc->zone_flags & DA_ZONE_FLAG_MAX_SEQ_SET) {
2900                         params->max_seq_zones = softc->max_seq_zones;
2901                         params->flags |= DISK_ZONE_MAX_SEQ_SET;
2902                 }
2903                 if (softc->zone_flags & DA_ZONE_FLAG_RZ_SUP)
2904                         params->flags |= DISK_ZONE_RZ_SUP;
2905
2906                 if (softc->zone_flags & DA_ZONE_FLAG_OPEN_SUP)
2907                         params->flags |= DISK_ZONE_OPEN_SUP;
2908
2909                 if (softc->zone_flags & DA_ZONE_FLAG_CLOSE_SUP)
2910                         params->flags |= DISK_ZONE_CLOSE_SUP;
2911
2912                 if (softc->zone_flags & DA_ZONE_FLAG_FINISH_SUP)
2913                         params->flags |= DISK_ZONE_FINISH_SUP;
2914
2915                 if (softc->zone_flags & DA_ZONE_FLAG_RWP_SUP)
2916                         params->flags |= DISK_ZONE_RWP_SUP;
2917                 break;
2918         }
2919         default:
2920                 break;
2921         }
2922 bailout:
2923         return (error);
2924 }
2925
2926 static void
2927 dastart(struct cam_periph *periph, union ccb *start_ccb)
2928 {
2929         struct da_softc *softc;
2930
2931         softc = (struct da_softc *)periph->softc;
2932
2933         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dastart\n"));
2934
2935 skipstate:
2936         switch (softc->state) {
2937         case DA_STATE_NORMAL:
2938         {
2939                 struct bio *bp;
2940                 uint8_t tag_code;
2941
2942 more:
2943                 bp = cam_iosched_next_bio(softc->cam_iosched);
2944                 if (bp == NULL) {
2945                         if (cam_iosched_has_work_flags(softc->cam_iosched, DA_WORK_TUR)) {
2946                                 cam_iosched_clr_work_flags(softc->cam_iosched, DA_WORK_TUR);
2947                                 scsi_test_unit_ready(&start_ccb->csio,
2948                                      /*retries*/ da_retry_count,
2949                                      dadone,
2950                                      MSG_SIMPLE_Q_TAG,
2951                                      SSD_FULL_SIZE,
2952                                      da_default_timeout * 1000);
2953                                 start_ccb->ccb_h.ccb_bp = NULL;
2954                                 start_ccb->ccb_h.ccb_state = DA_CCB_TUR;
2955                                 xpt_action(start_ccb);
2956                         } else
2957                                 xpt_release_ccb(start_ccb);
2958                         break;
2959                 }
2960
2961                 if (bp->bio_cmd == BIO_DELETE) {
2962                         if (softc->delete_func != NULL) {
2963                                 softc->delete_func(periph, start_ccb, bp);
2964                                 goto out;
2965                         } else {
2966                                 /* Not sure this is possible, but failsafe by lying and saying "sure, done." */
2967                                 biofinish(bp, NULL, 0);
2968                                 goto more;
2969                         }
2970                 }
2971
2972                 if (cam_iosched_has_work_flags(softc->cam_iosched, DA_WORK_TUR)) {
2973                         cam_iosched_clr_work_flags(softc->cam_iosched, DA_WORK_TUR);
2974                         cam_periph_release_locked(periph);      /* XXX is this still valid? I think so but unverified */
2975                 }
2976
2977                 if ((bp->bio_flags & BIO_ORDERED) != 0 ||
2978                     (softc->flags & DA_FLAG_NEED_OTAG) != 0) {
2979                         softc->flags &= ~DA_FLAG_NEED_OTAG;
2980                         softc->flags |= DA_FLAG_WAS_OTAG;
2981                         tag_code = MSG_ORDERED_Q_TAG;
2982                 } else {
2983                         tag_code = MSG_SIMPLE_Q_TAG;
2984                 }
2985
2986                 switch (bp->bio_cmd) {
2987                 case BIO_WRITE:
2988                 case BIO_READ:
2989                 {
2990                         void *data_ptr;
2991                         int rw_op;
2992
2993                         biotrack(bp, __func__);
2994
2995                         if (bp->bio_cmd == BIO_WRITE) {
2996                                 softc->flags |= DA_FLAG_DIRTY;
2997                                 rw_op = SCSI_RW_WRITE;
2998                         } else {
2999                                 rw_op = SCSI_RW_READ;
3000                         }
3001
3002                         data_ptr = bp->bio_data;
3003                         if ((bp->bio_flags & (BIO_UNMAPPED|BIO_VLIST)) != 0) {
3004                                 rw_op |= SCSI_RW_BIO;
3005                                 data_ptr = bp;
3006                         }
3007
3008                         scsi_read_write(&start_ccb->csio,
3009                                         /*retries*/da_retry_count,
3010                                         /*cbfcnp*/dadone,
3011                                         /*tag_action*/tag_code,
3012                                         rw_op,
3013                                         /*byte2*/0,
3014                                         softc->minimum_cmd_size,
3015                                         /*lba*/bp->bio_pblkno,
3016                                         /*block_count*/bp->bio_bcount /
3017                                         softc->params.secsize,
3018                                         data_ptr,
3019                                         /*dxfer_len*/ bp->bio_bcount,
3020                                         /*sense_len*/SSD_FULL_SIZE,
3021                                         da_default_timeout * 1000);
3022 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
3023                         start_ccb->csio.bio = bp;
3024 #endif
3025                         break;
3026                 }
3027                 case BIO_FLUSH:
3028                         /*
3029                          * If we don't support sync cache, or the disk
3030                          * isn't dirty, FLUSH is a no-op.  Use the
3031                          * allocated * CCB for the next bio if one is
3032                          * available.
3033                          */
3034                         if ((softc->quirks & DA_Q_NO_SYNC_CACHE) != 0 ||
3035                             (softc->flags & DA_FLAG_DIRTY) == 0) {
3036                                 biodone(bp);
3037                                 goto skipstate;
3038                         }
3039
3040                         /*
3041                          * BIO_FLUSH doesn't currently communicate
3042                          * range data, so we synchronize the cache
3043                          * over the whole disk.  We also force
3044                          * ordered tag semantics the flush applies
3045                          * to all previously queued I/O.
3046                          */
3047                         scsi_synchronize_cache(&start_ccb->csio,
3048                                                /*retries*/1,
3049                                                /*cbfcnp*/dadone,
3050                                                MSG_ORDERED_Q_TAG,
3051                                                /*begin_lba*/0,
3052                                                /*lb_count*/0,
3053                                                SSD_FULL_SIZE,
3054                                                da_default_timeout*1000);
3055                         /*
3056                          * Clear the dirty flag before sending the command.
3057                          * Either this sync cache will be successful, or it
3058                          * will fail after a retry.  If it fails, it is
3059                          * unlikely to be successful if retried later, so
3060                          * we'll save ourselves time by just marking the
3061                          * device clean.
3062                          */
3063                         softc->flags &= ~DA_FLAG_DIRTY;
3064                         break;
3065                 case BIO_ZONE: {
3066                         int error, queue_ccb;
3067
3068                         queue_ccb = 0;
3069
3070                         error = da_zone_cmd(periph, start_ccb, bp,&queue_ccb);
3071                         if ((error != 0)
3072                          || (queue_ccb == 0)) {
3073                                 biofinish(bp, NULL, error);
3074                                 xpt_release_ccb(start_ccb);
3075                                 return;
3076                         }
3077                         break;
3078                 }
3079                 }
3080                 start_ccb->ccb_h.ccb_state = DA_CCB_BUFFER_IO;
3081                 start_ccb->ccb_h.flags |= CAM_UNLOCKED;
3082                 start_ccb->ccb_h.softtimeout = sbttotv(da_default_softtimeout);
3083
3084 out:
3085                 LIST_INSERT_HEAD(&softc->pending_ccbs,
3086                                  &start_ccb->ccb_h, periph_links.le);
3087
3088                 /* We expect a unit attention from this device */
3089                 if ((softc->flags & DA_FLAG_RETRY_UA) != 0) {
3090                         start_ccb->ccb_h.ccb_state |= DA_CCB_RETRY_UA;
3091                         softc->flags &= ~DA_FLAG_RETRY_UA;
3092                 }
3093
3094                 start_ccb->ccb_h.ccb_bp = bp;
3095                 softc->refcount++;
3096                 cam_periph_unlock(periph);
3097                 xpt_action(start_ccb);
3098                 cam_periph_lock(periph);
3099                 softc->refcount--;
3100
3101                 /* May have more work to do, so ensure we stay scheduled */
3102                 daschedule(periph);
3103                 break;
3104         }
3105         case DA_STATE_PROBE_RC:
3106         {
3107                 struct scsi_read_capacity_data *rcap;
3108
3109                 rcap = (struct scsi_read_capacity_data *)
3110                     malloc(sizeof(*rcap), M_SCSIDA, M_NOWAIT|M_ZERO);
3111                 if (rcap == NULL) {
3112                         printf("dastart: Couldn't malloc read_capacity data\n");
3113                         /* da_free_periph??? */
3114                         break;
3115                 }
3116                 scsi_read_capacity(&start_ccb->csio,
3117                                    /*retries*/da_retry_count,
3118                                    dadone,
3119                                    MSG_SIMPLE_Q_TAG,
3120                                    rcap,
3121                                    SSD_FULL_SIZE,
3122                                    /*timeout*/5000);
3123                 start_ccb->ccb_h.ccb_bp = NULL;
3124                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_RC;
3125                 xpt_action(start_ccb);
3126                 break;
3127         }
3128         case DA_STATE_PROBE_RC16:
3129         {
3130                 struct scsi_read_capacity_data_long *rcaplong;
3131
3132                 rcaplong = (struct scsi_read_capacity_data_long *)
3133                         malloc(sizeof(*rcaplong), M_SCSIDA, M_NOWAIT|M_ZERO);
3134                 if (rcaplong == NULL) {
3135                         printf("dastart: Couldn't malloc read_capacity data\n");
3136                         /* da_free_periph??? */
3137                         break;
3138                 }
3139                 scsi_read_capacity_16(&start_ccb->csio,
3140                                       /*retries*/ da_retry_count,
3141                                       /*cbfcnp*/ dadone,
3142                                       /*tag_action*/ MSG_SIMPLE_Q_TAG,
3143                                       /*lba*/ 0,
3144                                       /*reladr*/ 0,
3145                                       /*pmi*/ 0,
3146                                       /*rcap_buf*/ (uint8_t *)rcaplong,
3147                                       /*rcap_buf_len*/ sizeof(*rcaplong),
3148                                       /*sense_len*/ SSD_FULL_SIZE,
3149                                       /*timeout*/ da_default_timeout * 1000);
3150                 start_ccb->ccb_h.ccb_bp = NULL;
3151                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_RC16;
3152                 xpt_action(start_ccb);
3153                 break;
3154         }
3155         case DA_STATE_PROBE_LBP:
3156         {
3157                 struct scsi_vpd_logical_block_prov *lbp;
3158
3159                 if (!scsi_vpd_supported_page(periph, SVPD_LBP)) {
3160                         /*
3161                          * If we get here we don't support any SBC-3 delete
3162                          * methods with UNMAP as the Logical Block Provisioning
3163                          * VPD page support is required for devices which
3164                          * support it according to T10/1799-D Revision 31
3165                          * however older revisions of the spec don't mandate
3166                          * this so we currently don't remove these methods
3167                          * from the available set.
3168                          */
3169                         softc->state = DA_STATE_PROBE_BLK_LIMITS;
3170                         goto skipstate;
3171                 }
3172
3173                 lbp = (struct scsi_vpd_logical_block_prov *)
3174                         malloc(sizeof(*lbp), M_SCSIDA, M_NOWAIT|M_ZERO);
3175
3176                 if (lbp == NULL) {
3177                         printf("dastart: Couldn't malloc lbp data\n");
3178                         /* da_free_periph??? */
3179                         break;
3180                 }
3181
3182                 scsi_inquiry(&start_ccb->csio,
3183                              /*retries*/da_retry_count,
3184                              /*cbfcnp*/dadone,
3185                              /*tag_action*/MSG_SIMPLE_Q_TAG,
3186                              /*inq_buf*/(u_int8_t *)lbp,
3187                              /*inq_len*/sizeof(*lbp),
3188                              /*evpd*/TRUE,
3189                              /*page_code*/SVPD_LBP,
3190                              /*sense_len*/SSD_MIN_SIZE,
3191                              /*timeout*/da_default_timeout * 1000);
3192                 start_ccb->ccb_h.ccb_bp = NULL;
3193                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_LBP;
3194                 xpt_action(start_ccb);
3195                 break;
3196         }
3197         case DA_STATE_PROBE_BLK_LIMITS:
3198         {
3199                 struct scsi_vpd_block_limits *block_limits;
3200
3201                 if (!scsi_vpd_supported_page(periph, SVPD_BLOCK_LIMITS)) {
3202                         /* Not supported skip to next probe */
3203                         softc->state = DA_STATE_PROBE_BDC;
3204                         goto skipstate;
3205                 }
3206
3207                 block_limits = (struct scsi_vpd_block_limits *)
3208                         malloc(sizeof(*block_limits), M_SCSIDA, M_NOWAIT|M_ZERO);
3209
3210                 if (block_limits == NULL) {
3211                         printf("dastart: Couldn't malloc block_limits data\n");
3212                         /* da_free_periph??? */
3213                         break;
3214                 }
3215
3216                 scsi_inquiry(&start_ccb->csio,
3217                              /*retries*/da_retry_count,
3218                              /*cbfcnp*/dadone,
3219                              /*tag_action*/MSG_SIMPLE_Q_TAG,
3220                              /*inq_buf*/(u_int8_t *)block_limits,
3221                              /*inq_len*/sizeof(*block_limits),
3222                              /*evpd*/TRUE,
3223                              /*page_code*/SVPD_BLOCK_LIMITS,
3224                              /*sense_len*/SSD_MIN_SIZE,
3225                              /*timeout*/da_default_timeout * 1000);
3226                 start_ccb->ccb_h.ccb_bp = NULL;
3227                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_BLK_LIMITS;
3228                 xpt_action(start_ccb);
3229                 break;
3230         }
3231         case DA_STATE_PROBE_BDC:
3232         {
3233                 struct scsi_vpd_block_characteristics *bdc;
3234
3235                 if (!scsi_vpd_supported_page(periph, SVPD_BDC)) {
3236                         softc->state = DA_STATE_PROBE_ATA;
3237                         goto skipstate;
3238                 }
3239
3240                 bdc = (struct scsi_vpd_block_characteristics *)
3241                         malloc(sizeof(*bdc), M_SCSIDA, M_NOWAIT|M_ZERO);
3242
3243                 if (bdc == NULL) {
3244                         printf("dastart: Couldn't malloc bdc data\n");
3245                         /* da_free_periph??? */
3246                         break;
3247                 }
3248
3249                 scsi_inquiry(&start_ccb->csio,
3250                              /*retries*/da_retry_count,
3251                              /*cbfcnp*/dadone,
3252                              /*tag_action*/MSG_SIMPLE_Q_TAG,
3253                              /*inq_buf*/(u_int8_t *)bdc,
3254                              /*inq_len*/sizeof(*bdc),
3255                              /*evpd*/TRUE,
3256                              /*page_code*/SVPD_BDC,
3257                              /*sense_len*/SSD_MIN_SIZE,
3258                              /*timeout*/da_default_timeout * 1000);
3259                 start_ccb->ccb_h.ccb_bp = NULL;
3260                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_BDC;
3261                 xpt_action(start_ccb);
3262                 break;
3263         }
3264         case DA_STATE_PROBE_ATA:
3265         {
3266                 struct ata_params *ata_params;
3267
3268                 if (!scsi_vpd_supported_page(periph, SVPD_ATA_INFORMATION)) {
3269                         if ((softc->zone_mode == DA_ZONE_HOST_AWARE)
3270                          || (softc->zone_mode == DA_ZONE_HOST_MANAGED)) {
3271                                 /*
3272                                  * Note that if the ATA VPD page isn't
3273                                  * supported, we aren't talking to an ATA
3274                                  * device anyway.  Support for that VPD
3275                                  * page is mandatory for SCSI to ATA (SAT)
3276                                  * translation layers.
3277                                  */
3278                                 softc->state = DA_STATE_PROBE_ZONE;
3279                                 goto skipstate;
3280                         }
3281                         daprobedone(periph, start_ccb);
3282                         break;
3283                 }
3284
3285                 ata_params = (struct ata_params*)
3286                         malloc(sizeof(*ata_params), M_SCSIDA,M_NOWAIT|M_ZERO);
3287
3288                 if (ata_params == NULL) {
3289                         xpt_print(periph->path, "Couldn't malloc ata_params "
3290                             "data\n");
3291                         /* da_free_periph??? */
3292                         break;
3293                 }
3294
3295                 scsi_ata_identify(&start_ccb->csio,
3296                                   /*retries*/da_retry_count,
3297                                   /*cbfcnp*/dadone,
3298                                   /*tag_action*/MSG_SIMPLE_Q_TAG,
3299                                   /*data_ptr*/(u_int8_t *)ata_params,
3300                                   /*dxfer_len*/sizeof(*ata_params),
3301                                   /*sense_len*/SSD_FULL_SIZE,
3302                                   /*timeout*/da_default_timeout * 1000);
3303                 start_ccb->ccb_h.ccb_bp = NULL;
3304                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA;
3305                 xpt_action(start_ccb);
3306                 break;
3307         }
3308         case DA_STATE_PROBE_ATA_LOGDIR:
3309         {
3310                 struct ata_gp_log_dir *log_dir;
3311                 int retval;
3312
3313                 retval = 0;
3314
3315                 if ((softc->flags & DA_FLAG_CAN_ATA_LOG) == 0) {
3316                         /*
3317                          * If we don't have log support, not much point in
3318                          * trying to probe zone support.
3319                          */
3320                         daprobedone(periph, start_ccb);
3321                         break;
3322                 }
3323
3324                 /*
3325                  * If we have an ATA device (the SCSI ATA Information VPD
3326                  * page should be present and the ATA identify should have
3327                  * succeeded) and it supports logs, ask for the log directory.
3328                  */
3329
3330                 log_dir = malloc(sizeof(*log_dir), M_SCSIDA, M_NOWAIT|M_ZERO);
3331                 if (log_dir == NULL) {
3332                         xpt_print(periph->path, "Couldn't malloc log_dir "
3333                             "data\n");
3334                         daprobedone(periph, start_ccb);
3335                         break;
3336                 }
3337
3338                 retval = scsi_ata_read_log(&start_ccb->csio,
3339                     /*retries*/ da_retry_count,
3340                     /*cbfcnp*/ dadone,
3341                     /*tag_action*/ MSG_SIMPLE_Q_TAG,
3342                     /*log_address*/ ATA_LOG_DIRECTORY,
3343                     /*page_number*/ 0,
3344                     /*block_count*/ 1,
3345                     /*protocol*/ softc->flags & DA_FLAG_CAN_ATA_DMA ?
3346                                  AP_PROTO_DMA : AP_PROTO_PIO_IN,
3347                     /*data_ptr*/ (uint8_t *)log_dir,
3348                     /*dxfer_len*/ sizeof(*log_dir),
3349                     /*sense_len*/ SSD_FULL_SIZE,
3350                     /*timeout*/ da_default_timeout * 1000);
3351
3352                 if (retval != 0) {
3353                         xpt_print(periph->path, "scsi_ata_read_log() failed!");
3354                         free(log_dir, M_SCSIDA);
3355                         daprobedone(periph, start_ccb);
3356                         break;
3357                 }
3358                 start_ccb->ccb_h.ccb_bp = NULL;
3359                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA_LOGDIR;
3360                 xpt_action(start_ccb);
3361                 break;
3362         }
3363         case DA_STATE_PROBE_ATA_IDDIR:
3364         {
3365                 struct ata_identify_log_pages *id_dir;
3366                 int retval;
3367
3368                 retval = 0;
3369
3370                 /*
3371                  * Check here to see whether the Identify Device log is
3372                  * supported in the directory of logs.  If so, continue
3373                  * with requesting the log of identify device pages.
3374                  */
3375                 if ((softc->flags & DA_FLAG_CAN_ATA_IDLOG) == 0) {
3376                         daprobedone(periph, start_ccb);
3377                         break;
3378                 }
3379
3380                 id_dir = malloc(sizeof(*id_dir), M_SCSIDA, M_NOWAIT | M_ZERO);
3381                 if (id_dir == NULL) {
3382                         xpt_print(periph->path, "Couldn't malloc id_dir "
3383                             "data\n");
3384                         daprobedone(periph, start_ccb);
3385                         break;
3386                 }
3387
3388                 retval = scsi_ata_read_log(&start_ccb->csio,
3389                     /*retries*/ da_retry_count,
3390                     /*cbfcnp*/ dadone,
3391                     /*tag_action*/ MSG_SIMPLE_Q_TAG,
3392                     /*log_address*/ ATA_IDENTIFY_DATA_LOG,
3393                     /*page_number*/ ATA_IDL_PAGE_LIST,
3394                     /*block_count*/ 1,
3395                     /*protocol*/ softc->flags & DA_FLAG_CAN_ATA_DMA ?
3396                                  AP_PROTO_DMA : AP_PROTO_PIO_IN,
3397                     /*data_ptr*/ (uint8_t *)id_dir,
3398                     /*dxfer_len*/ sizeof(*id_dir),
3399                     /*sense_len*/ SSD_FULL_SIZE,
3400                     /*timeout*/ da_default_timeout * 1000);
3401
3402                 if (retval != 0) {
3403                         xpt_print(periph->path, "scsi_ata_read_log() failed!");
3404                         free(id_dir, M_SCSIDA);
3405                         daprobedone(periph, start_ccb);
3406                         break;
3407                 }
3408                 start_ccb->ccb_h.ccb_bp = NULL;
3409                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA_IDDIR;
3410                 xpt_action(start_ccb);
3411                 break;
3412         }
3413         case DA_STATE_PROBE_ATA_SUP:
3414         {
3415                 struct ata_identify_log_sup_cap *sup_cap;
3416                 int retval;
3417
3418                 retval = 0;
3419
3420                 /*
3421                  * Check here to see whether the Supported Capabilities log
3422                  * is in the list of Identify Device logs.
3423                  */
3424                 if ((softc->flags & DA_FLAG_CAN_ATA_SUPCAP) == 0) {
3425                         daprobedone(periph, start_ccb);
3426                         break;
3427                 }
3428
3429                 sup_cap = malloc(sizeof(*sup_cap), M_SCSIDA, M_NOWAIT|M_ZERO);
3430                 if (sup_cap == NULL) {
3431                         xpt_print(periph->path, "Couldn't malloc sup_cap "
3432                             "data\n");
3433                         daprobedone(periph, start_ccb);
3434                         break;
3435                 }
3436
3437                 retval = scsi_ata_read_log(&start_ccb->csio,
3438                     /*retries*/ da_retry_count,
3439                     /*cbfcnp*/ dadone,
3440                     /*tag_action*/ MSG_SIMPLE_Q_TAG,
3441                     /*log_address*/ ATA_IDENTIFY_DATA_LOG,
3442                     /*page_number*/ ATA_IDL_SUP_CAP,
3443                     /*block_count*/ 1,
3444                     /*protocol*/ softc->flags & DA_FLAG_CAN_ATA_DMA ?
3445                                  AP_PROTO_DMA : AP_PROTO_PIO_IN,
3446                     /*data_ptr*/ (uint8_t *)sup_cap,
3447                     /*dxfer_len*/ sizeof(*sup_cap),
3448                     /*sense_len*/ SSD_FULL_SIZE,
3449                     /*timeout*/ da_default_timeout * 1000);
3450
3451                 if (retval != 0) {
3452                         xpt_print(periph->path, "scsi_ata_read_log() failed!");
3453                         free(sup_cap, M_SCSIDA);
3454                         daprobedone(periph, start_ccb);
3455                         break;
3456
3457                 }
3458
3459                 start_ccb->ccb_h.ccb_bp = NULL;
3460                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA_SUP;
3461                 xpt_action(start_ccb);
3462                 break;
3463         }
3464         case DA_STATE_PROBE_ATA_ZONE:
3465         {
3466                 struct ata_zoned_info_log *ata_zone;
3467                 int retval;
3468
3469                 retval = 0;
3470
3471                 /*
3472                  * Check here to see whether the zoned device information
3473                  * page is supported.  If so, continue on to request it.
3474                  * If not, skip to DA_STATE_PROBE_LOG or done.
3475                  */
3476                 if ((softc->flags & DA_FLAG_CAN_ATA_ZONE) == 0) {
3477                         daprobedone(periph, start_ccb);
3478                         break;
3479                 }
3480                 ata_zone = malloc(sizeof(*ata_zone), M_SCSIDA,
3481                                   M_NOWAIT|M_ZERO);
3482                 if (ata_zone == NULL) {
3483                         xpt_print(periph->path, "Couldn't malloc ata_zone "
3484                             "data\n");
3485                         daprobedone(periph, start_ccb);
3486                         break;
3487                 }
3488
3489                 retval = scsi_ata_read_log(&start_ccb->csio,
3490                     /*retries*/ da_retry_count,
3491                     /*cbfcnp*/ dadone,
3492                     /*tag_action*/ MSG_SIMPLE_Q_TAG,
3493                     /*log_address*/ ATA_IDENTIFY_DATA_LOG,
3494                     /*page_number*/ ATA_IDL_ZDI,
3495                     /*block_count*/ 1,
3496                     /*protocol*/ softc->flags & DA_FLAG_CAN_ATA_DMA ?
3497                                  AP_PROTO_DMA : AP_PROTO_PIO_IN,
3498                     /*data_ptr*/ (uint8_t *)ata_zone,
3499                     /*dxfer_len*/ sizeof(*ata_zone),
3500                     /*sense_len*/ SSD_FULL_SIZE,
3501                     /*timeout*/ da_default_timeout * 1000);
3502
3503                 if (retval != 0) {
3504                         xpt_print(periph->path, "scsi_ata_read_log() failed!");
3505                         free(ata_zone, M_SCSIDA);
3506                         daprobedone(periph, start_ccb);
3507                         break;
3508                 }
3509                 start_ccb->ccb_h.ccb_bp = NULL;
3510                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA_ZONE;
3511                 xpt_action(start_ccb);
3512
3513                 break;
3514         }
3515         case DA_STATE_PROBE_ZONE:
3516         {
3517                 struct scsi_vpd_zoned_bdc *bdc;
3518
3519                 /*
3520                  * Note that this page will be supported for SCSI protocol
3521                  * devices that support ZBC (SMR devices), as well as ATA
3522                  * protocol devices that are behind a SAT (SCSI to ATA
3523                  * Translation) layer that supports converting ZBC commands
3524                  * to their ZAC equivalents.
3525                  */
3526                 if (!scsi_vpd_supported_page(periph, SVPD_ZONED_BDC)) {
3527                         daprobedone(periph, start_ccb);
3528                         break;
3529                 }
3530                 bdc = (struct scsi_vpd_zoned_bdc *)
3531                         malloc(sizeof(*bdc), M_SCSIDA, M_NOWAIT|M_ZERO);
3532
3533                 if (bdc == NULL) {
3534                         xpt_release_ccb(start_ccb);
3535                         xpt_print(periph->path, "Couldn't malloc zone VPD "
3536                             "data\n");
3537                         break;
3538                 }
3539                 scsi_inquiry(&start_ccb->csio,
3540                              /*retries*/da_retry_count,
3541                              /*cbfcnp*/dadone,
3542                              /*tag_action*/MSG_SIMPLE_Q_TAG,
3543                              /*inq_buf*/(u_int8_t *)bdc,
3544                              /*inq_len*/sizeof(*bdc),
3545                              /*evpd*/TRUE,
3546                              /*page_code*/SVPD_ZONED_BDC,
3547                              /*sense_len*/SSD_FULL_SIZE,
3548                              /*timeout*/da_default_timeout * 1000);
3549                 start_ccb->ccb_h.ccb_bp = NULL;
3550                 start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ZONE;
3551                 xpt_action(start_ccb);
3552                 break;
3553         }
3554         }
3555 }
3556
3557 /*
3558  * In each of the methods below, while its the caller's
3559  * responsibility to ensure the request will fit into a
3560  * single device request, we might have changed the delete
3561  * method due to the device incorrectly advertising either
3562  * its supported methods or limits.
3563  *
3564  * To prevent this causing further issues we validate the
3565  * against the methods limits, and warn which would
3566  * otherwise be unnecessary.
3567  */
3568 static void
3569 da_delete_unmap(struct cam_periph *periph, union ccb *ccb, struct bio *bp)
3570 {
3571         struct da_softc *softc = (struct da_softc *)periph->softc;;
3572         struct bio *bp1;
3573         uint8_t *buf = softc->unmap_buf;
3574         struct scsi_unmap_desc *d = (void *)&buf[UNMAP_HEAD_SIZE];
3575         uint64_t lba, lastlba = (uint64_t)-1;
3576         uint64_t totalcount = 0;
3577         uint64_t count;
3578         uint32_t c, lastcount = 0, ranges = 0;
3579
3580         /*
3581          * Currently this doesn't take the UNMAP
3582          * Granularity and Granularity Alignment
3583          * fields into account.
3584          *
3585          * This could result in both unoptimal unmap
3586          * requests as as well as UNMAP calls unmapping
3587          * fewer LBA's than requested.
3588          */
3589
3590         bzero(softc->unmap_buf, sizeof(softc->unmap_buf));
3591         bp1 = bp;
3592         do {
3593                 /*
3594                  * Note: ada and da are different in how they store the
3595                  * pending bp's in a trim. ada stores all of them in the
3596                  * trim_req.bps. da stores all but the first one in the
3597                  * delete_run_queue. ada then completes all the bps in
3598                  * its adadone() loop. da completes all the bps in the
3599                  * delete_run_queue in dadone, and relies on the biodone
3600                  * after to complete. This should be reconciled since there's
3601                  * no real reason to do it differently. XXX
3602                  */
3603                 if (bp1 != bp)
3604                         bioq_insert_tail(&softc->delete_run_queue, bp1);
3605                 lba = bp1->bio_pblkno;
3606                 count = bp1->bio_bcount / softc->params.secsize;
3607
3608                 /* Try to extend the previous range. */
3609                 if (lba == lastlba) {
3610                         c = omin(count, UNMAP_RANGE_MAX - lastcount);
3611                         lastlba += c;
3612                         lastcount += c;
3613                         scsi_ulto4b(lastcount, d[ranges - 1].length);
3614                         count -= c;
3615                         lba += c;
3616                         totalcount += c;
3617                 } else if ((softc->quirks & DA_Q_STRICT_UNMAP) &&
3618                     softc->unmap_gran != 0) {
3619                         /* Align length of the previous range. */
3620                         if ((c = lastcount % softc->unmap_gran) != 0) {
3621                                 if (lastcount <= c) {
3622                                         totalcount -= lastcount;
3623                                         lastlba = (uint64_t)-1;
3624                                         lastcount = 0;
3625                                         ranges--;
3626                                 } else {
3627                                         totalcount -= c;
3628                                         lastlba -= c;
3629                                         lastcount -= c;
3630                                         scsi_ulto4b(lastcount, d[ranges - 1].length);
3631                                 }
3632                         }
3633                         /* Align beginning of the new range. */
3634                         c = (lba - softc->unmap_gran_align) % softc->unmap_gran;
3635                         if (c != 0) {
3636                                 c = softc->unmap_gran - c;
3637                                 if (count <= c) {
3638                                         count = 0;
3639                                 } else {
3640                                         lba += c;
3641                                         count -= c;
3642                                 }
3643                         }
3644                 }
3645
3646                 while (count > 0) {
3647                         c = omin(count, UNMAP_RANGE_MAX);
3648                         if (totalcount + c > softc->unmap_max_lba ||
3649                             ranges >= softc->unmap_max_ranges) {
3650                                 xpt_print(periph->path,
3651                                     "%s issuing short delete %ld > %ld"
3652                                     "|| %d >= %d",
3653                                     da_delete_method_desc[softc->delete_method],
3654                                     totalcount + c, softc->unmap_max_lba,
3655                                     ranges, softc->unmap_max_ranges);
3656                                 break;
3657                         }
3658                         scsi_u64to8b(lba, d[ranges].lba);
3659                         scsi_ulto4b(c, d[ranges].length);
3660                         lba += c;
3661                         totalcount += c;
3662                         ranges++;
3663                         count -= c;
3664                         lastlba = lba;
3665                         lastcount = c;
3666                 }
3667                 bp1 = cam_iosched_next_trim(softc->cam_iosched);
3668                 if (bp1 == NULL)
3669                         break;
3670                 if (ranges >= softc->unmap_max_ranges ||
3671                     totalcount + bp1->bio_bcount /
3672                     softc->params.secsize > softc->unmap_max_lba) {
3673                         cam_iosched_put_back_trim(softc->cam_iosched, bp1);
3674                         break;
3675                 }
3676         } while (1);
3677
3678         /* Align length of the last range. */
3679         if ((softc->quirks & DA_Q_STRICT_UNMAP) && softc->unmap_gran != 0 &&
3680             (c = lastcount % softc->unmap_gran) != 0) {
3681                 if (lastcount <= c)
3682                         ranges--;
3683                 else
3684                         scsi_ulto4b(lastcount - c, d[ranges - 1].length);
3685         }
3686
3687         scsi_ulto2b(ranges * 16 + 6, &buf[0]);
3688         scsi_ulto2b(ranges * 16, &buf[2]);
3689
3690         scsi_unmap(&ccb->csio,
3691                    /*retries*/da_retry_count,
3692                    /*cbfcnp*/dadone,
3693                    /*tag_action*/MSG_SIMPLE_Q_TAG,
3694                    /*byte2*/0,
3695                    /*data_ptr*/ buf,
3696                    /*dxfer_len*/ ranges * 16 + 8,
3697                    /*sense_len*/SSD_FULL_SIZE,
3698                    da_default_timeout * 1000);
3699         ccb->ccb_h.ccb_state = DA_CCB_DELETE;
3700         ccb->ccb_h.flags |= CAM_UNLOCKED;
3701         cam_iosched_submit_trim(softc->cam_iosched);
3702 }
3703
3704 static void
3705 da_delete_trim(struct cam_periph *periph, union ccb *ccb, struct bio *bp)
3706 {
3707         struct da_softc *softc = (struct da_softc *)periph->softc;
3708         struct bio *bp1;
3709         uint8_t *buf = softc->unmap_buf;
3710         uint64_t lastlba = (uint64_t)-1;
3711         uint64_t count;
3712         uint64_t lba;
3713         uint32_t lastcount = 0, c, requestcount;
3714         int ranges = 0, off, block_count;
3715
3716         bzero(softc->unmap_buf, sizeof(softc->unmap_buf));
3717         bp1 = bp;
3718         do {
3719                 if (bp1 != bp)//XXX imp XXX
3720                         bioq_insert_tail(&softc->delete_run_queue, bp1);
3721                 lba = bp1->bio_pblkno;
3722                 count = bp1->bio_bcount / softc->params.secsize;
3723                 requestcount = count;
3724
3725                 /* Try to extend the previous range. */
3726                 if (lba == lastlba) {
3727                         c = omin(count, ATA_DSM_RANGE_MAX - lastcount);
3728                         lastcount += c;
3729                         off = (ranges - 1) * 8;
3730                         buf[off + 6] = lastcount & 0xff;
3731                         buf[off + 7] = (lastcount >> 8) & 0xff;
3732                         count -= c;
3733                         lba += c;
3734                 }
3735
3736                 while (count > 0) {
3737                         c = omin(count, ATA_DSM_RANGE_MAX);
3738                         off = ranges * 8;
3739
3740                         buf[off + 0] = lba & 0xff;
3741                         buf[off + 1] = (lba >> 8) & 0xff;
3742                         buf[off + 2] = (lba >> 16) & 0xff;
3743                         buf[off + 3] = (lba >> 24) & 0xff;
3744                         buf[off + 4] = (lba >> 32) & 0xff;
3745                         buf[off + 5] = (lba >> 40) & 0xff;
3746                         buf[off + 6] = c & 0xff;
3747                         buf[off + 7] = (c >> 8) & 0xff;
3748                         lba += c;
3749                         ranges++;
3750                         count -= c;
3751                         lastcount = c;
3752                         if (count != 0 && ranges == softc->trim_max_ranges) {
3753                                 xpt_print(periph->path,
3754                                     "%s issuing short delete %ld > %ld\n",
3755                                     da_delete_method_desc[softc->delete_method],
3756                                     requestcount,
3757                                     (softc->trim_max_ranges - ranges) *
3758                                     ATA_DSM_RANGE_MAX);
3759                                 break;
3760                         }
3761                 }
3762                 lastlba = lba;
3763                 bp1 = cam_iosched_next_trim(softc->cam_iosched);
3764                 if (bp1 == NULL)
3765                         break;
3766                 if (bp1->bio_bcount / softc->params.secsize >
3767                     (softc->trim_max_ranges - ranges) * ATA_DSM_RANGE_MAX) {
3768                         cam_iosched_put_back_trim(softc->cam_iosched, bp1);
3769                         break;
3770                 }
3771         } while (1);
3772
3773         block_count = howmany(ranges, ATA_DSM_BLK_RANGES);
3774         scsi_ata_trim(&ccb->csio,
3775                       /*retries*/da_retry_count,
3776                       /*cbfcnp*/dadone,
3777                       /*tag_action*/MSG_SIMPLE_Q_TAG,
3778                       block_count,
3779                       /*data_ptr*/buf,
3780                       /*dxfer_len*/block_count * ATA_DSM_BLK_SIZE,
3781                       /*sense_len*/SSD_FULL_SIZE,
3782                       da_default_timeout * 1000);
3783         ccb->ccb_h.ccb_state = DA_CCB_DELETE;
3784         ccb->ccb_h.flags |= CAM_UNLOCKED;
3785         cam_iosched_submit_trim(softc->cam_iosched);
3786 }
3787
3788 /*
3789  * We calculate ws_max_blks here based off d_delmaxsize instead
3790  * of using softc->ws_max_blks as it is absolute max for the
3791  * device not the protocol max which may well be lower.
3792  */
3793 static void
3794 da_delete_ws(struct cam_periph *periph, union ccb *ccb, struct bio *bp)
3795 {
3796         struct da_softc *softc;
3797         struct bio *bp1;
3798         uint64_t ws_max_blks;
3799         uint64_t lba;
3800         uint64_t count; /* forward compat with WS32 */
3801
3802         softc = (struct da_softc *)periph->softc;
3803         ws_max_blks = softc->disk->d_delmaxsize / softc->params.secsize;
3804         lba = bp->bio_pblkno;
3805         count = 0;
3806         bp1 = bp;
3807         do {
3808                 if (bp1 != bp)//XXX imp XXX
3809                         bioq_insert_tail(&softc->delete_run_queue, bp1);
3810                 count += bp1->bio_bcount / softc->params.secsize;
3811                 if (count > ws_max_blks) {
3812                         xpt_print(periph->path,
3813                             "%s issuing short delete %ld > %ld\n",
3814                             da_delete_method_desc[softc->delete_method],
3815                             count, ws_max_blks);
3816                         count = omin(count, ws_max_blks);
3817                         break;
3818                 }
3819                 bp1 = cam_iosched_next_trim(softc->cam_iosched);
3820                 if (bp1 == NULL)
3821                         break;
3822                 if (lba + count != bp1->bio_pblkno ||
3823                     count + bp1->bio_bcount /
3824                     softc->params.secsize > ws_max_blks) {
3825                         cam_iosched_put_back_trim(softc->cam_iosched, bp1);
3826                         break;
3827                 }
3828         } while (1);
3829
3830         scsi_write_same(&ccb->csio,
3831                         /*retries*/da_retry_count,
3832                         /*cbfcnp*/dadone,
3833                         /*tag_action*/MSG_SIMPLE_Q_TAG,
3834                         /*byte2*/softc->delete_method ==
3835                             DA_DELETE_ZERO ? 0 : SWS_UNMAP,
3836                         softc->delete_method == DA_DELETE_WS16 ? 16 : 10,
3837                         /*lba*/lba,
3838                         /*block_count*/count,
3839                         /*data_ptr*/ __DECONST(void *, zero_region),
3840                         /*dxfer_len*/ softc->params.secsize,
3841                         /*sense_len*/SSD_FULL_SIZE,
3842                         da_default_timeout * 1000);
3843         ccb->ccb_h.ccb_state = DA_CCB_DELETE;
3844         ccb->ccb_h.flags |= CAM_UNLOCKED;
3845         cam_iosched_submit_trim(softc->cam_iosched);
3846 }
3847
3848 static int
3849 cmd6workaround(union ccb *ccb)
3850 {
3851         struct scsi_rw_6 cmd6;
3852         struct scsi_rw_10 *cmd10;
3853         struct da_softc *softc;
3854         u_int8_t *cdb;
3855         struct bio *bp;
3856         int frozen;
3857
3858         cdb = ccb->csio.cdb_io.cdb_bytes;
3859         softc = (struct da_softc *)xpt_path_periph(ccb->ccb_h.path)->softc;
3860
3861         if (ccb->ccb_h.ccb_state == DA_CCB_DELETE) {
3862                 da_delete_methods old_method = softc->delete_method;
3863
3864                 /*
3865                  * Typically there are two reasons for failure here
3866                  * 1. Delete method was detected as supported but isn't
3867                  * 2. Delete failed due to invalid params e.g. too big
3868                  *
3869                  * While we will attempt to choose an alternative delete method
3870                  * this may result in short deletes if the existing delete
3871                  * requests from geom are big for the new method chosen.
3872                  *
3873                  * This method assumes that the error which triggered this
3874                  * will not retry the io otherwise a panic will occur
3875                  */
3876                 dadeleteflag(softc, old_method, 0);
3877                 dadeletemethodchoose(softc, DA_DELETE_DISABLE);
3878                 if (softc->delete_method == DA_DELETE_DISABLE)
3879                         xpt_print(ccb->ccb_h.path,
3880                                   "%s failed, disabling BIO_DELETE\n",
3881                                   da_delete_method_desc[old_method]);
3882                 else
3883                         xpt_print(ccb->ccb_h.path,
3884                                   "%s failed, switching to %s BIO_DELETE\n",
3885                                   da_delete_method_desc[old_method],
3886                                   da_delete_method_desc[softc->delete_method]);
3887
3888                 while ((bp = bioq_takefirst(&softc->delete_run_queue)) != NULL)
3889                         cam_iosched_queue_work(softc->cam_iosched, bp);
3890                 cam_iosched_queue_work(softc->cam_iosched,
3891                     (struct bio *)ccb->ccb_h.ccb_bp);
3892                 ccb->ccb_h.ccb_bp = NULL;
3893                 return (0);
3894         }
3895
3896         /* Detect unsupported PREVENT ALLOW MEDIUM REMOVAL. */
3897         if ((ccb->ccb_h.flags & CAM_CDB_POINTER) == 0 &&
3898             (*cdb == PREVENT_ALLOW) &&
3899             (softc->quirks & DA_Q_NO_PREVENT) == 0) {
3900                 if (bootverbose)
3901                         xpt_print(ccb->ccb_h.path,
3902                             "PREVENT ALLOW MEDIUM REMOVAL not supported.\n");
3903                 softc->quirks |= DA_Q_NO_PREVENT;
3904                 return (0);
3905         }
3906
3907         /* Detect unsupported SYNCHRONIZE CACHE(10). */
3908         if ((ccb->ccb_h.flags & CAM_CDB_POINTER) == 0 &&
3909             (*cdb == SYNCHRONIZE_CACHE) &&
3910             (softc->quirks & DA_Q_NO_SYNC_CACHE) == 0) {
3911                 if (bootverbose)
3912                         xpt_print(ccb->ccb_h.path,
3913                             "SYNCHRONIZE CACHE(10) not supported.\n");
3914                 softc->quirks |= DA_Q_NO_SYNC_CACHE;
3915                 softc->disk->d_flags &= ~DISKFLAG_CANFLUSHCACHE;
3916                 return (0);
3917         }
3918
3919         /* Translation only possible if CDB is an array and cmd is R/W6 */
3920         if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0 ||
3921             (*cdb != READ_6 && *cdb != WRITE_6))
3922                 return 0;
3923
3924         xpt_print(ccb->ccb_h.path, "READ(6)/WRITE(6) not supported, "
3925             "increasing minimum_cmd_size to 10.\n");
3926         softc->minimum_cmd_size = 10;
3927
3928         bcopy(cdb, &cmd6, sizeof(struct scsi_rw_6));
3929         cmd10 = (struct scsi_rw_10 *)cdb;
3930         cmd10->opcode = (cmd6.opcode == READ_6) ? READ_10 : WRITE_10;
3931         cmd10->byte2 = 0;
3932         scsi_ulto4b(scsi_3btoul(cmd6.addr), cmd10->addr);
3933         cmd10->reserved = 0;
3934         scsi_ulto2b(cmd6.length, cmd10->length);
3935         cmd10->control = cmd6.control;
3936         ccb->csio.cdb_len = sizeof(*cmd10);
3937
3938         /* Requeue request, unfreezing queue if necessary */
3939         frozen = (ccb->ccb_h.status & CAM_DEV_QFRZN) != 0;
3940         ccb->ccb_h.status = CAM_REQUEUE_REQ;
3941         xpt_action(ccb);
3942         if (frozen) {
3943                 cam_release_devq(ccb->ccb_h.path,
3944                                  /*relsim_flags*/0,
3945                                  /*reduction*/0,
3946                                  /*timeout*/0,
3947                                  /*getcount_only*/0);
3948         }
3949         return (ERESTART);
3950 }
3951
3952 static void
3953 dazonedone(struct cam_periph *periph, union ccb *ccb)
3954 {
3955         struct da_softc *softc;
3956         struct bio *bp;
3957
3958         softc = periph->softc;
3959         bp = (struct bio *)ccb->ccb_h.ccb_bp;
3960
3961         switch (bp->bio_zone.zone_cmd) {
3962         case DISK_ZONE_OPEN:
3963         case DISK_ZONE_CLOSE:
3964         case DISK_ZONE_FINISH:
3965         case DISK_ZONE_RWP:
3966                 break;
3967         case DISK_ZONE_REPORT_ZONES: {
3968                 uint32_t avail_len;
3969                 struct disk_zone_report *rep;
3970                 struct scsi_report_zones_hdr *hdr;
3971                 struct scsi_report_zones_desc *desc;
3972                 struct disk_zone_rep_entry *entry;
3973                 uint32_t num_alloced, hdr_len, num_avail;
3974                 uint32_t num_to_fill, i;
3975                 int ata;
3976
3977                 rep = &bp->bio_zone.zone_params.report;
3978                 avail_len = ccb->csio.dxfer_len - ccb->csio.resid;
3979                 /*
3980                  * Note that bio_resid isn't normally used for zone
3981                  * commands, but it is used by devstat_end_transaction_bio()
3982                  * to determine how much data was transferred.  Because
3983                  * the size of the SCSI/ATA data structures is different
3984                  * than the size of the BIO interface structures, the
3985                  * amount of data actually transferred from the drive will
3986                  * be different than the amount of data transferred to
3987                  * the user.
3988                  */
3989                 bp->bio_resid = ccb->csio.resid;
3990                 num_alloced = rep->entries_allocated;
3991                 hdr = (struct scsi_report_zones_hdr *)ccb->csio.data_ptr;
3992                 if (avail_len < sizeof(*hdr)) {
3993                         /*
3994                          * Is there a better error than EIO here?  We asked
3995                          * for at least the header, and we got less than
3996                          * that.
3997                          */
3998                         bp->bio_error = EIO;
3999                         bp->bio_flags |= BIO_ERROR;
4000                         bp->bio_resid = bp->bio_bcount;
4001                         break;
4002                 }
4003
4004                 if (softc->zone_interface == DA_ZONE_IF_ATA_PASS)
4005                         ata = 1;
4006                 else
4007                         ata = 0;
4008
4009                 hdr_len = ata ? le32dec(hdr->length) :
4010                                 scsi_4btoul(hdr->length);
4011                 if (hdr_len > 0)
4012                         rep->entries_available = hdr_len / sizeof(*desc);
4013                 else
4014                         rep->entries_available = 0;
4015                 /*
4016                  * NOTE: using the same values for the BIO version of the
4017                  * same field as the SCSI/ATA values.  This means we could
4018                  * get some additional values that aren't defined in bio.h
4019                  * if more values of the same field are defined later.
4020                  */
4021                 rep->header.same = hdr->byte4 & SRZ_SAME_MASK;
4022                 rep->header.maximum_lba = ata ?  le64dec(hdr->maximum_lba) :
4023                                           scsi_8btou64(hdr->maximum_lba);
4024                 /*
4025                  * If the drive reports no entries that match the query,
4026                  * we're done.
4027                  */
4028                 if (hdr_len == 0) {
4029                         rep->entries_filled = 0;
4030                         break;
4031                 }
4032
4033                 num_avail = min((avail_len - sizeof(*hdr)) / sizeof(*desc),
4034                                 hdr_len / sizeof(*desc));
4035                 /*
4036                  * If the drive didn't return any data, then we're done.
4037                  */
4038                 if (num_avail == 0) {
4039                         rep->entries_filled = 0;
4040                         break;
4041                 }
4042
4043                 num_to_fill = min(num_avail, rep->entries_allocated);
4044                 /*
4045                  * If the user didn't allocate any entries for us to fill,
4046                  * we're done.
4047                  */
4048                 if (num_to_fill == 0) {
4049                         rep->entries_filled = 0;
4050                         break;
4051                 }
4052
4053                 for (i = 0, desc = &hdr->desc_list[0], entry=&rep->entries[0];
4054                      i < num_to_fill; i++, desc++, entry++) {
4055                         /*
4056                          * NOTE: we're mapping the values here directly
4057                          * from the SCSI/ATA bit definitions to the bio.h
4058                          * definitons.  There is also a warning in
4059                          * disk_zone.h, but the impact is that if
4060                          * additional values are added in the SCSI/ATA
4061                          * specs these will be visible to consumers of
4062                          * this interface.
4063                          */
4064                         entry->zone_type = desc->zone_type & SRZ_TYPE_MASK;
4065                         entry->zone_condition =
4066                             (desc->zone_flags & SRZ_ZONE_COND_MASK) >>
4067                             SRZ_ZONE_COND_SHIFT;
4068                         entry->zone_flags |= desc->zone_flags &
4069                             (SRZ_ZONE_NON_SEQ|SRZ_ZONE_RESET);
4070                         entry->zone_length =
4071                             ata ? le64dec(desc->zone_length) :
4072                                   scsi_8btou64(desc->zone_length);
4073                         entry->zone_start_lba =
4074                             ata ? le64dec(desc->zone_start_lba) :
4075                                   scsi_8btou64(desc->zone_start_lba);
4076                         entry->write_pointer_lba =
4077                             ata ? le64dec(desc->write_pointer_lba) :
4078                                   scsi_8btou64(desc->write_pointer_lba);
4079                 }
4080                 rep->entries_filled = num_to_fill;
4081                 break;
4082         }
4083         case DISK_ZONE_GET_PARAMS:
4084         default:
4085                 /*
4086                  * In theory we should not get a GET_PARAMS bio, since it
4087                  * should be handled without queueing the command to the
4088                  * drive.
4089                  */
4090                 panic("%s: Invalid zone command %d", __func__,
4091                     bp->bio_zone.zone_cmd);
4092                 break;
4093         }
4094
4095         if (bp->bio_zone.zone_cmd == DISK_ZONE_REPORT_ZONES)
4096                 free(ccb->csio.data_ptr, M_SCSIDA);
4097 }
4098
4099 static void
4100 dadone(struct cam_periph *periph, union ccb *done_ccb)
4101 {
4102         struct da_softc *softc;
4103         struct ccb_scsiio *csio;
4104         u_int32_t  priority;
4105         da_ccb_state state;
4106
4107         softc = (struct da_softc *)periph->softc;
4108         priority = done_ccb->ccb_h.pinfo.priority;
4109
4110         CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone\n"));
4111
4112         csio = &done_ccb->csio;
4113 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
4114         if (csio->bio != NULL)
4115                 biotrack(csio->bio, __func__);
4116 #endif
4117         state = csio->ccb_h.ccb_state & DA_CCB_TYPE_MASK;
4118         switch (state) {
4119         case DA_CCB_BUFFER_IO:
4120         case DA_CCB_DELETE:
4121         {
4122                 struct bio *bp, *bp1;
4123
4124                 cam_periph_lock(periph);
4125                 bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
4126                 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4127                         int error;
4128                         int sf;
4129
4130                         if ((csio->ccb_h.ccb_state & DA_CCB_RETRY_UA) != 0)
4131                                 sf = SF_RETRY_UA;
4132                         else
4133                                 sf = 0;
4134
4135                         error = daerror(done_ccb, CAM_RETRY_SELTO, sf);
4136                         if (error == ERESTART) {
4137                                 /*
4138                                  * A retry was scheduled, so
4139                                  * just return.
4140                                  */
4141                                 cam_periph_unlock(periph);
4142                                 return;
4143                         }
4144                         bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
4145                         if (error != 0) {
4146                                 int queued_error;
4147
4148                                 /*
4149                                  * return all queued I/O with EIO, so that
4150                                  * the client can retry these I/Os in the
4151                                  * proper order should it attempt to recover.
4152                                  */
4153                                 queued_error = EIO;
4154
4155                                 if (error == ENXIO
4156                                  && (softc->flags & DA_FLAG_PACK_INVALID)== 0) {
4157                                         /*
4158                                          * Catastrophic error.  Mark our pack as
4159                                          * invalid.
4160                                          */
4161                                         /*
4162                                          * XXX See if this is really a media
4163                                          * XXX change first?
4164                                          */
4165                                         xpt_print(periph->path,
4166                                             "Invalidating pack\n");
4167                                         softc->flags |= DA_FLAG_PACK_INVALID;
4168 #ifdef CAM_IO_STATS
4169                                         softc->invalidations++;
4170 #endif
4171                                         queued_error = ENXIO;
4172                                 }
4173                                 cam_iosched_flush(softc->cam_iosched, NULL,
4174                                            queued_error);
4175                                 if (bp != NULL) {
4176                                         bp->bio_error = error;
4177                                         bp->bio_resid = bp->bio_bcount;
4178                                         bp->bio_flags |= BIO_ERROR;
4179                                 }
4180                         } else if (bp != NULL) {
4181                                 if (state == DA_CCB_DELETE)
4182                                         bp->bio_resid = 0;
4183                                 else
4184                                         bp->bio_resid = csio->resid;
4185                                 bp->bio_error = 0;
4186                                 if (bp->bio_resid != 0)
4187                                         bp->bio_flags |= BIO_ERROR;
4188                         }
4189                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
4190                                 cam_release_devq(done_ccb->ccb_h.path,
4191                                                  /*relsim_flags*/0,
4192                                                  /*reduction*/0,
4193                                                  /*timeout*/0,
4194                                                  /*getcount_only*/0);
4195                 } else if (bp != NULL) {
4196                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
4197                                 panic("REQ_CMP with QFRZN");
4198                         if (bp->bio_cmd == BIO_ZONE)
4199                                 dazonedone(periph, done_ccb);
4200                         else if (state == DA_CCB_DELETE)
4201                                 bp->bio_resid = 0;
4202                         else
4203                                 bp->bio_resid = csio->resid;
4204                         if ((csio->resid > 0)
4205                          && (bp->bio_cmd != BIO_ZONE))
4206                                 bp->bio_flags |= BIO_ERROR;
4207                         if (softc->error_inject != 0) {
4208                                 bp->bio_error = softc->error_inject;
4209                                 bp->bio_resid = bp->bio_bcount;
4210                                 bp->bio_flags |= BIO_ERROR;
4211                                 softc->error_inject = 0;
4212                         }
4213                 }
4214
4215                 if (bp != NULL)
4216                         biotrack(bp, __func__);
4217                 LIST_REMOVE(&done_ccb->ccb_h, periph_links.le);
4218                 if (LIST_EMPTY(&softc->pending_ccbs))
4219                         softc->flags |= DA_FLAG_WAS_OTAG;
4220
4221                 /*
4222                  * We need to call cam_iosched before we call biodone so that we
4223                  * don't measure any activity that happens in the completion
4224                  * routine, which in the case of sendfile can be quite
4225                  * extensive.
4226                  */
4227                 cam_iosched_bio_complete(softc->cam_iosched, bp, done_ccb);
4228                 xpt_release_ccb(done_ccb);
4229                 if (state == DA_CCB_DELETE) {
4230                         TAILQ_HEAD(, bio) queue;
4231
4232                         TAILQ_INIT(&queue);
4233                         TAILQ_CONCAT(&queue, &softc->delete_run_queue.queue, bio_queue);
4234                         softc->delete_run_queue.insert_point = NULL;
4235                         /*
4236                          * Normally, the xpt_release_ccb() above would make sure
4237                          * that when we have more work to do, that work would
4238                          * get kicked off. However, we specifically keep
4239                          * delete_running set to 0 before the call above to
4240                          * allow other I/O to progress when many BIO_DELETE
4241                          * requests are pushed down. We set delete_running to 0
4242                          * and call daschedule again so that we don't stall if
4243                          * there are no other I/Os pending apart from BIO_DELETEs.
4244                          */
4245                         cam_iosched_trim_done(softc->cam_iosched);
4246                         daschedule(periph);
4247                         cam_periph_unlock(periph);
4248                         while ((bp1 = TAILQ_FIRST(&queue)) != NULL) {
4249                                 TAILQ_REMOVE(&queue, bp1, bio_queue);
4250                                 bp1->bio_error = bp->bio_error;
4251                                 if (bp->bio_flags & BIO_ERROR) {
4252                                         bp1->bio_flags |= BIO_ERROR;
4253                                         bp1->bio_resid = bp1->bio_bcount;
4254                                 } else
4255                                         bp1->bio_resid = 0;
4256                                 biodone(bp1);
4257                         }
4258                 } else {
4259                         daschedule(periph);
4260                         cam_periph_unlock(periph);
4261                 }
4262                 if (bp != NULL)
4263                         biodone(bp);
4264                 return;
4265         }
4266         case DA_CCB_PROBE_RC:
4267         case DA_CCB_PROBE_RC16:
4268         {
4269                 struct     scsi_read_capacity_data *rdcap;
4270                 struct     scsi_read_capacity_data_long *rcaplong;
4271                 char       *announce_buf;
4272                 int        lbp;
4273
4274                 lbp = 0;
4275                 rdcap = NULL;
4276                 rcaplong = NULL;
4277                 /* XXX TODO: can this be a malloc? */
4278                 announce_buf = softc->announce_temp;
4279                 bzero(announce_buf, DA_ANNOUNCETMP_SZ);
4280
4281                 if (state == DA_CCB_PROBE_RC)
4282                         rdcap =(struct scsi_read_capacity_data *)csio->data_ptr;
4283                 else
4284                         rcaplong = (struct scsi_read_capacity_data_long *)
4285                                 csio->data_ptr;
4286
4287                 if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4288                         struct disk_params *dp;
4289                         uint32_t block_size;
4290                         uint64_t maxsector;
4291                         u_int lalba;    /* Lowest aligned LBA. */
4292
4293                         if (state == DA_CCB_PROBE_RC) {
4294                                 block_size = scsi_4btoul(rdcap->length);
4295                                 maxsector = scsi_4btoul(rdcap->addr);
4296                                 lalba = 0;
4297
4298                                 /*
4299                                  * According to SBC-2, if the standard 10
4300                                  * byte READ CAPACITY command returns 2^32,
4301                                  * we should issue the 16 byte version of
4302                                  * the command, since the device in question
4303                                  * has more sectors than can be represented
4304                                  * with the short version of the command.
4305                                  */
4306                                 if (maxsector == 0xffffffff) {
4307                                         free(rdcap, M_SCSIDA);
4308                                         xpt_release_ccb(done_ccb);
4309                                         softc->state = DA_STATE_PROBE_RC16;
4310                                         xpt_schedule(periph, priority);
4311                                         return;
4312                                 }
4313                         } else {
4314                                 block_size = scsi_4btoul(rcaplong->length);
4315                                 maxsector = scsi_8btou64(rcaplong->addr);
4316                                 lalba = scsi_2btoul(rcaplong->lalba_lbp);
4317                         }
4318
4319                         /*
4320                          * Because GEOM code just will panic us if we
4321                          * give them an 'illegal' value we'll avoid that
4322                          * here.
4323                          */
4324                         if (block_size == 0) {
4325                                 block_size = 512;
4326                                 if (maxsector == 0)
4327                                         maxsector = -1;
4328                         }
4329                         if (block_size >= MAXPHYS) {
4330                                 xpt_print(periph->path,
4331                                     "unsupportable block size %ju\n",
4332                                     (uintmax_t) block_size);
4333                                 announce_buf = NULL;
4334                                 cam_periph_invalidate(periph);
4335                         } else {
4336                                 /*
4337                                  * We pass rcaplong into dasetgeom(),
4338                                  * because it will only use it if it is
4339                                  * non-NULL.
4340                                  */
4341                                 dasetgeom(periph, block_size, maxsector,
4342                                           rcaplong, sizeof(*rcaplong));
4343                                 lbp = (lalba & SRC16_LBPME_A);
4344                                 dp = &softc->params;
4345                                 snprintf(announce_buf, DA_ANNOUNCETMP_SZ,
4346                                     "%juMB (%ju %u byte sectors)",
4347                                     ((uintmax_t)dp->secsize * dp->sectors) /
4348                                      (1024 * 1024),
4349                                     (uintmax_t)dp->sectors, dp->secsize);
4350                         }
4351                 } else {
4352                         int     error;
4353
4354                         /*
4355                          * Retry any UNIT ATTENTION type errors.  They
4356                          * are expected at boot.
4357                          */
4358                         error = daerror(done_ccb, CAM_RETRY_SELTO,
4359                                         SF_RETRY_UA|SF_NO_PRINT);
4360                         if (error == ERESTART) {
4361                                 /*
4362                                  * A retry was scheuled, so
4363                                  * just return.
4364                                  */
4365                                 return;
4366                         } else if (error != 0) {
4367                                 int asc, ascq;
4368                                 int sense_key, error_code;
4369                                 int have_sense;
4370                                 cam_status status;
4371                                 struct ccb_getdev cgd;
4372
4373                                 /* Don't wedge this device's queue */
4374                                 status = done_ccb->ccb_h.status;
4375                                 if ((status & CAM_DEV_QFRZN) != 0)
4376                                         cam_release_devq(done_ccb->ccb_h.path,
4377                                                          /*relsim_flags*/0,
4378                                                          /*reduction*/0,
4379                                                          /*timeout*/0,
4380                                                          /*getcount_only*/0);
4381
4382
4383                                 xpt_setup_ccb(&cgd.ccb_h,
4384                                               done_ccb->ccb_h.path,
4385                                               CAM_PRIORITY_NORMAL);
4386                                 cgd.ccb_h.func_code = XPT_GDEV_TYPE;
4387                                 xpt_action((union ccb *)&cgd);
4388
4389                                 if (scsi_extract_sense_ccb(done_ccb,
4390                                     &error_code, &sense_key, &asc, &ascq))
4391                                         have_sense = TRUE;
4392                                 else
4393                                         have_sense = FALSE;
4394
4395                                 /*
4396                                  * If we tried READ CAPACITY(16) and failed,
4397                                  * fallback to READ CAPACITY(10).
4398                                  */
4399                                 if ((state == DA_CCB_PROBE_RC16) &&
4400                                     (softc->flags & DA_FLAG_CAN_RC16) &&
4401                                     (((csio->ccb_h.status & CAM_STATUS_MASK) ==
4402                                         CAM_REQ_INVALID) ||
4403                                      ((have_sense) &&
4404                                       (error_code == SSD_CURRENT_ERROR) &&
4405                                       (sense_key == SSD_KEY_ILLEGAL_REQUEST)))) {
4406                                         softc->flags &= ~DA_FLAG_CAN_RC16;
4407                                         free(rdcap, M_SCSIDA);
4408                                         xpt_release_ccb(done_ccb);
4409                                         softc->state = DA_STATE_PROBE_RC;
4410                                         xpt_schedule(periph, priority);
4411                                         return;
4412                                 }
4413
4414                                 /*
4415                                  * Attach to anything that claims to be a
4416                                  * direct access or optical disk device,
4417                                  * as long as it doesn't return a "Logical
4418                                  * unit not supported" (0x25) error.
4419                                  * "Internal Target Failure" (0x44) is also
4420                                  * special and typically means that the
4421                                  * device is a SATA drive behind a SATL
4422                                  * translation that's fallen into a
4423                                  * terminally fatal state.
4424                                  */
4425                                 if ((have_sense)
4426                                  && (asc != 0x25) && (asc != 0x44)
4427                                  && (error_code == SSD_CURRENT_ERROR)) {
4428                                         const char *sense_key_desc;
4429                                         const char *asc_desc;
4430
4431                                         dasetgeom(periph, 512, -1, NULL, 0);
4432                                         scsi_sense_desc(sense_key, asc, ascq,
4433                                                         &cgd.inq_data,
4434                                                         &sense_key_desc,
4435                                                         &asc_desc);
4436                                         snprintf(announce_buf,
4437                                             DA_ANNOUNCETMP_SZ,
4438                                             "Attempt to query device "
4439                                             "size failed: %s, %s",
4440                                             sense_key_desc, asc_desc);
4441                                 } else {
4442                                         if (have_sense)
4443                                                 scsi_sense_print(
4444                                                         &done_ccb->csio);
4445                                         else {
4446                                                 xpt_print(periph->path,
4447                                                     "got CAM status %#x\n",
4448                                                     done_ccb->ccb_h.status);
4449                                         }
4450
4451                                         xpt_print(periph->path, "fatal error, "
4452                                             "failed to attach to device\n");
4453
4454                                         announce_buf = NULL;
4455
4456                                         /*
4457                                          * Free up resources.
4458                                          */
4459                                         cam_periph_invalidate(periph);
4460                                 }
4461                         }
4462                 }
4463                 free(csio->data_ptr, M_SCSIDA);
4464                 if (announce_buf != NULL &&
4465                     ((softc->flags & DA_FLAG_ANNOUNCED) == 0)) {
4466                         struct sbuf sb;
4467
4468                         sbuf_new(&sb, softc->announcebuf, DA_ANNOUNCE_SZ,
4469                             SBUF_FIXEDLEN);
4470                         xpt_announce_periph_sbuf(periph, &sb, announce_buf);
4471                         xpt_announce_quirks_sbuf(periph, &sb, softc->quirks,
4472                             DA_Q_BIT_STRING);
4473                         sbuf_finish(&sb);
4474                         sbuf_putbuf(&sb);
4475
4476                         /*
4477                          * Create our sysctl variables, now that we know
4478                          * we have successfully attached.
4479                          */
4480                         /* increase the refcount */
4481                         if (cam_periph_acquire(periph) == CAM_REQ_CMP) {
4482
4483                                 taskqueue_enqueue(taskqueue_thread,
4484                                                   &softc->sysctl_task);
4485                         } else {
4486                                 /* XXX This message is useless! */
4487                                 xpt_print(periph->path, "fatal error, "
4488                                     "could not acquire reference count\n");
4489                         }
4490                 }
4491
4492                 /* We already probed the device. */
4493                 if (softc->flags & DA_FLAG_PROBED) {
4494                         daprobedone(periph, done_ccb);
4495                         return;
4496                 }
4497
4498                 /* Ensure re-probe doesn't see old delete. */
4499                 softc->delete_available = 0;
4500                 dadeleteflag(softc, DA_DELETE_ZERO, 1);
4501                 if (lbp && (softc->quirks & DA_Q_NO_UNMAP) == 0) {
4502                         /*
4503                          * Based on older SBC-3 spec revisions
4504                          * any of the UNMAP methods "may" be
4505                          * available via LBP given this flag so
4506                          * we flag all of them as available and
4507                          * then remove those which further
4508                          * probes confirm aren't available
4509                          * later.
4510                          *
4511                          * We could also check readcap(16) p_type
4512                          * flag to exclude one or more invalid
4513                          * write same (X) types here
4514                          */
4515                         dadeleteflag(softc, DA_DELETE_WS16, 1);
4516                         dadeleteflag(softc, DA_DELETE_WS10, 1);
4517                         dadeleteflag(softc, DA_DELETE_UNMAP, 1);
4518
4519                         xpt_release_ccb(done_ccb);
4520                         softc->state = DA_STATE_PROBE_LBP;
4521                         xpt_schedule(periph, priority);
4522                         return;
4523                 }
4524
4525                 xpt_release_ccb(done_ccb);
4526                 softc->state = DA_STATE_PROBE_BDC;
4527                 xpt_schedule(periph, priority);
4528                 return;
4529         }
4530         case DA_CCB_PROBE_LBP:
4531         {
4532                 struct scsi_vpd_logical_block_prov *lbp;
4533
4534                 lbp = (struct scsi_vpd_logical_block_prov *)csio->data_ptr;
4535
4536                 if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4537                         /*
4538                          * T10/1799-D Revision 31 states at least one of these
4539                          * must be supported but we don't currently enforce this.
4540                          */
4541                         dadeleteflag(softc, DA_DELETE_WS16,
4542                                      (lbp->flags & SVPD_LBP_WS16));
4543                         dadeleteflag(softc, DA_DELETE_WS10,
4544                                      (lbp->flags & SVPD_LBP_WS10));
4545                         dadeleteflag(softc, DA_DELETE_UNMAP,
4546                                      (lbp->flags & SVPD_LBP_UNMAP));
4547                 } else {
4548                         int error;
4549                         error = daerror(done_ccb, CAM_RETRY_SELTO,
4550                                         SF_RETRY_UA|SF_NO_PRINT);
4551                         if (error == ERESTART)
4552                                 return;
4553                         else if (error != 0) {
4554                                 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
4555                                         /* Don't wedge this device's queue */
4556                                         cam_release_devq(done_ccb->ccb_h.path,
4557                                                          /*relsim_flags*/0,
4558                                                          /*reduction*/0,
4559                                                          /*timeout*/0,
4560                                                          /*getcount_only*/0);
4561                                 }
4562
4563                                 /*
4564                                  * Failure indicates we don't support any SBC-3
4565                                  * delete methods with UNMAP
4566                                  */
4567                         }
4568                 }
4569
4570                 free(lbp, M_SCSIDA);
4571                 xpt_release_ccb(done_ccb);
4572                 softc->state = DA_STATE_PROBE_BLK_LIMITS;
4573                 xpt_schedule(periph, priority);
4574                 return;
4575         }
4576         case DA_CCB_PROBE_BLK_LIMITS:
4577         {
4578                 struct scsi_vpd_block_limits *block_limits;
4579
4580                 block_limits = (struct scsi_vpd_block_limits *)csio->data_ptr;
4581
4582                 if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4583                         uint32_t max_txfer_len = scsi_4btoul(
4584                                 block_limits->max_txfer_len);
4585                         uint32_t max_unmap_lba_cnt = scsi_4btoul(
4586                                 block_limits->max_unmap_lba_cnt);
4587                         uint32_t max_unmap_blk_cnt = scsi_4btoul(
4588                                 block_limits->max_unmap_blk_cnt);
4589                         uint32_t unmap_gran = scsi_4btoul(
4590                                 block_limits->opt_unmap_grain);
4591                         uint32_t unmap_gran_align = scsi_4btoul(
4592                                 block_limits->unmap_grain_align);
4593                         uint64_t ws_max_blks = scsi_8btou64(
4594                                 block_limits->max_write_same_length);
4595
4596                         if (max_txfer_len != 0) {
4597                                 softc->disk->d_maxsize = MIN(softc->maxio,
4598                                     (off_t)max_txfer_len * softc->params.secsize);
4599                         }
4600
4601                         /*
4602                          * We should already support UNMAP but we check lba
4603                          * and block count to be sure
4604                          */
4605                         if (max_unmap_lba_cnt != 0x00L &&
4606                             max_unmap_blk_cnt != 0x00L) {
4607                                 softc->unmap_max_lba = max_unmap_lba_cnt;
4608                                 softc->unmap_max_ranges = min(max_unmap_blk_cnt,
4609                                         UNMAP_MAX_RANGES);
4610                                 if (unmap_gran > 1) {
4611                                         softc->unmap_gran = unmap_gran;
4612                                         if (unmap_gran_align & 0x80000000) {
4613                                                 softc->unmap_gran_align =
4614                                                     unmap_gran_align &
4615                                                     0x7fffffff;
4616                                         }
4617                                 }
4618                         } else {
4619                                 /*
4620                                  * Unexpected UNMAP limits which means the
4621                                  * device doesn't actually support UNMAP
4622                                  */
4623                                 dadeleteflag(softc, DA_DELETE_UNMAP, 0);
4624                         }
4625
4626                         if (ws_max_blks != 0x00L)
4627                                 softc->ws_max_blks = ws_max_blks;
4628                 } else {
4629                         int error;
4630                         error = daerror(done_ccb, CAM_RETRY_SELTO,
4631                                         SF_RETRY_UA|SF_NO_PRINT);
4632                         if (error == ERESTART)
4633                                 return;
4634                         else if (error != 0) {
4635                                 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
4636                                         /* Don't wedge this device's queue */
4637                                         cam_release_devq(done_ccb->ccb_h.path,
4638                                                          /*relsim_flags*/0,
4639                                                          /*reduction*/0,
4640                                                          /*timeout*/0,
4641                                                          /*getcount_only*/0);
4642                                 }
4643
4644                                 /*
4645                                  * Failure here doesn't mean UNMAP is not
4646                                  * supported as this is an optional page.
4647                                  */
4648                                 softc->unmap_max_lba = 1;
4649                                 softc->unmap_max_ranges = 1;
4650                         }
4651                 }
4652
4653                 free(block_limits, M_SCSIDA);
4654                 xpt_release_ccb(done_ccb);
4655                 softc->state = DA_STATE_PROBE_BDC;
4656                 xpt_schedule(periph, priority);
4657                 return;
4658         }
4659         case DA_CCB_PROBE_BDC:
4660         {
4661                 struct scsi_vpd_block_device_characteristics *bdc;
4662
4663                 bdc = (struct scsi_vpd_block_device_characteristics *)
4664                     csio->data_ptr;
4665
4666                 if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4667                         uint32_t valid_len;
4668
4669                         /*
4670                          * Disable queue sorting for non-rotational media
4671                          * by default.
4672                          */
4673                         u_int16_t old_rate = softc->disk->d_rotation_rate;
4674
4675                         valid_len = csio->dxfer_len - csio->resid;
4676                         if (SBDC_IS_PRESENT(bdc, valid_len,
4677                             medium_rotation_rate)) {
4678                                 softc->disk->d_rotation_rate =
4679                                         scsi_2btoul(bdc->medium_rotation_rate);
4680                                 if (softc->disk->d_rotation_rate ==
4681                                     SVPD_BDC_RATE_NON_ROTATING) {
4682                                         cam_iosched_set_sort_queue(
4683                                             softc->cam_iosched, 0);
4684                                         softc->rotating = 0;
4685                                 }
4686                                 if (softc->disk->d_rotation_rate != old_rate) {
4687                                         disk_attr_changed(softc->disk,
4688                                             "GEOM::rotation_rate", M_NOWAIT);
4689                                 }
4690                         }
4691                         if ((SBDC_IS_PRESENT(bdc, valid_len, flags))
4692                          && (softc->zone_mode == DA_ZONE_NONE)) {
4693                                 int ata_proto;
4694
4695                                 if (scsi_vpd_supported_page(periph,
4696                                     SVPD_ATA_INFORMATION))
4697                                         ata_proto = 1;
4698                                 else
4699                                         ata_proto = 0;
4700
4701                                 /*
4702                                  * The Zoned field will only be set for
4703                                  * Drive Managed and Host Aware drives.  If
4704                                  * they are Host Managed, the device type
4705                                  * in the standard INQUIRY data should be
4706                                  * set to T_ZBC_HM (0x14).
4707                                  */
4708                                 if ((bdc->flags & SVPD_ZBC_MASK) ==
4709                                      SVPD_HAW_ZBC) {
4710                                         softc->zone_mode = DA_ZONE_HOST_AWARE;
4711                                         softc->zone_interface = (ata_proto) ?
4712                                            DA_ZONE_IF_ATA_SAT : DA_ZONE_IF_SCSI;
4713                                 } else if ((bdc->flags & SVPD_ZBC_MASK) ==
4714                                      SVPD_DM_ZBC) {
4715                                         softc->zone_mode =DA_ZONE_DRIVE_MANAGED;
4716                                         softc->zone_interface = (ata_proto) ?
4717                                            DA_ZONE_IF_ATA_SAT : DA_ZONE_IF_SCSI;
4718                                 } else if ((bdc->flags & SVPD_ZBC_MASK) !=
4719                                           SVPD_ZBC_NR) {
4720                                         xpt_print(periph->path, "Unknown zoned "
4721                                             "type %#x",
4722                                             bdc->flags & SVPD_ZBC_MASK);
4723                                 }
4724                         }
4725                 } else {
4726                         int error;
4727                         error = daerror(done_ccb, CAM_RETRY_SELTO,
4728                                         SF_RETRY_UA|SF_NO_PRINT);
4729                         if (error == ERESTART)
4730                                 return;
4731                         else if (error != 0) {
4732                                 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
4733                                         /* Don't wedge this device's queue */
4734                                         cam_release_devq(done_ccb->ccb_h.path,
4735                                                          /*relsim_flags*/0,
4736                                                          /*reduction*/0,
4737                                                          /*timeout*/0,
4738                                                          /*getcount_only*/0);
4739                                 }
4740                         }
4741                 }
4742
4743                 free(bdc, M_SCSIDA);
4744                 xpt_release_ccb(done_ccb);
4745                 softc->state = DA_STATE_PROBE_ATA;
4746                 xpt_schedule(periph, priority);
4747                 return;
4748         }
4749         case DA_CCB_PROBE_ATA:
4750         {
4751                 int i;
4752                 struct ata_params *ata_params;
4753                 int continue_probe;
4754                 int error;
4755                 int16_t *ptr;
4756
4757                 ata_params = (struct ata_params *)csio->data_ptr;
4758                 ptr = (uint16_t *)ata_params;
4759                 continue_probe = 0;
4760                 error = 0;
4761
4762                 if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4763                         uint16_t old_rate;
4764
4765                         for (i = 0; i < sizeof(*ata_params) / 2; i++)
4766                                 ptr[i] = le16toh(ptr[i]);
4767                         if (ata_params->support_dsm & ATA_SUPPORT_DSM_TRIM &&
4768                             (softc->quirks & DA_Q_NO_UNMAP) == 0) {
4769                                 dadeleteflag(softc, DA_DELETE_ATA_TRIM, 1);
4770                                 if (ata_params->max_dsm_blocks != 0)
4771                                         softc->trim_max_ranges = min(
4772                                           softc->trim_max_ranges,
4773                                           ata_params->max_dsm_blocks *
4774                                           ATA_DSM_BLK_RANGES);
4775                         }
4776                         /*
4777                          * Disable queue sorting for non-rotational media
4778                          * by default.
4779                          */
4780                         old_rate = softc->disk->d_rotation_rate;
4781                         softc->disk->d_rotation_rate =
4782                             ata_params->media_rotation_rate;
4783                         if (softc->disk->d_rotation_rate ==
4784                             ATA_RATE_NON_ROTATING) {
4785                                 cam_iosched_set_sort_queue(softc->cam_iosched, 0);
4786                                 softc->rotating = 0;
4787                         }
4788                         if (softc->disk->d_rotation_rate != old_rate) {
4789                                 disk_attr_changed(softc->disk,
4790                                     "GEOM::rotation_rate", M_NOWAIT);
4791                         }
4792
4793                         if (ata_params->capabilities1 & ATA_SUPPORT_DMA)
4794                                 softc->flags |= DA_FLAG_CAN_ATA_DMA;
4795
4796                         if (ata_params->support.extension &
4797                             ATA_SUPPORT_GENLOG)
4798                                 softc->flags |= DA_FLAG_CAN_ATA_LOG;
4799
4800                         /*
4801                          * At this point, if we have a SATA host aware drive,
4802                          * we communicate via ATA passthrough unless the
4803                          * SAT layer supports ZBC -> ZAC translation.  In
4804                          * that case,
4805                          */
4806                         /*
4807                          * XXX KDM figure out how to detect a host managed
4808                          * SATA drive.
4809                          */
4810                         if (softc->zone_mode == DA_ZONE_NONE) {
4811                                 /*
4812                                  * Note that we don't override the zone
4813                                  * mode or interface if it has already been
4814                                  * set.  This is because it has either been
4815                                  * set as a quirk, or when we probed the
4816                                  * SCSI Block Device Characteristics page,
4817                                  * the zoned field was set.  The latter
4818                                  * means that the SAT layer supports ZBC to
4819                                  * ZAC translation, and we would prefer to
4820                                  * use that if it is available.
4821                                  */
4822                                 if ((ata_params->support3 &
4823                                     ATA_SUPPORT_ZONE_MASK) ==
4824                                     ATA_SUPPORT_ZONE_HOST_AWARE) {
4825                                         softc->zone_mode = DA_ZONE_HOST_AWARE;
4826                                         softc->zone_interface =
4827                                             DA_ZONE_IF_ATA_PASS;
4828                                 } else if ((ata_params->support3 &
4829                                             ATA_SUPPORT_ZONE_MASK) ==
4830                                             ATA_SUPPORT_ZONE_DEV_MANAGED) {
4831                                         softc->zone_mode =DA_ZONE_DRIVE_MANAGED;
4832                                         softc->zone_interface =
4833                                             DA_ZONE_IF_ATA_PASS;
4834                                 }
4835                         }
4836
4837                 } else {
4838                         error = daerror(done_ccb, CAM_RETRY_SELTO,
4839                                         SF_RETRY_UA|SF_NO_PRINT);
4840                         if (error == ERESTART)
4841                                 return;
4842                         else if (error != 0) {
4843                                 if ((done_ccb->ccb_h.status &
4844                                      CAM_DEV_QFRZN) != 0) {
4845                                         /* Don't wedge this device's queue */
4846                                         cam_release_devq(done_ccb->ccb_h.path,
4847                                                          /*relsim_flags*/0,
4848                                                          /*reduction*/0,
4849                                                          /*timeout*/0,
4850                                                          /*getcount_only*/0);
4851                                 }
4852                         }
4853                 }
4854
4855                 free(ata_params, M_SCSIDA);
4856                 if ((softc->zone_mode == DA_ZONE_HOST_AWARE)
4857                  || (softc->zone_mode == DA_ZONE_HOST_MANAGED)) {
4858                         /*
4859                          * If the ATA IDENTIFY failed, we could be talking
4860                          * to a SCSI drive, although that seems unlikely,
4861                          * since the drive did report that it supported the
4862                          * ATA Information VPD page.  If the ATA IDENTIFY
4863                          * succeeded, and the SAT layer doesn't support
4864                          * ZBC -> ZAC translation, continue on to get the
4865                          * directory of ATA logs, and complete the rest of
4866                          * the ZAC probe.  If the SAT layer does support
4867                          * ZBC -> ZAC translation, we want to use that,
4868                          * and we'll probe the SCSI Zoned Block Device
4869                          * Characteristics VPD page next.
4870                          */
4871                         if ((error == 0)
4872                          && (softc->flags & DA_FLAG_CAN_ATA_LOG)
4873                          && (softc->zone_interface == DA_ZONE_IF_ATA_PASS))
4874                                 softc->state = DA_STATE_PROBE_ATA_LOGDIR;
4875                         else
4876                                 softc->state = DA_STATE_PROBE_ZONE;
4877                         continue_probe = 1;
4878                 }
4879                 if (continue_probe != 0) {
4880                         xpt_release_ccb(done_ccb);
4881                         xpt_schedule(periph, priority);
4882                         return;
4883                 } else
4884                         daprobedone(periph, done_ccb);
4885                 return;
4886         }
4887         case DA_CCB_PROBE_ATA_LOGDIR:
4888         {
4889                 int error;
4890
4891                 if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4892                         error = 0;
4893                         softc->valid_logdir_len = 0;
4894                         bzero(&softc->ata_logdir, sizeof(softc->ata_logdir));
4895                         softc->valid_logdir_len =
4896                                 csio->dxfer_len - csio->resid;
4897                         if (softc->valid_logdir_len > 0)
4898                                 bcopy(csio->data_ptr, &softc->ata_logdir,
4899                                     min(softc->valid_logdir_len,
4900                                         sizeof(softc->ata_logdir)));
4901                         /*
4902                          * Figure out whether the Identify Device log is
4903                          * supported.  The General Purpose log directory
4904                          * has a header, and lists the number of pages
4905                          * available for each GP log identified by the
4906                          * offset into the list.
4907                          */
4908                         if ((softc->valid_logdir_len >=
4909                             ((ATA_IDENTIFY_DATA_LOG + 1) * sizeof(uint16_t)))
4910                          && (le16dec(softc->ata_logdir.header) ==
4911                              ATA_GP_LOG_DIR_VERSION)
4912                          && (le16dec(&softc->ata_logdir.num_pages[
4913                              (ATA_IDENTIFY_DATA_LOG *
4914                              sizeof(uint16_t)) - sizeof(uint16_t)]) > 0)){
4915                                 softc->flags |= DA_FLAG_CAN_ATA_IDLOG;
4916                         } else {
4917                                 softc->flags &= ~DA_FLAG_CAN_ATA_IDLOG;
4918                         }
4919                 } else {
4920                         error = daerror(done_ccb, CAM_RETRY_SELTO,
4921                                         SF_RETRY_UA|SF_NO_PRINT);
4922                         if (error == ERESTART)
4923                                 return;
4924                         else if (error != 0) {
4925                                 /*
4926                                  * If we can't get the ATA log directory,
4927                                  * then ATA logs are effectively not
4928                                  * supported even if the bit is set in the
4929                                  * identify data.
4930                                  */
4931                                 softc->flags &= ~(DA_FLAG_CAN_ATA_LOG |
4932                                                   DA_FLAG_CAN_ATA_IDLOG);
4933                                 if ((done_ccb->ccb_h.status &
4934                                      CAM_DEV_QFRZN) != 0) {
4935                                         /* Don't wedge this device's queue */
4936                                         cam_release_devq(done_ccb->ccb_h.path,
4937                                                          /*relsim_flags*/0,
4938                                                          /*reduction*/0,
4939                                                          /*timeout*/0,
4940                                                          /*getcount_only*/0);
4941                                 }
4942                         }
4943                 }
4944
4945                 free(csio->data_ptr, M_SCSIDA);
4946
4947                 if ((error == 0)
4948                  && (softc->flags & DA_FLAG_CAN_ATA_IDLOG)) {
4949                         softc->state = DA_STATE_PROBE_ATA_IDDIR;
4950                         xpt_release_ccb(done_ccb);
4951                         xpt_schedule(periph, priority);
4952                         return;
4953                 }
4954                 daprobedone(periph, done_ccb);
4955                 return;
4956         }
4957         case DA_CCB_PROBE_ATA_IDDIR:
4958         {
4959                 int error;
4960
4961                 if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4962                         off_t entries_offset, max_entries;
4963                         error = 0;
4964
4965                         softc->valid_iddir_len = 0;
4966                         bzero(&softc->ata_iddir, sizeof(softc->ata_iddir));
4967                         softc->flags &= ~(DA_FLAG_CAN_ATA_SUPCAP |
4968                                           DA_FLAG_CAN_ATA_ZONE);
4969                         softc->valid_iddir_len =
4970                                 csio->dxfer_len - csio->resid;
4971                         if (softc->valid_iddir_len > 0)
4972                                 bcopy(csio->data_ptr, &softc->ata_iddir,
4973                                     min(softc->valid_iddir_len,
4974                                         sizeof(softc->ata_iddir)));
4975
4976                         entries_offset =
4977                             __offsetof(struct ata_identify_log_pages,entries);
4978                         max_entries = softc->valid_iddir_len - entries_offset;
4979                         if ((softc->valid_iddir_len > (entries_offset + 1))
4980                          && (le64dec(softc->ata_iddir.header) ==
4981                              ATA_IDLOG_REVISION)
4982                          && (softc->ata_iddir.entry_count > 0)) {
4983                                 int num_entries, i;
4984
4985                                 num_entries = softc->ata_iddir.entry_count;
4986                                 num_entries = min(num_entries,
4987                                    softc->valid_iddir_len - entries_offset);
4988                                 for (i = 0; i < num_entries &&
4989                                      i < max_entries; i++) {
4990                                         if (softc->ata_iddir.entries[i] ==
4991                                             ATA_IDL_SUP_CAP)
4992                                                 softc->flags |=
4993                                                     DA_FLAG_CAN_ATA_SUPCAP;
4994                                         else if (softc->ata_iddir.entries[i]==
4995                                                  ATA_IDL_ZDI)
4996                                                 softc->flags |=
4997                                                     DA_FLAG_CAN_ATA_ZONE;
4998
4999                                         if ((softc->flags &
5000                                              DA_FLAG_CAN_ATA_SUPCAP)
5001                                          && (softc->flags &
5002                                              DA_FLAG_CAN_ATA_ZONE))
5003                                                 break;
5004                                 }
5005                         }
5006                 } else {
5007                         error = daerror(done_ccb, CAM_RETRY_SELTO,
5008                                         SF_RETRY_UA|SF_NO_PRINT);
5009                         if (error == ERESTART)
5010                                 return;
5011                         else if (error != 0) {
5012                                 /*
5013                                  * If we can't get the ATA Identify Data log
5014                                  * directory, then it effectively isn't
5015                                  * supported even if the ATA Log directory
5016                                  * a non-zero number of pages present for
5017                                  * this log.
5018                                  */
5019                                 softc->flags &= ~DA_FLAG_CAN_ATA_IDLOG;
5020                                 if ((done_ccb->ccb_h.status &
5021                                      CAM_DEV_QFRZN) != 0) {
5022                                         /* Don't wedge this device's queue */
5023                                         cam_release_devq(done_ccb->ccb_h.path,
5024                                                          /*relsim_flags*/0,
5025                                                          /*reduction*/0,
5026                                                          /*timeout*/0,
5027                                                          /*getcount_only*/0);
5028                                 }
5029                         }
5030                 }
5031
5032                 free(csio->data_ptr, M_SCSIDA);
5033
5034                 if ((error == 0)
5035                  && (softc->flags & DA_FLAG_CAN_ATA_SUPCAP)) {
5036                         softc->state = DA_STATE_PROBE_ATA_SUP;
5037                         xpt_release_ccb(done_ccb);
5038                         xpt_schedule(periph, priority);
5039                         return;
5040                 }
5041                 daprobedone(periph, done_ccb);
5042                 return;
5043         }
5044         case DA_CCB_PROBE_ATA_SUP:
5045         {
5046                 int error;
5047
5048                 if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5049                         uint32_t valid_len;
5050                         size_t needed_size;
5051                         struct ata_identify_log_sup_cap *sup_cap;
5052                         error = 0;
5053
5054                         sup_cap = (struct ata_identify_log_sup_cap *)
5055                             csio->data_ptr;
5056                         valid_len = csio->dxfer_len - csio->resid;
5057                         needed_size =
5058                             __offsetof(struct ata_identify_log_sup_cap,
5059                             sup_zac_cap) + 1 + sizeof(sup_cap->sup_zac_cap);
5060                         if (valid_len >= needed_size) {
5061                                 uint64_t zoned, zac_cap;
5062
5063                                 zoned = le64dec(sup_cap->zoned_cap);
5064                                 if (zoned & ATA_ZONED_VALID) {
5065                                         /*
5066                                          * This should have already been
5067                                          * set, because this is also in the
5068                                          * ATA identify data.
5069                                          */
5070                                         if ((zoned & ATA_ZONED_MASK) ==
5071                                             ATA_SUPPORT_ZONE_HOST_AWARE)
5072                                                 softc->zone_mode =
5073                                                     DA_ZONE_HOST_AWARE;
5074                                         else if ((zoned & ATA_ZONED_MASK) ==
5075                                             ATA_SUPPORT_ZONE_DEV_MANAGED)
5076                                                 softc->zone_mode =
5077                                                     DA_ZONE_DRIVE_MANAGED;
5078                                 }
5079
5080                                 zac_cap = le64dec(sup_cap->sup_zac_cap);
5081                                 if (zac_cap & ATA_SUP_ZAC_CAP_VALID) {
5082                                         if (zac_cap & ATA_REPORT_ZONES_SUP)
5083                                                 softc->zone_flags |=
5084                                                     DA_ZONE_FLAG_RZ_SUP;
5085                                         if (zac_cap & ATA_ND_OPEN_ZONE_SUP)
5086                                                 softc->zone_flags |=
5087                                                     DA_ZONE_FLAG_OPEN_SUP;
5088                                         if (zac_cap & ATA_ND_CLOSE_ZONE_SUP)
5089                                                 softc->zone_flags |=
5090                                                     DA_ZONE_FLAG_CLOSE_SUP;
5091                                         if (zac_cap & ATA_ND_FINISH_ZONE_SUP)
5092                                                 softc->zone_flags |=
5093                                                     DA_ZONE_FLAG_FINISH_SUP;
5094                                         if (zac_cap & ATA_ND_RWP_SUP)
5095                                                 softc->zone_flags |=
5096                                                     DA_ZONE_FLAG_RWP_SUP;
5097                                 } else {
5098                                         /*
5099                                          * This field was introduced in
5100                                          * ACS-4, r08 on April 28th, 2015.
5101                                          * If the drive firmware was written
5102                                          * to an earlier spec, it won't have
5103                                          * the field.  So, assume all
5104                                          * commands are supported.
5105                                          */
5106                                         softc->zone_flags |=
5107                                             DA_ZONE_FLAG_SUP_MASK;
5108                                 }
5109
5110                         }
5111                 } else {
5112                         error = daerror(done_ccb, CAM_RETRY_SELTO,
5113                                         SF_RETRY_UA|SF_NO_PRINT);
5114                         if (error == ERESTART)
5115                                 return;
5116                         else if (error != 0) {
5117                                 /*
5118                                  * If we can't get the ATA Identify Data
5119                                  * Supported Capabilities page, clear the
5120                                  * flag...
5121                                  */
5122                                 softc->flags &= ~DA_FLAG_CAN_ATA_SUPCAP;
5123                                 /*
5124                                  * And clear zone capabilities.
5125                                  */
5126                                 softc->zone_flags &= ~DA_ZONE_FLAG_SUP_MASK;
5127                                 if ((done_ccb->ccb_h.status &
5128                                      CAM_DEV_QFRZN) != 0) {
5129                                         /* Don't wedge this device's queue */
5130                                         cam_release_devq(done_ccb->ccb_h.path,
5131                                                          /*relsim_flags*/0,
5132                                                          /*reduction*/0,
5133                                                          /*timeout*/0,
5134                                                          /*getcount_only*/0);
5135                                 }
5136                         }
5137                 }
5138
5139                 free(csio->data_ptr, M_SCSIDA);
5140
5141                 if ((error == 0)
5142                  && (softc->flags & DA_FLAG_CAN_ATA_ZONE)) {
5143                         softc->state = DA_STATE_PROBE_ATA_ZONE;
5144                         xpt_release_ccb(done_ccb);
5145                         xpt_schedule(periph, priority);
5146                         return;
5147                 }
5148                 daprobedone(periph, done_ccb);
5149                 return;
5150         }
5151         case DA_CCB_PROBE_ATA_ZONE:
5152         {
5153                 int error;
5154
5155                 if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5156                         struct ata_zoned_info_log *zi_log;
5157                         uint32_t valid_len;
5158                         size_t needed_size;
5159
5160                         zi_log = (struct ata_zoned_info_log *)csio->data_ptr;
5161
5162                         valid_len = csio->dxfer_len - csio->resid;
5163                         needed_size = __offsetof(struct ata_zoned_info_log,
5164                             version_info) + 1 + sizeof(zi_log->version_info);
5165                         if (valid_len >= needed_size) {
5166                                 uint64_t tmpvar;
5167
5168                                 tmpvar = le64dec(zi_log->zoned_cap);
5169                                 if (tmpvar & ATA_ZDI_CAP_VALID) {
5170                                         if (tmpvar & ATA_ZDI_CAP_URSWRZ)
5171                                                 softc->zone_flags |=
5172                                                     DA_ZONE_FLAG_URSWRZ;
5173                                         else
5174                                                 softc->zone_flags &=
5175                                                     ~DA_ZONE_FLAG_URSWRZ;
5176                                 }
5177                                 tmpvar = le64dec(zi_log->optimal_seq_zones);
5178                                 if (tmpvar & ATA_ZDI_OPT_SEQ_VALID) {
5179                                         softc->zone_flags |=
5180                                             DA_ZONE_FLAG_OPT_SEQ_SET;
5181                                         softc->optimal_seq_zones = (tmpvar &
5182                                             ATA_ZDI_OPT_SEQ_MASK);
5183                                 } else {
5184                                         softc->zone_flags &=
5185                                             ~DA_ZONE_FLAG_OPT_SEQ_SET;
5186                                         softc->optimal_seq_zones = 0;
5187                                 }
5188
5189                                 tmpvar =le64dec(zi_log->optimal_nonseq_zones);
5190                                 if (tmpvar & ATA_ZDI_OPT_NS_VALID) {
5191                                         softc->zone_flags |=
5192                                             DA_ZONE_FLAG_OPT_NONSEQ_SET;
5193                                         softc->optimal_nonseq_zones =
5194                                             (tmpvar & ATA_ZDI_OPT_NS_MASK);
5195                                 } else {
5196                                         softc->zone_flags &=
5197                                             ~DA_ZONE_FLAG_OPT_NONSEQ_SET;
5198                                         softc->optimal_nonseq_zones = 0;
5199                                 }
5200
5201                                 tmpvar = le64dec(zi_log->max_seq_req_zones);
5202                                 if (tmpvar & ATA_ZDI_MAX_SEQ_VALID) {
5203                                         softc->zone_flags |=
5204                                             DA_ZONE_FLAG_MAX_SEQ_SET;
5205                                         softc->max_seq_zones =
5206                                             (tmpvar & ATA_ZDI_MAX_SEQ_MASK);
5207                                 } else {
5208                                         softc->zone_flags &=
5209                                             ~DA_ZONE_FLAG_MAX_SEQ_SET;
5210                                         softc->max_seq_zones = 0;
5211                                 }
5212                         }
5213                 } else {
5214                         error = daerror(done_ccb, CAM_RETRY_SELTO,
5215                                         SF_RETRY_UA|SF_NO_PRINT);
5216                         if (error == ERESTART)
5217                                 return;
5218                         else if (error != 0) {
5219                                 softc->flags &= ~DA_FLAG_CAN_ATA_ZONE;
5220                                 softc->flags &= ~DA_ZONE_FLAG_SET_MASK;
5221
5222                                 if ((done_ccb->ccb_h.status &
5223                                      CAM_DEV_QFRZN) != 0) {
5224                                         /* Don't wedge this device's queue */
5225                                         cam_release_devq(done_ccb->ccb_h.path,
5226                                                          /*relsim_flags*/0,
5227                                                          /*reduction*/0,
5228                                                          /*timeout*/0,
5229                                                          /*getcount_only*/0);
5230                                 }
5231                         }
5232
5233                 }
5234                 free(csio->data_ptr, M_SCSIDA);
5235
5236                 daprobedone(periph, done_ccb);
5237                 return;
5238         }
5239         case DA_CCB_PROBE_ZONE:
5240         {
5241                 int error;
5242
5243                 if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5244                         uint32_t valid_len;
5245                         size_t needed_len;
5246                         struct scsi_vpd_zoned_bdc *zoned_bdc;
5247
5248                         error = 0;
5249                         zoned_bdc = (struct scsi_vpd_zoned_bdc *)
5250                                 csio->data_ptr;
5251                         valid_len = csio->dxfer_len - csio->resid;
5252                         needed_len = __offsetof(struct scsi_vpd_zoned_bdc,
5253                             max_seq_req_zones) + 1 +
5254                             sizeof(zoned_bdc->max_seq_req_zones);
5255                         if ((valid_len >= needed_len)
5256                          && (scsi_2btoul(zoned_bdc->page_length) >=
5257                              SVPD_ZBDC_PL)) {
5258                                 if (zoned_bdc->flags & SVPD_ZBDC_URSWRZ)
5259                                         softc->zone_flags |=
5260                                             DA_ZONE_FLAG_URSWRZ;
5261                                 else
5262                                         softc->zone_flags &=
5263                                             ~DA_ZONE_FLAG_URSWRZ;
5264                                 softc->optimal_seq_zones =
5265                                     scsi_4btoul(zoned_bdc->optimal_seq_zones);
5266                                 softc->zone_flags |= DA_ZONE_FLAG_OPT_SEQ_SET;
5267                                 softc->optimal_nonseq_zones = scsi_4btoul(
5268                                     zoned_bdc->optimal_nonseq_zones);
5269                                 softc->zone_flags |=
5270                                     DA_ZONE_FLAG_OPT_NONSEQ_SET;
5271                                 softc->max_seq_zones =
5272                                     scsi_4btoul(zoned_bdc->max_seq_req_zones);
5273                                 softc->zone_flags |= DA_ZONE_FLAG_MAX_SEQ_SET;
5274                         }
5275                         /*
5276                          * All of the zone commands are mandatory for SCSI
5277                          * devices.
5278                          *
5279                          * XXX KDM this is valid as of September 2015.
5280                          * Re-check this assumption once the SAT spec is
5281                          * updated to support SCSI ZBC to ATA ZAC mapping.
5282                          * Since ATA allows zone commands to be reported
5283                          * as supported or not, this may not necessarily
5284                          * be true for an ATA device behind a SAT (SCSI to
5285                          * ATA Translation) layer.
5286                          */
5287                         softc->zone_flags |= DA_ZONE_FLAG_SUP_MASK;
5288                 } else {
5289                         error = daerror(done_ccb, CAM_RETRY_SELTO,
5290                                         SF_RETRY_UA|SF_NO_PRINT);
5291                         if (error == ERESTART)
5292                                 return;
5293                         else if (error != 0) {
5294                                 if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5295                                         /* Don't wedge this device's queue */
5296                                         cam_release_devq(done_ccb->ccb_h.path,
5297                                                          /*relsim_flags*/0,
5298                                                          /*reduction*/0,
5299                                                          /*timeout*/0,
5300                                                          /*getcount_only*/0);
5301                                 }
5302                         }
5303                 }
5304                 daprobedone(periph, done_ccb);
5305                 return;
5306         }
5307         case DA_CCB_DUMP:
5308                 /* No-op.  We're polling */
5309                 return;
5310         case DA_CCB_TUR:
5311         {
5312                 if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5313
5314                         if (daerror(done_ccb, CAM_RETRY_SELTO,
5315                             SF_RETRY_UA | SF_NO_RECOVERY | SF_NO_PRINT) ==
5316                             ERESTART)
5317                                 return;
5318                         if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
5319                                 cam_release_devq(done_ccb->ccb_h.path,
5320                                                  /*relsim_flags*/0,
5321                                                  /*reduction*/0,
5322                                                  /*timeout*/0,
5323                                                  /*getcount_only*/0);
5324                 }
5325                 xpt_release_ccb(done_ccb);
5326                 cam_periph_release_locked(periph);
5327                 return;
5328         }
5329         default:
5330                 break;
5331         }
5332         xpt_release_ccb(done_ccb);
5333 }
5334
5335 static void
5336 dareprobe(struct cam_periph *periph)
5337 {
5338         struct da_softc   *softc;
5339         cam_status status;
5340
5341         softc = (struct da_softc *)periph->softc;
5342
5343         /* Probe in progress; don't interfere. */
5344         if (softc->state != DA_STATE_NORMAL)
5345                 return;
5346
5347         status = cam_periph_acquire(periph);
5348         KASSERT(status == CAM_REQ_CMP,
5349             ("dareprobe: cam_periph_acquire failed"));
5350
5351         if (softc->flags & DA_FLAG_CAN_RC16)
5352                 softc->state = DA_STATE_PROBE_RC16;
5353         else
5354                 softc->state = DA_STATE_PROBE_RC;
5355
5356         xpt_schedule(periph, CAM_PRIORITY_DEV);
5357 }
5358
5359 static int
5360 daerror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags)
5361 {
5362         struct da_softc   *softc;
5363         struct cam_periph *periph;
5364         int error, error_code, sense_key, asc, ascq;
5365
5366 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
5367         if (ccb->csio.bio != NULL)
5368                 biotrack(ccb->csio.bio, __func__);
5369 #endif
5370
5371         periph = xpt_path_periph(ccb->ccb_h.path);
5372         softc = (struct da_softc *)periph->softc;
5373
5374         /*
5375          * Automatically detect devices that do not support
5376          * READ(6)/WRITE(6) and upgrade to using 10 byte cdbs.
5377          */
5378         error = 0;
5379         if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INVALID) {
5380                 error = cmd6workaround(ccb);
5381         } else if (scsi_extract_sense_ccb(ccb,
5382             &error_code, &sense_key, &asc, &ascq)) {
5383                 if (sense_key == SSD_KEY_ILLEGAL_REQUEST)
5384                         error = cmd6workaround(ccb);
5385                 /*
5386                  * If the target replied with CAPACITY DATA HAS CHANGED UA,
5387                  * query the capacity and notify upper layers.
5388                  */
5389                 else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
5390                     asc == 0x2A && ascq == 0x09) {
5391                         xpt_print(periph->path, "Capacity data has changed\n");
5392                         softc->flags &= ~DA_FLAG_PROBED;
5393                         dareprobe(periph);
5394                         sense_flags |= SF_NO_PRINT;
5395                 } else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
5396                     asc == 0x28 && ascq == 0x00) {
5397                         softc->flags &= ~DA_FLAG_PROBED;
5398                         disk_media_changed(softc->disk, M_NOWAIT);
5399                 } else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
5400                     asc == 0x3F && ascq == 0x03) {
5401                         xpt_print(periph->path, "INQUIRY data has changed\n");
5402                         softc->flags &= ~DA_FLAG_PROBED;
5403                         dareprobe(periph);
5404                         sense_flags |= SF_NO_PRINT;
5405                 } else if (sense_key == SSD_KEY_NOT_READY &&
5406                     asc == 0x3a && (softc->flags & DA_FLAG_PACK_INVALID) == 0) {
5407                         softc->flags |= DA_FLAG_PACK_INVALID;
5408                         disk_media_gone(softc->disk, M_NOWAIT);
5409                 }
5410         }
5411         if (error == ERESTART)
5412                 return (ERESTART);
5413
5414 #ifdef CAM_IO_STATS
5415         switch (ccb->ccb_h.status & CAM_STATUS_MASK) {
5416         case CAM_CMD_TIMEOUT:
5417                 softc->timeouts++;
5418                 break;
5419         case CAM_REQ_ABORTED:
5420         case CAM_REQ_CMP_ERR:
5421         case CAM_REQ_TERMIO:
5422         case CAM_UNREC_HBA_ERROR:
5423         case CAM_DATA_RUN_ERR:
5424                 softc->errors++;
5425                 break;
5426         default:
5427                 break;
5428         }
5429 #endif
5430
5431         /*
5432          * XXX
5433          * Until we have a better way of doing pack validation,
5434          * don't treat UAs as errors.
5435          */
5436         sense_flags |= SF_RETRY_UA;
5437
5438         if (softc->quirks & DA_Q_RETRY_BUSY)
5439                 sense_flags |= SF_RETRY_BUSY;
5440         return(cam_periph_error(ccb, cam_flags, sense_flags));
5441 }
5442
5443 static void
5444 damediapoll(void *arg)
5445 {
5446         struct cam_periph *periph = arg;
5447         struct da_softc *softc = periph->softc;
5448
5449         if (!cam_iosched_has_work_flags(softc->cam_iosched, DA_WORK_TUR) &&
5450             LIST_EMPTY(&softc->pending_ccbs)) {
5451                 if (cam_periph_acquire(periph) == CAM_REQ_CMP) {
5452                         cam_iosched_set_work_flags(softc->cam_iosched, DA_WORK_TUR);
5453                         daschedule(periph);
5454                 }
5455         }
5456         /* Queue us up again */
5457         if (da_poll_period != 0)
5458                 callout_schedule(&softc->mediapoll_c, da_poll_period * hz);
5459 }
5460
5461 static void
5462 daprevent(struct cam_periph *periph, int action)
5463 {
5464         struct  da_softc *softc;
5465         union   ccb *ccb;
5466         int     error;
5467
5468         softc = (struct da_softc *)periph->softc;
5469
5470         if (((action == PR_ALLOW)
5471           && (softc->flags & DA_FLAG_PACK_LOCKED) == 0)
5472          || ((action == PR_PREVENT)
5473           && (softc->flags & DA_FLAG_PACK_LOCKED) != 0)) {
5474                 return;
5475         }
5476
5477         ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
5478
5479         scsi_prevent(&ccb->csio,
5480                      /*retries*/1,
5481                      /*cbcfp*/dadone,
5482                      MSG_SIMPLE_Q_TAG,
5483                      action,
5484                      SSD_FULL_SIZE,
5485                      5000);
5486
5487         error = cam_periph_runccb(ccb, daerror, CAM_RETRY_SELTO,
5488             SF_RETRY_UA | SF_NO_PRINT, softc->disk->d_devstat);
5489
5490         if (error == 0) {
5491                 if (action == PR_ALLOW)
5492                         softc->flags &= ~DA_FLAG_PACK_LOCKED;
5493                 else
5494                         softc->flags |= DA_FLAG_PACK_LOCKED;
5495         }
5496
5497         xpt_release_ccb(ccb);
5498 }
5499
5500 static void
5501 dasetgeom(struct cam_periph *periph, uint32_t block_len, uint64_t maxsector,
5502           struct scsi_read_capacity_data_long *rcaplong, size_t rcap_len)
5503 {
5504         struct ccb_calc_geometry ccg;
5505         struct da_softc *softc;
5506         struct disk_params *dp;
5507         u_int lbppbe, lalba;
5508         int error;
5509
5510         softc = (struct da_softc *)periph->softc;
5511
5512         dp = &softc->params;
5513         dp->secsize = block_len;
5514         dp->sectors = maxsector + 1;
5515         if (rcaplong != NULL) {
5516                 lbppbe = rcaplong->prot_lbppbe & SRC16_LBPPBE;
5517                 lalba = scsi_2btoul(rcaplong->lalba_lbp);
5518                 lalba &= SRC16_LALBA_A;
5519         } else {
5520                 lbppbe = 0;
5521                 lalba = 0;
5522         }
5523
5524         if (lbppbe > 0) {
5525                 dp->stripesize = block_len << lbppbe;
5526                 dp->stripeoffset = (dp->stripesize - block_len * lalba) %
5527                     dp->stripesize;
5528         } else if (softc->quirks & DA_Q_4K) {
5529                 dp->stripesize = 4096;
5530                 dp->stripeoffset = 0;
5531         } else if (softc->unmap_gran != 0) {
5532                 dp->stripesize = block_len * softc->unmap_gran;
5533                 dp->stripeoffset = (dp->stripesize - block_len *
5534                     softc->unmap_gran_align) % dp->stripesize;
5535         } else {
5536                 dp->stripesize = 0;
5537                 dp->stripeoffset = 0;
5538         }
5539         /*
5540          * Have the controller provide us with a geometry
5541          * for this disk.  The only time the geometry
5542          * matters is when we boot and the controller
5543          * is the only one knowledgeable enough to come
5544          * up with something that will make this a bootable
5545          * device.
5546          */
5547         xpt_setup_ccb(&ccg.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
5548         ccg.ccb_h.func_code = XPT_CALC_GEOMETRY;
5549         ccg.block_size = dp->secsize;
5550         ccg.volume_size = dp->sectors;
5551         ccg.heads = 0;
5552         ccg.secs_per_track = 0;
5553         ccg.cylinders = 0;
5554         xpt_action((union ccb*)&ccg);
5555         if ((ccg.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5556                 /*
5557                  * We don't know what went wrong here- but just pick
5558                  * a geometry so we don't have nasty things like divide
5559                  * by zero.
5560                  */
5561                 dp->heads = 255;
5562                 dp->secs_per_track = 255;
5563                 dp->cylinders = dp->sectors / (255 * 255);
5564                 if (dp->cylinders == 0) {
5565                         dp->cylinders = 1;
5566                 }
5567         } else {
5568                 dp->heads = ccg.heads;
5569                 dp->secs_per_track = ccg.secs_per_track;
5570                 dp->cylinders = ccg.cylinders;
5571         }
5572
5573         /*
5574          * If the user supplied a read capacity buffer, and if it is
5575          * different than the previous buffer, update the data in the EDT.
5576          * If it's the same, we don't bother.  This avoids sending an
5577          * update every time someone opens this device.
5578          */
5579         if ((rcaplong != NULL)
5580          && (bcmp(rcaplong, &softc->rcaplong,
5581                   min(sizeof(softc->rcaplong), rcap_len)) != 0)) {
5582                 struct ccb_dev_advinfo cdai;
5583
5584                 xpt_setup_ccb(&cdai.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
5585                 cdai.ccb_h.func_code = XPT_DEV_ADVINFO;
5586                 cdai.buftype = CDAI_TYPE_RCAPLONG;
5587                 cdai.flags = CDAI_FLAG_STORE;
5588                 cdai.bufsiz = rcap_len;
5589                 cdai.buf = (uint8_t *)rcaplong;
5590                 xpt_action((union ccb *)&cdai);
5591                 if ((cdai.ccb_h.status & CAM_DEV_QFRZN) != 0)
5592                         cam_release_devq(cdai.ccb_h.path, 0, 0, 0, FALSE);
5593                 if (cdai.ccb_h.status != CAM_REQ_CMP) {
5594                         xpt_print(periph->path, "%s: failed to set read "
5595                                   "capacity advinfo\n", __func__);
5596                         /* Use cam_error_print() to decode the status */
5597                         cam_error_print((union ccb *)&cdai, CAM_ESF_CAM_STATUS,
5598                                         CAM_EPF_ALL);
5599                 } else {
5600                         bcopy(rcaplong, &softc->rcaplong,
5601                               min(sizeof(softc->rcaplong), rcap_len));
5602                 }
5603         }
5604
5605         softc->disk->d_sectorsize = softc->params.secsize;
5606         softc->disk->d_mediasize = softc->params.secsize * (off_t)softc->params.sectors;
5607         softc->disk->d_stripesize = softc->params.stripesize;
5608         softc->disk->d_stripeoffset = softc->params.stripeoffset;
5609         /* XXX: these are not actually "firmware" values, so they may be wrong */
5610         softc->disk->d_fwsectors = softc->params.secs_per_track;
5611         softc->disk->d_fwheads = softc->params.heads;
5612         softc->disk->d_devstat->block_size = softc->params.secsize;
5613         softc->disk->d_devstat->flags &= ~DEVSTAT_BS_UNAVAILABLE;
5614
5615         error = disk_resize(softc->disk, M_NOWAIT);
5616         if (error != 0)
5617                 xpt_print(periph->path, "disk_resize(9) failed, error = %d\n", error);
5618 }
5619
5620 static void
5621 dasendorderedtag(void *arg)
5622 {
5623         struct da_softc *softc = arg;
5624
5625         if (da_send_ordered) {
5626                 if (!LIST_EMPTY(&softc->pending_ccbs)) {
5627                         if ((softc->flags & DA_FLAG_WAS_OTAG) == 0)
5628                                 softc->flags |= DA_FLAG_NEED_OTAG;
5629                         softc->flags &= ~DA_FLAG_WAS_OTAG;
5630                 }
5631         }
5632         /* Queue us up again */
5633         callout_reset(&softc->sendordered_c,
5634             (da_default_timeout * hz) / DA_ORDEREDTAG_INTERVAL,
5635             dasendorderedtag, softc);
5636 }
5637
5638 /*
5639  * Step through all DA peripheral drivers, and if the device is still open,
5640  * sync the disk cache to physical media.
5641  */
5642 static void
5643 dashutdown(void * arg, int howto)
5644 {
5645         struct cam_periph *periph;
5646         struct da_softc *softc;
5647         union ccb *ccb;
5648         int error;
5649
5650         CAM_PERIPH_FOREACH(periph, &dadriver) {
5651                 softc = (struct da_softc *)periph->softc;
5652                 if (SCHEDULER_STOPPED()) {
5653                         /* If we paniced with the lock held, do not recurse. */
5654                         if (!cam_periph_owned(periph) &&
5655                             (softc->flags & DA_FLAG_OPEN)) {
5656                                 dadump(softc->disk, NULL, 0, 0, 0);
5657                         }
5658                         continue;
5659                 }
5660                 cam_periph_lock(periph);
5661
5662                 /*
5663                  * We only sync the cache if the drive is still open, and
5664                  * if the drive is capable of it..
5665                  */
5666                 if (((softc->flags & DA_FLAG_OPEN) == 0)
5667                  || (softc->quirks & DA_Q_NO_SYNC_CACHE)) {
5668                         cam_periph_unlock(periph);
5669                         continue;
5670                 }
5671
5672                 ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
5673                 scsi_synchronize_cache(&ccb->csio,
5674                                        /*retries*/0,
5675                                        /*cbfcnp*/dadone,
5676                                        MSG_SIMPLE_Q_TAG,
5677                                        /*begin_lba*/0, /* whole disk */
5678                                        /*lb_count*/0,
5679                                        SSD_FULL_SIZE,
5680                                        60 * 60 * 1000);
5681
5682                 error = cam_periph_runccb(ccb, daerror, /*cam_flags*/0,
5683                     /*sense_flags*/ SF_NO_RECOVERY | SF_NO_RETRY | SF_QUIET_IR,
5684                     softc->disk->d_devstat);
5685                 if (error != 0)
5686                         xpt_print(periph->path, "Synchronize cache failed\n");
5687                 xpt_release_ccb(ccb);
5688                 cam_periph_unlock(periph);
5689         }
5690 }
5691
5692 #else /* !_KERNEL */
5693
5694 /*
5695  * XXX These are only left out of the kernel build to silence warnings.  If,
5696  * for some reason these functions are used in the kernel, the ifdefs should
5697  * be moved so they are included both in the kernel and userland.
5698  */
5699 void
5700 scsi_format_unit(struct ccb_scsiio *csio, u_int32_t retries,
5701                  void (*cbfcnp)(struct cam_periph *, union ccb *),
5702                  u_int8_t tag_action, u_int8_t byte2, u_int16_t ileave,
5703                  u_int8_t *data_ptr, u_int32_t dxfer_len, u_int8_t sense_len,
5704                  u_int32_t timeout)
5705 {
5706         struct scsi_format_unit *scsi_cmd;
5707
5708         scsi_cmd = (struct scsi_format_unit *)&csio->cdb_io.cdb_bytes;
5709         scsi_cmd->opcode = FORMAT_UNIT;
5710         scsi_cmd->byte2 = byte2;
5711         scsi_ulto2b(ileave, scsi_cmd->interleave);
5712
5713         cam_fill_csio(csio,
5714                       retries,
5715                       cbfcnp,
5716                       /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
5717                       tag_action,
5718                       data_ptr,
5719                       dxfer_len,
5720                       sense_len,
5721                       sizeof(*scsi_cmd),
5722                       timeout);
5723 }
5724
5725 void
5726 scsi_read_defects(struct ccb_scsiio *csio, uint32_t retries,
5727                   void (*cbfcnp)(struct cam_periph *, union ccb *),
5728                   uint8_t tag_action, uint8_t list_format,
5729                   uint32_t addr_desc_index, uint8_t *data_ptr,
5730                   uint32_t dxfer_len, int minimum_cmd_size,
5731                   uint8_t sense_len, uint32_t timeout)
5732 {
5733         uint8_t cdb_len;
5734
5735         /*
5736          * These conditions allow using the 10 byte command.  Otherwise we
5737          * need to use the 12 byte command.
5738          */
5739         if ((minimum_cmd_size <= 10)
5740          && (addr_desc_index == 0)
5741          && (dxfer_len <= SRDD10_MAX_LENGTH)) {
5742                 struct scsi_read_defect_data_10 *cdb10;
5743
5744                 cdb10 = (struct scsi_read_defect_data_10 *)
5745                         &csio->cdb_io.cdb_bytes;
5746
5747                 cdb_len = sizeof(*cdb10);
5748                 bzero(cdb10, cdb_len);
5749                 cdb10->opcode = READ_DEFECT_DATA_10;
5750                 cdb10->format = list_format;
5751                 scsi_ulto2b(dxfer_len, cdb10->alloc_length);
5752         } else {
5753                 struct scsi_read_defect_data_12 *cdb12;
5754
5755                 cdb12 = (struct scsi_read_defect_data_12 *)
5756                         &csio->cdb_io.cdb_bytes;
5757
5758                 cdb_len = sizeof(*cdb12);
5759                 bzero(cdb12, cdb_len);
5760                 cdb12->opcode = READ_DEFECT_DATA_12;
5761                 cdb12->format = list_format;
5762                 scsi_ulto4b(dxfer_len, cdb12->alloc_length);
5763                 scsi_ulto4b(addr_desc_index, cdb12->address_descriptor_index);
5764         }
5765
5766         cam_fill_csio(csio,
5767                       retries,
5768                       cbfcnp,
5769                       /*flags*/ CAM_DIR_IN,
5770                       tag_action,
5771                       data_ptr,
5772                       dxfer_len,
5773                       sense_len,
5774                       cdb_len,
5775                       timeout);
5776 }
5777
5778 void
5779 scsi_sanitize(struct ccb_scsiio *csio, u_int32_t retries,
5780               void (*cbfcnp)(struct cam_periph *, union ccb *),
5781               u_int8_t tag_action, u_int8_t byte2, u_int16_t control,
5782               u_int8_t *data_ptr, u_int32_t dxfer_len, u_int8_t sense_len,
5783               u_int32_t timeout)
5784 {
5785         struct scsi_sanitize *scsi_cmd;
5786
5787         scsi_cmd = (struct scsi_sanitize *)&csio->cdb_io.cdb_bytes;
5788         scsi_cmd->opcode = SANITIZE;
5789         scsi_cmd->byte2 = byte2;
5790         scsi_cmd->control = control;
5791         scsi_ulto2b(dxfer_len, scsi_cmd->length);
5792
5793         cam_fill_csio(csio,
5794                       retries,
5795                       cbfcnp,
5796                       /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
5797                       tag_action,
5798                       data_ptr,
5799                       dxfer_len,
5800                       sense_len,
5801                       sizeof(*scsi_cmd),
5802                       timeout);
5803 }
5804
5805 #endif /* _KERNEL */
5806
5807 void
5808 scsi_zbc_out(struct ccb_scsiio *csio, uint32_t retries,
5809              void (*cbfcnp)(struct cam_periph *, union ccb *),
5810              uint8_t tag_action, uint8_t service_action, uint64_t zone_id,
5811              uint8_t zone_flags, uint8_t *data_ptr, uint32_t dxfer_len,
5812              uint8_t sense_len, uint32_t timeout)
5813 {
5814         struct scsi_zbc_out *scsi_cmd;
5815
5816         scsi_cmd = (struct scsi_zbc_out *)&csio->cdb_io.cdb_bytes;
5817         scsi_cmd->opcode = ZBC_OUT;
5818         scsi_cmd->service_action = service_action;
5819         scsi_u64to8b(zone_id, scsi_cmd->zone_id);
5820         scsi_cmd->zone_flags = zone_flags;
5821
5822         cam_fill_csio(csio,
5823                       retries,
5824                       cbfcnp,
5825                       /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
5826                       tag_action,
5827                       data_ptr,
5828                       dxfer_len,
5829                       sense_len,
5830                       sizeof(*scsi_cmd),
5831                       timeout);
5832 }
5833
5834 void
5835 scsi_zbc_in(struct ccb_scsiio *csio, uint32_t retries,
5836             void (*cbfcnp)(struct cam_periph *, union ccb *),
5837             uint8_t tag_action, uint8_t service_action, uint64_t zone_start_lba,
5838             uint8_t zone_options, uint8_t *data_ptr, uint32_t dxfer_len,
5839             uint8_t sense_len, uint32_t timeout)
5840 {
5841         struct scsi_zbc_in *scsi_cmd;
5842
5843         scsi_cmd = (struct scsi_zbc_in *)&csio->cdb_io.cdb_bytes;
5844         scsi_cmd->opcode = ZBC_IN;
5845         scsi_cmd->service_action = service_action;
5846         scsi_ulto4b(dxfer_len, scsi_cmd->length);
5847         scsi_u64to8b(zone_start_lba, scsi_cmd->zone_start_lba);
5848         scsi_cmd->zone_options = zone_options;
5849
5850         cam_fill_csio(csio,
5851                       retries,
5852                       cbfcnp,
5853                       /*flags*/ (dxfer_len > 0) ? CAM_DIR_IN : CAM_DIR_NONE,
5854                       tag_action,
5855                       data_ptr,
5856                       dxfer_len,
5857                       sense_len,
5858                       sizeof(*scsi_cmd),
5859                       timeout);
5860
5861 }
5862
5863 int
5864 scsi_ata_zac_mgmt_out(struct ccb_scsiio *csio, uint32_t retries,
5865                       void (*cbfcnp)(struct cam_periph *, union ccb *),
5866                       uint8_t tag_action, int use_ncq,
5867                       uint8_t zm_action, uint64_t zone_id, uint8_t zone_flags,
5868                       uint8_t *data_ptr, uint32_t dxfer_len,
5869                       uint8_t *cdb_storage, size_t cdb_storage_len,
5870                       uint8_t sense_len, uint32_t timeout)
5871 {
5872         uint8_t command_out, protocol, ata_flags;
5873         uint16_t features_out;
5874         uint32_t sectors_out, auxiliary;
5875         int retval;
5876
5877         retval = 0;
5878
5879         if (use_ncq == 0) {
5880                 command_out = ATA_ZAC_MANAGEMENT_OUT;
5881                 features_out = (zm_action & 0xf) | (zone_flags << 8);
5882                 ata_flags = AP_FLAG_BYT_BLOK_BLOCKS;
5883                 if (dxfer_len == 0) {
5884                         protocol = AP_PROTO_NON_DATA;
5885                         ata_flags |= AP_FLAG_TLEN_NO_DATA;
5886                         sectors_out = 0;
5887                 } else {
5888                         protocol = AP_PROTO_DMA;
5889                         ata_flags |= AP_FLAG_TLEN_SECT_CNT |
5890                                      AP_FLAG_TDIR_TO_DEV;
5891                         sectors_out = ((dxfer_len >> 9) & 0xffff);
5892                 }
5893                 auxiliary = 0;
5894         } else {
5895                 ata_flags = AP_FLAG_BYT_BLOK_BLOCKS;
5896                 if (dxfer_len == 0) {
5897                         command_out = ATA_NCQ_NON_DATA;
5898                         features_out = ATA_NCQ_ZAC_MGMT_OUT;
5899                         /*
5900                          * We're assuming the SCSI to ATA translation layer
5901                          * will set the NCQ tag number in the tag field.
5902                          * That isn't clear from the SAT-4 spec (as of rev 05).
5903                          */
5904                         sectors_out = 0;
5905                         ata_flags |= AP_FLAG_TLEN_NO_DATA;
5906                 } else {
5907                         command_out = ATA_SEND_FPDMA_QUEUED;
5908                         /*
5909                          * Note that we're defaulting to normal priority,
5910                          * and assuming that the SCSI to ATA translation
5911                          * layer will insert the NCQ tag number in the tag
5912                          * field.  That isn't clear in the SAT-4 spec (as
5913                          * of rev 05).
5914                          */
5915                         sectors_out = ATA_SFPDMA_ZAC_MGMT_OUT << 8;
5916
5917                         ata_flags |= AP_FLAG_TLEN_FEAT |
5918                                      AP_FLAG_TDIR_TO_DEV;
5919
5920                         /*
5921                          * For SEND FPDMA QUEUED, the transfer length is
5922                          * encoded in the FEATURE register, and 0 means
5923                          * that 65536 512 byte blocks are to be tranferred.
5924                          * In practice, it seems unlikely that we'll see
5925                          * a transfer that large, and it may confuse the
5926                          * the SAT layer, because generally that means that
5927                          * 0 bytes should be transferred.
5928                          */
5929                         if (dxfer_len == (65536 * 512)) {
5930                                 features_out = 0;
5931                         } else if (dxfer_len <= (65535 * 512)) {
5932                                 features_out = ((dxfer_len >> 9) & 0xffff);
5933                         } else {
5934                                 /* The transfer is too big. */
5935                                 retval = 1;
5936                                 goto bailout;
5937                         }
5938
5939                 }
5940
5941                 auxiliary = (zm_action & 0xf) | (zone_flags << 8);
5942                 protocol = AP_PROTO_FPDMA;
5943         }
5944
5945         protocol |= AP_EXTEND;
5946
5947         retval = scsi_ata_pass(csio,
5948             retries,
5949             cbfcnp,
5950             /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
5951             tag_action,
5952             /*protocol*/ protocol,
5953             /*ata_flags*/ ata_flags,
5954             /*features*/ features_out,
5955             /*sector_count*/ sectors_out,
5956             /*lba*/ zone_id,
5957             /*command*/ command_out,
5958             /*device*/ 0,
5959             /*icc*/ 0,
5960             /*auxiliary*/ auxiliary,
5961             /*control*/ 0,
5962             /*data_ptr*/ data_ptr,
5963             /*dxfer_len*/ dxfer_len,
5964             /*cdb_storage*/ cdb_storage,
5965             /*cdb_storage_len*/ cdb_storage_len,
5966             /*minimum_cmd_size*/ 0,
5967             /*sense_len*/ SSD_FULL_SIZE,
5968             /*timeout*/ timeout);
5969
5970 bailout:
5971
5972         return (retval);
5973 }
5974
5975 int
5976 scsi_ata_zac_mgmt_in(struct ccb_scsiio *csio, uint32_t retries,
5977                      void (*cbfcnp)(struct cam_periph *, union ccb *),
5978                      uint8_t tag_action, int use_ncq,
5979                      uint8_t zm_action, uint64_t zone_id, uint8_t zone_flags,
5980                      uint8_t *data_ptr, uint32_t dxfer_len,
5981                      uint8_t *cdb_storage, size_t cdb_storage_len,
5982                      uint8_t sense_len, uint32_t timeout)
5983 {
5984         uint8_t command_out, protocol;
5985         uint16_t features_out, sectors_out;
5986         uint32_t auxiliary;
5987         int ata_flags;
5988         int retval;
5989
5990         retval = 0;
5991         ata_flags = AP_FLAG_TDIR_FROM_DEV | AP_FLAG_BYT_BLOK_BLOCKS;
5992
5993         if (use_ncq == 0) {
5994                 command_out = ATA_ZAC_MANAGEMENT_IN;
5995                 /* XXX KDM put a macro here */
5996                 features_out = (zm_action & 0xf) | (zone_flags << 8);
5997                 sectors_out = dxfer_len >> 9; /* XXX KDM macro */
5998                 protocol = AP_PROTO_DMA;
5999                 ata_flags |= AP_FLAG_TLEN_SECT_CNT;
6000                 auxiliary = 0;
6001         } else {
6002                 ata_flags |= AP_FLAG_TLEN_FEAT;
6003
6004                 command_out = ATA_RECV_FPDMA_QUEUED;
6005                 sectors_out = ATA_RFPDMA_ZAC_MGMT_IN << 8;
6006
6007                 /*
6008                  * For RECEIVE FPDMA QUEUED, the transfer length is
6009                  * encoded in the FEATURE register, and 0 means
6010                  * that 65536 512 byte blocks are to be tranferred.
6011                  * In practice, it seems unlikely that we'll see
6012                  * a transfer that large, and it may confuse the
6013                  * the SAT layer, because generally that means that
6014                  * 0 bytes should be transferred.
6015                  */
6016                 if (dxfer_len == (65536 * 512)) {
6017                         features_out = 0;
6018                 } else if (dxfer_len <= (65535 * 512)) {
6019                         features_out = ((dxfer_len >> 9) & 0xffff);
6020                 } else {
6021                         /* The transfer is too big. */
6022                         retval = 1;
6023                         goto bailout;
6024                 }
6025                 auxiliary = (zm_action & 0xf) | (zone_flags << 8),
6026                 protocol = AP_PROTO_FPDMA;
6027         }
6028
6029         protocol |= AP_EXTEND;
6030
6031         retval = scsi_ata_pass(csio,
6032             retries,
6033             cbfcnp,
6034             /*flags*/ CAM_DIR_IN,
6035             tag_action,
6036             /*protocol*/ protocol,
6037             /*ata_flags*/ ata_flags,
6038             /*features*/ features_out,
6039             /*sector_count*/ sectors_out,
6040             /*lba*/ zone_id,
6041             /*command*/ command_out,
6042             /*device*/ 0,
6043             /*icc*/ 0,
6044             /*auxiliary*/ auxiliary,
6045             /*control*/ 0,
6046             /*data_ptr*/ data_ptr,
6047             /*dxfer_len*/ (dxfer_len >> 9) * 512, /* XXX KDM */
6048             /*cdb_storage*/ cdb_storage,
6049             /*cdb_storage_len*/ cdb_storage_len,
6050             /*minimum_cmd_size*/ 0,
6051             /*sense_len*/ SSD_FULL_SIZE,
6052             /*timeout*/ timeout);
6053
6054 bailout:
6055         return (retval);
6056 }