Deleted Added
sdiff udiff text old ( 183542 ) new ( 183704 )
full compact
mmc.c (183542) mmc.c (183704)
1/*-
2 * Copyright (c) 2006 Bernd Walter. All rights reserved.
3 * Copyright (c) 2006 M. Warner Losh. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 37 unchanged lines hidden (view full) ---

46 * implication, estoppel or otherwise under any patent or other rights of the
47 * SD Group, SD-3C LLC, the SD Card Association or any third party. Nothing
48 * herein shall be construed as an obligation by the SD Group, the SD-3C LLC
49 * or the SD Card Association to disclose or distribute any technical
50 * information, know-how or other confidential information to any third party.
51 */
52
53#include <sys/cdefs.h>
1/*-
2 * Copyright (c) 2006 Bernd Walter. All rights reserved.
3 * Copyright (c) 2006 M. Warner Losh. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 37 unchanged lines hidden (view full) ---

46 * implication, estoppel or otherwise under any patent or other rights of the
47 * SD Group, SD-3C LLC, the SD Card Association or any third party. Nothing
48 * herein shall be construed as an obligation by the SD Group, the SD-3C LLC
49 * or the SD Card Association to disclose or distribute any technical
50 * information, know-how or other confidential information to any third party.
51 */
52
53#include <sys/cdefs.h>
54__FBSDID("$FreeBSD: head/sys/dev/mmc/mmc.c 183542 2008-10-02 07:06:59Z imp $");
54__FBSDID("$FreeBSD: head/sys/dev/mmc/mmc.c 183704 2008-10-08 17:35:41Z mav $");
55
56#include <sys/param.h>
57#include <sys/systm.h>
58#include <sys/kernel.h>
59#include <sys/malloc.h>
60#include <sys/lock.h>
61#include <sys/module.h>
62#include <sys/mutex.h>
63#include <sys/bus.h>
55
56#include <sys/param.h>
57#include <sys/systm.h>
58#include <sys/kernel.h>
59#include <sys/malloc.h>
60#include <sys/lock.h>
61#include <sys/module.h>
62#include <sys/mutex.h>
63#include <sys/bus.h>
64#include <sys/endian.h>
64
65#include <dev/mmc/mmcreg.h>
66#include <dev/mmc/mmcbrvar.h>
67#include <dev/mmc/mmcvar.h>
68#include "mmcbr_if.h"
69#include "mmcbus_if.h"
70
71struct mmc_softc {

--- 5 unchanged lines hidden (view full) ---

77};
78
79/*
80 * Per-card data
81 */
82struct mmc_ivars {
83 uint32_t raw_cid[4]; /* Raw bits of the CID */
84 uint32_t raw_csd[4]; /* Raw bits of the CSD */
65
66#include <dev/mmc/mmcreg.h>
67#include <dev/mmc/mmcbrvar.h>
68#include <dev/mmc/mmcvar.h>
69#include "mmcbr_if.h"
70#include "mmcbus_if.h"
71
72struct mmc_softc {

--- 5 unchanged lines hidden (view full) ---

78};
79
80/*
81 * Per-card data
82 */
83struct mmc_ivars {
84 uint32_t raw_cid[4]; /* Raw bits of the CID */
85 uint32_t raw_csd[4]; /* Raw bits of the CSD */
86 uint32_t raw_scr[2]; /* Raw bits of the SCR */
87 uint8_t raw_ext_csd[512]; /* Raw bits of the EXT_CSD */
85 uint16_t rca;
86 enum mmc_card_mode mode;
87 struct mmc_cid cid; /* cid decoded */
88 struct mmc_csd csd; /* csd decoded */
88 uint16_t rca;
89 enum mmc_card_mode mode;
90 struct mmc_cid cid; /* cid decoded */
91 struct mmc_csd csd; /* csd decoded */
92 struct mmc_scr scr; /* scr decoded */
89 u_char read_only; /* True when the device is read-only */
93 u_char read_only; /* True when the device is read-only */
94 u_char bus_width; /* Bus width to use */
95 u_char timing; /* Bus timing support */
96 u_char high_cap; /* High Capacity card */
97 uint32_t tran_speed; /* Max speed in normal mode */
98 uint32_t hs_tran_speed; /* Max speed in high speed mode */
90};
91
92#define CMD_RETRIES 3
93
94/* bus entry points */
95static int mmc_probe(device_t dev);
96static int mmc_attach(device_t dev);
97static int mmc_detach(device_t dev);

--- 8 unchanged lines hidden (view full) ---

106#define MMC_ASSERT_UNLOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_NOTOWNED);
107
108static void mmc_delayed_attach(void *);
109static void mmc_power_down(struct mmc_softc *sc);
110static int mmc_wait_for_cmd(struct mmc_softc *sc, struct mmc_command *cmd,
111 int retries);
112static int mmc_wait_for_command(struct mmc_softc *sc, uint32_t opcode,
113 uint32_t arg, uint32_t flags, uint32_t *resp, int retries);
99};
100
101#define CMD_RETRIES 3
102
103/* bus entry points */
104static int mmc_probe(device_t dev);
105static int mmc_attach(device_t dev);
106static int mmc_detach(device_t dev);

--- 8 unchanged lines hidden (view full) ---

115#define MMC_ASSERT_UNLOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_NOTOWNED);
116
117static void mmc_delayed_attach(void *);
118static void mmc_power_down(struct mmc_softc *sc);
119static int mmc_wait_for_cmd(struct mmc_softc *sc, struct mmc_command *cmd,
120 int retries);
121static int mmc_wait_for_command(struct mmc_softc *sc, uint32_t opcode,
122 uint32_t arg, uint32_t flags, uint32_t *resp, int retries);
123static int mmc_select_card(struct mmc_softc *sc, uint16_t rca);
124static int mmc_set_bus_width(struct mmc_softc *sc, uint16_t rca, int width);
125static int mmc_app_send_scr(struct mmc_softc *sc, uint16_t rca, uint32_t *rawscr);
126static void mmc_app_decode_scr(uint32_t *raw_scr, struct mmc_scr *scr);
127static int mmc_send_ext_csd(struct mmc_softc *sc, uint8_t *rawextcsd);
114
115static void
116mmc_ms_delay(int ms)
117{
118 DELAY(1000 * ms); /* XXX BAD */
119}
120
121static int

