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