xref: /freebsd/sys/cam/scsi/scsi_da.c (revision 85f87cf491bec6f90948a85b10f5523ea24db9e3)
1 /*-
2  * Implementation of SCSI Direct Access Peripheral driver for CAM.
3  *
4  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
5  *
6  * Copyright (c) 1997 Justin T. Gibbs.
7  * All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions, and the following disclaimer,
14  *    without modification, immediately at the beginning of the file.
15  * 2. The name of the author may not be used to endorse or promote products
16  *    derived from this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
22  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  */
30 
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
33 
34 #include <sys/param.h>
35 
36 #ifdef _KERNEL
37 #include "opt_da.h"
38 #include <sys/systm.h>
39 #include <sys/kernel.h>
40 #include <sys/bio.h>
41 #include <sys/sysctl.h>
42 #include <sys/taskqueue.h>
43 #include <sys/lock.h>
44 #include <sys/mutex.h>
45 #include <sys/conf.h>
46 #include <sys/devicestat.h>
47 #include <sys/eventhandler.h>
48 #include <sys/malloc.h>
49 #include <sys/cons.h>
50 #include <sys/endian.h>
51 #include <sys/proc.h>
52 #include <sys/sbuf.h>
53 #include <geom/geom.h>
54 #include <geom/geom_disk.h>
55 #include <machine/atomic.h>
56 #endif /* _KERNEL */
57 
58 #ifndef _KERNEL
59 #include <stdio.h>
60 #include <string.h>
61 #endif /* _KERNEL */
62 
63 #include <cam/cam.h>
64 #include <cam/cam_ccb.h>
65 #include <cam/cam_periph.h>
66 #include <cam/cam_xpt_periph.h>
67 #ifdef _KERNEL
68 #include <cam/cam_xpt_internal.h>
69 #endif /* _KERNEL */
70 #include <cam/cam_sim.h>
71 #include <cam/cam_iosched.h>
72 
73 #include <cam/scsi/scsi_message.h>
74 #include <cam/scsi/scsi_da.h>
75 
76 #ifdef _KERNEL
77 /*
78  * Note that there are probe ordering dependencies here.  The order isn't
79  * controlled by this enumeration, but by explicit state transitions in
80  * dastart() and dadone().  Here are some of the dependencies:
81  *
82  * 1. RC should come first, before RC16, unless there is evidence that RC16
83  *    is supported.
84  * 2. BDC needs to come before any of the ATA probes, or the ZONE probe.
85  * 3. The ATA probes should go in this order:
86  *    ATA -> LOGDIR -> IDDIR -> SUP -> ATA_ZONE
87  */
88 typedef enum {
89 	DA_STATE_PROBE_WP,
90 	DA_STATE_PROBE_RC,
91 	DA_STATE_PROBE_RC16,
92 	DA_STATE_PROBE_LBP,
93 	DA_STATE_PROBE_BLK_LIMITS,
94 	DA_STATE_PROBE_BDC,
95 	DA_STATE_PROBE_ATA,
96 	DA_STATE_PROBE_ATA_LOGDIR,
97 	DA_STATE_PROBE_ATA_IDDIR,
98 	DA_STATE_PROBE_ATA_SUP,
99 	DA_STATE_PROBE_ATA_ZONE,
100 	DA_STATE_PROBE_ZONE,
101 	DA_STATE_NORMAL
102 } da_state;
103 
104 typedef enum {
105 	DA_FLAG_PACK_INVALID	= 0x000001,
106 	DA_FLAG_NEW_PACK	= 0x000002,
107 	DA_FLAG_PACK_LOCKED	= 0x000004,
108 	DA_FLAG_PACK_REMOVABLE	= 0x000008,
109 	DA_FLAG_NEED_OTAG	= 0x000020,
110 	DA_FLAG_WAS_OTAG	= 0x000040,
111 	DA_FLAG_RETRY_UA	= 0x000080,
112 	DA_FLAG_OPEN		= 0x000100,
113 	DA_FLAG_SCTX_INIT	= 0x000200,
114 	DA_FLAG_CAN_RC16	= 0x000400,
115 	DA_FLAG_PROBED		= 0x000800,
116 	DA_FLAG_DIRTY		= 0x001000,
117 	DA_FLAG_ANNOUNCED	= 0x002000,
118 	DA_FLAG_CAN_ATA_DMA	= 0x004000,
119 	DA_FLAG_CAN_ATA_LOG	= 0x008000,
120 	DA_FLAG_CAN_ATA_IDLOG	= 0x010000,
121 	DA_FLAG_CAN_ATA_SUPCAP	= 0x020000,
122 	DA_FLAG_CAN_ATA_ZONE	= 0x040000,
123 	DA_FLAG_TUR_PENDING	= 0x080000
124 } da_flags;
125 
126 typedef enum {
127 	DA_Q_NONE		= 0x00,
128 	DA_Q_NO_SYNC_CACHE	= 0x01,
129 	DA_Q_NO_6_BYTE		= 0x02,
130 	DA_Q_NO_PREVENT		= 0x04,
131 	DA_Q_4K			= 0x08,
132 	DA_Q_NO_RC16		= 0x10,
133 	DA_Q_NO_UNMAP		= 0x20,
134 	DA_Q_RETRY_BUSY		= 0x40,
135 	DA_Q_SMR_DM		= 0x80,
136 	DA_Q_STRICT_UNMAP	= 0x100,
137 	DA_Q_128KB		= 0x200
138 } da_quirks;
139 
140 #define DA_Q_BIT_STRING		\
141 	"\020"			\
142 	"\001NO_SYNC_CACHE"	\
143 	"\002NO_6_BYTE"		\
144 	"\003NO_PREVENT"	\
145 	"\0044K"		\
146 	"\005NO_RC16"		\
147 	"\006NO_UNMAP"		\
148 	"\007RETRY_BUSY"	\
149 	"\010SMR_DM"		\
150 	"\011STRICT_UNMAP"	\
151 	"\012128KB"
152 
153 typedef enum {
154 	DA_CCB_PROBE_RC		= 0x01,
155 	DA_CCB_PROBE_RC16	= 0x02,
156 	DA_CCB_PROBE_LBP	= 0x03,
157 	DA_CCB_PROBE_BLK_LIMITS	= 0x04,
158 	DA_CCB_PROBE_BDC	= 0x05,
159 	DA_CCB_PROBE_ATA	= 0x06,
160 	DA_CCB_BUFFER_IO	= 0x07,
161 	DA_CCB_DUMP		= 0x0A,
162 	DA_CCB_DELETE		= 0x0B,
163 	DA_CCB_TUR		= 0x0C,
164 	DA_CCB_PROBE_ZONE	= 0x0D,
165 	DA_CCB_PROBE_ATA_LOGDIR	= 0x0E,
166 	DA_CCB_PROBE_ATA_IDDIR	= 0x0F,
167 	DA_CCB_PROBE_ATA_SUP	= 0x10,
168 	DA_CCB_PROBE_ATA_ZONE	= 0x11,
169 	DA_CCB_PROBE_WP		= 0x12,
170 	DA_CCB_TYPE_MASK	= 0x1F,
171 	DA_CCB_RETRY_UA		= 0x20
172 } da_ccb_state;
173 
174 /*
175  * Order here is important for method choice
176  *
177  * We prefer ATA_TRIM as tests run against a Sandforce 2281 SSD attached to
178  * LSI 2008 (mps) controller (FW: v12, Drv: v14) resulted 20% quicker deletes
179  * using ATA_TRIM than the corresponding UNMAP results for a real world mysql
180  * import taking 5mins.
181  *
182  */
183 typedef enum {
184 	DA_DELETE_NONE,
185 	DA_DELETE_DISABLE,
186 	DA_DELETE_ATA_TRIM,
187 	DA_DELETE_UNMAP,
188 	DA_DELETE_WS16,
189 	DA_DELETE_WS10,
190 	DA_DELETE_ZERO,
191 	DA_DELETE_MIN = DA_DELETE_ATA_TRIM,
192 	DA_DELETE_MAX = DA_DELETE_ZERO
193 } da_delete_methods;
194 
195 /*
196  * For SCSI, host managed drives show up as a separate device type.  For
197  * ATA, host managed drives also have a different device signature.
198  * XXX KDM figure out the ATA host managed signature.
199  */
200 typedef enum {
201 	DA_ZONE_NONE		= 0x00,
202 	DA_ZONE_DRIVE_MANAGED	= 0x01,
203 	DA_ZONE_HOST_AWARE	= 0x02,
204 	DA_ZONE_HOST_MANAGED	= 0x03
205 } da_zone_mode;
206 
207 /*
208  * We distinguish between these interface cases in addition to the drive type:
209  * o ATA drive behind a SCSI translation layer that knows about ZBC/ZAC
210  * o ATA drive behind a SCSI translation layer that does not know about
211  *   ZBC/ZAC, and so needs to be managed via ATA passthrough.  In this
212  *   case, we would need to share the ATA code with the ada(4) driver.
213  * o SCSI drive.
214  */
215 typedef enum {
216 	DA_ZONE_IF_SCSI,
217 	DA_ZONE_IF_ATA_PASS,
218 	DA_ZONE_IF_ATA_SAT,
219 } da_zone_interface;
220 
221 typedef enum {
222 	DA_ZONE_FLAG_RZ_SUP		= 0x0001,
223 	DA_ZONE_FLAG_OPEN_SUP		= 0x0002,
224 	DA_ZONE_FLAG_CLOSE_SUP		= 0x0004,
225 	DA_ZONE_FLAG_FINISH_SUP		= 0x0008,
226 	DA_ZONE_FLAG_RWP_SUP		= 0x0010,
227 	DA_ZONE_FLAG_SUP_MASK		= (DA_ZONE_FLAG_RZ_SUP |
228 					   DA_ZONE_FLAG_OPEN_SUP |
229 					   DA_ZONE_FLAG_CLOSE_SUP |
230 					   DA_ZONE_FLAG_FINISH_SUP |
231 					   DA_ZONE_FLAG_RWP_SUP),
232 	DA_ZONE_FLAG_URSWRZ		= 0x0020,
233 	DA_ZONE_FLAG_OPT_SEQ_SET	= 0x0040,
234 	DA_ZONE_FLAG_OPT_NONSEQ_SET	= 0x0080,
235 	DA_ZONE_FLAG_MAX_SEQ_SET	= 0x0100,
236 	DA_ZONE_FLAG_SET_MASK		= (DA_ZONE_FLAG_OPT_SEQ_SET |
237 					   DA_ZONE_FLAG_OPT_NONSEQ_SET |
238 					   DA_ZONE_FLAG_MAX_SEQ_SET)
239 } da_zone_flags;
240 
241 static struct da_zone_desc {
242 	da_zone_flags value;
243 	const char *desc;
244 } da_zone_desc_table[] = {
245 	{DA_ZONE_FLAG_RZ_SUP, "Report Zones" },
246 	{DA_ZONE_FLAG_OPEN_SUP, "Open" },
247 	{DA_ZONE_FLAG_CLOSE_SUP, "Close" },
248 	{DA_ZONE_FLAG_FINISH_SUP, "Finish" },
249 	{DA_ZONE_FLAG_RWP_SUP, "Reset Write Pointer" },
250 };
251 
252 typedef void da_delete_func_t (struct cam_periph *periph, union ccb *ccb,
253 			      struct bio *bp);
254 static da_delete_func_t da_delete_trim;
255 static da_delete_func_t da_delete_unmap;
256 static da_delete_func_t da_delete_ws;
257 
258 static const void * da_delete_functions[] = {
259 	NULL,
260 	NULL,
261 	da_delete_trim,
262 	da_delete_unmap,
263 	da_delete_ws,
264 	da_delete_ws,
265 	da_delete_ws
266 };
267 
268 static const char *da_delete_method_names[] =
269     { "NONE", "DISABLE", "ATA_TRIM", "UNMAP", "WS16", "WS10", "ZERO" };
270 static const char *da_delete_method_desc[] =
271     { "NONE", "DISABLED", "ATA TRIM", "UNMAP", "WRITE SAME(16) with UNMAP",
272       "WRITE SAME(10) with UNMAP", "ZERO" };
273 
274 /* Offsets into our private area for storing information */
275 #define ccb_state	ppriv_field0
276 #define ccb_bp		ppriv_ptr1
277 
278 struct disk_params {
279 	u_int8_t  heads;
280 	u_int32_t cylinders;
281 	u_int8_t  secs_per_track;
282 	u_int32_t secsize;	/* Number of bytes/sector */
283 	u_int64_t sectors;	/* total number sectors */
284 	u_int     stripesize;
285 	u_int     stripeoffset;
286 };
287 
288 #define UNMAP_RANGE_MAX		0xffffffff
289 #define UNMAP_HEAD_SIZE		8
290 #define UNMAP_RANGE_SIZE	16
291 #define UNMAP_MAX_RANGES	2048 /* Protocol Max is 4095 */
292 #define UNMAP_BUF_SIZE		((UNMAP_MAX_RANGES * UNMAP_RANGE_SIZE) + \
293 				UNMAP_HEAD_SIZE)
294 
295 #define WS10_MAX_BLKS		0xffff
296 #define WS16_MAX_BLKS		0xffffffff
297 #define ATA_TRIM_MAX_RANGES	((UNMAP_BUF_SIZE / \
298 	(ATA_DSM_RANGE_SIZE * ATA_DSM_BLK_SIZE)) * ATA_DSM_BLK_SIZE)
299 
300 #define DA_WORK_TUR		(1 << 16)
301 
302 typedef enum {
303 	DA_REF_OPEN = 1,
304 	DA_REF_OPEN_HOLD,
305 	DA_REF_CLOSE_HOLD,
306 	DA_REF_PROBE_HOLD,
307 	DA_REF_TUR,
308 	DA_REF_GEOM,
309 	DA_REF_SYSCTL,
310 	DA_REF_REPROBE,
311 	DA_REF_MAX		/* KEEP LAST */
312 } da_ref_token;
313 
314 struct da_softc {
315 	struct   cam_iosched_softc *cam_iosched;
316 	struct	 bio_queue_head delete_run_queue;
317 	LIST_HEAD(, ccb_hdr) pending_ccbs;
318 	int	 refcount;		/* Active xpt_action() calls */
319 	da_state state;
320 	da_flags flags;
321 	da_quirks quirks;
322 	int	 minimum_cmd_size;
323 	int	 error_inject;
324 	int	 trim_max_ranges;
325 	int	 delete_available;	/* Delete methods possibly available */
326 	da_zone_mode			zone_mode;
327 	da_zone_interface		zone_interface;
328 	da_zone_flags			zone_flags;
329 	struct ata_gp_log_dir		ata_logdir;
330 	int				valid_logdir_len;
331 	struct ata_identify_log_pages	ata_iddir;
332 	int				valid_iddir_len;
333 	uint64_t			optimal_seq_zones;
334 	uint64_t			optimal_nonseq_zones;
335 	uint64_t			max_seq_zones;
336 	u_int			maxio;
337 	uint32_t		unmap_max_ranges;
338 	uint32_t		unmap_max_lba; /* Max LBAs in UNMAP req */
339 	uint32_t		unmap_gran;
340 	uint32_t		unmap_gran_align;
341 	uint64_t		ws_max_blks;
342 	uint64_t		trim_count;
343 	uint64_t		trim_ranges;
344 	uint64_t		trim_lbas;
345 	da_delete_methods	delete_method_pref;
346 	da_delete_methods	delete_method;
347 	da_delete_func_t	*delete_func;
348 	int			unmappedio;
349 	int			rotating;
350 	int			p_type;
351 	struct	 disk_params params;
352 	struct	 disk *disk;
353 	union	 ccb saved_ccb;
354 	struct task		sysctl_task;
355 	struct sysctl_ctx_list	sysctl_ctx;
356 	struct sysctl_oid	*sysctl_tree;
357 	struct callout		sendordered_c;
358 	uint64_t wwpn;
359 	uint8_t	 unmap_buf[UNMAP_BUF_SIZE];
360 	struct scsi_read_capacity_data_long rcaplong;
361 	struct callout		mediapoll_c;
362 	int			ref_flags[DA_REF_MAX];
363 #ifdef CAM_IO_STATS
364 	struct sysctl_ctx_list	sysctl_stats_ctx;
365 	struct sysctl_oid	*sysctl_stats_tree;
366 	u_int	errors;
367 	u_int	timeouts;
368 	u_int	invalidations;
369 #endif
370 #define DA_ANNOUNCETMP_SZ 160
371 	char			announce_temp[DA_ANNOUNCETMP_SZ];
372 #define DA_ANNOUNCE_SZ 400
373 	char			announcebuf[DA_ANNOUNCE_SZ];
374 };
375 
376 #define dadeleteflag(softc, delete_method, enable)			\
377 	if (enable) {							\
378 		softc->delete_available |= (1 << delete_method);	\
379 	} else {							\
380 		softc->delete_available &= ~(1 << delete_method);	\
381 	}
382 
383 struct da_quirk_entry {
384 	struct scsi_inquiry_pattern inq_pat;
385 	da_quirks quirks;
386 };
387 
388 static const char quantum[] = "QUANTUM";
389 static const char microp[] = "MICROP";
390 
391 static struct da_quirk_entry da_quirk_table[] =
392 {
393 	/* SPI, FC devices */
394 	{
395 		/*
396 		 * Fujitsu M2513A MO drives.
397 		 * Tested devices: M2513A2 firmware versions 1200 & 1300.
398 		 * (dip switch selects whether T_DIRECT or T_OPTICAL device)
399 		 * Reported by: W.Scholten <whs@xs4all.nl>
400 		 */
401 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "FUJITSU", "M2513A", "*"},
402 		/*quirks*/ DA_Q_NO_SYNC_CACHE
403 	},
404 	{
405 		/* See above. */
406 		{T_OPTICAL, SIP_MEDIA_REMOVABLE, "FUJITSU", "M2513A", "*"},
407 		/*quirks*/ DA_Q_NO_SYNC_CACHE
408 	},
409 	{
410 		/*
411 		 * This particular Fujitsu drive doesn't like the
412 		 * synchronize cache command.
413 		 * Reported by: Tom Jackson <toj@gorilla.net>
414 		 */
415 		{T_DIRECT, SIP_MEDIA_FIXED, "FUJITSU", "M2954*", "*"},
416 		/*quirks*/ DA_Q_NO_SYNC_CACHE
417 	},
418 	{
419 		/*
420 		 * This drive doesn't like the synchronize cache command
421 		 * either.  Reported by: Matthew Jacob <mjacob@feral.com>
422 		 * in NetBSD PR kern/6027, August 24, 1998.
423 		 */
424 		{T_DIRECT, SIP_MEDIA_FIXED, microp, "2217*", "*"},
425 		/*quirks*/ DA_Q_NO_SYNC_CACHE
426 	},
427 	{
428 		/*
429 		 * This drive doesn't like the synchronize cache command
430 		 * either.  Reported by: Hellmuth Michaelis (hm@kts.org)
431 		 * (PR 8882).
432 		 */
433 		{T_DIRECT, SIP_MEDIA_FIXED, microp, "2112*", "*"},
434 		/*quirks*/ DA_Q_NO_SYNC_CACHE
435 	},
436 	{
437 		/*
438 		 * Doesn't like the synchronize cache command.
439 		 * Reported by: Blaz Zupan <blaz@gold.amis.net>
440 		 */
441 		{T_DIRECT, SIP_MEDIA_FIXED, "NEC", "D3847*", "*"},
442 		/*quirks*/ DA_Q_NO_SYNC_CACHE
443 	},
444 	{
445 		/*
446 		 * Doesn't like the synchronize cache command.
447 		 * Reported by: Blaz Zupan <blaz@gold.amis.net>
448 		 */
449 		{T_DIRECT, SIP_MEDIA_FIXED, quantum, "MAVERICK 540S", "*"},
450 		/*quirks*/ DA_Q_NO_SYNC_CACHE
451 	},
452 	{
453 		/*
454 		 * Doesn't like the synchronize cache command.
455 		 */
456 		{T_DIRECT, SIP_MEDIA_FIXED, quantum, "LPS525S", "*"},
457 		/*quirks*/ DA_Q_NO_SYNC_CACHE
458 	},
459 	{
460 		/*
461 		 * Doesn't like the synchronize cache command.
462 		 * Reported by: walter@pelissero.de
463 		 */
464 		{T_DIRECT, SIP_MEDIA_FIXED, quantum, "LPS540S", "*"},
465 		/*quirks*/ DA_Q_NO_SYNC_CACHE
466 	},
467 	{
468 		/*
469 		 * Doesn't work correctly with 6 byte reads/writes.
470 		 * Returns illegal request, and points to byte 9 of the
471 		 * 6-byte CDB.
472 		 * Reported by:  Adam McDougall <bsdx@spawnet.com>
473 		 */
474 		{T_DIRECT, SIP_MEDIA_FIXED, quantum, "VIKING 4*", "*"},
475 		/*quirks*/ DA_Q_NO_6_BYTE
476 	},
477 	{
478 		/* See above. */
479 		{T_DIRECT, SIP_MEDIA_FIXED, quantum, "VIKING 2*", "*"},
480 		/*quirks*/ DA_Q_NO_6_BYTE
481 	},
482 	{
483 		/*
484 		 * Doesn't like the synchronize cache command.
485 		 * Reported by: walter@pelissero.de
486 		 */
487 		{T_DIRECT, SIP_MEDIA_FIXED, "CONNER", "CP3500*", "*"},
488 		/*quirks*/ DA_Q_NO_SYNC_CACHE
489 	},
490 	{
491 		/*
492 		 * The CISS RAID controllers do not support SYNC_CACHE
493 		 */
494 		{T_DIRECT, SIP_MEDIA_FIXED, "COMPAQ", "RAID*", "*"},
495 		/*quirks*/ DA_Q_NO_SYNC_CACHE
496 	},
497 	{
498 		/*
499 		 * The STEC SSDs sometimes hang on UNMAP.
500 		 */
501 		{T_DIRECT, SIP_MEDIA_FIXED, "STEC", "*", "*"},
502 		/*quirks*/ DA_Q_NO_UNMAP
503 	},
504 	{
505 		/*
506 		 * VMware returns BUSY status when storage has transient
507 		 * connectivity problems, so better wait.
508 		 * Also VMware returns odd errors on misaligned UNMAPs.
509 		 */
510 		{T_DIRECT, SIP_MEDIA_FIXED, "VMware*", "*", "*"},
511 		/*quirks*/ DA_Q_RETRY_BUSY | DA_Q_STRICT_UNMAP
512 	},
513 	/* USB mass storage devices supported by umass(4) */
514 	{
515 		/*
516 		 * EXATELECOM (Sigmatel) i-Bead 100/105 USB Flash MP3 Player
517 		 * PR: kern/51675
518 		 */
519 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "EXATEL", "i-BEAD10*", "*"},
520 		/*quirks*/ DA_Q_NO_SYNC_CACHE
521 	},
522 	{
523 		/*
524 		 * Power Quotient Int. (PQI) USB flash key
525 		 * PR: kern/53067
526 		 */
527 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Generic*", "USB Flash Disk*",
528 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
529 	},
530 	{
531 		/*
532 		 * Creative Nomad MUVO mp3 player (USB)
533 		 * PR: kern/53094
534 		 */
535 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "CREATIVE", "NOMAD_MUVO", "*"},
536 		/*quirks*/ DA_Q_NO_SYNC_CACHE|DA_Q_NO_PREVENT
537 	},
538 	{
539 		/*
540 		 * Jungsoft NEXDISK USB flash key
541 		 * PR: kern/54737
542 		 */
543 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "JUNGSOFT", "NEXDISK*", "*"},
544 		/*quirks*/ DA_Q_NO_SYNC_CACHE
545 	},
546 	{
547 		/*
548 		 * FreeDik USB Mini Data Drive
549 		 * PR: kern/54786
550 		 */
551 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "FreeDik*", "Mini Data Drive",
552 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
553 	},
554 	{
555 		/*
556 		 * Sigmatel USB Flash MP3 Player
557 		 * PR: kern/57046
558 		 */
559 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "SigmaTel", "MSCN", "*"},
560 		/*quirks*/ DA_Q_NO_SYNC_CACHE|DA_Q_NO_PREVENT
561 	},
562 	{
563 		/*
564 		 * Neuros USB Digital Audio Computer
565 		 * PR: kern/63645
566 		 */
567 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "NEUROS", "dig. audio comp.",
568 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
569 	},
570 	{
571 		/*
572 		 * SEAGRAND NP-900 MP3 Player
573 		 * PR: kern/64563
574 		 */
575 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "SEAGRAND", "NP-900*", "*"},
576 		/*quirks*/ DA_Q_NO_SYNC_CACHE|DA_Q_NO_PREVENT
577 	},
578 	{
579 		/*
580 		 * iRiver iFP MP3 player (with UMS Firmware)
581 		 * PR: kern/54881, i386/63941, kern/66124
582 		 */
583 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "iRiver", "iFP*", "*"},
584 		/*quirks*/ DA_Q_NO_SYNC_CACHE
585 	},
586 	{
587 		/*
588 		 * Frontier Labs NEX IA+ Digital Audio Player, rev 1.10/0.01
589 		 * PR: kern/70158
590 		 */
591 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "FL" , "Nex*", "*"},
592 		/*quirks*/ DA_Q_NO_SYNC_CACHE
593 	},
594 	{
595 		/*
596 		 * ZICPlay USB MP3 Player with FM
597 		 * PR: kern/75057
598 		 */
599 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "ACTIONS*" , "USB DISK*", "*"},
600 		/*quirks*/ DA_Q_NO_SYNC_CACHE
601 	},
602 	{
603 		/*
604 		 * TEAC USB floppy mechanisms
605 		 */
606 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "TEAC" , "FD-05*", "*"},
607 		/*quirks*/ DA_Q_NO_SYNC_CACHE
608 	},
609 	{
610 		/*
611 		 * Kingston DataTraveler II+ USB Pen-Drive.
612 		 * Reported by: Pawel Jakub Dawidek <pjd@FreeBSD.org>
613 		 */
614 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Kingston" , "DataTraveler II+",
615 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
616 	},
617 	{
618 		/*
619 		 * USB DISK Pro PMAP
620 		 * Reported by: jhs
621 		 * PR: usb/96381
622 		 */
623 		{T_DIRECT, SIP_MEDIA_REMOVABLE, " ", "USB DISK Pro", "PMAP"},
624 		/*quirks*/ DA_Q_NO_SYNC_CACHE
625 	},
626 	{
627 		/*
628 		 * Motorola E398 Mobile Phone (TransFlash memory card).
629 		 * Reported by: Wojciech A. Koszek <dunstan@FreeBSD.czest.pl>
630 		 * PR: usb/89889
631 		 */
632 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Motorola" , "Motorola Phone",
633 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
634 	},
635 	{
636 		/*
637 		 * Qware BeatZkey! Pro
638 		 * PR: usb/79164
639 		 */
640 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "GENERIC", "USB DISK DEVICE",
641 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
642 	},
643 	{
644 		/*
645 		 * Time DPA20B 1GB MP3 Player
646 		 * PR: usb/81846
647 		 */
648 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "USB2.0*", "(FS) FLASH DISK*",
649 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
650 	},
651 	{
652 		/*
653 		 * Samsung USB key 128Mb
654 		 * PR: usb/90081
655 		 */
656 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "USB-DISK", "FreeDik-FlashUsb",
657 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
658 	},
659 	{
660 		/*
661 		 * Kingston DataTraveler 2.0 USB Flash memory.
662 		 * PR: usb/89196
663 		 */
664 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Kingston", "DataTraveler 2.0",
665 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
666 	},
667 	{
668 		/*
669 		 * Creative MUVO Slim mp3 player (USB)
670 		 * PR: usb/86131
671 		 */
672 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "CREATIVE", "MuVo Slim",
673 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE|DA_Q_NO_PREVENT
674 		},
675 	{
676 		/*
677 		 * United MP5512 Portable MP3 Player (2-in-1 USB DISK/MP3)
678 		 * PR: usb/80487
679 		 */
680 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Generic*", "MUSIC DISK",
681 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
682 	},
683 	{
684 		/*
685 		 * SanDisk Micro Cruzer 128MB
686 		 * PR: usb/75970
687 		 */
688 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "SanDisk" , "Micro Cruzer",
689 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
690 	},
691 	{
692 		/*
693 		 * TOSHIBA TransMemory USB sticks
694 		 * PR: kern/94660
695 		 */
696 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "TOSHIBA", "TransMemory",
697 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
698 	},
699 	{
700 		/*
701 		 * PNY USB 3.0 Flash Drives
702 		*/
703 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "PNY", "USB 3.0 FD*",
704 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE | DA_Q_NO_RC16
705 	},
706 	{
707 		/*
708 		 * PNY USB Flash keys
709 		 * PR: usb/75578, usb/72344, usb/65436
710 		 */
711 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "*" , "USB DISK*",
712 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
713 	},
714 	{
715 		/*
716 		 * Genesys GL3224
717 		 */
718 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Generic*", "STORAGE DEVICE*",
719 		"120?"}, /*quirks*/ DA_Q_NO_SYNC_CACHE | DA_Q_4K | DA_Q_NO_RC16
720 	},
721 	{
722 		/*
723 		 * Genesys 6-in-1 Card Reader
724 		 * PR: usb/94647
725 		 */
726 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Generic*", "STORAGE DEVICE*",
727 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
728 	},
729 	{
730 		/*
731 		 * Rekam Digital CAMERA
732 		 * PR: usb/98713
733 		 */
734 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "CAMERA*", "4MP-9J6*",
735 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
736 	},
737 	{
738 		/*
739 		 * iRiver H10 MP3 player
740 		 * PR: usb/102547
741 		 */
742 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "iriver", "H10*",
743 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
744 	},
745 	{
746 		/*
747 		 * iRiver U10 MP3 player
748 		 * PR: usb/92306
749 		 */
750 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "iriver", "U10*",
751 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
752 	},
753 	{
754 		/*
755 		 * X-Micro Flash Disk
756 		 * PR: usb/96901
757 		 */
758 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "X-Micro", "Flash Disk",
759 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
760 	},
761 	{
762 		/*
763 		 * EasyMP3 EM732X USB 2.0 Flash MP3 Player
764 		 * PR: usb/96546
765 		 */
766 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "EM732X", "MP3 Player*",
767 		"1.00"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
768 	},
769 	{
770 		/*
771 		 * Denver MP3 player
772 		 * PR: usb/107101
773 		 */
774 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "DENVER", "MP3 PLAYER",
775 		 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
776 	},
777 	{
778 		/*
779 		 * Philips USB Key Audio KEY013
780 		 * PR: usb/68412
781 		 */
782 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "PHILIPS", "Key*", "*"},
783 		/*quirks*/ DA_Q_NO_SYNC_CACHE | DA_Q_NO_PREVENT
784 	},
785 	{
786 		/*
787 		 * JNC MP3 Player
788 		 * PR: usb/94439
789 		 */
790 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "JNC*" , "MP3 Player*",
791 		 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
792 	},
793 	{
794 		/*
795 		 * SAMSUNG MP0402H
796 		 * PR: usb/108427
797 		 */
798 		{T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "MP0402H", "*"},
799 		/*quirks*/ DA_Q_NO_SYNC_CACHE
800 	},
801 	{
802 		/*
803 		 * I/O Magic USB flash - Giga Bank
804 		 * PR: usb/108810
805 		 */
806 		{T_DIRECT, SIP_MEDIA_FIXED, "GS-Magic", "stor*", "*"},
807 		/*quirks*/ DA_Q_NO_SYNC_CACHE
808 	},
809 	{
810 		/*
811 		 * JoyFly 128mb USB Flash Drive
812 		 * PR: 96133
813 		 */
814 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "USB 2.0", "Flash Disk*",
815 		 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
816 	},
817 	{
818 		/*
819 		 * ChipsBnk usb stick
820 		 * PR: 103702
821 		 */
822 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "ChipsBnk", "USB*",
823 		 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
824 	},
825 	{
826 		/*
827 		 * Storcase (Kingston) InfoStation IFS FC2/SATA-R 201A
828 		 * PR: 129858
829 		 */
830 		{T_DIRECT, SIP_MEDIA_FIXED, "IFS", "FC2/SATA-R*",
831 		 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
832 	},
833 	{
834 		/*
835 		 * Samsung YP-U3 mp3-player
836 		 * PR: 125398
837 		 */
838 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Samsung", "YP-U3",
839 		 "*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
840 	},
841 	{
842 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Netac", "OnlyDisk*",
843 		 "2000"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
844 	},
845 	{
846 		/*
847 		 * Sony Cyber-Shot DSC cameras
848 		 * PR: usb/137035
849 		 */
850 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Sony", "Sony DSC", "*"},
851 		/*quirks*/ DA_Q_NO_SYNC_CACHE | DA_Q_NO_PREVENT
852 	},
853 	{
854 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "Kingston", "DataTraveler G3",
855 		 "1.00"}, /*quirks*/ DA_Q_NO_PREVENT
856 	},
857 	{
858 		/* At least several Transcent USB sticks lie on RC16. */
859 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "JetFlash", "Transcend*",
860 		 "*"}, /*quirks*/ DA_Q_NO_RC16
861 	},
862 	{
863 		/*
864 		 * I-O Data USB Flash Disk
865 		 * PR: usb/211716
866 		 */
867 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "I-O DATA", "USB Flash Disk*",
868 		 "*"}, /*quirks*/ DA_Q_NO_RC16
869 	},
870 	{
871 		/*
872 		 * SLC CHIPFANCIER USB drives
873 		 * PR: usb/234503 (RC10 right, RC16 wrong)
874 		 * 16GB, 32GB and 128GB confirmed to have same issue
875 		 */
876 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "*SLC", "CHIPFANCIER",
877 		 "*"}, /*quirks*/ DA_Q_NO_RC16
878        },
879 	/* ATA/SATA devices over SAS/USB/... */
880 	{
881 		/* Sandisk X400 */
882 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SanDisk SD8SB8U1*", "*" },
883 		/*quirks*/DA_Q_128KB
884 	},
885 	{
886 		/* Hitachi Advanced Format (4k) drives */
887 		{ T_DIRECT, SIP_MEDIA_FIXED, "Hitachi", "H??????????E3*", "*" },
888 		/*quirks*/DA_Q_4K
889 	},
890 	{
891 		/* Micron Advanced Format (4k) drives */
892 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Micron 5100 MTFDDAK*", "*" },
893 		/*quirks*/DA_Q_4K
894 	},
895 	{
896 		/* Samsung Advanced Format (4k) drives */
897 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG HD155UI*", "*" },
898 		/*quirks*/DA_Q_4K
899 	},
900 	{
901 		/* Samsung Advanced Format (4k) drives */
902 		{ T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "HD155UI*", "*" },
903 		/*quirks*/DA_Q_4K
904 	},
905 	{
906 		/* Samsung Advanced Format (4k) drives */
907 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG HD204UI*", "*" },
908 		/*quirks*/DA_Q_4K
909 	},
910 	{
911 		/* Samsung Advanced Format (4k) drives */
912 		{ T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "HD204UI*", "*" },
913 		/*quirks*/DA_Q_4K
914 	},
915 	{
916 		/* Seagate Barracuda Green Advanced Format (4k) drives */
917 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST????DL*", "*" },
918 		/*quirks*/DA_Q_4K
919 	},
920 	{
921 		/* Seagate Barracuda Green Advanced Format (4k) drives */
922 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST????DL", "*", "*" },
923 		/*quirks*/DA_Q_4K
924 	},
925 	{
926 		/* Seagate Barracuda Green Advanced Format (4k) drives */
927 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST???DM*", "*" },
928 		/*quirks*/DA_Q_4K
929 	},
930 	{
931 		/* Seagate Barracuda Green Advanced Format (4k) drives */
932 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST???DM*", "*", "*" },
933 		/*quirks*/DA_Q_4K
934 	},
935 	{
936 		/* Seagate Barracuda Green Advanced Format (4k) drives */
937 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST????DM*", "*" },
938 		/*quirks*/DA_Q_4K
939 	},
940 	{
941 		/* Seagate Barracuda Green Advanced Format (4k) drives */
942 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST????DM", "*", "*" },
943 		/*quirks*/DA_Q_4K
944 	},
945 	{
946 		/* Seagate Momentus Advanced Format (4k) drives */
947 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9500423AS*", "*" },
948 		/*quirks*/DA_Q_4K
949 	},
950 	{
951 		/* Seagate Momentus Advanced Format (4k) drives */
952 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST950042", "3AS*", "*" },
953 		/*quirks*/DA_Q_4K
954 	},
955 	{
956 		/* Seagate Momentus Advanced Format (4k) drives */
957 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9500424AS*", "*" },
958 		/*quirks*/DA_Q_4K
959 	},
960 	{
961 		/* Seagate Momentus Advanced Format (4k) drives */
962 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST950042", "4AS*", "*" },
963 		/*quirks*/DA_Q_4K
964 	},
965 	{
966 		/* Seagate Momentus Advanced Format (4k) drives */
967 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9640423AS*", "*" },
968 		/*quirks*/DA_Q_4K
969 	},
970 	{
971 		/* Seagate Momentus Advanced Format (4k) drives */
972 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST964042", "3AS*", "*" },
973 		/*quirks*/DA_Q_4K
974 	},
975 	{
976 		/* Seagate Momentus Advanced Format (4k) drives */
977 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9640424AS*", "*" },
978 		/*quirks*/DA_Q_4K
979 	},
980 	{
981 		/* Seagate Momentus Advanced Format (4k) drives */
982 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST964042", "4AS*", "*" },
983 		/*quirks*/DA_Q_4K
984 	},
985 	{
986 		/* Seagate Momentus Advanced Format (4k) drives */
987 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9750420AS*", "*" },
988 		/*quirks*/DA_Q_4K
989 	},
990 	{
991 		/* Seagate Momentus Advanced Format (4k) drives */
992 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST975042", "0AS*", "*" },
993 		/*quirks*/DA_Q_4K
994 	},
995 	{
996 		/* Seagate Momentus Advanced Format (4k) drives */
997 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9750422AS*", "*" },
998 		/*quirks*/DA_Q_4K
999 	},
1000 	{
1001 		/* Seagate Momentus Advanced Format (4k) drives */
1002 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST975042", "2AS*", "*" },
1003 		/*quirks*/DA_Q_4K
1004 	},
1005 	{
1006 		/* Seagate Momentus Advanced Format (4k) drives */
1007 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST9750423AS*", "*" },
1008 		/*quirks*/DA_Q_4K
1009 	},
1010 	{
1011 		/* Seagate Momentus Advanced Format (4k) drives */
1012 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST975042", "3AS*", "*" },
1013 		/*quirks*/DA_Q_4K
1014 	},
1015 	{
1016 		/* Seagate Momentus Thin Advanced Format (4k) drives */
1017 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST???LT*", "*" },
1018 		/*quirks*/DA_Q_4K
1019 	},
1020 	{
1021 		/* Seagate Momentus Thin Advanced Format (4k) drives */
1022 		{ T_DIRECT, SIP_MEDIA_FIXED, "ST???LT*", "*", "*" },
1023 		/*quirks*/DA_Q_4K
1024 	},
1025 	{
1026 		/* WDC Caviar Green Advanced Format (4k) drives */
1027 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD????RS*", "*" },
1028 		/*quirks*/DA_Q_4K
1029 	},
1030 	{
1031 		/* WDC Caviar Green Advanced Format (4k) drives */
1032 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "??RS*", "*" },
1033 		/*quirks*/DA_Q_4K
1034 	},
1035 	{
1036 		/* WDC Caviar Green Advanced Format (4k) drives */
1037 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD????RX*", "*" },
1038 		/*quirks*/DA_Q_4K
1039 	},
1040 	{
1041 		/* WDC Caviar Green Advanced Format (4k) drives */
1042 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "??RX*", "*" },
1043 		/*quirks*/DA_Q_4K
1044 	},
1045 	{
1046 		/* WDC Caviar Green Advanced Format (4k) drives */
1047 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD??????RS*", "*" },
1048 		/*quirks*/DA_Q_4K
1049 	},
1050 	{
1051 		/* WDC Caviar Green Advanced Format (4k) drives */
1052 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "????RS*", "*" },
1053 		/*quirks*/DA_Q_4K
1054 	},
1055 	{
1056 		/* WDC Caviar Green Advanced Format (4k) drives */
1057 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD??????RX*", "*" },
1058 		/*quirks*/DA_Q_4K
1059 	},
1060 	{
1061 		/* WDC Caviar Green Advanced Format (4k) drives */
1062 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "????RX*", "*" },
1063 		/*quirks*/DA_Q_4K
1064 	},
1065 	{
1066 		/* WDC Scorpio Black Advanced Format (4k) drives */
1067 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD???PKT*", "*" },
1068 		/*quirks*/DA_Q_4K
1069 	},
1070 	{
1071 		/* WDC Scorpio Black Advanced Format (4k) drives */
1072 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "?PKT*", "*" },
1073 		/*quirks*/DA_Q_4K
1074 	},
1075 	{
1076 		/* WDC Scorpio Black Advanced Format (4k) drives */
1077 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD?????PKT*", "*" },
1078 		/*quirks*/DA_Q_4K
1079 	},
1080 	{
1081 		/* WDC Scorpio Black Advanced Format (4k) drives */
1082 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "???PKT*", "*" },
1083 		/*quirks*/DA_Q_4K
1084 	},
1085 	{
1086 		/* WDC Scorpio Blue Advanced Format (4k) drives */
1087 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD???PVT*", "*" },
1088 		/*quirks*/DA_Q_4K
1089 	},
1090 	{
1091 		/* WDC Scorpio Blue Advanced Format (4k) drives */
1092 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "?PVT*", "*" },
1093 		/*quirks*/DA_Q_4K
1094 	},
1095 	{
1096 		/* WDC Scorpio Blue Advanced Format (4k) drives */
1097 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "WDC WD?????PVT*", "*" },
1098 		/*quirks*/DA_Q_4K
1099 	},
1100 	{
1101 		/* WDC Scorpio Blue Advanced Format (4k) drives */
1102 		{ T_DIRECT, SIP_MEDIA_FIXED, "WDC WD??", "???PVT*", "*" },
1103 		/*quirks*/DA_Q_4K
1104 	},
1105 	{
1106 		/*
1107 		 * Olympus digital cameras (C-3040ZOOM, C-2040ZOOM, C-1)
1108 		 * PR: usb/97472
1109 		 */
1110 		{ T_DIRECT, SIP_MEDIA_REMOVABLE, "OLYMPUS", "C*", "*"},
1111 		/*quirks*/ DA_Q_NO_6_BYTE | DA_Q_NO_SYNC_CACHE
1112 	},
1113 	{
1114 		/*
1115 		 * Olympus digital cameras (D-370)
1116 		 * PR: usb/97472
1117 		 */
1118 		{ T_DIRECT, SIP_MEDIA_REMOVABLE, "OLYMPUS", "D*", "*"},
1119 		/*quirks*/ DA_Q_NO_6_BYTE
1120 	},
1121 	{
1122 		/*
1123 		 * Olympus digital cameras (E-100RS, E-10).
1124 		 * PR: usb/97472
1125 		 */
1126 		{ T_DIRECT, SIP_MEDIA_REMOVABLE, "OLYMPUS", "E*", "*"},
1127 		/*quirks*/ DA_Q_NO_6_BYTE | DA_Q_NO_SYNC_CACHE
1128 	},
1129 	{
1130 		/*
1131 		 * Olympus FE-210 camera
1132 		 */
1133 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "OLYMPUS", "FE210*",
1134 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
1135 	},
1136 	{
1137 		/*
1138 		* Pentax Digital Camera
1139 		* PR: usb/93389
1140 		*/
1141 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "PENTAX", "DIGITAL CAMERA",
1142 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
1143 	},
1144 	{
1145 		/*
1146 		 * LG UP3S MP3 player
1147 		 */
1148 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "LG", "UP3S",
1149 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
1150 	},
1151 	{
1152 		/*
1153 		 * Laser MP3-2GA13 MP3 player
1154 		 */
1155 		{T_DIRECT, SIP_MEDIA_REMOVABLE, "USB 2.0", "(HS) Flash Disk",
1156 		"*"}, /*quirks*/ DA_Q_NO_SYNC_CACHE
1157 	},
1158 	{
1159 		/*
1160 		 * LaCie external 250GB Hard drive des by Porsche
1161 		 * Submitted by: Ben Stuyts <ben@altesco.nl>
1162 		 * PR: 121474
1163 		 */
1164 		{T_DIRECT, SIP_MEDIA_FIXED, "SAMSUNG", "HM250JI", "*"},
1165 		/*quirks*/ DA_Q_NO_SYNC_CACHE
1166 	},
1167 	/* SATA SSDs */
1168 	{
1169 		/*
1170 		 * Corsair Force 2 SSDs
1171 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1172 		 */
1173 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Corsair CSSD-F*", "*" },
1174 		/*quirks*/DA_Q_4K
1175 	},
1176 	{
1177 		/*
1178 		 * Corsair Force 3 SSDs
1179 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1180 		 */
1181 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Corsair Force 3*", "*" },
1182 		/*quirks*/DA_Q_4K
1183 	},
1184         {
1185 		/*
1186 		 * Corsair Neutron GTX SSDs
1187 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1188 		 */
1189 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "Corsair Neutron GTX*", "*" },
1190 		/*quirks*/DA_Q_4K
1191 	},
1192 	{
1193 		/*
1194 		 * Corsair Force GT & GS SSDs
1195 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1196 		 */
1197 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Corsair Force G*", "*" },
1198 		/*quirks*/DA_Q_4K
1199 	},
1200 	{
1201 		/*
1202 		 * Crucial M4 SSDs
1203 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1204 		 */
1205 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "M4-CT???M4SSD2*", "*" },
1206 		/*quirks*/DA_Q_4K
1207 	},
1208 	{
1209 		/*
1210 		 * Crucial RealSSD C300 SSDs
1211 		 * 4k optimised
1212 		 */
1213 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "C300-CTFDDAC???MAG*",
1214 		"*" }, /*quirks*/DA_Q_4K
1215 	},
1216 	{
1217 		/*
1218 		 * Intel 320 Series SSDs
1219 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1220 		 */
1221 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSA2CW*", "*" },
1222 		/*quirks*/DA_Q_4K
1223 	},
1224 	{
1225 		/*
1226 		 * Intel 330 Series SSDs
1227 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1228 		 */
1229 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSC2CT*", "*" },
1230 		/*quirks*/DA_Q_4K
1231 	},
1232 	{
1233 		/*
1234 		 * Intel 510 Series SSDs
1235 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1236 		 */
1237 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSC2MH*", "*" },
1238 		/*quirks*/DA_Q_4K
1239 	},
1240 	{
1241 		/*
1242 		 * Intel 520 Series SSDs
1243 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1244 		 */
1245 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSC2BW*", "*" },
1246 		/*quirks*/DA_Q_4K
1247 	},
1248 	{
1249 		/*
1250 		 * Intel S3610 Series SSDs
1251 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1252 		 */
1253 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSC2BX*", "*" },
1254 		/*quirks*/DA_Q_4K
1255 	},
1256 	{
1257 		/*
1258 		 * Intel X25-M Series SSDs
1259 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1260 		 */
1261 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "INTEL SSDSA2M*", "*" },
1262 		/*quirks*/DA_Q_4K
1263 	},
1264 	{
1265 		/*
1266 		 * Kingston E100 Series SSDs
1267 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1268 		 */
1269 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "KINGSTON SE100S3*", "*" },
1270 		/*quirks*/DA_Q_4K
1271 	},
1272 	{
1273 		/*
1274 		 * Kingston HyperX 3k SSDs
1275 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1276 		 */
1277 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "KINGSTON SH103S3*", "*" },
1278 		/*quirks*/DA_Q_4K
1279 	},
1280 	{
1281 		/*
1282 		 * Marvell SSDs (entry taken from OpenSolaris)
1283 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1284 		 */
1285 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "MARVELL SD88SA02*", "*" },
1286 		/*quirks*/DA_Q_4K
1287 	},
1288 	{
1289 		/*
1290 		 * OCZ Agility 2 SSDs
1291 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1292 		 */
1293 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ-AGILITY2*", "*" },
1294 		/*quirks*/DA_Q_4K
1295 	},
1296 	{
1297 		/*
1298 		 * OCZ Agility 3 SSDs
1299 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1300 		 */
1301 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "OCZ-AGILITY3*", "*" },
1302 		/*quirks*/DA_Q_4K
1303 	},
1304 	{
1305 		/*
1306 		 * OCZ Deneva R Series SSDs
1307 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1308 		 */
1309 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "DENRSTE251M45*", "*" },
1310 		/*quirks*/DA_Q_4K
1311 	},
1312 	{
1313 		/*
1314 		 * OCZ Vertex 2 SSDs (inc pro series)
1315 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1316 		 */
1317 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "OCZ?VERTEX2*", "*" },
1318 		/*quirks*/DA_Q_4K
1319 	},
1320 	{
1321 		/*
1322 		 * OCZ Vertex 3 SSDs
1323 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1324 		 */
1325 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "OCZ-VERTEX3*", "*" },
1326 		/*quirks*/DA_Q_4K
1327 	},
1328 	{
1329 		/*
1330 		 * OCZ Vertex 4 SSDs
1331 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1332 		 */
1333 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "OCZ-VERTEX4*", "*" },
1334 		/*quirks*/DA_Q_4K
1335 	},
1336 	{
1337 		/*
1338 		 * Samsung 750 Series SSDs
1339 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1340 		 */
1341 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Samsung SSD 750*", "*" },
1342 		/*quirks*/DA_Q_4K
1343 	},
1344 	{
1345 		/*
1346 		 * Samsung 830 Series SSDs
1347 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1348 		 */
1349 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG SSD 830 Series*", "*" },
1350 		/*quirks*/DA_Q_4K
1351 	},
1352 	{
1353 		/*
1354 		 * Samsung 840 SSDs
1355 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1356 		 */
1357 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Samsung SSD 840*", "*" },
1358 		/*quirks*/DA_Q_4K
1359 	},
1360 	{
1361 		/*
1362 		 * Samsung 845 SSDs
1363 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1364 		 */
1365 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Samsung SSD 845*", "*" },
1366 		/*quirks*/DA_Q_4K
1367 	},
1368 	{
1369 		/*
1370 		 * Samsung 850 SSDs
1371 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1372 		 */
1373 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "Samsung SSD 850*", "*" },
1374 		/*quirks*/DA_Q_4K
1375 	},
1376 	{
1377 		/*
1378 		 * Samsung 843T Series SSDs (MZ7WD*)
1379 		 * Samsung PM851 Series SSDs (MZ7TE*)
1380 		 * Samsung PM853T Series SSDs (MZ7GE*)
1381 		 * Samsung SM863 Series SSDs (MZ7KM*)
1382 		 * 4k optimised
1383 		 */
1384 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SAMSUNG MZ7*", "*" },
1385 		/*quirks*/DA_Q_4K
1386 	},
1387 	{
1388 		/*
1389 		 * Same as for SAMSUNG MZ7* but enable the quirks for SSD
1390 		 * starting with MZ7* too
1391 		 */
1392 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "MZ7*", "*" },
1393 		/*quirks*/DA_Q_4K
1394 	},
1395 	{
1396 		/*
1397 		 * SuperTalent TeraDrive CT SSDs
1398 		 * 4k optimised & trim only works in 4k requests + 4k aligned
1399 		 */
1400 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "FTM??CT25H*", "*" },
1401 		/*quirks*/DA_Q_4K
1402 	},
1403 	{
1404 		/*
1405 		 * XceedIOPS SATA SSDs
1406 		 * 4k optimised
1407 		 */
1408 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "SG9XCS2D*", "*" },
1409 		/*quirks*/DA_Q_4K
1410 	},
1411 	{
1412 		/*
1413 		 * Hama Innostor USB-Stick
1414 		 */
1415 		{ T_DIRECT, SIP_MEDIA_REMOVABLE, "Innostor", "Innostor*", "*" },
1416 		/*quirks*/DA_Q_NO_RC16
1417 	},
1418 	{
1419 		/*
1420 		 * Seagate Lamarr 8TB Shingled Magnetic Recording (SMR)
1421 		 * Drive Managed SATA hard drive.  This drive doesn't report
1422 		 * in firmware that it is a drive managed SMR drive.
1423 		 */
1424 		{ T_DIRECT, SIP_MEDIA_FIXED, "ATA", "ST8000AS000[23]*", "*" },
1425 		/*quirks*/DA_Q_SMR_DM
1426 	},
1427 	{
1428 		/*
1429 		 * MX-ES USB Drive by Mach Xtreme
1430 		 */
1431 		{ T_DIRECT, SIP_MEDIA_REMOVABLE, "MX", "MXUB3*", "*"},
1432 		/*quirks*/DA_Q_NO_RC16
1433 	},
1434 };
1435 
1436 static	disk_strategy_t	dastrategy;
1437 static	dumper_t	dadump;
1438 static	periph_init_t	dainit;
1439 static	void		daasync(void *callback_arg, u_int32_t code,
1440 				struct cam_path *path, void *arg);
1441 static	void		dasysctlinit(void *context, int pending);
1442 static	int		dasysctlsofttimeout(SYSCTL_HANDLER_ARGS);
1443 static	int		dacmdsizesysctl(SYSCTL_HANDLER_ARGS);
1444 static	int		dadeletemethodsysctl(SYSCTL_HANDLER_ARGS);
1445 static	int		dazonemodesysctl(SYSCTL_HANDLER_ARGS);
1446 static	int		dazonesupsysctl(SYSCTL_HANDLER_ARGS);
1447 static	int		dadeletemaxsysctl(SYSCTL_HANDLER_ARGS);
1448 static	void		dadeletemethodset(struct da_softc *softc,
1449 					  da_delete_methods delete_method);
1450 static	off_t		dadeletemaxsize(struct da_softc *softc,
1451 					da_delete_methods delete_method);
1452 static	void		dadeletemethodchoose(struct da_softc *softc,
1453 					     da_delete_methods default_method);
1454 static	void		daprobedone(struct cam_periph *periph, union ccb *ccb);
1455 
1456 static	periph_ctor_t	daregister;
1457 static	periph_dtor_t	dacleanup;
1458 static	periph_start_t	dastart;
1459 static	periph_oninv_t	daoninvalidate;
1460 static	void		dazonedone(struct cam_periph *periph, union ccb *ccb);
1461 static	void		dadone(struct cam_periph *periph,
1462 			       union ccb *done_ccb);
1463 static void		dadone_probewp(struct cam_periph *periph,
1464 				       union ccb *done_ccb);
1465 static void		dadone_proberc(struct cam_periph *periph,
1466 				       union ccb *done_ccb);
1467 static void		dadone_probelbp(struct cam_periph *periph,
1468 					union ccb *done_ccb);
1469 static void		dadone_probeblklimits(struct cam_periph *periph,
1470 					      union ccb *done_ccb);
1471 static void		dadone_probebdc(struct cam_periph *periph,
1472 					union ccb *done_ccb);
1473 static void		dadone_probeata(struct cam_periph *periph,
1474 					union ccb *done_ccb);
1475 static void		dadone_probeatalogdir(struct cam_periph *periph,
1476 					      union ccb *done_ccb);
1477 static void		dadone_probeataiddir(struct cam_periph *periph,
1478 					     union ccb *done_ccb);
1479 static void		dadone_probeatasup(struct cam_periph *periph,
1480 					   union ccb *done_ccb);
1481 static void		dadone_probeatazone(struct cam_periph *periph,
1482 					    union ccb *done_ccb);
1483 static void		dadone_probezone(struct cam_periph *periph,
1484 					 union ccb *done_ccb);
1485 static void		dadone_tur(struct cam_periph *periph,
1486 				   union ccb *done_ccb);
1487 static  int		daerror(union ccb *ccb, u_int32_t cam_flags,
1488 				u_int32_t sense_flags);
1489 static void		daprevent(struct cam_periph *periph, int action);
1490 static void		dareprobe(struct cam_periph *periph);
1491 static void		dasetgeom(struct cam_periph *periph, uint32_t block_len,
1492 				  uint64_t maxsector,
1493 				  struct scsi_read_capacity_data_long *rcaplong,
1494 				  size_t rcap_size);
1495 static timeout_t	dasendorderedtag;
1496 static void		dashutdown(void *arg, int howto);
1497 static timeout_t	damediapoll;
1498 
1499 #ifndef	DA_DEFAULT_POLL_PERIOD
1500 #define	DA_DEFAULT_POLL_PERIOD	3
1501 #endif
1502 
1503 #ifndef DA_DEFAULT_TIMEOUT
1504 #define DA_DEFAULT_TIMEOUT 60	/* Timeout in seconds */
1505 #endif
1506 
1507 #ifndef DA_DEFAULT_SOFTTIMEOUT
1508 #define DA_DEFAULT_SOFTTIMEOUT	0
1509 #endif
1510 
1511 #ifndef	DA_DEFAULT_RETRY
1512 #define	DA_DEFAULT_RETRY	4
1513 #endif
1514 
1515 #ifndef	DA_DEFAULT_SEND_ORDERED
1516 #define	DA_DEFAULT_SEND_ORDERED	1
1517 #endif
1518 
1519 static int da_poll_period = DA_DEFAULT_POLL_PERIOD;
1520 static int da_retry_count = DA_DEFAULT_RETRY;
1521 static int da_default_timeout = DA_DEFAULT_TIMEOUT;
1522 static sbintime_t da_default_softtimeout = DA_DEFAULT_SOFTTIMEOUT;
1523 static int da_send_ordered = DA_DEFAULT_SEND_ORDERED;
1524 static int da_disable_wp_detection = 0;
1525 
1526 static SYSCTL_NODE(_kern_cam, OID_AUTO, da, CTLFLAG_RD, 0,
1527             "CAM Direct Access Disk driver");
1528 SYSCTL_INT(_kern_cam_da, OID_AUTO, poll_period, CTLFLAG_RWTUN,
1529            &da_poll_period, 0, "Media polling period in seconds");
1530 SYSCTL_INT(_kern_cam_da, OID_AUTO, retry_count, CTLFLAG_RWTUN,
1531            &da_retry_count, 0, "Normal I/O retry count");
1532 SYSCTL_INT(_kern_cam_da, OID_AUTO, default_timeout, CTLFLAG_RWTUN,
1533            &da_default_timeout, 0, "Normal I/O timeout (in seconds)");
1534 SYSCTL_INT(_kern_cam_da, OID_AUTO, send_ordered, CTLFLAG_RWTUN,
1535            &da_send_ordered, 0, "Send Ordered Tags");
1536 SYSCTL_INT(_kern_cam_da, OID_AUTO, disable_wp_detection, CTLFLAG_RWTUN,
1537            &da_disable_wp_detection, 0,
1538 	   "Disable detection of write-protected disks");
1539 
1540 SYSCTL_PROC(_kern_cam_da, OID_AUTO, default_softtimeout,
1541     CTLTYPE_UINT | CTLFLAG_RW, NULL, 0, dasysctlsofttimeout, "I",
1542     "Soft I/O timeout (ms)");
1543 TUNABLE_INT64("kern.cam.da.default_softtimeout", &da_default_softtimeout);
1544 
1545 /*
1546  * DA_ORDEREDTAG_INTERVAL determines how often, relative
1547  * to the default timeout, we check to see whether an ordered
1548  * tagged transaction is appropriate to prevent simple tag
1549  * starvation.  Since we'd like to ensure that there is at least
1550  * 1/2 of the timeout length left for a starved transaction to
1551  * complete after we've sent an ordered tag, we must poll at least
1552  * four times in every timeout period.  This takes care of the worst
1553  * case where a starved transaction starts during an interval that
1554  * meets the requirement "don't send an ordered tag" test so it takes
1555  * us two intervals to determine that a tag must be sent.
1556  */
1557 #ifndef DA_ORDEREDTAG_INTERVAL
1558 #define DA_ORDEREDTAG_INTERVAL 4
1559 #endif
1560 
1561 static struct periph_driver dadriver =
1562 {
1563 	dainit, "da",
1564 	TAILQ_HEAD_INITIALIZER(dadriver.units), /* generation */ 0
1565 };
1566 
1567 PERIPHDRIVER_DECLARE(da, dadriver);
1568 
1569 static MALLOC_DEFINE(M_SCSIDA, "scsi_da", "scsi_da buffers");
1570 
1571 /*
1572  * This driver takes out references / holds in well defined pairs, never
1573  * recursively. These macros / inline functions enforce those rules. They
1574  * are only enabled with DA_TRACK_REFS or INVARIANTS. If DA_TRACK_REFS is
1575  * defined to be 2 or larger, the tracking also includes debug printfs.
1576  */
1577 #if defined(DA_TRACK_REFS) || defined(INVARIANTS)
1578 
1579 #ifndef DA_TRACK_REFS
1580 #define DA_TRACK_REFS 1
1581 #endif
1582 
1583 #if DA_TRACK_REFS > 1
1584 static const char *da_ref_text[] = {
1585 	"bogus",
1586 	"open",
1587 	"open hold",
1588 	"close hold",
1589 	"reprobe hold",
1590 	"Test Unit Ready",
1591 	"Geom",
1592 	"sysctl",
1593 	"reprobe",
1594 	"max -- also bogus"
1595 };
1596 
1597 #define DA_PERIPH_PRINT(periph, msg, args...)		\
1598 	CAM_PERIPH_PRINT(periph, msg, ##args)
1599 #else
1600 #define DA_PERIPH_PRINT(periph, msg, args...)
1601 #endif
1602 
1603 static inline void
1604 token_sanity(da_ref_token token)
1605 {
1606 	if ((unsigned)token >= DA_REF_MAX)
1607 		panic("Bad token value passed in %d\n", token);
1608 }
1609 
1610 static inline int
1611 da_periph_hold(struct cam_periph *periph, int priority, da_ref_token token)
1612 {
1613 	int err = cam_periph_hold(periph, priority);
1614 
1615 	token_sanity(token);
1616 	DA_PERIPH_PRINT(periph, "Holding device %s (%d): %d\n",
1617 	    da_ref_text[token], token, err);
1618 	if (err == 0) {
1619 		int cnt;
1620 		struct da_softc *softc = periph->softc;
1621 
1622 		cnt = atomic_fetchadd_int(&softc->ref_flags[token], 1);
1623 		if (cnt != 0)
1624 			panic("Re-holding for reason %d, cnt = %d", token, cnt);
1625 	}
1626 	return (err);
1627 }
1628 
1629 static inline void
1630 da_periph_unhold(struct cam_periph *periph, da_ref_token token)
1631 {
1632 	int cnt;
1633 	struct da_softc *softc = periph->softc;
1634 
1635 	token_sanity(token);
1636 	DA_PERIPH_PRINT(periph, "Unholding device %s (%d)\n",
1637 	    da_ref_text[token], token);
1638 	cnt = atomic_fetchadd_int(&softc->ref_flags[token], -1);
1639 	if (cnt != 1)
1640 		panic("Unholding %d with cnt = %d", token, cnt);
1641 	cam_periph_unhold(periph);
1642 }
1643 
1644 static inline int
1645 da_periph_acquire(struct cam_periph *periph, da_ref_token token)
1646 {
1647 	int err = cam_periph_acquire(periph);
1648 
1649 	token_sanity(token);
1650 	DA_PERIPH_PRINT(periph, "acquiring device %s (%d): %d\n",
1651 	    da_ref_text[token], token, err);
1652 	if (err == 0) {
1653 		int cnt;
1654 		struct da_softc *softc = periph->softc;
1655 
1656 		cnt = atomic_fetchadd_int(&softc->ref_flags[token], 1);
1657 		if (cnt != 0)
1658 			panic("Re-refing for reason %d, cnt = %d", token, cnt);
1659 	}
1660 	return (err);
1661 }
1662 
1663 static inline void
1664 da_periph_release(struct cam_periph *periph, da_ref_token token)
1665 {
1666 	int cnt;
1667 	struct da_softc *softc = periph->softc;
1668 
1669 	token_sanity(token);
1670 	DA_PERIPH_PRINT(periph, "releasing device %s (%d)\n",
1671 	    da_ref_text[token], token);
1672 	cnt = atomic_fetchadd_int(&softc->ref_flags[token], -1);
1673 	if (cnt != 1)
1674 		panic("Releasing %d with cnt = %d", token, cnt);
1675 	cam_periph_release(periph);
1676 }
1677 
1678 static inline void
1679 da_periph_release_locked(struct cam_periph *periph, da_ref_token token)
1680 {
1681 	int cnt;
1682 	struct da_softc *softc = periph->softc;
1683 
1684 	token_sanity(token);
1685 	DA_PERIPH_PRINT(periph, "releasing device (locked) %s (%d)\n",
1686 	    da_ref_text[token], token);
1687 	cnt = atomic_fetchadd_int(&softc->ref_flags[token], -1);
1688 	if (cnt != 1)
1689 		panic("Unholding %d with cnt = %d", token, cnt);
1690 	cam_periph_release_locked(periph);
1691 }
1692 
1693 #define cam_periph_hold POISON
1694 #define cam_periph_unhold POISON
1695 #define cam_periph_acquire POISON
1696 #define cam_periph_release POISON
1697 #define cam_periph_release_locked POISON
1698 
1699 #else
1700 #define	da_periph_hold(periph, prio, token)	cam_periph_hold((periph), (prio))
1701 #define da_periph_unhold(periph, token)		cam_periph_unhold((periph))
1702 #define da_periph_acquire(periph, token)	cam_periph_acquire((periph))
1703 #define da_periph_release(periph, token)	cam_periph_release((periph))
1704 #define da_periph_release_locked(periph, token)	cam_periph_release_locked((periph))
1705 #endif
1706 
1707 static int
1708 daopen(struct disk *dp)
1709 {
1710 	struct cam_periph *periph;
1711 	struct da_softc *softc;
1712 	int error;
1713 
1714 	periph = (struct cam_periph *)dp->d_drv1;
1715 	if (da_periph_acquire(periph, DA_REF_OPEN) != 0) {
1716 		return (ENXIO);
1717 	}
1718 
1719 	cam_periph_lock(periph);
1720 	if ((error = da_periph_hold(periph, PRIBIO|PCATCH, DA_REF_OPEN_HOLD)) != 0) {
1721 		cam_periph_unlock(periph);
1722 		da_periph_release(periph, DA_REF_OPEN);
1723 		return (error);
1724 	}
1725 
1726 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
1727 	    ("daopen\n"));
1728 
1729 	softc = (struct da_softc *)periph->softc;
1730 	dareprobe(periph);
1731 
1732 	/* Wait for the disk size update.  */
1733 	error = cam_periph_sleep(periph, &softc->disk->d_mediasize, PRIBIO,
1734 	    "dareprobe", 0);
1735 	if (error != 0)
1736 		xpt_print(periph->path, "unable to retrieve capacity data\n");
1737 
1738 	if (periph->flags & CAM_PERIPH_INVALID)
1739 		error = ENXIO;
1740 
1741 	if (error == 0 && (softc->flags & DA_FLAG_PACK_REMOVABLE) != 0 &&
1742 	    (softc->quirks & DA_Q_NO_PREVENT) == 0)
1743 		daprevent(periph, PR_PREVENT);
1744 
1745 	if (error == 0) {
1746 		softc->flags &= ~DA_FLAG_PACK_INVALID;
1747 		softc->flags |= DA_FLAG_OPEN;
1748 	}
1749 
1750 	da_periph_unhold(periph, DA_REF_OPEN_HOLD);
1751 	cam_periph_unlock(periph);
1752 
1753 	if (error != 0)
1754 		da_periph_release(periph, DA_REF_OPEN);
1755 
1756 	return (error);
1757 }
1758 
1759 static int
1760 daclose(struct disk *dp)
1761 {
1762 	struct	cam_periph *periph;
1763 	struct	da_softc *softc;
1764 	union	ccb *ccb;
1765 
1766 	periph = (struct cam_periph *)dp->d_drv1;
1767 	softc = (struct da_softc *)periph->softc;
1768 	cam_periph_lock(periph);
1769 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
1770 	    ("daclose\n"));
1771 
1772 	if (da_periph_hold(periph, PRIBIO, DA_REF_CLOSE_HOLD) == 0) {
1773 
1774 		/* Flush disk cache. */
1775 		if ((softc->flags & DA_FLAG_DIRTY) != 0 &&
1776 		    (softc->quirks & DA_Q_NO_SYNC_CACHE) == 0 &&
1777 		    (softc->flags & DA_FLAG_PACK_INVALID) == 0) {
1778 			ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
1779 			scsi_synchronize_cache(&ccb->csio, /*retries*/1,
1780 			    /*cbfcnp*/NULL, MSG_SIMPLE_Q_TAG,
1781 			    /*begin_lba*/0, /*lb_count*/0, SSD_FULL_SIZE,
1782 			    5 * 60 * 1000);
1783 			cam_periph_runccb(ccb, daerror, /*cam_flags*/0,
1784 			    /*sense_flags*/SF_RETRY_UA | SF_QUIET_IR,
1785 			    softc->disk->d_devstat);
1786 			softc->flags &= ~DA_FLAG_DIRTY;
1787 			xpt_release_ccb(ccb);
1788 		}
1789 
1790 		/* Allow medium removal. */
1791 		if ((softc->flags & DA_FLAG_PACK_REMOVABLE) != 0 &&
1792 		    (softc->quirks & DA_Q_NO_PREVENT) == 0)
1793 			daprevent(periph, PR_ALLOW);
1794 
1795 		da_periph_unhold(periph, DA_REF_CLOSE_HOLD);
1796 	}
1797 
1798 	/*
1799 	 * If we've got removeable media, mark the blocksize as
1800 	 * unavailable, since it could change when new media is
1801 	 * inserted.
1802 	 */
1803 	if ((softc->flags & DA_FLAG_PACK_REMOVABLE) != 0)
1804 		softc->disk->d_devstat->flags |= DEVSTAT_BS_UNAVAILABLE;
1805 
1806 	softc->flags &= ~DA_FLAG_OPEN;
1807 	while (softc->refcount != 0)
1808 		cam_periph_sleep(periph, &softc->refcount, PRIBIO, "daclose", 1);
1809 	cam_periph_unlock(periph);
1810 	da_periph_release(periph, DA_REF_OPEN);
1811 	return (0);
1812 }
1813 
1814 static void
1815 daschedule(struct cam_periph *periph)
1816 {
1817 	struct da_softc *softc = (struct da_softc *)periph->softc;
1818 
1819 	if (softc->state != DA_STATE_NORMAL)
1820 		return;
1821 
1822 	cam_iosched_schedule(softc->cam_iosched, periph);
1823 }
1824 
1825 /*
1826  * Actually translate the requested transfer into one the physical driver
1827  * can understand.  The transfer is described by a buf and will include
1828  * only one physical transfer.
1829  */
1830 static void
1831 dastrategy(struct bio *bp)
1832 {
1833 	struct cam_periph *periph;
1834 	struct da_softc *softc;
1835 
1836 	periph = (struct cam_periph *)bp->bio_disk->d_drv1;
1837 	softc = (struct da_softc *)periph->softc;
1838 
1839 	cam_periph_lock(periph);
1840 
1841 	/*
1842 	 * If the device has been made invalid, error out
1843 	 */
1844 	if ((softc->flags & DA_FLAG_PACK_INVALID)) {
1845 		cam_periph_unlock(periph);
1846 		biofinish(bp, NULL, ENXIO);
1847 		return;
1848 	}
1849 
1850 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dastrategy(%p)\n", bp));
1851 
1852 	/*
1853 	 * Zone commands must be ordered, because they can depend on the
1854 	 * effects of previously issued commands, and they may affect
1855 	 * commands after them.
1856 	 */
1857 	if (bp->bio_cmd == BIO_ZONE)
1858 		bp->bio_flags |= BIO_ORDERED;
1859 
1860 	/*
1861 	 * Place it in the queue of disk activities for this disk
1862 	 */
1863 	cam_iosched_queue_work(softc->cam_iosched, bp);
1864 
1865 	/*
1866 	 * Schedule ourselves for performing the work.
1867 	 */
1868 	daschedule(periph);
1869 	cam_periph_unlock(periph);
1870 
1871 	return;
1872 }
1873 
1874 static int
1875 dadump(void *arg, void *virtual, vm_offset_t physical, off_t offset, size_t length)
1876 {
1877 	struct	    cam_periph *periph;
1878 	struct	    da_softc *softc;
1879 	u_int	    secsize;
1880 	struct	    ccb_scsiio csio;
1881 	struct	    disk *dp;
1882 	int	    error = 0;
1883 
1884 	dp = arg;
1885 	periph = dp->d_drv1;
1886 	softc = (struct da_softc *)periph->softc;
1887 	secsize = softc->params.secsize;
1888 
1889 	if ((softc->flags & DA_FLAG_PACK_INVALID) != 0)
1890 		return (ENXIO);
1891 
1892 	memset(&csio, 0, sizeof(csio));
1893 	if (length > 0) {
1894 		xpt_setup_ccb(&csio.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
1895 		csio.ccb_h.ccb_state = DA_CCB_DUMP;
1896 		scsi_read_write(&csio,
1897 				/*retries*/0,
1898 				/*cbfcnp*/NULL,
1899 				MSG_ORDERED_Q_TAG,
1900 				/*read*/SCSI_RW_WRITE,
1901 				/*byte2*/0,
1902 				/*minimum_cmd_size*/ softc->minimum_cmd_size,
1903 				offset / secsize,
1904 				length / secsize,
1905 				/*data_ptr*/(u_int8_t *) virtual,
1906 				/*dxfer_len*/length,
1907 				/*sense_len*/SSD_FULL_SIZE,
1908 				da_default_timeout * 1000);
1909 		error = cam_periph_runccb((union ccb *)&csio, cam_periph_error,
1910 		    0, SF_NO_RECOVERY | SF_NO_RETRY, NULL);
1911 		if (error != 0)
1912 			printf("Aborting dump due to I/O error.\n");
1913 		return (error);
1914 	}
1915 
1916 	/*
1917 	 * Sync the disk cache contents to the physical media.
1918 	 */
1919 	if ((softc->quirks & DA_Q_NO_SYNC_CACHE) == 0) {
1920 
1921 		xpt_setup_ccb(&csio.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
1922 		csio.ccb_h.ccb_state = DA_CCB_DUMP;
1923 		scsi_synchronize_cache(&csio,
1924 				       /*retries*/0,
1925 				       /*cbfcnp*/NULL,
1926 				       MSG_SIMPLE_Q_TAG,
1927 				       /*begin_lba*/0,/* Cover the whole disk */
1928 				       /*lb_count*/0,
1929 				       SSD_FULL_SIZE,
1930 				       5 * 1000);
1931 		error = cam_periph_runccb((union ccb *)&csio, cam_periph_error,
1932 		    0, SF_NO_RECOVERY | SF_NO_RETRY, NULL);
1933 		if (error != 0)
1934 			xpt_print(periph->path, "Synchronize cache failed\n");
1935 	}
1936 	return (error);
1937 }
1938 
1939 static int
1940 dagetattr(struct bio *bp)
1941 {
1942 	int ret;
1943 	struct cam_periph *periph;
1944 
1945 	periph = (struct cam_periph *)bp->bio_disk->d_drv1;
1946 	cam_periph_lock(periph);
1947 	ret = xpt_getattr(bp->bio_data, bp->bio_length, bp->bio_attribute,
1948 	    periph->path);
1949 	cam_periph_unlock(periph);
1950 	if (ret == 0)
1951 		bp->bio_completed = bp->bio_length;
1952 	return ret;
1953 }
1954 
1955 static void
1956 dainit(void)
1957 {
1958 	cam_status status;
1959 
1960 	/*
1961 	 * Install a global async callback.  This callback will
1962 	 * receive async callbacks like "new device found".
1963 	 */
1964 	status = xpt_register_async(AC_FOUND_DEVICE, daasync, NULL, NULL);
1965 
1966 	if (status != CAM_REQ_CMP) {
1967 		printf("da: Failed to attach master async callback "
1968 		       "due to status 0x%x!\n", status);
1969 	} else if (da_send_ordered) {
1970 
1971 		/* Register our shutdown event handler */
1972 		if ((EVENTHANDLER_REGISTER(shutdown_post_sync, dashutdown,
1973 					   NULL, SHUTDOWN_PRI_DEFAULT)) == NULL)
1974 		    printf("dainit: shutdown event registration failed!\n");
1975 	}
1976 }
1977 
1978 /*
1979  * Callback from GEOM, called when it has finished cleaning up its
1980  * resources.
1981  */
1982 static void
1983 dadiskgonecb(struct disk *dp)
1984 {
1985 	struct cam_periph *periph;
1986 
1987 	periph = (struct cam_periph *)dp->d_drv1;
1988 	da_periph_release(periph, DA_REF_GEOM);
1989 }
1990 
1991 static void
1992 daoninvalidate(struct cam_periph *periph)
1993 {
1994 	struct da_softc *softc;
1995 
1996 	cam_periph_assert(periph, MA_OWNED);
1997 	softc = (struct da_softc *)periph->softc;
1998 
1999 	/*
2000 	 * De-register any async callbacks.
2001 	 */
2002 	xpt_register_async(0, daasync, periph, periph->path);
2003 
2004 	softc->flags |= DA_FLAG_PACK_INVALID;
2005 #ifdef CAM_IO_STATS
2006 	softc->invalidations++;
2007 #endif
2008 
2009 	/*
2010 	 * Return all queued I/O with ENXIO.
2011 	 * XXX Handle any transactions queued to the card
2012 	 *     with XPT_ABORT_CCB.
2013 	 */
2014 	cam_iosched_flush(softc->cam_iosched, NULL, ENXIO);
2015 
2016 	/*
2017 	 * Tell GEOM that we've gone away, we'll get a callback when it is
2018 	 * done cleaning up its resources.
2019 	 */
2020 	disk_gone(softc->disk);
2021 }
2022 
2023 static void
2024 dacleanup(struct cam_periph *periph)
2025 {
2026 	struct da_softc *softc;
2027 
2028 	softc = (struct da_softc *)periph->softc;
2029 
2030 	cam_periph_unlock(periph);
2031 
2032 	cam_iosched_fini(softc->cam_iosched);
2033 
2034 	/*
2035 	 * If we can't free the sysctl tree, oh well...
2036 	 */
2037 	if ((softc->flags & DA_FLAG_SCTX_INIT) != 0) {
2038 #ifdef CAM_IO_STATS
2039 		if (sysctl_ctx_free(&softc->sysctl_stats_ctx) != 0)
2040 			xpt_print(periph->path,
2041 			    "can't remove sysctl stats context\n");
2042 #endif
2043 		if (sysctl_ctx_free(&softc->sysctl_ctx) != 0)
2044 			xpt_print(periph->path,
2045 			    "can't remove sysctl context\n");
2046 	}
2047 
2048 	callout_drain(&softc->mediapoll_c);
2049 	disk_destroy(softc->disk);
2050 	callout_drain(&softc->sendordered_c);
2051 	free(softc, M_DEVBUF);
2052 	cam_periph_lock(periph);
2053 }
2054 
2055 static void
2056 daasync(void *callback_arg, u_int32_t code,
2057 	struct cam_path *path, void *arg)
2058 {
2059 	struct cam_periph *periph;
2060 	struct da_softc *softc;
2061 
2062 	periph = (struct cam_periph *)callback_arg;
2063 	switch (code) {
2064 	case AC_FOUND_DEVICE:	/* callback to create periph, no locking yet */
2065 	{
2066 		struct ccb_getdev *cgd;
2067 		cam_status status;
2068 
2069 		cgd = (struct ccb_getdev *)arg;
2070 		if (cgd == NULL)
2071 			break;
2072 
2073 		if (cgd->protocol != PROTO_SCSI)
2074 			break;
2075 		if (SID_QUAL(&cgd->inq_data) != SID_QUAL_LU_CONNECTED)
2076 			break;
2077 		if (SID_TYPE(&cgd->inq_data) != T_DIRECT
2078 		    && SID_TYPE(&cgd->inq_data) != T_RBC
2079 		    && SID_TYPE(&cgd->inq_data) != T_OPTICAL
2080 		    && SID_TYPE(&cgd->inq_data) != T_ZBC_HM)
2081 			break;
2082 
2083 		/*
2084 		 * Allocate a peripheral instance for
2085 		 * this device and start the probe
2086 		 * process.
2087 		 */
2088 		status = cam_periph_alloc(daregister, daoninvalidate,
2089 					  dacleanup, dastart,
2090 					  "da", CAM_PERIPH_BIO,
2091 					  path, daasync,
2092 					  AC_FOUND_DEVICE, cgd);
2093 
2094 		if (status != CAM_REQ_CMP
2095 		 && status != CAM_REQ_INPROG)
2096 			printf("daasync: Unable to attach to new device "
2097 				"due to status 0x%x\n", status);
2098 		return;
2099 	}
2100 	case AC_ADVINFO_CHANGED:	/* Doesn't touch periph */
2101 	{
2102 		uintptr_t buftype;
2103 
2104 		buftype = (uintptr_t)arg;
2105 		if (buftype == CDAI_TYPE_PHYS_PATH) {
2106 			struct da_softc *softc;
2107 
2108 			softc = periph->softc;
2109 			disk_attr_changed(softc->disk, "GEOM::physpath",
2110 					  M_NOWAIT);
2111 		}
2112 		break;
2113 	}
2114 	case AC_UNIT_ATTENTION:
2115 	{
2116 		union ccb *ccb;
2117 		int error_code, sense_key, asc, ascq;
2118 
2119 		softc = (struct da_softc *)periph->softc;
2120 		ccb = (union ccb *)arg;
2121 
2122 		/*
2123 		 * Handle all UNIT ATTENTIONs except our own, as they will be
2124 		 * handled by daerror(). Since this comes from a different periph,
2125 		 * that periph's lock is held, not ours, so we have to take it ours
2126 		 * out to touch softc flags.
2127 		 */
2128 		if (xpt_path_periph(ccb->ccb_h.path) != periph &&
2129 		    scsi_extract_sense_ccb(ccb,
2130 		     &error_code, &sense_key, &asc, &ascq)) {
2131 			if (asc == 0x2A && ascq == 0x09) {
2132 				xpt_print(ccb->ccb_h.path,
2133 				    "Capacity data has changed\n");
2134 				cam_periph_lock(periph);
2135 				softc->flags &= ~DA_FLAG_PROBED;
2136 				cam_periph_unlock(periph);
2137 				dareprobe(periph);
2138 			} else if (asc == 0x28 && ascq == 0x00) {
2139 				cam_periph_lock(periph);
2140 				softc->flags &= ~DA_FLAG_PROBED;
2141 				cam_periph_unlock(periph);
2142 				disk_media_changed(softc->disk, M_NOWAIT);
2143 			} else if (asc == 0x3F && ascq == 0x03) {
2144 				xpt_print(ccb->ccb_h.path,
2145 				    "INQUIRY data has changed\n");
2146 				cam_periph_lock(periph);
2147 				softc->flags &= ~DA_FLAG_PROBED;
2148 				cam_periph_unlock(periph);
2149 				dareprobe(periph);
2150 			}
2151 		}
2152 		break;
2153 	}
2154 	case AC_SCSI_AEN:		/* Called for this path: periph locked */
2155 		/*
2156 		 * Appears to be currently unused for SCSI devices, only ata SIMs
2157 		 * generate this.
2158 		 */
2159 		cam_periph_assert(periph, MA_OWNED);
2160 		softc = (struct da_softc *)periph->softc;
2161 		if (!cam_iosched_has_work_flags(softc->cam_iosched, DA_WORK_TUR) &&
2162 		    (softc->flags & DA_FLAG_TUR_PENDING) == 0) {
2163 			if (da_periph_acquire(periph, DA_REF_TUR) == 0) {
2164 				cam_iosched_set_work_flags(softc->cam_iosched, DA_WORK_TUR);
2165 				daschedule(periph);
2166 			}
2167 		}
2168 		/* FALLTHROUGH */
2169 	case AC_SENT_BDR:		/* Called for this path: periph locked */
2170 	case AC_BUS_RESET:		/* Called for this path: periph locked */
2171 	{
2172 		struct ccb_hdr *ccbh;
2173 
2174 		cam_periph_assert(periph, MA_OWNED);
2175 		softc = (struct da_softc *)periph->softc;
2176 		/*
2177 		 * Don't fail on the expected unit attention
2178 		 * that will occur.
2179 		 */
2180 		softc->flags |= DA_FLAG_RETRY_UA;
2181 		LIST_FOREACH(ccbh, &softc->pending_ccbs, periph_links.le)
2182 			ccbh->ccb_state |= DA_CCB_RETRY_UA;
2183 		break;
2184 	}
2185 	case AC_INQ_CHANGED:		/* Called for this path: periph locked */
2186 		cam_periph_assert(periph, MA_OWNED);
2187 		softc = (struct da_softc *)periph->softc;
2188 		softc->flags &= ~DA_FLAG_PROBED;
2189 		dareprobe(periph);
2190 		break;
2191 	default:
2192 		break;
2193 	}
2194 	cam_periph_async(periph, code, path, arg);
2195 }
2196 
2197 static void
2198 dasysctlinit(void *context, int pending)
2199 {
2200 	struct cam_periph *periph;
2201 	struct da_softc *softc;
2202 	char tmpstr[32], tmpstr2[16];
2203 	struct ccb_trans_settings cts;
2204 
2205 	periph = (struct cam_periph *)context;
2206 	/*
2207 	 * periph was held for us when this task was enqueued
2208 	 */
2209 	if (periph->flags & CAM_PERIPH_INVALID) {
2210 		da_periph_release(periph, DA_REF_SYSCTL);
2211 		return;
2212 	}
2213 
2214 	softc = (struct da_softc *)periph->softc;
2215 	snprintf(tmpstr, sizeof(tmpstr), "CAM DA unit %d", periph->unit_number);
2216 	snprintf(tmpstr2, sizeof(tmpstr2), "%d", periph->unit_number);
2217 
2218 	sysctl_ctx_init(&softc->sysctl_ctx);
2219 	cam_periph_lock(periph);
2220 	softc->flags |= DA_FLAG_SCTX_INIT;
2221 	cam_periph_unlock(periph);
2222 	softc->sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&softc->sysctl_ctx,
2223 		SYSCTL_STATIC_CHILDREN(_kern_cam_da), OID_AUTO, tmpstr2,
2224 		CTLFLAG_RD, 0, tmpstr, "device_index");
2225 	if (softc->sysctl_tree == NULL) {
2226 		printf("dasysctlinit: unable to allocate sysctl tree\n");
2227 		da_periph_release(periph, DA_REF_SYSCTL);
2228 		return;
2229 	}
2230 
2231 	/*
2232 	 * Now register the sysctl handler, so the user can change the value on
2233 	 * the fly.
2234 	 */
2235 	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2236 		OID_AUTO, "delete_method", CTLTYPE_STRING | CTLFLAG_RWTUN,
2237 		softc, 0, dadeletemethodsysctl, "A",
2238 		"BIO_DELETE execution method");
2239 	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2240 		OID_AUTO, "delete_max", CTLTYPE_U64 | CTLFLAG_RW,
2241 		softc, 0, dadeletemaxsysctl, "Q",
2242 		"Maximum BIO_DELETE size");
2243 	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2244 		OID_AUTO, "minimum_cmd_size", CTLTYPE_INT | CTLFLAG_RW,
2245 		&softc->minimum_cmd_size, 0, dacmdsizesysctl, "I",
2246 		"Minimum CDB size");
2247 	SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2248 		SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
2249 		"trim_count", CTLFLAG_RD, &softc->trim_count,
2250 		"Total number of unmap/dsm commands sent");
2251 	SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2252 		SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
2253 		"trim_ranges", CTLFLAG_RD, &softc->trim_ranges,
2254 		"Total number of ranges in unmap/dsm commands");
2255 	SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2256 		SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
2257 		"trim_lbas", CTLFLAG_RD, &softc->trim_lbas,
2258 		"Total lbas in the unmap/dsm commands sent");
2259 
2260 	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2261 		OID_AUTO, "zone_mode", CTLTYPE_STRING | CTLFLAG_RD,
2262 		softc, 0, dazonemodesysctl, "A",
2263 		"Zone Mode");
2264 	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2265 		OID_AUTO, "zone_support", CTLTYPE_STRING | CTLFLAG_RD,
2266 		softc, 0, dazonesupsysctl, "A",
2267 		"Zone Support");
2268 	SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2269 		SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
2270 		"optimal_seq_zones", CTLFLAG_RD, &softc->optimal_seq_zones,
2271 		"Optimal Number of Open Sequential Write Preferred Zones");
2272 	SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2273 		SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
2274 		"optimal_nonseq_zones", CTLFLAG_RD,
2275 		&softc->optimal_nonseq_zones,
2276 		"Optimal Number of Non-Sequentially Written Sequential Write "
2277 		"Preferred Zones");
2278 	SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2279 		SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO,
2280 		"max_seq_zones", CTLFLAG_RD, &softc->max_seq_zones,
2281 		"Maximum Number of Open Sequential Write Required Zones");
2282 
2283 	SYSCTL_ADD_INT(&softc->sysctl_ctx,
2284 		       SYSCTL_CHILDREN(softc->sysctl_tree),
2285 		       OID_AUTO,
2286 		       "error_inject",
2287 		       CTLFLAG_RW,
2288 		       &softc->error_inject,
2289 		       0,
2290 		       "error_inject leaf");
2291 
2292 	SYSCTL_ADD_INT(&softc->sysctl_ctx,
2293 		       SYSCTL_CHILDREN(softc->sysctl_tree),
2294 		       OID_AUTO,
2295 		       "unmapped_io",
2296 		       CTLFLAG_RD,
2297 		       &softc->unmappedio,
2298 		       0,
2299 		       "Unmapped I/O support");
2300 
2301 	SYSCTL_ADD_INT(&softc->sysctl_ctx,
2302 		       SYSCTL_CHILDREN(softc->sysctl_tree),
2303 		       OID_AUTO,
2304 		       "rotating",
2305 		       CTLFLAG_RD,
2306 		       &softc->rotating,
2307 		       0,
2308 		       "Rotating media");
2309 
2310 	SYSCTL_ADD_INT(&softc->sysctl_ctx,
2311 		       SYSCTL_CHILDREN(softc->sysctl_tree),
2312 		       OID_AUTO,
2313 		       "p_type",
2314 		       CTLFLAG_RD,
2315 		       &softc->p_type,
2316 		       0,
2317 		       "DIF protection type");
2318 
2319 #ifdef CAM_TEST_FAILURE
2320 	SYSCTL_ADD_PROC(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
2321 		OID_AUTO, "invalidate", CTLTYPE_U64 | CTLFLAG_RW | CTLFLAG_MPSAFE,
2322 		periph, 0, cam_periph_invalidate_sysctl, "I",
2323 		"Write 1 to invalidate the drive immediately");
2324 #endif
2325 
2326 	/*
2327 	 * Add some addressing info.
2328 	 */
2329 	memset(&cts, 0, sizeof (cts));
2330 	xpt_setup_ccb(&cts.ccb_h, periph->path, CAM_PRIORITY_NONE);
2331 	cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
2332 	cts.type = CTS_TYPE_CURRENT_SETTINGS;
2333 	cam_periph_lock(periph);
2334 	xpt_action((union ccb *)&cts);
2335 	cam_periph_unlock(periph);
2336 	if (cts.ccb_h.status != CAM_REQ_CMP) {
2337 		da_periph_release(periph, DA_REF_SYSCTL);
2338 		return;
2339 	}
2340 	if (cts.protocol == PROTO_SCSI && cts.transport == XPORT_FC) {
2341 		struct ccb_trans_settings_fc *fc = &cts.xport_specific.fc;
2342 		if (fc->valid & CTS_FC_VALID_WWPN) {
2343 			softc->wwpn = fc->wwpn;
2344 			SYSCTL_ADD_UQUAD(&softc->sysctl_ctx,
2345 			    SYSCTL_CHILDREN(softc->sysctl_tree),
2346 			    OID_AUTO, "wwpn", CTLFLAG_RD,
2347 			    &softc->wwpn, "World Wide Port Name");
2348 		}
2349 	}
2350 
2351 #ifdef CAM_IO_STATS
2352 	/*
2353 	 * Now add some useful stats.
2354 	 * XXX These should live in cam_periph and be common to all periphs
2355 	 */
2356 	softc->sysctl_stats_tree = SYSCTL_ADD_NODE(&softc->sysctl_stats_ctx,
2357 	    SYSCTL_CHILDREN(softc->sysctl_tree), OID_AUTO, "stats",
2358 	    CTLFLAG_RD, 0, "Statistics");
2359 	SYSCTL_ADD_INT(&softc->sysctl_stats_ctx,
2360 		       SYSCTL_CHILDREN(softc->sysctl_stats_tree),
2361 		       OID_AUTO,
2362 		       "errors",
2363 		       CTLFLAG_RD,
2364 		       &softc->errors,
2365 		       0,
2366 		       "Transport errors reported by the SIM");
2367 	SYSCTL_ADD_INT(&softc->sysctl_stats_ctx,
2368 		       SYSCTL_CHILDREN(softc->sysctl_stats_tree),
2369 		       OID_AUTO,
2370 		       "timeouts",
2371 		       CTLFLAG_RD,
2372 		       &softc->timeouts,
2373 		       0,
2374 		       "Device timeouts reported by the SIM");
2375 	SYSCTL_ADD_INT(&softc->sysctl_stats_ctx,
2376 		       SYSCTL_CHILDREN(softc->sysctl_stats_tree),
2377 		       OID_AUTO,
2378 		       "pack_invalidations",
2379 		       CTLFLAG_RD,
2380 		       &softc->invalidations,
2381 		       0,
2382 		       "Device pack invalidations");
2383 #endif
2384 
2385 	cam_iosched_sysctl_init(softc->cam_iosched, &softc->sysctl_ctx,
2386 	    softc->sysctl_tree);
2387 
2388 	da_periph_release(periph, DA_REF_SYSCTL);
2389 }
2390 
2391 static int
2392 dadeletemaxsysctl(SYSCTL_HANDLER_ARGS)
2393 {
2394 	int error;
2395 	uint64_t value;
2396 	struct da_softc *softc;
2397 
2398 	softc = (struct da_softc *)arg1;
2399 
2400 	value = softc->disk->d_delmaxsize;
2401 	error = sysctl_handle_64(oidp, &value, 0, req);
2402 	if ((error != 0) || (req->newptr == NULL))
2403 		return (error);
2404 
2405 	/* only accept values smaller than the calculated value */
2406 	if (value > dadeletemaxsize(softc, softc->delete_method)) {
2407 		return (EINVAL);
2408 	}
2409 	softc->disk->d_delmaxsize = value;
2410 
2411 	return (0);
2412 }
2413 
2414 static int
2415 dacmdsizesysctl(SYSCTL_HANDLER_ARGS)
2416 {
2417 	int error, value;
2418 
2419 	value = *(int *)arg1;
2420 
2421 	error = sysctl_handle_int(oidp, &value, 0, req);
2422 
2423 	if ((error != 0)
2424 	 || (req->newptr == NULL))
2425 		return (error);
2426 
2427 	/*
2428 	 * Acceptable values here are 6, 10, 12 or 16.
2429 	 */
2430 	if (value < 6)
2431 		value = 6;
2432 	else if ((value > 6)
2433 	      && (value <= 10))
2434 		value = 10;
2435 	else if ((value > 10)
2436 	      && (value <= 12))
2437 		value = 12;
2438 	else if (value > 12)
2439 		value = 16;
2440 
2441 	*(int *)arg1 = value;
2442 
2443 	return (0);
2444 }
2445 
2446 static int
2447 dasysctlsofttimeout(SYSCTL_HANDLER_ARGS)
2448 {
2449 	sbintime_t value;
2450 	int error;
2451 
2452 	value = da_default_softtimeout / SBT_1MS;
2453 
2454 	error = sysctl_handle_int(oidp, (int *)&value, 0, req);
2455 	if ((error != 0) || (req->newptr == NULL))
2456 		return (error);
2457 
2458 	/* XXX Should clip this to a reasonable level */
2459 	if (value > da_default_timeout * 1000)
2460 		return (EINVAL);
2461 
2462 	da_default_softtimeout = value * SBT_1MS;
2463 	return (0);
2464 }
2465 
2466 static void
2467 dadeletemethodset(struct da_softc *softc, da_delete_methods delete_method)
2468 {
2469 
2470 	softc->delete_method = delete_method;
2471 	softc->disk->d_delmaxsize = dadeletemaxsize(softc, delete_method);
2472 	softc->delete_func = da_delete_functions[delete_method];
2473 
2474 	if (softc->delete_method > DA_DELETE_DISABLE)
2475 		softc->disk->d_flags |= DISKFLAG_CANDELETE;
2476 	else
2477 		softc->disk->d_flags &= ~DISKFLAG_CANDELETE;
2478 }
2479 
2480 static off_t
2481 dadeletemaxsize(struct da_softc *softc, da_delete_methods delete_method)
2482 {
2483 	off_t sectors;
2484 
2485 	switch(delete_method) {
2486 	case DA_DELETE_UNMAP:
2487 		sectors = (off_t)softc->unmap_max_lba;
2488 		break;
2489 	case DA_DELETE_ATA_TRIM:
2490 		sectors = (off_t)ATA_DSM_RANGE_MAX * softc->trim_max_ranges;
2491 		break;
2492 	case DA_DELETE_WS16:
2493 		sectors = omin(softc->ws_max_blks, WS16_MAX_BLKS);
2494 		break;
2495 	case DA_DELETE_ZERO:
2496 	case DA_DELETE_WS10:
2497 		sectors = omin(softc->ws_max_blks, WS10_MAX_BLKS);
2498 		break;
2499 	default:
2500 		return 0;
2501 	}
2502 
2503 	return (off_t)softc->params.secsize *
2504 	    omin(sectors, softc->params.sectors);
2505 }
2506 
2507 static void
2508 daprobedone(struct cam_periph *periph, union ccb *ccb)
2509 {
2510 	struct da_softc *softc;
2511 
2512 	softc = (struct da_softc *)periph->softc;
2513 
2514 	cam_periph_assert(periph, MA_OWNED);
2515 
2516 	dadeletemethodchoose(softc, DA_DELETE_NONE);
2517 
2518 	if (bootverbose && (softc->flags & DA_FLAG_ANNOUNCED) == 0) {
2519 		char buf[80];
2520 		int i, sep;
2521 
2522 		snprintf(buf, sizeof(buf), "Delete methods: <");
2523 		sep = 0;
2524 		for (i = 0; i <= DA_DELETE_MAX; i++) {
2525 			if ((softc->delete_available & (1 << i)) == 0 &&
2526 			    i != softc->delete_method)
2527 				continue;
2528 			if (sep)
2529 				strlcat(buf, ",", sizeof(buf));
2530 			strlcat(buf, da_delete_method_names[i],
2531 			    sizeof(buf));
2532 			if (i == softc->delete_method)
2533 				strlcat(buf, "(*)", sizeof(buf));
2534 			sep = 1;
2535 		}
2536 		strlcat(buf, ">", sizeof(buf));
2537 		printf("%s%d: %s\n", periph->periph_name,
2538 		    periph->unit_number, buf);
2539 	}
2540 	if ((softc->disk->d_flags & DISKFLAG_WRITE_PROTECT) != 0 &&
2541 	    (softc->flags & DA_FLAG_ANNOUNCED) == 0) {
2542 		printf("%s%d: Write Protected\n", periph->periph_name,
2543 		    periph->unit_number);
2544 	}
2545 
2546 	/*
2547 	 * Since our peripheral may be invalidated by an error
2548 	 * above or an external event, we must release our CCB
2549 	 * before releasing the probe lock on the peripheral.
2550 	 * The peripheral will only go away once the last lock
2551 	 * is removed, and we need it around for the CCB release
2552 	 * operation.
2553 	 */
2554 	xpt_release_ccb(ccb);
2555 	softc->state = DA_STATE_NORMAL;
2556 	softc->flags |= DA_FLAG_PROBED;
2557 	daschedule(periph);
2558 	wakeup(&softc->disk->d_mediasize);
2559 	if ((softc->flags & DA_FLAG_ANNOUNCED) == 0) {
2560 		softc->flags |= DA_FLAG_ANNOUNCED;
2561 		da_periph_unhold(periph, DA_REF_PROBE_HOLD);
2562 	} else
2563 		da_periph_release_locked(periph, DA_REF_REPROBE);
2564 }
2565 
2566 static void
2567 dadeletemethodchoose(struct da_softc *softc, da_delete_methods default_method)
2568 {
2569 	int i, methods;
2570 
2571 	/* If available, prefer the method requested by user. */
2572 	i = softc->delete_method_pref;
2573 	methods = softc->delete_available | (1 << DA_DELETE_DISABLE);
2574 	if (methods & (1 << i)) {
2575 		dadeletemethodset(softc, i);
2576 		return;
2577 	}
2578 
2579 	/* Use the pre-defined order to choose the best performing delete. */
2580 	for (i = DA_DELETE_MIN; i <= DA_DELETE_MAX; i++) {
2581 		if (i == DA_DELETE_ZERO)
2582 			continue;
2583 		if (softc->delete_available & (1 << i)) {
2584 			dadeletemethodset(softc, i);
2585 			return;
2586 		}
2587 	}
2588 
2589 	/* Fallback to default. */
2590 	dadeletemethodset(softc, default_method);
2591 }
2592 
2593 static int
2594 dadeletemethodsysctl(SYSCTL_HANDLER_ARGS)
2595 {
2596 	char buf[16];
2597 	const char *p;
2598 	struct da_softc *softc;
2599 	int i, error, value;
2600 
2601 	softc = (struct da_softc *)arg1;
2602 
2603 	value = softc->delete_method;
2604 	if (value < 0 || value > DA_DELETE_MAX)
2605 		p = "UNKNOWN";
2606 	else
2607 		p = da_delete_method_names[value];
2608 	strncpy(buf, p, sizeof(buf));
2609 	error = sysctl_handle_string(oidp, buf, sizeof(buf), req);
2610 	if (error != 0 || req->newptr == NULL)
2611 		return (error);
2612 	for (i = 0; i <= DA_DELETE_MAX; i++) {
2613 		if (strcmp(buf, da_delete_method_names[i]) == 0)
2614 			break;
2615 	}
2616 	if (i > DA_DELETE_MAX)
2617 		return (EINVAL);
2618 	softc->delete_method_pref = i;
2619 	dadeletemethodchoose(softc, DA_DELETE_NONE);
2620 	return (0);
2621 }
2622 
2623 static int
2624 dazonemodesysctl(SYSCTL_HANDLER_ARGS)
2625 {
2626 	char tmpbuf[40];
2627 	struct da_softc *softc;
2628 	int error;
2629 
2630 	softc = (struct da_softc *)arg1;
2631 
2632 	switch (softc->zone_mode) {
2633 	case DA_ZONE_DRIVE_MANAGED:
2634 		snprintf(tmpbuf, sizeof(tmpbuf), "Drive Managed");
2635 		break;
2636 	case DA_ZONE_HOST_AWARE:
2637 		snprintf(tmpbuf, sizeof(tmpbuf), "Host Aware");
2638 		break;
2639 	case DA_ZONE_HOST_MANAGED:
2640 		snprintf(tmpbuf, sizeof(tmpbuf), "Host Managed");
2641 		break;
2642 	case DA_ZONE_NONE:
2643 	default:
2644 		snprintf(tmpbuf, sizeof(tmpbuf), "Not Zoned");
2645 		break;
2646 	}
2647 
2648 	error = sysctl_handle_string(oidp, tmpbuf, sizeof(tmpbuf), req);
2649 
2650 	return (error);
2651 }
2652 
2653 static int
2654 dazonesupsysctl(SYSCTL_HANDLER_ARGS)
2655 {
2656 	char tmpbuf[180];
2657 	struct da_softc *softc;
2658 	struct sbuf sb;
2659 	int error, first;
2660 	unsigned int i;
2661 
2662 	softc = (struct da_softc *)arg1;
2663 
2664 	error = 0;
2665 	first = 1;
2666 	sbuf_new(&sb, tmpbuf, sizeof(tmpbuf), 0);
2667 
2668 	for (i = 0; i < sizeof(da_zone_desc_table) /
2669 	     sizeof(da_zone_desc_table[0]); i++) {
2670 		if (softc->zone_flags & da_zone_desc_table[i].value) {
2671 			if (first == 0)
2672 				sbuf_printf(&sb, ", ");
2673 			else
2674 				first = 0;
2675 			sbuf_cat(&sb, da_zone_desc_table[i].desc);
2676 		}
2677 	}
2678 
2679 	if (first == 1)
2680 		sbuf_printf(&sb, "None");
2681 
2682 	sbuf_finish(&sb);
2683 
2684 	error = sysctl_handle_string(oidp, sbuf_data(&sb), sbuf_len(&sb), req);
2685 
2686 	return (error);
2687 }
2688 
2689 static cam_status
2690 daregister(struct cam_periph *periph, void *arg)
2691 {
2692 	struct da_softc *softc;
2693 	struct ccb_pathinq cpi;
2694 	struct ccb_getdev *cgd;
2695 	char tmpstr[80];
2696 	caddr_t match;
2697 	int quirks;
2698 
2699 	cgd = (struct ccb_getdev *)arg;
2700 	if (cgd == NULL) {
2701 		printf("daregister: no getdev CCB, can't register device\n");
2702 		return(CAM_REQ_CMP_ERR);
2703 	}
2704 
2705 	softc = (struct da_softc *)malloc(sizeof(*softc), M_DEVBUF,
2706 	    M_NOWAIT|M_ZERO);
2707 
2708 	if (softc == NULL) {
2709 		printf("daregister: Unable to probe new device. "
2710 		       "Unable to allocate softc\n");
2711 		return(CAM_REQ_CMP_ERR);
2712 	}
2713 
2714 	if (cam_iosched_init(&softc->cam_iosched, periph) != 0) {
2715 		printf("daregister: Unable to probe new device. "
2716 		       "Unable to allocate iosched memory\n");
2717 		free(softc, M_DEVBUF);
2718 		return(CAM_REQ_CMP_ERR);
2719 	}
2720 
2721 	LIST_INIT(&softc->pending_ccbs);
2722 	softc->state = DA_STATE_PROBE_WP;
2723 	bioq_init(&softc->delete_run_queue);
2724 	if (SID_IS_REMOVABLE(&cgd->inq_data))
2725 		softc->flags |= DA_FLAG_PACK_REMOVABLE;
2726 	softc->unmap_max_ranges = UNMAP_MAX_RANGES;
2727 	softc->unmap_max_lba = UNMAP_RANGE_MAX;
2728 	softc->unmap_gran = 0;
2729 	softc->unmap_gran_align = 0;
2730 	softc->ws_max_blks = WS16_MAX_BLKS;
2731 	softc->trim_max_ranges = ATA_TRIM_MAX_RANGES;
2732 	softc->rotating = 1;
2733 
2734 	periph->softc = softc;
2735 
2736 	/*
2737 	 * See if this device has any quirks.
2738 	 */
2739 	match = cam_quirkmatch((caddr_t)&cgd->inq_data,
2740 			       (caddr_t)da_quirk_table,
2741 			       nitems(da_quirk_table),
2742 			       sizeof(*da_quirk_table), scsi_inquiry_match);
2743 
2744 	if (match != NULL)
2745 		softc->quirks = ((struct da_quirk_entry *)match)->quirks;
2746 	else
2747 		softc->quirks = DA_Q_NONE;
2748 
2749 	/* Check if the SIM does not want 6 byte commands */
2750 	xpt_path_inq(&cpi, periph->path);
2751 	if (cpi.ccb_h.status == CAM_REQ_CMP && (cpi.hba_misc & PIM_NO_6_BYTE))
2752 		softc->quirks |= DA_Q_NO_6_BYTE;
2753 
2754 	/* Override quirks if tunable is set */
2755 	snprintf(tmpstr, sizeof(tmpstr), "kern.cam.da.%d.quirks",
2756 		 periph->unit_number);
2757 	quirks = softc->quirks;
2758 	TUNABLE_INT_FETCH(tmpstr, &quirks);
2759 	softc->quirks = quirks;
2760 
2761 	if (SID_TYPE(&cgd->inq_data) == T_ZBC_HM)
2762 		softc->zone_mode = DA_ZONE_HOST_MANAGED;
2763 	else if (softc->quirks & DA_Q_SMR_DM)
2764 		softc->zone_mode = DA_ZONE_DRIVE_MANAGED;
2765 	else
2766 		softc->zone_mode = DA_ZONE_NONE;
2767 
2768 	if (softc->zone_mode != DA_ZONE_NONE) {
2769 		if (scsi_vpd_supported_page(periph, SVPD_ATA_INFORMATION)) {
2770 			if (scsi_vpd_supported_page(periph, SVPD_ZONED_BDC))
2771 				softc->zone_interface = DA_ZONE_IF_ATA_SAT;
2772 			else
2773 				softc->zone_interface = DA_ZONE_IF_ATA_PASS;
2774 		} else
2775 			softc->zone_interface = DA_ZONE_IF_SCSI;
2776 	}
2777 
2778 	TASK_INIT(&softc->sysctl_task, 0, dasysctlinit, periph);
2779 
2780 	/*
2781 	 * Take an exclusive section lock qon the periph while dastart is called
2782 	 * to finish the probe.  The lock will be dropped in dadone at the end
2783 	 * of probe. This locks out daopen and daclose from racing with the
2784 	 * probe.
2785 	 *
2786 	 * XXX if cam_periph_hold returns an error, we don't hold a refcount.
2787 	 */
2788 	(void)da_periph_hold(periph, PRIBIO, DA_REF_PROBE_HOLD);
2789 
2790 	/*
2791 	 * Schedule a periodic event to occasionally send an
2792 	 * ordered tag to a device.
2793 	 */
2794 	callout_init_mtx(&softc->sendordered_c, cam_periph_mtx(periph), 0);
2795 	callout_reset(&softc->sendordered_c,
2796 	    (da_default_timeout * hz) / DA_ORDEREDTAG_INTERVAL,
2797 	    dasendorderedtag, periph);
2798 
2799 	cam_periph_unlock(periph);
2800 	/*
2801 	 * RBC devices don't have to support READ(6), only READ(10).
2802 	 */
2803 	if (softc->quirks & DA_Q_NO_6_BYTE || SID_TYPE(&cgd->inq_data) == T_RBC)
2804 		softc->minimum_cmd_size = 10;
2805 	else
2806 		softc->minimum_cmd_size = 6;
2807 
2808 	/*
2809 	 * Load the user's default, if any.
2810 	 */
2811 	snprintf(tmpstr, sizeof(tmpstr), "kern.cam.da.%d.minimum_cmd_size",
2812 		 periph->unit_number);
2813 	TUNABLE_INT_FETCH(tmpstr, &softc->minimum_cmd_size);
2814 
2815 	/*
2816 	 * 6, 10, 12 and 16 are the currently permissible values.
2817 	 */
2818 	if (softc->minimum_cmd_size > 12)
2819 		softc->minimum_cmd_size = 16;
2820 	else if (softc->minimum_cmd_size > 10)
2821 		softc->minimum_cmd_size = 12;
2822 	else if (softc->minimum_cmd_size > 6)
2823 		softc->minimum_cmd_size = 10;
2824 	else
2825 		softc->minimum_cmd_size = 6;
2826 
2827 	/* Predict whether device may support READ CAPACITY(16). */
2828 	if (SID_ANSI_REV(&cgd->inq_data) >= SCSI_REV_SPC3 &&
2829 	    (softc->quirks & DA_Q_NO_RC16) == 0) {
2830 		softc->flags |= DA_FLAG_CAN_RC16;
2831 	}
2832 
2833 	/*
2834 	 * Register this media as a disk.
2835 	 */
2836 	softc->disk = disk_alloc();
2837 	softc->disk->d_devstat = devstat_new_entry(periph->periph_name,
2838 			  periph->unit_number, 0,
2839 			  DEVSTAT_BS_UNAVAILABLE,
2840 			  SID_TYPE(&cgd->inq_data) |
2841 			  XPORT_DEVSTAT_TYPE(cpi.transport),
2842 			  DEVSTAT_PRIORITY_DISK);
2843 	softc->disk->d_open = daopen;
2844 	softc->disk->d_close = daclose;
2845 	softc->disk->d_strategy = dastrategy;
2846 	softc->disk->d_dump = dadump;
2847 	softc->disk->d_getattr = dagetattr;
2848 	softc->disk->d_gone = dadiskgonecb;
2849 	softc->disk->d_name = "da";
2850 	softc->disk->d_drv1 = periph;
2851 	if (cpi.maxio == 0)
2852 		softc->maxio = DFLTPHYS;	/* traditional default */
2853 	else if (cpi.maxio > MAXPHYS)
2854 		softc->maxio = MAXPHYS;		/* for safety */
2855 	else
2856 		softc->maxio = cpi.maxio;
2857 	if (softc->quirks & DA_Q_128KB)
2858 		softc->maxio = min(softc->maxio, 128 * 1024);
2859 	softc->disk->d_maxsize = softc->maxio;
2860 	softc->disk->d_unit = periph->unit_number;
2861 	softc->disk->d_flags = DISKFLAG_DIRECT_COMPLETION | DISKFLAG_CANZONE;
2862 	if ((softc->quirks & DA_Q_NO_SYNC_CACHE) == 0)
2863 		softc->disk->d_flags |= DISKFLAG_CANFLUSHCACHE;
2864 	if ((cpi.hba_misc & PIM_UNMAPPED) != 0) {
2865 		softc->unmappedio = 1;
2866 		softc->disk->d_flags |= DISKFLAG_UNMAPPED_BIO;
2867 	}
2868 	cam_strvis(softc->disk->d_descr, cgd->inq_data.vendor,
2869 	    sizeof(cgd->inq_data.vendor), sizeof(softc->disk->d_descr));
2870 	strlcat(softc->disk->d_descr, " ", sizeof(softc->disk->d_descr));
2871 	cam_strvis(&softc->disk->d_descr[strlen(softc->disk->d_descr)],
2872 	    cgd->inq_data.product, sizeof(cgd->inq_data.product),
2873 	    sizeof(softc->disk->d_descr) - strlen(softc->disk->d_descr));
2874 	softc->disk->d_hba_vendor = cpi.hba_vendor;
2875 	softc->disk->d_hba_device = cpi.hba_device;
2876 	softc->disk->d_hba_subvendor = cpi.hba_subvendor;
2877 	softc->disk->d_hba_subdevice = cpi.hba_subdevice;
2878 
2879 	/*
2880 	 * Acquire a reference to the periph before we register with GEOM.
2881 	 * We'll release this reference once GEOM calls us back (via
2882 	 * dadiskgonecb()) telling us that our provider has been freed.
2883 	 */
2884 	if (da_periph_acquire(periph, DA_REF_GEOM) != 0) {
2885 		xpt_print(periph->path, "%s: lost periph during "
2886 			  "registration!\n", __func__);
2887 		cam_periph_lock(periph);
2888 		return (CAM_REQ_CMP_ERR);
2889 	}
2890 
2891 	disk_create(softc->disk, DISK_VERSION);
2892 	cam_periph_lock(periph);
2893 
2894 	/*
2895 	 * Add async callbacks for events of interest.
2896 	 * I don't bother checking if this fails as,
2897 	 * in most cases, the system will function just
2898 	 * fine without them and the only alternative
2899 	 * would be to not attach the device on failure.
2900 	 */
2901 	xpt_register_async(AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE |
2902 	    AC_ADVINFO_CHANGED | AC_SCSI_AEN | AC_UNIT_ATTENTION |
2903 	    AC_INQ_CHANGED, daasync, periph, periph->path);
2904 
2905 	/*
2906 	 * Emit an attribute changed notification just in case
2907 	 * physical path information arrived before our async
2908 	 * event handler was registered, but after anyone attaching
2909 	 * to our disk device polled it.
2910 	 */
2911 	disk_attr_changed(softc->disk, "GEOM::physpath", M_NOWAIT);
2912 
2913 	/*
2914 	 * Schedule a periodic media polling events.
2915 	 */
2916 	callout_init_mtx(&softc->mediapoll_c, cam_periph_mtx(periph), 0);
2917 	if ((softc->flags & DA_FLAG_PACK_REMOVABLE) &&
2918 	    (cgd->inq_flags & SID_AEN) == 0 &&
2919 	    da_poll_period != 0)
2920 		callout_reset(&softc->mediapoll_c, da_poll_period * hz,
2921 		    damediapoll, periph);
2922 
2923 	xpt_schedule(periph, CAM_PRIORITY_DEV);
2924 
2925 	return(CAM_REQ_CMP);
2926 }
2927 
2928 static int
2929 da_zone_bio_to_scsi(int disk_zone_cmd)
2930 {
2931 	switch (disk_zone_cmd) {
2932 	case DISK_ZONE_OPEN:
2933 		return ZBC_OUT_SA_OPEN;
2934 	case DISK_ZONE_CLOSE:
2935 		return ZBC_OUT_SA_CLOSE;
2936 	case DISK_ZONE_FINISH:
2937 		return ZBC_OUT_SA_FINISH;
2938 	case DISK_ZONE_RWP:
2939 		return ZBC_OUT_SA_RWP;
2940 	}
2941 
2942 	return -1;
2943 }
2944 
2945 static int
2946 da_zone_cmd(struct cam_periph *periph, union ccb *ccb, struct bio *bp,
2947 	    int *queue_ccb)
2948 {
2949 	struct da_softc *softc;
2950 	int error;
2951 
2952 	error = 0;
2953 
2954 	if (bp->bio_cmd != BIO_ZONE) {
2955 		error = EINVAL;
2956 		goto bailout;
2957 	}
2958 
2959 	softc = periph->softc;
2960 
2961 	switch (bp->bio_zone.zone_cmd) {
2962 	case DISK_ZONE_OPEN:
2963 	case DISK_ZONE_CLOSE:
2964 	case DISK_ZONE_FINISH:
2965 	case DISK_ZONE_RWP: {
2966 		int zone_flags;
2967 		int zone_sa;
2968 		uint64_t lba;
2969 
2970 		zone_sa = da_zone_bio_to_scsi(bp->bio_zone.zone_cmd);
2971 		if (zone_sa == -1) {
2972 			xpt_print(periph->path, "Cannot translate zone "
2973 			    "cmd %#x to SCSI\n", bp->bio_zone.zone_cmd);
2974 			error = EINVAL;
2975 			goto bailout;
2976 		}
2977 
2978 		zone_flags = 0;
2979 		lba = bp->bio_zone.zone_params.rwp.id;
2980 
2981 		if (bp->bio_zone.zone_params.rwp.flags &
2982 		    DISK_ZONE_RWP_FLAG_ALL)
2983 			zone_flags |= ZBC_OUT_ALL;
2984 
2985 		if (softc->zone_interface != DA_ZONE_IF_ATA_PASS) {
2986 			scsi_zbc_out(&ccb->csio,
2987 				     /*retries*/ da_retry_count,
2988 				     /*cbfcnp*/ dadone,
2989 				     /*tag_action*/ MSG_SIMPLE_Q_TAG,
2990 				     /*service_action*/ zone_sa,
2991 				     /*zone_id*/ lba,
2992 				     /*zone_flags*/ zone_flags,
2993 				     /*data_ptr*/ NULL,
2994 				     /*dxfer_len*/ 0,
2995 				     /*sense_len*/ SSD_FULL_SIZE,
2996 				     /*timeout*/ da_default_timeout * 1000);
2997 		} else {
2998 			/*
2999 			 * Note that in this case, even though we can
3000 			 * technically use NCQ, we don't bother for several
3001 			 * reasons:
3002 			 * 1. It hasn't been tested on a SAT layer that
3003 			 *    supports it.  This is new as of SAT-4.
3004 			 * 2. Even when there is a SAT layer that supports
3005 			 *    it, that SAT layer will also probably support
3006 			 *    ZBC -> ZAC translation, since they are both
3007 			 *    in the SAT-4 spec.
3008 			 * 3. Translation will likely be preferable to ATA
3009 			 *    passthrough.  LSI / Avago at least single
3010 			 *    steps ATA passthrough commands in the HBA,
3011 			 *    regardless of protocol, so unless that
3012 			 *    changes, there is a performance penalty for
3013 			 *    doing ATA passthrough no matter whether
3014 			 *    you're using NCQ/FPDMA, DMA or PIO.
3015 			 * 4. It requires a 32-byte CDB, which at least at
3016 			 *    this point in CAM requires a CDB pointer, which
3017 			 *    would require us to allocate an additional bit
3018 			 *    of storage separate from the CCB.
3019 			 */
3020 			error = scsi_ata_zac_mgmt_out(&ccb->csio,
3021 			    /*retries*/ da_retry_count,
3022 			    /*cbfcnp*/ dadone,
3023 			    /*tag_action*/ MSG_SIMPLE_Q_TAG,
3024 			    /*use_ncq*/ 0,
3025 			    /*zm_action*/ zone_sa,
3026 			    /*zone_id*/ lba,
3027 			    /*zone_flags*/ zone_flags,
3028 			    /*data_ptr*/ NULL,
3029 			    /*dxfer_len*/ 0,
3030 			    /*cdb_storage*/ NULL,
3031 			    /*cdb_storage_len*/ 0,
3032 			    /*sense_len*/ SSD_FULL_SIZE,
3033 			    /*timeout*/ da_default_timeout * 1000);
3034 			if (error != 0) {
3035 				error = EINVAL;
3036 				xpt_print(periph->path,
3037 				    "scsi_ata_zac_mgmt_out() returned an "
3038 				    "error!");
3039 				goto bailout;
3040 			}
3041 		}
3042 		*queue_ccb = 1;
3043 
3044 		break;
3045 	}
3046 	case DISK_ZONE_REPORT_ZONES: {
3047 		uint8_t *rz_ptr;
3048 		uint32_t num_entries, alloc_size;
3049 		struct disk_zone_report *rep;
3050 
3051 		rep = &bp->bio_zone.zone_params.report;
3052 
3053 		num_entries = rep->entries_allocated;
3054 		if (num_entries == 0) {
3055 			xpt_print(periph->path, "No entries allocated for "
3056 			    "Report Zones request\n");
3057 			error = EINVAL;
3058 			goto bailout;
3059 		}
3060 		alloc_size = sizeof(struct scsi_report_zones_hdr) +
3061 		    (sizeof(struct scsi_report_zones_desc) * num_entries);
3062 		alloc_size = min(alloc_size, softc->disk->d_maxsize);
3063 		rz_ptr = malloc(alloc_size, M_SCSIDA, M_NOWAIT | M_ZERO);
3064 		if (rz_ptr == NULL) {
3065 			xpt_print(periph->path, "Unable to allocate memory "
3066 			   "for Report Zones request\n");
3067 			error = ENOMEM;
3068 			goto bailout;
3069 		}
3070 
3071 		if (softc->zone_interface != DA_ZONE_IF_ATA_PASS) {
3072 			scsi_zbc_in(&ccb->csio,
3073 				    /*retries*/ da_retry_count,
3074 				    /*cbcfnp*/ dadone,
3075 				    /*tag_action*/ MSG_SIMPLE_Q_TAG,
3076 				    /*service_action*/ ZBC_IN_SA_REPORT_ZONES,
3077 				    /*zone_start_lba*/ rep->starting_id,
3078 				    /*zone_options*/ rep->rep_options,
3079 				    /*data_ptr*/ rz_ptr,
3080 				    /*dxfer_len*/ alloc_size,
3081 				    /*sense_len*/ SSD_FULL_SIZE,
3082 				    /*timeout*/ da_default_timeout * 1000);
3083 		} else {
3084 			/*
3085 			 * Note that in this case, even though we can
3086 			 * technically use NCQ, we don't bother for several
3087 			 * reasons:
3088 			 * 1. It hasn't been tested on a SAT layer that
3089 			 *    supports it.  This is new as of SAT-4.
3090 			 * 2. Even when there is a SAT layer that supports
3091 			 *    it, that SAT layer will also probably support
3092 			 *    ZBC -> ZAC translation, since they are both
3093 			 *    in the SAT-4 spec.
3094 			 * 3. Translation will likely be preferable to ATA
3095 			 *    passthrough.  LSI / Avago at least single
3096 			 *    steps ATA passthrough commands in the HBA,
3097 			 *    regardless of protocol, so unless that
3098 			 *    changes, there is a performance penalty for
3099 			 *    doing ATA passthrough no matter whether
3100 			 *    you're using NCQ/FPDMA, DMA or PIO.
3101 			 * 4. It requires a 32-byte CDB, which at least at
3102 			 *    this point in CAM requires a CDB pointer, which
3103 			 *    would require us to allocate an additional bit
3104 			 *    of storage separate from the CCB.
3105 			 */
3106 			error = scsi_ata_zac_mgmt_in(&ccb->csio,
3107 			    /*retries*/ da_retry_count,
3108 			    /*cbcfnp*/ dadone,
3109 			    /*tag_action*/ MSG_SIMPLE_Q_TAG,
3110 			    /*use_ncq*/ 0,
3111 			    /*zm_action*/ ATA_ZM_REPORT_ZONES,
3112 			    /*zone_id*/ rep->starting_id,
3113 			    /*zone_flags*/ rep->rep_options,
3114 			    /*data_ptr*/ rz_ptr,
3115 			    /*dxfer_len*/ alloc_size,
3116 			    /*cdb_storage*/ NULL,
3117 			    /*cdb_storage_len*/ 0,
3118 			    /*sense_len*/ SSD_FULL_SIZE,
3119 			    /*timeout*/ da_default_timeout * 1000);
3120 			if (error != 0) {
3121 				error = EINVAL;
3122 				xpt_print(periph->path,
3123 				    "scsi_ata_zac_mgmt_in() returned an "
3124 				    "error!");
3125 				goto bailout;
3126 			}
3127 		}
3128 
3129 		/*
3130 		 * For BIO_ZONE, this isn't normally needed.  However, it
3131 		 * is used by devstat_end_transaction_bio() to determine
3132 		 * how much data was transferred.
3133 		 */
3134 		/*
3135 		 * XXX KDM we have a problem.  But I'm not sure how to fix
3136 		 * it.  devstat uses bio_bcount - bio_resid to calculate
3137 		 * the amount of data transferred.   The GEOM disk code
3138 		 * uses bio_length - bio_resid to calculate the amount of
3139 		 * data in bio_completed.  We have different structure
3140 		 * sizes above and below the ada(4) driver.  So, if we
3141 		 * use the sizes above, the amount transferred won't be
3142 		 * quite accurate for devstat.  If we use different sizes
3143 		 * for bio_bcount and bio_length (above and below
3144 		 * respectively), then the residual needs to match one or
3145 		 * the other.  Everything is calculated after the bio
3146 		 * leaves the driver, so changing the values around isn't
3147 		 * really an option.  For now, just set the count to the
3148 		 * passed in length.  This means that the calculations
3149 		 * above (e.g. bio_completed) will be correct, but the
3150 		 * amount of data reported to devstat will be slightly
3151 		 * under or overstated.
3152 		 */
3153 		bp->bio_bcount = bp->bio_length;
3154 
3155 		*queue_ccb = 1;
3156 
3157 		break;
3158 	}
3159 	case DISK_ZONE_GET_PARAMS: {
3160 		struct disk_zone_disk_params *params;
3161 
3162 		params = &bp->bio_zone.zone_params.disk_params;
3163 		bzero(params, sizeof(*params));
3164 
3165 		switch (softc->zone_mode) {
3166 		case DA_ZONE_DRIVE_MANAGED:
3167 			params->zone_mode = DISK_ZONE_MODE_DRIVE_MANAGED;
3168 			break;
3169 		case DA_ZONE_HOST_AWARE:
3170 			params->zone_mode = DISK_ZONE_MODE_HOST_AWARE;
3171 			break;
3172 		case DA_ZONE_HOST_MANAGED:
3173 			params->zone_mode = DISK_ZONE_MODE_HOST_MANAGED;
3174 			break;
3175 		default:
3176 		case DA_ZONE_NONE:
3177 			params->zone_mode = DISK_ZONE_MODE_NONE;
3178 			break;
3179 		}
3180 
3181 		if (softc->zone_flags & DA_ZONE_FLAG_URSWRZ)
3182 			params->flags |= DISK_ZONE_DISK_URSWRZ;
3183 
3184 		if (softc->zone_flags & DA_ZONE_FLAG_OPT_SEQ_SET) {
3185 			params->optimal_seq_zones = softc->optimal_seq_zones;
3186 			params->flags |= DISK_ZONE_OPT_SEQ_SET;
3187 		}
3188 
3189 		if (softc->zone_flags & DA_ZONE_FLAG_OPT_NONSEQ_SET) {
3190 			params->optimal_nonseq_zones =
3191 			    softc->optimal_nonseq_zones;
3192 			params->flags |= DISK_ZONE_OPT_NONSEQ_SET;
3193 		}
3194 
3195 		if (softc->zone_flags & DA_ZONE_FLAG_MAX_SEQ_SET) {
3196 			params->max_seq_zones = softc->max_seq_zones;
3197 			params->flags |= DISK_ZONE_MAX_SEQ_SET;
3198 		}
3199 		if (softc->zone_flags & DA_ZONE_FLAG_RZ_SUP)
3200 			params->flags |= DISK_ZONE_RZ_SUP;
3201 
3202 		if (softc->zone_flags & DA_ZONE_FLAG_OPEN_SUP)
3203 			params->flags |= DISK_ZONE_OPEN_SUP;
3204 
3205 		if (softc->zone_flags & DA_ZONE_FLAG_CLOSE_SUP)
3206 			params->flags |= DISK_ZONE_CLOSE_SUP;
3207 
3208 		if (softc->zone_flags & DA_ZONE_FLAG_FINISH_SUP)
3209 			params->flags |= DISK_ZONE_FINISH_SUP;
3210 
3211 		if (softc->zone_flags & DA_ZONE_FLAG_RWP_SUP)
3212 			params->flags |= DISK_ZONE_RWP_SUP;
3213 		break;
3214 	}
3215 	default:
3216 		break;
3217 	}
3218 bailout:
3219 	return (error);
3220 }
3221 
3222 static void
3223 dastart(struct cam_periph *periph, union ccb *start_ccb)
3224 {
3225 	struct da_softc *softc;
3226 
3227 	cam_periph_assert(periph, MA_OWNED);
3228 	softc = (struct da_softc *)periph->softc;
3229 
3230 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dastart\n"));
3231 
3232 skipstate:
3233 	switch (softc->state) {
3234 	case DA_STATE_NORMAL:
3235 	{
3236 		struct bio *bp;
3237 		uint8_t tag_code;
3238 
3239 more:
3240 		bp = cam_iosched_next_bio(softc->cam_iosched);
3241 		if (bp == NULL) {
3242 			if (cam_iosched_has_work_flags(softc->cam_iosched,
3243 			    DA_WORK_TUR)) {
3244 				softc->flags |= DA_FLAG_TUR_PENDING;
3245 				cam_iosched_clr_work_flags(softc->cam_iosched,
3246 				    DA_WORK_TUR);
3247 				scsi_test_unit_ready(&start_ccb->csio,
3248 				     /*retries*/ da_retry_count,
3249 				     dadone_tur,
3250 				     MSG_SIMPLE_Q_TAG,
3251 				     SSD_FULL_SIZE,
3252 				     da_default_timeout * 1000);
3253 				start_ccb->ccb_h.ccb_bp = NULL;
3254 				start_ccb->ccb_h.ccb_state = DA_CCB_TUR;
3255 				xpt_action(start_ccb);
3256 			} else
3257 				xpt_release_ccb(start_ccb);
3258 			break;
3259 		}
3260 
3261 		if (bp->bio_cmd == BIO_DELETE) {
3262 			if (softc->delete_func != NULL) {
3263 				softc->delete_func(periph, start_ccb, bp);
3264 				goto out;
3265 			} else {
3266 				/*
3267 				 * Not sure this is possible, but failsafe by
3268 				 * lying and saying "sure, done."
3269 				 */
3270 				biofinish(bp, NULL, 0);
3271 				goto more;
3272 			}
3273 		}
3274 
3275 		if (cam_iosched_has_work_flags(softc->cam_iosched,
3276 		    DA_WORK_TUR)) {
3277 			cam_iosched_clr_work_flags(softc->cam_iosched,
3278 			    DA_WORK_TUR);
3279 			da_periph_release_locked(periph, DA_REF_TUR);
3280 		}
3281 
3282 		if ((bp->bio_flags & BIO_ORDERED) != 0 ||
3283 		    (softc->flags & DA_FLAG_NEED_OTAG) != 0) {
3284 			softc->flags &= ~DA_FLAG_NEED_OTAG;
3285 			softc->flags |= DA_FLAG_WAS_OTAG;
3286 			tag_code = MSG_ORDERED_Q_TAG;
3287 		} else {
3288 			tag_code = MSG_SIMPLE_Q_TAG;
3289 		}
3290 
3291 		switch (bp->bio_cmd) {
3292 		case BIO_WRITE:
3293 		case BIO_READ:
3294 		{
3295 			void *data_ptr;
3296 			int rw_op;
3297 
3298 			biotrack(bp, __func__);
3299 
3300 			if (bp->bio_cmd == BIO_WRITE) {
3301 				softc->flags |= DA_FLAG_DIRTY;
3302 				rw_op = SCSI_RW_WRITE;
3303 			} else {
3304 				rw_op = SCSI_RW_READ;
3305 			}
3306 
3307 			data_ptr = bp->bio_data;
3308 			if ((bp->bio_flags & (BIO_UNMAPPED|BIO_VLIST)) != 0) {
3309 				rw_op |= SCSI_RW_BIO;
3310 				data_ptr = bp;
3311 			}
3312 
3313 			scsi_read_write(&start_ccb->csio,
3314 					/*retries*/da_retry_count,
3315 					/*cbfcnp*/dadone,
3316 					/*tag_action*/tag_code,
3317 					rw_op,
3318 					/*byte2*/0,
3319 					softc->minimum_cmd_size,
3320 					/*lba*/bp->bio_pblkno,
3321 					/*block_count*/bp->bio_bcount /
3322 					softc->params.secsize,
3323 					data_ptr,
3324 					/*dxfer_len*/ bp->bio_bcount,
3325 					/*sense_len*/SSD_FULL_SIZE,
3326 					da_default_timeout * 1000);
3327 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
3328 			start_ccb->csio.bio = bp;
3329 #endif
3330 			break;
3331 		}
3332 		case BIO_FLUSH:
3333 			/*
3334 			 * If we don't support sync cache, or the disk
3335 			 * isn't dirty, FLUSH is a no-op.  Use the
3336 			 * allocated CCB for the next bio if one is
3337 			 * available.
3338 			 */
3339 			if ((softc->quirks & DA_Q_NO_SYNC_CACHE) != 0 ||
3340 			    (softc->flags & DA_FLAG_DIRTY) == 0) {
3341 				biodone(bp);
3342 				goto skipstate;
3343 			}
3344 
3345 			/*
3346 			 * BIO_FLUSH doesn't currently communicate
3347 			 * range data, so we synchronize the cache
3348 			 * over the whole disk.
3349 			 */
3350 			scsi_synchronize_cache(&start_ccb->csio,
3351 					       /*retries*/1,
3352 					       /*cbfcnp*/dadone,
3353 					       /*tag_action*/tag_code,
3354 					       /*begin_lba*/0,
3355 					       /*lb_count*/0,
3356 					       SSD_FULL_SIZE,
3357 					       da_default_timeout*1000);
3358 			/*
3359 			 * Clear the dirty flag before sending the command.
3360 			 * Either this sync cache will be successful, or it
3361 			 * will fail after a retry.  If it fails, it is
3362 			 * unlikely to be successful if retried later, so
3363 			 * we'll save ourselves time by just marking the
3364 			 * device clean.
3365 			 */
3366 			softc->flags &= ~DA_FLAG_DIRTY;
3367 			break;
3368 		case BIO_ZONE: {
3369 			int error, queue_ccb;
3370 
3371 			queue_ccb = 0;
3372 
3373 			error = da_zone_cmd(periph, start_ccb, bp,&queue_ccb);
3374 			if ((error != 0)
3375 			 || (queue_ccb == 0)) {
3376 				biofinish(bp, NULL, error);
3377 				xpt_release_ccb(start_ccb);
3378 				return;
3379 			}
3380 			break;
3381 		}
3382 		}
3383 		start_ccb->ccb_h.ccb_state = DA_CCB_BUFFER_IO;
3384 		start_ccb->ccb_h.flags |= CAM_UNLOCKED;
3385 		start_ccb->ccb_h.softtimeout = sbttotv(da_default_softtimeout);
3386 
3387 out:
3388 		LIST_INSERT_HEAD(&softc->pending_ccbs,
3389 				 &start_ccb->ccb_h, periph_links.le);
3390 
3391 		/* We expect a unit attention from this device */
3392 		if ((softc->flags & DA_FLAG_RETRY_UA) != 0) {
3393 			start_ccb->ccb_h.ccb_state |= DA_CCB_RETRY_UA;
3394 			softc->flags &= ~DA_FLAG_RETRY_UA;
3395 		}
3396 
3397 		start_ccb->ccb_h.ccb_bp = bp;
3398 		softc->refcount++;
3399 		cam_periph_unlock(periph);
3400 		xpt_action(start_ccb);
3401 		cam_periph_lock(periph);
3402 
3403 		/* May have more work to do, so ensure we stay scheduled */
3404 		daschedule(periph);
3405 		break;
3406 	}
3407 	case DA_STATE_PROBE_WP:
3408 	{
3409 		void  *mode_buf;
3410 		int    mode_buf_len;
3411 
3412 		if (da_disable_wp_detection) {
3413 			if ((softc->flags & DA_FLAG_CAN_RC16) != 0)
3414 				softc->state = DA_STATE_PROBE_RC16;
3415 			else
3416 				softc->state = DA_STATE_PROBE_RC;
3417 			goto skipstate;
3418 		}
3419 		mode_buf_len = 192;
3420 		mode_buf = malloc(mode_buf_len, M_SCSIDA, M_NOWAIT);
3421 		if (mode_buf == NULL) {
3422 			xpt_print(periph->path, "Unable to send mode sense - "
3423 			    "malloc failure\n");
3424 			if ((softc->flags & DA_FLAG_CAN_RC16) != 0)
3425 				softc->state = DA_STATE_PROBE_RC16;
3426 			else
3427 				softc->state = DA_STATE_PROBE_RC;
3428 			goto skipstate;
3429 		}
3430 		scsi_mode_sense_len(&start_ccb->csio,
3431 				    /*retries*/ da_retry_count,
3432 				    /*cbfcnp*/ dadone_probewp,
3433 				    /*tag_action*/ MSG_SIMPLE_Q_TAG,
3434 				    /*dbd*/ FALSE,
3435 				    /*pc*/ SMS_PAGE_CTRL_CURRENT,
3436 				    /*page*/ SMS_ALL_PAGES_PAGE,
3437 				    /*param_buf*/ mode_buf,
3438 				    /*param_len*/ mode_buf_len,
3439 				    /*minimum_cmd_size*/ softc->minimum_cmd_size,
3440 				    /*sense_len*/ SSD_FULL_SIZE,
3441 				    /*timeout*/ da_default_timeout * 1000);
3442 		start_ccb->ccb_h.ccb_bp = NULL;
3443 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_WP;
3444 		xpt_action(start_ccb);
3445 		break;
3446 	}
3447 	case DA_STATE_PROBE_RC:
3448 	{
3449 		struct scsi_read_capacity_data *rcap;
3450 
3451 		rcap = (struct scsi_read_capacity_data *)
3452 		    malloc(sizeof(*rcap), M_SCSIDA, M_NOWAIT|M_ZERO);
3453 		if (rcap == NULL) {
3454 			printf("dastart: Couldn't malloc read_capacity data\n");
3455 			/* da_free_periph??? */
3456 			break;
3457 		}
3458 		scsi_read_capacity(&start_ccb->csio,
3459 				   /*retries*/da_retry_count,
3460 				   dadone_proberc,
3461 				   MSG_SIMPLE_Q_TAG,
3462 				   rcap,
3463 				   SSD_FULL_SIZE,
3464 				   /*timeout*/5000);
3465 		start_ccb->ccb_h.ccb_bp = NULL;
3466 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_RC;
3467 		xpt_action(start_ccb);
3468 		break;
3469 	}
3470 	case DA_STATE_PROBE_RC16:
3471 	{
3472 		struct scsi_read_capacity_data_long *rcaplong;
3473 
3474 		rcaplong = (struct scsi_read_capacity_data_long *)
3475 			malloc(sizeof(*rcaplong), M_SCSIDA, M_NOWAIT|M_ZERO);
3476 		if (rcaplong == NULL) {
3477 			printf("dastart: Couldn't malloc read_capacity data\n");
3478 			/* da_free_periph??? */
3479 			break;
3480 		}
3481 		scsi_read_capacity_16(&start_ccb->csio,
3482 				      /*retries*/ da_retry_count,
3483 				      /*cbfcnp*/ dadone_proberc,
3484 				      /*tag_action*/ MSG_SIMPLE_Q_TAG,
3485 				      /*lba*/ 0,
3486 				      /*reladr*/ 0,
3487 				      /*pmi*/ 0,
3488 				      /*rcap_buf*/ (uint8_t *)rcaplong,
3489 				      /*rcap_buf_len*/ sizeof(*rcaplong),
3490 				      /*sense_len*/ SSD_FULL_SIZE,
3491 				      /*timeout*/ da_default_timeout * 1000);
3492 		start_ccb->ccb_h.ccb_bp = NULL;
3493 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_RC16;
3494 		xpt_action(start_ccb);
3495 		break;
3496 	}
3497 	case DA_STATE_PROBE_LBP:
3498 	{
3499 		struct scsi_vpd_logical_block_prov *lbp;
3500 
3501 		if (!scsi_vpd_supported_page(periph, SVPD_LBP)) {
3502 			/*
3503 			 * If we get here we don't support any SBC-3 delete
3504 			 * methods with UNMAP as the Logical Block Provisioning
3505 			 * VPD page support is required for devices which
3506 			 * support it according to T10/1799-D Revision 31
3507 			 * however older revisions of the spec don't mandate
3508 			 * this so we currently don't remove these methods
3509 			 * from the available set.
3510 			 */
3511 			softc->state = DA_STATE_PROBE_BLK_LIMITS;
3512 			goto skipstate;
3513 		}
3514 
3515 		lbp = (struct scsi_vpd_logical_block_prov *)
3516 			malloc(sizeof(*lbp), M_SCSIDA, M_NOWAIT|M_ZERO);
3517 
3518 		if (lbp == NULL) {
3519 			printf("dastart: Couldn't malloc lbp data\n");
3520 			/* da_free_periph??? */
3521 			break;
3522 		}
3523 
3524 		scsi_inquiry(&start_ccb->csio,
3525 			     /*retries*/da_retry_count,
3526 			     /*cbfcnp*/dadone_probelbp,
3527 			     /*tag_action*/MSG_SIMPLE_Q_TAG,
3528 			     /*inq_buf*/(u_int8_t *)lbp,
3529 			     /*inq_len*/sizeof(*lbp),
3530 			     /*evpd*/TRUE,
3531 			     /*page_code*/SVPD_LBP,
3532 			     /*sense_len*/SSD_MIN_SIZE,
3533 			     /*timeout*/da_default_timeout * 1000);
3534 		start_ccb->ccb_h.ccb_bp = NULL;
3535 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_LBP;
3536 		xpt_action(start_ccb);
3537 		break;
3538 	}
3539 	case DA_STATE_PROBE_BLK_LIMITS:
3540 	{
3541 		struct scsi_vpd_block_limits *block_limits;
3542 
3543 		if (!scsi_vpd_supported_page(periph, SVPD_BLOCK_LIMITS)) {
3544 			/* Not supported skip to next probe */
3545 			softc->state = DA_STATE_PROBE_BDC;
3546 			goto skipstate;
3547 		}
3548 
3549 		block_limits = (struct scsi_vpd_block_limits *)
3550 			malloc(sizeof(*block_limits), M_SCSIDA, M_NOWAIT|M_ZERO);
3551 
3552 		if (block_limits == NULL) {
3553 			printf("dastart: Couldn't malloc block_limits data\n");
3554 			/* da_free_periph??? */
3555 			break;
3556 		}
3557 
3558 		scsi_inquiry(&start_ccb->csio,
3559 			     /*retries*/da_retry_count,
3560 			     /*cbfcnp*/dadone_probeblklimits,
3561 			     /*tag_action*/MSG_SIMPLE_Q_TAG,
3562 			     /*inq_buf*/(u_int8_t *)block_limits,
3563 			     /*inq_len*/sizeof(*block_limits),
3564 			     /*evpd*/TRUE,
3565 			     /*page_code*/SVPD_BLOCK_LIMITS,
3566 			     /*sense_len*/SSD_MIN_SIZE,
3567 			     /*timeout*/da_default_timeout * 1000);
3568 		start_ccb->ccb_h.ccb_bp = NULL;
3569 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_BLK_LIMITS;
3570 		xpt_action(start_ccb);
3571 		break;
3572 	}
3573 	case DA_STATE_PROBE_BDC:
3574 	{
3575 		struct scsi_vpd_block_characteristics *bdc;
3576 
3577 		if (!scsi_vpd_supported_page(periph, SVPD_BDC)) {
3578 			softc->state = DA_STATE_PROBE_ATA;
3579 			goto skipstate;
3580 		}
3581 
3582 		bdc = (struct scsi_vpd_block_characteristics *)
3583 			malloc(sizeof(*bdc), M_SCSIDA, M_NOWAIT|M_ZERO);
3584 
3585 		if (bdc == NULL) {
3586 			printf("dastart: Couldn't malloc bdc data\n");
3587 			/* da_free_periph??? */
3588 			break;
3589 		}
3590 
3591 		scsi_inquiry(&start_ccb->csio,
3592 			     /*retries*/da_retry_count,
3593 			     /*cbfcnp*/dadone_probebdc,
3594 			     /*tag_action*/MSG_SIMPLE_Q_TAG,
3595 			     /*inq_buf*/(u_int8_t *)bdc,
3596 			     /*inq_len*/sizeof(*bdc),
3597 			     /*evpd*/TRUE,
3598 			     /*page_code*/SVPD_BDC,
3599 			     /*sense_len*/SSD_MIN_SIZE,
3600 			     /*timeout*/da_default_timeout * 1000);
3601 		start_ccb->ccb_h.ccb_bp = NULL;
3602 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_BDC;
3603 		xpt_action(start_ccb);
3604 		break;
3605 	}
3606 	case DA_STATE_PROBE_ATA:
3607 	{
3608 		struct ata_params *ata_params;
3609 
3610 		if (!scsi_vpd_supported_page(periph, SVPD_ATA_INFORMATION)) {
3611 			if ((softc->zone_mode == DA_ZONE_HOST_AWARE)
3612 			 || (softc->zone_mode == DA_ZONE_HOST_MANAGED)) {
3613 				/*
3614 				 * Note that if the ATA VPD page isn't
3615 				 * supported, we aren't talking to an ATA
3616 				 * device anyway.  Support for that VPD
3617 				 * page is mandatory for SCSI to ATA (SAT)
3618 				 * translation layers.
3619 				 */
3620 				softc->state = DA_STATE_PROBE_ZONE;
3621 				goto skipstate;
3622 			}
3623 			daprobedone(periph, start_ccb);
3624 			break;
3625 		}
3626 
3627 		ata_params = &periph->path->device->ident_data;
3628 
3629 		scsi_ata_identify(&start_ccb->csio,
3630 				  /*retries*/da_retry_count,
3631 				  /*cbfcnp*/dadone_probeata,
3632                                   /*tag_action*/MSG_SIMPLE_Q_TAG,
3633 				  /*data_ptr*/(u_int8_t *)ata_params,
3634 				  /*dxfer_len*/sizeof(*ata_params),
3635 				  /*sense_len*/SSD_FULL_SIZE,
3636 				  /*timeout*/da_default_timeout * 1000);
3637 		start_ccb->ccb_h.ccb_bp = NULL;
3638 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA;
3639 		xpt_action(start_ccb);
3640 		break;
3641 	}
3642 	case DA_STATE_PROBE_ATA_LOGDIR:
3643 	{
3644 		struct ata_gp_log_dir *log_dir;
3645 		int retval;
3646 
3647 		retval = 0;
3648 
3649 		if ((softc->flags & DA_FLAG_CAN_ATA_LOG) == 0) {
3650 			/*
3651 			 * If we don't have log support, not much point in
3652 			 * trying to probe zone support.
3653 			 */
3654 			daprobedone(periph, start_ccb);
3655 			break;
3656 		}
3657 
3658 		/*
3659 		 * If we have an ATA device (the SCSI ATA Information VPD
3660 		 * page should be present and the ATA identify should have
3661 		 * succeeded) and it supports logs, ask for the log directory.
3662 		 */
3663 
3664 		log_dir = malloc(sizeof(*log_dir), M_SCSIDA, M_NOWAIT|M_ZERO);
3665 		if (log_dir == NULL) {
3666 			xpt_print(periph->path, "Couldn't malloc log_dir "
3667 			    "data\n");
3668 			daprobedone(periph, start_ccb);
3669 			break;
3670 		}
3671 
3672 		retval = scsi_ata_read_log(&start_ccb->csio,
3673 		    /*retries*/ da_retry_count,
3674 		    /*cbfcnp*/ dadone_probeatalogdir,
3675 		    /*tag_action*/ MSG_SIMPLE_Q_TAG,
3676 		    /*log_address*/ ATA_LOG_DIRECTORY,
3677 		    /*page_number*/ 0,
3678 		    /*block_count*/ 1,
3679 		    /*protocol*/ softc->flags & DA_FLAG_CAN_ATA_DMA ?
3680 				 AP_PROTO_DMA : AP_PROTO_PIO_IN,
3681 		    /*data_ptr*/ (uint8_t *)log_dir,
3682 		    /*dxfer_len*/ sizeof(*log_dir),
3683 		    /*sense_len*/ SSD_FULL_SIZE,
3684 		    /*timeout*/ da_default_timeout * 1000);
3685 
3686 		if (retval != 0) {
3687 			xpt_print(periph->path, "scsi_ata_read_log() failed!");
3688 			free(log_dir, M_SCSIDA);
3689 			daprobedone(periph, start_ccb);
3690 			break;
3691 		}
3692 		start_ccb->ccb_h.ccb_bp = NULL;
3693 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA_LOGDIR;
3694 		xpt_action(start_ccb);
3695 		break;
3696 	}
3697 	case DA_STATE_PROBE_ATA_IDDIR:
3698 	{
3699 		struct ata_identify_log_pages *id_dir;
3700 		int retval;
3701 
3702 		retval = 0;
3703 
3704 		/*
3705 		 * Check here to see whether the Identify Device log is
3706 		 * supported in the directory of logs.  If so, continue
3707 		 * with requesting the log of identify device pages.
3708 		 */
3709 		if ((softc->flags & DA_FLAG_CAN_ATA_IDLOG) == 0) {
3710 			daprobedone(periph, start_ccb);
3711 			break;
3712 		}
3713 
3714 		id_dir = malloc(sizeof(*id_dir), M_SCSIDA, M_NOWAIT | M_ZERO);
3715 		if (id_dir == NULL) {
3716 			xpt_print(periph->path, "Couldn't malloc id_dir "
3717 			    "data\n");
3718 			daprobedone(periph, start_ccb);
3719 			break;
3720 		}
3721 
3722 		retval = scsi_ata_read_log(&start_ccb->csio,
3723 		    /*retries*/ da_retry_count,
3724 		    /*cbfcnp*/ dadone_probeataiddir,
3725 		    /*tag_action*/ MSG_SIMPLE_Q_TAG,
3726 		    /*log_address*/ ATA_IDENTIFY_DATA_LOG,
3727 		    /*page_number*/ ATA_IDL_PAGE_LIST,
3728 		    /*block_count*/ 1,
3729 		    /*protocol*/ softc->flags & DA_FLAG_CAN_ATA_DMA ?
3730 				 AP_PROTO_DMA : AP_PROTO_PIO_IN,
3731 		    /*data_ptr*/ (uint8_t *)id_dir,
3732 		    /*dxfer_len*/ sizeof(*id_dir),
3733 		    /*sense_len*/ SSD_FULL_SIZE,
3734 		    /*timeout*/ da_default_timeout * 1000);
3735 
3736 		if (retval != 0) {
3737 			xpt_print(periph->path, "scsi_ata_read_log() failed!");
3738 			free(id_dir, M_SCSIDA);
3739 			daprobedone(periph, start_ccb);
3740 			break;
3741 		}
3742 		start_ccb->ccb_h.ccb_bp = NULL;
3743 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA_IDDIR;
3744 		xpt_action(start_ccb);
3745 		break;
3746 	}
3747 	case DA_STATE_PROBE_ATA_SUP:
3748 	{
3749 		struct ata_identify_log_sup_cap *sup_cap;
3750 		int retval;
3751 
3752 		retval = 0;
3753 
3754 		/*
3755 		 * Check here to see whether the Supported Capabilities log
3756 		 * is in the list of Identify Device logs.
3757 		 */
3758 		if ((softc->flags & DA_FLAG_CAN_ATA_SUPCAP) == 0) {
3759 			daprobedone(periph, start_ccb);
3760 			break;
3761 		}
3762 
3763 		sup_cap = malloc(sizeof(*sup_cap), M_SCSIDA, M_NOWAIT|M_ZERO);
3764 		if (sup_cap == NULL) {
3765 			xpt_print(periph->path, "Couldn't malloc sup_cap "
3766 			    "data\n");
3767 			daprobedone(periph, start_ccb);
3768 			break;
3769 		}
3770 
3771 		retval = scsi_ata_read_log(&start_ccb->csio,
3772 		    /*retries*/ da_retry_count,
3773 		    /*cbfcnp*/ dadone_probeatasup,
3774 		    /*tag_action*/ MSG_SIMPLE_Q_TAG,
3775 		    /*log_address*/ ATA_IDENTIFY_DATA_LOG,
3776 		    /*page_number*/ ATA_IDL_SUP_CAP,
3777 		    /*block_count*/ 1,
3778 		    /*protocol*/ softc->flags & DA_FLAG_CAN_ATA_DMA ?
3779 				 AP_PROTO_DMA : AP_PROTO_PIO_IN,
3780 		    /*data_ptr*/ (uint8_t *)sup_cap,
3781 		    /*dxfer_len*/ sizeof(*sup_cap),
3782 		    /*sense_len*/ SSD_FULL_SIZE,
3783 		    /*timeout*/ da_default_timeout * 1000);
3784 
3785 		if (retval != 0) {
3786 			xpt_print(periph->path, "scsi_ata_read_log() failed!");
3787 			free(sup_cap, M_SCSIDA);
3788 			daprobedone(periph, start_ccb);
3789 			break;
3790 
3791 		}
3792 
3793 		start_ccb->ccb_h.ccb_bp = NULL;
3794 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA_SUP;
3795 		xpt_action(start_ccb);
3796 		break;
3797 	}
3798 	case DA_STATE_PROBE_ATA_ZONE:
3799 	{
3800 		struct ata_zoned_info_log *ata_zone;
3801 		int retval;
3802 
3803 		retval = 0;
3804 
3805 		/*
3806 		 * Check here to see whether the zoned device information
3807 		 * page is supported.  If so, continue on to request it.
3808 		 * If not, skip to DA_STATE_PROBE_LOG or done.
3809 		 */
3810 		if ((softc->flags & DA_FLAG_CAN_ATA_ZONE) == 0) {
3811 			daprobedone(periph, start_ccb);
3812 			break;
3813 		}
3814 		ata_zone = malloc(sizeof(*ata_zone), M_SCSIDA,
3815 				  M_NOWAIT|M_ZERO);
3816 		if (ata_zone == NULL) {
3817 			xpt_print(periph->path, "Couldn't malloc ata_zone "
3818 			    "data\n");
3819 			daprobedone(periph, start_ccb);
3820 			break;
3821 		}
3822 
3823 		retval = scsi_ata_read_log(&start_ccb->csio,
3824 		    /*retries*/ da_retry_count,
3825 		    /*cbfcnp*/ dadone_probeatazone,
3826 		    /*tag_action*/ MSG_SIMPLE_Q_TAG,
3827 		    /*log_address*/ ATA_IDENTIFY_DATA_LOG,
3828 		    /*page_number*/ ATA_IDL_ZDI,
3829 		    /*block_count*/ 1,
3830 		    /*protocol*/ softc->flags & DA_FLAG_CAN_ATA_DMA ?
3831 				 AP_PROTO_DMA : AP_PROTO_PIO_IN,
3832 		    /*data_ptr*/ (uint8_t *)ata_zone,
3833 		    /*dxfer_len*/ sizeof(*ata_zone),
3834 		    /*sense_len*/ SSD_FULL_SIZE,
3835 		    /*timeout*/ da_default_timeout * 1000);
3836 
3837 		if (retval != 0) {
3838 			xpt_print(periph->path, "scsi_ata_read_log() failed!");
3839 			free(ata_zone, M_SCSIDA);
3840 			daprobedone(periph, start_ccb);
3841 			break;
3842 		}
3843 		start_ccb->ccb_h.ccb_bp = NULL;
3844 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ATA_ZONE;
3845 		xpt_action(start_ccb);
3846 
3847 		break;
3848 	}
3849 	case DA_STATE_PROBE_ZONE:
3850 	{
3851 		struct scsi_vpd_zoned_bdc *bdc;
3852 
3853 		/*
3854 		 * Note that this page will be supported for SCSI protocol
3855 		 * devices that support ZBC (SMR devices), as well as ATA
3856 		 * protocol devices that are behind a SAT (SCSI to ATA
3857 		 * Translation) layer that supports converting ZBC commands
3858 		 * to their ZAC equivalents.
3859 		 */
3860 		if (!scsi_vpd_supported_page(periph, SVPD_ZONED_BDC)) {
3861 			daprobedone(periph, start_ccb);
3862 			break;
3863 		}
3864 		bdc = (struct scsi_vpd_zoned_bdc *)
3865 			malloc(sizeof(*bdc), M_SCSIDA, M_NOWAIT|M_ZERO);
3866 
3867 		if (bdc == NULL) {
3868 			xpt_release_ccb(start_ccb);
3869 			xpt_print(periph->path, "Couldn't malloc zone VPD "
3870 			    "data\n");
3871 			break;
3872 		}
3873 		scsi_inquiry(&start_ccb->csio,
3874 			     /*retries*/da_retry_count,
3875 			     /*cbfcnp*/dadone_probezone,
3876 			     /*tag_action*/MSG_SIMPLE_Q_TAG,
3877 			     /*inq_buf*/(u_int8_t *)bdc,
3878 			     /*inq_len*/sizeof(*bdc),
3879 			     /*evpd*/TRUE,
3880 			     /*page_code*/SVPD_ZONED_BDC,
3881 			     /*sense_len*/SSD_FULL_SIZE,
3882 			     /*timeout*/da_default_timeout * 1000);
3883 		start_ccb->ccb_h.ccb_bp = NULL;
3884 		start_ccb->ccb_h.ccb_state = DA_CCB_PROBE_ZONE;
3885 		xpt_action(start_ccb);
3886 		break;
3887 	}
3888 	}
3889 }
3890 
3891 /*
3892  * In each of the methods below, while its the caller's
3893  * responsibility to ensure the request will fit into a
3894  * single device request, we might have changed the delete
3895  * method due to the device incorrectly advertising either
3896  * its supported methods or limits.
3897  *
3898  * To prevent this causing further issues we validate the
3899  * against the methods limits, and warn which would
3900  * otherwise be unnecessary.
3901  */
3902 static void
3903 da_delete_unmap(struct cam_periph *periph, union ccb *ccb, struct bio *bp)
3904 {
3905 	struct da_softc *softc = (struct da_softc *)periph->softc;;
3906 	struct bio *bp1;
3907 	uint8_t *buf = softc->unmap_buf;
3908 	struct scsi_unmap_desc *d = (void *)&buf[UNMAP_HEAD_SIZE];
3909 	uint64_t lba, lastlba = (uint64_t)-1;
3910 	uint64_t totalcount = 0;
3911 	uint64_t count;
3912 	uint32_t c, lastcount = 0, ranges = 0;
3913 
3914 	/*
3915 	 * Currently this doesn't take the UNMAP
3916 	 * Granularity and Granularity Alignment
3917 	 * fields into account.
3918 	 *
3919 	 * This could result in both unoptimal unmap
3920 	 * requests as as well as UNMAP calls unmapping
3921 	 * fewer LBA's than requested.
3922 	 */
3923 
3924 	bzero(softc->unmap_buf, sizeof(softc->unmap_buf));
3925 	bp1 = bp;
3926 	do {
3927 		/*
3928 		 * Note: ada and da are different in how they store the
3929 		 * pending bp's in a trim. ada stores all of them in the
3930 		 * trim_req.bps. da stores all but the first one in the
3931 		 * delete_run_queue. ada then completes all the bps in
3932 		 * its adadone() loop. da completes all the bps in the
3933 		 * delete_run_queue in dadone, and relies on the biodone
3934 		 * after to complete. This should be reconciled since there's
3935 		 * no real reason to do it differently. XXX
3936 		 */
3937 		if (bp1 != bp)
3938 			bioq_insert_tail(&softc->delete_run_queue, bp1);
3939 		lba = bp1->bio_pblkno;
3940 		count = bp1->bio_bcount / softc->params.secsize;
3941 
3942 		/* Try to extend the previous range. */
3943 		if (lba == lastlba) {
3944 			c = omin(count, UNMAP_RANGE_MAX - lastcount);
3945 			lastlba += c;
3946 			lastcount += c;
3947 			scsi_ulto4b(lastcount, d[ranges - 1].length);
3948 			count -= c;
3949 			lba += c;
3950 			totalcount += c;
3951 		} else if ((softc->quirks & DA_Q_STRICT_UNMAP) &&
3952 		    softc->unmap_gran != 0) {
3953 			/* Align length of the previous range. */
3954 			if ((c = lastcount % softc->unmap_gran) != 0) {
3955 				if (lastcount <= c) {
3956 					totalcount -= lastcount;
3957 					lastlba = (uint64_t)-1;
3958 					lastcount = 0;
3959 					ranges--;
3960 				} else {
3961 					totalcount -= c;
3962 					lastlba -= c;
3963 					lastcount -= c;
3964 					scsi_ulto4b(lastcount,
3965 					    d[ranges - 1].length);
3966 				}
3967 			}
3968 			/* Align beginning of the new range. */
3969 			c = (lba - softc->unmap_gran_align) % softc->unmap_gran;
3970 			if (c != 0) {
3971 				c = softc->unmap_gran - c;
3972 				if (count <= c) {
3973 					count = 0;
3974 				} else {
3975 					lba += c;
3976 					count -= c;
3977 				}
3978 			}
3979 		}
3980 
3981 		while (count > 0) {
3982 			c = omin(count, UNMAP_RANGE_MAX);
3983 			if (totalcount + c > softc->unmap_max_lba ||
3984 			    ranges >= softc->unmap_max_ranges) {
3985 				xpt_print(periph->path,
3986 				    "%s issuing short delete %ld > %ld"
3987 				    "|| %d >= %d",
3988 				    da_delete_method_desc[softc->delete_method],
3989 				    totalcount + c, softc->unmap_max_lba,
3990 				    ranges, softc->unmap_max_ranges);
3991 				break;
3992 			}
3993 			scsi_u64to8b(lba, d[ranges].lba);
3994 			scsi_ulto4b(c, d[ranges].length);
3995 			lba += c;
3996 			totalcount += c;
3997 			ranges++;
3998 			count -= c;
3999 			lastlba = lba;
4000 			lastcount = c;
4001 		}
4002 		bp1 = cam_iosched_next_trim(softc->cam_iosched);
4003 		if (bp1 == NULL)
4004 			break;
4005 		if (ranges >= softc->unmap_max_ranges ||
4006 		    totalcount + bp1->bio_bcount /
4007 		    softc->params.secsize > softc->unmap_max_lba) {
4008 			cam_iosched_put_back_trim(softc->cam_iosched, bp1);
4009 			break;
4010 		}
4011 	} while (1);
4012 
4013 	/* Align length of the last range. */
4014 	if ((softc->quirks & DA_Q_STRICT_UNMAP) && softc->unmap_gran != 0 &&
4015 	    (c = lastcount % softc->unmap_gran) != 0) {
4016 		if (lastcount <= c)
4017 			ranges--;
4018 		else
4019 			scsi_ulto4b(lastcount - c, d[ranges - 1].length);
4020 	}
4021 
4022 	scsi_ulto2b(ranges * 16 + 6, &buf[0]);
4023 	scsi_ulto2b(ranges * 16, &buf[2]);
4024 
4025 	scsi_unmap(&ccb->csio,
4026 		   /*retries*/da_retry_count,
4027 		   /*cbfcnp*/dadone,
4028 		   /*tag_action*/MSG_SIMPLE_Q_TAG,
4029 		   /*byte2*/0,
4030 		   /*data_ptr*/ buf,
4031 		   /*dxfer_len*/ ranges * 16 + 8,
4032 		   /*sense_len*/SSD_FULL_SIZE,
4033 		   da_default_timeout * 1000);
4034 	ccb->ccb_h.ccb_state = DA_CCB_DELETE;
4035 	ccb->ccb_h.flags |= CAM_UNLOCKED;
4036 	softc->trim_count++;
4037 	softc->trim_ranges += ranges;
4038 	softc->trim_lbas += totalcount;
4039 	cam_iosched_submit_trim(softc->cam_iosched);
4040 }
4041 
4042 static void
4043 da_delete_trim(struct cam_periph *periph, union ccb *ccb, struct bio *bp)
4044 {
4045 	struct da_softc *softc = (struct da_softc *)periph->softc;
4046 	struct bio *bp1;
4047 	uint8_t *buf = softc->unmap_buf;
4048 	uint64_t lastlba = (uint64_t)-1;
4049 	uint64_t count;
4050 	uint64_t lba;
4051 	uint32_t lastcount = 0, c, requestcount;
4052 	int ranges = 0, off, block_count;
4053 
4054 	bzero(softc->unmap_buf, sizeof(softc->unmap_buf));
4055 	bp1 = bp;
4056 	do {
4057 		if (bp1 != bp)//XXX imp XXX
4058 			bioq_insert_tail(&softc->delete_run_queue, bp1);
4059 		lba = bp1->bio_pblkno;
4060 		count = bp1->bio_bcount / softc->params.secsize;
4061 		requestcount = count;
4062 
4063 		/* Try to extend the previous range. */
4064 		if (lba == lastlba) {
4065 			c = omin(count, ATA_DSM_RANGE_MAX - lastcount);
4066 			lastcount += c;
4067 			off = (ranges - 1) * 8;
4068 			buf[off + 6] = lastcount & 0xff;
4069 			buf[off + 7] = (lastcount >> 8) & 0xff;
4070 			count -= c;
4071 			lba += c;
4072 		}
4073 
4074 		while (count > 0) {
4075 			c = omin(count, ATA_DSM_RANGE_MAX);
4076 			off = ranges * 8;
4077 
4078 			buf[off + 0] = lba & 0xff;
4079 			buf[off + 1] = (lba >> 8) & 0xff;
4080 			buf[off + 2] = (lba >> 16) & 0xff;
4081 			buf[off + 3] = (lba >> 24) & 0xff;
4082 			buf[off + 4] = (lba >> 32) & 0xff;
4083 			buf[off + 5] = (lba >> 40) & 0xff;
4084 			buf[off + 6] = c & 0xff;
4085 			buf[off + 7] = (c >> 8) & 0xff;
4086 			lba += c;
4087 			ranges++;
4088 			count -= c;
4089 			lastcount = c;
4090 			if (count != 0 && ranges == softc->trim_max_ranges) {
4091 				xpt_print(periph->path,
4092 				    "%s issuing short delete %ld > %ld\n",
4093 				    da_delete_method_desc[softc->delete_method],
4094 				    requestcount,
4095 				    (softc->trim_max_ranges - ranges) *
4096 				    ATA_DSM_RANGE_MAX);
4097 				break;
4098 			}
4099 		}
4100 		lastlba = lba;
4101 		bp1 = cam_iosched_next_trim(softc->cam_iosched);
4102 		if (bp1 == NULL)
4103 			break;
4104 		if (bp1->bio_bcount / softc->params.secsize >
4105 		    (softc->trim_max_ranges - ranges) * ATA_DSM_RANGE_MAX) {
4106 			cam_iosched_put_back_trim(softc->cam_iosched, bp1);
4107 			break;
4108 		}
4109 	} while (1);
4110 
4111 	block_count = howmany(ranges, ATA_DSM_BLK_RANGES);
4112 	scsi_ata_trim(&ccb->csio,
4113 		      /*retries*/da_retry_count,
4114 		      /*cbfcnp*/dadone,
4115 		      /*tag_action*/MSG_SIMPLE_Q_TAG,
4116 		      block_count,
4117 		      /*data_ptr*/buf,
4118 		      /*dxfer_len*/block_count * ATA_DSM_BLK_SIZE,
4119 		      /*sense_len*/SSD_FULL_SIZE,
4120 		      da_default_timeout * 1000);
4121 	ccb->ccb_h.ccb_state = DA_CCB_DELETE;
4122 	ccb->ccb_h.flags |= CAM_UNLOCKED;
4123 	cam_iosched_submit_trim(softc->cam_iosched);
4124 }
4125 
4126 /*
4127  * We calculate ws_max_blks here based off d_delmaxsize instead
4128  * of using softc->ws_max_blks as it is absolute max for the
4129  * device not the protocol max which may well be lower.
4130  */
4131 static void
4132 da_delete_ws(struct cam_periph *periph, union ccb *ccb, struct bio *bp)
4133 {
4134 	struct da_softc *softc;
4135 	struct bio *bp1;
4136 	uint64_t ws_max_blks;
4137 	uint64_t lba;
4138 	uint64_t count; /* forward compat with WS32 */
4139 
4140 	softc = (struct da_softc *)periph->softc;
4141 	ws_max_blks = softc->disk->d_delmaxsize / softc->params.secsize;
4142 	lba = bp->bio_pblkno;
4143 	count = 0;
4144 	bp1 = bp;
4145 	do {
4146 		if (bp1 != bp)//XXX imp XXX
4147 			bioq_insert_tail(&softc->delete_run_queue, bp1);
4148 		count += bp1->bio_bcount / softc->params.secsize;
4149 		if (count > ws_max_blks) {
4150 			xpt_print(periph->path,
4151 			    "%s issuing short delete %ld > %ld\n",
4152 			    da_delete_method_desc[softc->delete_method],
4153 			    count, ws_max_blks);
4154 			count = omin(count, ws_max_blks);
4155 			break;
4156 		}
4157 		bp1 = cam_iosched_next_trim(softc->cam_iosched);
4158 		if (bp1 == NULL)
4159 			break;
4160 		if (lba + count != bp1->bio_pblkno ||
4161 		    count + bp1->bio_bcount /
4162 		    softc->params.secsize > ws_max_blks) {
4163 			cam_iosched_put_back_trim(softc->cam_iosched, bp1);
4164 			break;
4165 		}
4166 	} while (1);
4167 
4168 	scsi_write_same(&ccb->csio,
4169 			/*retries*/da_retry_count,
4170 			/*cbfcnp*/dadone,
4171 			/*tag_action*/MSG_SIMPLE_Q_TAG,
4172 			/*byte2*/softc->delete_method ==
4173 			    DA_DELETE_ZERO ? 0 : SWS_UNMAP,
4174 			softc->delete_method == DA_DELETE_WS16 ? 16 : 10,
4175 			/*lba*/lba,
4176 			/*block_count*/count,
4177 			/*data_ptr*/ __DECONST(void *, zero_region),
4178 			/*dxfer_len*/ softc->params.secsize,
4179 			/*sense_len*/SSD_FULL_SIZE,
4180 			da_default_timeout * 1000);
4181 	ccb->ccb_h.ccb_state = DA_CCB_DELETE;
4182 	ccb->ccb_h.flags |= CAM_UNLOCKED;
4183 	cam_iosched_submit_trim(softc->cam_iosched);
4184 }
4185 
4186 static int
4187 cmd6workaround(union ccb *ccb)
4188 {
4189 	struct scsi_rw_6 cmd6;
4190 	struct scsi_rw_10 *cmd10;
4191 	struct da_softc *softc;
4192 	u_int8_t *cdb;
4193 	struct bio *bp;
4194 	int frozen;
4195 
4196 	cdb = ccb->csio.cdb_io.cdb_bytes;
4197 	softc = (struct da_softc *)xpt_path_periph(ccb->ccb_h.path)->softc;
4198 
4199 	if (ccb->ccb_h.ccb_state == DA_CCB_DELETE) {
4200 		da_delete_methods old_method = softc->delete_method;
4201 
4202 		/*
4203 		 * Typically there are two reasons for failure here
4204 		 * 1. Delete method was detected as supported but isn't
4205 		 * 2. Delete failed due to invalid params e.g. too big
4206 		 *
4207 		 * While we will attempt to choose an alternative delete method
4208 		 * this may result in short deletes if the existing delete
4209 		 * requests from geom are big for the new method chosen.
4210 		 *
4211 		 * This method assumes that the error which triggered this
4212 		 * will not retry the io otherwise a panic will occur
4213 		 */
4214 		dadeleteflag(softc, old_method, 0);
4215 		dadeletemethodchoose(softc, DA_DELETE_DISABLE);
4216 		if (softc->delete_method == DA_DELETE_DISABLE)
4217 			xpt_print(ccb->ccb_h.path,
4218 				  "%s failed, disabling BIO_DELETE\n",
4219 				  da_delete_method_desc[old_method]);
4220 		else
4221 			xpt_print(ccb->ccb_h.path,
4222 				  "%s failed, switching to %s BIO_DELETE\n",
4223 				  da_delete_method_desc[old_method],
4224 				  da_delete_method_desc[softc->delete_method]);
4225 
4226 		while ((bp = bioq_takefirst(&softc->delete_run_queue)) != NULL)
4227 			cam_iosched_queue_work(softc->cam_iosched, bp);
4228 		cam_iosched_queue_work(softc->cam_iosched,
4229 		    (struct bio *)ccb->ccb_h.ccb_bp);
4230 		ccb->ccb_h.ccb_bp = NULL;
4231 		return (0);
4232 	}
4233 
4234 	/* Detect unsupported PREVENT ALLOW MEDIUM REMOVAL. */
4235 	if ((ccb->ccb_h.flags & CAM_CDB_POINTER) == 0 &&
4236 	    (*cdb == PREVENT_ALLOW) &&
4237 	    (softc->quirks & DA_Q_NO_PREVENT) == 0) {
4238 		if (bootverbose)
4239 			xpt_print(ccb->ccb_h.path,
4240 			    "PREVENT ALLOW MEDIUM REMOVAL not supported.\n");
4241 		softc->quirks |= DA_Q_NO_PREVENT;
4242 		return (0);
4243 	}
4244 
4245 	/* Detect unsupported SYNCHRONIZE CACHE(10). */
4246 	if ((ccb->ccb_h.flags & CAM_CDB_POINTER) == 0 &&
4247 	    (*cdb == SYNCHRONIZE_CACHE) &&
4248 	    (softc->quirks & DA_Q_NO_SYNC_CACHE) == 0) {
4249 		if (bootverbose)
4250 			xpt_print(ccb->ccb_h.path,
4251 			    "SYNCHRONIZE CACHE(10) not supported.\n");
4252 		softc->quirks |= DA_Q_NO_SYNC_CACHE;
4253 		softc->disk->d_flags &= ~DISKFLAG_CANFLUSHCACHE;
4254 		return (0);
4255 	}
4256 
4257 	/* Translation only possible if CDB is an array and cmd is R/W6 */
4258 	if ((ccb->ccb_h.flags & CAM_CDB_POINTER) != 0 ||
4259 	    (*cdb != READ_6 && *cdb != WRITE_6))
4260 		return 0;
4261 
4262 	xpt_print(ccb->ccb_h.path, "READ(6)/WRITE(6) not supported, "
4263 	    "increasing minimum_cmd_size to 10.\n");
4264 	softc->minimum_cmd_size = 10;
4265 
4266 	bcopy(cdb, &cmd6, sizeof(struct scsi_rw_6));
4267 	cmd10 = (struct scsi_rw_10 *)cdb;
4268 	cmd10->opcode = (cmd6.opcode == READ_6) ? READ_10 : WRITE_10;
4269 	cmd10->byte2 = 0;
4270 	scsi_ulto4b(scsi_3btoul(cmd6.addr), cmd10->addr);
4271 	cmd10->reserved = 0;
4272 	scsi_ulto2b(cmd6.length, cmd10->length);
4273 	cmd10->control = cmd6.control;
4274 	ccb->csio.cdb_len = sizeof(*cmd10);
4275 
4276 	/* Requeue request, unfreezing queue if necessary */
4277 	frozen = (ccb->ccb_h.status & CAM_DEV_QFRZN) != 0;
4278 	ccb->ccb_h.status = CAM_REQUEUE_REQ;
4279 	xpt_action(ccb);
4280 	if (frozen) {
4281 		cam_release_devq(ccb->ccb_h.path,
4282 				 /*relsim_flags*/0,
4283 				 /*reduction*/0,
4284 				 /*timeout*/0,
4285 				 /*getcount_only*/0);
4286 	}
4287 	return (ERESTART);
4288 }
4289 
4290 static void
4291 dazonedone(struct cam_periph *periph, union ccb *ccb)
4292 {
4293 	struct da_softc *softc;
4294 	struct bio *bp;
4295 
4296 	softc = periph->softc;
4297 	bp = (struct bio *)ccb->ccb_h.ccb_bp;
4298 
4299 	switch (bp->bio_zone.zone_cmd) {
4300 	case DISK_ZONE_OPEN:
4301 	case DISK_ZONE_CLOSE:
4302 	case DISK_ZONE_FINISH:
4303 	case DISK_ZONE_RWP:
4304 		break;
4305 	case DISK_ZONE_REPORT_ZONES: {
4306 		uint32_t avail_len;
4307 		struct disk_zone_report *rep;
4308 		struct scsi_report_zones_hdr *hdr;
4309 		struct scsi_report_zones_desc *desc;
4310 		struct disk_zone_rep_entry *entry;
4311 		uint32_t hdr_len, num_avail;
4312 		uint32_t num_to_fill, i;
4313 		int ata;
4314 
4315 		rep = &bp->bio_zone.zone_params.report;
4316 		avail_len = ccb->csio.dxfer_len - ccb->csio.resid;
4317 		/*
4318 		 * Note that bio_resid isn't normally used for zone
4319 		 * commands, but it is used by devstat_end_transaction_bio()
4320 		 * to determine how much data was transferred.  Because
4321 		 * the size of the SCSI/ATA data structures is different
4322 		 * than the size of the BIO interface structures, the
4323 		 * amount of data actually transferred from the drive will
4324 		 * be different than the amount of data transferred to
4325 		 * the user.
4326 		 */
4327 		bp->bio_resid = ccb->csio.resid;
4328 		hdr = (struct scsi_report_zones_hdr *)ccb->csio.data_ptr;
4329 		if (avail_len < sizeof(*hdr)) {
4330 			/*
4331 			 * Is there a better error than EIO here?  We asked
4332 			 * for at least the header, and we got less than
4333 			 * that.
4334 			 */
4335 			bp->bio_error = EIO;
4336 			bp->bio_flags |= BIO_ERROR;
4337 			bp->bio_resid = bp->bio_bcount;
4338 			break;
4339 		}
4340 
4341 		if (softc->zone_interface == DA_ZONE_IF_ATA_PASS)
4342 			ata = 1;
4343 		else
4344 			ata = 0;
4345 
4346 		hdr_len = ata ? le32dec(hdr->length) :
4347 				scsi_4btoul(hdr->length);
4348 		if (hdr_len > 0)
4349 			rep->entries_available = hdr_len / sizeof(*desc);
4350 		else
4351 			rep->entries_available = 0;
4352 		/*
4353 		 * NOTE: using the same values for the BIO version of the
4354 		 * same field as the SCSI/ATA values.  This means we could
4355 		 * get some additional values that aren't defined in bio.h
4356 		 * if more values of the same field are defined later.
4357 		 */
4358 		rep->header.same = hdr->byte4 & SRZ_SAME_MASK;
4359 		rep->header.maximum_lba = ata ?  le64dec(hdr->maximum_lba) :
4360 					  scsi_8btou64(hdr->maximum_lba);
4361 		/*
4362 		 * If the drive reports no entries that match the query,
4363 		 * we're done.
4364 		 */
4365 		if (hdr_len == 0) {
4366 			rep->entries_filled = 0;
4367 			break;
4368 		}
4369 
4370 		num_avail = min((avail_len - sizeof(*hdr)) / sizeof(*desc),
4371 				hdr_len / sizeof(*desc));
4372 		/*
4373 		 * If the drive didn't return any data, then we're done.
4374 		 */
4375 		if (num_avail == 0) {
4376 			rep->entries_filled = 0;
4377 			break;
4378 		}
4379 
4380 		num_to_fill = min(num_avail, rep->entries_allocated);
4381 		/*
4382 		 * If the user didn't allocate any entries for us to fill,
4383 		 * we're done.
4384 		 */
4385 		if (num_to_fill == 0) {
4386 			rep->entries_filled = 0;
4387 			break;
4388 		}
4389 
4390 		for (i = 0, desc = &hdr->desc_list[0], entry=&rep->entries[0];
4391 		     i < num_to_fill; i++, desc++, entry++) {
4392 			/*
4393 			 * NOTE: we're mapping the values here directly
4394 			 * from the SCSI/ATA bit definitions to the bio.h
4395 			 * definitons.  There is also a warning in
4396 			 * disk_zone.h, but the impact is that if
4397 			 * additional values are added in the SCSI/ATA
4398 			 * specs these will be visible to consumers of
4399 			 * this interface.
4400 			 */
4401 			entry->zone_type = desc->zone_type & SRZ_TYPE_MASK;
4402 			entry->zone_condition =
4403 			    (desc->zone_flags & SRZ_ZONE_COND_MASK) >>
4404 			    SRZ_ZONE_COND_SHIFT;
4405 			entry->zone_flags |= desc->zone_flags &
4406 			    (SRZ_ZONE_NON_SEQ|SRZ_ZONE_RESET);
4407 			entry->zone_length =
4408 			    ata ? le64dec(desc->zone_length) :
4409 				  scsi_8btou64(desc->zone_length);
4410 			entry->zone_start_lba =
4411 			    ata ? le64dec(desc->zone_start_lba) :
4412 				  scsi_8btou64(desc->zone_start_lba);
4413 			entry->write_pointer_lba =
4414 			    ata ? le64dec(desc->write_pointer_lba) :
4415 				  scsi_8btou64(desc->write_pointer_lba);
4416 		}
4417 		rep->entries_filled = num_to_fill;
4418 		break;
4419 	}
4420 	case DISK_ZONE_GET_PARAMS:
4421 	default:
4422 		/*
4423 		 * In theory we should not get a GET_PARAMS bio, since it
4424 		 * should be handled without queueing the command to the
4425 		 * drive.
4426 		 */
4427 		panic("%s: Invalid zone command %d", __func__,
4428 		    bp->bio_zone.zone_cmd);
4429 		break;
4430 	}
4431 
4432 	if (bp->bio_zone.zone_cmd == DISK_ZONE_REPORT_ZONES)
4433 		free(ccb->csio.data_ptr, M_SCSIDA);
4434 }
4435 
4436 static void
4437 dadone(struct cam_periph *periph, union ccb *done_ccb)
4438 {
4439 	struct bio *bp, *bp1;
4440 	struct da_softc *softc;
4441 	struct ccb_scsiio *csio;
4442 	u_int32_t  priority;
4443 	da_ccb_state state;
4444 
4445 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone\n"));
4446 
4447 	softc = (struct da_softc *)periph->softc;
4448 	priority = done_ccb->ccb_h.pinfo.priority;
4449 	csio = &done_ccb->csio;
4450 
4451 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
4452 	if (csio->bio != NULL)
4453 		biotrack(csio->bio, __func__);
4454 #endif
4455 	state = csio->ccb_h.ccb_state & DA_CCB_TYPE_MASK;
4456 
4457 	cam_periph_lock(periph);
4458 	bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
4459 	if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
4460 		int error;
4461 		int sf;
4462 
4463 		if ((csio->ccb_h.ccb_state & DA_CCB_RETRY_UA) != 0)
4464 			sf = SF_RETRY_UA;
4465 		else
4466 			sf = 0;
4467 
4468 		error = daerror(done_ccb, CAM_RETRY_SELTO, sf);
4469 		if (error == ERESTART) {
4470 			/* A retry was scheduled, so just return. */
4471 			cam_periph_unlock(periph);
4472 			return;
4473 		}
4474 		bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
4475 		if (error != 0) {
4476 			int queued_error;
4477 
4478 			/*
4479 			 * return all queued I/O with EIO, so that
4480 			 * the client can retry these I/Os in the
4481 			 * proper order should it attempt to recover.
4482 			 */
4483 			queued_error = EIO;
4484 
4485 			if (error == ENXIO
4486 			 && (softc->flags & DA_FLAG_PACK_INVALID)== 0) {
4487 				/*
4488 				 * Catastrophic error.  Mark our pack as
4489 				 * invalid.
4490 				 *
4491 				 * XXX See if this is really a media
4492 				 * XXX change first?
4493 				 */
4494 				xpt_print(periph->path, "Invalidating pack\n");
4495 				softc->flags |= DA_FLAG_PACK_INVALID;
4496 #ifdef CAM_IO_STATS
4497 				softc->invalidations++;
4498 #endif
4499 				queued_error = ENXIO;
4500 			}
4501 			cam_iosched_flush(softc->cam_iosched, NULL,
4502 			   queued_error);
4503 			if (bp != NULL) {
4504 				bp->bio_error = error;
4505 				bp->bio_resid = bp->bio_bcount;
4506 				bp->bio_flags |= BIO_ERROR;
4507 			}
4508 		} else if (bp != NULL) {
4509 			if (state == DA_CCB_DELETE)
4510 				bp->bio_resid = 0;
4511 			else
4512 				bp->bio_resid = csio->resid;
4513 			bp->bio_error = 0;
4514 			if (bp->bio_resid != 0)
4515 				bp->bio_flags |= BIO_ERROR;
4516 		}
4517 		if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
4518 			cam_release_devq(done_ccb->ccb_h.path,
4519 					 /*relsim_flags*/0,
4520 					 /*reduction*/0,
4521 					 /*timeout*/0,
4522 					 /*getcount_only*/0);
4523 	} else if (bp != NULL) {
4524 		if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
4525 			panic("REQ_CMP with QFRZN");
4526 		if (bp->bio_cmd == BIO_ZONE)
4527 			dazonedone(periph, done_ccb);
4528 		else if (state == DA_CCB_DELETE)
4529 			bp->bio_resid = 0;
4530 		else
4531 			bp->bio_resid = csio->resid;
4532 		if ((csio->resid > 0) && (bp->bio_cmd != BIO_ZONE))
4533 			bp->bio_flags |= BIO_ERROR;
4534 		if (softc->error_inject != 0) {
4535 			bp->bio_error = softc->error_inject;
4536 			bp->bio_resid = bp->bio_bcount;
4537 			bp->bio_flags |= BIO_ERROR;
4538 			softc->error_inject = 0;
4539 		}
4540 	}
4541 
4542 	if (bp != NULL)
4543 		biotrack(bp, __func__);
4544 	LIST_REMOVE(&done_ccb->ccb_h, periph_links.le);
4545 	if (LIST_EMPTY(&softc->pending_ccbs))
4546 		softc->flags |= DA_FLAG_WAS_OTAG;
4547 
4548 	/*
4549 	 * We need to call cam_iosched before we call biodone so that we don't
4550 	 * measure any activity that happens in the completion routine, which in
4551 	 * the case of sendfile can be quite extensive. Release the periph
4552 	 * refcount taken in dastart() for each CCB.
4553 	 */
4554 	cam_iosched_bio_complete(softc->cam_iosched, bp, done_ccb);
4555 	xpt_release_ccb(done_ccb);
4556 	KASSERT(softc->refcount >= 1, ("dadone softc %p refcount %d", softc, softc->refcount));
4557 	softc->refcount--;
4558 	if (state == DA_CCB_DELETE) {
4559 		TAILQ_HEAD(, bio) queue;
4560 
4561 		TAILQ_INIT(&queue);
4562 		TAILQ_CONCAT(&queue, &softc->delete_run_queue.queue, bio_queue);
4563 		softc->delete_run_queue.insert_point = NULL;
4564 		/*
4565 		 * Normally, the xpt_release_ccb() above would make sure
4566 		 * that when we have more work to do, that work would
4567 		 * get kicked off. However, we specifically keep
4568 		 * delete_running set to 0 before the call above to
4569 		 * allow other I/O to progress when many BIO_DELETE
4570 		 * requests are pushed down. We set delete_running to 0
4571 		 * and call daschedule again so that we don't stall if
4572 		 * there are no other I/Os pending apart from BIO_DELETEs.
4573 		 */
4574 		cam_iosched_trim_done(softc->cam_iosched);
4575 		daschedule(periph);
4576 		cam_periph_unlock(periph);
4577 		while ((bp1 = TAILQ_FIRST(&queue)) != NULL) {
4578 			TAILQ_REMOVE(&queue, bp1, bio_queue);
4579 			bp1->bio_error = bp->bio_error;
4580 			if (bp->bio_flags & BIO_ERROR) {
4581 				bp1->bio_flags |= BIO_ERROR;
4582 				bp1->bio_resid = bp1->bio_bcount;
4583 			} else
4584 				bp1->bio_resid = 0;
4585 			biodone(bp1);
4586 		}
4587 	} else {
4588 		daschedule(periph);
4589 		cam_periph_unlock(periph);
4590 	}
4591 	if (bp != NULL)
4592 		biodone(bp);
4593 	return;
4594 }
4595 
4596 static void
4597 dadone_probewp(struct cam_periph *periph, union ccb *done_ccb)
4598 {
4599 	struct scsi_mode_header_6 *mode_hdr6;
4600 	struct scsi_mode_header_10 *mode_hdr10;
4601 	struct da_softc *softc;
4602 	struct ccb_scsiio *csio;
4603 	u_int32_t  priority;
4604 	uint8_t dev_spec;
4605 
4606 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probewp\n"));
4607 
4608 	softc = (struct da_softc *)periph->softc;
4609 	priority = done_ccb->ccb_h.pinfo.priority;
4610 	csio = &done_ccb->csio;
4611 
4612 	cam_periph_assert(periph, MA_OWNED);
4613 
4614 	if (softc->minimum_cmd_size > 6) {
4615 		mode_hdr10 = (struct scsi_mode_header_10 *)csio->data_ptr;
4616 		dev_spec = mode_hdr10->dev_spec;
4617 	} else {
4618 		mode_hdr6 = (struct scsi_mode_header_6 *)csio->data_ptr;
4619 		dev_spec = mode_hdr6->dev_spec;
4620 	}
4621 	if (cam_ccb_status(done_ccb) == CAM_REQ_CMP) {
4622 		if ((dev_spec & 0x80) != 0)
4623 			softc->disk->d_flags |= DISKFLAG_WRITE_PROTECT;
4624 		else
4625 			softc->disk->d_flags &= ~DISKFLAG_WRITE_PROTECT;
4626 	} else {
4627 		int error;
4628 
4629 		error = daerror(done_ccb, CAM_RETRY_SELTO,
4630 				SF_RETRY_UA|SF_NO_PRINT);
4631 		if (error == ERESTART)
4632 			return;
4633 		else if (error != 0) {
4634 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
4635 				/* Don't wedge this device's queue */
4636 				cam_release_devq(done_ccb->ccb_h.path,
4637 						 /*relsim_flags*/0,
4638 						 /*reduction*/0,
4639 						 /*timeout*/0,
4640 						 /*getcount_only*/0);
4641 			}
4642 		}
4643 	}
4644 
4645 	free(csio->data_ptr, M_SCSIDA);
4646 	xpt_release_ccb(done_ccb);
4647 	if ((softc->flags & DA_FLAG_CAN_RC16) != 0)
4648 		softc->state = DA_STATE_PROBE_RC16;
4649 	else
4650 		softc->state = DA_STATE_PROBE_RC;
4651 	xpt_schedule(periph, priority);
4652 	return;
4653 }
4654 
4655 static void
4656 dadone_proberc(struct cam_periph *periph, union ccb *done_ccb)
4657 {
4658 	struct scsi_read_capacity_data *rdcap;
4659 	struct scsi_read_capacity_data_long *rcaplong;
4660 	struct da_softc *softc;
4661 	struct ccb_scsiio *csio;
4662 	da_ccb_state state;
4663 	char *announce_buf;
4664 	u_int32_t  priority;
4665 	int lbp, n;
4666 
4667 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_proberc\n"));
4668 
4669 	softc = (struct da_softc *)periph->softc;
4670 	priority = done_ccb->ccb_h.pinfo.priority;
4671 	csio = &done_ccb->csio;
4672 	state = csio->ccb_h.ccb_state & DA_CCB_TYPE_MASK;
4673 
4674 	lbp = 0;
4675 	rdcap = NULL;
4676 	rcaplong = NULL;
4677 	/* XXX TODO: can this be a malloc? */
4678 	announce_buf = softc->announce_temp;
4679 	bzero(announce_buf, DA_ANNOUNCETMP_SZ);
4680 
4681 	if (state == DA_CCB_PROBE_RC)
4682 		rdcap =(struct scsi_read_capacity_data *)csio->data_ptr;
4683 	else
4684 		rcaplong = (struct scsi_read_capacity_data_long *)
4685 			csio->data_ptr;
4686 
4687 	cam_periph_assert(periph, MA_OWNED);
4688 
4689 	if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4690 		struct disk_params *dp;
4691 		uint32_t block_size;
4692 		uint64_t maxsector;
4693 		u_int lalba;	/* Lowest aligned LBA. */
4694 
4695 		if (state == DA_CCB_PROBE_RC) {
4696 			block_size = scsi_4btoul(rdcap->length);
4697 			maxsector = scsi_4btoul(rdcap->addr);
4698 			lalba = 0;
4699 
4700 			/*
4701 			 * According to SBC-2, if the standard 10
4702 			 * byte READ CAPACITY command returns 2^32,
4703 			 * we should issue the 16 byte version of
4704 			 * the command, since the device in question
4705 			 * has more sectors than can be represented
4706 			 * with the short version of the command.
4707 			 */
4708 			if (maxsector == 0xffffffff) {
4709 				free(rdcap, M_SCSIDA);
4710 				xpt_release_ccb(done_ccb);
4711 				softc->state = DA_STATE_PROBE_RC16;
4712 				xpt_schedule(periph, priority);
4713 				return;
4714 			}
4715 		} else {
4716 			block_size = scsi_4btoul(rcaplong->length);
4717 			maxsector = scsi_8btou64(rcaplong->addr);
4718 			lalba = scsi_2btoul(rcaplong->lalba_lbp);
4719 		}
4720 
4721 		/*
4722 		 * Because GEOM code just will panic us if we
4723 		 * give them an 'illegal' value we'll avoid that
4724 		 * here.
4725 		 */
4726 		if (block_size == 0) {
4727 			block_size = 512;
4728 			if (maxsector == 0)
4729 				maxsector = -1;
4730 		}
4731 		if (block_size >= MAXPHYS) {
4732 			xpt_print(periph->path,
4733 			    "unsupportable block size %ju\n",
4734 			    (uintmax_t) block_size);
4735 			announce_buf = NULL;
4736 			cam_periph_invalidate(periph);
4737 		} else {
4738 			/*
4739 			 * We pass rcaplong into dasetgeom(),
4740 			 * because it will only use it if it is
4741 			 * non-NULL.
4742 			 */
4743 			dasetgeom(periph, block_size, maxsector,
4744 				  rcaplong, sizeof(*rcaplong));
4745 			lbp = (lalba & SRC16_LBPME_A);
4746 			dp = &softc->params;
4747 			n = snprintf(announce_buf, DA_ANNOUNCETMP_SZ,
4748 			    "%juMB (%ju %u byte sectors",
4749 			    ((uintmax_t)dp->secsize * dp->sectors) /
4750 			     (1024 * 1024),
4751 			    (uintmax_t)dp->sectors, dp->secsize);
4752 			if (softc->p_type != 0) {
4753 				n += snprintf(announce_buf + n,
4754 				    DA_ANNOUNCETMP_SZ - n,
4755 				    ", DIF type %d", softc->p_type);
4756 			}
4757 			snprintf(announce_buf + n, DA_ANNOUNCETMP_SZ - n, ")");
4758 		}
4759 	} else {
4760 		int error;
4761 
4762 		/*
4763 		 * Retry any UNIT ATTENTION type errors.  They
4764 		 * are expected at boot.
4765 		 */
4766 		error = daerror(done_ccb, CAM_RETRY_SELTO,
4767 				SF_RETRY_UA|SF_NO_PRINT);
4768 		if (error == ERESTART) {
4769 			/*
4770 			 * A retry was scheuled, so
4771 			 * just return.
4772 			 */
4773 			return;
4774 		} else if (error != 0) {
4775 			int asc, ascq;
4776 			int sense_key, error_code;
4777 			int have_sense;
4778 			cam_status status;
4779 			struct ccb_getdev cgd;
4780 
4781 			/* Don't wedge this device's queue */
4782 			status = done_ccb->ccb_h.status;
4783 			if ((status & CAM_DEV_QFRZN) != 0)
4784 				cam_release_devq(done_ccb->ccb_h.path,
4785 						 /*relsim_flags*/0,
4786 						 /*reduction*/0,
4787 						 /*timeout*/0,
4788 						 /*getcount_only*/0);
4789 
4790 
4791 			xpt_setup_ccb(&cgd.ccb_h, done_ccb->ccb_h.path,
4792 				      CAM_PRIORITY_NORMAL);
4793 			cgd.ccb_h.func_code = XPT_GDEV_TYPE;
4794 			xpt_action((union ccb *)&cgd);
4795 
4796 			if (scsi_extract_sense_ccb(done_ccb,
4797 			    &error_code, &sense_key, &asc, &ascq))
4798 				have_sense = TRUE;
4799 			else
4800 				have_sense = FALSE;
4801 
4802 			/*
4803 			 * If we tried READ CAPACITY(16) and failed,
4804 			 * fallback to READ CAPACITY(10).
4805 			 */
4806 			if ((state == DA_CCB_PROBE_RC16) &&
4807 			    (softc->flags & DA_FLAG_CAN_RC16) &&
4808 			    (((csio->ccb_h.status & CAM_STATUS_MASK) ==
4809 				CAM_REQ_INVALID) ||
4810 			     ((have_sense) &&
4811 			      (error_code == SSD_CURRENT_ERROR ||
4812 			       error_code == SSD_DESC_CURRENT_ERROR) &&
4813 			      (sense_key == SSD_KEY_ILLEGAL_REQUEST)))) {
4814 				cam_periph_assert(periph, MA_OWNED);
4815 				softc->flags &= ~DA_FLAG_CAN_RC16;
4816 				free(rdcap, M_SCSIDA);
4817 				xpt_release_ccb(done_ccb);
4818 				softc->state = DA_STATE_PROBE_RC;
4819 				xpt_schedule(periph, priority);
4820 				return;
4821 			}
4822 
4823 			/*
4824 			 * Attach to anything that claims to be a
4825 			 * direct access or optical disk device,
4826 			 * as long as it doesn't return a "Logical
4827 			 * unit not supported" (0x25) error.
4828 			 * "Internal Target Failure" (0x44) is also
4829 			 * special and typically means that the
4830 			 * device is a SATA drive behind a SATL
4831 			 * translation that's fallen into a
4832 			 * terminally fatal state.
4833 			 */
4834 			if ((have_sense)
4835 			 && (asc != 0x25) && (asc != 0x44)
4836 			 && (error_code == SSD_CURRENT_ERROR
4837 			  || error_code == SSD_DESC_CURRENT_ERROR)) {
4838 				const char *sense_key_desc;
4839 				const char *asc_desc;
4840 
4841 				dasetgeom(periph, 512, -1, NULL, 0);
4842 				scsi_sense_desc(sense_key, asc, ascq,
4843 						&cgd.inq_data, &sense_key_desc,
4844 						&asc_desc);
4845 				snprintf(announce_buf, DA_ANNOUNCETMP_SZ,
4846 				    "Attempt to query device "
4847 				    "size failed: %s, %s",
4848 				    sense_key_desc, asc_desc);
4849 			} else {
4850 				if (have_sense)
4851 					scsi_sense_print(&done_ccb->csio);
4852 				else {
4853 					xpt_print(periph->path,
4854 					    "got CAM status %#x\n",
4855 					    done_ccb->ccb_h.status);
4856 				}
4857 
4858 				xpt_print(periph->path, "fatal error, "
4859 				    "failed to attach to device\n");
4860 
4861 				announce_buf = NULL;
4862 
4863 				/*
4864 				 * Free up resources.
4865 				 */
4866 				cam_periph_invalidate(periph);
4867 			}
4868 		}
4869 	}
4870 	free(csio->data_ptr, M_SCSIDA);
4871 	if (announce_buf != NULL &&
4872 	    ((softc->flags & DA_FLAG_ANNOUNCED) == 0)) {
4873 		struct sbuf sb;
4874 
4875 		sbuf_new(&sb, softc->announcebuf, DA_ANNOUNCE_SZ,
4876 		    SBUF_FIXEDLEN);
4877 		xpt_announce_periph_sbuf(periph, &sb, announce_buf);
4878 		xpt_announce_quirks_sbuf(periph, &sb, softc->quirks,
4879 		    DA_Q_BIT_STRING);
4880 		sbuf_finish(&sb);
4881 		sbuf_putbuf(&sb);
4882 
4883 		/*
4884 		 * Create our sysctl variables, now that we know
4885 		 * we have successfully attached.
4886 		 */
4887 		/* increase the refcount */
4888 		if (da_periph_acquire(periph, DA_REF_SYSCTL) == 0) {
4889 			taskqueue_enqueue(taskqueue_thread,
4890 					  &softc->sysctl_task);
4891 		} else {
4892 			/* XXX This message is useless! */
4893 			xpt_print(periph->path, "fatal error, "
4894 			    "could not acquire reference count\n");
4895 		}
4896 	}
4897 
4898 	/* We already probed the device. */
4899 	if (softc->flags & DA_FLAG_PROBED) {
4900 		daprobedone(periph, done_ccb);
4901 		return;
4902 	}
4903 
4904 	/* Ensure re-probe doesn't see old delete. */
4905 	softc->delete_available = 0;
4906 	dadeleteflag(softc, DA_DELETE_ZERO, 1);
4907 	if (lbp && (softc->quirks & DA_Q_NO_UNMAP) == 0) {
4908 		/*
4909 		 * Based on older SBC-3 spec revisions
4910 		 * any of the UNMAP methods "may" be
4911 		 * available via LBP given this flag so
4912 		 * we flag all of them as available and
4913 		 * then remove those which further
4914 		 * probes confirm aren't available
4915 		 * later.
4916 		 *
4917 		 * We could also check readcap(16) p_type
4918 		 * flag to exclude one or more invalid
4919 		 * write same (X) types here
4920 		 */
4921 		dadeleteflag(softc, DA_DELETE_WS16, 1);
4922 		dadeleteflag(softc, DA_DELETE_WS10, 1);
4923 		dadeleteflag(softc, DA_DELETE_UNMAP, 1);
4924 
4925 		xpt_release_ccb(done_ccb);
4926 		softc->state = DA_STATE_PROBE_LBP;
4927 		xpt_schedule(periph, priority);
4928 		return;
4929 	}
4930 
4931 	xpt_release_ccb(done_ccb);
4932 	softc->state = DA_STATE_PROBE_BDC;
4933 	xpt_schedule(periph, priority);
4934 	return;
4935 }
4936 
4937 static void
4938 dadone_probelbp(struct cam_periph *periph, union ccb *done_ccb)
4939 {
4940 	struct scsi_vpd_logical_block_prov *lbp;
4941 	struct da_softc *softc;
4942 	struct ccb_scsiio *csio;
4943 	u_int32_t  priority;
4944 
4945 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probelbp\n"));
4946 
4947 	softc = (struct da_softc *)periph->softc;
4948 	priority = done_ccb->ccb_h.pinfo.priority;
4949 	csio = &done_ccb->csio;
4950 	lbp = (struct scsi_vpd_logical_block_prov *)csio->data_ptr;
4951 
4952 	cam_periph_assert(periph, MA_OWNED);
4953 
4954 	if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
4955 		/*
4956 		 * T10/1799-D Revision 31 states at least one of these
4957 		 * must be supported but we don't currently enforce this.
4958 		 */
4959 		dadeleteflag(softc, DA_DELETE_WS16,
4960 		     (lbp->flags & SVPD_LBP_WS16));
4961 		dadeleteflag(softc, DA_DELETE_WS10,
4962 			     (lbp->flags & SVPD_LBP_WS10));
4963 		dadeleteflag(softc, DA_DELETE_UNMAP,
4964 			     (lbp->flags & SVPD_LBP_UNMAP));
4965 	} else {
4966 		int error;
4967 		error = daerror(done_ccb, CAM_RETRY_SELTO,
4968 				SF_RETRY_UA|SF_NO_PRINT);
4969 		if (error == ERESTART)
4970 			return;
4971 		else if (error != 0) {
4972 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
4973 				/* Don't wedge this device's queue */
4974 				cam_release_devq(done_ccb->ccb_h.path,
4975 						 /*relsim_flags*/0,
4976 						 /*reduction*/0,
4977 						 /*timeout*/0,
4978 						 /*getcount_only*/0);
4979 			}
4980 
4981 			/*
4982 			 * Failure indicates we don't support any SBC-3
4983 			 * delete methods with UNMAP
4984 			 */
4985 		}
4986 	}
4987 
4988 	free(lbp, M_SCSIDA);
4989 	xpt_release_ccb(done_ccb);
4990 	softc->state = DA_STATE_PROBE_BLK_LIMITS;
4991 	xpt_schedule(periph, priority);
4992 	return;
4993 }
4994 
4995 static void
4996 dadone_probeblklimits(struct cam_periph *periph, union ccb *done_ccb)
4997 {
4998 	struct scsi_vpd_block_limits *block_limits;
4999 	struct da_softc *softc;
5000 	struct ccb_scsiio *csio;
5001 	u_int32_t  priority;
5002 
5003 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probeblklimits\n"));
5004 
5005 	softc = (struct da_softc *)periph->softc;
5006 	priority = done_ccb->ccb_h.pinfo.priority;
5007 	csio = &done_ccb->csio;
5008 	block_limits = (struct scsi_vpd_block_limits *)csio->data_ptr;
5009 
5010 	cam_periph_assert(periph, MA_OWNED);
5011 
5012 	if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5013 		uint32_t max_txfer_len = scsi_4btoul(
5014 			block_limits->max_txfer_len);
5015 		uint32_t max_unmap_lba_cnt = scsi_4btoul(
5016 			block_limits->max_unmap_lba_cnt);
5017 		uint32_t max_unmap_blk_cnt = scsi_4btoul(
5018 			block_limits->max_unmap_blk_cnt);
5019 		uint32_t unmap_gran = scsi_4btoul(
5020 			block_limits->opt_unmap_grain);
5021 		uint32_t unmap_gran_align = scsi_4btoul(
5022 			block_limits->unmap_grain_align);
5023 		uint64_t ws_max_blks = scsi_8btou64(
5024 			block_limits->max_write_same_length);
5025 
5026 		if (max_txfer_len != 0) {
5027 			softc->disk->d_maxsize = MIN(softc->maxio,
5028 			    (off_t)max_txfer_len * softc->params.secsize);
5029 		}
5030 
5031 		/*
5032 		 * We should already support UNMAP but we check lba
5033 		 * and block count to be sure
5034 		 */
5035 		if (max_unmap_lba_cnt != 0x00L &&
5036 		    max_unmap_blk_cnt != 0x00L) {
5037 			softc->unmap_max_lba = max_unmap_lba_cnt;
5038 			softc->unmap_max_ranges = min(max_unmap_blk_cnt,
5039 				UNMAP_MAX_RANGES);
5040 			if (unmap_gran > 1) {
5041 				softc->unmap_gran = unmap_gran;
5042 				if (unmap_gran_align & 0x80000000) {
5043 					softc->unmap_gran_align =
5044 					    unmap_gran_align & 0x7fffffff;
5045 				}
5046 			}
5047 		} else {
5048 			/*
5049 			 * Unexpected UNMAP limits which means the
5050 			 * device doesn't actually support UNMAP
5051 			 */
5052 			dadeleteflag(softc, DA_DELETE_UNMAP, 0);
5053 		}
5054 
5055 		if (ws_max_blks != 0x00L)
5056 			softc->ws_max_blks = ws_max_blks;
5057 	} else {
5058 		int error;
5059 		error = daerror(done_ccb, CAM_RETRY_SELTO,
5060 				SF_RETRY_UA|SF_NO_PRINT);
5061 		if (error == ERESTART)
5062 			return;
5063 		else if (error != 0) {
5064 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5065 				/* Don't wedge this device's queue */
5066 				cam_release_devq(done_ccb->ccb_h.path,
5067 						 /*relsim_flags*/0,
5068 						 /*reduction*/0,
5069 						 /*timeout*/0,
5070 						 /*getcount_only*/0);
5071 			}
5072 
5073 			/*
5074 			 * Failure here doesn't mean UNMAP is not
5075 			 * supported as this is an optional page.
5076 			 */
5077 			softc->unmap_max_lba = 1;
5078 			softc->unmap_max_ranges = 1;
5079 		}
5080 	}
5081 
5082 	free(block_limits, M_SCSIDA);
5083 	xpt_release_ccb(done_ccb);
5084 	softc->state = DA_STATE_PROBE_BDC;
5085 	xpt_schedule(periph, priority);
5086 	return;
5087 }
5088 
5089 static void
5090 dadone_probebdc(struct cam_periph *periph, union ccb *done_ccb)
5091 {
5092 	struct scsi_vpd_block_device_characteristics *bdc;
5093 	struct da_softc *softc;
5094 	struct ccb_scsiio *csio;
5095 	u_int32_t  priority;
5096 
5097 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probebdc\n"));
5098 
5099 	softc = (struct da_softc *)periph->softc;
5100 	priority = done_ccb->ccb_h.pinfo.priority;
5101 	csio = &done_ccb->csio;
5102 	bdc = (struct scsi_vpd_block_device_characteristics *)csio->data_ptr;
5103 
5104 	cam_periph_assert(periph, MA_OWNED);
5105 
5106 	if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5107 		uint32_t valid_len;
5108 
5109 		/*
5110 		 * Disable queue sorting for non-rotational media
5111 		 * by default.
5112 		 */
5113 		u_int16_t old_rate = softc->disk->d_rotation_rate;
5114 
5115 		valid_len = csio->dxfer_len - csio->resid;
5116 		if (SBDC_IS_PRESENT(bdc, valid_len,
5117 		    medium_rotation_rate)) {
5118 			softc->disk->d_rotation_rate =
5119 				scsi_2btoul(bdc->medium_rotation_rate);
5120 			if (softc->disk->d_rotation_rate ==
5121 			    SVPD_BDC_RATE_NON_ROTATING) {
5122 				cam_iosched_set_sort_queue(
5123 				    softc->cam_iosched, 0);
5124 				softc->rotating = 0;
5125 			}
5126 			if (softc->disk->d_rotation_rate != old_rate) {
5127 				disk_attr_changed(softc->disk,
5128 				    "GEOM::rotation_rate", M_NOWAIT);
5129 			}
5130 		}
5131 		if ((SBDC_IS_PRESENT(bdc, valid_len, flags))
5132 		 && (softc->zone_mode == DA_ZONE_NONE)) {
5133 			int ata_proto;
5134 
5135 			if (scsi_vpd_supported_page(periph,
5136 			    SVPD_ATA_INFORMATION))
5137 				ata_proto = 1;
5138 			else
5139 				ata_proto = 0;
5140 
5141 			/*
5142 			 * The Zoned field will only be set for
5143 			 * Drive Managed and Host Aware drives.  If
5144 			 * they are Host Managed, the device type
5145 			 * in the standard INQUIRY data should be
5146 			 * set to T_ZBC_HM (0x14).
5147 			 */
5148 			if ((bdc->flags & SVPD_ZBC_MASK) ==
5149 			     SVPD_HAW_ZBC) {
5150 				softc->zone_mode = DA_ZONE_HOST_AWARE;
5151 				softc->zone_interface = (ata_proto) ?
5152 				   DA_ZONE_IF_ATA_SAT : DA_ZONE_IF_SCSI;
5153 			} else if ((bdc->flags & SVPD_ZBC_MASK) ==
5154 			     SVPD_DM_ZBC) {
5155 				softc->zone_mode =DA_ZONE_DRIVE_MANAGED;
5156 				softc->zone_interface = (ata_proto) ?
5157 				   DA_ZONE_IF_ATA_SAT : DA_ZONE_IF_SCSI;
5158 			} else if ((bdc->flags & SVPD_ZBC_MASK) !=
5159 				  SVPD_ZBC_NR) {
5160 				xpt_print(periph->path, "Unknown zoned "
5161 				    "type %#x",
5162 				    bdc->flags & SVPD_ZBC_MASK);
5163 			}
5164 		}
5165 	} else {
5166 		int error;
5167 		error = daerror(done_ccb, CAM_RETRY_SELTO,
5168 				SF_RETRY_UA|SF_NO_PRINT);
5169 		if (error == ERESTART)
5170 			return;
5171 		else if (error != 0) {
5172 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5173 				/* Don't wedge this device's queue */
5174 				cam_release_devq(done_ccb->ccb_h.path,
5175 						 /*relsim_flags*/0,
5176 						 /*reduction*/0,
5177 						 /*timeout*/0,
5178 						 /*getcount_only*/0);
5179 			}
5180 		}
5181 	}
5182 
5183 	free(bdc, M_SCSIDA);
5184 	xpt_release_ccb(done_ccb);
5185 	softc->state = DA_STATE_PROBE_ATA;
5186 	xpt_schedule(periph, priority);
5187 	return;
5188 }
5189 
5190 static void
5191 dadone_probeata(struct cam_periph *periph, union ccb *done_ccb)
5192 {
5193 	struct ata_params *ata_params;
5194 	struct ccb_scsiio *csio;
5195 	struct da_softc *softc;
5196 	u_int32_t  priority;
5197 	int continue_probe;
5198 	int error;
5199 	int16_t *ptr;
5200 
5201 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probeata\n"));
5202 
5203 	softc = (struct da_softc *)periph->softc;
5204 	priority = done_ccb->ccb_h.pinfo.priority;
5205 	csio = &done_ccb->csio;
5206 	ata_params = (struct ata_params *)csio->data_ptr;
5207 	ptr = (uint16_t *)ata_params;
5208 	continue_probe = 0;
5209 	error = 0;
5210 
5211 	cam_periph_assert(periph, MA_OWNED);
5212 
5213 	if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5214 		uint16_t old_rate;
5215 
5216 		ata_param_fixup(ata_params);
5217 		if (ata_params->support_dsm & ATA_SUPPORT_DSM_TRIM &&
5218 		    (softc->quirks & DA_Q_NO_UNMAP) == 0) {
5219 			dadeleteflag(softc, DA_DELETE_ATA_TRIM, 1);
5220 			if (ata_params->max_dsm_blocks != 0)
5221 				softc->trim_max_ranges = min(
5222 				  softc->trim_max_ranges,
5223 				  ata_params->max_dsm_blocks *
5224 				  ATA_DSM_BLK_RANGES);
5225 		}
5226 		/*
5227 		 * Disable queue sorting for non-rotational media
5228 		 * by default.
5229 		 */
5230 		old_rate = softc->disk->d_rotation_rate;
5231 		softc->disk->d_rotation_rate = ata_params->media_rotation_rate;
5232 		if (softc->disk->d_rotation_rate == ATA_RATE_NON_ROTATING) {
5233 			cam_iosched_set_sort_queue(softc->cam_iosched, 0);
5234 			softc->rotating = 0;
5235 		}
5236 		if (softc->disk->d_rotation_rate != old_rate) {
5237 			disk_attr_changed(softc->disk,
5238 			    "GEOM::rotation_rate", M_NOWAIT);
5239 		}
5240 
5241 		cam_periph_assert(periph, MA_OWNED);
5242 		if (ata_params->capabilities1 & ATA_SUPPORT_DMA)
5243 			softc->flags |= DA_FLAG_CAN_ATA_DMA;
5244 
5245 		if (ata_params->support.extension & ATA_SUPPORT_GENLOG)
5246 			softc->flags |= DA_FLAG_CAN_ATA_LOG;
5247 
5248 		/*
5249 		 * At this point, if we have a SATA host aware drive,
5250 		 * we communicate via ATA passthrough unless the
5251 		 * SAT layer supports ZBC -> ZAC translation.  In
5252 		 * that case,
5253 		 *
5254 		 * XXX KDM figure out how to detect a host managed
5255 		 * SATA drive.
5256 		 */
5257 		if (softc->zone_mode == DA_ZONE_NONE) {
5258 			/*
5259 			 * Note that we don't override the zone
5260 			 * mode or interface if it has already been
5261 			 * set.  This is because it has either been
5262 			 * set as a quirk, or when we probed the
5263 			 * SCSI Block Device Characteristics page,
5264 			 * the zoned field was set.  The latter
5265 			 * means that the SAT layer supports ZBC to
5266 			 * ZAC translation, and we would prefer to
5267 			 * use that if it is available.
5268 			 */
5269 			if ((ata_params->support3 &
5270 			    ATA_SUPPORT_ZONE_MASK) ==
5271 			    ATA_SUPPORT_ZONE_HOST_AWARE) {
5272 				softc->zone_mode = DA_ZONE_HOST_AWARE;
5273 				softc->zone_interface =
5274 				    DA_ZONE_IF_ATA_PASS;
5275 			} else if ((ata_params->support3 &
5276 				    ATA_SUPPORT_ZONE_MASK) ==
5277 				    ATA_SUPPORT_ZONE_DEV_MANAGED) {
5278 				softc->zone_mode =DA_ZONE_DRIVE_MANAGED;
5279 				softc->zone_interface = DA_ZONE_IF_ATA_PASS;
5280 			}
5281 		}
5282 
5283 	} else {
5284 		error = daerror(done_ccb, CAM_RETRY_SELTO,
5285 				SF_RETRY_UA|SF_NO_PRINT);
5286 		if (error == ERESTART)
5287 			return;
5288 		else if (error != 0) {
5289 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5290 				/* Don't wedge this device's queue */
5291 				cam_release_devq(done_ccb->ccb_h.path,
5292 						 /*relsim_flags*/0,
5293 						 /*reduction*/0,
5294 						 /*timeout*/0,
5295 						 /*getcount_only*/0);
5296 			}
5297 		}
5298 	}
5299 
5300 	if ((softc->zone_mode == DA_ZONE_HOST_AWARE)
5301 	 || (softc->zone_mode == DA_ZONE_HOST_MANAGED)) {
5302 		/*
5303 		 * If the ATA IDENTIFY failed, we could be talking
5304 		 * to a SCSI drive, although that seems unlikely,
5305 		 * since the drive did report that it supported the
5306 		 * ATA Information VPD page.  If the ATA IDENTIFY
5307 		 * succeeded, and the SAT layer doesn't support
5308 		 * ZBC -> ZAC translation, continue on to get the
5309 		 * directory of ATA logs, and complete the rest of
5310 		 * the ZAC probe.  If the SAT layer does support
5311 		 * ZBC -> ZAC translation, we want to use that,
5312 		 * and we'll probe the SCSI Zoned Block Device
5313 		 * Characteristics VPD page next.
5314 		 */
5315 		if ((error == 0)
5316 		 && (softc->flags & DA_FLAG_CAN_ATA_LOG)
5317 		 && (softc->zone_interface == DA_ZONE_IF_ATA_PASS))
5318 			softc->state = DA_STATE_PROBE_ATA_LOGDIR;
5319 		else
5320 			softc->state = DA_STATE_PROBE_ZONE;
5321 		continue_probe = 1;
5322 	}
5323 	if (continue_probe != 0) {
5324 		xpt_release_ccb(done_ccb);
5325 		xpt_schedule(periph, priority);
5326 		return;
5327 	} else
5328 		daprobedone(periph, done_ccb);
5329 	return;
5330 }
5331 
5332 static void
5333 dadone_probeatalogdir(struct cam_periph *periph, union ccb *done_ccb)
5334 {
5335 	struct da_softc *softc;
5336 	struct ccb_scsiio *csio;
5337 	u_int32_t  priority;
5338 	int error;
5339 
5340 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probeatalogdir\n"));
5341 
5342 	softc = (struct da_softc *)periph->softc;
5343 	priority = done_ccb->ccb_h.pinfo.priority;
5344 	csio = &done_ccb->csio;
5345 
5346 	cam_periph_assert(periph, MA_OWNED);
5347 	if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5348 		error = 0;
5349 		softc->valid_logdir_len = 0;
5350 		bzero(&softc->ata_logdir, sizeof(softc->ata_logdir));
5351 		softc->valid_logdir_len = csio->dxfer_len - csio->resid;
5352 		if (softc->valid_logdir_len > 0)
5353 			bcopy(csio->data_ptr, &softc->ata_logdir,
5354 			    min(softc->valid_logdir_len,
5355 				sizeof(softc->ata_logdir)));
5356 		/*
5357 		 * Figure out whether the Identify Device log is
5358 		 * supported.  The General Purpose log directory
5359 		 * has a header, and lists the number of pages
5360 		 * available for each GP log identified by the
5361 		 * offset into the list.
5362 		 */
5363 		if ((softc->valid_logdir_len >=
5364 		    ((ATA_IDENTIFY_DATA_LOG + 1) * sizeof(uint16_t)))
5365 		 && (le16dec(softc->ata_logdir.header) ==
5366 		     ATA_GP_LOG_DIR_VERSION)
5367 		 && (le16dec(&softc->ata_logdir.num_pages[
5368 		     (ATA_IDENTIFY_DATA_LOG *
5369 		     sizeof(uint16_t)) - sizeof(uint16_t)]) > 0)){
5370 			softc->flags |= DA_FLAG_CAN_ATA_IDLOG;
5371 		} else {
5372 			softc->flags &= ~DA_FLAG_CAN_ATA_IDLOG;
5373 		}
5374 	} else {
5375 		error = daerror(done_ccb, CAM_RETRY_SELTO,
5376 				SF_RETRY_UA|SF_NO_PRINT);
5377 		if (error == ERESTART)
5378 			return;
5379 		else if (error != 0) {
5380 			/*
5381 			 * If we can't get the ATA log directory,
5382 			 * then ATA logs are effectively not
5383 			 * supported even if the bit is set in the
5384 			 * identify data.
5385 			 */
5386 			softc->flags &= ~(DA_FLAG_CAN_ATA_LOG |
5387 					  DA_FLAG_CAN_ATA_IDLOG);
5388 			if ((done_ccb->ccb_h.status &
5389 			     CAM_DEV_QFRZN) != 0) {
5390 				/* Don't wedge this device's queue */
5391 				cam_release_devq(done_ccb->ccb_h.path,
5392 						 /*relsim_flags*/0,
5393 						 /*reduction*/0,
5394 						 /*timeout*/0,
5395 						 /*getcount_only*/0);
5396 			}
5397 		}
5398 	}
5399 
5400 	free(csio->data_ptr, M_SCSIDA);
5401 
5402 	if ((error == 0)
5403 	 && (softc->flags & DA_FLAG_CAN_ATA_IDLOG)) {
5404 		softc->state = DA_STATE_PROBE_ATA_IDDIR;
5405 		xpt_release_ccb(done_ccb);
5406 		xpt_schedule(periph, priority);
5407 		return;
5408 	}
5409 	daprobedone(periph, done_ccb);
5410 	return;
5411 }
5412 
5413 static void
5414 dadone_probeataiddir(struct cam_periph *periph, union ccb *done_ccb)
5415 {
5416 	struct da_softc *softc;
5417 	struct ccb_scsiio *csio;
5418 	u_int32_t  priority;
5419 	int error;
5420 
5421 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probeataiddir\n"));
5422 
5423 	softc = (struct da_softc *)periph->softc;
5424 	priority = done_ccb->ccb_h.pinfo.priority;
5425 	csio = &done_ccb->csio;
5426 
5427 	cam_periph_assert(periph, MA_OWNED);
5428 
5429 	if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5430 		off_t entries_offset, max_entries;
5431 		error = 0;
5432 
5433 		softc->valid_iddir_len = 0;
5434 		bzero(&softc->ata_iddir, sizeof(softc->ata_iddir));
5435 		softc->flags &= ~(DA_FLAG_CAN_ATA_SUPCAP |
5436 				  DA_FLAG_CAN_ATA_ZONE);
5437 		softc->valid_iddir_len = csio->dxfer_len - csio->resid;
5438 		if (softc->valid_iddir_len > 0)
5439 			bcopy(csio->data_ptr, &softc->ata_iddir,
5440 			    min(softc->valid_iddir_len,
5441 				sizeof(softc->ata_iddir)));
5442 
5443 		entries_offset =
5444 		    __offsetof(struct ata_identify_log_pages,entries);
5445 		max_entries = softc->valid_iddir_len - entries_offset;
5446 		if ((softc->valid_iddir_len > (entries_offset + 1))
5447 		 && (le64dec(softc->ata_iddir.header) == ATA_IDLOG_REVISION)
5448 		 && (softc->ata_iddir.entry_count > 0)) {
5449 			int num_entries, i;
5450 
5451 			num_entries = softc->ata_iddir.entry_count;
5452 			num_entries = min(num_entries,
5453 			   softc->valid_iddir_len - entries_offset);
5454 			for (i = 0; i < num_entries && i < max_entries; i++) {
5455 				if (softc->ata_iddir.entries[i] ==
5456 				    ATA_IDL_SUP_CAP)
5457 					softc->flags |= DA_FLAG_CAN_ATA_SUPCAP;
5458 				else if (softc->ata_iddir.entries[i] ==
5459 					 ATA_IDL_ZDI)
5460 					softc->flags |= DA_FLAG_CAN_ATA_ZONE;
5461 
5462 				if ((softc->flags & DA_FLAG_CAN_ATA_SUPCAP)
5463 				 && (softc->flags & DA_FLAG_CAN_ATA_ZONE))
5464 					break;
5465 			}
5466 		}
5467 	} else {
5468 		error = daerror(done_ccb, CAM_RETRY_SELTO,
5469 				SF_RETRY_UA|SF_NO_PRINT);
5470 		if (error == ERESTART)
5471 			return;
5472 		else if (error != 0) {
5473 			/*
5474 			 * If we can't get the ATA Identify Data log
5475 			 * directory, then it effectively isn't
5476 			 * supported even if the ATA Log directory
5477 			 * a non-zero number of pages present for
5478 			 * this log.
5479 			 */
5480 			softc->flags &= ~DA_FLAG_CAN_ATA_IDLOG;
5481 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5482 				/* Don't wedge this device's queue */
5483 				cam_release_devq(done_ccb->ccb_h.path,
5484 						 /*relsim_flags*/0,
5485 						 /*reduction*/0,
5486 						 /*timeout*/0,
5487 						 /*getcount_only*/0);
5488 			}
5489 		}
5490 	}
5491 
5492 	free(csio->data_ptr, M_SCSIDA);
5493 
5494 	if ((error == 0) && (softc->flags & DA_FLAG_CAN_ATA_SUPCAP)) {
5495 		softc->state = DA_STATE_PROBE_ATA_SUP;
5496 		xpt_release_ccb(done_ccb);
5497 		xpt_schedule(periph, priority);
5498 		return;
5499 	}
5500 	daprobedone(periph, done_ccb);
5501 	return;
5502 }
5503 
5504 static void
5505 dadone_probeatasup(struct cam_periph *periph, union ccb *done_ccb)
5506 {
5507 	struct da_softc *softc;
5508 	struct ccb_scsiio *csio;
5509 	u_int32_t  priority;
5510 	int error;
5511 
5512 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probeatasup\n"));
5513 
5514 	softc = (struct da_softc *)periph->softc;
5515 	priority = done_ccb->ccb_h.pinfo.priority;
5516 	csio = &done_ccb->csio;
5517 
5518 	cam_periph_assert(periph, MA_OWNED);
5519 
5520 	if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5521 		uint32_t valid_len;
5522 		size_t needed_size;
5523 		struct ata_identify_log_sup_cap *sup_cap;
5524 		error = 0;
5525 
5526 		sup_cap = (struct ata_identify_log_sup_cap *)csio->data_ptr;
5527 		valid_len = csio->dxfer_len - csio->resid;
5528 		needed_size = __offsetof(struct ata_identify_log_sup_cap,
5529 		    sup_zac_cap) + 1 + sizeof(sup_cap->sup_zac_cap);
5530 		if (valid_len >= needed_size) {
5531 			uint64_t zoned, zac_cap;
5532 
5533 			zoned = le64dec(sup_cap->zoned_cap);
5534 			if (zoned & ATA_ZONED_VALID) {
5535 				/*
5536 				 * This should have already been
5537 				 * set, because this is also in the
5538 				 * ATA identify data.
5539 				 */
5540 				if ((zoned & ATA_ZONED_MASK) ==
5541 				    ATA_SUPPORT_ZONE_HOST_AWARE)
5542 					softc->zone_mode = DA_ZONE_HOST_AWARE;
5543 				else if ((zoned & ATA_ZONED_MASK) ==
5544 				    ATA_SUPPORT_ZONE_DEV_MANAGED)
5545 					softc->zone_mode =
5546 					    DA_ZONE_DRIVE_MANAGED;
5547 			}
5548 
5549 			zac_cap = le64dec(sup_cap->sup_zac_cap);
5550 			if (zac_cap & ATA_SUP_ZAC_CAP_VALID) {
5551 				if (zac_cap & ATA_REPORT_ZONES_SUP)
5552 					softc->zone_flags |=
5553 					    DA_ZONE_FLAG_RZ_SUP;
5554 				if (zac_cap & ATA_ND_OPEN_ZONE_SUP)
5555 					softc->zone_flags |=
5556 					    DA_ZONE_FLAG_OPEN_SUP;
5557 				if (zac_cap & ATA_ND_CLOSE_ZONE_SUP)
5558 					softc->zone_flags |=
5559 					    DA_ZONE_FLAG_CLOSE_SUP;
5560 				if (zac_cap & ATA_ND_FINISH_ZONE_SUP)
5561 					softc->zone_flags |=
5562 					    DA_ZONE_FLAG_FINISH_SUP;
5563 				if (zac_cap & ATA_ND_RWP_SUP)
5564 					softc->zone_flags |=
5565 					    DA_ZONE_FLAG_RWP_SUP;
5566 			} else {
5567 				/*
5568 				 * This field was introduced in
5569 				 * ACS-4, r08 on April 28th, 2015.
5570 				 * If the drive firmware was written
5571 				 * to an earlier spec, it won't have
5572 				 * the field.  So, assume all
5573 				 * commands are supported.
5574 				 */
5575 				softc->zone_flags |= DA_ZONE_FLAG_SUP_MASK;
5576 			}
5577 		}
5578 	} else {
5579 		error = daerror(done_ccb, CAM_RETRY_SELTO,
5580 				SF_RETRY_UA|SF_NO_PRINT);
5581 		if (error == ERESTART)
5582 			return;
5583 		else if (error != 0) {
5584 			/*
5585 			 * If we can't get the ATA Identify Data
5586 			 * Supported Capabilities page, clear the
5587 			 * flag...
5588 			 */
5589 			softc->flags &= ~DA_FLAG_CAN_ATA_SUPCAP;
5590 			/*
5591 			 * And clear zone capabilities.
5592 			 */
5593 			softc->zone_flags &= ~DA_ZONE_FLAG_SUP_MASK;
5594 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5595 				/* Don't wedge this device's queue */
5596 				cam_release_devq(done_ccb->ccb_h.path,
5597 						 /*relsim_flags*/0,
5598 						 /*reduction*/0,
5599 						 /*timeout*/0,
5600 						 /*getcount_only*/0);
5601 			}
5602 		}
5603 	}
5604 
5605 	free(csio->data_ptr, M_SCSIDA);
5606 
5607 	if ((error == 0) && (softc->flags & DA_FLAG_CAN_ATA_ZONE)) {
5608 		softc->state = DA_STATE_PROBE_ATA_ZONE;
5609 		xpt_release_ccb(done_ccb);
5610 		xpt_schedule(periph, priority);
5611 		return;
5612 	}
5613 	daprobedone(periph, done_ccb);
5614 	return;
5615 }
5616 
5617 static void
5618 dadone_probeatazone(struct cam_periph *periph, union ccb *done_ccb)
5619 {
5620 	struct da_softc *softc;
5621 	struct ccb_scsiio *csio;
5622 	int error;
5623 
5624 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probeatazone\n"));
5625 
5626 	softc = (struct da_softc *)periph->softc;
5627 	csio = &done_ccb->csio;
5628 
5629 	cam_periph_assert(periph, MA_OWNED);
5630 
5631 	if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5632 		struct ata_zoned_info_log *zi_log;
5633 		uint32_t valid_len;
5634 		size_t needed_size;
5635 
5636 		zi_log = (struct ata_zoned_info_log *)csio->data_ptr;
5637 
5638 		valid_len = csio->dxfer_len - csio->resid;
5639 		needed_size = __offsetof(struct ata_zoned_info_log,
5640 		    version_info) + 1 + sizeof(zi_log->version_info);
5641 		if (valid_len >= needed_size) {
5642 			uint64_t tmpvar;
5643 
5644 			tmpvar = le64dec(zi_log->zoned_cap);
5645 			if (tmpvar & ATA_ZDI_CAP_VALID) {
5646 				if (tmpvar & ATA_ZDI_CAP_URSWRZ)
5647 					softc->zone_flags |=
5648 					    DA_ZONE_FLAG_URSWRZ;
5649 				else
5650 					softc->zone_flags &=
5651 					    ~DA_ZONE_FLAG_URSWRZ;
5652 			}
5653 			tmpvar = le64dec(zi_log->optimal_seq_zones);
5654 			if (tmpvar & ATA_ZDI_OPT_SEQ_VALID) {
5655 				softc->zone_flags |= DA_ZONE_FLAG_OPT_SEQ_SET;
5656 				softc->optimal_seq_zones = (tmpvar &
5657 				    ATA_ZDI_OPT_SEQ_MASK);
5658 			} else {
5659 				softc->zone_flags &= ~DA_ZONE_FLAG_OPT_SEQ_SET;
5660 				softc->optimal_seq_zones = 0;
5661 			}
5662 
5663 			tmpvar =le64dec(zi_log->optimal_nonseq_zones);
5664 			if (tmpvar & ATA_ZDI_OPT_NS_VALID) {
5665 				softc->zone_flags |=
5666 				    DA_ZONE_FLAG_OPT_NONSEQ_SET;
5667 				softc->optimal_nonseq_zones =
5668 				    (tmpvar & ATA_ZDI_OPT_NS_MASK);
5669 			} else {
5670 				softc->zone_flags &=
5671 				    ~DA_ZONE_FLAG_OPT_NONSEQ_SET;
5672 				softc->optimal_nonseq_zones = 0;
5673 			}
5674 
5675 			tmpvar = le64dec(zi_log->max_seq_req_zones);
5676 			if (tmpvar & ATA_ZDI_MAX_SEQ_VALID) {
5677 				softc->zone_flags |= DA_ZONE_FLAG_MAX_SEQ_SET;
5678 				softc->max_seq_zones =
5679 				    (tmpvar & ATA_ZDI_MAX_SEQ_MASK);
5680 			} else {
5681 				softc->zone_flags &= ~DA_ZONE_FLAG_MAX_SEQ_SET;
5682 				softc->max_seq_zones = 0;
5683 			}
5684 		}
5685 	} else {
5686 		error = daerror(done_ccb, CAM_RETRY_SELTO,
5687 				SF_RETRY_UA|SF_NO_PRINT);
5688 		if (error == ERESTART)
5689 			return;
5690 		else if (error != 0) {
5691 			softc->flags &= ~DA_FLAG_CAN_ATA_ZONE;
5692 			softc->flags &= ~DA_ZONE_FLAG_SET_MASK;
5693 
5694 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5695 				/* Don't wedge this device's queue */
5696 				cam_release_devq(done_ccb->ccb_h.path,
5697 						 /*relsim_flags*/0,
5698 						 /*reduction*/0,
5699 						 /*timeout*/0,
5700 						 /*getcount_only*/0);
5701 			}
5702 		}
5703 
5704 	}
5705 
5706 	free(csio->data_ptr, M_SCSIDA);
5707 
5708 	daprobedone(periph, done_ccb);
5709 	return;
5710 }
5711 
5712 static void
5713 dadone_probezone(struct cam_periph *periph, union ccb *done_ccb)
5714 {
5715 	struct da_softc *softc;
5716 	struct ccb_scsiio *csio;
5717 	int error;
5718 
5719 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_probezone\n"));
5720 
5721 	softc = (struct da_softc *)periph->softc;
5722 	csio = &done_ccb->csio;
5723 
5724 	cam_periph_assert(periph, MA_OWNED);
5725 
5726 	if ((csio->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_CMP) {
5727 		uint32_t valid_len;
5728 		size_t needed_len;
5729 		struct scsi_vpd_zoned_bdc *zoned_bdc;
5730 
5731 		error = 0;
5732 		zoned_bdc = (struct scsi_vpd_zoned_bdc *)csio->data_ptr;
5733 		valid_len = csio->dxfer_len - csio->resid;
5734 		needed_len = __offsetof(struct scsi_vpd_zoned_bdc,
5735 		    max_seq_req_zones) + 1 +
5736 		    sizeof(zoned_bdc->max_seq_req_zones);
5737 		if ((valid_len >= needed_len)
5738 		 && (scsi_2btoul(zoned_bdc->page_length) >= SVPD_ZBDC_PL)) {
5739 			if (zoned_bdc->flags & SVPD_ZBDC_URSWRZ)
5740 				softc->zone_flags |= DA_ZONE_FLAG_URSWRZ;
5741 			else
5742 				softc->zone_flags &= ~DA_ZONE_FLAG_URSWRZ;
5743 			softc->optimal_seq_zones =
5744 			    scsi_4btoul(zoned_bdc->optimal_seq_zones);
5745 			softc->zone_flags |= DA_ZONE_FLAG_OPT_SEQ_SET;
5746 			softc->optimal_nonseq_zones = scsi_4btoul(
5747 			    zoned_bdc->optimal_nonseq_zones);
5748 			softc->zone_flags |= DA_ZONE_FLAG_OPT_NONSEQ_SET;
5749 			softc->max_seq_zones =
5750 			    scsi_4btoul(zoned_bdc->max_seq_req_zones);
5751 			softc->zone_flags |= DA_ZONE_FLAG_MAX_SEQ_SET;
5752 		}
5753 		/*
5754 		 * All of the zone commands are mandatory for SCSI
5755 		 * devices.
5756 		 *
5757 		 * XXX KDM this is valid as of September 2015.
5758 		 * Re-check this assumption once the SAT spec is
5759 		 * updated to support SCSI ZBC to ATA ZAC mapping.
5760 		 * Since ATA allows zone commands to be reported
5761 		 * as supported or not, this may not necessarily
5762 		 * be true for an ATA device behind a SAT (SCSI to
5763 		 * ATA Translation) layer.
5764 		 */
5765 		softc->zone_flags |= DA_ZONE_FLAG_SUP_MASK;
5766 	} else {
5767 		error = daerror(done_ccb, CAM_RETRY_SELTO,
5768 				SF_RETRY_UA|SF_NO_PRINT);
5769 		if (error == ERESTART)
5770 			return;
5771 		else if (error != 0) {
5772 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
5773 				/* Don't wedge this device's queue */
5774 				cam_release_devq(done_ccb->ccb_h.path,
5775 						 /*relsim_flags*/0,
5776 						 /*reduction*/0,
5777 						 /*timeout*/0,
5778 						 /*getcount_only*/0);
5779 			}
5780 		}
5781 	}
5782 
5783 	free(csio->data_ptr, M_SCSIDA);
5784 
5785 	daprobedone(periph, done_ccb);
5786 	return;
5787 }
5788 
5789 static void
5790 dadone_tur(struct cam_periph *periph, union ccb *done_ccb)
5791 {
5792 	struct da_softc *softc;
5793 	struct ccb_scsiio *csio;
5794 
5795 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("dadone_tur\n"));
5796 
5797 	softc = (struct da_softc *)periph->softc;
5798 	csio = &done_ccb->csio;
5799 
5800 	cam_periph_assert(periph, MA_OWNED);
5801 
5802 	if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
5803 
5804 		if (daerror(done_ccb, CAM_RETRY_SELTO,
5805 		    SF_RETRY_UA | SF_NO_RECOVERY | SF_NO_PRINT) == ERESTART)
5806 			return;	/* Will complete again, keep reference */
5807 		if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
5808 			cam_release_devq(done_ccb->ccb_h.path,
5809 					 /*relsim_flags*/0,
5810 					 /*reduction*/0,
5811 					 /*timeout*/0,
5812 					 /*getcount_only*/0);
5813 	}
5814 	xpt_release_ccb(done_ccb);
5815 	softc->flags &= ~DA_FLAG_TUR_PENDING;
5816 	da_periph_release_locked(periph, DA_REF_TUR);
5817 	return;
5818 }
5819 
5820 static void
5821 dareprobe(struct cam_periph *periph)
5822 {
5823 	struct da_softc	  *softc;
5824 	int status;
5825 
5826 	softc = (struct da_softc *)periph->softc;
5827 
5828 	/* Probe in progress; don't interfere. */
5829 	if (softc->state != DA_STATE_NORMAL)
5830 		return;
5831 
5832 	status = da_periph_acquire(periph, DA_REF_REPROBE);
5833 	KASSERT(status == 0, ("dareprobe: cam_periph_acquire failed"));
5834 
5835 	softc->state = DA_STATE_PROBE_WP;
5836 	xpt_schedule(periph, CAM_PRIORITY_DEV);
5837 }
5838 
5839 static int
5840 daerror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags)
5841 {
5842 	struct da_softc	  *softc;
5843 	struct cam_periph *periph;
5844 	int error, error_code, sense_key, asc, ascq;
5845 
5846 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
5847 	if (ccb->csio.bio != NULL)
5848 		biotrack(ccb->csio.bio, __func__);
5849 #endif
5850 
5851 	periph = xpt_path_periph(ccb->ccb_h.path);
5852 	softc = (struct da_softc *)periph->softc;
5853 
5854 	cam_periph_assert(periph, MA_OWNED);
5855 
5856 	/*
5857 	 * Automatically detect devices that do not support
5858 	 * READ(6)/WRITE(6) and upgrade to using 10 byte cdbs.
5859 	 */
5860 	error = 0;
5861 	if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INVALID) {
5862 		error = cmd6workaround(ccb);
5863 	} else if (scsi_extract_sense_ccb(ccb,
5864 	    &error_code, &sense_key, &asc, &ascq)) {
5865 		if (sense_key == SSD_KEY_ILLEGAL_REQUEST)
5866 			error = cmd6workaround(ccb);
5867 		/*
5868 		 * If the target replied with CAPACITY DATA HAS CHANGED UA,
5869 		 * query the capacity and notify upper layers.
5870 		 */
5871 		else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
5872 		    asc == 0x2A && ascq == 0x09) {
5873 			xpt_print(periph->path, "Capacity data has changed\n");
5874 			softc->flags &= ~DA_FLAG_PROBED;
5875 			dareprobe(periph);
5876 			sense_flags |= SF_NO_PRINT;
5877 		} else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
5878 		    asc == 0x28 && ascq == 0x00) {
5879 			softc->flags &= ~DA_FLAG_PROBED;
5880 			disk_media_changed(softc->disk, M_NOWAIT);
5881 		} else if (sense_key == SSD_KEY_UNIT_ATTENTION &&
5882 		    asc == 0x3F && ascq == 0x03) {
5883 			xpt_print(periph->path, "INQUIRY data has changed\n");
5884 			softc->flags &= ~DA_FLAG_PROBED;
5885 			dareprobe(periph);
5886 			sense_flags |= SF_NO_PRINT;
5887 		} else if (sense_key == SSD_KEY_NOT_READY &&
5888 		    asc == 0x3a && (softc->flags & DA_FLAG_PACK_INVALID) == 0) {
5889 			softc->flags |= DA_FLAG_PACK_INVALID;
5890 			disk_media_gone(softc->disk, M_NOWAIT);
5891 		}
5892 	}
5893 	if (error == ERESTART)
5894 		return (ERESTART);
5895 
5896 #ifdef CAM_IO_STATS
5897 	switch (ccb->ccb_h.status & CAM_STATUS_MASK) {
5898 	case CAM_CMD_TIMEOUT:
5899 		softc->timeouts++;
5900 		break;
5901 	case CAM_REQ_ABORTED:
5902 	case CAM_REQ_CMP_ERR:
5903 	case CAM_REQ_TERMIO:
5904 	case CAM_UNREC_HBA_ERROR:
5905 	case CAM_DATA_RUN_ERR:
5906 		softc->errors++;
5907 		break;
5908 	default:
5909 		break;
5910 	}
5911 #endif
5912 
5913 	/*
5914 	 * XXX
5915 	 * Until we have a better way of doing pack validation,
5916 	 * don't treat UAs as errors.
5917 	 */
5918 	sense_flags |= SF_RETRY_UA;
5919 
5920 	if (softc->quirks & DA_Q_RETRY_BUSY)
5921 		sense_flags |= SF_RETRY_BUSY;
5922 	return(cam_periph_error(ccb, cam_flags, sense_flags));
5923 }
5924 
5925 static void
5926 damediapoll(void *arg)
5927 {
5928 	struct cam_periph *periph = arg;
5929 	struct da_softc *softc = periph->softc;
5930 
5931 	if (!cam_iosched_has_work_flags(softc->cam_iosched, DA_WORK_TUR) &&
5932 	    (softc->flags & DA_FLAG_TUR_PENDING) == 0 &&
5933 	    LIST_EMPTY(&softc->pending_ccbs)) {
5934 		if (da_periph_acquire(periph, DA_REF_TUR) == 0) {
5935 			cam_iosched_set_work_flags(softc->cam_iosched, DA_WORK_TUR);
5936 			daschedule(periph);
5937 		}
5938 	}
5939 	/* Queue us up again */
5940 	if (da_poll_period != 0)
5941 		callout_schedule(&softc->mediapoll_c, da_poll_period * hz);
5942 }
5943 
5944 static void
5945 daprevent(struct cam_periph *periph, int action)
5946 {
5947 	struct	da_softc *softc;
5948 	union	ccb *ccb;
5949 	int	error;
5950 
5951 	cam_periph_assert(periph, MA_OWNED);
5952 	softc = (struct da_softc *)periph->softc;
5953 
5954 	if (((action == PR_ALLOW)
5955 	  && (softc->flags & DA_FLAG_PACK_LOCKED) == 0)
5956 	 || ((action == PR_PREVENT)
5957 	  && (softc->flags & DA_FLAG_PACK_LOCKED) != 0)) {
5958 		return;
5959 	}
5960 
5961 	ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
5962 
5963 	scsi_prevent(&ccb->csio,
5964 		     /*retries*/1,
5965 		     /*cbcfp*/NULL,
5966 		     MSG_SIMPLE_Q_TAG,
5967 		     action,
5968 		     SSD_FULL_SIZE,
5969 		     5000);
5970 
5971 	error = cam_periph_runccb(ccb, daerror, CAM_RETRY_SELTO,
5972 	    SF_RETRY_UA | SF_NO_PRINT, softc->disk->d_devstat);
5973 
5974 	if (error == 0) {
5975 		if (action == PR_ALLOW)
5976 			softc->flags &= ~DA_FLAG_PACK_LOCKED;
5977 		else
5978 			softc->flags |= DA_FLAG_PACK_LOCKED;
5979 	}
5980 
5981 	xpt_release_ccb(ccb);
5982 }
5983 
5984 static void
5985 dasetgeom(struct cam_periph *periph, uint32_t block_len, uint64_t maxsector,
5986 	  struct scsi_read_capacity_data_long *rcaplong, size_t rcap_len)
5987 {
5988 	struct ccb_calc_geometry ccg;
5989 	struct da_softc *softc;
5990 	struct disk_params *dp;
5991 	u_int lbppbe, lalba;
5992 	int error;
5993 
5994 	softc = (struct da_softc *)periph->softc;
5995 
5996 	dp = &softc->params;
5997 	dp->secsize = block_len;
5998 	dp->sectors = maxsector + 1;
5999 	if (rcaplong != NULL) {
6000 		lbppbe = rcaplong->prot_lbppbe & SRC16_LBPPBE;
6001 		lalba = scsi_2btoul(rcaplong->lalba_lbp);
6002 		lalba &= SRC16_LALBA_A;
6003 		if (rcaplong->prot & SRC16_PROT_EN)
6004 			softc->p_type = ((rcaplong->prot & SRC16_P_TYPE) >>
6005 			    SRC16_P_TYPE_SHIFT) + 1;
6006 		else
6007 			softc->p_type = 0;
6008 	} else {
6009 		lbppbe = 0;
6010 		lalba = 0;
6011 		softc->p_type = 0;
6012 	}
6013 
6014 	if (lbppbe > 0) {
6015 		dp->stripesize = block_len << lbppbe;
6016 		dp->stripeoffset = (dp->stripesize - block_len * lalba) %
6017 		    dp->stripesize;
6018 	} else if (softc->quirks & DA_Q_4K) {
6019 		dp->stripesize = 4096;
6020 		dp->stripeoffset = 0;
6021 	} else if (softc->unmap_gran != 0) {
6022 		dp->stripesize = block_len * softc->unmap_gran;
6023 		dp->stripeoffset = (dp->stripesize - block_len *
6024 		    softc->unmap_gran_align) % dp->stripesize;
6025 	} else {
6026 		dp->stripesize = 0;
6027 		dp->stripeoffset = 0;
6028 	}
6029 	/*
6030 	 * Have the controller provide us with a geometry
6031 	 * for this disk.  The only time the geometry
6032 	 * matters is when we boot and the controller
6033 	 * is the only one knowledgeable enough to come
6034 	 * up with something that will make this a bootable
6035 	 * device.
6036 	 */
6037 	xpt_setup_ccb(&ccg.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
6038 	ccg.ccb_h.func_code = XPT_CALC_GEOMETRY;
6039 	ccg.block_size = dp->secsize;
6040 	ccg.volume_size = dp->sectors;
6041 	ccg.heads = 0;
6042 	ccg.secs_per_track = 0;
6043 	ccg.cylinders = 0;
6044 	xpt_action((union ccb*)&ccg);
6045 	if ((ccg.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
6046 		/*
6047 		 * We don't know what went wrong here- but just pick
6048 		 * a geometry so we don't have nasty things like divide
6049 		 * by zero.
6050 		 */
6051 		dp->heads = 255;
6052 		dp->secs_per_track = 255;
6053 		dp->cylinders = dp->sectors / (255 * 255);
6054 		if (dp->cylinders == 0) {
6055 			dp->cylinders = 1;
6056 		}
6057 	} else {
6058 		dp->heads = ccg.heads;
6059 		dp->secs_per_track = ccg.secs_per_track;
6060 		dp->cylinders = ccg.cylinders;
6061 	}
6062 
6063 	/*
6064 	 * If the user supplied a read capacity buffer, and if it is
6065 	 * different than the previous buffer, update the data in the EDT.
6066 	 * If it's the same, we don't bother.  This avoids sending an
6067 	 * update every time someone opens this device.
6068 	 */
6069 	if ((rcaplong != NULL)
6070 	 && (bcmp(rcaplong, &softc->rcaplong,
6071 		  min(sizeof(softc->rcaplong), rcap_len)) != 0)) {
6072 		struct ccb_dev_advinfo cdai;
6073 
6074 		xpt_setup_ccb(&cdai.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
6075 		cdai.ccb_h.func_code = XPT_DEV_ADVINFO;
6076 		cdai.buftype = CDAI_TYPE_RCAPLONG;
6077 		cdai.flags = CDAI_FLAG_STORE;
6078 		cdai.bufsiz = rcap_len;
6079 		cdai.buf = (uint8_t *)rcaplong;
6080 		xpt_action((union ccb *)&cdai);
6081 		if ((cdai.ccb_h.status & CAM_DEV_QFRZN) != 0)
6082 			cam_release_devq(cdai.ccb_h.path, 0, 0, 0, FALSE);
6083 		if (cdai.ccb_h.status != CAM_REQ_CMP) {
6084 			xpt_print(periph->path, "%s: failed to set read "
6085 				  "capacity advinfo\n", __func__);
6086 			/* Use cam_error_print() to decode the status */
6087 			cam_error_print((union ccb *)&cdai, CAM_ESF_CAM_STATUS,
6088 					CAM_EPF_ALL);
6089 		} else {
6090 			bcopy(rcaplong, &softc->rcaplong,
6091 			      min(sizeof(softc->rcaplong), rcap_len));
6092 		}
6093 	}
6094 
6095 	softc->disk->d_sectorsize = softc->params.secsize;
6096 	softc->disk->d_mediasize = softc->params.secsize * (off_t)softc->params.sectors;
6097 	softc->disk->d_stripesize = softc->params.stripesize;
6098 	softc->disk->d_stripeoffset = softc->params.stripeoffset;
6099 	/* XXX: these are not actually "firmware" values, so they may be wrong */
6100 	softc->disk->d_fwsectors = softc->params.secs_per_track;
6101 	softc->disk->d_fwheads = softc->params.heads;
6102 	softc->disk->d_devstat->block_size = softc->params.secsize;
6103 	softc->disk->d_devstat->flags &= ~DEVSTAT_BS_UNAVAILABLE;
6104 
6105 	error = disk_resize(softc->disk, M_NOWAIT);
6106 	if (error != 0)
6107 		xpt_print(periph->path, "disk_resize(9) failed, error = %d\n", error);
6108 }
6109 
6110 static void
6111 dasendorderedtag(void *arg)
6112 {
6113 	struct cam_periph *periph = arg;
6114 	struct da_softc *softc = periph->softc;
6115 
6116 	cam_periph_assert(periph, MA_OWNED);
6117 	if (da_send_ordered) {
6118 		if (!LIST_EMPTY(&softc->pending_ccbs)) {
6119 			if ((softc->flags & DA_FLAG_WAS_OTAG) == 0)
6120 				softc->flags |= DA_FLAG_NEED_OTAG;
6121 			softc->flags &= ~DA_FLAG_WAS_OTAG;
6122 		}
6123 	}
6124 
6125 	/* Queue us up again */
6126 	callout_reset(&softc->sendordered_c,
6127 	    (da_default_timeout * hz) / DA_ORDEREDTAG_INTERVAL,
6128 	    dasendorderedtag, periph);
6129 }
6130 
6131 /*
6132  * Step through all DA peripheral drivers, and if the device is still open,
6133  * sync the disk cache to physical media.
6134  */
6135 static void
6136 dashutdown(void * arg, int howto)
6137 {
6138 	struct cam_periph *periph;
6139 	struct da_softc *softc;
6140 	union ccb *ccb;
6141 	int error;
6142 
6143 	CAM_PERIPH_FOREACH(periph, &dadriver) {
6144 		softc = (struct da_softc *)periph->softc;
6145 		if (SCHEDULER_STOPPED()) {
6146 			/* If we paniced with the lock held, do not recurse. */
6147 			if (!cam_periph_owned(periph) &&
6148 			    (softc->flags & DA_FLAG_OPEN)) {
6149 				dadump(softc->disk, NULL, 0, 0, 0);
6150 			}
6151 			continue;
6152 		}
6153 		cam_periph_lock(periph);
6154 
6155 		/*
6156 		 * We only sync the cache if the drive is still open, and
6157 		 * if the drive is capable of it..
6158 		 */
6159 		if (((softc->flags & DA_FLAG_OPEN) == 0)
6160 		 || (softc->quirks & DA_Q_NO_SYNC_CACHE)) {
6161 			cam_periph_unlock(periph);
6162 			continue;
6163 		}
6164 
6165 		ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
6166 		scsi_synchronize_cache(&ccb->csio,
6167 				       /*retries*/0,
6168 				       /*cbfcnp*/NULL,
6169 				       MSG_SIMPLE_Q_TAG,
6170 				       /*begin_lba*/0, /* whole disk */
6171 				       /*lb_count*/0,
6172 				       SSD_FULL_SIZE,
6173 				       60 * 60 * 1000);
6174 
6175 		error = cam_periph_runccb(ccb, daerror, /*cam_flags*/0,
6176 		    /*sense_flags*/ SF_NO_RECOVERY | SF_NO_RETRY | SF_QUIET_IR,
6177 		    softc->disk->d_devstat);
6178 		if (error != 0)
6179 			xpt_print(periph->path, "Synchronize cache failed\n");
6180 		xpt_release_ccb(ccb);
6181 		cam_periph_unlock(periph);
6182 	}
6183 }
6184 
6185 #else /* !_KERNEL */
6186 
6187 /*
6188  * XXX These are only left out of the kernel build to silence warnings.  If,
6189  * for some reason these functions are used in the kernel, the ifdefs should
6190  * be moved so they are included both in the kernel and userland.
6191  */
6192 void
6193 scsi_format_unit(struct ccb_scsiio *csio, u_int32_t retries,
6194 		 void (*cbfcnp)(struct cam_periph *, union ccb *),
6195 		 u_int8_t tag_action, u_int8_t byte2, u_int16_t ileave,
6196 		 u_int8_t *data_ptr, u_int32_t dxfer_len, u_int8_t sense_len,
6197 		 u_int32_t timeout)
6198 {
6199 	struct scsi_format_unit *scsi_cmd;
6200 
6201 	scsi_cmd = (struct scsi_format_unit *)&csio->cdb_io.cdb_bytes;
6202 	scsi_cmd->opcode = FORMAT_UNIT;
6203 	scsi_cmd->byte2 = byte2;
6204 	scsi_ulto2b(ileave, scsi_cmd->interleave);
6205 
6206 	cam_fill_csio(csio,
6207 		      retries,
6208 		      cbfcnp,
6209 		      /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
6210 		      tag_action,
6211 		      data_ptr,
6212 		      dxfer_len,
6213 		      sense_len,
6214 		      sizeof(*scsi_cmd),
6215 		      timeout);
6216 }
6217 
6218 void
6219 scsi_read_defects(struct ccb_scsiio *csio, uint32_t retries,
6220 		  void (*cbfcnp)(struct cam_periph *, union ccb *),
6221 		  uint8_t tag_action, uint8_t list_format,
6222 		  uint32_t addr_desc_index, uint8_t *data_ptr,
6223 		  uint32_t dxfer_len, int minimum_cmd_size,
6224 		  uint8_t sense_len, uint32_t timeout)
6225 {
6226 	uint8_t cdb_len;
6227 
6228 	/*
6229 	 * These conditions allow using the 10 byte command.  Otherwise we
6230 	 * need to use the 12 byte command.
6231 	 */
6232 	if ((minimum_cmd_size <= 10)
6233 	 && (addr_desc_index == 0)
6234 	 && (dxfer_len <= SRDD10_MAX_LENGTH)) {
6235 		struct scsi_read_defect_data_10 *cdb10;
6236 
6237 		cdb10 = (struct scsi_read_defect_data_10 *)
6238 			&csio->cdb_io.cdb_bytes;
6239 
6240 		cdb_len = sizeof(*cdb10);
6241 		bzero(cdb10, cdb_len);
6242                 cdb10->opcode = READ_DEFECT_DATA_10;
6243                 cdb10->format = list_format;
6244                 scsi_ulto2b(dxfer_len, cdb10->alloc_length);
6245 	} else {
6246 		struct scsi_read_defect_data_12 *cdb12;
6247 
6248 		cdb12 = (struct scsi_read_defect_data_12 *)
6249 			&csio->cdb_io.cdb_bytes;
6250 
6251 		cdb_len = sizeof(*cdb12);
6252 		bzero(cdb12, cdb_len);
6253                 cdb12->opcode = READ_DEFECT_DATA_12;
6254                 cdb12->format = list_format;
6255                 scsi_ulto4b(dxfer_len, cdb12->alloc_length);
6256 		scsi_ulto4b(addr_desc_index, cdb12->address_descriptor_index);
6257 	}
6258 
6259 	cam_fill_csio(csio,
6260 		      retries,
6261 		      cbfcnp,
6262 		      /*flags*/ CAM_DIR_IN,
6263 		      tag_action,
6264 		      data_ptr,
6265 		      dxfer_len,
6266 		      sense_len,
6267 		      cdb_len,
6268 		      timeout);
6269 }
6270 
6271 void
6272 scsi_sanitize(struct ccb_scsiio *csio, u_int32_t retries,
6273 	      void (*cbfcnp)(struct cam_periph *, union ccb *),
6274 	      u_int8_t tag_action, u_int8_t byte2, u_int16_t control,
6275 	      u_int8_t *data_ptr, u_int32_t dxfer_len, u_int8_t sense_len,
6276 	      u_int32_t timeout)
6277 {
6278 	struct scsi_sanitize *scsi_cmd;
6279 
6280 	scsi_cmd = (struct scsi_sanitize *)&csio->cdb_io.cdb_bytes;
6281 	scsi_cmd->opcode = SANITIZE;
6282 	scsi_cmd->byte2 = byte2;
6283 	scsi_cmd->control = control;
6284 	scsi_ulto2b(dxfer_len, scsi_cmd->length);
6285 
6286 	cam_fill_csio(csio,
6287 		      retries,
6288 		      cbfcnp,
6289 		      /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
6290 		      tag_action,
6291 		      data_ptr,
6292 		      dxfer_len,
6293 		      sense_len,
6294 		      sizeof(*scsi_cmd),
6295 		      timeout);
6296 }
6297 
6298 #endif /* _KERNEL */
6299 
6300 void
6301 scsi_zbc_out(struct ccb_scsiio *csio, uint32_t retries,
6302 	     void (*cbfcnp)(struct cam_periph *, union ccb *),
6303 	     uint8_t tag_action, uint8_t service_action, uint64_t zone_id,
6304 	     uint8_t zone_flags, uint8_t *data_ptr, uint32_t dxfer_len,
6305 	     uint8_t sense_len, uint32_t timeout)
6306 {
6307 	struct scsi_zbc_out *scsi_cmd;
6308 
6309 	scsi_cmd = (struct scsi_zbc_out *)&csio->cdb_io.cdb_bytes;
6310 	scsi_cmd->opcode = ZBC_OUT;
6311 	scsi_cmd->service_action = service_action;
6312 	scsi_u64to8b(zone_id, scsi_cmd->zone_id);
6313 	scsi_cmd->zone_flags = zone_flags;
6314 
6315 	cam_fill_csio(csio,
6316 		      retries,
6317 		      cbfcnp,
6318 		      /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
6319 		      tag_action,
6320 		      data_ptr,
6321 		      dxfer_len,
6322 		      sense_len,
6323 		      sizeof(*scsi_cmd),
6324 		      timeout);
6325 }
6326 
6327 void
6328 scsi_zbc_in(struct ccb_scsiio *csio, uint32_t retries,
6329 	    void (*cbfcnp)(struct cam_periph *, union ccb *),
6330 	    uint8_t tag_action, uint8_t service_action, uint64_t zone_start_lba,
6331 	    uint8_t zone_options, uint8_t *data_ptr, uint32_t dxfer_len,
6332 	    uint8_t sense_len, uint32_t timeout)
6333 {
6334 	struct scsi_zbc_in *scsi_cmd;
6335 
6336 	scsi_cmd = (struct scsi_zbc_in *)&csio->cdb_io.cdb_bytes;
6337 	scsi_cmd->opcode = ZBC_IN;
6338 	scsi_cmd->service_action = service_action;
6339 	scsi_ulto4b(dxfer_len, scsi_cmd->length);
6340 	scsi_u64to8b(zone_start_lba, scsi_cmd->zone_start_lba);
6341 	scsi_cmd->zone_options = zone_options;
6342 
6343 	cam_fill_csio(csio,
6344 		      retries,
6345 		      cbfcnp,
6346 		      /*flags*/ (dxfer_len > 0) ? CAM_DIR_IN : CAM_DIR_NONE,
6347 		      tag_action,
6348 		      data_ptr,
6349 		      dxfer_len,
6350 		      sense_len,
6351 		      sizeof(*scsi_cmd),
6352 		      timeout);
6353 
6354 }
6355 
6356 int
6357 scsi_ata_zac_mgmt_out(struct ccb_scsiio *csio, uint32_t retries,
6358 		      void (*cbfcnp)(struct cam_periph *, union ccb *),
6359 		      uint8_t tag_action, int use_ncq,
6360 		      uint8_t zm_action, uint64_t zone_id, uint8_t zone_flags,
6361 		      uint8_t *data_ptr, uint32_t dxfer_len,
6362 		      uint8_t *cdb_storage, size_t cdb_storage_len,
6363 		      uint8_t sense_len, uint32_t timeout)
6364 {
6365 	uint8_t command_out, protocol, ata_flags;
6366 	uint16_t features_out;
6367 	uint32_t sectors_out, auxiliary;
6368 	int retval;
6369 
6370 	retval = 0;
6371 
6372 	if (use_ncq == 0) {
6373 		command_out = ATA_ZAC_MANAGEMENT_OUT;
6374 		features_out = (zm_action & 0xf) | (zone_flags << 8);
6375 		ata_flags = AP_FLAG_BYT_BLOK_BLOCKS;
6376 		if (dxfer_len == 0) {
6377 			protocol = AP_PROTO_NON_DATA;
6378 			ata_flags |= AP_FLAG_TLEN_NO_DATA;
6379 			sectors_out = 0;
6380 		} else {
6381 			protocol = AP_PROTO_DMA;
6382 			ata_flags |= AP_FLAG_TLEN_SECT_CNT |
6383 				     AP_FLAG_TDIR_TO_DEV;
6384 			sectors_out = ((dxfer_len >> 9) & 0xffff);
6385 		}
6386 		auxiliary = 0;
6387 	} else {
6388 		ata_flags = AP_FLAG_BYT_BLOK_BLOCKS;
6389 		if (dxfer_len == 0) {
6390 			command_out = ATA_NCQ_NON_DATA;
6391 			features_out = ATA_NCQ_ZAC_MGMT_OUT;
6392 			/*
6393 			 * We're assuming the SCSI to ATA translation layer
6394 			 * will set the NCQ tag number in the tag field.
6395 			 * That isn't clear from the SAT-4 spec (as of rev 05).
6396 			 */
6397 			sectors_out = 0;
6398 			ata_flags |= AP_FLAG_TLEN_NO_DATA;
6399 		} else {
6400 			command_out = ATA_SEND_FPDMA_QUEUED;
6401 			/*
6402 			 * Note that we're defaulting to normal priority,
6403 			 * and assuming that the SCSI to ATA translation
6404 			 * layer will insert the NCQ tag number in the tag
6405 			 * field.  That isn't clear in the SAT-4 spec (as
6406 			 * of rev 05).
6407 			 */
6408 			sectors_out = ATA_SFPDMA_ZAC_MGMT_OUT << 8;
6409 
6410 			ata_flags |= AP_FLAG_TLEN_FEAT |
6411 				     AP_FLAG_TDIR_TO_DEV;
6412 
6413 			/*
6414 			 * For SEND FPDMA QUEUED, the transfer length is
6415 			 * encoded in the FEATURE register, and 0 means
6416 			 * that 65536 512 byte blocks are to be tranferred.
6417 			 * In practice, it seems unlikely that we'll see
6418 			 * a transfer that large, and it may confuse the
6419 			 * the SAT layer, because generally that means that
6420 			 * 0 bytes should be transferred.
6421 			 */
6422 			if (dxfer_len == (65536 * 512)) {
6423 				features_out = 0;
6424 			} else if (dxfer_len <= (65535 * 512)) {
6425 				features_out = ((dxfer_len >> 9) & 0xffff);
6426 			} else {
6427 				/* The transfer is too big. */
6428 				retval = 1;
6429 				goto bailout;
6430 			}
6431 
6432 		}
6433 
6434 		auxiliary = (zm_action & 0xf) | (zone_flags << 8);
6435 		protocol = AP_PROTO_FPDMA;
6436 	}
6437 
6438 	protocol |= AP_EXTEND;
6439 
6440 	retval = scsi_ata_pass(csio,
6441 	    retries,
6442 	    cbfcnp,
6443 	    /*flags*/ (dxfer_len > 0) ? CAM_DIR_OUT : CAM_DIR_NONE,
6444 	    tag_action,
6445 	    /*protocol*/ protocol,
6446 	    /*ata_flags*/ ata_flags,
6447 	    /*features*/ features_out,
6448 	    /*sector_count*/ sectors_out,
6449 	    /*lba*/ zone_id,
6450 	    /*command*/ command_out,
6451 	    /*device*/ 0,
6452 	    /*icc*/ 0,
6453 	    /*auxiliary*/ auxiliary,
6454 	    /*control*/ 0,
6455 	    /*data_ptr*/ data_ptr,
6456 	    /*dxfer_len*/ dxfer_len,
6457 	    /*cdb_storage*/ cdb_storage,
6458 	    /*cdb_storage_len*/ cdb_storage_len,
6459 	    /*minimum_cmd_size*/ 0,
6460 	    /*sense_len*/ SSD_FULL_SIZE,
6461 	    /*timeout*/ timeout);
6462 
6463 bailout:
6464 
6465 	return (retval);
6466 }
6467 
6468 int
6469 scsi_ata_zac_mgmt_in(struct ccb_scsiio *csio, uint32_t retries,
6470 		     void (*cbfcnp)(struct cam_periph *, union ccb *),
6471 		     uint8_t tag_action, int use_ncq,
6472 		     uint8_t zm_action, uint64_t zone_id, uint8_t zone_flags,
6473 		     uint8_t *data_ptr, uint32_t dxfer_len,
6474 		     uint8_t *cdb_storage, size_t cdb_storage_len,
6475 		     uint8_t sense_len, uint32_t timeout)
6476 {
6477 	uint8_t command_out, protocol;
6478 	uint16_t features_out, sectors_out;
6479 	uint32_t auxiliary;
6480 	int ata_flags;
6481 	int retval;
6482 
6483 	retval = 0;
6484 	ata_flags = AP_FLAG_TDIR_FROM_DEV | AP_FLAG_BYT_BLOK_BLOCKS;
6485 
6486 	if (use_ncq == 0) {
6487 		command_out = ATA_ZAC_MANAGEMENT_IN;
6488 		/* XXX KDM put a macro here */
6489 		features_out = (zm_action & 0xf) | (zone_flags << 8);
6490 		sectors_out = dxfer_len >> 9; /* XXX KDM macro */
6491 		protocol = AP_PROTO_DMA;
6492 		ata_flags |= AP_FLAG_TLEN_SECT_CNT;
6493 		auxiliary = 0;
6494 	} else {
6495 		ata_flags |= AP_FLAG_TLEN_FEAT;
6496 
6497 		command_out = ATA_RECV_FPDMA_QUEUED;
6498 		sectors_out = ATA_RFPDMA_ZAC_MGMT_IN << 8;
6499 
6500 		/*
6501 		 * For RECEIVE FPDMA QUEUED, the transfer length is
6502 		 * encoded in the FEATURE register, and 0 means
6503 		 * that 65536 512 byte blocks are to be tranferred.
6504 		 * In practice, it seems unlikely that we'll see
6505 		 * a transfer that large, and it may confuse the
6506 		 * the SAT layer, because generally that means that
6507 		 * 0 bytes should be transferred.
6508 		 */
6509 		if (dxfer_len == (65536 * 512)) {
6510 			features_out = 0;
6511 		} else if (dxfer_len <= (65535 * 512)) {
6512 			features_out = ((dxfer_len >> 9) & 0xffff);
6513 		} else {
6514 			/* The transfer is too big. */
6515 			retval = 1;
6516 			goto bailout;
6517 		}
6518 		auxiliary = (zm_action & 0xf) | (zone_flags << 8),
6519 		protocol = AP_PROTO_FPDMA;
6520 	}
6521 
6522 	protocol |= AP_EXTEND;
6523 
6524 	retval = scsi_ata_pass(csio,
6525 	    retries,
6526 	    cbfcnp,
6527 	    /*flags*/ CAM_DIR_IN,
6528 	    tag_action,
6529 	    /*protocol*/ protocol,
6530 	    /*ata_flags*/ ata_flags,
6531 	    /*features*/ features_out,
6532 	    /*sector_count*/ sectors_out,
6533 	    /*lba*/ zone_id,
6534 	    /*command*/ command_out,
6535 	    /*device*/ 0,
6536 	    /*icc*/ 0,
6537 	    /*auxiliary*/ auxiliary,
6538 	    /*control*/ 0,
6539 	    /*data_ptr*/ data_ptr,
6540 	    /*dxfer_len*/ (dxfer_len >> 9) * 512, /* XXX KDM */
6541 	    /*cdb_storage*/ cdb_storage,
6542 	    /*cdb_storage_len*/ cdb_storage_len,
6543 	    /*minimum_cmd_size*/ 0,
6544 	    /*sense_len*/ SSD_FULL_SIZE,
6545 	    /*timeout*/ timeout);
6546 
6547 bailout:
6548 	return (retval);
6549 }
6550