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