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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
23 * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
24 */
25
26 /*
27 * SD card slot support.
28 */
29
30 #include <sys/types.h>
31 #include <sys/cmn_err.h>
32 #include <sys/varargs.h>
33 #include <sys/ddi.h>
34 #include <sys/sunddi.h>
35 #include <sys/sdcard/sda_impl.h>
36
37
38 /*
39 * Prototypes.
40 */
41
42 static void sda_slot_insert(void *);
43 static sda_err_t sda_slot_check_response(sda_cmd_t *);
44 static void sda_slot_handle_detect(sda_slot_t *);
45 static void sda_slot_handle_transfer(sda_slot_t *, sda_err_t);
46 static void sda_slot_handle_fault(sda_slot_t *, sda_fault_t);
47 static void sda_slot_abort(sda_slot_t *, sda_err_t);
48 static void sda_slot_halt(sda_slot_t *);
49 static void sda_slot_thread(void *);
50 static void sda_slot_vprintf(sda_slot_t *, int, const char *, va_list);
51
52 /*
53 * Static Variables.
54 */
55
56 static struct {
57 sda_fault_t fault;
58 const char *msg;
59 } sda_slot_faults[] = {
60 { SDA_FAULT_TIMEOUT, "Data transfer timed out" },
61 { SDA_FAULT_ACMD12, "Auto CMD12 failure" },
62 { SDA_FAULT_CRC7, "CRC7 failure on CMD/DAT line" },
63 { SDA_FAULT_PROTO, "SD/MMC protocol signaling error" },
64 { SDA_FAULT_INIT, "Card initialization failure" },
65 { SDA_FAULT_HOST, "Internal host or slot failure" },
66 { SDA_FAULT_CURRENT, "Current overlimit detected" },
67 { SDA_FAULT_RESET, "Failed to reset slot" },
68 { SDA_FAULT_NONE, NULL }, /* sentinel, must be last! */
69 };
70
71 /*
72 * Internal implementation.
73 */
74
75 /*
76 * These allow for recursive entry. This is necessary to facilitate
77 * simpler locking with things like the fault handler, where a caller
78 * might already be "holding" the slot.
79 *
80 * This is modeled in part after ndi_devi_enter and ndi_devi_exit.
81 */
82 void
sda_slot_enter(sda_slot_t * slot)83 sda_slot_enter(sda_slot_t *slot)
84 {
85 kt_did_t self = ddi_get_kt_did();
86 mutex_enter(&slot->s_lock);
87 if (slot->s_owner == self) {
88 slot->s_circular++;
89 } else {
90 while ((slot->s_owner != 0) && (slot->s_owner != self)) {
91 cv_wait(&slot->s_cv, &slot->s_lock);
92 }
93 slot->s_owner = self;
94 slot->s_circular++;
95 }
96 mutex_exit(&slot->s_lock);
97 }
98
99 void
sda_slot_exit(sda_slot_t * slot)100 sda_slot_exit(sda_slot_t *slot)
101 {
102 ASSERT(sda_slot_owned(slot));
103
104 mutex_enter(&slot->s_lock);
105 slot->s_circular--;
106 if (slot->s_circular == 0) {
107 slot->s_owner = 0;
108 cv_broadcast(&slot->s_cv);
109 }
110 mutex_exit(&slot->s_lock);
111 }
112
113 boolean_t
sda_slot_owned(sda_slot_t * slot)114 sda_slot_owned(sda_slot_t *slot)
115 {
116 return (slot->s_owner == ddi_get_kt_did());
117 }
118
119 sda_err_t
sda_slot_check_response(sda_cmd_t * cmdp)120 sda_slot_check_response(sda_cmd_t *cmdp)
121 {
122 uint32_t errs;
123 switch (cmdp->sc_rtype & 0xf) {
124 case R1:
125 if ((errs = (cmdp->sc_response[0] & R1_ERRS)) != 0) {
126 if (errs & (R1_WP_VIOLATION | R1_CSD_OVERWRITE)) {
127 return (SDA_EWPROTECT);
128 }
129 if (errs & (R1_ADDRESS_ERROR | R1_BLOCK_LEN_ERROR |
130 R1_OUT_OF_RANGE | R1_ERASE_PARAM)) {
131 return (SDA_EINVAL);
132 }
133 return (SDA_EIO);
134 }
135 break;
136 case R5:
137 if ((errs = (cmdp->sc_response[0] & R5_ERRS)) != 0) {
138 return (SDA_EIO);
139 }
140 break;
141 }
142 return (SDA_EOK);
143 }
144
145 void
sda_slot_halt(sda_slot_t * slot)146 sda_slot_halt(sda_slot_t *slot)
147 {
148 sda_slot_enter(slot);
149 slot->s_ops.so_halt(slot->s_prv);
150 /* We need to wait 1 msec for power down. */
151 drv_usecwait(1000);
152 sda_slot_exit(slot);
153 }
154
155 void
sda_slot_reset(sda_slot_t * slot)156 sda_slot_reset(sda_slot_t *slot)
157 {
158 sda_slot_enter(slot);
159 if (slot->s_ops.so_reset(slot->s_prv) != 0) {
160 sda_slot_fault(slot, SDA_FAULT_RESET);
161 }
162 sda_slot_exit(slot);
163 }
164
165 int
sda_slot_power_on(sda_slot_t * slot)166 sda_slot_power_on(sda_slot_t *slot)
167 {
168 int rv;
169 uint32_t ocr;
170
171 sda_slot_enter(slot);
172
173 /*
174 * Get the voltage supplied by the host. Note that we expect
175 * hosts will include a range of 2.7-3.7 in their supported
176 * voltage ranges. The spec does not allow for hosts that
177 * cannot supply a voltage in this range, yet.
178 */
179 if ((rv = sda_getprop(slot, SDA_PROP_OCR, &ocr)) != 0) {
180 sda_slot_err(slot, "Failed to get host OCR (%d)", rv);
181 goto done;
182 }
183 if ((ocr & OCR_HI_MASK) == 0) {
184 sda_slot_err(slot, "Host does not support standard voltages.");
185 rv = ENOTSUP;
186 goto done;
187 }
188
189 /*
190 * We prefer 3.3V, 3.0V, and failing that, just use the
191 * maximum that the host supports. 3.3V is preferable,
192 * because it is the typical common voltage that just about
193 * everything supports. Otherwise we just pick the highest
194 * supported voltage. This facilitates initial power up.
195 */
196 if (ocr & OCR_32_33V) {
197 slot->s_cur_ocr = OCR_32_33V;
198 } else if (ocr & OCR_29_30V) {
199 slot->s_cur_ocr = OCR_29_30V;
200 } else {
201 slot->s_cur_ocr = (1U << (ddi_fls(ocr) - 1));
202 }
203
204 /*
205 * Turn on the power.
206 */
207 if ((rv = sda_setprop(slot, SDA_PROP_OCR, slot->s_cur_ocr)) != 0) {
208 sda_slot_err(slot, "Failed to set OCR %x (%d)",
209 slot->s_cur_ocr, rv);
210 goto done;
211 }
212
213 sda_slot_exit(slot);
214
215 /*
216 * Wait 250 msec (per spec) for power ramp to complete.
217 */
218 delay(drv_usectohz(250000));
219 return (0);
220
221 done:
222 sda_slot_exit(slot);
223 return (rv);
224 }
225
226 void
sda_slot_power_off(sda_slot_t * slot)227 sda_slot_power_off(sda_slot_t *slot)
228 {
229 sda_slot_enter(slot);
230 (void) sda_setprop(slot, SDA_PROP_OCR, 0);
231 /* XXX: FMA: on failure this should cause a fault to be generated */
232 /* spec requires voltage to stay low for at least 1 msec */
233 drv_usecwait(1000);
234 sda_slot_exit(slot);
235 }
236
237 void
sda_slot_insert(void * arg)238 sda_slot_insert(void *arg)
239 {
240 sda_slot_t *slot = arg;
241
242 if (sda_init_card(slot) != SDA_EOK) {
243 /*
244 * Remove power from the slot. If a more severe fault
245 * occurred, then a manual reset with cfgadm will be needed.
246 */
247 sda_slot_err(slot, "Unable to initialize card!");
248 sda_slot_enter(slot);
249 sda_slot_power_off(slot);
250 sda_slot_abort(slot, SDA_ENODEV);
251 sda_slot_exit(slot);
252
253 } else if ((slot->s_flags & SLOTF_MEMORY) == 0) {
254 /*
255 * SDIO: For SDIO, we can write the card's
256 * MANFID tuple in CIS to the UUID. Until we
257 * support SDIO, we just suppress creating
258 * devinfo nodes.
259 */
260 sda_slot_err(slot, "Non-memory target not supported");
261 } else {
262
263 sda_slot_enter(slot);
264 if (sda_mem_parse_cid_csd(slot) != DDI_SUCCESS) {
265 sda_slot_err(slot,
266 "Unable to parse card identification");
267 } else {
268 slot->s_warn = B_FALSE;
269 slot->s_ready = B_TRUE;
270 }
271 sda_slot_exit(slot);
272 }
273
274 slot->s_stamp = ddi_get_time();
275 slot->s_intransit = 0;
276 bd_state_change(slot->s_bdh);
277 }
278
279 void
sda_slot_abort(sda_slot_t * slot,sda_err_t errno)280 sda_slot_abort(sda_slot_t *slot, sda_err_t errno)
281 {
282 sda_cmd_t *cmdp;
283
284 ASSERT(sda_slot_owned(slot));
285
286 if ((cmdp = slot->s_xfrp) != NULL) {
287 slot->s_xfrp = NULL;
288 sda_cmd_notify(cmdp, 0, errno);
289 list_insert_tail(&slot->s_abortlist, cmdp);
290 }
291 while ((cmdp = list_head(&slot->s_cmdlist)) != NULL) {
292 list_remove(&slot->s_cmdlist, cmdp);
293 sda_cmd_notify(cmdp, 0, errno);
294 list_insert_tail(&slot->s_abortlist, cmdp);
295 }
296
297 sda_slot_wakeup(slot);
298 }
299
300 void
sda_slot_handle_transfer(sda_slot_t * slot,sda_err_t errno)301 sda_slot_handle_transfer(sda_slot_t *slot, sda_err_t errno)
302 {
303 sda_cmd_t *cmdp;
304
305 sda_slot_enter(slot);
306
307 if ((cmdp = slot->s_xfrp) != NULL) {
308
309 slot->s_xfrp = NULL;
310 slot->s_xfrtmo = 0;
311 (void) sda_setprop(slot, SDA_PROP_LED, 0);
312 sda_slot_exit(slot);
313
314 sda_slot_wakeup(slot);
315
316 sda_cmd_notify(cmdp, SDA_CMDF_DAT, errno);
317 } else {
318 sda_slot_exit(slot);
319 }
320 }
321
322 void
sda_slot_handle_fault(sda_slot_t * slot,sda_fault_t fault)323 sda_slot_handle_fault(sda_slot_t *slot, sda_fault_t fault)
324 {
325 const char *msg;
326 int i;
327
328 sda_slot_enter(slot);
329
330 if ((fault == SDA_FAULT_TIMEOUT) && (slot->s_init)) {
331 /*
332 * Timeouts during initialization are quite normal.
333 */
334 sda_slot_exit(slot);
335 return;
336 }
337
338 slot->s_failed = B_TRUE;
339 sda_slot_abort(slot, SDA_EFAULT);
340
341 msg = "Unknown fault (%d)";
342 for (i = 0; sda_slot_faults[i].msg != NULL; i++) {
343 if (sda_slot_faults[i].fault == fault) {
344 msg = sda_slot_faults[i].msg;
345 break;
346 }
347 }
348
349 /*
350 * FMA would be a better choice here.
351 */
352 sda_slot_err(slot, msg, fault);
353
354 /*
355 * Shut down the slot. Interaction from userland via cfgadm
356 * can revive it.
357 *
358 * FMA can help here.
359 */
360 sda_slot_halt(slot);
361
362 sda_slot_exit(slot);
363 }
364
365 void
sda_slot_handle_detect(sda_slot_t * slot)366 sda_slot_handle_detect(sda_slot_t *slot)
367 {
368 uint32_t inserted;
369
370 sda_slot_enter(slot);
371
372 slot->s_stamp = ddi_get_time();
373 slot->s_intransit = 1;
374 slot->s_flags = 0;
375 slot->s_rca = 0;
376 slot->s_ready = B_FALSE;
377
378 sda_getprop(slot, SDA_PROP_INSERTED, &inserted);
379 slot->s_inserted = (inserted != 0);
380
381 if (slot->s_inserted && !slot->s_failed) {
382 /*
383 * We need to initialize the card, so we only support
384 * hipri commands for now.
385 */
386 slot->s_init = B_TRUE;
387 sda_slot_exit(slot);
388
389 /*
390 * Card insertion occurred. We have to run this on
391 * another task, to avoid deadlock as the task may
392 * need to dispatch commands.
393 */
394
395 (void) ddi_taskq_dispatch(slot->s_hp_tq, sda_slot_insert, slot,
396 DDI_SLEEP);
397 } else {
398
399 /*
400 * Nuke in-flight commands.
401 */
402 sda_slot_abort(slot, SDA_ENODEV);
403
404 /*
405 * Restart the slot (incl. power cycle). This gets the
406 * slot to a known good state.
407 */
408 sda_slot_reset(slot);
409
410 slot->s_intransit = 0;
411 sda_slot_exit(slot);
412
413 bd_state_change(slot->s_bdh);
414 }
415
416 sda_slot_wakeup(slot);
417 }
418
419 void
sda_slot_transfer(sda_slot_t * slot,sda_err_t errno)420 sda_slot_transfer(sda_slot_t *slot, sda_err_t errno)
421 {
422 mutex_enter(&slot->s_evlock);
423 slot->s_errno = errno;
424 slot->s_xfrdone = B_TRUE;
425 cv_broadcast(&slot->s_evcv);
426 mutex_exit(&slot->s_evlock);
427 }
428
429 void
sda_slot_detect(sda_slot_t * slot)430 sda_slot_detect(sda_slot_t *slot)
431 {
432 mutex_enter(&slot->s_evlock);
433 slot->s_detect = B_TRUE;
434 cv_broadcast(&slot->s_evcv);
435 mutex_exit(&slot->s_evlock);
436 }
437
438 void
sda_slot_fault(sda_slot_t * slot,sda_fault_t fault)439 sda_slot_fault(sda_slot_t *slot, sda_fault_t fault)
440 {
441 mutex_enter(&slot->s_evlock);
442 slot->s_fault = fault;
443 cv_broadcast(&slot->s_evcv);
444 mutex_exit(&slot->s_evlock);
445 }
446
447 void
sda_slot_wakeup(sda_slot_t * slot)448 sda_slot_wakeup(sda_slot_t *slot)
449 {
450 mutex_enter(&slot->s_evlock);
451 slot->s_wake = B_TRUE;
452 cv_broadcast(&slot->s_evcv);
453 mutex_exit(&slot->s_evlock);
454 }
455
456 void
sda_slot_init(sda_slot_t * slot)457 sda_slot_init(sda_slot_t *slot)
458 {
459 mutex_init(&slot->s_lock, NULL, MUTEX_DRIVER, NULL);
460 cv_init(&slot->s_cv, NULL, CV_DRIVER, NULL);
461 mutex_init(&slot->s_evlock, NULL, MUTEX_DRIVER, NULL);
462 cv_init(&slot->s_evcv, NULL, CV_DRIVER, NULL);
463
464 sda_cmd_list_init(&slot->s_cmdlist);
465 sda_cmd_list_init(&slot->s_abortlist);
466 }
467
468 void
sda_slot_fini(sda_slot_t * slot)469 sda_slot_fini(sda_slot_t *slot)
470 {
471 sda_cmd_list_fini(&slot->s_cmdlist);
472 sda_cmd_list_fini(&slot->s_abortlist);
473 mutex_destroy(&slot->s_lock);
474 mutex_destroy(&slot->s_evlock);
475 cv_destroy(&slot->s_cv);
476 cv_destroy(&slot->s_evcv);
477 }
478
479 static bd_ops_t sda_bd_ops = {
480 BD_OPS_VERSION_0,
481 sda_mem_bd_driveinfo,
482 sda_mem_bd_mediainfo,
483 NULL, /* devid_init */
484 NULL, /* sync_cache */
485 sda_mem_bd_read,
486 sda_mem_bd_write,
487 };
488
489 void
sda_slot_attach(sda_slot_t * slot)490 sda_slot_attach(sda_slot_t *slot)
491 {
492 sda_host_t *h = slot->s_hostp;
493 char name[16];
494 uint32_t cap;
495
496 /*
497 * We have two taskqs. The first taskq is used for
498 * card initialization.
499 *
500 * The second is used for the main processing loop.
501 *
502 * The reason for a separate taskq is that initialization
503 * needs to acquire locks which may be held by the slot
504 * thread, or by device driver context... use of the separate
505 * taskq breaks the deadlock. Additionally, the
506 * initialization task may need to sleep quite a while during
507 * card initialization.
508 */
509
510 slot->s_bdh = bd_alloc_handle(slot, &sda_bd_ops, h->h_dma, KM_SLEEP);
511 ASSERT(slot->s_bdh);
512
513 sda_slot_enter(slot);
514
515 (void) snprintf(name, sizeof (name), "slot_%d_hp_tq",
516 slot->s_slot_num);
517 slot->s_hp_tq = ddi_taskq_create(h->h_dip, name, 1,
518 TASKQ_DEFAULTPRI, 0);
519 if (slot->s_hp_tq == NULL) {
520 /* Generally, this failure should never occur */
521 sda_slot_err(slot, "Unable to create hotplug slot taskq");
522 sda_slot_exit(slot);
523 bd_free_handle(slot->s_bdh);
524 slot->s_bdh = NULL;
525 return;
526 }
527
528 /* create the main processing thread */
529 (void) snprintf(name, sizeof (name), "slot_%d_main_tq",
530 slot->s_slot_num);
531 slot->s_main_tq = ddi_taskq_create(h->h_dip, name, 1,
532 TASKQ_DEFAULTPRI, 0);
533 if (slot->s_main_tq == NULL) {
534 /* Generally, this failure should never occur */
535 sda_slot_err(slot, "Unable to create main slot taskq");
536 sda_slot_exit(slot);
537 bd_free_handle(slot->s_bdh);
538 slot->s_bdh = NULL;
539 return;
540 }
541 (void) ddi_taskq_dispatch(slot->s_main_tq, sda_slot_thread, slot,
542 DDI_SLEEP);
543
544 /*
545 * Determine slot capabilities.
546 */
547 slot->s_caps = 0;
548
549 if ((sda_getprop(slot, SDA_PROP_CAP_NOPIO, &cap) == 0) && (cap != 0)) {
550 slot->s_caps |= SLOT_CAP_NOPIO;
551 }
552 if ((sda_getprop(slot, SDA_PROP_CAP_4BITS, &cap) == 0) && (cap != 0)) {
553 slot->s_caps |= SLOT_CAP_4BITS;
554 }
555 if ((sda_getprop(slot, SDA_PROP_CAP_HISPEED, &cap) == 0) &&
556 (cap != 0)) {
557 slot->s_caps |= SLOT_CAP_HISPEED;
558 }
559
560 /* make sure that the host is started up */
561 if (slot->s_ops.so_reset(slot->s_prv) != 0) {
562 sda_slot_fault(slot, SDA_FAULT_RESET);
563 }
564
565 sda_slot_exit(slot);
566
567 (void) bd_attach_handle(h->h_dip, slot->s_bdh);
568 }
569
570 void
sda_slot_detach(sda_slot_t * slot)571 sda_slot_detach(sda_slot_t *slot)
572 {
573 /*
574 * Shut down the thread.
575 */
576 (void) bd_detach_handle(slot->s_bdh);
577
578 mutex_enter(&slot->s_evlock);
579 slot->s_detach = B_TRUE;
580 cv_broadcast(&slot->s_evcv);
581 mutex_exit(&slot->s_evlock);
582
583 /*
584 * Nuke the taskqs. We do this after stopping the background
585 * thread to avoid deadlock.
586 */
587 if (slot->s_main_tq)
588 ddi_taskq_destroy(slot->s_main_tq);
589 if (slot->s_hp_tq)
590 ddi_taskq_destroy(slot->s_hp_tq);
591
592 bd_free_handle(slot->s_bdh);
593 }
594
595 void
sda_slot_suspend(sda_slot_t * slot)596 sda_slot_suspend(sda_slot_t *slot)
597 {
598 mutex_enter(&slot->s_evlock);
599 slot->s_suspend = B_TRUE;
600 cv_broadcast(&slot->s_evcv);
601 mutex_exit(&slot->s_evlock);
602 ddi_taskq_wait(slot->s_main_tq);
603 }
604
605 void
sda_slot_resume(sda_slot_t * slot)606 sda_slot_resume(sda_slot_t *slot)
607 {
608 mutex_enter(&slot->s_evlock);
609 slot->s_suspend = B_FALSE;
610 /*
611 * A card change event may have occurred, and in any case we need
612 * to reinitialize the card.
613 */
614 slot->s_detect = B_TRUE;
615 mutex_exit(&slot->s_evlock);
616
617 /* Start up a new instance of the main processing task. */
618 (void) ddi_taskq_dispatch(slot->s_main_tq, sda_slot_thread, slot,
619 DDI_SLEEP);
620 }
621
622 void
sda_slot_thread(void * arg)623 sda_slot_thread(void *arg)
624 {
625 sda_slot_t *slot = arg;
626
627 for (;;) {
628 sda_cmd_t *cmdp;
629 boolean_t datline;
630 sda_err_t rv;
631
632 mutex_enter(&slot->s_evlock);
633
634 /*
635 * Process any abort list first.
636 */
637 if ((cmdp = list_head(&slot->s_abortlist)) != NULL) {
638 list_remove(&slot->s_abortlist, cmdp);
639 mutex_exit(&slot->s_evlock);
640 /*
641 * EOK used here, to avoid clobbering previous
642 * error code.
643 */
644 sda_cmd_notify(cmdp, SDA_CMDF_BUSY | SDA_CMDF_DAT,
645 SDA_EOK);
646 continue;
647 }
648
649 if (slot->s_detach) {
650 /* Parent is detaching the slot, bail out. */
651 break;
652 }
653
654 if ((slot->s_suspend) && (slot->s_xfrp == NULL)) {
655 /*
656 * Host wants to suspend, but don't do it if
657 * we have a transfer outstanding.
658 */
659 break;
660 }
661
662 if (slot->s_detect) {
663 slot->s_detect = B_FALSE;
664 mutex_exit(&slot->s_evlock);
665
666 sda_slot_handle_detect(slot);
667 continue;
668 }
669
670 if (slot->s_xfrdone) {
671 sda_err_t errno;
672
673 errno = slot->s_errno;
674 slot->s_errno = SDA_EOK;
675 slot->s_xfrdone = B_FALSE;
676 mutex_exit(&slot->s_evlock);
677
678 sda_slot_handle_transfer(slot, errno);
679 continue;
680 }
681
682 if (slot->s_fault != SDA_FAULT_NONE) {
683 sda_fault_t fault;
684
685 fault = slot->s_fault;
686 slot->s_fault = SDA_FAULT_NONE;
687 mutex_exit(&slot->s_evlock);
688
689 sda_slot_handle_fault(slot, fault);
690 continue;
691 }
692
693 if ((slot->s_xfrp != NULL) && (gethrtime() > slot->s_xfrtmo)) {
694 /*
695 * The device stalled processing the data request.
696 * At this point, we really have no choice but to
697 * nuke the request, and flag a fault.
698 */
699 mutex_exit(&slot->s_evlock);
700 sda_slot_handle_transfer(slot, SDA_ETIME);
701 sda_slot_fault(slot, SDA_FAULT_TIMEOUT);
702 continue;
703 }
704
705 /*
706 * If the slot has suspended, then we can't process
707 * any new commands yet.
708 */
709 if ((slot->s_suspend) || (!slot->s_wake)) {
710
711 /*
712 * We use a timed wait if we are waiting for a
713 * data transfer to complete. Otherwise we
714 * avoid the timed wait to avoid waking CPU
715 * (power savings.)
716 */
717
718 if ((slot->s_xfrp != NULL) || (slot->s_reap)) {
719 /* Wait 3 sec (reap attempts). */
720 (void) cv_reltimedwait(&slot->s_evcv,
721 &slot->s_evlock, drv_usectohz(3000000),
722 TR_CLOCK_TICK);
723 } else {
724 (void) cv_wait(&slot->s_evcv, &slot->s_evlock);
725 }
726
727 mutex_exit(&slot->s_evlock);
728 continue;
729 }
730
731 slot->s_wake = B_FALSE;
732
733 mutex_exit(&slot->s_evlock);
734
735 /*
736 * We're awake now, so look for work to do. First
737 * acquire access to the slot.
738 */
739 sda_slot_enter(slot);
740
741
742 /*
743 * If no more commands to process, go back to sleep.
744 */
745 if ((cmdp = list_head(&slot->s_cmdlist)) == NULL) {
746 sda_slot_exit(slot);
747 continue;
748 }
749
750 /*
751 * If the current command is not an initialization
752 * command, but we are initializing, go back to sleep.
753 * (This happens potentially during a card reset or
754 * suspend/resume cycle, where the card has not been
755 * removed, but a reset is in progress.)
756 */
757 if (slot->s_init && !(cmdp->sc_flags & SDA_CMDF_INIT)) {
758 sda_slot_exit(slot);
759 continue;
760 }
761
762 datline = ((cmdp->sc_flags & SDA_CMDF_DAT) != 0);
763
764 if (datline) {
765 /*
766 * If the current command has a data phase
767 * while a transfer is in progress, then go
768 * back to sleep.
769 */
770 if (slot->s_xfrp != NULL) {
771 sda_slot_exit(slot);
772 continue;
773 }
774
775 /*
776 * Note that APP_CMD doesn't have a data phase,
777 * although the associated ACMD might.
778 */
779 if (cmdp->sc_index != CMD_APP_CMD) {
780 slot->s_xfrp = cmdp;
781 /*
782 * All commands should complete in
783 * less than 5 seconds. The worst
784 * case is actually somewhere around 4
785 * seconds, but that is when the clock
786 * is only 100 kHz.
787 */
788 slot->s_xfrtmo = gethrtime() +
789 5000000000ULL;
790 (void) sda_setprop(slot, SDA_PROP_LED, 1);
791 }
792 }
793
794 /*
795 * We're committed to dispatching this command now,
796 * so remove it from the list.
797 */
798 list_remove(&slot->s_cmdlist, cmdp);
799
800 /*
801 * There could be more commands after this one, so we
802 * mark ourself so we stay awake for another cycle.
803 */
804 sda_slot_wakeup(slot);
805
806 /*
807 * Submit the command. Note that we are holding the
808 * slot lock here, so it is critical that the caller
809 * *not* call back up into the framework. The caller
810 * must break context. But doing it this way prevents
811 * a critical race on card removal.
812 *
813 * Note that we don't resubmit memory to the device if
814 * it isn't flagged as ready (e.g. if the wrong device
815 * was inserted!)
816 */
817 if ((!slot->s_ready) && (cmdp->sc_flags & SDA_CMDF_MEM)) {
818 rv = SDA_ENODEV;
819 } else {
820 rv = slot->s_ops.so_cmd(slot->s_prv, cmdp);
821 }
822 if (rv == SDA_EOK)
823 rv = sda_slot_check_response(cmdp);
824
825 if (rv == SDA_EOK) {
826 /*
827 * If APP_CMD completed properly, then
828 * resubmit with ACMD index. Note wake was
829 * already set above.
830 */
831 if (cmdp->sc_index == CMD_APP_CMD) {
832 if ((cmdp->sc_response[0] & R1_APP_CMD) == 0) {
833 sda_slot_log(slot, "APP_CMD not set!");
834 }
835 sda_cmd_resubmit_acmd(slot, cmdp);
836 sda_slot_exit(slot);
837
838 continue;
839 }
840
841 } else if (datline) {
842 /*
843 * If an error occurred and we were expecting
844 * a transfer phase, we have to clean up.
845 */
846 (void) sda_setprop(slot, SDA_PROP_LED, 0);
847 slot->s_xfrp = NULL;
848 slot->s_xfrtmo = 0;
849
850 /*
851 * And notify any waiter.
852 */
853 sda_slot_exit(slot);
854 sda_cmd_notify(cmdp, SDA_CMDF_BUSY | SDA_CMDF_DAT, rv);
855 continue;
856 }
857
858 /*
859 * Wake any waiter.
860 */
861 sda_slot_exit(slot);
862 sda_cmd_notify(cmdp, SDA_CMDF_BUSY, rv);
863 }
864
865 mutex_exit(&slot->s_evlock);
866 }
867
868 void
sda_slot_vprintf(sda_slot_t * s,int level,const char * fmt,va_list ap)869 sda_slot_vprintf(sda_slot_t *s, int level, const char *fmt, va_list ap)
870 {
871 char msgbuf[256];
872 const char *pfx, *sfx;
873
874 if (level == CE_CONT) {
875 pfx = "!";
876 sfx = "\n";
877 } else {
878 pfx = sfx = "";
879 }
880
881 if (s != NULL) {
882 dev_info_t *dip = s->s_hostp->h_dip;
883
884 (void) snprintf(msgbuf, sizeof (msgbuf),
885 "%s%s%d: slot %d: %s%s", pfx,
886 ddi_driver_name(dip), ddi_get_instance(dip),
887 s->s_slot_num, fmt, sfx);
888 } else {
889 (void) snprintf(msgbuf, sizeof (msgbuf), "%ssda: %s%s",
890 pfx, fmt, sfx);
891 }
892 vcmn_err(level, msgbuf, ap);
893 }
894
895 void
sda_slot_err(sda_slot_t * s,const char * fmt,...)896 sda_slot_err(sda_slot_t *s, const char *fmt, ...)
897 {
898 va_list ap;
899
900 va_start(ap, fmt);
901 sda_slot_vprintf(s, CE_WARN, fmt, ap);
902 va_end(ap);
903 }
904
905 void
sda_slot_log(sda_slot_t * s,const char * fmt,...)906 sda_slot_log(sda_slot_t *s, const char *fmt, ...)
907 {
908 va_list ap;
909
910 va_start(ap, fmt);
911 sda_slot_vprintf(s, CE_CONT, fmt, ap);
912 va_end(ap);
913 }
914