xref: /freebsd/sys/cam/ata/ata_pmp.c (revision 66fd12cf4896eb08ad8e7a2627537f84ead84dd3)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause
3  *
4  * Copyright (c) 2009 Alexander Motin <mav@FreeBSD.org>
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer,
12  *    without modification, immediately at the beginning of the file.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
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 <geom/geom_disk.h>
48 #endif /* _KERNEL */
49 
50 #ifndef _KERNEL
51 #include <stdio.h>
52 #include <string.h>
53 #endif /* _KERNEL */
54 
55 #include <cam/cam.h>
56 #include <cam/cam_ccb.h>
57 #include <cam/cam_periph.h>
58 #include <cam/cam_xpt_periph.h>
59 #include <cam/cam_xpt_internal.h>
60 #include <cam/cam_sim.h>
61 
62 #include <cam/ata/ata_all.h>
63 
64 #ifdef _KERNEL
65 
66 typedef enum {
67 	PMP_STATE_NORMAL,
68 	PMP_STATE_PORTS,
69 	PMP_STATE_PM_QUIRKS_1,
70 	PMP_STATE_PM_QUIRKS_2,
71 	PMP_STATE_PM_QUIRKS_3,
72 	PMP_STATE_PRECONFIG,
73 	PMP_STATE_RESET,
74 	PMP_STATE_CONNECT,
75 	PMP_STATE_CHECK,
76 	PMP_STATE_CLEAR,
77 	PMP_STATE_CONFIG,
78 	PMP_STATE_SCAN
79 } pmp_state;
80 
81 typedef enum {
82 	PMP_FLAG_SCTX_INIT	= 0x200
83 } pmp_flags;
84 
85 typedef enum {
86 	PMP_CCB_PROBE		= 0x01,
87 } pmp_ccb_state;
88 
89 /* Offsets into our private area for storing information */
90 #define ccb_state	ppriv_field0
91 #define ccb_bp		ppriv_ptr1
92 
93 struct pmp_softc {
94 	SLIST_ENTRY(pmp_softc)	links;
95 	pmp_state		state;
96 	pmp_flags		flags;
97 	uint32_t		pm_pid;
98 	uint32_t		pm_prv;
99 	int			pm_ports;
100 	int			pm_step;
101 	int			pm_try;
102 	int			found;
103 	int			reset;
104 	int			frozen;
105 	int			restart;
106 	int			events;
107 #define PMP_EV_RESET	1
108 #define PMP_EV_RESCAN	2
109 	u_int			caps;
110 	struct task		sysctl_task;
111 	struct sysctl_ctx_list	sysctl_ctx;
112 	struct sysctl_oid	*sysctl_tree;
113 };
114 
115 static	periph_init_t	pmpinit;
116 static	void		pmpasync(void *callback_arg, u_int32_t code,
117 				struct cam_path *path, void *arg);
118 static	void		pmpsysctlinit(void *context, int pending);
119 static	periph_ctor_t	pmpregister;
120 static	periph_dtor_t	pmpcleanup;
121 static	periph_start_t	pmpstart;
122 static	periph_oninv_t	pmponinvalidate;
123 static	void		pmpdone(struct cam_periph *periph,
124 			       union ccb *done_ccb);
125 
126 #ifndef PMP_DEFAULT_TIMEOUT
127 #define PMP_DEFAULT_TIMEOUT 30	/* Timeout in seconds */
128 #endif
129 
130 #ifndef	PMP_DEFAULT_RETRY
131 #define	PMP_DEFAULT_RETRY	1
132 #endif
133 
134 #ifndef	PMP_DEFAULT_HIDE_SPECIAL
135 #define	PMP_DEFAULT_HIDE_SPECIAL	1
136 #endif
137 
138 static int pmp_retry_count = PMP_DEFAULT_RETRY;
139 static int pmp_default_timeout = PMP_DEFAULT_TIMEOUT;
140 static int pmp_hide_special = PMP_DEFAULT_HIDE_SPECIAL;
141 
142 static SYSCTL_NODE(_kern_cam, OID_AUTO, pmp, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
143     "CAM Direct Access Disk driver");
144 SYSCTL_INT(_kern_cam_pmp, OID_AUTO, retry_count, CTLFLAG_RWTUN,
145            &pmp_retry_count, 0, "Normal I/O retry count");
146 SYSCTL_INT(_kern_cam_pmp, OID_AUTO, default_timeout, CTLFLAG_RWTUN,
147            &pmp_default_timeout, 0, "Normal I/O timeout (in seconds)");
148 SYSCTL_INT(_kern_cam_pmp, OID_AUTO, hide_special, CTLFLAG_RWTUN,
149            &pmp_hide_special, 0, "Hide extra ports");
150 
151 static struct periph_driver pmpdriver =
152 {
153 	pmpinit, "pmp",
154 	TAILQ_HEAD_INITIALIZER(pmpdriver.units), /* generation */ 0,
155 	CAM_PERIPH_DRV_EARLY
156 };
157 
158 PERIPHDRIVER_DECLARE(pmp, pmpdriver);
159 
160 static void
161 pmpinit(void)
162 {
163 	cam_status status;
164 
165 	/*
166 	 * Install a global async callback.  This callback will
167 	 * receive async callbacks like "new device found".
168 	 */
169 	status = xpt_register_async(AC_FOUND_DEVICE, pmpasync, NULL, NULL);
170 
171 	if (status != CAM_REQ_CMP) {
172 		printf("pmp: Failed to attach master async callback "
173 		       "due to status 0x%x!\n", status);
174 	}
175 }
176 
177 static void
178 pmpfreeze(struct cam_periph *periph, int mask)
179 {
180 	struct pmp_softc *softc = (struct pmp_softc *)periph->softc;
181 	struct cam_path *dpath;
182 	int i;
183 
184 	mask &= ~softc->frozen;
185 	for (i = 0; i < 15; i++) {
186 		if ((mask & (1 << i)) == 0)
187 			continue;
188 		if (xpt_create_path(&dpath, periph,
189 		    xpt_path_path_id(periph->path),
190 		    i, 0) == CAM_REQ_CMP) {
191 			softc->frozen |= (1 << i);
192 			xpt_acquire_device(dpath->device);
193 			cam_freeze_devq(dpath);
194 			xpt_free_path(dpath);
195 		}
196 	}
197 }
198 
199 static void
200 pmprelease(struct cam_periph *periph, int mask)
201 {
202 	struct pmp_softc *softc = (struct pmp_softc *)periph->softc;
203 	struct cam_path *dpath;
204 	int i;
205 
206 	mask &= softc->frozen;
207 	for (i = 0; i < 15; i++) {
208 		if ((mask & (1 << i)) == 0)
209 			continue;
210 		if (xpt_create_path(&dpath, periph,
211 		    xpt_path_path_id(periph->path),
212 		    i, 0) == CAM_REQ_CMP) {
213 			softc->frozen &= ~(1 << i);
214 			cam_release_devq(dpath, 0, 0, 0, FALSE);
215 			xpt_release_device(dpath->device);
216 			xpt_free_path(dpath);
217 		}
218 	}
219 }
220 
221 static void
222 pmponinvalidate(struct cam_periph *periph)
223 {
224 	struct cam_path *dpath;
225 	int i;
226 
227 	/*
228 	 * De-register any async callbacks.
229 	 */
230 	xpt_register_async(0, pmpasync, periph, periph->path);
231 
232 	for (i = 0; i < 15; i++) {
233 		if (xpt_create_path(&dpath, periph,
234 		    xpt_path_path_id(periph->path),
235 		    i, 0) == CAM_REQ_CMP) {
236 			xpt_async(AC_LOST_DEVICE, dpath, NULL);
237 			xpt_free_path(dpath);
238 		}
239 	}
240 	pmprelease(periph, -1);
241 }
242 
243 static void
244 pmpcleanup(struct cam_periph *periph)
245 {
246 	struct pmp_softc *softc;
247 
248 	softc = (struct pmp_softc *)periph->softc;
249 
250 	cam_periph_unlock(periph);
251 
252 	/*
253 	 * If we can't free the sysctl tree, oh well...
254 	 */
255 	if ((softc->flags & PMP_FLAG_SCTX_INIT) != 0
256 	    && sysctl_ctx_free(&softc->sysctl_ctx) != 0) {
257 		xpt_print(periph->path, "can't remove sysctl context\n");
258 	}
259 
260 	free(softc, M_DEVBUF);
261 	cam_periph_lock(periph);
262 }
263 
264 static void
265 pmpasync(void *callback_arg, u_int32_t code,
266 	struct cam_path *path, void *arg)
267 {
268 	struct cam_periph *periph;
269 	struct pmp_softc *softc;
270 
271 	periph = (struct cam_periph *)callback_arg;
272 	switch (code) {
273 	case AC_FOUND_DEVICE:
274 	{
275 		struct ccb_getdev *cgd;
276 		cam_status status;
277 
278 		cgd = (struct ccb_getdev *)arg;
279 		if (cgd == NULL)
280 			break;
281 
282 		if (cgd->protocol != PROTO_SATAPM)
283 			break;
284 
285 		/*
286 		 * Allocate a peripheral instance for
287 		 * this device and start the probe
288 		 * process.
289 		 */
290 		status = cam_periph_alloc(pmpregister, pmponinvalidate,
291 					  pmpcleanup, pmpstart,
292 					  "pmp", CAM_PERIPH_BIO,
293 					  path, pmpasync,
294 					  AC_FOUND_DEVICE, cgd);
295 
296 		if (status != CAM_REQ_CMP
297 		 && status != CAM_REQ_INPROG)
298 			printf("pmpasync: Unable to attach to new device "
299 				"due to status 0x%x\n", status);
300 		break;
301 	}
302 	case AC_SCSI_AEN:
303 	case AC_SENT_BDR:
304 	case AC_BUS_RESET:
305 		softc = (struct pmp_softc *)periph->softc;
306 		cam_periph_async(periph, code, path, arg);
307 		if (code == AC_SCSI_AEN)
308 			softc->events |= PMP_EV_RESCAN;
309 		else
310 			softc->events |= PMP_EV_RESET;
311 		if (code == AC_SCSI_AEN && softc->state != PMP_STATE_NORMAL)
312 			break;
313 		xpt_hold_boot();
314 		pmpfreeze(periph, softc->found);
315 		if (code == AC_SENT_BDR || code == AC_BUS_RESET)
316 			softc->found = 0; /* We have to reset everything. */
317 		if (softc->state == PMP_STATE_NORMAL) {
318 			if (cam_periph_acquire(periph) == 0) {
319 				if (softc->pm_pid == 0x37261095 ||
320 				    softc->pm_pid == 0x38261095)
321 					softc->state = PMP_STATE_PM_QUIRKS_1;
322 				else
323 					softc->state = PMP_STATE_PRECONFIG;
324 				xpt_schedule(periph, CAM_PRIORITY_DEV);
325 			} else {
326 				pmprelease(periph, softc->found);
327 				xpt_release_boot();
328 			}
329 		} else
330 			softc->restart = 1;
331 		break;
332 	default:
333 		cam_periph_async(periph, code, path, arg);
334 		break;
335 	}
336 }
337 
338 static void
339 pmpsysctlinit(void *context, int pending)
340 {
341 	struct cam_periph *periph;
342 	struct pmp_softc *softc;
343 	char tmpstr[32], tmpstr2[16];
344 
345 	periph = (struct cam_periph *)context;
346 	if (cam_periph_acquire(periph) != 0)
347 		return;
348 
349 	softc = (struct pmp_softc *)periph->softc;
350 	snprintf(tmpstr, sizeof(tmpstr), "CAM PMP unit %d", periph->unit_number);
351 	snprintf(tmpstr2, sizeof(tmpstr2), "%d", periph->unit_number);
352 
353 	sysctl_ctx_init(&softc->sysctl_ctx);
354 	softc->flags |= PMP_FLAG_SCTX_INIT;
355 	softc->sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&softc->sysctl_ctx,
356 		SYSCTL_STATIC_CHILDREN(_kern_cam_pmp), OID_AUTO, tmpstr2,
357 		CTLFLAG_RD | CTLFLAG_MPSAFE, 0, tmpstr, "device_index");
358 	if (softc->sysctl_tree == NULL) {
359 		printf("pmpsysctlinit: unable to allocate sysctl tree\n");
360 		cam_periph_release(periph);
361 		return;
362 	}
363 
364 	cam_periph_release(periph);
365 }
366 
367 static cam_status
368 pmpregister(struct cam_periph *periph, void *arg)
369 {
370 	struct pmp_softc *softc;
371 	struct ccb_getdev *cgd;
372 
373 	cgd = (struct ccb_getdev *)arg;
374 	if (cgd == NULL) {
375 		printf("pmpregister: no getdev CCB, can't register device\n");
376 		return(CAM_REQ_CMP_ERR);
377 	}
378 
379 	softc = (struct pmp_softc *)malloc(sizeof(*softc), M_DEVBUF,
380 	    M_NOWAIT|M_ZERO);
381 
382 	if (softc == NULL) {
383 		printf("pmpregister: Unable to probe new device. "
384 		       "Unable to allocate softc\n");
385 		return(CAM_REQ_CMP_ERR);
386 	}
387 	periph->softc = softc;
388 
389 	softc->pm_pid = ((uint32_t *)&cgd->ident_data)[0];
390 	softc->pm_prv = ((uint32_t *)&cgd->ident_data)[1];
391 	TASK_INIT(&softc->sysctl_task, 0, pmpsysctlinit, periph);
392 
393 	xpt_announce_periph(periph, NULL);
394 
395 	/*
396 	 * Add async callbacks for bus reset and
397 	 * bus device reset calls.  I don't bother
398 	 * checking if this fails as, in most cases,
399 	 * the system will function just fine without
400 	 * them and the only alternative would be to
401 	 * not attach the device on failure.
402 	 */
403 	xpt_register_async(AC_SENT_BDR | AC_BUS_RESET | AC_LOST_DEVICE |
404 		AC_SCSI_AEN, pmpasync, periph, periph->path);
405 
406 	/*
407 	 * Take an exclusive refcount on the periph while pmpstart is called
408 	 * to finish the probe.  The reference will be dropped in pmpdone at
409 	 * the end of probe.
410 	 */
411 	(void)cam_periph_acquire(periph);
412 	xpt_hold_boot();
413 	softc->state = PMP_STATE_PORTS;
414 	softc->events = PMP_EV_RESCAN;
415 	xpt_schedule(periph, CAM_PRIORITY_DEV);
416 
417 	return(CAM_REQ_CMP);
418 }
419 
420 static void
421 pmpstart(struct cam_periph *periph, union ccb *start_ccb)
422 {
423 	struct ccb_trans_settings cts;
424 	struct ccb_ataio *ataio;
425 	struct pmp_softc *softc;
426 	struct cam_path *dpath;
427 	int revision = 0;
428 
429 	softc = (struct pmp_softc *)periph->softc;
430 	ataio = &start_ccb->ataio;
431 
432 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("pmpstart\n"));
433 
434 	if (softc->restart) {
435 		softc->restart = 0;
436 		if (softc->pm_pid == 0x37261095 || softc->pm_pid == 0x38261095)
437 			softc->state = min(softc->state, PMP_STATE_PM_QUIRKS_1);
438 		else
439 			softc->state = min(softc->state, PMP_STATE_PRECONFIG);
440 	}
441 	/* Fetch user wanted device speed. */
442 	if (softc->state == PMP_STATE_RESET ||
443 	    softc->state == PMP_STATE_CONNECT) {
444 		if (xpt_create_path(&dpath, periph,
445 		    xpt_path_path_id(periph->path),
446 		    softc->pm_step, 0) == CAM_REQ_CMP) {
447 			bzero(&cts, sizeof(cts));
448 			xpt_setup_ccb(&cts.ccb_h, dpath, CAM_PRIORITY_NONE);
449 			cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
450 			cts.type = CTS_TYPE_USER_SETTINGS;
451 			xpt_action((union ccb *)&cts);
452 			if (cts.xport_specific.sata.valid & CTS_SATA_VALID_REVISION)
453 				revision = cts.xport_specific.sata.revision;
454 			xpt_free_path(dpath);
455 		}
456 	}
457 	switch (softc->state) {
458 	case PMP_STATE_PORTS:
459 		cam_fill_ataio(ataio,
460 		      pmp_retry_count,
461 		      pmpdone,
462 		      /*flags*/CAM_DIR_NONE,
463 		      0,
464 		      /*data_ptr*/NULL,
465 		      /*dxfer_len*/0,
466 		      pmp_default_timeout * 1000);
467 		ata_pm_read_cmd(ataio, 2, 15);
468 		break;
469 
470 	case PMP_STATE_PM_QUIRKS_1:
471 	case PMP_STATE_PM_QUIRKS_3:
472 		cam_fill_ataio(ataio,
473 		      pmp_retry_count,
474 		      pmpdone,
475 		      /*flags*/CAM_DIR_NONE,
476 		      0,
477 		      /*data_ptr*/NULL,
478 		      /*dxfer_len*/0,
479 		      pmp_default_timeout * 1000);
480 		ata_pm_read_cmd(ataio, 129, 15);
481 		break;
482 
483 	case PMP_STATE_PM_QUIRKS_2:
484 		cam_fill_ataio(ataio,
485 		      pmp_retry_count,
486 		      pmpdone,
487 		      /*flags*/CAM_DIR_NONE,
488 		      0,
489 		      /*data_ptr*/NULL,
490 		      /*dxfer_len*/0,
491 		      pmp_default_timeout * 1000);
492 		ata_pm_write_cmd(ataio, 129, 15, softc->caps & ~0x1);
493 		break;
494 
495 	case PMP_STATE_PRECONFIG:
496 		/* Get/update host SATA capabilities. */
497 		bzero(&cts, sizeof(cts));
498 		xpt_setup_ccb(&cts.ccb_h, periph->path, CAM_PRIORITY_NONE);
499 		cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
500 		cts.type = CTS_TYPE_CURRENT_SETTINGS;
501 		xpt_action((union ccb *)&cts);
502 		if (cts.xport_specific.sata.valid & CTS_SATA_VALID_CAPS)
503 			softc->caps = cts.xport_specific.sata.caps;
504 		else
505 			softc->caps = 0;
506 		cam_fill_ataio(ataio,
507 		      pmp_retry_count,
508 		      pmpdone,
509 		      /*flags*/CAM_DIR_NONE,
510 		      0,
511 		      /*data_ptr*/NULL,
512 		      /*dxfer_len*/0,
513 		      pmp_default_timeout * 1000);
514 		ata_pm_write_cmd(ataio, 0x60, 15, 0x0);
515 		break;
516 	case PMP_STATE_RESET:
517 		cam_fill_ataio(ataio,
518 		      pmp_retry_count,
519 		      pmpdone,
520 		      /*flags*/CAM_DIR_NONE,
521 		      0,
522 		      /*data_ptr*/NULL,
523 		      /*dxfer_len*/0,
524 		      pmp_default_timeout * 1000);
525 		ata_pm_write_cmd(ataio, 2, softc->pm_step,
526 		    (revision << 4) |
527 		    ((softc->found & (1 << softc->pm_step)) ? 0 : 1));
528 		break;
529 	case PMP_STATE_CONNECT:
530 		cam_fill_ataio(ataio,
531 		      pmp_retry_count,
532 		      pmpdone,
533 		      /*flags*/CAM_DIR_NONE,
534 		      0,
535 		      /*data_ptr*/NULL,
536 		      /*dxfer_len*/0,
537 		      pmp_default_timeout * 1000);
538 		ata_pm_write_cmd(ataio, 2, softc->pm_step,
539 		    (revision << 4));
540 		break;
541 	case PMP_STATE_CHECK:
542 		cam_fill_ataio(ataio,
543 		      pmp_retry_count,
544 		      pmpdone,
545 		      /*flags*/CAM_DIR_NONE,
546 		      0,
547 		      /*data_ptr*/NULL,
548 		      /*dxfer_len*/0,
549 		      pmp_default_timeout * 1000);
550 		ata_pm_read_cmd(ataio, 0, softc->pm_step);
551 		break;
552 	case PMP_STATE_CLEAR:
553 		softc->reset = 0;
554 		cam_fill_ataio(ataio,
555 		      pmp_retry_count,
556 		      pmpdone,
557 		      /*flags*/CAM_DIR_NONE,
558 		      0,
559 		      /*data_ptr*/NULL,
560 		      /*dxfer_len*/0,
561 		      pmp_default_timeout * 1000);
562 		ata_pm_write_cmd(ataio, 1, softc->pm_step, 0xFFFFFFFF);
563 		break;
564 	case PMP_STATE_CONFIG:
565 		cam_fill_ataio(ataio,
566 		      pmp_retry_count,
567 		      pmpdone,
568 		      /*flags*/CAM_DIR_NONE,
569 		      0,
570 		      /*data_ptr*/NULL,
571 		      /*dxfer_len*/0,
572 		      pmp_default_timeout * 1000);
573 		ata_pm_write_cmd(ataio, 0x60, 15, 0x07 |
574 		    ((softc->caps & CTS_SATA_CAPS_H_AN) ? 0x08 : 0));
575 		break;
576 	default:
577 		break;
578 	}
579 	xpt_action(start_ccb);
580 }
581 
582 static void
583 pmpdone(struct cam_periph *periph, union ccb *done_ccb)
584 {
585 	struct ccb_trans_settings cts;
586 	struct pmp_softc *softc;
587 	struct ccb_ataio *ataio;
588 	struct cam_path *dpath;
589 	u_int32_t  priority, res;
590 	int i;
591 
592 	softc = (struct pmp_softc *)periph->softc;
593 	ataio = &done_ccb->ataio;
594 
595 	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("pmpdone\n"));
596 
597 	priority = done_ccb->ccb_h.pinfo.priority;
598 
599 	if ((done_ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
600 		if (cam_periph_error(done_ccb, 0, 0) == ERESTART) {
601 			return;
602 		} else if ((done_ccb->ccb_h.status & CAM_DEV_QFRZN) != 0) {
603 			cam_release_devq(done_ccb->ccb_h.path,
604 			    /*relsim_flags*/0,
605 			    /*reduction*/0,
606 			    /*timeout*/0,
607 			    /*getcount_only*/0);
608 		}
609 		goto done;
610 	}
611 
612 	if (softc->restart) {
613 		softc->restart = 0;
614 		xpt_release_ccb(done_ccb);
615 		if (softc->pm_pid == 0x37261095 || softc->pm_pid == 0x38261095)
616 			softc->state = min(softc->state, PMP_STATE_PM_QUIRKS_1);
617 		else
618 			softc->state = min(softc->state, PMP_STATE_PRECONFIG);
619 		xpt_schedule(periph, priority);
620 		return;
621 	}
622 
623 	switch (softc->state) {
624 	case PMP_STATE_PORTS:
625 		softc->pm_ports = (ataio->res.lba_high << 24) +
626 		    (ataio->res.lba_mid << 16) +
627 		    (ataio->res.lba_low << 8) +
628 		    ataio->res.sector_count;
629 		if (pmp_hide_special) {
630 			/*
631 			 * This PMP declares 6 ports, while only 5 of them
632 			 * are real. Port 5 is a SEMB port, probing which
633 			 * causes timeouts if external SEP is not connected
634 			 * to PMP over I2C.
635 			 */
636 			if ((softc->pm_pid == 0x37261095 ||
637 			     softc->pm_pid == 0x38261095) &&
638 			    softc->pm_ports == 6)
639 				softc->pm_ports = 5;
640 
641 			/*
642 			 * This PMP declares 7 ports, while only 5 of them
643 			 * are real. Port 5 is a fake "Config  Disk" with
644 			 * 640 sectors size. Port 6 is a SEMB port.
645 			 */
646 			if (softc->pm_pid == 0x47261095 && softc->pm_ports == 7)
647 				softc->pm_ports = 5;
648 
649 			/*
650 			 * These PMPs have extra configuration port.
651 			 */
652 			if (softc->pm_pid == 0x57231095 ||
653 			    softc->pm_pid == 0x57331095 ||
654 			    softc->pm_pid == 0x57341095 ||
655 			    softc->pm_pid == 0x57441095)
656 				softc->pm_ports--;
657 		}
658 		printf("%s%d: %d fan-out ports\n",
659 		    periph->periph_name, periph->unit_number,
660 		    softc->pm_ports);
661 		if (softc->pm_pid == 0x37261095 || softc->pm_pid == 0x38261095)
662 			softc->state = PMP_STATE_PM_QUIRKS_1;
663 		else
664 			softc->state = PMP_STATE_PRECONFIG;
665 		xpt_release_ccb(done_ccb);
666 		xpt_schedule(periph, priority);
667 		return;
668 
669 	case PMP_STATE_PM_QUIRKS_1:
670 		softc->caps = (ataio->res.lba_high << 24) +
671 		    (ataio->res.lba_mid << 16) +
672 		    (ataio->res.lba_low << 8) +
673 		    ataio->res.sector_count;
674 		if (softc->caps & 0x1)
675 			softc->state = PMP_STATE_PM_QUIRKS_2;
676 		else
677 			softc->state = PMP_STATE_PRECONFIG;
678 		xpt_release_ccb(done_ccb);
679 		xpt_schedule(periph, priority);
680 		return;
681 
682 	case PMP_STATE_PM_QUIRKS_2:
683 		if (bootverbose)
684 			softc->state = PMP_STATE_PM_QUIRKS_3;
685 		else
686 			softc->state = PMP_STATE_PRECONFIG;
687 		xpt_release_ccb(done_ccb);
688 		xpt_schedule(periph, priority);
689 		return;
690 
691 	case PMP_STATE_PM_QUIRKS_3:
692 		res = (ataio->res.lba_high << 24) +
693 		    (ataio->res.lba_mid << 16) +
694 		    (ataio->res.lba_low << 8) +
695 		    ataio->res.sector_count;
696 		printf("%s%d: Disabling SiI3x26 R_OK in GSCR_POLL: %x->%x\n",
697 		    periph->periph_name, periph->unit_number, softc->caps, res);
698 		softc->state = PMP_STATE_PRECONFIG;
699 		xpt_release_ccb(done_ccb);
700 		xpt_schedule(periph, priority);
701 		return;
702 
703 	case PMP_STATE_PRECONFIG:
704 		softc->pm_step = 0;
705 		softc->state = PMP_STATE_RESET;
706 		softc->reset |= ~softc->found;
707 		xpt_release_ccb(done_ccb);
708 		xpt_schedule(periph, priority);
709 		return;
710 	case PMP_STATE_RESET:
711 		softc->pm_step++;
712 		if (softc->pm_step >= softc->pm_ports) {
713 			softc->pm_step = 0;
714 			cam_freeze_devq(periph->path);
715 			cam_release_devq(periph->path,
716 			    RELSIM_RELEASE_AFTER_TIMEOUT,
717 			    /*reduction*/0,
718 			    /*timeout*/5,
719 			    /*getcount_only*/0);
720 			softc->state = PMP_STATE_CONNECT;
721 		}
722 		xpt_release_ccb(done_ccb);
723 		xpt_schedule(periph, priority);
724 		return;
725 	case PMP_STATE_CONNECT:
726 		softc->pm_step++;
727 		if (softc->pm_step >= softc->pm_ports) {
728 			softc->pm_step = 0;
729 			softc->pm_try = 0;
730 			cam_freeze_devq(periph->path);
731 			cam_release_devq(periph->path,
732 			    RELSIM_RELEASE_AFTER_TIMEOUT,
733 			    /*reduction*/0,
734 			    /*timeout*/10,
735 			    /*getcount_only*/0);
736 			softc->state = PMP_STATE_CHECK;
737 		}
738 		xpt_release_ccb(done_ccb);
739 		xpt_schedule(periph, priority);
740 		return;
741 	case PMP_STATE_CHECK:
742 		res = (ataio->res.lba_high << 24) +
743 		    (ataio->res.lba_mid << 16) +
744 		    (ataio->res.lba_low << 8) +
745 		    ataio->res.sector_count;
746 		if (((res & 0xf0f) == 0x103 && (res & 0x0f0) != 0) ||
747 		    (res & 0x600) != 0) {
748 			if (bootverbose) {
749 				printf("%s%d: port %d status: %08x\n",
750 				    periph->periph_name, periph->unit_number,
751 				    softc->pm_step, res);
752 			}
753 			/* Report device speed if it is online. */
754 			if ((res & 0xf0f) == 0x103 &&
755 			    xpt_create_path(&dpath, periph,
756 			    xpt_path_path_id(periph->path),
757 			    softc->pm_step, 0) == CAM_REQ_CMP) {
758 				bzero(&cts, sizeof(cts));
759 				xpt_setup_ccb(&cts.ccb_h, dpath, CAM_PRIORITY_NONE);
760 				cts.ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
761 				cts.type = CTS_TYPE_CURRENT_SETTINGS;
762 				cts.xport_specific.sata.revision = (res & 0x0f0) >> 4;
763 				cts.xport_specific.sata.valid = CTS_SATA_VALID_REVISION;
764 				cts.xport_specific.sata.caps = softc->caps &
765 				    (CTS_SATA_CAPS_H_PMREQ |
766 				     CTS_SATA_CAPS_H_DMAAA |
767 				     CTS_SATA_CAPS_H_AN);
768 				cts.xport_specific.sata.valid |= CTS_SATA_VALID_CAPS;
769 				xpt_action((union ccb *)&cts);
770 				xpt_free_path(dpath);
771 			}
772 			softc->found |= (1 << softc->pm_step);
773 			softc->pm_step++;
774 		} else {
775 			if (softc->pm_try < 10) {
776 				cam_freeze_devq(periph->path);
777 				cam_release_devq(periph->path,
778 				    RELSIM_RELEASE_AFTER_TIMEOUT,
779 				    /*reduction*/0,
780 				    /*timeout*/10,
781 				    /*getcount_only*/0);
782 				softc->pm_try++;
783 			} else {
784 				if (bootverbose) {
785 					printf("%s%d: port %d status: %08x\n",
786 					    periph->periph_name, periph->unit_number,
787 					    softc->pm_step, res);
788 				}
789 				softc->found &= ~(1 << softc->pm_step);
790 				if (xpt_create_path(&dpath, periph,
791 				    done_ccb->ccb_h.path_id,
792 				    softc->pm_step, 0) == CAM_REQ_CMP) {
793 					xpt_async(AC_LOST_DEVICE, dpath, NULL);
794 					xpt_free_path(dpath);
795 				}
796 				softc->pm_step++;
797 			}
798 		}
799 		if (softc->pm_step >= softc->pm_ports) {
800 			if (softc->reset & softc->found) {
801 				cam_freeze_devq(periph->path);
802 				cam_release_devq(periph->path,
803 				    RELSIM_RELEASE_AFTER_TIMEOUT,
804 				    /*reduction*/0,
805 				    /*timeout*/1000,
806 				    /*getcount_only*/0);
807 			}
808 			softc->state = PMP_STATE_CLEAR;
809 			softc->pm_step = 0;
810 		}
811 		xpt_release_ccb(done_ccb);
812 		xpt_schedule(periph, priority);
813 		return;
814 	case PMP_STATE_CLEAR:
815 		softc->pm_step++;
816 		if (softc->pm_step >= softc->pm_ports) {
817 			softc->state = PMP_STATE_CONFIG;
818 			softc->pm_step = 0;
819 		}
820 		xpt_release_ccb(done_ccb);
821 		xpt_schedule(periph, priority);
822 		return;
823 	case PMP_STATE_CONFIG:
824 		for (i = 0; i < softc->pm_ports; i++) {
825 			union ccb *ccb;
826 
827 			if ((softc->found & (1 << i)) == 0)
828 				continue;
829 			if (xpt_create_path(&dpath, periph,
830 			    xpt_path_path_id(periph->path),
831 			    i, 0) != CAM_REQ_CMP) {
832 				printf("pmpdone: xpt_create_path failed\n");
833 				continue;
834 			}
835 			/* If we did hard reset to this device, inform XPT. */
836 			if ((softc->reset & softc->found & (1 << i)) != 0)
837 				xpt_async(AC_SENT_BDR, dpath, NULL);
838 			/* If rescan requested, scan this device. */
839 			if (softc->events & PMP_EV_RESCAN) {
840 				ccb = xpt_alloc_ccb_nowait();
841 				if (ccb == NULL) {
842 					xpt_free_path(dpath);
843 					goto done;
844 				}
845 				xpt_setup_ccb(&ccb->ccb_h, dpath, CAM_PRIORITY_XPT);
846 				xpt_rescan(ccb);
847 			} else
848 				xpt_free_path(dpath);
849 		}
850 		break;
851 	default:
852 		break;
853 	}
854 done:
855 	xpt_release_ccb(done_ccb);
856 	softc->state = PMP_STATE_NORMAL;
857 	softc->events = 0;
858 	xpt_release_boot();
859 	pmprelease(periph, -1);
860 	cam_periph_release_locked(periph);
861 }
862 
863 #endif /* _KERNEL */
864