freebsd-nq/sys/dev/mmc/mmc.c
2008-09-28 23:24:52 +00:00

813 lines
20 KiB
C

/*-
* Copyright (c) 2006 Bernd Walter. All rights reserved.
* Copyright (c) 2006 M. Warner Losh. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* Portions of this software may have been developed with reference to
* the SD Simplified Specification. The following disclaimer may apply:
*
* The following conditions apply to the release of the simplified
* specification ("Simplified Specification") by the SD Card Association and
* the SD Group. The Simplified Specification is a subset of the complete SD
* Specification which is owned by the SD Card Association and the SD
* Group. This Simplified Specification is provided on a non-confidential
* basis subject to the disclaimers below. Any implementation of the
* Simplified Specification may require a license from the SD Card
* Association, SD Group, SD-3C LLC or other third parties.
*
* Disclaimers:
*
* The information contained in the Simplified Specification is presented only
* as a standard specification for SD Cards and SD Host/Ancillary products and
* is provided "AS-IS" without any representations or warranties of any
* kind. No responsibility is assumed by the SD Group, SD-3C LLC or the SD
* Card Association for any damages, any infringements of patents or other
* right of the SD Group, SD-3C LLC, the SD Card Association or any third
* parties, which may result from its use. No license is granted by
* implication, estoppel or otherwise under any patent or other rights of the
* SD Group, SD-3C LLC, the SD Card Association or any third party. Nothing
* herein shall be construed as an obligation by the SD Group, the SD-3C LLC
* or the SD Card Association to disclose or distribute any technical
* information, know-how or other confidential information to any third party.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/lock.h>
#include <sys/module.h>
#include <sys/mutex.h>
#include <sys/bus.h>
#include <dev/mmc/mmcreg.h>
#include <dev/mmc/mmcbrvar.h>
#include <dev/mmc/mmcvar.h>
#include "mmcbr_if.h"
#include "mmcbus_if.h"
struct mmc_softc {
device_t dev;
struct mtx sc_mtx;
struct intr_config_hook config_intrhook;
device_t owner;
uint32_t last_rca;
};
/*
* Per-card data
*/
struct mmc_ivars {
uint32_t raw_cid[4]; /* Raw bits of the CID */
uint32_t raw_csd[4]; /* Raw bits of the CSD */
uint16_t rca;
enum mmc_card_mode mode;
struct mmc_cid cid; /* cid decoded */
struct mmc_csd csd; /* csd decoded */
u_char read_only; /* True when the device is read-only */
};
#define CMD_RETRIES 3
/* bus entry points */
static int mmc_probe(device_t dev);
static int mmc_attach(device_t dev);
static int mmc_detach(device_t dev);
#define MMC_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx)
#define MMC_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx)
#define MMC_LOCK_INIT(_sc) \
mtx_init(&_sc->sc_mtx, device_get_nameunit(_sc->dev), \
"mmc", MTX_DEF)
#define MMC_LOCK_DESTROY(_sc) mtx_destroy(&_sc->sc_mtx);
#define MMC_ASSERT_LOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_OWNED);
#define MMC_ASSERT_UNLOCKED(_sc) mtx_assert(&_sc->sc_mtx, MA_NOTOWNED);
static void mmc_delayed_attach(void *);
static void mmc_power_down(struct mmc_softc *sc);
static int mmc_wait_for_cmd(struct mmc_softc *sc, struct mmc_command *cmd,
int retries);
static int mmc_wait_for_command(struct mmc_softc *sc, uint32_t opcode,
uint32_t arg, uint32_t flags, uint32_t *resp, int retries);
static void
mmc_ms_delay(int ms)
{
DELAY(1000 * ms); /* XXX BAD */
}
static int
mmc_probe(device_t dev)
{
device_set_desc(dev, "MMC/SD bus");
return (0);
}
static int
mmc_attach(device_t dev)
{
struct mmc_softc *sc;
sc = device_get_softc(dev);
sc->dev = dev;
MMC_LOCK_INIT(sc);
/* We'll probe and attach our children later, but before / mount */
sc->config_intrhook.ich_func = mmc_delayed_attach;
sc->config_intrhook.ich_arg = sc;
if (config_intrhook_establish(&sc->config_intrhook) != 0)
device_printf(dev, "config_intrhook_establish failed\n");
return (0);
}
static int
mmc_detach(device_t dev)
{
struct mmc_softc *sc = device_get_softc(dev);
device_t *kids;
int i, nkid;
/* kill children [ph33r]. -sorbo */
if (device_get_children(sc->dev, &kids, &nkid) != 0)
return 0;
for (i = 0; i < nkid; i++) {
device_t kid = kids[i];
void *ivar = device_get_ivars(kid);
device_detach(kid);
device_delete_child(sc->dev, kid);
free(ivar, M_DEVBUF);
}
free(kids, M_TEMP);
mmc_power_down(sc);
MMC_LOCK_DESTROY(sc);
return 0;
}
static int
mmc_acquire_bus(device_t busdev, device_t dev)
{
struct mmc_softc *sc;
int err;
int rca;
err = MMCBR_ACQUIRE_HOST(device_get_parent(busdev), dev);
if (err)
return (err);
sc = device_get_softc(busdev);
MMC_LOCK(sc);
if (sc->owner)
panic("mmc: host bridge didn't seralize us.");
sc->owner = dev;
MMC_UNLOCK(sc);
if (busdev != dev) {
// Keep track of the last rca that we've selected. If
// we're asked to do it again, don't. We never unselect
// unless the bus code itself wants the mmc bus.
rca = mmc_get_rca(dev);
if (sc->last_rca != rca) {
mmc_wait_for_command(sc, MMC_SELECT_CARD, rca << 16,
MMC_RSP_R1 | MMC_CMD_AC, NULL, CMD_RETRIES);
sc->last_rca = rca;
}
// XXX should set bus width here?
} else {
// If there's a card selected, stand down.
if (sc->last_rca != 0) {
mmc_wait_for_command(sc, MMC_SELECT_CARD, 0,
MMC_RSP_R1 | MMC_CMD_AC, NULL, CMD_RETRIES);
sc->last_rca = 0;
}
// XXX should set bus width here?
}
return (0);
}
static int
mmc_release_bus(device_t busdev, device_t dev)
{
struct mmc_softc *sc;
int err;
sc = device_get_softc(busdev);
MMC_LOCK(sc);
if (!sc->owner)
panic("mmc: releasing unowned bus.");
if (sc->owner != dev)
panic("mmc: you don't own the bus. game over.");
MMC_UNLOCK(sc);
err = MMCBR_RELEASE_HOST(device_get_parent(busdev), dev);
if (err)
return (err);
MMC_LOCK(sc);
sc->owner = NULL;
MMC_UNLOCK(sc);
return (0);
}
static void
mmc_rescan_cards(struct mmc_softc *sc)
{
/* XXX: Look at the children and see if they respond to status */
}
static uint32_t
mmc_select_vdd(struct mmc_softc *sc, uint32_t ocr)
{
return ocr & MMC_OCR_VOLTAGE;
}
static int
mmc_highest_voltage(uint32_t ocr)
{
int i;
for (i = 30; i >= 0; i--)
if (ocr & (1 << i))
return i;
return (-1);
}
static void
mmc_wakeup(struct mmc_request *req)
{
struct mmc_softc *sc;
// printf("Wakeup for req %p done_data %p\n", req, req->done_data);
sc = (struct mmc_softc *)req->done_data;
MMC_LOCK(sc);
req->flags |= MMC_REQ_DONE;
wakeup(req);
MMC_UNLOCK(sc);
}
static int
mmc_wait_for_req(struct mmc_softc *sc, struct mmc_request *req)
{
int err;
req->done = mmc_wakeup;
req->done_data = sc;
// printf("Submitting request %p sc %p\n", req, sc);
MMCBR_REQUEST(device_get_parent(sc->dev), sc->dev, req);
MMC_LOCK(sc);
do {
err = msleep(req, &sc->sc_mtx, PZERO | PCATCH, "mmcreq",
hz / 10);
} while (!(req->flags & MMC_REQ_DONE) && err == EAGAIN);
// printf("Request %p done with error %d\n", req, err);
MMC_UNLOCK(sc);
return (err);
}
static int
mmc_wait_for_request(device_t brdev, device_t reqdev, struct mmc_request *req)
{
struct mmc_softc *sc = device_get_softc(brdev);
return mmc_wait_for_req(sc, req);
}
static int
mmc_wait_for_cmd(struct mmc_softc *sc, struct mmc_command *cmd, int retries)
{
struct mmc_request mreq;
memset(&mreq, 0, sizeof(mreq));
memset(cmd->resp, 0, sizeof(cmd->resp));
cmd->retries = retries;
cmd->data = NULL;
mreq.cmd = cmd;
// printf("CMD: %x ARG %x\n", cmd->opcode, cmd->arg);
mmc_wait_for_req(sc, &mreq);
return (cmd->error);
}
static int
mmc_wait_for_app_cmd(struct mmc_softc *sc, uint32_t rca,
struct mmc_command *cmd, int retries)
{
struct mmc_command appcmd;
int err = MMC_ERR_NONE, i;
for (i = 0; i <= retries; i++) {
appcmd.opcode = MMC_APP_CMD;
appcmd.arg = rca << 16;
appcmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
mmc_wait_for_cmd(sc, &appcmd, 0);
err = appcmd.error;
if (err != MMC_ERR_NONE)
continue;
if (!(appcmd.resp[0] & R1_APP_CMD))
return MMC_ERR_FAILED;
mmc_wait_for_cmd(sc, cmd, 0);
err = cmd->error;
if (err == MMC_ERR_NONE)
break;
}
return (err);
}
static int
mmc_wait_for_command(struct mmc_softc *sc, uint32_t opcode,
uint32_t arg, uint32_t flags, uint32_t *resp, int retries)
{
struct mmc_command cmd;
int err;
memset(&cmd, 0, sizeof(cmd));
cmd.opcode = opcode;
cmd.arg = arg;
cmd.flags = flags;
err = mmc_wait_for_cmd(sc, &cmd, retries);
if (err)
return (err);
if (cmd.error)
return (cmd.error);
if (resp) {
if (flags & MMC_RSP_136)
memcpy(resp, cmd.resp, 4 * sizeof(uint32_t));
else
*resp = cmd.resp[0];
}
return (0);
}
static void
mmc_idle_cards(struct mmc_softc *sc)
{
device_t dev;
struct mmc_command cmd;
dev = sc->dev;
mmcbr_set_chip_select(dev, cs_high);
mmcbr_update_ios(dev);
mmc_ms_delay(1);
memset(&cmd, 0, sizeof(cmd));
cmd.opcode = MMC_GO_IDLE_STATE;
cmd.arg = 0;
cmd.flags = MMC_RSP_NONE | MMC_CMD_BC;
mmc_wait_for_cmd(sc, &cmd, 0);
mmc_ms_delay(1);
mmcbr_set_chip_select(dev, cs_dontcare);
mmcbr_update_ios(dev);
mmc_ms_delay(1);
}
static int
mmc_send_app_op_cond(struct mmc_softc *sc, uint32_t ocr, uint32_t *rocr)
{
struct mmc_command cmd;
int err = MMC_ERR_NONE, i;
memset(&cmd, 0, sizeof(cmd));
cmd.opcode = ACMD_SD_SEND_OP_COND;
cmd.arg = ocr;
cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
for (i = 0; i < 100; i++) {
err = mmc_wait_for_app_cmd(sc, 0, &cmd, CMD_RETRIES);
if (err != MMC_ERR_NONE)
break;
if ((cmd.resp[0] & MMC_OCR_CARD_BUSY) || ocr == 0)
break;
err = MMC_ERR_TIMEOUT;
mmc_ms_delay(10);
}
if (rocr && err == MMC_ERR_NONE)
*rocr = cmd.resp[0];
return err;
}
static int
mmc_send_op_cond(struct mmc_softc *sc, uint32_t ocr, uint32_t *rocr)
{
struct mmc_command cmd;
int err = MMC_ERR_NONE, i;
memset(&cmd, 0, sizeof(cmd));
cmd.opcode = MMC_SEND_OP_COND;
cmd.arg = ocr;
cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR;
for (i = 0; i < 100; i++) {
err = mmc_wait_for_cmd(sc, &cmd, CMD_RETRIES);
if (err != MMC_ERR_NONE)
break;
if ((cmd.resp[0] & MMC_OCR_CARD_BUSY) || ocr == 0)
break;
err = MMC_ERR_TIMEOUT;
mmc_ms_delay(10);
}
if (rocr && err == MMC_ERR_NONE)
*rocr = cmd.resp[0];
return err;
}
static void
mmc_power_up(struct mmc_softc *sc)
{
device_t dev;
dev = sc->dev;
mmcbr_set_vdd(dev, mmc_highest_voltage(mmcbr_get_host_ocr(dev)));
mmcbr_set_bus_mode(dev, opendrain);
mmcbr_set_chip_select(dev, cs_dontcare);
mmcbr_set_bus_width(dev, bus_width_1);
mmcbr_set_power_mode(dev, power_up);
mmcbr_set_clock(dev, 0);
mmcbr_update_ios(dev);
mmc_ms_delay(1);
mmcbr_set_clock(dev, mmcbr_get_f_min(sc->dev));
mmcbr_set_power_mode(dev, power_on);
mmcbr_update_ios(dev);
mmc_ms_delay(2);
}
static void
mmc_power_down(struct mmc_softc *sc)
{
device_t dev = sc->dev;
mmcbr_set_bus_mode(dev, opendrain);
mmcbr_set_chip_select(dev, cs_dontcare);
mmcbr_set_bus_width(dev, bus_width_1);
mmcbr_set_power_mode(dev, power_off);
mmcbr_set_clock(dev, 0);
mmcbr_update_ios(dev);
}
static uint32_t
mmc_get_bits(uint32_t *bits, int start, int size)
{
const int i = 3 - (start / 32);
const int shift = start & 31;
uint32_t retval = bits[i] >> shift;
if (size + shift > 32)
retval |= bits[i - 1] << (32 - shift);
return retval & ((1 << size) - 1);
}
static void
mmc_decode_cid(int is_sd, uint32_t *raw_cid, struct mmc_cid *cid)
{
int i;
memset(cid, 0, sizeof(*cid));
if (is_sd) {
/* There's no version info, so we take it on faith */
cid->mid = mmc_get_bits(raw_cid, 120, 8);
cid->oid = mmc_get_bits(raw_cid, 104, 16);
for (i = 0; i < 5; i++)
cid->pnm[i] = mmc_get_bits(raw_cid, 96 - i * 8, 8);
cid->prv = mmc_get_bits(raw_cid, 56, 8);
cid->psn = mmc_get_bits(raw_cid, 24, 32);
cid->mdt_year = mmc_get_bits(raw_cid, 12, 8) + 2001;
cid->mdt_month = mmc_get_bits(raw_cid, 8, 4);
} else {
// XXX write me
panic("write mmc cid decoder");
}
}
static const int exp[8] = {
1, 10, 100, 1000, 10000, 100000, 1000000, 10000000
};
static const int mant[16] = {
10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80
};
static const int cur_min[8] = {
500, 1000, 5000, 10000, 25000, 35000, 60000, 100000
};
static const int cur_max[8] = {
1000, 5000, 10000, 25000, 35000, 45000, 800000, 200000
};
static void
mmc_decode_csd(int is_sd, uint32_t *raw_csd, struct mmc_csd *csd)
{
int v;
int m;
int e;
memset(csd, 0, sizeof(*csd));
if (is_sd) {
csd->csd_structure = v = mmc_get_bits(raw_csd, 126, 2);
if (v == 0) {
m = mmc_get_bits(raw_csd, 115, 4);
e = mmc_get_bits(raw_csd, 112, 3);
csd->tacc = exp[e] * mant[m] + 9 / 10;
csd->nsac = mmc_get_bits(raw_csd, 104, 8) * 100;
m = mmc_get_bits(raw_csd, 99, 4);
e = mmc_get_bits(raw_csd, 96, 3);
csd->tran_speed = exp[e] * 10000 * mant[m];
csd->ccc = mmc_get_bits(raw_csd, 84, 12);
csd->read_bl_len = 1 << mmc_get_bits(raw_csd, 80, 4);
csd->read_bl_partial = mmc_get_bits(raw_csd, 79, 1);
csd->write_blk_misalign = mmc_get_bits(raw_csd, 78, 1);
csd->read_blk_misalign = mmc_get_bits(raw_csd, 77, 1);
csd->dsr_imp = mmc_get_bits(raw_csd, 76, 1);
csd->vdd_r_curr_min = cur_min[mmc_get_bits(raw_csd, 59, 3)];
csd->vdd_r_curr_max = cur_max[mmc_get_bits(raw_csd, 56, 3)];
csd->vdd_w_curr_min = cur_min[mmc_get_bits(raw_csd, 53, 3)];
csd->vdd_w_curr_max = cur_max[mmc_get_bits(raw_csd, 50, 3)];
m = mmc_get_bits(raw_csd, 62, 12);
e = mmc_get_bits(raw_csd, 47, 3);
csd->capacity = ((1 + m) << (e + 2)) * csd->read_bl_len;
csd->erase_blk_en = mmc_get_bits(raw_csd, 46, 1);
csd->sector_size = mmc_get_bits(raw_csd, 39, 7);
csd->wp_grp_size = mmc_get_bits(raw_csd, 32, 7);
csd->wp_grp_enable = mmc_get_bits(raw_csd, 31, 1);
csd->r2w_factor = 1 << mmc_get_bits(raw_csd, 26, 3);
csd->write_bl_len = 1 << mmc_get_bits(raw_csd, 22, 4);
csd->write_bl_partial = mmc_get_bits(raw_csd, 21, 1);
} else if (v == 1) {
panic("Write SDHC CSD parser");
} else
panic("unknown SD CSD version");
} else {
panic("Write a MMC CSD parser");
}
}
static int
mmc_all_send_cid(struct mmc_softc *sc, uint32_t *rawcid)
{
struct mmc_command cmd;
int err;
cmd.opcode = MMC_ALL_SEND_CID;
cmd.arg = 0;
cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
err = mmc_wait_for_cmd(sc, &cmd, 0);
memcpy(rawcid, cmd.resp, 4 * sizeof(uint32_t));
return (err);
}
static int
mmc_send_csd(struct mmc_softc *sc, uint16_t rca, uint32_t *rawcid)
{
struct mmc_command cmd;
int err;
cmd.opcode = MMC_SEND_CSD;
cmd.arg = rca << 16;
cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
err = mmc_wait_for_cmd(sc, &cmd, 0);
memcpy(rawcid, cmd.resp, 4 * sizeof(uint32_t));
return (err);
}
static int
mmc_send_relative_addr(struct mmc_softc *sc, uint32_t *resp)
{
struct mmc_command cmd;
int err;
cmd.opcode = SD_SEND_RELATIVE_ADDR;
cmd.arg = 0;
cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR;
err = mmc_wait_for_cmd(sc, &cmd, 0);
*resp = cmd.resp[0];
return (err);
}
static void
mmc_discover_cards(struct mmc_softc *sc)
{
struct mmc_ivars *ivar;
int err;
uint32_t resp;
device_t child;
while (1) {
ivar = malloc(sizeof(struct mmc_ivars), M_DEVBUF, M_WAITOK);
if (!ivar)
return;
err = mmc_all_send_cid(sc, ivar->raw_cid);
if (err == MMC_ERR_TIMEOUT)
break;
if (err != MMC_ERR_NONE) {
printf("Error reading CID %d\n", err);
break;
}
if (mmcbr_get_mode(sc->dev) == mode_sd) {
ivar->mode = mode_sd;
mmc_decode_cid(1, ivar->raw_cid, &ivar->cid);
mmc_send_relative_addr(sc, &resp);
ivar->rca = resp >> 16;
if (mmcbr_get_ro(sc->dev))
ivar->read_only = 1;
mmc_send_csd(sc, ivar->rca, ivar->raw_csd);
mmc_decode_csd(1, ivar->raw_csd, &ivar->csd);
printf("SD CARD: %lld bytes\n", (long long)
ivar->csd.capacity);
child = device_add_child(sc->dev, NULL, -1);
device_set_ivars(child, ivar);
return;
}
panic("Write MMC card code here");
}
free(ivar, M_DEVBUF);
}
static void
mmc_go_discovery(struct mmc_softc *sc)
{
uint32_t ocr;
device_t dev;
dev = sc->dev;
if (mmcbr_get_power_mode(dev) != power_on) {
// First, try SD modes
mmcbr_set_mode(dev, mode_sd);
mmc_power_up(sc);
mmcbr_set_bus_mode(dev, pushpull);
mmc_idle_cards(sc);
if (mmc_send_app_op_cond(sc, 0, &ocr) != MMC_ERR_NONE) {
// Failed, try MMC
mmcbr_set_mode(dev, mode_mmc);
if (mmc_send_op_cond(sc, 0, &ocr) != MMC_ERR_NONE)
return; // Failed both, punt! XXX power down?
}
mmcbr_set_ocr(dev, mmc_select_vdd(sc, ocr));
if (mmcbr_get_ocr(dev) != 0)
mmc_idle_cards(sc);
} else {
mmcbr_set_bus_mode(dev, opendrain);
mmcbr_set_clock(dev, mmcbr_get_f_min(dev));
mmcbr_update_ios(dev);
// XXX recompute vdd based on new cards?
}
/*
* Make sure that we have a mutually agreeable voltage to at least
* one card on the bus.
*/
if (mmcbr_get_ocr(dev) == 0)
return;
/*
* Reselect the cards after we've idled them above.
*/
if (mmcbr_get_mode(dev) == mode_sd)
mmc_send_app_op_cond(sc, mmcbr_get_ocr(dev), NULL);
else
mmc_send_op_cond(sc, mmcbr_get_ocr(dev), NULL);
mmc_discover_cards(sc);
mmcbr_set_bus_mode(dev, pushpull);
mmcbr_update_ios(dev);
bus_generic_attach(dev);
// mmc_update_children_sysctl(dev);
}
static int
mmc_calculate_clock(struct mmc_softc *sc)
{
int max_dtr = 0;
int nkid, i, f_min, f_max;
device_t *kids;
f_min = mmcbr_get_f_min(sc->dev);
f_max = mmcbr_get_f_max(sc->dev);
max_dtr = f_max;
if (device_get_children(sc->dev, &kids, &nkid) != 0)
panic("can't get children");
for (i = 0; i < nkid; i++)
if (mmc_get_tran_speed(kids[i]) < max_dtr)
max_dtr = mmc_get_tran_speed(kids[i]);
free(kids, M_TEMP);
device_printf(sc->dev, "setting transfer rate to %d.%03dMHz\n",
max_dtr / 1000000, (max_dtr / 1000) % 1000);
return max_dtr;
}
static void
mmc_scan(struct mmc_softc *sc)
{
device_t dev;
dev = sc->dev;
mmc_acquire_bus(dev, dev);
if (mmcbr_get_power_mode(dev) == power_on)
mmc_rescan_cards(sc);
mmc_go_discovery(sc);
mmcbr_set_clock(dev, mmc_calculate_clock(sc));
mmcbr_update_ios(dev);
mmc_release_bus(dev, dev);
// XXX probe/attach/detach children?
}
static int
mmc_read_ivar(device_t bus, device_t child, int which, u_char *result)
{
struct mmc_ivars *ivar = device_get_ivars(child);
switch (which) {
default:
return (EINVAL);
case MMC_IVAR_DSR_IMP:
*(int *)result = ivar->csd.dsr_imp;
break;
case MMC_IVAR_MEDIA_SIZE:
*(int *)result = ivar->csd.capacity;
break;
case MMC_IVAR_RCA:
*(int *)result = ivar->rca;
break;
case MMC_IVAR_SECTOR_SIZE:
*(int *)result = 512;
break;
case MMC_IVAR_TRAN_SPEED:
*(int *)result = ivar->csd.tran_speed;
break;
case MMC_IVAR_READ_ONLY:
*(int *)result = ivar->read_only;
break;
}
return (0);
}
static int
mmc_write_ivar(device_t bus, device_t child, int which, uintptr_t value)
{
// None are writable ATM
switch (which) {
default:
return (EINVAL);
}
return (0);
}
static void
mmc_delayed_attach(void *xsc)
{
struct mmc_softc *sc = xsc;
mmc_scan(sc);
config_intrhook_disestablish(&sc->config_intrhook);
}
static device_method_t mmc_methods[] = {
/* device_if */
DEVMETHOD(device_probe, mmc_probe),
DEVMETHOD(device_attach, mmc_attach),
DEVMETHOD(device_detach, mmc_detach),
/* Bus interface */
DEVMETHOD(bus_read_ivar, mmc_read_ivar),
DEVMETHOD(bus_write_ivar, mmc_write_ivar),
/* MMC Bus interface */
DEVMETHOD(mmcbus_wait_for_request, mmc_wait_for_request),
DEVMETHOD(mmcbus_acquire_bus, mmc_acquire_bus),
DEVMETHOD(mmcbus_release_bus, mmc_release_bus),
{0, 0},
};
static driver_t mmc_driver = {
"mmc",
mmc_methods,
sizeof(struct mmc_softc),
};
static devclass_t mmc_devclass;
DRIVER_MODULE(mmc, at91_mci, mmc_driver, mmc_devclass, 0, 0);
DRIVER_MODULE(mmc, sdh, mmc_driver, mmc_devclass, 0, 0);