sdmmc.c revision 1.10 1 /* $NetBSD: sdmmc.c,v 1.10 2012/01/21 19:44:31 nonaka Exp $ */
2 /* $OpenBSD: sdmmc.c,v 1.18 2009/01/09 10:58:38 jsg Exp $ */
3
4 /*
5 * Copyright (c) 2006 Uwe Stuehler <uwe (at) openbsd.org>
6 *
7 * Permission to use, copy, modify, and distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
10 *
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 */
19
20 /*-
21 * Copyright (C) 2007, 2008, 2009 NONAKA Kimihiro <nonaka (at) netbsd.org>
22 * All rights reserved.
23 *
24 * Redistribution and use in source and binary forms, with or without
25 * modification, are permitted provided that the following conditions
26 * are met:
27 * 1. Redistributions of source code must retain the above copyright
28 * notice, this list of conditions and the following disclaimer.
29 * 2. Redistributions in binary form must reproduce the above copyright
30 * notice, this list of conditions and the following disclaimer in the
31 * documentation and/or other materials provided with the distribution.
32 *
33 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
34 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
35 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
36 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
37 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
38 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
39 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
40 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
41 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
42 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43 */
44
45 /*
46 * Host controller independent SD/MMC bus driver based on information
47 * from SanDisk SD Card Product Manual Revision 2.2 (SanDisk), SDIO
48 * Simple Specification Version 1.0 (SDIO) and the Linux "mmc" driver.
49 */
50
51 #include <sys/cdefs.h>
52 __KERNEL_RCSID(0, "$NetBSD: sdmmc.c,v 1.10 2012/01/21 19:44:31 nonaka Exp $");
53
54 #include <sys/param.h>
55 #include <sys/device.h>
56 #include <sys/kernel.h>
57 #include <sys/kthread.h>
58 #include <sys/malloc.h>
59 #include <sys/proc.h>
60 #include <sys/systm.h>
61 #include <sys/callout.h>
62
63 #include <machine/vmparam.h>
64
65 #include <dev/sdmmc/sdmmc_ioreg.h>
66 #include <dev/sdmmc/sdmmcchip.h>
67 #include <dev/sdmmc/sdmmcreg.h>
68 #include <dev/sdmmc/sdmmcvar.h>
69
70 #ifdef SDMMC_DEBUG
71 int sdmmcdebug = 1;
72 static void sdmmc_dump_command(struct sdmmc_softc *, struct sdmmc_command *);
73 #define DPRINTF(n,s) do { if ((n) <= sdmmcdebug) printf s; } while (0)
74 #else
75 #define DPRINTF(n,s) do {} while (0)
76 #endif
77
78 #define DEVNAME(sc) SDMMCDEVNAME(sc)
79
80 static int sdmmc_match(device_t, cfdata_t, void *);
81 static void sdmmc_attach(device_t, device_t, void *);
82 static int sdmmc_detach(device_t, int);
83
84 CFATTACH_DECL_NEW(sdmmc, sizeof(struct sdmmc_softc),
85 sdmmc_match, sdmmc_attach, sdmmc_detach, NULL);
86
87 static void sdmmc_doattach(device_t);
88 static void sdmmc_task_thread(void *);
89 static void sdmmc_discover_task(void *);
90 static void sdmmc_polling_card(void *);
91 static void sdmmc_card_attach(struct sdmmc_softc *);
92 static void sdmmc_card_detach(struct sdmmc_softc *, int);
93 static int sdmmc_print(void *, const char *);
94 static int sdmmc_enable(struct sdmmc_softc *);
95 static void sdmmc_disable(struct sdmmc_softc *);
96 static int sdmmc_scan(struct sdmmc_softc *);
97 static int sdmmc_init(struct sdmmc_softc *);
98
99 static int
100 sdmmc_match(device_t parent, cfdata_t cf, void *aux)
101 {
102 struct sdmmcbus_attach_args *saa = (struct sdmmcbus_attach_args *)aux;
103
104 if (strcmp(saa->saa_busname, cf->cf_name) == 0)
105 return 1;
106 return 0;
107 }
108
109 static void
110 sdmmc_attach(device_t parent, device_t self, void *aux)
111 {
112 struct sdmmc_softc *sc = device_private(self);
113 struct sdmmcbus_attach_args *saa = (struct sdmmcbus_attach_args *)aux;
114 int error;
115
116 aprint_normal("\n");
117 aprint_naive("\n");
118
119 sc->sc_dev = self;
120 sc->sc_sct = saa->saa_sct;
121 sc->sc_spi_sct = saa->saa_spi_sct;
122 sc->sc_sch = saa->saa_sch;
123 sc->sc_dmat = saa->saa_dmat;
124 sc->sc_clkmin = saa->saa_clkmin;
125 sc->sc_clkmax = saa->saa_clkmax;
126 sc->sc_busclk = sc->sc_clkmax;
127 sc->sc_buswidth = 1;
128 sc->sc_caps = saa->saa_caps;
129
130 if (ISSET(sc->sc_caps, SMC_CAPS_DMA)) {
131 error = bus_dmamap_create(sc->sc_dmat, MAXPHYS, SDMMC_MAXNSEGS,
132 MAXPHYS, 0, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW, &sc->sc_dmap);
133 if (error) {
134 aprint_error_dev(sc->sc_dev,
135 "couldn't create dma map. (error=%d)\n", error);
136 return;
137 }
138 }
139
140 if (ISSET(sc->sc_caps, SMC_CAPS_POLL_CARD_DET)) {
141 callout_init(&sc->sc_card_detect_ch, 0);
142 callout_reset(&sc->sc_card_detect_ch, hz,
143 sdmmc_polling_card, sc);
144 }
145
146 SIMPLEQ_INIT(&sc->sf_head);
147 TAILQ_INIT(&sc->sc_tskq);
148 TAILQ_INIT(&sc->sc_intrq);
149
150 sdmmc_init_task(&sc->sc_discover_task, sdmmc_discover_task, sc);
151 sdmmc_init_task(&sc->sc_intr_task, sdmmc_intr_task, sc);
152
153 mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_SDMMC);
154 mutex_init(&sc->sc_tskq_mtx, MUTEX_DEFAULT, IPL_SDMMC);
155 mutex_init(&sc->sc_discover_task_mtx, MUTEX_DEFAULT, IPL_SDMMC);
156 mutex_init(&sc->sc_intr_task_mtx, MUTEX_DEFAULT, IPL_SDMMC);
157 cv_init(&sc->sc_tskq_cv, "mmctaskq");
158
159 if (!pmf_device_register(self, NULL, NULL)) {
160 aprint_error_dev(self, "couldn't establish power handler\n");
161 }
162
163 SET(sc->sc_flags, SMF_INITED);
164
165 /*
166 * Create the event thread that will attach and detach cards
167 * and perform other lengthy operations.
168 */
169 config_pending_incr();
170 config_interrupts(self, sdmmc_doattach);
171 }
172
173 static int
174 sdmmc_detach(device_t self, int flags)
175 {
176 struct sdmmc_softc *sc = device_private(self);
177 int error;
178
179 mutex_enter(&sc->sc_tskq_mtx);
180 sc->sc_dying = 1;
181 cv_signal(&sc->sc_tskq_cv);
182 while (sc->sc_tskq_lwp != NULL)
183 cv_wait(&sc->sc_tskq_cv, &sc->sc_tskq_mtx);
184 mutex_exit(&sc->sc_tskq_mtx);
185
186 pmf_device_deregister(self);
187
188 error = config_detach_children(self, flags);
189 if (error)
190 return error;
191 return 0;
192 }
193
194 static void
195 sdmmc_doattach(device_t dev)
196 {
197 struct sdmmc_softc *sc = device_private(dev);
198
199 if (kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL,
200 sdmmc_task_thread, sc, &sc->sc_tskq_lwp, "%s", device_xname(dev))) {
201 aprint_error_dev(dev, "couldn't create task thread\n");
202 }
203 }
204
205 void
206 sdmmc_add_task(struct sdmmc_softc *sc, struct sdmmc_task *task)
207 {
208
209 mutex_enter(&sc->sc_tskq_mtx);
210 task->onqueue = 1;
211 task->sc = sc;
212 TAILQ_INSERT_TAIL(&sc->sc_tskq, task, next);
213 cv_broadcast(&sc->sc_tskq_cv);
214 mutex_exit(&sc->sc_tskq_mtx);
215 }
216
217 static inline void
218 sdmmc_del_task1(struct sdmmc_softc *sc, struct sdmmc_task *task)
219 {
220
221 TAILQ_REMOVE(&sc->sc_tskq, task, next);
222 task->sc = NULL;
223 task->onqueue = 0;
224 }
225
226 void
227 sdmmc_del_task(struct sdmmc_task *task)
228 {
229 struct sdmmc_softc *sc = (struct sdmmc_softc *)task->sc;
230
231 if (sc != NULL) {
232 mutex_enter(&sc->sc_tskq_mtx);
233 sdmmc_del_task1(sc, task);
234 mutex_exit(&sc->sc_tskq_mtx);
235 }
236 }
237
238 static void
239 sdmmc_task_thread(void *arg)
240 {
241 struct sdmmc_softc *sc = (struct sdmmc_softc *)arg;
242 struct sdmmc_task *task;
243
244 sdmmc_discover_task(sc);
245 config_pending_decr();
246
247 mutex_enter(&sc->sc_tskq_mtx);
248 for (;;) {
249 task = TAILQ_FIRST(&sc->sc_tskq);
250 if (task != NULL) {
251 sdmmc_del_task1(sc, task);
252 mutex_exit(&sc->sc_tskq_mtx);
253 (*task->func)(task->arg);
254 mutex_enter(&sc->sc_tskq_mtx);
255 } else {
256 /* Check for the exit condition. */
257 if (sc->sc_dying)
258 break;
259 cv_wait(&sc->sc_tskq_cv, &sc->sc_tskq_mtx);
260 }
261 }
262 /* time to die. */
263 sc->sc_dying = 0;
264 if (ISSET(sc->sc_flags, SMF_CARD_PRESENT))
265 sdmmc_card_detach(sc, DETACH_FORCE);
266 sc->sc_tskq_lwp = NULL;
267 cv_broadcast(&sc->sc_tskq_cv);
268 mutex_exit(&sc->sc_tskq_mtx);
269 kthread_exit(0);
270 }
271
272 void
273 sdmmc_needs_discover(device_t dev)
274 {
275 struct sdmmc_softc *sc = device_private(dev);
276
277 if (!ISSET(sc->sc_flags, SMF_INITED))
278 return;
279
280 mutex_enter(&sc->sc_discover_task_mtx);
281 if (!sdmmc_task_pending(&sc->sc_discover_task))
282 sdmmc_add_task(sc, &sc->sc_discover_task);
283 mutex_exit(&sc->sc_discover_task_mtx);
284 }
285
286 static void
287 sdmmc_discover_task(void *arg)
288 {
289 struct sdmmc_softc *sc = (struct sdmmc_softc *)arg;
290
291 if (sdmmc_chip_card_detect(sc->sc_sct, sc->sc_sch)) {
292 if (!ISSET(sc->sc_flags, SMF_CARD_PRESENT)) {
293 SET(sc->sc_flags, SMF_CARD_PRESENT);
294 sdmmc_card_attach(sc);
295 if (!ISSET(sc->sc_flags, SMF_CARD_ATTACHED))
296 CLR(sc->sc_flags, SMF_CARD_PRESENT);
297 }
298 } else {
299 if (ISSET(sc->sc_flags, SMF_CARD_PRESENT)) {
300 CLR(sc->sc_flags, SMF_CARD_PRESENT);
301 sdmmc_card_detach(sc, DETACH_FORCE);
302 }
303 }
304 }
305
306 static void
307 sdmmc_polling_card(void *arg)
308 {
309 struct sdmmc_softc *sc = (struct sdmmc_softc *)arg;
310 int card_detect;
311 int s;
312
313 s = splsdmmc();
314 card_detect = sdmmc_chip_card_detect(sc->sc_sct, sc->sc_sch);
315 if (card_detect) {
316 if (!ISSET(sc->sc_flags, SMF_CARD_PRESENT)) {
317 sdmmc_needs_discover(sc->sc_dev);
318 }
319 } else {
320 if (ISSET(sc->sc_flags, SMF_CARD_PRESENT)) {
321 sdmmc_needs_discover(sc->sc_dev);
322 }
323 }
324 splx(s);
325
326 callout_schedule(&sc->sc_card_detect_ch, hz);
327 }
328
329 /*
330 * Called from process context when a card is present.
331 */
332 static void
333 sdmmc_card_attach(struct sdmmc_softc *sc)
334 {
335 struct sdmmc_function *sf;
336 struct sdmmc_attach_args saa;
337 int error;
338
339 DPRINTF(1,("%s: attach card\n", DEVNAME(sc)));
340
341 CLR(sc->sc_flags, SMF_CARD_ATTACHED);
342
343 /*
344 * Power up the card (or card stack).
345 */
346 error = sdmmc_enable(sc);
347 if (error) {
348 if (!ISSET(sc->sc_caps, SMC_CAPS_POLL_CARD_DET)) {
349 aprint_error_dev(sc->sc_dev, "couldn't enable card\n");
350 }
351 goto err;
352 }
353
354 /*
355 * Scan for I/O functions and memory cards on the bus,
356 * allocating a sdmmc_function structure for each.
357 */
358 error = sdmmc_scan(sc);
359 if (error) {
360 aprint_error_dev(sc->sc_dev, "no functions\n");
361 goto err;
362 }
363
364 /*
365 * Initialize the I/O functions and memory cards.
366 */
367 error = sdmmc_init(sc);
368 if (error) {
369 aprint_error_dev(sc->sc_dev, "init failed\n");
370 goto err;
371 }
372
373 SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
374 if (ISSET(sc->sc_flags, SMF_IO_MODE) && sf->number < 1)
375 continue;
376
377 memset(&saa, 0, sizeof saa);
378 saa.manufacturer = sf->cis.manufacturer;
379 saa.product = sf->cis.product;
380 saa.interface = sf->interface;
381 saa.sf = sf;
382
383 sf->child =
384 config_found_ia(sc->sc_dev, "sdmmc", &saa, sdmmc_print);
385 }
386
387 SET(sc->sc_flags, SMF_CARD_ATTACHED);
388 return;
389
390 err:
391 sdmmc_card_detach(sc, DETACH_FORCE);
392 }
393
394 /*
395 * Called from process context with DETACH_* flags from <sys/device.h>
396 * when cards are gone.
397 */
398 static void
399 sdmmc_card_detach(struct sdmmc_softc *sc, int flags)
400 {
401 struct sdmmc_function *sf, *sfnext;
402
403 DPRINTF(1,("%s: detach card\n", DEVNAME(sc)));
404
405 if (ISSET(sc->sc_flags, SMF_CARD_ATTACHED)) {
406 SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
407 if (sf->child != NULL) {
408 config_detach(sf->child, DETACH_FORCE);
409 sf->child = NULL;
410 }
411 }
412
413 KASSERT(TAILQ_EMPTY(&sc->sc_intrq));
414
415 CLR(sc->sc_flags, SMF_CARD_ATTACHED);
416 }
417
418 /* Power down. */
419 sdmmc_disable(sc);
420
421 /* Free all sdmmc_function structures. */
422 for (sf = SIMPLEQ_FIRST(&sc->sf_head); sf != NULL; sf = sfnext) {
423 sfnext = SIMPLEQ_NEXT(sf, sf_list);
424 sdmmc_function_free(sf);
425 }
426 SIMPLEQ_INIT(&sc->sf_head);
427 sc->sc_function_count = 0;
428 sc->sc_fn0 = NULL;
429 }
430
431 static int
432 sdmmc_print(void *aux, const char *pnp)
433 {
434 struct sdmmc_attach_args *sa = aux;
435 struct sdmmc_function *sf = sa->sf;
436 struct sdmmc_cis *cis = &sf->sc->sc_fn0->cis;
437 int i;
438
439 if (pnp) {
440 if (sf->number == 0)
441 return QUIET;
442
443 for (i = 0; i < 4 && cis->cis1_info[i]; i++)
444 printf("%s%s", i ? ", " : "\"", cis->cis1_info[i]);
445 if (i != 0)
446 printf("\"");
447
448 if (cis->manufacturer != SDMMC_VENDOR_INVALID &&
449 cis->product != SDMMC_PRODUCT_INVALID) {
450 printf("%s(", i ? " " : "");
451 if (cis->manufacturer != SDMMC_VENDOR_INVALID)
452 printf("manufacturer 0x%x%s",
453 cis->manufacturer,
454 cis->product == SDMMC_PRODUCT_INVALID ?
455 "" : ", ");
456 if (cis->product != SDMMC_PRODUCT_INVALID)
457 printf("product 0x%x", cis->product);
458 printf(")");
459 }
460 printf("%sat %s", i ? " " : "", pnp);
461 }
462 if (sf->number > 0)
463 printf(" function %d", sf->number);
464
465 if (!pnp) {
466 for (i = 0; i < 3 && cis->cis1_info[i]; i++)
467 printf("%s%s", i ? ", " : " \"", cis->cis1_info[i]);
468 if (i != 0)
469 printf("\"");
470 }
471 return UNCONF;
472 }
473
474 static int
475 sdmmc_enable(struct sdmmc_softc *sc)
476 {
477 int error;
478
479 /*
480 * Calculate the equivalent of the card OCR from the host
481 * capabilities and select the maximum supported bus voltage.
482 */
483 error = sdmmc_chip_bus_power(sc->sc_sct, sc->sc_sch,
484 sdmmc_chip_host_ocr(sc->sc_sct, sc->sc_sch));
485 if (error) {
486 aprint_error_dev(sc->sc_dev, "couldn't supply bus power\n");
487 goto out;
488 }
489
490 /*
491 * Select the minimum clock frequency.
492 */
493 error = sdmmc_chip_bus_clock(sc->sc_sct, sc->sc_sch, SDMMC_SDCLK_400K);
494 if (error) {
495 aprint_error_dev(sc->sc_dev, "couldn't supply clock\n");
496 goto out;
497 }
498
499 /* XXX wait for card to power up */
500 sdmmc_delay(100000);
501
502 if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) {
503 /* Initialize SD I/O card function(s). */
504 error = sdmmc_io_enable(sc);
505 if (error)
506 goto out;
507 }
508
509 /* Initialize SD/MMC memory card(s). */
510 if (ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE) ||
511 ISSET(sc->sc_flags, SMF_MEM_MODE))
512 error = sdmmc_mem_enable(sc);
513
514 out:
515 if (error)
516 sdmmc_disable(sc);
517 return error;
518 }
519
520 static void
521 sdmmc_disable(struct sdmmc_softc *sc)
522 {
523 /* XXX complete commands if card is still present. */
524
525 if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) {
526 /* Make sure no card is still selected. */
527 (void)sdmmc_select_card(sc, NULL);
528 }
529
530 /* Turn off bus power and clock. */
531 (void)sdmmc_chip_bus_width(sc->sc_sct, sc->sc_sch, 1);
532 (void)sdmmc_chip_bus_clock(sc->sc_sct, sc->sc_sch, SDMMC_SDCLK_OFF);
533 (void)sdmmc_chip_bus_power(sc->sc_sct, sc->sc_sch, 0);
534 sc->sc_busclk = sc->sc_clkmax;
535 }
536
537 /*
538 * Set the lowest bus voltage supported by the card and the host.
539 */
540 int
541 sdmmc_set_bus_power(struct sdmmc_softc *sc, uint32_t host_ocr,
542 uint32_t card_ocr)
543 {
544 uint32_t bit;
545
546 /* Mask off unsupported voltage levels and select the lowest. */
547 DPRINTF(1,("%s: host_ocr=%x ", DEVNAME(sc), host_ocr));
548 host_ocr &= card_ocr;
549 for (bit = 4; bit < 23; bit++) {
550 if (ISSET(host_ocr, (1 << bit))) {
551 host_ocr &= (3 << bit);
552 break;
553 }
554 }
555 DPRINTF(1,("card_ocr=%x new_ocr=%x\n", card_ocr, host_ocr));
556
557 if (host_ocr == 0 ||
558 sdmmc_chip_bus_power(sc->sc_sct, sc->sc_sch, host_ocr) != 0)
559 return 1;
560 return 0;
561 }
562
563 struct sdmmc_function *
564 sdmmc_function_alloc(struct sdmmc_softc *sc)
565 {
566 struct sdmmc_function *sf;
567
568 sf = malloc(sizeof *sf, M_DEVBUF, M_WAITOK|M_ZERO);
569 if (sf == NULL) {
570 aprint_error_dev(sc->sc_dev,
571 "couldn't alloc memory (sdmmc function)\n");
572 return NULL;
573 }
574
575 sf->sc = sc;
576 sf->number = -1;
577 sf->cis.manufacturer = SDMMC_VENDOR_INVALID;
578 sf->cis.product = SDMMC_PRODUCT_INVALID;
579 sf->cis.function = SDMMC_FUNCTION_INVALID;
580 sf->width = 1;
581
582 if (ISSET(sc->sc_flags, SMF_MEM_MODE) &&
583 ISSET(sc->sc_caps, SMC_CAPS_DMA) &&
584 !ISSET(sc->sc_caps, SMC_CAPS_MULTI_SEG_DMA)) {
585 bus_dma_segment_t ds;
586 int rseg, error;
587
588 error = bus_dmamap_create(sc->sc_dmat, SDMMC_SECTOR_SIZE, 1,
589 SDMMC_SECTOR_SIZE, 0, BUS_DMA_WAITOK, &sf->bbuf_dmap);
590 if (error)
591 goto fail1;
592 error = bus_dmamem_alloc(sc->sc_dmat, SDMMC_SECTOR_SIZE,
593 PAGE_SIZE, 0, &ds, 1, &rseg, BUS_DMA_WAITOK);
594 if (error)
595 goto fail2;
596 error = bus_dmamem_map(sc->sc_dmat, &ds, 1, SDMMC_SECTOR_SIZE,
597 &sf->bbuf, BUS_DMA_WAITOK);
598 if (error)
599 goto fail3;
600 error = bus_dmamap_load(sc->sc_dmat, sf->bbuf_dmap,
601 sf->bbuf, SDMMC_SECTOR_SIZE, NULL,
602 BUS_DMA_WAITOK|BUS_DMA_READ|BUS_DMA_WRITE);
603 if (!error)
604 goto out;
605
606 bus_dmamem_unmap(sc->sc_dmat, sf->bbuf, SDMMC_SECTOR_SIZE);
607 fail3:
608 bus_dmamem_free(sc->sc_dmat, &ds, 1);
609 fail2:
610 bus_dmamap_destroy(sc->sc_dmat, sf->bbuf_dmap);
611 fail1:
612 free(sf, M_DEVBUF);
613 sf = NULL;
614 }
615 out:
616
617 return sf;
618 }
619
620 void
621 sdmmc_function_free(struct sdmmc_function *sf)
622 {
623 struct sdmmc_softc *sc = sf->sc;
624
625 if (ISSET(sc->sc_flags, SMF_MEM_MODE) &&
626 ISSET(sc->sc_caps, SMC_CAPS_DMA) &&
627 !ISSET(sc->sc_caps, SMC_CAPS_MULTI_SEG_DMA)) {
628 bus_dmamap_unload(sc->sc_dmat, sf->bbuf_dmap);
629 bus_dmamem_unmap(sc->sc_dmat, sf->bbuf, SDMMC_SECTOR_SIZE);
630 bus_dmamem_free(sc->sc_dmat,
631 sf->bbuf_dmap->dm_segs, sf->bbuf_dmap->dm_nsegs);
632 bus_dmamap_destroy(sc->sc_dmat, sf->bbuf_dmap);
633 }
634
635 free(sf, M_DEVBUF);
636 }
637
638 /*
639 * Scan for I/O functions and memory cards on the bus, allocating a
640 * sdmmc_function structure for each.
641 */
642 static int
643 sdmmc_scan(struct sdmmc_softc *sc)
644 {
645
646 if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) {
647 /* Scan for I/O functions. */
648 if (ISSET(sc->sc_flags, SMF_IO_MODE))
649 sdmmc_io_scan(sc);
650 }
651
652 /* Scan for memory cards on the bus. */
653 if (ISSET(sc->sc_flags, SMF_MEM_MODE))
654 sdmmc_mem_scan(sc);
655
656 /* There should be at least one function now. */
657 if (SIMPLEQ_EMPTY(&sc->sf_head)) {
658 aprint_error_dev(sc->sc_dev, "couldn't identify card\n");
659 return 1;
660 }
661 return 0;
662 }
663
664 /*
665 * Initialize all the distinguished functions of the card, be it I/O
666 * or memory functions.
667 */
668 static int
669 sdmmc_init(struct sdmmc_softc *sc)
670 {
671 struct sdmmc_function *sf;
672
673 /* Initialize all identified card functions. */
674 SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
675 if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) {
676 if (ISSET(sc->sc_flags, SMF_IO_MODE) &&
677 sdmmc_io_init(sc, sf) != 0) {
678 aprint_error_dev(sc->sc_dev,
679 "i/o init failed\n");
680 }
681 }
682
683 if (ISSET(sc->sc_flags, SMF_MEM_MODE) &&
684 sdmmc_mem_init(sc, sf) != 0) {
685 aprint_error_dev(sc->sc_dev, "mem init failed\n");
686 }
687 }
688
689 /* Any good functions left after initialization? */
690 SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
691 if (!ISSET(sf->flags, SFF_ERROR))
692 return 0;
693 }
694
695 /* No, we should probably power down the card. */
696 return 1;
697 }
698
699 void
700 sdmmc_delay(u_int usecs)
701 {
702
703 delay(usecs);
704 }
705
706 int
707 sdmmc_app_command(struct sdmmc_softc *sc, struct sdmmc_function *sf, struct sdmmc_command *cmd)
708 {
709 struct sdmmc_command acmd;
710 int error;
711
712 DPRINTF(1,("sdmmc_app_command: start\n"));
713
714 /* Don't lock */
715
716 memset(&acmd, 0, sizeof(acmd));
717 acmd.c_opcode = MMC_APP_CMD;
718 if (sf != NULL) {
719 acmd.c_arg = sf->rca << 16;
720 acmd.c_flags = SCF_CMD_AC | SCF_RSP_R1 | SCF_RSP_SPI_R1;
721 } else {
722 acmd.c_arg = 0;
723 acmd.c_flags = SCF_CMD_BCR | SCF_RSP_R1 | SCF_RSP_SPI_R1;
724 }
725
726 error = sdmmc_mmc_command(sc, &acmd);
727 if (error == 0) {
728 if (!ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE) &&
729 !ISSET(MMC_R1(acmd.c_resp), MMC_R1_APP_CMD)) {
730 /* Card does not support application commands. */
731 error = ENODEV;
732 } else {
733 error = sdmmc_mmc_command(sc, cmd);
734 }
735 }
736 DPRINTF(1,("sdmmc_app_command: done (error=%d)\n", error));
737 return error;
738 }
739
740 /*
741 * Execute MMC command and data transfers. All interactions with the
742 * host controller to complete the command happen in the context of
743 * the current process.
744 */
745 int
746 sdmmc_mmc_command(struct sdmmc_softc *sc, struct sdmmc_command *cmd)
747 {
748 int error;
749
750 DPRINTF(1,("sdmmc_mmc_command: cmd=%d, arg=%#x, flags=%#x\n",
751 cmd->c_opcode, cmd->c_arg, cmd->c_flags));
752
753 /* Don't lock */
754
755 #if defined(DIAGNOSTIC) || defined(SDMMC_DEBUG)
756 if (cmd->c_data && !ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE)) {
757 if (sc->sc_card == NULL)
758 panic("%s: deselected card\n", DEVNAME(sc));
759 }
760 #endif
761
762 sdmmc_chip_exec_command(sc->sc_sct, sc->sc_sch, cmd);
763
764 #ifdef SDMMC_DEBUG
765 sdmmc_dump_command(sc, cmd);
766 #endif
767
768 error = cmd->c_error;
769
770 DPRINTF(1,("sdmmc_mmc_command: error=%d\n", error));
771
772 return error;
773 }
774
775 /*
776 * Send the "GO IDLE STATE" command.
777 */
778 void
779 sdmmc_go_idle_state(struct sdmmc_softc *sc)
780 {
781 struct sdmmc_command cmd;
782
783 DPRINTF(1,("sdmmc_go_idle_state\n"));
784
785 /* Don't lock */
786
787 memset(&cmd, 0, sizeof(cmd));
788 cmd.c_opcode = MMC_GO_IDLE_STATE;
789 cmd.c_flags = SCF_CMD_BC | SCF_RSP_R0 | SCF_RSP_SPI_R1;
790
791 (void)sdmmc_mmc_command(sc, &cmd);
792 }
793
794 /*
795 * Retrieve (SD) or set (MMC) the relative card address (RCA).
796 */
797 int
798 sdmmc_set_relative_addr(struct sdmmc_softc *sc, struct sdmmc_function *sf)
799 {
800 struct sdmmc_command cmd;
801 int error;
802
803 /* Don't lock */
804
805 if (ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE))
806 return EIO;
807
808 memset(&cmd, 0, sizeof(cmd));
809 if (ISSET(sc->sc_flags, SMF_SD_MODE)) {
810 cmd.c_opcode = SD_SEND_RELATIVE_ADDR;
811 cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R6;
812 } else {
813 cmd.c_opcode = MMC_SET_RELATIVE_ADDR;
814 cmd.c_arg = MMC_ARG_RCA(sf->rca);
815 cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1;
816 }
817 error = sdmmc_mmc_command(sc, &cmd);
818 if (error)
819 return error;
820
821 if (ISSET(sc->sc_flags, SMF_SD_MODE))
822 sf->rca = SD_R6_RCA(cmd.c_resp);
823
824 return 0;
825 }
826
827 int
828 sdmmc_select_card(struct sdmmc_softc *sc, struct sdmmc_function *sf)
829 {
830 struct sdmmc_command cmd;
831 int error;
832
833 /* Don't lock */
834
835 if (ISSET(sc->sc_caps, SMC_CAPS_SPI_MODE))
836 return EIO;
837
838 if (sc->sc_card == sf
839 || (sf && sc->sc_card && sc->sc_card->rca == sf->rca)) {
840 sc->sc_card = sf;
841 return 0;
842 }
843
844 memset(&cmd, 0, sizeof(cmd));
845 cmd.c_opcode = MMC_SELECT_CARD;
846 cmd.c_arg = (sf == NULL) ? 0 : MMC_ARG_RCA(sf->rca);
847 cmd.c_flags = SCF_CMD_AC | ((sf == NULL) ? SCF_RSP_R0 : SCF_RSP_R1);
848 error = sdmmc_mmc_command(sc, &cmd);
849 if (error == 0 || sf == NULL)
850 sc->sc_card = sf;
851
852 return error;
853 }
854
855 #ifdef SDMMC_DEBUG
856 static void
857 sdmmc_dump_command(struct sdmmc_softc *sc, struct sdmmc_command *cmd)
858 {
859 int i;
860
861 DPRINTF(1,("%s: cmd %u arg=%#x data=%p dlen=%d flags=%#x (error %d)\n",
862 DEVNAME(sc), cmd->c_opcode, cmd->c_arg, cmd->c_data,
863 cmd->c_datalen, cmd->c_flags, cmd->c_error));
864
865 if (cmd->c_error || sdmmcdebug < 1)
866 return;
867
868 aprint_normal_dev(sc->sc_dev, "resp=");
869 if (ISSET(cmd->c_flags, SCF_RSP_136))
870 for (i = 0; i < sizeof cmd->c_resp; i++)
871 aprint_normal("%02x ", ((uint8_t *)cmd->c_resp)[i]);
872 else if (ISSET(cmd->c_flags, SCF_RSP_PRESENT))
873 for (i = 0; i < 4; i++)
874 aprint_normal("%02x ", ((uint8_t *)cmd->c_resp)[i]);
875 else
876 aprint_normal("none");
877 aprint_normal("\n");
878 }
879
880 void
881 sdmmc_dump_data(const char *title, void *ptr, size_t size)
882 {
883 char buf[16];
884 uint8_t *p = ptr;
885 int i, j;
886
887 printf("sdmmc_dump_data: %s\n", title ? title : "");
888 printf("--------+--------------------------------------------------+------------------+\n");
889 printf("offset | +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +a +b +c +d +e +f | data |\n");
890 printf("--------+--------------------------------------------------+------------------+\n");
891 for (i = 0; i < (int)size; i++) {
892 if ((i % 16) == 0) {
893 printf("%08x| ", i);
894 } else if ((i % 16) == 8) {
895 printf(" ");
896 }
897
898 printf("%02x ", p[i]);
899 buf[i % 16] = p[i];
900
901 if ((i % 16) == 15) {
902 printf("| ");
903 for (j = 0; j < 16; j++) {
904 if (buf[j] >= 0x20 && buf[j] <= 0x7e) {
905 printf("%c", buf[j]);
906 } else {
907 printf(".");
908 }
909 }
910 printf(" |\n");
911 }
912 }
913 if ((i % 16) != 0) {
914 j = (i % 16);
915 for (; j < 16; j++) {
916 printf(" ");
917 if ((j % 16) == 8) {
918 printf(" ");
919 }
920 }
921
922 printf("| ");
923 for (j = 0; j < (i % 16); j++) {
924 if (buf[j] >= 0x20 && buf[j] <= 0x7e) {
925 printf("%c", buf[j]);
926 } else {
927 printf(".");
928 }
929 }
930 for (; j < 16; j++) {
931 printf(" ");
932 }
933 printf(" |\n");
934 }
935 printf("--------+--------------------------------------------------+------------------+\n");
936 }
937 #endif
938