1163516Simp/*- 2163516Simp * Copyright (c) 2006 Bernd Walter. All rights reserved. 3163516Simp * Copyright (c) 2006 M. Warner Losh. All rights reserved. 4318494Smarius * Copyright (c) 2017 Marius Strobl <marius@FreeBSD.org> 5163516Simp * 6163516Simp * Redistribution and use in source and binary forms, with or without 7163516Simp * modification, are permitted provided that the following conditions 8163516Simp * are met: 9163516Simp * 1. Redistributions of source code must retain the above copyright 10163516Simp * notice, this list of conditions and the following disclaimer. 11163516Simp * 2. Redistributions in binary form must reproduce the above copyright 12163516Simp * notice, this list of conditions and the following disclaimer in the 13163516Simp * documentation and/or other materials provided with the distribution. 14163516Simp * 15163516Simp * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 16163516Simp * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17163516Simp * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18163516Simp * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 19163516Simp * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20163516Simp * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21163516Simp * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22163516Simp * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23163516Simp * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24163516Simp * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25170002Simp * 26170002Simp * Portions of this software may have been developed with reference to 27170002Simp * the SD Simplified Specification. The following disclaimer may apply: 28170002Simp * 29170002Simp * The following conditions apply to the release of the simplified 30170002Simp * specification ("Simplified Specification") by the SD Card Association and 31170002Simp * the SD Group. The Simplified Specification is a subset of the complete SD 32170002Simp * Specification which is owned by the SD Card Association and the SD 33170002Simp * Group. This Simplified Specification is provided on a non-confidential 34170002Simp * basis subject to the disclaimers below. Any implementation of the 35170002Simp * Simplified Specification may require a license from the SD Card 36170002Simp * Association, SD Group, SD-3C LLC or other third parties. 37170002Simp * 38170002Simp * Disclaimers: 39170002Simp * 40170002Simp * The information contained in the Simplified Specification is presented only 41170002Simp * as a standard specification for SD Cards and SD Host/Ancillary products and 42170002Simp * is provided "AS-IS" without any representations or warranties of any 43170002Simp * kind. No responsibility is assumed by the SD Group, SD-3C LLC or the SD 44170002Simp * Card Association for any damages, any infringements of patents or other 45170002Simp * right of the SD Group, SD-3C LLC, the SD Card Association or any third 46170002Simp * parties, which may result from its use. No license is granted by 47170002Simp * implication, estoppel or otherwise under any patent or other rights of the 48170002Simp * SD Group, SD-3C LLC, the SD Card Association or any third party. Nothing 49170002Simp * herein shall be construed as an obligation by the SD Group, the SD-3C LLC 50170002Simp * or the SD Card Association to disclose or distribute any technical 51170002Simp * information, know-how or other confidential information to any third party. 52163516Simp */ 53163516Simp 54163516Simp#include <sys/cdefs.h> 55163516Simp__FBSDID("$FreeBSD: stable/11/sys/dev/mmc/mmc.c 340740 2018-11-21 18:53:30Z marius $"); 56163516Simp 57163516Simp#include <sys/param.h> 58163516Simp#include <sys/systm.h> 59163516Simp#include <sys/kernel.h> 60163516Simp#include <sys/malloc.h> 61163516Simp#include <sys/lock.h> 62163516Simp#include <sys/module.h> 63163516Simp#include <sys/mutex.h> 64163516Simp#include <sys/bus.h> 65183704Smav#include <sys/endian.h> 66187875Smav#include <sys/sysctl.h> 67275951Sian#include <sys/time.h> 68163516Simp 69318197Smarius#include <dev/mmc/bridge.h> 70318197Smarius#include <dev/mmc/mmc_private.h> 71318197Smarius#include <dev/mmc/mmc_subr.h> 72163516Simp#include <dev/mmc/mmcreg.h> 73163516Simp#include <dev/mmc/mmcbrvar.h> 74163516Simp#include <dev/mmc/mmcvar.h> 75318197Smarius 76163516Simp#include "mmcbr_if.h" 77163516Simp#include "mmcbus_if.h" 78163516Simp 79318494SmariusCTASSERT(bus_timing_max <= sizeof(uint32_t) * NBBY); 80318494Smarius 81163516Simp/* 82163516Simp * Per-card data 83163516Simp */ 84163516Simpstruct mmc_ivars { 85163516Simp uint32_t raw_cid[4]; /* Raw bits of the CID */ 86163516Simp uint32_t raw_csd[4]; /* Raw bits of the CSD */ 87183704Smav uint32_t raw_scr[2]; /* Raw bits of the SCR */ 88318197Smarius uint8_t raw_ext_csd[MMC_EXTCSD_SIZE]; /* Raw bits of the EXT_CSD */ 89184033Smav uint32_t raw_sd_status[16]; /* Raw bits of the SD_STATUS */ 90163516Simp uint16_t rca; 91322119Smarius u_char read_only; /* True when the device is read-only */ 92322119Smarius u_char high_cap; /* High Capacity device (block addressed) */ 93163516Simp enum mmc_card_mode mode; 94322119Smarius enum mmc_bus_width bus_width; /* Bus width to use */ 95163516Simp struct mmc_cid cid; /* cid decoded */ 96163516Simp struct mmc_csd csd; /* csd decoded */ 97183704Smav struct mmc_scr scr; /* scr decoded */ 98184033Smav struct mmc_sd_status sd_status; /* SD_STATUS decoded */ 99183731Smav uint32_t sec_count; /* Card capacity in 512byte blocks */ 100318494Smarius uint32_t timings; /* Mask of bus timings supported */ 101318494Smarius uint32_t vccq_120; /* Mask of bus timings at VCCQ of 1.2 V */ 102318494Smarius uint32_t vccq_180; /* Mask of bus timings at VCCQ of 1.8 V */ 103183704Smav uint32_t tran_speed; /* Max speed in normal mode */ 104183704Smav uint32_t hs_tran_speed; /* Max speed in high speed mode */ 105184033Smav uint32_t erase_sector; /* Card native erase sector size */ 106318197Smarius uint32_t cmd6_time; /* Generic switch timeout [us] */ 107322388Smarius uint32_t quirks; /* Quirks as per mmc_quirk->quirks */ 108234524Smarius char card_id_string[64];/* Formatted CID info (serial, MFG, etc) */ 109269341Sian char card_sn_string[16];/* Formatted serial # for disk->d_ident */ 110163516Simp}; 111163516Simp 112318197Smarius#define CMD_RETRIES 3 113163516Simp 114322388Smariusstatic const struct mmc_quirk mmc_quirks[] = { 115322388Smarius /* 116322388Smarius * For some SanDisk iNAND devices, the CMD38 argument needs to be 117322388Smarius * provided in EXT_CSD[113]. 118322388Smarius */ 119322388Smarius { 0x2, 0x100, "SEM02G", MMC_QUIRK_INAND_CMD38 }, 120322388Smarius { 0x2, 0x100, "SEM04G", MMC_QUIRK_INAND_CMD38 }, 121322388Smarius { 0x2, 0x100, "SEM08G", MMC_QUIRK_INAND_CMD38 }, 122322388Smarius { 0x2, 0x100, "SEM16G", MMC_QUIRK_INAND_CMD38 }, 123322388Smarius { 0x2, 0x100, "SEM32G", MMC_QUIRK_INAND_CMD38 }, 124322388Smarius 125322388Smarius /* 126322388Smarius * Disable TRIM for Kingston eMMCs where a firmware bug can lead to 127322388Smarius * unrecoverable data corruption. 128322388Smarius */ 129322388Smarius { 0x70, MMC_QUIRK_OID_ANY, "V10008", MMC_QUIRK_BROKEN_TRIM }, 130322388Smarius { 0x70, MMC_QUIRK_OID_ANY, "V10016", MMC_QUIRK_BROKEN_TRIM }, 131322388Smarius 132322388Smarius { 0x0, 0x0, NULL, 0x0 } 133322388Smarius}; 134322388Smarius 135227309Sedstatic SYSCTL_NODE(_hw, OID_AUTO, mmc, CTLFLAG_RD, NULL, "mmc driver"); 136187875Smav 137188044Simpstatic int mmc_debug; 138318197SmariusSYSCTL_INT(_hw_mmc, OID_AUTO, debug, CTLFLAG_RWTUN, &mmc_debug, 0, 139318197Smarius "Debug level"); 140187875Smav 141163516Simp/* bus entry points */ 142236491Smariusstatic int mmc_acquire_bus(device_t busdev, device_t dev); 143163516Simpstatic int mmc_attach(device_t dev); 144236491Smariusstatic int mmc_child_location_str(device_t dev, device_t child, char *buf, 145236491Smarius size_t buflen); 146163516Simpstatic int mmc_detach(device_t dev); 147236491Smariusstatic int mmc_probe(device_t dev); 148236491Smariusstatic int mmc_read_ivar(device_t bus, device_t child, int which, 149236491Smarius uintptr_t *result); 150236491Smariusstatic int mmc_release_bus(device_t busdev, device_t dev); 151236491Smariusstatic int mmc_resume(device_t dev); 152322119Smariusstatic void mmc_retune_pause(device_t busdev, device_t dev, bool retune); 153322119Smariusstatic void mmc_retune_unpause(device_t busdev, device_t dev); 154185721Smavstatic int mmc_suspend(device_t dev); 155322119Smariusstatic int mmc_wait_for_request(device_t busdev, device_t dev, 156236491Smarius struct mmc_request *req); 157236491Smariusstatic int mmc_write_ivar(device_t bus, device_t child, int which, 158236491Smarius uintptr_t value); 159163516Simp 160318197Smarius#define MMC_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx) 161163516Simp#define MMC_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx) 162318197Smarius#define MMC_LOCK_INIT(_sc) \ 163318197Smarius mtx_init(&(_sc)->sc_mtx, device_get_nameunit((_sc)->dev), \ 164163516Simp "mmc", MTX_DEF) 165318197Smarius#define MMC_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->sc_mtx); 166318197Smarius#define MMC_ASSERT_LOCKED(_sc) mtx_assert(&(_sc)->sc_mtx, MA_OWNED); 167318197Smarius#define MMC_ASSERT_UNLOCKED(_sc) mtx_assert(&(_sc)->sc_mtx, MA_NOTOWNED); 168163516Simp 169236491Smariusstatic int mmc_all_send_cid(struct mmc_softc *sc, uint32_t *rawcid); 170236491Smariusstatic void mmc_app_decode_scr(uint32_t *raw_scr, struct mmc_scr *scr); 171236491Smariusstatic void mmc_app_decode_sd_status(uint32_t *raw_sd_status, 172236491Smarius struct mmc_sd_status *sd_status); 173236491Smariusstatic int mmc_app_sd_status(struct mmc_softc *sc, uint16_t rca, 174236491Smarius uint32_t *rawsdstatus); 175236491Smariusstatic int mmc_app_send_scr(struct mmc_softc *sc, uint16_t rca, 176236491Smarius uint32_t *rawscr); 177183763Smavstatic int mmc_calculate_clock(struct mmc_softc *sc); 178318197Smariusstatic void mmc_decode_cid_mmc(uint32_t *raw_cid, struct mmc_cid *cid, 179318197Smarius bool is_4_41p); 180236491Smariusstatic void mmc_decode_cid_sd(uint32_t *raw_cid, struct mmc_cid *cid); 181236491Smariusstatic void mmc_decode_csd_mmc(uint32_t *raw_csd, struct mmc_csd *csd); 182322119Smariusstatic int mmc_decode_csd_sd(uint32_t *raw_csd, struct mmc_csd *csd); 183236491Smariusstatic void mmc_delayed_attach(void *xsc); 184322119Smariusstatic int mmc_delete_cards(struct mmc_softc *sc, bool final); 185236491Smariusstatic void mmc_discover_cards(struct mmc_softc *sc); 186236491Smariusstatic void mmc_format_card_id_string(struct mmc_ivars *ivar); 187236491Smariusstatic void mmc_go_discovery(struct mmc_softc *sc); 188236491Smariusstatic uint32_t mmc_get_bits(uint32_t *bits, int bit_len, int start, 189236491Smarius int size); 190236491Smariusstatic int mmc_highest_voltage(uint32_t ocr); 191322119Smariusstatic bool mmc_host_timing(device_t dev, enum mmc_bus_timing timing); 192236491Smariusstatic void mmc_idle_cards(struct mmc_softc *sc); 193236491Smariusstatic void mmc_ms_delay(int ms); 194236491Smariusstatic void mmc_log_card(device_t dev, struct mmc_ivars *ivar, int newcard); 195183449Simpstatic void mmc_power_down(struct mmc_softc *sc); 196236491Smariusstatic void mmc_power_up(struct mmc_softc *sc); 197236491Smariusstatic void mmc_rescan_cards(struct mmc_softc *sc); 198322119Smariusstatic int mmc_retune(device_t busdev, device_t dev, bool reset); 199236491Smariusstatic void mmc_scan(struct mmc_softc *sc); 200236491Smariusstatic int mmc_sd_switch(struct mmc_softc *sc, uint8_t mode, uint8_t grp, 201236491Smarius uint8_t value, uint8_t *res); 202236491Smariusstatic int mmc_select_card(struct mmc_softc *sc, uint16_t rca); 203236491Smariusstatic uint32_t mmc_select_vdd(struct mmc_softc *sc, uint32_t ocr); 204236491Smariusstatic int mmc_send_app_op_cond(struct mmc_softc *sc, uint32_t ocr, 205236491Smarius uint32_t *rocr); 206236491Smariusstatic int mmc_send_csd(struct mmc_softc *sc, uint16_t rca, uint32_t *rawcsd); 207236491Smariusstatic int mmc_send_if_cond(struct mmc_softc *sc, uint8_t vhs); 208236491Smariusstatic int mmc_send_op_cond(struct mmc_softc *sc, uint32_t ocr, 209236491Smarius uint32_t *rocr); 210236491Smariusstatic int mmc_send_relative_addr(struct mmc_softc *sc, uint32_t *resp); 211236491Smariusstatic int mmc_set_blocklen(struct mmc_softc *sc, uint32_t len); 212322119Smariusstatic int mmc_set_card_bus_width(struct mmc_softc *sc, struct mmc_ivars *ivar, 213322119Smarius enum mmc_bus_timing timing); 214318494Smariusstatic int mmc_set_power_class(struct mmc_softc *sc, struct mmc_ivars *ivar); 215236491Smariusstatic int mmc_set_relative_addr(struct mmc_softc *sc, uint16_t resp); 216318197Smariusstatic int mmc_set_timing(struct mmc_softc *sc, struct mmc_ivars *ivar, 217318494Smarius enum mmc_bus_timing timing); 218322119Smariusstatic int mmc_set_vccq(struct mmc_softc *sc, struct mmc_ivars *ivar, 219322119Smarius enum mmc_bus_timing timing); 220322119Smariusstatic int mmc_switch_to_hs200(struct mmc_softc *sc, struct mmc_ivars *ivar, 221322119Smarius uint32_t clock); 222322119Smariusstatic int mmc_switch_to_hs400(struct mmc_softc *sc, struct mmc_ivars *ivar, 223322119Smarius uint32_t max_dtr, enum mmc_bus_timing max_timing); 224236491Smariusstatic int mmc_test_bus_width(struct mmc_softc *sc); 225318494Smariusstatic uint32_t mmc_timing_to_dtr(struct mmc_ivars *ivar, 226318494Smarius enum mmc_bus_timing timing); 227318494Smariusstatic const char *mmc_timing_to_string(enum mmc_bus_timing timing); 228322119Smariusstatic void mmc_update_child_list(struct mmc_softc *sc); 229163516Simpstatic int mmc_wait_for_command(struct mmc_softc *sc, uint32_t opcode, 230163516Simp uint32_t arg, uint32_t flags, uint32_t *resp, int retries); 231236491Smariusstatic int mmc_wait_for_req(struct mmc_softc *sc, struct mmc_request *req); 232236491Smariusstatic void mmc_wakeup(struct mmc_request *req); 233163516Simp 234163516Simpstatic void 235163516Simpmmc_ms_delay(int ms) 236163516Simp{ 237236491Smarius 238163516Simp DELAY(1000 * ms); /* XXX BAD */ 239163516Simp} 240163516Simp 241163516Simpstatic int 242163516Simpmmc_probe(device_t dev) 243163516Simp{ 244163516Simp 245183445Simp device_set_desc(dev, "MMC/SD bus"); 246163516Simp return (0); 247163516Simp} 248163516Simp 249163516Simpstatic int 250163516Simpmmc_attach(device_t dev) 251163516Simp{ 252163516Simp struct mmc_softc *sc; 253163516Simp 254163516Simp sc = device_get_softc(dev); 255163516Simp sc->dev = dev; 256163516Simp MMC_LOCK_INIT(sc); 257163516Simp 258163516Simp /* We'll probe and attach our children later, but before / mount */ 259163516Simp sc->config_intrhook.ich_func = mmc_delayed_attach; 260163516Simp sc->config_intrhook.ich_arg = sc; 261163516Simp if (config_intrhook_establish(&sc->config_intrhook) != 0) 262163516Simp device_printf(dev, "config_intrhook_establish failed\n"); 263163516Simp return (0); 264163516Simp} 265163516Simp 266163516Simpstatic int 267163516Simpmmc_detach(device_t dev) 268163516Simp{ 269169567Simp struct mmc_softc *sc = device_get_softc(dev); 270185721Smav int err; 271169567Simp 272322119Smarius err = mmc_delete_cards(sc, true); 273322119Smarius if (err != 0) 274185721Smav return (err); 275183449Simp mmc_power_down(sc); 276169567Simp MMC_LOCK_DESTROY(sc); 277169567Simp 278183467Simp return (0); 279163516Simp} 280163516Simp 281163516Simpstatic int 282185721Smavmmc_suspend(device_t dev) 283185721Smav{ 284185721Smav struct mmc_softc *sc = device_get_softc(dev); 285185721Smav int err; 286185721Smav 287185721Smav err = bus_generic_suspend(dev); 288322119Smarius if (err != 0) 289318197Smarius return (err); 290322119Smarius /* 291322119Smarius * We power down with the bus acquired here, mainly so that no device 292322119Smarius * is selected any longer and sc->last_rca gets set to 0. Otherwise, 293322119Smarius * the deselect as part of the bus acquisition in mmc_scan() may fail 294322119Smarius * during resume, as the bus isn't powered up again before later in 295322119Smarius * mmc_go_discovery(). 296322119Smarius */ 297322119Smarius err = mmc_acquire_bus(dev, dev); 298322119Smarius if (err != 0) 299322119Smarius return (err); 300185721Smav mmc_power_down(sc); 301322119Smarius err = mmc_release_bus(dev, dev); 302322119Smarius return (err); 303185721Smav} 304185721Smav 305185721Smavstatic int 306185721Smavmmc_resume(device_t dev) 307185721Smav{ 308185721Smav struct mmc_softc *sc = device_get_softc(dev); 309185721Smav 310185721Smav mmc_scan(sc); 311185721Smav return (bus_generic_resume(dev)); 312185721Smav} 313185721Smav 314185721Smavstatic int 315163516Simpmmc_acquire_bus(device_t busdev, device_t dev) 316163516Simp{ 317163516Simp struct mmc_softc *sc; 318183704Smav struct mmc_ivars *ivar; 319322119Smarius int err; 320322119Smarius uint16_t rca; 321318494Smarius enum mmc_bus_timing timing; 322163516Simp 323183452Simp err = MMCBR_ACQUIRE_HOST(device_get_parent(busdev), busdev); 324163516Simp if (err) 325163516Simp return (err); 326163516Simp sc = device_get_softc(busdev); 327163516Simp MMC_LOCK(sc); 328163516Simp if (sc->owner) 329236156Smarius panic("mmc: host bridge didn't serialize us."); 330163516Simp sc->owner = dev; 331163516Simp MMC_UNLOCK(sc); 332163516Simp 333163516Simp if (busdev != dev) { 334183453Simp /* 335183453Simp * Keep track of the last rca that we've selected. If 336183453Simp * we're asked to do it again, don't. We never 337183453Simp * unselect unless the bus code itself wants the mmc 338183453Simp * bus, and constantly reselecting causes problems. 339183453Simp */ 340318197Smarius ivar = device_get_ivars(dev); 341318197Smarius rca = ivar->rca; 342163516Simp if (sc->last_rca != rca) { 343318494Smarius if (mmc_select_card(sc, rca) != MMC_ERR_NONE) { 344322119Smarius device_printf(busdev, "Card at relative " 345322119Smarius "address %d failed to select\n", rca); 346318494Smarius return (ENXIO); 347318494Smarius } 348163516Simp sc->last_rca = rca; 349318494Smarius timing = mmcbr_get_timing(busdev); 350322119Smarius /* 351322119Smarius * For eMMC modes, setting/updating bus width and VCCQ 352322119Smarius * only really is necessary if there actually is more 353322119Smarius * than one device on the bus as generally that already 354322119Smarius * had to be done by mmc_calculate_clock() or one of 355322119Smarius * its calees. Moreover, setting the bus width anew 356322119Smarius * can trigger re-tuning (via a CRC error on the next 357322119Smarius * CMD), even if not switching between devices an the 358322119Smarius * previously selected one is still tuned. Obviously, 359322119Smarius * we need to re-tune the host controller if devices 360322119Smarius * are actually switched, though. 361322119Smarius */ 362322119Smarius if (timing >= bus_timing_mmc_ddr52 && 363322119Smarius sc->child_count == 1) 364322119Smarius return (0); 365183704Smav /* Prepare bus width for the new card. */ 366187875Smav if (bootverbose || mmc_debug) { 367183763Smav device_printf(busdev, 368318494Smarius "setting bus width to %d bits %s timing\n", 369183775Simp (ivar->bus_width == bus_width_4) ? 4 : 370318494Smarius (ivar->bus_width == bus_width_8) ? 8 : 1, 371318494Smarius mmc_timing_to_string(timing)); 372183763Smav } 373322119Smarius if (mmc_set_card_bus_width(sc, ivar, timing) != 374322119Smarius MMC_ERR_NONE) { 375322119Smarius device_printf(busdev, "Card at relative " 376322119Smarius "address %d failed to set bus width\n", 377318494Smarius rca); 378318494Smarius return (ENXIO); 379318494Smarius } 380322119Smarius mmcbr_set_bus_width(busdev, ivar->bus_width); 381322119Smarius mmcbr_update_ios(busdev); 382322119Smarius if (mmc_set_vccq(sc, ivar, timing) != MMC_ERR_NONE) { 383322119Smarius device_printf(busdev, "Failed to set VCCQ " 384322119Smarius "for card at relative address %d\n", rca); 385318494Smarius return (ENXIO); 386318494Smarius } 387322119Smarius if (timing >= bus_timing_mmc_hs200 && 388322119Smarius mmc_retune(busdev, dev, true) != 0) { 389322119Smarius device_printf(busdev, "Card at relative " 390322119Smarius "address %d failed to re-tune\n", rca); 391318494Smarius return (ENXIO); 392318494Smarius } 393163516Simp } 394163516Simp } else { 395183453Simp /* 396183453Simp * If there's a card selected, stand down. 397183453Simp */ 398163516Simp if (sc->last_rca != 0) { 399322119Smarius if (mmc_select_card(sc, 0) != MMC_ERR_NONE) 400322119Smarius return (ENXIO); 401163516Simp sc->last_rca = 0; 402163516Simp } 403163516Simp } 404163516Simp 405163516Simp return (0); 406163516Simp} 407163516Simp 408163516Simpstatic int 409163516Simpmmc_release_bus(device_t busdev, device_t dev) 410163516Simp{ 411163516Simp struct mmc_softc *sc; 412163516Simp int err; 413163516Simp 414163516Simp sc = device_get_softc(busdev); 415163516Simp 416163516Simp MMC_LOCK(sc); 417163516Simp if (!sc->owner) 418163516Simp panic("mmc: releasing unowned bus."); 419163516Simp if (sc->owner != dev) 420163516Simp panic("mmc: you don't own the bus. game over."); 421163516Simp MMC_UNLOCK(sc); 422183452Simp err = MMCBR_RELEASE_HOST(device_get_parent(busdev), busdev); 423163516Simp if (err) 424163516Simp return (err); 425163516Simp MMC_LOCK(sc); 426163516Simp sc->owner = NULL; 427163516Simp MMC_UNLOCK(sc); 428163516Simp return (0); 429163516Simp} 430163516Simp 431163516Simpstatic uint32_t 432163516Simpmmc_select_vdd(struct mmc_softc *sc, uint32_t ocr) 433163516Simp{ 434183446Simp 435183467Simp return (ocr & MMC_OCR_VOLTAGE); 436163516Simp} 437163516Simp 438163516Simpstatic int 439163516Simpmmc_highest_voltage(uint32_t ocr) 440163516Simp{ 441163516Simp int i; 442163516Simp 443245755Sgonzo for (i = MMC_OCR_MAX_VOLTAGE_SHIFT; 444245755Sgonzo i >= MMC_OCR_MIN_VOLTAGE_SHIFT; i--) 445163516Simp if (ocr & (1 << i)) 446183467Simp return (i); 447163516Simp return (-1); 448163516Simp} 449163516Simp 450163516Simpstatic void 451163516Simpmmc_wakeup(struct mmc_request *req) 452163516Simp{ 453163516Simp struct mmc_softc *sc; 454163516Simp 455163516Simp sc = (struct mmc_softc *)req->done_data; 456163516Simp MMC_LOCK(sc); 457163516Simp req->flags |= MMC_REQ_DONE; 458185721Smav MMC_UNLOCK(sc); 459163516Simp wakeup(req); 460163516Simp} 461163516Simp 462163516Simpstatic int 463163516Simpmmc_wait_for_req(struct mmc_softc *sc, struct mmc_request *req) 464163516Simp{ 465163516Simp 466163516Simp req->done = mmc_wakeup; 467163516Simp req->done_data = sc; 468322119Smarius if (__predict_false(mmc_debug > 1)) { 469187875Smav device_printf(sc->dev, "REQUEST: CMD%d arg %#x flags %#x", 470187875Smav req->cmd->opcode, req->cmd->arg, req->cmd->flags); 471187875Smav if (req->cmd->data) { 472187875Smav printf(" data %d\n", (int)req->cmd->data->len); 473187875Smav } else 474187875Smav printf("\n"); 475187875Smav } 476163516Simp MMCBR_REQUEST(device_get_parent(sc->dev), sc->dev, req); 477163516Simp MMC_LOCK(sc); 478185721Smav while ((req->flags & MMC_REQ_DONE) == 0) 479185721Smav msleep(req, &sc->sc_mtx, 0, "mmcreq", 0); 480163516Simp MMC_UNLOCK(sc); 481322119Smarius if (__predict_false(mmc_debug > 2 || (mmc_debug > 0 && 482322119Smarius req->cmd->error != MMC_ERR_NONE))) 483312399Smarius device_printf(sc->dev, "CMD%d RESULT: %d\n", 484254431Sian req->cmd->opcode, req->cmd->error); 485185721Smav return (0); 486163516Simp} 487163516Simp 488163516Simpstatic int 489322119Smariusmmc_wait_for_request(device_t busdev, device_t dev, struct mmc_request *req) 490163516Simp{ 491322119Smarius struct mmc_softc *sc; 492322119Smarius struct mmc_ivars *ivar; 493322119Smarius int err, i; 494322119Smarius enum mmc_retune_req retune_req; 495163516Simp 496322119Smarius sc = device_get_softc(busdev); 497322119Smarius KASSERT(sc->owner != NULL, 498322119Smarius ("%s: Request from %s without bus being acquired.", __func__, 499322119Smarius device_get_nameunit(dev))); 500322119Smarius 501322119Smarius /* 502322119Smarius * Unless no device is selected or re-tuning is already ongoing, 503322119Smarius * execute re-tuning if a) the bridge is requesting to do so and 504322119Smarius * re-tuning hasn't been otherwise paused, or b) if a child asked 505322119Smarius * to be re-tuned prior to pausing (see also mmc_retune_pause()). 506322119Smarius */ 507322119Smarius if (__predict_false(sc->last_rca != 0 && sc->retune_ongoing == 0 && 508322119Smarius (((retune_req = mmcbr_get_retune_req(busdev)) != retune_req_none && 509322119Smarius sc->retune_paused == 0) || sc->retune_needed == 1))) { 510322119Smarius if (__predict_false(mmc_debug > 1)) { 511322119Smarius device_printf(busdev, 512322119Smarius "Re-tuning with%s circuit reset required\n", 513322119Smarius retune_req == retune_req_reset ? "" : "out"); 514322119Smarius } 515322119Smarius if (device_get_parent(dev) == busdev) 516322119Smarius ivar = device_get_ivars(dev); 517322119Smarius else { 518322119Smarius for (i = 0; i < sc->child_count; i++) { 519322119Smarius ivar = device_get_ivars(sc->child_list[i]); 520322119Smarius if (ivar->rca == sc->last_rca) 521322119Smarius break; 522322119Smarius } 523322119Smarius if (ivar->rca != sc->last_rca) 524322119Smarius return (EINVAL); 525322119Smarius } 526322119Smarius sc->retune_ongoing = 1; 527322119Smarius err = mmc_retune(busdev, dev, retune_req == retune_req_reset); 528322119Smarius sc->retune_ongoing = 0; 529322119Smarius switch (err) { 530322119Smarius case MMC_ERR_NONE: 531322119Smarius case MMC_ERR_FAILED: /* Re-tune error but still might work */ 532322119Smarius break; 533322119Smarius case MMC_ERR_BADCRC: /* Switch failure on HS400 recovery */ 534322119Smarius return (ENXIO); 535322119Smarius case MMC_ERR_INVALID: /* Driver implementation b0rken */ 536322119Smarius default: /* Unknown error, should not happen */ 537322119Smarius return (EINVAL); 538322119Smarius } 539322119Smarius sc->retune_needed = 0; 540322119Smarius } 541183467Simp return (mmc_wait_for_req(sc, req)); 542163516Simp} 543163516Simp 544163516Simpstatic int 545163516Simpmmc_wait_for_command(struct mmc_softc *sc, uint32_t opcode, 546163516Simp uint32_t arg, uint32_t flags, uint32_t *resp, int retries) 547163516Simp{ 548163516Simp struct mmc_command cmd; 549163516Simp int err; 550163516Simp 551163516Simp memset(&cmd, 0, sizeof(cmd)); 552163516Simp cmd.opcode = opcode; 553163516Simp cmd.arg = arg; 554163516Simp cmd.flags = flags; 555183470Simp cmd.data = NULL; 556318197Smarius err = mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, retries); 557163516Simp if (err) 558163516Simp return (err); 559163516Simp if (resp) { 560163516Simp if (flags & MMC_RSP_136) 561163516Simp memcpy(resp, cmd.resp, 4 * sizeof(uint32_t)); 562163516Simp else 563163516Simp *resp = cmd.resp[0]; 564163516Simp } 565163516Simp return (0); 566163516Simp} 567163516Simp 568163516Simpstatic void 569163516Simpmmc_idle_cards(struct mmc_softc *sc) 570163516Simp{ 571163516Simp device_t dev; 572163516Simp struct mmc_command cmd; 573312399Smarius 574163516Simp dev = sc->dev; 575163516Simp mmcbr_set_chip_select(dev, cs_high); 576163516Simp mmcbr_update_ios(dev); 577163516Simp mmc_ms_delay(1); 578163516Simp 579163516Simp memset(&cmd, 0, sizeof(cmd)); 580163516Simp cmd.opcode = MMC_GO_IDLE_STATE; 581163516Simp cmd.arg = 0; 582163516Simp cmd.flags = MMC_RSP_NONE | MMC_CMD_BC; 583183470Simp cmd.data = NULL; 584318197Smarius mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, CMD_RETRIES); 585163516Simp mmc_ms_delay(1); 586163516Simp 587163516Simp mmcbr_set_chip_select(dev, cs_dontcare); 588163516Simp mmcbr_update_ios(dev); 589163516Simp mmc_ms_delay(1); 590163516Simp} 591163516Simp 592163516Simpstatic int 593163516Simpmmc_send_app_op_cond(struct mmc_softc *sc, uint32_t ocr, uint32_t *rocr) 594163516Simp{ 595163516Simp struct mmc_command cmd; 596163516Simp int err = MMC_ERR_NONE, i; 597163516Simp 598163516Simp memset(&cmd, 0, sizeof(cmd)); 599163516Simp cmd.opcode = ACMD_SD_SEND_OP_COND; 600163516Simp cmd.arg = ocr; 601163516Simp cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR; 602183470Simp cmd.data = NULL; 603163516Simp 604216941Spjd for (i = 0; i < 1000; i++) { 605318197Smarius err = mmc_wait_for_app_cmd(sc->dev, sc->dev, 0, &cmd, 606318197Smarius CMD_RETRIES); 607163516Simp if (err != MMC_ERR_NONE) 608163516Simp break; 609183709Smav if ((cmd.resp[0] & MMC_OCR_CARD_BUSY) || 610183709Smav (ocr & MMC_OCR_VOLTAGE) == 0) 611163516Simp break; 612163516Simp err = MMC_ERR_TIMEOUT; 613163516Simp mmc_ms_delay(10); 614163516Simp } 615163516Simp if (rocr && err == MMC_ERR_NONE) 616163516Simp *rocr = cmd.resp[0]; 617183467Simp return (err); 618163516Simp} 619163516Simp 620163516Simpstatic int 621163516Simpmmc_send_op_cond(struct mmc_softc *sc, uint32_t ocr, uint32_t *rocr) 622163516Simp{ 623163516Simp struct mmc_command cmd; 624163516Simp int err = MMC_ERR_NONE, i; 625163516Simp 626163516Simp memset(&cmd, 0, sizeof(cmd)); 627163516Simp cmd.opcode = MMC_SEND_OP_COND; 628163516Simp cmd.arg = ocr; 629163516Simp cmd.flags = MMC_RSP_R3 | MMC_CMD_BCR; 630183470Simp cmd.data = NULL; 631163516Simp 632216941Spjd for (i = 0; i < 1000; i++) { 633318197Smarius err = mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, CMD_RETRIES); 634163516Simp if (err != MMC_ERR_NONE) 635163516Simp break; 636183709Smav if ((cmd.resp[0] & MMC_OCR_CARD_BUSY) || 637183709Smav (ocr & MMC_OCR_VOLTAGE) == 0) 638163516Simp break; 639163516Simp err = MMC_ERR_TIMEOUT; 640163516Simp mmc_ms_delay(10); 641163516Simp } 642163516Simp if (rocr && err == MMC_ERR_NONE) 643163516Simp *rocr = cmd.resp[0]; 644183467Simp return (err); 645163516Simp} 646163516Simp 647183704Smavstatic int 648183704Smavmmc_send_if_cond(struct mmc_softc *sc, uint8_t vhs) 649183704Smav{ 650183704Smav struct mmc_command cmd; 651183704Smav int err; 652183704Smav 653183704Smav memset(&cmd, 0, sizeof(cmd)); 654183704Smav cmd.opcode = SD_SEND_IF_COND; 655183704Smav cmd.arg = (vhs << 8) + 0xAA; 656183704Smav cmd.flags = MMC_RSP_R7 | MMC_CMD_BCR; 657183704Smav cmd.data = NULL; 658183704Smav 659318197Smarius err = mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, CMD_RETRIES); 660183704Smav return (err); 661183704Smav} 662183704Smav 663163516Simpstatic void 664163516Simpmmc_power_up(struct mmc_softc *sc) 665163516Simp{ 666163516Simp device_t dev; 667318494Smarius enum mmc_vccq vccq; 668163516Simp 669163516Simp dev = sc->dev; 670163516Simp mmcbr_set_vdd(dev, mmc_highest_voltage(mmcbr_get_host_ocr(dev))); 671163516Simp mmcbr_set_bus_mode(dev, opendrain); 672163516Simp mmcbr_set_chip_select(dev, cs_dontcare); 673163516Simp mmcbr_set_bus_width(dev, bus_width_1); 674163516Simp mmcbr_set_power_mode(dev, power_up); 675163516Simp mmcbr_set_clock(dev, 0); 676163516Simp mmcbr_update_ios(dev); 677318494Smarius for (vccq = vccq_330; ; vccq--) { 678318494Smarius mmcbr_set_vccq(dev, vccq); 679318494Smarius if (mmcbr_switch_vccq(dev) == 0 || vccq == vccq_120) 680318494Smarius break; 681318494Smarius } 682163516Simp mmc_ms_delay(1); 683163516Simp 684318494Smarius mmcbr_set_clock(dev, SD_MMC_CARD_ID_FREQUENCY); 685183704Smav mmcbr_set_timing(dev, bus_timing_normal); 686163516Simp mmcbr_set_power_mode(dev, power_on); 687163516Simp mmcbr_update_ios(dev); 688163516Simp mmc_ms_delay(2); 689163516Simp} 690163516Simp 691183449Simpstatic void 692183449Simpmmc_power_down(struct mmc_softc *sc) 693183449Simp{ 694183449Simp device_t dev = sc->dev; 695183449Simp 696183449Simp mmcbr_set_bus_mode(dev, opendrain); 697183449Simp mmcbr_set_chip_select(dev, cs_dontcare); 698183449Simp mmcbr_set_bus_width(dev, bus_width_1); 699183449Simp mmcbr_set_power_mode(dev, power_off); 700183449Simp mmcbr_set_clock(dev, 0); 701183704Smav mmcbr_set_timing(dev, bus_timing_normal); 702183449Simp mmcbr_update_ios(dev); 703183449Simp} 704183449Simp 705183704Smavstatic int 706183704Smavmmc_select_card(struct mmc_softc *sc, uint16_t rca) 707183704Smav{ 708322119Smarius int err, flags; 709183775Simp 710183775Simp flags = (rca ? MMC_RSP_R1B : MMC_RSP_NONE) | MMC_CMD_AC; 711322119Smarius sc->retune_paused++; 712322119Smarius err = mmc_wait_for_command(sc, MMC_SELECT_CARD, (uint32_t)rca << 16, 713322119Smarius flags, NULL, CMD_RETRIES); 714322119Smarius sc->retune_paused--; 715322119Smarius return (err); 716183704Smav} 717183704Smav 718183704Smavstatic int 719188044Simpmmc_sd_switch(struct mmc_softc *sc, uint8_t mode, uint8_t grp, uint8_t value, 720188044Simp uint8_t *res) 721183704Smav{ 722183704Smav int err; 723183704Smav struct mmc_command cmd; 724183704Smav struct mmc_data data; 725183704Smav 726254432Sian memset(&cmd, 0, sizeof(cmd)); 727254432Sian memset(&data, 0, sizeof(data)); 728188044Simp memset(res, 0, 64); 729183704Smav 730183704Smav cmd.opcode = SD_SWITCH_FUNC; 731183704Smav cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC; 732188044Simp cmd.arg = mode << 31; /* 0 - check, 1 - set */ 733183704Smav cmd.arg |= 0x00FFFFFF; 734183705Smav cmd.arg &= ~(0xF << (grp * 4)); 735183705Smav cmd.arg |= value << (grp * 4); 736183704Smav cmd.data = &data; 737183704Smav 738183704Smav data.data = res; 739183704Smav data.len = 64; 740183704Smav data.flags = MMC_DATA_READ; 741183704Smav 742318197Smarius err = mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, CMD_RETRIES); 743183704Smav return (err); 744183704Smav} 745183704Smav 746183704Smavstatic int 747322119Smariusmmc_set_card_bus_width(struct mmc_softc *sc, struct mmc_ivars *ivar, 748322119Smarius enum mmc_bus_timing timing) 749183704Smav{ 750187546Simp struct mmc_command cmd; 751183704Smav int err; 752187546Simp uint8_t value; 753183704Smav 754183704Smav if (mmcbr_get_mode(sc->dev) == mode_sd) { 755254432Sian memset(&cmd, 0, sizeof(cmd)); 756234524Smarius cmd.opcode = ACMD_SET_CLR_CARD_DETECT; 757234524Smarius cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 758234524Smarius cmd.arg = SD_CLR_CARD_DETECT; 759318197Smarius err = mmc_wait_for_app_cmd(sc->dev, sc->dev, ivar->rca, &cmd, 760318197Smarius CMD_RETRIES); 761234524Smarius if (err != 0) 762234524Smarius return (err); 763254432Sian memset(&cmd, 0, sizeof(cmd)); 764183704Smav cmd.opcode = ACMD_SET_BUS_WIDTH; 765183704Smav cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 766318197Smarius switch (ivar->bus_width) { 767183704Smav case bus_width_1: 768183704Smav cmd.arg = SD_BUS_WIDTH_1; 769183704Smav break; 770183704Smav case bus_width_4: 771183704Smav cmd.arg = SD_BUS_WIDTH_4; 772183704Smav break; 773183704Smav default: 774183704Smav return (MMC_ERR_INVALID); 775183704Smav } 776318197Smarius err = mmc_wait_for_app_cmd(sc->dev, sc->dev, ivar->rca, &cmd, 777318197Smarius CMD_RETRIES); 778183704Smav } else { 779318197Smarius switch (ivar->bus_width) { 780183704Smav case bus_width_1: 781322119Smarius if (timing == bus_timing_mmc_hs400 || 782322119Smarius timing == bus_timing_mmc_hs400es) 783322119Smarius return (MMC_ERR_INVALID); 784183704Smav value = EXT_CSD_BUS_WIDTH_1; 785183704Smav break; 786183704Smav case bus_width_4: 787322119Smarius switch (timing) { 788318494Smarius case bus_timing_mmc_ddr52: 789322119Smarius value = EXT_CSD_BUS_WIDTH_4_DDR; 790322119Smarius break; 791318494Smarius case bus_timing_mmc_hs400: 792318494Smarius case bus_timing_mmc_hs400es: 793322119Smarius return (MMC_ERR_INVALID); 794318494Smarius default: 795318494Smarius value = EXT_CSD_BUS_WIDTH_4; 796318494Smarius break; 797318494Smarius } 798183704Smav break; 799183704Smav case bus_width_8: 800322119Smarius value = 0; 801322119Smarius switch (timing) { 802322119Smarius case bus_timing_mmc_hs400es: 803322119Smarius value = EXT_CSD_BUS_WIDTH_ES; 804322119Smarius /* FALLTHROUGH */ 805318494Smarius case bus_timing_mmc_ddr52: 806318494Smarius case bus_timing_mmc_hs400: 807322119Smarius value |= EXT_CSD_BUS_WIDTH_8_DDR; 808318494Smarius break; 809318494Smarius default: 810318494Smarius value = EXT_CSD_BUS_WIDTH_8; 811318494Smarius break; 812318494Smarius } 813183704Smav break; 814183704Smav default: 815183704Smav return (MMC_ERR_INVALID); 816183704Smav } 817318197Smarius err = mmc_switch(sc->dev, sc->dev, ivar->rca, 818318197Smarius EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH, value, 819318197Smarius ivar->cmd6_time, true); 820183704Smav } 821183704Smav return (err); 822183704Smav} 823183704Smav 824183704Smavstatic int 825318494Smariusmmc_set_power_class(struct mmc_softc *sc, struct mmc_ivars *ivar) 826183704Smav{ 827318494Smarius device_t dev; 828318494Smarius const uint8_t *ext_csd; 829318494Smarius uint32_t clock; 830318494Smarius uint8_t value; 831340740Smarius enum mmc_bus_timing timing; 832340740Smarius enum mmc_bus_width bus_width; 833183704Smav 834318494Smarius dev = sc->dev; 835340740Smarius timing = mmcbr_get_timing(dev); 836340740Smarius bus_width = ivar->bus_width; 837340740Smarius if (mmcbr_get_mode(dev) != mode_mmc || ivar->csd.spec_vers < 4 || 838340740Smarius timing == bus_timing_normal || bus_width == bus_width_1) 839318494Smarius return (MMC_ERR_NONE); 840318494Smarius 841318494Smarius value = 0; 842318494Smarius ext_csd = ivar->raw_ext_csd; 843318494Smarius clock = mmcbr_get_clock(dev); 844318494Smarius switch (1 << mmcbr_get_vdd(dev)) { 845318494Smarius case MMC_OCR_LOW_VOLTAGE: 846318494Smarius if (clock <= MMC_TYPE_HS_26_MAX) 847318494Smarius value = ext_csd[EXT_CSD_PWR_CL_26_195]; 848318494Smarius else if (clock <= MMC_TYPE_HS_52_MAX) { 849340740Smarius if (timing >= bus_timing_mmc_ddr52 && 850340740Smarius bus_width >= bus_width_4) 851318494Smarius value = ext_csd[EXT_CSD_PWR_CL_52_195_DDR]; 852318494Smarius else 853318494Smarius value = ext_csd[EXT_CSD_PWR_CL_52_195]; 854318494Smarius } else if (clock <= MMC_TYPE_HS200_HS400ES_MAX) 855318494Smarius value = ext_csd[EXT_CSD_PWR_CL_200_195]; 856183704Smav break; 857318494Smarius case MMC_OCR_270_280: 858318494Smarius case MMC_OCR_280_290: 859318494Smarius case MMC_OCR_290_300: 860318494Smarius case MMC_OCR_300_310: 861318494Smarius case MMC_OCR_310_320: 862318494Smarius case MMC_OCR_320_330: 863318494Smarius case MMC_OCR_330_340: 864318494Smarius case MMC_OCR_340_350: 865318494Smarius case MMC_OCR_350_360: 866318494Smarius if (clock <= MMC_TYPE_HS_26_MAX) 867318494Smarius value = ext_csd[EXT_CSD_PWR_CL_26_360]; 868318494Smarius else if (clock <= MMC_TYPE_HS_52_MAX) { 869340740Smarius if (timing == bus_timing_mmc_ddr52 && 870340740Smarius bus_width >= bus_width_4) 871318494Smarius value = ext_csd[EXT_CSD_PWR_CL_52_360_DDR]; 872318494Smarius else 873318494Smarius value = ext_csd[EXT_CSD_PWR_CL_52_360]; 874318494Smarius } else if (clock <= MMC_TYPE_HS200_HS400ES_MAX) { 875340740Smarius if (bus_width == bus_width_8) 876318494Smarius value = ext_csd[EXT_CSD_PWR_CL_200_360_DDR]; 877318494Smarius else 878318494Smarius value = ext_csd[EXT_CSD_PWR_CL_200_360]; 879318494Smarius } 880183704Smav break; 881183704Smav default: 882318494Smarius device_printf(dev, "No power class support for VDD 0x%x\n", 883318494Smarius 1 << mmcbr_get_vdd(dev)); 884183704Smav return (MMC_ERR_INVALID); 885183704Smav } 886318494Smarius 887340740Smarius if (bus_width == bus_width_8) 888318494Smarius value = (value & EXT_CSD_POWER_CLASS_8BIT_MASK) >> 889318494Smarius EXT_CSD_POWER_CLASS_8BIT_SHIFT; 890318494Smarius else 891318494Smarius value = (value & EXT_CSD_POWER_CLASS_4BIT_MASK) >> 892318494Smarius EXT_CSD_POWER_CLASS_4BIT_SHIFT; 893318494Smarius 894318494Smarius if (value == 0) 895318494Smarius return (MMC_ERR_NONE); 896318494Smarius 897318494Smarius return (mmc_switch(dev, dev, ivar->rca, EXT_CSD_CMD_SET_NORMAL, 898318494Smarius EXT_CSD_POWER_CLASS, value, ivar->cmd6_time, true)); 899318494Smarius} 900318494Smarius 901318494Smariusstatic int 902318494Smariusmmc_set_timing(struct mmc_softc *sc, struct mmc_ivars *ivar, 903318494Smarius enum mmc_bus_timing timing) 904318494Smarius{ 905318494Smarius u_char switch_res[64]; 906318494Smarius uint8_t value; 907318494Smarius int err; 908318494Smarius 909318197Smarius if (mmcbr_get_mode(sc->dev) == mode_sd) { 910318494Smarius switch (timing) { 911318494Smarius case bus_timing_normal: 912318494Smarius value = SD_SWITCH_NORMAL_MODE; 913318494Smarius break; 914318494Smarius case bus_timing_hs: 915318494Smarius value = SD_SWITCH_HS_MODE; 916318494Smarius break; 917318494Smarius default: 918318494Smarius return (MMC_ERR_INVALID); 919318494Smarius } 920188044Simp err = mmc_sd_switch(sc, SD_SWITCH_MODE_SET, SD_SWITCH_GROUP1, 921188044Simp value, switch_res); 922318197Smarius if (err != MMC_ERR_NONE) 923318197Smarius return (err); 924318197Smarius if ((switch_res[16] & 0xf) != value) 925318197Smarius return (MMC_ERR_FAILED); 926318197Smarius mmcbr_set_timing(sc->dev, timing); 927318197Smarius mmcbr_update_ios(sc->dev); 928318197Smarius } else { 929318494Smarius switch (timing) { 930318494Smarius case bus_timing_normal: 931318494Smarius value = EXT_CSD_HS_TIMING_BC; 932318494Smarius break; 933318494Smarius case bus_timing_hs: 934318494Smarius case bus_timing_mmc_ddr52: 935318494Smarius value = EXT_CSD_HS_TIMING_HS; 936318494Smarius break; 937322119Smarius case bus_timing_mmc_hs200: 938322119Smarius value = EXT_CSD_HS_TIMING_HS200; 939322119Smarius break; 940322119Smarius case bus_timing_mmc_hs400: 941322119Smarius case bus_timing_mmc_hs400es: 942322119Smarius value = EXT_CSD_HS_TIMING_HS400; 943322119Smarius break; 944318494Smarius default: 945318494Smarius return (MMC_ERR_INVALID); 946318494Smarius } 947318197Smarius err = mmc_switch(sc->dev, sc->dev, ivar->rca, 948318197Smarius EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING, value, 949318197Smarius ivar->cmd6_time, false); 950318197Smarius if (err != MMC_ERR_NONE) 951318197Smarius return (err); 952318197Smarius mmcbr_set_timing(sc->dev, timing); 953318197Smarius mmcbr_update_ios(sc->dev); 954318197Smarius err = mmc_switch_status(sc->dev, sc->dev, ivar->rca, 955318197Smarius ivar->cmd6_time); 956318197Smarius } 957183704Smav return (err); 958183704Smav} 959183704Smav 960322119Smariusstatic int 961322119Smariusmmc_set_vccq(struct mmc_softc *sc, struct mmc_ivars *ivar, 962322119Smarius enum mmc_bus_timing timing) 963322119Smarius{ 964322119Smarius 965322119Smarius if (isset(&ivar->vccq_120, timing)) 966322119Smarius mmcbr_set_vccq(sc->dev, vccq_120); 967322119Smarius else if (isset(&ivar->vccq_180, timing)) 968322119Smarius mmcbr_set_vccq(sc->dev, vccq_180); 969322119Smarius else 970322119Smarius mmcbr_set_vccq(sc->dev, vccq_330); 971322119Smarius if (mmcbr_switch_vccq(sc->dev) != 0) 972322119Smarius return (MMC_ERR_INVALID); 973322119Smarius else 974322119Smarius return (MMC_ERR_NONE); 975322119Smarius} 976322119Smarius 977318197Smariusstatic const uint8_t p8[8] = { 978318197Smarius 0x55, 0xAA, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 979318197Smarius}; 980318197Smarius 981318197Smariusstatic const uint8_t p8ok[8] = { 982318197Smarius 0xAA, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 983318197Smarius}; 984318197Smarius 985318197Smariusstatic const uint8_t p4[4] = { 986318197Smarius 0x5A, 0x00, 0x00, 0x00 987318197Smarius}; 988318197Smarius 989318197Smariusstatic const uint8_t p4ok[4] = { 990318197Smarius 0xA5, 0x00, 0x00, 0x00 991318197Smarius}; 992318197Smarius 993183704Smavstatic int 994183704Smavmmc_test_bus_width(struct mmc_softc *sc) 995183704Smav{ 996183704Smav struct mmc_command cmd; 997183704Smav struct mmc_data data; 998318197Smarius uint8_t buf[8]; 999183704Smav int err; 1000183704Smav 1001183704Smav if (mmcbr_get_caps(sc->dev) & MMC_CAP_8_BIT_DATA) { 1002183704Smav mmcbr_set_bus_width(sc->dev, bus_width_8); 1003183704Smav mmcbr_update_ios(sc->dev); 1004183704Smav 1005275951Sian sc->squelched++; /* Errors are expected, squelch reporting. */ 1006254432Sian memset(&cmd, 0, sizeof(cmd)); 1007254432Sian memset(&data, 0, sizeof(data)); 1008183704Smav cmd.opcode = MMC_BUSTEST_W; 1009183704Smav cmd.arg = 0; 1010183704Smav cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC; 1011183704Smav cmd.data = &data; 1012183704Smav 1013318197Smarius data.data = __DECONST(void *, p8); 1014183704Smav data.len = 8; 1015183704Smav data.flags = MMC_DATA_WRITE; 1016318197Smarius mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, 0); 1017312399Smarius 1018254432Sian memset(&cmd, 0, sizeof(cmd)); 1019254432Sian memset(&data, 0, sizeof(data)); 1020183704Smav cmd.opcode = MMC_BUSTEST_R; 1021183704Smav cmd.arg = 0; 1022183704Smav cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC; 1023183704Smav cmd.data = &data; 1024183704Smav 1025183704Smav data.data = buf; 1026183704Smav data.len = 8; 1027183704Smav data.flags = MMC_DATA_READ; 1028318197Smarius err = mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, 0); 1029275951Sian sc->squelched--; 1030312399Smarius 1031183704Smav mmcbr_set_bus_width(sc->dev, bus_width_1); 1032183704Smav mmcbr_update_ios(sc->dev); 1033183704Smav 1034183704Smav if (err == MMC_ERR_NONE && memcmp(buf, p8ok, 8) == 0) 1035183704Smav return (bus_width_8); 1036183704Smav } 1037183704Smav 1038183704Smav if (mmcbr_get_caps(sc->dev) & MMC_CAP_4_BIT_DATA) { 1039183704Smav mmcbr_set_bus_width(sc->dev, bus_width_4); 1040183704Smav mmcbr_update_ios(sc->dev); 1041183704Smav 1042275951Sian sc->squelched++; /* Errors are expected, squelch reporting. */ 1043254432Sian memset(&cmd, 0, sizeof(cmd)); 1044254432Sian memset(&data, 0, sizeof(data)); 1045183704Smav cmd.opcode = MMC_BUSTEST_W; 1046183704Smav cmd.arg = 0; 1047183704Smav cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC; 1048183704Smav cmd.data = &data; 1049183704Smav 1050318197Smarius data.data = __DECONST(void *, p4); 1051183704Smav data.len = 4; 1052183704Smav data.flags = MMC_DATA_WRITE; 1053318197Smarius mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, 0); 1054312399Smarius 1055254432Sian memset(&cmd, 0, sizeof(cmd)); 1056254432Sian memset(&data, 0, sizeof(data)); 1057183704Smav cmd.opcode = MMC_BUSTEST_R; 1058183704Smav cmd.arg = 0; 1059183704Smav cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC; 1060183704Smav cmd.data = &data; 1061183704Smav 1062183704Smav data.data = buf; 1063183704Smav data.len = 4; 1064183704Smav data.flags = MMC_DATA_READ; 1065318197Smarius err = mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, 0); 1066275951Sian sc->squelched--; 1067183704Smav 1068183704Smav mmcbr_set_bus_width(sc->dev, bus_width_1); 1069183704Smav mmcbr_update_ios(sc->dev); 1070183704Smav 1071183704Smav if (err == MMC_ERR_NONE && memcmp(buf, p4ok, 4) == 0) 1072183704Smav return (bus_width_4); 1073183704Smav } 1074183704Smav return (bus_width_1); 1075183704Smav} 1076183704Smav 1077163516Simpstatic uint32_t 1078184033Smavmmc_get_bits(uint32_t *bits, int bit_len, int start, int size) 1079163516Simp{ 1080183729Simp const int i = (bit_len / 32) - (start / 32) - 1; 1081163516Simp const int shift = start & 31; 1082163516Simp uint32_t retval = bits[i] >> shift; 1083318197Smarius 1084163516Simp if (size + shift > 32) 1085163516Simp retval |= bits[i - 1] << (32 - shift); 1086217509Smav return (retval & ((1llu << size) - 1)); 1087163516Simp} 1088163516Simp 1089163516Simpstatic void 1090183729Simpmmc_decode_cid_sd(uint32_t *raw_cid, struct mmc_cid *cid) 1091163516Simp{ 1092163516Simp int i; 1093163516Simp 1094183729Simp /* There's no version info, so we take it on faith */ 1095163516Simp memset(cid, 0, sizeof(*cid)); 1096184033Smav cid->mid = mmc_get_bits(raw_cid, 128, 120, 8); 1097184033Smav cid->oid = mmc_get_bits(raw_cid, 128, 104, 16); 1098183729Simp for (i = 0; i < 5; i++) 1099184033Smav cid->pnm[i] = mmc_get_bits(raw_cid, 128, 96 - i * 8, 8); 1100187875Smav cid->pnm[5] = 0; 1101184033Smav cid->prv = mmc_get_bits(raw_cid, 128, 56, 8); 1102184033Smav cid->psn = mmc_get_bits(raw_cid, 128, 24, 32); 1103187875Smav cid->mdt_year = mmc_get_bits(raw_cid, 128, 12, 8) + 2000; 1104184033Smav cid->mdt_month = mmc_get_bits(raw_cid, 128, 8, 4); 1105163516Simp} 1106163516Simp 1107183729Simpstatic void 1108318197Smariusmmc_decode_cid_mmc(uint32_t *raw_cid, struct mmc_cid *cid, bool is_4_41p) 1109183729Simp{ 1110183729Simp int i; 1111183729Simp 1112183729Simp /* There's no version info, so we take it on faith */ 1113183729Simp memset(cid, 0, sizeof(*cid)); 1114184033Smav cid->mid = mmc_get_bits(raw_cid, 128, 120, 8); 1115184033Smav cid->oid = mmc_get_bits(raw_cid, 128, 104, 8); 1116183729Simp for (i = 0; i < 6; i++) 1117184033Smav cid->pnm[i] = mmc_get_bits(raw_cid, 128, 96 - i * 8, 8); 1118187875Smav cid->pnm[6] = 0; 1119184033Smav cid->prv = mmc_get_bits(raw_cid, 128, 48, 8); 1120184033Smav cid->psn = mmc_get_bits(raw_cid, 128, 16, 32); 1121184033Smav cid->mdt_month = mmc_get_bits(raw_cid, 128, 12, 4); 1122318197Smarius cid->mdt_year = mmc_get_bits(raw_cid, 128, 8, 4); 1123318197Smarius if (is_4_41p) 1124318197Smarius cid->mdt_year += 2013; 1125318197Smarius else 1126318197Smarius cid->mdt_year += 1997; 1127183729Simp} 1128183729Simp 1129234524Smariusstatic void 1130234524Smariusmmc_format_card_id_string(struct mmc_ivars *ivar) 1131234524Smarius{ 1132234524Smarius char oidstr[8]; 1133234524Smarius uint8_t c1; 1134234524Smarius uint8_t c2; 1135234524Smarius 1136234524Smarius /* 1137234524Smarius * Format a card ID string for use by the mmcsd driver, it's what 1138234524Smarius * appears between the <> in the following: 1139322388Smarius * mmcsd0: 968MB <SD SD01G 8.0 SN 2686905 MFG 08/2008 by 3 TN> at mmc0 1140234524Smarius * 22.5MHz/4bit/128-block 1141234524Smarius * 1142269341Sian * Also format just the card serial number, which the mmcsd driver will 1143269341Sian * use as the disk->d_ident string. 1144269341Sian * 1145234524Smarius * The card_id_string in mmc_ivars is currently allocated as 64 bytes, 1146234524Smarius * and our max formatted length is currently 55 bytes if every field 1147234524Smarius * contains the largest value. 1148234524Smarius * 1149234524Smarius * Sometimes the oid is two printable ascii chars; when it's not, 1150234524Smarius * format it as 0xnnnn instead. 1151234524Smarius */ 1152234524Smarius c1 = (ivar->cid.oid >> 8) & 0x0ff; 1153234524Smarius c2 = ivar->cid.oid & 0x0ff; 1154234524Smarius if (c1 > 0x1f && c1 < 0x7f && c2 > 0x1f && c2 < 0x7f) 1155234524Smarius snprintf(oidstr, sizeof(oidstr), "%c%c", c1, c2); 1156234524Smarius else 1157234524Smarius snprintf(oidstr, sizeof(oidstr), "0x%04x", ivar->cid.oid); 1158269341Sian snprintf(ivar->card_sn_string, sizeof(ivar->card_sn_string), 1159269341Sian "%08X", ivar->cid.psn); 1160234524Smarius snprintf(ivar->card_id_string, sizeof(ivar->card_id_string), 1161269341Sian "%s%s %s %d.%d SN %08X MFG %02d/%04d by %d %s", 1162234524Smarius ivar->mode == mode_sd ? "SD" : "MMC", ivar->high_cap ? "HC" : "", 1163234524Smarius ivar->cid.pnm, ivar->cid.prv >> 4, ivar->cid.prv & 0x0f, 1164234524Smarius ivar->cid.psn, ivar->cid.mdt_month, ivar->cid.mdt_year, 1165234524Smarius ivar->cid.mid, oidstr); 1166234524Smarius} 1167234524Smarius 1168163516Simpstatic const int exp[8] = { 1169163516Simp 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000 1170163516Simp}; 1171234524Smarius 1172163516Simpstatic const int mant[16] = { 1173234524Smarius 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80 1174163516Simp}; 1175234524Smarius 1176163516Simpstatic const int cur_min[8] = { 1177163516Simp 500, 1000, 5000, 10000, 25000, 35000, 60000, 100000 1178163516Simp}; 1179234524Smarius 1180163516Simpstatic const int cur_max[8] = { 1181163516Simp 1000, 5000, 10000, 25000, 35000, 45000, 800000, 200000 1182163516Simp}; 1183163516Simp 1184322119Smariusstatic int 1185183729Simpmmc_decode_csd_sd(uint32_t *raw_csd, struct mmc_csd *csd) 1186163516Simp{ 1187163516Simp int v; 1188163516Simp int m; 1189163516Simp int e; 1190163516Simp 1191163516Simp memset(csd, 0, sizeof(*csd)); 1192184033Smav csd->csd_structure = v = mmc_get_bits(raw_csd, 128, 126, 2); 1193183729Simp if (v == 0) { 1194184033Smav m = mmc_get_bits(raw_csd, 128, 115, 4); 1195184033Smav e = mmc_get_bits(raw_csd, 128, 112, 3); 1196236156Smarius csd->tacc = (exp[e] * mant[m] + 9) / 10; 1197184033Smav csd->nsac = mmc_get_bits(raw_csd, 128, 104, 8) * 100; 1198184033Smav m = mmc_get_bits(raw_csd, 128, 99, 4); 1199184033Smav e = mmc_get_bits(raw_csd, 128, 96, 3); 1200183704Smav csd->tran_speed = exp[e] * 10000 * mant[m]; 1201184033Smav csd->ccc = mmc_get_bits(raw_csd, 128, 84, 12); 1202184033Smav csd->read_bl_len = 1 << mmc_get_bits(raw_csd, 128, 80, 4); 1203184033Smav csd->read_bl_partial = mmc_get_bits(raw_csd, 128, 79, 1); 1204184033Smav csd->write_blk_misalign = mmc_get_bits(raw_csd, 128, 78, 1); 1205184033Smav csd->read_blk_misalign = mmc_get_bits(raw_csd, 128, 77, 1); 1206184033Smav csd->dsr_imp = mmc_get_bits(raw_csd, 128, 76, 1); 1207318197Smarius csd->vdd_r_curr_min = 1208318197Smarius cur_min[mmc_get_bits(raw_csd, 128, 59, 3)]; 1209318197Smarius csd->vdd_r_curr_max = 1210318197Smarius cur_max[mmc_get_bits(raw_csd, 128, 56, 3)]; 1211318197Smarius csd->vdd_w_curr_min = 1212318197Smarius cur_min[mmc_get_bits(raw_csd, 128, 53, 3)]; 1213318197Smarius csd->vdd_w_curr_max = 1214318197Smarius cur_max[mmc_get_bits(raw_csd, 128, 50, 3)]; 1215184033Smav m = mmc_get_bits(raw_csd, 128, 62, 12); 1216184033Smav e = mmc_get_bits(raw_csd, 128, 47, 3); 1217183704Smav csd->capacity = ((1 + m) << (e + 2)) * csd->read_bl_len; 1218184033Smav csd->erase_blk_en = mmc_get_bits(raw_csd, 128, 46, 1); 1219184033Smav csd->erase_sector = mmc_get_bits(raw_csd, 128, 39, 7) + 1; 1220184033Smav csd->wp_grp_size = mmc_get_bits(raw_csd, 128, 32, 7); 1221184033Smav csd->wp_grp_enable = mmc_get_bits(raw_csd, 128, 31, 1); 1222184033Smav csd->r2w_factor = 1 << mmc_get_bits(raw_csd, 128, 26, 3); 1223184033Smav csd->write_bl_len = 1 << mmc_get_bits(raw_csd, 128, 22, 4); 1224184033Smav csd->write_bl_partial = mmc_get_bits(raw_csd, 128, 21, 1); 1225322119Smarius return (MMC_ERR_NONE); 1226183729Simp } else if (v == 1) { 1227184033Smav m = mmc_get_bits(raw_csd, 128, 115, 4); 1228184033Smav e = mmc_get_bits(raw_csd, 128, 112, 3); 1229236156Smarius csd->tacc = (exp[e] * mant[m] + 9) / 10; 1230184033Smav csd->nsac = mmc_get_bits(raw_csd, 128, 104, 8) * 100; 1231184033Smav m = mmc_get_bits(raw_csd, 128, 99, 4); 1232184033Smav e = mmc_get_bits(raw_csd, 128, 96, 3); 1233183729Simp csd->tran_speed = exp[e] * 10000 * mant[m]; 1234184033Smav csd->ccc = mmc_get_bits(raw_csd, 128, 84, 12); 1235184033Smav csd->read_bl_len = 1 << mmc_get_bits(raw_csd, 128, 80, 4); 1236184033Smav csd->read_bl_partial = mmc_get_bits(raw_csd, 128, 79, 1); 1237184033Smav csd->write_blk_misalign = mmc_get_bits(raw_csd, 128, 78, 1); 1238184033Smav csd->read_blk_misalign = mmc_get_bits(raw_csd, 128, 77, 1); 1239184033Smav csd->dsr_imp = mmc_get_bits(raw_csd, 128, 76, 1); 1240318197Smarius csd->capacity = ((uint64_t)mmc_get_bits(raw_csd, 128, 48, 22) + 1241318197Smarius 1) * 512 * 1024; 1242184033Smav csd->erase_blk_en = mmc_get_bits(raw_csd, 128, 46, 1); 1243184033Smav csd->erase_sector = mmc_get_bits(raw_csd, 128, 39, 7) + 1; 1244184033Smav csd->wp_grp_size = mmc_get_bits(raw_csd, 128, 32, 7); 1245184033Smav csd->wp_grp_enable = mmc_get_bits(raw_csd, 128, 31, 1); 1246184033Smav csd->r2w_factor = 1 << mmc_get_bits(raw_csd, 128, 26, 3); 1247184033Smav csd->write_bl_len = 1 << mmc_get_bits(raw_csd, 128, 22, 4); 1248184033Smav csd->write_bl_partial = mmc_get_bits(raw_csd, 128, 21, 1); 1249322119Smarius return (MMC_ERR_NONE); 1250322119Smarius } 1251322119Smarius return (MMC_ERR_INVALID); 1252163516Simp} 1253163516Simp 1254183704Smavstatic void 1255183729Simpmmc_decode_csd_mmc(uint32_t *raw_csd, struct mmc_csd *csd) 1256183729Simp{ 1257183729Simp int m; 1258183729Simp int e; 1259183729Simp 1260183729Simp memset(csd, 0, sizeof(*csd)); 1261184033Smav csd->csd_structure = mmc_get_bits(raw_csd, 128, 126, 2); 1262184033Smav csd->spec_vers = mmc_get_bits(raw_csd, 128, 122, 4); 1263184033Smav m = mmc_get_bits(raw_csd, 128, 115, 4); 1264184033Smav e = mmc_get_bits(raw_csd, 128, 112, 3); 1265183729Simp csd->tacc = exp[e] * mant[m] + 9 / 10; 1266184033Smav csd->nsac = mmc_get_bits(raw_csd, 128, 104, 8) * 100; 1267184033Smav m = mmc_get_bits(raw_csd, 128, 99, 4); 1268184033Smav e = mmc_get_bits(raw_csd, 128, 96, 3); 1269183729Simp csd->tran_speed = exp[e] * 10000 * mant[m]; 1270184033Smav csd->ccc = mmc_get_bits(raw_csd, 128, 84, 12); 1271184033Smav csd->read_bl_len = 1 << mmc_get_bits(raw_csd, 128, 80, 4); 1272184033Smav csd->read_bl_partial = mmc_get_bits(raw_csd, 128, 79, 1); 1273184033Smav csd->write_blk_misalign = mmc_get_bits(raw_csd, 128, 78, 1); 1274184033Smav csd->read_blk_misalign = mmc_get_bits(raw_csd, 128, 77, 1); 1275184033Smav csd->dsr_imp = mmc_get_bits(raw_csd, 128, 76, 1); 1276184033Smav csd->vdd_r_curr_min = cur_min[mmc_get_bits(raw_csd, 128, 59, 3)]; 1277184033Smav csd->vdd_r_curr_max = cur_max[mmc_get_bits(raw_csd, 128, 56, 3)]; 1278184033Smav csd->vdd_w_curr_min = cur_min[mmc_get_bits(raw_csd, 128, 53, 3)]; 1279184033Smav csd->vdd_w_curr_max = cur_max[mmc_get_bits(raw_csd, 128, 50, 3)]; 1280184033Smav m = mmc_get_bits(raw_csd, 128, 62, 12); 1281184033Smav e = mmc_get_bits(raw_csd, 128, 47, 3); 1282183729Simp csd->capacity = ((1 + m) << (e + 2)) * csd->read_bl_len; 1283184033Smav csd->erase_blk_en = 0; 1284184033Smav csd->erase_sector = (mmc_get_bits(raw_csd, 128, 42, 5) + 1) * 1285184033Smav (mmc_get_bits(raw_csd, 128, 37, 5) + 1); 1286184033Smav csd->wp_grp_size = mmc_get_bits(raw_csd, 128, 32, 5); 1287184033Smav csd->wp_grp_enable = mmc_get_bits(raw_csd, 128, 31, 1); 1288184033Smav csd->r2w_factor = 1 << mmc_get_bits(raw_csd, 128, 26, 3); 1289184033Smav csd->write_bl_len = 1 << mmc_get_bits(raw_csd, 128, 22, 4); 1290184033Smav csd->write_bl_partial = mmc_get_bits(raw_csd, 128, 21, 1); 1291183729Simp} 1292183729Simp 1293183729Simpstatic void 1294183704Smavmmc_app_decode_scr(uint32_t *raw_scr, struct mmc_scr *scr) 1295183704Smav{ 1296183704Smav unsigned int scr_struct; 1297183704Smav 1298183704Smav memset(scr, 0, sizeof(*scr)); 1299183729Simp 1300184033Smav scr_struct = mmc_get_bits(raw_scr, 64, 60, 4); 1301183704Smav if (scr_struct != 0) { 1302183704Smav printf("Unrecognised SCR structure version %d\n", 1303183704Smav scr_struct); 1304183704Smav return; 1305183704Smav } 1306184033Smav scr->sda_vsn = mmc_get_bits(raw_scr, 64, 56, 4); 1307184033Smav scr->bus_widths = mmc_get_bits(raw_scr, 64, 48, 4); 1308183704Smav} 1309183704Smav 1310184033Smavstatic void 1311184033Smavmmc_app_decode_sd_status(uint32_t *raw_sd_status, 1312184033Smav struct mmc_sd_status *sd_status) 1313184033Smav{ 1314184033Smav 1315184033Smav memset(sd_status, 0, sizeof(*sd_status)); 1316184033Smav 1317184033Smav sd_status->bus_width = mmc_get_bits(raw_sd_status, 512, 510, 2); 1318184033Smav sd_status->secured_mode = mmc_get_bits(raw_sd_status, 512, 509, 1); 1319184033Smav sd_status->card_type = mmc_get_bits(raw_sd_status, 512, 480, 16); 1320184033Smav sd_status->prot_area = mmc_get_bits(raw_sd_status, 512, 448, 12); 1321184033Smav sd_status->speed_class = mmc_get_bits(raw_sd_status, 512, 440, 8); 1322184033Smav sd_status->perf_move = mmc_get_bits(raw_sd_status, 512, 432, 8); 1323184033Smav sd_status->au_size = mmc_get_bits(raw_sd_status, 512, 428, 4); 1324184033Smav sd_status->erase_size = mmc_get_bits(raw_sd_status, 512, 408, 16); 1325184033Smav sd_status->erase_timeout = mmc_get_bits(raw_sd_status, 512, 402, 6); 1326184033Smav sd_status->erase_offset = mmc_get_bits(raw_sd_status, 512, 400, 2); 1327184033Smav} 1328184033Smav 1329163516Simpstatic int 1330163516Simpmmc_all_send_cid(struct mmc_softc *sc, uint32_t *rawcid) 1331163516Simp{ 1332163516Simp struct mmc_command cmd; 1333163516Simp int err; 1334163516Simp 1335254432Sian memset(&cmd, 0, sizeof(cmd)); 1336163516Simp cmd.opcode = MMC_ALL_SEND_CID; 1337163516Simp cmd.arg = 0; 1338163516Simp cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR; 1339183470Simp cmd.data = NULL; 1340318197Smarius err = mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, CMD_RETRIES); 1341163516Simp memcpy(rawcid, cmd.resp, 4 * sizeof(uint32_t)); 1342163516Simp return (err); 1343163516Simp} 1344163516Simp 1345163516Simpstatic int 1346236156Smariusmmc_send_csd(struct mmc_softc *sc, uint16_t rca, uint32_t *rawcsd) 1347163516Simp{ 1348163516Simp struct mmc_command cmd; 1349163516Simp int err; 1350163516Simp 1351254432Sian memset(&cmd, 0, sizeof(cmd)); 1352163516Simp cmd.opcode = MMC_SEND_CSD; 1353163516Simp cmd.arg = rca << 16; 1354163516Simp cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR; 1355183470Simp cmd.data = NULL; 1356318197Smarius err = mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, CMD_RETRIES); 1357236156Smarius memcpy(rawcsd, cmd.resp, 4 * sizeof(uint32_t)); 1358163516Simp return (err); 1359163516Simp} 1360163516Simp 1361163516Simpstatic int 1362183704Smavmmc_app_send_scr(struct mmc_softc *sc, uint16_t rca, uint32_t *rawscr) 1363183704Smav{ 1364183704Smav int err; 1365183704Smav struct mmc_command cmd; 1366183704Smav struct mmc_data data; 1367183704Smav 1368254432Sian memset(&cmd, 0, sizeof(cmd)); 1369254432Sian memset(&data, 0, sizeof(data)); 1370183704Smav 1371183704Smav memset(rawscr, 0, 8); 1372183704Smav cmd.opcode = ACMD_SEND_SCR; 1373183704Smav cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC; 1374183704Smav cmd.arg = 0; 1375183704Smav cmd.data = &data; 1376183704Smav 1377183704Smav data.data = rawscr; 1378183704Smav data.len = 8; 1379183704Smav data.flags = MMC_DATA_READ; 1380183704Smav 1381318197Smarius err = mmc_wait_for_app_cmd(sc->dev, sc->dev, rca, &cmd, CMD_RETRIES); 1382183704Smav rawscr[0] = be32toh(rawscr[0]); 1383183704Smav rawscr[1] = be32toh(rawscr[1]); 1384183704Smav return (err); 1385183704Smav} 1386183704Smav 1387183704Smavstatic int 1388318197Smariusmmc_app_sd_status(struct mmc_softc *sc, uint16_t rca, uint32_t *rawsdstatus) 1389183704Smav{ 1390183704Smav struct mmc_command cmd; 1391183704Smav struct mmc_data data; 1392184033Smav int err, i; 1393184033Smav 1394254432Sian memset(&cmd, 0, sizeof(cmd)); 1395254432Sian memset(&data, 0, sizeof(data)); 1396184033Smav 1397184033Smav memset(rawsdstatus, 0, 64); 1398184033Smav cmd.opcode = ACMD_SD_STATUS; 1399184033Smav cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC; 1400184033Smav cmd.arg = 0; 1401184033Smav cmd.data = &data; 1402184033Smav 1403184033Smav data.data = rawsdstatus; 1404184033Smav data.len = 64; 1405184033Smav data.flags = MMC_DATA_READ; 1406184033Smav 1407318197Smarius err = mmc_wait_for_app_cmd(sc->dev, sc->dev, rca, &cmd, CMD_RETRIES); 1408184033Smav for (i = 0; i < 16; i++) 1409184033Smav rawsdstatus[i] = be32toh(rawsdstatus[i]); 1410184033Smav return (err); 1411184033Smav} 1412184033Smav 1413184033Smavstatic int 1414183704Smavmmc_set_relative_addr(struct mmc_softc *sc, uint16_t resp) 1415183704Smav{ 1416183704Smav struct mmc_command cmd; 1417183704Smav int err; 1418183704Smav 1419254432Sian memset(&cmd, 0, sizeof(cmd)); 1420183704Smav cmd.opcode = MMC_SET_RELATIVE_ADDR; 1421183704Smav cmd.arg = resp << 16; 1422183704Smav cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR; 1423183704Smav cmd.data = NULL; 1424318197Smarius err = mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, CMD_RETRIES); 1425183704Smav return (err); 1426183704Smav} 1427183704Smav 1428183704Smavstatic int 1429163516Simpmmc_send_relative_addr(struct mmc_softc *sc, uint32_t *resp) 1430163516Simp{ 1431163516Simp struct mmc_command cmd; 1432163516Simp int err; 1433163516Simp 1434254432Sian memset(&cmd, 0, sizeof(cmd)); 1435163516Simp cmd.opcode = SD_SEND_RELATIVE_ADDR; 1436163516Simp cmd.arg = 0; 1437163516Simp cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR; 1438183470Simp cmd.data = NULL; 1439318197Smarius err = mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, CMD_RETRIES); 1440163516Simp *resp = cmd.resp[0]; 1441163516Simp return (err); 1442163516Simp} 1443163516Simp 1444236156Smariusstatic int 1445236156Smariusmmc_set_blocklen(struct mmc_softc *sc, uint32_t len) 1446236156Smarius{ 1447236156Smarius struct mmc_command cmd; 1448236156Smarius int err; 1449236156Smarius 1450254432Sian memset(&cmd, 0, sizeof(cmd)); 1451236156Smarius cmd.opcode = MMC_SET_BLOCKLEN; 1452236156Smarius cmd.arg = len; 1453236156Smarius cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 1454236156Smarius cmd.data = NULL; 1455318197Smarius err = mmc_wait_for_cmd(sc->dev, sc->dev, &cmd, CMD_RETRIES); 1456236156Smarius return (err); 1457236156Smarius} 1458236156Smarius 1459318494Smariusstatic uint32_t 1460318494Smariusmmc_timing_to_dtr(struct mmc_ivars *ivar, enum mmc_bus_timing timing) 1461318494Smarius{ 1462318494Smarius 1463318494Smarius switch (timing) { 1464318494Smarius case bus_timing_normal: 1465318494Smarius return (ivar->tran_speed); 1466318494Smarius case bus_timing_hs: 1467318494Smarius return (ivar->hs_tran_speed); 1468318494Smarius case bus_timing_uhs_sdr12: 1469318494Smarius return (SD_SDR12_MAX); 1470318494Smarius case bus_timing_uhs_sdr25: 1471318494Smarius return (SD_SDR25_MAX); 1472318494Smarius case bus_timing_uhs_ddr50: 1473318494Smarius return (SD_DDR50_MAX); 1474318494Smarius case bus_timing_uhs_sdr50: 1475318494Smarius return (SD_SDR50_MAX); 1476318494Smarius case bus_timing_uhs_sdr104: 1477318494Smarius return (SD_SDR104_MAX); 1478318494Smarius case bus_timing_mmc_ddr52: 1479318494Smarius return (MMC_TYPE_DDR52_MAX); 1480318494Smarius case bus_timing_mmc_hs200: 1481318494Smarius case bus_timing_mmc_hs400: 1482318494Smarius case bus_timing_mmc_hs400es: 1483318494Smarius return (MMC_TYPE_HS200_HS400ES_MAX); 1484318494Smarius } 1485318494Smarius return (0); 1486318494Smarius} 1487318494Smarius 1488318494Smariusstatic const char * 1489318494Smariusmmc_timing_to_string(enum mmc_bus_timing timing) 1490318494Smarius{ 1491318494Smarius 1492318494Smarius switch (timing) { 1493318494Smarius case bus_timing_normal: 1494318494Smarius return ("normal speed"); 1495318494Smarius case bus_timing_hs: 1496318494Smarius return ("high speed"); 1497318494Smarius case bus_timing_uhs_sdr12: 1498318494Smarius case bus_timing_uhs_sdr25: 1499318494Smarius case bus_timing_uhs_sdr50: 1500318494Smarius case bus_timing_uhs_sdr104: 1501318494Smarius return ("single data rate"); 1502318494Smarius case bus_timing_uhs_ddr50: 1503318494Smarius case bus_timing_mmc_ddr52: 1504318494Smarius return ("dual data rate"); 1505318494Smarius case bus_timing_mmc_hs200: 1506318494Smarius return ("HS200"); 1507318494Smarius case bus_timing_mmc_hs400: 1508318494Smarius return ("HS400"); 1509318494Smarius case bus_timing_mmc_hs400es: 1510318494Smarius return ("HS400 with enhanced strobe"); 1511318494Smarius } 1512318494Smarius return (""); 1513318494Smarius} 1514318494Smarius 1515322119Smariusstatic bool 1516322119Smariusmmc_host_timing(device_t dev, enum mmc_bus_timing timing) 1517322119Smarius{ 1518322119Smarius int host_caps; 1519322119Smarius 1520322119Smarius host_caps = mmcbr_get_caps(dev); 1521322119Smarius 1522322119Smarius#define HOST_TIMING_CAP(host_caps, cap) ({ \ 1523322119Smarius bool retval; \ 1524322119Smarius if (((host_caps) & (cap)) == (cap)) \ 1525322119Smarius retval = true; \ 1526322119Smarius else \ 1527322119Smarius retval = false; \ 1528322119Smarius retval; \ 1529322119Smarius}) 1530322119Smarius 1531322119Smarius switch (timing) { 1532322119Smarius case bus_timing_normal: 1533322119Smarius return (true); 1534322119Smarius case bus_timing_hs: 1535322119Smarius return (HOST_TIMING_CAP(host_caps, MMC_CAP_HSPEED)); 1536322119Smarius case bus_timing_uhs_sdr12: 1537322119Smarius return (HOST_TIMING_CAP(host_caps, MMC_CAP_UHS_SDR12)); 1538322119Smarius case bus_timing_uhs_sdr25: 1539322119Smarius return (HOST_TIMING_CAP(host_caps, MMC_CAP_UHS_SDR25)); 1540322119Smarius case bus_timing_uhs_ddr50: 1541322119Smarius return (HOST_TIMING_CAP(host_caps, MMC_CAP_UHS_DDR50)); 1542322119Smarius case bus_timing_uhs_sdr50: 1543322119Smarius return (HOST_TIMING_CAP(host_caps, MMC_CAP_UHS_SDR50)); 1544322119Smarius case bus_timing_uhs_sdr104: 1545322119Smarius return (HOST_TIMING_CAP(host_caps, MMC_CAP_UHS_SDR104)); 1546322119Smarius case bus_timing_mmc_ddr52: 1547322119Smarius return (HOST_TIMING_CAP(host_caps, MMC_CAP_MMC_DDR52)); 1548322119Smarius case bus_timing_mmc_hs200: 1549322119Smarius return (HOST_TIMING_CAP(host_caps, MMC_CAP_MMC_HS200)); 1550322119Smarius case bus_timing_mmc_hs400: 1551322119Smarius return (HOST_TIMING_CAP(host_caps, MMC_CAP_MMC_HS400)); 1552322119Smarius case bus_timing_mmc_hs400es: 1553322119Smarius return (HOST_TIMING_CAP(host_caps, MMC_CAP_MMC_HS400 | 1554322119Smarius MMC_CAP_MMC_ENH_STROBE)); 1555322119Smarius } 1556322119Smarius 1557322119Smarius#undef HOST_TIMING_CAP 1558322119Smarius 1559322119Smarius return (false); 1560322119Smarius} 1561322119Smarius 1562163516Simpstatic void 1563187875Smavmmc_log_card(device_t dev, struct mmc_ivars *ivar, int newcard) 1564187875Smav{ 1565318494Smarius enum mmc_bus_timing max_timing, timing; 1566318197Smarius 1567254425Sian device_printf(dev, "Card at relative address 0x%04x%s:\n", 1568187875Smav ivar->rca, newcard ? " added" : ""); 1569234524Smarius device_printf(dev, " card: %s\n", ivar->card_id_string); 1570318494Smarius max_timing = bus_timing_normal; 1571318494Smarius for (timing = bus_timing_max; timing > bus_timing_normal; timing--) { 1572318494Smarius if (isset(&ivar->timings, timing)) { 1573318494Smarius max_timing = timing; 1574318494Smarius break; 1575318494Smarius } 1576318494Smarius } 1577322388Smarius device_printf(dev, " quirks: %b\n", ivar->quirks, MMC_QUIRKS_FMT); 1578318494Smarius device_printf(dev, " bus: %ubit, %uMHz (%s timing)\n", 1579187875Smav (ivar->bus_width == bus_width_1 ? 1 : 1580187875Smav (ivar->bus_width == bus_width_4 ? 4 : 8)), 1581318494Smarius mmc_timing_to_dtr(ivar, timing) / 1000000, 1582318494Smarius mmc_timing_to_string(timing)); 1583187875Smav device_printf(dev, " memory: %u blocks, erase sector %u blocks%s\n", 1584187875Smav ivar->sec_count, ivar->erase_sector, 1585187875Smav ivar->read_only ? ", read-only" : ""); 1586187875Smav} 1587187875Smav 1588187875Smavstatic void 1589163516Simpmmc_discover_cards(struct mmc_softc *sc) 1590163516Simp{ 1591318197Smarius u_char switch_res[64]; 1592318197Smarius uint32_t raw_cid[4]; 1593185721Smav struct mmc_ivars *ivar = NULL; 1594322388Smarius const struct mmc_quirk *quirk; 1595338637Smarius const uint8_t *ext_csd; 1596318197Smarius device_t child; 1597322119Smarius int err, host_caps, i, newcard; 1598318197Smarius uint32_t resp, sec_count, status; 1599183704Smav uint16_t rca = 2; 1600338637Smarius int16_t rev; 1601338637Smarius uint8_t card_type; 1602163516Simp 1603318494Smarius host_caps = mmcbr_get_caps(sc->dev); 1604187875Smav if (bootverbose || mmc_debug) 1605187875Smav device_printf(sc->dev, "Probing cards\n"); 1606163516Simp while (1) { 1607322119Smarius child = NULL; 1608275951Sian sc->squelched++; /* Errors are expected, squelch reporting. */ 1609185721Smav err = mmc_all_send_cid(sc, raw_cid); 1610275951Sian sc->squelched--; 1611163516Simp if (err == MMC_ERR_TIMEOUT) 1612163516Simp break; 1613163516Simp if (err != MMC_ERR_NONE) { 1614183468Simp device_printf(sc->dev, "Error reading CID %d\n", err); 1615163516Simp break; 1616163516Simp } 1617185721Smav newcard = 1; 1618322119Smarius for (i = 0; i < sc->child_count; i++) { 1619322119Smarius ivar = device_get_ivars(sc->child_list[i]); 1620318197Smarius if (memcmp(ivar->raw_cid, raw_cid, sizeof(raw_cid)) == 1621318197Smarius 0) { 1622185721Smav newcard = 0; 1623185721Smav break; 1624185721Smav } 1625185721Smav } 1626187875Smav if (bootverbose || mmc_debug) { 1627318197Smarius device_printf(sc->dev, 1628318197Smarius "%sard detected (CID %08x%08x%08x%08x)\n", 1629187875Smav newcard ? "New c" : "C", 1630187875Smav raw_cid[0], raw_cid[1], raw_cid[2], raw_cid[3]); 1631187875Smav } 1632185721Smav if (newcard) { 1633185721Smav ivar = malloc(sizeof(struct mmc_ivars), M_DEVBUF, 1634185721Smav M_WAITOK | M_ZERO); 1635185721Smav memcpy(ivar->raw_cid, raw_cid, sizeof(raw_cid)); 1636185721Smav } 1637183704Smav if (mmcbr_get_ro(sc->dev)) 1638183704Smav ivar->read_only = 1; 1639183704Smav ivar->bus_width = bus_width_1; 1640318494Smarius setbit(&ivar->timings, bus_timing_normal); 1641183704Smav ivar->mode = mmcbr_get_mode(sc->dev); 1642183704Smav if (ivar->mode == mode_sd) { 1643183729Simp mmc_decode_cid_sd(ivar->raw_cid, &ivar->cid); 1644318494Smarius err = mmc_send_relative_addr(sc, &resp); 1645318494Smarius if (err != MMC_ERR_NONE) { 1646318494Smarius device_printf(sc->dev, 1647318494Smarius "Error getting RCA %d\n", err); 1648322119Smarius goto free_ivar; 1649318494Smarius } 1650163516Simp ivar->rca = resp >> 16; 1651183704Smav /* Get card CSD. */ 1652318494Smarius err = mmc_send_csd(sc, ivar->rca, ivar->raw_csd); 1653318494Smarius if (err != MMC_ERR_NONE) { 1654318494Smarius device_printf(sc->dev, 1655318494Smarius "Error getting CSD %d\n", err); 1656322119Smarius goto free_ivar; 1657318494Smarius } 1658236156Smarius if (bootverbose || mmc_debug) 1659236156Smarius device_printf(sc->dev, 1660236156Smarius "%sard detected (CSD %08x%08x%08x%08x)\n", 1661236156Smarius newcard ? "New c" : "C", ivar->raw_csd[0], 1662236156Smarius ivar->raw_csd[1], ivar->raw_csd[2], 1663236156Smarius ivar->raw_csd[3]); 1664322119Smarius err = mmc_decode_csd_sd(ivar->raw_csd, &ivar->csd); 1665322119Smarius if (err != MMC_ERR_NONE) { 1666322119Smarius device_printf(sc->dev, "Error decoding CSD\n"); 1667322119Smarius goto free_ivar; 1668322119Smarius } 1669183731Smav ivar->sec_count = ivar->csd.capacity / MMC_SECTOR_SIZE; 1670183704Smav if (ivar->csd.csd_structure > 0) 1671183704Smav ivar->high_cap = 1; 1672183704Smav ivar->tran_speed = ivar->csd.tran_speed; 1673312399Smarius ivar->erase_sector = ivar->csd.erase_sector * 1674184033Smav ivar->csd.write_bl_len / MMC_SECTOR_SIZE; 1675312399Smarius 1676318197Smarius err = mmc_send_status(sc->dev, sc->dev, ivar->rca, 1677318197Smarius &status); 1678236156Smarius if (err != MMC_ERR_NONE) { 1679236156Smarius device_printf(sc->dev, 1680236156Smarius "Error reading card status %d\n", err); 1681322119Smarius goto free_ivar; 1682236156Smarius } 1683236156Smarius if ((status & R1_CARD_IS_LOCKED) != 0) { 1684236156Smarius device_printf(sc->dev, 1685322119Smarius "Card is password protected, skipping\n"); 1686322119Smarius goto free_ivar; 1687236156Smarius } 1688236156Smarius 1689318197Smarius /* Get card SCR. Card must be selected to fetch it. */ 1690318494Smarius err = mmc_select_card(sc, ivar->rca); 1691318494Smarius if (err != MMC_ERR_NONE) { 1692318494Smarius device_printf(sc->dev, 1693318494Smarius "Error selecting card %d\n", err); 1694322119Smarius goto free_ivar; 1695318494Smarius } 1696318494Smarius err = mmc_app_send_scr(sc, ivar->rca, ivar->raw_scr); 1697318494Smarius if (err != MMC_ERR_NONE) { 1698318494Smarius device_printf(sc->dev, 1699318494Smarius "Error reading SCR %d\n", err); 1700322119Smarius goto free_ivar; 1701318494Smarius } 1702183704Smav mmc_app_decode_scr(ivar->raw_scr, &ivar->scr); 1703188044Simp /* Get card switch capabilities (command class 10). */ 1704183704Smav if ((ivar->scr.sda_vsn >= 1) && 1705318197Smarius (ivar->csd.ccc & (1 << 10))) { 1706318494Smarius err = mmc_sd_switch(sc, SD_SWITCH_MODE_CHECK, 1707188044Simp SD_SWITCH_GROUP1, SD_SWITCH_NOCHANGE, 1708188044Simp switch_res); 1709318494Smarius if (err == MMC_ERR_NONE && 1710318494Smarius switch_res[13] & (1 << SD_SWITCH_HS_MODE)) { 1711318494Smarius setbit(&ivar->timings, bus_timing_hs); 1712318494Smarius ivar->hs_tran_speed = SD_HS_MAX; 1713183704Smav } 1714183704Smav } 1715283128Simp 1716283128Simp /* 1717285678Sian * We deselect then reselect the card here. Some cards 1718285678Sian * become unselected and timeout with the above two 1719285678Sian * commands, although the state tables / diagrams in the 1720285678Sian * standard suggest they go back to the transfer state. 1721285678Sian * Other cards don't become deselected, and if we 1722318197Smarius * attempt to blindly re-select them, we get timeout 1723285678Sian * errors from some controllers. So we deselect then 1724285678Sian * reselect to handle all situations. The only thing we 1725285678Sian * use from the sd_status is the erase sector size, but 1726285678Sian * it is still nice to get that right. 1727283128Simp */ 1728322119Smarius (void)mmc_select_card(sc, 0); 1729318494Smarius (void)mmc_select_card(sc, ivar->rca); 1730318494Smarius (void)mmc_app_sd_status(sc, ivar->rca, 1731318494Smarius ivar->raw_sd_status); 1732184033Smav mmc_app_decode_sd_status(ivar->raw_sd_status, 1733184033Smav &ivar->sd_status); 1734184033Smav if (ivar->sd_status.au_size != 0) { 1735184033Smav ivar->erase_sector = 1736184033Smav 16 << ivar->sd_status.au_size; 1737184033Smav } 1738322119Smarius /* Find maximum supported bus width. */ 1739318494Smarius if ((host_caps & MMC_CAP_4_BIT_DATA) && 1740183704Smav (ivar->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) 1741183704Smav ivar->bus_width = bus_width_4; 1742236156Smarius 1743322119Smarius goto child_common; 1744163516Simp } 1745183704Smav ivar->rca = rca++; 1746318494Smarius err = mmc_set_relative_addr(sc, ivar->rca); 1747318494Smarius if (err != MMC_ERR_NONE) { 1748318494Smarius device_printf(sc->dev, "Error setting RCA %d\n", err); 1749322119Smarius goto free_ivar; 1750318494Smarius } 1751183704Smav /* Get card CSD. */ 1752318494Smarius err = mmc_send_csd(sc, ivar->rca, ivar->raw_csd); 1753318494Smarius if (err != MMC_ERR_NONE) { 1754318494Smarius device_printf(sc->dev, "Error getting CSD %d\n", err); 1755322119Smarius goto free_ivar; 1756318494Smarius } 1757236156Smarius if (bootverbose || mmc_debug) 1758236156Smarius device_printf(sc->dev, 1759236156Smarius "%sard detected (CSD %08x%08x%08x%08x)\n", 1760236156Smarius newcard ? "New c" : "C", ivar->raw_csd[0], 1761236156Smarius ivar->raw_csd[1], ivar->raw_csd[2], 1762236156Smarius ivar->raw_csd[3]); 1763236156Smarius 1764183729Simp mmc_decode_csd_mmc(ivar->raw_csd, &ivar->csd); 1765183731Smav ivar->sec_count = ivar->csd.capacity / MMC_SECTOR_SIZE; 1766183704Smav ivar->tran_speed = ivar->csd.tran_speed; 1767312399Smarius ivar->erase_sector = ivar->csd.erase_sector * 1768184033Smav ivar->csd.write_bl_len / MMC_SECTOR_SIZE; 1769236156Smarius 1770318197Smarius err = mmc_send_status(sc->dev, sc->dev, ivar->rca, &status); 1771236156Smarius if (err != MMC_ERR_NONE) { 1772236156Smarius device_printf(sc->dev, 1773236156Smarius "Error reading card status %d\n", err); 1774322119Smarius goto free_ivar; 1775236156Smarius } 1776236156Smarius if ((status & R1_CARD_IS_LOCKED) != 0) { 1777236156Smarius device_printf(sc->dev, 1778322119Smarius "Card is password protected, skipping\n"); 1779322119Smarius goto free_ivar; 1780236156Smarius } 1781236156Smarius 1782318494Smarius err = mmc_select_card(sc, ivar->rca); 1783318494Smarius if (err != MMC_ERR_NONE) { 1784318494Smarius device_printf(sc->dev, "Error selecting card %d\n", 1785318494Smarius err); 1786322119Smarius goto free_ivar; 1787318494Smarius } 1788276106Simp 1789338637Smarius rev = -1; 1790318197Smarius /* Only MMC >= 4.x devices support EXT_CSD. */ 1791183704Smav if (ivar->csd.spec_vers >= 4) { 1792318197Smarius err = mmc_send_ext_csd(sc->dev, sc->dev, 1793318197Smarius ivar->raw_ext_csd); 1794318197Smarius if (err != MMC_ERR_NONE) { 1795318197Smarius device_printf(sc->dev, 1796318197Smarius "Error reading EXT_CSD %d\n", err); 1797322119Smarius goto free_ivar; 1798318197Smarius } 1799338637Smarius ext_csd = ivar->raw_ext_csd; 1800338637Smarius rev = ext_csd[EXT_CSD_REV]; 1801183731Smav /* Handle extended capacity from EXT_CSD */ 1802338637Smarius sec_count = le32dec(&ext_csd[EXT_CSD_SEC_CNT]); 1803183731Smav if (sec_count != 0) { 1804183731Smav ivar->sec_count = sec_count; 1805183731Smav ivar->high_cap = 1; 1806183731Smav } 1807322119Smarius /* Find maximum supported bus width. */ 1808322119Smarius ivar->bus_width = mmc_test_bus_width(sc); 1809318494Smarius /* Get device speeds beyond normal mode. */ 1810338637Smarius card_type = ext_csd[EXT_CSD_CARD_TYPE]; 1811338637Smarius if ((card_type & EXT_CSD_CARD_TYPE_HS_52) != 0) { 1812318494Smarius setbit(&ivar->timings, bus_timing_hs); 1813318494Smarius ivar->hs_tran_speed = MMC_TYPE_HS_52_MAX; 1814338637Smarius } else if ((card_type & EXT_CSD_CARD_TYPE_HS_26) != 0) { 1815318494Smarius setbit(&ivar->timings, bus_timing_hs); 1816318494Smarius ivar->hs_tran_speed = MMC_TYPE_HS_26_MAX; 1817318494Smarius } 1818338637Smarius if ((card_type & EXT_CSD_CARD_TYPE_DDR_52_1_2V) != 0 && 1819318494Smarius (host_caps & MMC_CAP_SIGNALING_120) != 0) { 1820318494Smarius setbit(&ivar->timings, bus_timing_mmc_ddr52); 1821318494Smarius setbit(&ivar->vccq_120, bus_timing_mmc_ddr52); 1822318494Smarius } 1823338637Smarius if ((card_type & EXT_CSD_CARD_TYPE_DDR_52_1_8V) != 0 && 1824318494Smarius (host_caps & MMC_CAP_SIGNALING_180) != 0) { 1825318494Smarius setbit(&ivar->timings, bus_timing_mmc_ddr52); 1826318494Smarius setbit(&ivar->vccq_180, bus_timing_mmc_ddr52); 1827318494Smarius } 1828338637Smarius if ((card_type & EXT_CSD_CARD_TYPE_HS200_1_2V) != 0 && 1829322119Smarius (host_caps & MMC_CAP_SIGNALING_120) != 0) { 1830322119Smarius setbit(&ivar->timings, bus_timing_mmc_hs200); 1831322119Smarius setbit(&ivar->vccq_120, bus_timing_mmc_hs200); 1832322119Smarius } 1833338637Smarius if ((card_type & EXT_CSD_CARD_TYPE_HS200_1_8V) != 0 && 1834322119Smarius (host_caps & MMC_CAP_SIGNALING_180) != 0) { 1835322119Smarius setbit(&ivar->timings, bus_timing_mmc_hs200); 1836322119Smarius setbit(&ivar->vccq_180, bus_timing_mmc_hs200); 1837322119Smarius } 1838338637Smarius if ((card_type & EXT_CSD_CARD_TYPE_HS400_1_2V) != 0 && 1839322119Smarius (host_caps & MMC_CAP_SIGNALING_120) != 0 && 1840322119Smarius ivar->bus_width == bus_width_8) { 1841322119Smarius setbit(&ivar->timings, bus_timing_mmc_hs400); 1842322119Smarius setbit(&ivar->vccq_120, bus_timing_mmc_hs400); 1843322119Smarius } 1844338637Smarius if ((card_type & EXT_CSD_CARD_TYPE_HS400_1_8V) != 0 && 1845322119Smarius (host_caps & MMC_CAP_SIGNALING_180) != 0 && 1846322119Smarius ivar->bus_width == bus_width_8) { 1847322119Smarius setbit(&ivar->timings, bus_timing_mmc_hs400); 1848322119Smarius setbit(&ivar->vccq_180, bus_timing_mmc_hs400); 1849322119Smarius } 1850338637Smarius if ((card_type & EXT_CSD_CARD_TYPE_HS400_1_2V) != 0 && 1851338637Smarius (ext_csd[EXT_CSD_STROBE_SUPPORT] & 1852322119Smarius EXT_CSD_STROBE_SUPPORT_EN) != 0 && 1853322119Smarius (host_caps & MMC_CAP_SIGNALING_120) != 0 && 1854322119Smarius ivar->bus_width == bus_width_8) { 1855322119Smarius setbit(&ivar->timings, bus_timing_mmc_hs400es); 1856322119Smarius setbit(&ivar->vccq_120, bus_timing_mmc_hs400es); 1857322119Smarius } 1858338637Smarius if ((card_type & EXT_CSD_CARD_TYPE_HS400_1_8V) != 0 && 1859338637Smarius (ext_csd[EXT_CSD_STROBE_SUPPORT] & 1860322119Smarius EXT_CSD_STROBE_SUPPORT_EN) != 0 && 1861322119Smarius (host_caps & MMC_CAP_SIGNALING_180) != 0 && 1862322119Smarius ivar->bus_width == bus_width_8) { 1863322119Smarius setbit(&ivar->timings, bus_timing_mmc_hs400es); 1864322119Smarius setbit(&ivar->vccq_180, bus_timing_mmc_hs400es); 1865322119Smarius } 1866318197Smarius /* 1867318197Smarius * Determine generic switch timeout (provided in 1868318197Smarius * units of 10 ms), defaulting to 500 ms. 1869318197Smarius */ 1870318197Smarius ivar->cmd6_time = 500 * 1000; 1871338637Smarius if (rev >= 6) 1872318197Smarius ivar->cmd6_time = 10 * 1873338637Smarius ext_csd[EXT_CSD_GEN_CMD6_TIME]; 1874184033Smav /* Handle HC erase sector size. */ 1875338637Smarius if (ext_csd[EXT_CSD_ERASE_GRP_SIZE] != 0) { 1876184033Smav ivar->erase_sector = 1024 * 1877338637Smarius ext_csd[EXT_CSD_ERASE_GRP_SIZE]; 1878318197Smarius err = mmc_switch(sc->dev, sc->dev, ivar->rca, 1879318197Smarius EXT_CSD_CMD_SET_NORMAL, 1880318197Smarius EXT_CSD_ERASE_GRP_DEF, 1881318197Smarius EXT_CSD_ERASE_GRP_DEF_EN, 1882318197Smarius ivar->cmd6_time, true); 1883318197Smarius if (err != MMC_ERR_NONE) { 1884318197Smarius device_printf(sc->dev, 1885318197Smarius "Error setting erase group %d\n", 1886318197Smarius err); 1887322119Smarius goto free_ivar; 1888318197Smarius } 1889184033Smav } 1890183704Smav } 1891236156Smarius 1892338637Smarius mmc_decode_cid_mmc(ivar->raw_cid, &ivar->cid, rev >= 5); 1893322119Smarius 1894322119Smariuschild_common: 1895322388Smarius for (quirk = &mmc_quirks[0]; quirk->mid != 0x0; quirk++) { 1896322388Smarius if ((quirk->mid == MMC_QUIRK_MID_ANY || 1897322388Smarius quirk->mid == ivar->cid.mid) && 1898322388Smarius (quirk->oid == MMC_QUIRK_OID_ANY || 1899322388Smarius quirk->oid == ivar->cid.oid) && 1900322388Smarius strncmp(quirk->pnm, ivar->cid.pnm, 1901322388Smarius sizeof(ivar->cid.pnm)) == 0) { 1902322388Smarius ivar->quirks = quirk->quirks; 1903322388Smarius break; 1904322388Smarius } 1905322388Smarius } 1906322388Smarius 1907236156Smarius /* 1908236156Smarius * Some cards that report maximum I/O block sizes greater 1909236156Smarius * than 512 require the block length to be set to 512, even 1910236156Smarius * though that is supposed to be the default. Example: 1911236156Smarius * 1912236156Smarius * Transcend 2GB SDSC card, CID: 1913236156Smarius * mid=0x1b oid=0x534d pnm="00000" prv=1.0 mdt=00.2000 1914236156Smarius */ 1915236156Smarius if (ivar->csd.read_bl_len != MMC_SECTOR_SIZE || 1916236156Smarius ivar->csd.write_bl_len != MMC_SECTOR_SIZE) 1917236156Smarius mmc_set_blocklen(sc, MMC_SECTOR_SIZE); 1918236156Smarius 1919234524Smarius mmc_format_card_id_string(ivar); 1920236156Smarius 1921187875Smav if (bootverbose || mmc_debug) 1922187875Smav mmc_log_card(sc->dev, ivar, newcard); 1923185721Smav if (newcard) { 1924185721Smav /* Add device. */ 1925185721Smav child = device_add_child(sc->dev, NULL, -1); 1926322119Smarius if (child != NULL) { 1927322119Smarius device_set_ivars(child, ivar); 1928322119Smarius sc->child_list = realloc(sc->child_list, 1929322119Smarius sizeof(device_t) * sc->child_count + 1, 1930322119Smarius M_DEVBUF, M_WAITOK); 1931322119Smarius sc->child_list[sc->child_count++] = child; 1932322119Smarius } else 1933322119Smarius device_printf(sc->dev, "Error adding child\n"); 1934185721Smav } 1935322119Smarius 1936322119Smariusfree_ivar: 1937322119Smarius if (newcard && child == NULL) 1938322119Smarius free(ivar, M_DEVBUF); 1939322119Smarius (void)mmc_select_card(sc, 0); 1940322119Smarius /* 1941322119Smarius * Not returning here when one MMC device could no be added 1942322119Smarius * potentially would mean looping forever when that device 1943322119Smarius * is broken (in which case it also may impact the remainder 1944322119Smarius * of the bus anyway, though). 1945322119Smarius */ 1946322119Smarius if ((newcard && child == NULL) || 1947322119Smarius mmcbr_get_mode(sc->dev) == mode_sd) 1948322119Smarius return; 1949163516Simp } 1950163516Simp} 1951163516Simp 1952163516Simpstatic void 1953322119Smariusmmc_update_child_list(struct mmc_softc *sc) 1954322119Smarius{ 1955322119Smarius device_t child; 1956322119Smarius int i, j; 1957322119Smarius 1958322119Smarius if (sc->child_count == 0) { 1959322119Smarius free(sc->child_list, M_DEVBUF); 1960322119Smarius return; 1961322119Smarius } 1962322119Smarius for (i = j = 0; i < sc->child_count; i++) { 1963322119Smarius for (;;) { 1964322119Smarius child = sc->child_list[j++]; 1965322119Smarius if (child != NULL) 1966322119Smarius break; 1967322119Smarius } 1968322119Smarius if (i != j) 1969322119Smarius sc->child_list[i] = child; 1970322119Smarius } 1971322119Smarius sc->child_list = realloc(sc->child_list, sizeof(device_t) * 1972322119Smarius sc->child_count, M_DEVBUF, M_WAITOK); 1973322119Smarius} 1974322119Smarius 1975322119Smariusstatic void 1976185721Smavmmc_rescan_cards(struct mmc_softc *sc) 1977185721Smav{ 1978318197Smarius struct mmc_ivars *ivar; 1979322119Smarius int err, i, j; 1980185721Smav 1981322119Smarius for (i = j = 0; i < sc->child_count; i++) { 1982322119Smarius ivar = device_get_ivars(sc->child_list[i]); 1983318197Smarius if (mmc_select_card(sc, ivar->rca) != MMC_ERR_NONE) { 1984187875Smav if (bootverbose || mmc_debug) 1985318197Smarius device_printf(sc->dev, 1986322119Smarius "Card at relative address %d lost\n", 1987187875Smav ivar->rca); 1988322119Smarius err = device_delete_child(sc->dev, sc->child_list[i]); 1989322119Smarius if (err != 0) { 1990322119Smarius j++; 1991322119Smarius continue; 1992322119Smarius } 1993185721Smav free(ivar, M_DEVBUF); 1994322119Smarius } else 1995322119Smarius j++; 1996185721Smav } 1997322119Smarius if (sc->child_count == j) 1998322119Smarius goto out; 1999322119Smarius sc->child_count = j; 2000322119Smarius mmc_update_child_list(sc); 2001322119Smariusout: 2002322119Smarius (void)mmc_select_card(sc, 0); 2003185721Smav} 2004185721Smav 2005185721Smavstatic int 2006322119Smariusmmc_delete_cards(struct mmc_softc *sc, bool final) 2007185721Smav{ 2008185721Smav struct mmc_ivars *ivar; 2009322119Smarius int err, i, j; 2010185721Smav 2011322119Smarius err = 0; 2012322119Smarius for (i = j = 0; i < sc->child_count; i++) { 2013322119Smarius ivar = device_get_ivars(sc->child_list[i]); 2014187875Smav if (bootverbose || mmc_debug) 2015318197Smarius device_printf(sc->dev, 2016322119Smarius "Card at relative address %d deleted\n", 2017187875Smav ivar->rca); 2018322119Smarius err = device_delete_child(sc->dev, sc->child_list[i]); 2019322119Smarius if (err != 0) { 2020322119Smarius j++; 2021322119Smarius if (final == false) 2022322119Smarius continue; 2023322119Smarius else 2024322119Smarius break; 2025322119Smarius } 2026185721Smav free(ivar, M_DEVBUF); 2027185721Smav } 2028322119Smarius sc->child_count = j; 2029322119Smarius mmc_update_child_list(sc); 2030322119Smarius return (err); 2031185721Smav} 2032185721Smav 2033185721Smavstatic void 2034163516Simpmmc_go_discovery(struct mmc_softc *sc) 2035163516Simp{ 2036163516Simp uint32_t ocr; 2037163516Simp device_t dev; 2038183704Smav int err; 2039163516Simp 2040163516Simp dev = sc->dev; 2041163516Simp if (mmcbr_get_power_mode(dev) != power_on) { 2042183453Simp /* 2043183453Simp * First, try SD modes 2044183453Simp */ 2045275951Sian sc->squelched++; /* Errors are expected, squelch reporting. */ 2046163516Simp mmcbr_set_mode(dev, mode_sd); 2047163516Simp mmc_power_up(sc); 2048163516Simp mmcbr_set_bus_mode(dev, pushpull); 2049187875Smav if (bootverbose || mmc_debug) 2050187875Smav device_printf(sc->dev, "Probing bus\n"); 2051163516Simp mmc_idle_cards(sc); 2052183704Smav err = mmc_send_if_cond(sc, 1); 2053187875Smav if ((bootverbose || mmc_debug) && err == 0) 2054318197Smarius device_printf(sc->dev, 2055318197Smarius "SD 2.0 interface conditions: OK\n"); 2056236156Smarius if (mmc_send_app_op_cond(sc, 0, &ocr) != MMC_ERR_NONE) { 2057187875Smav if (bootverbose || mmc_debug) 2058187875Smav device_printf(sc->dev, "SD probe: failed\n"); 2059183453Simp /* 2060183453Simp * Failed, try MMC 2061183453Simp */ 2062163516Simp mmcbr_set_mode(dev, mode_mmc); 2063187875Smav if (mmc_send_op_cond(sc, 0, &ocr) != MMC_ERR_NONE) { 2064187875Smav if (bootverbose || mmc_debug) 2065318197Smarius device_printf(sc->dev, 2066318197Smarius "MMC probe: failed\n"); 2067185721Smav ocr = 0; /* Failed both, powerdown. */ 2068187875Smav } else if (bootverbose || mmc_debug) 2069187875Smav device_printf(sc->dev, 2070187875Smav "MMC probe: OK (OCR: 0x%08x)\n", ocr); 2071187875Smav } else if (bootverbose || mmc_debug) 2072318197Smarius device_printf(sc->dev, "SD probe: OK (OCR: 0x%08x)\n", 2073318197Smarius ocr); 2074275951Sian sc->squelched--; 2075187875Smav 2076163516Simp mmcbr_set_ocr(dev, mmc_select_vdd(sc, ocr)); 2077163516Simp if (mmcbr_get_ocr(dev) != 0) 2078163516Simp mmc_idle_cards(sc); 2079163516Simp } else { 2080163516Simp mmcbr_set_bus_mode(dev, opendrain); 2081318494Smarius mmcbr_set_clock(dev, SD_MMC_CARD_ID_FREQUENCY); 2082163516Simp mmcbr_update_ios(dev); 2083183453Simp /* XXX recompute vdd based on new cards? */ 2084163516Simp } 2085163516Simp /* 2086163516Simp * Make sure that we have a mutually agreeable voltage to at least 2087163516Simp * one card on the bus. 2088163516Simp */ 2089187875Smav if (bootverbose || mmc_debug) 2090318197Smarius device_printf(sc->dev, "Current OCR: 0x%08x\n", 2091318197Smarius mmcbr_get_ocr(dev)); 2092185721Smav if (mmcbr_get_ocr(dev) == 0) { 2093261944Sian device_printf(sc->dev, "No compatible cards found on bus\n"); 2094322119Smarius (void)mmc_delete_cards(sc, false); 2095185721Smav mmc_power_down(sc); 2096163516Simp return; 2097185721Smav } 2098163516Simp /* 2099163516Simp * Reselect the cards after we've idled them above. 2100163516Simp */ 2101183704Smav if (mmcbr_get_mode(dev) == mode_sd) { 2102183704Smav err = mmc_send_if_cond(sc, 1); 2103183704Smav mmc_send_app_op_cond(sc, 2104183775Simp (err ? 0 : MMC_OCR_CCS) | mmcbr_get_ocr(dev), NULL); 2105183704Smav } else 2106279359Sian mmc_send_op_cond(sc, MMC_OCR_CCS | mmcbr_get_ocr(dev), NULL); 2107163516Simp mmc_discover_cards(sc); 2108185721Smav mmc_rescan_cards(sc); 2109163516Simp 2110163516Simp mmcbr_set_bus_mode(dev, pushpull); 2111163516Simp mmcbr_update_ios(dev); 2112183763Smav mmc_calculate_clock(sc); 2113163516Simp} 2114163516Simp 2115163516Simpstatic int 2116163516Simpmmc_calculate_clock(struct mmc_softc *sc) 2117163516Simp{ 2118322119Smarius device_t dev; 2119183704Smav struct mmc_ivars *ivar; 2120322119Smarius int i; 2121318494Smarius uint32_t dtr, max_dtr; 2122322119Smarius uint16_t rca; 2123318494Smarius enum mmc_bus_timing max_timing, timing; 2124322119Smarius bool changed, hs400; 2125312399Smarius 2126322119Smarius dev = sc->dev; 2127322119Smarius max_dtr = mmcbr_get_f_max(dev); 2128322119Smarius max_timing = bus_timing_max; 2129318494Smarius do { 2130318494Smarius changed = false; 2131322119Smarius for (i = 0; i < sc->child_count; i++) { 2132322119Smarius ivar = device_get_ivars(sc->child_list[i]); 2133322119Smarius if (isclr(&ivar->timings, max_timing) || 2134322119Smarius !mmc_host_timing(dev, max_timing)) { 2135322119Smarius for (timing = max_timing - 1; timing >= 2136318494Smarius bus_timing_normal; timing--) { 2137322119Smarius if (isset(&ivar->timings, timing) && 2138322119Smarius mmc_host_timing(dev, timing)) { 2139318494Smarius max_timing = timing; 2140318494Smarius break; 2141318494Smarius } 2142318494Smarius } 2143318494Smarius changed = true; 2144318494Smarius } 2145318494Smarius dtr = mmc_timing_to_dtr(ivar, max_timing); 2146318494Smarius if (dtr < max_dtr) { 2147318494Smarius max_dtr = dtr; 2148318494Smarius changed = true; 2149318494Smarius } 2150318494Smarius } 2151318494Smarius } while (changed == true); 2152322119Smarius 2153318197Smarius if (bootverbose || mmc_debug) { 2154322119Smarius device_printf(dev, 2155318494Smarius "setting transfer rate to %d.%03dMHz (%s timing)\n", 2156318197Smarius max_dtr / 1000000, (max_dtr / 1000) % 1000, 2157318494Smarius mmc_timing_to_string(max_timing)); 2158318197Smarius } 2159322119Smarius 2160322119Smarius /* 2161322119Smarius * HS400 must be tuned in HS200 mode, so in case of HS400 we begin 2162322119Smarius * with HS200 following the sequence as described in "6.6.2.2 HS200 2163322119Smarius * timing mode selection" of the eMMC specification v5.1, too, and 2164322119Smarius * switch to max_timing later. HS400ES requires no tuning and, thus, 2165322119Smarius * can be switch to directly, but requires the same detour via high 2166322119Smarius * speed mode as does HS400 (see mmc_switch_to_hs400()). 2167322119Smarius */ 2168322119Smarius hs400 = max_timing == bus_timing_mmc_hs400; 2169322119Smarius timing = hs400 == true ? bus_timing_mmc_hs200 : max_timing; 2170322119Smarius for (i = 0; i < sc->child_count; i++) { 2171322119Smarius ivar = device_get_ivars(sc->child_list[i]); 2172318494Smarius if ((ivar->timings & ~(1 << bus_timing_normal)) == 0) 2173340740Smarius goto clock; 2174322119Smarius 2175322119Smarius rca = ivar->rca; 2176322119Smarius if (mmc_select_card(sc, rca) != MMC_ERR_NONE) { 2177322119Smarius device_printf(dev, "Card at relative address %d " 2178322119Smarius "failed to select\n", rca); 2179322119Smarius continue; 2180322119Smarius } 2181322119Smarius 2182322119Smarius if (timing == bus_timing_mmc_hs200 || /* includes HS400 */ 2183322119Smarius timing == bus_timing_mmc_hs400es) { 2184322119Smarius if (mmc_set_vccq(sc, ivar, timing) != MMC_ERR_NONE) { 2185322119Smarius device_printf(dev, "Failed to set VCCQ for " 2186322119Smarius "card at relative address %d\n", rca); 2187322119Smarius continue; 2188322119Smarius } 2189322119Smarius } 2190322119Smarius 2191322119Smarius if (timing == bus_timing_mmc_hs200) { /* includes HS400 */ 2192322119Smarius /* Set bus width (required for initial tuning). */ 2193322119Smarius if (mmc_set_card_bus_width(sc, ivar, timing) != 2194322119Smarius MMC_ERR_NONE) { 2195322119Smarius device_printf(dev, "Card at relative address " 2196322119Smarius "%d failed to set bus width\n", rca); 2197322119Smarius continue; 2198322119Smarius } 2199322119Smarius mmcbr_set_bus_width(dev, ivar->bus_width); 2200322119Smarius mmcbr_update_ios(dev); 2201322119Smarius } else if (timing == bus_timing_mmc_hs400es) { 2202322119Smarius if (mmc_switch_to_hs400(sc, ivar, max_dtr, timing) != 2203322119Smarius MMC_ERR_NONE) { 2204322119Smarius device_printf(dev, "Card at relative address " 2205322119Smarius "%d failed to set %s timing\n", rca, 2206322119Smarius mmc_timing_to_string(timing)); 2207322119Smarius continue; 2208322119Smarius } 2209322119Smarius goto power_class; 2210322119Smarius } 2211322119Smarius 2212322119Smarius if (mmc_set_timing(sc, ivar, timing) != MMC_ERR_NONE) { 2213322119Smarius device_printf(dev, "Card at relative address %d " 2214322119Smarius "failed to set %s timing\n", rca, 2215322119Smarius mmc_timing_to_string(timing)); 2216322119Smarius continue; 2217322119Smarius } 2218322119Smarius 2219322119Smarius if (timing == bus_timing_mmc_ddr52) { 2220322119Smarius /* 2221322119Smarius * Set EXT_CSD_BUS_WIDTH_n_DDR in EXT_CSD_BUS_WIDTH 2222322119Smarius * (must be done after switching to EXT_CSD_HS_TIMING). 2223322119Smarius */ 2224322119Smarius if (mmc_set_card_bus_width(sc, ivar, timing) != 2225322119Smarius MMC_ERR_NONE) { 2226322119Smarius device_printf(dev, "Card at relative address " 2227322119Smarius "%d failed to set bus width\n", rca); 2228322119Smarius continue; 2229322119Smarius } 2230322119Smarius mmcbr_set_bus_width(dev, ivar->bus_width); 2231322119Smarius mmcbr_update_ios(dev); 2232322119Smarius if (mmc_set_vccq(sc, ivar, timing) != MMC_ERR_NONE) { 2233322119Smarius device_printf(dev, "Failed to set VCCQ for " 2234322119Smarius "card at relative address %d\n", rca); 2235322119Smarius continue; 2236322119Smarius } 2237322119Smarius } 2238322119Smarius 2239340740Smariusclock: 2240322119Smarius /* Set clock (must be done before initial tuning). */ 2241322119Smarius mmcbr_set_clock(dev, max_dtr); 2242322119Smarius mmcbr_update_ios(dev); 2243322119Smarius 2244322119Smarius if (mmcbr_tune(dev, hs400) != 0) { 2245322119Smarius device_printf(dev, "Card at relative address %d " 2246322119Smarius "failed to execute initial tuning\n", rca); 2247322119Smarius continue; 2248322119Smarius } 2249322119Smarius 2250322119Smarius if (hs400 == true && mmc_switch_to_hs400(sc, ivar, max_dtr, 2251322119Smarius max_timing) != MMC_ERR_NONE) { 2252322119Smarius device_printf(dev, "Card at relative address %d " 2253322119Smarius "failed to set %s timing\n", rca, 2254322119Smarius mmc_timing_to_string(max_timing)); 2255322119Smarius continue; 2256322119Smarius } 2257322119Smarius 2258322119Smariuspower_class: 2259322119Smarius if (mmc_set_power_class(sc, ivar) != MMC_ERR_NONE) { 2260322119Smarius device_printf(dev, "Card at relative address %d " 2261322119Smarius "failed to set power class\n", rca); 2262322119Smarius } 2263183704Smav } 2264322119Smarius (void)mmc_select_card(sc, 0); 2265318197Smarius return (max_dtr); 2266163516Simp} 2267163516Simp 2268322119Smarius/* 2269322119Smarius * Switch from HS200 to HS400 (either initially or for re-tuning) or directly 2270322119Smarius * to HS400ES. This follows the sequences described in "6.6.2.3 HS400 timing 2271322119Smarius * mode selection" of the eMMC specification v5.1. 2272322119Smarius */ 2273322119Smariusstatic int 2274322119Smariusmmc_switch_to_hs400(struct mmc_softc *sc, struct mmc_ivars *ivar, 2275322119Smarius uint32_t clock, enum mmc_bus_timing max_timing) 2276322119Smarius{ 2277322119Smarius device_t dev; 2278322119Smarius int err; 2279322119Smarius uint16_t rca; 2280322119Smarius 2281322119Smarius dev = sc->dev; 2282322119Smarius rca = ivar->rca; 2283322119Smarius 2284322119Smarius /* 2285322119Smarius * Both clock and timing must be set as appropriate for high speed 2286322119Smarius * before eventually switching to HS400/HS400ES; mmc_set_timing() 2287322119Smarius * will issue mmcbr_update_ios(). 2288322119Smarius */ 2289322119Smarius mmcbr_set_clock(dev, ivar->hs_tran_speed); 2290322119Smarius err = mmc_set_timing(sc, ivar, bus_timing_hs); 2291322119Smarius if (err != MMC_ERR_NONE) 2292322119Smarius return (err); 2293322119Smarius 2294322119Smarius /* 2295322119Smarius * Set EXT_CSD_BUS_WIDTH_8_DDR in EXT_CSD_BUS_WIDTH (and additionally 2296322119Smarius * EXT_CSD_BUS_WIDTH_ES for HS400ES). 2297322119Smarius */ 2298322119Smarius err = mmc_set_card_bus_width(sc, ivar, max_timing); 2299322119Smarius if (err != MMC_ERR_NONE) 2300322119Smarius return (err); 2301322119Smarius mmcbr_set_bus_width(dev, ivar->bus_width); 2302322119Smarius mmcbr_update_ios(dev); 2303322119Smarius 2304322119Smarius /* Finally, switch to HS400/HS400ES mode. */ 2305322119Smarius err = mmc_set_timing(sc, ivar, max_timing); 2306322119Smarius if (err != MMC_ERR_NONE) 2307322119Smarius return (err); 2308322119Smarius mmcbr_set_clock(dev, clock); 2309322119Smarius mmcbr_update_ios(dev); 2310322119Smarius return (MMC_ERR_NONE); 2311322119Smarius} 2312322119Smarius 2313322119Smarius/* 2314322119Smarius * Switch from HS400 to HS200 (for re-tuning). 2315322119Smarius */ 2316322119Smariusstatic int 2317322119Smariusmmc_switch_to_hs200(struct mmc_softc *sc, struct mmc_ivars *ivar, 2318322119Smarius uint32_t clock) 2319322119Smarius{ 2320322119Smarius device_t dev; 2321322119Smarius int err; 2322322119Smarius uint16_t rca; 2323322119Smarius 2324322119Smarius dev = sc->dev; 2325322119Smarius rca = ivar->rca; 2326322119Smarius 2327322119Smarius /* 2328322119Smarius * Both clock and timing must initially be set as appropriate for 2329322119Smarius * DDR52 before eventually switching to HS200; mmc_set_timing() 2330322119Smarius * will issue mmcbr_update_ios(). 2331322119Smarius */ 2332322119Smarius mmcbr_set_clock(dev, ivar->hs_tran_speed); 2333322119Smarius err = mmc_set_timing(sc, ivar, bus_timing_mmc_ddr52); 2334322119Smarius if (err != MMC_ERR_NONE) 2335322119Smarius return (err); 2336322119Smarius 2337322119Smarius /* 2338322119Smarius * Next, switch to high speed. Thus, clear EXT_CSD_BUS_WIDTH_n_DDR 2339322119Smarius * in EXT_CSD_BUS_WIDTH and update bus width and timing in ios. 2340322119Smarius */ 2341322119Smarius err = mmc_set_card_bus_width(sc, ivar, bus_timing_hs); 2342322119Smarius if (err != MMC_ERR_NONE) 2343322119Smarius return (err); 2344322119Smarius mmcbr_set_bus_width(dev, ivar->bus_width); 2345322119Smarius mmcbr_set_timing(sc->dev, bus_timing_hs); 2346322119Smarius mmcbr_update_ios(dev); 2347322119Smarius 2348322119Smarius /* Finally, switch to HS200 mode. */ 2349322119Smarius err = mmc_set_timing(sc, ivar, bus_timing_mmc_hs200); 2350322119Smarius if (err != MMC_ERR_NONE) 2351322119Smarius return (err); 2352322119Smarius mmcbr_set_clock(dev, clock); 2353322119Smarius mmcbr_update_ios(dev); 2354322119Smarius return (MMC_ERR_NONE); 2355322119Smarius} 2356322119Smarius 2357322119Smariusstatic int 2358322119Smariusmmc_retune(device_t busdev, device_t dev, bool reset) 2359322119Smarius{ 2360322119Smarius struct mmc_softc *sc; 2361322119Smarius struct mmc_ivars *ivar; 2362322119Smarius int err; 2363322119Smarius uint32_t clock; 2364322119Smarius enum mmc_bus_timing timing; 2365322119Smarius 2366322119Smarius if (device_get_parent(dev) != busdev) 2367322119Smarius return (MMC_ERR_INVALID); 2368322119Smarius 2369322119Smarius sc = device_get_softc(busdev); 2370322119Smarius if (sc->retune_needed != 1 && sc->retune_paused != 0) 2371322119Smarius return (MMC_ERR_INVALID); 2372322119Smarius 2373322119Smarius timing = mmcbr_get_timing(busdev); 2374322119Smarius if (timing == bus_timing_mmc_hs400) { 2375322119Smarius /* 2376322119Smarius * Controllers use the data strobe line to latch data from 2377322119Smarius * the devices in HS400 mode so periodic re-tuning isn't 2378322119Smarius * expected to be required, i. e. only if a CRC or tuning 2379322119Smarius * error is signaled to the bridge. In these latter cases 2380322119Smarius * we are asked to reset the tuning circuit and need to do 2381322119Smarius * the switch timing dance. 2382322119Smarius */ 2383322119Smarius if (reset == false) 2384322119Smarius return (0); 2385322119Smarius ivar = device_get_ivars(dev); 2386322119Smarius clock = mmcbr_get_clock(busdev); 2387322119Smarius if (mmc_switch_to_hs200(sc, ivar, clock) != MMC_ERR_NONE) 2388322119Smarius return (MMC_ERR_BADCRC); 2389322119Smarius } 2390322119Smarius err = mmcbr_retune(busdev, reset); 2391322119Smarius if (err != 0 && timing == bus_timing_mmc_hs400) 2392322119Smarius return (MMC_ERR_BADCRC); 2393322119Smarius switch (err) { 2394322119Smarius case 0: 2395322119Smarius break; 2396322119Smarius case EIO: 2397322119Smarius return (MMC_ERR_FAILED); 2398322119Smarius default: 2399322119Smarius return (MMC_ERR_INVALID); 2400322119Smarius } 2401322119Smarius if (timing == bus_timing_mmc_hs400) { 2402322119Smarius if (mmc_switch_to_hs400(sc, ivar, clock, timing) != 2403322119Smarius MMC_ERR_NONE) 2404322119Smarius return (MMC_ERR_BADCRC); 2405322119Smarius } 2406322119Smarius return (MMC_ERR_NONE); 2407322119Smarius} 2408322119Smarius 2409163516Simpstatic void 2410322119Smariusmmc_retune_pause(device_t busdev, device_t dev, bool retune) 2411322119Smarius{ 2412322119Smarius struct mmc_softc *sc; 2413322119Smarius 2414322119Smarius sc = device_get_softc(busdev); 2415322119Smarius KASSERT(device_get_parent(dev) == busdev, 2416322119Smarius ("%s: %s is not a child of %s", __func__, device_get_nameunit(dev), 2417322119Smarius device_get_nameunit(busdev))); 2418322119Smarius KASSERT(sc->owner != NULL, 2419322119Smarius ("%s: Request from %s without bus being acquired.", __func__, 2420322119Smarius device_get_nameunit(dev))); 2421322119Smarius 2422322119Smarius if (retune == true && sc->retune_paused == 0) 2423322119Smarius sc->retune_needed = 1; 2424322119Smarius sc->retune_paused++; 2425322119Smarius} 2426322119Smarius 2427322119Smariusstatic void 2428322119Smariusmmc_retune_unpause(device_t busdev, device_t dev) 2429322119Smarius{ 2430322119Smarius struct mmc_softc *sc; 2431322119Smarius 2432322119Smarius sc = device_get_softc(busdev); 2433322119Smarius KASSERT(device_get_parent(dev) == busdev, 2434322119Smarius ("%s: %s is not a child of %s", __func__, device_get_nameunit(dev), 2435322119Smarius device_get_nameunit(busdev))); 2436322119Smarius KASSERT(sc->owner != NULL, 2437322119Smarius ("%s: Request from %s without bus being acquired.", __func__, 2438322119Smarius device_get_nameunit(dev))); 2439322119Smarius KASSERT(sc->retune_paused != 0, 2440322119Smarius ("%s: Re-tune pause count already at 0", __func__)); 2441322119Smarius 2442322119Smarius sc->retune_paused--; 2443322119Smarius} 2444322119Smarius 2445322119Smariusstatic void 2446163516Simpmmc_scan(struct mmc_softc *sc) 2447163516Simp{ 2448185721Smav device_t dev = sc->dev; 2449322119Smarius int err; 2450163516Simp 2451322119Smarius err = mmc_acquire_bus(dev, dev); 2452322119Smarius if (err != 0) { 2453322119Smarius device_printf(dev, "Failed to acquire bus for scanning\n"); 2454322119Smarius return; 2455322119Smarius } 2456163516Simp mmc_go_discovery(sc); 2457322119Smarius err = mmc_release_bus(dev, dev); 2458322119Smarius if (err != 0) { 2459322119Smarius device_printf(dev, "Failed to release bus after scanning\n"); 2460322119Smarius return; 2461322119Smarius } 2462322119Smarius (void)bus_generic_attach(dev); 2463163516Simp} 2464163516Simp 2465163516Simpstatic int 2466189727Simpmmc_read_ivar(device_t bus, device_t child, int which, uintptr_t *result) 2467163516Simp{ 2468163516Simp struct mmc_ivars *ivar = device_get_ivars(child); 2469163516Simp 2470163516Simp switch (which) { 2471163516Simp default: 2472163516Simp return (EINVAL); 2473318197Smarius case MMC_IVAR_SPEC_VERS: 2474318197Smarius *result = ivar->csd.spec_vers; 2475318197Smarius break; 2476163516Simp case MMC_IVAR_DSR_IMP: 2477222475Sjchandra *result = ivar->csd.dsr_imp; 2478163516Simp break; 2479163516Simp case MMC_IVAR_MEDIA_SIZE: 2480222475Sjchandra *result = ivar->sec_count; 2481163516Simp break; 2482163516Simp case MMC_IVAR_RCA: 2483222475Sjchandra *result = ivar->rca; 2484163516Simp break; 2485163516Simp case MMC_IVAR_SECTOR_SIZE: 2486222475Sjchandra *result = MMC_SECTOR_SIZE; 2487163516Simp break; 2488163516Simp case MMC_IVAR_TRAN_SPEED: 2489222475Sjchandra *result = mmcbr_get_clock(bus); 2490163516Simp break; 2491183447Simp case MMC_IVAR_READ_ONLY: 2492222475Sjchandra *result = ivar->read_only; 2493183447Simp break; 2494183704Smav case MMC_IVAR_HIGH_CAP: 2495222475Sjchandra *result = ivar->high_cap; 2496183704Smav break; 2497183763Smav case MMC_IVAR_CARD_TYPE: 2498222475Sjchandra *result = ivar->mode; 2499183763Smav break; 2500183763Smav case MMC_IVAR_BUS_WIDTH: 2501222475Sjchandra *result = ivar->bus_width; 2502183763Smav break; 2503184033Smav case MMC_IVAR_ERASE_SECTOR: 2504222475Sjchandra *result = ivar->erase_sector; 2505184033Smav break; 2506184452Smav case MMC_IVAR_MAX_DATA: 2507222475Sjchandra *result = mmcbr_get_max_data(bus); 2508184452Smav break; 2509322388Smarius case MMC_IVAR_CMD6_TIMEOUT: 2510322388Smarius *result = ivar->cmd6_time; 2511322388Smarius break; 2512322388Smarius case MMC_IVAR_QUIRKS: 2513322388Smarius *result = ivar->quirks; 2514322388Smarius break; 2515234524Smarius case MMC_IVAR_CARD_ID_STRING: 2516234524Smarius *(char **)result = ivar->card_id_string; 2517234524Smarius break; 2518269341Sian case MMC_IVAR_CARD_SN_STRING: 2519269341Sian *(char **)result = ivar->card_sn_string; 2520269341Sian break; 2521163516Simp } 2522163516Simp return (0); 2523163516Simp} 2524163516Simp 2525163516Simpstatic int 2526163516Simpmmc_write_ivar(device_t bus, device_t child, int which, uintptr_t value) 2527163516Simp{ 2528318197Smarius 2529183453Simp /* 2530183453Simp * None are writable ATM 2531183453Simp */ 2532183453Simp return (EINVAL); 2533163516Simp} 2534163516Simp 2535163516Simpstatic void 2536163516Simpmmc_delayed_attach(void *xsc) 2537163516Simp{ 2538163516Simp struct mmc_softc *sc = xsc; 2539312399Smarius 2540163516Simp mmc_scan(sc); 2541163516Simp config_intrhook_disestablish(&sc->config_intrhook); 2542163516Simp} 2543163516Simp 2544208441Smavstatic int 2545208441Smavmmc_child_location_str(device_t dev, device_t child, char *buf, 2546208441Smav size_t buflen) 2547208441Smav{ 2548208441Smav 2549208441Smav snprintf(buf, buflen, "rca=0x%04x", mmc_get_rca(child)); 2550208441Smav return (0); 2551208441Smav} 2552208441Smav 2553163516Simpstatic device_method_t mmc_methods[] = { 2554163516Simp /* device_if */ 2555163516Simp DEVMETHOD(device_probe, mmc_probe), 2556163516Simp DEVMETHOD(device_attach, mmc_attach), 2557163516Simp DEVMETHOD(device_detach, mmc_detach), 2558185721Smav DEVMETHOD(device_suspend, mmc_suspend), 2559185721Smav DEVMETHOD(device_resume, mmc_resume), 2560163516Simp 2561163516Simp /* Bus interface */ 2562163516Simp DEVMETHOD(bus_read_ivar, mmc_read_ivar), 2563163516Simp DEVMETHOD(bus_write_ivar, mmc_write_ivar), 2564208441Smav DEVMETHOD(bus_child_location_str, mmc_child_location_str), 2565163516Simp 2566163516Simp /* MMC Bus interface */ 2567322119Smarius DEVMETHOD(mmcbus_retune_pause, mmc_retune_pause), 2568322119Smarius DEVMETHOD(mmcbus_retune_unpause, mmc_retune_unpause), 2569163516Simp DEVMETHOD(mmcbus_wait_for_request, mmc_wait_for_request), 2570163516Simp DEVMETHOD(mmcbus_acquire_bus, mmc_acquire_bus), 2571163516Simp DEVMETHOD(mmcbus_release_bus, mmc_release_bus), 2572163516Simp 2573234524Smarius DEVMETHOD_END 2574163516Simp}; 2575163516Simp 2576292180Siandriver_t mmc_driver = { 2577163516Simp "mmc", 2578163516Simp mmc_methods, 2579163516Simp sizeof(struct mmc_softc), 2580163516Simp}; 2581292180Siandevclass_t mmc_devclass; 2582297127Sian 2583318197SmariusMODULE_VERSION(mmc, MMC_VERSION); 2584