Annotation of sys/dev/sdmmc/sdmmc.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: sdmmc.c,v 1.12 2007/05/31 10:09:01 uwe Exp $ */
2:
3: /*
4: * Copyright (c) 2006 Uwe Stuehler <uwe@openbsd.org>
5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: /*
20: * Host controller independent SD/MMC bus driver based on information
21: * from SanDisk SD Card Product Manual Revision 2.2 (SanDisk), SDIO
22: * Simple Specification Version 1.0 (SDIO) and the Linux "mmc" driver.
23: */
24:
25: #include <sys/param.h>
26: #include <sys/device.h>
27: #include <sys/kernel.h>
28: #include <sys/kthread.h>
29: #include <sys/malloc.h>
30: #include <sys/proc.h>
31: #include <sys/systm.h>
32:
33: #include <scsi/scsi_all.h>
34: #include <scsi/scsiconf.h>
35:
36: #include <dev/sdmmc/sdmmc_ioreg.h>
37: #include <dev/sdmmc/sdmmc_scsi.h>
38: #include <dev/sdmmc/sdmmcchip.h>
39: #include <dev/sdmmc/sdmmcreg.h>
40: #include <dev/sdmmc/sdmmcvar.h>
41:
42: #ifdef SDMMC_IOCTL
43: #include "bio.h"
44: #if NBIO < 1
45: #undef SDMMC_IOCTL
46: #endif
47: #include <dev/biovar.h>
48: #endif
49:
50: int sdmmc_match(struct device *, void *, void *);
51: void sdmmc_attach(struct device *, struct device *, void *);
52: int sdmmc_detach(struct device *, int);
53: void sdmmc_create_thread(void *);
54: void sdmmc_task_thread(void *);
55: void sdmmc_discover_task(void *);
56: void sdmmc_card_attach(struct sdmmc_softc *);
57: void sdmmc_card_detach(struct sdmmc_softc *, int);
58: int sdmmc_enable(struct sdmmc_softc *);
59: void sdmmc_disable(struct sdmmc_softc *);
60: int sdmmc_scan(struct sdmmc_softc *);
61: int sdmmc_init(struct sdmmc_softc *);
62: int sdmmc_set_bus_width(struct sdmmc_function *);
63: #ifdef SDMMC_IOCTL
64: int sdmmc_ioctl(struct device *, u_long, caddr_t);
65: #endif
66:
67: #define DEVNAME(sc) SDMMCDEVNAME(sc)
68:
69: #ifdef SDMMC_DEBUG
70: int sdmmcdebug = 0;
71: extern int sdhcdebug; /* XXX should have a sdmmc_chip_debug() function */
72: 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: struct cfattach sdmmc_ca = {
79: sizeof(struct sdmmc_softc), sdmmc_match, sdmmc_attach, sdmmc_detach
80: };
81:
82: struct cfdriver sdmmc_cd = {
83: NULL, "sdmmc", DV_DULL
84: };
85:
86: int
87: sdmmc_match(struct device *parent, void *match, void *aux)
88: {
89: struct cfdata *cf = match;
90: struct sdmmcbus_attach_args *saa = aux;
91:
92: return strcmp(saa->saa_busname, cf->cf_driver->cd_name) == 0;
93: }
94:
95: void
96: sdmmc_attach(struct device *parent, struct device *self, void *aux)
97: {
98: struct sdmmc_softc *sc = (struct sdmmc_softc *)self;
99: struct sdmmcbus_attach_args *saa = aux;
100:
101: printf("\n");
102:
103: sc->sct = saa->sct;
104: sc->sch = saa->sch;
105:
106: SIMPLEQ_INIT(&sc->sf_head);
107: TAILQ_INIT(&sc->sc_tskq);
108: TAILQ_INIT(&sc->sc_intrq);
109: sdmmc_init_task(&sc->sc_discover_task, sdmmc_discover_task, sc);
110: sdmmc_init_task(&sc->sc_intr_task, sdmmc_intr_task, sc);
111: lockinit(&sc->sc_lock, PRIBIO, DEVNAME(sc), 0, LK_CANRECURSE);
112:
113: #ifdef SDMMC_IOCTL
114: if (bio_register(self, sdmmc_ioctl) != 0)
115: printf("%s: unable to register ioctl\n", DEVNAME(sc));
116: #endif
117:
118: /*
119: * Create the event thread that will attach and detach cards
120: * and perform other lengthy operations.
121: */
122: #ifdef DO_CONFIG_PENDING
123: config_pending_incr();
124: #endif
125: kthread_create_deferred(sdmmc_create_thread, sc);
126: }
127:
128: int
129: sdmmc_detach(struct device *self, int flags)
130: {
131: struct sdmmc_softc *sc = (struct sdmmc_softc *)self;
132:
133: sc->sc_dying = 1;
134: while (sc->sc_task_thread != NULL) {
135: wakeup(&sc->sc_tskq);
136: tsleep(sc, PWAIT, "mmcdie", 0);
137: }
138: return 0;
139: }
140:
141: void
142: sdmmc_create_thread(void *arg)
143: {
144: struct sdmmc_softc *sc = arg;
145:
146: if (kthread_create(sdmmc_task_thread, sc, &sc->sc_task_thread,
147: "%s", DEVNAME(sc)) != 0)
148: printf("%s: can't create task thread\n", DEVNAME(sc));
149:
150: #ifdef DO_CONFIG_PENDING
151: config_pending_decr();
152: #endif
153: }
154:
155: void
156: sdmmc_task_thread(void *arg)
157: {
158: struct sdmmc_softc *sc = arg;
159: struct sdmmc_task *task;
160: int s;
161:
162: sdmmc_needs_discover(&sc->sc_dev);
163:
164: s = splsdmmc();
165: while (!sc->sc_dying) {
166: for (task = TAILQ_FIRST(&sc->sc_tskq); task != NULL;
167: task = TAILQ_FIRST(&sc->sc_tskq)) {
168: splx(s);
169: sdmmc_del_task(task);
170: task->func(task->arg);
171: s = splsdmmc();
172: }
173: tsleep(&sc->sc_tskq, PWAIT, "mmctsk", 0);
174: }
175: splx(s);
176:
177: if (ISSET(sc->sc_flags, SMF_CARD_PRESENT))
178: sdmmc_card_detach(sc, DETACH_FORCE);
179:
180: sc->sc_task_thread = NULL;
181: wakeup(sc);
182: kthread_exit(0);
183: }
184:
185: void
186: sdmmc_add_task(struct sdmmc_softc *sc, struct sdmmc_task *task)
187: {
188: int s;
189:
190: s = splsdmmc();
191: TAILQ_INSERT_TAIL(&sc->sc_tskq, task, next);
192: task->onqueue = 1;
193: task->sc = sc;
194: wakeup(&sc->sc_tskq);
195: splx(s);
196: }
197:
198: void
199: sdmmc_del_task(struct sdmmc_task *task)
200: {
201: struct sdmmc_softc *sc = task->sc;
202: int s;
203:
204: if (sc == NULL)
205: return;
206:
207: s = splsdmmc();
208: task->sc = NULL;
209: task->onqueue = 0;
210: TAILQ_REMOVE(&sc->sc_tskq, task, next);
211: splx(s);
212: }
213:
214: void
215: sdmmc_needs_discover(struct device *self)
216: {
217: struct sdmmc_softc *sc = (struct sdmmc_softc *)self;
218:
219: if (!sdmmc_task_pending(&sc->sc_discover_task))
220: sdmmc_add_task(sc, &sc->sc_discover_task);
221: }
222:
223: void
224: sdmmc_discover_task(void *arg)
225: {
226: struct sdmmc_softc *sc = arg;
227:
228: if (sdmmc_chip_card_detect(sc->sct, sc->sch)) {
229: if (!ISSET(sc->sc_flags, SMF_CARD_PRESENT)) {
230: SET(sc->sc_flags, SMF_CARD_PRESENT);
231: sdmmc_card_attach(sc);
232: }
233: } else {
234: if (ISSET(sc->sc_flags, SMF_CARD_PRESENT)) {
235: CLR(sc->sc_flags, SMF_CARD_PRESENT);
236: sdmmc_card_detach(sc, DETACH_FORCE);
237: }
238: }
239: }
240:
241: /*
242: * Called from process context when a card is present.
243: */
244: void
245: sdmmc_card_attach(struct sdmmc_softc *sc)
246: {
247: DPRINTF(1,("%s: attach card\n", DEVNAME(sc)));
248:
249: SDMMC_LOCK(sc);
250: CLR(sc->sc_flags, SMF_CARD_ATTACHED);
251:
252: /*
253: * Power up the card (or card stack).
254: */
255: if (sdmmc_enable(sc) != 0) {
256: printf("%s: can't enable card\n", DEVNAME(sc));
257: goto err;
258: }
259:
260: /*
261: * Scan for I/O functions and memory cards on the bus,
262: * allocating a sdmmc_function structure for each.
263: */
264: if (sdmmc_scan(sc) != 0) {
265: printf("%s: no functions\n", DEVNAME(sc));
266: goto err;
267: }
268:
269: /*
270: * Initialize the I/O functions and memory cards.
271: */
272: if (sdmmc_init(sc) != 0) {
273: printf("%s: init failed\n", DEVNAME(sc));
274: goto err;
275: }
276:
277: /* Attach SCSI emulation for memory cards. */
278: if (ISSET(sc->sc_flags, SMF_MEM_MODE))
279: sdmmc_scsi_attach(sc);
280:
281: /* Attach I/O function drivers. */
282: if (ISSET(sc->sc_flags, SMF_IO_MODE))
283: sdmmc_io_attach(sc);
284:
285: SET(sc->sc_flags, SMF_CARD_ATTACHED);
286: SDMMC_UNLOCK(sc);
287: return;
288: err:
289: sdmmc_card_detach(sc, DETACH_FORCE);
290: SDMMC_UNLOCK(sc);
291: }
292:
293: /*
294: * Called from process context with DETACH_* flags from <sys/device.h>
295: * when cards are gone.
296: */
297: void
298: sdmmc_card_detach(struct sdmmc_softc *sc, int flags)
299: {
300: struct sdmmc_function *sf, *sfnext;
301:
302: DPRINTF(1,("%s: detach card\n", DEVNAME(sc)));
303:
304: if (ISSET(sc->sc_flags, SMF_CARD_ATTACHED)) {
305: /* Detach I/O function drivers. */
306: if (ISSET(sc->sc_flags, SMF_IO_MODE))
307: sdmmc_io_detach(sc);
308:
309: /* Detach the SCSI emulation for memory cards. */
310: if (ISSET(sc->sc_flags, SMF_MEM_MODE))
311: sdmmc_scsi_detach(sc);
312:
313: CLR(sc->sc_flags, SMF_CARD_ATTACHED);
314: }
315:
316: /* Power down. */
317: sdmmc_disable(sc);
318:
319: /* Free all sdmmc_function structures. */
320: for (sf = SIMPLEQ_FIRST(&sc->sf_head); sf != NULL; sf = sfnext) {
321: sfnext = SIMPLEQ_NEXT(sf, sf_list);
322: sdmmc_function_free(sf);
323: }
324: SIMPLEQ_INIT(&sc->sf_head);
325: sc->sc_function_count = 0;
326: sc->sc_fn0 = NULL;
327: }
328:
329: int
330: sdmmc_enable(struct sdmmc_softc *sc)
331: {
332: u_int32_t host_ocr;
333: int error;
334:
335: /*
336: * Calculate the equivalent of the card OCR from the host
337: * capabilities and select the maximum supported bus voltage.
338: */
339: host_ocr = sdmmc_chip_host_ocr(sc->sct, sc->sch);
340: error = sdmmc_chip_bus_power(sc->sct, sc->sch, host_ocr);
341: if (error != 0) {
342: printf("%s: can't supply bus power\n", DEVNAME(sc));
343: goto err;
344: }
345:
346: /*
347: * Select the minimum clock frequency.
348: */
349: error = sdmmc_chip_bus_clock(sc->sct, sc->sch, SDMMC_SDCLK_400KHZ);
350: if (error != 0) {
351: printf("%s: can't supply clock\n", DEVNAME(sc));
352: goto err;
353: }
354:
355: /* XXX wait for card to power up */
356: sdmmc_delay(100000);
357:
358: /* Initialize SD I/O card function(s). */
359: if ((error = sdmmc_io_enable(sc)) != 0)
360: goto err;
361:
362: /* Initialize SD/MMC memory card(s). */
363: if (ISSET(sc->sc_flags, SMF_MEM_MODE) &&
364: (error = sdmmc_mem_enable(sc)) != 0)
365: goto err;
366:
367: /* XXX respect host and card capabilities */
368: if (ISSET(sc->sc_flags, SMF_SD_MODE))
369: (void)sdmmc_chip_bus_clock(sc->sct, sc->sch,
370: SDMMC_SDCLK_25MHZ);
371:
372: err:
373: if (error != 0)
374: sdmmc_disable(sc);
375: return error;
376: }
377:
378: void
379: sdmmc_disable(struct sdmmc_softc *sc)
380: {
381: /* XXX complete commands if card is still present. */
382:
383: /* Make sure no card is still selected. */
384: (void)sdmmc_select_card(sc, NULL);
385:
386: /* Turn off bus power and clock. */
387: (void)sdmmc_chip_bus_clock(sc->sct, sc->sch, SDMMC_SDCLK_OFF);
388: (void)sdmmc_chip_bus_power(sc->sct, sc->sch, 0);
389: }
390:
391: /*
392: * Set the lowest bus voltage supported by the card and the host.
393: */
394: int
395: sdmmc_set_bus_power(struct sdmmc_softc *sc, u_int32_t host_ocr,
396: u_int32_t card_ocr)
397: {
398: u_int32_t bit;
399:
400: /* Mask off unsupported voltage levels and select the lowest. */
401: DPRINTF(1,("%s: host_ocr=%x ", DEVNAME(sc), host_ocr));
402: host_ocr &= card_ocr;
403: for (bit = 4; bit < 23; bit++) {
404: if (ISSET(host_ocr, 1<<bit)) {
405: host_ocr &= 3<<bit;
406: break;
407: }
408: }
409: DPRINTF(1,("card_ocr=%x new_ocr=%x\n", card_ocr, host_ocr));
410:
411: if (host_ocr == 0 ||
412: sdmmc_chip_bus_power(sc->sct, sc->sch, host_ocr) != 0)
413: return 1;
414: return 0;
415: }
416:
417: struct sdmmc_function *
418: sdmmc_function_alloc(struct sdmmc_softc *sc)
419: {
420: struct sdmmc_function *sf;
421:
422: MALLOC(sf, struct sdmmc_function *, sizeof *sf, M_DEVBUF,
423: M_WAITOK);
424: bzero(sf, sizeof *sf);
425: sf->sc = sc;
426: sf->number = -1;
427: sf->cis.manufacturer = SDMMC_VENDOR_INVALID;
428: sf->cis.product = SDMMC_PRODUCT_INVALID;
429: sf->cis.function = SDMMC_FUNCTION_INVALID;
430: return sf;
431: }
432:
433: void
434: sdmmc_function_free(struct sdmmc_function *sf)
435: {
436: FREE(sf, M_DEVBUF);
437: }
438:
439: /*
440: * Scan for I/O functions and memory cards on the bus, allocating a
441: * sdmmc_function structure for each.
442: */
443: int
444: sdmmc_scan(struct sdmmc_softc *sc)
445: {
446: /* Scan for I/O functions. */
447: if (ISSET(sc->sc_flags, SMF_IO_MODE))
448: sdmmc_io_scan(sc);
449:
450: /* Scan for memory cards on the bus. */
451: if (ISSET(sc->sc_flags, SMF_MEM_MODE))
452: sdmmc_mem_scan(sc);
453:
454: /* There should be at least one function now. */
455: if (SIMPLEQ_EMPTY(&sc->sf_head)) {
456: printf("%s: can't identify card\n", DEVNAME(sc));
457: return 1;
458: }
459: return 0;
460: }
461:
462: /*
463: * Initialize all the distinguished functions of the card, be it I/O
464: * or memory functions.
465: */
466: int
467: sdmmc_init(struct sdmmc_softc *sc)
468: {
469: struct sdmmc_function *sf;
470:
471: /* Initialize all identified card functions. */
472: SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
473: if (ISSET(sc->sc_flags, SMF_IO_MODE) &&
474: sdmmc_io_init(sc, sf) != 0)
475: printf("%s: i/o init failed\n", DEVNAME(sc));
476:
477: if (ISSET(sc->sc_flags, SMF_MEM_MODE) &&
478: sdmmc_mem_init(sc, sf) != 0)
479: printf("%s: mem init failed\n", DEVNAME(sc));
480: }
481:
482: /* Any good functions left after initialization? */
483: SIMPLEQ_FOREACH(sf, &sc->sf_head, sf_list) {
484: if (!ISSET(sf->flags, SFF_ERROR))
485: return 0;
486: }
487: /* No, we should probably power down the card. */
488: return 1;
489: }
490:
491: void
492: sdmmc_delay(u_int usecs)
493: {
494: int ticks = usecs / (1000000 / hz);
495:
496: if (ticks > 0)
497: tsleep(&sdmmc_delay, PWAIT, "mmcdly", ticks);
498: else
499: delay(usecs);
500: }
501:
502: int
503: sdmmc_app_command(struct sdmmc_softc *sc, struct sdmmc_command *cmd)
504: {
505: struct sdmmc_command acmd;
506: int error;
507:
508: SDMMC_LOCK(sc);
509:
510: bzero(&acmd, sizeof acmd);
511: acmd.c_opcode = MMC_APP_CMD;
512: acmd.c_arg = 0;
513: acmd.c_flags = SCF_CMD_AC | SCF_RSP_R1;
514:
515: error = sdmmc_mmc_command(sc, &acmd);
516: if (error != 0) {
517: SDMMC_UNLOCK(sc);
518: return error;
519: }
520:
521: if (!ISSET(MMC_R1(acmd.c_resp), MMC_R1_APP_CMD)) {
522: /* Card does not support application commands. */
523: SDMMC_UNLOCK(sc);
524: return ENODEV;
525: }
526:
527: error = sdmmc_mmc_command(sc, cmd);
528: SDMMC_UNLOCK(sc);
529: return error;
530: }
531:
532: /*
533: * Execute MMC command and data transfers. All interactions with the
534: * host controller to complete the command happen in the context of
535: * the current process.
536: */
537: int
538: sdmmc_mmc_command(struct sdmmc_softc *sc, struct sdmmc_command *cmd)
539: {
540: int error;
541:
542: SDMMC_LOCK(sc);
543:
544: sdmmc_chip_exec_command(sc->sct, sc->sch, cmd);
545:
546: #ifdef SDMMC_DEBUG
547: sdmmc_dump_command(sc, cmd);
548: #endif
549:
550: error = cmd->c_error;
551: wakeup(cmd);
552:
553: SDMMC_UNLOCK(sc);
554: return error;
555: }
556:
557: /*
558: * Send the "GO IDLE STATE" command.
559: */
560: void
561: sdmmc_go_idle_state(struct sdmmc_softc *sc)
562: {
563: struct sdmmc_command cmd;
564:
565: bzero(&cmd, sizeof cmd);
566: cmd.c_opcode = MMC_GO_IDLE_STATE;
567: cmd.c_flags = SCF_CMD_BC | SCF_RSP_R0;
568:
569: (void)sdmmc_mmc_command(sc, &cmd);
570: }
571:
572: /*
573: * Retrieve (SD) or set (MMC) the relative card address (RCA).
574: */
575: int
576: sdmmc_set_relative_addr(struct sdmmc_softc *sc,
577: struct sdmmc_function *sf)
578: {
579: struct sdmmc_command cmd;
580:
581: bzero(&cmd, sizeof cmd);
582:
583: if (ISSET(sc->sc_flags, SMF_SD_MODE)) {
584: cmd.c_opcode = SD_SEND_RELATIVE_ADDR;
585: cmd.c_flags = SCF_CMD_BCR | SCF_RSP_R6;
586: } else {
587: cmd.c_opcode = MMC_SET_RELATIVE_ADDR;
588: cmd.c_arg = MMC_ARG_RCA(sf->rca);
589: cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1;
590: }
591:
592: if (sdmmc_mmc_command(sc, &cmd) != 0)
593: return 1;
594:
595: if (ISSET(sc->sc_flags, SMF_SD_MODE))
596: sf->rca = SD_R6_RCA(cmd.c_resp);
597: return 0;
598: }
599:
600: /*
601: * Switch card and host to the maximum supported bus width.
602: */
603: int
604: sdmmc_set_bus_width(struct sdmmc_function *sf)
605: {
606: struct sdmmc_softc *sc = sf->sc;
607: struct sdmmc_command cmd;
608: int error;
609:
610: SDMMC_LOCK(sc);
611:
612: if (!ISSET(sc->sc_flags, SMF_SD_MODE)) {
613: SDMMC_UNLOCK(sc);
614: return EOPNOTSUPP;
615: }
616:
617: if ((error = sdmmc_select_card(sc, sf)) != 0) {
618: SDMMC_UNLOCK(sc);
619: return error;
620: }
621:
622: bzero(&cmd, sizeof cmd);
623: cmd.c_opcode = SD_APP_SET_BUS_WIDTH;
624: cmd.c_arg = SD_ARG_BUS_WIDTH_4;
625: cmd.c_flags = SCF_CMD_AC | SCF_RSP_R1;
626: error = sdmmc_app_command(sc, &cmd);
627: SDMMC_UNLOCK(sc);
628: return error;
629: }
630:
631: int
632: sdmmc_select_card(struct sdmmc_softc *sc, struct sdmmc_function *sf)
633: {
634: struct sdmmc_command cmd;
635: int error;
636:
637: if (sc->sc_card == sf || (sf && sc->sc_card &&
638: sc->sc_card->rca == sf->rca)) {
639: sc->sc_card = sf;
640: return 0;
641: }
642:
643: bzero(&cmd, sizeof cmd);
644: cmd.c_opcode = MMC_SELECT_CARD;
645: cmd.c_arg = sf == NULL ? 0 : MMC_ARG_RCA(sf->rca);
646: cmd.c_flags = SCF_CMD_AC | (sf == NULL ? SCF_RSP_R0 : SCF_RSP_R1);
647: error = sdmmc_mmc_command(sc, &cmd);
648: if (error == 0 || sf == NULL)
649: sc->sc_card = sf;
650: return error;
651: }
652:
653: #ifdef SDMMC_IOCTL
654: int
655: sdmmc_ioctl(struct device *self, u_long request, caddr_t addr)
656: {
657: struct sdmmc_softc *sc = (struct sdmmc_softc *)self;
658: struct sdmmc_command *ucmd;
659: struct sdmmc_command cmd;
660: void *data;
661: int error;
662:
663: switch (request) {
664: #ifdef SDMMC_DEBUG
665: case SDIOCSETDEBUG:
666: sdmmcdebug = (((struct bio_sdmmc_debug *)addr)->debug) & 0xff;
667: sdhcdebug = (((struct bio_sdmmc_debug *)addr)->debug >> 8) & 0xff;
668: break;
669: #endif
670:
671: case SDIOCEXECMMC:
672: case SDIOCEXECAPP:
673: ucmd = &((struct bio_sdmmc_command *)addr)->cmd;
674:
675: /* Refuse to transfer more than 512K per command. */
676: if (ucmd->c_datalen > 524288)
677: return ENOMEM;
678:
679: /* Verify that the data buffer is safe to copy. */
680: if ((ucmd->c_datalen > 0 && ucmd->c_data == NULL) ||
681: (ucmd->c_datalen < 1 && ucmd->c_data != NULL) ||
682: ucmd->c_datalen < 0)
683: return EINVAL;
684:
685: bzero(&cmd, sizeof cmd);
686: cmd.c_opcode = ucmd->c_opcode;
687: cmd.c_arg = ucmd->c_arg;
688: cmd.c_flags = ucmd->c_flags;
689: cmd.c_blklen = ucmd->c_blklen;
690:
691: if (ucmd->c_data) {
692: data = malloc(ucmd->c_datalen, M_TEMP,
693: M_WAITOK | M_CANFAIL);
694: if (data == NULL)
695: return ENOMEM;
696: if (copyin(ucmd->c_data, data, ucmd->c_datalen))
697: return EFAULT;
698:
699: cmd.c_data = data;
700: cmd.c_datalen = ucmd->c_datalen;
701: }
702:
703: if (request == SDIOCEXECMMC)
704: error = sdmmc_mmc_command(sc, &cmd);
705: else
706: error = sdmmc_app_command(sc, &cmd);
707: if (error && !cmd.c_error)
708: cmd.c_error = error;
709:
710: bcopy(&cmd.c_resp, ucmd->c_resp, sizeof cmd.c_resp);
711: ucmd->c_flags = cmd.c_flags;
712: ucmd->c_error = cmd.c_error;
713:
714: if (ucmd->c_data && copyout(data, ucmd->c_data,
715: ucmd->c_datalen))
716: return EFAULT;
717:
718: if (ucmd->c_data)
719: free(data, M_TEMP);
720: break;
721:
722: default:
723: return ENOTTY;
724: }
725: return 0;
726: }
727: #endif
728:
729: #ifdef SDMMC_DEBUG
730: void
731: sdmmc_dump_command(struct sdmmc_softc *sc, struct sdmmc_command *cmd)
732: {
733: int i;
734:
735: DPRINTF(1,("%s: cmd %u arg=%#x data=%#x dlen=%d flags=%#x "
736: "proc=\"%s\" (error %d)\n", DEVNAME(sc), cmd->c_opcode,
737: cmd->c_arg, cmd->c_data, cmd->c_datalen, cmd->c_flags,
738: curproc ? curproc->p_comm : "", cmd->c_error));
739:
740: if (cmd->c_error || sdmmcdebug < 1)
741: return;
742:
743: printf("%s: resp=", DEVNAME(sc));
744: if (ISSET(cmd->c_flags, SCF_RSP_136))
745: for (i = 0; i < sizeof cmd->c_resp; i++)
746: printf("%02x ", ((u_char *)cmd->c_resp)[i]);
747: else if (ISSET(cmd->c_flags, SCF_RSP_PRESENT))
748: for (i = 0; i < 4; i++)
749: printf("%02x ", ((u_char *)cmd->c_resp)[i]);
750: printf("\n");
751: }
752: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to sdmmc.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / sdmmc