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 26 #include <sys/cdefs.h> 27 __FBSDID("$FreeBSD$"); 28 29 #include <sys/param.h> 30 #include <sys/systm.h> 31 #include <sys/kernel.h> 32 #include <sys/malloc.h> 33 #include <sys/lock.h> 34 #include <sys/module.h> 35 #include <sys/mutex.h> 36 #include <sys/bus.h> 37 38 #include <dev/mmc/mmcreg.h> 39 #include <dev/mmc/mmcbrvar.h> 40 #include <dev/mmc/mmcvar.h> 41 #include "mmcbr_if.h" 42 #include "mmcbus_if.h" 43 44 struct mmc_softc { 45 device_t dev; 46 struct mtx sc_mtx; 47 struct intr_config_hook config_intrhook; 48 device_t owner; 49 uint32_t last_rca; 50 }; 51 52 /* 53 * Per-card data 54 */ 55 struct mmc_ivars { 56 uint32_t raw_cid[4]; /* Raw bits of the CID */ 57 uint32_t raw_csd[4]; /* Raw bits of the CSD */ 58 uint16_t rca; 59 enum mmc_card_mode mode; 60 struct mmc_cid cid; /* cid decoded */ 61 struct mmc_csd csd; /* csd decoded */ 62 }; 63 64 #define CMD_RETRIES 3 65 66 /* bus entry points */ 67 static int mmc_probe(device_t dev); 68 static int mmc_attach(device_t dev); 69 static int mmc_detach(device_t dev); 70 71 #define MMC_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx) 72 #define MMC_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx) 73 #define MMC_LOCK_INIT(_sc) \ 74 mtx_init(&_sc->sc_mtx, device_get_nameunit(_sc->dev), \ 75 "mmc", MTX_DEF) 76 #define MMC_LOCK_DESTROY(_sc) mtx_destroy(&_sc->sc_mtx); 77 #define MMC_ASSERT_LOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_OWNED); 78 #define MMC_ASSERT_UNLOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_NOTOWNED); 79 80 static void mmc_delayed_attach(void *); 81 static int mmc_wait_for_cmd(struct mmc_softc *sc, struct mmc_command *cmd, 82 int retries); 83 static int mmc_wait_for_command(struct mmc_softc *sc, uint32_t opcode, 84 uint32_t arg, uint32_t flags, uint32_t *resp, int retries); 85 86 static void 87 mmc_ms_delay(int ms) 88 { 89 DELAY(1000 * ms); /* XXX BAD */ 90 } 91 92 static int 93 mmc_probe(device_t dev) 94 { 95 96 device_set_desc(dev, "mmc/sd bus"); 97 return (0); 98 } 99 100 static int 101 mmc_attach(device_t dev) 102 { 103 struct mmc_softc *sc; 104 105 sc = device_get_softc(dev); 106 sc->dev = dev; 107 MMC_LOCK_INIT(sc); 108 109 /* We'll probe and attach our children later, but before / mount */ 110 sc->config_intrhook.ich_func = mmc_delayed_attach; 111 sc->config_intrhook.ich_arg = sc; 112 if (config_intrhook_establish(&sc->config_intrhook) != 0) 113 device_printf(dev, "config_intrhook_establish failed\n"); 114 return (0); 115 } 116 117 static int 118 mmc_detach(device_t dev) 119 { 120 struct mmc_softc *sc = device_get_softc(dev); 121 device_t *kids; 122 int i, nkid; 123 124 /* kill children [ph33r]. -sorbo */ 125 if (device_get_children(sc->dev, &kids, &nkid) != 0) 126 return 0; 127 for (i = 0; i < nkid; i++) { 128 device_t kid = kids[i]; 129 void *ivar = device_get_ivars(kid); 130 131 device_detach(kid); 132 device_delete_child(sc->dev, kid); 133 free(ivar, M_DEVBUF); 134 } 135 free(kids, M_TEMP); 136 137 MMC_LOCK_DESTROY(sc); 138 139 return 0; 140 } 141 142 static int 143 mmc_acquire_bus(device_t busdev, device_t dev) 144 { 145 struct mmc_softc *sc; 146 int err; 147 int rca; 148 149 err = MMCBR_ACQUIRE_HOST(device_get_parent(busdev), dev); 150 if (err) 151 return (err); 152 sc = device_get_softc(busdev); 153 MMC_LOCK(sc); 154 if (sc->owner) 155 panic("mmc: host bridge didn't seralize us."); 156 sc->owner = dev; 157 MMC_UNLOCK(sc); 158 159 if (busdev != dev) { 160 // Keep track of the last rca that we've selected. If 161 // we're asked to do it again, don't. We never unselect 162 // unless the bus code itself wants the mmc bus. 163 rca = mmc_get_rca(dev); 164 if (sc->last_rca != rca) { 165 mmc_wait_for_command(sc, MMC_SELECT_CARD, rca << 16, 166 MMC_RSP_R1 | MMC_CMD_AC, NULL, CMD_RETRIES); 167 sc->last_rca = rca; 168 } 169 // XXX should set bus width here? 170 } else { 171 // If there's a card selected, stand down. 172 if (sc->last_rca != 0) { 173 mmc_wait_for_command(sc, MMC_SELECT_CARD, 0, 174 MMC_RSP_R1 | MMC_CMD_AC, NULL, CMD_RETRIES); 175 sc->last_rca = 0; 176 } 177 // XXX should set bus width here? 178 } 179 180 return (0); 181 } 182 183 static int 184 mmc_release_bus(device_t busdev, device_t dev) 185 { 186 struct mmc_softc *sc; 187 int err; 188 189 sc = device_get_softc(busdev); 190 191 MMC_LOCK(sc); 192 if (!sc->owner) 193 panic("mmc: releasing unowned bus."); 194 if (sc->owner != dev) 195 panic("mmc: you don't own the bus. game over."); 196 MMC_UNLOCK(sc); 197 err = MMCBR_RELEASE_HOST(device_get_parent(busdev), dev); 198 if (err) 199 return (err); 200 MMC_LOCK(sc); 201 sc->owner = NULL; 202 MMC_UNLOCK(sc); 203 return (0); 204 } 205 206 static void 207 mmc_rescan_cards(struct mmc_softc *sc) 208 { 209 /* XXX: Look at the children and see if they respond to status */ 210 } 211 212 static uint32_t 213 mmc_select_vdd(struct mmc_softc *sc, uint32_t ocr) 214 { 215 // XXX 216 return ocr; 217 } 218 219 static int 220 mmc_highest_voltage(uint32_t ocr) 221 { 222 int i; 223 224 for (i = 30; i >= 0; i--) 225 if (ocr & (1 << i)) 226 return i; 227 return (-1); 228 } 229 230 static void 231 mmc_wakeup(struct mmc_request *req) 232 { 233 struct mmc_softc *sc; 234 235 // printf("Wakeup for req %p done_data %p\n", req, req->done_data); 236 sc = (struct mmc_softc *)req->done_data; 237 MMC_LOCK(sc); 238 req->flags |= MMC_REQ_DONE; 239 wakeup(req); 240 MMC_UNLOCK(sc); 241 } 242 243 static int 244 mmc_wait_for_req(struct mmc_softc *sc, struct mmc_request *req) 245 { 246 int err; 247 248 req->done = mmc_wakeup; 249 req->done_data = sc; 250 // printf("Submitting request %p sc %p\n", req, sc); 251 MMCBR_REQUEST(device_get_parent(sc->dev), sc->dev, req); 252 MMC_LOCK(sc); 253 do { 254 err = msleep(req, &sc->sc_mtx, PZERO | PCATCH, "mmcreq", 255 hz / 10); 256 } while (!(req->flags & MMC_REQ_DONE) && err == EAGAIN); 257 // printf("Request %p done with error %d\n", req, err); 258 MMC_UNLOCK(sc); 259 return (err); 260 } 261 262 static int 263 mmc_wait_for_request(device_t brdev, device_t reqdev, struct mmc_request *req) 264 { 265 struct mmc_softc *sc = device_get_softc(brdev); 266 267 return mmc_wait_for_req(sc, req); 268 } 269 270 static int 271 mmc_wait_for_cmd(struct mmc_softc *sc, struct mmc_command *cmd, int retries) 272 { 273 struct mmc_request mreq; 274 275 memset(&mreq, 0, sizeof(mreq)); 276 memset(cmd->resp, 0, sizeof(cmd->resp)); 277 cmd->retries = retries; 278 cmd->data = NULL; 279 mreq.cmd = cmd; 280 // printf("CMD: %x ARG %x\n", cmd->opcode, cmd->arg); 281 mmc_wait_for_req(sc, &mreq); 282 return (cmd->error); 283 } 284 285 static int 286 mmc_wait_for_app_cmd(struct mmc_softc *sc, uint32_t rca, 287 struct mmc_command *cmd, int retries) 288 { 289 struct mmc_command appcmd; 290 int err = MMC_ERR_NONE, i; 291 292 for (i = 0; i <= retries; i++) { 293 appcmd.opcode = MMC_APP_CMD; 294 appcmd.arg = rca << 16; 295 appcmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 296 mmc_wait_for_cmd(sc, &appcmd, 0); 297 err = appcmd.error; 298 if (err != MMC_ERR_NONE) 299 continue; 300 if (!(appcmd.resp[0] & R1_APP_CMD)) 301 return MMC_ERR_FAILED; 302 mmc_wait_for_cmd(sc, cmd, 0); 303 err = cmd->error; 304 if (err == MMC_ERR_NONE) 305 break; 306 } 307 return (err); 308 } 309 310 static int 311 mmc_wait_for_command(struct mmc_softc *sc, uint32_t opcode, 312 uint32_t arg, uint32_t flags, uint32_t *resp, int retries) 313 { 314 struct mmc_command cmd; 315 int err; 316 317 memset(&cmd, 0, sizeof(cmd)); 318 cmd.opcode = opcode; 319 cmd.arg = arg; 320 cmd.flags = flags; 321 err = mmc_wait_for_cmd(sc, &cmd, retries); 322 if (err) 323 return (err); 324 if (cmd.error) 325 return (cmd.error); 326 if (resp) { 327 if (flags & MMC_RSP_136) 328 memcpy(resp, cmd.resp, 4 * sizeof(uint32_t)); 329 else 330 *resp = cmd.resp[0]; 331 } 332 return (0); 333 } 334 335 static void 336 mmc_idle_cards(struct mmc_softc *sc) 337 { 338 device_t dev; 339 struct mmc_command cmd; 340 341 dev = sc->dev; 342 mmcbr_set_chip_select(dev, cs_high); 343 mmcbr_update_ios(dev); 344 mmc_ms_delay(1); 345 346 memset(&cmd, 0, sizeof(cmd)); 347 cmd.opcode = MMC_GO_IDLE_STATE; 348 cmd.arg = 0; 349 cmd.flags = MMC_RSP_NONE | MMC_CMD_BC; 350 mmc_wait_for_cmd(sc, &cmd, 0); 351 mmc_ms_delay(1); 352 353 mmcbr_set_chip_select(dev, cs_dontcare); 354 mmcbr_update_ios(dev); 355 mmc_ms_delay(1); 356 } 357 358 static int 359 mmc_send_app_op_cond(struct mmc_softc *sc, uint32_t ocr, uint32_t *rocr) 360 { 361 struct mmc_command cmd; 362 int err = MMC_ERR_NONE, i; 363 364 memset(&cmd, 0, sizeof(cmd)); 365 cmd.opcode = ACMD_SD_SEND_OP_COND; 366 cmd.arg = ocr; 367 cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR; 368 369 for (i = 0; i < 10; i++) { 370 err = mmc_wait_for_app_cmd(sc, 0, &cmd, CMD_RETRIES); 371 if (err != MMC_ERR_NONE) 372 break; 373 if ((cmd.resp[0] & MMC_OCR_CARD_BUSY) || ocr == 0) 374 break; 375 err = MMC_ERR_TIMEOUT; 376 mmc_ms_delay(10); 377 } 378 if (rocr && err == MMC_ERR_NONE) 379 *rocr = cmd.resp[0]; 380 return err; 381 } 382 383 static int 384 mmc_send_op_cond(struct mmc_softc *sc, uint32_t ocr, uint32_t *rocr) 385 { 386 struct mmc_command cmd; 387 int err = MMC_ERR_NONE, i; 388 389 memset(&cmd, 0, sizeof(cmd)); 390 cmd.opcode = MMC_SEND_OP_COND; 391 cmd.arg = ocr; 392 cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR; 393 394 for (i = 0; i < 100; i++) { 395 err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES); 396 if (err != MMC_ERR_NONE) 397 break; 398 if ((cmd.resp[0] & MMC_OCR_CARD_BUSY) || ocr == 0) 399 break; 400 err = MMC_ERR_TIMEOUT; 401 mmc_ms_delay(10); 402 } 403 if (rocr && err == MMC_ERR_NONE) 404 *rocr = cmd.resp[0]; 405 return err; 406 } 407 408 static void 409 mmc_power_up(struct mmc_softc *sc) 410 { 411 device_t dev; 412 413 dev = sc->dev; 414 mmcbr_set_vdd(dev, mmc_highest_voltage(mmcbr_get_host_ocr(dev))); 415 mmcbr_set_bus_mode(dev, opendrain); 416 mmcbr_set_chip_select(dev, cs_dontcare); 417 mmcbr_set_bus_width(dev, bus_width_1); 418 mmcbr_set_power_mode(dev, power_up); 419 mmcbr_set_clock(dev, 0); 420 mmcbr_update_ios(dev); 421 mmc_ms_delay(1); 422 423 mmcbr_set_clock(dev, mmcbr_get_f_min(sc->dev)); 424 mmcbr_set_power_mode(dev, power_on); 425 mmcbr_update_ios(dev); 426 mmc_ms_delay(2); 427 } 428 429 // I wonder if the following is endian safe. 430 static uint32_t 431 mmc_get_bits(uint32_t *bits, int start, int size) 432 { 433 const int i = 3 - (start / 32); 434 const int shift = start & 31; 435 uint32_t retval = bits[i] >> shift; 436 if (size + shift > 32) 437 retval |= bits[i - 1] << (32 - shift); 438 return retval & ((1 << size) - 1); 439 } 440 441 static void 442 mmc_decode_cid(int is_sd, uint32_t *raw_cid, struct mmc_cid *cid) 443 { 444 int i; 445 446 memset(cid, 0, sizeof(*cid)); 447 if (is_sd) { 448 /* There's no version info, so we take it on faith */ 449 cid->mid = mmc_get_bits(raw_cid, 120, 8); 450 cid->oid = mmc_get_bits(raw_cid, 104, 16); 451 for (i = 0; i < 5; i++) 452 cid->pnm[i] = mmc_get_bits(raw_cid, 96 - i * 8, 8); 453 cid->prv = mmc_get_bits(raw_cid, 56, 8); 454 cid->psn = mmc_get_bits(raw_cid, 24, 32); 455 cid->mdt_year = mmc_get_bits(raw_cid, 12, 8) + 2001; 456 cid->mdt_month = mmc_get_bits(raw_cid, 8, 4); 457 } else { 458 // XXX write me 459 panic("write mmc cid decoder"); 460 } 461 } 462 463 static const int exp[8] = { 464 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000 465 }; 466 static const int mant[16] = { 467 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80 468 }; 469 static const int cur_min[8] = { 470 500, 1000, 5000, 10000, 25000, 35000, 60000, 100000 471 }; 472 static const int cur_max[8] = { 473 1000, 5000, 10000, 25000, 35000, 45000, 800000, 200000 474 }; 475 476 static void 477 mmc_decode_csd(int is_sd, uint32_t *raw_csd, struct mmc_csd *csd) 478 { 479 int v; 480 int m; 481 int e; 482 483 memset(csd, 0, sizeof(*csd)); 484 if (is_sd) { 485 csd->csd_structure = v = mmc_get_bits(raw_csd, 126, 2); 486 if (v == 0) { 487 m = mmc_get_bits(raw_csd, 115, 4); 488 e = mmc_get_bits(raw_csd, 112, 3); 489 csd->tacc = exp[e] * mant[m] + 9 / 10; 490 csd->nsac = mmc_get_bits(raw_csd, 104, 8) * 100; 491 m = mmc_get_bits(raw_csd, 99, 4); 492 e = mmc_get_bits(raw_csd, 96, 3); 493 csd->tran_speed = exp[e] * 10000 * mant[m]; 494 csd->ccc = mmc_get_bits(raw_csd, 84, 12); 495 csd->read_bl_len = 1 << mmc_get_bits(raw_csd, 80, 4); 496 csd->read_bl_partial = mmc_get_bits(raw_csd, 79, 1); 497 csd->write_blk_misalign = mmc_get_bits(raw_csd, 78, 1); 498 csd->read_blk_misalign = mmc_get_bits(raw_csd, 77, 1); 499 csd->dsr_imp = mmc_get_bits(raw_csd, 76, 1); 500 csd->vdd_r_curr_min = cur_min[mmc_get_bits(raw_csd, 59, 3)]; 501 csd->vdd_r_curr_max = cur_max[mmc_get_bits(raw_csd, 56, 3)]; 502 csd->vdd_w_curr_min = cur_min[mmc_get_bits(raw_csd, 53, 3)]; 503 csd->vdd_w_curr_max = cur_max[mmc_get_bits(raw_csd, 50, 3)]; 504 m = mmc_get_bits(raw_csd, 62, 12); 505 e = mmc_get_bits(raw_csd, 47, 3); 506 csd->capacity = ((1 + m) << (e + 2)) * csd->read_bl_len; 507 csd->erase_blk_en = mmc_get_bits(raw_csd, 46, 1); 508 csd->sector_size = mmc_get_bits(raw_csd, 39, 7); 509 csd->wp_grp_size = mmc_get_bits(raw_csd, 32, 7); 510 csd->wp_grp_enable = mmc_get_bits(raw_csd, 31, 1); 511 csd->r2w_factor = 1 << mmc_get_bits(raw_csd, 26, 3); 512 csd->write_bl_len = 1 << mmc_get_bits(raw_csd, 22, 4); 513 csd->write_bl_partial = mmc_get_bits(raw_csd, 21, 1); 514 } else if (v == 1) { 515 panic("Write SDHC CSD parser"); 516 } else 517 panic("unknown SD CSD version"); 518 } else { 519 panic("Write a MMC CSD parser"); 520 } 521 } 522 523 static int 524 mmc_all_send_cid(struct mmc_softc *sc, uint32_t *rawcid) 525 { 526 struct mmc_command cmd; 527 int err; 528 529 cmd.opcode = MMC_ALL_SEND_CID; 530 cmd.arg = 0; 531 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR; 532 err = mmc_wait_for_cmd(sc, &cmd, 0); 533 memcpy(rawcid, cmd.resp, 4 * sizeof(uint32_t)); 534 return (err); 535 } 536 537 static int 538 mmc_send_csd(struct mmc_softc *sc, uint16_t rca, uint32_t *rawcid) 539 { 540 struct mmc_command cmd; 541 int err; 542 543 cmd.opcode = MMC_SEND_CSD; 544 cmd.arg = rca << 16; 545 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR; 546 err = mmc_wait_for_cmd(sc, &cmd, 0); 547 memcpy(rawcid, cmd.resp, 4 * sizeof(uint32_t)); 548 return (err); 549 } 550 551 static int 552 mmc_send_relative_addr(struct mmc_softc *sc, uint32_t *resp) 553 { 554 struct mmc_command cmd; 555 int err; 556 557 cmd.opcode = SD_SEND_RELATIVE_ADDR; 558 cmd.arg = 0; 559 cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR; 560 err = mmc_wait_for_cmd(sc, &cmd, 0); 561 *resp = cmd.resp[0]; 562 return (err); 563 } 564 565 static void 566 mmc_discover_cards(struct mmc_softc *sc) 567 { 568 struct mmc_ivars *ivar; 569 int err; 570 uint32_t resp; 571 device_t child; 572 573 while (1) { 574 ivar = malloc(sizeof(struct mmc_ivars), M_DEVBUF, M_WAITOK); 575 if (!ivar) 576 return; 577 err = mmc_all_send_cid(sc, ivar->raw_cid); 578 if (err == MMC_ERR_TIMEOUT) 579 break; 580 if (err != MMC_ERR_NONE) { 581 printf("Error reading CID %d\n", err); 582 break; 583 } 584 if (mmcbr_get_mode(sc->dev) == mode_sd) { 585 ivar->mode = mode_sd; 586 mmc_decode_cid(1, ivar->raw_cid, &ivar->cid); 587 mmc_send_relative_addr(sc, &resp); 588 ivar->rca = resp >> 16; 589 // RO check 590 mmc_send_csd(sc, ivar->rca, ivar->raw_csd); 591 mmc_decode_csd(1, ivar->raw_csd, &ivar->csd); 592 printf("SD CARD: %lld bytes\n", (long long) 593 ivar->csd.capacity); 594 child = device_add_child(sc->dev, NULL, -1); 595 device_set_ivars(child, ivar); 596 return; 597 } 598 panic("Write MMC card code here"); 599 } 600 free(ivar, M_DEVBUF); 601 } 602 603 static void 604 mmc_go_discovery(struct mmc_softc *sc) 605 { 606 uint32_t ocr; 607 device_t dev; 608 609 dev = sc->dev; 610 if (mmcbr_get_power_mode(dev) != power_on) { 611 // First, try SD modes 612 mmcbr_set_mode(dev, mode_sd); 613 mmc_power_up(sc); 614 mmcbr_set_bus_mode(dev, pushpull); 615 mmc_idle_cards(sc); 616 if (mmc_send_app_op_cond(sc, 0, &ocr) != MMC_ERR_NONE) { 617 // Failed, try MMC 618 mmcbr_set_mode(dev, mode_mmc); 619 if (mmc_send_op_cond(sc, 0, &ocr) != MMC_ERR_NONE) 620 return; // Failed both, punt! XXX power down? 621 } 622 mmcbr_set_ocr(dev, mmc_select_vdd(sc, ocr)); 623 if (mmcbr_get_ocr(dev) != 0) 624 mmc_idle_cards(sc); 625 } else { 626 mmcbr_set_bus_mode(dev, opendrain); 627 mmcbr_set_clock(dev, mmcbr_get_f_min(dev)); 628 mmcbr_update_ios(dev); 629 // XXX recompute vdd based on new cards? 630 } 631 /* 632 * Make sure that we have a mutually agreeable voltage to at least 633 * one card on the bus. 634 */ 635 if (mmcbr_get_ocr(dev) == 0) 636 return; 637 /* 638 * Reselect the cards after we've idled them above. 639 */ 640 if (mmcbr_get_mode(dev) == mode_sd) 641 mmc_send_app_op_cond(sc, mmcbr_get_ocr(dev), NULL); 642 else 643 mmc_send_op_cond(sc, mmcbr_get_ocr(dev), NULL); 644 mmc_discover_cards(sc); 645 646 mmcbr_set_bus_mode(dev, pushpull); 647 mmcbr_update_ios(dev); 648 bus_generic_attach(dev); 649 // mmc_update_children_sysctl(dev); 650 } 651 652 static int 653 mmc_calculate_clock(struct mmc_softc *sc) 654 { 655 int max_dtr = 0; 656 int nkid, i, f_min, f_max; 657 device_t *kids; 658 659 f_min = mmcbr_get_f_min(sc->dev); 660 f_max = mmcbr_get_f_max(sc->dev); 661 max_dtr = f_max; 662 if (device_get_children(sc->dev, &kids, &nkid) != 0) 663 panic("can't get children"); 664 for (i = 0; i < nkid; i++) 665 if (mmc_get_tran_speed(kids[i]) < max_dtr) 666 max_dtr = mmc_get_tran_speed(kids[i]); 667 free(kids, M_TEMP); 668 device_printf(sc->dev, "setting transfer rate to %d.%03dMHz\n", 669 max_dtr / 1000000, (max_dtr / 1000) % 1000); 670 return max_dtr; 671 } 672 673 static void 674 mmc_scan(struct mmc_softc *sc) 675 { 676 device_t dev; 677 678 dev = sc->dev; 679 mmc_acquire_bus(dev, dev); 680 681 if (mmcbr_get_power_mode(dev) == power_on) 682 mmc_rescan_cards(sc); 683 mmc_go_discovery(sc); 684 mmcbr_set_clock(dev, mmc_calculate_clock(sc)); 685 mmcbr_update_ios(dev); 686 687 mmc_release_bus(dev, dev); 688 // XXX probe/attach/detach children? 689 } 690 691 static int 692 mmc_read_ivar(device_t bus, device_t child, int which, u_char *result) 693 { 694 struct mmc_ivars *ivar = device_get_ivars(child); 695 696 switch (which) { 697 default: 698 return (EINVAL); 699 case MMC_IVAR_DSR_IMP: 700 *(int *)result = ivar->csd.dsr_imp; 701 break; 702 case MMC_IVAR_MEDIA_SIZE: 703 *(int *)result = ivar->csd.capacity; 704 break; 705 case MMC_IVAR_RCA: 706 *(int *)result = ivar->rca; 707 break; 708 case MMC_IVAR_SECTOR_SIZE: 709 *(int *)result = 512; 710 break; 711 case MMC_IVAR_TRAN_SPEED: 712 *(int *)result = ivar->csd.tran_speed; 713 break; 714 } 715 return (0); 716 } 717 718 static int 719 mmc_write_ivar(device_t bus, device_t child, int which, uintptr_t value) 720 { 721 // None are writable ATM 722 switch (which) { 723 default: 724 return (EINVAL); 725 } 726 return (0); 727 } 728 729 730 static void 731 mmc_delayed_attach(void *xsc) 732 { 733 struct mmc_softc *sc = xsc; 734 735 mmc_scan(sc); 736 config_intrhook_disestablish(&sc->config_intrhook); 737 } 738 739 static device_method_t mmc_methods[] = { 740 /* device_if */ 741 DEVMETHOD(device_probe, mmc_probe), 742 DEVMETHOD(device_attach, mmc_attach), 743 DEVMETHOD(device_detach, mmc_detach), 744 745 /* Bus interface */ 746 DEVMETHOD(bus_read_ivar, mmc_read_ivar), 747 DEVMETHOD(bus_write_ivar, mmc_write_ivar), 748 749 /* MMC Bus interface */ 750 DEVMETHOD(mmcbus_wait_for_request, mmc_wait_for_request), 751 DEVMETHOD(mmcbus_acquire_bus, mmc_acquire_bus), 752 DEVMETHOD(mmcbus_release_bus, mmc_release_bus), 753 754 {0, 0}, 755 }; 756 757 static driver_t mmc_driver = { 758 "mmc", 759 mmc_methods, 760 sizeof(struct mmc_softc), 761 }; 762 static devclass_t mmc_devclass; 763 764 765 DRIVER_MODULE(mmc, at91_mci, mmc_driver, mmc_devclass, 0, 0); 766 DRIVER_MODULE(mmc, sdh, mmc_driver, mmc_devclass, 0, 0); 767