xref: /freebsd/sys/cam/ata/ata_da.c (revision cc3f4b99653c34ae64f8a1fddea370abefef680e)
1 /*-
2  * Copyright (c) 2009 Alexander Motin <mav@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer,
10  *    without modification, immediately at the beginning of the file.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26 
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 
30 #include "opt_ada.h"
31 
32 #include <sys/param.h>
33 
34 #ifdef _KERNEL
35 #include <sys/systm.h>
36 #include <sys/kernel.h>
37 #include <sys/bio.h>
38 #include <sys/sysctl.h>
39 #include <sys/taskqueue.h>
40 #include <sys/lock.h>
41 #include <sys/mutex.h>
42 #include <sys/conf.h>
43 #include <sys/devicestat.h>
44 #include <sys/eventhandler.h>
45 #include <sys/malloc.h>
46 #include <sys/cons.h>
47 #include <sys/proc.h>
48 #include <sys/reboot.h>
49 #include <geom/geom_disk.h>
50 #endif /* _KERNEL */
51 
52 #ifndef _KERNEL
53 #include <stdio.h>
54 #include <string.h>
55 #endif /* _KERNEL */
56 
57 #include <cam/cam.h>
58 #include <cam/cam_ccb.h>
59 #include <cam/cam_periph.h>
60 #include <cam/cam_xpt_periph.h>
61 #include <cam/cam_sim.h>
62 
63 #include <cam/ata/ata_all.h>
64 
65 #include <machine/md_var.h>	/* geometry translation */
66 
67 #ifdef _KERNEL
68 
69 #define ATA_MAX_28BIT_LBA               268435455UL
70 
71 typedef enum {
72 	ADA_STATE_RAHEAD,
73 	ADA_STATE_WCACHE,
74 	ADA_STATE_NORMAL
75 } ada_state;
76 
77 typedef enum {
78 	ADA_FLAG_CAN_48BIT	= 0x0002,
79 	ADA_FLAG_CAN_FLUSHCACHE	= 0x0004,
80 	ADA_FLAG_CAN_NCQ	= 0x0008,
81 	ADA_FLAG_CAN_DMA	= 0x0010,
82 	ADA_FLAG_NEED_OTAG	= 0x0020,
83 	ADA_FLAG_WAS_OTAG	= 0x0040,
84 	ADA_FLAG_CAN_TRIM	= 0x0080,
85 	ADA_FLAG_OPEN		= 0x0100,
86 	ADA_FLAG_SCTX_INIT	= 0x0200,
87 	ADA_FLAG_CAN_CFA        = 0x0400,
88 	ADA_FLAG_CAN_POWERMGT   = 0x0800,
89 	ADA_FLAG_CAN_DMA48	= 0x1000,
90 	ADA_FLAG_DIRTY		= 0x2000
91 } ada_flags;
92 
93 typedef enum {
94 	ADA_Q_NONE		= 0x00,
95 	ADA_Q_4K		= 0x01,
96 } ada_quirks;
97 
98 #define ADA_Q_BIT_STRING	\
99 	"\020"			\
100 	"\0014K"
101 
102 typedef enum {
103 	ADA_CCB_RAHEAD		= 0x01,
104 	ADA_CCB_WCACHE		= 0x02,
105 	ADA_CCB_BUFFER_IO	= 0x03,
106 	ADA_CCB_DUMP		= 0x05,
107 	ADA_CCB_TRIM		= 0x06,
108 	ADA_CCB_TYPE_MASK	= 0x0F,
109 } ada_ccb_state;
110 
111 /* Offsets into our private area for storing information */
112 #define ccb_state	ppriv_field0
113 #define ccb_bp		ppriv_ptr1
114 
115 struct disk_params {
116 	u_int8_t  heads;
117 	u_int8_t  secs_per_track;
118 	u_int32_t cylinders;
119 	u_int32_t secsize;	/* Number of bytes/logical sector */
120 	u_int64_t sectors;	/* Total number sectors */
121 };
122 
123 #define TRIM_MAX_BLOCKS	8
124 #define TRIM_MAX_RANGES	(TRIM_MAX_BLOCKS * ATA_DSM_BLK_RANGES)
125 struct trim_request {
126 	uint8_t		data[TRIM_MAX_RANGES * ATA_DSM_RANGE_SIZE];
127 	TAILQ_HEAD(, bio) bps;
128 };
129 
130 struct ada_softc {
131 	struct	 bio_queue_head bio_queue;
132 	struct	 bio_queue_head trim_queue;
133 	int	 outstanding_cmds;	/* Number of active commands */
134 	int	 refcount;		/* Active xpt_action() calls */
135 	ada_state state;
136 	ada_flags flags;
137 	ada_quirks quirks;
138 	int	 sort_io_queue;
139 	int	 trim_max_ranges;
140 	int	 trim_running;
141 	int	 read_ahead;
142 	int	 write_cache;
143 #ifdef ADA_TEST_FAILURE
144 	int      force_read_error;
145 	int      force_write_error;
146 	int      periodic_read_error;
147 	int      periodic_read_count;
148 #endif
149 	struct	 disk_params params;
150 	struct	 disk *disk;
151 	struct task		sysctl_task;
152 	struct sysctl_ctx_list	sysctl_ctx;
153 	struct sysctl_oid	*sysctl_tree;
154 	struct callout		sendordered_c;
155 	struct trim_request	trim_req;
156 };
157 
158 struct ada_quirk_entry {
159 	struct scsi_inquiry_pattern inq_pat;
160 	ada_quirks quirks;
161 };
162 
163 static struct ada_quirk_entry ada_quirk_table[] =
164 {
165 	{
166 		/* Hitachi Advanced Format (4k) drives */
167 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "Hitachi H??????????E3*", "*" },
168 		/*quirks*/ADA_Q_4K
169 	},
170 	{
171 		/* Samsung Advanced Format (4k) drives */
172 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "SAMSUNG HD155UI*", "*" },
173 		/*quirks*/ADA_Q_4K
174 	},
175 	{
176 		/* Samsung Advanced Format (4k) drives */
177 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "SAMSUNG HD204UI*", "*" },
178 		/*quirks*/ADA_Q_4K
179 	},
180 	{
181 		/* Seagate Barracuda Green Advanced Format (4k) drives */
182 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "ST????DL*", "*" },
183 		/*quirks*/ADA_Q_4K
184 	},
185 	{
186 		/* Seagate Barracuda Advanced Format (4k) drives */
187 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "ST???DM*", "*" },
188 		/*quirks*/ADA_Q_4K
189 	},
190 	{
191 		/* Seagate Barracuda Advanced Format (4k) drives */
192 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "ST????DM*", "*" },
193 		/*quirks*/ADA_Q_4K
194 	},
195 	{
196 		/* Seagate Momentus Advanced Format (4k) drives */
197 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9500423AS*", "*" },
198 		/*quirks*/ADA_Q_4K
199 	},
200 	{
201 		/* Seagate Momentus Advanced Format (4k) drives */
202 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9500424AS*", "*" },
203 		/*quirks*/ADA_Q_4K
204 	},
205 	{
206 		/* Seagate Momentus Advanced Format (4k) drives */
207 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9640423AS*", "*" },
208 		/*quirks*/ADA_Q_4K
209 	},
210 	{
211 		/* Seagate Momentus Advanced Format (4k) drives */
212 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9640424AS*", "*" },
213 		/*quirks*/ADA_Q_4K
214 	},
215 	{
216 		/* Seagate Momentus Advanced Format (4k) drives */
217 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9750420AS*", "*" },
218 		/*quirks*/ADA_Q_4K
219 	},
220 	{
221 		/* Seagate Momentus Advanced Format (4k) drives */
222 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9750422AS*", "*" },
223 		/*quirks*/ADA_Q_4K
224 	},
225 	{
226 		/* Seagate Momentus Advanced Format (4k) drives */
227 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "ST9750423AS*", "*" },
228 		/*quirks*/ADA_Q_4K
229 	},
230 	{
231 		/* Seagate Momentus Thin Advanced Format (4k) drives */
232 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "ST???LT*", "*" },
233 		/*quirks*/ADA_Q_4K
234 	},
235 	{
236 		/* WDC Caviar Green Advanced Format (4k) drives */
237 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD????RS*", "*" },
238 		/*quirks*/ADA_Q_4K
239 	},
240 	{
241 		/* WDC Caviar Green Advanced Format (4k) drives */
242 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD????RX*", "*" },
243 		/*quirks*/ADA_Q_4K
244 	},
245 	{
246 		/* WDC Caviar Green Advanced Format (4k) drives */
247 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD??????RS*", "*" },
248 		/*quirks*/ADA_Q_4K
249 	},
250 	{
251 		/* WDC Caviar Green Advanced Format (4k) drives */
252 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD??????RX*", "*" },
253 		/*quirks*/ADA_Q_4K
254 	},
255 	{
256 		/* WDC Scorpio Black Advanced Format (4k) drives */
257 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD???PKT*", "*" },
258 		/*quirks*/ADA_Q_4K
259 	},
260 	{
261 		/* WDC Scorpio Black Advanced Format (4k) drives */
262 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD?????PKT*", "*" },
263 		/*quirks*/ADA_Q_4K
264 	},
265 	{
266 		/* WDC Scorpio Blue Advanced Format (4k) drives */
267 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD???PVT*", "*" },
268 		/*quirks*/ADA_Q_4K
269 	},
270 	{
271 		/* WDC Scorpio Blue Advanced Format (4k) drives */
272 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "WDC WD?????PVT*", "*" },
273 		/*quirks*/ADA_Q_4K
274 	},
275 	/* SSDs */
276 	{
277 		/*
278 		 * Corsair Force 2 SSDs
279 		 * 4k optimised & trim only works in 4k requests + 4k aligned
280 		 */
281 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "Corsair CSSD-F*", "*" },
282 		/*quirks*/ADA_Q_4K
283 	},
284 	{
285 		/*
286 		 * Corsair Force 3 SSDs
287 		 * 4k optimised & trim only works in 4k requests + 4k aligned
288 		 */
289 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "Corsair Force 3*", "*" },
290 		/*quirks*/ADA_Q_4K
291 	},
292 	{
293 		/*
294 		 * Corsair Neutron GTX SSDs
295 		 * 4k optimised & trim only works in 4k requests + 4k aligned
296 		 */
297 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "Corsair Neutron GTX*", "*" },
298 		/*quirks*/ADA_Q_4K
299 	},
300 	{
301 		/*
302 		 * Corsair Force GT SSDs
303 		 * 4k optimised & trim only works in 4k requests + 4k aligned
304 		 */
305 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "Corsair Force GT*", "*" },
306 		/*quirks*/ADA_Q_4K
307 	},
308 	{
309 		/*
310 		 * Crucial M4 SSDs
311 		 * 4k optimised & trim only works in 4k requests + 4k aligned
312 		 */
313 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "M4-CT???M4SSD2*", "*" },
314 		/*quirks*/ADA_Q_4K
315 	},
316 	{
317 		/*
318 		 * Crucial RealSSD C300 SSDs
319 		 * 4k optimised
320 		 */
321 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "C300-CTFDDAC???MAG*",
322 		"*" }, /*quirks*/ADA_Q_4K
323 	},
324 	{
325 		/*
326 		 * Intel 320 Series SSDs
327 		 * 4k optimised & trim only works in 4k requests + 4k aligned
328 		 */
329 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "INTEL SSDSA2CW*", "*" },
330 		/*quirks*/ADA_Q_4K
331 	},
332 	{
333 		/*
334 		 * Intel 330 Series SSDs
335 		 * 4k optimised & trim only works in 4k requests + 4k aligned
336 		 */
337 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "INTEL SSDSC2CT*", "*" },
338 		/*quirks*/ADA_Q_4K
339 	},
340 	{
341 		/*
342 		 * Intel 510 Series SSDs
343 		 * 4k optimised & trim only works in 4k requests + 4k aligned
344 		 */
345 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "INTEL SSDSC2MH*", "*" },
346 		/*quirks*/ADA_Q_4K
347 	},
348 	{
349 		/*
350 		 * Intel 520 Series SSDs
351 		 * 4k optimised & trim only works in 4k requests + 4k aligned
352 		 */
353 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "INTEL SSDSC2BW*", "*" },
354 		/*quirks*/ADA_Q_4K
355 	},
356 	{
357 		/*
358 		 * Intel X25-M Series SSDs
359 		 * 4k optimised & trim only works in 4k requests + 4k aligned
360 		 */
361 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "INTEL SSDSA2M*", "*" },
362 		/*quirks*/ADA_Q_4K
363 	},
364 	{
365 		/*
366 		 * Kingston E100 Series SSDs
367 		 * 4k optimised & trim only works in 4k requests + 4k aligned
368 		 */
369 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "KINGSTON SE100S3*", "*" },
370 		/*quirks*/ADA_Q_4K
371 	},
372 	{
373 		/*
374 		 * Kingston HyperX 3k SSDs
375 		 * 4k optimised & trim only works in 4k requests + 4k aligned
376 		 */
377 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "KINGSTON SH103S3*", "*" },
378 		/*quirks*/ADA_Q_4K
379 	},
380 	{
381 		/*
382 		 * Marvell SSDs (entry taken from OpenSolaris)
383 		 * 4k optimised & trim only works in 4k requests + 4k aligned
384 		 */
385 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "MARVELL SD88SA02*", "*" },
386 		/*quirks*/ADA_Q_4K
387 	},
388 	{
389 		/*
390 		 * OCZ Agility 2 SSDs
391 		 * 4k optimised & trim only works in 4k requests + 4k aligned
392 		 */
393 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ-AGILITY2*", "*" },
394 		/*quirks*/ADA_Q_4K
395 	},
396 	{
397 		/*
398 		 * OCZ Agility 3 SSDs
399 		 * 4k optimised & trim only works in 4k requests + 4k aligned
400 		 */
401 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ-AGILITY3*", "*" },
402 		/*quirks*/ADA_Q_4K
403 	},
404 	{
405 		/*
406 		 * OCZ Deneva R Series SSDs
407 		 * 4k optimised & trim only works in 4k requests + 4k aligned
408 		 */
409 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "DENRSTE251M45*", "*" },
410 		/*quirks*/ADA_Q_4K
411 	},
412 	{
413 		/*
414 		 * OCZ Vertex 2 SSDs (inc pro series)
415 		 * 4k optimised & trim only works in 4k requests + 4k aligned
416 		 */
417 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ?VERTEX2*", "*" },
418 		/*quirks*/ADA_Q_4K
419 	},
420 	{
421 		/*
422 		 * OCZ Vertex 3 SSDs
423 		 * 4k optimised & trim only works in 4k requests + 4k aligned
424 		 */
425 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ-VERTEX3*", "*" },
426 		/*quirks*/ADA_Q_4K
427 	},
428 	{
429 		/*
430 		 * OCZ Vertex 4 SSDs
431 		 * 4k optimised & trim only works in 4k requests + 4k aligned
432 		 */
433 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "OCZ-VERTEX4*", "*" },
434 		/*quirks*/ADA_Q_4K
435 	},
436 	{
437 		/*
438 		 * Samsung 830 Series SSDs
439 		 * 4k optimised
440 		 */
441 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "SAMSUNG SSD 830 Series*", "*" },
442 		/*quirks*/ADA_Q_4K
443 	},
444 	{
445 		/*
446 		 * SuperTalent TeraDrive CT SSDs
447 		 * 4k optimised & trim only works in 4k requests + 4k aligned
448 		 */
449 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "FTM??CT25H*", "*" },
450 		/*quirks*/ADA_Q_4K
451 	},
452 	{
453 		/*
454 		 * XceedIOPS SATA SSDs
455 		 * 4k optimised
456 		 */
457 		{ T_DIRECT, SIP_MEDIA_FIXED, "*", "SG9XCS2D*", "*" },
458 		/*quirks*/ADA_Q_4K
459 	},
460 	{
461 		/* Default */
462 		{
463 		  T_ANY, SIP_MEDIA_REMOVABLE|SIP_MEDIA_FIXED,
464 		  /*vendor*/"*", /*product*/"*", /*revision*/"*"
465 		},
466 		/*quirks*/0
467 	},
468 };
469 
470 static	disk_strategy_t	adastrategy;
471 static	dumper_t	adadump;
472 static	periph_init_t	adainit;
473 static	void		adaasync(void *callback_arg, u_int32_t code,
474 				struct cam_path *path, void *arg);
475 static	void		adasysctlinit(void *context, int pending);
476 static	periph_ctor_t	adaregister;
477 static	periph_dtor_t	adacleanup;
478 static	periph_start_t	adastart;
479 static	periph_oninv_t	adaoninvalidate;
480 static	void		adadone(struct cam_periph *periph,
481 			       union ccb *done_ccb);
482 static  int		adaerror(union ccb *ccb, u_int32_t cam_flags,
483 				u_int32_t sense_flags);
484 static void		adagetparams(struct cam_periph *periph,
485 				struct ccb_getdev *cgd);
486 static timeout_t	adasendorderedtag;
487 static void		adashutdown(void *arg, int howto);
488 static void		adasuspend(void *arg);
489 static void		adaresume(void *arg);
490 
491 #ifndef	ADA_DEFAULT_LEGACY_ALIASES
492 #define	ADA_DEFAULT_LEGACY_ALIASES	1
493 #endif
494 
495 #ifndef ADA_DEFAULT_TIMEOUT
496 #define ADA_DEFAULT_TIMEOUT 30	/* Timeout in seconds */
497 #endif
498 
499 #ifndef	ADA_DEFAULT_RETRY
500 #define	ADA_DEFAULT_RETRY	4
501 #endif
502 
503 #ifndef	ADA_DEFAULT_SEND_ORDERED
504 #define	ADA_DEFAULT_SEND_ORDERED	1
505 #endif
506 
507 #ifndef	ADA_DEFAULT_SPINDOWN_SHUTDOWN
508 #define	ADA_DEFAULT_SPINDOWN_SHUTDOWN	1
509 #endif
510 
511 #ifndef	ADA_DEFAULT_SPINDOWN_SUSPEND
512 #define	ADA_DEFAULT_SPINDOWN_SUSPEND	1
513 #endif
514 
515 #ifndef	ADA_DEFAULT_READ_AHEAD
516 #define	ADA_DEFAULT_READ_AHEAD	1
517 #endif
518 
519 #ifndef	ADA_DEFAULT_WRITE_CACHE
520 #define	ADA_DEFAULT_WRITE_CACHE	1
521 #endif
522 
523 #define	ADA_RA	(softc->read_ahead >= 0 ? \
524 		 softc->read_ahead : ada_read_ahead)
525 #define	ADA_WC	(softc->write_cache >= 0 ? \
526 		 softc->write_cache : ada_write_cache)
527 #define	ADA_SIO	(softc->sort_io_queue >= 0 ? \
528 		 softc->sort_io_queue : cam_sort_io_queues)
529 
530 /*
531  * Most platforms map firmware geometry to actual, but some don't.  If
532  * not overridden, default to nothing.
533  */
534 #ifndef ata_disk_firmware_geom_adjust
535 #define	ata_disk_firmware_geom_adjust(disk)
536 #endif
537 
538 static int ada_legacy_aliases = ADA_DEFAULT_LEGACY_ALIASES;
539 static int ada_retry_count = ADA_DEFAULT_RETRY;
540 static int ada_default_timeout = ADA_DEFAULT_TIMEOUT;
541 static int ada_send_ordered = ADA_DEFAULT_SEND_ORDERED;
542 static int ada_spindown_shutdown = ADA_DEFAULT_SPINDOWN_SHUTDOWN;
543 static int ada_spindown_suspend = ADA_DEFAULT_SPINDOWN_SUSPEND;
544 static int ada_read_ahead = ADA_DEFAULT_READ_AHEAD;
545 static int ada_write_cache = ADA_DEFAULT_WRITE_CACHE;
546 
547 static SYSCTL_NODE(_kern_cam, OID_AUTO, ada, CTLFLAG_RD, 0,
548             "CAM Direct Access Disk driver");
549 SYSCTL_INT(_kern_cam_ada, OID_AUTO, legacy_aliases, CTLFLAG_RW,
550            &ada_legacy_aliases, 0, "Create legacy-like device aliases");
551 TUNABLE_INT("kern.cam.ada.legacy_aliases", &ada_legacy_aliases);
552 SYSCTL_INT(_kern_cam_ada, OID_AUTO, retry_count, CTLFLAG_RW,
553            &ada_retry_count, 0, "Normal I/O retry count");
554 TUNABLE_INT("kern.cam.ada.retry_count", &ada_retry_count);
555 SYSCTL_INT(_kern_cam_ada, OID_AUTO, default_timeout, CTLFLAG_RW,
556            &ada_default_timeout, 0, "Normal I/O timeout (in seconds)");
557 TUNABLE_INT("kern.cam.ada.default_timeout", &ada_default_timeout);
558 SYSCTL_INT(_kern_cam_ada, OID_AUTO, send_ordered, CTLFLAG_RW,
559            &ada_send_ordered, 0, "Send Ordered Tags");
560 TUNABLE_INT("kern.cam.ada.send_ordered", &ada_send_ordered);
561 SYSCTL_INT(_kern_cam_ada, OID_AUTO, spindown_shutdown, CTLFLAG_RW,
562            &ada_spindown_shutdown, 0, "Spin down upon shutdown");
563 TUNABLE_INT("kern.cam.ada.spindown_shutdown", &ada_spindown_shutdown);
564 SYSCTL_INT(_kern_cam_ada, OID_AUTO, spindown_suspend, CTLFLAG_RW,
565            &ada_spindown_suspend, 0, "Spin down upon suspend");
566 TUNABLE_INT("kern.cam.ada.spindown_suspend", &ada_spindown_suspend);
567 SYSCTL_INT(_kern_cam_ada, OID_AUTO, read_ahead, CTLFLAG_RW,
568            &ada_read_ahead, 0, "Enable disk read-ahead");
569 TUNABLE_INT("kern.cam.ada.read_ahead", &ada_read_ahead);
570 SYSCTL_INT(_kern_cam_ada, OID_AUTO, write_cache, CTLFLAG_RW,
571            &ada_write_cache, 0, "Enable disk write cache");
572 TUNABLE_INT("kern.cam.ada.write_cache", &ada_write_cache);
573 
574 /*
575  * ADA_ORDEREDTAG_INTERVAL determines how often, relative
576  * to the default timeout, we check to see whether an ordered
577  * tagged transaction is appropriate to prevent simple tag
578  * starvation.  Since we'd like to ensure that there is at least
579  * 1/2 of the timeout length left for a starved transaction to
580  * complete after we've sent an ordered tag, we must poll at least
581  * four times in every timeout period.  This takes care of the worst
582  * case where a starved transaction starts during an interval that
583  * meets the requirement "don't send an ordered tag" test so it takes
584  * us two intervals to determine that a tag must be sent.
585  */
586 #ifndef ADA_ORDEREDTAG_INTERVAL
587 #define ADA_ORDEREDTAG_INTERVAL 4
588 #endif
589 
590 static struct periph_driver adadriver =
591 {
592 	adainit, "ada",
593 	TAILQ_HEAD_INITIALIZER(adadriver.units), /* generation */ 0
594 };
595 
596 PERIPHDRIVER_DECLARE(ada, adadriver);
597 
598 static MALLOC_DEFINE(M_ATADA, "ata_da", "ata_da buffers");
599 
600 static int
601 adaopen(struct disk *dp)
602 {
603 	struct cam_periph *periph;
604 	struct ada_softc *softc;
605 	int error;
606 
607 	periph = (struct cam_periph *)dp->d_drv1;
608 	if (cam_periph_acquire(periph) != CAM_REQ_CMP) {
609 		return(ENXIO);
610 	}
611 
612 	cam_periph_lock(periph);
613 	if ((error = cam_periph_hold(periph, PRIBIO|PCATCH)) != 0) {
614 		cam_periph_unlock(periph);
615 		cam_periph_release(periph);
616 		return (error);
617 	}
618 
619 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
620 	    ("adaopen\n"));
621 
622 	softc = (struct ada_softc *)periph->softc;
623 	softc->flags |= ADA_FLAG_OPEN;
624 
625 	cam_periph_unhold(periph);
626 	cam_periph_unlock(periph);
627 	return (0);
628 }
629 
630 static int
631 adaclose(struct disk *dp)
632 {
633 	struct	cam_periph *periph;
634 	struct	ada_softc *softc;
635 	union ccb *ccb;
636 	int error;
637 
638 	periph = (struct cam_periph *)dp->d_drv1;
639 	softc = (struct ada_softc *)periph->softc;
640 	cam_periph_lock(periph);
641 
642 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE | CAM_DEBUG_PERIPH,
643 	    ("adaclose\n"));
644 
645 	/* We only sync the cache if the drive is capable of it. */
646 	if ((softc->flags & ADA_FLAG_DIRTY) != 0 &&
647 	    (softc->flags & ADA_FLAG_CAN_FLUSHCACHE) != 0 &&
648 	    (periph->flags & CAM_PERIPH_INVALID) == 0 &&
649 	    cam_periph_hold(periph, PRIBIO) == 0) {
650 
651 		ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
652 		cam_fill_ataio(&ccb->ataio,
653 				    1,
654 				    adadone,
655 				    CAM_DIR_NONE,
656 				    0,
657 				    NULL,
658 				    0,
659 				    ada_default_timeout*1000);
660 
661 		if (softc->flags & ADA_FLAG_CAN_48BIT)
662 			ata_48bit_cmd(&ccb->ataio, ATA_FLUSHCACHE48, 0, 0, 0);
663 		else
664 			ata_28bit_cmd(&ccb->ataio, ATA_FLUSHCACHE, 0, 0, 0);
665 		error = cam_periph_runccb(ccb, adaerror, /*cam_flags*/0,
666 		    /*sense_flags*/0, softc->disk->d_devstat);
667 
668 		if (error != 0)
669 			xpt_print(periph->path, "Synchronize cache failed\n");
670 		else
671 			softc->flags &= ~ADA_FLAG_DIRTY;
672 		xpt_release_ccb(ccb);
673 		cam_periph_unhold(periph);
674 	}
675 
676 	softc->flags &= ~ADA_FLAG_OPEN;
677 
678 	while (softc->refcount != 0)
679 		cam_periph_sleep(periph, &softc->refcount, PRIBIO, "adaclose", 1);
680 	cam_periph_unlock(periph);
681 	cam_periph_release(periph);
682 	return (0);
683 }
684 
685 static void
686 adaschedule(struct cam_periph *periph)
687 {
688 	struct ada_softc *softc = (struct ada_softc *)periph->softc;
689 
690 	if (softc->state != ADA_STATE_NORMAL)
691 		return;
692 
693 	/* Check if we have more work to do. */
694 	if (bioq_first(&softc->bio_queue) ||
695 	    (!softc->trim_running && bioq_first(&softc->trim_queue))) {
696 		xpt_schedule(periph, CAM_PRIORITY_NORMAL);
697 	}
698 }
699 
700 /*
701  * Actually translate the requested transfer into one the physical driver
702  * can understand.  The transfer is described by a buf and will include
703  * only one physical transfer.
704  */
705 static void
706 adastrategy(struct bio *bp)
707 {
708 	struct cam_periph *periph;
709 	struct ada_softc *softc;
710 
711 	periph = (struct cam_periph *)bp->bio_disk->d_drv1;
712 	softc = (struct ada_softc *)periph->softc;
713 
714 	cam_periph_lock(periph);
715 
716 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("adastrategy(%p)\n", bp));
717 
718 	/*
719 	 * If the device has been made invalid, error out
720 	 */
721 	if ((periph->flags & CAM_PERIPH_INVALID) != 0) {
722 		cam_periph_unlock(periph);
723 		biofinish(bp, NULL, ENXIO);
724 		return;
725 	}
726 
727 	/*
728 	 * Place it in the queue of disk activities for this disk
729 	 */
730 	if (bp->bio_cmd == BIO_DELETE &&
731 	    (softc->flags & ADA_FLAG_CAN_TRIM)) {
732 		if (ADA_SIO)
733 		    bioq_disksort(&softc->trim_queue, bp);
734 		else
735 		    bioq_insert_tail(&softc->trim_queue, bp);
736 	} else {
737 		if (ADA_SIO)
738 		    bioq_disksort(&softc->bio_queue, bp);
739 		else
740 		    bioq_insert_tail(&softc->bio_queue, bp);
741 	}
742 
743 	/*
744 	 * Schedule ourselves for performing the work.
745 	 */
746 	adaschedule(periph);
747 	cam_periph_unlock(periph);
748 
749 	return;
750 }
751 
752 static int
753 adadump(void *arg, void *virtual, vm_offset_t physical, off_t offset, size_t length)
754 {
755 	struct	    cam_periph *periph;
756 	struct	    ada_softc *softc;
757 	u_int	    secsize;
758 	union	    ccb ccb;
759 	struct	    disk *dp;
760 	uint64_t    lba;
761 	uint16_t    count;
762 	int	    error = 0;
763 
764 	dp = arg;
765 	periph = dp->d_drv1;
766 	softc = (struct ada_softc *)periph->softc;
767 	cam_periph_lock(periph);
768 	secsize = softc->params.secsize;
769 	lba = offset / secsize;
770 	count = length / secsize;
771 
772 	if ((periph->flags & CAM_PERIPH_INVALID) != 0) {
773 		cam_periph_unlock(periph);
774 		return (ENXIO);
775 	}
776 
777 	if (length > 0) {
778 		xpt_setup_ccb(&ccb.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
779 		ccb.ccb_h.ccb_state = ADA_CCB_DUMP;
780 		cam_fill_ataio(&ccb.ataio,
781 		    0,
782 		    adadone,
783 		    CAM_DIR_OUT,
784 		    0,
785 		    (u_int8_t *) virtual,
786 		    length,
787 		    ada_default_timeout*1000);
788 		if ((softc->flags & ADA_FLAG_CAN_48BIT) &&
789 		    (lba + count >= ATA_MAX_28BIT_LBA ||
790 		    count >= 256)) {
791 			ata_48bit_cmd(&ccb.ataio, ATA_WRITE_DMA48,
792 			    0, lba, count);
793 		} else {
794 			ata_28bit_cmd(&ccb.ataio, ATA_WRITE_DMA,
795 			    0, lba, count);
796 		}
797 		xpt_polled_action(&ccb);
798 
799 		error = cam_periph_error(&ccb,
800 		    0, SF_NO_RECOVERY | SF_NO_RETRY, NULL);
801 		if ((ccb.ccb_h.status & CAM_DEV_QFRZN) != 0)
802 			cam_release_devq(ccb.ccb_h.path, /*relsim_flags*/0,
803 			    /*reduction*/0, /*timeout*/0, /*getcount_only*/0);
804 		if (error != 0)
805 			printf("Aborting dump due to I/O error.\n");
806 
807 		cam_periph_unlock(periph);
808 		return (error);
809 	}
810 
811 	if (softc->flags & ADA_FLAG_CAN_FLUSHCACHE) {
812 		xpt_setup_ccb(&ccb.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
813 
814 		ccb.ccb_h.ccb_state = ADA_CCB_DUMP;
815 		cam_fill_ataio(&ccb.ataio,
816 				    0,
817 				    adadone,
818 				    CAM_DIR_NONE,
819 				    0,
820 				    NULL,
821 				    0,
822 				    ada_default_timeout*1000);
823 
824 		if (softc->flags & ADA_FLAG_CAN_48BIT)
825 			ata_48bit_cmd(&ccb.ataio, ATA_FLUSHCACHE48, 0, 0, 0);
826 		else
827 			ata_28bit_cmd(&ccb.ataio, ATA_FLUSHCACHE, 0, 0, 0);
828 		xpt_polled_action(&ccb);
829 
830 		error = cam_periph_error(&ccb,
831 		    0, SF_NO_RECOVERY | SF_NO_RETRY, NULL);
832 		if ((ccb.ccb_h.status & CAM_DEV_QFRZN) != 0)
833 			cam_release_devq(ccb.ccb_h.path, /*relsim_flags*/0,
834 			    /*reduction*/0, /*timeout*/0, /*getcount_only*/0);
835 		if (error != 0)
836 			xpt_print(periph->path, "Synchronize cache failed\n");
837 	}
838 	cam_periph_unlock(periph);
839 	return (error);
840 }
841 
842 static void
843 adainit(void)
844 {
845 	cam_status status;
846 
847 	/*
848 	 * Install a global async callback.  This callback will
849 	 * receive async callbacks like "new device found".
850 	 */
851 	status = xpt_register_async(AC_FOUND_DEVICE, adaasync, NULL, NULL);
852 
853 	if (status != CAM_REQ_CMP) {
854 		printf("ada: Failed to attach master async callback "
855 		       "due to status 0x%x!\n", status);
856 	} else if (ada_send_ordered) {
857 
858 		/* Register our event handlers */
859 		if ((EVENTHANDLER_REGISTER(power_suspend, adasuspend,
860 					   NULL, EVENTHANDLER_PRI_LAST)) == NULL)
861 		    printf("adainit: power event registration failed!\n");
862 		if ((EVENTHANDLER_REGISTER(power_resume, adaresume,
863 					   NULL, EVENTHANDLER_PRI_LAST)) == NULL)
864 		    printf("adainit: power event registration failed!\n");
865 		if ((EVENTHANDLER_REGISTER(shutdown_post_sync, adashutdown,
866 					   NULL, SHUTDOWN_PRI_DEFAULT)) == NULL)
867 		    printf("adainit: shutdown event registration failed!\n");
868 	}
869 }
870 
871 /*
872  * Callback from GEOM, called when it has finished cleaning up its
873  * resources.
874  */
875 static void
876 adadiskgonecb(struct disk *dp)
877 {
878 	struct cam_periph *periph;
879 
880 	periph = (struct cam_periph *)dp->d_drv1;
881 
882 	cam_periph_release(periph);
883 }
884 
885 static void
886 adaoninvalidate(struct cam_periph *periph)
887 {
888 	struct ada_softc *softc;
889 
890 	softc = (struct ada_softc *)periph->softc;
891 
892 	/*
893 	 * De-register any async callbacks.
894 	 */
895 	xpt_register_async(0, adaasync, periph, periph->path);
896 
897 	/*
898 	 * Return all queued I/O with ENXIO.
899 	 * XXX Handle any transactions queued to the card
900 	 *     with XPT_ABORT_CCB.
901 	 */
902 	bioq_flush(&softc->bio_queue, NULL, ENXIO);
903 	bioq_flush(&softc->trim_queue, NULL, ENXIO);
904 
905 	disk_gone(softc->disk);
906 }
907 
908 static void
909 adacleanup(struct cam_periph *periph)
910 {
911 	struct ada_softc *softc;
912 
913 	softc = (struct ada_softc *)periph->softc;
914 
915 	cam_periph_unlock(periph);
916 
917 	/*
918 	 * If we can't free the sysctl tree, oh well...
919 	 */
920 	if ((softc->flags & ADA_FLAG_SCTX_INIT) != 0
921 	    && sysctl_ctx_free(&softc->sysctl_ctx) != 0) {
922 		xpt_print(periph->path, "can't remove sysctl context\n");
923 	}
924 
925 	disk_destroy(softc->disk);
926 	callout_drain(&softc->sendordered_c);
927 	free(softc, M_DEVBUF);
928 	cam_periph_lock(periph);
929 }
930 
931 static void
932 adaasync(void *callback_arg, u_int32_t code,
933 	struct cam_path *path, void *arg)
934 {
935 	struct ccb_getdev cgd;
936 	struct cam_periph *periph;
937 	struct ada_softc *softc;
938 
939 	periph = (struct cam_periph *)callback_arg;
940 	switch (code) {
941 	case AC_FOUND_DEVICE:
942 	{
943 		struct ccb_getdev *cgd;
944 		cam_status status;
945 
946 		cgd = (struct ccb_getdev *)arg;
947 		if (cgd == NULL)
948 			break;
949 
950 		if (cgd->protocol != PROTO_ATA)
951 			break;
952 
953 		/*
954 		 * Allocate a peripheral instance for
955 		 * this device and start the probe
956 		 * process.
957 		 */
958 		status = cam_periph_alloc(adaregister, adaoninvalidate,
959 					  adacleanup, adastart,
960 					  "ada", CAM_PERIPH_BIO,
961 					  path, adaasync,
962 					  AC_FOUND_DEVICE, cgd);
963 
964 		if (status != CAM_REQ_CMP
965 		 && status != CAM_REQ_INPROG)
966 			printf("adaasync: Unable to attach to new device "
967 				"due to status 0x%x\n", status);
968 		break;
969 	}
970 	case AC_GETDEV_CHANGED:
971 	{
972 		softc = (struct ada_softc *)periph->softc;
973 		xpt_setup_ccb(&cgd.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
974 		cgd.ccb_h.func_code = XPT_GDEV_TYPE;
975 		xpt_action((union ccb *)&cgd);
976 
977 		if ((cgd.ident_data.capabilities1 & ATA_SUPPORT_DMA) &&
978 		    (cgd.inq_flags & SID_DMA))
979 			softc->flags |= ADA_FLAG_CAN_DMA;
980 		else
981 			softc->flags &= ~ADA_FLAG_CAN_DMA;
982 		if (cgd.ident_data.support.command2 & ATA_SUPPORT_ADDRESS48) {
983 			softc->flags |= ADA_FLAG_CAN_48BIT;
984 			if (cgd.inq_flags & SID_DMA48)
985 				softc->flags |= ADA_FLAG_CAN_DMA48;
986 			else
987 				softc->flags &= ~ADA_FLAG_CAN_DMA48;
988 		} else
989 			softc->flags &= ~(ADA_FLAG_CAN_48BIT |
990 			    ADA_FLAG_CAN_DMA48);
991 		if ((cgd.ident_data.satacapabilities & ATA_SUPPORT_NCQ) &&
992 		    (cgd.inq_flags & SID_DMA) && (cgd.inq_flags & SID_CmdQue))
993 			softc->flags |= ADA_FLAG_CAN_NCQ;
994 		else
995 			softc->flags &= ~ADA_FLAG_CAN_NCQ;
996 		if ((cgd.ident_data.support_dsm & ATA_SUPPORT_DSM_TRIM) &&
997 		    (cgd.inq_flags & SID_DMA))
998 			softc->flags |= ADA_FLAG_CAN_TRIM;
999 		else
1000 			softc->flags &= ~ADA_FLAG_CAN_TRIM;
1001 
1002 		cam_periph_async(periph, code, path, arg);
1003 		break;
1004 	}
1005 	case AC_ADVINFO_CHANGED:
1006 	{
1007 		uintptr_t buftype;
1008 
1009 		buftype = (uintptr_t)arg;
1010 		if (buftype == CDAI_TYPE_PHYS_PATH) {
1011 			struct ada_softc *softc;
1012 
1013 			softc = periph->softc;
1014 			disk_attr_changed(softc->disk, "GEOM::physpath",
1015 					  M_NOWAIT);
1016 		}
1017 		break;
1018 	}
1019 	case AC_SENT_BDR:
1020 	case AC_BUS_RESET:
1021 	{
1022 		softc = (struct ada_softc *)periph->softc;
1023 		cam_periph_async(periph, code, path, arg);
1024 		if (softc->state != ADA_STATE_NORMAL)
1025 			break;
1026 		xpt_setup_ccb(&cgd.ccb_h, periph->path, CAM_PRIORITY_NORMAL);
1027 		cgd.ccb_h.func_code = XPT_GDEV_TYPE;
1028 		xpt_action((union ccb *)&cgd);
1029 		if (ADA_RA >= 0 &&
1030 		    cgd.ident_data.support.command1 & ATA_SUPPORT_LOOKAHEAD)
1031 			softc->state = ADA_STATE_RAHEAD;
1032 		else if (ADA_WC >= 0 &&
1033 		    cgd.ident_data.support.command1 & ATA_SUPPORT_WRITECACHE)
1034 			softc->state = ADA_STATE_WCACHE;
1035 		else
1036 		    break;
1037 		if (cam_periph_acquire(periph) != CAM_REQ_CMP)
1038 			softc->state = ADA_STATE_NORMAL;
1039 		else
1040 			xpt_schedule(periph, CAM_PRIORITY_DEV);
1041 	}
1042 	default:
1043 		cam_periph_async(periph, code, path, arg);
1044 		break;
1045 	}
1046 }
1047 
1048 static void
1049 adasysctlinit(void *context, int pending)
1050 {
1051 	struct cam_periph *periph;
1052 	struct ada_softc *softc;
1053 	char tmpstr[80], tmpstr2[80];
1054 
1055 	periph = (struct cam_periph *)context;
1056 
1057 	/* periph was held for us when this task was enqueued */
1058 	if ((periph->flags & CAM_PERIPH_INVALID) != 0) {
1059 		cam_periph_release(periph);
1060 		return;
1061 	}
1062 
1063 	softc = (struct ada_softc *)periph->softc;
1064 	snprintf(tmpstr, sizeof(tmpstr), "CAM ADA unit %d", periph->unit_number);
1065 	snprintf(tmpstr2, sizeof(tmpstr2), "%d", periph->unit_number);
1066 
1067 	sysctl_ctx_init(&softc->sysctl_ctx);
1068 	softc->flags |= ADA_FLAG_SCTX_INIT;
1069 	softc->sysctl_tree = SYSCTL_ADD_NODE(&softc->sysctl_ctx,
1070 		SYSCTL_STATIC_CHILDREN(_kern_cam_ada), OID_AUTO, tmpstr2,
1071 		CTLFLAG_RD, 0, tmpstr);
1072 	if (softc->sysctl_tree == NULL) {
1073 		printf("adasysctlinit: unable to allocate sysctl tree\n");
1074 		cam_periph_release(periph);
1075 		return;
1076 	}
1077 
1078 	SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1079 		OID_AUTO, "read_ahead", CTLFLAG_RW | CTLFLAG_MPSAFE,
1080 		&softc->read_ahead, 0, "Enable disk read ahead.");
1081 	SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1082 		OID_AUTO, "write_cache", CTLFLAG_RW | CTLFLAG_MPSAFE,
1083 		&softc->write_cache, 0, "Enable disk write cache.");
1084 	SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1085 		OID_AUTO, "sort_io_queue", CTLFLAG_RW | CTLFLAG_MPSAFE,
1086 		&softc->sort_io_queue, 0,
1087 		"Sort IO queue to try and optimise disk access patterns");
1088 #ifdef ADA_TEST_FAILURE
1089 	/*
1090 	 * Add a 'door bell' sysctl which allows one to set it from userland
1091 	 * and cause something bad to happen.  For the moment, we only allow
1092 	 * whacking the next read or write.
1093 	 */
1094 	SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1095 		OID_AUTO, "force_read_error", CTLFLAG_RW | CTLFLAG_MPSAFE,
1096 		&softc->force_read_error, 0,
1097 		"Force a read error for the next N reads.");
1098 	SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1099 		OID_AUTO, "force_write_error", CTLFLAG_RW | CTLFLAG_MPSAFE,
1100 		&softc->force_write_error, 0,
1101 		"Force a write error for the next N writes.");
1102 	SYSCTL_ADD_INT(&softc->sysctl_ctx, SYSCTL_CHILDREN(softc->sysctl_tree),
1103 		OID_AUTO, "periodic_read_error", CTLFLAG_RW | CTLFLAG_MPSAFE,
1104 		&softc->periodic_read_error, 0,
1105 		"Force a read error every N reads (don't set too low).");
1106 #endif
1107 	cam_periph_release(periph);
1108 }
1109 
1110 static int
1111 adagetattr(struct bio *bp)
1112 {
1113 	int ret;
1114 	struct cam_periph *periph;
1115 
1116 	periph = (struct cam_periph *)bp->bio_disk->d_drv1;
1117 	cam_periph_lock(periph);
1118 	ret = xpt_getattr(bp->bio_data, bp->bio_length, bp->bio_attribute,
1119 	    periph->path);
1120 	cam_periph_unlock(periph);
1121 	if (ret == 0)
1122 		bp->bio_completed = bp->bio_length;
1123 	return ret;
1124 }
1125 
1126 static cam_status
1127 adaregister(struct cam_periph *periph, void *arg)
1128 {
1129 	struct ada_softc *softc;
1130 	struct ccb_pathinq cpi;
1131 	struct ccb_getdev *cgd;
1132 	char   announce_buf[80], buf1[32];
1133 	struct disk_params *dp;
1134 	caddr_t match;
1135 	u_int maxio;
1136 	int legacy_id, quirks;
1137 
1138 	cgd = (struct ccb_getdev *)arg;
1139 	if (cgd == NULL) {
1140 		printf("adaregister: no getdev CCB, can't register device\n");
1141 		return(CAM_REQ_CMP_ERR);
1142 	}
1143 
1144 	softc = (struct ada_softc *)malloc(sizeof(*softc), M_DEVBUF,
1145 	    M_NOWAIT|M_ZERO);
1146 
1147 	if (softc == NULL) {
1148 		printf("adaregister: Unable to probe new device. "
1149 		    "Unable to allocate softc\n");
1150 		return(CAM_REQ_CMP_ERR);
1151 	}
1152 
1153 	bioq_init(&softc->bio_queue);
1154 	bioq_init(&softc->trim_queue);
1155 
1156 	if ((cgd->ident_data.capabilities1 & ATA_SUPPORT_DMA) &&
1157 	    (cgd->inq_flags & SID_DMA))
1158 		softc->flags |= ADA_FLAG_CAN_DMA;
1159 	if (cgd->ident_data.support.command2 & ATA_SUPPORT_ADDRESS48) {
1160 		softc->flags |= ADA_FLAG_CAN_48BIT;
1161 		if (cgd->inq_flags & SID_DMA48)
1162 			softc->flags |= ADA_FLAG_CAN_DMA48;
1163 	}
1164 	if (cgd->ident_data.support.command2 & ATA_SUPPORT_FLUSHCACHE)
1165 		softc->flags |= ADA_FLAG_CAN_FLUSHCACHE;
1166 	if (cgd->ident_data.support.command1 & ATA_SUPPORT_POWERMGT)
1167 		softc->flags |= ADA_FLAG_CAN_POWERMGT;
1168 	if ((cgd->ident_data.satacapabilities & ATA_SUPPORT_NCQ) &&
1169 	    (cgd->inq_flags & SID_DMA) && (cgd->inq_flags & SID_CmdQue))
1170 		softc->flags |= ADA_FLAG_CAN_NCQ;
1171 	if ((cgd->ident_data.support_dsm & ATA_SUPPORT_DSM_TRIM) &&
1172 	    (cgd->inq_flags & SID_DMA)) {
1173 		softc->flags |= ADA_FLAG_CAN_TRIM;
1174 		softc->trim_max_ranges = TRIM_MAX_RANGES;
1175 		if (cgd->ident_data.max_dsm_blocks != 0) {
1176 			softc->trim_max_ranges =
1177 			    min(cgd->ident_data.max_dsm_blocks *
1178 				ATA_DSM_BLK_RANGES, softc->trim_max_ranges);
1179 		}
1180 	}
1181 	if (cgd->ident_data.support.command2 & ATA_SUPPORT_CFA)
1182 		softc->flags |= ADA_FLAG_CAN_CFA;
1183 
1184 	periph->softc = softc;
1185 
1186 	/*
1187 	 * See if this device has any quirks.
1188 	 */
1189 	match = cam_quirkmatch((caddr_t)&cgd->ident_data,
1190 			       (caddr_t)ada_quirk_table,
1191 			       sizeof(ada_quirk_table)/sizeof(*ada_quirk_table),
1192 			       sizeof(*ada_quirk_table), ata_identify_match);
1193 	if (match != NULL)
1194 		softc->quirks = ((struct ada_quirk_entry *)match)->quirks;
1195 	else
1196 		softc->quirks = ADA_Q_NONE;
1197 
1198 	bzero(&cpi, sizeof(cpi));
1199 	xpt_setup_ccb(&cpi.ccb_h, periph->path, CAM_PRIORITY_NONE);
1200 	cpi.ccb_h.func_code = XPT_PATH_INQ;
1201 	xpt_action((union ccb *)&cpi);
1202 
1203 	TASK_INIT(&softc->sysctl_task, 0, adasysctlinit, periph);
1204 
1205 	/*
1206 	 * Register this media as a disk
1207 	 */
1208 	(void)cam_periph_hold(periph, PRIBIO);
1209 	cam_periph_unlock(periph);
1210 	snprintf(announce_buf, sizeof(announce_buf),
1211 	    "kern.cam.ada.%d.quirks", periph->unit_number);
1212 	quirks = softc->quirks;
1213 	TUNABLE_INT_FETCH(announce_buf, &quirks);
1214 	softc->quirks = quirks;
1215 	softc->read_ahead = -1;
1216 	snprintf(announce_buf, sizeof(announce_buf),
1217 	    "kern.cam.ada.%d.read_ahead", periph->unit_number);
1218 	TUNABLE_INT_FETCH(announce_buf, &softc->read_ahead);
1219 	softc->write_cache = -1;
1220 	snprintf(announce_buf, sizeof(announce_buf),
1221 	    "kern.cam.ada.%d.write_cache", periph->unit_number);
1222 	TUNABLE_INT_FETCH(announce_buf, &softc->write_cache);
1223 	/* Disable queue sorting for non-rotational media by default. */
1224 	if (cgd->ident_data.media_rotation_rate == ATA_RATE_NON_ROTATING)
1225 		softc->sort_io_queue = 0;
1226 	else
1227 		softc->sort_io_queue = -1;
1228 	adagetparams(periph, cgd);
1229 	softc->disk = disk_alloc();
1230 	softc->disk->d_rotation_rate = cgd->ident_data.media_rotation_rate;
1231 	softc->disk->d_devstat = devstat_new_entry(periph->periph_name,
1232 			  periph->unit_number, softc->params.secsize,
1233 			  DEVSTAT_ALL_SUPPORTED,
1234 			  DEVSTAT_TYPE_DIRECT |
1235 			  XPORT_DEVSTAT_TYPE(cpi.transport),
1236 			  DEVSTAT_PRIORITY_DISK);
1237 	softc->disk->d_open = adaopen;
1238 	softc->disk->d_close = adaclose;
1239 	softc->disk->d_strategy = adastrategy;
1240 	softc->disk->d_getattr = adagetattr;
1241 	softc->disk->d_dump = adadump;
1242 	softc->disk->d_gone = adadiskgonecb;
1243 	softc->disk->d_name = "ada";
1244 	softc->disk->d_drv1 = periph;
1245 	maxio = cpi.maxio;		/* Honor max I/O size of SIM */
1246 	if (maxio == 0)
1247 		maxio = DFLTPHYS;	/* traditional default */
1248 	else if (maxio > MAXPHYS)
1249 		maxio = MAXPHYS;	/* for safety */
1250 	if (softc->flags & ADA_FLAG_CAN_48BIT)
1251 		maxio = min(maxio, 65536 * softc->params.secsize);
1252 	else					/* 28bit ATA command limit */
1253 		maxio = min(maxio, 256 * softc->params.secsize);
1254 	softc->disk->d_maxsize = maxio;
1255 	softc->disk->d_unit = periph->unit_number;
1256 	softc->disk->d_flags = DISKFLAG_DIRECT_COMPLETION;
1257 	if (softc->flags & ADA_FLAG_CAN_FLUSHCACHE)
1258 		softc->disk->d_flags |= DISKFLAG_CANFLUSHCACHE;
1259 	if (softc->flags & ADA_FLAG_CAN_TRIM) {
1260 		softc->disk->d_flags |= DISKFLAG_CANDELETE;
1261 		softc->disk->d_delmaxsize = softc->params.secsize *
1262 					    ATA_DSM_RANGE_MAX *
1263 					    softc->trim_max_ranges;
1264 	} else if ((softc->flags & ADA_FLAG_CAN_CFA) &&
1265 	    !(softc->flags & ADA_FLAG_CAN_48BIT)) {
1266 		softc->disk->d_flags |= DISKFLAG_CANDELETE;
1267 		softc->disk->d_delmaxsize = 256 * softc->params.secsize;
1268 	} else
1269 		softc->disk->d_delmaxsize = maxio;
1270 	if ((cpi.hba_misc & PIM_UNMAPPED) != 0)
1271 		softc->disk->d_flags |= DISKFLAG_UNMAPPED_BIO;
1272 	strlcpy(softc->disk->d_descr, cgd->ident_data.model,
1273 	    MIN(sizeof(softc->disk->d_descr), sizeof(cgd->ident_data.model)));
1274 	strlcpy(softc->disk->d_ident, cgd->ident_data.serial,
1275 	    MIN(sizeof(softc->disk->d_ident), sizeof(cgd->ident_data.serial)));
1276 	softc->disk->d_hba_vendor = cpi.hba_vendor;
1277 	softc->disk->d_hba_device = cpi.hba_device;
1278 	softc->disk->d_hba_subvendor = cpi.hba_subvendor;
1279 	softc->disk->d_hba_subdevice = cpi.hba_subdevice;
1280 
1281 	softc->disk->d_sectorsize = softc->params.secsize;
1282 	softc->disk->d_mediasize = (off_t)softc->params.sectors *
1283 	    softc->params.secsize;
1284 	if (ata_physical_sector_size(&cgd->ident_data) !=
1285 	    softc->params.secsize) {
1286 		softc->disk->d_stripesize =
1287 		    ata_physical_sector_size(&cgd->ident_data);
1288 		softc->disk->d_stripeoffset = (softc->disk->d_stripesize -
1289 		    ata_logical_sector_offset(&cgd->ident_data)) %
1290 		    softc->disk->d_stripesize;
1291 	} else if (softc->quirks & ADA_Q_4K) {
1292 		softc->disk->d_stripesize = 4096;
1293 		softc->disk->d_stripeoffset = 0;
1294 	}
1295 	softc->disk->d_fwsectors = softc->params.secs_per_track;
1296 	softc->disk->d_fwheads = softc->params.heads;
1297 	ata_disk_firmware_geom_adjust(softc->disk);
1298 
1299 	if (ada_legacy_aliases) {
1300 #ifdef ATA_STATIC_ID
1301 		legacy_id = xpt_path_legacy_ata_id(periph->path);
1302 #else
1303 		legacy_id = softc->disk->d_unit;
1304 #endif
1305 		if (legacy_id >= 0) {
1306 			snprintf(announce_buf, sizeof(announce_buf),
1307 			    "kern.devalias.%s%d",
1308 			    softc->disk->d_name, softc->disk->d_unit);
1309 			snprintf(buf1, sizeof(buf1),
1310 			    "ad%d", legacy_id);
1311 			setenv(announce_buf, buf1);
1312 		}
1313 	} else
1314 		legacy_id = -1;
1315 	/*
1316 	 * Acquire a reference to the periph before we register with GEOM.
1317 	 * We'll release this reference once GEOM calls us back (via
1318 	 * adadiskgonecb()) telling us that our provider has been freed.
1319 	 */
1320 	if (cam_periph_acquire(periph) != CAM_REQ_CMP) {
1321 		xpt_print(periph->path, "%s: lost periph during "
1322 			  "registration!\n", __func__);
1323 		cam_periph_lock(periph);
1324 		return (CAM_REQ_CMP_ERR);
1325 	}
1326 	disk_create(softc->disk, DISK_VERSION);
1327 	cam_periph_lock(periph);
1328 	cam_periph_unhold(periph);
1329 
1330 	dp = &softc->params;
1331 	snprintf(announce_buf, sizeof(announce_buf),
1332 		"%juMB (%ju %u byte sectors: %dH %dS/T %dC)",
1333 		(uintmax_t)(((uintmax_t)dp->secsize *
1334 		dp->sectors) / (1024*1024)),
1335 		(uintmax_t)dp->sectors,
1336 		dp->secsize, dp->heads,
1337 		dp->secs_per_track, dp->cylinders);
1338 	xpt_announce_periph(periph, announce_buf);
1339 	xpt_announce_quirks(periph, softc->quirks, ADA_Q_BIT_STRING);
1340 	if (legacy_id >= 0)
1341 		printf("%s%d: Previously was known as ad%d\n",
1342 		       periph->periph_name, periph->unit_number, legacy_id);
1343 
1344 	/*
1345 	 * Create our sysctl variables, now that we know
1346 	 * we have successfully attached.
1347 	 */
1348 	if (cam_periph_acquire(periph) == CAM_REQ_CMP)
1349 		taskqueue_enqueue(taskqueue_thread, &softc->sysctl_task);
1350 
1351 	/*
1352 	 * Add async callbacks for bus reset and
1353 	 * bus device reset calls.  I don't bother
1354 	 * checking if this fails as, in most cases,
1355 	 * the system will function just fine without
1356 	 * them and the only alternative would be to
1357 	 * not attach the device on failure.
1358 	 */
1359 	xpt_register_async(AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE |
1360 	    AC_GETDEV_CHANGED | AC_ADVINFO_CHANGED,
1361 	    adaasync, periph, periph->path);
1362 
1363 	/*
1364 	 * Schedule a periodic event to occasionally send an
1365 	 * ordered tag to a device.
1366 	 */
1367 	callout_init_mtx(&softc->sendordered_c, cam_periph_mtx(periph), 0);
1368 	callout_reset(&softc->sendordered_c,
1369 	    (ada_default_timeout * hz) / ADA_ORDEREDTAG_INTERVAL,
1370 	    adasendorderedtag, softc);
1371 
1372 	if (ADA_RA >= 0 &&
1373 	    cgd->ident_data.support.command1 & ATA_SUPPORT_LOOKAHEAD) {
1374 		softc->state = ADA_STATE_RAHEAD;
1375 	} else if (ADA_WC >= 0 &&
1376 	    cgd->ident_data.support.command1 & ATA_SUPPORT_WRITECACHE) {
1377 		softc->state = ADA_STATE_WCACHE;
1378 	} else {
1379 		softc->state = ADA_STATE_NORMAL;
1380 		return(CAM_REQ_CMP);
1381 	}
1382 	if (cam_periph_acquire(periph) != CAM_REQ_CMP)
1383 		softc->state = ADA_STATE_NORMAL;
1384 	else
1385 		xpt_schedule(periph, CAM_PRIORITY_DEV);
1386 	return(CAM_REQ_CMP);
1387 }
1388 
1389 static void
1390 adastart(struct cam_periph *periph, union ccb *start_ccb)
1391 {
1392 	struct ada_softc *softc = (struct ada_softc *)periph->softc;
1393 	struct ccb_ataio *ataio = &start_ccb->ataio;
1394 
1395 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("adastart\n"));
1396 
1397 	switch (softc->state) {
1398 	case ADA_STATE_NORMAL:
1399 	{
1400 		struct bio *bp;
1401 		u_int8_t tag_code;
1402 
1403 		/* Run TRIM if not running yet. */
1404 		if (!softc->trim_running &&
1405 		    (bp = bioq_first(&softc->trim_queue)) != 0) {
1406 			struct trim_request *req = &softc->trim_req;
1407 			struct bio *bp1;
1408 			uint64_t lastlba = (uint64_t)-1;
1409 			int c, lastcount = 0, off, ranges = 0;
1410 
1411 			softc->trim_running = 1;
1412 			bzero(req, sizeof(*req));
1413 			TAILQ_INIT(&req->bps);
1414 			bp1 = bp;
1415 			do {
1416 				uint64_t lba = bp1->bio_pblkno;
1417 				int count = bp1->bio_bcount /
1418 				    softc->params.secsize;
1419 
1420 				bioq_remove(&softc->trim_queue, bp1);
1421 
1422 				/* Try to extend the previous range. */
1423 				if (lba == lastlba) {
1424 					c = min(count, ATA_DSM_RANGE_MAX - lastcount);
1425 					lastcount += c;
1426 					off = (ranges - 1) * ATA_DSM_RANGE_SIZE;
1427 					req->data[off + 6] = lastcount & 0xff;
1428 					req->data[off + 7] =
1429 					    (lastcount >> 8) & 0xff;
1430 					count -= c;
1431 					lba += c;
1432 				}
1433 
1434 				while (count > 0) {
1435 					c = min(count, ATA_DSM_RANGE_MAX);
1436 					off = ranges * ATA_DSM_RANGE_SIZE;
1437 					req->data[off + 0] = lba & 0xff;
1438 					req->data[off + 1] = (lba >> 8) & 0xff;
1439 					req->data[off + 2] = (lba >> 16) & 0xff;
1440 					req->data[off + 3] = (lba >> 24) & 0xff;
1441 					req->data[off + 4] = (lba >> 32) & 0xff;
1442 					req->data[off + 5] = (lba >> 40) & 0xff;
1443 					req->data[off + 6] = c & 0xff;
1444 					req->data[off + 7] = (c >> 8) & 0xff;
1445 					lba += c;
1446 					count -= c;
1447 					lastcount = c;
1448 					ranges++;
1449 					/*
1450 					 * Its the caller's responsibility to ensure the
1451 					 * request will fit so we don't need to check for
1452 					 * overrun here
1453 					 */
1454 				}
1455 				lastlba = lba;
1456 				TAILQ_INSERT_TAIL(&req->bps, bp1, bio_queue);
1457 				bp1 = bioq_first(&softc->trim_queue);
1458 				if (bp1 == NULL ||
1459 				    bp1->bio_bcount / softc->params.secsize >
1460 				    (softc->trim_max_ranges - ranges) *
1461 				    ATA_DSM_RANGE_MAX)
1462 					break;
1463 			} while (1);
1464 			cam_fill_ataio(ataio,
1465 			    ada_retry_count,
1466 			    adadone,
1467 			    CAM_DIR_OUT,
1468 			    0,
1469 			    req->data,
1470 			    ((ranges + ATA_DSM_BLK_RANGES - 1) /
1471 			        ATA_DSM_BLK_RANGES) * ATA_DSM_BLK_SIZE,
1472 			    ada_default_timeout * 1000);
1473 			ata_48bit_cmd(ataio, ATA_DATA_SET_MANAGEMENT,
1474 			    ATA_DSM_TRIM, 0, (ranges + ATA_DSM_BLK_RANGES -
1475 			    1) / ATA_DSM_BLK_RANGES);
1476 			start_ccb->ccb_h.ccb_state = ADA_CCB_TRIM;
1477 			start_ccb->ccb_h.flags |= CAM_UNLOCKED;
1478 			goto out;
1479 		}
1480 		/* Run regular command. */
1481 		bp = bioq_first(&softc->bio_queue);
1482 		if (bp == NULL) {
1483 			xpt_release_ccb(start_ccb);
1484 			break;
1485 		}
1486 		bioq_remove(&softc->bio_queue, bp);
1487 
1488 		if ((bp->bio_flags & BIO_ORDERED) != 0
1489 		 || (softc->flags & ADA_FLAG_NEED_OTAG) != 0) {
1490 			softc->flags &= ~ADA_FLAG_NEED_OTAG;
1491 			softc->flags |= ADA_FLAG_WAS_OTAG;
1492 			tag_code = 0;
1493 		} else {
1494 			tag_code = 1;
1495 		}
1496 		switch (bp->bio_cmd) {
1497 		case BIO_WRITE:
1498 			softc->flags |= ADA_FLAG_DIRTY;
1499 			/* FALLTHROUGH */
1500 		case BIO_READ:
1501 		{
1502 			uint64_t lba = bp->bio_pblkno;
1503 			uint16_t count = bp->bio_bcount / softc->params.secsize;
1504 #ifdef ADA_TEST_FAILURE
1505 			int fail = 0;
1506 
1507 			/*
1508 			 * Support the failure ioctls.  If the command is a
1509 			 * read, and there are pending forced read errors, or
1510 			 * if a write and pending write errors, then fail this
1511 			 * operation with EIO.  This is useful for testing
1512 			 * purposes.  Also, support having every Nth read fail.
1513 			 *
1514 			 * This is a rather blunt tool.
1515 			 */
1516 			if (bp->bio_cmd == BIO_READ) {
1517 				if (softc->force_read_error) {
1518 					softc->force_read_error--;
1519 					fail = 1;
1520 				}
1521 				if (softc->periodic_read_error > 0) {
1522 					if (++softc->periodic_read_count >=
1523 					    softc->periodic_read_error) {
1524 						softc->periodic_read_count = 0;
1525 						fail = 1;
1526 					}
1527 				}
1528 			} else {
1529 				if (softc->force_write_error) {
1530 					softc->force_write_error--;
1531 					fail = 1;
1532 				}
1533 			}
1534 			if (fail) {
1535 				bp->bio_error = EIO;
1536 				bp->bio_flags |= BIO_ERROR;
1537 				biodone(bp);
1538 				xpt_release_ccb(start_ccb);
1539 				adaschedule(periph);
1540 				return;
1541 			}
1542 #endif
1543 			KASSERT((bp->bio_flags & BIO_UNMAPPED) == 0 ||
1544 			    round_page(bp->bio_bcount + bp->bio_ma_offset) /
1545 			    PAGE_SIZE == bp->bio_ma_n,
1546 			    ("Short bio %p", bp));
1547 			cam_fill_ataio(ataio,
1548 			    ada_retry_count,
1549 			    adadone,
1550 			    (bp->bio_cmd == BIO_READ ? CAM_DIR_IN :
1551 				CAM_DIR_OUT) | ((bp->bio_flags & BIO_UNMAPPED)
1552 				!= 0 ? CAM_DATA_BIO : 0),
1553 			    tag_code,
1554 			    ((bp->bio_flags & BIO_UNMAPPED) != 0) ? (void *)bp :
1555 				bp->bio_data,
1556 			    bp->bio_bcount,
1557 			    ada_default_timeout*1000);
1558 
1559 			if ((softc->flags & ADA_FLAG_CAN_NCQ) && tag_code) {
1560 				if (bp->bio_cmd == BIO_READ) {
1561 					ata_ncq_cmd(ataio, ATA_READ_FPDMA_QUEUED,
1562 					    lba, count);
1563 				} else {
1564 					ata_ncq_cmd(ataio, ATA_WRITE_FPDMA_QUEUED,
1565 					    lba, count);
1566 				}
1567 			} else if ((softc->flags & ADA_FLAG_CAN_48BIT) &&
1568 			    (lba + count >= ATA_MAX_28BIT_LBA ||
1569 			    count > 256)) {
1570 				if (softc->flags & ADA_FLAG_CAN_DMA48) {
1571 					if (bp->bio_cmd == BIO_READ) {
1572 						ata_48bit_cmd(ataio, ATA_READ_DMA48,
1573 						    0, lba, count);
1574 					} else {
1575 						ata_48bit_cmd(ataio, ATA_WRITE_DMA48,
1576 						    0, lba, count);
1577 					}
1578 				} else {
1579 					if (bp->bio_cmd == BIO_READ) {
1580 						ata_48bit_cmd(ataio, ATA_READ_MUL48,
1581 						    0, lba, count);
1582 					} else {
1583 						ata_48bit_cmd(ataio, ATA_WRITE_MUL48,
1584 						    0, lba, count);
1585 					}
1586 				}
1587 			} else {
1588 				if (count == 256)
1589 					count = 0;
1590 				if (softc->flags & ADA_FLAG_CAN_DMA) {
1591 					if (bp->bio_cmd == BIO_READ) {
1592 						ata_28bit_cmd(ataio, ATA_READ_DMA,
1593 						    0, lba, count);
1594 					} else {
1595 						ata_28bit_cmd(ataio, ATA_WRITE_DMA,
1596 						    0, lba, count);
1597 					}
1598 				} else {
1599 					if (bp->bio_cmd == BIO_READ) {
1600 						ata_28bit_cmd(ataio, ATA_READ_MUL,
1601 						    0, lba, count);
1602 					} else {
1603 						ata_28bit_cmd(ataio, ATA_WRITE_MUL,
1604 						    0, lba, count);
1605 					}
1606 				}
1607 			}
1608 			break;
1609 		}
1610 		case BIO_DELETE:
1611 		{
1612 			uint64_t lba = bp->bio_pblkno;
1613 			uint16_t count = bp->bio_bcount / softc->params.secsize;
1614 
1615 			cam_fill_ataio(ataio,
1616 			    ada_retry_count,
1617 			    adadone,
1618 			    CAM_DIR_NONE,
1619 			    0,
1620 			    NULL,
1621 			    0,
1622 			    ada_default_timeout*1000);
1623 
1624 			if (count >= 256)
1625 				count = 0;
1626 			ata_28bit_cmd(ataio, ATA_CFA_ERASE, 0, lba, count);
1627 			break;
1628 		}
1629 		case BIO_FLUSH:
1630 			cam_fill_ataio(ataio,
1631 			    1,
1632 			    adadone,
1633 			    CAM_DIR_NONE,
1634 			    0,
1635 			    NULL,
1636 			    0,
1637 			    ada_default_timeout*1000);
1638 
1639 			if (softc->flags & ADA_FLAG_CAN_48BIT)
1640 				ata_48bit_cmd(ataio, ATA_FLUSHCACHE48, 0, 0, 0);
1641 			else
1642 				ata_28bit_cmd(ataio, ATA_FLUSHCACHE, 0, 0, 0);
1643 			break;
1644 		}
1645 		start_ccb->ccb_h.ccb_state = ADA_CCB_BUFFER_IO;
1646 		start_ccb->ccb_h.flags |= CAM_UNLOCKED;
1647 out:
1648 		start_ccb->ccb_h.ccb_bp = bp;
1649 		softc->outstanding_cmds++;
1650 		softc->refcount++;
1651 		cam_periph_unlock(periph);
1652 		xpt_action(start_ccb);
1653 		cam_periph_lock(periph);
1654 		softc->refcount--;
1655 
1656 		/* May have more work to do, so ensure we stay scheduled */
1657 		adaschedule(periph);
1658 		break;
1659 	}
1660 	case ADA_STATE_RAHEAD:
1661 	case ADA_STATE_WCACHE:
1662 	{
1663 		cam_fill_ataio(ataio,
1664 		    1,
1665 		    adadone,
1666 		    CAM_DIR_NONE,
1667 		    0,
1668 		    NULL,
1669 		    0,
1670 		    ada_default_timeout*1000);
1671 
1672 		if (softc->state == ADA_STATE_RAHEAD) {
1673 			ata_28bit_cmd(ataio, ATA_SETFEATURES, ADA_RA ?
1674 			    ATA_SF_ENAB_RCACHE : ATA_SF_DIS_RCACHE, 0, 0);
1675 			start_ccb->ccb_h.ccb_state = ADA_CCB_RAHEAD;
1676 		} else {
1677 			ata_28bit_cmd(ataio, ATA_SETFEATURES, ADA_WC ?
1678 			    ATA_SF_ENAB_WCACHE : ATA_SF_DIS_WCACHE, 0, 0);
1679 			start_ccb->ccb_h.ccb_state = ADA_CCB_WCACHE;
1680 		}
1681 		start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
1682 		xpt_action(start_ccb);
1683 		break;
1684 	}
1685 	}
1686 }
1687 
1688 static void
1689 adadone(struct cam_periph *periph, union ccb *done_ccb)
1690 {
1691 	struct ada_softc *softc;
1692 	struct ccb_ataio *ataio;
1693 	struct ccb_getdev *cgd;
1694 	struct cam_path *path;
1695 	int state;
1696 
1697 	softc = (struct ada_softc *)periph->softc;
1698 	ataio = &done_ccb->ataio;
1699 	path = done_ccb->ccb_h.path;
1700 
1701 	CAM_DEBUG(path, CAM_DEBUG_TRACE, ("adadone\n"));
1702 
1703 	state = ataio->ccb_h.ccb_state & ADA_CCB_TYPE_MASK;
1704 	switch (state) {
1705 	case ADA_CCB_BUFFER_IO:
1706 	case ADA_CCB_TRIM:
1707 	{
1708 		struct bio *bp;
1709 		int error;
1710 
1711 		cam_periph_lock(periph);
1712 		if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1713 			error = adaerror(done_ccb, 0, 0);
1714 			if (error == ERESTART) {
1715 				/* A retry was scheduled, so just return. */
1716 				cam_periph_unlock(periph);
1717 				return;
1718 			}
1719 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
1720 				cam_release_devq(path,
1721 						 /*relsim_flags*/0,
1722 						 /*reduction*/0,
1723 						 /*timeout*/0,
1724 						 /*getcount_only*/0);
1725 		} else {
1726 			if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0)
1727 				panic("REQ_CMP with QFRZN");
1728 			error = 0;
1729 		}
1730 		bp = (struct bio *)done_ccb->ccb_h.ccb_bp;
1731 		bp->bio_error = error;
1732 		if (error != 0) {
1733 			bp->bio_resid = bp->bio_bcount;
1734 			bp->bio_flags |= BIO_ERROR;
1735 		} else {
1736 			if (state == ADA_CCB_TRIM)
1737 				bp->bio_resid = 0;
1738 			else
1739 				bp->bio_resid = ataio->resid;
1740 			if (bp->bio_resid > 0)
1741 				bp->bio_flags |= BIO_ERROR;
1742 		}
1743 		softc->outstanding_cmds--;
1744 		if (softc->outstanding_cmds == 0)
1745 			softc->flags |= ADA_FLAG_WAS_OTAG;
1746 		xpt_release_ccb(done_ccb);
1747 		if (state == ADA_CCB_TRIM) {
1748 			TAILQ_HEAD(, bio) queue;
1749 			struct bio *bp1;
1750 
1751 			TAILQ_INIT(&queue);
1752 			TAILQ_CONCAT(&queue, &softc->trim_req.bps, bio_queue);
1753 			softc->trim_running = 0;
1754 			adaschedule(periph);
1755 			cam_periph_unlock(periph);
1756 			while ((bp1 = TAILQ_FIRST(&queue)) != NULL) {
1757 				TAILQ_REMOVE(&queue, bp1, bio_queue);
1758 				bp1->bio_error = error;
1759 				if (error != 0) {
1760 					bp1->bio_flags |= BIO_ERROR;
1761 					bp1->bio_resid = bp1->bio_bcount;
1762 				} else
1763 					bp1->bio_resid = 0;
1764 				biodone(bp1);
1765 			}
1766 		} else {
1767 			cam_periph_unlock(periph);
1768 			biodone(bp);
1769 		}
1770 		return;
1771 	}
1772 	case ADA_CCB_RAHEAD:
1773 	{
1774 		if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1775 			if (adaerror(done_ccb, 0, 0) == ERESTART) {
1776 out:
1777 				/* Drop freeze taken due to CAM_DEV_QFREEZE */
1778 				cam_release_devq(path, 0, 0, 0, FALSE);
1779 				return;
1780 			} else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
1781 				cam_release_devq(path,
1782 				    /*relsim_flags*/0,
1783 				    /*reduction*/0,
1784 				    /*timeout*/0,
1785 				    /*getcount_only*/0);
1786 			}
1787 		}
1788 
1789 		/*
1790 		 * Since our peripheral may be invalidated by an error
1791 		 * above or an external event, we must release our CCB
1792 		 * before releasing the reference on the peripheral.
1793 		 * The peripheral will only go away once the last reference
1794 		 * is removed, and we need it around for the CCB release
1795 		 * operation.
1796 		 */
1797 		cgd = (struct ccb_getdev *)done_ccb;
1798 		xpt_setup_ccb(&cgd->ccb_h, path, CAM_PRIORITY_NORMAL);
1799 		cgd->ccb_h.func_code = XPT_GDEV_TYPE;
1800 		xpt_action((union ccb *)cgd);
1801 		if (ADA_WC >= 0 &&
1802 		    cgd->ident_data.support.command1 & ATA_SUPPORT_WRITECACHE) {
1803 			softc->state = ADA_STATE_WCACHE;
1804 			xpt_release_ccb(done_ccb);
1805 			xpt_schedule(periph, CAM_PRIORITY_DEV);
1806 			goto out;
1807 		}
1808 		softc->state = ADA_STATE_NORMAL;
1809 		xpt_release_ccb(done_ccb);
1810 		/* Drop freeze taken due to CAM_DEV_QFREEZE */
1811 		cam_release_devq(path, 0, 0, 0, FALSE);
1812 		adaschedule(periph);
1813 		cam_periph_release_locked(periph);
1814 		return;
1815 	}
1816 	case ADA_CCB_WCACHE:
1817 	{
1818 		if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
1819 			if (adaerror(done_ccb, 0, 0) == ERESTART) {
1820 				goto out;
1821 			} else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
1822 				cam_release_devq(path,
1823 				    /*relsim_flags*/0,
1824 				    /*reduction*/0,
1825 				    /*timeout*/0,
1826 				    /*getcount_only*/0);
1827 			}
1828 		}
1829 
1830 		softc->state = ADA_STATE_NORMAL;
1831 		/*
1832 		 * Since our peripheral may be invalidated by an error
1833 		 * above or an external event, we must release our CCB
1834 		 * before releasing the reference on the peripheral.
1835 		 * The peripheral will only go away once the last reference
1836 		 * is removed, and we need it around for the CCB release
1837 		 * operation.
1838 		 */
1839 		xpt_release_ccb(done_ccb);
1840 		/* Drop freeze taken due to CAM_DEV_QFREEZE */
1841 		cam_release_devq(path, 0, 0, 0, FALSE);
1842 		adaschedule(periph);
1843 		cam_periph_release_locked(periph);
1844 		return;
1845 	}
1846 	case ADA_CCB_DUMP:
1847 		/* No-op.  We're polling */
1848 		return;
1849 	default:
1850 		break;
1851 	}
1852 	xpt_release_ccb(done_ccb);
1853 }
1854 
1855 static int
1856 adaerror(union ccb *ccb, u_int32_t cam_flags, u_int32_t sense_flags)
1857 {
1858 
1859 	return(cam_periph_error(ccb, cam_flags, sense_flags, NULL));
1860 }
1861 
1862 static void
1863 adagetparams(struct cam_periph *periph, struct ccb_getdev *cgd)
1864 {
1865 	struct ada_softc *softc = (struct ada_softc *)periph->softc;
1866 	struct disk_params *dp = &softc->params;
1867 	u_int64_t lbasize48;
1868 	u_int32_t lbasize;
1869 
1870 	dp->secsize = ata_logical_sector_size(&cgd->ident_data);
1871 	if ((cgd->ident_data.atavalid & ATA_FLAG_54_58) &&
1872 		cgd->ident_data.current_heads && cgd->ident_data.current_sectors) {
1873 		dp->heads = cgd->ident_data.current_heads;
1874 		dp->secs_per_track = cgd->ident_data.current_sectors;
1875 		dp->cylinders = cgd->ident_data.cylinders;
1876 		dp->sectors = (u_int32_t)cgd->ident_data.current_size_1 |
1877 			  ((u_int32_t)cgd->ident_data.current_size_2 << 16);
1878 	} else {
1879 		dp->heads = cgd->ident_data.heads;
1880 		dp->secs_per_track = cgd->ident_data.sectors;
1881 		dp->cylinders = cgd->ident_data.cylinders;
1882 		dp->sectors = cgd->ident_data.cylinders * dp->heads * dp->secs_per_track;
1883 	}
1884 	lbasize = (u_int32_t)cgd->ident_data.lba_size_1 |
1885 		  ((u_int32_t)cgd->ident_data.lba_size_2 << 16);
1886 
1887 	/* use the 28bit LBA size if valid or bigger than the CHS mapping */
1888 	if (cgd->ident_data.cylinders == 16383 || dp->sectors < lbasize)
1889 		dp->sectors = lbasize;
1890 
1891 	/* use the 48bit LBA size if valid */
1892 	lbasize48 = ((u_int64_t)cgd->ident_data.lba_size48_1) |
1893 		    ((u_int64_t)cgd->ident_data.lba_size48_2 << 16) |
1894 		    ((u_int64_t)cgd->ident_data.lba_size48_3 << 32) |
1895 		    ((u_int64_t)cgd->ident_data.lba_size48_4 << 48);
1896 	if ((cgd->ident_data.support.command2 & ATA_SUPPORT_ADDRESS48) &&
1897 	    lbasize48 > ATA_MAX_28BIT_LBA)
1898 		dp->sectors = lbasize48;
1899 }
1900 
1901 static void
1902 adasendorderedtag(void *arg)
1903 {
1904 	struct ada_softc *softc = arg;
1905 
1906 	if (ada_send_ordered) {
1907 		if (softc->outstanding_cmds > 0) {
1908 			if ((softc->flags & ADA_FLAG_WAS_OTAG) == 0)
1909 				softc->flags |= ADA_FLAG_NEED_OTAG;
1910 			softc->flags &= ~ADA_FLAG_WAS_OTAG;
1911 		}
1912 	}
1913 	/* Queue us up again */
1914 	callout_reset(&softc->sendordered_c,
1915 	    (ada_default_timeout * hz) / ADA_ORDEREDTAG_INTERVAL,
1916 	    adasendorderedtag, softc);
1917 }
1918 
1919 /*
1920  * Step through all ADA peripheral drivers, and if the device is still open,
1921  * sync the disk cache to physical media.
1922  */
1923 static void
1924 adaflush(void)
1925 {
1926 	struct cam_periph *periph;
1927 	struct ada_softc *softc;
1928 	union ccb *ccb;
1929 	int error;
1930 
1931 	CAM_PERIPH_FOREACH(periph, &adadriver) {
1932 		softc = (struct ada_softc *)periph->softc;
1933 		if (SCHEDULER_STOPPED()) {
1934 			/* If we paniced with the lock held, do not recurse. */
1935 			if (!cam_periph_owned(periph) &&
1936 			    (softc->flags & ADA_FLAG_OPEN)) {
1937 				adadump(softc->disk, NULL, 0, 0, 0);
1938 			}
1939 			continue;
1940 		}
1941 		cam_periph_lock(periph);
1942 		/*
1943 		 * We only sync the cache if the drive is still open, and
1944 		 * if the drive is capable of it..
1945 		 */
1946 		if (((softc->flags & ADA_FLAG_OPEN) == 0) ||
1947 		    (softc->flags & ADA_FLAG_CAN_FLUSHCACHE) == 0) {
1948 			cam_periph_unlock(periph);
1949 			continue;
1950 		}
1951 
1952 		ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
1953 		cam_fill_ataio(&ccb->ataio,
1954 				    0,
1955 				    adadone,
1956 				    CAM_DIR_NONE,
1957 				    0,
1958 				    NULL,
1959 				    0,
1960 				    ada_default_timeout*1000);
1961 		if (softc->flags & ADA_FLAG_CAN_48BIT)
1962 			ata_48bit_cmd(&ccb->ataio, ATA_FLUSHCACHE48, 0, 0, 0);
1963 		else
1964 			ata_28bit_cmd(&ccb->ataio, ATA_FLUSHCACHE, 0, 0, 0);
1965 
1966 		error = cam_periph_runccb(ccb, adaerror, /*cam_flags*/0,
1967 		    /*sense_flags*/ SF_NO_RECOVERY | SF_NO_RETRY,
1968 		    softc->disk->d_devstat);
1969 		if (error != 0)
1970 			xpt_print(periph->path, "Synchronize cache failed\n");
1971 		xpt_release_ccb(ccb);
1972 		cam_periph_unlock(periph);
1973 	}
1974 }
1975 
1976 static void
1977 adaspindown(uint8_t cmd, int flags)
1978 {
1979 	struct cam_periph *periph;
1980 	struct ada_softc *softc;
1981 	union ccb *ccb;
1982 	int error;
1983 
1984 	CAM_PERIPH_FOREACH(periph, &adadriver) {
1985 		/* If we paniced with lock held - not recurse here. */
1986 		if (cam_periph_owned(periph))
1987 			continue;
1988 		cam_periph_lock(periph);
1989 		softc = (struct ada_softc *)periph->softc;
1990 		/*
1991 		 * We only spin-down the drive if it is capable of it..
1992 		 */
1993 		if ((softc->flags & ADA_FLAG_CAN_POWERMGT) == 0) {
1994 			cam_periph_unlock(periph);
1995 			continue;
1996 		}
1997 
1998 		if (bootverbose)
1999 			xpt_print(periph->path, "spin-down\n");
2000 
2001 		ccb = cam_periph_getccb(periph, CAM_PRIORITY_NORMAL);
2002 		cam_fill_ataio(&ccb->ataio,
2003 				    0,
2004 				    adadone,
2005 				    CAM_DIR_NONE | flags,
2006 				    0,
2007 				    NULL,
2008 				    0,
2009 				    ada_default_timeout*1000);
2010 		ata_28bit_cmd(&ccb->ataio, cmd, 0, 0, 0);
2011 
2012 		error = cam_periph_runccb(ccb, adaerror, /*cam_flags*/0,
2013 		    /*sense_flags*/ SF_NO_RECOVERY | SF_NO_RETRY,
2014 		    softc->disk->d_devstat);
2015 		if (error != 0)
2016 			xpt_print(periph->path, "Spin-down disk failed\n");
2017 		xpt_release_ccb(ccb);
2018 		cam_periph_unlock(periph);
2019 	}
2020 }
2021 
2022 static void
2023 adashutdown(void *arg, int howto)
2024 {
2025 
2026 	adaflush();
2027 	if (ada_spindown_shutdown != 0 &&
2028 	    (howto & (RB_HALT | RB_POWEROFF)) != 0)
2029 		adaspindown(ATA_STANDBY_IMMEDIATE, 0);
2030 }
2031 
2032 static void
2033 adasuspend(void *arg)
2034 {
2035 
2036 	adaflush();
2037 	if (ada_spindown_suspend != 0)
2038 		adaspindown(ATA_SLEEP, CAM_DEV_QFREEZE);
2039 }
2040 
2041 static void
2042 adaresume(void *arg)
2043 {
2044 	struct cam_periph *periph;
2045 	struct ada_softc *softc;
2046 
2047 	if (ada_spindown_suspend == 0)
2048 		return;
2049 
2050 	CAM_PERIPH_FOREACH(periph, &adadriver) {
2051 		cam_periph_lock(periph);
2052 		softc = (struct ada_softc *)periph->softc;
2053 		/*
2054 		 * We only spin-down the drive if it is capable of it..
2055 		 */
2056 		if ((softc->flags & ADA_FLAG_CAN_POWERMGT) == 0) {
2057 			cam_periph_unlock(periph);
2058 			continue;
2059 		}
2060 
2061 		if (bootverbose)
2062 			xpt_print(periph->path, "resume\n");
2063 
2064 		/*
2065 		 * Drop freeze taken due to CAM_DEV_QFREEZE flag set on
2066 		 * sleep request.
2067 		 */
2068 		cam_release_devq(periph->path,
2069 			 /*relsim_flags*/0,
2070 			 /*openings*/0,
2071 			 /*timeout*/0,
2072 			 /*getcount_only*/0);
2073 
2074 		cam_periph_unlock(periph);
2075 	}
2076 }
2077 
2078 #endif /* _KERNEL */
2079