2023-10-13 08:34:52

by liuchang_125125

Subject: [PATCH 3/9] scsi: bht: card: Add the source files related to card initialization

From: Charl Liu <[email protected]>

1.card_ddr200_support: check whether the card supports DDR200/DDR225 mode
2.cardcommon: define common functions related to card initialization
3.cardinterface: implement card initialization main flow and define
the functions related to card operations
4.mmc: define the functions related to MMC/eMMC card initialization
5.output_tuning: implement card tuning flow and related functions
6.sd: implement SD legacy card initialization flow and related functions
7.thermal: define the functions related to thermal control
8.uhs2: implement SD UHS2 card initialization flow and related functions

Signed-off-by: Charl Liu <[email protected]>
---
Change in V1:
Add the source files related to card initialization.
---
drivers/scsi/bht/card/card_ddr200_support.c | 195 ++
drivers/scsi/bht/card/card_ddr200_support.h | 38 +
drivers/scsi/bht/card/cardcommon.c | 961 ++++++
drivers/scsi/bht/card/cardcommon.h | 123 +
drivers/scsi/bht/card/cardinterface.c | 2448 +++++++++++++++
drivers/scsi/bht/card/mmc.c | 1666 ++++++++++
drivers/scsi/bht/card/output_tuning.c | 756 +++++
drivers/scsi/bht/card/sd.c | 3029 +++++++++++++++++++
drivers/scsi/bht/card/thermal.c | 348 +++
drivers/scsi/bht/card/uhs2.c | 1228 ++++++++
10 files changed, 10792 insertions(+)
create mode 100644 drivers/scsi/bht/card/card_ddr200_support.c
create mode 100644 drivers/scsi/bht/card/card_ddr200_support.h
create mode 100644 drivers/scsi/bht/card/cardcommon.c
create mode 100644 drivers/scsi/bht/card/cardcommon.h
create mode 100644 drivers/scsi/bht/card/cardinterface.c
create mode 100644 drivers/scsi/bht/card/mmc.c
create mode 100644 drivers/scsi/bht/card/output_tuning.c
create mode 100644 drivers/scsi/bht/card/sd.c
create mode 100644 drivers/scsi/bht/card/thermal.c
create mode 100644 drivers/scsi/bht/card/uhs2.c

