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