| // 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 "sdmmc.h" |
| |
| #define TRACE 0 |
| |
| #if TRACE |
| #define xprintf(fmt...) printf(fmt) |
| #else |
| #define xprintf(fmt...) \ |
| do { \ |
| } while (0) |
| #endif |
| |
| // If this bit is set in the Operating Conditions Register, then we know that |
| // the card is a SDHC (high capacity) card. |
| #define OCR_SDHC 0xc0000000 |
| |
| // The "STRUCTURE" field of the "Card Specific Data" register defines the |
| // version of the structure and how to interpret the rest of the bits. |
| #define CSD_STRUCT_V1 0x0 |
| #define CSD_STRUCT_V2 0x1 |
| |
| zx_status_t sdmmc_probe_sd(sdmmc_t* sdmmc, iotxn_t* setup_txn) { |
| zx_status_t st; |
| |
| // Get the protocol data from the iotxn. We use this to pass the command |
| // type and command arguments to the EMMC driver. |
| sdmmc_protocol_data_t* pdata = |
| iotxn_pdata(setup_txn, sdmmc_protocol_data_t); |
| |
| // Issue the SEND_IF_COND command, this will tell us that we can talk to |
| // the card correctly and it will also tell us if the voltage range that we |
| // have supplied has been accepted. |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_SEND_IF_COND, 0x1aa, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: SDMMC_SEND_IF_COND failed, retcode = %d\n", st); |
| goto err; |
| } |
| if ((pdata->response[0] & 0xFFF) != 0x1aa) { |
| // The card should have replied with the pattern that we sent. |
| xprintf("sdmmc: SDMMC_SEND_IF_COND got bad reply = %"PRIu32"\n", |
| pdata->response[0]); |
| goto err; |
| } |
| |
| // Get the operating conditions from the card. |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_APP_CMD, 0, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: SDMMC_APP_CMD failed, retcode = %d\n", st); |
| goto err; |
| } |
| if ((sdmmc_do_command(sdmmc->host_mxdev, SDMMC_SD_SEND_OP_COND, 0, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: SDMMC_SD_SEND_OP_COND failed, retcode = %d\n", st); |
| goto err; |
| } |
| |
| int attempt = 0; |
| const int max_attempts = 10; |
| bool card_supports_18v_signalling = false; |
| while (true) { |
| // Ask for high speed. |
| const uint32_t flags = (1 << 30) | 0x00ff8000 | (1 << 24); |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_APP_CMD, 0, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: APP_CMD failed with retcode = %d\n", st); |
| goto err; |
| } |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_SD_SEND_OP_COND, flags, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: SD_SEND_OP_COND failed with retcode = %d\n", st); |
| goto err; |
| } |
| |
| const uint32_t ocr = pdata->response[0]; |
| if (ocr & (1 << 31)) { |
| if (!(ocr & OCR_SDHC)) { |
| // Card is not an SDHC card. We currently don't support this. |
| xprintf("sdmmc: unsupported card type, must use sdhc card\n"); |
| goto err; |
| } |
| card_supports_18v_signalling = !!((ocr >> 24) & 0x1); |
| break; |
| } |
| |
| if (++attempt == max_attempts) { |
| xprintf("sdmmc: too many attempt trying to negotiate card OCR\n"); |
| goto err; |
| } |
| |
| zx_nanosleep(zx_deadline_after(ZX_MSEC(5))); |
| } |
| |
| uint32_t new_bus_frequency = 25000000; |
| st = device_ioctl(sdmmc->host_mxdev, IOCTL_SDMMC_SET_BUS_FREQ, &new_bus_frequency, |
| sizeof(new_bus_frequency), NULL, 0, NULL); |
| if (st != ZX_OK) { |
| // This is non-fatal but the card will run slowly. |
| xprintf("sdmmc: failed to increase bus frequency.\n"); |
| } |
| |
| // Try to switch the bus voltage to 1.8v |
| if (card_supports_18v_signalling) { |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_VOLTAGE_SWITCH, 0, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: failed to send switch voltage command to card, " |
| "retcode = %d\n", st); |
| goto err; |
| } |
| |
| const uint32_t new_voltage = SDMMC_SIGNAL_VOLTAGE_180; |
| st = device_ioctl(sdmmc->host_mxdev, IOCTL_SDMMC_SET_SIGNAL_VOLTAGE, &new_voltage, |
| sizeof(new_voltage), NULL, 0, NULL); |
| if (st != ZX_OK) { |
| xprintf("sdmmc: Card supports 1.8v signalling but was unable to " |
| "switch to 1.8v mode, retcode = %d\n", st); |
| goto err; |
| } |
| } |
| |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_ALL_SEND_CID, 0, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: ALL_SEND_CID failed with retcode = %d\n", st); |
| goto err; |
| } |
| |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_SEND_RELATIVE_ADDR, 0, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: SEND_RELATIVE_ADDR failed with retcode = %d\n", st); |
| goto err; |
| } |
| |
| sdmmc->type = SDMMC_TYPE_SD; |
| sdmmc->rca = (pdata->response[0] >> 16) & 0xffff; |
| if (pdata->response[0] & 0xe000) { |
| xprintf("sdmmc: SEND_RELATIVE_ADDR failed with resp = %d\n", |
| (pdata->response[0] & 0xe000)); |
| st = ZX_ERR_INTERNAL; |
| goto err; |
| } |
| if ((pdata->response[0] & (1u << 8)) == 0) { |
| xprintf("sdmmc: SEND_RELATIVE_ADDR failed. Card not ready.\n"); |
| st = ZX_ERR_INTERNAL; |
| goto err; |
| } |
| |
| // Determine the size of the card. |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_SEND_CSD, sdmmc->rca << 16, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: failed to send app cmd, retcode = %d\n", st); |
| goto err; |
| } |
| |
| // For now we only support SDHC cards. These cards must have a CSD type = 1, |
| // since CSD type 0 is unable to support SDHC sized cards. |
| uint8_t csd_structure = (pdata->response[0] >> 30) & 0x3; |
| if (csd_structure != CSD_STRUCT_V2) { |
| xprintf("sdmmc: unsupported card type, expected CSD version = %d, " |
| "got version %d\n", CSD_STRUCT_V2, csd_structure); |
| goto err; |
| } |
| |
| const uint32_t c_size = ((pdata->response[2] >> 16) | |
| (pdata->response[1] << 16)) & 0x3fffff; |
| sdmmc->capacity = (c_size + 1ul) * 512ul * 1024ul; |
| printf("sdmmc: found card with capacity = %"PRIu64"B\n", sdmmc->capacity); |
| |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_SELECT_CARD, sdmmc->rca << 16, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: SELECT_CARD failed with retcode = %d\n", st); |
| goto err; |
| } |
| |
| pdata->blockcount = 1; |
| pdata->blocksize = 8; |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_APP_CMD, sdmmc->rca << 16, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: APP_CMD failed with retcode = %d\n", st); |
| goto err; |
| } |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_SEND_SCR, 0, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: SEND_SCR failed with retcode = %d\n", st); |
| goto err; |
| } |
| pdata->blockcount = 512; |
| pdata->blocksize = 1; |
| |
| uint32_t scr; |
| iotxn_copyfrom(setup_txn, &scr, sizeof(scr), 0); |
| scr = be32toh(scr); |
| |
| // If this card supports 4 bit mode, then put it into 4 bit mode. |
| const uint32_t supported_bus_widths = (scr >> 16) & 0xf; |
| if (supported_bus_widths & 0x4) { |
| |
| do { |
| // First tell the card to go into four bit mode: |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_APP_CMD, sdmmc->rca << 16, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: failed to send app cmd, retcode = %d\n", st); |
| break; |
| } |
| if ((st = sdmmc_do_command(sdmmc->host_mxdev, SDMMC_SET_BUS_WIDTH, 2, setup_txn)) != ZX_OK) { |
| xprintf("sdmmc: failed to set card bus width, retcode = %d\n", st); |
| break; |
| } |
| const uint32_t new_bus_width = SDMMC_BUS_WIDTH_4; |
| // FIXME(yky) use #define |
| st = device_ioctl(sdmmc->host_mxdev, IOCTL_SDMMC_SET_BUS_WIDTH, &new_bus_width, |
| sizeof(new_bus_width), NULL, 0, NULL); |
| if (st != ZX_OK) { |
| xprintf("sdmmc: failed to set host bus width, retcode = %d\n", st); |
| } |
| } while (false); |
| } |
| |
| err: |
| return st; |
| } |
| |