diff --git a/drivers/scsi/bht/card/card_ddr200_support.c b/drivers/scsi/bht/card/card_ddr200_support.c
new file mode 100644
index 000000000000..b7fb935d700c
--- /dev/null
+++ b/drivers/scsi/bht/card/card_ddr200_support.c
@@ -0,0 +1,195 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2014 BHT Inc.
+ *
+ * File Name: card_ddr200_support.c
+ *
+ * Abstract: check whether the card supports DDR200/DDR225 mode
+ *
+ * Version: 1.00
+ *
+ * Author: Fred
+ *
+ * Environment: OS Independent
+ *
+ * History:
+ *
+ * 12/17/2021 Creation Fred
+ */
+
+#include "../include/basic.h"
+#include "../include/hostapi.h"
+#include "../include/debug.h"
+#include "card_ddr200_support.h"
+
+bool sandisk_ddr_support(sd_card_t *card, bool ddr_mode)
+{
+ bool ret = FALSE;
+ u32 prv_tmp;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "oemid is 0x%04x,\n"
+ "prod_name[0] is %x,\n"
+ "prod_name[1] is %x,\n"
+ "prod_name[2] is %x,\n"
+ "prod_name[3] is %x,\n"
+ "prod_name[4] is %x,\n"
+ "prv is 0x%x\n", card->info.cid.oemid,
+ card->info.cid.prod_name[0], card->info.cid.prod_name[1],
+ card->info.cid.prod_name[2], card->info.cid.prod_name[3],
+ card->info.cid.prod_name[4], card->info.cid.prv);
+
+ /*
+ * check whether support DDR200 or DDR225
+ * support DDR200 mode if prv is 0x85
+ * support DDR225 mode if prv is 0x86
+ */
+ if (ddr_mode)
+ prv_tmp = 0x85;
+ else
+ prv_tmp = 0x86;
+
+ if (card->info.cid.oemid == 0x4453
+ && card->info.cid.prod_name[0] == 0x53
+ && (card->info.cid.prod_name[1] == 0x4E
+ || card->info.cid.prod_name[1] == 0x46
+ || card->info.cid.prod_name[1] == 0x52))
+ ret = TRUE;
+ else if ((card->info.cid.oemid == 0x4453
+ || card->info.cid.oemid == 0x5744)
+ && card->info.cid.prv == prv_tmp)
+ ret = TRUE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+bool lexar_transend_ddr200_support(sd_card_t *card)
+{
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "reserved is 0x%x, Group 2 vendor spcific is 0x%x\n",
+ card->info.cid.reserved,
+ card_info->sw_func_cap.sd_command_system);
+
+ if ((card->info.cid.reserved == 0xA)
+ && ((card_info->sw_func_cap.sd_command_system) & (1 << 6)))
+ ret = TRUE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+bool phison_kingston_ddr200_support(sd_card_t *card)
+{
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "sd_specx is 0x%04x, reserved_B0 is 0x%04x, reserved_B1 is 0x%04x\n",
+ card_info->scr.sd_specx, card_info->scr.reserved_B0,
+ card_info->scr.reserved_B1);
+
+ if ((card_info->scr.sd_specx >= 2)
+ && (card_info->scr.reserved_B0 == 0x32)
+ && (card_info->scr.reserved_B1 == 0x64))
+ ret = TRUE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+bool manuefecture_ddr200_support(sd_card_t *card, u32 check_methood)
+{
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ card->ddr225_card_flag = FALSE;
+
+ if (card->info.cid.prv == 0x86) {
+ ret = sandisk_ddr_support(card, FALSE);
+ if (ret) {
+ card->ddr225_card_flag = TRUE;
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "DDR225 Check Stag: host support DDR225 mode\n");
+ } else {
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "DDR225 Check Stag: host not support DDR225 mode\n");
+ }
+
+ goto exit;
+ }
+
+ switch (check_methood) {
+ case SANDISK:
+ ret = sandisk_ddr_support(card, TRUE);
+ break;
+ case LEXAR:
+ case TRANSEND:
+ ret = lexar_transend_ddr200_support(card);
+ break;
+ case PHISON:
+ case KINGSTON:
+ ret = phison_kingston_ddr200_support(card);
+ break;
+ default:
+ break;
+ }
+
+exit:
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+bool sd_ddr_support(sd_card_t *card)
+{
+ byte i = 0;
+ bool ret = FALSE;
+ sd_host_t *host = card->host;
+ card_info_t *card_info = &(card->info);
+ cfg_item_t *cfg = card->host->cfg;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if ((sdhci_readl(host, 0x110) & (1 << 16)) &&
+ (sdhci_readl(host, 0x3e) & (1 << 3))) {
+ if ((card_info->sw_func_cap.sd_access_mode & (1 << 3)) &&
+ (card_info->sw_func_cap.sd_command_system) & (1 << 6)) {
+ while (i <= MAX_DDR200_CHECK_METHOD) {
+ ret = manuefecture_ddr200_support(card, i);
+ if (ret)
+ break;
+
+ i++;
+ }
+ }
+ }
+
+ /*
+ * 1.card support DDR200
+ * 2.driver registry control
+ */
+ if (ret && (cfg->card_item.test_max_access_mode.value == 0x5))
+ ret = TRUE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+
+ return ret;
+}
diff --git a/drivers/scsi/bht/card/card_ddr200_support.h b/drivers/scsi/bht/card/card_ddr200_support.h
new file mode 100644
index 000000000000..a984a0dc01b4
--- /dev/null
+++ b/drivers/scsi/bht/card/card_ddr200_support.h
@@ -0,0 +1,38 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2014 BHT Inc.
+ *
+ * File Name: card_ddr200_support.h
+ *
+ * Abstract: the functon declaration about checking whether the card supports DDR200/DDR225 mode
+ *
+ * Version: 1.00
+ *
+ * Author: Fred
+ *
+ * Environment: OS Independent
+ *
+ * History:
+ *
+ * 12/17/2021 Creation Fred
+ */
+
+#ifndef _CARD_DDR200_SUPPORT_H
+#define _CARD_DDR200_SUPPORT_H
+
+#include "../include/card.h"
+
+#define MAX_DDR200_CHECK_METHOD 0x4
+#define SANDISK 0x0
+#define LEXAR 0x1
+#define TRANSEND 0x2
+#define PHISON 0x3
+#define KINGSTON 0x4
+
+bool sandisk_ddr_support(sd_card_t *card, bool ddr_mode);
+bool lexar_transend_ddr200_support(sd_card_t *card);
+bool phison_kingston_ddr200_support(sd_card_t *card);
+bool sd_ddr_support(sd_card_t *card);
+bool manuefecture_ddr200_support(sd_card_t *card, u32 check_methood);
+
+#endif
diff --git a/drivers/scsi/bht/card/cardcommon.c b/drivers/scsi/bht/card/cardcommon.c
new file mode 100644
index 000000000000..7a5d4a444b0c
--- /dev/null
+++ b/drivers/scsi/bht/card/cardcommon.c
@@ -0,0 +1,961 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2014 BHT Inc.
+ *
+ * File Name: cardcommon.c
+ *
+ * Abstract: define card related common functions
+ *
+ * Version: 1.00
+ *
+ * Author: Samuel
+ *
+ * Environment: OS Independent
+ *
+ * History:
+ *
+ * 9/2/2014 Creation Samuel
+ */
+
+#include "../include/basic.h"
+#include "../include/hostapi.h"
+#include "../include/cmdhandler.h"
+#include "../include/debug.h"
+#include "../include/util.h"
+#include "../include/tqapi.h"
+#include "../include/transhapi.h"
+#include "cardcommon.h"
+
+bool card_need_get_info(sd_card_t *card)
+{
+ if ((card->quick_init) && (card->initialized_once))
+ return FALSE;
+ else
+ return TRUE;
+}
+
+bool card_send_command12(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool ret = FALSE;
+ u32 status = 0;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ ret = card_send_sdcmd(card, sd_cmd, SD_CMD12, 0,
+ CMD_FLG_R1B | CMD_FLG_RESCHK, DATA_DIR_NONE, NULL,
+ 0);
+
+ if (ret == FALSE) {
+ if ((sd_cmd->err.resp_err & RESP_ERR_TYPE_OUT_OF_RANGE) ==
+ RESP_ERR_TYPE_OUT_OF_RANGE) {
+ ret = card_get_card_status(card, sd_cmd, &status);
+ }
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+bool card_send_sdcmd_timeout(sd_card_t *card,
+ sd_command_t *sd_cmd,
+ byte cmd_index,
+ u32 argument,
+ u32 cmdflag,
+ e_data_dir dir,
+ byte *data, u32 datalen, u32 timeout)
+{
+
+ sd_data_t sd_data;
+ bool ret;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARDCMD_TRACE, NOT_TO_RAM,
+ "Enter %s cmd=0x%02X arg=0x%08X\n", __func__, cmd_index,
+ argument);
+
+ /* Avoid recursion call */
+ if (card->has_built_inf && cmd_index != SD_CMD12) {
+ ret = card_send_command12(card, sd_cmd);
+ if (ret == FALSE)
+ goto exit;
+ }
+
+ os_memset(sd_cmd, 0, sizeof(sd_command_t));
+
+ sd_cmd->cmd_flag = cmdflag;
+ sd_cmd->cmd_index = cmd_index;
+ sd_cmd->argument = argument;
+ sd_cmd->sd_cmd = 1;
+ sd_cmd->timeout = timeout;
+
+ if (dir == DATA_DIR_NONE)
+ sd_cmd->data = NULL;
+ else {
+ os_memset(&sd_data, 0, sizeof(sd_data_t));
+ sd_cmd->data = &sd_data;
+ sd_data.dir = dir;
+ sd_data.data_mng.driver_buff = data;
+ sd_data.data_mng.total_bytess = datalen;
+ if (cmdflag & CMD_FLG_ADMA_SDMA) {
+ ret =
+ build_dma_ctx(card->host->pdx, &sd_data, cmdflag,
+ dir, data, datalen, 0, 0);
+ if (ret == FALSE) {
+ DbgErr("build adma io error\n");
+ ret = FALSE;
+ goto exit;
+ }
+ }
+
+ if (sd_cmd->cmd_flag & CMD_FLG_DDR200_WORK_AROUND)
+ sd_cmd->gg8_ddr200_workaround = 1;
+ }
+
+ ret = cmd_generate_reg(card, sd_cmd);
+ if (ret == FALSE)
+ goto exit;
+
+ ret = cmd_execute_sync(card, sd_cmd, NULL);
+
+exit:
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARDCMD_TRACE, NOT_TO_RAM,
+ "Exit(%d) %s\n", ret, __func__);
+ return ret;
+
+}
+
+bool card_send_sdcmd_dma_timeout(sd_card_t *card,
+ sd_command_t *sd_cmd,
+ sd_data_t *sd_data,
+ byte cmd_index,
+ u32 argument,
+ u32 cmdflag,
+ e_data_dir dir,
+ byte *data, u32 datalen, u32 timeout)
+{
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARDCMD_TRACE, NOT_TO_RAM,
+ "Enter %s cmd=0x%02X arg=0x%08X\n", __func__, cmd_index,
+ argument);
+
+ /* Avoid recursion call */
+ if (card->has_built_inf && cmd_index != SD_CMD12) {
+ ret = card_send_command12(card, sd_cmd);
+ if (ret == FALSE)
+ goto exit;
+ }
+
+ os_memset(sd_cmd, 0, sizeof(sd_command_t));
+
+ sd_cmd->cmd_flag = cmdflag;
+ sd_cmd->cmd_index = cmd_index;
+ sd_cmd->argument = argument;
+ sd_cmd->sd_cmd = 1;
+ sd_cmd->timeout = timeout;
+
+ if (dir == DATA_DIR_NONE)
+ sd_cmd->data = NULL;
+ else {
+ sd_cmd->data = sd_data;
+ sd_data->dir = dir;
+ /* sd_data->data_mng.driver_buff = data; */
+ sd_data->data_mng.total_bytess = datalen;
+ }
+
+ ret = cmd_generate_reg(card, sd_cmd);
+ if (ret == FALSE)
+ goto exit;
+
+ ret = cmd_execute_sync(card, sd_cmd, NULL);
+
+exit:
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARDCMD_TRACE, NOT_TO_RAM,
+ "Exit(%d) %s\n", ret, __func__);
+ return ret;
+
+}
+
+/*
+ * Function Name: card_send_sdcmd
+ *
+ * Abstract: Issue command
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to the sd command structure. the caller need to check it's status.
+ * byte cmd_index: Command Index
+ * u32 argument: Command argument
+ * u32 cmdflag: Command flags, like response tpye, DMA or PIO
+ * e_data_dir dir: data direction: NONE/IN/OUT
+ * byte *data: Pointer to the data buffer for data command
+ * u32 datalen: Data length for transfer.
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if command successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller:
+ *
+ */
+
+bool card_send_sdcmd(sd_card_t *card,
+ sd_command_t *sd_cmd,
+ byte cmd_index,
+ u32 argument,
+ u32 cmdflag, e_data_dir dir, byte *data, u32 datalen)
+{
+ return card_send_sdcmd_timeout(card, sd_cmd, cmd_index, argument,
+ cmdflag, dir, data, datalen, 0);
+}
+
+bool card_wr_protect(sd_card_t *card)
+{
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+
+ if (card_info->csd.temp_protect || card_info->csd.parm_protect)
+ ret = TRUE;
+
+ return ret;
+}
+
+bool card_reset_card(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ byte cmd_index = (byte) (SD_CMD0);
+ u32 argument = 0;
+ u32 cmdflag = 0;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+bool card_all_send_cid(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ byte cmd_index = SD_CMD2;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R2;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+ card_info_t *card_info = &(card->info);
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Issue CMD2 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (ret) {
+ os_memcpy(&(card_info->raw_cid[0]), &(sd_cmd->response[0]), 16);
+ card_info->cid.manfid = card_info->raw_cid[0];
+ card_info->cid.oemid =
+ card_info->raw_cid[1] | (card_info->raw_cid[2] << 8);
+ os_memcpy(card_info->cid.prod_name, &(card_info->raw_cid[3]), 5);
+ card_info->cid.prv = card_info->raw_cid[8];
+ card_info->cid.serial =
+ card_info->raw_cid[9] |
+ (card_info->raw_cid[10] << 8) |
+ (card_info->raw_cid[11] << 16) |
+ (card_info->raw_cid[12] << 24);
+ card_info->cid.reserved = card_info->raw_cid[13] >> 4;
+ }
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ * Function Name: card_get_rca
+ *
+ * Abstract: Ask the card to publish a new relative address RCA (CMD3)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_card_identify
+ *
+ */
+
+bool card_get_rca(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ byte cmd_index = SD_CMD3;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R6 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+
+ bool ret = FALSE;
+
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Issue CMD3 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (ret) {
+ /* Update the card RCA */
+ card_info->rca = (sd_cmd->response[0] & 0xFFFF0000) >> 16;
+ }
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ * Function Name: card_select_card
+ *
+ * Abstract: Select card (CMD7)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_card_select
+ *
+ */
+
+bool card_select_card(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ byte cmd_index = SD_CMD7;
+ u32 argument = 0;
+ u32 cmdflag = 0;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (card->card_type == CARD_UHS2)
+ cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ else
+ cmdflag = CMD_FLG_R1B | CMD_FLG_RESCHK;
+ argument = (card_info->rca) << 16;
+
+ /* Issue CMD7 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (ret == TRUE) {
+ /* Get Lock/Unlock status, CMD7 Response [25].
+ * Check bit 25 of CMD7 response.
+ */
+ if (sd_cmd->response[0] & BIT25)
+ card->locked = TRUE;
+ else
+ card->locked = FALSE;
+ }
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit(%d) %s locked=%d\n", ret, __func__, card->locked);
+ return ret;
+}
+
+/*
+ * Function Name: card_deselect_card
+ *
+ * Abstract: De-Select card (CMD7)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_read_csd
+ *
+ */
+
+bool card_deselect_card(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ byte cmd_index = SD_CMD7;
+ u32 argument = 0;
+ u32 cmdflag = 0;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ cmdflag = 0;
+ argument = 0;
+
+ /* Issue CMD7 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit(%d) %s locked=%d\n", ret, __func__, card->locked);
+ return ret;
+}
+
+/*
+ * Function Name: card_set_csd_info
+ *
+ * Abstract: Acquired CSD Data, to be stored into Struct of CSD and Card.
+ * Save some contents of CSD Register into Struct of CSD,
+ * and generate(calcurate) necessary Data to save into Struct of Card.
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * unsigned char *csdbuff: CSD Buffer Pointer
+ * csd_t *csd_info: CSD information Pointer
+ *
+ * Output: None
+ *
+ * Return value: None
+ *
+ * Notes:
+ *
+ * Caller: card_get_csd
+ *
+ */
+
+static void card_set_csd_info(sd_card_t *card, unsigned char *csdbuff,
+csd_t *csd_info)
+{
+ u32 blocknr, mult, block_len, dummy1, dummy2;
+ byte i;
+ u32 value, unit;
+ byte taac_value, taac_unit;
+ u64 tmpsize;
+
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ value = unit = taac_value = taac_unit = 0;
+ mult = block_len = 1;
+ blocknr = dummy1 = dummy2 = 0;
+
+ /* Store the CSD information to Struct of CSD */
+
+ /* Get "CSD Structure" */
+ csd_info->csd_structure = ((csdbuff[0] & 0xC0) >> 6);
+
+ /* Get MMC "Spec_Vers" ( = System Specification version ) */
+ csd_info->mmc_spec_vers = ((csdbuff[0] & 0x3C) >> 2);
+
+ /* Get "TRAN SPEED" */
+ csd_info->tran_speed = csdbuff[3];
+
+ /* Get "TAAC" */
+ csd_info->taac = csdbuff[1];
+
+ /* Get "NSAC" */
+ csd_info->nsac = csdbuff[2];
+
+ /* Get "read_bl_len" */
+ csd_info->read_bl_len = (csdbuff[5] & 0x0F);
+
+ /* Get "PERM_WRITE_PROTECT" */
+ csd_info->parm_protect = (csdbuff[14] & 0x20) >> 5;
+
+ /* Get "TMP_WRITE_PROTECT" */
+ csd_info->temp_protect = (csdbuff[14] & 0x10) >> 4;
+
+ /* Get "c_size" */
+ csd_info->c_size = 0;
+
+ if (card->card_type == CARD_SD || card->card_type == CARD_UHS2) {
+ if (csd_info->csd_structure == 0) {
+ /* CSD Version 1.0 (Standard Capacity) */
+ dummy1 = (csdbuff[6] & 0x03);
+ dummy1 = (dummy1 << 10);
+ dummy2 = csdbuff[7];
+ dummy2 = (dummy2 << 2);
+ dummy2 = (dummy1 | dummy2);
+ csd_info->c_size =
+ (dummy2 | ((csdbuff[8] & 0xC0) >> 6));
+ } else {
+ /* CSD Version 2.0 (High Capacity and Extended Capacity) */
+ dummy1 = (csdbuff[7] & 0x3F);
+ dummy1 = (dummy1 << 16);
+ dummy2 = csdbuff[8];
+ dummy2 = (dummy2 << 8);
+ dummy2 = (dummy1 | dummy2);
+ csd_info->c_size = (dummy2 | (csdbuff[9] & 0xFF));
+ }
+ } else if ((card->card_type == CARD_MMC) ||
+ (card->card_type == CARD_EMMC)
+ ) {
+ if (card_info->card_ccs == 0) {
+ /* (Standard Capacity) */
+ dummy1 = (csdbuff[6] & 0x03);
+ dummy1 = (dummy1 << 10);
+ dummy2 = csdbuff[7];
+ dummy2 = (dummy2 << 2);
+ dummy2 = (dummy1 | dummy2);
+ csd_info->c_size =
+ (dummy2 | ((csdbuff[8] & 0xC0) >> 6));
+ } else {
+ /* (High Capacity and Extended Capacity) */
+ dummy1 = (csdbuff[7] & 0x3F);
+ dummy1 = (dummy1 << 16);
+ dummy2 = csdbuff[8];
+ dummy2 = (dummy2 << 8);
+ dummy2 = (dummy1 | dummy2);
+ csd_info->c_size = (dummy2 | (csdbuff[9] & 0xFF));
+ }
+
+ }
+
+ /* Get "sect_size" */
+ if ((card->card_type == CARD_MMC) || (card->card_type == CARD_EMMC)
+ ) {
+ /* MMC */
+ csd_info->sector_size = ((csdbuff[10] & 0x7C) >> 2);
+ } else {
+ /* SD Memory Card */
+ csd_info->sector_size = (((csdbuff[10] & 0x3f) << 1) |
+ ((csdbuff[11] & 0x80) >> 7));
+ }
+
+ /* Get "c_size_mult" */
+ if (card->card_type == CARD_SD || card->card_type == CARD_UHS2) {
+ if (csd_info->csd_structure == 0) {
+ /* CSD Version 1.0 (Standard Capacity) */
+ csd_info->c_size_mult = (((csdbuff[9] & 0x03) << 1) |
+ ((csdbuff[10] & 0x80) >> 7));
+ } else {
+ /* CSD Version 2.0 (High Capacity and Extended Capacity) */
+ /* not exist */
+ ;
+ }
+ } else if ((card->card_type == CARD_MMC) ||
+ (card->card_type == CARD_EMMC)
+ ) {
+
+ if (card_info->card_ccs == 0) {
+ /* CSD Version 1.0 (Standard Capacity) */
+ csd_info->c_size_mult = (((csdbuff[9] & 0x03) << 1) |
+ ((csdbuff[10] & 0x80) >> 7));
+ } else {
+ /* CSD Version 2.0 (High Capacity and Extended Capacity) */
+ /* not exist */
+ ;
+ }
+ }
+
+ /*
+ * Acquired CSD Data, to be stored into Struct of CSD and Card
+ * Save some contents of CSD Register into Struct of CSD, and
+ * generate(calcurate) necessary Data to save into Struct of Card
+ */
+
+ /* Calcuration of Total Sector count & Card Size */
+ if (card->card_type == CARD_SD || card->card_type == CARD_UHS2) {
+ if (csd_info->csd_structure == 0) {
+ /* CSD Version 1.0 (Standard Capacity) */
+ for (i = 0; i < (csd_info->c_size_mult + 2); i++)
+ mult = mult * 2;
+ for (i = 0; i < csd_info->read_bl_len; i++)
+ block_len = block_len * 2;
+ blocknr = (csd_info->c_size + 1) * mult;
+ /* Card Size (Byte) */
+
+ card->sec_count = ((u64) (blocknr) * (u64) (block_len));
+ } else {
+ /* CSD Version 2.0 (High Capacity and Extended Capacity) */
+
+ /* Card Size (Byte) */
+
+ /* (c_size + 1) * 512K */
+ tmpsize = ((u64) csd_info->c_size) + 1;
+ card->sec_count = tmpsize * 524288;
+ }
+ } else if ((card->card_type == CARD_MMC) ||
+ (card->card_type == CARD_EMMC)
+ ) {
+ if (card_info->card_ccs == 0) {
+ /* CSD Version 1.0 (Standard Capacity) */
+ for (i = 0; i < (csd_info->c_size_mult + 2); i++)
+ mult = mult * 2;
+ for (i = 0; i < csd_info->read_bl_len; i++)
+ block_len = block_len * 2;
+ blocknr = (csd_info->c_size + 1) * mult;
+
+ /* Card Size (Byte) */
+
+ card->sec_count = ((u64) (blocknr) * (u64) (block_len));
+ } else {
+ /* sector size will calculate at MMC_Set_CSDEXT() */
+ ;
+ }
+ }
+
+ /* Total sector count of Card */
+ card->sec_count = ((card->sec_count) / (SD_BLOCK_LEN));
+ /* SD_INFO_PRINTF("Card_Info.sect_num = %x\n", Card_Info.sect_num); */
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit %s CardSectors: %d, %dGB\n", __func__,
+ card->sec_count, card->sec_count / 2 / 1024 / 1024);
+
+}
+
+/*
+ * Function Name: card_get_csd
+ *
+ * Abstract: Addressed card sends its card-specific data (CSD) on the CMD line (CMD9)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_read_csd
+ *
+ */
+
+bool card_get_csd(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ byte cmd_index = SD_CMD9;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R2;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ argument = card_info->rca << 16;
+
+ /* Issue CMD9 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (ret) {
+ /* Set the card CSD info */
+ os_memcpy(&(card_info->raw_csd[0]), &(sd_cmd->response[0]), 16);
+ /* Parse the CSD info */
+ card_set_csd_info(card, card_info->raw_csd, &(card_info->csd));
+ }
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ * Function Name: card_get_card_status
+ *
+ * Abstract: Read the SD Status Register (SSR) (ACMD13)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_check_rw_ready
+ *
+ */
+
+bool card_get_card_status(sd_card_t *card,
+ sd_command_t *sd_cmd, u32 *card_status)
+{
+
+ byte cmd_index = SD_CMD13;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Issue CMD13 */
+ argument = (card_info->rca << 16);
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (ret) {
+ /* Send the card status */
+ os_memcpy(card_status, &(sd_cmd->response[0]), 4);
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+bool card_check_rw_ready(sd_card_t *card, sd_command_t *sd_cmd,
+ int timeout_ms)
+{
+ bool result = FALSE;
+ u32 card_status = 0;
+ loop_wait_t wait;
+ u32 delay_us = 10;
+
+ util_init_waitloop(card->host->pdx, timeout_ms, delay_us, &wait);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM,
+ "Enter %s, timeout_ms=%d\n", __func__, timeout_ms);
+
+ do {
+ result = card_get_card_status(card, sd_cmd, &card_status);
+ if (result == FALSE)
+ goto exit;
+
+ os_udelay(delay_us);
+ } while (((card_status & 0x900) != 0x900) && (!util_is_timeout(&wait)));
+
+ if ((card_status & 0x900) != 0x900)
+ result = FALSE;
+
+exit:
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ * Function Name: card_set_block_len
+ *
+ * Abstract: Set the block length for all following block commands (ACMD6, block length = 5126)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ * u32 arg: SD_BLOCK_LEN
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_init_get_info
+ *
+ */
+
+bool card_set_block_len(sd_card_t *card, sd_command_t *sd_cmd, u32 arg)
+{
+ byte cmd_index = SD_CMD16;
+ u32 argument = arg;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s, arg=0x%x\n", __func__, arg);
+
+ /* Issue CMD16 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (!ret)
+ DbgErr("Set Block Length(CMD6) %d Error!!", argument);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ * Function Name: card_get_legacy_freq
+ *
+ * Abstract:
+ * 1. Set the specific clock frequency
+ * 2. Set DM/DN and Clock Divider
+ *
+ * Input:
+ *
+ * sd_card_t *card: Pointer to the card structure
+ * u32 clk_freq_khz: clock frequency to be set (KHz)
+ * bool ddr_mode: if it is DDR50 mode (100MHz same as SDR50), need to check max frequency for DDR50
+ *
+ * Output: DMDN Values
+ *
+ * Return value: BIT[31:16]:dmdn BIT[14:0] basediv
+ *
+ * Notes:
+ *
+ * Caller: card_legacy_change_clock
+ *
+ */
+
+static u32 card_get_legacy_freq(sd_card_t *card, u32 clk_freq_khz,
+ bool ddr_mode)
+{
+ u32 value = 0;
+ u16 index = 0;
+ sd_host_t *host = card->host;
+ u16 freq_level = card->degrade_freq_level;
+ /* cfg_max_freq_item_t * freq = &(host->cfg->host_item.max_freq_item); */
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s, Clock frequency %d KHz, ddr50_mode=%\n",
+ __func__, clk_freq_khz, ddr_mode);
+ if (host->cfg == NULL || host->cfg->dmdn_tbl == NULL) {
+ DbgErr("host cfg is null\n");
+ return 0;
+ }
+
+ /* Set DM/DN according to the clock frequency */
+ switch (clk_freq_khz) {
+ case SD_CLK_ID_400K:
+ value = host->cfg->dmdn_tbl[FREQ_400K_START_INDEX];
+ break;
+ case SD_CLK_50M:
+ if (ddr_mode)
+ value = host->cfg->dmdn_tbl[FREQ_DDR50M_START_INDEX];
+ else
+ value = host->cfg->dmdn_tbl[FREQ_50M_START_INDEX];
+ break;
+
+ case SD_CLK_100M:
+ index = (u16) FREQ_100M_START_INDEX + freq_level;
+ if (index > (u16) FREQ_100M_DEGRE_INDEX)
+ index = (u16) FREQ_100M_DEGRE_INDEX;
+ value = host->cfg->dmdn_tbl[index];
+ break;
+
+ case SD_CLK_200M:
+ if (ddr_mode) {
+ index = (u16) FREQ_DDR200M_START_INDEX + freq_level;
+ if (index > (u16) FREQ_DDR200M_DEGRE_INDEX)
+ index = (u16) FREQ_DDR200M_DEGRE_INDEX;
+ value = host->cfg->dmdn_tbl[index];
+ } else {
+ index = (u16) FREQ_200M_START_INDEX + freq_level;
+ if (index > (u16) FREQ_200M_DEGRE_INDEX)
+ index = (u16) FREQ_200M_DEGRE_INDEX;
+ value = host->cfg->dmdn_tbl[index];
+ }
+ break;
+ case SD_CLK_225M:
+ index = (u16) FREQ_DDR225M_START_INDEX + freq_level;
+ if (index > (u16) FREQ_DDR225M_DEGRE_INDEX)
+ index = (u16) FREQ_DDR225M_DEGRE_INDEX;
+ value = host->cfg->dmdn_tbl[index];
+ break;
+
+ case SD_CLK_75M:
+ value = host->cfg->dmdn_tbl[FREQ_75M_START_INDEX];
+ break;
+
+ default:
+ value = host->cfg->dmdn_tbl[FREQ_25M_START_INDEX];
+ break;
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, TO_RAM,
+ "%s Exit Clock=%d (KHz): value=0x%08X\n", __func__,
+ clk_freq_khz, value);
+
+ return value;
+
+}
+
+/*
+ * Function Name: card_legacy_change_clock
+ *
+ * Abstract:
+ * 1. Stop clock
+ * 2. Set the clock frequency (DM/DN, clk divider)
+ * 3. Start the clock
+ *
+ * Input:
+ *
+ * sd_card_t *card: Pointer to the card structure
+ * u32 clk_freq_khz: clock frequency to be set (KHz)
+ * bool ddr_mode: if it is DDR200/DDR50 mode (100MHz same as SDR50),
+ * need to check max frequency for DDR200/DDR50
+ *
+ * Output: None
+ *
+ * Return value: None
+ *
+ * Notes:
+ *
+ * Caller: sd_init_stage2
+ *
+ */
+
+void card_legacy_change_clock(sd_card_t *card, u32 clk_freq_khz, bool ddr_mode)
+{
+ u32 value;
+ sd_host_t *host = card->host;
+
+ value = card_get_legacy_freq(card, clk_freq_khz, ddr_mode);
+ host_change_clock(host, value);
+
+}
diff --git a/drivers/scsi/bht/card/cardcommon.h b/drivers/scsi/bht/card/cardcommon.h
new file mode 100644
index 000000000000..985411bb0802
--- /dev/null
+++ b/drivers/scsi/bht/card/cardcommon.h
@@ -0,0 +1,123 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2014 BHT Inc.
+ *
+ * File Name: cardcommon.h
+ *
+ * Abstract: Include card related common functions.
+ *
+ * Version: 1.00
+ *
+ * Author: Samuel
+ *
+ * Environment: OS Independent
+ *
+ * History:
+ *
+ * 9/2/2014 Creation Samuel
+ */
+
+#ifndef _CARDCOMMON_H
+#define _CARDCOMMON_H
+
+#include "../include/card.h"
+
+/* SD Legacy (UHSI, HS, DS) card initialization */
+bool sd_legacy_init(sd_card_t *card);
+
+/* MMC or eMMC card initialization */
+bool emmc_init(sd_card_t *card, bool bemmc);
+bool emmc_init_stage2(sd_card_t *card);
+bool emmc_tuning(sd_card_t *card, sd_command_t *sd_cmd);
+
+bool sd_tuning(sd_card_t *card, sd_command_t *sd_cmd, u32 timeout);
+
+bool card_get_card_status(sd_card_t *card,
+ sd_command_t *sd_cmd, u32 *card_status);
+
+bool card_reset_card(sd_card_t *card, sd_command_t *sd_cmd);
+
+bool card_all_send_cid(sd_card_t *card, sd_command_t *sd_cmd);
+
+bool card_get_rca(sd_card_t *card, sd_command_t *sd_cmd);
+
+bool card_select_card(sd_card_t *card, sd_command_t *sd_cmd);
+
+bool card_get_csd(sd_card_t *card, sd_command_t *sd_cmd);
+
+bool card_send_command12(sd_card_t *card, sd_command_t *sd_cmd);
+
+bool card_set_block_len(sd_card_t *card, sd_command_t *sd_cmd, u32 arg);
+
+bool uhs2_card_init(sd_card_t *card);
+void card_power_on(sd_card_t *card);
+
+/*
+ * (1) If uhs2 call uhs2 cmd handler
+ * (2) generate sd_cmd_t structure and sd_data structure(pio only)
+ * (3) call cmd_generate_reg(sd_cmd)
+ * (4) call cmd_execute
+ * (5) do error recover if necessary
+ * (6) return result
+ */
+
+bool card_send_sdcmd(sd_card_t *card,
+ sd_command_t *sd_cmd,
+ byte cmd_index,
+ u32 argument,
+ u32 cmdflag, e_data_dir dir, byte *data, u32 datalen);
+
+bool uhs2_native_ccmd(sd_card_t *card, sd_command_t *sd_cmd,
+ u16 ioaddr, bool broadcast, bool rwcmd, byte payload_num,
+ u32 *payload);
+
+bool card_send_sdcmd_dma_timeout(sd_card_t *card,
+ sd_command_t *sd_cmd,
+ sd_data_t *sd_data,
+ byte cmd_index,
+ u32 argument,
+ u32 cmdflag,
+ e_data_dir dir,
+ byte *data, u32 datalen, u32 timeout);
+
+bool card_select_card(sd_card_t *card, sd_command_t *sd_cmd);
+
+bool sd_switch_function_check(sd_card_t *card, sd_command_t *sd_cmd);
+
+bool sd_switch_function_set_pl(sd_card_t *card,
+ sd_command_t *sd_cmd, byte power_limit);
+
+bool card_wr_protect(sd_card_t *card);
+
+bool sd_card_identify(sd_card_t *card);
+
+bool sd_init_get_info(sd_card_t *card);
+
+bool sd_init_stage2(sd_card_t *card);
+
+bool uhs2_enter_dmt(sd_card_t *card, sd_command_t *sd_cmd, sd_host_t *host,
+ bool hbr);
+bool uhs2_resume_dmt(sd_card_t *card, sd_command_t *sd_cmd, sd_host_t *host,
+ bool hbr);
+
+bool sd_card_select(sd_card_t *card);
+bool uhs2_init_stage2(sd_card_t *card);
+bool uhs2_full_reset_card(sd_card_t *card);
+
+bool sd_switch_power_limit(sd_card_t *card, sd_command_t *sd_cmd, bool *bchg);
+
+bool card_check_rw_ready(sd_card_t *card, sd_command_t *sd_cmd,
+ int timeout_ms);
+
+void card_legacy_change_clock(sd_card_t *card, u32 clk_freq_khz,
+ bool ddr50_mode);
+
+bool card_need_get_info(sd_card_t *card);
+
+bool card_deselect_card(sd_card_t *card, sd_command_t *sd_cmd);
+
+bool sd_program_csd(sd_card_t *card, sd_command_t *sd_cmd, byte *data);
+
+bool sd_read_csd(sd_card_t *card, sd_command_t *sd_cmd, byte *data);
+
+#endif
diff --git a/drivers/scsi/bht/card/cardinterface.c b/drivers/scsi/bht/card/cardinterface.c
new file mode 100644
index 000000000000..6c8ee43f2e11
--- /dev/null
+++ b/drivers/scsi/bht/card/cardinterface.c
@@ -0,0 +1,2448 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2014 BHT Inc.
+ *
+ * File Name: cardinterface.c
+ *
+ * Abstract:
+ * 1. Card initialization main entry
+ * 2. Interface for card operations
+ *
+ * Version: 1.00
+ *
+ * Author: Samuel
+ *
+ * Environment: OS Independent
+ *
+ * History:
+ *
+ * 9/3/2014 Creation Samuel
+ */
+
+#include "../include/basic.h"
+#include "../include/card.h"
+#include "../include/cardapi.h"
+#include "../include/hostapi.h"
+#include "../include/transhapi.h"
+#include "../include/hostvenapi.h"
+#include "../include/util.h"
+#include "../include/debug.h"
+#include "../include/cmdhandler.h"
+#include "../host/hostven.h"
+#include "../include/card.h"
+#include "../host/hostreg.h"
+#include "../include/funcapi.h"
+#include "../tagqueue/tq_trans_api.h"
+#include "../include/cmdhandler.h"
+#include "cardcommon.h"
+
+/* Thomas add for direct remove 7.0 */
+extern void bht_sd_remove(struct pci_dev *pdev);
+
+bool sd_thermal_control(sd_card_t *card);
+void uhs2_degrade_policy(sd_card_t *card, sd_command_t *sd_cmd);
+bool uhs2_sd_error_recovery(sd_card_t *card, sd_command_t *sd_cmd);
+void sd_degrade_policy(sd_card_t *card);
+void mmc_degrade_policy(sd_card_t *card);
+u32 card_get_uhs2_freq(sd_card_t *card);
+u32 sdr104_sdr50_output_tuning(sd_card_t *card, u32 address);
+u32 ddr200_output_tuning(sd_card_t *card, u32 address);
+
+bool sd_dll_divider(sd_card_t *card, sd_command_t *pcmd);
+
+byte tuning_address_content_buf[512] = { 0 };
+
+bool store_tuning_address_content(sd_card_t *card, u64 tuning_address)
+{
+ bool ret = 0;
+ sd_command_t sd_cmd;
+ u32 cmdflag;
+ sd_host_t *host = card->host;
+
+ card->read_signal_block_flag = TRUE;
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ /* Save Current DMA mode */
+ host_transfer_init(card->host, FALSE, TRUE);
+ cmdflag = CMD_FLG_RESCHK | CMD_FLG_R1 | CMD_FLG_ADMA_SDMA;
+
+ ret =
+ card_send_sdcmd_timeout(card, &sd_cmd, SD_CMD17,
+ (u32) tuning_address, (cmdflag),
+ DATA_DIR_IN, tuning_address_content_buf,
+ 512, 500);
+ if (ret == FALSE) {
+ host_reset(host, SDHCI_RESET_CMD);
+ host_reset(host, SDHCI_RESET_DATA);
+ card->read_signal_block_flag = FALSE;
+ DbgErr("Read data FAILED when store tuning address content\n");
+ }
+
+ /* Resorte current DMA mode */
+ host_transfer_init(card->host, card->inf_trans_enable, FALSE);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+ return ret;
+}
+
+bool restore_tuning_address_content(sd_card_t *card, u64 tuning_address)
+{
+ bool ret = 0;
+ int i = 0;
+ sd_command_t sd_cmd;
+ u32 cmdflag;
+ byte tuning_temp_buf[512];
+ bool gg8_ddr200 = 0;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (card->host->chip_type == CHIP_GG8
+ && card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_DDR200) {
+ /* Save Current DMA mode */
+ host_transfer_init(card->host, TRUE, FALSE);
+ gg8_ddr200 = 1;
+ cmdflag =
+ CMD_FLG_RESCHK | CMD_FLG_R1 | CMD_FLG_ADMA_SDMA |
+ CMD_FLG_DDR200_WORK_AROUND | CMD_FLG_INF_BUILD;
+ } else {
+ /* Save Current DMA mode */
+ host_transfer_init(card->host, FALSE, TRUE);
+ cmdflag = CMD_FLG_RESCHK | CMD_FLG_R1 | CMD_FLG_ADMA_SDMA;
+ }
+
+ ret =
+ card_send_sdcmd_timeout(card, &sd_cmd,
+ gg8_ddr200 ? SD_CMD25 : SD_CMD24,
+ (u32) tuning_address, (cmdflag),
+ DATA_DIR_OUT, tuning_address_content_buf,
+ 512, 500);
+ if (ret == FALSE) {
+ DbgErr
+ ("Write data FAILED when restore tuning address content\n");
+ goto exit;
+ }
+
+ ret =
+ card_send_sdcmd_timeout(card, &sd_cmd,
+ gg8_ddr200 ? SD_CMD18 : SD_CMD17,
+ (u32) tuning_address,
+ (cmdflag | CMD_FLG_ADMA_SDMA), DATA_DIR_IN,
+ tuning_temp_buf, 512, 500);
+ if (ret == FALSE) {
+ DbgErr("Read data FAILED when store tuning address content\n");
+ goto exit;
+ }
+
+ for (i = 0; i < 512; i++) {
+ if (tuning_temp_buf[i] != tuning_address_content_buf[i]) {
+ DbgErr("Tuning address compare err!!!Write data 0x%x, Read out data 0x%x, Offset %d\n",
+ tuning_address_content_buf[i], tuning_temp_buf[i], i);
+ ret = FALSE;
+ break;
+ }
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Write data 0x%x, Read out data 0x%x, Offset %d\n",
+ tuning_address_content_buf[i], tuning_temp_buf[i], i);
+ }
+
+exit:
+ /* Resorte current DMA mode */
+ host_transfer_init(card->host, card->inf_trans_enable, FALSE);
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+ return ret;
+}
+
+bool card_output_tuning(sd_card_t *card, u64 tuning_address)
+{
+ sd_host_t *host = card->host;
+ int ii, jj, pattern_i, first_0, dll_i_mod;
+ int dat_cmp, dll_result[16];
+ byte test_patern[6] = { 0x55, 0xaa, 0x00, 0xff, 0xf0, 0x0f };
+ u32 dll_i, window_pass_number[16],
+ window_start_adr[16], window_pass_number_max, dll_mod;
+ u32 ret = FALSE;
+ bool result = FALSE;
+ sd_command_t sd_cmd;
+ u32 cmdflag;
+ u8 phase_count = 11;
+
+ byte *test_buf = kcalloc(512, sizeof(unsigned char), GFP_KERNEL);
+ byte *test_buf_read = kcalloc(512, sizeof(unsigned char), GFP_KERNEL);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (test_buf == NULL || test_buf_read == NULL) {
+ DbgErr("kcalloc buffer failed\n");
+ if (test_buf != NULL)
+ kfree(test_buf);
+ if (test_buf_read != NULL)
+ kfree(test_buf_read);
+ return FALSE;
+ }
+
+ host->output_tuning.start_block = (u32) tuning_address;
+ host->output_tuning.auto_phase_flag = FALSE;
+
+ /* Save Current DMA mode */
+ if (card->host->chip_type == CHIP_GG8
+ && card->info.sw_cur_setting.sd_access_mode != SD_FNC_AM_DDR200)
+ host_transfer_init(host, FALSE, TRUE);
+ else
+ host_transfer_init(host, TRUE, FALSE);
+
+ if (host->chip_type == CHIP_GG8 || host->chip_type == CHIP_ALBATROSS) {
+ if (card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_DDR200)
+ ret = ddr200_output_tuning(card, (u32) tuning_address);
+ else
+ ret =
+ sdr104_sdr50_output_tuning(card,
+ (u32) tuning_address);
+
+ if (ret == 0)
+ result = TRUE;
+ } else {
+ cmdflag = CMD_FLG_RESCHK | CMD_FLG_R1 | CMD_FLG_ADMA_SDMA;
+ window_pass_number_max = 0;
+ for (dll_i = 0; dll_i < phase_count; dll_i++)
+ dll_result[dll_i] = TRUE;
+
+ for (dll_i = 0; dll_i < 512; dll_i++)
+ test_buf[dll_i] = test_patern[dll_i % 6];
+
+ host_cmddat_line_reset(host);
+
+ if (host->chip_type != CHIP_GG8
+ || host->chip_type == CHIP_ALBATROSS) {
+ if (card_check_rw_ready(card, &sd_cmd, 600) != TRUE) {
+ DbgErr
+ ("Error when output_tuning, card_check_rw_ready fail\n");
+ goto exit;
+ }
+ }
+
+ for (dll_i = 0; dll_i < phase_count; dll_i++) {
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM, " - DLL Adjust Test %d\n", dll_i);
+
+ if (card->card_present == FALSE) {
+ DbgErr
+ ("Error when output_tuning, card is removed\n");
+ goto exit;
+ }
+ host_cmddat_line_reset(host);
+ host_set_output_tuning_phase(host, dll_i);
+
+ if (card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_SDR104
+ || card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_SDR50
+ || card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_DDR200) {
+
+ ret = sd_tuning(card, &sd_cmd, 150);
+ if (ret == FALSE) {
+ DbgErr("Error when output_tuning, sd_tuning fail at phase %d\n", dll_i);
+ dll_result[dll_i] = FALSE;
+ continue;
+ }
+ }
+
+ for (pattern_i = 0; pattern_i < 1; pattern_i++) {
+
+ ret = card_send_sdcmd_timeout(card, &sd_cmd,
+ SD_CMD24,
+ host->output_tuning.start_block,
+ (cmdflag),
+ DATA_DIR_OUT,
+ test_buf, 512, 500);
+ if (ret == FALSE) {
+ DbgErr("Write data FAILED when output_tuning\n");
+ dll_result[dll_i] = FALSE;
+ host_cmddat_line_reset(host);
+ card_send_command12(card, &sd_cmd);
+ if (card_check_rw_ready
+ (card, &sd_cmd, 600) != TRUE) {
+ DbgErr("Error when output_tuning write CMD, card_check_rw_ready fail\n");
+ goto exit;
+ }
+ break;
+ }
+
+ ret = card_send_sdcmd_timeout(card, &sd_cmd,
+ SD_CMD17,
+ host->output_tuning.start_block,
+ (cmdflag),
+ DATA_DIR_IN,
+ test_buf_read, 512,
+ 500);
+ if (ret == FALSE) {
+ DbgErr("Read data FAILED when output_tuning\n");
+ dll_result[dll_i] = FALSE;
+ host_cmddat_line_reset(host);
+ card_send_command12(card, &sd_cmd);
+ if (card_check_rw_ready(card, &sd_cmd, 600) != TRUE) {
+ DbgErr("Error when output_tuning read CMD, card_check_rw_ready fail\n");
+ goto exit;
+ }
+ break;
+ }
+
+ dat_cmp = TRUE;
+ for (ii = 0; ii < (1 * 512); ii++) {
+ if (*(test_buf + ii) !=
+ *(test_buf_read + ii)) {
+ dat_cmp = FALSE;
+ dll_result[dll_i] = FALSE;
+ break;
+ }
+ }
+ if (dat_cmp == FALSE)
+ DbgErr("Compare data FAILED at index %d!!!\n", ii);
+
+ }
+ }
+
+ for (ii = 0; ii < 16; ii++) {
+ window_pass_number[ii] = 0;
+ window_start_adr[ii] = 0;
+ }
+
+ first_0 = 0;
+ for (dll_i = 0; dll_i < phase_count; dll_i++) {
+ if (dll_result[dll_i] != TRUE) {
+ first_0 = dll_i;
+ break;
+ }
+ }
+
+ jj = 0;
+ for (dll_i = 0; dll_i < phase_count; dll_i++) {
+ dll_i_mod = (first_0 + dll_i) % phase_count;
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM, "DLL phase [%x] result %d.\n",
+ dll_i_mod, dll_result[dll_i_mod]);
+ if (dll_result[dll_i_mod] == TRUE)
+ window_pass_number[jj]++;
+ else {
+ if (window_pass_number[jj] > 0)
+ jj++;
+ }
+ if (window_pass_number[jj] == 1)
+ window_start_adr[jj] = dll_i_mod;
+ }
+
+ for (ii = 0; ii < phase_count; ii++) {
+ if (window_pass_number_max < window_pass_number[ii]) {
+ window_pass_number_max = window_pass_number[ii];
+ jj = ii;
+ }
+ }
+
+ if (window_pass_number_max == 0)
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM,
+ "DLL test result: All DLL test FAIL\n");
+ else {
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM,
+ "DLL test result: Total %d DLL test PASS\n",
+ window_pass_number_max);
+ window_pass_number_max = window_pass_number_max >> 1;
+ dll_mod = window_start_adr[jj] + window_pass_number_max;
+ dll_mod = dll_mod % phase_count;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM, "select DLL phase Number %d\n",
+ dll_mod);
+ host->output_tuning.auto_phase = dll_mod;
+ host->output_tuning.auto_phase_flag = TRUE;
+ result = TRUE;
+ host_set_output_tuning_phase(host,
+ host->output_tuning.auto_phase);
+ if (card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_SDR104
+ || card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_SDR50
+ || card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_DDR200) {
+ ret = sd_tuning(card, &sd_cmd, 150);
+ if (ret == FALSE) {
+ DbgErr
+ ("Error when output_tuning, sd_tuning fail\n");
+ result = FALSE;
+ goto exit;
+ }
+ }
+
+ }
+
+ }
+exit:
+
+ /* Resorte current DMA mode */
+ host_transfer_init(host, card->inf_trans_enable, FALSE);
+ if (result == FALSE)
+ hostven_set_output_tuning_phase(host, 0, TRUE);
+ host_cmddat_line_reset(host);
+ host->output_tuning.auto_flag = FALSE;
+
+ kfree(test_buf);
+ kfree(test_buf_read);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s result is %d\n", __func__, result);
+
+ return result;
+}
+
+static bool legacy_error_recovery(sd_card_t *card, sd_command_t *pcmd)
+{
+ bool ret;
+ sd_command_t sd_cmd;
+ card_info_t *card_info = &(card->info);
+ sd_host_t *host = card->host;
+ bht_dev_ext_t *pdx = host->pdx;
+ cfg_output_tuning_item_t *cfg =
+ &pdx->cfg->feature_item.output_tuning_item;
+
+ DbgInfo(MODULE_LEGACY_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Enter %s\n", __func__);
+
+ /* Follow SD Host Spec V4.10 Section 3.10.1 Error Interrupt Recovery flow (Page 179) */
+ card_send_command12(card, &sd_cmd);
+
+ /* Call host api to do host related recovery stage2 */
+ ret =
+ host_error_int_recovery_stage2(card->host,
+ sd_cmd.err.legacy_err_reg);
+
+ if (ret == FALSE)
+ goto exit;
+
+ ret = card_check_rw_ready(card, &sd_cmd, 150);
+
+ if (ret == FALSE) {
+ DbgErr("Card status is not ready after error recovery");
+ goto exit;
+ }
+
+ if (pcmd != NULL) {
+ /* Crc error */
+ if (pcmd->err.legacy_err_reg & (BIT1 | BIT5)) {
+ if (host->cfg->feature_item.output_tuning_item.enable_dll
+ == 0) {
+ if (card->card_type == CARD_SD)
+ ret = sd_tuning(card, &sd_cmd, 0);
+ else if (card->card_type == CARD_EMMC)
+ ret = emmc_tuning(card, &sd_cmd);
+ } else {
+
+ if (card->card_type == CARD_SD &&
+ pcmd->data &&
+ pcmd->data->dir == DATA_DIR_OUT &&
+ ((cfg->enable_dll == 1)
+ && (cfg->enable_dll_divider == 1))
+ && (card_info->sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_DDR50)) {
+ ret = sd_dll_divider(card, pcmd);
+ if (ret)
+ goto exit;
+ } else if (pcmd->data
+ && pcmd->data->dir == DATA_DIR_OUT) {
+ if (card->card_type == CARD_SD
+ || card->card_type == CARD_EMMC) {
+ if (hostven_fix_output_tuning(card->host,
+ card_info->sw_cur_setting.sd_access_mode)
+ == FALSE) {
+ ret = card_output_tuning(card,
+ pcmd->argument);
+ if (ret)
+ goto exit;
+ }
+ }
+ } else if (pcmd->data
+ && pcmd->data->dir == DATA_DIR_IN) {
+ if (card->card_type == CARD_SD) {
+ ret =
+ sd_tuning(card, &sd_cmd, 0);
+ } else if (card->card_type == CARD_EMMC) {
+ ret =
+ emmc_tuning(card, &sd_cmd);
+ }
+ }
+ }
+ }
+
+ }
+
+exit:
+ DbgInfo(MODULE_LEGACY_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s\n", __func__);
+ return ret;
+}
+
+/*
+ * Function Name: card_degrade_policy
+ *
+ * Abstract: This Function is used set card degrade flag
+ * if blightway is set, this function can also do card operation which don't need reinit
+ *
+ * Input:
+ *
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd: if the init occurred at init stage this parameter will be null
+ *
+ * Output: None
+ *
+ * Return value: None
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ *
+ */
+
+void card_degrade_policy(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ DbgInfo(MODULE_ALL_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Enter %s\n", __func__);
+ switch (card->card_type) {
+ case CARD_SD:
+ sd_degrade_policy(card);
+ break;
+ case CARD_UHS2:
+ uhs2_degrade_policy(card, sd_cmd);
+ break;
+ case CARD_EMMC:
+ case CARD_MMC:
+ mmc_degrade_policy(card);
+ break;
+ default:
+ break;
+
+ }
+ DbgInfo(MODULE_ALL_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+}
+
+/*
+ * Function Name: card_rw_recovery
+ *
+ * Abstract: This Function is used to do card rw error recovery
+ *
+ * Input:
+ *
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd: if the init occurred at init stage this parameter will be null
+ *
+ * Output: None
+ *
+ * Return value: If the routine succeeds, it must return TRUE,
+ * and fill trans_reg_t part. otherwize reutrn FALSE
+ *
+ * Notes:
+ *
+ * Caller: card_recovery_flow
+ *
+ */
+
+static bool card_rw_recovery(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ if (sd_cmd == NULL)
+ return FALSE;
+
+ switch (card->card_type) {
+ case CARD_EMMC:
+ case CARD_MMC:
+ case CARD_SD:
+ return legacy_error_recovery(card, sd_cmd);
+ case CARD_UHS2:
+ return uhs2_sd_error_recovery(card, sd_cmd);
+ default:
+ DbgErr("Error Card no RW error recovery\n");
+ break;
+
+ }
+
+ return FALSE;
+}
+
+/*
+ * Function Name: card_init_infinite
+ *
+ * Abstract: This Function is used to determine whehter use infinte or not according to card type
+ *
+ * Input:
+ *
+ * sd_card_t *card : The Command will send to which Card
+ * sd_host_t *host: Pointer to the host structure
+ *
+ * Output: None
+ *
+ * Return value: None
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ *
+ */
+
+static void card_init_transfer(sd_card_t *card, sd_host_t *host)
+{
+ bool autocmd23 = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ card->has_built_inf = FALSE;
+ card->last_dir = DATA_DIR_NONE;
+ card->last_sect = 0;
+
+ if (host->cfg->host_item.test_infinite_transfer_mode.enable_inf ==
+ FALSE) {
+ card->inf_trans_enable = FALSE;
+ goto next;
+ }
+
+ switch (card->card_type) {
+ case CARD_UHS2:
+ card->inf_trans_enable =
+ (byte) host->cfg->host_item.test_infinite_transfer_mode.enable_sd40_inf;
+ break;
+ case CARD_SD:
+ card->inf_trans_enable =
+ (byte) host->cfg->host_item.test_infinite_transfer_mode.enable_legacy_inf;
+ break;
+ case CARD_MMC:
+ card->inf_trans_enable =
+ (byte) host->cfg->host_item.test_infinite_transfer_mode.enable_mmc_inf;
+ break;
+ case CARD_EMMC:
+ card->inf_trans_enable =
+ (byte) host->cfg->host_item.test_infinite_transfer_mode.enable_emmc_inf;
+ break;
+ default:
+ card->inf_trans_enable = FALSE;
+ break;
+ }
+
+next:
+ if ((card->card_type == CARD_SD) && (card->info.scr.cmd_support & 0x2))
+ autocmd23 = TRUE;
+
+ host_transfer_init(host, card->inf_trans_enable, FALSE);
+ host_enable_cmd23(host, autocmd23);
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+}
+
+/*
+ * Function Name: card_switch2_adma
+ *
+ * Abstract: call this function to switch to adma2 mode, caller must restore.
+ *
+ * Input:
+ *
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd: if the init occurred at init stage this parameter will be null
+ *
+ * Output: None
+ *
+ * Return value: If the routine succeeds, it must return TRUE, otherwize reutrn FALSE
+ *
+ * Notes:
+ *
+ * Caller:
+ *
+ */
+
+bool card_switch2_adma(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_ERROR_RECOVER | FEATURE_IOCTL_TRACE,
+ NOT_TO_RAM, "Enter %s\n", __func__);
+ /* stop inf */
+ if (card->has_built_inf) {
+ /* need stop first */
+ ret = card_stop_infinite(card, FALSE, sd_cmd);
+ if (ret == FALSE) {
+ DbgErr("Stop Inf error for swithc2_adma\n");
+ goto exit;
+ }
+ }
+
+ host_transfer_init(card->host, FALSE, TRUE);
+ ret = TRUE;
+exit:
+ DbgInfo(MODULE_ALL_CARD, FEATURE_ERROR_RECOVER | FEATURE_IOCTL_TRACE,
+ NOT_TO_RAM, "Enter %s ret=%d\n", __func__, ret);
+ return ret;
+}
+
+/*
+ * Function Name: card_degrade_info_init
+ *
+ * Abstract: init card degrade info
+ *
+ * Input:
+ *
+ * sd_card_t *card : The Command will send to which Card
+ * sd_host_t *host: Pointer to the host structure
+ *
+ * Output: None
+ *
+ * Return value: None
+ *
+ * Notes:
+ *
+ * Caller: card_stuct_init
+ *
+ */
+
+static void card_degrade_info_init(sd_card_t *card, sd_host_t *host)
+{
+ /* 1. Init the target access mode (Legacy mode) to the maximum access mode. */
+ card->sw_target_setting.sd_access_mode =
+ (byte) host->cfg->card_item.test_max_access_mode.value;
+
+ /* 2. Init the target drive strength */
+ card->sw_target_setting.sd_drv_type =
+ (byte) host->cfg->card_item.test_driver_strength_sel.value;
+
+ /* 3. Init the target power limit */
+ card->sw_target_setting.sd_power_limit =
+ (byte) host->cfg->card_item.test_max_power_limit.value;
+
+ card->degrade_uhs2_range = 0;
+ card->degrade_uhs2_half = 0;
+ card->degrade_uhs2_legacy = 0;
+ card->degrade_final = 0;
+ card->degrade_freq_level = 0;
+
+ /* below item is used for thremal control */
+ card->thermal_enable = 0;
+ card->thermal_uhs2_range = 0;
+ card->thermal_uhs2_half_dis = 0;
+ card->thermal_uhs2_lpm = 0;
+ card->thermal_access_mode = 0;
+ card->thermal_power_limit = 0;
+
+ card->continue_init_fail_cnt = 0;
+ card->continue_rw_err_cnt = 0;
+ card->adma_err_cnt = 0;
+
+}
+
+/*
+ * Function Name: card_stuct_init
+ *
+ * Abstract:
+ *
+ * 1. init card control info, such as degrade info
+ * 2. bind card to host and memset function
+ *
+ * Input:
+ *
+ * bht_dev_ext_t* pdev_ext: Pointer to the device structure
+ *
+ * Output: None
+ *
+ * Return value: None
+ *
+ * Notes:
+ *
+ * Caller: req_global_init
+ *
+ */
+
+void card_stuct_init(bht_dev_ext_t *pdev_ext)
+{
+ sd_card_t *card;
+ sd_host_t *host;
+
+ /* Support 1 virtual card so far. */
+ card = &(pdev_ext->card);
+
+ /* 1. Zero the card structure */
+ os_memset(card, 0, sizeof(sd_card_t));
+
+ /* 2. set the host point of card */
+ card->host = &(pdev_ext->host);
+ host = card->host;
+
+ /* 3. Error Count clear */
+ card->adma_err_cnt = 0;
+ card->continue_init_fail_cnt = 0;
+ card->continue_rw_err_cnt = 0;
+ card->restore_tuning_content_fail = 0;
+ card->read_signal_block_flag = 0;
+
+ card_degrade_info_init(card, host);
+ card->host->output_tuning.auto_phase_flag = FALSE;
+ card->retry_output_fail_phase = 0xFF;
+}
+
+/*
+ * Function Name: card_stuct_uinit
+ *
+ * Abstract:
+ *
+ * 1. this function is called by card remvoe and enter pm
+ * 2. this function will only clear software flag
+ *
+ * Input:
+ *
+ * sd_card_t *card : Pointer to the card structure
+ *
+ * Output: None
+ *
+ * Return value: None
+ *
+ * Notes:
+ *
+ * Caller: remove_card_handle
+ *
+ */
+
+void card_stuct_uinit(sd_card_t *card)
+{
+ card->initialized_once = FALSE;
+ card->card_type = CARD_NONE;
+ os_memset(&card->info, 0, sizeof(card->info));
+ card->has_built_inf = FALSE;
+ card->inf_trans_enable = FALSE;
+ card->last_dir = DATA_DIR_NONE;
+ card->last_sect = 0;
+ os_memset(&card->mmc, 0, sizeof(card->mmc));
+ os_memset(&card->uhs2_info, 0, sizeof(card->uhs2_info));
+ card->quirk = 0;
+ card->quick_init = 0;
+
+ card->adma_err_cnt = 0;
+ card->continue_init_fail_cnt = 0;
+ card->continue_rw_err_cnt = 0;
+ card->restore_tuning_content_fail = 0;
+ card->read_signal_block_flag = 0;
+
+ card->state = CARD_STATE_POWEROFF;
+ card->write_protected = FALSE;
+ card_degrade_info_init(card, card->host);
+ card->host->output_tuning.auto_phase_flag = FALSE;
+ card->thread_init_card_flag = 0;
+ card->retry_output_fail_phase = 0xFF;
+}
+
+static inline bool uhs2_support(sd_host_t *host)
+{
+ bool ret = TRUE;
+ /* 1. Host do not support UHSII */
+ if (!host->uhs2_supp)
+ ret = FALSE;
+
+ /* 1 TODO. correct the check condition */
+ /* 2. Configuration settings to disable UHSII function */
+ if (host->cfg->card_item.sd_card_mode_dis.dis_sd40_card)
+ ret = FALSE;
+ return ret;
+
+}
+
+static inline bool emmc_enabled(sd_host_t *host)
+{
+ /* 1. Configuration settings to disable eMMC function */
+ bool ret = FALSE;
+
+ if (host->cfg->card_item.emmc_mode.emmc_enable)
+ ret = TRUE;
+
+ return ret;
+}
+
+inline bool mmc_disabled(sd_host_t *host)
+{
+ /* 1. Configuration settings to disable eMMC function */
+ bool ret = FALSE;
+
+ if (host->cfg->card_item.mmc_mode_dis.dis_mmc_func)
+ ret = TRUE;
+ return ret;
+}
+
+static void card_variable_init(sd_card_t *card)
+{
+ card->info.card_ccs = 0;
+ card->info.card_s18a = 0;
+ card->info.rca = 0;
+ card->info.ddr_flag = 0;
+ card->info.io_signal_vol = 0;
+ os_memset(&card->info.sw_cur_setting, 0, sizeof(sd_sw_func_t));
+
+ card->uhs2_info.dev_id = 0;
+ os_memset(&card->uhs2_info.uhs2_setting, 0, sizeof(uhs2_info_t));
+ card->mmc.cur_buswidth = EMMC_1Bit_BUSWIDTH;
+ card->mmc.cur_hs_type = 0;
+}
+
+/*
+ * Related register setting and Driver behavior description
+ * 1). SD7.0 Card capacibility detection register
+ * 0x1e0[29:28] = 2’b11: Enable hardware capability detection interrupt;
+ * 0x1e0[25:24] = 2’b11: enable hardware capability detection interrupt status.
+ * 0x1e0[17:16]: write 1 to this bit to clear interrupt status.
+ *
+ */
+static bool check_express_card_clkreqn_status(sd_card_t *card)
+{
+ u32 delay_us = 1;
+ u32 delay_ms;
+ loop_wait_t wait;
+ u32 regval;
+ bool ret = FALSE;
+ sd_host_t *host = card->host;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ switch (host->cfg->card_item.sd7_sdmode_switch_control.switch_method_ctrl) {
+ case HW_DETEC_HW_SWITCH:
+ /* hardware interrupt control */
+ DbgInfo(MODULE_SD_HOST, FEATURE_INTR_TRACE, NOT_TO_RAM,
+ "before clkreqn_status : %d\n", host->clkreqn_status);
+ while (1) {
+ if (os_atomic_read(&host->clkreqn_status) == 1) {
+ ret = TRUE;
+ DbgInfo(MODULE_SD_HOST, FEATURE_INTR_TRACE,
+ NOT_TO_RAM,
+ "Wait express clkreqn complete status ok\n");
+ break;
+ } else if (os_atomic_read(&host->clkreqn_status) == 2) {
+ ret = FALSE;
+ DbgInfo(MODULE_SD_HOST, FEATURE_INTR_TRACE,
+ NOT_TO_RAM,
+ "Wait express clkreqn timeout\n");
+ break;
+ }
+
+ if (card->card_present == FALSE) {
+ ret = FALSE;
+ DbgErr("card is removed\n");
+ break;
+ }
+ }
+ DbgInfo(MODULE_SD_HOST, FEATURE_INTR_TRACE, NOT_TO_RAM,
+ "after clkreqn_status : %d\n", host->clkreqn_status);
+ break;
+
+ case SW_POLL_SW_SWITCH:
+ case SW_POLL_SWCTRL_SWITCH:
+ /* software control */
+
+ /* set polling tmie fix value 30ms */
+ delay_ms = 30;
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "software control\n");
+
+ util_init_waitloop(host->pdx, delay_ms, delay_us, &wait);
+ while (!util_is_timeout(&wait)) {
+ if (host_check_lost(host)) {
+ ret = TRUE;
+ break;
+ }
+
+ if (((sdhci_readl(host, 0x1e0) & (0x1)) == 0)) {
+ ret = TRUE;
+ break;
+ }
+
+ if (card->card_present == FALSE) {
+ ret = FALSE;
+ DbgErr("card is removed\n");
+ break;
+ }
+ }
+
+ break;
+
+ case SW_POLL_INTER_SW_SWITCH:
+ case SW_POLL_INTER_SWCRTL_SWITCH:
+ /* hardware polling control */
+ DbgInfo(MODULE_SD_HOST, FEATURE_INTR_TRACE, NOT_TO_RAM,
+ "software polling control\n");
+ while (1) {
+ if (host_check_lost(host)) {
+ ret = TRUE;
+ DbgErr("chip lost, already switch to sd7.0\n");
+ break;
+ }
+
+ regval = sdhci_readl(host, 0x1e0);
+ if (regval & (1 << 16)) {
+
+ DbgInfo(MODULE_SD_HOST, FEATURE_INTR_TRACE,
+ NOT_TO_RAM,
+ "Wait express clkreqn complete status ok\n");
+ ret = TRUE;
+ sdhci_or16(host, 0x1e2, 0x01);
+ break;
+ } else if (regval & (1 << 17)) {
+ DbgInfo(MODULE_SD_HOST, FEATURE_INTR_TRACE,
+ NOT_TO_RAM,
+ "Wait express clkreqn timeout\n");
+ ret = FALSE;
+ sdhci_or16(host, 0x1e2, 0x02);
+ break;
+ }
+
+ if (card->card_present == FALSE) {
+ ret = FALSE;
+ break;
+ DbgErr("card is removed\n");
+ }
+ }
+ break;
+
+ default:
+ DbgErr("no such value!\n");
+ break;
+ }
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit %s (%d)\n", __func__, ret);
+
+ return ret;
+}
+
+static bool Turn_on_vdd2_or_vdd3(sd_card_t *card, bool flag)
+{
+ sd_host_t *host = card->host;
+ u32 regval;
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ regval = sdhci_readl(host, 0x1e0);
+ switch (host->cfg->card_item.sd7_sdmode_switch_control.switch_method_ctrl) {
+ case HW_DETEC_HW_SWITCH:
+ /* set 0x1e0[29:28] = 2’b11, set 0x1e0[25:24] = 2’b11 */
+ regval |= (0x33 << 24);
+ break;
+
+ case SW_POLL_SW_SWITCH:
+ case SW_POLL_SWCTRL_SWITCH:
+ /* set 0x1e0[29:28] = 2’b00, set 0x1e0[25:24] = 2’b00 */
+ regval &= 0xccffffff;
+ break;
+
+ case SW_POLL_INTER_SW_SWITCH:
+ case SW_POLL_INTER_SWCRTL_SWITCH:
+ /* set 0x1e0[29:28] = 2’b00, set 0x1e0[25:24] = 2’b11 */
+ regval |= (0x3 << 24);
+ break;
+
+ default:
+ DbgErr("Error:no such value in registry sd7_sdmode_switch_control, use default value\n");
+ regval |= (0x33 << 24);
+ break;
+ }
+ sdhci_writel(host, 0x1e0, regval);
+
+ /* 1:VDD3 0:VDD2 */
+ if ((flag)
+ && (host->cfg->card_item.sd7_sdmode_switch_control.vdd3_control)) {
+
+ /* Turn on vdd3 */
+ os_atomic_set(&host->clkreqn_status, 0);
+ host_set_vddx_power(host, VDD3, POWER_ON);
+ ret = check_express_card_clkreqn_status(card);
+ if (!ret) {
+ DbgErr("check clkreq failed fater turn on vdd3\n");
+ /* Turn off vdd3 */
+ host_set_vddx_power(host, VDD3, POWER_OFF);
+
+ /* Turn on vdd2 */
+ os_atomic_set(&host->clkreqn_status, 0);
+ host_set_vddx_power(host, VDD2, POWER_ON);
+ ret = check_express_card_clkreqn_status(card);
+ if (!ret) {
+ DbgErr("check clkreq failed fater turn on vdd2\n");
+ host_set_vddx_power(host, VDD2, POWER_OFF);
+ }
+ }
+ } else {
+ /* Turn on vdd2 */
+ os_atomic_set(&host->clkreqn_status, 0);
+ host_set_vddx_power(host, VDD2, POWER_ON);
+
+ ret = check_express_card_clkreqn_status(card);
+ if (!ret) {
+ DbgErr("check clkreq failed fater turn on vdd2 derectily\n");
+ host_set_vddx_power(host, VDD2, POWER_OFF);
+ }
+ }
+ return ret;
+}
+
+bool pcie_mode_init(sd_card_t *card, bool code_flag)
+{
+ sd_host_t *host = card->host;
+ u32 regval;
+ bool ret;
+ bool host_support_vdd3;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* set flag that driver in sd_express mode */
+ host->sd_express_flag = TRUE;
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Set sd_express_flag\n");
+
+ regval = sdhci_readl(host, 0x44);
+ if (!(regval & (1 << 29)))
+ host_support_vdd3 = FALSE;
+ else
+ host_support_vdd3 = TRUE;
+
+ /* flag 1:for sd cmd code */
+ if (code_flag) {
+
+ host_enable_clock(host, FALSE);
+
+ /* stop clk */
+ if (shift_bit_func_enable(host)) {
+ set_pattern_value(host, 0x34);
+ return TRUE;
+ }
+
+ if (card->card_support_vdd3 && host_support_vdd3)
+ ret = Turn_on_vdd2_or_vdd3(card, TRUE);
+ else
+ ret = Turn_on_vdd2_or_vdd3(card, FALSE);
+
+ } else {
+ /* flag 0 ：for trail run code */
+ if (shift_bit_func_enable(host)) {
+ set_pattern_value(host, 0x34);
+ return TRUE;
+ }
+ ret = Turn_on_vdd2_or_vdd3(card, host_support_vdd3);
+ }
+
+ if (ret) {
+ /*
+ * Software: if pcr 0x444[9]=1,
+ * set sd host register 054h[8]=1 to assert express_card_mode
+ */
+ regval = pci_readl(host, 0x444);
+ if (regval & (1 << 9)) {
+ regval = sdhci_readl(host, 0x54);
+ regval |= (1 << 8);
+ sdhci_writel(host, 0x54, regval);
+ }
+ return TRUE;
+
+ }
+
+ DbgErr("Exit pcie mode init with FALSE\n");
+ host->sd_express_flag = FALSE;
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Clear sd_express_flag\n");
+ return FALSE;
+}
+
+bool gg8_get_card_capability_flag(sd_card_t *card, bool check_uhs2_flag)
+{
+ bool ret;
+ bool flag_f8 = FALSE;
+ sd_command_t sd_cmd;
+ sd_host_t *host = card->host;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (check_uhs2_flag) {
+ host_init(host);
+ card_variable_init(card);
+ host_init_400k_clock(host);
+ host_internal_clk_setup(host, TRUE);
+
+ /* 1. Power on card */
+ if (host_get_vdd1_state(host) == FALSE) {
+ os_mdelay(10);
+ /* host_set_vdd1_power(host, TRUE, SDHCI_POWER_VDD1_330); */
+ if (shift_bit_func_enable(host))
+ set_pattern_value(host, 0x11);
+
+ host_set_vddx_power(host, VDD1, POWER_ON);
+ }
+ }
+ /* 1 SD CLK Start */
+ host_enable_clock(host, TRUE);
+
+ /* 2 CMD0 */
+ ret = card_reset_card(card, &sd_cmd);
+ if (!ret) {
+ /* Go Idle State command failed. exit directly. */
+ DbgErr("Reset Card (CMD0) Failed.\n");
+ return FALSE;
+
+ }
+ /* 3. Issue send IF condition command (CMD8) */
+ if (check_uhs2_flag)
+ ret = sd_send_if_cond(card, &sd_cmd, 0x000001AA);
+ else
+ ret = sd_send_if_cond(card, &sd_cmd, 0x000031AA);
+
+
+ if (!ret) {
+ /* 3.1 Error response */
+ if (sd_cmd.err.error_code == ERR_CODE_RESP_ERR ||
+ sd_cmd.err.error_code == ERR_CODE_NO_CARD) {
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "CMD8 Response Error or no card.\n");
+ } else {
+ /* 5.2 No Response (Standard Capacity Card) */
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "CMD8 No Responser.\n");
+ }
+
+ return FALSE;
+
+ } else {
+ /* 5.3 Good Response (High Capacity card) */
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "CMD8 Good Responser\n");
+ flag_f8 = TRUE;
+ }
+
+ /* 5.4.1 read R7 */
+
+ /* sd_send_if_cond argument = 0x000031AA check card support pcie */
+ if (check_uhs2_flag == FALSE) {
+ /* host ask card's PCIe availability */
+ if (!(sd_cmd.response[0] & 0x1000))
+ card->card_support_pcie = FALSE;
+ else
+ card->card_support_pcie = TRUE;
+
+ if (sd_cmd.response[0] & 0x2000) {
+ /* host ask whether card support VDD3 */
+ card->card_support_vdd3 = TRUE;
+ } else
+ card->card_support_vdd3 = FALSE;
+
+ }
+
+ /* if check_uhs2_flag == true, send ACMD41 to check response bit 29 */
+ if (check_uhs2_flag) {
+ ret = card_init_ready(card, &sd_cmd, flag_f8);
+
+ if (!ret) {
+ DbgErr("Wait for card ready (ACMD41) Failed.\n");
+ return FALSE;
+ }
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+ return TRUE;
+}
+
+bool gg8_sd70_card_init(sd_card_t *card)
+{
+ bool ret;
+ u32 regval;
+ sd_host_t *host = card->host;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ card->pcie_init_flag = TRUE;
+
+ /* update card status */
+ card->card_present = hostven_chk_card_present(host);
+
+ /* check card exist? */
+ if (card->card_present == FALSE || card->card_chg)
+ return FALSE;
+
+
+ if (INIT_DELAY & INIT_DELAY_EN_MASK) {
+ os_mdelay(INIT_DELAY & INIT_DELAY_CFG_MASK);
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "%s init delay %d ms\n", __func__,
+ (INIT_DELAY & INIT_DELAY_CFG_MASK));
+ } else {
+ os_mdelay(200);
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "%s init delay %d ms\n", __func__, 200);
+ }
+
+ /* 0 host side init */
+ host_init(host);
+ card_variable_init(card);
+ host_init_400k_clock(host);
+ host_internal_clk_setup(host, TRUE);
+
+ /* 1. Power on card */
+ if (shift_bit_func_enable(host) &&
+ (host->cfg->card_item.sd7_sdmode_switch_control.card_init_flow_select)) {
+ os_mdelay(10);
+
+ if (shift_bit_func_enable(host))
+ set_pattern_value(host, 0x10);
+
+ host_set_vddx_power(host, VDD1, POWER_ON);
+ } else {
+ if (host_get_vdd1_state(host) == FALSE) {
+ os_mdelay(10);
+
+ if (shift_bit_func_enable(host))
+ set_pattern_value(host, 0x10);
+
+ host_set_vddx_power(host, VDD1, POWER_ON);
+ }
+ }
+
+ regval = pci_readl(host, 0x444);
+ if (!(regval & (0x1 << 11))) {
+ /* CMD8 */
+
+ /* FALSE no need to send ACMD41 */
+ ret = gg8_get_card_capability_flag(card, FALSE);
+ if (!ret) {
+ DbgErr
+ ("gg8_get_card_capability_flag exit with faile\n");
+ }
+
+ regval = pci_readl(host, 0x444);
+ if (!(regval & (0x7 << 8))) {
+ DbgErr("host not support to switch to sd7.0\n");
+ card->pcie_init_flag = FALSE;
+ return FALSE;
+ }
+
+ if (card->card_support_pcie) {
+ ret = pcie_mode_init(card, TRUE);
+ if (!ret) {
+ DbgErr("pci cmd mode init failed\n");
+ card->pcie_init_flag = FALSE;
+ } else {
+ card->pcie_init_flag = TRUE;
+ }
+ } else {
+ DbgErr("card not support pcie\n");
+ card->pcie_init_flag = FALSE;
+ return FALSE;
+ }
+ } else {
+
+ /* trail run */
+ ret = pcie_mode_init(card, FALSE);
+ if (!ret) {
+ DbgErr("pci trail run mode init failed\n");
+ card->pcie_init_flag = FALSE;
+ } else {
+ card->pcie_init_flag = TRUE;
+ }
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+ /* Thomas test: call remove here. */
+ if (card->pcie_init_flag == TRUE) {
+ bht_sd_remove(host->pci_dev.pci_dev);
+
+ return TRUE;
+ }
+
+ if (ret) {
+ card_init_transfer(card, host);
+ card->initialized_once = TRUE;
+ card->state = CARD_STATE_WORKING;
+ card->continue_init_fail_cnt = 0;
+ if (host_wr_protect_pin(host) || card_wr_protect(card))
+ card->write_protected = TRUE;
+ else
+ card->write_protected = FALSE;
+
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}
+
+/*
+ * Function Name: card_pcie_support
+ *
+ * Abstract: check whether the card supports SD7.0 mode
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output: None
+ *
+ * Return value: return TRUE if the card supports SD7.0 mode, otherwise return FALSE
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ *
+ */
+
+bool card_pcie_support(sd_card_t *card)
+{
+ bool ret = FALSE;
+ u32 regval = 0;
+ bool host_support_sd70 = FALSE;
+ bool sd_cmd_low = FALSE;
+ bool registry_support_sd70 = TRUE;
+ bool any_switch_case_enable = FALSE;
+ sd_host_t *host = card->host;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if ((sdhci_readl(host, 0x40) & (1 << 20)))
+ host_support_sd70 = TRUE;
+
+ if ((pci_readl(host, 0x444) & 0x700))
+ any_switch_case_enable = TRUE;
+
+ /* polling PCR 0x448[31] */
+ if ((pci_readl(host, 0x448) & (1 << 31))) {
+ regval = pci_readl(host, 0x448);
+ regval |= (1 << 31);
+ pci_writel(host, 0x448, regval);
+ card->cmd_low_reset_flag = TRUE;
+ } else {
+ sd_cmd_low = TRUE;
+ }
+
+ if (host->cfg->card_item.sd_card_mode_dis.dis_sd70_card)
+ registry_support_sd70 = FALSE;
+
+ if (host_support_sd70 && sd_cmd_low && registry_support_sd70
+ && any_switch_case_enable && (card->cmd_low_reset_flag == FALSE)) {
+ if ((pci_readl(host, 0x444) & (1 << 10))) {
+ if ((pci_readl(host, 0x444) & (1 << 15))) {
+ if ((pci_readl(host, 0x50c) & (1 << 6)))
+ ret = FALSE;
+ else
+ ret = TRUE;
+ } else {
+ if ((pci_readl(host, 0x50c) & (1 << 6)))
+ ret = TRUE;
+ else
+ ret = FALSE;
+ }
+ } else {
+ ret = TRUE;
+ }
+ } else {
+ ret = FALSE;
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit %s with(%d)\n", __func__, ret);
+ return ret;
+}
+
+/*
+ * Function Name: card_init
+ *
+ * Abstract: Main card initialize entry.
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * int retry_num [in]: Retry number if card init failed.
+ * bool bfullreset: full reset flag
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: thread_init_card
+ *
+ */
+
+bool card_init(sd_card_t *card, int retry_num, bool bfullreset)
+{
+ bool ret = FALSE;
+ bool stbl = FALSE;
+ sd_host_t *host = card->host;
+ bool first_init = TRUE;
+ u32 regval;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (host->pdx == NULL) {
+ DbgErr("host->pdx should not be NULL\n");
+ return FALSE;
+ }
+ if (host_check_lost(host)) {
+ DbgErr("Host lost at card init start\n");
+ return FALSE;
+ }
+
+ if (shift_bit_func_enable(host) &&
+ (host->cfg->card_item.sd7_sdmode_switch_control.card_init_flow_select))
+ goto retry;
+ else
+ goto express_flow;
+
+express_flow:
+ /* SD7.0 card mode init flow */
+ if (host->chip_type == CHIP_GG8) {
+ if (card_pcie_support(card)) {
+ ret = gg8_sd70_card_init(card);
+
+ if (!ret) {
+ regval = pci_readl(host, 0x444);
+ regval &= (~(1 << 11));
+ pci_writel(host, 0x444, regval);
+ }
+
+ if (card->pcie_init_flag == FALSE) {
+ if (card->card_present == TRUE) {
+ if (shift_bit_func_enable(host)
+ && (host->cfg->card_item.sd7_sdmode_switch_control.card_init_flow_select))
+ goto legacy;
+ else
+ goto retry;
+ } else
+ return FALSE;
+ } else {
+ card->card_type = CARD_SD70;
+ card->card_present = FALSE;
+ return ret;
+ }
+ } else if (card->card_present == TRUE) {
+ if (shift_bit_func_enable(host)
+ && (host->cfg->card_item.sd7_sdmode_switch_control.card_init_flow_select))
+ goto legacy;
+ else
+ goto retry;
+ } else {
+ return FALSE;
+ }
+ }
+
+retry:
+
+ /* update card status */
+ card->card_present = hostven_chk_card_present(host);
+ if (first_init == TRUE) {
+ first_init = FALSE;
+ } else {
+
+ /* check card exist? */
+ if (card->card_present == FALSE || card->card_chg) {
+ ret = FALSE;
+ goto end;
+ }
+
+ if (INIT_DELAY & INIT_DELAY_EN_MASK) {
+ os_mdelay(INIT_DELAY & INIT_DELAY_CFG_MASK);
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "%s init delay %d ms\n", __func__,
+ (INIT_DELAY & INIT_DELAY_CFG_MASK));
+ } else {
+ os_mdelay(200);
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "%s init delay %d ms\n", __func__, 200);
+ }
+
+ }
+
+ /* Do some Host side initialization */
+ if (bfullreset == FALSE)
+ host_init(host);
+ card_variable_init(card);
+
+ /* Check eMMC function enabled or not */
+ if (emmc_enabled(host)) {
+ hostven_set_pml0_requrest(host, FALSE);
+ ret = emmc_init(card, TRUE);
+ goto exit;
+ }
+
+ if (card_need_get_info(card) == FALSE) {
+ switch (card->card_type) {
+ case CARD_EMMC:
+ case CARD_MMC:
+ goto mmc;
+ case CARD_SD:
+ goto legacy;
+ default:
+ break;
+ }
+ }
+
+ /* Check host and configuration support UHSII or not */
+ if ((uhs2_support(host))
+ && (card->degrade_uhs2_legacy == 0)
+ && (card->card_type != CARD_MMC && card->card_type != CARD_SD)) {
+ u32 clk_value = card_get_uhs2_freq(card);
+
+ DbgErr("host support uhs2\n");
+ DbgErr("uhs2 trail run mode\n");
+
+ hostven_set_pml0_requrest(host, TRUE);
+ host_uhs2_init(host, clk_value, bfullreset);
+ ret = host_uhs2_phychk(host, FALSE, &stbl);
+
+ /* phy init ok */
+ if (ret) {
+ ret = uhs2_card_init(card);
+ if (ret) {
+ if (shift_bit_func_enable(host))
+ set_pattern_value(host, 0x32);
+
+ goto exit;
+ } else if (card->card_type == CARD_SDIO) {
+ ret = FALSE;
+ goto end;
+ }
+ }
+ /* stbl check failed */
+ else if (stbl == FALSE) {
+ if (shift_bit_func_enable(host)
+ && (host->cfg->card_item.sd7_sdmode_switch_control.card_init_flow_select)) {
+ host_uhs2_clear(host,
+ (bool)host->cfg->card_item.test_uhs2_setting2.enable_power_off_vdd1);
+ regval = pci_readl(host, 0x444);
+ if (regval & (1 << 11)) {
+ regval &= (~(1 << 11));
+ pci_writel(host, 0x444, regval);
+ }
+ card_variable_init(card);
+ hostven_set_pml0_requrest(host, FALSE);
+ goto express_flow;
+ }
+
+ if (card->card_type == CARD_UHS2
+ && card->degrade_uhs2_legacy) {
+ card->card_type = CARD_NONE;
+ card->quick_init = 0;
+ card->degrade_freq_level = 0;
+
+ /* If card last stb.l is ok we continue try as UHS2 */
+ goto exit;
+ }
+
+ host_uhs2_clear(host,
+ (bool)host->cfg->card_item.test_uhs2_setting2.enable_power_off_vdd1);
+ goto legacy;
+ }
+
+ DbgErr("UHS2 init failed\n");
+ /* UHS2 init failed case, try again */
+ goto exit;
+ }
+
+legacy:
+
+ regval = pci_readl(host, 0x444);
+ if (regval & (1 << 11)) {
+ regval &= (~(1 << 11));
+ pci_writel(host, 0x444, regval);
+ }
+
+ card_variable_init(card);
+ /* Do SD Legacy card initialization */
+ if (card->card_type != CARD_MMC) {
+ hostven_set_pml0_requrest(host, FALSE);
+ ret = sd_legacy_init(card);
+ if (card->card_type == CARD_SDIO) {
+ ret = FALSE;
+ goto end;
+ }
+
+ if ((ret == FALSE)
+ && (card->sw_ctrl_swicth_to_express == FALSE)) {
+ DbgErr("Legacy SD Init failed\n");
+ goto mmc;
+ } else
+ goto exit;
+ }
+
+mmc:
+ if ((card->card_type != CARD_SD) && (card->card_type != CARD_UHS2)) {
+ if (mmc_disabled(host)) {
+ DbgErr("Registry disable MMC card function!!\n");
+ goto exit;
+ }
+ host_poweroff(host, card->card_type);
+ host_init(host);
+ card_variable_init(card);
+ hostven_set_pml0_requrest(host, FALSE);
+ ret = emmc_init(card, FALSE);
+ }
+
+exit:
+ if (ret == TRUE) {
+ card_init_transfer(card, host);
+ card->initialized_once = TRUE;
+ card->state = CARD_STATE_WORKING;
+ card->continue_init_fail_cnt = 0;
+ if (host_wr_protect_pin(host) || card_wr_protect(card))
+ card->write_protected = TRUE;
+ else
+ card->write_protected = FALSE;
+
+ } else {
+ if (card->sw_ctrl_swicth_to_express == TRUE)
+ goto end;
+
+ card->continue_init_fail_cnt++;
+ retry_num--;
+ if ((retry_num == 0) ||
+ (card->card_present == FALSE) ||
+ (card->card_type == CARD_ERROR) || host_check_lost(host)) {
+ goto end;
+ }
+
+ /* Call degarde policy if try_times >= 4 */
+ if (card->continue_init_fail_cnt >= CARD_INIT_DEGARDE_TIME)
+ card_degrade_policy(card, NULL);
+
+ /* Need power cycle for retry, etc. */
+ if (card->card_type == CARD_UHS2) {
+ if (host->cfg->card_item.test_uhs2_setting2.enable_full_reset_reinit) {
+ /* If last time not use fullreset, then use fullreset */
+ bfullreset = bfullreset ? FALSE : TRUE;
+ if (bfullreset) {
+ uhs2_full_reset_card(card);
+ DbgErr
+ ("Card Init failed do fullreset retry\n");
+ goto retry;
+ }
+ }
+ }
+
+ host_poweroff(host, CARD_NONE);
+ card->state = CARD_STATE_POWEROFF;
+ DbgErr("Card Init failed do poweroff retry\n");
+ goto retry;
+ }
+
+end:
+ if (ret == FALSE) {
+ host_poweroff(host, CARD_NONE);
+ card->state = CARD_STATE_POWEROFF;
+ if ((card->degrade_final) ||
+ (card->card_type == CARD_NONE
+ && card->continue_init_fail_cnt >= 5)) {
+ DbgErr("Card finally Init failed\n");
+ card->card_type = CARD_ERROR;
+ }
+ card->quick_init = 0;
+ }
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, ret);
+ return ret;
+}
+
+bool card_init_stage2(sd_card_t *card)
+{
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ switch (card->card_type) {
+ case CARD_SD:
+ ret = sd_init_stage2(card);
+ break;
+ case CARD_UHS2:
+ ret = uhs2_init_stage2(card);
+ break;
+ case CARD_MMC:
+ case CARD_EMMC:
+ ret = emmc_init_stage2(card);
+ break;
+ default:
+
+ break;
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, ret);
+ return ret;
+}
+
+/*
+ * Function Name: card_power_off
+ *
+ * Abstract: This function is used to set card to power off status
+ * 1. Resume from Sleep mode if necessary
+ * 2. Stop Infintie transfer if necessary
+ * 3. Poweroff Card
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * bool directly: If true means do card poweroff directly(often use at error case)
+ *
+ * Output: None
+ *
+ * Return value: None
+ *
+ * Notes:
+ *
+ * Caller: card_enter_sleep
+ *
+ */
+
+void card_power_off(sd_card_t *card, bool directly)
+{
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM,
+ "Enter %s directy=%d\n", __func__, directly);
+
+ if (directly)
+ goto next;
+
+ /* If wake up failed than goto poweroff directly */
+ if (card_resume_sleep(card, FALSE) == FALSE)
+ goto next;
+
+ if (card_stop_infinite(card, FALSE, NULL) == FALSE)
+ goto next;
+ else {
+ /* go dormant for UHSII D3-hot */
+ card_enter_sleep(card, FALSE, TRUE);
+ }
+
+next:
+ if (card->state != CARD_STATE_POWEROFF)
+ host_poweroff(card->host, card->card_type);
+ card->state = CARD_STATE_POWEROFF;
+ card->thread_init_card_flag = 0;
+ card->has_built_inf = FALSE;
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+}
+
+/*
+ * Function Name: card_thermal_control
+ *
+ * Abstract: This Function is used to do card thremal control, only for SD
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output: None
+ *
+ * Return value: TRUE means ok, others means error, caller need do error recovery
+ *
+ * Notes: run in thread context
+ *
+ * Caller: func_thermal_control
+ *
+ */
+
+bool card_thermal_control(sd_card_t *card)
+{
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_FUNC_THERMAL, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (card->card_present == FALSE)
+ goto exit;
+
+ if (card->card_type == CARD_SD)
+ ret = sd_thermal_control(card);
+
+exit:
+ DbgInfo(MODULE_ALL_CARD, FEATURE_FUNC_THERMAL, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+ return ret;
+}
+
+bool card_stop_infinite(sd_card_t *card, bool recover, sd_command_t *pcmd)
+{
+ bool ret = TRUE;
+ sd_command_t sd_cmd;
+ sd_command_t *cmd = (pcmd == NULL) ? &sd_cmd : pcmd;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (card->card_present == FALSE || card->has_built_inf == FALSE)
+ goto exit;
+
+ ret = card_send_command12(card, cmd);
+ if (ret == FALSE && recover) {
+ DbgErr("Stop Inf failed for cmd12\n");
+ ret = card_rw_recovery(card, cmd);
+ if (ret == FALSE)
+ goto exit;
+ }
+
+ if (ret == TRUE)
+ ret = card_check_rw_ready(card, cmd, 150);
+
+exit:
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, ret);
+ return ret;
+
+}
+
+bool card_enter_sleep(sd_card_t *card, bool recover, bool deepslp)
+{
+ bool ret = TRUE;
+ sd_command_t sd_cmd;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (card->card_type == CARD_UHS2) {
+ if (deepslp && card->uhs2_info.uhs2_cap.hibernate == 0)
+ deepslp = FALSE;
+ ret = card_stop_infinite(card, recover, &sd_cmd);
+ if (ret == FALSE)
+ goto exit;
+
+ ret = uhs2_enter_dmt(card, &sd_cmd, card->host, deepslp);
+
+ if (ret == TRUE) {
+ card->state =
+ deepslp ? CARD_STATE_DEEP_SLEEP : CARD_STATE_SLEEP;
+ }
+ }
+
+exit:
+ if (ret == FALSE) {
+ DbgErr("enter sleep failed\n");
+ card_power_off(card, TRUE);
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, ret);
+ return ret;
+
+}
+
+bool card_resume_sleep(sd_card_t *card, bool recover)
+{
+ bool ret = TRUE;
+ bool deepslp = FALSE;
+ sd_command_t sd_cmd;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (card->state != CARD_STATE_DEEP_SLEEP
+ && card->state != CARD_STATE_SLEEP)
+ goto exit;
+
+ if (card->card_type == CARD_UHS2) {
+ deepslp = (card->state == CARD_STATE_DEEP_SLEEP) ? TRUE : FALSE;
+ ret = uhs2_resume_dmt(card, &sd_cmd, card->host, deepslp);
+
+ if (ret == TRUE)
+ card->state = CARD_STATE_WORKING;
+ }
+
+exit:
+ if (ret == FALSE) {
+ DbgErr("resume sleep failed\n");
+ if (recover)
+ card_power_off(card, TRUE);
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_OPS, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, ret);
+ return ret;
+}
+
+bool card_piorw_data(sd_card_t *card, u32 sec_addr, u32 sec_cnt,
+ e_data_dir dir, byte *data)
+{
+ bool ret = FALSE;
+
+ sd_command_t sd_cmd;
+ sd_host_t *host = card->host;
+ u8 cmd_index = 0;
+ u32 cmd_flag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ cfg_item_t *cfg = NULL;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_RW_TRACE, NOT_TO_RAM,
+ "Enter %s dir=%d seccnt=0x%08X secaddr=0x%08X\n", __func__,
+ dir, sec_cnt, sec_addr);
+
+ X_ASSERT(host != NULL);
+
+ cfg = host->cfg;
+ X_ASSERT(cfg != NULL);
+
+ if (data == NULL)
+ goto exit;
+
+ if (sec_cnt > 1)
+ cmd_flag |= CMD_FLG_MULDATA;
+
+ if (cmd_flag & CMD_FLG_MULDATA) {
+ if (dir == DATA_DIR_OUT)
+ cmd_index = SD_CMD25;
+ else
+ cmd_index = SD_CMD18;
+ } else {
+ if (dir == DATA_DIR_OUT)
+ cmd_index = SD_CMD24;
+ else
+ cmd_index = SD_CMD17;
+ }
+
+ cmd_set_auto_cmd_flag(card, &cmd_flag);
+ ret =
+ card_send_sdcmd(card, &sd_cmd, cmd_index, sec_addr, cmd_flag, dir,
+ data, sec_cnt * 512);
+ /* todo error recovery and cmd13 */
+
+exit:
+ if (ret == FALSE)
+ DbgErr("Card Pio dir=%d seccnt=0x%08X secaddr=0x%08X failed\n",
+ dir, sec_cnt, sec_addr);
+ DbgInfo(MODULE_ALL_CARD, FEATURE_RW_TRACE, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, ret);
+ return ret;
+}
+
+static void card_cmd_copy(sd_command_t *dst, sd_command_t *src)
+{
+ sd_data_t *data = dst->data;
+
+ os_memcpy(dst, src, sizeof(sd_command_t));
+ dst->data = data;
+
+ if (data && src->data)
+ os_memcpy(dst->data, src->data, sizeof(sd_data_t));
+ else
+ src->data = NULL;
+}
+
+bool card_dma_rw_data(sd_card_t *card, u32 dma_mode, u32 sec_addr, u32 sec_cnt,
+ e_data_dir dir, byte *data, sg_list_t *sglist,
+ u32 sg_len, sd_command_t *cmd_err)
+{
+ bool ret = FALSE;
+
+ sd_command_t sd_cmd;
+ sd_data_t sd_data;
+ sd_host_t *host = card->host;
+ u8 cmd_index = 0;
+ u32 cmd_flag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ cfg_item_t *cfg = NULL;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_RW_TRACE, NOT_TO_RAM,
+ "Enter %s dir=%d seccnt=0x%08X secaddr=0x%08X\n", __func__,
+ dir, sec_cnt, sec_addr);
+
+ cfg = host->cfg;
+
+ if (data == NULL && dma_mode != CFG_TRANS_MODE_ADMA2) {
+ DbgErr("%s argument wrong\n", __func__);
+ goto end;
+ }
+
+ if (sec_cnt > 1)
+ cmd_flag |= CMD_FLG_MULDATA;
+
+ if (cmd_flag & CMD_FLG_MULDATA) {
+ if (dir == DATA_DIR_OUT)
+ cmd_index = SD_CMD25;
+ else
+ cmd_index = SD_CMD18;
+ } else {
+ if (dir == DATA_DIR_OUT)
+ cmd_index = SD_CMD24;
+ else
+ cmd_index = SD_CMD17;
+ }
+
+ cmd_set_auto_cmd_flag(card, &cmd_flag);
+ /* set dma mode */
+ if (dma_mode == CFG_TRANS_MODE_SDMA) {
+ /* host_dma_select(card->host, TRANS_SDMA); */
+ cmd_flag |= CMD_FLG_SDMA;
+ if ((card->card_type != CARD_UHS2) &&
+ (cmd_flag & CMD_FLG_AUTO23)) {
+ /* SDMA don't use auto CMD23 */
+ cmd_flag &= ~CMD_FLG_AUTO23;
+ cmd_flag |= CMD_FLG_AUTO12;
+ }
+ } else if (dma_mode == CFG_TRANS_MODE_ADMA2) {
+ cmd_flag |= CMD_FLG_ADMA2;
+ } else {
+ /* host_dma_select(card->host, TRANS_ADMA2); */
+ cmd_flag |= CMD_FLG_ADMA_SDMA;
+ }
+
+ os_memset(&sd_data, 0, sizeof(sd_data_t));
+ ret =
+ build_dma_ctx(card->host->pdx, &sd_data, cmd_flag, dir, data,
+ sec_cnt * 512, sglist, sg_len);
+ if (ret == FALSE) {
+ DbgErr("build dma ctx failed\n");
+ goto end;
+ }
+
+ ret =
+ card_send_sdcmd_dma_timeout(card, &sd_cmd, &sd_data, cmd_index,
+ sec_addr, cmd_flag, dir, data,
+ sec_cnt * 512, 0);
+
+ if (ret == FALSE && cmd_err != NULL)
+ card_cmd_copy(cmd_err, &sd_cmd);
+
+end:
+ if (ret == FALSE) {
+ DbgErr("Card dma dir=%d seccnt=0x%08X secaddr=0x%08X failed\n",
+ dir, sec_cnt, sec_addr);
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_RW_TRACE, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, ret);
+ return ret;
+}
+
+/*
+ * Currently this function is used for dump mode only,
+ * todo to let it support normal case(Add node2 init code for normal case)
+ */
+bool card_adma2_rw_inf(sd_card_t *card, u32 sec_addr, u32 sec_cnt,
+ e_data_dir dir, sg_list_t *sglist, u32 sg_len,
+ sd_command_t *cmd_err)
+{
+ u32 flg = 0;
+ bool ret = FALSE;
+ sd_command_t sd_cmd;
+ dma_desc_buf_t *pdma = 0;
+ bht_dev_ext_t *pdx = card->host->pdx;
+ node_t *node = NULL;
+ sd_data_t sd_data;
+ bool data_26bit_len =
+ pdx->cfg->host_item.test_dma_mode_setting.enable_dma_26bit_len ?
+ TRUE : FALSE;
+ DbgInfo(MODULE_ALL_CARD, FEATURE_RW_TRACE, NOT_TO_RAM,
+ "Enter %s dir=%d seccnt=0x%08X secaddr=0x%08X\n", __func__,
+ dir, sec_cnt, sec_addr);
+
+ /* Step1 Check can use Infinte or not */
+ flg = cmd_can_use_inf(card, dir, sec_addr, sec_cnt);
+
+ /* not continue case stop infinite first */
+ if (card->has_built_inf && (flg != CMD_FLG_INF_CON)) {
+ ret = card_stop_infinite(card, FALSE, &sd_cmd);
+ if (ret == FALSE) {
+ DbgErr("%s stop infinite failed\n", __func__);
+ goto exit;
+ }
+ }
+
+ /* Non Infinte Case */
+ if (flg == 0) {
+ ret =
+ card_dma_rw_data(card, CFG_TRANS_MODE_ADMA2, sec_addr,
+ sec_cnt, dir, NULL, sglist, sg_len,
+ cmd_err);
+ goto end;
+ }
+
+ /* Step2 Build Infinte sd_cmd */
+ node =
+ (pdx->dma_api.cur_node !=
+ &pdx->dma_api.dma_node) ? &pdx->dma_api.dma_node :
+ &pdx->dma_api.dma_node2;
+ os_memset(&sd_cmd, 0, sizeof(sd_command_t));
+ pdx->dma_api.cur_node = node;
+ if (dir == DATA_DIR_IN)
+ sd_cmd.cmd_index = SD_CMD18;
+ else
+ sd_cmd.cmd_index = SD_CMD25;
+
+ sd_cmd.argument = sec_addr;
+ sd_cmd.cmd_flag |=
+ CMD_FLG_R1 | CMD_FLG_RESCHK | CMD_FLG_MULDATA | CMD_FLG_ADMA2 | flg;
+ sd_cmd.sd_cmd = 1;
+
+ /* Step3 alloc dma desc buf */
+ pdma = node_get_desc_res(node, MAX_ADMA2_TABLE_LEN);
+ if (pdma == NULL) {
+ DbgErr("%s get desc res failed\n", __func__);
+ ret = FALSE;
+ goto exit;
+ }
+
+ node->phy_node_buffer.head = *pdma;
+ node->phy_node_buffer.end =
+ build_adma2_desc(sglist, sg_len, (byte *) pdma->va, pdma->len,
+ card->host->bit64_enable, data_26bit_len);
+
+ if (node->phy_node_buffer.end.va == NULL) {
+ DbgErr("%s prepare dma buffer failed\n", __func__);
+ ret = FALSE;
+ goto exit;
+ }
+
+ if (flg & CMD_FLG_INF_CON)
+ update_adma2_inf_tb(node->phy_node_buffer.end.va,
+ &(pdx->dma_api.adma2_inf_link_addr),
+ &node->phy_node_buffer.head.pa,
+ card->host->bit64_enable);
+ else
+ update_adma2_inf_tb(node->phy_node_buffer.end.va,
+ &(pdx->dma_api.adma2_inf_link_addr), NULL,
+ card->host->bit64_enable);
+
+ /* Step4 Send Command12 */
+ sd_cmd.data = &sd_data;
+ sd_cmd.data->data_mng.driver_buff = NULL;
+ sd_cmd.data->data_mng.offset = sd_cmd.data->data_mng.srb_cnt = 0;
+ sd_cmd.data->dir = dir;
+ sd_cmd.data->data_mng.total_bytess = sec_cnt * SD_BLOCK_LEN;
+ sd_cmd.data->data_mng.sys_addr = node->general_desc_tbl.pa;
+
+ cmd_generate_reg(card, &sd_cmd);
+ /* 4.issue cmd */
+ ret = cmd_execute_sync(card, &sd_cmd, NULL);
+
+exit:
+ if (ret == FALSE && cmd_err != NULL)
+ card_cmd_copy(cmd_err, &sd_cmd);
+
+end:
+ DbgInfo(MODULE_ALL_CARD, FEATURE_RW_TRACE, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, ret);
+ return ret;
+
+}
+
+/*
+ * Function Name: card_recovery_flow
+ *
+ * Abstract: This Function is used to do card rw error recovery flow
+ *
+ * Input:
+ *
+ * sd_card_t *card: The Command will send to which Card
+ * sd_command_t *sd_cmd: if the init occurred at init stage this parameter will be null
+ *
+ * Output: None
+ *
+ * Return value:
+ * REQ_RESULT_NO_CARD: card not exist or not card
+ * REQ_RESULT_ACCESS_ERR: card rw recovery failed
+ * REQ_RESULT_OK: no error
+ *
+ * Notes: This function is called in thread context to do RW Error Recovery
+ *
+ * Caller: tag_queue_rw_data_issue_stage
+ *
+ */
+
+e_req_result card_recovery_flow(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ e_req_result result = REQ_RESULT_ACCESS_ERR;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Enter %s\n", __func__);
+
+ os_mdelay(50);
+ if (card->card_present == FALSE || card->card_chg
+ || host_check_lost(card->host) || card->sw_ctrl_swicth_to_express) {
+ DbgErr("Error Recover for no card\n");
+ result = REQ_RESULT_NO_CARD;
+ goto exit;
+ }
+
+ card->continue_rw_err_cnt++;
+
+ /* If Adma Error */
+ if (cmd_is_adma_error(sd_cmd)) {
+ DbgInfo(MODULE_ALL_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Adma error\n", __func__);
+ card->adma_err_cnt++;
+ if (card->adma_err_cnt >= 3) {
+ DbgInfo(MODULE_ALL_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM, "continue adma err>=3\n",
+ __func__);
+ card_degrade_policy(card, sd_cmd);
+ card->continue_rw_err_cnt = 0;
+ card->adma_err_cnt = 0;
+ /* card->thread_init_card_flag = 0; */
+ card_power_off(card, TRUE);
+ if (card_init(card, 1, FALSE) == FALSE) {
+ if (card->card_type == CARD_ERROR) {
+ DbgErr("Adma error recover fatal\n");
+ result = REQ_RESULT_NO_CARD;
+ } else {
+ DbgErr("Adma error recover failed\n");
+ result = REQ_RESULT_ACCESS_ERR;
+ }
+ } else
+ result = REQ_RESULT_OK;
+ goto exit;
+ }
+ }
+
+ if (card_rw_recovery(card, sd_cmd) == FALSE) {
+ card->continue_rw_err_cnt++;
+ if (card->continue_rw_err_cnt >= 3) {
+ DbgInfo(MODULE_ALL_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM, "continue rw err>=3\n",
+ __func__);
+ card_degrade_policy(card, sd_cmd);
+ card->continue_rw_err_cnt = 0;
+ card->adma_err_cnt = 0;
+ }
+
+ card_power_off(card, TRUE);
+ if (card_init(card, 1, FALSE) == FALSE) {
+ if (card->card_type == CARD_ERROR) {
+ DbgErr(" error recover fatal\n");
+ result = REQ_RESULT_NO_CARD;
+ } else {
+ DbgErr("error recover failed\n");
+ result = REQ_RESULT_ACCESS_ERR;
+ }
+ } else
+ result = REQ_RESULT_OK;
+ } else
+ result = REQ_RESULT_OK;
+exit:
+ DbgInfo(MODULE_ALL_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "EXIT %s\n",
+ __func__);
+ return result;
+}
+
+bool card_set_blkcnt(sd_card_t *card, sd_command_t *sd_cmd, u32 blkcnt)
+{
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_LEGACY_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Enter %s blkcnt=%d\n", __func__, blkcnt);
+ ret =
+ card_send_sdcmd(card, sd_cmd, SD_CMD23, blkcnt,
+ CMD_FLG_R1 | CMD_FLG_RESCHK, DATA_DIR_NONE, NULL,
+ 0);
+ if (ret == FALSE)
+ DbgErr("issue cmd23 failed\n");
+
+ DbgInfo(MODULE_LEGACY_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, ret);
+
+ return ret;
+}
+
+/*
+ * Function Name: card_is_poweroff
+ *
+ * Abstract: This Function is used to get card power state
+ *
+ * Input:
+ *
+ * sd_card_t *card : The target Card
+ *
+ * Output: None
+ *
+ * Return value:
+ * TRUE: card poweroff
+ * FALSE: card doesn't poweroff
+ *
+ * Notes:
+ *
+ * Caller: tag_queue_rw_data_issue_stage
+ *
+ */
+
+bool card_is_poweroff(sd_card_t *card)
+{
+ if (card->state == CARD_STATE_POWEROFF)
+ return TRUE;
+ else
+ return FALSE;
+}
+
+/*
+ * Function Name: card_read_csd
+ *
+ * Abstract: De-select the card and send CMD9, and then select the card.
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ *
+ * byte *data: used for storing CSD data
+ *
+ * Return value:
+ * TRUE: read CSD successfully
+ * FALSE: occur error when read CSD
+ *
+ * Notes:
+ *
+ * Caller: thread_gen_io
+ *
+ */
+
+bool card_read_csd(sd_card_t *card, byte *data)
+{
+
+ sd_command_t sd_cmd;
+
+ os_memset(&sd_cmd, 0, sizeof(sd_command_t));
+
+ return sd_read_csd(card, &sd_cmd, data);
+
+}
+
+/*
+ * Function Name: card_program_csd
+ *
+ * Abstract: Program CSD by CMD27
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ *
+ * byte *data: used for storing CSD data
+ *
+ * Return value: return TRUE if program CSD successfully, else return FALSE
+ *
+ * Notes:
+ *
+ * Caller: thread_gen_io
+ *
+ */
+
+bool card_program_csd(sd_card_t *card, byte *data)
+{
+
+ sd_command_t sd_cmd;
+
+ os_memset(&sd_cmd, 0, sizeof(sd_command_t));
+ return sd_program_csd(card, &sd_cmd, data);
+
+}
diff --git a/drivers/scsi/bht/card/mmc.c b/drivers/scsi/bht/card/mmc.c
new file mode 100644
index 000000000000..449307972400
--- /dev/null
+++ b/drivers/scsi/bht/card/mmc.c
@@ -0,0 +1,1666 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2014 BHT Inc.
+ *
+ * File Name: mmc.c
+ *
+ * Abstract: mmc/emmc card initialization
+ *
+ * Version: 1.00
+ *
+ * Author: Amma.Li
+ *
+ * Environment: OS Independent
+ *
+ * History:
+ *
+ * 9/23/2014 Creation Amma.Li
+ */
+#include "../include/basic.h"
+#include "../include/cardapi.h"
+#include "../include/hostapi.h"
+#include "../host/hostven.h"
+#include "../host/hostreg.h"
+#include "cardcommon.h"
+#include "../include/cmdhandler.h"
+#include "../include/debug.h"
+#include "../include/util.h"
+#define MMC_SPEC_VERS 0x04U
+/* ------------------emmc setting-------------------- */
+/* ext_csd[196]: card type */
+#define MMC_CARD_TYPE_H200 0x30U
+#define MMC_CARD_TYPE_H400 0xC0U
+#define MMC_CARD_TYPE_HS 0x0FU
+#define MMC_CARD_DDR_SUPP 0x0CU
+#define MMC_CARD_TYPE_HS_DDR_12 0x8
+#define MMC_CARD_TYPE_HS_DDR_18 0x4
+#define MMC_CARD_TYPE_HS_52M 0x2
+#define MMC_CARD_TYPE_HS_26M 0x1
+/* ext_csd[183]: Bus Width */
+#define MMC_EXTCSD_BUS_WIDTH (0x00B70000)
+#define MMC_BUSW_1BIT 0
+#define MMC_BUSW_SDR_4BIT (1 << 8)
+#define MMC_BUSW_SDR_8BIT (2 << 8)
+#define MMC_BUSW_DDR_4BIT (5 << 8)
+#define MMC_BUSW_DDR_8BIT (6 << 8)
+/* ext_csd[185]: HS_TIMING */
+#define MMC_EXTCSD_HS_TIMING (0x00B90000)
+#define MMC_TIMING_BACKWARDS 0
+#define MMC_TIMING_HIGH_SPEED (1 << 8)
+#define MMC_TIMING_HS200 (2 << 8)
+#define MMC_TIMING_HS400 (3 << 8)
+#define MMC_DRIVER_TYPE 0
+/* emmc CMD6 setting */
+#define MMC_EXTCSD_WRITE (3 << 24)
+#define MMC_EXTCSD_SET (1 << 24)
+#define MMC_EXTCSD_CLEAN (2 < 24)
+/* emmc/mmc RCA */
+#define MMC_RCA (1 << 16)
+/* -------------emmc setting end------------------ */
+static void emmc_get_ext_csd_info(sd_card_t *card);
+static bool emmc_switch_buswidth(sd_card_t *card, sd_command_t *sd_cmd);
+static void emmc_set_freq(sd_card_t *card, u32 clock_freq, bool bddr50);
+
+/* -------------emmc / mmc card CMD setting------------- */
+
+/*
+ * Function Name: emmc_card_init_ready
+ *
+ * Abstract:
+ * 1. Issue CMD1 to Get OCR
+ * 2. Set the card ocr variable
+ * 3. Wait for card ready
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if card ready, else return FALSE
+ *
+ * Notes:
+ *
+ * Caller: emmc_init
+ *
+ */
+
+static bool emmc_card_init_ready(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ byte cmd_index = SD_CMD1;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R3;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+ bool ret = FALSE;
+ loop_wait_t wait;
+ u32 delay_us = 20;
+
+ sd_host_t *host = card->host;
+ card_info_t *card_info = &(card->info);
+ cfg_emmc_mode_t *emmc_mode = &(host->cfg->card_item.emmc_mode);
+
+ if (emmc_mode->enable_18_vcc)
+ argument |= EMMC_OCR_LOW;
+ else
+ argument |= EMMC_OCR_HI;
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s arg 0x%08x\n", __func__, argument);
+
+ /* Wait for card ready */
+ util_init_waitloop(card->host->pdx,
+ host->cfg->timeout_item.test_card_init_timeout.value,
+ delay_us, &wait);
+
+ do {
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag,
+ dir, data, datalen);
+ if (ret == FALSE) {
+ DbgErr("Issue CMD1 to get eMMC card OCR Fail.\n");
+ break;
+ }
+
+ /* Check Busy status. 0b: On initialization; 1b: Initialization Complete. */
+ if ((sd_cmd->response[0] & 0x80000000) == 0) {
+ os_udelay(delay_us);
+ continue;
+ } else {
+ break;
+ }
+ } while (!util_is_timeout(&wait));
+
+ /* If card ready, set related software flags */
+ if (ret) {
+ /* check card ready or not */
+ if (sd_cmd->response[0] & 0x80000000) {
+ if (sd_cmd->response[0] & 0x40000000)
+ /* the capability > 2GB */
+ card_info->card_ccs = 1;
+ else
+ /* the capability < 2GB */
+ card_info->card_ccs = 0;
+ } else
+ ret = FALSE;
+ }
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ * Function Name: emmc_set_rca
+ *
+ * Abstract: Set a new relative address RCA for MMC/eMMC card(CMD3)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if issue CMD3 successfully, else return FALSE
+ *
+ * Notes:
+ *
+ * Caller: emmc_init
+ *
+ */
+
+bool emmc_set_rca(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool ret = FALSE;
+ byte cmd_index = SD_CMD3;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+ card_info_t *card_info = &(card->info);
+
+ argument = MMC_RCA;
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s arg 0x%08x\n", __func__, argument);
+
+ /* Issue CMD3 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (ret) {
+ /* Update the card RCA */
+ card_info->rca = (argument & 0xffff0000) >> 16;
+ }
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ * Function Name: emmc_get_ext_csd
+ *
+ * Abstract: Read the MMC/EMMC card Ext_Csd Data
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if issue eMMC CMD8 successfully, else return FALSE
+ *
+ * Notes:
+ *
+ * Caller: emmc_init
+ *
+ */
+
+static bool emmc_get_ext_csd(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ byte cmd_index = SD_CMD8;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1;
+ e_data_dir dir = DATA_DIR_IN;
+ byte data[512];
+ u32 datalen = 512;
+
+ bool ret = FALSE;
+ mmc_card_info_t *mmc_info = &(card->mmc);
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Issue eMMC CMD8 to get Ext_Csd */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (ret) {
+ /* Get the Ext_Csd */
+ os_memcpy(&(mmc_info->raw_extcsd[0]), data, 512);
+ emmc_get_ext_csd_info(card);
+ }
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ * Function Name: emmc_send_cmd6
+ *
+ * Abstract:
+ * 1. Issue CMD6 to switch mode to modify the Ext_Csd register
+ * 2. Set the emmc card hs_timing & bus width
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ * argument: [31:26] set to 0
+ * [25:24]: Access 1: set 2: clean 3: write
+ * [23:16]: Index the ext_csd index
+ * [15:8]: value
+ * [7:3]: set to 0
+ * [2:0]: cmd set
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if issue CMD6 successfully, else return FALSE
+ *
+ * Notes:
+ *
+ * Caller: emmc_switch_buswidth
+ *
+ */
+
+static bool emmc_send_cmd6(sd_card_t *card,
+ sd_command_t *sd_cmd, u32 argument)
+{
+ bool result = FALSE;
+ byte cmd_index = SD_CMD6;
+ u32 cmdflag = CMD_FLG_R1B;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s arg = 0x%08x\n", __func__, argument);
+ result =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+
+ return result;
+}
+
+/*
+ *
+ * Function Name: emmc_bustest_r
+ *
+ * Abstract:
+ * 1. MMC/eMMC card bus width test read (CMD14)
+ * 2. A host reads the reversed bus testing data pattern from a Device.
+ * 3. Used after CMD19 (bus width test write CMD),
+ * need to check the cmd and data transfer error
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ * u8 *buf : read data pattern buffer
+ * u32 data_len : read data length
+ *
+ * Output: None
+ *
+ * Return value: Return TRUE if issue CMD14 successfully, else return FALSE
+ *
+ * Notes:
+ *
+ * Caller: emmc_bus_width_test
+ */
+static bool emmc_bustest_r(sd_card_t *card,
+ sd_command_t *sd_cmd, u8 *buf, u32 data_len)
+{
+ bool result = FALSE;
+ byte cmd_index = SD_CMD14;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_IN;
+ byte *data = buf;
+ u32 datalen = data_len;
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ result =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: emmc_bustest_w
+ *
+ * Abstract:
+ *
+ * 1. MMC/eMMC card bus width test write (CMD19)
+ * 2. A host send the reversed bus testing data pattern from a Device.
+ * 3. Do not need to check the cmd and data transfer error
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ * u8 *buf : write data pattern buffer
+ * u32 data_len : write data length
+ *
+ * Output:
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+static bool emmc_bustest_w(sd_card_t *card,
+ sd_command_t *sd_cmd, u8 *buf, u32 data_len)
+{
+ bool result = FALSE;
+ byte cmd_index = SD_CMD19;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK | CMD_FLG_NO_TRANS;
+ e_data_dir dir = DATA_DIR_OUT;
+ byte *data = buf;
+ u32 datalen = data_len;
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ result =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+
+ return result;
+}
+
+/*
+ *
+ * Function Name: emmc_tuning_hw
+ *
+ * Abstract:
+ *
+ * 1. Hardware Tuning Procedure (CMD21)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_tuning
+ */
+
+static bool emmc_tuning_hw(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool result = FALSE;
+ byte cmd_index = SD_CMD21;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_TUNE;
+ e_data_dir dir = DATA_DIR_IN;
+ byte data[64];
+ sd_host_t *host = card->host;
+ u32 datalen = 0x40;
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* set hardware tuning */
+ host_set_tuning_mode(host, TRUE);
+
+ if ((host->chip_type == CHIP_SDS0) ||
+ (host->chip_type == CHIP_SDS1) || (host->chip_type == CHIP_FUJIN2)
+ ) {
+ /* add 200us delay before CMD19 to fix FJ2 ASIC issue 14# */
+ os_udelay(200);
+ }
+
+ /* send emmc tuning CMD21 */
+ result =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (result == FALSE) {
+ DbgErr("eMMC card send hardware tuning CMD failed!!\n");
+ goto exit;
+ }
+
+ /* check tuning success or not */
+ result = host_chk_tuning_comp(host, TRUE);
+ if (!result)
+ DbgErr("Check eMMC tuning failed!\n");
+
+exit:
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: sd_tuning_sw
+ *
+ * Abstract:
+ *
+ * 1. Software Tuning Procedure (CMD21)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_tuning
+ */
+static bool emmc_tuning_sw(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool result = FALSE;
+ byte cmd_index = SD_CMD21;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_TUNE;
+ e_data_dir dir = DATA_DIR_IN;
+ byte data[64];
+ u16 i = 0;
+ sd_host_t *host = card->host;
+ u32 datalen = 0x40;
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ for (i = 0; i < 100; i++) {
+ /* set software tuning */
+ host_set_tuning_mode(host, FALSE);
+
+ if ((host->chip_type == CHIP_SDS0) ||
+ (host->chip_type == CHIP_SDS1) ||
+ (host->chip_type == CHIP_FUJIN2)
+ ) {
+ /* add 200us delay before CMD19 to fix FJ2 ASIC issue 14# */
+ os_udelay(200);
+ }
+
+ /* send emmc tuning CMD21 */
+ result =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag,
+ dir, data, datalen);
+ if (result == FALSE) {
+ DbgErr("eMMC card hardware tuning failed!!\n");
+ goto exit;
+ }
+
+ /* check tuning success or not */
+ result = host_chk_tuning_comp(host, FALSE);
+ if (result)
+ break;
+ }
+
+exit:
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: emmc_tuning
+ *
+ * Abstract:
+ *
+ * 1. Send Hw tuning or Sw tuning by the registry setting
+ * 2. tuning mode: 1 = CFG_TUNING_MODE_HW 0 = CFG_TUNING_MODE_SW
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+bool emmc_tuning(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool result = FALSE;
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (card->mmc.cur_hs_type != EMMC_MODE_HS200
+ && card->mmc.cur_hs_type != EMMC_MODE_HS400) {
+ result = TRUE;
+ goto exit;
+ }
+
+ if (TUNING_MODE)
+ result = emmc_tuning_hw(card, sd_cmd);
+ else
+ result = emmc_tuning_sw(card, sd_cmd);
+
+exit:
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: emmc_bus_width_test
+ *
+ * Abstract:
+ * 1. MMC/eMMC card bus width test by CMD14 (read) and CMD19(write)
+ * 2. The data pattern decided by the bus width (8-bit\4-bit)
+ * 3. Do not need to check the CMD19 any cmd and data transfer error
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ * u32 data_len : data pattern length
+ *
+ * Output:
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+static bool emmc_bus_width_test(sd_card_t *card,
+ sd_command_t *sd_cmd, u32 data_len)
+{
+ bool result = FALSE;
+ u8 buf[8] = { 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa };
+ u8 patten[8] = { 0 };
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s datlen %d\n", __func__, data_len);
+
+ if (card->card_present == FALSE)
+ goto exit;
+
+ if (data_len == 4) {
+ os_memset(buf, 0, 8);
+ os_memset(buf, 0x5a, 4);
+
+ }
+
+ /* send CMD19 (eMMC bus write) */
+ result = emmc_bustest_w(card, sd_cmd, buf, data_len);
+
+ /* delay NCR clock */
+ os_udelay(20);
+
+ /* send CMD14 (eMMC bus read) */
+ result = emmc_bustest_r(card, sd_cmd, patten, data_len);
+ if (!result) {
+ DbgErr("eMMC card CMD14 Receive bus width data Failed.\n");
+ } else {
+ result = FALSE;
+
+ /* check patten */
+ if (data_len == 8) {
+ if ((patten[0] == 0xaa) || (patten[1] == 0x55)) {
+ result = TRUE;
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT,
+ NOT_TO_RAM,
+ "8-bit bus width test OK!!\n");
+ }
+ } else if (data_len == 4) {
+ if (patten[0] == 0xa5) {
+ result = TRUE;
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT,
+ NOT_TO_RAM,
+ "4-bit bus width test OK!!\n");
+ }
+ }
+ }
+
+exit:
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: emmc_get_ext_csd_info
+ *
+ * Abstract:
+ *
+ * 1. Get the Ext_Csd structure
+ * (card_type, power class for 52M 26M 1.8V 3.3V voltage)
+ * from the Ext_Csd raw
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ * None
+ *
+ * Return value:
+ *
+ * None
+ *
+ * Notes:
+ *
+ * Caller: emmc_get_ext_csd
+ */
+static void emmc_get_ext_csd_info(sd_card_t *card)
+{
+ mmc_card_info_t *mmc_info = &(card->mmc);
+ extcsd_t *ext_csd = &(mmc_info->ext_csd);
+ u8 *raw_ext_csd = &(mmc_info->raw_extcsd[0]);
+
+ ext_csd->card_type = *(raw_ext_csd + 196);
+ ext_csd->driver_strength_type = *(raw_ext_csd + 197);
+ ext_csd->pwr_cl_52_195 = *(raw_ext_csd + 200);
+ ext_csd->pwr_cl_26_195 = *(raw_ext_csd + 201);
+ ext_csd->pwr_cl_52_360 = *(raw_ext_csd + 202);
+ ext_csd->pwr_cl_26_360 = *(raw_ext_csd + 203);
+ ext_csd->pwr_cl_ddr_52_195 = *(raw_ext_csd + 238);
+ ext_csd->pwr_cl_ddr_52_360 = *(raw_ext_csd + 239);
+ ext_csd->sec_cnt =
+ (*(raw_ext_csd + 215) << 24) + (*(raw_ext_csd + 214) << 16) +
+ (*(raw_ext_csd + 213) << 8) + *(raw_ext_csd + 212);
+}
+
+/*
+ *
+ * Function Name: emmc_switch_hs400
+ *
+ * Abstract:
+ * 1. eMMC card switch HS400 mode
+ *
+ * Input:
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ * None
+ *
+ * Return value:
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ * Caller: emmc_init_stage2
+ */
+static bool emmc_switch_hs400(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool result = FALSE;
+ u32 argument = 0;
+ sd_host_t *host = card->host;
+
+ mmc_card_info_t *mmc_info = &(card->mmc);
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+#if (0)
+ /* 1. Check card support hs400 */
+ if ((mmc_info->ext_csd.card_type & MMC_CARD_TYPE_H400) == 0) {
+ DbgErr("eMMC card don't support HS400 mode!!\n");
+ goto exit;
+ }
+
+ /* 2. check card support 8-bit bus width */
+ if ((mmc_info->cur_buswidth != EMMC_8Bit_BUSWIDTH) ||
+ (host->bus_8bit_supp == FALSE)
+ ) {
+ DbgErr("The card or host don't support 8bit bus width!!\n");
+ goto exit;
+ }
+#endif
+
+ /* 3. clear UHSI mode select */
+ host_set_uhs_mode(host, 0);
+
+ /* 4.set card mode to DDR50 mode (eMMC: CMD6) */
+ argument =
+ (MMC_EXTCSD_WRITE | MMC_EXTCSD_HS_TIMING | MMC_TIMING_HIGH_SPEED |
+ (mmc_info->drv_strength << 12));
+ result = emmc_send_cmd6(card, sd_cmd, argument);
+ if (!result) {
+ DbgErr("Switch DDR50 mode Failed.\n");
+ goto exit;
+ }
+
+ /* 5. change clock to 50M Hz for DDR50 mode */
+ emmc_set_freq(card, SD_CLK_50M, TRUE);
+
+ /* 6.change to 8-bit DDR mode (eMMC: CMD6) */
+ argument =
+ (MMC_EXTCSD_WRITE | MMC_EXTCSD_BUS_WIDTH | MMC_BUSW_DDR_8BIT);
+ result = emmc_send_cmd6(card, sd_cmd, argument);
+ if (!result) {
+ DbgErr("Change to 8-bit DDR mode Failed.\n");
+ goto exit;
+ }
+
+ /* 7.switch to hs400 */
+ argument =
+ (MMC_EXTCSD_WRITE | MMC_EXTCSD_HS_TIMING | MMC_TIMING_HS400 |
+ (mmc_info->drv_strength << 12));
+ result = emmc_send_cmd6(card, sd_cmd, argument);
+ if (!result) {
+ DbgErr("Switch hs400 mode Failed.\n");
+ goto exit;
+ }
+
+ /* 8.if switch hs400 ok, set PCI Register */
+ host_emmc_hs400_set(host, TRUE);
+
+ /* 9.change SDCLK frequency to 200M Hz */
+ emmc_set_freq(card, SD_CLK_BASE, FALSE);
+
+exit:
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: emmc_switch_hs200
+ *
+ * Abstract:
+ * 1. eMMC card switch HS200 mode
+ *
+ * Input:
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ * None
+ *
+ * Return value:
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ * Caller: emmc_init_stage2
+ */
+static bool emmc_switch_hs200(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool result = FALSE;
+ u32 argument = 0;
+ u32 card_status = 0;
+ sd_host_t *host = card->host;
+ mmc_card_info_t *mmc_info = &(card->mmc);
+ cfg_emmc_mode_t *emmc_mode = &(host->cfg->card_item.emmc_mode);
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* 1. switch signal Data Rate mode bus width (4-bit or 8-bit: eMMC CMD6) */
+ mmc_info->cur_hs_type = EMMC_MODE_HS200;
+ result = emmc_switch_buswidth(card, sd_cmd);
+ if (!result) {
+ DbgErr("Set signal Data Rate 8/4-bit Bus Width Failed.\n");
+ goto exit;
+ }
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Card support driver type %x\n",
+ mmc_info->ext_csd.driver_strength_type);
+ if ((2 << (emmc_mode->drv_strength)) &
+ (mmc_info->ext_csd.driver_strength_type)
+ )
+ mmc_info->drv_strength = (byte) emmc_mode->drv_strength;
+ else
+ mmc_info->drv_strength = 0;
+ /* 2.switch card support driver type & hs200 mode (eMMC: CMD6) */
+ argument =
+ (MMC_EXTCSD_WRITE | MMC_EXTCSD_HS_TIMING | MMC_TIMING_HS200 |
+ (mmc_info->drv_strength << 12));
+ result = emmc_send_cmd6(card, sd_cmd, argument);
+ if (!result) {
+ DbgErr("Switch HS200 mode Failed.\n");
+ goto exit;
+ }
+
+ /* 3.check card status (Issue CMD13) */
+ result = card_get_card_status(card, sd_cmd, &card_status);
+ if ((result == FALSE) || (card_status & 0x80)
+ ) {
+ DbgErr("Card Status failed.\n");
+ goto exit;
+ }
+
+ /* 4.change clock to 200M Hz */
+ emmc_set_freq(card, SD_CLK_BASE, FALSE);
+
+ /* 5.switch mode (hs200 == SDR104) */
+ host_set_uhs_mode(host, SDHCI_CTRL_UHS_HS200);
+
+ if (((host->chip_type < CHIP_SEAEAGLE2) || (host->chip_type == CHIP_GG8)
+ || (host->chip_type == CHIP_ALBATROSS))
+ && (mmc_info->cur_buswidth == EMMC_8Bit_BUSWIDTH)) {
+ host_set_buswidth(host, BUS_WIDTH4);
+ }
+
+ result = emmc_tuning(card, sd_cmd);
+ if (!result)
+ goto exit;
+
+ if (mmc_info->cur_buswidth == EMMC_8Bit_BUSWIDTH)
+ host_set_buswidth(host, BUS_WIDTH8);
+
+ /* 7.if tuning ok, set PCI & Host Register */
+ host_emmc_hs400_set(host, FALSE);
+
+exit:
+ if (result == FALSE)
+ mmc_info->cur_hs_type = 0;
+ else
+ emmc_mode->enable_ddr_mode = 0;
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: emmc_switch_hs
+ *
+ * Abstract:
+ * 1. eMMC card switch High Speed mode
+ *
+ * Input:
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ * None
+ *
+ * Return value:
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ * Caller: emmc_init_stage2
+ */
+static bool emmc_switch_hs(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool result = FALSE;
+ u32 argument = 0;
+ u32 clk = 0;
+ bool bddr50 = FALSE;
+ sd_host_t *host = card->host;
+ u32 b_dis_hs = host->cfg->card_item.emmc_mode.dis_hs;
+ u8 device_type = card->mmc.ext_csd.card_type;
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /*
+ * if registry set disable hs mode or host don't support high speed,
+ * check card type, and set the clk
+ */
+ if (b_dis_hs || (host->hs_supp == 0)) {
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "User disable high speed, select 25M timing!!\n");
+ if (device_type & MMC_CARD_TYPE_HS_26M) {
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "select 25M timing!!\n");
+ clk = SD_CLK_25M;
+ }
+ } else {
+ if (device_type &
+ (MMC_CARD_TYPE_HS_52M | MMC_CARD_TYPE_HS_DDR_12 |
+ MMC_CARD_TYPE_HS_DDR_18)) {
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "select 52M timing!!\n");
+ clk = SD_CLK_50M;
+ if ((host->cfg->card_item.emmc_mode.enable_ddr_mode) &&
+ (device_type & MMC_CARD_DDR_SUPP)
+ ) {
+ bddr50 = TRUE;
+ }
+ } else if (device_type & MMC_CARD_TYPE_HS_26M) {
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "select 25M timing!!\n");
+ clk = SD_CLK_25M;
+ }
+ }
+
+ /* dump power size */
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "PMclass- 52M, DDR, 3.3v: 0x%xh 1.8v: 0x%xh\n",
+ card->mmc.ext_csd.pwr_cl_ddr_52_360,
+ card->mmc.ext_csd.pwr_cl_ddr_52_195);
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "PMclass- 26M, SDR, 3.3v: 0x%xh 1.8v: 0x%xh\n",
+ card->mmc.ext_csd.pwr_cl_26_360,
+ card->mmc.ext_csd.pwr_cl_26_195);
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "PMclass- 52M, SDR, 1.8v: 0x%xh 3.3v: 0x%xh\n",
+ card->mmc.ext_csd.pwr_cl_52_195,
+ card->mmc.ext_csd.pwr_cl_52_360);
+
+ /* if host & card all support high speed, then set the hs_timing */
+ if (clk) {
+ argument =
+ (MMC_EXTCSD_WRITE | MMC_EXTCSD_HS_TIMING |
+ MMC_TIMING_HIGH_SPEED);
+ result = emmc_send_cmd6(card, sd_cmd, argument);
+ if (!result) {
+ DbgErr("Switch High Speed mode Failed.\n");
+ goto exit;
+ }
+ }
+
+ /* change clock */
+ if (clk)
+ emmc_set_freq(card, clk, bddr50);
+
+ /* if clock > 50M hz, set 0x28[2]: high speed enable */
+ if (clk == SD_CLK_50M)
+ host_set_highspeed(host, TRUE);
+
+exit:
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: emmc_ddr_mode_set
+ *
+ * Abstract:
+ * 1. set eMMC card DDR50 mode
+ *
+ * Input:
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ * None
+ *
+ * Return value:
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ * Caller: emmc_init_stage2
+ */
+static void emmc_ddr_mode_set(sd_card_t *card)
+{
+ sd_host_t *host = card->host;
+ u32 b_dis_hs = host->cfg->card_item.emmc_mode.dis_hs;
+ u8 device_type = card->mmc.ext_csd.card_type;
+ u32 enable_ddr = host->cfg->card_item.emmc_mode.enable_ddr_mode;
+
+ if ((b_dis_hs == FALSE) &&
+ (enable_ddr) && (device_type & MMC_CARD_DDR_SUPP)
+ ) {
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Set host DDR50 mode!!\n");
+ host_set_uhs_mode(host, SDHCI_CTRL_UHS_DDR50);
+ host_emmc_ddr_set(host, TRUE);
+ } else {
+ host->cfg->card_item.emmc_mode.enable_ddr_mode = 0;
+ host_emmc_ddr_set(host, FALSE);
+ }
+
+}
+
+/*
+ *
+ * Function Name: emmc_switch_buswidth
+ *
+ * Abstract:
+ * 1. set eMMC card bus width
+ *
+ * Input:
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ * None
+ *
+ * Return value:
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ * Caller: emmc_init_stage2
+ */
+static bool emmc_switch_buswidth(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool result = FALSE;
+ u32 argument = 0;
+ u32 data_len = 0;
+ sd_host_t *host = card->host;
+ mmc_card_info_t *mmc_info = &(card->mmc);
+ u32 dis_8_bit = host->cfg->card_item.emmc_mode.dis_8bit_bus_width;
+ u32 dis_4_bit = host->cfg->card_item.emmc_mode.dis_4bit_bus_width;
+ u32 enable_ddr = host->cfg->card_item.emmc_mode.enable_ddr_mode;
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (card->card_present == FALSE)
+ goto exit;
+
+ /* check host & user support 8-bit bus width */
+ if ((dis_8_bit == 0) && (host->bus_8bit_supp)
+ ) {
+ mmc_info->cur_buswidth = EMMC_8Bit_BUSWIDTH;
+ data_len = 8;
+
+ /* host set 8-bit bus width */
+ host_set_buswidth(host, BUS_WIDTH8);
+
+ /* delay 100us */
+ os_udelay(100);
+
+ result = emmc_bus_width_test(card, sd_cmd, data_len);
+ if (result == TRUE) {
+ if (enable_ddr &&
+ (card->mmc.ext_csd.card_type & MMC_CARD_DDR_SUPP) &&
+ (mmc_info->cur_hs_type != EMMC_MODE_HS200)
+ ) {
+ argument =
+ (MMC_EXTCSD_WRITE | MMC_EXTCSD_BUS_WIDTH |
+ MMC_BUSW_DDR_8BIT);
+ } else {
+ argument =
+ (MMC_EXTCSD_WRITE | MMC_EXTCSD_BUS_WIDTH |
+ MMC_BUSW_SDR_8BIT);
+ }
+ result = emmc_send_cmd6(card, sd_cmd, argument);
+ if (!result)
+ DbgErr("Set 8-bit bus width Failed.\n");
+ else
+ goto exit;
+ }
+ DbgErr("Set 8-bit bus width Failed.\n");
+
+ }
+
+ /* check user support 4-bit bus width */
+ if (dis_4_bit == FALSE) {
+ mmc_info->cur_buswidth = EMMC_4Bit_BUSWIDTH;
+ /* host set 4-bit bus width */
+ host_set_buswidth(host, BUS_WIDTH4);
+ data_len = 4;
+
+ /* Test 4-bit patten, set block size to 4 bytes */
+ result = emmc_bus_width_test(card, sd_cmd, data_len);
+ if (!result)
+ goto exit;
+
+ if (enable_ddr &&
+ (card->mmc.ext_csd.card_type & MMC_CARD_DDR_SUPP) &&
+ (mmc_info->cur_hs_type != EMMC_MODE_HS200)
+ ) {
+ argument =
+ (MMC_EXTCSD_WRITE | MMC_EXTCSD_BUS_WIDTH |
+ MMC_BUSW_DDR_4BIT);
+ } else {
+ argument =
+ (MMC_EXTCSD_WRITE | MMC_EXTCSD_BUS_WIDTH |
+ MMC_BUSW_SDR_4BIT);
+ }
+
+ result = emmc_send_cmd6(card, sd_cmd, argument);
+ if (!result)
+ DbgErr("Set 4-bit bus width Failed.\n");
+ else
+ goto exit;
+
+ DbgErr("Set 4-bit bus width Failed.\n");
+
+ }
+
+ /* default 1-bit bus width */
+ mmc_info->cur_buswidth = EMMC_1Bit_BUSWIDTH;
+ host_set_buswidth(host, BUS_WIDTH1);
+
+exit:
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: emmc_set_trans_clk
+ *
+ * Abstract:
+ * 1. set MMC/eMMC card(Not support HS) transfer clock
+ *
+ * Input:
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ * None
+ *
+ * Return value:
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ * Caller: emmc_init_stage2
+ */
+static bool emmc_set_trans_clk(sd_card_t *card)
+{
+ bool result = FALSE;
+ u32 freq_unit = 0;
+ u32 multip_factor = 0;
+ u32 trans_clk;
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ /* get the frequency unit 0: 1KHz 1: 10KHz 2: 100KHz 3: 1000KHZ */
+ switch ((card_info->csd.tran_speed) & 0x7) {
+ case 0:
+ freq_unit = 1;
+ break;
+ case 1:
+ freq_unit = 10;
+ break;
+ case 2:
+ freq_unit = 100;
+ break;
+ case 3:
+ freq_unit = 1000;
+ break;
+ default:
+ return result;
+ }
+
+ switch (((card_info->csd.tran_speed) & 0x78) >> 3) {
+ case 1:
+ multip_factor = 100;
+ break;
+ case 2:
+ multip_factor = 120;
+ break;
+ case 3:
+ multip_factor = 130;
+ break;
+ case 4:
+ multip_factor = 150;
+ break;
+ case 5:
+ multip_factor = 200;
+ break;
+ case 6:
+ multip_factor = 260;
+ break;
+ case 7:
+ multip_factor = 300;
+ break;
+ case 8:
+ multip_factor = 350;
+ break;
+ case 9:
+ multip_factor = 400;
+ break;
+ case 10:
+ multip_factor = 450;
+ break;
+ case 11:
+ multip_factor = 520;
+ break;
+ case 12:
+ multip_factor = 550;
+ break;
+ case 13:
+ multip_factor = 600;
+ break;
+ case 14:
+ multip_factor = 700;
+ break;
+ case 15:
+ multip_factor = 800;
+ break;
+ default:
+ goto exit;
+ }
+
+ trans_clk = freq_unit * multip_factor;
+ if (trans_clk >= SD_CLK_BASE) {
+ /* 200M Hz */
+ trans_clk = SD_CLK_BASE;
+ }
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "MMC support trans clk=%d\n", trans_clk);
+ /* change transfer clock */
+ emmc_set_freq(card, trans_clk, FALSE);
+ result = TRUE;
+
+exit:
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+static u64 get_emmc_sec_count(sd_card_t *card)
+{
+ u64 capability = 0;
+
+ card_info_t *card_info = &(card->info);
+ mmc_card_info_t *mmc_info = &(card->mmc);
+
+ /* <2G capability / SD_BLOCK_LEN */
+ if (card_info->card_ccs == 0)
+ capability = card->sec_count;
+ else {
+ /* > 2G sector count */
+ capability = mmc_info->ext_csd.sec_cnt;
+ }
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "MMC * EMMC sector count = 0x%x!!\n", capability);
+ return capability;
+}
+
+/*
+ *
+ * Function Name: set_emmc_block_len
+ *
+ * Abstract:
+ * 1. set MMC/eMMC card block length
+ *
+ * Input:
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * bool b_hs400: if DDR mode, can't set CMD16 to set block length
+ *
+ * Output:
+ * None
+ *
+ * Return value:
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ * Caller: emmc_init_stage2
+ */
+static bool set_emmc_block_len(sd_card_t *card, bool b_hs400)
+{
+ bool result = FALSE;
+ u32 block_len = 0;
+ card_info_t *card_info = &(card->info);
+ sd_host_t *host = card->host;
+ cfg_emmc_mode_t *cfg_emmc_mode = &(host->cfg->card_item.emmc_mode);
+ sd_command_t sd_cmd;
+
+ os_memset(&sd_cmd, 0, sizeof(sd_command_t));
+
+ block_len = (2 << (card_info->csd.read_bl_len));
+
+ if (block_len > host->max_block_len) {
+ DbgWarn(MODULE_MMC_CARD, NOT_TO_RAM,
+ "Device block length > HW Init max block length!!\n");
+ }
+
+ if ((cfg_emmc_mode->enable_ddr_mode) || b_hs400) {
+ /* todo: if DDR mode, */
+ result = TRUE;
+ } else {
+ result = card_set_block_len(card, &sd_cmd, SD_BLOCK_LEN);
+ }
+
+ return result;
+}
+
+/*
+ *
+ * Function Name: emmc_init_stage2
+ *
+ * Abstract:
+ * 1. emmc card initialize main function.
+ * 2. Fill virtual card structure, like cid, csd, ext_csd etc.
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init_stage2
+ */
+bool emmc_init_stage2(sd_card_t *card)
+{
+ bool result = FALSE;
+ sd_host_t *host = card->host;
+ mmc_card_info_t *mmc_info = &card->mmc;
+ cfg_emmc_mode_t *cfg_emmc_mode = &(host->cfg->card_item.emmc_mode);
+ sd_command_t sd_cmd;
+
+ os_memset(&sd_cmd, 0, sizeof(sd_command_t));
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* set card work clock to 25M */
+ if (mmc_info->ext_csd.card_type) {
+ emmc_set_freq(card, SD_CLK_25M, FALSE);
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Set eMMC Card Host Clock to 25MHz.\n");
+ }
+
+ /* check emmc card HS200 mode */
+ if ((mmc_info->ext_csd.card_type & MMC_CARD_TYPE_H200) &&
+ (cfg_emmc_mode->enable_force_hs != 1)
+ ) {
+ result = emmc_switch_hs200(card, &sd_cmd);
+ if (result == FALSE) {
+ DbgErr("Switch hs200 mode failed!!\n");
+ goto exit;
+ }
+
+ if ((cfg_emmc_mode->enable_force_hs200) ||
+ (mmc_info->cur_buswidth != EMMC_8Bit_BUSWIDTH) ||
+ (host->bus_8bit_supp == FALSE)
+ )
+ goto exit;
+
+ /* check emmc card HS400 mode */
+ if ((host->chip_type == CHIP_SEAEAGLE2
+ || cfg_emmc_mode->enable_force_hs400
+ || host->chip_type == CHIP_GG8
+ || host->chip_type == CHIP_ALBATROSS)
+ && (mmc_info->ext_csd.card_type & MMC_CARD_TYPE_H400)
+ ) {
+ /* choose the eMMC hs400 mode */
+ result = emmc_switch_hs400(card, &sd_cmd);
+ if (result == FALSE)
+ DbgErr("Switch hs400 mode failed!!\n");
+ else
+ mmc_info->cur_hs_type = EMMC_MODE_HS400;
+ }
+
+ goto exit;
+ }
+
+ /* check emmc card HS mode */
+ if ((mmc_info->ext_csd.card_type) & MMC_CARD_TYPE_HS) {
+ result = emmc_switch_hs(card, &sd_cmd);
+ if (result == FALSE)
+ DbgErr("Switch hs mode failed!!\n");
+
+ } else {
+ /* set transfer clock */
+ result = emmc_set_trans_clk(card);
+ if (!result) {
+ DbgErr("Set Basic transfer clock failed.\n");
+ goto exit;
+ }
+ }
+
+ /* set MMC/eMMC card bus width & DDR mode */
+ if (emmc_switch_buswidth(card, &sd_cmd) == TRUE) {
+ /* DDR mode not support 1-bit */
+ emmc_ddr_mode_set(card);
+ }
+
+exit:
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: emmc_init
+ *
+ * Abstract:
+ * 1. emmc card initialize main function.
+ * 2. Fill virtual card structure, like cid, csd, ext_csd etc.
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+bool emmc_init(sd_card_t *card, bool bemmc)
+{
+ bool result = FALSE;
+ sd_host_t *host = card->host;
+ card_info_t *card_info = &(card->info);
+ sd_command_t sd_cmd;
+ cfg_emmc_mode_t *cfg_emmc_mode = &(host->cfg->card_item.emmc_mode);
+ mmc_card_info_t *mmc_info = &(card->mmc);
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s bemmc = %d\n", __func__, bemmc);
+ os_memset(&sd_cmd, 0, sizeof(sd_command_t));
+ os_memset(mmc_info, 0, sizeof(mmc_card_info_t));
+
+ /* 1. emmc host init */
+ result = host_emmc_init(host, cfg_emmc_mode);
+ if (result == FALSE) {
+ DbgErr("Emmc Host Init Failed.\n");
+ goto exit;
+ }
+
+ /* 2. Issue reset command (CMD0) */
+ result = card_reset_card(card, &sd_cmd);
+ result = card_reset_card(card, &sd_cmd);
+ if (!result) {
+ /* Go Idle State command failed. exit directly. */
+ DbgErr("Reset Card (CMD0) Failed.\n");
+ goto exit;
+ }
+
+ /* 2. Wait for card ready (CMD01) */
+ result = emmc_card_init_ready(card, &sd_cmd);
+ if (!result) {
+ DbgErr("Wait for card ready CMD1 Failed.\n");
+ goto exit;
+ }
+
+ if (bemmc)
+ card->card_type = CARD_EMMC;
+ else
+ card->card_type = CARD_MMC;
+
+ /* Get card CID(CMD2) */
+ result = card_all_send_cid(card, &sd_cmd);
+ if (!result) {
+ DbgErr("Get card CID(CMD2) failed.\n");
+ goto exit;
+ }
+
+ /* 4. Set card relative address (CMD3) */
+ result = emmc_set_rca(card, &sd_cmd);
+ if (!result) {
+ DbgErr
+ ("MMC/eMMC card set card relative address (CMD3) failed.\n");
+ goto exit;
+ }
+
+ /* 5. Get CSD (CMD9) */
+ result = card_get_csd(card, &sd_cmd);
+ if (!result) {
+ DbgErr("Get CSD (CMD9) failed.\n");
+ goto exit;
+ }
+
+ /* 6. Select the card (CMD7) */
+ result = card_select_card(card, &sd_cmd);
+ if (!result) {
+ DbgErr("Select card (CMD7) failed.\n");
+ goto exit;
+ }
+
+ /* 7. Check card lock */
+ if (card->locked == TRUE) {
+ DbgErr("Card is locked!!\n");
+ goto exit;
+ }
+
+ /* 8. Check card SPEC version */
+ if (card_info->csd.mmc_spec_vers < MMC_SPEC_VERS) {
+ DbgWarn(MODULE_MMC_CARD, NOT_TO_RAM,
+ "Spec version < 4: it's old MMC Device!!\n");
+ /* set transfer clock */
+ result = emmc_set_trans_clk(card);
+ if (!result) {
+ DbgErr("Set Basic transfer clock failed.\n");
+ goto exit;
+ }
+ goto exit;
+ }
+
+ /* 9. Get Ext_Csd */
+ result = emmc_get_ext_csd(card, &sd_cmd);
+ if (!result) {
+ DbgErr("Get mmc Ext_Csd failed.\n");
+ goto exit;
+ }
+
+ /* 10. Switch Card mode */
+ result = card_init_stage2(card);
+
+exit:
+ if (result) {
+ /* max LBA */
+ card->sec_count = get_emmc_sec_count(card);
+ result =
+ set_emmc_block_len(card,
+ (mmc_info->cur_hs_type ==
+ EMMC_MODE_HS400) ? TRUE : FALSE);
+ if (!result)
+ DbgErr("Set block length failed.\n");
+ }
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ * Function Name: mmc_degrade_policy
+ * Abstract: This Function is used set sd degrade flag
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ *
+ * Return value:
+ *
+ */
+void mmc_degrade_policy(sd_card_t *card)
+{
+
+ /* check if at hs200 or hs400 then can degrade freq */
+ /* else set degrade_all flag */
+
+ cfg_emmc_mode_t *cfg_emmc_mode =
+ &(card->host->cfg->card_item.emmc_mode);
+
+ if (cfg_emmc_mode->enable_force_hs400
+ || cfg_emmc_mode->enable_force_hs200
+ || (card->mmc.ext_csd.card_type & MMC_CARD_TYPE_H400)
+ || (card->mmc.ext_csd.card_type & MMC_CARD_TYPE_H200)) {
+ if (card->degrade_freq_level < CARD_DEGRADE_FREQ_TIMES)
+ card->degrade_freq_level++;
+ else
+ card->degrade_final = 1;
+ } else
+ card->degrade_final = 1;
+
+ DbgErr("EMMC degrade final=%d freq_level=%d\n", card->degrade_final,
+ card->degrade_freq_level);
+
+}
+
+static void emmc_set_freq(sd_card_t *card, u32 clock_freq, bool bddr50)
+{
+ sd_host_t *host = card->host;
+ u32 value = 0;
+ u16 index = card->degrade_freq_level;
+
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s, clk_freq_khz=%dkhz, ddr50_mode=%d\n", __func__,
+ clock_freq, bddr50);
+ switch (clock_freq) {
+ case SD_CLK_ID_400K:
+ value = host->cfg->dmdn_tbl[FREQ_EMMC_400K_START_INDEX];
+ break;
+ case SD_CLK_50M:
+ if (bddr50)
+ value =
+ host->cfg->dmdn_tbl[FREQ_EMMC_DDR50M_START_INDEX];
+ else
+ value = host->cfg->dmdn_tbl[FREQ_EMMC_50M_START_INDEX];
+ break;
+ case SD_CLK_200M:
+ value = host->cfg->dmdn_tbl[FREQ_EMMC_200M_START_INDEX + index];
+ break;
+ default:
+ value = host->cfg->dmdn_tbl[FREQ_EMMC_25M_START_INDEX];
+ break;
+ }
+ host_change_clock(host, value);
+ DbgInfo(MODULE_MMC_CARD, FEATURE_CARD_INIT, TO_RAM,
+ "Enter %s, clk_freq_khz=%dkhz, ddr50_mode=%d\n", __func__,
+ clock_freq, bddr50);
+}
diff --git a/drivers/scsi/bht/card/output_tuning.c b/drivers/scsi/bht/card/output_tuning.c
new file mode 100644
index 000000000000..de1ae5e4f388
--- /dev/null
+++ b/drivers/scsi/bht/card/output_tuning.c
@@ -0,0 +1,756 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2022 BHT Inc.
+ *
+ * File Name: output_tuning.c
+ *
+ * Abstract:
+ * 1. Card tuning main entry
+ * 2. Interface for card tuning
+ *
+ * Version: 1.00
+ *
+ * Author: Chevron
+ *
+ * Environment: OS Independent
+ *
+ * History:
+ *
+ * 3/8/2022 Creation Chevron
+ */
+
+#include "../include/basic.h"
+#include "../include/card.h"
+#include "../include/cardapi.h"
+#include "cardcommon.h"
+#include "../include/hostapi.h"
+#include "../include/transhapi.h"
+#include "../include/hostvenapi.h"
+#include "../include/util.h"
+#include "../include/debug.h"
+#include "../include/cmdhandler.h"
+#include "../host/hostven.h"
+#include "../include/card.h"
+#include "../host/hostreg.h"
+
+/* None Device error */
+#define SD_SUCCESS 0x00000000
+/* Device error */
+#define SD_ERR_DEVICE 0x00000001
+/*mmio value set timeout */
+#define SD_ERR_MMIO_SET_TIMEOUT 0x00000002
+#define SD_ERR_ALL_PHASE_PASS 0x00000003
+#define SD_ERR_FATAL 0x00000004
+/* Device error need degrade */
+#define SD_ERR_DEVICE_DEGRADE 0x00000005
+/* Device error need retry */
+#define SD_ERR_DEVICE_RETRY 0x00000006
+/* Device error need increase drive strength */
+#define SD_ERR_DEVICE_DS_INS 0x00000007
+/* Retry Over */
+#define SD_ERR_RETRY_OVER 0x80000000
+/* CRC Error */
+#define SD_ERR_CRC_MISSMACH 0x40000000
+/* No Response */
+#define SD_ERR_NO_RESPONSE 0x20000000
+/* No Response */
+#define SD_ERR_NO_RESPONSE 0x20000000
+
+u16 tuning_phase_result(sd_card_t *card)
+{
+ u16 result[4] = { 0 };
+ u8 phase_count = 11;
+ u16 phase_mask = 0x7FF;
+ /* u32 device_status; */
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ /* Only GG8 support 14 phase tuning */
+ if (card->host->chip_type == CHIP_GG8
+ || card->host->chip_type == CHIP_ALBATROSS) {
+ phase_count = 14;
+ phase_mask = 0x3FFF;
+ }
+
+ /* get tuning result of 3 cycle */
+ result[0] =
+ sdhci_readl(card->host, SDHCI_SAMPLE_CLK_RESULT_LOW) & phase_mask;
+ result[1] =
+ (sdhci_readl(card->host, SDHCI_SAMPLE_CLK_RESULT_LOW) >>
+ phase_count) & phase_mask;
+
+ /* Low bits result */
+ result[2] =
+ ((sdhci_readl(card->host, SDHCI_SAMPLE_CLK_RESULT_LOW) >>
+ (phase_count << 1) & phase_mask));
+
+ /* Result of full bits */
+ if (card->host->chip_type == CHIP_GG8
+ || card->host->chip_type == CHIP_ALBATROSS)
+ result[2] |=
+ (sdhci_readl(card->host, SDHCI_SAMPLE_CLK_RESULT_UP) &
+ 0x3FF) << 4;
+ else
+ result[2] |=
+ (sdhci_readl(card->host, SDHCI_SAMPLE_CLK_RESULT_UP) &
+ 0x3FF) << 1;
+
+ result[3] = result[0] & result[1] & result[2];
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s, result 0x%x, phase count %d\n", __func__,
+ result[3], phase_count);
+ return result[3];
+}
+
+u8 select_tuning_phase(u16 tuning_phase, u8 phase_cnt)
+{
+ u8 temp[14] = { 0 };
+ u8 cnt[14] = { 0 };
+ u8 sel_phase, val, pos, start_phase;
+ u8 i, j;
+
+ i = j = val = pos = sel_phase = 0;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ for (i = 0; i < phase_cnt; i++)
+ temp[i] = (tuning_phase >> i) & 0x01;
+
+ for (i = 0; i < phase_cnt; i++) {
+ for (j = 0; j < phase_cnt; j++) {
+ if (temp[(i + j) % phase_cnt])
+ cnt[i]++;
+ else
+ break;
+ }
+ }
+
+ val = cnt[0];
+ for (i = 0; i < phase_cnt - 1; i++) {
+ if (cnt[i + 1] > val) {
+ val = cnt[i + 1];
+ pos = i + 1;
+ }
+ }
+
+ start_phase = (phase_cnt == 14 ? 9 : 8);
+ sel_phase = ((start_phase + pos + cnt[pos] / 2) % phase_cnt);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s select phase %d\n", __func__, sel_phase);
+ return sel_phase;
+}
+
+void set_input_tuning_phase(sd_card_t *card, u8 sel_phase)
+{
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ host_enable_clock(card->host, FALSE);
+
+ /* Clear origin phase */
+ sdhci_and32(card->host, SDHCI_DLL_PHASE_CFG, ~0x1F000000);
+ /* select the 1B0h[27:24] to config the phase selection */
+ sdhci_or32(card->host, SDHCI_DLL_PHASE_CFG, BIT28);
+ /* set new phase */
+ sdhci_or32(card->host, SDHCI_DLL_PHASE_CFG, sel_phase << 24);
+
+ host_enable_clock(card->host, TRUE);
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s select phase %d\n", __func__, sel_phase);
+}
+
+void generate_traverse_range(sd_card_t *card, u8 center_point, u8 offset,
+ u8 *start_point, u8 *end_point)
+{
+ u16 phase_mask_all_pass = 0;
+ u8 phase_cnt = 11;
+
+ if (card->host->chip_type == CHIP_GG8
+ || card->host->chip_type == CHIP_ALBATROSS)
+ phase_cnt = 14;
+
+ if (phase_cnt == 14)
+ phase_mask_all_pass = 0x3FFF;
+ else
+ phase_mask_all_pass = 0x7FF;
+
+ if (center_point < offset) {
+ *start_point = phase_cnt + center_point - offset;
+ *end_point = phase_cnt + center_point + offset;
+ } else {
+ *start_point = center_point - offset;
+ *end_point = center_point + offset;
+ }
+}
+
+u8 get_output_fix_phase(sd_card_t *card)
+{
+ cfg_output_tuning_item_t *output_tuning =
+ &card->host->cfg->feature_item.output_tuning_item;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_DDR200) {
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "output_tuning_item DDR200\n");
+ return (u8) output_tuning->fixed_value_ddr200;
+ } else if (card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_SDR104) {
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "output_tuning_item SDR104\n");
+ return (u8) output_tuning->fixed_value_sdr104;
+ } else if (card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_SDR50) {
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "output_tuning_item SDR50\n");
+ return (u8) output_tuning->fixed_value_sdr50;
+ } else {
+ /* Not support this mode at Bayhub Driver */
+ DbgErr("sd_access_mode %d isn't supported !!!",
+ card->info.sw_cur_setting.sd_access_mode);
+ return 0;
+ }
+
+}
+
+/* Use to find a output phase in which input tuning result is not all pass */
+u32 find_input_phase_fail_point(sd_card_t *card, u8 *output_phase,
+ u16 *input_tuning_result)
+{
+ u32 result = 0;
+ u8 start_phase, end_phase, index_phase;
+ u8 output_fix_phase = 0;
+ u8 i = 0;
+ u16 phase_mask_all_pass = 0;
+ int ret = 0;
+ sd_command_t sd_cmd;
+ u8 phase_cnt = 11;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ if (card->host->chip_type == CHIP_GG8
+ || card->host->chip_type == CHIP_ALBATROSS)
+ phase_cnt = 14;
+
+ output_fix_phase = get_output_fix_phase(card);
+
+ if (phase_cnt == 14)
+ phase_mask_all_pass = 0x3FFF;
+ else
+ phase_mask_all_pass = 0x7FF;
+ generate_traverse_range(card, output_fix_phase, 3, &start_phase,
+ &end_phase);
+
+ for (i = start_phase; i <= end_phase; i++) {
+ index_phase = i % phase_cnt;
+
+ host_set_output_tuning_phase(card->host, index_phase);
+
+ ret = sd_tuning(card, &sd_cmd, 150);
+ if (!ret && sd_cmd.err.error_code) {
+ DbgErr("Uncorrect fix output phase!!!\n");
+ result = SD_ERR_FATAL;
+ break;
+ } else if (!ret) {
+ result = SD_ERR_DEVICE_DEGRADE;
+ break;
+ }
+
+ *input_tuning_result = tuning_phase_result(card);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "output phase is %d, input result is 0x%x\n",
+ index_phase, *input_tuning_result);
+ if (*input_tuning_result == phase_mask_all_pass) {
+ result = SD_ERR_ALL_PHASE_PASS;
+ continue;
+ } else {
+ *output_phase = index_phase;
+ result = SD_SUCCESS;
+ break;
+ }
+ }
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+ return result;
+}
+
+u32 generate_output_input_phase_pair(sd_card_t *card, u8 input_fix_phase,
+ u8 ddr200)
+{
+ u32 result = 0;
+ u8 output_phase = 0;
+ u8 input_phase = 0;
+ u16 input_tuning_result = 0;
+ u8 output_fix_phase = 0;
+ u8 start_phase, end_phase, index_phase, offset;
+ u8 i = 0;
+ u8 phase_cnt = 11;
+ u16 phase_mask_all_pass = 0x7FF;
+ sd_command_t sd_cmd;
+ int ret = 0;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ if (card->host->chip_type == CHIP_GG8
+ || card->host->chip_type == CHIP_ALBATROSS) {
+ phase_cnt = 14;
+ phase_mask_all_pass = 0x3FFF;
+ }
+ if (ddr200) {
+ output_fix_phase =
+ (u8) card->host->cfg->feature_item.output_tuning_item.fixed_value_sdr104;
+ offset = 2;
+ } else {
+ output_fix_phase = get_output_fix_phase(card);
+ offset = 3;
+ }
+ generate_traverse_range(card, output_fix_phase, offset, &start_phase,
+ &end_phase);
+
+ for (i = start_phase; i <= end_phase; i++) {
+ index_phase = i % phase_cnt;
+
+ host_set_output_tuning_phase(card->host, index_phase);
+
+ ret = sd_tuning(card, &sd_cmd, 150);
+ if (!ret && sd_cmd.err.error_code) {
+ DbgErr("Uncorrect fix output phase!!!\n");
+ result = SD_ERR_FATAL;
+ break;
+ } else if (!ret) {
+ result = SD_ERR_DEVICE_DEGRADE;
+ break;
+ }
+
+ input_tuning_result = tuning_phase_result(card);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "output phase is %d, input result is 0x%x\n",
+ index_phase, input_tuning_result);
+ if (ddr200) {
+ card->output_input_phase_pair[index_phase] =
+ select_tuning_phase(input_tuning_result,
+ phase_cnt);
+ continue;
+ }
+
+ if (input_tuning_result == phase_mask_all_pass) {
+ result = SD_ERR_ALL_PHASE_PASS;
+ continue;
+ } else {
+ output_phase = index_phase;
+ result = SD_SUCCESS;
+ break;
+ }
+ }
+
+ /* result = find_input_phase_fail_point(card, &output_phase, &input_tuning_result); */
+ if (ret && ddr200) {
+ u8 temp_phase_pair[14] = { 0 };
+ u8 j;
+
+ /* add all input phase */
+ for (i = start_phase; i <= end_phase; i++) {
+
+ input_phase =
+ card->output_input_phase_pair[i % phase_cnt];
+ /* caclute the <output,input> phase pair */
+ for (j = i; j < (i + phase_cnt); j++) {
+ index_phase = j % phase_cnt;
+ temp_phase_pair[index_phase] += input_phase;
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM,
+ "caclute ddr output-input pair:0x%x-0x%x\n",
+ index_phase, input_phase);
+ input_phase = (input_phase + 1) % phase_cnt;
+ }
+ }
+
+ /* caclute the avargae value for other <output,input> phase pair */
+ for (i = end_phase + 1; i < (start_phase + phase_cnt); i++) {
+ index_phase = i % phase_cnt;
+ card->output_input_phase_pair[index_phase] =
+ temp_phase_pair[index_phase] / (1 + (offset << 1));
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM,
+ "###caclute ddr output-input pair:0x%x-0x%x\n",
+ index_phase,
+ card->output_input_phase_pair[index_phase]);
+ }
+
+ } else if ((result == SD_SUCCESS) || (result == SD_ERR_ALL_PHASE_PASS)) {
+ if (result == SD_SUCCESS) {
+ start_phase = output_phase;
+ end_phase = output_phase + phase_cnt;
+ input_phase =
+ select_tuning_phase(input_tuning_result, phase_cnt);
+ } else {
+ start_phase = output_fix_phase;
+ end_phase = output_fix_phase + phase_cnt;
+ input_phase = input_fix_phase;
+ card->input_phase_all_pass = 1;
+ result = SD_SUCCESS;
+ }
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "output-input result:0x%x-0x%x\n", output_phase,
+ input_tuning_result);
+
+ for (i = start_phase; i < end_phase; i++) {
+ index_phase = i % phase_cnt;
+ card->output_input_phase_pair[index_phase] =
+ input_phase;
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM, "output-input pair:0x%x-0x%x\n",
+ index_phase, input_phase);
+ input_phase = (input_phase + 1) % phase_cnt;
+ }
+ }
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+ return result;
+}
+
+int output_tuning(sd_card_t *card, u32 address, bool ddr200)
+{
+ int ret = 0;
+ u8 test_patern[6] = { 0x55, 0xaa, 0x00, 0xff, 0xf0, 0x0f };
+ u8 input_tuning_pattern[64] = {
+ 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xcc,
+ 0xcc, 0xcc, 0x33, 0xcc, 0xcc,
+ 0xcc, 0x33, 0x33, 0xcc, 0xcc, 0xcc, 0xff, 0xff, 0xff, 0xee,
+ 0xff, 0xff, 0xff, 0xee, 0xee, 0xff,
+ 0xff, 0xff, 0xdd, 0xff, 0xff, 0xff, 0xdd, 0xdd, 0xff, 0xff,
+ 0xff, 0xbb, 0xff, 0xff, 0xff, 0xbb,
+ 0xbb, 0xff, 0xff, 0xff, 0x77, 0xff, 0xff, 0xff, 0x77, 0x77,
+ 0xff, 0x77, 0xbb, 0xdd, 0xee, 0xff
+ };
+ int j, k, pattern_i;
+ u32 result = 0;
+ sd_command_t sd_cmd;
+ u32 cmdflag;
+
+ u8 *test_buf = kcalloc(512, sizeof(unsigned char), GFP_KERNEL);
+ u8 *test_buf_read = kcalloc(512, sizeof(unsigned char), GFP_KERNEL);
+
+ if (test_buf == NULL || test_buf_read == NULL) {
+ DbgErr("kcalloc buffer failed\n");
+ if (test_buf != NULL)
+ kfree(test_buf);
+ if (test_buf_read != NULL)
+ kfree(test_buf_read);
+ return SD_ERR_FATAL;
+ }
+
+ if (ddr200)
+ cmdflag =
+ CMD_FLG_RESCHK | CMD_FLG_R1 | CMD_FLG_ADMA_SDMA |
+ CMD_FLG_DDR200_WORK_AROUND | CMD_FLG_INF_BUILD;
+ else
+ cmdflag = CMD_FLG_RESCHK | CMD_FLG_R1 | CMD_FLG_ADMA_SDMA;
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* the output tuning pattern make up by four part */
+ for (pattern_i = 0; pattern_i < 4; pattern_i++) {
+ if (pattern_i < 3) {
+ for (k = 0; k < 512; k++) {
+ test_buf[k] =
+ test_patern[(k % 2) + 2 * pattern_i];
+ }
+ } else {
+ for (j = 0; j < 8; j++) {
+ for (k = 0; k < 64; k++) {
+ if (j % 2) {
+ test_buf[k + 64 * j] =
+ input_tuning_pattern[k];
+ } else {
+ test_buf[k + 64 * j] =
+ input_tuning_pattern[(k +
+ 63) %
+ 64];
+ }
+ }
+ }
+ }
+
+ ret =
+ card_send_sdcmd_timeout(card, &sd_cmd,
+ ddr200 ? SD_CMD25 : SD_CMD24,
+ address, cmdflag, DATA_DIR_OUT,
+ test_buf, 512, 500);
+ if (ret == FALSE) {
+ if (card->input_phase_all_pass) {
+ if (sd_cmd.err.legacy_err_reg & 0x0E) {
+ DbgErr
+ ("Uncorrect fix input phase!!!\n");
+ result = SD_ERR_FATAL;
+ goto end;
+ }
+ }
+
+ if ((sd_cmd.err.legacy_err_reg & 0x80F)
+ && (card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_DDR200)) {
+ DbgErr("Uncorrect fix output phase!!!\n");
+ result = SD_ERR_FATAL;
+ goto end;
+ }
+
+ if (card->info.sw_cur_setting.sd_access_mode !=
+ SD_FNC_AM_DDR200) {
+ DbgErr
+ ("Recovery fail at tuning stage, need re-init!!!\n");
+ result = SD_ERR_DEVICE_RETRY;
+ } else {
+ host_cmddat_line_reset(card->host);
+ card_send_command12(card, &sd_cmd);
+ if (card_check_rw_ready(card, &sd_cmd, 600) !=
+ TRUE) {
+ DbgErr
+ ("Uncorrect fix output phase for DDR200!!!\n");
+ result = SD_ERR_FATAL;
+ } else
+ result = SD_ERR_CRC_MISSMACH;
+ }
+ goto end;
+ }
+
+ ret =
+ card_send_sdcmd_timeout(card, &sd_cmd,
+ ddr200 ? SD_CMD18 : SD_CMD17,
+ address, (cmdflag), DATA_DIR_IN,
+ test_buf_read, 512, 500);
+ if (ret == FALSE) {
+ if (card->input_phase_all_pass) {
+ if (sd_cmd.err.legacy_err_reg & 0x6E) {
+ DbgErr
+ ("Uncorrect fix input phase!!!\n");
+ result = SD_ERR_FATAL;
+ goto end;
+ }
+ }
+
+ if ((sd_cmd.err.legacy_err_reg & 0x80F)
+ && (card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_DDR200)) {
+ DbgErr("Uncorrect fix output phase!!!\n");
+ result = SD_ERR_FATAL;
+ goto end;
+ }
+
+ if (card->info.sw_cur_setting.sd_access_mode !=
+ SD_FNC_AM_DDR200) {
+ DbgErr
+ ("Recovery fail at tuning stage, need re-init!!!\n");
+ result = SD_ERR_DEVICE_RETRY;
+ } else {
+ host_cmddat_line_reset(card->host);
+ card_send_command12(card, &sd_cmd);
+ if (card_check_rw_ready(card, &sd_cmd, 600) !=
+ TRUE) {
+ DbgErr
+ ("Uncorrect fix output phase for DDR200!!!\n");
+ result = SD_ERR_FATAL;
+ } else
+ result = SD_ERR_CRC_MISSMACH;
+ }
+ goto end;
+ }
+
+ for (j = 0; j < (1 * 512); j++) {
+ if (*(test_buf + j) != *(test_buf_read + j)) {
+ result = SD_ERR_CRC_MISSMACH;
+ DbgErr("Compare failed!!!\n");
+ goto end;
+ }
+ }
+ }
+ result = SD_SUCCESS;
+end:
+
+ kfree(test_buf);
+ kfree(test_buf_read);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s(%d)\n", __func__, result);
+ return result;
+}
+
+u32 sdr104_sdr50_output_tuning(sd_card_t *card, u32 address)
+{
+ u8 start_phase, end_phase, index_phase;
+ u8 best_output_phase = 0, best_input_phase = 0;
+ u8 i = 0;
+ u8 output_fix_phase = 0;
+ u8 input_fix_phase = 0;
+ u8 output_fail_phase = 0x0;
+ u32 result = 0;
+ u8 phase_cnt = 11;
+ sd_command_t sd_cmd;
+
+ output_fix_phase = get_output_fix_phase(card);
+
+ if (card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_SDR104)
+ input_fix_phase =
+ (u8) card->host->cfg->feature_item.output_tuning_item.sdr104_input_fix_phase_value;
+ else
+ input_fix_phase =
+ (u8) card->host->cfg->feature_item.output_tuning_item.sdr50_input_fix_phase_value;
+
+ if (card->host->chip_type == CHIP_GG8
+ || card->host->chip_type == CHIP_ALBATROSS)
+ phase_cnt = 14;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Enter %s, retry_output_fail_phase is 0x%x\n", __func__,
+ card->retry_output_fail_phase);
+
+ if (card->retry_output_fail_phase != 0xFF) {
+ best_output_phase =
+ (card->retry_output_fail_phase +
+ (phase_cnt >> 1)) % (phase_cnt);
+ best_input_phase =
+ card->output_input_phase_pair[best_output_phase];
+ goto phase_set;
+ }
+
+ result = generate_output_input_phase_pair(card, input_fix_phase, 0);
+ if (result == SD_ERR_DEVICE_DEGRADE || result == SD_ERR_FATAL)
+ goto exit;
+ else if (result == SD_SUCCESS) {
+ start_phase = output_fix_phase + 4;
+ end_phase = start_phase + phase_cnt;
+ for (i = start_phase; i < end_phase; i++) {
+ index_phase = i % phase_cnt;
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM,
+ "output phase is %d, input phase is %d\n",
+ index_phase,
+ card->output_input_phase_pair[index_phase]);
+
+ host_set_output_tuning_phase(card->host, index_phase);
+ set_input_tuning_phase(card,
+ card->output_input_phase_pair
+ [index_phase]);
+ result = output_tuning(card, address, 0);
+ if (result == SD_SUCCESS)
+ continue;
+ else if (result == SD_ERR_FATAL)
+ goto exit;
+ else {
+ card->retry_output_fail_phase = index_phase;
+ goto exit;
+ }
+ }
+
+ if (i == end_phase)
+ best_output_phase = output_fix_phase;
+ else
+ best_output_phase =
+ (output_fail_phase + (phase_cnt >> 1)) % phase_cnt;
+
+ best_input_phase =
+ card->output_input_phase_pair[best_output_phase];
+ }
+
+phase_set:
+ host_set_output_tuning_phase(card->host, best_output_phase);
+
+ if (sd_tuning(card, &sd_cmd, 150) == FALSE)
+ result = SD_ERR_FATAL;
+ else
+ result = SD_SUCCESS;
+
+exit:
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s result %d,best_output_phase 0x%x, best_input_phase 0x%x\n",
+ __func__, result, best_output_phase, best_input_phase);
+
+ return result;
+}
+
+u32 ddr200_output_tuning(sd_card_t *card, u32 address)
+{
+ u32 result = 0;
+ u8 start_phase, end_phase, index_phase;
+ u8 best_output_phase = 0;
+ u8 output_fix_phase = 0;
+ u8 i = 0;
+ u8 cnt = 0;
+ int pos = -1;
+ u8 phase_cnt = 11;
+ sd_host_t *host = card->host;
+ u16 output_tuning_result = 0;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ if (card->host->chip_type == CHIP_GG8
+ || card->host->chip_type == CHIP_ALBATROSS)
+ phase_cnt = 14;
+
+ /* get output-input pair at DDR200 mode for DDR200_workaround */
+ result =
+ generate_output_input_phase_pair(card,
+ (u8) card->host->cfg->feature_item.output_tuning_item.sdr104_input_fix_phase_value,
+ 1);
+ if (result == SD_ERR_DEVICE_DEGRADE || result == SD_ERR_FATAL)
+ goto exit;
+
+ output_fix_phase = get_output_fix_phase(card);
+
+ generate_traverse_range(card, output_fix_phase, 4, &start_phase,
+ &end_phase);
+
+ for (i = start_phase; i <= end_phase; i++) {
+ index_phase = i % phase_cnt;
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "output phase is %d\n", index_phase);
+
+ /* Used to update input/output phase before write command */
+ host->cur_output_phase = index_phase;
+ result = output_tuning(card, address, 1);
+
+ if (result == SD_SUCCESS) {
+ output_tuning_result |= 1 << index_phase;
+ if (pos == -1)
+ pos = index_phase;
+ cnt++;
+ } else if (result == SD_ERR_FATAL)
+ goto exit;
+ else {
+ /* Find the bad phase after good phase */
+ if (pos != -1) {
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM,
+ "break output phase is %d\n",
+ index_phase);
+ break;
+ }
+ }
+ }
+
+ if (!cnt) {
+ DbgErr("All phase failed when output_tuning!!!\n");
+ result = SD_ERR_DEVICE_DEGRADE;
+ } else {
+ best_output_phase = (pos + (cnt >> 1)) % phase_cnt;
+ host->cur_output_phase = best_output_phase;
+ host_set_output_tuning_phase(card->host, best_output_phase);
+ set_input_tuning_phase(card,
+ card->output_input_phase_pair
+ [best_output_phase]);
+
+ result = SD_SUCCESS;
+ }
+
+exit:
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "best_output_phase 0x%x, output_tuning_result 0x%x\n",
+ best_output_phase, output_tuning_result);
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s, result %d\n", __func__, result);
+ return result;
+}
diff --git a/drivers/scsi/bht/card/sd.c b/drivers/scsi/bht/card/sd.c
new file mode 100644
index 000000000000..6a21d76945a7
--- /dev/null
+++ b/drivers/scsi/bht/card/sd.c
@@ -0,0 +1,3029 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2014 BHT Inc.
+ *
+ * File Name: sd.c
+ *
+ * Abstract: SD Legacy card initialization
+ *
+ * Version: 1.00
+ *
+ * Author: Samuel
+ *
+ * Environment: OS Independent
+ *
+ * History:
+ *
+ * 9/2/2014 Creation Samuel
+ */
+#include "../include/basic.h"
+#include "../include/cardapi.h"
+#include "../include/hostapi.h"
+#include "cardcommon.h"
+#include "../include/debug.h"
+#include "../include/cmdhandler.h"
+#include "../include/host.h"
+#include "../include/util.h"
+#include "../include/hostvenapi.h"
+#include "../host/hostven.h"
+#include "card_ddr200_support.h"
+#include "../include/funcapi.h"
+/* 0: card not support ddr200 mode, 1: support */
+u32 sd_card_ddr200_flag;
+extern bool card_output_tuning(sd_card_t *card, u64 tuning_address);
+extern bool store_tuning_address_content(sd_card_t *card, u64 tuning_address);
+extern bool restore_tuning_address_content(sd_card_t *card,
+ u64 tuning_address);
+extern u32 generate_output_input_phase_pair(sd_card_t *card,
+ u8 input_fix_phase, u8 ddr200);
+
+inline bool uhs1_support(sd_host_t *host)
+{
+ bool ret = TRUE;
+
+ /* 2. Configuration settings to disable UHSI function */
+ if (host->cfg->card_item.sd_card_mode_dis.dis_sd30_card)
+ ret = FALSE;
+
+ return ret;
+
+}
+
+static inline bool need_switch_sig_voltage(sd_card_t *card)
+{
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+
+ if (card->card_type == CARD_UHS2)
+ goto exit;
+
+ /* 1. Check configuration settings
+ * BH722SE2LN-A UHS1 issue#3 Sharkbay QS ULT #6 platform, BH driver 10024,
+ * set card mode to be SDR25 or SDR12 by registry, but the card is SD2.0 mode.
+ * Change to switch voltage when s18a is true.
+ */
+
+ if (card_info->card_s18a)
+ ret = TRUE;
+
+exit:
+ return ret;
+}
+
+static inline bool card_support_cmd6(sd_card_t *card)
+{
+ bool ret = TRUE;
+ card_info_t *card_info = &(card->info);
+ /* 1. SD Memory Card - Spec. Version 1.0 and 1.01 do not support CMD6 */
+ if (card_info->scr.sd_spec < SCR_SPEC_VER_1)
+ ret = FALSE;
+
+ return ret;
+}
+
+#define SDHCI_POWER_VDD1_330 0x0E00
+#define POWER_ON TRUE
+#define POWER_OFF FALSE
+
+bool sd_send_if_cond(sd_card_t *card, sd_command_t *sd_cmd, u32 argument)
+{
+ byte cmd_index = SD_CMD8;
+ /* u32 argument = 0x000001AA; * VHS set. 2.7-3.6V Check Pattern : 0xAA */
+ u32 cmdflag = CMD_FLG_R7 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+
+ if (ret) {
+ /* Pattern Check */
+ if ((sd_cmd->response[0] & 0xFF) != 0xAA) {
+ sd_cmd->err.error_code = ERR_CODE_RESP_ERR;
+ ret = FALSE;
+ DbgErr("CMD8 response pattern check failed.");
+ }
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ * static bool sdio_check(sd_card_t *card, sd_command_t *sd_cmd)
+ * {
+ * byte cmd_index = SD_CMD5;
+ * u32 argument = 0;
+ * u32 cmdflag = CMD_FLG_R4 | CMD_FLG_RESCHK;
+ * e_data_dir dir = DATA_DIR_NONE;
+ * byte *data = NULL;
+ * u32 datalen = 0;
+ * bool ret = FALSE;
+ *
+ * DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ * __func__);
+ *
+ * ret =
+ * card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ * data, datalen);
+ *
+ * DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ * ret, __func__);
+ * return ret;
+ * }
+ */
+
+/*
+ *
+ * Function Name: card_init_ready
+ *
+ * Abstract:
+ *
+ * 1. Issue ACMD41 to Get OCR
+ * 2. Set the card ocr variable
+ * 3. Wait for card ready.
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ * bool flag_f8: Command 8 is executed correctly.
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+bool card_init_ready(sd_card_t *card, sd_command_t *sd_cmd, bool flag_f8)
+{
+ byte cmd_index = SD_CMD41 | SD_APPCMD;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R3;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+ bool ret = FALSE;
+ loop_wait_t wait;
+ u32 delay_us = 20;
+
+ sd_host_t *host = card->host;
+ card_info_t *card_info = &(card->info);
+
+ /* default is 0 */
+ card->uhs2_card = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s, flag_f8=%d\n", __func__, flag_f8);
+
+ if (flag_f8)
+ os_udelay(20);
+
+ /* 3. Start the card initialization */
+ /* 3.1 Set argument according to the flag F8 (command 8 executed correctly) */
+ argument = (1 << fls32(host->ocr_avail));
+
+ if (card->card_type != CARD_UHS2) {
+ if (flag_f8) {
+ if (uhs1_support(host)) {
+ /*
+ * BH722SE2LN-A UHS1 issue#3 Sharkbay QS ULT #6 platform,
+ * BH driver 10024,
+ * set card mode to be SDR25 or SDR12 by registry,
+ * but the card is SD2.0 mode.
+ * Change to send s18R for SDR12/SDR25/SDR50/SDR104.
+ */
+
+ /* Try to set the HCS/XPC/S18R */
+ argument |= 0x51000000;
+ } else {
+ /* Try to set the HCS */
+ argument |= 0x40000000;
+
+ /* Set XPC */
+ argument |= BIT28;
+ }
+ }
+ } else {
+ /* UHS2 case */
+ /* Set HCS bit only */
+ argument |= BIT30;
+
+ /* Set XPC */
+ argument |= BIT28;
+ }
+
+ /* 3.2 Wait for card ready */
+ util_init_waitloop(card->host->pdx,
+ host->cfg->timeout_item.test_card_init_timeout.value,
+ delay_us, &wait);
+
+ do {
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag,
+ dir, data, datalen);
+ if (!ret)
+ break;
+
+ if (flag_f8)
+ os_udelay(delay_us);
+
+ /* Check Busy status. 0b: On initialization; 1b: Initialization Complete. */
+ if ((sd_cmd->response[0] & 0x80000000) == 0) {
+ ret = FALSE;
+ continue;
+ } else {
+ /* card is ready */
+ ret = TRUE;
+ /* check uhs2 or not */
+ if ((sd_cmd->response[0] & (1 << 29)) != 0)
+ card->uhs2_card = TRUE;
+ break;
+ }
+ } while (!util_is_timeout(&wait));
+
+ /* 3.3 If card ready, set related software flags */
+ if (ret) {
+ /* 3.3.1. Set sd_virt_card OCR */
+ card_info->card_ccs = (sd_cmd->response[0] & BIT30) >> 30;
+ if (uhs1_support(host))
+ card_info->card_s18a =
+ (sd_cmd->response[0] & BIT24) >> 24;
+ else
+ card_info->card_s18a = 0;
+
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: signal_voltage_switch
+ *
+ * Abstract:
+ *
+ * 1. Do Signal Voltage Switch Procedure (UHSI, CMD11)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+static bool signal_voltage_switch(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ byte cmd_index = SD_CMD11;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+ bool ret = FALSE;
+ sd_host_t *host = card->host;
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /*
+ * 1. If S18A of ACMD41 is se to 0, do not need to switch signal voltage,
+ * Exit from this procedure
+ */
+ if (card_info->card_s18a == 0) {
+ ret = TRUE;
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Do not need to switch signal voltage.\n");
+
+ goto EXIT;
+ }
+
+ /* 2. Issue CMD11 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (!ret) {
+ DbgErr("Issue CMD11 failed.\n");
+ goto EXIT;
+ }
+
+ ret = host_enable_sd_signal18v(host);
+
+ /* 3.3V->1.8V OK */
+ if (ret == FALSE)
+ goto ERROR;
+ goto EXIT;
+
+ERROR:
+
+ /* return to previous status */
+
+ host_1_8v_sig_set(host, FALSE);
+
+EXIT:
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+
+}
+
+/*
+ *
+ * Function Name: sd_get_sdstatus
+ *
+ * Abstract:
+ *
+ * 1. Read the SD Status Register (SSR) (ACMD13)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+static bool sd_get_sdstatus(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ byte cmd_index = SD_CMD13 | SD_APPCMD;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_IN;
+ u32 datalen = 64;
+
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Issue ACMD13 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ &(card_info->raw_ssr[0]), datalen);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_send_cmd35
+ *
+ * Abstract:
+ *
+ * 1. Read the SD Status Register (SSR) (CMD13)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+static bool sd_send_cmd35(sd_card_t *card)
+{
+
+ byte cmd_index = SD_CMD35;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_OUT;
+ sd_command_t sd_cmd;
+ byte buffer[512] = {
+ 0x10, 0x03,
+ 0x27, 0x86, 0x45, 0xA5, 0x19, 0x40, 0xF2, 0x25,
+ 0x20, 0x47, 0xDF, 0x94, 0xB8, 0x16, 0x13, 0x00,
+ 0x11, 0xF2, 0x1B, 0x4F, 0x23, 0x08, 0x2B, 0x33,
+ 0x21, 0x8C, 0x16, 0x52, 0x6A, 0x1D, 0x89, 0xE3,
+ 0x14, 0x09, 0x53, 0x84, 0x09, 0x47, 0x59, 0x50,
+ 0x57, 0xBB, 0x71, 0x3C, 0x47, 0xA7, 0x2A, 0x46,
+ 0xE2, 0xAF, 0x43, 0x10, 0x44, 0x05, 0x53, 0x7A,
+ 0x79, 0xC3, 0x29, 0xF3, 0x83, 0x45, 0x22, 0x1B,
+ };
+ u32 datalen = 512;
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Issue CMD35 */
+ ret =
+ card_send_sdcmd(card, &sd_cmd, cmd_index, argument, cmdflag, dir,
+ buffer, datalen);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_send_cmd34
+ *
+ * Abstract:
+ *
+ * 1. Read the SD Status Register (SSR) (CMD13)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+static bool sd_send_cmd34(sd_card_t *card)
+{
+
+ byte cmd_index = SD_CMD34;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_IN;
+ sd_command_t sd_cmd;
+ byte buffer[512] = { 0x00, 0x00, };
+ u32 datalen = 512;
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Issue CMD34 */
+ ret =
+ card_send_sdcmd(card, &sd_cmd, cmd_index, argument, cmdflag, dir,
+ buffer, datalen);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_set_bus_width
+ *
+ * Abstract:
+ *
+ * 1. Set Bus Width to 4bit (ACMD6)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+static bool sd_set_bus_width(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ byte cmd_index = SD_CMD6 | SD_APPCMD;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ argument = BUS_WIDTH_4BIT;
+
+ /* Issue ACMD6 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_get_cid
+ *
+ * Abstract:
+ *
+ * 1. Addressed card sends its card identification data (CID)
+ * on the CMD line (CMD10)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+static bool sd_get_cid(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ byte cmd_index = SD_CMD10;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R2;
+ e_data_dir dir = DATA_DIR_NONE;
+ byte *data = NULL;
+ u32 datalen = 0;
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ argument = card_info->rca << 16;
+
+ /* Issue CMD10 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (ret) {
+ /* Set the card CID info */
+ os_memcpy(&(card_info->raw_cid[0]), &(sd_cmd->response[0]), 16);
+ /* Parse the CID info */
+ card_info->cid.manfid = card_info->raw_cid[0];
+ card_info->cid.oemid =
+ card_info->raw_cid[1] | (card_info->raw_cid[2] << 8);
+ os_memcpy(card_info->cid.prod_name, &(card_info->raw_cid[3]),
+ 5);
+ card_info->cid.prv = card_info->raw_cid[8];
+ card_info->cid.serial =
+ card_info->raw_cid[9] | (card_info->raw_cid[10] << 8) |
+ (card_info->raw_cid[11] << 16) | (card_info->raw_cid[12] << 24);
+ }
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_get_scr
+ *
+ * Abstract:
+ *
+ * 1. Read the SD Configuration Register (SCR) (ACMD51)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+static bool sd_get_scr(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ byte cmd_index = SD_CMD51 | SD_APPCMD;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_IN;
+ u32 datalen = 8;
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Issue ACMD51 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ &(card_info->raw_scr[0]), datalen);
+ if (ret) {
+ /* Parse the CSD info */
+ card_info->scr.sd_spec = card_info->raw_scr[0] & 0xF;
+ card_info->scr.cmd_support = card_info->raw_scr[3] & 0xF;
+ card_info->scr.sd_spec3 = card_info->raw_scr[2] & 0x80;
+ card_info->scr.sd_specx =
+ (card_info->raw_scr[2] & 0x3) << 2 |
+ (card_info->raw_scr[3] & 0xc0) >> 6;
+ card_info->scr.reserved_B0 = card_info->raw_scr[7] & 0xFF;
+ card_info->scr.reserved_B1 = card_info->raw_scr[6] & 0xFF;
+ }
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_get_scr
+ *
+ * Abstract:
+ *
+ * 1. Read the SD Configuration Register (SCR) (ACMD51)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+/*
+ * static bool sd_clear_card_detect(sd_card_t *card)
+ * {
+ *
+ * sd_command_t sd_cmd;
+ * byte cmd_index = SD_CMD42 | SD_APPCMD;
+ * u32 argument = 0;
+ * u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ * e_data_dir dir = DATA_DIR_NONE;
+ * bool ret = FALSE;
+ *
+ * DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ * __func__);
+ *
+ * ret =
+ * card_send_sdcmd(card, &sd_cmd, cmd_index, argument, cmdflag, dir,
+ * NULL, 0);
+ * DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ * ret, __func__);
+ * return ret;
+ * }
+ */
+
+/*
+ *
+ * Function Name: sd_switch_function_set_am
+ *
+ * Abstract:
+ *
+ * 1. Set SD switch function status (Access Mode) (CMD6)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ * byte access_mode: access mode which want be set.
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_switch_function_set
+ */
+
+bool sd_switch_function_set_am(sd_card_t *card,
+ sd_command_t *sd_cmd, byte access_mode)
+{
+
+ byte cmd_index = SD_CMD6;
+ u32 argument = SD_FNC_SW | SD_FNC_G1_INFL;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_IN;
+ byte data[64];
+ u32 datalen = 64;
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s, access_mode=0x%x\n", __func__, access_mode);
+
+ if (access_mode == SD_FNC_AM_DDR200)
+ argument = 0x80FFFFEF;
+ else
+ argument |= access_mode;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Set AM to %x, argument=%08X\n", access_mode, argument);
+
+ /* Issue CMD6 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_switch_function_set_ds
+ *
+ * Abstract:
+ *
+ * 1. Set SD switch function status (Driver Strength) (CMD6)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ * byte driver_strength: driver strength which want be set.
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_switch_function_set
+ */
+
+bool sd_switch_function_set_ds(sd_card_t *card,
+ sd_command_t *sd_cmd, byte driver_strength)
+{
+
+ byte cmd_index = SD_CMD6;
+ u32 argument = SD_FNC_SW | SD_FNC_G3_INFL;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_IN;
+ byte data[64];
+ u32 datalen = 64;
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s, driver_strength=0x%x\n", __func__,
+ driver_strength);
+
+ argument |= driver_strength << 8;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Set Driver Strength to %x, argument=%08X\n", driver_strength,
+ argument);
+
+ /* Issue CMD6 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+static byte card_get_max_am_cap(sd_card_t *card)
+{
+ byte max_am_cap = 0;
+
+ if (sd_ddr_support(card))
+ max_am_cap = SD_FNC_AM_DDR200;
+ else if (card->info.sw_func_cap.sd_access_mode & (1 << SD_FNC_AM_SDR104))
+ max_am_cap = SD_FNC_AM_SDR104;
+ else if (card->info.sw_func_cap.sd_access_mode & (1 << SD_FNC_AM_SDR50))
+ max_am_cap = SD_FNC_AM_SDR50;
+ else if (card->info.sw_func_cap.sd_access_mode & (1 << SD_FNC_AM_DDR50))
+ max_am_cap = SD_FNC_AM_DDR50;
+ else if (card->info.sw_func_cap.sd_access_mode & (1 << SD_FNC_AM_HS))
+ max_am_cap = SD_FNC_AM_HS;
+ else if (card->info.sw_func_cap.sd_access_mode & (1 << SD_FNC_AM_DS))
+ max_am_cap = SD_FNC_AM_DS;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "(%x) %s\n",
+ max_am_cap, __func__);
+ return max_am_cap;
+}
+
+static byte card_get_min_am(byte am1, byte am2)
+{
+ byte am = 0;
+
+ switch (am1) {
+ case SD_FNC_AM_DDR200:
+ am = am2;
+ break;
+ case SD_FNC_AM_SDR104:
+ if (am2 == SD_FNC_AM_DDR200)
+ am = am1;
+ else
+ am = am2;
+ break;
+ case SD_FNC_AM_SDR50:
+ if (am2 == SD_FNC_AM_SDR104 || am2 == SD_FNC_AM_DDR200)
+ am = am1;
+ else
+ am = am2;
+ break;
+ case SD_FNC_AM_DDR50:
+ if (am2 == SD_FNC_AM_SDR50 || am2 == SD_FNC_AM_SDR104
+ || am2 == SD_FNC_AM_DDR200) {
+ am = am1;
+ } else {
+ am = am2;
+ }
+ break;
+ case SD_FNC_AM_HS:
+ if (am2 == SD_FNC_AM_DS)
+ am = am2;
+ else
+ am = am1;
+ break;
+ case SD_FNC_AM_DS:
+ am = am1;
+ break;
+ default:
+ break;
+ }
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "(%x) %s\n", am,
+ __func__);
+ return am;
+}
+
+static byte card_power_limit_to_index(u8 pmlimit)
+{
+ byte i = 0;
+ byte power_limit[5] = {
+ SD_FNC_PL_072W,
+ SD_FNC_PL_144W,
+ SD_FNC_PL_180W,
+ SD_FNC_PL_216W,
+ SD_FNC_PL_288W
+ };
+
+ for (i = 0; i < 5; i++)
+ if (power_limit[i] == pmlimit)
+ return i;
+
+ return 0;
+}
+
+bool sd_switch_power_limit(sd_card_t *card, sd_command_t *sd_cmd, bool *bchg)
+{
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+ bool high_to_low = TRUE;
+ byte start;
+
+ byte power_limit[5] = {
+ SD_FNC_PL_072W,
+ SD_FNC_PL_144W,
+ SD_FNC_PL_180W,
+ SD_FNC_PL_216W,
+ SD_FNC_PL_288W
+ };
+ int i;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s, *bchg= %d\n", __func__, *bchg);
+
+ /*
+ * 3.1 Get Max Power Limit, default: 2.88W
+ * 3.2 check the Max power limit that card support
+ * Check order: 2.88W -> 2.16W -> 1.8W -> 1.44W -> 0,72W
+ */
+
+ start =
+ card_power_limit_to_index(card->sw_target_setting.sd_power_limit);
+ if (start > 4) {
+ DbgErr("Power Limit settings invalid!");
+ start = 4;
+ }
+
+ /* start = i; */
+ if (card->thermal_enable)
+ if (card->thermal_heat == 0)
+ high_to_low = FALSE;
+
+ if (high_to_low) {
+ for (i = start; i >= 0; i--) {
+ if (card_info->sw_cur_setting.sd_power_limit ==
+ power_limit[i] && *bchg == FALSE) {
+ ret = TRUE;
+ *bchg = FALSE;
+ break;
+ }
+ /* Check card support or not */
+ if (card_info->sw_func_cap.sd_power_limit &
+ (1 << (power_limit[i]))) {
+ ret =
+ sd_switch_function_set_pl(card, sd_cmd,
+ power_limit[i]);
+ if (!ret) {
+ DbgErr
+ ("Set Power Limit to %X Failed.\n",
+ power_limit[i]);
+ goto exit;
+ }
+ /* Update the current settings */
+ card_info->sw_cur_setting.sd_power_limit =
+ power_limit[i];
+ DbgInfo(MODULE_ALL_CARD,
+ FEATURE_FUNC_THERMAL |
+ FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Powerlimit1 index=%d\n", i);
+ *bchg = TRUE;
+ break;
+ }
+ }
+ } else {
+ for (i = 0; i <= start; i++) {
+ if (card_info->sw_cur_setting.sd_power_limit ==
+ power_limit[i] && *bchg == FALSE) {
+ ret = TRUE;
+ *bchg = FALSE;
+ break;
+ }
+ /* Check card support or not */
+ if (card_info->sw_func_cap.sd_power_limit &
+ (1 << (power_limit[i]))) {
+ ret =
+ sd_switch_function_set_pl(card, sd_cmd,
+ power_limit[i]);
+ if (!ret) {
+ DbgErr
+ ("Set Power Limit to %X Failed.\n",
+ power_limit[i]);
+ goto exit;
+ }
+ /* Update the current settings */
+ card_info->sw_cur_setting.sd_power_limit =
+ power_limit[i];
+ DbgInfo(MODULE_ALL_CARD,
+ FEATURE_FUNC_THERMAL |
+ FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Powerlimit2 index=%d\n", i);
+ *bchg = TRUE;
+ break;
+ }
+ }
+ }
+exit:
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+bool sd_switch_access_mode(sd_card_t *card, sd_command_t *sd_cmd, bool *bchg)
+{
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+ byte i;
+ u32 clock_freq;
+ u32 regval;
+
+ sd_host_t *host = card->host;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s, *bchg= %d\n", __func__, *bchg);
+
+ /* 4.1 Get Max Access Mode of UHSI */
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "card->sw_target_setting.sd_access_mode %d\n",
+ card->sw_target_setting.sd_access_mode);
+ card->sw_target_setting.sd_access_mode =
+ card_get_min_am(card->sw_target_setting.sd_access_mode,
+ (byte) card_get_max_am_cap(card));
+ i = card->sw_target_setting.sd_access_mode;
+
+ while (i >= 0) {
+ /* Check card support or not */
+ if (i == SD_FNC_AM_DDR200) {
+ ret = sd_switch_function_set_am(card, sd_cmd, i);
+ if (!ret) {
+ DbgErr("Set Access Mode to %X Failed.\n", i);
+ i = SD_FNC_AM_SDR104;
+ continue;
+ }
+
+ /* Update the current settings */
+ card_info->sw_cur_setting.sd_access_mode = i;
+ DbgInfo(MODULE_ALL_CARD,
+ FEATURE_FUNC_THERMAL | FEATURE_CARD_INIT,
+ NOT_TO_RAM, "Access Mode=%d\n", i);
+ *bchg = TRUE;
+ break;
+ }
+
+ if (card_info->sw_func_cap.sd_access_mode & (1 << i)) {
+ if (card_info->sw_cur_setting.sd_access_mode == i
+ && *bchg == FALSE) {
+ ret = TRUE;
+ *bchg = FALSE;
+ goto exit;
+ }
+ ret = sd_switch_function_set_am(card, sd_cmd, i);
+ if (!ret) {
+ DbgErr("Set Access Mode to %X Failed.\n", i);
+ goto exit;
+ }
+ /* Update the current settings */
+ card_info->sw_cur_setting.sd_access_mode = i;
+ DbgInfo(MODULE_ALL_CARD,
+ FEATURE_FUNC_THERMAL | FEATURE_CARD_INIT,
+ NOT_TO_RAM, "Access Mode=%d\n", i);
+ *bchg = TRUE;
+ break;
+ }
+
+ /* If DDR50 is the target access mode,
+ * then the next access mode should be High Speed (1),
+ * instead of SDR104 (3)
+ */
+ if (i == SD_FNC_AM_DDR50) {
+ i = SD_FNC_AM_HS;
+ continue;
+ }
+
+ i--;
+ }
+
+ /* 5 Set timing accrodingly */
+ switch (card_info->sw_cur_setting.sd_access_mode) {
+ case SD_FNC_AM_DDR200:
+ {
+ if (card->ddr225_card_flag)
+ clock_freq = SD_CLK_225M;
+ else
+ clock_freq = SD_CLK_200M;
+
+ break;
+ }
+ case SD_FNC_AM_SDR104:
+ {
+ clock_freq = SD_CLK_200M;
+ break;
+ }
+ case SD_FNC_AM_SDR50:
+ {
+ clock_freq = SD_CLK_100M;
+ break;
+ }
+ case SD_FNC_AM_SDR25:
+ {
+ clock_freq = SD_CLK_50M;
+ break;
+ }
+ case SD_FNC_AM_SDR12:
+ {
+ clock_freq = SD_CLK_25M;
+ break;
+ }
+ case SD_FNC_AM_DDR50:
+ {
+ clock_freq = SD_CLK_50M;
+ break;
+ }
+ default:
+ {
+ clock_freq = SD_CLK_25M;
+ break;
+ }
+ }
+
+ if (card_info->sw_cur_setting.sd_access_mode == SD_FNC_AM_DDR50
+ || card_info->sw_cur_setting.sd_access_mode == SD_FNC_AM_DDR200) {
+ card_legacy_change_clock(card, clock_freq, TRUE);
+ } else {
+ card_legacy_change_clock(card, clock_freq, FALSE);
+ }
+
+ /*
+ * if the switch is successful,set host mode to DDR200
+ * host 0x110[17]=1
+ */
+ if (card_info->sw_cur_setting.sd_access_mode == SD_FNC_AM_DDR200) {
+ regval = sdhci_readl(host, 0x110);
+ regval |= (1 << 17);
+ sdhci_writel(host, 0x110, regval);
+ }
+
+ host_set_uhs_mode(host, card_info->sw_cur_setting.sd_access_mode);
+
+exit:
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+
+}
+
+/*
+ *
+ * Function Name: sd_switch_function_set
+ *
+ * Abstract:
+ *
+ * 1. Set SD switch function status
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+bool sd_switch_function_set(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ bool ret = FALSE;
+ sd_host_t *host = card->host;
+ card_info_t *card_info = &(card->info);
+ bool bchg = TRUE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* 1. Check the function card supported */
+
+ /*
+ * 2. Set Driver Strength
+ * As default, driver do not set driver strength
+ * Only set it when configure driver_strength enabled
+ */
+
+ if (host->cfg->card_item.test_driver_strength_sel.enable_set) {
+ byte driver_strength = card->sw_target_setting.sd_drv_type;
+ /* Do function switch when card support this function */
+ if ((1 << driver_strength) &
+ (card_info->sw_func_cap.sd_drv_type)) {
+ ret =
+ sd_switch_function_set_ds(card, sd_cmd,
+ driver_strength);
+ if (!ret) {
+ DbgErr("Set driver strength to %X Failed.\n",
+ driver_strength);
+ goto exit;
+ }
+ /* Update the current settings */
+ card_info->sw_cur_setting.sd_drv_type = driver_strength;
+ }
+ } else if ((card_info->cid.manfid == 0x1b) && sd_ddr_support(card)) {
+ /* Driver strength select 3h: Type D */
+ byte driver_strength = 0x3;
+
+ PrintMsg("Samsung DDR200 card need switch DS to type D\n");
+
+ ret = sd_switch_function_set_ds(card, sd_cmd, driver_strength);
+ if (!ret) {
+ DbgErr("Set driver strength to %X Failed.\n",
+ driver_strength);
+ goto exit;
+ }
+ /* Update the current settings */
+ card_info->sw_cur_setting.sd_drv_type = driver_strength;
+ } else {
+ /* do nothing */
+ }
+
+ /* 3. Set Power Limit. */
+ /* Init case we always do pm setting */
+ bchg = TRUE;
+ ret = sd_switch_power_limit(card, sd_cmd, &bchg);
+ if (!ret) {
+ DbgErr("Set Power Limit Failed.\n");
+ goto exit;
+ }
+
+ /* 4. Set Access mode */
+ /* Init case we always do am setting */
+ bchg = TRUE;
+ ret = sd_switch_access_mode(card, sd_cmd, &bchg);
+ if (!ret) {
+ DbgErr("Set Access Mode Failed.\n");
+ goto exit;
+ }
+exit:
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_tuning_hw
+ *
+ * Abstract:
+ *
+ * 1. Hardware Tuning Procedure (CMD19)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_tuning
+ */
+
+bool sd_tuning_hw(sd_card_t *card, sd_command_t *sd_cmd, u32 timeout)
+{
+
+ byte cmd_index = SD_CMD19;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_TUNE;
+ e_data_dir dir = DATA_DIR_IN;
+ byte data[64];
+ u32 datalen = 64;
+
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* 1. Set driver HW mode here */
+ host_set_tuning_mode(card->host, TRUE);
+ /* add 200us delay before CMD19 to fix FJ2 ASIC issue 14 */
+ if (card->host->chip_type == CHIP_FUJIN2)
+ os_udelay(200);
+
+ /* 2. Tuning now */
+ ret =
+ card_send_sdcmd_timeout(card, sd_cmd, cmd_index, argument, cmdflag,
+ dir, data, datalen, timeout);
+ if (!ret)
+ DbgErr(" - SendCommand19 failed during tuning!\n");
+ else
+ ret = host_chk_tuning_comp(card->host, TRUE);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_tuning_sw
+ *
+ * Abstract:
+ *
+ * 1. Software Tuning Procedure (CMD19)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_tuning
+ */
+
+bool sd_tuning_sw(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ byte cmd_index = SD_CMD19;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_TUNE;
+ e_data_dir dir = DATA_DIR_IN;
+ byte data[64];
+ u32 datalen = 64;
+ u16 i;
+
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Try 100 SW tuning */
+ for (i = 0; i < 100; i++) {
+ /* 1. Set driver SW mode here */
+ host_set_tuning_mode(card->host, FALSE);
+ /* add 200us delay before CMD19 to fix FJ2 ASIC issue 14 */
+ if (card->host->chip_type == CHIP_FUJIN2)
+ os_udelay(200);
+
+ /* 2. Tuning now */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag,
+ dir, data, datalen);
+ if (!ret) {
+ DbgErr("SendCommand19 failed during tuning!\n");
+ break;
+ }
+
+ ret = host_chk_tuning_comp(card->host, TRUE);
+ if (ret)
+ break;
+
+ }
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_tuning
+ *
+ * Abstract:
+ *
+ * 1. Tuning Procedure (CMD19)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+bool sd_tuning(sd_card_t *card, sd_command_t *sd_cmd, u32 timeout)
+{
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (card_info->sw_cur_setting.sd_access_mode < SD_FNC_AM_SDR50) {
+ /* Only do tuning procedure for DDR50, SDR104, SDR50,DDR200 */
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "No need to do tuning for access mode %d\n",
+ card_info->sw_cur_setting.sd_access_mode);
+ ret = TRUE;
+ } else {
+ if (TUNING_MODE) {
+ /* HW tuning */
+ ret = sd_tuning_hw(card, sd_cmd, timeout);
+ } else {
+ ret = sd_tuning_sw(card, sd_cmd);
+ }
+
+ }
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_switch_function_check
+ *
+ * Abstract:
+ *
+ * 1. Get SD switch function status (CMD6)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+bool sd_switch_function_check(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ byte cmd_index = SD_CMD6;
+ u32 argument = SD_FNC_NOINFL;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_IN;
+ byte data[64];
+ u32 datalen = 64;
+ bool ret = FALSE;
+ card_info_t *card_info = &(card->info);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Issue CMD6 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (ret) {
+ /* Set the card swich function status info */
+ card_info->sw_func_cap.sd_access_mode = data[13];
+ card_info->sw_func_cap.sd_command_system = data[10];
+ card_info->sw_func_cap.sd_drv_type = data[9];
+ card_info->sw_func_cap.sd_power_limit = data[7];
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Card Sup AM:%X\n",
+ card_info->sw_func_cap.sd_access_mode);
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Card Sup CS:%X\n",
+ card_info->sw_func_cap.sd_command_system);
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Card Sup DS:%X\n", card_info->sw_func_cap.sd_drv_type);
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Card Sup PL:%X\n",
+ card_info->sw_func_cap.sd_power_limit);
+ }
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_switch_function_set_pl
+ *
+ * Abstract:
+ *
+ * 1. Set SD switch function status (Power Limit) (CMD6)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ * byte driver_strength: driver strength which want be set.
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_switch_function_set
+ */
+
+bool sd_switch_function_set_pl(sd_card_t *card,
+ sd_command_t *sd_cmd, byte power_limit)
+{
+
+ byte cmd_index = SD_CMD6;
+ u32 argument = SD_FNC_SW | SD_FNC_G4_INFL;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_IN;
+ byte data[64];
+ u32 datalen = 64;
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Enter %s, power_limit=%d\n", __func__, power_limit);
+
+ argument |= (power_limit) << 12;
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Set Power Limit to %x, argument=%08X\n", power_limit,
+ argument);
+
+ /* Issue CMD6 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_switch_function_set_pl
+ *
+ * Abstract:
+ *
+ * 1. Set SD switch function status (Power Limit) (CMD6)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ * byte driver_strength: driver strength which want be set.
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_switch_function_set
+ */
+
+bool sd_lightning_mode_sw(sd_card_t *card, sd_command_t *sd_cmd)
+{
+
+ byte cmd_index = SD_CMD6;
+ u32 argument = SD_FNC_SW | SD_FNC_G4_INFL;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_IN;
+ byte data[64];
+ u32 datalen = 64;
+ u32 card_status = 0;
+ bool ret = FALSE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* 1. Check if lightning mode is enabled or not */
+ /* Host was set to do not support lightning mode */
+ goto EXIT;
+
+ if (card->info.cid.manfid != MID_SANDISK) {
+ /* Card is not SanDisk Card */
+ goto EXIT;
+ }
+
+ /* 2. Set card to vendor specific mode */
+ {
+ cmd_index = SD_CMD6;
+ argument = SD_FNC_SW | SD_FNC_G2_VEN;
+ cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ dir = DATA_DIR_IN;
+ datalen = 64;
+ /* Issue CMD6 */
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag,
+ dir, data, datalen);
+ if (ret == FALSE) {
+ DbgErr(("Set Vendor Specific mode failed!\n"));
+
+ goto EXIT;
+ }
+ }
+
+ /* 3. Send CMD13 */
+ ret = card_get_card_status(card, sd_cmd, &card_status);
+ if (ret == FALSE) {
+ DbgErr(("Send Status error(CMD13)\n"));
+
+ goto EXIT;
+ }
+
+ /* 4. Send CMD35 */
+ ret = sd_send_cmd35(card);
+ if (ret == FALSE) {
+ DbgErr(("Send Status error(CMD13)\n"));
+
+ goto EXIT;
+ }
+
+ /* Send CMD34 */
+ ret = sd_send_cmd34(card);
+ if (ret == FALSE) {
+ DbgErr(("Send Status error(CMD13)\n"));
+
+ goto EXIT;
+ }
+
+ /* Delay */
+ os_mdelay(1);
+
+EXIT:
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ ret, __func__);
+ return ret;
+}
+
+/*
+ *
+ * Function Name: sd_card_identify
+ *
+ * Abstract:
+ *
+ * 1. Issue reset command (CMD0)
+ * 2. Issue send IF condition command (CMD8)
+ * 3. SDIO swithch function supportted?
+ * 4. Wait for card ready (ACMD41)
+ * 5. Signal voltage switch prucedure (CMD11)
+ * 6. Get card CID(CMD2)
+ * 7. Get card relative address (CMD3)
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_legacy_init, ush2_card_init
+ */
+
+bool sd_card_identify(sd_card_t *card)
+{
+ bool result = FALSE;
+ bool flag_f8 = FALSE;
+ sd_command_t sd_cmd;
+ u32 argument = 0x000001AA;
+
+ card->uhs2_card = FALSE;
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ os_memset(&sd_cmd, 0, sizeof(sd_command_t));
+
+ if (card->card_type != CARD_UHS2)
+ os_udelay(200);
+
+ /* 1. Issue reset command (CMD0) */
+
+ result = card_reset_card(card, &sd_cmd);
+ if (!result) {
+ /* Go Idle State command failed. exit directly. */
+ DbgErr("Reset Card (CMD0) Failed.\n");
+ goto exit;
+ }
+
+ /* 2. Issue send IF condition command (CMD8) */
+ result = sd_send_if_cond(card, &sd_cmd, argument);
+ if (!result) {
+
+ /* 2.1 Error response */
+ if (sd_cmd.err.error_code == ERR_CODE_RESP_ERR ||
+ sd_cmd.err.error_code == ERR_CODE_NO_CARD) {
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "CMD8 Response Error or no card.\n");
+ goto exit;
+ }
+
+ /* 2.2 No Response (Standard Capacity Card) */
+ {
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "CMD8 No Responser.\n");
+
+ /* 2.2.1 Set flag F8 = 0 */
+ flag_f8 = FALSE;
+#if (0)
+ card->card_cap_type = CARD_SDSC_V1;
+#endif
+ /* 2.2.2 Reset card (CMD0) again. */
+ result = card_reset_card(card, &sd_cmd);
+ if (!result) {
+ /* Go Idle State command failed. exit directly. */
+ DbgErr("Reset Card Again (CMD0) Failed.\n");
+ goto exit;
+ }
+ }
+ } else {
+ /* 2.3 Good Response (High Capacity card) */
+ /* 2.3.1 Set flag F8 = 1 */
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "CMD8 Good Responser (High Capacity Card).\n");
+
+ flag_f8 = TRUE;
+ }
+
+ /* 3. SDIO swithch function supportted? */
+#if (0)
+ /* RTU_OK */
+ if ((card->card_type != CARD_SD) && (card->card_type != CARD_UHS2)) {
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "SDIO swithch function supportted.\n");
+
+ /* 3.1 issue CMD5 to check card is SDIO card or not */
+ result = sdio_check(card, &sd_cmd);
+ if (result == TRUE) {
+ /* 3.1.1 set card type to SDIO_CARD */
+ card->card_type = CARD_SDIO;
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "SDIO card.\n");
+ /* 3.1.3 Return failed */
+ result = FALSE;
+ goto exit;
+ }
+ }
+#endif
+
+ /* 4. Wait for card ready (ACMD41) */
+ result = card_init_ready(card, &sd_cmd, flag_f8);
+ if (!result) {
+ /*
+ * 4.1 Return failed for following cases:
+ * - OCR check fail,
+ * - or command timeout,
+ * - or command55 fail,
+ * - or ACMD41 response error
+ */
+ DbgErr("Wait for card ready (ACMD41) Failed.\n");
+ goto exit;
+ }
+
+ /* Try to init as SD Legacy card */
+ if (card->card_type != CARD_UHS2)
+ card->card_type = CARD_SD;
+
+ /* 5. Signal voltage switch prucedure (CMD11) */
+ if (need_switch_sig_voltage(card)) {
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Need to do signal voltage switch.\n");
+
+ result = signal_voltage_switch(card, &sd_cmd);
+ if (!result) {
+ /*
+ * 5.1 If signal voltage switch failed,
+ * need return failed for power cycle.
+ */
+ DbgErr("Signal voltage switch failed.\n");
+ goto exit;
+ }
+ }
+
+ /* 6. Get card CID(CMD2) */
+ result = card_all_send_cid(card, &sd_cmd);
+ if (!result) {
+ /* 6.1 If failed, need return failed for power cycle. */
+ DbgErr("Get card CID(CMD2) failed.\n");
+ goto exit;
+ }
+
+ /* 7. Get card relative address (CMD3) */
+ result = card_get_rca(card, &sd_cmd);
+ if (!result) {
+ /* 7.1 If failed, need return failed for power cycle. */
+ DbgErr("Get card relative address (CMD3) failed.\n");
+ goto exit;
+ }
+
+exit:
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: sd_card_select
+ *
+ * Abstract:
+ *
+ * 1. Get CID (CMD10)
+ * 2. Get CSD (CMD9)
+ * 3. Select the card (CMD7)
+ * 4. Get Lock/Unlock status, CMD7 Response [25].
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: sd_legacy_init, ush2_card_init
+ */
+
+bool sd_card_select(sd_card_t *card)
+{
+ bool result = FALSE;
+ sd_command_t sd_cmd;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ os_memset(&sd_cmd, 0, sizeof(sd_command_t));
+
+ if (card_need_get_info(card)) {
+ /* 1.1 Get CID (CMD10) */
+ result = sd_get_cid(card, &sd_cmd);
+ if (!result) {
+ DbgErr("Get CID (CMD10) failed.\n");
+ goto exit;
+ }
+
+ /* 1.2 Get CSD (CMD9) */
+ result = card_get_csd(card, &sd_cmd);
+ if (!result) {
+ DbgErr("Get CSD (CMD9) failed.\n");
+ goto exit;
+ }
+ } else {
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Already get card info, skip getting CID,CSD.\n");
+ }
+
+ /* 2. Select the card (CMD7) */
+ result = card_select_card(card, &sd_cmd);
+ if (!result) {
+ /* 2.1 If failed, need return failed for power cycle. */
+ DbgErr("Select card (CMD7) failed.\n");
+ goto exit;
+ }
+
+exit:
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+
+}
+
+bool sd_init_get_info(sd_card_t *card)
+{
+ bool result = TRUE;
+ sd_command_t sd_cmd;
+ sd_host_t *host = card->host;
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ os_memset(&sd_cmd, 0, sizeof(sd_command_t));
+
+ /* 11. Set bus width */
+ /* uhs2 card don't need this flow */
+ if (card->card_type == CARD_SD) {
+ /* 11.1 Set card bus width (ACMD6) */
+ result = sd_set_bus_width(card, &sd_cmd);
+ if (!result) {
+ /* 11.1 If failed, need return failed for power cycle. */
+ DbgErr("Set card bus width (ACMD6) failed.\n");
+ goto exit;
+ }
+
+ /* 11.2 Set Host bus width */
+ host_set_buswidth(host, BUS_WIDTH4);
+
+ /* 12. Set block length (CMD16) */
+ result = card_set_block_len(card, &sd_cmd, SD_BLOCK_LEN);
+ if (!result) {
+ /* 12.1 If failed, need return failed for power cycle. */
+ DbgErr("Set block length (CMD16) failed.\n");
+ goto exit;
+ }
+ }
+
+ /* 13. Get card related info, like CID,CSD, SCR, SD_Status */
+ if (card_need_get_info(card)) {
+ /* 13.3 Get SCR (ACMD51) */
+ result = sd_get_scr(card, &sd_cmd);
+ if (!result) {
+ DbgErr("Get SCR (ACMD51) failed.\n");
+ goto exit;
+ }
+ /* 13.4 Get SD Status (ACMD13) */
+ result = sd_get_sdstatus(card, &sd_cmd);
+ if (!result) {
+ DbgErr("Get SD Status (ACMD13) failed.\n");
+ goto exit;
+ }
+ } else {
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Already get card info, skip getting SCR, SD_Status.\n");
+ }
+
+exit:
+ DbgInfo(MODULE_ALL_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+bool sd_init_stage2(sd_card_t *card)
+{
+ bool result = FALSE;
+ sd_host_t *host = card->host;
+ cfg_item_t *cfg_item = card->host->cfg;
+ card_info_t *card_info = &(card->info);
+ sd_command_t sd_cmd;
+ u8 tuning_type = 0;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ os_memset(&sd_cmd, 0, sizeof(sd_command_t));
+
+ if (host->chip_type != CHIP_GG8) {
+ /* 1. Set SD Host Clock to 25MHz */
+ card_legacy_change_clock(card, SD_CLK_25M, FALSE);
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Set SD Host Clock to 25MHz.\n");
+ } else
+ os_mdelay(15);
+
+ result = sd_init_get_info(card);
+ if (!result) {
+ DbgErr("SD Card get info failed\n");
+ goto exit;
+ }
+#if (0)
+ /* Turns Off the Pull-up resistor of the SD Card */
+ result = sd_clear_card_detect(card);
+ if (!result) {
+ DbgErr
+ ("Turns Off the Pull-up resistor of the SD Card failed\n");
+ goto exit;
+ }
+#endif
+
+ if (card->restore_tuning_content_fail) {
+ result =
+ restore_tuning_address_content(card,
+ card->sec_count -
+ TUNING_ADDRESS_OFFSET);
+ if (!result) {
+ DbgErr("restore_tuning_address_content failed\n");
+ card->restore_tuning_content_fail = 1;
+ goto exit;
+ }
+ }
+
+ /* 2. Need to clear High Speed Enable */
+ host_set_highspeed(host, FALSE);
+
+ /* 3. Swich function check/set */
+ if (card_info->scr.sd_spec < SCR_SPEC_VER_1) {
+ result = TRUE;
+ card->sw_target_setting.sd_access_mode = SD_FNC_AM_DS;
+ if (host->chip_type == CHIP_GG8) {
+ /* 1. Set SD Host Clock to 25MHz */
+ card_legacy_change_clock(card, SD_CLK_25M, FALSE);
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Set SD Host Clock to 25MHz.\n");
+ }
+ goto exit;
+ } else if (!(card_info->card_s18a)) {
+ card->sw_target_setting.sd_access_mode =
+ os_min(card->sw_target_setting.sd_access_mode,
+ SD_FNC_AM_HS);
+ if (card_need_get_info(card)) {
+ /* 3.1. Check if card support Hight Speed. */
+ result = sd_switch_function_check(card, &sd_cmd);
+ if (!result) {
+ DbgErr("Swich function check (CMD6) failed.\n");
+ goto exit;
+ }
+ } else {
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Card function check skipped.\n");
+ }
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Card support High Speed.\n");
+
+ if ((card->info.sw_func_cap.sd_access_mode & (1 << SD_FNC_AM_HS))
+ && (card->sw_target_setting.sd_access_mode >= SD_FNC_AM_HS)) {
+ result =
+ sd_switch_function_set_am(card, &sd_cmd,
+ SD_FNC_AM_HS);
+ if (!result) {
+ DbgErr
+ ("Set Access Mode to High Speed Failed.\n");
+ goto exit;
+ }
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Switch to High Speed OK.\n");
+ if (host->chip_type == CHIP_GG8) {
+ /* 1. Set SD Host Clock to 25MHz */
+ card_legacy_change_clock(card, SD_CLK_25M,
+ FALSE);
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT,
+ NOT_TO_RAM,
+ "Set SD Host Clock to 25MHz.\n");
+ }
+
+ /* 3.2. Update the current settings */
+ card_info->sw_cur_setting.sd_access_mode = SD_FNC_AM_HS;
+ /* 3.3. Need to set High Speed Enable */
+ host_set_highspeed(host, TRUE);
+
+ /* 4. Check Lighting card support */
+ result = sd_lightning_mode_sw(card, &sd_cmd);
+ if (result == TRUE) {
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT,
+ NOT_TO_RAM,
+ "Card support Lighting mode, change clock to 75MHz.\n");
+ /* 4.1. Change the clock to 75MHz */
+ card_legacy_change_clock(card, SD_CLK_75M,
+ FALSE);
+ } else {
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT,
+ NOT_TO_RAM, "Change clock to 50MHz.\n");
+ /* 4.2. Change the clock to 50MHz */
+ card_legacy_change_clock(card, SD_CLK_50M,
+ FALSE);
+ }
+ result = TRUE;
+ } else {
+ /*
+ * Degrade access mode to Default Speed case.
+ * Need to switch access mode to Default Speed
+ * as card default AM is High Speed.
+ */
+ result =
+ sd_switch_function_set_am(card, &sd_cmd,
+ SD_FNC_AM_DS);
+ if (!result) {
+ DbgErr
+ ("Set Access Mode to Default Speed Failed.\n");
+ goto exit;
+ }
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Switch to Default Speed OK.\n");
+
+ }
+
+ } else {
+
+ if (card_need_get_info(card)) {
+
+ /* 5.1 Swich function check first to get card function capabilities */
+ result = sd_switch_function_check(card, &sd_cmd);
+ if (!result) {
+ DbgErr("Swich function check (CMD6) failed.\n");
+ goto exit;
+ }
+ } else {
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Card function check skipped.\n");
+ }
+
+ if ((card_get_max_am_cap(card) >= SD_FNC_AM_SDR50)
+ && (cfg_item->card_item.test_max_access_mode.value >= 0x2))
+ result =
+ store_tuning_address_content(card,
+ card->sec_count -
+ TUNING_ADDRESS_OFFSET);
+ else
+ /* SD2.0 card shall not store tuning */
+ result = FALSE;
+
+ if (!result) {
+ DbgErr("store_tuning_address_contento failed\n");
+ /* goto exit; */
+ }
+
+ /*
+ * 5.2 Swich function check set.
+ * - Driver Strength,
+ * - Access Mode,
+ * - Power Limit
+ * - Change clock freq
+ */
+
+ result = sd_switch_function_set(card, &sd_cmd);
+ if (!result) {
+ DbgErr("Swich function set (CMD6) failed.\n");
+ goto exit;
+ }
+
+ tuning_type =
+ hostven_tuning_type_selection(host,
+ card_info->sw_cur_setting.sd_access_mode);
+
+ /* 5.3 Tuning Procedure (for DDR200, SDR104 and SDR50 Only) */
+ if (card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_SDR104
+ || card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_SDR50
+ || card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_DDR200) {
+ switch (tuning_type) {
+ case 0:
+ hostven_fix_output_tuning(host,
+ card_info->sw_cur_setting.sd_access_mode);
+ break;
+ case 1:
+ hostven_fix_output_tuning(host,
+ card_info->sw_cur_setting.sd_access_mode);
+ result = sd_tuning(card, &sd_cmd, 0);
+ if (!result) {
+ DbgErr("Tuning (CMD19) failed.\n");
+ goto exit;
+ }
+ break;
+ case 2:
+ result =
+ card_output_tuning(card,
+ card->sec_count -
+ TUNING_ADDRESS_OFFSET);
+ if (!result) {
+ DbgErr("card_output_tuning failed.\n");
+ card->restore_tuning_content_fail = 1;
+ goto exit;
+ }
+
+ if (card->read_signal_block_flag) {
+ result =
+ restore_tuning_address_content(card,
+ card->sec_count
+ -
+ TUNING_ADDRESS_OFFSET);
+ if (!result) {
+ DbgErr
+ ("restore_tuning_address_content failed\n");
+ card->restore_tuning_content_fail
+ = 1;
+ goto exit;
+ }
+ } else {
+ erase_rw_blk_start_set(card, &sd_cmd,
+ (u32)
+ (card->sec_count)
+ -
+ TUNING_ADDRESS_OFFSET);
+ erase_rw_blk_end_set(card, &sd_cmd,
+ ((u32)
+ (card->sec_count)
+ -
+ TUNING_ADDRESS_OFFSET)
+ + 1);
+ func_erase(card, &sd_cmd);
+ }
+
+ break;
+ default:
+ break;
+ }
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Tuning Procedure Done. Access Mode=%d.\n",
+ card_info->sw_cur_setting.sd_access_mode);
+ }
+
+ }
+exit:
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(%d) %s\n",
+ result, __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: sd_legacy_init
+ *
+ * Abstract:
+ *
+ * 1. sd legacy card (uhs1, legacy) initialize main function.
+ * 2. Fill virtual card structure, like cid, csd, etc.
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller: card_init
+ */
+
+bool sd_legacy_init(sd_card_t *card)
+{
+ bool result = FALSE;
+ sd_host_t *host = card->host;
+
+ card->uhs2_card = FALSE;
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (shift_bit_func_enable(host))
+ set_pattern_value(host, 0x10);
+
+ host_sd_init(host);
+
+ /* SD Card Identification */
+ result = sd_card_identify(card);
+ if (!result) {
+ DbgErr("SD Card Identification Stage failed.\n");
+ goto error_exit;
+ }
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Card Identification Stage OK.\n");
+
+ /* SD Card Select and lock/unlock check */
+ result = sd_card_select(card);
+ if (!result) {
+ DbgErr("SD Card Select failed.\n");
+ goto error_exit;
+ }
+
+ if (card->locked == TRUE) {
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Card is Locked.\n");
+ goto next;
+ }
+
+ result = card_init_stage2(card);
+ if (!result) {
+ DbgErr("SD init stage 2 failed.\n");
+ goto error_exit;
+ }
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Card Init Stage 2 OK.\n");
+
+next:
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit(OK) %s\n",
+ __func__);
+ return result;
+
+error_exit:
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit(FAIL) %s\n", __func__);
+ return result;
+}
+
+static byte sd_get_lower_am(sd_card_t *card, byte access_mode)
+{
+ cfg_item_t *cfg = card->host->cfg;
+ byte lower_am = 0;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT | FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM, "Enter %s, access_mode=%d\n", __func__,
+ access_mode);
+
+ /* Degrade access mode according to current access mode. */
+ switch (access_mode) {
+ case SD_FNC_AM_DDR200:
+ lower_am =
+ card_get_min_am((byte) cfg->card_item.test_max_access_mode.value,
+ (byte) card_get_max_am_cap(card));
+ break;
+ case SD_FNC_AM_SDR104:
+ /* Degrade to SDR50 directly */
+ lower_am = SD_FNC_AM_SDR50;
+ break;
+ case SD_FNC_AM_SDR50:
+ if ((cfg->card_item.test_max_access_mode.value == SD_FNC_AM_DDR50)
+ && (card->info.sw_func_cap.sd_access_mode &
+ (1 << SD_FNC_AM_DDR50))) {
+ /*
+ * Max Access mode is DDR50 and card support DD50,
+ * then can be degrade to DDR50
+ */
+ lower_am = SD_FNC_AM_DDR50;
+ } else {
+ /* Degrade to High Speed */
+ lower_am = SD_FNC_AM_HS;
+ }
+ break;
+ case SD_FNC_AM_DDR50:
+ /* Degrade to High Speed directly */
+ lower_am = SD_FNC_AM_HS;
+ break;
+ case SD_FNC_AM_HS:
+ /* Degrade to Default Speed directly */
+ lower_am = SD_FNC_AM_DS;
+ break;
+ default:
+ lower_am = SD_FNC_AM_DS;
+ break;
+ }
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT | FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM, "Exit(%d) %s\n", lower_am, __func__);
+ return lower_am;
+}
+
+static byte sd_get_higher_am(sd_card_t *card, byte access_mode)
+{
+ cfg_item_t *cfg = card->host->cfg;
+ byte higher_am = 0;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT | FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM, "Enter %s, access_mode=%d\n", __func__,
+ access_mode);
+
+ /* get higher access mode. */
+ switch (access_mode) {
+ case SD_FNC_AM_DDR200:
+ higher_am = SD_FNC_AM_DDR200;
+ break;
+ case SD_FNC_AM_SDR104:
+ /* Keep SDR104 */
+ if (sd_ddr_support(card)
+ && (cfg->card_item.test_max_access_mode.value ==
+ SD_FNC_AM_SDR104))
+ higher_am = SD_FNC_AM_DDR200;
+ else
+ higher_am = SD_FNC_AM_SDR104;
+
+ break;
+ case SD_FNC_AM_SDR50:
+ if ((cfg->card_item.test_max_access_mode.value ==
+ SD_FNC_AM_SDR104)
+ && card->info.sw_func_cap.sd_access_mode &
+ (1 << SD_FNC_AM_SDR104)) {
+ /* SDR104 */
+ higher_am = SD_FNC_AM_SDR104;
+ } else {
+ /* SDR50 */
+ higher_am = SD_FNC_AM_SDR50;
+ }
+ break;
+ case SD_FNC_AM_DDR50:
+ /* Degrade to High Speed directly */
+ if ((cfg->card_item.test_max_access_mode.value ==
+ SD_FNC_AM_SDR50)
+ && card->info.sw_func_cap.sd_access_mode &
+ (1 << SD_FNC_AM_SDR50)) {
+ /* SDR50 is higher level access mode of DDR50 */
+ higher_am = SD_FNC_AM_SDR50;
+ } else {
+ /* No change */
+ higher_am = SD_FNC_AM_DDR50;
+ }
+ break;
+ case SD_FNC_AM_HS:
+ /* Degrade to Default Speed directly */
+ if ((cfg->card_item.test_max_access_mode.value ==
+ SD_FNC_AM_DDR50)
+ && card->info.sw_func_cap.sd_access_mode &
+ (1 << SD_FNC_AM_DDR50)) {
+ /* DDR50 supported, then it is higher level access mode of High Speed. */
+ higher_am = SD_FNC_AM_DDR50;
+ } else if ((cfg->card_item.test_max_access_mode.value ==
+ SD_FNC_AM_SDR50)
+ && card->info.sw_func_cap.sd_access_mode &
+ (1 << SD_FNC_AM_SDR50)) {
+ /*
+ * DDR50 do not supported,
+ * then SDR50 is the higher level access mode of High Speed.
+ */
+ higher_am = SD_FNC_AM_SDR50;
+ } else {
+ /* No change */
+ higher_am = SD_FNC_AM_HS;
+ }
+ break;
+ case SD_FNC_AM_DS:
+ if ((cfg->card_item.test_max_access_mode.value == SD_FNC_AM_HS)
+ && card->info.sw_func_cap.sd_access_mode &
+ (1 << SD_FNC_AM_HS)) {
+ /* High Speed is the higher level access mode of Default Speed. */
+ higher_am = SD_FNC_AM_HS;
+ } else {
+ /* No change */
+ higher_am = SD_FNC_AM_DS;
+ }
+ break;
+ default:
+ break;
+ }
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_CARD_INIT | FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM, "Exit(%d) %s\n", higher_am, __func__);
+ return higher_am;
+}
+
+/*
+ * Function Name: sd_degrade_policy
+ *
+ * Abstract: This Function is used set sd degrade flag
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+
+ * Return value:
+ */
+void sd_degrade_policy(sd_card_t *card)
+{
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ if (card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_SDR50 ||
+ card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_SDR104 ||
+ card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_DDR200) {
+ /* If Access Mode >= SDR50, then try to degrade freq first */
+ if (card->degrade_freq_level < CARD_DEGRADE_FREQ_TIMES) {
+ /* Degrade freq less than 3 times, continue to degrade freq */
+ card->degrade_freq_level++;
+ } else {
+ /* As degrade mode is needed, clear the degrade freq level. */
+ card->degrade_freq_level = 0;
+
+ /* Degrade freq larger than 3 times, then degrade accessmode */
+ card->sw_target_setting.sd_access_mode =
+ sd_get_lower_am(card,
+ card->sw_target_setting.sd_access_mode);
+ /* If Degrade to Default Speed already. Mark as degrade final */
+ if (card->sw_target_setting.sd_access_mode ==
+ SD_FNC_AM_DS) {
+ card->degrade_final = 1;
+ }
+ }
+ } else {
+ /* As degrade mode is needed, clear the degrade freq level. */
+ card->degrade_freq_level = 0;
+
+ /* If Access Mode < SDR50, then degrade access mode directly */
+ card->sw_target_setting.sd_access_mode =
+ sd_get_lower_am(card,
+ card->sw_target_setting.sd_access_mode);
+ /* If Degrade to Default Speed already. Mark as degrade final */
+ if (card->sw_target_setting.sd_access_mode == SD_FNC_AM_DS)
+ card->degrade_final = 1;
+
+ }
+
+ DbgErr("Legacy SD degrade target=%d freq_level=%d final=%d\n",
+ card->sw_target_setting.sd_access_mode, card->degrade_freq_level,
+ card->degrade_final);
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+}
+
+/*
+ * Function Name: uhs2_thermal_control
+ * Abstract: This Function is used to do card thremal control, only for SD and UHS2 card
+ *
+ * Input:
+ * sd_card_t *card
+ *
+ * Return value:
+ * TRUE: means ok
+ * others means error occur, caller need do error recovery
+ *
+ * Notes:
+ * run in thread context
+ */
+
+bool sd_thermal_control(sd_card_t *card)
+{
+ bool bheat = (bool)card->thermal_heat;
+ sd_command_t sd_cmd;
+ bool result = TRUE;
+ bool change_am = FALSE;
+ byte am = 0;
+ bool bchg = FALSE;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_FUNC_THERMAL, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* 2.0 Card don't do thermal control */
+ if (card->info.card_s18a == 0
+ || card->host->cfg->card_item.sd_card_mode_dis.dis_sd30_card)
+ goto exit;
+
+ if (bheat) {
+ am = sd_get_higher_am(card,
+ card->info.sw_cur_setting.sd_access_mode);
+ } else {
+ am = sd_get_lower_am(card,
+ card->info.sw_cur_setting.sd_access_mode);
+ }
+
+ /* If one access mode need tuning and another don't need we can't change */
+ if (am == card->info.sw_cur_setting.sd_access_mode) {
+ change_am = FALSE;
+ } else if (am == SD_FNC_AM_SDR50 || am == SD_FNC_AM_SDR104
+ || am == SD_FNC_AM_DDR200) {
+ if (card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_SDR50
+ || card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_DDR200
+ || card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_SDR104)
+ change_am = TRUE;
+ else if (am != SD_FNC_AM_SDR50 && am != SD_FNC_AM_SDR104
+ && am != SD_FNC_AM_DDR200)
+ if (card->info.sw_cur_setting.sd_access_mode !=
+ SD_FNC_AM_SDR50
+ && card->info.sw_cur_setting.sd_access_mode !=
+ SD_FNC_AM_SDR104
+ && card->info.sw_cur_setting.sd_access_mode !=
+ SD_FNC_AM_DDR200)
+ change_am = TRUE;
+ }
+/* next: */
+ if (change_am) {
+ card->thermal_access_mode = am;
+ DbgInfo(MODULE_SD_CARD, FEATURE_FUNC_THERMAL, NOT_TO_RAM,
+ "thermal switch am = %d\n", am);
+ result = card_stop_infinite(card, TRUE, NULL);
+ if (result == FALSE) {
+ DbgErr("uhs2 Thermal Stop Infinite failed1\n");
+ goto exit;
+ }
+
+ result = sd_switch_access_mode(card, &sd_cmd, &bchg);
+ if (result == FALSE)
+ goto exit;
+
+ if (card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_SDR104
+ || card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_SDR50
+ || card->info.sw_cur_setting.sd_access_mode ==
+ SD_FNC_AM_DDR200) {
+
+ if (bchg)
+ result = sd_tuning(card, &sd_cmd, 0);
+ if (!result) {
+ DbgErr("Tuning failed for thermal control.\n");
+ goto exit;
+ }
+ }
+ }
+
+ if (bchg == FALSE) {
+ DbgInfo(MODULE_SD_CARD, FEATURE_FUNC_THERMAL, NOT_TO_RAM,
+ "thermal switch pm heatup = %d\n", card->thermal_heat);
+ result = card_stop_infinite(card, TRUE, NULL);
+ if (result == FALSE) {
+ DbgErr("uhs2 Thermal Stop Infinite failed1\n");
+ goto exit;
+ }
+ result = sd_switch_power_limit(card, &sd_cmd, &bchg);
+ }
+
+ if (result == TRUE && bchg)
+ host_cmddat_line_reset(card->host);
+
+exit:
+ DbgInfo(MODULE_SD_CARD, FEATURE_FUNC_THERMAL, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+ return result;
+
+}
+
+static u8 sd_adjust_tuning(sd_card_t *card, u32 input_n1, u32 output_n1)
+{
+ u8 result = TRUE;
+ sd_command_t sd_cmd;
+ sd_host_t *host = card->host;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ hostven_set_tuning_phase(host, input_n1, output_n1, FALSE);
+
+ if (card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_SDR104 ||
+ card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_SDR50 ||
+ card->info.sw_cur_setting.sd_access_mode == SD_FNC_AM_DDR200) {
+
+ result = sd_tuning(card, &sd_cmd, 150);
+ if (result == FALSE) {
+ DbgErr("sd adjust tuning: sd_tuning fail\n");
+ result = FALSE;
+ goto exit;
+ }
+ }
+
+exit:
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+ return result;
+}
+
+static void sd_calc_max_passrange(u8 *pdata, u32 *ret, u32 *sum)
+{
+ u32 window_pass_number[22], window_start_adr[22],
+ window_pass_number_max;
+ int ii, jj, first_0, dll_i_mod, dll_i, dll_mod;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ for (ii = 0; ii < 22; ii++) {
+ window_pass_number[ii] = 0;
+ window_start_adr[ii] = 0;
+ }
+
+ first_0 = 0;
+ window_pass_number_max = 0;
+ for (dll_i = 0; dll_i < 22; dll_i++) {
+ if (pdata[dll_i] == 0) {
+ first_0 = dll_i;
+ break;
+ }
+ }
+ jj = 0;
+ for (dll_i = 0; dll_i < 22; dll_i++) {
+ dll_i_mod = (first_0 + dll_i) % 22;
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "DLL phase [%x] result %d.\n", dll_i_mod,
+ pdata[dll_i_mod]);
+ if (pdata[dll_i_mod] != 0)
+ window_pass_number[jj]++;
+ else {
+ if (window_pass_number[jj] > 0)
+ jj++;
+
+ }
+ if ((window_pass_number[jj] == 1) && (jj > 0)) {
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM, "Error! there are %d DLL window\n",
+ (jj + 1));
+ }
+ if (window_pass_number[jj] == 1)
+ window_start_adr[jj] = dll_i_mod;
+ }
+
+ for (ii = 0; ii < 22; ii++) {
+ if (window_pass_number_max < window_pass_number[ii]) {
+ window_pass_number_max = window_pass_number[ii];
+ jj = ii;
+ }
+ }
+ if (window_pass_number_max == 0)
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "DLL test result: All DLL test FAIL\n");
+ else {
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "DLL test result: Total %d DLL test PASS\n",
+ window_pass_number_max);
+ window_pass_number_max = window_pass_number_max >> 1;
+ dll_mod = window_start_adr[jj] + window_pass_number_max;
+ dll_mod = dll_mod % 22;
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "select DLL phase Number %d\n", dll_mod);
+ }
+ *ret = dll_mod;
+ *sum = window_pass_number_max;
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+}
+
+/* The caller check */
+u8 testbuf_write[512];
+u8 testbuf_read[512];
+
+bool sd_dll_divider(sd_card_t *card, sd_command_t *pcmd)
+{
+
+ u32 ii, jj, pattern_i;
+ bool ret = FALSE, result = FALSE, datcmp;
+
+ u32 window_pass_sum, dll_i, input_n1, output_n1, input_n, output_n,
+ DLL_input_Phase = 0, DLL_output_Phase = 0;
+ sd_command_t sd_cmd;
+ byte test_patern[6] = { 0x55, 0xaa, 0x00, 0xff, 0xf0, 0x0f };
+ u32 cmdflag;
+ sd_host_t *host = card->host;
+ u8 phasecheck[22][22], phasepass[22];
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ host->output_tuning.start_block = pcmd->argument;
+
+ /* If use read write, Save Current DMA mode */
+ host_transfer_init(host, FALSE, TRUE);
+ cmdflag = CMD_FLG_RESCHK | CMD_FLG_R1 | CMD_FLG_ADMA_SDMA;
+ jj = 0;
+ host_cmddat_line_reset(host);
+ for (dll_i = 0; dll_i < 512; dll_i++)
+ testbuf_write[dll_i] = test_patern[dll_i % 6];
+ if (card_check_rw_ready(card, &sd_cmd, 600) != TRUE) {
+ DbgErr
+ ("Error when sd dll divider, card_check_rw_ready fail\n");
+ result = FALSE;
+ goto exit;
+ }
+
+ if (hostven_dll_input_tuning_init(host) == FALSE) {
+ DbgErr
+ ("Error when sd dll divider, hostven_dll_input_tuning_init fail\n");
+ result = FALSE;
+ goto exit;
+ }
+
+ for (output_n1 = 0; output_n1 < 22; output_n1++)
+ for (input_n1 = 0; input_n1 < 22; input_n1++) {
+
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM,
+ " - DLL input tuning Test %d , %d\n", input_n1,
+ output_n1);
+ phasecheck[output_n1][input_n1] = 0;
+ phasepass[output_n1] = 0;
+ host_cmddat_line_reset(host);
+
+ if (sd_adjust_tuning(card, input_n1, output_n1) ==
+ FALSE) {
+ DbgErr
+ (" -adjust Output Tuning phase FAILED!!!\n");
+
+ continue;
+ }
+ for (pattern_i = 0; pattern_i < 1; pattern_i++) {
+ for (ii = 0; ii < (1 * 512); ii++)
+ (*(testbuf_read + ii)) = 0x96;
+
+ ret =
+ card_send_sdcmd_timeout(card, &sd_cmd,
+ SD_CMD24,
+ host->output_tuning.start_block,
+ (cmdflag),
+ DATA_DIR_OUT,
+ testbuf_write, 512,
+ 50);
+ if (ret == FALSE)
+ break;
+ ret =
+ card_send_sdcmd_timeout(card, &sd_cmd,
+ SD_CMD17,
+ host->output_tuning.start_block,
+ (cmdflag),
+ DATA_DIR_IN,
+ testbuf_read, 512,
+ 50);
+ if (ret == FALSE) {
+ DbgErr
+ ("Read data FAILED when output_tuning\n");
+
+ break;
+ }
+
+ datcmp = TRUE;
+ for (ii = 0; ii < (1 * 512); ii++) {
+ if (*(testbuf_write + ii) !=
+ *(testbuf_read + ii)) {
+ datcmp = FALSE;
+ phasecheck[output_n1][input_n1]
+ = 0;
+ break;
+ }
+ }
+ if (datcmp == FALSE) {
+ DbgInfo(MODULE_SD_CARD,
+ FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM,
+ "Compare data FAILED at index %d!!!\n",
+ ii);
+ } else {
+ DbgInfo(MODULE_SD_CARD,
+ FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM,
+ "Compare data OK.\n");
+ phasecheck[output_n1][input_n1] = 1;
+ }
+ }
+ }
+
+ for (output_n = 0; output_n < 22; output_n++) {
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ " ## The output tuning %d: ", output_n);
+ for (input_n = 0; input_n < 22; input_n++)
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER,
+ NOT_TO_RAM, " %d: %d ", input_n,
+ phasecheck[output_n][input_n]);
+ }
+
+ for (output_n = 0; output_n < 22; output_n++) {
+ for (input_n = 0; input_n < 22; input_n++)
+ phasepass[output_n] += phasecheck[output_n][input_n];
+ }
+
+ /* check for the max pass range */
+ sd_calc_max_passrange(phasepass, &DLL_output_Phase, &window_pass_sum);
+ sd_calc_max_passrange(phasecheck[DLL_output_Phase], &DLL_input_Phase,
+ &window_pass_sum);
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "The best input tuning phase is %d\n", DLL_input_Phase);
+ /* Get the optimized clock phase to do read/write test */
+ hostven_set_tuning_phase(host, DLL_input_Phase, DLL_output_Phase,
+ FALSE);
+ result = TRUE;
+
+exit:
+ /* Resorte current DMA mode */
+ host_transfer_init(host, card->inf_trans_enable, FALSE);
+ if (result == FALSE)
+ hostven_set_tuning_phase(host, 0, 0, TRUE);
+ host_cmddat_line_reset(host);
+ DbgInfo(MODULE_SD_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+ return result;
+}
+
+/*
+ *
+ * Function Name: sd_read_csd
+ *
+ * Abstract:
+ *
+ * 1. De-select the card and send CMD9, and then select the card.
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller:
+ */
+bool sd_read_csd(sd_card_t *card, sd_command_t *sd_cmd, byte *data)
+{
+ card_info_t *card_info = &(card->info);
+ bool ret = FALSE, ret1 = FALSE, ret2 = FALSE;
+
+ ret = card_deselect_card(card, sd_cmd);
+ if (!ret)
+ goto exit_select_card;
+
+ ret1 = card_get_csd(card, sd_cmd);
+
+exit_select_card:
+ ret2 = card_select_card(card, sd_cmd);
+
+ if ((ret == FALSE) || (ret1 == FALSE) || (ret2 == FALSE))
+ return FALSE;
+ else {
+ os_memcpy(data, &(card_info->raw_csd[0]), 0x10);
+ return TRUE;
+ }
+}
+
+/*
+ *
+ * Function Name: sd_program_csd
+ *
+ * Abstract:
+ *
+ * 1. Program CSD by CMD27.
+ *
+ * Input:
+ *
+ * sd_card_t *card [in] [out]: Pointer to the virtual card structure
+ * sd_command_t *sd_cmd: Pointer to sd command structure
+ *
+ * Output:
+ *
+ * None
+ *
+ * Return value:
+ *
+ * Return TRUE if card init successfully, else return FALSE.
+ *
+ * Notes:
+ *
+ * Caller:
+ */
+bool sd_program_csd(sd_card_t *card, sd_command_t *sd_cmd, byte *data)
+{
+
+ byte cmd_index = SD_CMD27;
+ u32 argument = 0;
+ u32 cmdflag = CMD_FLG_R1 | CMD_FLG_RESCHK;
+ e_data_dir dir = DATA_DIR_OUT;
+ u32 datalen = 0x10;
+ sd_host_t *host = card->host;
+ bool ret = FALSE;
+
+ ret =
+ card_send_sdcmd(card, sd_cmd, cmd_index, argument, cmdflag, dir,
+ data, datalen);
+ if (ret == FALSE)
+ DbgErr("CMD27 failed\n");
+
+ host_cmddat_line_reset(host);
+
+ DbgInfo(MODULE_ALL_CARD, FEATURE_RW_TRACE, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, ret);
+ return ret;
+
+}
diff --git a/drivers/scsi/bht/card/thermal.c b/drivers/scsi/bht/card/thermal.c
new file mode 100644
index 000000000000..bda251476944
--- /dev/null
+++ b/drivers/scsi/bht/card/thermal.c
@@ -0,0 +1,348 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2014 BHT Inc.
+ *
+ * File Name: thermal.c
+ *
+ * Abstract: This File is used to handle thread event
+ *
+ * Version: 1.00
+ *
+ * Author: Peter.Guo
+ *
+ * Environment: OS Independent
+ *
+ * History:
+ *
+ * 11/05/2014 Creation Peter.Guo
+ */
+
+#include "../include/basic.h"
+#include "../include/card.h"
+#include "../include/function.h"
+#include "../include/cardapi.h"
+#include "cardcommon.h"
+#include "../include/hostapi.h"
+#include "../include/util.h"
+#include "../include/debug.h"
+
+/*
+ * Function Name: thermal_gpio_sensor
+ * Abstract: This Function is used to do get sensor result for thermal control
+ *
+ * Input:
+ * sd_host_t *host
+ *
+ * Return value:
+ * NORMAL
+ * COOL
+ * HOT
+ *
+ * Notes:
+ * run in thread context
+ */
+
+static e_thermal_val thermal_gpio_sensor(sd_host_t *host)
+{
+ e_thermal_val result = THERMAL_NORMAL;
+ u32 value = 0;
+
+ DbgInfo(MODULE_THERMAL, FEATURE_FUNC_THERMAL, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ switch (host->chip_type) {
+ case CHIP_SEAEAGLE:
+ ven_and32(host, 0x22c, ~0x7);
+ ven_or32(host, 0x22c, 0x13);
+ value = ven_readl(host, 0x22c);
+ value = (value & 0x40) >> 6;
+ break;
+ case CHIP_SEAEAGLE2:
+ case CHIP_GG8:
+ case CHIP_ALBATROSS:
+ ven_and32(host, 0x50c, ~0x7);
+ ven_or32(host, 0x50c, 0x13);
+ value = ven_readl(host, 0x50c);
+ value = (value & 0x40) >> 6;
+ break;
+ default:
+ value = pci_readl(host, 0xD4);
+ value = (value & 0x80) >> 7;
+ break;
+ }
+
+ result = (e_thermal_val) value;
+
+ DbgInfo(MODULE_THERMAL, FEATURE_FUNC_THERMAL, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, value);
+ return result;
+
+}
+
+/*
+ * Function Name: thermal_i2c_sensor
+ * Abstract: This Function is used to do get sensor result for thermal control
+ *
+ * Input:
+ * sd_host_t *host
+ *
+ * Return value:
+ * NORMAL
+ * COOL
+ * HOT
+ *
+ * Notes:
+ * run in thread context
+ */
+
+static e_thermal_val thermal_i2c_sensor(sd_host_t *host)
+{
+ u32 temp_val = 0, count = 0;
+ u32 upper_limit = 0, lower_limit = 0;
+ e_thermal_val result = THERMAL_NORMAL;
+
+ DbgInfo(MODULE_THERMAL, FEATURE_FUNC_THERMAL, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Enable I2C I/F */
+ ven_and32(host, 0x228, ~0x7);
+ ven_or32(host, 0x228, 0x1);
+ ven_and32(host, 0x230, ~0x7);
+ ven_or32(host, 0x230, 0x1);
+ os_mdelay(1);
+
+ /* Reset I2C function */
+ ven_writel(host, 0x220, 0x80000000);
+
+ os_mdelay(1);
+
+ /* Set FLTR and One short bit */
+ ven_writel(host, 0x220, 0x440000);
+ ven_writel(host, 0x220, 0x20009401);
+
+ while ((ven_readl(host, 0x220) & 0x20000000)) {
+ /* Timeout 5ms */
+ if (count == 5) {
+ DbgErr(" - Wait I2C write operation timeout!\n");
+ break;
+ }
+ /* else if (device_status == DEVICE_STATUS_CHIPLOST) */
+ else if (ven_readl(host, 0x220) == 0xffffffff) {
+ DbgErr("break loop because chip lost!\n");
+ break;
+ }
+
+ os_mdelay(1);
+ count += 1;
+ }
+
+ /* Read the temperature value */
+ ven_writel(host, 0x220, 0x50009400);
+
+ while ((ven_readl(host, 0x220) & 0x10000000)) {
+ /* Timeout 5ms */
+ if (count == 5) {
+ DbgErr(" - Wait I2C read operation timeout!\n");
+ break;
+ }
+ /* else if (device_status == DEVICE_STATUS_CHIPLOST) */
+ else if (ven_readl(host, 0x220) == 0xffffffff) {
+ DbgErr("break loop because chip lost!!\n");
+ break;
+ }
+ os_mdelay(1);
+ count += 1;
+ }
+
+ temp_val = (ven_readl(host, 0x224) & 0xffff) >> 6;
+ /* upper_limit = (tmp_high & 0xffff0000) >> 16; */
+ /* lower_limit = tmp_low & 0xffff; */
+
+ if ((temp_val & 0x200) && (upper_limit & 0x8000)) {
+ if ((temp_val & 0x1ff) < ((upper_limit & 0x1ff) << 2)) {
+ result = THERMAL_HOT;
+ goto exit;
+ }
+ }
+
+ if ((0 == (temp_val & 0x200)) && (upper_limit & 0x8000)) {
+ result = THERMAL_HOT;
+ goto exit;
+ }
+
+ if ((0 == (temp_val & 0x200)) && (0 == (upper_limit & 0x8000))) {
+ if ((temp_val & 0x1ff) > ((upper_limit & 0x1ff) << 2)) {
+ result = THERMAL_HOT;
+ goto exit;
+ }
+ }
+
+ if ((temp_val & 0x200) && (lower_limit & 0x8000)) {
+ if ((temp_val & 0x1ff) > ((lower_limit & 0x1ff) << 2)) {
+ result = THERMAL_COOL;
+ goto exit;
+ }
+ }
+
+ if ((temp_val & 0x200) && (0 == (lower_limit & 0x8000))) {
+ result = THERMAL_COOL;
+ goto exit;
+ }
+
+ if ((0 == (temp_val & 0x200)) && (0 == (lower_limit & 0x8000))) {
+ if ((temp_val & 0x1ff) < ((lower_limit & 0x1ff) << 2)) {
+ result = THERMAL_COOL;
+ goto exit;
+ }
+ }
+
+exit:
+ DbgInfo(MODULE_THERMAL, FEATURE_FUNC_THERMAL, NOT_TO_RAM,
+ "Exit %s result=%d\n", __func__, result);
+ return result;
+
+}
+
+/*
+ * Function Name: func_thermal_control
+ * Abstract: This Function is used to do thremal control
+ * This function should be called before send card Read Write
+ *
+ * Input:
+ * sd_card_t *card
+ *
+ * Return value:
+ * TRUE: means ok
+ * others means error occur, caller need do error recovery
+ *
+ * Notes:
+ * run in thread context
+ */
+
+bool func_thermal_control(sd_card_t *card)
+{
+ sd_host_t *host = card->host;
+ bht_dev_ext_t *pdx = host->pdx;
+ bool result = TRUE;
+ e_thermal_val thermal = THERMAL_NORMAL;
+
+ DbgInfo(MODULE_THERMAL, FEATURE_FUNC_THERMAL, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* If Thermal Control is disabled then do nothing */
+ if (pdx->thermal.enable == 0)
+ goto exit;
+
+ /* If Thermal timeout is not occur then do nothing */
+ if (pdx->thermal.enable_timer_chk == 1 && pdx->thermal.timeout == 0)
+ goto exit;
+
+ pdx->thermal.timeout = 0;
+ pdx->thermal.last_check_ms = os_get_cur_tick();
+
+ /* If card not working do nothing */
+ if (card->state != CARD_STATE_WORKING || card->card_present == FALSE)
+ goto exit;
+
+ if (card->initialized_once == FALSE)
+ goto exit;
+
+ /* Currently only uhs2 and SD support thermal control */
+ switch (card->card_type) {
+ case CARD_SD:
+ case CARD_UHS2:
+ break;
+ default:
+ goto exit;
+ }
+
+ if (pdx->thermal.use_i2c)
+ thermal = thermal_i2c_sensor(host);
+ else
+ thermal = thermal_gpio_sensor(host);
+
+ DbgInfo(MODULE_THERMAL, FEATURE_FUNC_THERMAL, NOT_TO_RAM,
+ "Start do Thermal control sensor=%d\n", thermal);
+
+ if (thermal == THERMAL_NORMAL) {
+ /* nothing to do for no thermal change */
+ goto exit;
+ } else if (thermal == THERMAL_COOL) {
+ /* NEED change to higher mode */
+ pdx->card.thermal_enable = 1;
+ pdx->card.thermal_heat = 1;
+ result = card_thermal_control(card);
+ } else {
+ /* change to lower mode */
+ pdx->card.thermal_enable = 1;
+ pdx->card.thermal_heat = 0;
+ result = card_thermal_control(card);
+ }
+
+ pdx->card.thermal_enable = 0;
+
+exit:
+ DbgInfo(MODULE_THERMAL, FEATURE_FUNC_THERMAL, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, result);
+ return result;
+}
+
+/*
+ * Function Name: func_thermal_control
+ * Abstract: This Function is used to update thermal control time
+ * This function should be called before send card Read Write
+ *
+ * Input:
+ * sd_card_t *card
+ *
+ * Return value:
+ * TRUE: means ok
+ * others means error occur, caller need do error recovery
+ *
+ * Notes:
+ */
+
+void func_thermal_update_time(bht_dev_ext_t *pdx)
+{
+ /* If time check for thermal contorl is not enable do nothing */
+ if (pdx->thermal.enable == 0 || pdx->thermal.enable_timer_chk == 0)
+ return;
+
+ if (pdx->card.state != CARD_STATE_WORKING
+ || pdx->card.card_present == FALSE)
+ return;
+
+ if (pdx->card.initialized_once == FALSE)
+ return;
+
+ if (pdx->thermal.timeout == 0) {
+ pdx->thermal.timeout =
+ (os_get_cur_tick() >
+ (pdx->thermal.last_check_ms +
+ pdx->thermal.check_period_ms)) ? 1 : 0;
+ }
+
+}
+
+void thermal_init(bht_dev_ext_t *pdx)
+{
+ pdx->thermal.enable = 0;
+ if (pdx->thermal.enable == 0)
+ return;
+ pdx->thermal.use_i2c = 0;
+ pdx->thermal.last_check_ms = os_get_cur_tick();
+ pdx->thermal.enable_timer_chk = 0;
+ pdx->thermal.check_period_ms = 0;
+ DbgInfo(MODULE_THERMAL, FEATURE_DRIVER_INIT, NOT_TO_RAM,
+ "thermal enable=%d i2c=%d timechk=%dms chkperiod=%dms\n",
+ pdx->thermal.enable, pdx->thermal.use_i2c,
+ pdx->thermal.enable_timer_chk, pdx->thermal.check_period_ms);
+
+}
+
+void thermal_uninit(bht_dev_ext_t *pdx)
+{
+ if (pdx->thermal.enable == 0)
+ return;
+ pdx->thermal.last_check_ms = os_get_cur_tick();
+}
diff --git a/drivers/scsi/bht/card/uhs2.c b/drivers/scsi/bht/card/uhs2.c
new file mode 100644
index 000000000000..6f9511b5d33d
--- /dev/null
+++ b/drivers/scsi/bht/card/uhs2.c
@@ -0,0 +1,1228 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2014 BHT Inc.
+ *
+ * File Name: uhs2.c
+ *
+ * Abstract: SD UHS2 card initialization
+ *
+ * Version: 1.00
+ *
+ * Author: peter.guo
+ *
+ * Environment: OS Independent
+ *
+ * History:
+ *
+ * 10/10/2014 Creation Peter.Guo
+ */
+
+#include "../include/basic.h"
+#include "../include/cmdhandler.h"
+#include "../include/cardapi.h"
+#include "../include/hostapi.h"
+#include "cardcommon.h"
+#include "../include/util.h"
+#include "../include/debug.h"
+
+#define UHS2_DEVINIT_CF 0x00000800
+#define UHS2_DEVINIT_GAP 0x0000000F
+#define UHS2_ENUM_PLD 0x00000000
+#define UHS2_GODRM_HBNEN 0x00000080
+#define UHS2_ENMR_IDF 0x000000F0
+#define UHS2_ENMR_IDL 0x0000000F
+
+#define UHS2_LANES_2L_HD 0x00
+#define UHS2_LANES_2D1UFD 0x02
+#define UHS2_LANES_1D2UFD 0x03
+#define UHS2_LANES_2D2UFD 0x04
+
+#define UHS2_UNRECOVER_ERROR (BIT0 | BIT2 | BIT7)
+
+static inline bool uhs2_is_uncoverable(sd_command_t *sd_cmd)
+{
+ if ((sd_cmd->err.error_code == ERR_CODE_TIMEOUT) ||
+ (sd_cmd->err.uhs2_err_reg & UHS2_UNRECOVER_ERROR))
+ return TRUE;
+ else
+ return FALSE;
+}
+
+/*
+ * Function Name: uhs2_access_reg
+ *
+ * Abstract: This Function is used to send uhs2 ccmd
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd: This parameter will contail card command info
+ * byte ioaddr: ioaddr for uhs2 ccmd
+ * bool broadcast: use broadcast or not
+ * bool rwcmd: Set RW flag in uhs2 header or not
+ * byte payload_num: payload count
+ *
+ * Input & Output:
+ * u32 *payload: contain the register want to setting,
+ * and store return regs value
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ *
+ * Notes:
+ * so giving the routine another name requires you to modify the build tools.
+ */
+
+static bool uhs2_native_ccmd_internal(sd_card_t *card, sd_command_t *sd_cmd,
+ u16 ioaddr, bool broadcast, bool rwcmd,
+ byte payload_num, u32 *payload)
+{
+ bool result = FALSE;
+ u32 headarg = UHS2_CMD_HEADER_NP;
+ int i;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARDCMD_TRACE, NOT_TO_RAM,
+ "Enter %s ioaddr=0x%04X\n", __func__, ioaddr);
+
+ /* step1 prepare header for uhs2 ccmd */
+ headarg |= UHS2_NATIVE_CCMD_IOADDR(ioaddr);
+
+ if (broadcast == FALSE)
+ headarg |= UHS2_HEADER_DID(card->uhs2_info.dev_id);
+
+ if (rwcmd)
+ headarg |= UHS2_NATIVE_HEADER_RW;
+
+ switch (payload_num) {
+ case 0:
+ break;
+ case 1:
+ headarg |= UHS2_NATIVE_CCMD_PLEN4;
+ break;
+ case 2:
+ headarg |= UHS2_NATIVE_CCMD_PLEN8;
+ break;
+ case 4:
+ headarg |= UHS2_NATIVE_CCMD_PLEN16;
+ break;
+ default:
+ DbgErr("uhs2 ccmd payload number is wrong\n");
+ goto exit;
+ }
+
+ sd_cmd->uhs2_header = headarg;
+ if (rwcmd)
+ sd_cmd->uhs2_set_pld = 1;
+
+ /* step 2 set payload */
+ sd_cmd->payload_cnt = payload_num;
+ for (i = 1; i <= payload_num; i++)
+ sd_cmd->trans_reg[0].payload[i] = payload[i - 1];
+
+ result = cmd_generate_reg(card, sd_cmd);
+ if (result == FALSE)
+ goto exit;
+
+ result = cmd_execute_sync(card, sd_cmd, NULL);
+exit:
+ if (result == FALSE)
+ DbgErr("UHS2 Native cmd failed ioaddr=0x%02X errcode=0x%08X\n",
+ UHS2_GET_NATIVE_IOADDR(sd_cmd->uhs2_header),
+ sd_cmd->err.error_code);
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARDCMD_TRACE, NOT_TO_RAM,
+ "Exit %s result=%d\n", __func__, result);
+ return result;
+}
+
+bool uhs2_native_ccmd(sd_card_t *card, sd_command_t *sd_cmd,
+ u16 ioaddr, bool broadcast, bool rwcmd, byte payload_num,
+ u32 *payload)
+{
+ os_memset(sd_cmd, 0, sizeof(sd_command_t));
+ return uhs2_native_ccmd_internal(card, sd_cmd, ioaddr, broadcast, rwcmd,
+ payload_num, payload);
+}
+
+/*
+ * Function Name: uhs2_access_reg
+ *
+ * Abstract: This Function is used to read or inquiry or set uhs2 card registers
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd: This parameter will contail card command info
+ * byte ioaddr: reg addr
+ * bool broadcast: use broadcast or not
+ * bool setcfg: set reg or read reg
+ * byte payload_num: reg count
+ *
+ * Input & Output:
+ * u32 *payload: contain the register want to setting, and store return regs value
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ *
+ * Notes:
+ * so giving the routine another name requires you to modify the build tools.
+ */
+static bool uhs2_access_reg(sd_card_t *card, sd_command_t *sd_cmd,
+ u16 ioaddr, bool broadcast, bool setcfg,
+ byte payload_num, u32 *payload)
+{
+ u32 i;
+ bool result = FALSE;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARDCMD_TRACE, NOT_TO_RAM,
+ "Enter %s ioaddr=0x%04X\n", __func__, ioaddr);
+ os_memset(sd_cmd, 0, sizeof(sd_command_t));
+ if (payload_num > 4) {
+ DbgErr("payload_num is large than 4\n");
+ goto exit;
+ }
+
+ /* set reg case and broadcast inquiry need input value */
+ if (setcfg || broadcast) {
+ for (i = 0; i < payload_num; i++)
+ payload[i] = swapu32(payload[i]);
+ sd_cmd->uhs2_set_pld = 1;
+ } else {
+ for (i = 0; i < payload_num; i++)
+ payload[i] = 0;
+ }
+
+ result =
+ uhs2_native_ccmd_internal(card, sd_cmd, ioaddr, broadcast, setcfg,
+ payload_num, payload);
+ if (result == FALSE) {
+ DbgErr
+ ("uhs2 access reg failed ioaddr=0x%02X broadcast=%d setcfg=%d\n",
+ ioaddr, broadcast, setcfg);
+ goto exit;
+ }
+
+ /* set reg case don't need get register value */
+ if (setcfg == 0) {
+ for (i = 0; i < payload_num; i++)
+ payload[i] = swapu32(sd_cmd->response[i]);
+ }
+
+exit:
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARDCMD_TRACE, NOT_TO_RAM,
+ "Exit %s result=%d\n", __func__, result);
+ return result;
+}
+
+/*
+ * Function Name: uhs2_send_fullreset
+ *
+ * Abstract: This Function is used init Send UHS2 full reset ccmd
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd,
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+bool uhs2_send_fullreset(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool result = FALSE;
+ u32 payload = 0;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Enter %s\n", __func__);
+
+ result =
+ uhs2_native_ccmd(card, sd_cmd, UHS2_IOADDR_FULLRESET, TRUE, TRUE, 0,
+ &payload);
+
+ if (result == FALSE)
+ DbgErr("uhs2 fullreset failed\n");
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s\n", __func__);
+ return result;
+}
+
+/*
+ * Function Name: uhs2_trans_abort
+ *
+ * Abstract: This Function is used init Send UHS2 transfer abort command
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd,
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+bool uhs2_trans_abort(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool result = FALSE;
+ u32 payload = 0;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Enter %s\n", __func__);
+
+ result =
+ uhs2_native_ccmd(card, sd_cmd, UHS2_IOADDR_ABORT, FALSE, TRUE, 0,
+ &payload);
+
+ if (result == FALSE)
+ DbgErr("uhs2 trans_abort failed\n");
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, result);
+ return result;
+}
+
+/*
+ * Function Name: uhs2_full_reset_card
+ *
+ * Abstract: This Function is used to send full reset command, if failed do host reset for all
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+
+bool uhs2_full_reset_card(sd_card_t *card)
+{
+ sd_command_t sd_cmd;
+ bool result = FALSE;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_ERROR_RECOVER | FEATURE_CARD_OPS,
+ NOT_TO_RAM, "Enter %s\n", __func__);
+
+ result = uhs2_send_fullreset(card, &sd_cmd);
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_ERROR_RECOVER | FEATURE_CARD_OPS,
+ NOT_TO_RAM, "uhs2 full rest ret=%d\n", result);
+ if (result) {
+ os_udelay(200);
+ host_uhs2_reset(card->host, TRUE);
+ } else {
+ /* failed do reset for all */
+ host_uhs2_clear(card->host, TRUE);
+ }
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_ERROR_RECOVER | FEATURE_CARD_OPS,
+ NOT_TO_RAM, "Exit %s ret=%d\n", __func__, result);
+
+ return result;
+}
+
+/*
+ * Function Name: uhs2_send_devinit
+ *
+ * Abstract: This Function is used init send uhs2 dev_enum ccmd and get card deviceid
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd,
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+
+bool uhs2_dev_enumeration(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool result = FALSE;
+ u32 payload = 0;
+ u8 firstid, lastid;
+ u32 resp;
+ u8 devcnt = 0;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ firstid = lastid = 0;
+ payload = UHS2_ENUM_PLD;
+
+ result =
+ uhs2_native_ccmd(card, sd_cmd, UHS2_IOADDR_ENUM, TRUE, TRUE, 1,
+ &payload);
+ if (result == FALSE)
+ goto exit;
+
+ resp = sd_cmd->response[0];
+ firstid = (u8) ((resp & UHS2_ENMR_IDF) >> 4);
+ lastid = (u8) (resp & UHS2_ENMR_IDL);
+
+ if (firstid > lastid)
+ devcnt = (lastid + 0x10) - firstid;
+ else
+ devcnt = lastid - firstid + 1;
+
+ card->uhs2_info.dev_id = firstid;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, TO_RAM,
+ "firstid=0x%02X lastid=0x%02X\n", firstid, lastid);
+
+exit:
+ if (result == FALSE)
+ DbgErr("uhs2 enumeration failed\n");
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, result);
+ return result;
+
+}
+
+/*
+ * Function Name: uhs2_send_devinit
+ *
+ * Abstract: This Function is used init send uhs2 dev_init cmd
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd,
+ * u8 gap,
+ * u8 dap,
+ *
+ * Iput & Output:
+ * u8 *gd,
+ * u8 *cf
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+
+static bool uhs2_send_devinit(sd_card_t *card, sd_command_t *sd_cmd, u8 *gd,
+ u8 gap, u8 dap, u8 *cf)
+{
+ bool result = FALSE;
+ u32 payload;
+ u32 resp;
+
+ payload =
+ UHS2_DEVINIT_CF | (((*gd) & 0xf) << 4) | (gap & 0xf) | ((dap & 0xf)
+ << 12);
+ result =
+ uhs2_native_ccmd(card, sd_cmd, UHS2_IOADDR_DEVINIT, TRUE, TRUE, 1,
+ &payload);
+ if (result == FALSE)
+ goto exit;
+
+ resp = sd_cmd->response[0];
+ if (resp & UHS2_DEVINIT_CF)
+ *cf = 1;
+ else
+ *cf = 0;
+
+ if (gap == (resp & UHS2_DEVINIT_GAP))
+ (*gd)++;
+
+exit:
+ return result;
+}
+
+/*
+ * Function Name: uhs2_devinit_flow
+ *
+ * Abstract: This Function is used do device_init flow
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd,
+ * sd_host_t *host
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+static bool uhs2_devinit_flow(sd_card_t *card, sd_command_t *sd_cmd,
+ sd_host_t *host)
+{
+ bool result = FALSE;
+ u8 gd, dap, gap, cf;
+
+ /* max 1200ms delay */
+ u32 timeout = 1200;
+ loop_wait_t wait;
+ u32 delay_us = 20;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ cf = 0;
+ gd = 0;
+ dap = host->uhs2_cap.dap;
+ gap = host->uhs2_cap.gap;
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "devinit dap=0x%02X gap=0x%02X\n", dap, gap);
+
+ util_init_waitloop(card->host->pdx, timeout, delay_us, &wait);
+
+ do {
+ result = uhs2_send_devinit(card, sd_cmd, &gd, gap, dap, &cf);
+ os_udelay(delay_us);
+
+ if (result == FALSE) {
+ DbgErr("Device Init cmd error\n");
+ goto exit;
+ }
+ } while ((util_is_timeout(&wait) == FALSE) && (cf == 0));
+
+ if (cf == 0)
+ result = FALSE;
+
+exit:
+ if (result == FALSE)
+ DbgErr("host:%p devinit failed cf=%d\n", host, cf);
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Exit %s\n",
+ __func__);
+ return result;
+
+}
+
+/*
+ * Function Name: uhs2_send_devinit
+ *
+ * Abstract: This Function is used init send uhs2 dev_enum ccmd and get card deviceid
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd,
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+
+static bool uhs2_card_get_caps(sd_card_t *card, sd_command_t *sd_cmd,
+ sd_host_t *host)
+{
+ u32 payload[2];
+ bool result = FALSE;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /*
+ * Get phy capbality for both host and card support
+ * 1. Hibernate; 2. Lss_Dir; 3. Lss_Syn
+ */
+ os_memset(payload, 0, sizeof(payload));
+ result =
+ uhs2_access_reg(card, sd_cmd, UHS2_IOADDR_PHY_CAPL, FALSE, FALSE, 2,
+ payload);
+ if (result == FALSE) {
+ DbgErr("Inquiry card phy cap failed\n");
+ goto exit;
+ }
+
+ card->uhs2_info.uhs2_cap.hibernate = (payload[0] & BIT15) ? 1 : 0;
+ card->uhs2_info.uhs2_cap.n_lss_dir = ((payload[1] & 0xF0) >> 4);
+ card->uhs2_info.uhs2_cap.n_lss_syn = ((payload[1] & 0x0F));
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "card hbr=%d lssdir=%d lsssyn=%d\n",
+ card->uhs2_info.uhs2_cap.hibernate,
+ card->uhs2_info.uhs2_cap.n_lss_dir,
+ card->uhs2_info.uhs2_cap.n_lss_syn);
+
+ /*
+ * Get Link/Tran capbality for both host and card support
+ * 1. nfcu; 2. datagap; 3. max block length
+ */
+ os_memset(payload, 0, sizeof(payload));
+ result =
+ uhs2_access_reg(card, sd_cmd, UHS2_IOADDR_LINKT_CAPL, FALSE, FALSE,
+ 2, payload);
+ if (result == FALSE) {
+ DbgErr("Inquiry card link cap failed\n");
+ goto exit;
+ }
+
+ card->uhs2_info.uhs2_cap.n_fcu = ((payload[0] & 0xFF00) >> 8);
+ card->uhs2_info.uhs2_cap.n_data_gap = ((payload[1] & 0x00FF));
+ card->uhs2_info.uhs2_cap.max_blk_len =
+ ((payload[0] & 0xFFF00000) >> 20);
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "card nfcu=%d datagap=%d blklen=%d\n",
+ card->uhs2_info.uhs2_cap.n_fcu,
+ card->uhs2_info.uhs2_cap.n_data_gap,
+ card->uhs2_info.uhs2_cap.max_blk_len);
+
+ /* Below capabliies only decide host */
+ card->uhs2_info.uhs2_cap.speed_range = host->uhs2_cap.speed_range;
+ /* default we use Fast Mode */
+
+ /* card support low power mode */
+ card->uhs2_info.uhs2_cap.pwr_mode = 1;
+ card->uhs2_info.uhs2_cap.retry_cnt = host->uhs2_cap.retry_cnt;
+
+ os_memset(payload, 0, sizeof(payload));
+ result =
+ uhs2_access_reg(card, sd_cmd, UHS2_IOADDR_GEN_CAPL, FALSE, FALSE, 1,
+ payload);
+ if (result == FALSE) {
+ DbgErr("Inquiry card gen cap failed\n");
+ goto exit;
+ }
+
+ card->uhs2_info.uhs2_cap.half_supp = (payload[0] & BIT8) ? TRUE : FALSE;
+ card->uhs2_info.uhs2_cap.lanes = ((payload[0] & 0x0E00) >> 8);
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "card halfsupp=%d lanes=%d\n",
+ card->uhs2_info.uhs2_cap.half_supp,
+ card->uhs2_info.uhs2_cap.lanes);
+
+exit:
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit %s result=%d\n", __func__, result);
+ return result;
+
+}
+
+static byte uhs2_get_large_lss(u32 val1, u32 val2)
+{
+ u32 v1, v2;
+ u32 v = 0;
+
+ v1 = val1;
+ v2 = val2;
+
+ if (v1 == 0)
+ v1 = 16;
+ if (v2 == 0)
+ v2 = 16;
+
+ v = os_max(v1, v2);
+ if (v == 16)
+ v = 0;
+
+ return (byte) v;
+}
+
+/*
+ * Function Name: uhs2_get_card_setting_host
+ *
+ * Abstract: This Function is used generate uhs2 card setting by card caps and host caps
+ *
+ * Input:
+ * sd_card_t *card :
+ * sd_host_t *host
+ *
+ */
+static void uhs2_get_card_setting_host(sd_card_t *card, sd_host_t *host)
+{
+ u16 nfcu1, nfcu2;
+ byte lanes;
+
+ card->uhs2_info.uhs2_setting.hibernate =
+ card->uhs2_info.uhs2_cap.hibernate;
+ card->uhs2_info.uhs2_setting.n_lss_dir =
+ uhs2_get_large_lss(card->uhs2_info.uhs2_cap.n_lss_dir,
+ host->uhs2_cap.n_lss_dir);
+ card->uhs2_info.uhs2_setting.n_lss_syn =
+ uhs2_get_large_lss(card->uhs2_info.uhs2_cap.n_lss_syn,
+ host->uhs2_cap.n_lss_syn);
+
+ card->uhs2_info.uhs2_setting.n_data_gap =
+ os_max(card->uhs2_info.uhs2_cap.n_data_gap,
+ host->uhs2_cap.n_data_gap);
+ card->uhs2_info.uhs2_setting.max_blk_len = 0x200;
+
+ nfcu1 = card->uhs2_info.uhs2_cap.n_fcu;
+ nfcu2 = host->uhs2_cap.n_fcu;
+ if (nfcu1 == 0)
+ nfcu1 = 256;
+ if (nfcu2 == 0)
+ nfcu2 = 256;
+ card->uhs2_info.uhs2_setting.n_fcu =
+ (nfcu1 >
+ nfcu2) ? host->uhs2_cap.n_fcu : card->uhs2_info.uhs2_cap.n_fcu;
+
+ card->uhs2_info.uhs2_setting.speed_range =
+ card->uhs2_info.uhs2_cap.speed_range;
+ card->uhs2_info.uhs2_setting.pwr_mode = 0;
+ card->uhs2_info.uhs2_setting.retry_cnt = host->uhs2_cap.retry_cnt;
+
+ card->uhs2_info.uhs2_setting.half_supp =
+ os_min(card->uhs2_info.uhs2_cap.half_supp,
+ (host->uhs2_cap.num_of_lane & 0x1));
+ card->uhs2_info.uhs2_setting.lanes =
+ card->uhs2_info.uhs2_cap.lanes & host->uhs2_cap.num_of_lane;
+
+ lanes = card->uhs2_info.uhs2_setting.lanes;
+
+ if (lanes & UHS2_LANES_2D2UFD)
+ lanes = UHS2_LANES_2D2UFD;
+ else if (lanes & UHS2_LANES_1D2UFD)
+ lanes = UHS2_LANES_1D2UFD;
+ else if (lanes & UHS2_LANES_2D1UFD)
+ lanes = UHS2_LANES_2D1UFD;
+ else
+ lanes = UHS2_LANES_2L_HD;
+ card->uhs2_info.uhs2_setting.lanes = lanes;
+}
+
+/*
+ * Function Name: uhs2_get_card_setting_host
+ *
+ * Abstract: This Function is used generate uhs2 card setting by vendor setting
+ *
+ * Input:
+ * sd_card_t *card :
+ * sd_host_t *host
+ *
+ */
+static void uhs2_update_card_setting_vendor(sd_card_t *card, sd_host_t *host)
+{
+ u16 nfcu1, nfcu2;
+ cfg_uhs2_setting_t *cfg = &host->cfg->card_item.uhs2_setting;
+
+ card->uhs2_info.uhs2_setting.n_lss_dir =
+ uhs2_get_large_lss(card->uhs2_info.uhs2_setting.n_lss_dir,
+ cfg->min_lss_dir);
+ card->uhs2_info.uhs2_setting.n_lss_syn =
+ uhs2_get_large_lss(card->uhs2_info.uhs2_setting.n_lss_syn,
+ cfg->min_lss_syn);
+
+ card->uhs2_info.uhs2_setting.n_data_gap =
+ os_max(card->uhs2_info.uhs2_setting.n_data_gap,
+ cfg->min_data_gap_sel);
+
+ nfcu1 = (u16) card->uhs2_info.uhs2_setting.n_fcu;
+ nfcu2 = (u16) cfg->max_nfcn_sel;
+ if (nfcu1 == 0)
+ nfcu1 = 256;
+ if (nfcu2 == 0)
+ nfcu2 = 256;
+ card->uhs2_info.uhs2_setting.n_fcu =
+ (nfcu1 >
+ nfcu2) ? cfg->max_nfcn_sel : card->uhs2_info.uhs2_setting.n_fcu;
+
+ card->uhs2_info.uhs2_setting.speed_range =
+ os_min(card->uhs2_info.uhs2_setting.speed_range,
+ cfg->max_speed_range_sel);
+ card->uhs2_info.uhs2_setting.pwr_mode = (byte) cfg->fast_low_pwr_sel;
+
+ card->uhs2_info.uhs2_setting.half_supp =
+ os_min(card->uhs2_info.uhs2_cap.half_supp, cfg->half_full_sel);
+
+}
+
+/*
+ * Function Name: uhs2_update_card_setting_degrade
+ *
+ * Abstract: This Function is used generate uhs2 card setting by degrade info
+ *
+ * Input:
+ * sd_card_t *card :
+ * sd_host_t *host
+ *
+ */
+static void uhs2_update_card_setting_degrade(sd_card_t *card)
+{
+ if (card->degrade_uhs2_range)
+ card->uhs2_info.uhs2_setting.speed_range = 0;
+}
+
+/*
+ * Function Name: uhs2_update_card_setting_thermal
+ *
+ * Abstract: This Function is used generate uhs2 card setting by degrade info
+ *
+ * Input:
+ * sd_card_t *card :
+ * sd_host_t *host
+ *
+ */
+static void uhs2_update_card_setting_thermal(sd_card_t *card)
+{
+
+ if (card->thermal_enable == 0)
+ return;
+}
+
+/*
+ * Function Name: uhs2_cfg_set_card
+ *
+ * Abstract: This Function is used to set card's configuration
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd,
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+static bool uhs2_cfg_set_card(sd_card_t *card, sd_command_t *sd_cmd,
+ sd_host_t *host)
+{
+ u32 payload[2];
+ bool result = FALSE;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Set device Phy Setting register */
+ os_memset(payload, 0, sizeof(payload));
+ payload[0] = (card->uhs2_info.uhs2_setting.speed_range << 6);
+ payload[1] = (card->uhs2_info.uhs2_setting.n_lss_syn) |
+ (card->uhs2_info.uhs2_setting.n_lss_dir << 4);
+ result =
+ uhs2_access_reg(card, sd_cmd, UHS2_IOADDR_PHY_SETL, FALSE, TRUE, 2,
+ payload);
+ if (result == FALSE) {
+ DbgErr("set uhs2 cfg phy setting failed ret\n");
+ goto exit;
+ }
+
+ /* Set device Link and trans registers */
+ os_memset(payload, 0, sizeof(payload));
+ payload[0] = (card->uhs2_info.uhs2_setting.n_fcu << 8) |
+ (card->uhs2_info.uhs2_setting.retry_cnt << 16) |
+ (card->uhs2_info.uhs2_setting.max_blk_len << 20);
+ payload[1] = (card->uhs2_info.uhs2_setting.n_data_gap);
+ result =
+ uhs2_access_reg(card, sd_cmd, UHS2_IOADDR_LINKT_SETL, FALSE, TRUE,
+ 2, payload);
+ if (result == FALSE) {
+ DbgErr("set uhs2 cfg linktran setting failed\n");
+ goto exit;
+ }
+
+ /* Set device general setting registers */
+ os_memset(payload, 0, sizeof(payload));
+ payload[0] = (card->uhs2_info.uhs2_setting.pwr_mode) |
+ (card->uhs2_info.uhs2_setting.lanes << 8);
+ result =
+ uhs2_access_reg(card, sd_cmd, UHS2_IOADDR_GEN_SETL, FALSE, TRUE, 1,
+ payload);
+ if (result == FALSE) {
+ DbgErr("set uhs2 cfg gen setting failed ret\n");
+ goto exit;
+ }
+
+ /* Set device to active status */
+ os_memset(payload, 0, sizeof(payload));
+ /* Set config complete */
+ payload[0] = BIT31;
+ result =
+ uhs2_access_reg(card, sd_cmd, UHS2_IOADDR_GEN_SETH, FALSE, TRUE, 1,
+ payload);
+ if (result == FALSE) {
+ DbgErr("set uhs2 cfg set active failed\n");
+ return result;
+ }
+
+exit:
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, result);
+ return result;
+}
+
+/*
+ * Function Name: uhs2_enter_dmt
+ *
+ * Abstract: This Function is used to
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+bool uhs2_enter_dmt(sd_card_t *card, sd_command_t *sd_cmd, sd_host_t *host,
+ bool hbr)
+{
+ bool result = FALSE;
+ u32 payload = hbr ? UHS2_GODRM_HBNEN : 0;
+ byte retry_cnt = 2;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT | FEATURE_CARD_OPS,
+ NOT_TO_RAM, "Enter %s\n", __func__);
+retry:
+ retry_cnt--;
+ result =
+ uhs2_native_ccmd(card, sd_cmd, UHS2_IOADDR_GODMT, FALSE, TRUE, 1,
+ &payload);
+ if (result == FALSE) {
+ if (retry_cnt > 0) {
+ if (uhs2_is_uncoverable(sd_cmd))
+ goto exit;
+
+ result = uhs2_trans_abort(card, sd_cmd);
+ if (result == FALSE)
+ goto exit;
+ goto retry;
+ }
+ goto exit;
+ }
+ result = host_uhs2_go_dmt(host, hbr);
+
+exit:
+ if (result == FALSE)
+ DbgErr("UHS2 go dmt failed hbr=%d\n", hbr);
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT | FEATURE_CARD_OPS,
+ NOT_TO_RAM, "Exit %s ret=%d\n", __func__, result);
+ return result;
+}
+
+/*
+ * Function Name: uhs2_resume_dmt
+ * Abstract: This Function is used to
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+bool uhs2_resume_dmt(sd_card_t *card, sd_command_t *sd_cmd, sd_host_t *host,
+ bool hbr)
+{
+ return host_uhs2_resume_dmt(host, hbr);
+}
+
+/*
+ * Function Name: uhs2_card_configuration
+ *
+ * Abstract: This Function is used to
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+bool uhs2_card_configuration(sd_card_t *card, sd_command_t *sd_cmd,
+ sd_host_t *host)
+{
+ bool result = FALSE;
+ uhs2_info_t info;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ result = uhs2_cfg_set_card(card, sd_cmd, host);
+ if (result == FALSE)
+ goto exit;
+
+ os_memcpy(&info, &card->uhs2_info.uhs2_setting, sizeof(uhs2_info_t));
+ info.speed_range = 0;
+ info.lanes = 0;
+
+ host_uhs2_cfg_set(host, &info, FALSE);
+
+ if (card->uhs2_info.uhs2_setting.lanes == 0
+ && card->uhs2_info.uhs2_setting.speed_range == 0)
+ goto exit;
+
+ result = uhs2_enter_dmt(card, sd_cmd, host, FALSE);
+ if (result == FALSE)
+ goto exit;
+
+ info.speed_range = card->uhs2_info.uhs2_setting.speed_range;
+ info.lanes = card->uhs2_info.uhs2_setting.lanes;
+ host_uhs2_cfg_set(host, &info, TRUE);
+
+ result = uhs2_resume_dmt(card, sd_cmd, host, FALSE);
+ if (result == FALSE)
+ goto exit;
+
+exit:
+ if (result == FALSE)
+ DbgErr("UHS2 card configuration failed\n");
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, result);
+ return result;
+}
+
+bool uhs2_init_stage2(sd_card_t *card)
+{
+
+ bool result = FALSE;
+ sd_command_t sd_cmd;
+
+ /* Init stage always do pm setting */
+ bool bchg = TRUE;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+ os_memset(&sd_cmd, 0, sizeof(sd_command_t));
+
+ result = sd_init_get_info(card);
+ if (result == FALSE) {
+ DbgErr("SD Card get info failed\n");
+ goto exit;
+ }
+
+ if (card_need_get_info(card)) {
+ result = sd_switch_function_check(card, &sd_cmd);
+ if (!result) {
+ DbgErr("uhs2 swich function check failed.\n");
+ goto exit;
+ }
+ }
+
+ /* 14. Swich function check/set */
+
+ {
+ /*
+ * 14.2 Swich function check set.
+ * - Driver Strength,
+ * - Access Mode,
+ * - Power Limit
+ * - Change clock freq
+ */
+ result = sd_switch_power_limit(card, &sd_cmd, &bchg);
+ if (result == FALSE) {
+ DbgErr("uhs2 switch power limit failed\n");
+ goto exit;
+ }
+
+ }
+exit:
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, result);
+ return result;
+}
+
+/*
+ * Function Name: uhs2_card_init
+ *
+ * Abstract: This Function is used init uhs2 card
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+bool uhs2_card_init(sd_card_t *card)
+{
+ bool result = FALSE;
+ sd_command_t sd_cmd;
+ sd_host_t *host = card->host;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM, "Enter %s\n",
+ __func__);
+
+ /* Try to init as UHS2 card */
+ card->card_type = CARD_UHS2;
+ result = uhs2_devinit_flow(card, &sd_cmd, host);
+ if (result == FALSE)
+ goto exit;
+
+ /* do enumeration */
+ result = uhs2_dev_enumeration(card, &sd_cmd);
+ if (result == FALSE)
+ goto exit;
+
+ if (card_need_get_info(card)) {
+ /* Get card capabilities */
+ result = uhs2_card_get_caps(card, &sd_cmd, host);
+ if (result == FALSE)
+ goto exit;
+
+ }
+
+ uhs2_get_card_setting_host(card, host);
+ uhs2_update_card_setting_vendor(card, host);
+ uhs2_update_card_setting_degrade(card);
+ uhs2_update_card_setting_thermal(card);
+
+ result = uhs2_card_configuration(card, &sd_cmd, host);
+ if (result == FALSE)
+ goto exit;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, TO_RAM,
+ "uhs2 setting n_fcu=%d lss_dir=%d lss_syn=%d datagap=%d\n",
+ card->uhs2_info.uhs2_setting.n_fcu,
+ card->uhs2_info.uhs2_setting.n_lss_dir,
+ card->uhs2_info.uhs2_setting.n_lss_syn,
+ card->uhs2_info.uhs2_setting.n_data_gap);
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, TO_RAM,
+ "uhs2 Setting range=%d half=%d lpm=%d\n",
+ card->uhs2_info.uhs2_setting.speed_range,
+ card->uhs2_info.uhs2_setting.half_supp,
+ card->uhs2_info.uhs2_setting.pwr_mode);
+
+ result = sd_card_identify(card);
+ if (result == FALSE)
+ goto exit;
+
+ result = sd_card_select(card);
+ if (result == FALSE)
+ goto exit;
+
+ if (card->locked == TRUE) {
+ DbgWarn(MODULE_UHS2_CARD, NOT_TO_RAM, "uhs2 card is locked\n");
+ goto exit;
+ }
+
+ result = card_init_stage2(card);
+ if (result == FALSE) {
+ DbgErr("SD init stage 2 failed.\n");
+ goto exit;
+ }
+
+exit:
+ if (result == FALSE)
+ DbgErr("UHS2 card init failed\n");
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, result);
+ return result;
+}
+
+/*
+ * Function Name: uhs2_degrade_policy
+ *
+ * Abstract: This Function is used set uhs2 degrade flag
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+void uhs2_degrade_policy(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ if (card->degrade_freq_level < CARD_DEGRADE_FREQ_TIMES) {
+ card->degrade_freq_level++;
+ goto exit;
+ }
+
+ if (sd_cmd != NULL && card->uhs2_info.uhs2_setting.half_supp
+ && (card->degrade_uhs2_half == 0)) {
+ card->degrade_uhs2_half = 1;
+ goto exit;
+ }
+
+ if (card->degrade_uhs2_range == 0
+ && card->uhs2_info.uhs2_setting.speed_range) {
+ card->degrade_uhs2_range = 1;
+ goto exit;
+ }
+
+ card->degrade_uhs2_legacy = 1;
+ card->quick_init = 0;
+ card->card_type = CARD_NONE;
+ card->degrade_freq_level = 0;
+
+exit:
+ DbgErr("UHS2 degrade range=%d freq_level=%d half=%d legacy=%d\n",
+ card->degrade_uhs2_range, card->degrade_freq_level,
+ card->degrade_uhs2_half, card->degrade_uhs2_legacy);
+}
+
+static bool uhs2_read_status_reg(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool result = FALSE;
+ u32 payload = 0;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Enter %s\n", __func__);
+
+ result =
+ uhs2_access_reg(card, sd_cmd, UHS2_IOADDR_ST_REG, FALSE, FALSE, 1,
+ &payload);
+
+ if (result == FALSE)
+ DbgErr("uhs2 read status reg failed\n");
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, result);
+ return result;
+}
+
+/*
+ * Function Name: uhs2_sd_error_recovery
+ *
+ * Abstract: This Function is used do error recovery for uhs2
+ *
+ * Input:
+ * sd_card_t *card : The Command will send to which Card
+ * sd_command_t *sd_cmd
+ *
+ * Return value:
+ * If the routine succeeds, it must return TRUE, and fill trans_reg_t part.
+ * otherwize reutrn FALSE
+ */
+
+bool uhs2_sd_error_recovery(sd_card_t *card, sd_command_t *sd_cmd)
+{
+ bool result = FALSE;
+ sd_command_t recover_cmd;
+
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Enter %s\n", __func__);
+
+ if (sd_cmd == NULL)
+ goto exit;
+
+ /* If uncoverable do fullreset recover directly */
+ if (uhs2_is_uncoverable(sd_cmd))
+ goto full_reset;
+
+ host_uhs2_reset(card->host, FALSE);
+
+ /* do sd-tran */
+ result = uhs2_trans_abort(card, &recover_cmd);
+ if (result == FALSE)
+ goto full_reset;
+
+ result = uhs2_read_status_reg(card, &recover_cmd);
+ if (result == FALSE)
+ goto full_reset;
+
+ /* send cmd12 and check whether */
+ card_send_command12(card, &recover_cmd);
+ if (recover_cmd.uhs2_nack != 0)
+ goto full_reset;
+
+ result = card_check_rw_ready(card, &recover_cmd, 150);
+ if (result == FALSE)
+ goto full_reset;
+
+ goto exit;
+
+full_reset:
+ DbgErr("Do Full reset uhs2 recovery\n");
+ host_uhs2_reset(card->host, FALSE);
+ result = uhs2_full_reset_card(card);
+ if (result)
+ result = card_init(card, 1, TRUE);
+
+exit:
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_ERROR_RECOVER, NOT_TO_RAM,
+ "Exit %s ret=%d\n", __func__, result);
+ return result;
+}
+
+u32 card_get_uhs2_freq(sd_card_t *card)
+{
+ sd_host_t *host = card->host;
+ /* cfg_max_freq_item_t *freq = &(host->cfg->host_item.max_freq_item); */
+ u16 index = 0;
+ u32 value;
+
+ if (host->cfg == NULL || host->cfg->dmdn_tbl == NULL) {
+ DbgErr("host cfg is null\n");
+ return 0;
+ }
+
+ index = (u16) FREQ_UHS2M_START_INDEX + card->degrade_freq_level;
+ if (index > (u16) FREQ_UHS2M_DEGRE_INDEX)
+ index = (u16) FREQ_UHS2M_DEGRE_INDEX;
+ value = host->cfg->dmdn_tbl[index];
+ DbgInfo(MODULE_UHS2_CARD, FEATURE_CARD_INIT, NOT_TO_RAM,
+ "Get Uhs2 Dmdn=0x%08X\n", value);
+
+ return value;
+}
--
2.34.1