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
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *
25 * Portions of this software may have been developed with reference to
26 * the SD Simplified Specification. The following disclaimer may apply:
27 *
28 * The following conditions apply to the release of the simplified
29 * specification ("Simplified Specification") by the SD Card Association and
30 * the SD Group. The Simplified Specification is a subset of the complete SD
31 * Specification which is owned by the SD Card Association and the SD
32 * Group. This Simplified Specification is provided on a non-confidential
33 * basis subject to the disclaimers below. Any implementation of the
34 * Simplified Specification may require a license from the SD Card
35 * Association, SD Group, SD-3C LLC or other third parties.
36 *
37 * Disclaimers:
38 *
39 * The information contained in the Simplified Specification is presented only
40 * as a standard specification for SD Cards and SD Host/Ancillary products and
41 * is provided "AS-IS" without any representations or warranties of any
42 * kind. No responsibility is assumed by the SD Group, SD-3C LLC or the SD
43 * Card Association for any damages, any infringements of patents or other
44 * right of the SD Group, SD-3C LLC, the SD Card Association or any third
45 * parties, which may result from its use. No license is granted by
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
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24 *
25 * Portions of this software may have been developed with reference to
26 * the SD Simplified Specification. The following disclaimer may apply:
27 *
28 * The following conditions apply to the release of the simplified
29 * specification ("Simplified Specification") by the SD Card Association and
30 * the SD Group. The Simplified Specification is a subset of the complete SD
31 * Specification which is owned by the SD Card Association and the SD
32 * Group. This Simplified Specification is provided on a non-confidential
33 * basis subject to the disclaimers below. Any implementation of the
34 * Simplified Specification may require a license from the SD Card
35 * Association, SD Group, SD-3C LLC or other third parties.
36 *
37 * Disclaimers:
38 *
39 * The information contained in the Simplified Specification is presented only
40 * as a standard specification for SD Cards and SD Host/Ancillary products and
41 * is provided "AS-IS" without any representations or warranties of any
42 * kind. No responsibility is assumed by the SD Group, SD-3C LLC or the SD
43 * Card Association for any damages, any infringements of patents or other
44 * right of the SD Group, SD-3C LLC, the SD Card Association or any third
45 * parties, which may result from its use. No license is granted by
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 {
72 device_t dev;
73 struct mtx sc_mtx;
74 struct intr_config_hook config_intrhook;
75 device_t owner;
76 uint32_t last_rca;
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 {
73 device_t dev;
74 struct mtx sc_mtx;
75 struct intr_config_hook config_intrhook;
76 device_t owner;
77 uint32_t last_rca;
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);
98
99#define MMC_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx)
100#define MMC_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx)
101#define MMC_LOCK_INIT(_sc) \
102 mtx_init(&_sc->sc_mtx, device_get_nameunit(_sc->dev), \
103 "mmc", MTX_DEF)
104#define MMC_LOCK_DESTROY(_sc) mtx_destroy(&_sc->sc_mtx);
105#define MMC_ASSERT_LOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_OWNED);
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);
107
108#define MMC_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx)
109#define MMC_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx)
110#define MMC_LOCK_INIT(_sc) \
111 mtx_init(&_sc->sc_mtx, device_get_nameunit(_sc->dev), \
112 "mmc", MTX_DEF)
113#define MMC_LOCK_DESTROY(_sc) mtx_destroy(&_sc->sc_mtx);
114#define MMC_ASSERT_LOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_OWNED);
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
122mmc_probe(device_t dev)
123{
124
125 device_set_desc(dev, "MMC/SD bus");
126 return (0);
127}
128
129static int
130mmc_attach(device_t dev)
131{
132 struct mmc_softc *sc;
133
134 sc = device_get_softc(dev);
135 sc->dev = dev;
136 MMC_LOCK_INIT(sc);
137
138 /* We'll probe and attach our children later, but before / mount */
139 sc->config_intrhook.ich_func = mmc_delayed_attach;
140 sc->config_intrhook.ich_arg = sc;
141 if (config_intrhook_establish(&sc->config_intrhook) != 0)
142 device_printf(dev, "config_intrhook_establish failed\n");
143 return (0);
144}
145
146static int
147mmc_detach(device_t dev)
148{
149 struct mmc_softc *sc = device_get_softc(dev);
150 device_t *kids;
151 int i, nkid;
152
153 /* kill children [ph33r]. -sorbo */
154 if (device_get_children(sc->dev, &kids, &nkid) != 0)
155 return (0);
156 for (i = 0; i < nkid; i++) {
157 device_t kid = kids[i];
158 void *ivar = device_get_ivars(kid);
159
160 device_detach(kid);
161 device_delete_child(sc->dev, kid);
162 free(ivar, M_DEVBUF);
163 }
164 free(kids, M_TEMP);
165 mmc_power_down(sc);
166
167 MMC_LOCK_DESTROY(sc);
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
136mmc_probe(device_t dev)
137{
138
139 device_set_desc(dev, "MMC/SD bus");
140 return (0);
141}
142
143static int
144mmc_attach(device_t dev)
145{
146 struct mmc_softc *sc;
147
148 sc = device_get_softc(dev);
149 sc->dev = dev;
150 MMC_LOCK_INIT(sc);
151
152 /* We'll probe and attach our children later, but before / mount */
153 sc->config_intrhook.ich_func = mmc_delayed_attach;
154 sc->config_intrhook.ich_arg = sc;
155 if (config_intrhook_establish(&sc->config_intrhook) != 0)
156 device_printf(dev, "config_intrhook_establish failed\n");
157 return (0);
158}
159
160static int
161mmc_detach(device_t dev)
162{
163 struct mmc_softc *sc = device_get_softc(dev);
164 device_t *kids;
165 int i, nkid;
166
167 /* kill children [ph33r]. -sorbo */
168 if (device_get_children(sc->dev, &kids, &nkid) != 0)
169 return (0);
170 for (i = 0; i < nkid; i++) {
171 device_t kid = kids[i];
172 void *ivar = device_get_ivars(kid);
173
174 device_detach(kid);
175 device_delete_child(sc->dev, kid);
176 free(ivar, M_DEVBUF);
177 }
178 free(kids, M_TEMP);
179 mmc_power_down(sc);
180
181 MMC_LOCK_DESTROY(sc);
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);
184 if (sc->owner)
185 panic("mmc: host bridge didn't seralize us.");
186 sc->owner = dev;
187 MMC_UNLOCK(sc);
188
189 if (busdev != dev) {
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);
199 if (sc->owner)
200 panic("mmc: host bridge didn't seralize us.");
201 sc->owner = dev;
202 MMC_UNLOCK(sc);
203
204 if (busdev != dev) {
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{
221 struct mmc_softc *sc;
222 int err;
223
224 sc = device_get_softc(busdev);
225
226 MMC_LOCK(sc);
227 if (!sc->owner)
228 panic("mmc: releasing unowned bus.");
229 if (sc->owner != dev)
230 panic("mmc: you don't own the bus. game over.");
231 MMC_UNLOCK(sc);
232 err = MMCBR_RELEASE_HOST(device_get_parent(busdev), busdev);
233 if (err)
234 return (err);
235 MMC_LOCK(sc);
236 sc->owner = NULL;
237 MMC_UNLOCK(sc);
238 return (0);
239}
240
241static void
242mmc_rescan_cards(struct mmc_softc *sc)
243{
244 /* XXX: Look at the children and see if they respond to status */
245}
246
247static uint32_t
248mmc_select_vdd(struct mmc_softc *sc, uint32_t ocr)
249{
250
251 return (ocr & MMC_OCR_VOLTAGE);
252}
253
254static int
255mmc_highest_voltage(uint32_t ocr)
256{
257 int i;
258
259 for (i = 30; i >= 0; i--)
260 if (ocr & (1 << i))
261 return (i);
262 return (-1);
263}
264
265static void
266mmc_wakeup(struct mmc_request *req)
267{
268 struct mmc_softc *sc;
269
270/* printf("Wakeup for req %p done_data %p\n", req, req->done_data); */
271 sc = (struct mmc_softc *)req->done_data;
272 MMC_LOCK(sc);
273 req->flags |= MMC_REQ_DONE;
274 wakeup(req);
275 MMC_UNLOCK(sc);
276}
277
278static int
279mmc_wait_for_req(struct mmc_softc *sc, struct mmc_request *req)
280{
281 int err;
282
283 req->done = mmc_wakeup;
284 req->done_data = sc;
285/* printf("Submitting request %p sc %p\n", req, sc); */
286 MMCBR_REQUEST(device_get_parent(sc->dev), sc->dev, req);
287 MMC_LOCK(sc);
288 do {
289 err = msleep(req, &sc->sc_mtx, PZERO | PCATCH, "mmcreq",
290 hz / 10);
291 } while (!(req->flags & MMC_REQ_DONE) && err == EAGAIN);
292/* printf("Request %p done with error %d\n", req, err); */
293 MMC_UNLOCK(sc);
294 return (err);
295}
296
297static int
298mmc_wait_for_request(device_t brdev, device_t reqdev, struct mmc_request *req)
299{
300 struct mmc_softc *sc = device_get_softc(brdev);
301
302 return (mmc_wait_for_req(sc, req));
303}
304
305static int
306mmc_wait_for_cmd(struct mmc_softc *sc, struct mmc_command *cmd, int retries)
307{
308 struct mmc_request mreq;
309
310 memset(&mreq, 0, sizeof(mreq));
311 memset(cmd->resp, 0, sizeof(cmd->resp));
312 cmd->retries = retries;
313 mreq.cmd = cmd;
314/* printf("CMD: %x ARG %x\n", cmd->opcode, cmd->arg); */
315 mmc_wait_for_req(sc, &mreq);
316 return (cmd->error);
317}
318
319static int
320mmc_wait_for_app_cmd(struct mmc_softc *sc, uint32_t rca,
321 struct mmc_command *cmd, int retries)
322{
323 struct mmc_command appcmd;
324 int err = MMC_ERR_NONE, i;
325
326 for (i = 0; i <= retries; i++) {
327 appcmd.opcode = MMC_APP_CMD;
328 appcmd.arg = rca << 16;
329 appcmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
330 appcmd.data = NULL;
331 mmc_wait_for_cmd(sc, &appcmd, 0);
332 err = appcmd.error;
333 if (err != MMC_ERR_NONE)
334 continue;
335 if (!(appcmd.resp[0] & R1_APP_CMD))
336 return MMC_ERR_FAILED;
337 mmc_wait_for_cmd(sc, cmd, 0);
338 err = cmd->error;
339 if (err == MMC_ERR_NONE)
340 break;
341 }
342 return (err);
343}
344
345static int
346mmc_wait_for_command(struct mmc_softc *sc, uint32_t opcode,
347 uint32_t arg, uint32_t flags, uint32_t *resp, int retries)
348{
349 struct mmc_command cmd;
350 int err;
351
352 memset(&cmd, 0, sizeof(cmd));
353 cmd.opcode = opcode;
354 cmd.arg = arg;
355 cmd.flags = flags;
356 cmd.data = NULL;
357 err = mmc_wait_for_cmd(sc, &cmd, retries);
358 if (err)
359 return (err);
360 if (cmd.error)
361 return (cmd.error);
362 if (resp) {
363 if (flags & MMC_RSP_136)
364 memcpy(resp, cmd.resp, 4 * sizeof(uint32_t));
365 else
366 *resp = cmd.resp[0];
367 }
368 return (0);
369}
370
371static void
372mmc_idle_cards(struct mmc_softc *sc)
373{
374 device_t dev;
375 struct mmc_command cmd;
376
377 dev = sc->dev;
378 mmcbr_set_chip_select(dev, cs_high);
379 mmcbr_update_ios(dev);
380 mmc_ms_delay(1);
381
382 memset(&cmd, 0, sizeof(cmd));
383 cmd.opcode = MMC_GO_IDLE_STATE;
384 cmd.arg = 0;
385 cmd.flags = MMC_RSP_NONE | MMC_CMD_BC;
386 cmd.data = NULL;
387 mmc_wait_for_cmd(sc, &cmd, 0);
388 mmc_ms_delay(1);
389
390 mmcbr_set_chip_select(dev, cs_dontcare);
391 mmcbr_update_ios(dev);
392 mmc_ms_delay(1);
393}
394
395static int
396mmc_send_app_op_cond(struct mmc_softc *sc, uint32_t ocr, uint32_t *rocr)
397{
398 struct mmc_command cmd;
399 int err = MMC_ERR_NONE, i;
400
401 memset(&cmd, 0, sizeof(cmd));
402 cmd.opcode = ACMD_SD_SEND_OP_COND;
403 cmd.arg = ocr;
404 cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
405 cmd.data = NULL;
406
407 for (i = 0; i < 100; i++) {
408 err = mmc_wait_for_app_cmd(sc, 0, &cmd, CMD_RETRIES);
409 if (err != MMC_ERR_NONE)
410 break;
411 if ((cmd.resp[0] & MMC_OCR_CARD_BUSY) || ocr == 0)
412 break;
413 err = MMC_ERR_TIMEOUT;
414 mmc_ms_delay(10);
415 }
416 if (rocr && err == MMC_ERR_NONE)
417 *rocr = cmd.resp[0];
418 return (err);
419}
420
421static int
422mmc_send_op_cond(struct mmc_softc *sc, uint32_t ocr, uint32_t *rocr)
423{
424 struct mmc_command cmd;
425 int err = MMC_ERR_NONE, i;
426
427 memset(&cmd, 0, sizeof(cmd));
428 cmd.opcode = MMC_SEND_OP_COND;
429 cmd.arg = ocr;
430 cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
431 cmd.data = NULL;
432
433 for (i = 0; i < 100; i++) {
434 err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
435 if (err != MMC_ERR_NONE)
436 break;
437 if ((cmd.resp[0] & MMC_OCR_CARD_BUSY) || ocr == 0)
438 break;
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{
241 struct mmc_softc *sc;
242 int err;
243
244 sc = device_get_softc(busdev);
245
246 MMC_LOCK(sc);
247 if (!sc->owner)
248 panic("mmc: releasing unowned bus.");
249 if (sc->owner != dev)
250 panic("mmc: you don't own the bus. game over.");
251 MMC_UNLOCK(sc);
252 err = MMCBR_RELEASE_HOST(device_get_parent(busdev), busdev);
253 if (err)
254 return (err);
255 MMC_LOCK(sc);
256 sc->owner = NULL;
257 MMC_UNLOCK(sc);
258 return (0);
259}
260
261static void
262mmc_rescan_cards(struct mmc_softc *sc)
263{
264 /* XXX: Look at the children and see if they respond to status */
265}
266
267static uint32_t
268mmc_select_vdd(struct mmc_softc *sc, uint32_t ocr)
269{
270
271 return (ocr & MMC_OCR_VOLTAGE);
272}
273
274static int
275mmc_highest_voltage(uint32_t ocr)
276{
277 int i;
278
279 for (i = 30; i >= 0; i--)
280 if (ocr & (1 << i))
281 return (i);
282 return (-1);
283}
284
285static void
286mmc_wakeup(struct mmc_request *req)
287{
288 struct mmc_softc *sc;
289
290/* printf("Wakeup for req %p done_data %p\n", req, req->done_data); */
291 sc = (struct mmc_softc *)req->done_data;
292 MMC_LOCK(sc);
293 req->flags |= MMC_REQ_DONE;
294 wakeup(req);
295 MMC_UNLOCK(sc);
296}
297
298static int
299mmc_wait_for_req(struct mmc_softc *sc, struct mmc_request *req)
300{
301 int err;
302
303 req->done = mmc_wakeup;
304 req->done_data = sc;
305/* printf("Submitting request %p sc %p\n", req, sc); */
306 MMCBR_REQUEST(device_get_parent(sc->dev), sc->dev, req);
307 MMC_LOCK(sc);
308 do {
309 err = msleep(req, &sc->sc_mtx, PZERO | PCATCH, "mmcreq",
310 hz / 10);
311 } while (!(req->flags & MMC_REQ_DONE) && err == EAGAIN);
312/* printf("Request %p done with error %d\n", req, err); */
313 MMC_UNLOCK(sc);
314 return (err);
315}
316
317static int
318mmc_wait_for_request(device_t brdev, device_t reqdev, struct mmc_request *req)
319{
320 struct mmc_softc *sc = device_get_softc(brdev);
321
322 return (mmc_wait_for_req(sc, req));
323}
324
325static int
326mmc_wait_for_cmd(struct mmc_softc *sc, struct mmc_command *cmd, int retries)
327{
328 struct mmc_request mreq;
329
330 memset(&mreq, 0, sizeof(mreq));
331 memset(cmd->resp, 0, sizeof(cmd->resp));
332 cmd->retries = retries;
333 mreq.cmd = cmd;
334/* printf("CMD: %x ARG %x\n", cmd->opcode, cmd->arg); */
335 mmc_wait_for_req(sc, &mreq);
336 return (cmd->error);
337}
338
339static int
340mmc_wait_for_app_cmd(struct mmc_softc *sc, uint32_t rca,
341 struct mmc_command *cmd, int retries)
342{
343 struct mmc_command appcmd;
344 int err = MMC_ERR_NONE, i;
345
346 for (i = 0; i <= retries; i++) {
347 appcmd.opcode = MMC_APP_CMD;
348 appcmd.arg = rca << 16;
349 appcmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
350 appcmd.data = NULL;
351 mmc_wait_for_cmd(sc, &appcmd, 0);
352 err = appcmd.error;
353 if (err != MMC_ERR_NONE)
354 continue;
355 if (!(appcmd.resp[0] & R1_APP_CMD))
356 return MMC_ERR_FAILED;
357 mmc_wait_for_cmd(sc, cmd, 0);
358 err = cmd->error;
359 if (err == MMC_ERR_NONE)
360 break;
361 }
362 return (err);
363}
364
365static int
366mmc_wait_for_command(struct mmc_softc *sc, uint32_t opcode,
367 uint32_t arg, uint32_t flags, uint32_t *resp, int retries)
368{
369 struct mmc_command cmd;
370 int err;
371
372 memset(&cmd, 0, sizeof(cmd));
373 cmd.opcode = opcode;
374 cmd.arg = arg;
375 cmd.flags = flags;
376 cmd.data = NULL;
377 err = mmc_wait_for_cmd(sc, &cmd, retries);
378 if (err)
379 return (err);
380 if (cmd.error)
381 return (cmd.error);
382 if (resp) {
383 if (flags & MMC_RSP_136)
384 memcpy(resp, cmd.resp, 4 * sizeof(uint32_t));
385 else
386 *resp = cmd.resp[0];
387 }
388 return (0);
389}
390
391static void
392mmc_idle_cards(struct mmc_softc *sc)
393{
394 device_t dev;
395 struct mmc_command cmd;
396
397 dev = sc->dev;
398 mmcbr_set_chip_select(dev, cs_high);
399 mmcbr_update_ios(dev);
400 mmc_ms_delay(1);
401
402 memset(&cmd, 0, sizeof(cmd));
403 cmd.opcode = MMC_GO_IDLE_STATE;
404 cmd.arg = 0;
405 cmd.flags = MMC_RSP_NONE | MMC_CMD_BC;
406 cmd.data = NULL;
407 mmc_wait_for_cmd(sc, &cmd, 0);
408 mmc_ms_delay(1);
409
410 mmcbr_set_chip_select(dev, cs_dontcare);
411 mmcbr_update_ios(dev);
412 mmc_ms_delay(1);
413}
414
415static int
416mmc_send_app_op_cond(struct mmc_softc *sc, uint32_t ocr, uint32_t *rocr)
417{
418 struct mmc_command cmd;
419 int err = MMC_ERR_NONE, i;
420
421 memset(&cmd, 0, sizeof(cmd));
422 cmd.opcode = ACMD_SD_SEND_OP_COND;
423 cmd.arg = ocr;
424 cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
425 cmd.data = NULL;
426
427 for (i = 0; i < 100; i++) {
428 err = mmc_wait_for_app_cmd(sc, 0, &cmd, CMD_RETRIES);
429 if (err != MMC_ERR_NONE)
430 break;
431 if ((cmd.resp[0] & MMC_OCR_CARD_BUSY) || ocr == 0)
432 break;
433 err = MMC_ERR_TIMEOUT;
434 mmc_ms_delay(10);
435 }
436 if (rocr && err == MMC_ERR_NONE)
437 *rocr = cmd.resp[0];
438 return (err);
439}
440
441static int
442mmc_send_op_cond(struct mmc_softc *sc, uint32_t ocr, uint32_t *rocr)
443{
444 struct mmc_command cmd;
445 int err = MMC_ERR_NONE, i;
446
447 memset(&cmd, 0, sizeof(cmd));
448 cmd.opcode = MMC_SEND_OP_COND;
449 cmd.arg = ocr;
450 cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
451 cmd.data = NULL;
452
453 for (i = 0; i < 100; i++) {
454 err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
455 if (err != MMC_ERR_NONE)
456 break;
457 if ((cmd.resp[0] & MMC_OCR_CARD_BUSY) || ocr == 0)
458 break;
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);
489 return (retval & ((1 << size) - 1));
490}
491
492static void
493mmc_decode_cid(int is_sd, uint32_t *raw_cid, struct mmc_cid *cid)
494{
495 int i;
496
497 memset(cid, 0, sizeof(*cid));
498 if (is_sd) {
499 /* There's no version info, so we take it on faith */
500 cid->mid = mmc_get_bits(raw_cid, 120, 8);
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);
724 return (retval & ((1 << size) - 1));
725}
726
727static void
728mmc_decode_cid(int is_sd, uint32_t *raw_cid, struct mmc_cid *cid)
729{
730 int i;
731
732 memset(cid, 0, sizeof(*cid));
733 if (is_sd) {
734 /* There's no version info, so we take it on faith */
735 cid->mid = mmc_get_bits(raw_cid, 120, 8);
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
519};
520static const int cur_min[8] = {
521 500, 1000, 5000, 10000, 25000, 35000, 60000, 100000
522};
523static const int cur_max[8] = {
524 1000, 5000, 10000, 25000, 35000, 45000, 800000, 200000
525};
526
527static void
528mmc_decode_csd(int is_sd, uint32_t *raw_csd, struct mmc_csd *csd)
529{
530 int v;
531 int m;
532 int e;
533
534 memset(csd, 0, sizeof(*csd));
535 if (is_sd) {
536 csd->csd_structure = v = mmc_get_bits(raw_csd, 126, 2);
537 if (v == 0) {
538 m = mmc_get_bits(raw_csd, 115, 4);
539 e = mmc_get_bits(raw_csd, 112, 3);
540 csd->tacc = exp[e] * mant[m] + 9 / 10;
541 csd->nsac = mmc_get_bits(raw_csd, 104, 8) * 100;
542 m = mmc_get_bits(raw_csd, 99, 4);
543 e = mmc_get_bits(raw_csd, 96, 3);
544 csd->tran_speed = exp[e] * 10000 * mant[m];
545 csd->ccc = mmc_get_bits(raw_csd, 84, 12);
546 csd->read_bl_len = 1 << mmc_get_bits(raw_csd, 80, 4);
547 csd->read_bl_partial = mmc_get_bits(raw_csd, 79, 1);
548 csd->write_blk_misalign = mmc_get_bits(raw_csd, 78, 1);
549 csd->read_blk_misalign = mmc_get_bits(raw_csd, 77, 1);
550 csd->dsr_imp = mmc_get_bits(raw_csd, 76, 1);
551 csd->vdd_r_curr_min = cur_min[mmc_get_bits(raw_csd, 59, 3)];
552 csd->vdd_r_curr_max = cur_max[mmc_get_bits(raw_csd, 56, 3)];
553 csd->vdd_w_curr_min = cur_min[mmc_get_bits(raw_csd, 53, 3)];
554 csd->vdd_w_curr_max = cur_max[mmc_get_bits(raw_csd, 50, 3)];
555 m = mmc_get_bits(raw_csd, 62, 12);
556 e = mmc_get_bits(raw_csd, 47, 3);
557 csd->capacity = ((1 + m) << (e + 2)) * csd->read_bl_len;
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
760};
761static const int cur_min[8] = {
762 500, 1000, 5000, 10000, 25000, 35000, 60000, 100000
763};
764static const int cur_max[8] = {
765 1000, 5000, 10000, 25000, 35000, 45000, 800000, 200000
766};
767
768static void
769mmc_decode_csd(int is_sd, uint32_t *raw_csd, struct mmc_csd *csd)
770{
771 int v;
772 int m;
773 int e;
774
775 memset(csd, 0, sizeof(*csd));
776 if (is_sd) {
777 csd->csd_structure = v = mmc_get_bits(raw_csd, 126, 2);
778 if (v == 0) {
779 m = mmc_get_bits(raw_csd, 115, 4);
780 e = mmc_get_bits(raw_csd, 112, 3);
781 csd->tacc = exp[e] * mant[m] + 9 / 10;
782 csd->nsac = mmc_get_bits(raw_csd, 104, 8) * 100;
783 m = mmc_get_bits(raw_csd, 99, 4);
784 e = mmc_get_bits(raw_csd, 96, 3);
785 csd->tran_speed = exp[e] * 10000 * mant[m];
786 csd->ccc = mmc_get_bits(raw_csd, 84, 12);
787 csd->read_bl_len = 1 << mmc_get_bits(raw_csd, 80, 4);
788 csd->read_bl_partial = mmc_get_bits(raw_csd, 79, 1);
789 csd->write_blk_misalign = mmc_get_bits(raw_csd, 78, 1);
790 csd->read_blk_misalign = mmc_get_bits(raw_csd, 77, 1);
791 csd->dsr_imp = mmc_get_bits(raw_csd, 76, 1);
792 csd->vdd_r_curr_min = cur_min[mmc_get_bits(raw_csd, 59, 3)];
793 csd->vdd_r_curr_max = cur_max[mmc_get_bits(raw_csd, 56, 3)];
794 csd->vdd_w_curr_min = cur_min[mmc_get_bits(raw_csd, 53, 3)];
795 csd->vdd_w_curr_max = cur_max[mmc_get_bits(raw_csd, 50, 3)];
796 m = mmc_get_bits(raw_csd, 62, 12);
797 e = mmc_get_bits(raw_csd, 47, 3);
798 csd->capacity = ((1 + m) << (e + 2)) * csd->read_bl_len;
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;
582 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
583 cmd.data = NULL;
584 err = mmc_wait_for_cmd(sc, &cmd, 0);
585 memcpy(rawcid, cmd.resp, 4 * sizeof(uint32_t));
586 return (err);
587}
588
589static int
590mmc_send_csd(struct mmc_softc *sc, uint16_t rca, uint32_t *rawcid)
591{
592 struct mmc_command cmd;
593 int err;
594
595 cmd.opcode = MMC_SEND_CSD;
596 cmd.arg = rca << 16;
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;
893 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
894 cmd.data = NULL;
895 err = mmc_wait_for_cmd(sc, &cmd, 0);
896 memcpy(rawcid, cmd.resp, 4 * sizeof(uint32_t));
897 return (err);
898}
899
900static int
901mmc_send_csd(struct mmc_softc *sc, uint16_t rca, uint32_t *rawcid)
902{
903 struct mmc_command cmd;
904 int err;
905
906 cmd.opcode = MMC_SEND_CSD;
907 cmd.arg = rca << 16;
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;
613 cmd.data = NULL;
614 err = mmc_wait_for_cmd(sc, &cmd, 0);
615 *resp = cmd.resp[0];
616 return (err);
617}
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;
988 cmd.data = NULL;
989 err = mmc_wait_for_cmd(sc, &cmd, 0);
990 *resp = cmd.resp[0];
991 return (err);
992}
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));
683 if (mmcbr_get_ocr(dev) != 0)
684 mmc_idle_cards(sc);
685 } else {
686 mmcbr_set_bus_mode(dev, opendrain);
687 mmcbr_set_clock(dev, mmcbr_get_f_min(dev));
688 mmcbr_update_ios(dev);
689 /* XXX recompute vdd based on new cards? */
690 }
691 /*
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));
1116 if (mmcbr_get_ocr(dev) != 0)
1117 mmc_idle_cards(sc);
1118 } else {
1119 mmcbr_set_bus_mode(dev, opendrain);
1120 mmcbr_set_clock(dev, mmcbr_get_f_min(dev));
1121 mmcbr_update_ios(dev);
1122 /* XXX recompute vdd based on new cards? */
1123 }
1124 /*
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{
754 struct mmc_ivars *ivar = device_get_ivars(child);
755
756 switch (which) {
757 default:
758 return (EINVAL);
759 case MMC_IVAR_DSR_IMP:
760 *(int *)result = ivar->csd.dsr_imp;
761 break;
762 case MMC_IVAR_MEDIA_SIZE:
763 *(off_t *)result = ivar->csd.capacity / MMC_SECTOR_SIZE;
764 break;
765 case MMC_IVAR_RCA:
766 *(int *)result = ivar->rca;
767 break;
768 case MMC_IVAR_SECTOR_SIZE:
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{
1213 struct mmc_ivars *ivar = device_get_ivars(child);
1214
1215 switch (which) {
1216 default:
1217 return (EINVAL);
1218 case MMC_IVAR_DSR_IMP:
1219 *(int *)result = ivar->csd.dsr_imp;
1220 break;
1221 case MMC_IVAR_MEDIA_SIZE:
1222 *(off_t *)result = ivar->csd.capacity / MMC_SECTOR_SIZE;
1223 break;
1224 case MMC_IVAR_RCA:
1225 *(int *)result = ivar->rca;
1226 break;
1227 case MMC_IVAR_SECTOR_SIZE:
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 /*
785 * None are writable ATM
786 */
787 return (EINVAL);
788}
789
790
791static void
792mmc_delayed_attach(void *xsc)
793{
794 struct mmc_softc *sc = xsc;
795
796 mmc_scan(sc);
797 config_intrhook_disestablish(&sc->config_intrhook);
798}
799
800static device_method_t mmc_methods[] = {
801 /* device_if */
802 DEVMETHOD(device_probe, mmc_probe),
803 DEVMETHOD(device_attach, mmc_attach),
804 DEVMETHOD(device_detach, mmc_detach),
805
806 /* Bus interface */
807 DEVMETHOD(bus_read_ivar, mmc_read_ivar),
808 DEVMETHOD(bus_write_ivar, mmc_write_ivar),
809
810 /* MMC Bus interface */
811 DEVMETHOD(mmcbus_wait_for_request, mmc_wait_for_request),
812 DEVMETHOD(mmcbus_acquire_bus, mmc_acquire_bus),
813 DEVMETHOD(mmcbus_release_bus, mmc_release_bus),
814
815 {0, 0},
816};
817
818static driver_t mmc_driver = {
819 "mmc",
820 mmc_methods,
821 sizeof(struct mmc_softc),
822};
823static devclass_t mmc_devclass;
824
825
826DRIVER_MODULE(mmc, at91_mci, mmc_driver, mmc_devclass, 0, 0);
827DRIVER_MODULE(mmc, sdh, mmc_driver, mmc_devclass, 0, 0);
| 1239 }
1240 return (0);
1241}
1242
1243static int
1244mmc_write_ivar(device_t bus, device_t child, int which, uintptr_t value)
1245{
1246 /*
1247 * None are writable ATM
1248 */
1249 return (EINVAL);
1250}
1251
1252
1253static void
1254mmc_delayed_attach(void *xsc)
1255{
1256 struct mmc_softc *sc = xsc;
1257
1258 mmc_scan(sc);
1259 config_intrhook_disestablish(&sc->config_intrhook);
1260}
1261
1262static device_method_t mmc_methods[] = {
1263 /* device_if */
1264 DEVMETHOD(device_probe, mmc_probe),
1265 DEVMETHOD(device_attach, mmc_attach),
1266 DEVMETHOD(device_detach, mmc_detach),
1267
1268 /* Bus interface */
1269 DEVMETHOD(bus_read_ivar, mmc_read_ivar),
1270 DEVMETHOD(bus_write_ivar, mmc_write_ivar),
1271
1272 /* MMC Bus interface */
1273 DEVMETHOD(mmcbus_wait_for_request, mmc_wait_for_request),
1274 DEVMETHOD(mmcbus_acquire_bus, mmc_acquire_bus),
1275 DEVMETHOD(mmcbus_release_bus, mmc_release_bus),
1276
1277 {0, 0},
1278};
1279
1280static driver_t mmc_driver = {
1281 "mmc",
1282 mmc_methods,
1283 sizeof(struct mmc_softc),
1284};
1285static devclass_t mmc_devclass;
1286
1287
1288DRIVER_MODULE(mmc, at91_mci, mmc_driver, mmc_devclass, 0, 0);
1289DRIVER_MODULE(mmc, sdh, mmc_driver, mmc_devclass, 0, 0);
|