1/*-
2 * SPDX-License-Identifier: BSD-2-Clause
3 *
4 * Copyright (c) 2013,2014 Ilya Bakulin <ilya@bakulin.de>
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/param.h>
30#include <sys/bus.h>
31#include <sys/endian.h>
32#include <sys/systm.h>
33#include <sys/types.h>
34#include <sys/malloc.h>
35#include <sys/kernel.h>
36#include <sys/time.h>
37#include <sys/conf.h>
38#include <sys/fcntl.h>
39#include <sys/interrupt.h>
40#include <sys/sbuf.h>
41
42#include <sys/lock.h>
43#include <sys/mutex.h>
44#include <sys/sysctl.h>
45#include <sys/condvar.h>
46
47#include <cam/cam.h>
48#include <cam/cam_ccb.h>
49#include <cam/cam_queue.h>
50#include <cam/cam_periph.h>
51#include <cam/cam_sim.h>
52#include <cam/cam_xpt.h>
53#include <cam/cam_xpt_sim.h>
54#include <cam/cam_xpt_periph.h>
55#include <cam/cam_xpt_internal.h>
56#include <cam/cam_debug.h>
57
58#include <cam/mmc/mmc.h>
59#include <cam/mmc/mmc_bus.h>
60
61#include <machine/stdarg.h>	/* for xpt_print below */
62#include <machine/_inttypes.h>  /* for PRIu64 */
63
64FEATURE(mmccam, "CAM-based MMC/SD/SDIO stack");
65
66static struct cam_ed * mmc_alloc_device(struct cam_eb *bus,
67    struct cam_et *target, lun_id_t lun_id);
68static void mmc_dev_async(uint32_t async_code, struct cam_eb *bus,
69    struct cam_et *target, struct cam_ed *device, void *async_arg);
70static void	 mmc_action(union ccb *start_ccb);
71static void	 mmc_dev_advinfo(union ccb *start_ccb);
72static void	 mmc_announce_periph_sbuf(struct cam_periph *periph,
73    struct sbuf *sb);
74static void	 mmc_scan_lun(struct cam_periph *periph,
75    struct cam_path *path, cam_flags flags, union ccb *ccb);
76
77/* mmcprobe methods */
78static cam_status mmcprobe_register(struct cam_periph *periph, void *arg);
79static void	 mmcprobe_start(struct cam_periph *periph, union ccb *start_ccb);
80static void	 mmcprobe_cleanup(struct cam_periph *periph);
81static void	 mmcprobe_done(struct cam_periph *periph, union ccb *done_ccb);
82
83static void mmc_proto_announce_sbuf(struct cam_ed *device, struct sbuf *sb);
84static void mmc_proto_denounce_sbuf(struct cam_ed *device, struct sbuf *sb);
85static void mmc_proto_debug_out(union ccb *ccb);
86
87typedef enum {
88	PROBE_RESET,
89	PROBE_IDENTIFY,
90	PROBE_POWER_OFF,
91	PROBE_GET_HOST_OCR,
92	PROBE_RESET_BUS,
93	PROBE_SET_ID_FREQ,
94	PROBE_SET_CS,
95	PROBE_GO_IDLE_STATE,
96	PROBE_SDIO_RESET,
97	PROBE_SEND_IF_COND,
98	PROBE_SDIO_INIT,
99	PROBE_MMC_INIT,
100	PROBE_SEND_APP_OP_COND,
101	PROBE_GET_CID,
102	PROBE_GET_CSD,
103	PROBE_SEND_RELATIVE_ADDR,
104	PROBE_MMC_SET_RELATIVE_ADDR,
105	PROBE_SELECT_CARD,
106	PROBE_DONE,
107	PROBE_INVALID
108} probe_action;
109
110static char *probe_action_text[] = {
111	"PROBE_RESET",
112	"PROBE_IDENTIFY",
113	"PROBE_POWER_OFF",
114	"PROBE_GET_HOST_OCR",
115	"PROBE_RESET_BUS",
116	"PROBE_SET_ID_FREQ",
117	"PROBE_SET_CS",
118	"PROBE_GO_IDLE_STATE",
119	"PROBE_SDIO_RESET",
120	"PROBE_SEND_IF_COND",
121	"PROBE_SDIO_INIT",
122	"PROBE_MMC_INIT",
123	"PROBE_SEND_APP_OP_COND",
124	"PROBE_GET_CID",
125	"PROBE_GET_CSD",
126	"PROBE_SEND_RELATIVE_ADDR",
127	"PROBE_MMC_SET_RELATIVE_ADDR",
128	"PROBE_SELECT_CARD",
129	"PROBE_DONE",
130	"PROBE_INVALID"
131};
132
133#define PROBE_SET_ACTION(softc, newaction)	\
134do {									\
135	char **text;							\
136	text = probe_action_text;					\
137	CAM_DEBUG((softc)->periph->path, CAM_DEBUG_PROBE,		\
138	    ("Probe %s to %s\n", text[(softc)->action],			\
139	    text[(newaction)]));					\
140	(softc)->action = (newaction);					\
141} while(0)
142
143static struct xpt_xport_ops mmc_xport_ops = {
144	.alloc_device = mmc_alloc_device,
145	.action = mmc_action,
146	.async = mmc_dev_async,
147	.announce_sbuf = mmc_announce_periph_sbuf,
148};
149
150#define MMC_XPT_XPORT(x, X)				\
151	static struct xpt_xport mmc_xport_ ## x = {	\
152		.xport = XPORT_ ## X,			\
153		.name = #x,				\
154		.ops = &mmc_xport_ops,			\
155	};						\
156	CAM_XPT_XPORT(mmc_xport_ ## x);
157
158MMC_XPT_XPORT(mmc, MMCSD);
159
160static struct xpt_proto_ops mmc_proto_ops = {
161	.announce_sbuf = mmc_proto_announce_sbuf,
162	.denounce_sbuf = mmc_proto_denounce_sbuf,
163	.debug_out = mmc_proto_debug_out,
164};
165
166static struct xpt_proto mmc_proto = {
167	.proto = PROTO_MMCSD,
168	.name = "mmcsd",
169	.ops = &mmc_proto_ops,
170};
171CAM_XPT_PROTO(mmc_proto);
172
173typedef struct {
174	probe_action	action;
175	int             restart;
176	uint32_t	host_ocr;
177	uint32_t	flags;
178#define PROBE_FLAG_ACMD_SENT	0x1 /* CMD55 is sent, card expects ACMD */
179#define PROBE_FLAG_HOST_CAN_DO_18V   0x2 /* Host can do 1.8V signaling */
180	uint8_t         acmd41_count; /* how many times ACMD41 has been issued */
181	struct cam_periph *periph;
182} mmcprobe_softc;
183
184/* XPort functions -- an interface to CAM at periph side */
185
186static struct cam_ed *
187mmc_alloc_device(struct cam_eb *bus, struct cam_et *target, lun_id_t lun_id)
188{
189	struct cam_ed *device;
190
191	device = xpt_alloc_device(bus, target, lun_id);
192	if (device == NULL)
193		return (NULL);
194
195	device->quirk = NULL;
196	device->mintags = 0;
197	device->maxtags = 0;
198	bzero(&device->inq_data, sizeof(device->inq_data));
199	device->inq_flags = 0;
200	device->queue_flags = 0;
201	device->serial_num = NULL;
202	device->serial_num_len = 0;
203	return (device);
204}
205
206static void
207mmc_dev_async(uint32_t async_code, struct cam_eb *bus, struct cam_et *target,
208	      struct cam_ed *device, void *async_arg)
209{
210
211	/*
212	 * We only need to handle events for real devices.
213	 */
214	if (target->target_id == CAM_TARGET_WILDCARD
215            || device->lun_id == CAM_LUN_WILDCARD)
216		return;
217
218	if (async_code == AC_LOST_DEVICE &&
219	    (device->flags & CAM_DEV_UNCONFIGURED) == 0) {
220		device->flags |= CAM_DEV_UNCONFIGURED;
221		xpt_release_device(device);
222	}
223}
224
225/* Taken from nvme_scan_lun, thanks to bsdimp@ */
226static void
227mmc_scan_lun(struct cam_periph *periph, struct cam_path *path,
228	     cam_flags flags, union ccb *request_ccb)
229{
230	struct ccb_pathinq cpi;
231	cam_status status;
232	struct cam_periph *old_periph;
233	int lock;
234
235	CAM_DEBUG(path, CAM_DEBUG_TRACE, ("mmc_scan_lun\n"));
236
237	xpt_path_inq(&cpi, path);
238
239	if (cpi.ccb_h.status != CAM_REQ_CMP) {
240		if (request_ccb != NULL) {
241			request_ccb->ccb_h.status = cpi.ccb_h.status;
242			xpt_done(request_ccb);
243		}
244		return;
245	}
246
247	if (xpt_path_lun_id(path) == CAM_LUN_WILDCARD) {
248		CAM_DEBUG(path, CAM_DEBUG_TRACE, ("mmd_scan_lun ignoring bus\n"));
249		request_ccb->ccb_h.status = CAM_REQ_CMP;	/* XXX signal error ? */
250		xpt_done(request_ccb);
251		return;
252	}
253
254	lock = (xpt_path_owned(path) == 0);
255	if (lock)
256		xpt_path_lock(path);
257
258	if ((old_periph = cam_periph_find(path, "mmcprobe")) != NULL) {
259		if ((old_periph->flags & CAM_PERIPH_INVALID) == 0) {
260//			mmcprobe_softc *softc;
261//			softc = (mmcprobe_softc *)old_periph->softc;
262//                      Not sure if we need request ccb queue for mmc
263//			TAILQ_INSERT_TAIL(&softc->request_ccbs,
264//				&request_ccb->ccb_h, periph_links.tqe);
265//			softc->restart = 1;
266                        CAM_DEBUG(path, CAM_DEBUG_INFO,
267                                  ("Got scan request, but mmcprobe already exists\n"));
268			request_ccb->ccb_h.status = CAM_REQ_CMP_ERR;
269                        xpt_done(request_ccb);
270		} else {
271			request_ccb->ccb_h.status = CAM_REQ_CMP_ERR;
272			xpt_done(request_ccb);
273		}
274	} else {
275		CAM_DEBUG(path, CAM_DEBUG_INFO,
276		    (" Set up the mmcprobe device...\n"));
277
278                status = cam_periph_alloc(mmcprobe_register, NULL,
279					  mmcprobe_cleanup,
280					  mmcprobe_start,
281					  "mmcprobe",
282					  CAM_PERIPH_BIO,
283					  path, NULL, 0,
284					  request_ccb);
285                if (status != CAM_REQ_CMP) {
286			xpt_print(path, "xpt_scan_lun: cam_alloc_periph "
287                                  "returned an error, can't continue probe\n");
288		}
289		request_ccb->ccb_h.status = status;
290		xpt_done(request_ccb);
291	}
292
293	if (lock)
294		xpt_path_unlock(path);
295}
296
297static void
298mmc_action(union ccb *start_ccb)
299{
300	CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_TRACE,
301		  ("mmc_action! func_code=%x, action %s\n", start_ccb->ccb_h.func_code,
302		   xpt_action_name(start_ccb->ccb_h.func_code)));
303	switch (start_ccb->ccb_h.func_code) {
304	case XPT_SCAN_BUS:
305                /* FALLTHROUGH */
306	case XPT_SCAN_TGT:
307                /* FALLTHROUGH */
308	case XPT_SCAN_LUN:
309		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_INFO,
310			  ("XPT_SCAN_{BUS,TGT,LUN}\n"));
311		mmc_scan_lun(start_ccb->ccb_h.path->periph,
312			     start_ccb->ccb_h.path, start_ccb->crcn.flags,
313			     start_ccb);
314		break;
315
316	case XPT_DEV_ADVINFO:
317	{
318		mmc_dev_advinfo(start_ccb);
319		break;
320	}
321
322	default:
323		xpt_action_default(start_ccb);
324		break;
325	}
326}
327
328static void
329mmc_dev_advinfo(union ccb *start_ccb)
330{
331	struct cam_ed *device;
332	struct ccb_dev_advinfo *cdai;
333	off_t amt;
334
335	xpt_path_assert(start_ccb->ccb_h.path, MA_OWNED);
336	start_ccb->ccb_h.status = CAM_REQ_INVALID;
337	device = start_ccb->ccb_h.path->device;
338	cdai = &start_ccb->cdai;
339	CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_TRACE,
340		  ("%s: request %x\n", __func__, cdai->buftype));
341
342        /* We don't support writing any data */
343        if (cdai->flags & CDAI_FLAG_STORE)
344                panic("Attempt to store data?!");
345
346	switch(cdai->buftype) {
347	case CDAI_TYPE_SCSI_DEVID:
348		cdai->provsiz = device->device_id_len;
349		if (device->device_id_len == 0)
350			break;
351		amt = MIN(cdai->provsiz, cdai->bufsiz);
352		memcpy(cdai->buf, device->device_id, amt);
353		break;
354	case CDAI_TYPE_SERIAL_NUM:
355		cdai->provsiz = device->serial_num_len;
356		if (device->serial_num_len == 0)
357			break;
358		amt = MIN(cdai->provsiz, cdai->bufsiz);
359		memcpy(cdai->buf, device->serial_num, amt);
360		break;
361        case CDAI_TYPE_PHYS_PATH: /* pass(4) wants this */
362                cdai->provsiz = 0;
363                break;
364	case CDAI_TYPE_MMC_PARAMS:
365		cdai->provsiz = sizeof(struct mmc_params);
366		amt = MIN(cdai->provsiz, cdai->bufsiz);
367		memcpy(cdai->buf, &device->mmc_ident_data, amt);
368		break;
369	default:
370                panic("Unknown buftype");
371		return;
372	}
373	start_ccb->ccb_h.status = CAM_REQ_CMP;
374}
375
376static void
377mmc_announce_periph_sbuf(struct cam_periph *periph, struct sbuf *sb)
378{
379	struct	ccb_pathinq cpi;
380	struct	ccb_trans_settings cts;
381	struct	cam_path *path = periph->path;
382
383	cam_periph_assert(periph, MA_OWNED);
384
385	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("mmc_announce_periph_sbuf"));
386
387	memset(&cts, 0, sizeof(cts));
388	xpt_setup_ccb(&cts.ccb_h, path, CAM_PRIORITY_NORMAL);
389	cts.ccb_h.func_code = XPT_GET_TRAN_SETTINGS;
390	cts.type = CTS_TYPE_CURRENT_SETTINGS;
391	xpt_action((union ccb*)&cts);
392	if ((cts.ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP)
393		return;
394	xpt_path_inq(&cpi, periph->path);
395	CAM_DEBUG(path, CAM_DEBUG_INFO,
396	    ("XPT info: CLK %04d, ...\n", cts.proto_specific.mmc.ios.clock));
397}
398
399void
400mmccam_start_discovery(struct cam_sim *sim)
401{
402	union ccb *ccb;
403	uint32_t pathid;
404
405	pathid = cam_sim_path(sim);
406	ccb = xpt_alloc_ccb();
407
408	/*
409	 * We create a rescan request for BUS:0:0, since the card
410	 * will be at lun 0.
411	 */
412	if (xpt_create_path(&ccb->ccb_h.path, NULL, pathid,
413		/* target */ 0, /* lun */ 0) != CAM_REQ_CMP) {
414		xpt_free_ccb(ccb);
415		return;
416	}
417
418	KASSERT(xpt_path_sim_device(ccb->ccb_h.path) != NULL,
419	    ("%s(%s): device is not initialized on sim's path",
420	    __func__, cam_sim_name(sim)));
421	xpt_rescan(ccb);
422}
423
424/* This func is called per attached device :-( */
425static void
426mmc_print_ident(struct mmc_params *ident_data, struct sbuf *sb)
427{
428	bool space = false;
429
430	sbuf_printf(sb, "Relative addr: %08x\n", ident_data->card_rca);
431	sbuf_cat(sb, "Card features: <");
432	if (ident_data->card_features & CARD_FEATURE_MMC) {
433		sbuf_cat(sb, "MMC");
434		space = true;
435	}
436	if (ident_data->card_features & CARD_FEATURE_MEMORY) {
437		sbuf_printf(sb, "%sMemory", space ? " " : "");
438		space = true;
439	}
440	if (ident_data->card_features & CARD_FEATURE_SDHC) {
441		sbuf_printf(sb, "%sHigh-Capacity", space ? " " : "");
442		space = true;
443	}
444	if (ident_data->card_features & CARD_FEATURE_SD20) {
445		sbuf_printf(sb, "%sSD2.0-Conditions", space ? " " : "");
446		space = true;
447	}
448	if (ident_data->card_features & CARD_FEATURE_SDIO) {
449		sbuf_printf(sb, "%sSDIO", space ? " " : "");
450		space = true;
451	}
452	if (ident_data->card_features & CARD_FEATURE_18V) {
453		sbuf_printf(sb, "%s1.8-Signaling", space ? " " : "");
454	}
455	sbuf_cat(sb, ">\n");
456
457	if (ident_data->card_features & CARD_FEATURE_MEMORY)
458		sbuf_printf(sb, "Card memory OCR: %08x\n",
459		    ident_data->card_ocr);
460
461	if (ident_data->card_features & CARD_FEATURE_SDIO) {
462		sbuf_printf(sb, "Card IO OCR: %08x\n", ident_data->io_ocr);
463		sbuf_printf(sb, "Number of functions: %u\n",
464		    ident_data->sdio_func_count);
465	}
466}
467
468static void
469mmc_proto_announce_sbuf(struct cam_ed *device, struct sbuf *sb)
470{
471	mmc_print_ident(&device->mmc_ident_data, sb);
472}
473
474static void
475mmc_proto_denounce_sbuf(struct cam_ed *device, struct sbuf *sb)
476{
477	mmc_proto_announce_sbuf(device, sb);
478}
479
480static void
481mmc_proto_debug_out(union ccb *ccb)
482{
483	if (ccb->ccb_h.func_code != XPT_MMC_IO)
484		return;
485
486	CAM_DEBUG(ccb->ccb_h.path,
487	    CAM_DEBUG_CDB,("mmc_proto_debug_out\n"));
488}
489
490static periph_init_t probe_periph_init;
491
492static struct periph_driver probe_driver =
493{
494	probe_periph_init, "mmcprobe",
495	TAILQ_HEAD_INITIALIZER(probe_driver.units), /* generation */ 0,
496	CAM_PERIPH_DRV_EARLY
497};
498
499PERIPHDRIVER_DECLARE(mmcprobe, probe_driver);
500
501#define	CARD_ID_FREQUENCY 400000 /* Spec requires 400kHz max during ID phase. */
502
503static void
504probe_periph_init(void)
505{
506}
507
508static cam_status
509mmcprobe_register(struct cam_periph *periph, void *arg)
510{
511	mmcprobe_softc *softc;
512	union ccb *request_ccb;	/* CCB representing the probe request */
513	int status;
514
515	CAM_DEBUG(periph->path, CAM_DEBUG_TRACE, ("mmcprobe_register\n"));
516
517	request_ccb = (union ccb *)arg;
518	if (request_ccb == NULL) {
519		printf("mmcprobe_register: no probe CCB, "
520		       "can't register device\n");
521		return(CAM_REQ_CMP_ERR);
522	}
523
524	softc = (mmcprobe_softc *)malloc(sizeof(*softc), M_CAMXPT, M_NOWAIT);
525
526	if (softc == NULL) {
527		printf("proberegister: Unable to probe new device. "
528		       "Unable to allocate softc\n");
529		return(CAM_REQ_CMP_ERR);
530	}
531
532	softc->flags = 0;
533	softc->acmd41_count = 0;
534	periph->softc = softc;
535	softc->periph = periph;
536	softc->action = PROBE_INVALID;
537        softc->restart = 0;
538	status = cam_periph_acquire(periph);
539
540        memset(&periph->path->device->mmc_ident_data, 0, sizeof(struct mmc_params));
541	if (status != 0) {
542		printf("proberegister: cam_periph_acquire failed (status=%d)\n",
543			status);
544		return (CAM_REQ_CMP_ERR);
545	}
546	CAM_DEBUG(periph->path, CAM_DEBUG_PROBE, ("Probe started\n"));
547
548	if (periph->path->device->flags & CAM_DEV_UNCONFIGURED)
549		PROBE_SET_ACTION(softc, PROBE_RESET);
550	else
551		PROBE_SET_ACTION(softc, PROBE_IDENTIFY);
552
553	/* This will kick the ball */
554	xpt_schedule(periph, CAM_PRIORITY_XPT);
555
556	return(CAM_REQ_CMP);
557}
558
559static int
560mmc_highest_voltage(uint32_t ocr)
561{
562	int i;
563
564	for (i = MMC_OCR_MAX_VOLTAGE_SHIFT;
565	    i >= MMC_OCR_MIN_VOLTAGE_SHIFT; i--)
566		if (ocr & (1 << i))
567			return (i);
568	return (-1);
569}
570
571static inline void
572init_standard_ccb(union ccb *ccb, uint32_t cmd)
573{
574	ccb->ccb_h.func_code = cmd;
575	ccb->ccb_h.flags = CAM_DIR_OUT;
576	ccb->ccb_h.retry_count = 0;
577	ccb->ccb_h.timeout = 15 * 1000;
578	ccb->ccb_h.cbfcnp = mmcprobe_done;
579}
580
581static void
582mmcprobe_start(struct cam_periph *periph, union ccb *start_ccb)
583{
584	mmcprobe_softc *softc;
585	struct cam_path *path;
586	struct ccb_mmcio *mmcio;
587	struct ccb_trans_settings_mmc *cts;
588
589	CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("mmcprobe_start\n"));
590	softc = (mmcprobe_softc *)periph->softc;
591	path = start_ccb->ccb_h.path;
592	mmcio = &start_ccb->mmcio;
593	cts = &start_ccb->cts.proto_specific.mmc;
594	struct mmc_params *mmcp = &path->device->mmc_ident_data;
595
596	memset(&mmcio->cmd, 0, sizeof(struct mmc_command));
597
598	if (softc->restart) {
599		softc->restart = 0;
600		if (path->device->flags & CAM_DEV_UNCONFIGURED)
601			softc->action = PROBE_RESET;
602		else
603			softc->action = PROBE_IDENTIFY;
604	}
605
606	/* Here is the place where the identify fun begins */
607	switch (softc->action) {
608	case PROBE_RESET:
609		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("Start with PROBE_RESET\n"));
610		/* FALLTHROUGH */
611	case PROBE_IDENTIFY:
612		xpt_path_inq(&start_ccb->cpi, periph->path);
613		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("Start with PROBE_IDENTIFY\n"));
614		init_standard_ccb(start_ccb, XPT_MMC_GET_TRAN_SETTINGS);
615		break;
616
617	case PROBE_POWER_OFF:
618		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("power off the card\n"));
619		init_standard_ccb(start_ccb, XPT_MMC_SET_TRAN_SETTINGS);
620		cts->ios.power_mode = power_off;
621		cts->ios_valid = MMC_PM;
622		break;
623
624	case PROBE_GET_HOST_OCR:
625		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("get the host ocr\n"));
626		init_standard_ccb(start_ccb, XPT_MMC_GET_TRAN_SETTINGS);
627		break;
628
629	case PROBE_RESET_BUS:
630	{
631		uint32_t host_caps = cts->host_caps;
632		if (host_caps & MMC_CAP_SIGNALING_180)
633			softc->flags |= PROBE_FLAG_HOST_CAN_DO_18V;
634		uint32_t hv = mmc_highest_voltage(softc->host_ocr);
635		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("reseting the bus\n"));
636		init_standard_ccb(start_ccb, XPT_MMC_SET_TRAN_SETTINGS);
637		cts->ios.vdd = hv;
638		cts->ios.bus_mode = opendrain;
639		cts->ios.chip_select = cs_dontcare;
640		cts->ios.power_mode = power_up;
641		cts->ios.bus_width = bus_width_1;
642		cts->ios.clock = 0;
643		cts->ios_valid = MMC_VDD | MMC_PM | MMC_BM |
644			MMC_CS | MMC_BW | MMC_CLK;
645		break;
646	}
647
648	case PROBE_SET_ID_FREQ:
649		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("setting the ID freq\n"));
650		init_standard_ccb(start_ccb, XPT_MMC_SET_TRAN_SETTINGS);
651		cts->ios.power_mode = power_on;
652		cts->ios.clock = CARD_ID_FREQUENCY;
653		cts->ios.timing = bus_timing_normal;
654		cts->ios_valid = MMC_PM | MMC_CLK | MMC_BT;
655		break;
656
657	case PROBE_SET_CS:
658		/* Begin mmc_idle_cards() */
659		init_standard_ccb(start_ccb, XPT_MMC_SET_TRAN_SETTINGS);
660		cts->ios.chip_select = cs_high;
661		cts->ios_valid = MMC_CS;
662		break;
663
664	case PROBE_GO_IDLE_STATE:
665		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("Send first XPT_MMC_IO\n"));
666		init_standard_ccb(start_ccb, XPT_MMC_IO);
667		mmcio->cmd.opcode = MMC_GO_IDLE_STATE; /* CMD 0 */
668		mmcio->cmd.arg = 0;
669		mmcio->cmd.flags = MMC_RSP_NONE | MMC_CMD_BC;
670		mmcio->cmd.data = NULL;
671		mmcio->stop.opcode = 0;
672
673		/* XXX Reset I/O portion as well */
674		break;
675
676	case PROBE_SDIO_RESET:
677		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE,
678			  ("Start with PROBE_SDIO_RESET\n"));
679		uint32_t mmc_arg = SD_IO_RW_ADR(SD_IO_CCCR_CTL)
680			| SD_IO_RW_DAT(CCCR_CTL_RES) | SD_IO_RW_WR | SD_IO_RW_RAW;
681		cam_fill_mmcio(&start_ccb->mmcio,
682			       /*retries*/ 0,
683			       /*cbfcnp*/ mmcprobe_done,
684			       /*flags*/ CAM_DIR_NONE,
685			       /*mmc_opcode*/ SD_IO_RW_DIRECT,
686			       /*mmc_arg*/ mmc_arg,
687			       /*mmc_flags*/ MMC_RSP_R5 | MMC_CMD_AC,
688			       /*mmc_data*/ NULL,
689			       /*timeout*/ 1000);
690		break;
691	case PROBE_SEND_IF_COND:
692		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE,
693			  ("Start with PROBE_SEND_IF_COND\n"));
694		init_standard_ccb(start_ccb, XPT_MMC_IO);
695		mmcio->cmd.opcode = SD_SEND_IF_COND; /* CMD 8 */
696		mmcio->cmd.arg = (1 << 8) + 0xAA;
697		mmcio->cmd.flags = MMC_RSP_R7 | MMC_CMD_BCR;
698		mmcio->stop.opcode = 0;
699		break;
700
701	case PROBE_SDIO_INIT:
702		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE,
703			  ("Start with PROBE_SDIO_INIT\n"));
704		init_standard_ccb(start_ccb, XPT_MMC_IO);
705		mmcio->cmd.opcode = IO_SEND_OP_COND; /* CMD 5 */
706		mmcio->cmd.arg = mmcp->io_ocr;
707		mmcio->cmd.flags = MMC_RSP_R4;
708		mmcio->stop.opcode = 0;
709		break;
710
711	case PROBE_MMC_INIT:
712		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE,
713			  ("Start with PROBE_MMC_INIT\n"));
714		init_standard_ccb(start_ccb, XPT_MMC_IO);
715		mmcio->cmd.opcode = MMC_SEND_OP_COND; /* CMD 1 */
716		mmcio->cmd.arg = MMC_OCR_CCS | mmcp->card_ocr; /* CCS + ocr */;
717		mmcio->cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
718		mmcio->stop.opcode = 0;
719		break;
720
721	case PROBE_SEND_APP_OP_COND:
722		init_standard_ccb(start_ccb, XPT_MMC_IO);
723		if (softc->flags & PROBE_FLAG_ACMD_SENT) {
724			mmcio->cmd.opcode = ACMD_SD_SEND_OP_COND; /* CMD 41 */
725			/*
726			 * We set CCS bit because we do support SDHC cards.
727			 * XXX: Don't set CCS if no response to CMD8.
728			 */
729			uint32_t cmd_arg = MMC_OCR_CCS | mmcp->card_ocr; /* CCS + ocr */
730			if (softc->acmd41_count < 10 && mmcp->card_ocr != 0 )
731				cmd_arg |= MMC_OCR_S18R;
732			mmcio->cmd.arg = cmd_arg;
733			mmcio->cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
734			softc->acmd41_count++;
735		} else {
736			mmcio->cmd.opcode = MMC_APP_CMD; /* CMD 55 */
737			mmcio->cmd.arg = 0; /* rca << 16 */
738			mmcio->cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
739		}
740		mmcio->stop.opcode = 0;
741		break;
742
743	case PROBE_GET_CID: /* XXX move to mmc_da */
744		init_standard_ccb(start_ccb, XPT_MMC_IO);
745		mmcio->cmd.opcode = MMC_ALL_SEND_CID;
746		mmcio->cmd.arg = 0;
747		mmcio->cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
748		mmcio->stop.opcode = 0;
749		break;
750	case PROBE_SEND_RELATIVE_ADDR:
751		init_standard_ccb(start_ccb, XPT_MMC_IO);
752		mmcio->cmd.opcode = SD_SEND_RELATIVE_ADDR;
753		mmcio->cmd.arg = 0;
754		mmcio->cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
755		mmcio->stop.opcode = 0;
756		break;
757	case PROBE_MMC_SET_RELATIVE_ADDR:
758		init_standard_ccb(start_ccb, XPT_MMC_IO);
759		mmcio->cmd.opcode = MMC_SET_RELATIVE_ADDR;
760		mmcio->cmd.arg = MMC_PROPOSED_RCA << 16;
761		mmcio->cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
762		mmcio->stop.opcode = 0;
763		break;
764	case PROBE_SELECT_CARD:
765		init_standard_ccb(start_ccb, XPT_MMC_IO);
766		mmcio->cmd.opcode = MMC_SELECT_CARD;
767		mmcio->cmd.arg = (uint32_t)path->device->mmc_ident_data.card_rca << 16;
768		mmcio->cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
769		mmcio->stop.opcode = 0;
770		break;
771	case PROBE_GET_CSD: /* XXX move to mmc_da */
772		init_standard_ccb(start_ccb, XPT_MMC_IO);
773		mmcio->cmd.opcode = MMC_SEND_CSD;
774		mmcio->cmd.arg = (uint32_t)path->device->mmc_ident_data.card_rca << 16;
775		mmcio->cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
776		mmcio->stop.opcode = 0;
777		break;
778	case PROBE_DONE:
779		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("Start with PROBE_DONE\n"));
780		init_standard_ccb(start_ccb, XPT_SET_TRAN_SETTINGS);
781		cts->ios.bus_mode = pushpull;
782		cts->ios_valid = MMC_BM;
783		xpt_action(start_ccb);
784		return;
785		/* NOTREACHED */
786		break;
787	case PROBE_INVALID:
788		break;
789	default:
790		CAM_DEBUG(start_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("probestart: invalid action state 0x%x\n", softc->action));
791		panic("default: case in mmc_probe_start()");
792	}
793
794	start_ccb->ccb_h.flags |= CAM_DEV_QFREEZE;
795	xpt_action(start_ccb);
796}
797
798static void mmcprobe_cleanup(struct cam_periph *periph)
799{
800	free(periph->softc, M_CAMXPT);
801}
802
803static void
804mmcprobe_done(struct cam_periph *periph, union ccb *done_ccb)
805{
806	mmcprobe_softc *softc;
807	struct cam_path *path;
808
809	int err;
810	struct ccb_mmcio *mmcio;
811	uint32_t  priority;
812
813	CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("mmcprobe_done\n"));
814	softc = (mmcprobe_softc *)periph->softc;
815	path = done_ccb->ccb_h.path;
816	priority = done_ccb->ccb_h.pinfo.priority;
817
818	switch (softc->action) {
819	case PROBE_RESET:
820		/* FALLTHROUGH */
821	case PROBE_IDENTIFY:
822	{
823		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("done with PROBE_RESET\n"));
824		PROBE_SET_ACTION(softc, PROBE_POWER_OFF);
825		break;
826	}
827	case PROBE_POWER_OFF:
828	{
829		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("done with PROBE_POWER_OFF\n"));
830		PROBE_SET_ACTION(softc, PROBE_GET_HOST_OCR);
831		break;
832	}
833	case PROBE_GET_HOST_OCR:
834	{
835		struct ccb_trans_settings_mmc *cts;
836		cts = &done_ccb->cts.proto_specific.mmc;
837		softc->host_ocr = cts->host_ocr;
838		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("done with PROBE_GET_HOST_OCR (Got OCR=%x\n", softc->host_ocr));
839		PROBE_SET_ACTION(softc, PROBE_RESET_BUS);
840		break;
841	}
842	case PROBE_RESET_BUS:
843	{
844		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("done with PROBE_RESET_BUS\n"));
845		PROBE_SET_ACTION(softc, PROBE_SET_ID_FREQ);
846		break;
847	}
848	case PROBE_SET_ID_FREQ:
849	{
850		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("done with PROBE_SET_ID_FREQ\n"));
851		PROBE_SET_ACTION(softc, PROBE_SET_CS);
852		break;
853	}
854	case PROBE_SET_CS:
855	{
856		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("done with PROBE_SET_CS\n"));
857		PROBE_SET_ACTION(softc, PROBE_GO_IDLE_STATE);
858		break;
859	}
860	case PROBE_GO_IDLE_STATE:
861	{
862		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE, ("done with PROBE_GO_IDLE_STATE\n"));
863		mmcio = &done_ccb->mmcio;
864		err = mmcio->cmd.error;
865
866		if (err != MMC_ERR_NONE) {
867			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
868				  ("GO_IDLE_STATE failed with error %d\n",
869				   err));
870
871			/* There was a device there, but now it's gone... */
872			if ((path->device->flags & CAM_DEV_UNCONFIGURED) == 0) {
873				CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
874				  ("Device lost!\n"));
875
876				xpt_async(AC_LOST_DEVICE, path, NULL);
877			}
878			PROBE_SET_ACTION(softc, PROBE_INVALID);
879			break;
880		}
881		path->device->protocol = PROTO_MMCSD;
882		PROBE_SET_ACTION(softc, PROBE_SEND_IF_COND);
883		break;
884	}
885	case PROBE_SEND_IF_COND:
886	{
887		mmcio = &done_ccb->mmcio;
888		err = mmcio->cmd.error;
889		struct mmc_params *mmcp = &path->device->mmc_ident_data;
890
891		if (err != MMC_ERR_NONE || mmcio->cmd.resp[0] != 0x1AA) {
892			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
893				  ("IF_COND: error %d, pattern %08x\n",
894				   err, mmcio->cmd.resp[0]));
895		} else {
896			mmcp->card_features |= CARD_FEATURE_SD20;
897			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
898				  ("SD 2.0 interface conditions: OK\n"));
899		}
900                PROBE_SET_ACTION(softc, PROBE_SDIO_RESET);
901		break;
902	}
903	case PROBE_SDIO_RESET:
904	{
905		mmcio = &done_ccb->mmcio;
906		err = mmcio->cmd.error;
907
908		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
909		    ("SDIO_RESET: error %d, CCCR CTL register: %08x\n",
910		    err, mmcio->cmd.resp[0]));
911		PROBE_SET_ACTION(softc, PROBE_SDIO_INIT);
912		break;
913	}
914	case PROBE_SDIO_INIT:
915	{
916		mmcio = &done_ccb->mmcio;
917		err = mmcio->cmd.error;
918		struct mmc_params *mmcp = &path->device->mmc_ident_data;
919
920		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
921		    ("SDIO_INIT: error %d, %08x %08x %08x %08x\n",
922		    err, mmcio->cmd.resp[0],
923		    mmcio->cmd.resp[1],
924		    mmcio->cmd.resp[2],
925		    mmcio->cmd.resp[3]));
926
927		/*
928		 * Error here means that this card is not SDIO,
929		 * so proceed with memory init as if nothing has happened
930		 */
931		if (err != MMC_ERR_NONE) {
932			PROBE_SET_ACTION(softc, PROBE_SEND_APP_OP_COND);
933			break;
934		}
935		mmcp->card_features |= CARD_FEATURE_SDIO;
936		uint32_t ioifcond = mmcio->cmd.resp[0];
937		uint32_t io_ocr = ioifcond & R4_IO_OCR_MASK;
938
939		mmcp->sdio_func_count = R4_IO_NUM_FUNCTIONS(ioifcond);
940		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
941		    ("SDIO card: %d functions\n", mmcp->sdio_func_count));
942		if (io_ocr == 0) {
943			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
944			  ("SDIO OCR invalid, retrying\n"));
945			break; /* Retry */
946		}
947
948		if (io_ocr != 0 && mmcp->io_ocr == 0) {
949			mmcp->io_ocr = io_ocr;
950			break; /* Retry, this time with non-0 OCR */
951		}
952		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
953		    ("SDIO OCR: %08x\n", mmcp->io_ocr));
954
955		if (ioifcond & R4_IO_MEM_PRESENT) {
956			/* Combo card -- proceed to memory initialization */
957			PROBE_SET_ACTION(softc, PROBE_SEND_APP_OP_COND);
958		} else {
959			/* No memory portion -- get RCA and select card */
960			PROBE_SET_ACTION(softc, PROBE_SEND_RELATIVE_ADDR);
961		}
962		break;
963	}
964	case PROBE_MMC_INIT:
965	{
966		mmcio = &done_ccb->mmcio;
967		err = mmcio->cmd.error;
968		struct mmc_params *mmcp = &path->device->mmc_ident_data;
969
970		if (err != MMC_ERR_NONE) {
971			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
972				  ("MMC_INIT: error %d, resp %08x\n",
973				   err, mmcio->cmd.resp[0]));
974			PROBE_SET_ACTION(softc, PROBE_INVALID);
975			break;
976		}
977		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
978		    ("MMC card, OCR %08x\n", mmcio->cmd.resp[0]));
979
980		if (mmcp->card_ocr == 0) {
981			/* We haven't sent the OCR to the card yet -- do it */
982			mmcp->card_ocr = mmcio->cmd.resp[0];
983			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
984			    ("-> sending OCR to card\n"));
985			break;
986		}
987
988		if (!(mmcio->cmd.resp[0] & MMC_OCR_CARD_BUSY)) {
989			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
990			    ("Card is still powering up\n"));
991			break;
992		}
993
994		mmcp->card_features |= CARD_FEATURE_MMC | CARD_FEATURE_MEMORY;
995		PROBE_SET_ACTION(softc, PROBE_GET_CID);
996		break;
997	}
998	case PROBE_SEND_APP_OP_COND:
999	{
1000		mmcio = &done_ccb->mmcio;
1001		err = mmcio->cmd.error;
1002
1003		if (err != MMC_ERR_NONE) {
1004			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1005				  ("APP_OP_COND: error %d, resp %08x\n",
1006				   err, mmcio->cmd.resp[0]));
1007			PROBE_SET_ACTION(softc, PROBE_MMC_INIT);
1008			break;
1009		}
1010
1011		if (!(softc->flags & PROBE_FLAG_ACMD_SENT)) {
1012			/* Don't change the state */
1013			softc->flags |= PROBE_FLAG_ACMD_SENT;
1014			break;
1015		}
1016
1017		softc->flags &= ~PROBE_FLAG_ACMD_SENT;
1018		if ((mmcio->cmd.resp[0] & MMC_OCR_CARD_BUSY) ||
1019		    (mmcio->cmd.arg & MMC_OCR_VOLTAGE) == 0) {
1020			struct mmc_params *mmcp = &path->device->mmc_ident_data;
1021			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1022			    ("Card OCR: %08x\n",  mmcio->cmd.resp[0]));
1023			if (mmcp->card_ocr == 0) {
1024				mmcp->card_ocr = mmcio->cmd.resp[0];
1025				/* Now when we know OCR that we want -- send it to card */
1026				CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1027				    ("-> sending OCR to card\n"));
1028			} else {
1029				/* We already know the OCR and despite of that we
1030				 * are processing the answer to ACMD41 -> move on
1031				 */
1032				PROBE_SET_ACTION(softc, PROBE_GET_CID);
1033			}
1034			/* Getting an answer to ACMD41 means the card has memory */
1035			mmcp->card_features |= CARD_FEATURE_MEMORY;
1036
1037			/* Standard capacity vs High Capacity memory card */
1038			if (mmcio->cmd.resp[0] & MMC_OCR_CCS) {
1039				CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1040				    ("Card is SDHC\n"));
1041				mmcp->card_features |= CARD_FEATURE_SDHC;
1042			}
1043
1044			/* Whether the card supports 1.8V signaling */
1045			if (mmcio->cmd.resp[0] & MMC_OCR_S18A) {
1046				CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1047					  ("Card supports 1.8V signaling\n"));
1048				mmcp->card_features |= CARD_FEATURE_18V;
1049				if (softc->flags & PROBE_FLAG_HOST_CAN_DO_18V) {
1050					CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1051						  ("Host supports 1.8V signaling. Switch voltage!\n"));
1052					done_ccb->ccb_h.func_code = XPT_SET_TRAN_SETTINGS;
1053					done_ccb->ccb_h.flags = CAM_DIR_NONE;
1054					done_ccb->ccb_h.retry_count = 0;
1055					done_ccb->ccb_h.timeout = 100;
1056					done_ccb->ccb_h.cbfcnp = NULL;
1057					done_ccb->cts.proto_specific.mmc.ios.vccq = vccq_180;
1058					done_ccb->cts.proto_specific.mmc.ios_valid = MMC_VCCQ;
1059					xpt_action(done_ccb);
1060				}
1061			}
1062		} else {
1063			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1064				  ("Card not ready: %08x\n",  mmcio->cmd.resp[0]));
1065			/* Send CMD55+ACMD41 once again  */
1066			PROBE_SET_ACTION(softc, PROBE_SEND_APP_OP_COND);
1067		}
1068
1069		break;
1070	}
1071	case PROBE_GET_CID: /* XXX move to mmc_da */
1072	{
1073		mmcio = &done_ccb->mmcio;
1074		err = mmcio->cmd.error;
1075
1076		if (err != MMC_ERR_NONE) {
1077			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1078				  ("PROBE_GET_CID: error %d\n", err));
1079			PROBE_SET_ACTION(softc, PROBE_INVALID);
1080			break;
1081		}
1082
1083		struct mmc_params *mmcp = &path->device->mmc_ident_data;
1084		memcpy(mmcp->card_cid, mmcio->cmd.resp, 4 * sizeof(uint32_t));
1085		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1086		    ("CID %08x%08x%08x%08x\n",
1087		      mmcp->card_cid[0],
1088		      mmcp->card_cid[1],
1089		      mmcp->card_cid[2],
1090		      mmcp->card_cid[3]));
1091		if (mmcp->card_features & CARD_FEATURE_MMC)
1092			PROBE_SET_ACTION(softc, PROBE_MMC_SET_RELATIVE_ADDR);
1093		else
1094			PROBE_SET_ACTION(softc, PROBE_SEND_RELATIVE_ADDR);
1095		break;
1096	}
1097	case PROBE_SEND_RELATIVE_ADDR: {
1098		mmcio = &done_ccb->mmcio;
1099		err = mmcio->cmd.error;
1100		struct mmc_params *mmcp = &path->device->mmc_ident_data;
1101		uint16_t rca = mmcio->cmd.resp[0] >> 16;
1102		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1103		    ("Card published RCA: %u\n", rca));
1104		path->device->mmc_ident_data.card_rca = rca;
1105		if (err != MMC_ERR_NONE) {
1106			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1107				  ("PROBE_SEND_RELATIVE_ADDR: error %d\n", err));
1108			PROBE_SET_ACTION(softc, PROBE_INVALID);
1109			break;
1110		}
1111
1112		/* If memory is present, get CSD, otherwise select card */
1113		if (mmcp->card_features & CARD_FEATURE_MEMORY)
1114			PROBE_SET_ACTION(softc, PROBE_GET_CSD);
1115		else
1116			PROBE_SET_ACTION(softc, PROBE_SELECT_CARD);
1117		break;
1118	}
1119	case PROBE_MMC_SET_RELATIVE_ADDR:
1120		mmcio = &done_ccb->mmcio;
1121		err = mmcio->cmd.error;
1122		if (err != MMC_ERR_NONE) {
1123			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1124			    ("PROBE_MMC_SET_RELATIVE_ADDR: error %d\n", err));
1125			PROBE_SET_ACTION(softc, PROBE_INVALID);
1126			break;
1127		}
1128		path->device->mmc_ident_data.card_rca = MMC_PROPOSED_RCA;
1129		PROBE_SET_ACTION(softc, PROBE_GET_CSD);
1130		break;
1131	case PROBE_GET_CSD: {
1132		mmcio = &done_ccb->mmcio;
1133		err = mmcio->cmd.error;
1134
1135		if (err != MMC_ERR_NONE) {
1136			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1137				  ("PROBE_GET_CSD: error %d\n", err));
1138			PROBE_SET_ACTION(softc, PROBE_INVALID);
1139			break;
1140		}
1141
1142		struct mmc_params *mmcp = &path->device->mmc_ident_data;
1143		memcpy(mmcp->card_csd, mmcio->cmd.resp, 4 * sizeof(uint32_t));
1144		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1145		    ("CSD %08x%08x%08x%08x\n",
1146		      mmcp->card_csd[0],
1147		      mmcp->card_csd[1],
1148		      mmcp->card_csd[2],
1149		      mmcp->card_csd[3]));
1150		PROBE_SET_ACTION(softc, PROBE_SELECT_CARD);
1151		break;
1152	}
1153	case PROBE_SELECT_CARD: {
1154		mmcio = &done_ccb->mmcio;
1155		err = mmcio->cmd.error;
1156		if (err != MMC_ERR_NONE) {
1157			CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1158				  ("PROBE_SEND_RELATIVE_ADDR: error %d\n", err));
1159			PROBE_SET_ACTION(softc, PROBE_INVALID);
1160			break;
1161		}
1162
1163		PROBE_SET_ACTION(softc, PROBE_DONE);
1164		break;
1165	}
1166	default:
1167		CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1168			  ("mmcprobe_done: invalid action state 0x%x\n", softc->action));
1169		panic("default: case in mmc_probe_done()");
1170	}
1171
1172	if (softc->action == PROBE_INVALID &&
1173	  (path->device->flags & CAM_DEV_UNCONFIGURED) == 0) {
1174		xpt_async(AC_LOST_DEVICE, path, NULL);
1175	}
1176
1177	if (softc->action != PROBE_INVALID)
1178		xpt_schedule(periph, priority);
1179	/* Drop freeze taken due to CAM_DEV_QFREEZE flag set. */
1180	int frozen = cam_release_devq(path, 0, 0, 0, FALSE);
1181	CAM_DEBUG(done_ccb->ccb_h.path, CAM_DEBUG_PROBE,
1182	  ("mmcprobe_done: remaining freeze count %d\n", frozen));
1183
1184	if (softc->action == PROBE_DONE) {
1185                /* Notify the system that the device is found! */
1186		if (periph->path->device->flags & CAM_DEV_UNCONFIGURED) {
1187			path->device->flags &= ~CAM_DEV_UNCONFIGURED;
1188			xpt_acquire_device(path->device);
1189			done_ccb->ccb_h.func_code = XPT_GDEV_TYPE;
1190			xpt_action(done_ccb);
1191			xpt_async(AC_FOUND_DEVICE, path, done_ccb);
1192		}
1193	}
1194	xpt_release_ccb(done_ccb);
1195	if (softc->action == PROBE_DONE || softc->action == PROBE_INVALID) {
1196		cam_periph_invalidate(periph);
1197		cam_periph_release_locked(periph);
1198	}
1199}
1200
1201void
1202mmc_path_inq(struct ccb_pathinq *cpi, const char *hba,
1203    const struct cam_sim *sim, size_t maxio)
1204{
1205
1206	cpi->version_num = 1;
1207	cpi->hba_inquiry = 0;
1208	cpi->target_sprt = 0;
1209	cpi->hba_misc = PIM_NOBUSRESET | PIM_SEQSCAN;
1210	cpi->hba_eng_cnt = 0;
1211	cpi->max_target = 0;
1212	cpi->max_lun = 0;
1213	cpi->initiator_id = 1;
1214	cpi->maxio = maxio;
1215	strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN);
1216	strncpy(cpi->hba_vid, hba, HBA_IDLEN);
1217	strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN);
1218	cpi->unit_number = cam_sim_unit(sim);
1219	cpi->bus_id = cam_sim_bus(sim);
1220	cpi->protocol = PROTO_MMCSD;
1221	cpi->protocol_version = SCSI_REV_0;
1222	cpi->transport = XPORT_MMCSD;
1223	cpi->transport_version = 1;
1224
1225	cpi->base_transfer_speed = 100; /* XXX WTF? */
1226
1227	cpi->ccb_h.status = CAM_REQ_CMP;
1228}
1229