1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
  23  */
  24 /*
  25  * Copyright 2011 cyril.galibern@opensvc.com
  26  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
  27  */
  28 
  29 #ifndef _SYS_SCSI_TARGETS_SDDEF_H
  30 #define _SYS_SCSI_TARGETS_SDDEF_H
  31 
  32 #include <sys/dktp/fdisk.h>
  33 #include <sys/note.h>
  34 #include <sys/mhd.h>
  35 #include <sys/cmlb.h>
  36 
  37 #ifdef  __cplusplus
  38 extern "C" {
  39 #endif
  40 
  41 
  42 #if defined(_KERNEL) || defined(_KMEMUSER)
  43 
  44 
  45 #define SD_SUCCESS              0
  46 #define SD_FAILURE              (-1)
  47 
  48 #if defined(TRUE)
  49 #undef TRUE
  50 #endif
  51 
  52 #if defined(FALSE)
  53 #undef FALSE
  54 #endif
  55 
  56 #define TRUE                    1
  57 #define FALSE                   0
  58 
  59 #if defined(VERBOSE)
  60 #undef VERBOSE
  61 #endif
  62 
  63 #if defined(SILENT)
  64 #undef SILENT
  65 #endif
  66 
  67 
  68 /*
  69  *  Fault Injection Flag for Inclusion of Code
  70  *
  71  *  This should only be defined when SDDEBUG is defined
  72  * #if DEBUG || lint
  73  * #define      SD_FAULT_INJECTION
  74  * #endif
  75  */
  76 
  77 #if DEBUG || lint
  78 #define SD_FAULT_INJECTION
  79 #endif
  80 #define VERBOSE                 1
  81 #define SILENT                  0
  82 
  83 /*
  84  * Structures for recording whether a device is fully open or closed.
  85  * Assumptions:
  86  *
  87  *      + There are only 8 (sparc) or 16 (x86) disk slices possible.
  88  *      + BLK, MNT, CHR, SWP don't change in some future release!
  89  */
  90 
  91 #if defined(_SUNOS_VTOC_8)
  92 
  93 #define SDUNIT_SHIFT    3
  94 #define SDPART_MASK     7
  95 #define NSDMAP          NDKMAP
  96 
  97 #elif defined(_SUNOS_VTOC_16)
  98 
  99 /*
 100  * XXX - NSDMAP has multiple definitions, one more in cmlb_impl.h
 101  * If they are coalesced into one, this definition will follow suit.
 102  * FDISK partitions - 4 primary and MAX_EXT_PARTS number of Extended
 103  * Partitions.
 104  */
 105 #define FDISK_PARTS             (FD_NUMPART + MAX_EXT_PARTS)
 106 
 107 #define SDUNIT_SHIFT    6
 108 #define SDPART_MASK     63
 109 #define NSDMAP          (NDKMAP + FDISK_PARTS + 1)
 110 
 111 #else
 112 #error "No VTOC format defined."
 113 #endif
 114 
 115 
 116 #define SDUNIT(dev)     (getminor((dev)) >> SDUNIT_SHIFT)
 117 #define SDPART(dev)     (getminor((dev)) &  SDPART_MASK)
 118 
 119 /*
 120  * maximum number of partitions the driver keeps track of; with
 121  * EFI this can be larger than the number of partitions accessible
 122  * through the minor nodes.  It won't be used for keeping track
 123  * of open counts, partition kstats, etc.
 124  */
 125 #define MAXPART         (NSDMAP + 1)
 126 
 127 /*
 128  * Macro to retrieve the DDI instance number from the given buf struct.
 129  * The instance number is encoded in the minor device number.
 130  */
 131 #define SD_GET_INSTANCE_FROM_BUF(bp)                            \
 132         (getminor((bp)->b_edev) >> SDUNIT_SHIFT)
 133 
 134 
 135 
 136 struct ocinfo {
 137         /*
 138          * Types BLK, MNT, CHR, SWP,
 139          * assumed to be types 0-3.
 140          */
 141         uint64_t  lyr_open[NSDMAP];
 142         uint64_t  reg_open[OTYPCNT - 1];
 143 };
 144 
 145 #define OCSIZE  sizeof (struct ocinfo)
 146 
 147 union ocmap {
 148         uchar_t chkd[OCSIZE];
 149         struct ocinfo rinfo;
 150 };
 151 
 152 #define lyropen rinfo.lyr_open
 153 #define regopen rinfo.reg_open
 154 
 155 
 156 #define SD_CDB_GROUP0           0
 157 #define SD_CDB_GROUP1           1
 158 #define SD_CDB_GROUP5           2
 159 #define SD_CDB_GROUP4           3
 160 
 161 struct sd_cdbinfo {
 162         uchar_t  sc_grpcode;    /* CDB group code */
 163         uchar_t  sc_grpmask;    /* CDB group code mask (for cmd opcode) */
 164         uint64_t sc_maxlba;     /* Maximum logical block addr. supported */
 165         uint32_t sc_maxlen;     /* Maximum transfer length supported */
 166 };
 167 
 168 
 169 
 170 /*
 171  * The following declaration are for Non-512 byte block support for the
 172  * removable devices. (ex - DVD RAM, MO).
 173  * wm_state: This is an enumeration for the different states for
 174  * manipalating write range list during the read-modify-write-operation.
 175  */
 176 typedef enum {
 177         SD_WM_CHK_LIST,         /* Check list for overlapping writes */
 178         SD_WM_WAIT_MAP,         /* Wait for an overlapping I/O to complete */
 179         SD_WM_LOCK_RANGE,       /* Lock the range of lba to be written */
 180         SD_WM_DONE              /* I/O complete */
 181 } wm_state;
 182 
 183 /*
 184  * sd_w_map: Every write I/O will get one w_map allocated for it which will tell
 185  * the range on the media which is being written for that request.
 186  */
 187 struct sd_w_map {
 188         uint_t          wm_start;       /* Write start location */
 189         uint_t          wm_end;         /* Write end location */
 190         ushort_t        wm_flags;       /* State of the wmap */
 191         ushort_t        wm_wanted_count; /* # of threads waiting for region */
 192         void            *wm_private;    /* Used to store bp->b_private */
 193         struct buf      *wm_bufp;       /* to store buf pointer */
 194         struct sd_w_map *wm_next;       /* Forward pointed to sd_w_map */
 195         struct sd_w_map *wm_prev;       /* Back pointer to sd_w_map */
 196         kcondvar_t      wm_avail;       /* Sleep on this, while not available */
 197 };
 198 
 199 _NOTE(MUTEX_PROTECTS_DATA(scsi_device::sd_mutex, sd_w_map::wm_flags))
 200 
 201 
 202 /*
 203  * This is the struct for the layer-private data area for the
 204  * mapblocksize layer.
 205  */
 206 
 207 struct sd_mapblocksize_info {
 208         void            *mbs_oprivate;  /* saved value of xb_private */
 209         struct buf      *mbs_orig_bp;   /* ptr to original bp */
 210         struct sd_w_map *mbs_wmp;       /* ptr to write-map struct for RMW */
 211         ssize_t         mbs_copy_offset;
 212         int             mbs_layer_index;        /* chain index for RMW */
 213 };
 214 
 215 _NOTE(SCHEME_PROTECTS_DATA("unshared data", sd_mapblocksize_info))
 216 
 217 
 218 /*
 219  * sd_lun: The main data structure for a scsi logical unit.
 220  * Stored as the softstate structure for each device.
 221  */
 222 
 223 struct sd_lun {
 224 
 225         /* Back ptr to the SCSA scsi_device struct for this LUN */
 226         struct scsi_device      *un_sd;
 227 
 228         /*
 229          * Support for Auto-Request sense capability
 230          */
 231         struct buf      *un_rqs_bp;     /* ptr to request sense bp */
 232         struct scsi_pkt *un_rqs_pktp;   /* ptr to request sense scsi_pkt */
 233         int     un_sense_isbusy;        /* Busy flag for RQS buf */
 234 
 235         /*
 236          * These specify the layering chains to use with this instance. These
 237          * are initialized according to the values in the sd_chain_index_map[]
 238          * array. See the description of sd_chain_index_map[] for details.
 239          */
 240         int un_buf_chain_type;
 241         int un_uscsi_chain_type;
 242         int un_direct_chain_type;
 243         int un_priority_chain_type;
 244 
 245         /* Head & tail ptrs to the queue of bufs awaiting transport */
 246         struct buf      *un_waitq_headp;
 247         struct buf      *un_waitq_tailp;
 248 
 249         /* Ptr to the buf currently being retried (NULL if none) */
 250         struct buf      *un_retry_bp;
 251 
 252         /* This tracks the last kstat update for the un_retry_bp buf */
 253         void            (*un_retry_statp)(kstat_io_t *);
 254 
 255         void            *un_xbuf_attr;  /* xbuf attribute struct */
 256 
 257 
 258         /* System logical block size, in bytes. (defaults to DEV_BSIZE.) */
 259         uint32_t        un_sys_blocksize;
 260 
 261         /* The size of a logical block on the target, in bytes. */
 262         uint32_t        un_tgt_blocksize;
 263 
 264         /* The size of a physical block on the target, in bytes. */
 265         uint32_t        un_phy_blocksize;
 266 
 267         /*
 268          * The number of logical blocks on the target. This is adjusted
 269          * to be in terms of the block size specified by un_sys_blocksize
 270          * (ie, the system block size).
 271          */
 272         uint64_t        un_blockcount;
 273 
 274         /*
 275          * Various configuration data
 276          */
 277         uchar_t un_ctype;               /* Controller type */
 278         char    *un_node_type;          /* minor node type */
 279         uchar_t un_interconnect_type;   /* Interconnect for underlying HBA */
 280 
 281         uint_t  un_notready_retry_count; /* Per disk notready retry count */
 282         uint_t  un_busy_retry_count;    /* Per disk BUSY retry count */
 283 
 284         uint_t  un_retry_count;         /* Per disk retry count */
 285         uint_t  un_victim_retry_count;  /* Per disk victim retry count */
 286 
 287         /* (4356701, 4367306) */
 288         uint_t  un_reset_retry_count; /* max io retries before issuing reset */
 289         ushort_t un_reserve_release_time; /* reservation release timeout */
 290 
 291         uchar_t un_reservation_type;    /* SCSI-3 or SCSI-2 */
 292         uint_t  un_max_xfer_size;       /* Maximum DMA transfer size */
 293         int     un_partial_dma_supported;
 294         int     un_buf_breakup_supported;
 295 
 296         int     un_mincdb;              /* Smallest CDB to use */
 297         int     un_maxcdb;              /* Largest CDB to use */
 298         int     un_max_hba_cdb;         /* Largest CDB supported by HBA */
 299         int     un_status_len;
 300         int     un_pkt_flags;
 301 
 302         /*
 303          * Note: un_uscsi_timeout is a "mirror" of un_cmd_timeout, adjusted
 304          * for ISCD().  Any updates to un_cmd_timeout MUST be reflected
 305          * in un_uscsi_timeout as well!
 306          */
 307         ushort_t un_cmd_timeout;        /* Timeout for completion */
 308         ushort_t un_uscsi_timeout;      /* Timeout for USCSI completion */
 309         ushort_t un_busy_timeout;       /* Timeout for busy retry */
 310 
 311         /*
 312          * Info on current states, statuses, etc. (Updated frequently)
 313          */
 314         uchar_t un_state;               /* current state */
 315         uchar_t un_last_state;          /* last state */
 316         uchar_t un_last_pkt_reason;     /* used to suppress multiple msgs */
 317         int     un_tagflags;            /* Pkt Flags for Tagged Queueing  */
 318         short   un_resvd_status;        /* Reservation Status */
 319         ulong_t un_detach_count;        /* !0 if executing detach routine */
 320         ulong_t un_layer_count;         /* Current total # of layered opens */
 321         ulong_t un_opens_in_progress;   /* Current # of threads in sdopen */
 322 
 323         ksema_t un_semoclose;           /* serialize opens/closes */
 324 
 325         /*
 326          * Control & status info for command throttling
 327          */
 328         long    un_ncmds_in_driver;     /* number of cmds in driver */
 329         short   un_ncmds_in_transport;  /* number of cmds in transport */
 330         short   un_throttle;            /* max #cmds allowed in transport */
 331         short   un_saved_throttle;      /* saved value of un_throttle */
 332         short   un_busy_throttle;       /* saved un_throttle for BUSY */
 333         short   un_min_throttle;        /* min value of un_throttle */
 334         timeout_id_t    un_reset_throttle_timeid; /* timeout(9F) handle */
 335 
 336         /*
 337          * Multi-host (clustering) support
 338          */
 339         opaque_t        un_mhd_token;           /* scsi watch request */
 340         timeout_id_t    un_resvd_timeid;        /* for resvd recover */
 341 
 342         /* Event callback resources (photon) */
 343         ddi_eventcookie_t un_insert_event;      /* insert event */
 344         ddi_callback_id_t un_insert_cb_id;      /* insert callback */
 345         ddi_eventcookie_t un_remove_event;      /* remove event */
 346         ddi_callback_id_t un_remove_cb_id;      /* remove callback */
 347 
 348         uint_t          un_start_stop_cycle_page;       /* Saves start/stop */
 349                                                         /* cycle page */
 350         timeout_id_t    un_dcvb_timeid;         /* dlyd cv broadcast */
 351 
 352         /*
 353          * Data structures for open counts, partition info, VTOC,
 354          * stats, and other such bookkeeping info.
 355          */
 356         union   ocmap   un_ocmap;               /* open partition map */
 357         struct  kstat   *un_pstats[NSDMAP];     /* partition statistics */
 358         struct  kstat   *un_stats;              /* disk statistics */
 359         kstat_t         *un_errstats;           /* for error statistics */
 360         uint64_t        un_exclopen;            /* exclusive open bitmask */
 361         ddi_devid_t     un_devid;               /* device id */
 362         uint_t          un_vpd_page_mask;       /* Supported VPD pages */
 363 
 364         /*
 365          * Bit fields for various configuration/state/status info.
 366          * Comments indicate the condition if the value of the
 367          * variable is TRUE (nonzero).
 368          */
 369         uint32_t
 370             un_f_arq_enabled            :1,     /* Auto request sense is */
 371                                                 /* currently enabled */
 372             un_f_blockcount_is_valid    :1,     /* The un_blockcount */
 373                                                 /* value is currently valid */
 374             un_f_tgt_blocksize_is_valid :1,     /* The un_tgt_blocksize */
 375                                                 /* value is currently valid */
 376             un_f_allow_bus_device_reset :1,     /* Driver may issue a BDR as */
 377                                                 /* a part of error recovery. */
 378             un_f_is_fibre               :1,     /* The device supports fibre */
 379                                                 /* channel */
 380             un_f_sync_cache_supported   :1,     /* sync cache cmd supported */
 381                                                 /* supported */
 382             un_f_format_in_progress     :1,     /* The device is currently */
 383                                                 /* executing a FORMAT cmd. */
 384             un_f_opt_queueing           :1,     /* Enable Command Queuing to */
 385                                                 /* Host Adapter */
 386             un_f_opt_fab_devid          :1,     /* Disk has no valid/unique */
 387                                                 /* serial number.  */
 388             un_f_opt_disable_cache      :1,     /* Read/Write disk cache is */
 389                                                 /* disabled.  */
 390             un_f_cfg_is_atapi           :1,     /* This is an ATAPI device.  */
 391             un_f_write_cache_enabled    :1,     /* device return success on */
 392                                                 /* writes before transfer to */
 393                                                 /* physical media complete */
 394             un_f_cfg_playmsf_bcd        :1,     /* Play Audio, BCD params. */
 395             un_f_cfg_readsub_bcd        :1,     /* READ SUBCHANNEL BCD resp. */
 396             un_f_cfg_read_toc_trk_bcd   :1,     /* track # is BCD */
 397             un_f_cfg_read_toc_addr_bcd  :1,     /* address is BCD */
 398             un_f_cfg_no_read_header     :1,     /* READ HEADER not supported */
 399             un_f_cfg_read_cd_xd4        :1,     /* READ CD opcode is 0xd4 */
 400             un_f_mmc_cap                :1,     /* Device is MMC compliant */
 401             un_f_mmc_writable_media     :1,     /* writable media in device */
 402             un_f_dvdram_writable_device :1,     /* DVDRAM device is writable */
 403             un_f_cfg_cdda               :1,     /* READ CDDA supported */
 404             un_f_cfg_tur_check          :1,     /* verify un_ncmds before tur */
 405 
 406             un_f_use_adaptive_throttle  :1,     /* enable/disable adaptive */
 407                                                 /* throttling */
 408             un_f_pm_is_enabled          :1,     /* PM is enabled on this */
 409                                                 /* instance */
 410             un_f_watcht_stopped         :1,     /* media watch thread flag */
 411             un_f_pkstats_enabled        :1,     /* Flag to determine if */
 412                                                 /* partition kstats are */
 413                                                 /* enabled. */
 414             un_f_disksort_disabled      :1,     /* Flag to disable disksort */
 415             un_f_lun_reset_enabled      :1,     /* Set if target supports */
 416                                                 /* SCSI Logical Unit Reset */
 417             un_f_doorlock_supported     :1,     /* Device supports Doorlock */
 418             un_f_start_stop_supported   :1,     /* device has motor */
 419             un_f_reserved1              :1;
 420 
 421         uint32_t
 422             un_f_mboot_supported        :1,     /* mboot supported */
 423             un_f_is_hotpluggable        :1,     /* hotpluggable */
 424             un_f_has_removable_media    :1,     /* has removable media */
 425             un_f_non_devbsize_supported :1,     /* non-512 blocksize */
 426             un_f_devid_supported        :1,     /* device ID supported */
 427             un_f_eject_media_supported  :1,     /* media can be ejected */
 428             un_f_chk_wp_open            :1,     /* check if write-protected */
 429                                                 /* when being opened */
 430             un_f_descr_format_supported :1,     /* support descriptor format */
 431                                                 /* for sense data */
 432             un_f_check_start_stop       :1,     /* needs to check if */
 433                                                 /* START-STOP command is */
 434                                                 /* supported by hardware */
 435                                                 /* before issuing it */
 436             un_f_monitor_media_state    :1,     /* need a watch thread to */
 437                                                 /* monitor device state */
 438             un_f_attach_spinup          :1,     /* spin up once the */
 439                                                 /* device is attached */
 440             un_f_log_sense_supported    :1,     /* support log sense */
 441             un_f_pm_supported           :1,     /* support power-management */
 442             un_f_cfg_is_lsi             :1,     /* Is LSI device, */
 443                                                 /* default to NO */
 444             un_f_wcc_inprog             :1,     /* write cache change in */
 445                                                 /* progress */
 446             un_f_ejecting               :1,     /* media is ejecting */
 447             un_f_suppress_cache_flush   :1,     /* supress flush on */
 448                                                 /* write cache */
 449             un_f_sync_nv_supported      :1,     /* SYNC_NV */
 450                                                 /* bit is supported */
 451             un_f_sync_cache_required    :1,     /* flag to check if */
 452                                                 /* SYNC CACHE needs to be */
 453                                                 /* sent in sdclose */
 454             un_f_devid_transport_defined :1,    /* devid defined by transport */
 455             un_f_rmw_type                :2,    /* RMW type */
 456             un_f_power_condition_disabled :1,   /* power condition disabled */
 457                                                 /* through sd configuration */
 458             un_f_power_condition_supported :1,  /* support power condition */
 459                                                 /* field by hardware */
 460             un_f_pm_log_sense_smart     :1,     /* log sense support SMART */
 461                                                 /* feature attribute */
 462             un_f_is_solid_state         :1,     /* has solid state media */
 463             un_f_is_rotational          :1,     /* spinning rust */
 464             un_f_mmc_gesn_polling       :1,     /* use GET EVENT STATUS */
 465                                                 /* NOTIFICATION for polling */
 466             un_f_enable_rmw             :1,     /* Force RMW in sd driver */
 467             un_f_expnevent              :1,
 468             un_f_cache_mode_changeable  :1,     /* can change cache mode */
 469             un_f_reserved               :1;
 470 
 471         /* Ptr to table of strings for ASC/ASCQ error message printing */
 472         struct scsi_asq_key_strings     *un_additional_codes;
 473 
 474         /*
 475          * Power Management support.
 476          *
 477          * un_pm_mutex protects, un_pm_count, un_pm_timeid, un_pm_busy,
 478          * un_pm_busy_cv, and un_pm_idle_timeid.
 479          * It's not required that SD_MUTEX be acquired before acquiring
 480          * un_pm_mutex, however if they must both be held
 481          * then acquire SD_MUTEX first.
 482          *
 483          * un_pm_count is used to indicate PM state as follows:
 484          *      less than 0 the device is powered down,
 485          *      transition from 0 ==> 1, mark the device as busy via DDI
 486          *      transition from 1 ==> 0, mark the device as idle via DDI
 487          */
 488         kmutex_t        un_pm_mutex;
 489         int             un_pm_count;            /* indicates pm state */
 490         timeout_id_t    un_pm_timeid;           /* timeout id for pm */
 491         uint_t          un_pm_busy;
 492         kcondvar_t      un_pm_busy_cv;
 493         short           un_power_level;         /* Power Level */
 494         uchar_t         un_save_state;
 495         kcondvar_t      un_suspend_cv;          /* power management */
 496         kcondvar_t      un_disk_busy_cv;        /* wait for IO completion */
 497 
 498         /* Resources used for media change callback support */
 499         kcondvar_t      un_state_cv;            /* Cond Var on mediastate */
 500         enum dkio_state un_mediastate;          /* current media state */
 501         enum dkio_state un_specified_mediastate; /* expected state */
 502         opaque_t        un_swr_token;           /* scsi_watch request token */
 503 
 504         /* Non-512 byte block support */
 505         struct kmem_cache *un_wm_cache; /* fast alloc in non-512 write case */
 506         uint_t          un_rmw_count;   /* count of read-modify-writes */
 507         struct sd_w_map *un_wm;         /* head of sd_w_map chain */
 508         uint64_t        un_rmw_incre_count;     /* count I/O */
 509         timeout_id_t    un_rmw_msg_timeid;      /* for RMW message control */
 510 
 511         /* For timeout callback to issue a START STOP UNIT command */
 512         timeout_id_t    un_startstop_timeid;
 513 
 514         /* Timeout callback handle for SD_PATH_DIRECT_PRIORITY cmd restarts */
 515         timeout_id_t    un_direct_priority_timeid;
 516 
 517         /* TRAN_FATAL_ERROR count. Cleared by TRAN_ACCEPT from scsi_transport */
 518         ulong_t         un_tran_fatal_count;
 519 
 520         timeout_id_t    un_retry_timeid;
 521 
 522         hrtime_t        un_pm_idle_time;
 523         timeout_id_t    un_pm_idle_timeid;
 524 
 525         /*
 526          * Count to determine if a Sonoma controller is in the process of
 527          * failing over, and how many I/O's are failed with the 05/94/01
 528          * sense code.
 529          */
 530         uint_t          un_sonoma_failure_count;
 531 
 532         /*
 533          * Support for failfast operation.
 534          */
 535         struct buf      *un_failfast_bp;
 536         struct buf      *un_failfast_headp;
 537         struct buf      *un_failfast_tailp;
 538         uint32_t        un_failfast_state;
 539         /* Callback routine active counter */
 540         short           un_in_callback;
 541 
 542         kcondvar_t      un_wcc_cv;      /* synchronize changes to */
 543                                         /* un_f_write_cache_enabled */
 544 
 545 #ifdef SD_FAULT_INJECTION
 546         /* SD Fault Injection */
 547 #define SD_FI_MAX_BUF 65536
 548 #define SD_FI_MAX_ERROR 1024
 549         kmutex_t                        un_fi_mutex;
 550         uint_t                          sd_fi_buf_len;
 551         char                            sd_fi_log[SD_FI_MAX_BUF];
 552         struct sd_fi_pkt        *sd_fi_fifo_pkt[SD_FI_MAX_ERROR];
 553         struct sd_fi_xb         *sd_fi_fifo_xb[SD_FI_MAX_ERROR];
 554         struct sd_fi_un         *sd_fi_fifo_un[SD_FI_MAX_ERROR];
 555         struct sd_fi_arq        *sd_fi_fifo_arq[SD_FI_MAX_ERROR];
 556         uint_t                          sd_fi_fifo_start;
 557         uint_t                          sd_fi_fifo_end;
 558         uint_t                          sd_injection_mask;
 559 
 560 #endif
 561 
 562         cmlb_handle_t   un_cmlbhandle;
 563 
 564         /*
 565          * Pointer to internal struct sd_fm_internal in which
 566          * will pass necessary information for FMA ereport posting.
 567          */
 568         void            *un_fm_private;
 569 };
 570 
 571 #define SD_IS_VALID_LABEL(un)  (cmlb_is_valid(un->un_cmlbhandle))
 572 
 573 /*
 574  * Macros for conversions between "target" and "system" block sizes, and
 575  * for conversion between block counts and byte counts.  As used here,
 576  * "system" block size refers to the block size used by the kernel/
 577  * filesystem (this includes the disk label). The "target" block size
 578  * is the block size returned by the SCSI READ CAPACITY command.
 579  *
 580  * Note: These macros will round up to the next largest blocksize to accomodate
 581  * the number of blocks specified.
 582  */
 583 
 584 /* Convert a byte count to a number of target blocks */
 585 #define SD_BYTES2TGTBLOCKS(un, bytecount)                               \
 586         ((bytecount + (un->un_tgt_blocksize - 1))/un->un_tgt_blocksize)
 587 
 588 /* Convert a byte count to a number of physical blocks */
 589 #define SD_BYTES2PHYBLOCKS(un, bytecount)                               \
 590         ((bytecount + (un->un_phy_blocksize - 1))/un->un_phy_blocksize)
 591 
 592 /* Convert a target block count to a number of bytes */
 593 #define SD_TGTBLOCKS2BYTES(un, blockcount)                              \
 594         (blockcount * (un)->un_tgt_blocksize)
 595 
 596 /* Convert a byte count to a number of system blocks */
 597 #define SD_BYTES2SYSBLOCKS(bytecount)                           \
 598         ((bytecount + (DEV_BSIZE - 1))/DEV_BSIZE)
 599 
 600 /* Convert a system block count to a number of bytes */
 601 #define SD_SYSBLOCKS2BYTES(blockcount)                          \
 602         (blockcount * DEV_BSIZE)
 603 
 604 /*
 605  * Calculate the number of bytes needed to hold the requested number of bytes
 606  * based upon the native target sector/block size
 607  */
 608 #define SD_REQBYTES2TGTBYTES(un, bytecount)                             \
 609         (SD_BYTES2TGTBLOCKS(un, bytecount) * (un)->un_tgt_blocksize)
 610 
 611 /*
 612  * Calculate the byte offset from the beginning of the target block
 613  * to the system block location.
 614  */
 615 #define SD_TGTBYTEOFFSET(un, sysblk, tgtblk)                            \
 616         (SD_SYSBLOCKS2BYTES(sysblk) - SD_TGTBLOCKS2BYTES(un, tgtblk))
 617 
 618 /*
 619  * Calculate the target block location from the system block location
 620  */
 621 #define SD_SYS2TGTBLOCK(un, blockcnt)                                   \
 622         (blockcnt / ((un)->un_tgt_blocksize / DEV_BSIZE))
 623 
 624 /*
 625  * Calculate the target block location from the system block location
 626  */
 627 #define SD_TGT2SYSBLOCK(un, blockcnt)                                   \
 628         (blockcnt * ((un)->un_tgt_blocksize / DEV_BSIZE))
 629 
 630 /*
 631  * SD_DEFAULT_MAX_XFER_SIZE is the default value to bound the max xfer
 632  * for physio, for devices without tagged queuing enabled.
 633  * The default for devices with tagged queuing enabled is SD_MAX_XFER_SIZE
 634  */
 635 #if defined(__i386) || defined(__amd64)
 636 #define SD_DEFAULT_MAX_XFER_SIZE        (256 * 1024)
 637 #endif
 638 #define SD_MAX_XFER_SIZE                (1024 * 1024)
 639 
 640 /*
 641  * Warlock annotations
 642  */
 643 _NOTE(MUTEX_PROTECTS_DATA(scsi_device::sd_mutex, sd_lun))
 644 _NOTE(READ_ONLY_DATA(sd_lun::un_sd))
 645 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_reservation_type))
 646 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_mincdb))
 647 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_maxcdb))
 648 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_max_hba_cdb))
 649 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_status_len))
 650 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_f_arq_enabled))
 651 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_ctype))
 652 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_cmlbhandle))
 653 _NOTE(DATA_READABLE_WITHOUT_LOCK(sd_lun::un_fm_private))
 654 
 655 
 656 _NOTE(SCHEME_PROTECTS_DATA("safe sharing",
 657         sd_lun::un_mhd_token
 658         sd_lun::un_state
 659         sd_lun::un_tagflags
 660         sd_lun::un_f_format_in_progress
 661         sd_lun::un_resvd_timeid
 662         sd_lun::un_reset_throttle_timeid
 663         sd_lun::un_startstop_timeid
 664         sd_lun::un_dcvb_timeid
 665         sd_lun::un_f_allow_bus_device_reset
 666         sd_lun::un_sys_blocksize
 667         sd_lun::un_tgt_blocksize
 668         sd_lun::un_phy_blocksize
 669         sd_lun::un_additional_codes))
 670 
 671 _NOTE(SCHEME_PROTECTS_DATA("stable data",
 672         sd_lun::un_reserve_release_time
 673         sd_lun::un_max_xfer_size
 674         sd_lun::un_partial_dma_supported
 675         sd_lun::un_buf_breakup_supported
 676         sd_lun::un_f_is_fibre
 677         sd_lun::un_node_type
 678         sd_lun::un_buf_chain_type
 679         sd_lun::un_uscsi_chain_type
 680         sd_lun::un_direct_chain_type
 681         sd_lun::un_priority_chain_type
 682         sd_lun::un_xbuf_attr
 683         sd_lun::un_cmd_timeout
 684         sd_lun::un_pkt_flags))
 685 
 686 _NOTE(SCHEME_PROTECTS_DATA("Unshared data",
 687         block_descriptor
 688         buf
 689         cdrom_subchnl
 690         cdrom_tocentry
 691         cdrom_tochdr
 692         cdrom_read
 693         dk_cinfo
 694         dk_devid
 695         dk_label
 696         dk_map
 697         dk_temperature
 698         mhioc_inkeys
 699         mhioc_inresvs
 700         mode_caching
 701         mode_header
 702         mode_speed
 703         scsi_cdb
 704         scsi_arq_status
 705         scsi_extended_sense
 706         scsi_inquiry
 707         scsi_pkt
 708         uio
 709         uscsi_cmd))
 710 
 711 
 712 _NOTE(SCHEME_PROTECTS_DATA("stable data", scsi_device dk_cinfo))
 713 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", scsi_status scsi_cdb))
 714 
 715 _NOTE(MUTEX_PROTECTS_DATA(sd_lun::un_pm_mutex, sd_lun::un_pm_count
 716         sd_lun::un_pm_timeid sd_lun::un_pm_busy sd_lun::un_pm_busy_cv
 717         sd_lun::un_pm_idle_timeid))
 718 
 719 #ifdef SD_FAULT_INJECTION
 720 _NOTE(MUTEX_PROTECTS_DATA(sd_lun::un_fi_mutex,
 721         sd_lun::sd_fi_buf_len sd_lun::sd_fi_log))
 722 #endif
 723 
 724 /* _NOTE(LOCK_ORDER(sd_lun::un_sd.sd_mutex sd_lun::un_pm_mutex)) */
 725 
 726 
 727 
 728 /*
 729  * Referenced for frequently-accessed members of the unit structure
 730  */
 731 #define SD_SCSI_DEVP(un)        ((un)->un_sd)
 732 #define SD_DEVINFO(un)          ((un)->un_sd->sd_dev)
 733 #define SD_INQUIRY(un)          ((un)->un_sd->sd_inq)
 734 #define SD_MUTEX(un)            (&((un)->un_sd->sd_mutex))
 735 #define SD_ADDRESS(un)          (&((un)->un_sd->sd_address))
 736 #define SD_GET_DEV(un)          (sd_make_device(SD_DEVINFO(un)))
 737 #define SD_FM_LOG(un)           (((struct sd_fm_internal *)\
 738                                 ((un)->un_fm_private))->fm_log_level)
 739 
 740 
 741 /*
 742  * Values for un_ctype
 743  */
 744 #define CTYPE_CDROM             0
 745 #define CTYPE_MD21              1       /* Obsolete! */
 746 #define CTYPE_CCS               2
 747 #define CTYPE_ROD               3
 748 #define CTYPE_PXRE              4       /* Obsolete! */
 749 
 750 #define ISCD(un)                ((un)->un_ctype == CTYPE_CDROM)
 751 #define ISROD(un)               ((un)->un_ctype == CTYPE_ROD)
 752 #define ISPXRE(un)              ((un)->un_ctype == CTYPE_PXRE)
 753 
 754 /*
 755  * This macro checks the vendor of the device to see if it is LSI. Because
 756  * LSI has some devices out there that return 'Symbios' or 'SYMBIOS', we
 757  * need to check for those also.
 758  *
 759  * This is used in some vendor specific checks.
 760  */
 761 #define SD_IS_LSI(un)   ((un)->un_f_cfg_is_lsi == TRUE)
 762 
 763 /*
 764  * Macros to check if the lun is a Sun T3 or a T4
 765  */
 766 #define SD_IS_T3(un) \
 767         ((bcmp(SD_INQUIRY(un)->inq_vid, "SUN", 3) == 0) && \
 768         (bcmp(SD_INQUIRY(un)->inq_pid, "T3", 2) == 0))
 769 
 770 #define SD_IS_T4(un) \
 771         ((bcmp(SD_INQUIRY(un)->inq_vid, "SUN", 3) == 0) && \
 772         (bcmp(SD_INQUIRY(un)->inq_pid, "T4", 2) == 0))
 773 
 774 /*
 775  * Macros for non-512 byte writes to removable devices.
 776  */
 777 #define NOT_DEVBSIZE(un)        \
 778         ((un)->un_tgt_blocksize != (un)->un_sys_blocksize)
 779 
 780 /*
 781  * Check that a write map, used for locking lba ranges for writes, is in
 782  * the linked list.
 783  */
 784 #define ONLIST(un, wmp)         \
 785         (((un)->un_wm == (wmp)) || ((wmp)->wm_prev != NULL))
 786 
 787 /*
 788  * Free a write map which is on list. Basically make sure that nobody is
 789  * sleeping on it before freeing it.
 790  */
 791 #define FREE_ONLIST_WMAP(un, wmp)                               \
 792         if (!(wmp)->wm_wanted_count) {                               \
 793                 sd_free_inlist_wmap((un), (wmp));               \
 794                 (wmp) = NULL;                                   \
 795         }
 796 
 797 #define CHK_N_FREEWMP(un, wmp)                                  \
 798         if (!ONLIST((un), (wmp))) {                             \
 799                 kmem_cache_free((un)->un_wm_cache, (wmp));   \
 800                 (wmp) = NULL;                                   \
 801         } else {                                                \
 802                 FREE_ONLIST_WMAP((un), (wmp));                  \
 803         }
 804 
 805 /*
 806  * Values used to in wm_flags field of sd_w_map.
 807  */
 808 #define SD_WTYPE_SIMPLE 0x001   /* Write aligned at blksize boundary */
 809 #define SD_WTYPE_RMW    0x002   /* Write requires read-modify-write */
 810 #define SD_WM_BUSY              0x100   /* write-map is busy */
 811 
 812 /*
 813  * RMW type
 814  */
 815 #define SD_RMW_TYPE_DEFAULT     0       /* do rmw with warning message */
 816 #define SD_RMW_TYPE_NO_WARNING  1       /* do rmw without warning message */
 817 #define SD_RMW_TYPE_RETURN_ERROR        2       /* rmw disabled */
 818 
 819 /* Device error kstats */
 820 struct sd_errstats {
 821         struct kstat_named      sd_softerrs;
 822         struct kstat_named      sd_harderrs;
 823         struct kstat_named      sd_transerrs;
 824         struct kstat_named      sd_vid;
 825         struct kstat_named      sd_pid;
 826         struct kstat_named      sd_revision;
 827         struct kstat_named      sd_serial;
 828         struct kstat_named      sd_capacity;
 829         struct kstat_named      sd_rq_media_err;
 830         struct kstat_named      sd_rq_ntrdy_err;
 831         struct kstat_named      sd_rq_nodev_err;
 832         struct kstat_named      sd_rq_recov_err;
 833         struct kstat_named      sd_rq_illrq_err;
 834         struct kstat_named      sd_rq_pfa_err;
 835 };
 836 
 837 
 838 /*
 839  * Structs and definitions for SCSI-3 Persistent Reservation
 840  */
 841 typedef struct sd_prin_readkeys {
 842         uint32_t        generation;
 843         uint32_t        len;
 844         mhioc_resv_key_t *keylist;
 845 } sd_prin_readkeys_t;
 846 
 847 typedef struct sd_readresv_desc {
 848         mhioc_resv_key_t        resvkey;
 849         uint32_t                scope_specific_addr;
 850         uint8_t                 reserved_1;
 851 #if defined(_BIT_FIELDS_LTOH)
 852         uint8_t                 type:4,
 853                                 scope:4;
 854 #elif defined(_BIT_FIELDS_HTOL)
 855         uint8_t                 scope:4,
 856                                 type:4;
 857 #else
 858 #error  One of _BIT_FIELDS_LTOH or _BIT_FIELDS_HTOL must be defined
 859 #endif  /* _BIT_FIELDS_LTOH */
 860         uint8_t                 reserved_2;
 861         uint8_t                 reserved_3;
 862 } sd_readresv_desc_t;
 863 
 864 typedef struct sd_prin_readresv {
 865         uint32_t                generation;
 866         uint32_t                len;
 867         sd_readresv_desc_t      *readresv_desc;
 868 } sd_prin_readresv_t;
 869 
 870 typedef struct sd_prout {
 871         uchar_t         res_key[MHIOC_RESV_KEY_SIZE];
 872         uchar_t         service_key[MHIOC_RESV_KEY_SIZE];
 873         uint32_t        scope_address;
 874 #if defined(_BIT_FIELDS_LTOH)
 875         uchar_t         aptpl:1,
 876                         reserved:7;
 877 #elif defined(_BIT_FIELDS_HTOL)
 878         uchar_t         reserved:7,
 879                         aptpl:1;
 880 #else
 881 #error  One of _BIT_FIELDS_LTOH or _BIT_FIELDS_HTOL must be defined
 882 #endif  /* _BIT_FIELDS_LTOH */
 883         uchar_t         reserved_1;
 884         uint16_t        ext_len;
 885 } sd_prout_t;
 886 
 887 #define SD_READ_KEYS                    0x00
 888 #define SD_READ_RESV                    0x01
 889 
 890 #define SD_SCSI3_REGISTER               0x00
 891 #define SD_SCSI3_RESERVE                0x01
 892 #define SD_SCSI3_RELEASE                0x02
 893 #define SD_SCSI3_CLEAR                  0x03
 894 #define SD_SCSI3_PREEMPTANDABORT        0x05
 895 #define SD_SCSI3_REGISTERANDIGNOREKEY   0x06
 896 
 897 /*
 898  * Note: The default init of un_reservation_type is to the value of '0'
 899  * (from the ddi_softs_state_zalloc) which means it is defaulting to SCSI-3
 900  * reservation type. This is ok because during attach we use a SCSI-3
 901  * PRIORITY RESERVE IN command to determine the reservation type, and set
 902  * un_reservation_type for all cases.
 903  */
 904 #define SD_SCSI3_RESERVATION            0x0
 905 #define SD_SCSI2_RESERVATION            0x1
 906 #define SCSI3_RESV_DESC_LEN             16
 907 
 908 /*
 909  * Reservation Status's
 910  */
 911 #define SD_RELEASE                      0x0000
 912 #define SD_RESERVE                      0x0001
 913 #define SD_TKOWN                        0x0002
 914 #define SD_LOST_RESERVE                 0x0004
 915 #define SD_FAILFAST                     0x0080
 916 #define SD_WANT_RESERVE                 0x0100
 917 #define SD_RESERVATION_CONFLICT         0x0200
 918 #define SD_PRIORITY_RESERVE             0x0400
 919 
 920 #define SD_TARGET_IS_UNRESERVED         0
 921 #define SD_TARGET_IS_RESERVED           1
 922 
 923 /*
 924  * Save page in mode_select
 925  */
 926 #define SD_DONTSAVE_PAGE                0
 927 #define SD_SAVE_PAGE                    1
 928 
 929 /*
 930  * Delay before reclaiming reservation is 6 seconds, in units of micro seconds
 931  */
 932 #define SD_REINSTATE_RESV_DELAY         6000000
 933 
 934 #define SD_MODE2_BLKSIZE                2336    /* bytes */
 935 
 936 /*
 937  * Solid State Drive default sector size
 938  */
 939 #define SSD_SECSIZE                     4096
 940 
 941 /*
 942  * Resource type definitions for multi host control operations. Specifically,
 943  * queue and request definitions for reservation request handling between the
 944  * scsi facility callback function (sd_mhd_watch_cb) and the reservation
 945  * reclaim thread (sd_resv_reclaim_thread)
 946  */
 947 struct sd_thr_request {
 948         dev_t   dev;
 949         struct  sd_thr_request  *sd_thr_req_next;
 950 };
 951 
 952 struct sd_resv_reclaim_request {
 953         kthread_t               *srq_resv_reclaim_thread;
 954         struct  sd_thr_request  *srq_thr_req_head;
 955         struct  sd_thr_request  *srq_thr_cur_req;
 956         kcondvar_t              srq_inprocess_cv;
 957         kmutex_t                srq_resv_reclaim_mutex;
 958         kcondvar_t              srq_resv_reclaim_cv;
 959 };
 960 
 961 _NOTE(MUTEX_PROTECTS_DATA(sd_resv_reclaim_request::srq_resv_reclaim_mutex,
 962     sd_resv_reclaim_request))
 963 _NOTE(SCHEME_PROTECTS_DATA("unshared data", sd_thr_request))
 964 _NOTE(SCHEME_PROTECTS_DATA("Unshared data", sd_prout))
 965 
 966 
 967 
 968 /*
 969  * Driver Logging Components
 970  *
 971  * These components cover the functional entry points and areas of the
 972  * driver.  A component value is used for the entry point and utility
 973  * functions used by the entry point. The common component value is used
 974  * in those routines that are called from many areas of the driver.
 975  *
 976  * This can be done by adding the following two lines to /etc/system:
 977  * set sd:sd_component_mask=0x00080000
 978  * set sd:sd_level_mask=0x00000008
 979  */
 980 #define SD_LOG_PROBE                    0x00000001
 981 #define SD_LOG_ATTACH_DETACH            0x00000002
 982 #define SD_LOG_OPEN_CLOSE               0x00000004
 983 #define SD_LOG_READ_WRITE               0x00000008
 984 #define SD_LOG_POWER                    0x00000010
 985 #define SD_LOG_IOCTL                    0x00000020
 986 #define SD_LOG_IOCTL_MHD                0x00000040
 987 #define SD_LOG_IOCTL_RMMEDIA            0x00000080
 988 #define SD_LOG_IOCTL_DKIO               0x00000100
 989 #define SD_LOG_IO                       0x00000200
 990 #define SD_LOG_IO_CORE                  0x00000400
 991 #define SD_LOG_IO_DISKSORT              0x00000800
 992 #define SD_LOG_IO_PARTITION             0x00001000
 993 #define SD_LOG_IO_RMMEDIA               0x00002000
 994 #define SD_LOG_IO_CHKSUM                0x00004000
 995 #define SD_LOG_IO_SDIOCTL               0x00008000
 996 #define SD_LOG_IO_PM                    0x00010000
 997 #define SD_LOG_ERROR                    0x00020000
 998 #define SD_LOG_DUMP                     0x00040000
 999 #define SD_LOG_COMMON                   0x00080000
