xref: /illumos-gate/usr/src/uts/common/io/sdcard/impl/sda_mem.c (revision b31b5de1357c915fe7dab4d9646d9d84f9fe69bc)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * Memory target support for SDcard.
28  */
29 
30 #include <sys/types.h>
31 #include <sys/note.h>
32 #include <sys/conf.h>
33 #include <sys/scsi/adapters/blk2scsa.h>
34 #include <sys/ddi.h>
35 #include <sys/sunddi.h>
36 #include <sys/sdcard/sda.h>
37 #include <sys/sdcard/sda_impl.h>
38 
39 static int sda_mem_attach(dev_info_t *, ddi_attach_cmd_t);
40 static int sda_mem_detach(dev_info_t *, ddi_detach_cmd_t);
41 static int sda_mem_quiesce(dev_info_t *);
42 static b2s_err_t sda_mem_b2s_errno(sda_err_t);
43 static boolean_t sda_mem_b2s_request(void *, b2s_request_t *);
44 static boolean_t sda_mem_b2s_rw(sda_slot_t *, b2s_request_t *);
45 static void sda_mem_b2s_done(sda_cmd_t *);
46 static void sda_mem_getstring(uint32_t *, char *, int, int);
47 static int sda_mem_parse_cid_csd(sda_slot_t *, dev_info_t *);
48 static int sda_mem_cmd(sda_slot_t *, uint8_t, uint32_t, uint8_t, uint32_t *);
49 
50 
51 /*
52  * To minimize complexity and reduce layering, we implement almost the
53  * entire memory card driver (sdcard) here.  The memory card still
54  * needs to be a separate driver though, due to the requirement to
55  * have both SCSI HBA bus ops and SD bus ops.
56  */
57 
58 /*
59  * SCSA layer supplies a cb_ops, but we don't want it, because we
60  * don't want to expose a SCSI attachment point.  (Our parent handles
61  * the attachment point, the SCSI one would be confusing.)  We have to
62  * supply a stubbed out one, to prevent SCSA from trying to create minor
63  * nodes on our behalf.
64  *
65  * Perhaps at some future point we might want to expose a separate set
66  * of ioctls for these nodes, but for now we rely on our parent to do
67  * all that work.
68  */
69 static struct cb_ops sda_mem_ops = {
70 	nodev,			/* cb_open */
71 	nodev,			/* cb_close */
72 	nodev,			/* cb_strategy */
73 	nodev,			/* cb_print */
74 	nodev,			/* cb_dump */
75 	nodev,			/* cb_read */
76 	nodev,			/* cb_write */
77 	nodev,			/* cb_ioctl */
78 	nodev,			/* cb_devmap */
79 	nodev,			/* cb_mmap */
80 	nodev,			/* cb_segmap */
81 	nochpoll,		/* cb_chpoll */
82 	ddi_prop_op,		/* cb_prop_op */
83 	NULL,			/* cb_stream */
84 	D_MP			/* cb_flag */
85 };
86 
87 /*
88  * Here are the public functions.
89  */
90 void
91 sda_mem_init(struct modlinkage *modlp)
92 {
93 	struct dev_ops *devo;
94 
95 	devo = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
96 	devo->devo_attach = sda_mem_attach;
97 	devo->devo_detach = sda_mem_detach;
98 	devo->devo_quiesce = sda_mem_quiesce;
99 
100 	devo->devo_cb_ops = &sda_mem_ops;
101 
102 	/* it turns out that this can't ever really fail */
103 	(void) b2s_mod_init(modlp);
104 }
105 
106 void
107 sda_mem_fini(struct modlinkage *modlp)
108 {
109 	b2s_mod_fini(modlp);
110 }
111 
112 /*
113  * Everything beyond this is private.
114  */
115 
116 int
117 sda_mem_cmd(sda_slot_t *slot, uint8_t cmd, uint32_t arg, uint8_t rtype,
118     uint32_t *resp)
119 {
120 	sda_cmd_t	*cmdp;
121 	int		errno;
122 
123 	cmdp = sda_cmd_alloc(slot, cmd, arg, rtype, NULL, KM_SLEEP);
124 	if (cmdp == NULL) {
125 		return (ENOMEM);
126 	}
127 	errno = sda_cmd_exec(slot, cmdp, resp);
128 	sda_cmd_free(cmdp);
129 
130 	return (errno);
131 }
132 
133 boolean_t
134 sda_mem_b2s_rw(sda_slot_t *slot, b2s_request_t *reqp)
135 {
136 	sda_cmd_t	*cmdp;
137 	uint64_t	nblks;
138 	uint64_t	blkno;
139 	uint16_t	rblen;
140 	int		rv;
141 	uint8_t		index;
142 	uint16_t	flags;
143 
144 	blkno = reqp->br_lba;
145 	nblks = reqp->br_nblks;
146 
147 	switch (reqp->br_cmd) {
148 	case B2S_CMD_READ:
149 		if (nblks > 1) {
150 			index = CMD_READ_MULTI;
151 			flags = SDA_CMDF_DAT | SDA_CMDF_MEM | SDA_CMDF_READ |
152 			    SDA_CMDF_AUTO_CMD12;
153 		} else {
154 			index = CMD_READ_SINGLE;
155 			flags = SDA_CMDF_DAT | SDA_CMDF_MEM | SDA_CMDF_READ;
156 		}
157 		break;
158 	case B2S_CMD_WRITE:
159 		if (nblks > 1) {
160 			index = CMD_WRITE_MULTI;
161 			flags = SDA_CMDF_DAT | SDA_CMDF_MEM | SDA_CMDF_WRITE |
162 			    SDA_CMDF_AUTO_CMD12;
163 		} else {
164 			index = CMD_WRITE_SINGLE;
165 			flags = SDA_CMDF_DAT | SDA_CMDF_MEM | SDA_CMDF_WRITE;
166 		}
167 		break;
168 	default:
169 		ASSERT(0);
170 		break;
171 	}
172 
173 	cmdp = sda_cmd_alloc(slot, index, blkno << slot->s_bshift,
174 	    R1, reqp, KM_NOSLEEP);
175 	if (cmdp == NULL) {
176 		b2s_request_done(reqp, B2S_ENOMEM, 0);
177 		return (B_TRUE);
178 	}
179 
180 	if (slot->s_hostp->h_dma != NULL) {
181 		b2s_request_dma(reqp, &cmdp->sc_ndmac, &cmdp->sc_dmacs);
182 		cmdp->sc_kvaddr = 0;
183 	} else {
184 		cmdp->sc_ndmac = 0;
185 	}
186 	if ((slot->s_caps & SLOT_CAP_NOPIO) == 0) {
187 		size_t	maplen;
188 		b2s_request_mapin(reqp, &cmdp->sc_kvaddr, &maplen);
189 	}
190 
191 	if (nblks == 0) {
192 		/*
193 		 * This is not strictly a failure, but no work to do.
194 		 * We have to do it late here because we don't want to
195 		 * by pass the above media readiness checks.
196 		 */
197 		rv = B2S_EOK;
198 		goto failed;
199 	}
200 	if (nblks > 0xffff) {
201 		rv = B2S_EINVAL;
202 		goto failed;
203 	}
204 
205 	rblen = slot->s_blksz;
206 
207 	if ((blkno + nblks) > slot->s_nblks) {
208 		rv = B2S_EBLKADDR;
209 		goto failed;
210 	}
211 
212 	cmdp->sc_rtype = R1;
213 	cmdp->sc_blksz = rblen;
214 	cmdp->sc_nblks = (uint16_t)nblks;
215 	cmdp->sc_index = index;
216 	cmdp->sc_flags = flags;
217 
218 	sda_cmd_submit(slot, cmdp, sda_mem_b2s_done);
219 	return (B_TRUE);
220 
221 failed:
222 	sda_cmd_free(cmdp);
223 	b2s_request_done(reqp, rv, 0);
224 	return (B_TRUE);
225 }
226 
227 boolean_t
228 sda_mem_b2s_format(sda_slot_t *slot, b2s_request_t *reqp)
229 {
230 	sda_cmd_t	*cmdp;
231 	int		rv;
232 
233 
234 	rv = sda_mem_cmd(slot, CMD_ERASE_START, 0, R1, NULL);
235 	if (rv != 0) {
236 		b2s_request_done(reqp, sda_mem_b2s_errno(rv), 0);
237 		return (B_TRUE);
238 	}
239 	rv = sda_mem_cmd(slot, CMD_ERASE_END, slot->s_nblks - 1, R1, NULL);
240 	if (rv != 0) {
241 		b2s_request_done(reqp, sda_mem_b2s_errno(rv), 0);
242 		return (B_TRUE);
243 	}
244 
245 	cmdp = sda_cmd_alloc(slot, CMD_ERASE, 0, R1b, reqp, KM_NOSLEEP);
246 	if (cmdp == NULL) {
247 		b2s_request_done(reqp, B2S_ENOMEM, 0);
248 		return (B_TRUE);
249 	}
250 	cmdp->sc_flags = SDA_CMDF_DAT | SDA_CMDF_MEM;
251 
252 	sda_cmd_submit(slot, cmdp, sda_mem_b2s_done);
253 	return (B_TRUE);
254 }
255 
256 b2s_err_t
257 sda_mem_b2s_errno(sda_err_t errno)
258 {
259 	/* the hot path */
260 	if (errno == SDA_EOK) {
261 		return (B2S_EOK);
262 	}
263 
264 	switch (errno) {
265 	case SDA_ENOMEM:
266 		return (B2S_ENOMEM);
267 	case SDA_ETIME:
268 		return (B2S_ETIMEDOUT);
269 	case SDA_EWPROTECT:
270 		return (B2S_EWPROTECT);
271 	case SDA_ESUSPENDED:
272 	case SDA_ENODEV:
273 		return (B2S_ENOMEDIA);
274 	case SDA_EFAULT:
275 	case SDA_ECRC7:
276 	case SDA_EPROTO:
277 		return (B2S_EHARDWARE);
278 	case SDA_ERESET:
279 		return (B2S_ERESET);
280 	case SDA_EIO:
281 	case SDA_ERESID:
282 	default:
283 		return (B2S_EIO);
284 	}
285 }
286 
287 void
288 sda_mem_b2s_done(sda_cmd_t *cmdp)
289 {
290 	b2s_request_t	*reqp = sda_cmd_data(cmdp);
291 	int		errno = sda_cmd_errno(cmdp);
292 
293 	b2s_request_done(reqp, sda_mem_b2s_errno(errno), cmdp->sc_resid);
294 	sda_cmd_free(cmdp);
295 }
296 
297 boolean_t
298 sda_mem_b2s_request(void *arg, b2s_request_t *reqp)
299 {
300 	sda_slot_t	*slot = arg;
301 	int		rv;
302 
303 	switch (reqp->br_cmd) {
304 	case B2S_CMD_WRITE:
305 		if ((slot->s_flags & SLOTF_WRITABLE) == 0) {
306 			rv = B2S_EWPROTECT;
307 		} else {
308 			return (sda_mem_b2s_rw(slot, reqp));
309 		}
310 		break;
311 
312 	case B2S_CMD_READ:
313 		return (sda_mem_b2s_rw(slot, reqp));
314 
315 	case B2S_CMD_INQUIRY:
316 		reqp->br_inquiry.inq_vendor = "OSOL";
317 		reqp->br_inquiry.inq_product =
318 		    slot->s_flags & SLOTF_MMC ? "MultiMediaCard" :
319 		    slot->s_flags & SLOTF_SDHC ? "SDHC Memory Card" :
320 		    "SD Memory Card";
321 		reqp->br_inquiry.inq_revision = "";
322 		reqp->br_inquiry.inq_serial = "";
323 		rv = B2S_EOK;
324 		break;
325 
326 	case B2S_CMD_GETMEDIA:
327 		if (!slot->s_ready) {
328 			rv = B2S_ENODEV;
329 		} else {
330 			reqp->br_media.media_blksz = slot->s_blksz;
331 			reqp->br_media.media_nblks = slot->s_nblks;
332 			/* detect read-only cards */
333 			if (slot->s_flags & SLOTF_WRITABLE) {
334 				reqp->br_media.media_flags = 0;
335 			} else {
336 				reqp->br_media.media_flags =
337 				    B2S_MEDIA_FLAG_READ_ONLY;
338 			}
339 			rv = B2S_EOK;
340 		}
341 		break;
342 
343 	case B2S_CMD_FORMAT:
344 		return (sda_mem_b2s_format(slot, reqp));
345 
346 	case B2S_CMD_ABORT:
347 		sda_slot_mem_reset(slot, SDA_EABORT);
348 		rv = B2S_EOK;
349 		break;
350 
351 	case B2S_CMD_RESET:
352 		sda_slot_mem_reset(slot, SDA_ERESET);
353 		rv = B2S_EOK;
354 		break;
355 
356 	case B2S_CMD_START:
357 	case B2S_CMD_STOP:
358 	case B2S_CMD_SYNC:
359 		rv = B2S_EOK;
360 		break;
361 
362 	case B2S_CMD_LOCK:
363 	case B2S_CMD_UNLOCK:
364 	default:
365 		rv = B2S_ENOTSUP;
366 		break;
367 	}
368 
369 	b2s_request_done(reqp, rv, 0);
370 	return (B_TRUE);
371 }
372 
373 int
374 sda_mem_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
375 {
376 	sda_slot_t		*slot;
377 	b2s_nexus_t		*nexus;
378 	b2s_nexus_info_t	nexinfo;
379 	b2s_leaf_info_t		leafinfo;
380 
381 	switch (cmd) {
382 	case DDI_ATTACH:
383 		if ((slot = ddi_get_parent_data(dip)) == NULL) {
384 			return (DDI_FAILURE);
385 		}
386 
387 		if (sda_mem_parse_cid_csd(slot, dip) != DDI_SUCCESS) {
388 			return (DDI_FAILURE);
389 		}
390 
391 		nexinfo.nexus_version = B2S_VERSION_0;
392 		nexinfo.nexus_private = slot;
393 		nexinfo.nexus_dip = dip;
394 		nexinfo.nexus_dma_attr = slot->s_hostp->h_dma;
395 		nexinfo.nexus_request = sda_mem_b2s_request;
396 
397 		nexus = b2s_alloc_nexus(&nexinfo);
398 		if (nexus == NULL) {
399 			return (DDI_FAILURE);
400 		}
401 
402 		leafinfo.leaf_target = 0;
403 		leafinfo.leaf_lun = 0;
404 		leafinfo.leaf_flags =
405 		    B2S_LEAF_REMOVABLE | B2S_LEAF_HOTPLUGGABLE;
406 		leafinfo.leaf_unique_id = slot->s_uuid;
407 
408 		slot->s_leaf = b2s_attach_leaf(nexus, &leafinfo);
409 		if (slot->s_leaf == NULL) {
410 			b2s_free_nexus(nexus);
411 			return (DDI_FAILURE);
412 		}
413 
414 		slot->s_nexus = nexus;
415 		if (b2s_attach_nexus(nexus) != DDI_SUCCESS) {
416 			slot->s_nexus = NULL;
417 			b2s_free_nexus(nexus);
418 			return (DDI_FAILURE);
419 		}
420 		slot->s_nexus = nexus;
421 
422 		return (DDI_SUCCESS);
423 
424 
425 	case DDI_RESUME:
426 		return (DDI_SUCCESS);
427 
428 	default:
429 		return (DDI_FAILURE);
430 	}
431 }
432 
433 int
434 sda_mem_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
435 {
436 	sda_slot_t	*slot;
437 	b2s_nexus_t	*nexus;
438 
439 	switch (cmd) {
440 	case DDI_DETACH:
441 		if ((slot = ddi_get_parent_data(dip)) == NULL) {
442 			return (DDI_FAILURE);
443 		}
444 		if ((nexus = slot->s_nexus) == NULL) {
445 			/* nothing to do */
446 			return (DDI_SUCCESS);
447 		}
448 		if (b2s_detach_nexus(nexus) != DDI_SUCCESS) {
449 			return (DDI_FAILURE);
450 		}
451 		slot->s_nexus = NULL;
452 		b2s_free_nexus(nexus);
453 		return (DDI_SUCCESS);
454 
455 	case DDI_SUSPEND:
456 		return (DDI_SUCCESS);
457 
458 	default:
459 		return (DDI_FAILURE);
460 	}
461 }
462 
463 int
464 sda_mem_quiesce(dev_info_t *dip)
465 {
466 	_NOTE(ARGUNUSED(dip));
467 	/* no work to do */
468 	return (DDI_SUCCESS);
469 }
470 
471 uint32_t
472 sda_mem_getbits(uint32_t *resp, int hibit, int len)
473 {
474 	uint32_t	val = 0;
475 	uint32_t	bit;
476 
477 	for (bit = hibit; len--; bit--) {
478 		val <<= 1;
479 		val |= ((resp[bit / 32]) >> (bit % 32)) & 1;
480 	}
481 	return (val);
482 }
483 
484 void
485 sda_mem_getstring(uint32_t *resp, char *s, int hibit, int len)
486 {
487 	while (len--) {
488 		*s++ = sda_mem_getbits(resp, hibit, 8);
489 		hibit -= 8;
490 	}
491 	*s = 0;
492 }
493 
494 uint32_t
495 sda_mem_maxclk(sda_slot_t *slot)
496 {
497 	static const uint32_t	mult[16] = {
498 		0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80
499 	};
500 
501 	static const uint32_t	units[8] = {
502 		10000, 100000, 1000000, 10000000, 0, 0, 0, 0,
503 	};
504 	uint8_t			ts;
505 
506 	ts = sda_mem_getbits(slot->s_rcsd, 103, 8);
507 
508 	return ((units[ts & 0x7]) * (mult[(ts >> 3) & 0xf]));
509 }
510 
511 int
512 sda_mem_parse_cid_csd(sda_slot_t *slot, dev_info_t *dip)
513 {
514 	uint32_t	*rcid;
515 	uint32_t	*rcsd;
516 	int		csdver;
517 	uint16_t	rblen;
518 	uint16_t	bshift;
519 	uint32_t	cmult;
520 	uint32_t	csize;
521 	char		date[16];
522 	char		*dtype;
523 
524 	rcid = slot->s_rcid;
525 	rcsd = slot->s_rcsd;
526 
527 	csdver = sda_mem_getbits(rcsd, 127, 2);
528 
529 	if (slot->s_flags & SLOTF_SDMEM) {
530 		switch (csdver) {
531 		case 0:
532 			csize = sda_mem_getbits(rcsd, 73, 12);
533 			/* see comment above */
534 			rblen = (1 << sda_mem_getbits(rcsd, 83, 4));
535 			cmult = (4 << sda_mem_getbits(rcsd, 49, 3));
536 			bshift = 9;
537 			break;
538 		case 1:
539 			rblen = 512;
540 			csize = sda_mem_getbits(rcsd, 69, 22);
541 			cmult = 1024;
542 			bshift = 0;
543 			break;
544 		default:
545 			sda_slot_err(slot, "Unknown SD CSD version (%d)",
546 			    csdver);
547 			return (DDI_FAILURE);
548 		}
549 
550 		dtype = slot->s_flags & SLOTF_SDHC ? "sdhc" : "sdcard";
551 		slot->s_mfg = sda_mem_getbits(rcid, 127, 8);
552 		sda_mem_getstring(rcid, slot->s_oem, 119, 2);
553 		sda_mem_getstring(rcid, slot->s_prod, 103, 5);
554 		slot->s_majver = sda_mem_getbits(rcid, 63, 4);
555 		slot->s_minver = sda_mem_getbits(rcid, 59, 4);
556 		slot->s_serial =  sda_mem_getbits(rcid, 55, 32);
557 		slot->s_year = sda_mem_getbits(rcid, 19, 8) + 2000;
558 		slot->s_month = sda_mem_getbits(rcid, 11, 4);
559 
560 	} else if (slot->s_flags & SLOTF_MMC) {
561 		if ((csdver < 1) || (csdver > 2)) {
562 			sda_slot_err(slot, "Unknown MMC CSD version (%d)",
563 			    csdver);
564 			return (DDI_FAILURE);
565 		}
566 
567 		dtype = "mmc";
568 
569 		switch (sda_mem_getbits(rcsd, 125, 4)) {
570 		case 0:	/* MMC 1.0 - 1.2 */
571 		case 1:	/* MMC 1.4 */
572 			slot->s_mfg = sda_mem_getbits(rcid, 127, 24);
573 			slot->s_oem[0] = 0;
574 			sda_mem_getstring(rcid, slot->s_prod, 103, 7);
575 			slot->s_majver = sda_mem_getbits(rcid, 47, 4);
576 			slot->s_minver = sda_mem_getbits(rcid, 43, 4);
577 			slot->s_serial =  sda_mem_getbits(rcid, 39, 24);
578 			break;
579 
580 		case 2:	/* MMC 2.0 - 2.2 */
581 		case 3:	/* MMC 3.1 - 3.3 */
582 		case 4:	/* MMC 4.x */
583 			slot->s_mfg = sda_mem_getbits(rcid, 127, 8);
584 			sda_mem_getstring(rcid, slot->s_oem, 119, 2);
585 			sda_mem_getstring(rcid, slot->s_prod, 103, 6);
586 			slot->s_majver = sda_mem_getbits(rcid, 55, 4);
587 			slot->s_minver = sda_mem_getbits(rcid, 51, 4);
588 			slot->s_serial =  sda_mem_getbits(rcid, 47, 32);
589 			break;
590 
591 		default:
592 			/* this error isn't fatal to us */
593 			sda_slot_err(slot, "Unknown MMCA version (%d)",
594 			    sda_mem_getbits(rcsd, 125, 4));
595 			break;
596 		}
597 
598 		slot->s_year = sda_mem_getbits(rcid, 11, 4) + 1997;
599 		slot->s_month = sda_mem_getbits(rcid, 15, 4);
600 
601 		csize = sda_mem_getbits(rcsd, 73, 12);
602 		rblen = (1 << sda_mem_getbits(rcsd, 83, 4));
603 		cmult = (4 << sda_mem_getbits(rcsd, 49, 3));
604 		bshift = 9;
605 
606 	} else {
607 
608 		sda_slot_err(slot, "Card type unknown");
609 		return (DDI_FAILURE);
610 	}
611 
612 	/*
613 	 * These fields are common to all known MMC/SDcard memory cards.
614 	 *
615 	 * The spec requires that block size 512 be supported.
616 	 * The media may have a different native size, but 512
617 	 * byte blocks will always work.  This is true for SDcard,
618 	 * and apparently for MMC as well.
619 	 */
620 	rblen = max(rblen, 512);	/* paranoia */
621 	slot->s_nblks = (csize + 1) * cmult * (rblen / 512);
622 	slot->s_bshift = bshift;
623 	slot->s_blksz = 512;
624 
625 	slot->s_r2w = (1 << sda_mem_getbits(rcsd, 28, 3));
626 	slot->s_ccc = sda_mem_getbits(rcsd, 95, 12);
627 	slot->s_perm_wp = sda_mem_getbits(rcsd, 13, 1);
628 	slot->s_temp_wp = sda_mem_getbits(rcsd, 12, 1);
629 	slot->s_dsr = sda_mem_getbits(rcsd, 76, 1);
630 
631 	if (((slot->s_ccc & (1 << 4)) == 0) ||
632 	    (slot->s_perm_wp != 0) || (slot->s_temp_wp != 0)) {
633 		slot->s_flags &= ~SLOTF_WRITABLE;
634 	}
635 	(void) snprintf(date, sizeof (date), "%02d-%04d",
636 	    slot->s_month, slot->s_year);
637 
638 #define	prop_set_int(name, val)		\
639 	(void) ddi_prop_update_int(DDI_DEV_T_NONE, dip, name, val)
640 #define	prop_set_str(name, val)		\
641 	(void) ddi_prop_update_string(DDI_DEV_T_NONE, dip, name, val)
642 #define	prop_set_bool(name, val)	\
643 	if (val) (void) ddi_prop_create(DDI_DEV_T_NONE, dip, 0, name, NULL, 0)
644 
645 	prop_set_str("device-type", dtype);
646 	prop_set_int("mfg-id", slot->s_mfg);
647 	prop_set_str("product-id", slot->s_prod);
648 	prop_set_str("oem-id", slot->s_oem);
649 	prop_set_str("mfg-date", date);
650 
651 	prop_set_int("block-size", slot->s_blksz);
652 	prop_set_int("num-blocks", slot->s_nblks);
653 	prop_set_int("max-freq", slot->s_maxclk);
654 	prop_set_bool("dsr-implemented", slot->s_dsr);
655 	prop_set_int("ccc", slot->s_ccc);
656 	prop_set_bool("perm-wp", slot->s_perm_wp);
657 	prop_set_bool("temp-wp", slot->s_temp_wp);
658 
659 #undef	prop_set_int
660 #undef	prop_set_str
661 #undef	prop_set_bool
662 
663 	return (DDI_SUCCESS);
664 }
665