--- 46 unchanged lines hidden (view full) ---

168
169 return (0);
170}
171
172static int
173mmc_acquire_bus(device_t busdev, device_t dev)
174{
175 struct mmc_softc *sc;
128
129static void
130mmc_ms_delay(int ms)
131{
132 DELAY(1000 * ms); /* XXX BAD */
133}
134
135static int

--- 46 unchanged lines hidden (view full) ---

182
183 return (0);
184}
185
186static int
187mmc_acquire_bus(device_t busdev, device_t dev)
188{
189 struct mmc_softc *sc;
190 struct mmc_ivars *ivar;
176 int err;
177 int rca;
178
179 err = MMCBR_ACQUIRE_HOST(device_get_parent(busdev), busdev);
180 if (err)
181 return (err);
182 sc = device_get_softc(busdev);
183 MMC_LOCK(sc);

--- 6 unchanged lines hidden (view full) ---

190 /*
191 * Keep track of the last rca that we've selected. If
192 * we're asked to do it again, don't. We never
193 * unselect unless the bus code itself wants the mmc
194 * bus, and constantly reselecting causes problems.
195 */
196 rca = mmc_get_rca(dev);
197 if (sc->last_rca != rca) {
191 int err;
192 int rca;
193
194 err = MMCBR_ACQUIRE_HOST(device_get_parent(busdev), busdev);
195 if (err)
196 return (err);
197 sc = device_get_softc(busdev);
198 MMC_LOCK(sc);

--- 6 unchanged lines hidden (view full) ---

205 /*
206 * Keep track of the last rca that we've selected. If
207 * we're asked to do it again, don't. We never
208 * unselect unless the bus code itself wants the mmc
209 * bus, and constantly reselecting causes problems.
210 */
211 rca = mmc_get_rca(dev);
212 if (sc->last_rca != rca) {
198 mmc_wait_for_command(sc, MMC_SELECT_CARD, rca << 16,
199 MMC_RSP_R1 | MMC_CMD_AC, NULL, CMD_RETRIES);
213 mmc_select_card(sc, rca);
200 sc->last_rca = rca;
214 sc->last_rca = rca;
215 /* Prepare bus width for the new card. */
216 ivar = device_get_ivars(dev);
217 device_printf(busdev,
218 "setting bus width to %d bits\n",
219 (ivar->bus_width == bus_width_4)?4:
220 (ivar->bus_width == bus_width_8)?8:1);
221 mmc_set_bus_width(sc, rca, ivar->bus_width);
222 mmcbr_set_bus_width(busdev, ivar->bus_width);
223 mmcbr_update_ios(busdev);
201 }
224 }
202 /* XXX should set bus width here? */
203 } else {
204 /*
205 * If there's a card selected, stand down.
206 */
207 if (sc->last_rca != 0) {
225 } else {
226 /*
227 * If there's a card selected, stand down.
228 */
229 if (sc->last_rca != 0) {
208 mmc_wait_for_command(sc, MMC_SELECT_CARD, 0,
209 MMC_RSP_R1 | MMC_CMD_AC, NULL, CMD_RETRIES);
230 mmc_select_card(sc, 0);
210 sc->last_rca = 0;
211 }
231 sc->last_rca = 0;
232 }
212 /* XXX should set bus width here? */
213 }
214
215 return (0);
216}
217
218static int
219mmc_release_bus(device_t busdev, device_t dev)
220{

--- 218 unchanged lines hidden (view full) ---

439 err = MMC_ERR_TIMEOUT;
440 mmc_ms_delay(10);
441 }
442 if (rocr && err == MMC_ERR_NONE)
443 *rocr = cmd.resp[0];
444 return (err);
445}
446
233 }
234
235 return (0);
236}
237
238static int
239mmc_release_bus(device_t busdev, device_t dev)
240{

--- 218 unchanged lines hidden (view full) ---

459 err = MMC_ERR_TIMEOUT;
460 mmc_ms_delay(10);
461 }
462 if (rocr && err == MMC_ERR_NONE)
463 *rocr = cmd.resp[0];
464 return (err);
465}
466
467static int
468mmc_send_if_cond(struct mmc_softc *sc, uint8_t vhs)
469{
470 struct mmc_command cmd;
471 int err;
472
473 memset(&cmd, 0, sizeof(cmd));
474 cmd.opcode = SD_SEND_IF_COND;
475 cmd.arg = (vhs << 8) + 0xAA;
476 cmd.flags = MMC_RSP_R7 | MMC_CMD_BCR;
477 cmd.data = NULL;
478
479 err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
480 return (err);
481}
482
447static void
448mmc_power_up(struct mmc_softc *sc)
449{
450 device_t dev;
451
452 dev = sc->dev;
453 mmcbr_set_vdd(dev, mmc_highest_voltage(mmcbr_get_host_ocr(dev)));
454 mmcbr_set_bus_mode(dev, opendrain);
455 mmcbr_set_chip_select(dev, cs_dontcare);
456 mmcbr_set_bus_width(dev, bus_width_1);
457 mmcbr_set_power_mode(dev, power_up);
458 mmcbr_set_clock(dev, 0);
459 mmcbr_update_ios(dev);
460 mmc_ms_delay(1);
461
462 mmcbr_set_clock(dev, mmcbr_get_f_min(sc->dev));
483static void
484mmc_power_up(struct mmc_softc *sc)
485{
486 device_t dev;
487
488 dev = sc->dev;
489 mmcbr_set_vdd(dev, mmc_highest_voltage(mmcbr_get_host_ocr(dev)));
490 mmcbr_set_bus_mode(dev, opendrain);
491 mmcbr_set_chip_select(dev, cs_dontcare);
492 mmcbr_set_bus_width(dev, bus_width_1);
493 mmcbr_set_power_mode(dev, power_up);
494 mmcbr_set_clock(dev, 0);
495 mmcbr_update_ios(dev);
496 mmc_ms_delay(1);
497
498 mmcbr_set_clock(dev, mmcbr_get_f_min(sc->dev));
499 mmcbr_set_timing(dev, bus_timing_normal);
463 mmcbr_set_power_mode(dev, power_on);
464 mmcbr_update_ios(dev);
465 mmc_ms_delay(2);
466}
467
468static void
469mmc_power_down(struct mmc_softc *sc)
470{
471 device_t dev = sc->dev;
472
473 mmcbr_set_bus_mode(dev, opendrain);
474 mmcbr_set_chip_select(dev, cs_dontcare);
475 mmcbr_set_bus_width(dev, bus_width_1);
476 mmcbr_set_power_mode(dev, power_off);
477 mmcbr_set_clock(dev, 0);
500 mmcbr_set_power_mode(dev, power_on);
501 mmcbr_update_ios(dev);
502 mmc_ms_delay(2);
503}
504
505static void
506mmc_power_down(struct mmc_softc *sc)
507{
508 device_t dev = sc->dev;
509
510 mmcbr_set_bus_mode(dev, opendrain);
511 mmcbr_set_chip_select(dev, cs_dontcare);
512 mmcbr_set_bus_width(dev, bus_width_1);
513 mmcbr_set_power_mode(dev, power_off);
514 mmcbr_set_clock(dev, 0);
515 mmcbr_set_timing(dev, bus_timing_normal);
478 mmcbr_update_ios(dev);
479}
480
516 mmcbr_update_ios(dev);
517}
518
519static int
520mmc_select_card(struct mmc_softc *sc, uint16_t rca)
521{
522 return (mmc_wait_for_command(sc, MMC_SELECT_CARD, ((uint32_t)rca) << 16,
523 MMC_RSP_R1B | MMC_CMD_AC, NULL, CMD_RETRIES));
524}
525
526static int
527mmc_switch(struct mmc_softc *sc, uint8_t set, uint8_t index, uint8_t value)
528{
529 struct mmc_command cmd;
530 int err;
531
532 cmd.opcode = MMC_SWITCH_FUNC;
533 cmd.arg = (MMC_SWITCH_FUNC_WR << 24) |
534 (index << 16) |
535 (value << 8) |
536 set;
537 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
538 cmd.data = NULL;
539 err = mmc_wait_for_cmd(sc, &cmd, 0);
540 return (err);
541}
542
543static int
544mmc_sd_switch(struct mmc_softc *sc, uint8_t mode, uint8_t grp, uint8_t value, uint8_t *res)
545{
546 int err;
547 struct mmc_command cmd;
548 struct mmc_data data;
549
550 memset(&cmd, 0, sizeof(struct mmc_command));
551 memset(&data, 0, sizeof(struct mmc_data));
552
553 memset(res, 0, 64);
554 cmd.opcode = SD_SWITCH_FUNC;
555 cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
556 cmd.arg = mode << 31;
557 cmd.arg |= 0x00FFFFFF;
558 cmd.arg &= ~(0xF << grp);
559 cmd.arg |= value << grp;
560 cmd.data = &data;
561
562 data.data = res;
563 data.len = 64;
564 data.flags = MMC_DATA_READ;
565
566 err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
567 return (err);
568}
569
570static int
571mmc_set_bus_width(struct mmc_softc *sc, uint16_t rca, int width)
572{
573 int err;
574
575 if (mmcbr_get_mode(sc->dev) == mode_sd) {
576 struct mmc_command cmd;
577
578 memset(&cmd, 0, sizeof(struct mmc_command));
579 cmd.opcode = ACMD_SET_BUS_WIDTH;
580 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
581 switch (width) {
582 case bus_width_1:
583 cmd.arg = SD_BUS_WIDTH_1;
584 break;
585 case bus_width_4:
586 cmd.arg = SD_BUS_WIDTH_4;
587 break;
588 default:
589 return (MMC_ERR_INVALID);
590 }
591 err = mmc_wait_for_app_cmd(sc, rca, &cmd, CMD_RETRIES);
592 } else {
593 uint8_t value;
594
595 switch (width) {
596 case bus_width_1:
597 value = EXT_CSD_BUS_WIDTH_1;
598 break;
599 case bus_width_4:
600 value = EXT_CSD_BUS_WIDTH_4;
601 break;
602 case bus_width_8:
603 value = EXT_CSD_BUS_WIDTH_8;
604 break;
605 default:
606 return (MMC_ERR_INVALID);
607 }
608 err = mmc_switch(sc, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH, value);
609 }
610 return (err);
611}
612
613static int
614mmc_set_timing(struct mmc_softc *sc, int timing)
615{
616 int err;
617 uint8_t value;
618
619 switch (timing) {
620 case bus_timing_normal:
621 value = 0;
622 break;
623 case bus_timing_hs:
624 value = 1;
625 break;
626 default:
627 return (MMC_ERR_INVALID);
628 }
629 if (mmcbr_get_mode(sc->dev) == mode_sd) {
630 u_char switch_res[64];
631
632 err = mmc_sd_switch(sc, 1, 0, value, switch_res);
633 } else {
634 err = mmc_switch(sc, EXT_CSD_CMD_SET_NORMAL,
635 EXT_CSD_HS_TIMING, value);
636 }
637 return (err);
638}
639
640static int
641mmc_test_bus_width(struct mmc_softc *sc)
642{
643 struct mmc_command cmd;
644 struct mmc_data data;
645 int err;
646 uint8_t buf[8];
647 uint8_t p8[8] = { 0x55, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
648 uint8_t p8ok[8] = { 0xAA, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
649 uint8_t p4[4] = { 0x5A, 0x00, 0x00, 0x00, };
650 uint8_t p4ok[4] = { 0xA5, 0x00, 0x00, 0x00, };
651
652 if (mmcbr_get_caps(sc->dev) & MMC_CAP_8_BIT_DATA) {
653 mmcbr_set_bus_width(sc->dev, bus_width_8);
654 mmcbr_update_ios(sc->dev);
655
656 cmd.opcode = MMC_BUSTEST_W;
657 cmd.arg = 0;
658 cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
659 cmd.data = &data;
660
661 data.data = p8;
662 data.len = 8;
663 data.flags = MMC_DATA_WRITE;
664 mmc_wait_for_cmd(sc, &cmd, 0);
665
666 cmd.opcode = MMC_BUSTEST_R;
667 cmd.arg = 0;
668 cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
669 cmd.data = &data;
670
671 data.data = buf;
672 data.len = 8;
673 data.flags = MMC_DATA_READ;
674 err = mmc_wait_for_cmd(sc, &cmd, 0);
675
676 mmcbr_set_bus_width(sc->dev, bus_width_1);
677 mmcbr_update_ios(sc->dev);
678
679 if (err == MMC_ERR_NONE && memcmp(buf, p8ok, 8) == 0)
680 return (bus_width_8);
681 }
682
683 if (mmcbr_get_caps(sc->dev) & MMC_CAP_4_BIT_DATA) {
684 mmcbr_set_bus_width(sc->dev, bus_width_4);
685 mmcbr_update_ios(sc->dev);
686
687 cmd.opcode = MMC_BUSTEST_W;
688 cmd.arg = 0;
689 cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
690 cmd.data = &data;
691
692 data.data = p4;
693 data.len = 4;
694 data.flags = MMC_DATA_WRITE;
695 mmc_wait_for_cmd(sc, &cmd, 0);
696
697 cmd.opcode = MMC_BUSTEST_R;
698 cmd.arg = 0;
699 cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
700 cmd.data = &data;
701
702 data.data = buf;
703 data.len = 4;
704 data.flags = MMC_DATA_READ;
705 err = mmc_wait_for_cmd(sc, &cmd, 0);
706
707 mmcbr_set_bus_width(sc->dev, bus_width_1);
708 mmcbr_update_ios(sc->dev);
709
710 if (err == MMC_ERR_NONE && memcmp(buf, p4ok, 4) == 0)
711 return (bus_width_4);
712 }
713 return (bus_width_1);
714}
715
481static uint32_t
482mmc_get_bits(uint32_t *bits, int start, int size)
483{
484 const int i = 3 - (start / 32);
485 const int shift = start & 31;
486 uint32_t retval = bits[i] >> shift;
487 if (size + shift > 32)
488 retval |= bits[i - 1] << (32 - shift);

--- 12 unchanged lines hidden (view full) ---

501 cid->oid = mmc_get_bits(raw_cid, 104, 16);
502 for (i = 0; i < 5; i++)
503 cid->pnm[i] = mmc_get_bits(raw_cid, 96 - i * 8, 8);
504 cid->prv = mmc_get_bits(raw_cid, 56, 8);
505 cid->psn = mmc_get_bits(raw_cid, 24, 32);
506 cid->mdt_year = mmc_get_bits(raw_cid, 12, 8) + 2001;
507 cid->mdt_month = mmc_get_bits(raw_cid, 8, 4);
508 } else {
716static uint32_t
717mmc_get_bits(uint32_t *bits, int start, int size)
718{
719 const int i = 3 - (start / 32);
720 const int shift = start & 31;
721 uint32_t retval = bits[i] >> shift;
722 if (size + shift > 32)
723 retval |= bits[i - 1] << (32 - shift);

--- 12 unchanged lines hidden (view full) ---

736 cid->oid = mmc_get_bits(raw_cid, 104, 16);
737 for (i = 0; i < 5; i++)
738 cid->pnm[i] = mmc_get_bits(raw_cid, 96 - i * 8, 8);
739 cid->prv = mmc_get_bits(raw_cid, 56, 8);
740 cid->psn = mmc_get_bits(raw_cid, 24, 32);
741 cid->mdt_year = mmc_get_bits(raw_cid, 12, 8) + 2001;
742 cid->mdt_month = mmc_get_bits(raw_cid, 8, 4);
743 } else {
509 /* XXX write me */
510 panic("write mmc cid decoder");
744 cid->mid = mmc_get_bits(raw_cid, 120, 8);
745 cid->oid = mmc_get_bits(raw_cid, 104, 8);
746 for (i = 0; i < 6; i++)
747 cid->pnm[i] = mmc_get_bits(raw_cid, 96 - i * 8, 8);
748 cid->prv = mmc_get_bits(raw_cid, 48, 8);
749 cid->psn = mmc_get_bits(raw_cid, 16, 32);
750 cid->mdt_month = mmc_get_bits(raw_cid, 12, 4);
751 cid->mdt_year = mmc_get_bits(raw_cid, 8, 4) + 1997;
511 }
512}
513
514static const int exp[8] = {
515 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000
516};
517static const int mant[16] = {
518 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80

--- 39 unchanged lines hidden (view full) ---

558 csd->erase_blk_en = mmc_get_bits(raw_csd, 46, 1);
559 csd->sector_size = mmc_get_bits(raw_csd, 39, 7);
560 csd->wp_grp_size = mmc_get_bits(raw_csd, 32, 7);
561 csd->wp_grp_enable = mmc_get_bits(raw_csd, 31, 1);
562 csd->r2w_factor = 1 << mmc_get_bits(raw_csd, 26, 3);
563 csd->write_bl_len = 1 << mmc_get_bits(raw_csd, 22, 4);
564 csd->write_bl_partial = mmc_get_bits(raw_csd, 21, 1);
565 } else if (v == 1) {
752 }
753}
754
755static const int exp[8] = {
756 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000
757};
758static const int mant[16] = {
759 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80

--- 39 unchanged lines hidden (view full) ---

799 csd->erase_blk_en = mmc_get_bits(raw_csd, 46, 1);
800 csd->sector_size = mmc_get_bits(raw_csd, 39, 7);
801 csd->wp_grp_size = mmc_get_bits(raw_csd, 32, 7);
802 csd->wp_grp_enable = mmc_get_bits(raw_csd, 31, 1);
803 csd->r2w_factor = 1 << mmc_get_bits(raw_csd, 26, 3);
804 csd->write_bl_len = 1 << mmc_get_bits(raw_csd, 22, 4);
805 csd->write_bl_partial = mmc_get_bits(raw_csd, 21, 1);
806 } else if (v == 1) {
566 panic("Write SDHC CSD parser");
807 m = mmc_get_bits(raw_csd, 115, 4);
808 e = mmc_get_bits(raw_csd, 112, 3);
809 csd->tacc = exp[e] * mant[m] + 9 / 10;
810 csd->nsac = mmc_get_bits(raw_csd, 104, 8) * 100;
811 m = mmc_get_bits(raw_csd, 99, 4);
812 e = mmc_get_bits(raw_csd, 96, 3);
813 csd->tran_speed = exp[e] * 10000 * mant[m];
814 csd->ccc = mmc_get_bits(raw_csd, 84, 12);
815 csd->read_bl_len = 1 << mmc_get_bits(raw_csd, 80, 4);
816 csd->read_bl_partial = mmc_get_bits(raw_csd, 79, 1);
817 csd->write_blk_misalign = mmc_get_bits(raw_csd, 78, 1);
818 csd->read_blk_misalign = mmc_get_bits(raw_csd, 77, 1);
819 csd->dsr_imp = mmc_get_bits(raw_csd, 76, 1);
820 csd->capacity = ((uint64_t)mmc_get_bits(raw_csd, 48, 22) + 1) *
821 512 * 1024;
822 csd->erase_blk_en = mmc_get_bits(raw_csd, 46, 1);
823 csd->sector_size = mmc_get_bits(raw_csd, 39, 7);
824 csd->wp_grp_size = mmc_get_bits(raw_csd, 32, 7);
825 csd->wp_grp_enable = mmc_get_bits(raw_csd, 31, 1);
826 csd->r2w_factor = 1 << mmc_get_bits(raw_csd, 26, 3);
827 csd->write_bl_len = 1 << mmc_get_bits(raw_csd, 22, 4);
828 csd->write_bl_partial = mmc_get_bits(raw_csd, 21, 1);
567 } else
568 panic("unknown SD CSD version");
569 } else {
829 } else
830 panic("unknown SD CSD version");
831 } else {
570 panic("Write a MMC CSD parser");
832 csd->csd_structure = mmc_get_bits(raw_csd, 126, 2);
833 csd->spec_vers = mmc_get_bits(raw_csd, 122, 4);
834 m = mmc_get_bits(raw_csd, 115, 4);
835 e = mmc_get_bits(raw_csd, 112, 3);
836 csd->tacc = exp[e] * mant[m] + 9 / 10;
837 csd->nsac = mmc_get_bits(raw_csd, 104, 8) * 100;
838 m = mmc_get_bits(raw_csd, 99, 4);
839 e = mmc_get_bits(raw_csd, 96, 3);
840 csd->tran_speed = exp[e] * 10000 * mant[m];
841 csd->ccc = mmc_get_bits(raw_csd, 84, 12);
842 csd->read_bl_len = 1 << mmc_get_bits(raw_csd, 80, 4);
843 csd->read_bl_partial = mmc_get_bits(raw_csd, 79, 1);
844 csd->write_blk_misalign = mmc_get_bits(raw_csd, 78, 1);
845 csd->read_blk_misalign = mmc_get_bits(raw_csd, 77, 1);
846 csd->dsr_imp = mmc_get_bits(raw_csd, 76, 1);
847 csd->vdd_r_curr_min = cur_min[mmc_get_bits(raw_csd, 59, 3)];
848 csd->vdd_r_curr_max = cur_max[mmc_get_bits(raw_csd, 56, 3)];
849 csd->vdd_w_curr_min = cur_min[mmc_get_bits(raw_csd, 53, 3)];
850 csd->vdd_w_curr_max = cur_max[mmc_get_bits(raw_csd, 50, 3)];
851 m = mmc_get_bits(raw_csd, 62, 12);
852 e = mmc_get_bits(raw_csd, 47, 3);
853 csd->capacity = ((1 + m) << (e + 2)) * csd->read_bl_len;
854// csd->erase_blk_en = mmc_get_bits(raw_csd, 46, 1);
855// csd->sector_size = mmc_get_bits(raw_csd, 39, 7);
856 csd->wp_grp_size = mmc_get_bits(raw_csd, 32, 5);
857 csd->wp_grp_enable = mmc_get_bits(raw_csd, 31, 1);
858 csd->r2w_factor = 1 << mmc_get_bits(raw_csd, 26, 3);
859 csd->write_bl_len = 1 << mmc_get_bits(raw_csd, 22, 4);
860 csd->write_bl_partial = mmc_get_bits(raw_csd, 21, 1);
571 }
572}
573
861 }
862}
863
864static void
865mmc_app_decode_scr(uint32_t *raw_scr, struct mmc_scr *scr)
866{
867 unsigned int scr_struct;
868 uint32_t tmp[4];
869
870 tmp[3] = raw_scr[1];
871 tmp[2] = raw_scr[0];
872
873 memset(scr, 0, sizeof(*scr));
874
875 scr_struct = mmc_get_bits(tmp, 60, 4);
876 if (scr_struct != 0) {
877 printf("Unrecognised SCR structure version %d\n",
878 scr_struct);
879 return;
880 }
881 scr->sda_vsn = mmc_get_bits(tmp, 56, 4);
882 scr->bus_widths = mmc_get_bits(tmp, 48, 4);
883}
884
574static int
575mmc_all_send_cid(struct mmc_softc *sc, uint32_t *rawcid)
576{
577 struct mmc_command cmd;
578 int err;
579
580 cmd.opcode = MMC_ALL_SEND_CID;
581 cmd.arg = 0;

--- 15 unchanged lines hidden (view full) ---

597 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
598 cmd.data = NULL;
599 err = mmc_wait_for_cmd(sc, &cmd, 0);
600 memcpy(rawcid, cmd.resp, 4 * sizeof(uint32_t));
601 return (err);
602}
603
604static int
885static int
886mmc_all_send_cid(struct mmc_softc *sc, uint32_t *rawcid)
887{
888 struct mmc_command cmd;
889 int err;
890
891 cmd.opcode = MMC_ALL_SEND_CID;
892 cmd.arg = 0;

--- 15 unchanged lines hidden (view full) ---

908 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
909 cmd.data = NULL;
910 err = mmc_wait_for_cmd(sc, &cmd, 0);
911 memcpy(rawcid, cmd.resp, 4 * sizeof(uint32_t));
912 return (err);
913}
914
915static int
916mmc_app_send_scr(struct mmc_softc *sc, uint16_t rca, uint32_t *rawscr)
917{
918 int err;
919 struct mmc_command cmd;
920 struct mmc_data data;
921
922 memset(&cmd, 0, sizeof(struct mmc_command));
923 memset(&data, 0, sizeof(struct mmc_data));
924
925 memset(rawscr, 0, 8);
926 cmd.opcode = ACMD_SEND_SCR;
927 cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
928 cmd.arg = 0;
929 cmd.data = &data;
930
931 data.data = rawscr;
932 data.len = 8;
933 data.flags = MMC_DATA_READ;
934
935 err = mmc_wait_for_app_cmd(sc, rca, &cmd, CMD_RETRIES);
936 rawscr[0] = be32toh(rawscr[0]);
937 rawscr[1] = be32toh(rawscr[1]);
938 return (err);
939}
940
941static int
942mmc_send_ext_csd(struct mmc_softc *sc, uint8_t *rawextcsd)
943{
944 int err;
945 struct mmc_command cmd;
946 struct mmc_data data;
947
948 memset(&cmd, 0, sizeof(struct mmc_command));
949 memset(&data, 0, sizeof(struct mmc_data));
950
951 memset(rawextcsd, 0, 512);
952 cmd.opcode = MMC_SEND_EXT_CSD;
953 cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
954 cmd.arg = 0;
955 cmd.data = &data;
956
957 data.data = rawextcsd;
958 data.len = 512;
959 data.flags = MMC_DATA_READ;
960
961 err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
962 return (err);
963}
964
965static int
966mmc_set_relative_addr(struct mmc_softc *sc, uint16_t resp)
967{
968 struct mmc_command cmd;
969 int err;
970
971 cmd.opcode = MMC_SET_RELATIVE_ADDR;
972 cmd.arg = resp << 16;
973 cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
974 cmd.data = NULL;
975 err = mmc_wait_for_cmd(sc, &cmd, 0);
976 return (err);
977}
978
979static int
605mmc_send_relative_addr(struct mmc_softc *sc, uint32_t *resp)
606{
607 struct mmc_command cmd;
608 int err;
609
610 cmd.opcode = SD_SEND_RELATIVE_ADDR;
611 cmd.arg = 0;
612 cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;

--- 5 unchanged lines hidden (view full) ---

618
619static void
620mmc_discover_cards(struct mmc_softc *sc)
621{
622 struct mmc_ivars *ivar;
623 int err;
624 uint32_t resp;
625 device_t child;
980mmc_send_relative_addr(struct mmc_softc *sc, uint32_t *resp)
981{
982 struct mmc_command cmd;
983 int err;
984
985 cmd.opcode = SD_SEND_RELATIVE_ADDR;
986 cmd.arg = 0;
987 cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;

--- 5 unchanged lines hidden (view full) ---

993
994static void
995mmc_discover_cards(struct mmc_softc *sc)
996{
997 struct mmc_ivars *ivar;
998 int err;
999 uint32_t resp;
1000 device_t child;
1001 uint16_t rca = 2;
1002 u_char switch_res[64];
626
627 while (1) {
628 ivar = malloc(sizeof(struct mmc_ivars), M_DEVBUF,
629 M_WAITOK | M_ZERO);
630 if (!ivar)
631 return;
632 err = mmc_all_send_cid(sc, ivar->raw_cid);
633 if (err == MMC_ERR_TIMEOUT)
634 break;
635 if (err != MMC_ERR_NONE) {
636 device_printf(sc->dev, "Error reading CID %d\n", err);
637 break;
638 }
1003
1004 while (1) {
1005 ivar = malloc(sizeof(struct mmc_ivars), M_DEVBUF,
1006 M_WAITOK | M_ZERO);
1007 if (!ivar)
1008 return;
1009 err = mmc_all_send_cid(sc, ivar->raw_cid);
1010 if (err == MMC_ERR_TIMEOUT)
1011 break;
1012 if (err != MMC_ERR_NONE) {
1013 device_printf(sc->dev, "Error reading CID %d\n", err);
1014 break;
1015 }
639 if (mmcbr_get_mode(sc->dev) == mode_sd) {
640 ivar->mode = mode_sd;
1016 if (mmcbr_get_ro(sc->dev))
1017 ivar->read_only = 1;
1018 ivar->bus_width = bus_width_1;
1019 ivar->mode = mmcbr_get_mode(sc->dev);
1020 if (ivar->mode == mode_sd) {
641 mmc_decode_cid(1, ivar->raw_cid, &ivar->cid);
642 mmc_send_relative_addr(sc, &resp);
643 ivar->rca = resp >> 16;
1021 mmc_decode_cid(1, ivar->raw_cid, &ivar->cid);
1022 mmc_send_relative_addr(sc, &resp);
1023 ivar->rca = resp >> 16;
644 if (mmcbr_get_ro(sc->dev))
645 ivar->read_only = 1;
1024 /* Get card CSD. */
646 mmc_send_csd(sc, ivar->rca, ivar->raw_csd);
647 mmc_decode_csd(1, ivar->raw_csd, &ivar->csd);
1025 mmc_send_csd(sc, ivar->rca, ivar->raw_csd);
1026 mmc_decode_csd(1, ivar->raw_csd, &ivar->csd);
648 printf("SD CARD: %lld bytes\n", (long long)
649 ivar->csd.capacity);
1027 if (ivar->csd.csd_structure > 0)
1028 ivar->high_cap = 1;
1029 ivar->tran_speed = ivar->csd.tran_speed;
1030 /* Get card SCR. Card must be selected to fetch it. */
1031 mmc_select_card(sc, ivar->rca);
1032 mmc_app_send_scr(sc, ivar->rca, ivar->raw_scr);
1033 mmc_app_decode_scr(ivar->raw_scr, &ivar->scr);
1034 /* Get card switch capabilities. */
1035 if ((ivar->scr.sda_vsn >= 1) &&
1036 (ivar->csd.ccc & (1<<10))) {
1037 mmc_sd_switch(sc, 0, 0, 0xF, switch_res);
1038 if (switch_res[13] & 2) {
1039 ivar->timing = bus_timing_hs;
1040 ivar->hs_tran_speed = 50000000;
1041 }
1042 }
1043 mmc_select_card(sc, 0);
1044 /* Find max supported bus width. */
1045 if ((mmcbr_get_caps(sc->dev) & MMC_CAP_4_BIT_DATA) &&
1046 (ivar->scr.bus_widths & SD_SCR_BUS_WIDTH_4))
1047 ivar->bus_width = bus_width_4;
1048 /* Add device. */
650 child = device_add_child(sc->dev, NULL, -1);
651 device_set_ivars(child, ivar);
652 return;
653 }
1049 child = device_add_child(sc->dev, NULL, -1);
1050 device_set_ivars(child, ivar);
1051 return;
1052 }
654 panic("Write MMC card code here");
1053 mmc_decode_cid(0, ivar->raw_cid, &ivar->cid);
1054 ivar->rca = rca++;
1055 mmc_set_relative_addr(sc, ivar->rca);
1056 /* Get card CSD. */
1057 mmc_send_csd(sc, ivar->rca, ivar->raw_csd);
1058 mmc_decode_csd(0, ivar->raw_csd, &ivar->csd);
1059 ivar->tran_speed = ivar->csd.tran_speed;
1060 /* Only MMC >= 4.x cards support EXT_CSD. */
1061 if (ivar->csd.spec_vers >= 4) {
1062 /* Card must be selected to fetch EXT_CSD. */
1063 mmc_select_card(sc, ivar->rca);
1064 mmc_send_ext_csd(sc, ivar->raw_ext_csd);
1065 /* Get card speed in high speed mode. */
1066 ivar->timing = bus_timing_hs;
1067 if (((uint8_t *)(ivar->raw_ext_csd))[EXT_CSD_CARD_TYPE]
1068 & EXT_CSD_CARD_TYPE_52)
1069 ivar->hs_tran_speed = 52000000;
1070 else if (((uint8_t *)(ivar->raw_ext_csd))[EXT_CSD_CARD_TYPE]
1071 & EXT_CSD_CARD_TYPE_26)
1072 ivar->hs_tran_speed = 26000000;
1073 else
1074 ivar->hs_tran_speed = ivar->tran_speed;
1075 /* Find max supported bus width. */
1076 ivar->bus_width = mmc_test_bus_width(sc);
1077 mmc_select_card(sc, 0);
1078 } else {
1079 ivar->bus_width = bus_width_1;
1080 ivar->timing = bus_timing_normal;
1081 }
1082 /* Add device. */
1083 child = device_add_child(sc->dev, NULL, -1);
1084 device_set_ivars(child, ivar);
655 }
656 free(ivar, M_DEVBUF);
657}
658
659static void
660mmc_go_discovery(struct mmc_softc *sc)
661{
662 uint32_t ocr;
663 device_t dev;
1085 }
1086 free(ivar, M_DEVBUF);
1087}
1088
1089static void
1090mmc_go_discovery(struct mmc_softc *sc)
1091{
1092 uint32_t ocr;
1093 device_t dev;
1094 int err;
664
665 dev = sc->dev;
666 if (mmcbr_get_power_mode(dev) != power_on) {
667 /*
668 * First, try SD modes
669 */
670 mmcbr_set_mode(dev, mode_sd);
671 mmc_power_up(sc);
672 mmcbr_set_bus_mode(dev, pushpull);
673 mmc_idle_cards(sc);
1095
1096 dev = sc->dev;
1097 if (mmcbr_get_power_mode(dev) != power_on) {
1098 /*
1099 * First, try SD modes
1100 */
1101 mmcbr_set_mode(dev, mode_sd);
1102 mmc_power_up(sc);
1103 mmcbr_set_bus_mode(dev, pushpull);
1104 mmc_idle_cards(sc);
674 if (mmc_send_app_op_cond(sc, 0, &ocr) != MMC_ERR_NONE) {
1105 err = mmc_send_if_cond(sc, 1);
1106 if (mmc_send_app_op_cond(sc, err?0:MMC_OCR_CCS, &ocr) !=
1107 MMC_ERR_NONE) {
675 /*
676 * Failed, try MMC
677 */
678 mmcbr_set_mode(dev, mode_mmc);
679 if (mmc_send_op_cond(sc, 0, &ocr) != MMC_ERR_NONE)
680 return; /* Failed both, punt! XXX powerdown? */
681 }
682 mmcbr_set_ocr(dev, mmc_select_vdd(sc, ocr));

--- 9 unchanged lines hidden (view full) ---

692 * Make sure that we have a mutually agreeable voltage to at least
693 * one card on the bus.
694 */
695 if (mmcbr_get_ocr(dev) == 0)
696 return;
697 /*
698 * Reselect the cards after we've idled them above.
699 */
1108 /*
1109 * Failed, try MMC
1110 */
1111 mmcbr_set_mode(dev, mode_mmc);
1112 if (mmc_send_op_cond(sc, 0, &ocr) != MMC_ERR_NONE)
1113 return; /* Failed both, punt! XXX powerdown? */
1114 }
1115 mmcbr_set_ocr(dev, mmc_select_vdd(sc, ocr));

--- 9 unchanged lines hidden (view full) ---

1125 * Make sure that we have a mutually agreeable voltage to at least
1126 * one card on the bus.
1127 */
1128 if (mmcbr_get_ocr(dev) == 0)
1129 return;
1130 /*
1131 * Reselect the cards after we've idled them above.
1132 */
700 if (mmcbr_get_mode(dev) == mode_sd)
701 mmc_send_app_op_cond(sc, mmcbr_get_ocr(dev), NULL);
702 else
1133 if (mmcbr_get_mode(dev) == mode_sd) {
1134 err = mmc_send_if_cond(sc, 1);
1135 mmc_send_app_op_cond(sc,
1136 (err?0:MMC_OCR_CCS)|mmcbr_get_ocr(dev), NULL);
1137 } else
703 mmc_send_op_cond(sc, mmcbr_get_ocr(dev), NULL);
704 mmc_discover_cards(sc);
705
706 mmcbr_set_bus_mode(dev, pushpull);
707 mmcbr_update_ios(dev);
708 bus_generic_attach(dev);
709/* mmc_update_children_sysctl(dev);*/
710}
711
712static int
713mmc_calculate_clock(struct mmc_softc *sc)
714{
1138 mmc_send_op_cond(sc, mmcbr_get_ocr(dev), NULL);
1139 mmc_discover_cards(sc);
1140
1141 mmcbr_set_bus_mode(dev, pushpull);
1142 mmcbr_update_ios(dev);
1143 bus_generic_attach(dev);
1144/* mmc_update_children_sysctl(dev);*/
1145}
1146
1147static int
1148mmc_calculate_clock(struct mmc_softc *sc)
1149{
715 int max_dtr = 0;
1150 int max_dtr, max_hs_dtr, max_timing;
716 int nkid, i, f_min, f_max;
717 device_t *kids;
1151 int nkid, i, f_min, f_max;
1152 device_t *kids;
1153 struct mmc_ivars *ivar;
718
719 f_min = mmcbr_get_f_min(sc->dev);
720 f_max = mmcbr_get_f_max(sc->dev);
1154
1155 f_min = mmcbr_get_f_min(sc->dev);
1156 f_max = mmcbr_get_f_max(sc->dev);
721 max_dtr = f_max;
1157 max_dtr = max_hs_dtr = f_max;
1158 if ((mmcbr_get_caps(sc->dev) & MMC_CAP_HSPEED))
1159 max_timing = bus_timing_hs;
1160 else
1161 max_timing = bus_timing_normal;
722 if (device_get_children(sc->dev, &kids, &nkid) != 0)
723 panic("can't get children");
1162 if (device_get_children(sc->dev, &kids, &nkid) != 0)
1163 panic("can't get children");
724 for (i = 0; i < nkid; i++)
725 if (mmc_get_tran_speed(kids[i]) < max_dtr)
726 max_dtr = mmc_get_tran_speed(kids[i]);
1164 for (i = 0; i < nkid; i++) {
1165 ivar = device_get_ivars(kids[i]);
1166 if (ivar->timing < max_timing)
1167 max_timing = ivar->timing;
1168 if (ivar->tran_speed < max_dtr)
1169 max_dtr = ivar->tran_speed;
1170 if (ivar->hs_tran_speed < max_dtr)
1171 max_hs_dtr = ivar->hs_tran_speed;
1172 }
1173 for (i = 0; i < nkid; i++) {
1174 ivar = device_get_ivars(kids[i]);
1175 if (ivar->timing == bus_timing_normal)
1176 continue;
1177 mmc_select_card(sc, ivar->rca);
1178 mmc_set_timing(sc, max_timing);
1179 }
1180 mmc_select_card(sc, 0);
727 free(kids, M_TEMP);
1181 free(kids, M_TEMP);
728 device_printf(sc->dev, "setting transfer rate to %d.%03dMHz\n",
729 max_dtr / 1000000, (max_dtr / 1000) % 1000);
730 return (max_dtr);
1182 if (max_timing == bus_timing_hs)
1183 max_dtr = max_hs_dtr;
1184 device_printf(sc->dev, "setting transfer rate to %d.%03dMHz%s\n",
1185 max_dtr / 1000000, (max_dtr / 1000) % 1000,
1186 (max_timing == bus_timing_hs)?" with high speed timing":"");
1187 mmcbr_set_timing(sc->dev, max_timing);
1188 mmcbr_set_clock(sc->dev, max_dtr);
1189 mmcbr_update_ios(sc->dev);
1190 return max_dtr;
731}
732
733static void
734mmc_scan(struct mmc_softc *sc)
735{
736 device_t dev;
737
738 dev = sc->dev;
739 mmc_acquire_bus(dev, dev);
740
741 if (mmcbr_get_power_mode(dev) == power_on)
742 mmc_rescan_cards(sc);
743 mmc_go_discovery(sc);
1191}
1192
1193static void
1194mmc_scan(struct mmc_softc *sc)
1195{
1196 device_t dev;
1197
1198 dev = sc->dev;
1199 mmc_acquire_bus(dev, dev);
1200
1201 if (mmcbr_get_power_mode(dev) == power_on)
1202 mmc_rescan_cards(sc);
1203 mmc_go_discovery(sc);
744 mmcbr_set_clock(dev, mmc_calculate_clock(sc));
745 mmcbr_update_ios(dev);
1204 mmc_calculate_clock(sc);
746
747 mmc_release_bus(dev, dev);
748 /* XXX probe/attach/detach children? */
749}
750
751static int
752mmc_read_ivar(device_t bus, device_t child, int which, u_char *result)
753{

--- 15 unchanged lines hidden (view full) ---

769 *(int *)result = MMC_SECTOR_SIZE;
770 break;
771 case MMC_IVAR_TRAN_SPEED:
772 *(int *)result = ivar->csd.tran_speed;
773 break;
774 case MMC_IVAR_READ_ONLY:
775 *(int *)result = ivar->read_only;
776 break;
1205
1206 mmc_release_bus(dev, dev);
1207 /* XXX probe/attach/detach children? */
1208}
1209
1210static int
1211mmc_read_ivar(device_t bus, device_t child, int which, u_char *result)
1212{

--- 15 unchanged lines hidden (view full) ---

1228 *(int *)result = MMC_SECTOR_SIZE;
1229 break;
1230 case MMC_IVAR_TRAN_SPEED:
1231 *(int *)result = ivar->csd.tran_speed;
1232 break;
1233 case MMC_IVAR_READ_ONLY:
1234 *(int *)result = ivar->read_only;
1235 break;
1236 case MMC_IVAR_HIGH_CAP:
1237 *(int *)result = ivar->high_cap;
1238 break;
777 }
778 return (0);
779}
780
781static int
782mmc_write_ivar(device_t bus, device_t child, int which, uintptr_t value)
783{
784 /*

--- 43 unchanged lines hidden --- 		1239 }
1240 return (0);
1241}
1242
1243static int
1244mmc_write_ivar(device_t bus, device_t child, int which, uintptr_t value)
1245{
1246 /*

--- 43 unchanged lines hidden ---