1000 #define SD_LOG_SDTEST                   0x00100000
1001 #define SD_LOG_IOERR                    0x00200000
1002 #define SD_LOG_IO_FAILFAST              0x00400000
1003 
1004 /* Driver Logging Levels */
1005 #define SD_LOGMASK_ERROR                0x00000001
1006 #define SD_LOGMASK_DUMP_MEM             0x00000002
1007 #define SD_LOGMASK_INFO                 0x00000004
1008 #define SD_LOGMASK_TRACE                0x00000008
1009 #define SD_LOGMASK_DIAG                 0x00000010
1010 
1011 /* Driver Logging Formats */
1012 #define SD_LOG_HEX                      0x00000001
1013 #define SD_LOG_CHAR                     0x00000002
1014 
1015 /*
1016  * The following macros should be used to log driver debug information
1017  * only. The output is filtered according to the component and level mask
1018  * values. Non-debug information, such as driver warnings intended for
1019  * the user should be logged via the scsi_log facility to ensure that
1020  * they are not filtered.
1021  */
1022 #if DEBUG || lint
1023 #define SDDEBUG
1024 
1025 /* SD_ERROR is called to log driver error conditions */
1026 #define SD_ERROR        sd_log_err
1027 
1028 /* SD_TRACE is called to log driver trace conditions (function entry/exit) */
1029 #define SD_TRACE        sd_log_trace
1030 
1031 /* SD_INFO is called to log general purpose driver info */
1032 #define SD_INFO         sd_log_info
1033 
1034 /* SD_DUMP_MEMORY is called to dump a data buffer to the log */
1035 #define SD_DUMP_MEMORY  sd_dump_memory
1036 
1037 /* RESET/ABORTS testing ioctls */
1038 #define DKIOCRESET      (DKIOC|14)
1039 #define DKIOCABORT      (DKIOC|15)
1040 
1041 #ifdef SD_FAULT_INJECTION
1042 /*
1043  * sd_fi_pkt replicates the variables that are exposed through pkt
1044  *
1045  * sd_fi_xb replicates the variables that are exposed through xb
1046  *
1047  * sd_fi_un replicates the variables that are exposed through un
1048  *
1049  * sd_fi_arq replicates the variables that are
1050  *           exposed for Auto-Reqeust-Sense
1051  *
1052  */
1053 struct sd_fi_pkt {
1054         uint_t  pkt_flags;                      /* flags */
1055         uchar_t pkt_scbp;                       /* pointer to status block */
1056         uchar_t pkt_cdbp;                       /* pointer to command block */
1057         uint_t  pkt_state;                      /* state of command */
1058         uint_t  pkt_statistics;         /* statistics */
1059         uchar_t pkt_reason;                     /* reason completion called */
1060 };
1061 
1062 struct sd_fi_xb {
1063         daddr_t xb_blkno;
1064         ssize_t xb_dma_resid;
1065         short   xb_retry_count;
1066         short   xb_victim_retry_count;
1067         uchar_t xb_sense_status;
1068         uint_t  xb_sense_state;
1069         ssize_t xb_sense_resid;
1070         uchar_t xb_sense_data[SENSE_LENGTH];
1071         uchar_t es_code;
1072         uchar_t es_key;
1073         uchar_t es_add_code;
1074         uchar_t es_qual_code;
1075 };
1076 
1077 struct sd_fi_un {
1078         uchar_t inq_rmb;
1079         uchar_t un_ctype;
1080         uint_t  un_notready_retry_count;
1081         uint_t  un_reset_retry_count;
1082         uchar_t un_reservation_type;
1083         ushort_t un_notrdy_delay;
1084         short   un_resvd_status;
1085         uint32_t
1086                 un_f_arq_enabled,
1087                 un_f_allow_bus_device_reset,
1088                 un_f_opt_queueing;
1089         timeout_id_t    un_restart_timeid;
1090 };
1091 
1092 struct sd_fi_arq {
1093         struct scsi_status      sts_status;
1094         struct scsi_status      sts_rqpkt_status;
1095         uchar_t                         sts_rqpkt_reason;
1096         uchar_t                         sts_rqpkt_resid;
1097         uint_t                          sts_rqpkt_state;
1098         uint_t                          sts_rqpkt_statistics;
1099         struct scsi_extended_sense      sts_sensedata;
1100 };
1101 
1102 /*
1103  * Conditional set def
1104  */
1105 #define SD_CONDSET(a, b, c, d)                  \
1106         { \
1107         a->c = ((fi_ ## b)->c);                   \
1108         SD_INFO(SD_LOG_IOERR, un,               \
1109                         "sd_fault_injection:"   \
1110                         "setting %s to %d\n",   \
1111                         d, ((fi_ ## b)->c));         \
1112         }
1113 
1114 /* SD FaultInjection ioctls */
1115 #define SDIOC                   ('T'<<8)
1116 #define SDIOCSTART              (SDIOC|1)
1117 #define SDIOCSTOP               (SDIOC|2)
1118 #define SDIOCINSERTPKT  (SDIOC|3)
1119 #define SDIOCINSERTXB   (SDIOC|4)
1120 #define SDIOCINSERTUN   (SDIOC|5)
1121 #define SDIOCINSERTARQ  (SDIOC|6)
1122 #define SDIOCPUSH               (SDIOC|7)
1123 #define SDIOCRETRIEVE   (SDIOC|8)
1124 #define SDIOCRUN                (SDIOC|9)
1125 #endif
1126 
1127 #else
1128 
1129 #undef  SDDEBUG
1130 #define SD_ERROR        { if (0) sd_log_err; }
1131 #define SD_TRACE        { if (0) sd_log_trace; }
1132 #define SD_INFO         { if (0) sd_log_info; }
1133 #define SD_DUMP_MEMORY  { if (0) sd_dump_memory; }
1134 #endif
1135 
1136 
1137 /*
1138  * Miscellaneous macros
1139  */
1140 
1141 #define SD_USECTOHZ(x)                  (drv_usectohz((x)*1000000))
1142 #define SD_GET_PKT_STATUS(pktp)         ((*(pktp)->pkt_scbp) & STATUS_MASK)
1143 
1144 #define SD_BIOERROR(bp, errcode)                                        \
1145         if ((bp)->b_resid == 0) {                                    \
1146                 (bp)->b_resid = (bp)->b_bcount;                           \
1147         }                                                               \
1148         if ((bp)->b_error == 0) {                                    \
1149                 bioerror(bp, errcode);                                  \
1150         }                                                               \
1151         (bp)->b_flags |= B_ERROR;
1152 
1153 #define SD_FILL_SCSI1_LUN_CDB(lunp, cdbp)                               \
1154         if (! (lunp)->un_f_is_fibre &&                                       \
1155             SD_INQUIRY((lunp))->inq_ansi == 0x01) {                  \
1156                 int _lun = ddi_prop_get_int(DDI_DEV_T_ANY,              \
1157                     SD_DEVINFO((lunp)), DDI_PROP_DONTPASS,              \
1158                     SCSI_ADDR_PROP_LUN, 0);                             \
1159                 if (_lun > 0) {                                              \
1160                         (cdbp)->scc_lun = _lun;                              \
1161                 }                                                       \
1162         }
1163 
1164 #define SD_FILL_SCSI1_LUN(lunp, pktp)                                   \
1165         SD_FILL_SCSI1_LUN_CDB((lunp), (union scsi_cdb *)(pktp)->pkt_cdbp)
1166 
1167 /*
1168  * Disk driver states
1169  */
1170 
1171 #define SD_STATE_NORMAL         0
1172 #define SD_STATE_OFFLINE        1
1173 #define SD_STATE_RWAIT          2
1174 #define SD_STATE_DUMPING        3
1175 #define SD_STATE_SUSPENDED      4
1176 #define SD_STATE_PM_CHANGING    5
1177 
1178 /*
1179  * The table is to be interpreted as follows: The rows lists all the states
1180  * and each column is a state that a state in each row *can* reach. The entries
1181  * in the table list the event that cause that transition to take place.
1182  * For e.g.: To go from state RWAIT to SUSPENDED, event (d)-- which is the
1183  * invocation of DDI_SUSPEND-- has to take place. Note the same event could
1184  * cause the transition from one state to two different states. e.g., from
1185  * state SUSPENDED, when we get a DDI_RESUME, we just go back to the *last
1186  * state* whatever that might be. (NORMAL or OFFLINE).
1187  *
1188  *
1189  * State Transition Table:
1190  *
1191  *                    NORMAL  OFFLINE  RWAIT  DUMPING  SUSPENDED  PM_SUSPENDED
1192  *
1193  *   NORMAL              -      (a)      (b)     (c)      (d)       (h)
1194  *
1195  *   OFFLINE            (e)      -       (e)     (c)      (d)       NP
1196  *
1197  *   RWAIT              (f)     NP        -      (c)      (d)       (h)
1198  *
1199  *   DUMPING            NP      NP        NP      -        NP       NP
1200  *
1201  *   SUSPENDED          (g)     (g)       (b)     NP*      -        NP
1202  *
1203  *   PM_SUSPENDED       (i)     NP        (b)    (c)      (d)       -
1204  *
1205  *   NP :       Not Possible.
1206  *   (a):       Disk does not respond.
1207  *   (b):       Packet Allocation Fails
1208  *   (c):       Panic - Crash dump
1209  *   (d):       DDI_SUSPEND is called.
1210  *   (e):       Disk has a successful I/O completed.
1211  *   (f):       sdrunout() calls sdstart() which sets it NORMAL
1212  *   (g):       DDI_RESUME is called.
1213  *   (h):       Device threshold exceeded pm framework called power
1214  *              entry point or pm_lower_power called in detach.
1215  *   (i):       When new I/O come in.
1216  *    * :       When suspended, we dont change state during panic dump
1217  */
1218 
1219 
1220 #define SD_MAX_THROTTLE         256
1221 #define SD_MIN_THROTTLE         8
1222 /*
1223  * Lowest valid max. and min. throttle value.
1224  * This is set to 2 because if un_min_throttle were allowed to be 1 then
1225  * un_throttle would never get set to a value less than un_min_throttle
1226  * (0 is a special case) which means it would never get set back to
1227  * un_saved_throttle in routine sd_restore_throttle().
1228  */
1229 #define SD_LOWEST_VALID_THROTTLE        2
1230 
1231 
1232 
1233 /* Return codes for sd_send_polled_cmd() and sd_scsi_poll() */
1234 #define SD_CMD_SUCCESS                  0
1235 #define SD_CMD_FAILURE                  1
1236 #define SD_CMD_RESERVATION_CONFLICT     2
1237 #define SD_CMD_ILLEGAL_REQUEST          3
1238 #define SD_CMD_BECOMING_READY           4
1239 #define SD_CMD_CHECK_CONDITION          5
1240 
1241 /* Return codes for sd_ready_and_valid */
1242 #define SD_READY_VALID                  0
1243 #define SD_NOT_READY_VALID              1
1244 #define SD_RESERVED_BY_OTHERS           2
1245 
1246 #define SD_PATH_STANDARD                0
1247 #define SD_PATH_DIRECT                  1
1248 #define SD_PATH_DIRECT_PRIORITY         2
1249 
1250 #define SD_UNIT_ATTENTION_RETRY         40
1251 
1252 /*
1253  * The following three are bit flags passed into sd_send_scsi_TEST_UNIT_READY
1254  * to control specific behavior.
1255  */
1256 #define SD_CHECK_FOR_MEDIA              0x01
1257 #define SD_DONT_RETRY_TUR               0x02
1258 #define SD_BYPASS_PM                    0x04
1259 
1260 #define SD_GROUP0_MAX_ADDRESS   (0x1fffff)
1261 #define SD_GROUP0_MAXCOUNT      (0xff)
1262 #define SD_GROUP1_MAX_ADDRESS   (0xffffffff)
1263 #define SD_GROUP1_MAXCOUNT      (0xffff)
1264 
1265 #define SD_BECOMING_ACTIVE      0x01
1266 #define SD_REMOVAL_ALLOW        0
1267 #define SD_REMOVAL_PREVENT      1
1268 
1269 #define SD_GET_PKT_OPCODE(pktp) \
1270         (((union scsi_cdb *)((pktp)->pkt_cdbp))->cdb_un.cmd)
1271 
1272 
1273 #define SD_NO_RETRY_ISSUED              0
1274 #define SD_DELAYED_RETRY_ISSUED         1
1275 #define SD_IMMEDIATE_RETRY_ISSUED       2
1276 
1277 #if defined(__i386) || defined(__amd64)
1278 #define SD_UPDATE_B_RESID(bp, pktp)     \
1279         ((bp)->b_resid += (pktp)->pkt_resid + (SD_GET_XBUF(bp)->xb_dma_resid))
1280 #else
1281 #define SD_UPDATE_B_RESID(bp, pktp)     \
1282         ((bp)->b_resid += (pktp)->pkt_resid)
1283 #endif
1284 
1285 
1286 #define SD_RETRIES_MASK         0x00FF
1287 #define SD_RETRIES_NOCHECK      0x0000
1288 #define SD_RETRIES_STANDARD     0x0001
1289 #define SD_RETRIES_VICTIM       0x0002
1290 #define SD_RETRIES_BUSY         0x0003
1291 #define SD_RETRIES_UA           0x0004
1292 #define SD_RETRIES_ISOLATE      0x8000
1293 #define SD_RETRIES_FAILFAST     0x4000
1294 
1295 #define SD_UPDATE_RESERVATION_STATUS(un, pktp)                          \
1296 if (((pktp)->pkt_reason == CMD_RESET) ||                             \
1297         ((pktp)->pkt_statistics & (STAT_BUS_RESET | STAT_DEV_RESET))) { \
1298         if (((un)->un_resvd_status & SD_RESERVE) == SD_RESERVE) {        \
1299                 (un)->un_resvd_status |=                             \
1300                     (SD_LOST_RESERVE | SD_WANT_RESERVE);                \
1301         }                                                               \
1302 }
1303 
1304 #define SD_SENSE_DATA_IS_VALID          0
1305 #define SD_SENSE_DATA_IS_INVALID        1
1306 
1307 /*
1308  * Delay (in seconds) before restoring the "throttle limit" back
1309  * to its maximum value.
1310  * 60 seconds is what we will wait for to reset the
1311  * throttle back to it SD_MAX_THROTTLE for TRAN_BUSY.
1312  * 10 seconds for STATUS_QFULL because QFULL will incrementally
1313  * increase the throttle limit until it reaches max value.
1314  */
1315 #define SD_RESET_THROTTLE_TIMEOUT       60
1316 #define SD_QFULL_THROTTLE_TIMEOUT       10
1317 
1318 #define SD_THROTTLE_TRAN_BUSY           0
1319 #define SD_THROTTLE_QFULL               1
1320 
1321 #define SD_THROTTLE_RESET_INTERVAL      \
1322         (sd_reset_throttle_timeout * drv_usectohz(1000000))
1323 
1324 #define SD_QFULL_THROTTLE_RESET_INTERVAL        \
1325         (sd_qfull_throttle_timeout * drv_usectohz(1000000))
1326 
1327 
1328 /*
1329  * xb_pkt_flags defines
1330  * SD_XB_DMA_FREED indicates the scsi_pkt has had its DMA resources freed
1331  * by a call to scsi_dmafree(9F). The resources must be reallocated before
1332  *   before a call to scsi_transport can be made again.
1333  * SD_XB_USCSICMD indicates the scsi request is a uscsi request
1334  * SD_XB_INITPKT_MASK: since this field is also used to store flags for
1335  *   a scsi_init_pkt(9F) call, we need a mask to make sure that we don't
1336  *   pass any unintended bits to scsi_init_pkt(9F) (ugly hack).
1337  */
1338 #define SD_XB_DMA_FREED         0x20000000
1339 #define SD_XB_USCSICMD          0x40000000
1340 #define SD_XB_INITPKT_MASK      (PKT_CONSISTENT | PKT_DMA_PARTIAL)
1341 
1342 /*
1343  * Extension for the buf(9s) struct that we receive from a higher
1344  * layer. Located by b_private in the buf(9S).  (The previous contents
1345  * of b_private are saved & restored before calling biodone(9F).)
1346  */
1347 struct sd_xbuf {
1348 
1349         struct sd_lun   *xb_un;         /* Ptr to associated sd_lun */
1350         struct scsi_pkt *xb_pktp;       /* Ptr to associated scsi_pkt */
1351 
1352         /*
1353          * xb_pktinfo points to any optional data that may be needed
1354          * by the initpkt and/or destroypkt functions.  Typical
1355          * use might be to point to a struct uscsi_cmd.
1356          */
1357         void    *xb_pktinfo;
1358 
1359         /*
1360          * Layer-private data area. This may be used by any layer to store
1361          * layer-specific data on a per-IO basis. Typical usage is for an
1362          * iostart routine to save some info here for later use by its
1363          * partner iodone routine.  This area may be used to hold data or
1364          * a pointer to a data block that is allocated/freed by the layer's
1365          * iostart/iodone routines. Allocation & management policy for the
1366          * layer-private area is defined & implemented by each specific
1367          * layer as required.
1368          *
1369          * IMPORTANT: Since a higher layer may depend on the value in the
1370          * xb_private field, each layer must ensure that it returns the
1371          * buf/xbuf to the next higher layer (via SD_NEXT_IODONE()) with
1372          * the SAME VALUE in xb_private as when the buf/xbuf was first
1373          * received by the layer's iostart routine. Typically this is done
1374          * by the iostart routine saving the contents of xb_private into
1375          * a place in the layer-private data area, and the iodone routine
1376          * restoring the value of xb_private before deallocating the
1377          * layer-private data block and calling SD_NEXT_IODONE(). Of course,
1378          * if a layer never modifies xb_private in a buf/xbuf from a higher
1379          * layer, there will be no need to restore the value.
1380          *
1381          * Note that in the case where a layer _creates_ a buf/xbuf (such as
1382          * by calling sd_shadow_buf_alloc()) to pass to a lower layer, it is
1383          * not necessary to preserve the contents of xb_private as there is
1384          * no higher layer dependency on the value of xb_private. Such a
1385          * buf/xbuf must be deallocated by the layer that allocated it and
1386          * must *NEVER* be passed up to a higher layer.
1387          */
1388         void    *xb_private;    /* Layer-private data block */
1389 
1390         /*
1391          * We do not use the b_blkno provided in the buf(9S), as we need to
1392          * make adjustments to it in the driver, but it is not a field that
1393          * the driver owns or is free to modify.
1394          */
1395         daddr_t xb_blkno;               /* Absolute block # on target */
1396         uint64_t xb_ena;                /* ena for a specific SCSI command */
1397 
1398         int     xb_chain_iostart;       /* iostart side index */
1399         int     xb_chain_iodone;        /* iodone side index */
1400         int     xb_pkt_flags;           /* Flags for scsi_init_pkt() */
1401         ssize_t xb_dma_resid;
1402         short   xb_retry_count;
1403         short   xb_victim_retry_count;
1404         short   xb_ua_retry_count;      /* unit_attention retry counter */
1405         short   xb_nr_retry_count;      /* not ready retry counter */
1406 
1407         /*
1408          * Various status and data used when a RQS command is run on
1409          * the behalf of this command.
1410          */
1411         struct buf      *xb_sense_bp;   /* back ptr to buf, for RQS */
1412         uint_t  xb_sense_state;         /* scsi_pkt state of RQS command */
1413         ssize_t xb_sense_resid;         /* residual of RQS command */
1414         uchar_t xb_sense_status;        /* scsi status byte of RQS command */
1415         uchar_t xb_sense_data[SENSE_LENGTH];    /* sense data from RQS cmd */
1416         /*
1417          * Extra sense larger than SENSE_LENGTH will be allocated
1418          * right after xb_sense_data[SENSE_LENGTH]. Please do not
1419          * add any new field after it.
1420          */
1421 };
1422 
1423 _NOTE(SCHEME_PROTECTS_DATA("unique per pkt", sd_xbuf))
1424 
1425 #define SD_PKT_ALLOC_SUCCESS                    0
1426 #define SD_PKT_ALLOC_FAILURE                    1
1427 #define SD_PKT_ALLOC_FAILURE_NO_DMA             2
1428 #define SD_PKT_ALLOC_FAILURE_PKT_TOO_SMALL      3
1429 #define SD_PKT_ALLOC_FAILURE_CDB_TOO_SMALL      4
1430 
1431 #define SD_GET_XBUF(bp)         ((struct sd_xbuf *)((bp)->b_private))
1432 #define SD_GET_UN(bp)           ((SD_GET_XBUF(bp))->xb_un)
1433 #define SD_GET_PKTP(bp)         ((SD_GET_XBUF(bp))->xb_pktp)
1434 #define SD_GET_BLKNO(bp)        ((SD_GET_XBUF(bp))->xb_blkno)
1435 
1436 /*
1437  * Special-purpose struct for sd_send_scsi_cmd() to pass command-specific
1438  * data through the layering chains to sd_initpkt_for_uscsi().
1439  */
1440 struct sd_uscsi_info {
1441         int                     ui_flags;
1442         struct uscsi_cmd        *ui_cmdp;
1443         /*
1444          * ui_dkc is used by sd_send_scsi_SYNCHRONIZE_CACHE() to allow
1445          * for async completion notification.
1446          */
1447         struct dk_callback      ui_dkc;
1448         /*
1449          * The following fields are to be used for FMA ereport generation.
1450          */
1451         uchar_t                 ui_pkt_reason;
1452         uint32_t                ui_pkt_state;
1453         uint32_t                ui_pkt_statistics;
1454         uint64_t                ui_lba;
1455         uint64_t                ui_ena;
1456 };
1457 
1458 _NOTE(SCHEME_PROTECTS_DATA("Unshared data", sd_uscsi_info))
1459 
1460 /*
1461  * This structure is used to issue 'internal' command sequences from the
1462  * driver's attach(9E)/open(9E)/etc entry points. It provides a common context
1463  * for issuing command sequences, with the ability to issue a command
1464  * and provide expected/unexpected assessment of results at any code
1465  * level within the sd_ssc_t scope and preserve the information needed
1466  * produce telemetry for the problem, when needed, from a single
1467  * outer-most-scope point.
1468  *
1469  * The sd_ssc_t abstraction should result in well-structured code where
1470  * the basic code structure is not jeprodized by future localized improvement.
1471  *
1472  *   o  Scope for a sequence of commands.
1473  *   o  Within a scoped sequence of commands, provides a single top-level
1474  *      location for initiating telementry generation from captured data.
1475  *   o  Provide a common place to capture command execution data and driver
1476  *      assessment information for delivery to telemetry generation point.
1477  *   o  Mechanism to get device-as-detector (dad) and transport telemetry
1478  *      information from interrupt context (sdintr) back to the internal
1479  *      command 'driver-assessment' code.
1480  *   o  Ability to record assessment, and return information back to
1481  *      top-level telemetry generation code when an unexpected condition
1482  *      occurs.
1483  *   o  For code paths were an command itself was successful but
1484  *      the data returned looks suspect, the ability to record
1485  *      'unexpected data' conditions.
1486  *   o  Record assessment of issuing the command and interpreting
1487  *      the returned data for consumption by top-level ereport telemetry
1488  *      generation code.
1489  *   o  All data required to produce telemetry available off single data
1490  *      structure.
1491  */
1492 typedef struct {
1493         struct sd_lun           *ssc_un;
1494         struct uscsi_cmd        *ssc_uscsi_cmd;
1495         struct sd_uscsi_info    *ssc_uscsi_info;
1496         int                     ssc_flags; /* Bits for flags */
1497         char                    ssc_info[1024]; /* Buffer holding for info */
1498 } sd_ssc_t;
1499 
1500 _NOTE(SCHEME_PROTECTS_DATA("Unshared data", sd_ssc_t))
1501 
1502 /*
1503  * This struct switch different 'type-of-assessment'
1504  * as an input argument for sd_ssc_assessment
1505  *
1506  *
1507  * in sd_send_scsi_XXX or upper-level
1508  *
1509  * - SD_FMT_IGNORE
1510  *   when send uscsi command failed, and
1511  *   the following code check sense data properly.
1512  *   we use 'ignore' to let sd_ssc_assessment
1513  *   trust current and do not do additional
1514  *   checking for the uscsi command.
1515  *
1516  * - SD_FMT_IGNORE_COMPROMISE
1517  *   when send uscsi command failed, and
1518  *   the code does not check sense data or we don't
1519  *   think the checking is 100% coverage. We mark it
1520  *   as 'compromise' to indicate that we need to
1521  *   enhance current code in the future.
1522  *
1523  * - SD_FMT_STATUS_CHECK
1524  *   when send uscsi command failed and cause sd entries
1525  *   failed finally, we need to send out real reason against
1526  *   status of uscsi command no matter if there is sense back
1527  *   or not.
1528  *
1529  * - SD_FMT_STANDARD
1530  *   when send uscsi command succeeded, and
1531  *   the code does not check sense data, we need to check
1532  *   it to make sure there is no 'fault'.
1533  */
1534 enum sd_type_assessment {
1535         SD_FMT_IGNORE = 0,
1536         SD_FMT_IGNORE_COMPROMISE,
1537         SD_FMT_STATUS_CHECK,
1538         SD_FMT_STANDARD
1539 };
1540 
1541 /*
1542  * The following declaration are used as hints of severities when posting
1543  * SCSI FMA ereport.
1544  * - SD_FM_DRV_FATAL
1545  *   When posting ereport with SD_FM_DRV_FATAL, the payload
1546  *   "driver-assessment" will be "fail" or "fatal" depending on the
1547  *   sense-key value. If driver-assessment is "fail", it will be
1548  *   propagated to an upset, otherwise, a fault will be propagated.
1549  * - SD_FM_DRV_RETRY
1550  *   When posting ereport with SD_FM_DRV_RETRY, the payload
1551  *   "driver-assessment" will be "retry", and it will be propagated to an
1552  *   upset.
1553  * - SD_FM_DRV_RECOVERY
1554  *   When posting ereport with SD_FM_DRV_RECOVERY, the payload
1555  *   "driver-assessment" will be "recovered", and it will be propagated to
1556  *   an upset.
1557  * - SD_FM_DRV_NOTICE
1558  *   When posting ereport with SD_FM_DRV_NOTICE, the payload
1559  *   "driver-assessment" will be "info", and it will be propagated to an
1560  *   upset.
1561  */
1562 enum sd_driver_assessment {
1563         SD_FM_DRV_FATAL = 0,
1564         SD_FM_DRV_RETRY,
1565         SD_FM_DRV_RECOVERY,
1566         SD_FM_DRV_NOTICE
1567 };
1568 
1569 /*
1570  * The following structure is used as a buffer when posting SCSI FMA
1571  * ereport for raw i/o. It will be allocated per sd_lun when entering
1572  * sd_unit_attach and will be deallocated when entering sd_unit_detach.
1573  */
1574 struct sd_fm_internal {
1575         sd_ssc_t fm_ssc;
1576         struct uscsi_cmd fm_ucmd;
1577         struct sd_uscsi_info fm_uinfo;
1578         int fm_log_level;
1579 };
1580 
1581 /*
1582  * Bits in ssc_flags
1583  * sd_ssc_init will mark ssc_flags = SSC_FLAGS_UNKNOWN
1584  * sd_ssc_send will mark ssc_flags = SSC_FLAGS_CMD_ISSUED &
1585  *                                   SSC_FLAGS_NEED_ASSESSMENT
1586  * sd_ssc_assessment will clear SSC_FLAGS_CMD_ISSUED and
1587  * SSC_FLAGS_NEED_ASSESSMENT bits of ssc_flags.
1588  * SSC_FLAGS_CMD_ISSUED is to indicate whether the SCSI command has been
1589  * sent out.
1590  * SSC_FLAGS_NEED_ASSESSMENT is to guarantee we will not miss any
1591  * assessment point.
1592  */
1593 #define         SSC_FLAGS_UNKNOWN               0x00000000
1594 #define         SSC_FLAGS_CMD_ISSUED            0x00000001
1595 #define         SSC_FLAGS_NEED_ASSESSMENT       0x00000002
1596 #define         SSC_FLAGS_TRAN_ABORT            0x00000004
1597 
1598 /*
1599  * The following bits in ssc_flags are for detecting unexpected data.
1600  */
1601 #define         SSC_FLAGS_INVALID_PKT_REASON    0x00000010
1602 #define         SSC_FLAGS_INVALID_STATUS        0x00000020
1603 #define         SSC_FLAGS_INVALID_SENSE         0x00000040
1604 #define         SSC_FLAGS_INVALID_DATA          0x00000080
1605 
1606 /*
1607  * The following are the values available for sd_fm_internal::fm_log_level.
1608  * SD_FM_LOG_NSUP       The driver will log things in traditional way as if
1609  *                      the SCSI FMA feature is unavailable.
1610  * SD_FM_LOG_SILENT     The driver will not print out syslog for FMA error
1611  *                      telemetry, all the error telemetries will go into
1612  *                      FMA error log.
1613  * SD_FM_LOG_EREPORT    The driver will both print the FMA error telemetry
1614  *                      and post the error report, but the traditional
1615  *                      syslog for error telemetry will be suppressed.
1616  */
1617 #define         SD_FM_LOG_NSUP          0
1618 #define         SD_FM_LOG_SILENT        1
1619 #define         SD_FM_LOG_EREPORT       2
1620 
1621 /*
1622  * Macros and definitions for driver kstats and errstats
1623  *
1624  * Some third-party layered drivers (they know who they are) do not maintain
1625  * their open/close counts correctly which causes our kstat reporting to get
1626  * messed up & results in panics. These macros will update the driver kstats
1627  * only if the counts are valid.
1628  */
1629 #define SD_UPDATE_COMMON_KSTATS(kstat_function, kstatp)                 \
1630         if ((kstat_function)  == kstat_runq_exit ||                     \
1631             ((kstat_function) == kstat_runq_back_to_waitq)) {           \
1632                 if (((kstat_io_t *)(kstatp))->rcnt) {                        \
1633                         kstat_function((kstatp));                       \
1634                 } else {                                                \
1635                         cmn_err(CE_WARN,                                \
1636                 "kstat rcnt == 0 when exiting runq, please check\n");   \
1637                 }                                                       \
1638         } else if ((kstat_function) == kstat_waitq_exit ||              \
1639             ((kstat_function) == kstat_waitq_to_runq)) {                \
1640                 if (((kstat_io_t *)(kstatp))->wcnt) {                        \
1641                         kstat_function(kstatp);                         \
1642                 } else {                                                \
1643                         cmn_err(CE_WARN,                                \
1644                 "kstat wcnt == 0 when exiting waitq, please check\n");  \
1645                 }                                                       \
1646         } else {                                                        \
1647                 kstat_function(kstatp);                                 \
1648         }
1649 
1650 #define SD_UPDATE_KSTATS(un, kstat_function, bp)                        \
1651         ASSERT(SD_GET_XBUF(bp) != NULL);                                \
1652         if (SD_IS_BUFIO(SD_GET_XBUF(bp))) {                             \
1653                 struct kstat *pksp =                                    \
1654                         (un)->un_pstats[SDPART((bp)->b_edev)];            \
1655                 ASSERT(mutex_owned(SD_MUTEX(un)));                      \
1656                 if ((un)->un_stats != NULL) {                                \
1657                         kstat_io_t *kip = KSTAT_IO_PTR((un)->un_stats);      \
1658                         SD_UPDATE_COMMON_KSTATS(kstat_function, kip);   \
1659                 }                                                       \
1660                 if (pksp != NULL) {                                     \
1661                         kstat_io_t *kip = KSTAT_IO_PTR(pksp);           \
1662                         SD_UPDATE_COMMON_KSTATS(kstat_function, kip);   \
1663                 }                                                       \
1664         }
1665 
1666 #define SD_UPDATE_ERRSTATS(un, x)                                       \
1667         if ((un)->un_errstats != NULL) {                             \
1668                 struct sd_errstats *stp;                                \
1669                 ASSERT(mutex_owned(SD_MUTEX(un)));                      \
1670                 stp = (struct sd_errstats *)(un)->un_errstats->ks_data;   \
1671                 stp->x.value.ui32++;                                 \
1672         }
1673 
1674 #define SD_UPDATE_RDWR_STATS(un, bp)                                    \
1675         if ((un)->un_stats != NULL) {                                        \
1676                 kstat_io_t *kip = KSTAT_IO_PTR((un)->un_stats);              \
1677                 size_t n_done = (bp)->b_bcount - (bp)->b_resid;           \
1678                 if ((bp)->b_flags & B_READ) {                            \
1679                         kip->reads++;                                        \
1680                         kip->nread += n_done;                                \
1681                 } else {                                                \
1682                         kip->writes++;                                       \
1683                         kip->nwritten += n_done;                     \
1684                 }                                                       \
1685         }
1686 
1687 #define SD_UPDATE_PARTITION_STATS(un, bp)                               \
1688 {                                                                       \
1689         struct kstat *pksp = (un)->un_pstats[SDPART((bp)->b_edev)];       \
1690         if (pksp != NULL) {                                             \
1691                 kstat_io_t *kip = KSTAT_IO_PTR(pksp);                   \
1692                 size_t n_done = (bp)->b_bcount - (bp)->b_resid;           \
1693                 if ((bp)->b_flags & B_READ) {                            \
1694                         kip->reads++;                                        \
1695                         kip->nread += n_done;                                \
1696                 } else {                                                \
1697                         kip->writes++;                                       \
1698                         kip->nwritten += n_done;                     \
1699                 }                                                       \
1700         }                                                               \
1701 }
1702 
1703 
1704 #endif  /* defined(_KERNEL) || defined(_KMEMUSER) */
1705 
1706 
1707 /*
1708  * 60 seconds is a *very* reasonable amount of time for most slow CD
1709  * operations.
1710  */
1711 #define SD_IO_TIME                      60
1712 
1713 /*
1714  * 2 hours is an excessively reasonable amount of time for format operations.
1715  */
1716 #define SD_FMT_TIME                     (120 * 60)
1717 
1718 /*
1719  * 5 seconds is what we'll wait if we get a Busy Status back
1720  */
1721 #define SD_BSY_TIMEOUT                  (drv_usectohz(5 * 1000000))
1722 
1723 /*
1724  * 100 msec. is what we'll wait if we get Unit Attention.
1725  */
1726 #define SD_UA_RETRY_DELAY               (drv_usectohz((clock_t)100000))
1727 
1728 /*
1729  * 100 msec. is what we'll wait for restarted commands.
1730  */
1731 #define SD_RESTART_TIMEOUT              (drv_usectohz((clock_t)100000))
1732 
1733 /*
1734  * 10s misaligned I/O warning message interval
1735  */
1736 #define SD_RMW_MSG_PRINT_TIMEOUT        (drv_usectohz((clock_t)10000000))
1737 
1738 /*
1739  * 100 msec. is what we'll wait for certain retries for fibre channel
1740  * targets, 0 msec for parallel SCSI.
1741  */
1742 #if defined(__fibre)
1743 #define SD_RETRY_DELAY                  (drv_usectohz(100000))
1744 #else
1745 #define SD_RETRY_DELAY                  ((clock_t)0)
1746 #endif
1747 
1748 /*
1749  * Number of times we'll retry a normal operation.
1750  *
1751  * This includes retries due to transport failure
1752  * (need to distinguish between Target and Transport failure)
1753  *
1754  */
1755 #if defined(__fibre)
1756 #define SD_RETRY_COUNT                  3
1757 #else
1758 #define SD_RETRY_COUNT                  5
1759 #endif
1760 
1761 /*
1762  * Number of times we will retry for unit attention.
1763  */
1764 #define SD_UA_RETRY_COUNT               600
1765 
1766 #define SD_VICTIM_RETRY_COUNT(un)       (un->un_victim_retry_count)
1767 #define CD_NOT_READY_RETRY_COUNT(un)    (un->un_retry_count * 2)
1768 #define DISK_NOT_READY_RETRY_COUNT(un)  (un->un_retry_count / 2)
1769 
1770 
1771 /*
1772  * Maximum number of units we can support
1773  * (controlled by room in minor device byte)
1774  *
1775  * Note: this value is out of date.
1776  */
1777 #define SD_MAXUNIT                      32
1778 
1779 /*
1780  * 30 seconds is what we will wait for the IO to finish
1781  * before we fail the DDI_SUSPEND
1782  */
1783 #define SD_WAIT_CMDS_COMPLETE           30
1784 
1785 /*
1786  * Prevent/allow media removal flags
1787  */
1788 #define SD_REMOVAL_ALLOW                0
1789 #define SD_REMOVAL_PREVENT              1
1790 
1791 
1792 /*
1793  * Drive Types (and characteristics)
1794  */
1795 #define VIDMAX                          8
1796 #define PIDMAX                          16
1797 
1798 
1799 /*
1800  * The following #defines and type definitions for the property
1801  * processing component of the sd driver.
1802  */
1803 
1804 
1805 /* Miscellaneous Definitions */
1806 #define SD_CONF_VERSION_1               1
1807 #define SD_CONF_NOT_USED                32
1808 
1809 /*
1810  * "pm-capable" property values and macros
1811  */
1812 #define SD_PM_CAPABLE_UNDEFINED         -1
1813 
1814 #define SD_PM_CAPABLE_IS_UNDEFINED(pm_cap)      \
1815         (pm_cap == SD_PM_CAPABLE_UNDEFINED)
1816 
1817 #define SD_PM_CAPABLE_IS_FALSE(pm_cap)  \
1818         ((pm_cap & PM_CAPABLE_PM_MASK) == 0)
1819 
1820 #define SD_PM_CAPABLE_IS_TRUE(pm_cap)   \
1821         (!SD_PM_CAPABLE_IS_UNDEFINED(pm_cap) && \
1822             ((pm_cap & PM_CAPABLE_PM_MASK) > 0))
1823 
1824 #define SD_PM_CAPABLE_IS_SPC_4(pm_cap)  \
1825         ((pm_cap & PM_CAPABLE_PM_MASK) == PM_CAPABLE_SPC4)
1826 
1827 #define SD_PM_CAP_LOG_SUPPORTED(pm_cap) \
1828         ((pm_cap & PM_CAPABLE_LOG_SUPPORTED) ? TRUE : FALSE)
1829 
1830 #define SD_PM_CAP_SMART_LOG(pm_cap)     \
1831         ((pm_cap & PM_CAPABLE_SMART_LOG) ? TRUE : FALSE)
1832 
1833 /*
1834  * Property data values used in static configuration table
1835  * These are all based on device characteristics.
1836  * For fibre channel devices, the throttle value is usually
1837  * derived from the devices cmd Q depth divided by the number
1838  * of supported initiators.
1839  */
1840 #define ELITE_THROTTLE_VALUE            10
1841 #define SEAGATE_THROTTLE_VALUE          15
1842 #define IBM_THROTTLE_VALUE              15
1843 #define ST31200N_THROTTLE_VALUE         8
1844 #define FUJITSU_THROTTLE_VALUE          15
1845 #define SYMBIOS_THROTTLE_VALUE          16
1846 #define SYMBIOS_NOTREADY_RETRIES        24
1847 #define LSI_THROTTLE_VALUE              16
1848 #define LSI_NOTREADY_RETRIES            24
1849 #define LSI_OEM_NOTREADY_RETRIES        36
1850 #define PURPLE_THROTTLE_VALUE           64
1851 #define PURPLE_BUSY_RETRIES             60
1852 #define PURPLE_RESET_RETRY_COUNT        36
1853 #define PURPLE_RESERVE_RELEASE_TIME     60
1854 #define SVE_BUSY_RETRIES                60
1855 #define SVE_RESET_RETRY_COUNT           36
1856 #define SVE_RESERVE_RELEASE_TIME        60
1857 #define SVE_THROTTLE_VALUE              10
1858 #define SVE_MIN_THROTTLE_VALUE          2
1859 #define SVE_DISKSORT_DISABLED_FLAG      1
1860 #define MASERATI_DISKSORT_DISABLED_FLAG 1
1861 #define MASERATI_LUN_RESET_ENABLED_FLAG 1
1862 #define PIRUS_THROTTLE_VALUE            64
1863 #define PIRUS_NRR_COUNT                 60
1864 #define PIRUS_BUSY_RETRIES              60
1865 #define PIRUS_RESET_RETRY_COUNT         36
1866 #define PIRUS_MIN_THROTTLE_VALUE        16
1867 #define PIRUS_DISKSORT_DISABLED_FLAG    0
1868 #define PIRUS_LUN_RESET_ENABLED_FLAG    1
1869 
1870 /*
1871  * Driver Property Bit Flag definitions
1872  *
1873  * Unfortunately, for historical reasons, the bit-flag definitions are
1874  * different on SPARC, INTEL, & FIBRE platforms.
1875  */
1876 
1877 /*
1878  * Bit flag telling driver to set throttle from sd.conf sd-config-list
1879  * and driver table.
1880  *
1881  * The max throttle (q-depth) property implementation is for support of
1882  * fibre channel devices that can drop an i/o request when a queue fills
1883  * up. The number of commands sent to the disk from this driver is
1884  * regulated such that queue overflows are avoided.
1885  */
1886 #define SD_CONF_SET_THROTTLE            0
1887 #define SD_CONF_BSET_THROTTLE           (1 << SD_CONF_SET_THROTTLE)
1888 
1889 /*
1890  * Bit flag telling driver to set the controller type from sd.conf
1891  * sd-config-list and driver table.
1892  */
1893 #if defined(__i386) || defined(__amd64)
1894 #define SD_CONF_SET_CTYPE               1
1895 #elif defined(__fibre)
1896 #define SD_CONF_SET_CTYPE               5
1897 #else
1898 #define SD_CONF_SET_CTYPE               1
1899 #endif
1900 #define SD_CONF_BSET_CTYPE              (1 << SD_CONF_SET_CTYPE)
1901 
1902 /*
1903  * Bit flag telling driver to set the not ready retry count for a device from
1904  * sd.conf sd-config-list and driver table.
1905  */
1906 #if defined(__i386) || defined(__amd64)
1907 #define SD_CONF_SET_NOTREADY_RETRIES    10
1908 #elif defined(__fibre)
1909 #define SD_CONF_SET_NOTREADY_RETRIES    1
1910 #else
1911 #define SD_CONF_SET_NOTREADY_RETRIES    2
1912 #endif
1913 #define SD_CONF_BSET_NRR_COUNT          (1 << SD_CONF_SET_NOTREADY_RETRIES)
1914 
1915 /*
1916  * Bit flag telling driver to set SCSI status BUSY Retries from sd.conf
1917  * sd-config-list and driver table.
1918  */
1919 #if defined(__i386) || defined(__amd64)
1920 #define SD_CONF_SET_BUSY_RETRIES        11
1921 #elif defined(__fibre)
1922 #define SD_CONF_SET_BUSY_RETRIES        2
1923 #else
1924 #define SD_CONF_SET_BUSY_RETRIES        5
1925 #endif
1926 #define SD_CONF_BSET_BSY_RETRY_COUNT    (1 << SD_CONF_SET_BUSY_RETRIES)
1927 
1928 /*
1929  * Bit flag telling driver that device does not have a valid/unique serial
1930  * number.
1931  */
1932 #if defined(__i386) || defined(__amd64)
1933 #define SD_CONF_SET_FAB_DEVID           2
1934 #else
1935 #define SD_CONF_SET_FAB_DEVID           3
1936 #endif
1937 #define SD_CONF_BSET_FAB_DEVID          (1 << SD_CONF_SET_FAB_DEVID)
1938 
1939 /*
1940  * Bit flag telling driver to disable all caching for disk device.
1941  */
1942 #if defined(__i386) || defined(__amd64)
1943 #define SD_CONF_SET_NOCACHE             3
1944 #else
1945 #define SD_CONF_SET_NOCACHE             4
1946 #endif
1947 #define SD_CONF_BSET_NOCACHE            (1 << SD_CONF_SET_NOCACHE)
1948 
1949 /*
1950  * Bit flag telling driver that the PLAY AUDIO command requires parms in BCD
1951  * format rather than binary.
1952  */
1953 #if defined(__i386) || defined(__amd64)
1954 #define SD_CONF_SET_PLAYMSF_BCD         4
1955 #else
1956 #define SD_CONF_SET_PLAYMSF_BCD         6
1957 #endif
1958 #define SD_CONF_BSET_PLAYMSF_BCD        (1 << SD_CONF_SET_PLAYMSF_BCD)
1959 
1960 /*
1961  * Bit flag telling driver that the response from the READ SUBCHANNEL command
1962  * has BCD fields rather than binary.
1963  */
1964 #if defined(__i386) || defined(__amd64)
1965 #define SD_CONF_SET_READSUB_BCD         5
1966 #else
1967 #define SD_CONF_SET_READSUB_BCD         7
1968 #endif
1969 #define SD_CONF_BSET_READSUB_BCD        (1 << SD_CONF_SET_READSUB_BCD)
1970 
1971 /*
1972  * Bit in flags telling driver that the track number fields in the READ TOC
1973  * request and respone are in BCD rather than binary.
1974  */
1975 #if defined(__i386) || defined(__amd64)
1976 #define SD_CONF_SET_READ_TOC_TRK_BCD    6
1977 #else
1978 #define SD_CONF_SET_READ_TOC_TRK_BCD    8
1979 #endif
1980 #define SD_CONF_BSET_READ_TOC_TRK_BCD   (1 << SD_CONF_SET_READ_TOC_TRK_BCD)
1981 
1982 /*
1983  * Bit flag telling driver that the address fields in the READ TOC request and
1984  * respone are in BCD rather than binary.
1985  */
1986 #if defined(__i386) || defined(__amd64)
1987 #define SD_CONF_SET_READ_TOC_ADDR_BCD   7
1988 #else
1989 #define SD_CONF_SET_READ_TOC_ADDR_BCD   9
1990 #endif
1991 #define SD_CONF_BSET_READ_TOC_ADDR_BCD  (1 << SD_CONF_SET_READ_TOC_ADDR_BCD)
1992 
1993 /*
1994  * Bit flag telling the driver that the device doesn't support the READ HEADER
1995  * command.
1996  */
1997 #if defined(__i386) || defined(__amd64)
1998 #define SD_CONF_SET_NO_READ_HEADER      8
1999 #else
2000 #define SD_CONF_SET_NO_READ_HEADER      10
2001 #endif
2002 #define SD_CONF_BSET_NO_READ_HEADER     (1 << SD_CONF_SET_NO_READ_HEADER)
2003 
2004 /*
2005  * Bit flag telling the driver that for the READ CD command the device uses
2006  * opcode 0xd4 rather than 0xbe.
2007  */
2008 #if defined(__i386) || defined(__amd64)
2009 #define SD_CONF_SET_READ_CD_XD4         9
2010 #else
2011 #define SD_CONF_SET_READ_CD_XD4         11
2012 #endif
2013 #define SD_CONF_BSET_READ_CD_XD4        (1 << SD_CONF_SET_READ_CD_XD4)
2014 
2015 /*
2016  * Bit flag telling the driver to set SCSI status Reset Retries
2017  * (un_reset_retry_count) from sd.conf sd-config-list and driver table (4356701)
2018  */
2019 #define SD_CONF_SET_RST_RETRIES         12
2020 #define SD_CONF_BSET_RST_RETRIES        (1 << SD_CONF_SET_RST_RETRIES)
2021 
2022 /*
2023  * Bit flag telling the driver to set the reservation release timeout value
2024  * from sd.conf sd-config-list and driver table. (4367306)
2025  */
2026 #define SD_CONF_SET_RSV_REL_TIME        13
2027 #define SD_CONF_BSET_RSV_REL_TIME       (1 << SD_CONF_SET_RSV_REL_TIME)
2028 
2029 /*
2030  * Bit flag telling the driver to verify that no commands are pending for a
2031  * device before issuing a Test Unit Ready. This is a fw workaround for Seagate
2032  * eliteI drives. (4392016)
2033  */
2034 #define SD_CONF_SET_TUR_CHECK           14
2035 #define SD_CONF_BSET_TUR_CHECK          (1 << SD_CONF_SET_TUR_CHECK)
2036 
2037 /*
2038  * Bit in flags telling driver to set min. throttle from ssd.conf
2039  * ssd-config-list and driver table.
2040  */
2041 #define SD_CONF_SET_MIN_THROTTLE        15
2042 #define SD_CONF_BSET_MIN_THROTTLE       (1 << SD_CONF_SET_MIN_THROTTLE)
2043 
2044 /*
2045  * Bit in flags telling driver to set disksort disable flag from ssd.conf
2046  * ssd-config-list and driver table.
2047  */
2048 #define SD_CONF_SET_DISKSORT_DISABLED   16
2049 #define SD_CONF_BSET_DISKSORT_DISABLED  (1 << SD_CONF_SET_DISKSORT_DISABLED)
2050 
2051 /*
2052  * Bit in flags telling driver to set LUN Reset enable flag from [s]sd.conf
2053  * [s]sd-config-list and driver table.
2054  */
2055 #define SD_CONF_SET_LUN_RESET_ENABLED   17
2056 #define SD_CONF_BSET_LUN_RESET_ENABLED  (1 << SD_CONF_SET_LUN_RESET_ENABLED)
2057 
2058 /*
2059  * Bit in flags telling driver that the write cache on the device is
2060  * non-volatile.
2061  */
2062 #define SD_CONF_SET_CACHE_IS_NV 18
2063 #define SD_CONF_BSET_CACHE_IS_NV        (1 << SD_CONF_SET_CACHE_IS_NV)
2064 
2065 /*
2066  * Bit in flags telling driver that the power condition flag from [s]sd.conf
2067  * [s]sd-config-list and driver table.
2068  */
2069 #define SD_CONF_SET_PC_DISABLED 19
2070 #define SD_CONF_BSET_PC_DISABLED        (1 << SD_CONF_SET_PC_DISABLED)
2071 
2072 /*
2073  * This is the number of items currently settable in the sd.conf
2074  * sd-config-list.  The mask value is defined for parameter checking. The
2075  * item count and mask should be updated when new properties are added.
2076  */
2077 #define SD_CONF_MAX_ITEMS               19
2078 #define SD_CONF_BIT_MASK                0x0007FFFF
2079 
2080 typedef struct {
2081         int sdt_throttle;
2082         int sdt_ctype;
2083         int sdt_not_rdy_retries;
2084         int sdt_busy_retries;
2085         int sdt_reset_retries;
2086         int sdt_reserv_rel_time;
2087         int sdt_min_throttle;
2088         int sdt_disk_sort_dis;
2089         int sdt_lun_reset_enable;
2090         int sdt_suppress_cache_flush;
2091         int sdt_power_condition_dis;
2092 } sd_tunables;
2093 
2094 /* Type definition for static configuration table entries */
2095 typedef struct sd_disk_config {
2096         char    device_id[25];
2097         uint_t  flags;
2098         sd_tunables *properties;
2099 } sd_disk_config_t;
2100 
2101 /*
2102  * first 2 bits of byte 4 options for 1bh command
2103  */
2104 #define SD_TARGET_STOP                  0x00
2105 #define SD_TARGET_START                 0x01
2106 #define SD_TARGET_EJECT                 0x02
2107 #define SD_TARGET_CLOSE                 0x03
2108 
2109 /*
2110  * power condition of byte 4 for 1bh command
2111  */
2112 #define SD_TARGET_START_VALID           0x00
2113 #define SD_TARGET_ACTIVE                0x01
2114 #define SD_TARGET_IDLE                  0x02
2115 #define SD_TARGET_STANDBY               0x03
2116 
2117 
2118 #define SD_MODE_SENSE_PAGE3_CODE        0x03
2119 #define SD_MODE_SENSE_PAGE4_CODE        0x04
2120 
2121 #define SD_MODE_SENSE_PAGE3_LENGTH                                      \
2122         (sizeof (struct mode_format) + MODE_PARAM_LENGTH)
2123 #define SD_MODE_SENSE_PAGE4_LENGTH                                      \
2124         (sizeof (struct mode_geometry) + MODE_PARAM_LENGTH)
2125 
2126 /*
2127  * These command codes need to be moved to sys/scsi/generic/commands.h
2128  */
2129 
2130 /* Both versions of the Read CD command */
2131 
2132 /* the official SCMD_READ_CD now comes from cdio.h */
2133 #define SCMD_READ_CDD4          0xd4    /* the one used by some first */
2134                                         /* generation ATAPI CD drives */
2135 
2136 /* expected sector type filter values for Play and Read CD CDBs */
2137 #define CDROM_SECTOR_TYPE_CDDA          (1<<2)    /* IEC 908:1987 (CDDA) */
2138 #define CDROM_SECTOR_TYPE_MODE1         (2<<2)    /* Yellow book 2048 bytes */
2139 #define CDROM_SECTOR_TYPE_MODE2         (3<<2)    /* Yellow book 2335 bytes */
2140 #define CDROM_SECTOR_TYPE_MODE2_FORM1   (4<<2)    /* 2048 bytes */
2141 #define CDROM_SECTOR_TYPE_MODE2_FORM2   (5<<2)    /* 2324 bytes */
2142 
2143 /* READ CD filter bits (cdb[9]) */
2144 #define CDROM_READ_CD_SYNC      0x80    /* read sync field */
2145 #define CDROM_READ_CD_HDR       0x20    /* read four byte header */
2146 #define CDROM_READ_CD_SUBHDR    0x40    /* read sub-header */
2147 #define CDROM_READ_CD_ALLHDRS   0x60    /* read header and sub-header */
2148 #define CDROM_READ_CD_USERDATA  0x10    /* read user data */
2149 #define CDROM_READ_CD_EDC_ECC   0x08    /* read EDC and ECC field */
2150 #define CDROM_READ_CD_C2        0x02    /* read C2 error data */
2151 #define CDROM_READ_CD_C2_BEB    0x04    /* read C2 and Block Error Bits */
2152 
2153 
2154 /*
2155  * These belong in sys/scsi/generic/mode.h
2156  */
2157 
2158 /*
2159  * Mode Sense/Select Header response for Group 2 CDB.
2160  */
2161 
2162 struct mode_header_grp2 {
2163         uchar_t length_msb;             /* MSB - number of bytes following */
2164         uchar_t length_lsb;
2165         uchar_t medium_type;            /* device specific */
2166         uchar_t device_specific;        /* device specfic parameters */
2167         uchar_t resv[2];                /* reserved */
2168         uchar_t bdesc_length_hi;        /* length of block descriptor(s) */
2169                                         /* (if any) */
2170         uchar_t bdesc_length_lo;
2171 };
2172 
2173 _NOTE(SCHEME_PROTECTS_DATA("Unshared data", mode_header_grp2))
2174 
2175 /*
2176  * Length of the Mode Parameter Header for the Group 2 Mode Select command
2177  */
2178 #define MODE_HEADER_LENGTH_GRP2 (sizeof (struct mode_header_grp2))
2179 #define MODE_PARAM_LENGTH_GRP2 (MODE_HEADER_LENGTH_GRP2 + MODE_BLK_DESC_LENGTH)
2180 
2181 /*
2182  * Mode Page 1 - Error Recovery Page
2183  */
2184 #define MODEPAGE_ERR_RECOVER            1
2185 
2186 /*
2187  * The following buffer length define is 8 bytes for the Group 2 mode page
2188  * header, 8 bytes for the block descriptor and 26 bytes for the cdrom
2189  * capabilities page (per MMC-2)
2190  */
2191 #define MODEPAGE_CDROM_CAP              0x2A
2192 #define MODEPAGE_CDROM_CAP_LEN          26
2193 #define BUFLEN_MODE_CDROM_CAP           (MODEPAGE_CDROM_CAP_LEN + \
2194         MODE_HEADER_LENGTH_GRP2 + MODE_BLK_DESC_LENGTH)
2195 
2196 
2197 /*
2198  * Power management defines
2199  */
2200 #define SD_SPINDLE_UNINIT       (-1)
2201 #define SD_SPINDLE_OFF          0
2202 #define SD_SPINDLE_ON           1
2203 #define SD_SPINDLE_STOPPED      0
2204 #define SD_SPINDLE_STANDBY      1
2205 #define SD_SPINDLE_IDLE         2
2206 #define SD_SPINDLE_ACTIVE       3
2207 #define SD_PM_NOT_SUPPORTED     4
2208 
2209 /*
2210  * Power method flag
2211  */
2212 #define SD_START_STOP           0
2213 #define SD_POWER_CONDITION      1
2214 
2215 
2216 /*
2217  * Number of power level for start stop or power condition
2218  */
2219 #define SD_PM_NUM_LEVEL_SSU_SS  2
2220 #define SD_PM_NUM_LEVEL_SSU_PC  4
2221 
2222 /*
2223  * SD internal power state change flag
2224  */
2225 #define SD_PM_STATE_CHANGE      0
2226 #define SD_PM_STATE_ROLLBACK    1
2227 
2228 /*
2229  * Power attribute table
2230  */
2231 typedef struct disk_power_attr_ss {
2232         char *pm_comp[SD_PM_NUM_LEVEL_SSU_SS + 2];      /* pm component */
2233         int ran_perf[SD_PM_NUM_LEVEL_SSU_SS];           /* random performance */
2234         int pwr_saving[SD_PM_NUM_LEVEL_SSU_SS];         /* power saving */
2235         int latency[SD_PM_NUM_LEVEL_SSU_SS];            /* latency */
2236 }sd_power_attr_ss;
2237 
2238 typedef struct disk_power_attr_pc {
2239         char *pm_comp[SD_PM_NUM_LEVEL_SSU_PC + 2];      /* pm component */
2240         int ran_perf[SD_PM_NUM_LEVEL_SSU_PC];           /* random performance */
2241         int pwr_saving[SD_PM_NUM_LEVEL_SSU_PC];         /* power saving */
2242         int latency[SD_PM_NUM_LEVEL_SSU_PC];            /* latency */
2243 }sd_power_attr_pc;
2244 
2245 
2246 /*
2247  * No Need to resume if already in PM_SUSPEND state because the thread
2248  * was suspended in sdpower. It will be resumed when sdpower is invoked to make
2249  * the device active.
2250  * When the thread is suspended, the watch thread is terminated and
2251  * the token is NULLed so check for this condition.
2252  * If there's a thread that can be resumed, ie. token is not NULL, then
2253  * it can be resumed.
2254  */
2255 #define SD_OK_TO_RESUME_SCSI_WATCHER(un)        (un->un_swr_token != NULL)
2256 /*
2257  * No Need to resume if already in PM_SUSPEND state because the thread
2258  * was suspended in sdpower. It will be resumed when sdpower is invoked to make
2259  * the device active.
2260  * When the thread is suspended, the watch thread is terminated and
2261  * the token is NULLed so check for this condition.
2262  */
2263 #define SD_OK_TO_SUSPEND_SCSI_WATCHER(un)       (un->un_swr_token != NULL)
2264 #define SD_DEVICE_IS_IN_LOW_POWER(un)           ((un->un_f_pm_is_enabled) && \
2265                                                     (un->un_pm_count < 0))
2266 #define SD_PM_STATE_ACTIVE(un)                          \
2267                 (un->un_f_power_condition_supported ?        \
2268                 SD_SPINDLE_ACTIVE : SD_SPINDLE_ON)
2269 #define SD_PM_STATE_STOPPED(un)                         \
2270                 (un->un_f_power_condition_supported ?        \
2271                 SD_SPINDLE_STOPPED : SD_SPINDLE_OFF)
2272 #define SD_PM_IS_LEVEL_VALID(un, level)                 \
2273                 ((un->un_f_power_condition_supported &&      \
2274                 level >= SD_SPINDLE_STOPPED &&               \
2275                 level <= SD_SPINDLE_ACTIVE) ||               \
2276                 (!un->un_f_power_condition_supported &&      \
2277                 level >= SD_SPINDLE_OFF &&           \
2278                 level <= SD_SPINDLE_ON))
2279 #define SD_PM_IS_IO_CAPABLE(un, level)                  \
2280                 ((un->un_f_power_condition_supported &&      \
2281                 sd_pwr_pc.ran_perf[level] > 0) ||    \
2282                 (!un->un_f_power_condition_supported &&      \
2283                 sd_pwr_ss.ran_perf[level] > 0))
2284 #define SD_PM_STOP_MOTOR_NEEDED(un, level)              \
2285                 ((un->un_f_power_condition_supported &&      \
2286                 level <= SD_SPINDLE_STANDBY) ||              \
2287                 (!un->un_f_power_condition_supported &&      \
2288                 level == SD_SPINDLE_OFF))
2289 
2290 /*
2291  * Could move this define to some thing like log sense.h in SCSA headers
2292  * But for now let it live here.
2293  */
2294 #define START_STOP_CYCLE_COUNTER_PAGE_SIZE      0x28
2295 #define START_STOP_CYCLE_PAGE                   0x0E
2296 #define START_STOP_CYCLE_VU_PAGE                0x31
2297 
2298 /* CD-ROM Error Recovery Parameters page (0x01) */
2299 #define MODEPAGE_ERR_RECOV      0x1
2300 #define BUFLEN_CHG_BLK_MODE     MODE_HEADER_LENGTH + MODE_BLK_DESC_LENGTH
2301 
2302 /*
2303  * Vendor Specific (Toshiba) CD-ROM Speed page (0x31)
2304  *
2305  * The following buffer length define is 4 bytes for the Group 0 mode page
2306  * header, 8 bytes for the block descriptor and 4 bytes for the mode speed page.
2307  */
2308 #define MODEPAGE_CDROM_SPEED_LEN        4
2309 #define BUFLEN_MODE_CDROM_SPEED         MODEPAGE_CDROM_SPEED_LEN +\
2310                                         MODE_HEADER_LENGTH +\
2311                                         MODE_BLK_DESC_LENGTH
2312 #define SD_SPEED_1X                     176
2313 
2314 /* CD-ROM Audio Control Parameters page (0x0E) */
2315 #define MODEPAGE_AUDIO_CTRL             0x0E
2316 #define MODEPAGE_AUDIO_CTRL_LEN         16
2317 
2318 /* CD-ROM Sony Read Offset Defines */
2319 #define SONY_SESSION_OFFSET_LEN         12
2320 #define SONY_SESSION_OFFSET_KEY         0x40
2321 #define SONY_SESSION_OFFSET_VALID       0x0a
2322 
2323 /*
2324  * CD-ROM Write Protect Defines
2325  *
2326  * Bit 7 of the device specific field of the mode page header is the write
2327  * protect bit.
2328  */
2329 #define WRITE_PROTECT 0x80
2330 
2331 /*
2332  * Define for the length of a profile header returned in response to the
2333  * GET CONFIGURATION command
2334  */
2335 #define SD_PROFILE_HEADER_LEN           8       /* bytes */
2336 
2337 /*
2338  * Define the length of the data in response to the GET CONFIGURATION
2339  * command.  The 3rd byte of the feature descriptor contains the
2340  * current feature field that is of interest.  This field begins
2341  * after the feature header which is 8 bytes.  This variable length
2342  * was increased in size from 11 to 24 because some devices became
2343  * unresponsive with the smaller size.
2344  */
2345 #define SD_CURRENT_FEATURE_LEN          24      /* bytes */
2346 
2347 /*
2348  * Feature codes associated with GET CONFIGURATION command for supported
2349  * devices.
2350  */
2351 #define RANDOM_WRITABLE                 0x20
2352 #define HARDWARE_DEFECT_MANAGEMENT      0x24
2353 
2354 /*
2355  * Could move this define to some thing like log sense.h in SCSA headers
2356  * But for now let it live here.
2357  */
2358 #define TEMPERATURE_PAGE                        0x0D
2359 #define TEMPERATURE_PAGE_SIZE                   16      /* bytes */
2360 
2361 /* delay time used for sd_media_watch_cb delayed cv broadcast */
2362 #define MEDIA_ACCESS_DELAY 2000000
2363 
2364 
2365 /* SCSI power on or bus device reset additional sense code */
2366 #define SD_SCSI_RESET_SENSE_CODE        0x29
2367 
2368 /*
2369  * These defines are for the Vital Product Data Pages in the inquiry command.
2370  * They are the bits in the un_vpd_page mask, telling the supported pages.
2371  */
2372 #define SD_VPD_SUPPORTED_PG     0x01    /* 0x00 - Supported VPD pages */
2373 #define SD_VPD_UNIT_SERIAL_PG   0x02    /* 0x80 - Unit Serial Number */
2374 #define SD_VPD_OPERATING_PG     0x04    /* 0x81 - Implemented Op Defs */
2375 #define SD_VPD_ASCII_OP_PG      0x08    /* 0x82 - ASCII Op Defs */
2376 #define SD_VPD_DEVID_WWN_PG     0x10    /* 0x83 - Device Identification */
2377 #define SD_VPD_EXTENDED_DATA_PG 0x80    /* 0x86 - Extended data about the lun */
2378 #define SD_VPD_DEV_CHARACTER_PG 0x400   /* 0xB1 - Device Characteristics */
2379 
2380 /*
2381  * Non-volatile cache support
2382  *
2383  * Bit 1 of the byte 6 in the Extended INQUIRY data VPD page
2384  * is NV_SUP bit: An NV_SUP bit set to one indicates that
2385  * the device server supports a non-volatile cache.  An
2386  * NV_SUP bit set to zero indicates that the device
2387  * server may or may not support a non-volatile cache.
2388  *
2389  * Bit 2 of the byte 1 in the SYNC CACHE command is SYNC_NV
2390  * bit: The SYNC_NV bit specifies whether the device server
2391  * is required to synchronize volatile and non-volatile
2392  * caches.
2393  */
2394 #define SD_VPD_NV_SUP   0x02
2395 #define SD_SYNC_NV_BIT 0x04
2396 
2397 /*
2398  * Addition from sddef.intel.h
2399  */
2400 #if defined(__i386) || defined(__amd64)
2401 
2402 #define P0_RAW_DISK     (NDKMAP)
2403 #define FDISK_P1        (NDKMAP+1)
2404 #define FDISK_P2        (NDKMAP+2)
2405 #define FDISK_P3        (NDKMAP+3)
2406 #define FDISK_P4        (NDKMAP+4)
2407 
2408 #endif  /* __i386 || __amd64 */
2409 
2410 #ifdef  __cplusplus
2411 }
2412 #endif
2413 
2414 
2415 #endif  /* _SYS_SCSI_TARGETS_SDDEF_H */