| // Copyright 2017 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <inttypes.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include <ddk/device.h> |
| #include <ddk/protocol/sdmmc.h> |
| |
| #include <pretty/hexdump.h> |
| |
| #include "sdmmc.h" |
| |
| #define TRACE 0 |
| |
| #if TRACE |
| #define xprintf(fmt...) printf(fmt) |
| #else |
| #define xprintf(fmt...) \ |
| do { \ |
| } while (0) |
| #endif |
| |
| static zx_status_t mmc_send_op_cond(sdmmc_t* sdmmc, iotxn_t* txn, uint32_t ocr, uint32_t* rocr) { |
| sdmmc_protocol_data_t* pdata = iotxn_pdata(txn, sdmmc_protocol_data_t); |
| zx_status_t st; |
| // Request sector addressing if not probing |
| uint32_t arg = (ocr == 0) ? ocr : ((1 << 30) | ocr); |
| for (int i = 100; i; i--) { |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, MMC_SEND_OP_COND, arg, txn)) != ZX_OK) { |
| // fail on txn error |
| break; |
| } |
| // No need to wait for busy clear if probing |
| if ((arg == 0) || (pdata->response[0] & (1 << 31))) { |
| *rocr = pdata->response[0]; |
| break; |
| } |
| zx_nanosleep(zx_deadline_after(ZX_MSEC(10))); |
| } |
| return st; |
| } |
| |
| static zx_status_t mmc_all_send_cid(sdmmc_t* sdmmc, iotxn_t* txn, uint32_t cid[4]) { |
| sdmmc_protocol_data_t* pdata = iotxn_pdata(txn, sdmmc_protocol_data_t); |
| zx_status_t st; |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, MMC_ALL_SEND_CID, 0, txn)) == ZX_OK) { |
| cid[0] = pdata->response[0]; |
| cid[1] = pdata->response[1]; |
| cid[2] = pdata->response[2]; |
| cid[3] = pdata->response[3]; |
| } |
| return st; |
| } |
| |
| static zx_status_t mmc_set_relative_addr(sdmmc_t* sdmmc, iotxn_t* txn, uint16_t rca) { |
| return sdmmc_do_command(sdmmc->host_mxdev, MMC_SET_RELATIVE_ADDR, (rca << 16), txn); |
| } |
| |
| static zx_status_t mmc_send_csd(sdmmc_t* sdmmc, iotxn_t* txn, uint32_t csd[4]) { |
| sdmmc_protocol_data_t* pdata = iotxn_pdata(txn, sdmmc_protocol_data_t); |
| zx_status_t st; |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, MMC_SEND_CSD, sdmmc->rca << 16, txn)) == ZX_OK) { |
| csd[0] = pdata->response[0]; |
| csd[1] = pdata->response[1]; |
| csd[2] = pdata->response[2]; |
| csd[3] = pdata->response[3]; |
| } |
| return st; |
| } |
| |
| static zx_status_t mmc_send_ext_csd(sdmmc_t* sdmmc, iotxn_t* txn, uint8_t ext_csd[512]) { |
| sdmmc_protocol_data_t* pdata = iotxn_pdata(txn, sdmmc_protocol_data_t); |
| zx_status_t st; |
| // EXT_CSD is send in a data stage |
| pdata->blockcount = 1; |
| pdata->blocksize = 512; |
| txn->length = 512; |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, MMC_SEND_EXT_CSD, 0, txn)) == ZX_OK) { |
| iotxn_copyfrom(txn, ext_csd, 512, 0); |
| #if 0 |
| xprintf("EXT_CSD:\n"); |
| hexdump8_ex(ext_csd, 512, 0); |
| #endif |
| } |
| pdata->blockcount = 0; |
| pdata->blocksize = 0; |
| txn->length = 0; |
| return st; |
| } |
| |
| static zx_status_t mmc_select_card(sdmmc_t* sdmmc, iotxn_t* txn) { |
| return sdmmc_do_command(sdmmc->host_mxdev, MMC_SELECT_CARD, sdmmc->rca << 16, txn); |
| } |
| |
| static zx_status_t mmc_switch(sdmmc_t* sdmmc, iotxn_t* txn, uint8_t index, uint8_t value) { |
| uint32_t arg = (3 << 24) | // write byte |
| (index << 16) | (value << 8); |
| return sdmmc_do_command(sdmmc->host_mxdev, MMC_SWITCH, arg, txn); |
| } |
| |
| static zx_status_t mmc_send_status(sdmmc_t* sdmmc, iotxn_t* txn, uint32_t* status) { |
| sdmmc_protocol_data_t* pdata = iotxn_pdata(txn, sdmmc_protocol_data_t); |
| zx_status_t st = sdmmc_do_command(sdmmc->host_mxdev, MMC_SEND_STATUS, sdmmc->rca << 16, txn); |
| if (st == ZX_OK) { |
| *status = pdata->response[0]; |
| } |
| return st; |
| } |
| |
| static uint8_t mmc_select_bus_width(sdmmc_t* sdmmc, iotxn_t* txn) { |
| zx_status_t st; |
| // TODO verify host 8-bit support |
| unsigned bus_widths[] = { SDMMC_BUS_WIDTH_8, MMC_EXT_CSD_BUS_WIDTH_8, |
| SDMMC_BUS_WIDTH_4, MMC_EXT_CSD_BUS_WIDTH_4 }; |
| for (unsigned i = 0; i < sizeof(bus_widths)/sizeof(unsigned); i += 2) { |
| // Switch the card to the new bus width |
| if ((st = mmc_switch(sdmmc, txn, MMC_EXT_CSD_BUS_WIDTH, bus_widths[i+1])) != ZX_OK) { |
| xprintf("sdmmc: failed to MMC_SWITCH bus width to EXT_CSD %d, retcode = %d\n", bus_widths[i+1], st); |
| continue; |
| } |
| |
| // Check status after MMC_SWITCH |
| uint32_t status; |
| if ((st = mmc_send_status(sdmmc, txn, &status)) != ZX_OK) { |
| xprintf("sdmmc: failed to MMC_SEND_STATUS (bus width %d), retcode = %d\n", bus_widths[i], st); |
| continue; |
| } |
| if (status & MMC_STATUS_SWITCH_ERR) { |
| xprintf("sdmmc: mmc status error after MMC_SWITCH (bus width %d), status = 0x%08x\n", bus_widths[i], status); |
| continue; |
| } |
| |
| // Switch the host to the new bus width |
| uint32_t new_bus_width = bus_widths[i]; |
| if ((st = device_ioctl(sdmmc->host_mxdev, IOCTL_SDMMC_SET_BUS_WIDTH, &new_bus_width, sizeof(new_bus_width), NULL, 0, NULL)) != ZX_OK) { |
| xprintf("sdmmc: failed to switch the host bus width to %d, retcode = %d\n", bus_widths[i], st); |
| continue; |
| } |
| |
| // Read EXT_CSD again with the new bus width and compare |
| uint8_t new_ext_csd[512]; |
| if ((st = mmc_send_ext_csd(sdmmc, txn, new_ext_csd)) != ZX_OK) { |
| xprintf("sdmmc: failed to get EXT_CSD after switching bus width to %d, retcode = %d\n", bus_widths[i], st); |
| continue; |
| } |
| // Don't compare the BUS_WIDTH field because we just wrote to it |
| // TODO just compare the read-only fields |
| bool err = false; |
| for (unsigned j = 0; j < sizeof(new_ext_csd); j++) { |
| if (j == MMC_EXT_CSD_BUS_WIDTH) { |
| continue; |
| } |
| if (new_ext_csd[j] != sdmmc->raw_ext_csd[j]) { |
| err = true; |
| break; |
| } |
| } |
| if (err) { |
| xprintf("sdmmc: failed to switch to bus width %d\n", bus_widths[i]); |
| continue; |
| } |
| |
| sdmmc->bus_width = bus_widths[i]; |
| break; // successfully set bus width so no need to loop |
| } |
| return sdmmc->bus_width; |
| } |
| |
| static zx_status_t mmc_switch_timing(sdmmc_t* sdmmc, iotxn_t* txn, uint8_t new_timing) { |
| if (new_timing > MMC_EXT_CSD_HS_TIMING_HS400) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| // Switch the device timing |
| uint8_t ext_csd_timing[] = { |
| MMC_EXT_CSD_HS_TIMING_LEGACY, |
| MMC_EXT_CSD_HS_TIMING_HS, |
| MMC_EXT_CSD_HS_TIMING_HS200, |
| MMC_EXT_CSD_HS_TIMING_HS400 |
| }; |
| zx_status_t st = mmc_switch(sdmmc, txn, MMC_EXT_CSD_HS_TIMING, ext_csd_timing[new_timing]); |
| if (st != ZX_OK) { |
| xprintf("sdmmc: failed to switch device timing to %d\n", new_timing); |
| return st; |
| } |
| |
| // Switch the host timing |
| uint32_t arg = new_timing; |
| if ((st = device_ioctl(sdmmc->host_mxdev, IOCTL_SDMMC_SET_TIMING, &arg, sizeof(arg), NULL, 0, NULL)) != ZX_OK) { |
| xprintf("sdmmc: failed to switch host timing to %d\n", new_timing); |
| return st; |
| } |
| |
| // Check status after MMC_SWITCH |
| uint32_t status; |
| if ((st = mmc_send_status(sdmmc, txn, &status)) != ZX_OK) { |
| return st; |
| } |
| if (status & MMC_STATUS_SWITCH_ERR) { |
| xprintf("sdmmc: mmc status error after MMC_SWITCH, status = 0x%08x\n", status); |
| return ZX_ERR_INTERNAL; |
| } |
| |
| sdmmc->timing = new_timing; |
| return st; |
| } |
| |
| static zx_status_t mmc_decode_cid(sdmmc_t* sdmmc, const uint8_t* raw_cid) { |
| printf("sdmmc: product name=%c%c%c%c%c%c\n", |
| raw_cid[6], raw_cid[7], raw_cid[8], raw_cid[9], raw_cid[10], raw_cid[11]); |
| printf(" revision=%u.%u\n", (raw_cid[5] >> 4) & 0xf, raw_cid[5] & 0xf); |
| printf(" serial=%u\n", *((uint32_t*)&raw_cid[1])); |
| return ZX_OK; |
| } |
| |
| static zx_status_t mmc_decode_csd(sdmmc_t* sdmmc, const uint8_t* raw_csd) { |
| uint8_t spec_vrsn = (raw_csd[14] >> 2) & 0xf; |
| // Only support spec version > 4.0 |
| if (spec_vrsn < MMC_CID_SPEC_VRSN_40) { |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| |
| xprintf("sdmmc: CSD version %u spec version %u\n", (raw_csd[14] >> 6) & 0x3, spec_vrsn); |
| #if 0 |
| xprintf("CSD:\n"); |
| hexdump8_ex(raw_csd, 16, 0); |
| #endif |
| |
| // Only support high capacity (> 2GB) cards |
| uint16_t c_size = ((raw_csd[6] >> 6) & 0x3) | |
| (raw_csd[7] << 2) | |
| ((raw_csd[8] & 0x3) << 10); |
| if (c_size != 0xfff) { |
| xprintf("sdmmc: unsupported C_SIZE 0x%04x\n", c_size); |
| return ZX_ERR_NOT_SUPPORTED; |
| } |
| return ZX_OK; |
| } |
| |
| static zx_status_t mmc_decode_ext_csd(sdmmc_t* sdmmc, const uint8_t* raw_ext_csd) { |
| xprintf("sdmmc: EXT_CSD version %u CSD version %u\n", raw_ext_csd[192], raw_ext_csd[194]); |
| |
| // Get the capacity for the card |
| uint32_t sectors = (raw_ext_csd[212] << 0) | (raw_ext_csd[213] << 8) | (raw_ext_csd[214] << 16) | (raw_ext_csd[215] << 24); |
| sdmmc->capacity = sectors * 512ul; |
| |
| printf("sdmmc: found card with capacity = %" PRIu64 "B\n", sdmmc->capacity); |
| |
| return ZX_OK; |
| } |
| |
| static bool mmc_supports_hs(sdmmc_t* sdmmc) { |
| uint8_t device_type = sdmmc->raw_ext_csd[MMC_EXT_CSD_DEVICE_TYPE]; |
| return (device_type & (1 << 1)); |
| } |
| |
| static bool mmc_supports_hsddr(sdmmc_t* sdmmc) { |
| uint8_t device_type = sdmmc->raw_ext_csd[MMC_EXT_CSD_DEVICE_TYPE]; |
| // Only support HSDDR @ 1.8V/3V |
| return (device_type & (1 << 2)); |
| } |
| |
| static bool mmc_supports_hs200(sdmmc_t* sdmmc) { |
| uint8_t device_type = sdmmc->raw_ext_csd[MMC_EXT_CSD_DEVICE_TYPE]; |
| // Only support HS200 @ 1.8V |
| return (device_type & (1 << 4)); |
| } |
| |
| zx_status_t sdmmc_probe_mmc(sdmmc_t* sdmmc, iotxn_t* setup_txn) { |
| zx_status_t st; |
| |
| // Query OCR |
| uint32_t ocr = 0; |
| if ((st = mmc_send_op_cond(sdmmc, setup_txn, ocr, &ocr)) != ZX_OK) { |
| xprintf("sdmmc: MMC_SEND_OP_COND failed, retcode = %d\n", st); |
| goto err; |
| } |
| |
| // Check if the card matches the host's supported voltages and indicate sector mode |
| // TODO check with host |
| if ((st = mmc_send_op_cond(sdmmc, setup_txn, ocr, &ocr)) != ZX_OK) { |
| xprintf("sdmmc: MMC_SEND_OP_COND failed, retcode = %d\n", st); |
| goto err; |
| } |
| |
| // Get CID from card |
| // Only 1 card on eve so no need to loop |
| if ((st = mmc_all_send_cid(sdmmc, setup_txn, sdmmc->raw_cid)) != ZX_OK) { |
| xprintf("sdmmc: MMC_ALL_SEND_CID failed, retcode = %d\n", st); |
| goto err; |
| } |
| xprintf("sdmmc: MMC_ALL_SEND_CID cid 0x%08x 0x%08x 0x%08x 0x%08x\n", |
| sdmmc->raw_cid[0], |
| sdmmc->raw_cid[1], |
| sdmmc->raw_cid[2], |
| sdmmc->raw_cid[3]); |
| |
| mmc_decode_cid(sdmmc, (const uint8_t*)sdmmc->raw_cid); |
| |
| // Set relative card address |
| sdmmc->rca = 1; |
| if ((st = mmc_set_relative_addr(sdmmc, setup_txn, sdmmc->rca)) != ZX_OK) { |
| xprintf("sdmmc: MMC_SET_RELATIVE_ADDR failed, retcode = %d\n", st); |
| goto err; |
| } |
| |
| // Read CSD register |
| if ((st = mmc_send_csd(sdmmc, setup_txn, sdmmc->raw_csd)) != ZX_OK) { |
| xprintf("sdmmc: MMC_SEND_CSD failed, retcode = %d\n", st); |
| goto err; |
| } |
| |
| if ((st = mmc_decode_csd(sdmmc, (const uint8_t*)sdmmc->raw_csd)) != ZX_OK) { |
| goto err; |
| } |
| |
| // Select the card |
| if ((st = mmc_select_card(sdmmc, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: MMC_SELECT_CARD failed, retcode = %d\n", st); |
| goto err; |
| } |
| |
| // Read extended CSD register |
| if ((st = mmc_send_ext_csd(sdmmc, setup_txn, sdmmc->raw_ext_csd)) != ZX_OK) { |
| xprintf("sdmmc: MMC_SEND_EXT_CSD failed, retcode = %d\n", st); |
| goto err; |
| } |
| |
| if ((st = mmc_decode_ext_csd(sdmmc, (const uint8_t*)sdmmc->raw_ext_csd)) != ZX_OK) { |
| goto err; |
| } |
| |
| sdmmc->type = SDMMC_TYPE_MMC; |
| sdmmc->bus_width = SDMMC_BUS_WIDTH_1; |
| sdmmc->signal_voltage = SDMMC_SIGNAL_VOLTAGE_330; // TODO verify with host |
| |
| // Switch to high-speed timing |
| if (mmc_supports_hs(sdmmc)) { |
| // Switch to 1.8V signal voltage |
| const uint32_t new_voltage = SDMMC_SIGNAL_VOLTAGE_180; |
| if ((st = device_ioctl(sdmmc->host_mxdev, IOCTL_SDMMC_SET_SIGNAL_VOLTAGE, &new_voltage, |
| sizeof(new_voltage), NULL, 0, NULL)) != ZX_OK) { |
| xprintf("sdmmc: failed to switch to 1.8V signalling, retcode = %d\n", st); |
| goto err; |
| } |
| sdmmc->signal_voltage = new_voltage; |
| |
| // Switch to widest supported bus width |
| uint32_t new_bus_width = mmc_select_bus_width(sdmmc, setup_txn); |
| if (new_bus_width == SDMMC_BUS_WIDTH_1) { |
| xprintf("sdmmc: failed to select bus width\n"); |
| goto err; |
| } |
| |
| // If successfully switched to 4- or 8-bit bus, switch to high-speed timing |
| if ((st = mmc_switch_timing(sdmmc, setup_txn, SDMMC_TIMING_HS)) != ZX_OK) { |
| xprintf("sdmmc: failed to switch to high-speed timing\n"); |
| goto err; |
| } |
| |
| // Set the bus frequency to high-speed timing |
| uint32_t hs_freq = 52000000; // 52 mhz |
| if ((st = device_ioctl(sdmmc->host_mxdev, IOCTL_SDMMC_SET_BUS_FREQ, &hs_freq, sizeof(hs_freq), NULL, 0, NULL)) != ZX_OK) { |
| xprintf("sdmmc: failed to set host bus frequency, retcode = %d\n", st); |
| goto err; |
| } |
| sdmmc->clock_rate = hs_freq; |
| } else { |
| // Set the bus frequency to legacy timing |
| uint32_t bus_freq = 25000000; // 25 mhz |
| if ((st = device_ioctl(sdmmc->host_mxdev, IOCTL_SDMMC_SET_BUS_FREQ, &bus_freq, sizeof(bus_freq), NULL, 0, NULL)) != ZX_OK) { |
| xprintf("sdmmc: failed to set host bus frequency, retcode = %d\n", st); |
| goto err; |
| } |
| sdmmc->clock_rate = bus_freq; |
| sdmmc->timing = SDMMC_TIMING_LEGACY; |
| } |
| |
| xprintf("sdmmc: initialized mmc @ %u mhz bus width %d\n", sdmmc->clock_rate, sdmmc->bus_width); |
| |
| err: |
| return st; |
| } |
