diff options
Diffstat (limited to 'drivers/staging/rts5208/sd.c')
| -rw-r--r-- | drivers/staging/rts5208/sd.c | 2007 |
1 files changed, 1389 insertions, 618 deletions
diff --git a/drivers/staging/rts5208/sd.c b/drivers/staging/rts5208/sd.c index c28a92773f05..a8d657bb5c1b 100644 --- a/drivers/staging/rts5208/sd.c +++ b/drivers/staging/rts5208/sd.c @@ -25,9 +25,6 @@ #include <linux/sched.h> #include "rtsx.h" -#include "rtsx_transport.h" -#include "rtsx_scsi.h" -#include "rtsx_card.h" #include "sd.h" #define SD_MAX_RETRY_COUNT 3 @@ -108,13 +105,19 @@ static void sd_init_reg_addr(struct rtsx_chip *chip) static int sd_check_data0_status(struct rtsx_chip *chip) { + int retval; u8 stat; - RTSX_READ_REG(chip, REG_SD_STAT1, &stat); + retval = rtsx_read_register(chip, REG_SD_STAT1, &stat); + if (retval) { + rtsx_trace(chip); + return retval; + } if (!(stat & SD_DAT0_STATUS)) { sd_set_err_code(chip, SD_BUSY); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } return STATUS_SUCCESS; @@ -187,7 +190,8 @@ RTY_SEND_CMD: retval = sd_check_data0_status(chip); if (retval != STATUS_SUCCESS) { rtsx_clear_sd_error(chip); - TRACE_RET(chip, retval); + rtsx_trace(chip); + return retval; } } else { sd_set_err_code(chip, SD_TO_ERR); @@ -198,7 +202,8 @@ RTY_SEND_CMD: } rtsx_clear_sd_error(chip); - TRACE_RET(chip, retval); + rtsx_trace(chip); + return retval; } if (rsp_type == SD_RSP_TYPE_R0) @@ -208,14 +213,16 @@ RTY_SEND_CMD: if ((ptr[0] & 0xC0) != 0) { sd_set_err_code(chip, SD_STS_ERR); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (!(rsp_type & SD_NO_CHECK_CRC7)) { if (ptr[stat_idx] & SD_CRC7_ERR) { if (cmd_idx == WRITE_MULTIPLE_BLOCK) { sd_set_err_code(chip, SD_CRC_ERR); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (rty_cnt < SD_MAX_RETRY_COUNT) { wait_timeout(20); @@ -223,7 +230,8 @@ RTY_SEND_CMD: goto RTY_SEND_CMD; } else { sd_set_err_code(chip, SD_CRC_ERR); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } } @@ -232,8 +240,10 @@ RTY_SEND_CMD: if ((cmd_idx != SEND_RELATIVE_ADDR) && (cmd_idx != SEND_IF_COND)) { if (cmd_idx != STOP_TRANSMISSION) { - if (ptr[1] & 0x80) - TRACE_RET(chip, STATUS_FAIL); + if (ptr[1] & 0x80) { + rtsx_trace(chip); + return STATUS_FAIL; + } } #ifdef SUPPORT_SD_LOCK if (ptr[1] & 0x7D) @@ -243,17 +253,20 @@ RTY_SEND_CMD: { dev_dbg(rtsx_dev(chip), "ptr[1]: 0x%02x\n", ptr[1]); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (ptr[2] & 0xFF) { dev_dbg(rtsx_dev(chip), "ptr[2]: 0x%02x\n", ptr[2]); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (ptr[3] & 0x80) { dev_dbg(rtsx_dev(chip), "ptr[3]: 0x%02x\n", ptr[3]); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (ptr[3] & 0x01) sd_card->sd_data_buf_ready = 1; @@ -282,8 +295,10 @@ static int sd_read_data(struct rtsx_chip *chip, if (!buf) buf_len = 0; - if (buf_len > 512) - TRACE_RET(chip, STATUS_FAIL); + if (buf_len > 512) { + rtsx_trace(chip); + return STATUS_FAIL; + } rtsx_init_cmd(chip); @@ -323,13 +338,16 @@ static int sd_read_data(struct rtsx_chip *chip, SD_RSP_TYPE_R1, NULL, 0); } - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (buf && buf_len) { retval = rtsx_read_ppbuf(chip, buf, buf_len); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } return STATUS_SUCCESS; @@ -350,13 +368,16 @@ static int sd_write_data(struct rtsx_chip *chip, u8 trans_mode, if (buf_len > 512) { /* This function can't write data more than one page */ - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (buf && buf_len) { retval = rtsx_write_ppbuf(chip, buf, buf_len); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } rtsx_init_cmd(chip); @@ -395,7 +416,8 @@ static int sd_write_data(struct rtsx_chip *chip, u8 trans_mode, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); } - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } return STATUS_SUCCESS; @@ -412,7 +434,8 @@ static int sd_check_csd(struct rtsx_chip *chip, char check_wp) for (i = 0; i < 6; i++) { if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) { sd_set_err_code(chip, SD_NO_CARD); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } retval = sd_send_cmd_get_rsp(chip, SEND_CSD, sd_card->sd_addr, @@ -421,8 +444,10 @@ static int sd_check_csd(struct rtsx_chip *chip, char check_wp) break; } - if (i == 6) - TRACE_RET(chip, STATUS_FAIL); + if (i == 6) { + rtsx_trace(chip); + return STATUS_FAIL; + } memcpy(sd_card->raw_csd, rsp + 1, 15); @@ -464,10 +489,12 @@ static int sd_check_csd(struct rtsx_chip *chip, char check_wp) else sd_card->sd_clock = CLK_20; } else { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } else { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (CHK_MMC_SECTOR_MODE(sd_card)) { @@ -507,8 +534,8 @@ static int sd_check_csd(struct rtsx_chip *chip, char check_wp) static int sd_set_sample_push_timing(struct rtsx_chip *chip) { + int retval; struct sd_info *sd_card = &(chip->sd_card); - u8 val = 0; if ((chip->sd_ctl & SD_PUSH_POINT_CTL_MASK) == SD_PUSH_POINT_DELAY) @@ -536,7 +563,11 @@ static int sd_set_sample_push_timing(struct rtsx_chip *chip) val |= 0x08; } - RTSX_WRITE_REG(chip, REG_SD_CFG1, 0x1C, val); + retval = rtsx_write_register(chip, REG_SD_CFG1, 0x1C, val); + if (retval) { + rtsx_trace(chip); + return retval; + } return STATUS_SUCCESS; } @@ -585,6 +616,7 @@ static void sd_choose_proper_clock(struct rtsx_chip *chip) static int sd_set_clock_divider(struct rtsx_chip *chip, u8 clk_div) { + int retval; u8 mask = 0, val = 0; mask = 0x60; @@ -595,7 +627,11 @@ static int sd_set_clock_divider(struct rtsx_chip *chip, u8 clk_div) else if (clk_div == SD_CLK_DIVIDE_256) val = 0x20; - RTSX_WRITE_REG(chip, REG_SD_CFG1, mask, val); + retval = rtsx_write_register(chip, REG_SD_CFG1, mask, val); + if (retval) { + rtsx_trace(chip); + return retval; + } return STATUS_SUCCESS; } @@ -606,14 +642,18 @@ static int sd_set_init_para(struct rtsx_chip *chip) int retval; retval = sd_set_sample_push_timing(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } sd_choose_proper_clock(chip); retval = switch_clock(chip, sd_card->sd_clock); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } return STATUS_SUCCESS; } @@ -636,8 +676,10 @@ int sd_select_card(struct rtsx_chip *chip, int select) } retval = sd_send_cmd_get_rsp(chip, cmd_idx, addr, cmd_type, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } return STATUS_SUCCESS; } @@ -651,8 +693,10 @@ static int sd_update_lock_status(struct rtsx_chip *chip) retval = sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, rsp, 5); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (rsp[1] & 0x02) sd_card->sd_lock_status |= SD_LOCKED; @@ -662,8 +706,10 @@ static int sd_update_lock_status(struct rtsx_chip *chip) dev_dbg(rtsx_dev(chip), "sd_card->sd_lock_status = 0x%x\n", sd_card->sd_lock_status); - if (rsp[1] & 0x01) - TRACE_RET(chip, STATUS_FAIL); + if (rsp[1] & 0x01) { + rtsx_trace(chip); + return STATUS_FAIL; + } return STATUS_SUCCESS; } @@ -680,15 +726,18 @@ static int sd_wait_state_data_ready(struct rtsx_chip *chip, u8 state, retval = sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, rsp, 5); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (((rsp[3] & 0x1E) == state) && ((rsp[3] & 0x01) == data_ready)) return STATUS_SUCCESS; } - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } static int sd_change_bank_voltage(struct rtsx_chip *chip, u8 voltage) @@ -700,24 +749,39 @@ static int sd_change_bank_voltage(struct rtsx_chip *chip, u8 voltage) retval = rtsx_write_phy_register(chip, 0x08, 0x4FC0 | chip->phy_voltage); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } else { - RTSX_WRITE_REG(chip, SD_PAD_CTL, SD_IO_USING_1V8, 0); + retval = rtsx_write_register(chip, SD_PAD_CTL, + SD_IO_USING_1V8, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } } } else if (voltage == SD_IO_1V8) { if (chip->asic_code) { retval = rtsx_write_phy_register(chip, 0x08, 0x4C40 | chip->phy_voltage); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } else { - RTSX_WRITE_REG(chip, SD_PAD_CTL, SD_IO_USING_1V8, - SD_IO_USING_1V8); + retval = rtsx_write_register(chip, SD_PAD_CTL, + SD_IO_USING_1V8, + SD_IO_USING_1V8); + if (retval) { + rtsx_trace(chip); + return retval; + } } } else { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } return STATUS_SUCCESS; @@ -728,33 +792,61 @@ static int sd_voltage_switch(struct rtsx_chip *chip) int retval; u8 stat; - RTSX_WRITE_REG(chip, SD_BUS_STAT, SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP, - SD_CLK_TOGGLE_EN); + retval = rtsx_write_register(chip, SD_BUS_STAT, + SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP, + SD_CLK_TOGGLE_EN); + if (retval) { + rtsx_trace(chip); + return retval; + } retval = sd_send_cmd_get_rsp(chip, VOLTAGE_SWITCH, 0, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } udelay(chip->sd_voltage_switch_delay); - RTSX_READ_REG(chip, SD_BUS_STAT, &stat); + retval = rtsx_read_register(chip, SD_BUS_STAT, &stat); + if (retval) { + rtsx_trace(chip); + return retval; + } if (stat & (SD_CMD_STATUS | SD_DAT3_STATUS | SD_DAT2_STATUS | SD_DAT1_STATUS | SD_DAT0_STATUS)) { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } - RTSX_WRITE_REG(chip, SD_BUS_STAT, 0xFF, SD_CLK_FORCE_STOP); + retval = rtsx_write_register(chip, SD_BUS_STAT, 0xFF, + SD_CLK_FORCE_STOP); + if (retval) { + rtsx_trace(chip); + return retval; + } retval = sd_change_bank_voltage(chip, SD_IO_1V8); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } wait_timeout(50); - RTSX_WRITE_REG(chip, SD_BUS_STAT, 0xFF, SD_CLK_TOGGLE_EN); + retval = rtsx_write_register(chip, SD_BUS_STAT, 0xFF, + SD_CLK_TOGGLE_EN); + if (retval) { + rtsx_trace(chip); + return retval; + } wait_timeout(10); - RTSX_READ_REG(chip, SD_BUS_STAT, &stat); + retval = rtsx_read_register(chip, SD_BUS_STAT, &stat); + if (retval) { + rtsx_trace(chip); + return retval; + } if ((stat & (SD_CMD_STATUS | SD_DAT3_STATUS | SD_DAT2_STATUS | SD_DAT1_STATUS | SD_DAT0_STATUS)) != (SD_CMD_STATUS | SD_DAT3_STATUS | SD_DAT2_STATUS | @@ -763,23 +855,48 @@ static int sd_voltage_switch(struct rtsx_chip *chip) rtsx_write_register(chip, SD_BUS_STAT, SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP, 0); rtsx_write_register(chip, CARD_CLK_EN, 0xFF, 0); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } - RTSX_WRITE_REG(chip, SD_BUS_STAT, SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP, - 0); + retval = rtsx_write_register(chip, SD_BUS_STAT, + SD_CLK_TOGGLE_EN | SD_CLK_FORCE_STOP, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } return STATUS_SUCCESS; } static int sd_reset_dcm(struct rtsx_chip *chip, u8 tune_dir) { + int retval; + if (tune_dir == TUNE_RX) { - RTSX_WRITE_REG(chip, DCM_DRP_CTL, 0xFF, DCM_RESET | DCM_RX); - RTSX_WRITE_REG(chip, DCM_DRP_CTL, 0xFF, DCM_RX); + retval = rtsx_write_register(chip, DCM_DRP_CTL, 0xFF, + DCM_RESET | DCM_RX); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, DCM_DRP_CTL, 0xFF, DCM_RX); + if (retval) { + rtsx_trace(chip); + return retval; + } } else { - RTSX_WRITE_REG(chip, DCM_DRP_CTL, 0xFF, DCM_RESET | DCM_TX); - RTSX_WRITE_REG(chip, DCM_DRP_CTL, 0xFF, DCM_TX); + retval = rtsx_write_register(chip, DCM_DRP_CTL, 0xFF, + DCM_RESET | DCM_TX); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, DCM_DRP_CTL, 0xFF, DCM_TX); + if (retval) { + rtsx_trace(chip); + return retval; + } } return STATUS_SUCCESS; @@ -791,7 +908,7 @@ static int sd_change_phase(struct rtsx_chip *chip, u8 sample_point, u8 tune_dir) u16 SD_VP_CTL, SD_DCMPS_CTL; u8 val; int retval; - int ddr_rx = 0; + bool ddr_rx = false; dev_dbg(rtsx_dev(chip), "sd_change_phase (sample_point = %d, tune_dir = %d)\n", sample_point, tune_dir); @@ -800,19 +917,42 @@ static int sd_change_phase(struct rtsx_chip *chip, u8 sample_point, u8 tune_dir) SD_VP_CTL = SD_VPRX_CTL; SD_DCMPS_CTL = SD_DCMPS_RX_CTL; if (CHK_SD_DDR50(sd_card)) - ddr_rx = 1; + ddr_rx = true; } else { SD_VP_CTL = SD_VPTX_CTL; SD_DCMPS_CTL = SD_DCMPS_TX_CTL; } if (chip->asic_code) { - RTSX_WRITE_REG(chip, CLK_CTL, CHANGE_CLK, CHANGE_CLK); - RTSX_WRITE_REG(chip, SD_VP_CTL, 0x1F, sample_point); - RTSX_WRITE_REG(chip, SD_VPCLK0_CTL, PHASE_NOT_RESET, 0); - RTSX_WRITE_REG(chip, SD_VPCLK0_CTL, PHASE_NOT_RESET, - PHASE_NOT_RESET); - RTSX_WRITE_REG(chip, CLK_CTL, CHANGE_CLK, 0); + retval = rtsx_write_register(chip, CLK_CTL, CHANGE_CLK, + CHANGE_CLK); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, SD_VP_CTL, 0x1F, + sample_point); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, SD_VPCLK0_CTL, + PHASE_NOT_RESET, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, SD_VPCLK0_CTL, + PHASE_NOT_RESET, PHASE_NOT_RESET); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, CLK_CTL, CHANGE_CLK, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } } else { rtsx_read_register(chip, SD_VP_CTL, &val); dev_dbg(rtsx_dev(chip), "SD_VP_CTL: 0x%x\n", val); @@ -820,16 +960,34 @@ static int sd_change_phase(struct rtsx_chip *chip, u8 sample_point, u8 tune_dir) dev_dbg(rtsx_dev(chip), "SD_DCMPS_CTL: 0x%x\n", val); if (ddr_rx) { - RTSX_WRITE_REG(chip, SD_VP_CTL, PHASE_CHANGE, - PHASE_CHANGE); + retval = rtsx_write_register(chip, SD_VP_CTL, + PHASE_CHANGE, + PHASE_CHANGE); + if (retval) { + rtsx_trace(chip); + return retval; + } udelay(50); - RTSX_WRITE_REG(chip, SD_VP_CTL, 0xFF, - PHASE_CHANGE | PHASE_NOT_RESET | sample_point); + retval = rtsx_write_register(chip, SD_VP_CTL, 0xFF, + PHASE_CHANGE | PHASE_NOT_RESET | sample_point); + if (retval) { + rtsx_trace(chip); + return retval; + } } else { - RTSX_WRITE_REG(chip, CLK_CTL, CHANGE_CLK, CHANGE_CLK); + retval = rtsx_write_register(chip, CLK_CTL, + CHANGE_CLK, CHANGE_CLK); + if (retval) { + rtsx_trace(chip); + return retval; + } udelay(50); - RTSX_WRITE_REG(chip, SD_VP_CTL, 0xFF, - PHASE_NOT_RESET | sample_point); + retval = rtsx_write_register(chip, SD_VP_CTL, 0xFF, + PHASE_NOT_RESET | sample_point); + if (retval) { + rtsx_trace(chip); + return retval; + } } udelay(100); @@ -839,26 +997,52 @@ static int sd_change_phase(struct rtsx_chip *chip, u8 sample_point, u8 tune_dir) rtsx_add_cmd(chip, CHECK_REG_CMD, SD_DCMPS_CTL, DCMPS_CHANGE_DONE, DCMPS_CHANGE_DONE); retval = rtsx_send_cmd(chip, SD_CARD, 100); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, Fail); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto Fail; + } val = *rtsx_get_cmd_data(chip); - if (val & DCMPS_ERROR) - TRACE_GOTO(chip, Fail); + if (val & DCMPS_ERROR) { + rtsx_trace(chip); + goto Fail; + } - if ((val & DCMPS_CURRENT_PHASE) != sample_point) - TRACE_GOTO(chip, Fail); + if ((val & DCMPS_CURRENT_PHASE) != sample_point) { + rtsx_trace(chip); + goto Fail; + } - RTSX_WRITE_REG(chip, SD_DCMPS_CTL, DCMPS_CHANGE, 0); - if (ddr_rx) - RTSX_WRITE_REG(chip, SD_VP_CTL, PHASE_CHANGE, 0); - else - RTSX_WRITE_REG(chip, CLK_CTL, CHANGE_CLK, 0); + retval = rtsx_write_register(chip, SD_DCMPS_CTL, + DCMPS_CHANGE, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } + if (ddr_rx) { + retval = rtsx_write_register(chip, SD_VP_CTL, + PHASE_CHANGE, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } + } else { + retval = rtsx_write_register(chip, CLK_CTL, + CHANGE_CLK, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } + } udelay(50); } - RTSX_WRITE_REG(chip, SD_CFG1, SD_ASYNC_FIFO_NOT_RST, 0); + retval = rtsx_write_register(chip, SD_CFG1, SD_ASYNC_FIFO_NOT_RST, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } return STATUS_SUCCESS; @@ -883,8 +1067,10 @@ static int sd_check_spec(struct rtsx_chip *chip, u8 bus_width) retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } cmd[0] = 0x40 | SEND_SCR; cmd[1] = 0; @@ -896,13 +1082,16 @@ static int sd_check_spec(struct rtsx_chip *chip, u8 bus_width) buf, 8, 250); if (retval != STATUS_SUCCESS) { rtsx_clear_sd_error(chip); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } memcpy(sd_card->raw_scr, buf, 8); - if ((buf[0] & 0x0F) == 0) - TRACE_RET(chip, STATUS_FAIL); + if ((buf[0] & 0x0F) == 0) { + rtsx_trace(chip); + return STATUS_FAIL; + } return STATUS_SUCCESS; } @@ -944,7 +1133,8 @@ static int sd_query_switch_result(struct rtsx_chip *chip, u8 func_group, break; default: - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } else if (func_group == SD_FUNC_GROUP_3) { support_offset = FUNCTION_GROUP3_SUPPORT_OFFSET; @@ -971,7 +1161,8 @@ static int sd_query_switch_result(struct rtsx_chip *chip, u8 func_group, break; default: - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } else if (func_group == SD_FUNC_GROUP_4) { support_offset = FUNCTION_GROUP4_SUPPORT_OFFSET; @@ -998,23 +1189,27 @@ static int sd_query_switch_result(struct rtsx_chip *chip, u8 func_group, break; default: - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } else { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (func_group == SD_FUNC_GROUP_1) { if (!(buf[support_offset] & support_mask) || ((buf[query_switch_offset] & 0x0F) != query_switch)) { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } /* Check 'Busy Status' */ if ((buf[DATA_STRUCTURE_VER_OFFSET] == 0x01) && ((buf[check_busy_offset] & switch_busy) == switch_busy)) { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } return STATUS_SUCCESS; @@ -1056,7 +1251,8 @@ static int sd_check_switch_mode(struct rtsx_chip *chip, u8 mode, buf, 64, 250); if (retval != STATUS_SUCCESS) { rtsx_clear_sd_error(chip); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } dev_dbg(rtsx_dev(chip), "%*ph\n", 64, buf); @@ -1083,19 +1279,33 @@ static int sd_check_switch_mode(struct rtsx_chip *chip, u8 mode, dev_dbg(rtsx_dev(chip), "Maximum current consumption: %dmA\n", cc); - if ((cc == 0) || (cc > 800)) - TRACE_RET(chip, STATUS_FAIL); + if ((cc == 0) || (cc > 800)) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_query_switch_result(chip, func_group, func_to_switch, buf, 64); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if ((cc > 400) || (func_to_switch > CURRENT_LIMIT_400)) { - RTSX_WRITE_REG(chip, OCPPARA2, SD_OCP_THD_MASK, - chip->sd_800mA_ocp_thd); - RTSX_WRITE_REG(chip, CARD_PWR_CTL, PMOS_STRG_MASK, - PMOS_STRG_800mA); + retval = rtsx_write_register(chip, OCPPARA2, + SD_OCP_THD_MASK, + chip->sd_800mA_ocp_thd); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, CARD_PWR_CTL, + PMOS_STRG_MASK, + PMOS_STRG_800mA); + if (retval) { + rtsx_trace(chip); + return retval; + } } } @@ -1121,12 +1331,13 @@ static int sd_check_switch(struct rtsx_chip *chip, { int retval; int i; - int switch_good = 0; + bool switch_good = false; for (i = 0; i < 3; i++) { if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) { sd_set_err_code(chip, SD_NO_CARD); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } retval = sd_check_switch_mode(chip, SD_CHECK_MODE, func_group, @@ -1137,14 +1348,19 @@ static int sd_check_switch(struct rtsx_chip *chip, retval = sd_check_switch_mode(chip, SD_SWITCH_MODE, func_group, func_to_switch, bus_width); if (retval == STATUS_SUCCESS) { - switch_good = 1; + switch_good = true; break; } - RTSX_READ_REG(chip, SD_STAT1, &stat); + retval = rtsx_read_register(chip, SD_STAT1, &stat); + if (retval) { + rtsx_trace(chip); + return retval; + } if (stat & SD_CRC16_ERR) { dev_dbg(rtsx_dev(chip), "SD CRC16 error when switching mode\n"); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } @@ -1154,8 +1370,10 @@ static int sd_check_switch(struct rtsx_chip *chip, wait_timeout(20); } - if (!switch_good) - TRACE_RET(chip, STATUS_FAIL); + if (!switch_good) { + rtsx_trace(chip); + return STATUS_FAIL; + } return STATUS_SUCCESS; } @@ -1170,8 +1388,10 @@ static int sd_switch_function(struct rtsx_chip *chip, u8 bus_width) /* Get supported functions */ retval = sd_check_switch_mode(chip, SD_CHECK_MODE, NO_ARGUMENT, NO_ARGUMENT, bus_width); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } sd_card->func_group1_mask &= ~(sd_card->sd_switch_fail); @@ -1239,7 +1459,8 @@ static int sd_switch_function(struct rtsx_chip *chip, u8 bus_width) sd_card->sd_switch_fail = SDR104_SUPPORT_MASK | DDR50_SUPPORT_MASK | SDR50_SUPPORT_MASK; } - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (func_to_switch == SDR104_SUPPORT) @@ -1253,10 +1474,17 @@ static int sd_switch_function(struct rtsx_chip *chip, u8 bus_width) } if (CHK_SD_DDR50(sd_card)) { - RTSX_WRITE_REG(chip, SD_PUSH_POINT_CTL, 0x06, 0x04); + retval = rtsx_write_register(chip, SD_PUSH_POINT_CTL, 0x06, + 0x04); + if (retval) { + rtsx_trace(chip); + return retval; + } retval = sd_set_sample_push_timing(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } if (!func_to_switch || (func_to_switch == HS_SUPPORT)) { @@ -1310,15 +1538,22 @@ static int sd_switch_function(struct rtsx_chip *chip, u8 bus_width) retval = sd_check_switch(chip, SD_FUNC_GROUP_4, func_to_switch, bus_width); if (retval != STATUS_SUCCESS) { - if (sd_check_err_code(chip, SD_NO_CARD)) - TRACE_RET(chip, STATUS_FAIL); + if (sd_check_err_code(chip, SD_NO_CARD)) { + rtsx_trace(chip); + return STATUS_FAIL; + } } dev_dbg(rtsx_dev(chip), "Switch current limit finished! (%d)\n", retval); } - if (CHK_SD_DDR50(sd_card)) - RTSX_WRITE_REG(chip, SD_PUSH_POINT_CTL, 0x06, 0); + if (CHK_SD_DDR50(sd_card)) { + retval = rtsx_write_register(chip, SD_PUSH_POINT_CTL, 0x06, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } + } return STATUS_SUCCESS; } @@ -1330,7 +1565,11 @@ static int sd_wait_data_idle(struct rtsx_chip *chip) u8 val = 0; for (i = 0; i < 100; i++) { - RTSX_READ_REG(chip, SD_DATA_STATE, &val); + retval = rtsx_read_register(chip, SD_DATA_STATE, &val); + if (retval) { + rtsx_trace(chip); + return retval; + } if (val & SD_DATA_IDLE) { retval = STATUS_SUCCESS; break; @@ -1348,8 +1587,10 @@ static int sd_sdr_tuning_rx_cmd(struct rtsx_chip *chip, u8 sample_point) u8 cmd[5]; retval = sd_change_phase(chip, sample_point, TUNE_RX); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } cmd[0] = 0x40 | SEND_TUNING_PATTERN; cmd[1] = 0; @@ -1363,7 +1604,8 @@ static int sd_sdr_tuning_rx_cmd(struct rtsx_chip *chip, u8 sample_point) (void)sd_wait_data_idle(chip); rtsx_clear_sd_error(chip); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } return STATUS_SUCCESS; @@ -1376,15 +1618,19 @@ static int sd_ddr_tuning_rx_cmd(struct rtsx_chip *chip, u8 sample_point) u8 cmd[5]; retval = sd_change_phase(chip, sample_point, TUNE_RX); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } dev_dbg(rtsx_dev(chip), "sd ddr tuning rx\n"); retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } cmd[0] = 0x40 | SD_STATUS; cmd[1] = 0; @@ -1398,7 +1644,8 @@ static int sd_ddr_tuning_rx_cmd(struct rtsx_chip *chip, u8 sample_point) (void)sd_wait_data_idle(chip); rtsx_clear_sd_error(chip); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } return STATUS_SUCCESS; @@ -1418,8 +1665,10 @@ static int mmc_ddr_tunning_rx_cmd(struct rtsx_chip *chip, u8 sample_point) bus_width = SD_BUS_WIDTH_1; retval = sd_change_phase(chip, sample_point, TUNE_RX); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } dev_dbg(rtsx_dev(chip), "mmc ddr tuning rx\n"); @@ -1435,7 +1684,8 @@ static int mmc_ddr_tunning_rx_cmd(struct rtsx_chip *chip, u8 sample_point) (void)sd_wait_data_idle(chip); rtsx_clear_sd_error(chip); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } return STATUS_SUCCESS; @@ -1447,11 +1697,17 @@ static int sd_sdr_tuning_tx_cmd(struct rtsx_chip *chip, u8 sample_point) int retval; retval = sd_change_phase(chip, sample_point, TUNE_TX); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } - RTSX_WRITE_REG(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, - SD_RSP_80CLK_TIMEOUT_EN); + retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, + SD_RSP_80CLK_TIMEOUT_EN); + if (retval) { + rtsx_trace(chip); + return retval; + } retval = sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); @@ -1459,11 +1715,17 @@ static int sd_sdr_tuning_tx_cmd(struct rtsx_chip *chip, u8 sample_point) if (sd_check_err_code(chip, SD_RSP_TIMEOUT)) { rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } - RTSX_WRITE_REG(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0); + retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, + 0); + if (retval) { + rtsx_trace(chip); + return retval; + } return STATUS_SUCCESS; } @@ -1475,8 +1737,10 @@ static int sd_ddr_tuning_tx_cmd(struct rtsx_chip *chip, u8 sample_point) u8 cmd[5], bus_width; retval = sd_change_phase(chip, sample_point, TUNE_TX); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (CHK_SD(sd_card)) { bus_width = SD_BUS_WIDTH_4; @@ -1490,11 +1754,17 @@ static int sd_ddr_tuning_tx_cmd(struct rtsx_chip *chip, u8 sample_point) } retval = sd_wait_state_data_ready(chip, 0x08, 1, 1000); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } - RTSX_WRITE_REG(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, - SD_RSP_80CLK_TIMEOUT_EN); + retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, + SD_RSP_80CLK_TIMEOUT_EN); + if (retval) { + rtsx_trace(chip); + return retval; + } cmd[0] = 0x40 | PROGRAM_CSD; cmd[1] = 0; @@ -1507,10 +1777,16 @@ static int sd_ddr_tuning_tx_cmd(struct rtsx_chip *chip, u8 sample_point) if (retval != STATUS_SUCCESS) { rtsx_clear_sd_error(chip); rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } - RTSX_WRITE_REG(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0); + retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, + 0); + if (retval) { + rtsx_trace(chip); + return retval; + } sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); @@ -1524,7 +1800,8 @@ static u8 sd_search_final_phase(struct rtsx_chip *chip, u32 phase_map, struct sd_info *sd_card = &(chip->sd_card); struct timing_phase_path path[MAX_PHASE + 1]; int i, j, cont_path_cnt; - int new_block, max_len, final_path_idx; + bool new_block; + int max_len, final_path_idx; u8 final_phase = 0xFF; if (phase_map == 0xFFFFFFFF) { @@ -1537,12 +1814,12 @@ static u8 sd_search_final_phase(struct rtsx_chip *chip, u32 phase_map, } cont_path_cnt = 0; - new_block = 1; + new_block = true; j = 0; for (i = 0; i < MAX_PHASE + 1; i++) { if (phase_map & (1 << i)) { if (new_block) { - new_block = 0; + new_block = false; j = cont_path_cnt++; path[j].start = i; path[j].end = i; @@ -1550,7 +1827,7 @@ static u8 sd_search_final_phase(struct rtsx_chip *chip, u32 phase_map, path[j].end = i; } } else { - new_block = 1; + new_block = true; if (cont_path_cnt) { int idx = cont_path_cnt - 1; @@ -1654,8 +1931,10 @@ static int sd_tuning_rx(struct rtsx_chip *chip) } else { if (CHK_MMC_DDR52(sd_card)) tuning_cmd = mmc_ddr_tunning_rx_cmd; - else - TRACE_RET(chip, STATUS_FAIL); + else { + rtsx_trace(chip); + return STATUS_FAIL; + } } for (i = 0; i < 3; i++) { @@ -1663,7 +1942,8 @@ static int sd_tuning_rx(struct rtsx_chip *chip) for (j = MAX_PHASE; j >= 0; j--) { if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) { sd_set_err_code(chip, SD_NO_CARD); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } retval = tuning_cmd(chip, (u8)j); @@ -1680,12 +1960,16 @@ static int sd_tuning_rx(struct rtsx_chip *chip) dev_dbg(rtsx_dev(chip), "RX phase_map = 0x%08x\n", phase_map); final_phase = sd_search_final_phase(chip, phase_map, TUNE_RX); - if (final_phase == 0xFF) - TRACE_RET(chip, STATUS_FAIL); + if (final_phase == 0xFF) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_change_phase(chip, final_phase, TUNE_RX); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } return STATUS_SUCCESS; } @@ -1698,8 +1982,12 @@ static int sd_ddr_pre_tuning_tx(struct rtsx_chip *chip) u32 phase_map; u8 final_phase; - RTSX_WRITE_REG(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, - SD_RSP_80CLK_TIMEOUT_EN); + retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, + SD_RSP_80CLK_TIMEOUT_EN); + if (retval) { + rtsx_trace(chip); + return retval; + } phase_map = 0; for (i = MAX_PHASE; i >= 0; i--) { @@ -1707,7 +1995,8 @@ static int sd_ddr_pre_tuning_tx(struct rtsx_chip *chip) sd_set_err_code(chip, SD_NO_CARD); rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } retval = sd_change_phase(chip, (u8)i, TUNE_TX); @@ -1722,18 +2011,27 @@ static int sd_ddr_pre_tuning_tx(struct rtsx_chip *chip) phase_map |= 1 << i; } - RTSX_WRITE_REG(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0); + retval = rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, + 0); + if (retval) { + rtsx_trace(chip); + return retval; + } dev_dbg(rtsx_dev(chip), "DDR TX pre tune phase_map = 0x%08x\n", phase_map); final_phase = sd_search_final_phase(chip, phase_map, TUNE_TX); - if (final_phase == 0xFF) - TRACE_RET(chip, STATUS_FAIL); + if (final_phase == 0xFF) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_change_phase(chip, final_phase, TUNE_TX); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } dev_dbg(rtsx_dev(chip), "DDR TX pre tune phase: %d\n", (int)final_phase); @@ -1759,8 +2057,10 @@ static int sd_tuning_tx(struct rtsx_chip *chip) } else { if (CHK_MMC_DDR52(sd_card)) tuning_cmd = sd_ddr_tuning_tx_cmd; - else - TRACE_RET(chip, STATUS_FAIL); + else { + rtsx_trace(chip); + return STATUS_FAIL; + } } for (i = 0; i < 3; i++) { @@ -1770,7 +2070,8 @@ static int sd_tuning_tx(struct rtsx_chip *chip) sd_set_err_code(chip, SD_NO_CARD); rtsx_write_register(chip, SD_CFG3, SD_RSP_80CLK_TIMEOUT_EN, 0); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } retval = tuning_cmd(chip, (u8)j); @@ -1787,12 +2088,16 @@ static int sd_tuning_tx(struct rtsx_chip *chip) dev_dbg(rtsx_dev(chip), "TX phase_map = 0x%08x\n", phase_map); final_phase = sd_search_final_phase(chip, phase_map, TUNE_TX); - if (final_phase == 0xFF) - TRACE_RET(chip, STATUS_FAIL); + if (final_phase == 0xFF) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_change_phase(chip, final_phase, TUNE_TX); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } return STATUS_SUCCESS; } @@ -1802,12 +2107,16 @@ static int sd_sdr_tuning(struct rtsx_chip *chip) int retval; retval = sd_tuning_tx(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_tuning_rx(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } return STATUS_SUCCESS; } @@ -1818,23 +2127,31 @@ static int sd_ddr_tuning(struct rtsx_chip *chip) if (!(chip->sd_ctl & SD_DDR_TX_PHASE_SET_BY_USER)) { retval = sd_ddr_pre_tuning_tx(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } else { retval = sd_change_phase(chip, (u8)chip->sd_ddr_tx_phase, TUNE_TX); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } retval = sd_tuning_rx(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (!(chip->sd_ctl & SD_DDR_TX_PHASE_SET_BY_USER)) { retval = sd_tuning_tx(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } return STATUS_SUCCESS; @@ -1846,23 +2163,31 @@ static int mmc_ddr_tuning(struct rtsx_chip *chip) if (!(chip->sd_ctl & MMC_DDR_TX_PHASE_SET_BY_USER)) { retval = sd_ddr_pre_tuning_tx(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } else { retval = sd_change_phase(chip, (u8)chip->mmc_ddr_tx_phase, TUNE_TX); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } retval = sd_tuning_rx(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (!(chip->sd_ctl & MMC_DDR_TX_PHASE_SET_BY_USER)) { retval = sd_tuning_tx(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } return STATUS_SUCCESS; @@ -1875,12 +2200,16 @@ int sd_switch_clock(struct rtsx_chip *chip) int re_tuning = 0; retval = select_card(chip, SD_CARD); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = switch_clock(chip, sd_card->sd_clock); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (re_tuning) { if (CHK_SD(sd_card)) { @@ -1893,8 +2222,10 @@ int sd_switch_clock(struct rtsx_chip *chip) retval = mmc_ddr_tuning(chip); } - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } return STATUS_SUCCESS; @@ -1924,41 +2255,100 @@ static int sd_prepare_reset(struct rtsx_chip *chip) chip->sd_io = 0; retval = sd_set_init_para(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, retval); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return retval; + } - RTSX_WRITE_REG(chip, REG_SD_CFG1, 0xFF, 0x40); + retval = rtsx_write_register(chip, REG_SD_CFG1, 0xFF, 0x40); + if (retval) { + rtsx_trace(chip); + return retval; + } - RTSX_WRITE_REG(chip, CARD_STOP, SD_STOP | SD_CLR_ERR, - SD_STOP | SD_CLR_ERR); + retval = rtsx_write_register(chip, CARD_STOP, SD_STOP | SD_CLR_ERR, + SD_STOP | SD_CLR_ERR); + if (retval) { + rtsx_trace(chip); + return retval; + } retval = select_card(chip, SD_CARD); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } return STATUS_SUCCESS; } static int sd_pull_ctl_disable(struct rtsx_chip *chip) { + int retval; + if (CHECK_PID(chip, 0x5208)) { - RTSX_WRITE_REG(chip, CARD_PULL_CTL1, 0xFF, - XD_D3_PD | SD_D7_PD | SD_CLK_PD | SD_D5_PD); - RTSX_WRITE_REG(chip, CARD_PULL_CTL2, 0xFF, - SD_D6_PD | SD_D0_PD | SD_D1_PD | XD_D5_PD); - RTSX_WRITE_REG(chip, CARD_PULL_CTL3, 0xFF, - SD_D4_PD | XD_CE_PD | XD_CLE_PD | XD_CD_PU); - RTSX_WRITE_REG(chip, CARD_PULL_CTL4, 0xFF, - XD_RDY_PD | SD_D3_PD | SD_D2_PD | XD_ALE_PD); - RTSX_WRITE_REG(chip, CARD_PULL_CTL5, 0xFF, - MS_INS_PU | SD_WP_PD | SD_CD_PU | SD_CMD_PD); - RTSX_WRITE_REG(chip, CARD_PULL_CTL6, 0xFF, MS_D5_PD | MS_D4_PD); + retval = rtsx_write_register(chip, CARD_PULL_CTL1, 0xFF, + XD_D3_PD | SD_D7_PD | SD_CLK_PD | SD_D5_PD); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, CARD_PULL_CTL2, 0xFF, + SD_D6_PD | SD_D0_PD | SD_D1_PD | XD_D5_PD); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, CARD_PULL_CTL3, 0xFF, + SD_D4_PD | XD_CE_PD | XD_CLE_PD | XD_CD_PU); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, CARD_PULL_CTL4, 0xFF, + XD_RDY_PD | SD_D3_PD | SD_D2_PD | XD_ALE_PD); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, CARD_PULL_CTL5, 0xFF, + MS_INS_PU | SD_WP_PD | SD_CD_PU | SD_CMD_PD); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, CARD_PULL_CTL6, 0xFF, + MS_D5_PD | MS_D4_PD); + if (retval) { + rtsx_trace(chip); + return retval; + } } else if (CHECK_PID(chip, 0x5288)) { if (CHECK_BARO_PKG(chip, QFN)) { - RTSX_WRITE_REG(chip, CARD_PULL_CTL1, 0xFF, 0x55); - RTSX_WRITE_REG(chip, CARD_PULL_CTL2, 0xFF, 0x55); - RTSX_WRITE_REG(chip, CARD_PULL_CTL3, 0xFF, 0x4B); - RTSX_WRITE_REG(chip, CARD_PULL_CTL4, 0xFF, 0x69); + retval = rtsx_write_register(chip, CARD_PULL_CTL1, + 0xFF, 0x55); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, CARD_PULL_CTL2, + 0xFF, 0x55); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, CARD_PULL_CTL3, + 0xFF, 0x4B); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, CARD_PULL_CTL4, + 0xFF, 0x69); + if (retval) { + rtsx_trace(chip); + return retval; + } } } @@ -1998,8 +2388,10 @@ int sd_pull_ctl_enable(struct rtsx_chip *chip) } retval = rtsx_send_cmd(chip, SD_CARD, 100); - if (retval < 0) - TRACE_RET(chip, STATUS_FAIL); + if (retval < 0) { + rtsx_trace(chip); + return STATUS_FAIL; + } return STATUS_SUCCESS; } @@ -2009,29 +2401,41 @@ static int sd_init_power(struct rtsx_chip *chip) int retval; retval = sd_power_off_card3v3(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (!chip->ft2_fast_mode) wait_timeout(250); retval = enable_card_clock(chip, SD_CARD); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (chip->asic_code) { retval = sd_pull_ctl_enable(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } else { - RTSX_WRITE_REG(chip, FPGA_PULL_CTL, FPGA_SD_PULL_CTL_BIT | 0x20, - 0); + retval = rtsx_write_register(chip, FPGA_PULL_CTL, + FPGA_SD_PULL_CTL_BIT | 0x20, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } } if (!chip->ft2_fast_mode) { retval = card_power_on(chip, SD_CARD); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } wait_timeout(260); @@ -2039,21 +2443,37 @@ static int sd_init_power(struct rtsx_chip *chip) if (chip->ocp_stat & (SD_OC_NOW | SD_OC_EVER)) { dev_dbg(rtsx_dev(chip), "Over current, OCPSTAT is 0x%x\n", chip->ocp_stat); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } #endif } - RTSX_WRITE_REG(chip, CARD_OE, SD_OUTPUT_EN, SD_OUTPUT_EN); + retval = rtsx_write_register(chip, CARD_OE, SD_OUTPUT_EN, + SD_OUTPUT_EN); + if (retval) { + rtsx_trace(chip); + return retval; + } return STATUS_SUCCESS; } static int sd_dummy_clock(struct rtsx_chip *chip) { - RTSX_WRITE_REG(chip, REG_SD_CFG3, 0x01, 0x01); + int retval; + + retval = rtsx_write_register(chip, REG_SD_CFG3, 0x01, 0x01); + if (retval) { + rtsx_trace(chip); + return retval; + } wait_timeout(5); - RTSX_WRITE_REG(chip, REG_SD_CFG3, 0x01, 0); + retval = rtsx_write_register(chip, REG_SD_CFG3, 0x01, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } return STATUS_SUCCESS; } @@ -2085,7 +2505,8 @@ static int sd_read_lba0(struct rtsx_chip *chip) 5, 512, 1, bus_width, NULL, 0, 100); if (retval != STATUS_SUCCESS) { rtsx_clear_sd_error(chip); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } return STATUS_SUCCESS; @@ -2101,8 +2522,10 @@ static int sd_check_wp_state(struct rtsx_chip *chip) retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } cmd[0] = 0x40 | SD_STATUS; cmd[1] = 0; @@ -2117,7 +2540,8 @@ static int sd_check_wp_state(struct rtsx_chip *chip) sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } dev_dbg(rtsx_dev(chip), "ACMD13:\n"); @@ -2141,14 +2565,15 @@ static int sd_check_wp_state(struct rtsx_chip *chip) static int reset_sd(struct rtsx_chip *chip) { struct sd_info *sd_card = &(chip->sd_card); - int retval, i = 0, j = 0, k = 0, hi_cap_flow = 0; - int sd_dont_switch = 0; - int support_1v8 = 0; - int try_sdio = 1; + bool hi_cap_flow = false; + int retval, i = 0, j = 0, k = 0; + bool sd_dont_switch = false; + bool support_1v8 = false; + bool try_sdio = true; u8 rsp[16]; u8 switch_bus_width; u32 voltage = 0; - int sd20_mode = 0; + bool sd20_mode = false; SET_SD(sd_card); @@ -2157,7 +2582,7 @@ Switch_Fail: i = 0; j = 0; k = 0; - hi_cap_flow = 0; + hi_cap_flow = false; #ifdef SUPPORT_SD_LOCK if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON) @@ -2165,12 +2590,16 @@ Switch_Fail: #endif retval = sd_prepare_reset(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_dummy_clock(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip) && try_sdio) { int rty_cnt = 0; @@ -2178,7 +2607,8 @@ Switch_Fail: for (; rty_cnt < chip->sdio_retry_cnt; rty_cnt++) { if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) { sd_set_err_code(chip, SD_NO_CARD); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } retval = sd_send_cmd_get_rsp(chip, IO_SEND_OP_COND, 0, @@ -2190,7 +2620,8 @@ Switch_Fail: dev_dbg(rtsx_dev(chip), "SD_IO card (Function number: %d)!\n", func_num); chip->sd_io = 1; - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } break; @@ -2208,8 +2639,10 @@ Switch_Fail: RTY_SD_RST: retval = sd_send_cmd_get_rsp(chip, GO_IDLE_STATE, 0, SD_RSP_TYPE_R0, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } wait_timeout(20); @@ -2217,7 +2650,7 @@ RTY_SD_RST: SD_RSP_TYPE_R7, rsp, 5); if (retval == STATUS_SUCCESS) { if ((rsp[4] == 0xAA) && ((rsp[3] & 0x0f) == 0x01)) { - hi_cap_flow = 1; + hi_cap_flow = true; voltage = SUPPORT_VOLTAGE | 0x40000000; } } @@ -2227,8 +2660,10 @@ RTY_SD_RST: retval = sd_send_cmd_get_rsp(chip, GO_IDLE_STATE, 0, SD_RSP_TYPE_R0, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } wait_timeout(20); } @@ -2239,14 +2674,17 @@ RTY_SD_RST: if (retval != STATUS_SUCCESS) { if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) { sd_set_err_code(chip, SD_NO_CARD); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } j++; if (j < 3) goto RTY_SD_RST; - else - TRACE_RET(chip, STATUS_FAIL); + else { + rtsx_trace(chip); + return STATUS_FAIL; + } } retval = sd_send_cmd_get_rsp(chip, SD_APP_OP_COND, voltage, @@ -2255,16 +2693,20 @@ RTY_SD_RST: k++; if (k < 3) goto RTY_SD_RST; - else - TRACE_RET(chip, STATUS_FAIL); + else { + rtsx_trace(chip); + return STATUS_FAIL; + } } i++; wait_timeout(20); } while (!(rsp[1] & 0x80) && (i < 255)); - if (i == 255) - TRACE_RET(chip, STATUS_FAIL); + if (i == 255) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (hi_cap_flow) { if (rsp[1] & 0x40) @@ -2272,29 +2714,35 @@ RTY_SD_RST: else CLR_SD_HCXC(sd_card); - support_1v8 = 0; + support_1v8 = false; } else { CLR_SD_HCXC(sd_card); - support_1v8 = 0; + support_1v8 = false; } dev_dbg(rtsx_dev(chip), "support_1v8 = %d\n", support_1v8); if (support_1v8) { retval = sd_voltage_switch(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } retval = sd_send_cmd_get_rsp(chip, ALL_SEND_CID, 0, SD_RSP_TYPE_R2, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } for (i = 0; i < 3; i++) { retval = sd_send_cmd_get_rsp(chip, SEND_RELATIVE_ADDR, 0, SD_RSP_TYPE_R6, rsp, 5); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } sd_card->sd_addr = (u32)rsp[1] << 24; sd_card->sd_addr += (u32)rsp[2] << 16; @@ -2304,18 +2752,24 @@ RTY_SD_RST: } retval = sd_check_csd(chip, 1); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_select_card(chip, 1); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } #ifdef SUPPORT_SD_LOCK SD_UNLOCK_ENTRY: retval = sd_update_lock_status(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (sd_card->sd_lock_status & SD_LOCKED) { sd_card->sd_lock_status |= (SD_LOCK_1BIT_MODE | SD_PWD_EXIST); @@ -2327,24 +2781,32 @@ SD_UNLOCK_ENTRY: retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_send_cmd_get_rsp(chip, SET_CLR_CARD_DETECT, 0, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (support_1v8) { retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_send_cmd_get_rsp(chip, SET_BUS_WIDTH, 2, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } switch_bus_width = SD_BUS_WIDTH_4; } else { @@ -2353,15 +2815,19 @@ SD_UNLOCK_ENTRY: retval = sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (!(sd_card->raw_csd[4] & 0x40)) - sd_dont_switch = 1; + sd_dont_switch = true; if (!sd_dont_switch) { if (sd20_mode) { @@ -2378,16 +2844,16 @@ SD_UNLOCK_ENTRY: retval = sd_switch_function(chip, switch_bus_width); if (retval != STATUS_SUCCESS) { sd_init_power(chip); - sd_dont_switch = 1; - try_sdio = 0; + sd_dont_switch = true; + try_sdio = false; goto Switch_Fail; } } else { if (support_1v8) { sd_init_power(chip); - sd_dont_switch = 1; - try_sdio = 0; + sd_dont_switch = true; + try_sdio = false; goto Switch_Fail; } @@ -2397,13 +2863,17 @@ SD_UNLOCK_ENTRY: if (!support_1v8) { retval = sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_send_cmd_get_rsp(chip, SET_BUS_WIDTH, 2, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } #ifdef SUPPORT_SD_LOCK @@ -2413,12 +2883,18 @@ SD_UNLOCK_ENTRY: if (!sd20_mode && CHK_SD30_SPEED(sd_card)) { int read_lba0 = 1; - RTSX_WRITE_REG(chip, SD30_DRIVE_SEL, 0x07, - chip->sd30_drive_sel_1v8); + retval = rtsx_write_register(chip, SD30_DRIVE_SEL, 0x07, + chip->sd30_drive_sel_1v8); + if (retval) { + rtsx_trace(chip); + return retval; + } retval = sd_set_init_para(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (CHK_SD_DDR50(sd_card)) retval = sd_ddr_tuning(chip); @@ -2427,14 +2903,17 @@ SD_UNLOCK_ENTRY: if (retval != STATUS_SUCCESS) { if (sd20_mode) { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } else { retval = sd_init_power(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } - try_sdio = 0; - sd20_mode = 1; + try_sdio = false; + sd20_mode = true; goto Switch_Fail; } } @@ -2452,14 +2931,17 @@ SD_UNLOCK_ENTRY: retval = sd_read_lba0(chip); if (retval != STATUS_SUCCESS) { if (sd20_mode) { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } else { retval = sd_init_power(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } - try_sdio = 0; - sd20_mode = 1; + try_sdio = false; + sd20_mode = true; goto Switch_Fail; } } @@ -2467,15 +2949,27 @@ SD_UNLOCK_ENTRY: } retval = sd_check_wp_state(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } chip->card_bus_width[chip->card2lun[SD_CARD]] = 4; #ifdef SUPPORT_SD_LOCK if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON) { - RTSX_WRITE_REG(chip, REG_SD_BLOCK_CNT_H, 0xFF, 0x02); - RTSX_WRITE_REG(chip, REG_SD_BLOCK_CNT_L, 0xFF, 0x00); + retval = rtsx_write_register(chip, REG_SD_BLOCK_CNT_H, 0xFF, + 0x02); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, REG_SD_BLOCK_CNT_L, 0xFF, + 0x00); + if (retval) { + rtsx_trace(chip); + return retval; + } } #endif @@ -2493,8 +2987,10 @@ static int mmc_test_switch_bus(struct rtsx_chip *chip, u8 width) retval = sd_send_cmd_get_rsp(chip, BUSTEST_W, 0, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, SWITCH_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return SWITCH_FAIL; + } if (width == MMC_8BIT_BUS) { buf[0] = 0x55; @@ -2510,20 +3006,25 @@ static int mmc_test_switch_bus(struct rtsx_chip *chip, u8 width) } retval = rtsx_write_register(chip, REG_SD_CFG3, 0x02, 0x02); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, SWITCH_ERR); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return SWITCH_ERR; + } retval = sd_write_data(chip, SD_TM_AUTO_WRITE_3, NULL, 0, byte_cnt, 1, bus_width, buf, len, 100); if (retval != STATUS_SUCCESS) { rtsx_clear_sd_error(chip); rtsx_write_register(chip, REG_SD_CFG3, 0x02, 0); - TRACE_RET(chip, SWITCH_ERR); + rtsx_trace(chip); + return SWITCH_ERR; } retval = rtsx_write_register(chip, REG_SD_CFG3, 0x02, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, SWITCH_ERR); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return SWITCH_ERR; + } dev_dbg(rtsx_dev(chip), "SD/MMC CMD %d\n", BUSTEST_R); @@ -2558,7 +3059,8 @@ static int mmc_test_switch_bus(struct rtsx_chip *chip, u8 width) retval = rtsx_send_cmd(chip, SD_CARD, 100); if (retval < 0) { rtsx_clear_sd_error(chip); - TRACE_RET(chip, SWITCH_ERR); + rtsx_trace(chip); + return SWITCH_ERR; } ptr = rtsx_get_cmd_data(chip) + 1; @@ -2600,11 +3102,12 @@ static int mmc_test_switch_bus(struct rtsx_chip *chip, u8 width) } } - TRACE_RET(chip, SWITCH_FAIL); + rtsx_trace(chip); + return SWITCH_FAIL; } -static int mmc_switch_timing_bus(struct rtsx_chip *chip, int switch_ddr) +static int mmc_switch_timing_bus(struct rtsx_chip *chip, bool switch_ddr) { struct sd_info *sd_card = &(chip->sd_card); int retval; @@ -2651,14 +3154,16 @@ static int mmc_switch_timing_bus(struct rtsx_chip *chip, int switch_ddr) sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); } - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } ptr = rtsx_get_cmd_data(chip); if (ptr[0] & SD_TRANSFER_ERR) { sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (CHK_MMC_SECTOR_MODE(sd_card)) { @@ -2690,8 +3195,10 @@ static int mmc_switch_timing_bus(struct rtsx_chip *chip, int switch_ddr) sd_choose_proper_clock(chip); retval = switch_clock(chip, sd_card->sd_clock); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } /* Test Bus Procedure */ retval = mmc_test_switch_bus(chip, MMC_8BIT_BUS); @@ -2713,10 +3220,12 @@ static int mmc_switch_timing_bus(struct rtsx_chip *chip, int switch_ddr) CLR_MMC_8BIT(sd_card); CLR_MMC_4BIT(sd_card); } else { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } else { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } return STATUS_SUCCESS; @@ -2727,7 +3236,7 @@ static int reset_mmc(struct rtsx_chip *chip) { struct sd_info *sd_card = &(chip->sd_card); int retval, i = 0, j = 0, k = 0; - int switch_ddr = 1; + bool switch_ddr = true; u8 rsp[16]; u8 spec_ver = 0; u32 temp; @@ -2739,21 +3248,26 @@ static int reset_mmc(struct rtsx_chip *chip) Switch_Fail: retval = sd_prepare_reset(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, retval); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return retval; + } SET_MMC(sd_card); RTY_MMC_RST: retval = sd_send_cmd_get_rsp(chip, GO_IDLE_STATE, 0, SD_RSP_TYPE_R0, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } do { if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) { sd_set_err_code(chip, SD_NO_CARD); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } retval = sd_send_cmd_get_rsp(chip, SEND_OP_COND, @@ -2767,7 +3281,8 @@ RTY_MMC_RST: sd_clr_err_code(chip); goto RTY_MMC_RST; } else { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } else { j++; @@ -2775,7 +3290,8 @@ RTY_MMC_RST: sd_clr_err_code(chip); goto RTY_MMC_RST; } else { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } } @@ -2784,8 +3300,10 @@ RTY_MMC_RST: i++; } while (!(rsp[1] & 0x80) && (i < 255)); - if (i == 255) - TRACE_RET(chip, STATUS_FAIL); + if (i == 255) { + rtsx_trace(chip); + return STATUS_FAIL; + } if ((rsp[1] & 0x60) == 0x40) SET_MMC_SECTOR_MODE(sd_card); @@ -2794,40 +3312,54 @@ RTY_MMC_RST: retval = sd_send_cmd_get_rsp(chip, ALL_SEND_CID, 0, SD_RSP_TYPE_R2, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } sd_card->sd_addr = 0x00100000; retval = sd_send_cmd_get_rsp(chip, SET_RELATIVE_ADDR, sd_card->sd_addr, SD_RSP_TYPE_R6, rsp, 5); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_check_csd(chip, 1); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } spec_ver = (sd_card->raw_csd[0] & 0x3C) >> 2; retval = sd_select_card(chip, 1); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } #ifdef SUPPORT_SD_LOCK MMC_UNLOCK_ENTRY: retval = sd_update_lock_status(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } #endif retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } chip->card_bus_width[chip->card2lun[SD_CARD]] = 1; @@ -2837,29 +3369,39 @@ MMC_UNLOCK_ENTRY: retval = mmc_switch_timing_bus(chip, switch_ddr); if (retval != STATUS_SUCCESS) { retval = sd_init_power(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } sd_card->mmc_dont_switch_bus = 1; - TRACE_GOTO(chip, Switch_Fail); + rtsx_trace(chip); + goto Switch_Fail; } } - if (CHK_MMC_SECTOR_MODE(sd_card) && (sd_card->capacity == 0)) - TRACE_RET(chip, STATUS_FAIL); + if (CHK_MMC_SECTOR_MODE(sd_card) && (sd_card->capacity == 0)) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (switch_ddr && CHK_MMC_DDR52(sd_card)) { retval = sd_set_init_para(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = mmc_ddr_tuning(chip); if (retval != STATUS_SUCCESS) { retval = sd_init_power(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } - switch_ddr = 0; - TRACE_GOTO(chip, Switch_Fail); + switch_ddr = false; + rtsx_trace(chip); + goto Switch_Fail; } retval = sd_wait_state_data_ready(chip, 0x08, 1, 1000); @@ -2867,11 +3409,14 @@ MMC_UNLOCK_ENTRY: retval = sd_read_lba0(chip); if (retval != STATUS_SUCCESS) { retval = sd_init_power(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } - switch_ddr = 0; - TRACE_GOTO(chip, Switch_Fail); + switch_ddr = false; + rtsx_trace(chip); + goto Switch_Fail; } } } @@ -2879,8 +3424,18 @@ MMC_UNLOCK_ENTRY: #ifdef SUPPORT_SD_LOCK if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON) { - RTSX_WRITE_REG(chip, REG_SD_BLOCK_CNT_H, 0xFF, 0x02); - RTSX_WRITE_REG(chip, REG_SD_BLOCK_CNT_L, 0xFF, 0x00); + retval = rtsx_write_register(chip, REG_SD_BLOCK_CNT_H, 0xFF, + 0x02); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, REG_SD_BLOCK_CNT_L, 0xFF, + 0x00); + if (retval) { + rtsx_trace(chip); + return retval; + } } #endif @@ -2902,71 +3457,103 @@ int reset_sd_card(struct rtsx_chip *chip) chip->capacity[chip->card2lun[SD_CARD]] = 0; retval = enable_card_clock(chip, SD_CARD); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (chip->ignore_sd && CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) { if (chip->asic_code) { retval = sd_pull_ctl_enable(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } else { retval = rtsx_write_register(chip, FPGA_PULL_CTL, FPGA_SD_PULL_CTL_BIT | 0x20, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } retval = card_share_mode(chip, SD_CARD); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } chip->sd_io = 1; - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } retval = sd_init_power(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (chip->sd_ctl & RESET_MMC_FIRST) { retval = reset_mmc(chip); if (retval != STATUS_SUCCESS) { - if (sd_check_err_code(chip, SD_NO_CARD)) - TRACE_RET(chip, STATUS_FAIL); + if (sd_check_err_code(chip, SD_NO_CARD)) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = reset_sd(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } } else { retval = reset_sd(chip); if (retval != STATUS_SUCCESS) { - if (sd_check_err_code(chip, SD_NO_CARD)) - TRACE_RET(chip, STATUS_FAIL); + if (sd_check_err_code(chip, SD_NO_CARD)) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (chip->sd_io) { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } else { retval = reset_mmc(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } } } retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } - RTSX_WRITE_REG(chip, REG_SD_BYTE_CNT_L, 0xFF, 0); - RTSX_WRITE_REG(chip, REG_SD_BYTE_CNT_H, 0xFF, 2); + retval = rtsx_write_register(chip, REG_SD_BYTE_CNT_L, 0xFF, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, REG_SD_BYTE_CNT_H, 0xFF, 2); + if (retval) { + rtsx_trace(chip); + return retval; + } chip->capacity[chip->card2lun[SD_CARD]] = sd_card->capacity; retval = sd_set_init_para(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } dev_dbg(rtsx_dev(chip), "sd_card->sd_type = 0x%x\n", sd_card->sd_type); @@ -2992,29 +3579,47 @@ static int reset_mmc_only(struct rtsx_chip *chip) chip->capacity[chip->card2lun[SD_CARD]] = sd_card->capacity = 0; retval = enable_card_clock(chip, SD_CARD); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_init_power(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = reset_mmc(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } retval = sd_set_clock_divider(chip, SD_CLK_DIVIDE_0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } - RTSX_WRITE_REG(chip, REG_SD_BYTE_CNT_L, 0xFF, 0); - RTSX_WRITE_REG(chip, REG_SD_BYTE_CNT_H, 0xFF, 2); + retval = rtsx_write_register(chip, REG_SD_BYTE_CNT_L, 0xFF, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } + retval = rtsx_write_register(chip, REG_SD_BYTE_CNT_H, 0xFF, 2); + if (retval) { + rtsx_trace(chip); + return retval; + } chip->capacity[chip->card2lun[SD_CARD]] = sd_card->capacity; retval = sd_set_init_para(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } dev_dbg(rtsx_dev(chip), "In reset_mmc_only, sd_card->sd_type = 0x%x\n", sd_card->sd_type); @@ -3032,15 +3637,18 @@ static int wait_data_buf_ready(struct rtsx_chip *chip) for (i = 0; i < WAIT_DATA_READY_RTY_CNT; i++) { if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) { sd_set_err_code(chip, SD_NO_CARD); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } sd_card->sd_data_buf_ready = 0; retval = sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr, SD_RSP_TYPE_R1, NULL, 0); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (sd_card->sd_data_buf_ready) { return sd_send_cmd_get_rsp(chip, SEND_STATUS, @@ -3050,7 +3658,8 @@ static int wait_data_buf_ready(struct rtsx_chip *chip) sd_set_err_code(chip, SD_TO_ERR); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } void sd_stop_seq_mode(struct rtsx_chip *chip) @@ -3118,8 +3727,10 @@ static inline int sd_auto_tune_clock(struct rtsx_chip *chip) } retval = sd_switch_clock(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } return STATUS_SUCCESS; } @@ -3156,7 +3767,8 @@ int sd_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip, u32 start_sector, chip->card_fail |= SD_CARD; chip->capacity[chip->card2lun[SD_CARD]] = 0; chip->rw_need_retry = 1; - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } @@ -3170,7 +3782,8 @@ int sd_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip, u32 start_sector, retval = sd_switch_clock(chip); if (retval != STATUS_SUCCESS) { sd_set_err_code(chip, SD_IO_ERR); - TRACE_GOTO(chip, RW_FAIL); + rtsx_trace(chip); + goto RW_FAIL; } if (sd_card->seq_mode && @@ -3191,7 +3804,8 @@ int sd_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip, u32 start_sector, if (retval != STATUS_SUCCESS) { chip->rw_need_retry = 1; sd_set_err_code(chip, SD_STS_ERR); - TRACE_GOTO(chip, RW_FAIL); + rtsx_trace(chip); + goto RW_FAIL; } sd_card->seq_mode = 0; @@ -3199,7 +3813,8 @@ int sd_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip, u32 start_sector, retval = rtsx_write_register(chip, RBCTL, RB_FLUSH, RB_FLUSH); if (retval != STATUS_SUCCESS) { sd_set_err_code(chip, SD_IO_ERR); - TRACE_GOTO(chip, RW_FAIL); + rtsx_trace(chip); + goto RW_FAIL; } if ((sd_card->pre_sec_cnt < 0x80) @@ -3290,21 +3905,24 @@ int sd_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip, u32 start_sector, chip->rw_need_retry = 1; sd_set_err_code(chip, SD_TO_ERR); - TRACE_GOTO(chip, RW_FAIL); + rtsx_trace(chip); + goto RW_FAIL; } retval = wait_data_buf_ready(chip); if (retval != STATUS_SUCCESS) { chip->rw_need_retry = 1; sd_set_err_code(chip, SD_TO_ERR); - TRACE_GOTO(chip, RW_FAIL); + rtsx_trace(chip); + goto RW_FAIL; } retval = sd_send_cmd_get_rsp(chip, WRITE_MULTIPLE_BLOCK, data_addr, SD_RSP_TYPE_R1, NULL, 0); if (retval != STATUS_SUCCESS) { chip->rw_need_retry = 1; - TRACE_GOTO(chip, RW_FAIL); + rtsx_trace(chip); + goto RW_FAIL; } rtsx_init_cmd(chip); @@ -3348,7 +3966,8 @@ int sd_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip, u32 start_sector, if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) { chip->rw_need_retry = 0; dev_dbg(rtsx_dev(chip), "No card exist, exit sd_rw\n"); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } chip->rw_need_retry = 1; @@ -3357,21 +3976,25 @@ int sd_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip, u32 start_sector, SD_RSP_TYPE_R1b, NULL, 0); if (retval != STATUS_SUCCESS) { sd_set_err_code(chip, SD_STS_ERR); - TRACE_GOTO(chip, RW_FAIL); + rtsx_trace(chip); + goto RW_FAIL; } if (stat & (SD_CRC7_ERR | SD_CRC16_ERR | SD_CRC_WRITE_ERR)) { dev_dbg(rtsx_dev(chip), "SD CRC error, tune clock!\n"); sd_set_err_code(chip, SD_CRC_ERR); - TRACE_GOTO(chip, RW_FAIL); + rtsx_trace(chip); + goto RW_FAIL; } if (err == STATUS_TIMEDOUT) { sd_set_err_code(chip, SD_TO_ERR); - TRACE_GOTO(chip, RW_FAIL); + rtsx_trace(chip); + goto RW_FAIL; } - TRACE_RET(chip, err); + rtsx_trace(chip); + return err; } sd_card->pre_sec_addr = start_sector; @@ -3386,7 +4009,8 @@ RW_FAIL: if (detect_card_cd(chip, SD_CARD) != STATUS_SUCCESS) { chip->rw_need_retry = 0; dev_dbg(rtsx_dev(chip), "No card exist, exit sd_rw\n"); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (sd_check_err_code(chip, SD_CRC_ERR)) { @@ -3407,7 +4031,8 @@ RW_FAIL: } } - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } #ifdef SUPPORT_CPRM @@ -3417,7 +4042,7 @@ int soft_reset_sd_card(struct rtsx_chip *chip) } int ext_sd_send_cmd_get_rsp(struct rtsx_chip *chip, u8 cmd_idx, - u32 arg, u8 rsp_type, u8 *rsp, int rsp_len, int special_check) + u32 arg, u8 rsp_type, u8 *rsp, int rsp_len, bool special_check) { int retval; int timeout = 100; @@ -3473,13 +4098,16 @@ RTY_SEND_CMD: if (rsp_type & SD_WAIT_BUSY_END) { retval = sd_check_data0_status(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, retval); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return retval; + } } else { sd_set_err_code(chip, SD_TO_ERR); } } - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (rsp_type == SD_RSP_TYPE_R0) @@ -3489,14 +4117,16 @@ RTY_SEND_CMD: if ((ptr[0] & 0xC0) != 0) { sd_set_err_code(chip, SD_STS_ERR); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (!(rsp_type & SD_NO_CHECK_CRC7)) { if (ptr[stat_idx] & SD_CRC7_ERR) { if (cmd_idx == WRITE_MULTIPLE_BLOCK) { sd_set_err_code(chip, SD_CRC_ERR); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } if (rty_cnt < SD_MAX_RETRY_COUNT) { wait_timeout(20); @@ -3504,16 +4134,19 @@ RTY_SEND_CMD: goto RTY_SEND_CMD; } else { sd_set_err_code(chip, SD_CRC_ERR); - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; } } } if ((cmd_idx == SELECT_CARD) || (cmd_idx == APP_CMD) || (cmd_idx == SEND_STATUS) || (cmd_idx == STOP_TRANSMISSION)) { - if ((cmd_idx != STOP_TRANSMISSION) && (special_check == 0)) { - if (ptr[1] & 0x80) - TRACE_RET(chip, STATUS_FAIL); + if ((cmd_idx != STOP_TRANSMISSION) && !special_check) { + if (ptr[1] & 0x80) { + rtsx_trace(chip); + return STATUS_FAIL; + } } #ifdef SUPPORT_SD_LOCK if (ptr[1] & 0x7D) @@ -3521,19 +4154,26 @@ RTY_SEND_CMD: if (ptr[1] & 0x7F) #endif { - TRACE_RET(chip, STATUS_FAIL); + rtsx_trace(chip); + return STATUS_FAIL; + } + if (ptr[2] & 0xF8) { + rtsx_trace(chip); + return STATUS_FAIL; } - if (ptr[2] & 0xF8) - TRACE_RET(chip, STATUS_FAIL); if (cmd_idx == SELECT_CARD) { if (rsp_type == SD_RSP_TYPE_R2) { - if ((ptr[3] & 0x1E) != 0x04) - TRACE_RET(chip, STATUS_FAIL); + if ((ptr[3] & 0x1E) != 0x04) { + rtsx_trace(chip); + return STATUS_FAIL; + } } else if (rsp_type == SD_RSP_TYPE_R0) { - if ((ptr[3] & 0x1E) != 0x03) - TRACE_RET(chip, STATUS_FAIL); + if ((ptr[3] & 0x1E) != 0x03) { + rtsx_trace(chip); + return STATUS_FAIL; + } } } } @@ -3570,8 +4210,10 @@ int ext_sd_get_rsp(struct rtsx_chip *chip, int len, u8 *rsp, u8 rsp_type) rtsx_add_cmd(chip, READ_REG_CMD, REG_SD_CMD5, 0xFF, 0); retval = rtsx_send_cmd(chip, SD_CARD, 100); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } if (rsp) { int min_len = (rsp_len < len) ? rsp_len : len; @@ -3617,7 +4259,8 @@ int sd_pass_thru_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip) if (!(CHK_BIT(chip->lun_mc, lun))) { SET_BIT(chip->lun_mc, lun); set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } if ((0x53 != srb->cmnd[2]) || (0x44 != srb->cmnd[3]) || @@ -3625,7 +4268,8 @@ int sd_pass_thru_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip) (0x61 != srb->cmnd[6]) || (0x72 != srb->cmnd[7]) || (0x64 != srb->cmnd[8])) { set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } switch (srb->cmnd[1] & 0x0F) { @@ -3639,7 +4283,8 @@ int sd_pass_thru_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip) default: set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } buf[5] = (1 == CHK_SD(sd_card)) ? 0x01 : 0x02; @@ -3702,30 +4347,34 @@ int sd_execute_no_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) unsigned int lun = SCSI_LUN(srb); int retval, rsp_len; u8 cmd_idx, rsp_type; - u8 standby = 0, acmd = 0; + bool standby = false, acmd = false; u32 arg; if (!sd_card->sd_pass_thru_en) { set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } retval = sd_switch_clock(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, TRANSPORT_FAILED); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return TRANSPORT_FAILED; + } if (sd_card->pre_cmd_err) { sd_card->pre_cmd_err = 0; set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } cmd_idx = srb->cmnd[2] & 0x3F; if (srb->cmnd[1] & 0x02) - standby = 1; + standby = true; if (srb->cmnd[1] & 0x01) - acmd = 1; + acmd = true; arg = ((u32)srb->cmnd[3] << 24) | ((u32)srb->cmnd[4] << 16) | ((u32)srb->cmnd[5] << 8) | srb->cmnd[6]; @@ -3733,64 +4382,83 @@ int sd_execute_no_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) retval = get_rsp_type(srb, &rsp_type, &rsp_len); if (retval != STATUS_SUCCESS) { set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } sd_card->last_rsp_type = rsp_type; retval = sd_switch_clock(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, TRANSPORT_FAILED); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return TRANSPORT_FAILED; + } #ifdef SUPPORT_SD_LOCK if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) { if (CHK_MMC_8BIT(sd_card)) { retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_8); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, TRANSPORT_FAILED); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return TRANSPORT_FAILED; + } } else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card)) { retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, TRANSPORT_FAILED); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return TRANSPORT_FAILED; + } } } #else retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, TRANSPORT_FAILED); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return TRANSPORT_FAILED; + } #endif if (standby) { retval = sd_select_card(chip, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Cmd_Failed; + } } if (acmd) { retval = ext_sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, - SD_RSP_TYPE_R1, NULL, 0, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Cmd_Failed); + SD_RSP_TYPE_R1, NULL, 0, false); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Cmd_Failed; + } } retval = ext_sd_send_cmd_get_rsp(chip, cmd_idx, arg, rsp_type, - sd_card->rsp, rsp_len, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Cmd_Failed); + sd_card->rsp, rsp_len, false); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Cmd_Failed; + } if (standby) { retval = sd_select_card(chip, 1); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Cmd_Failed; + } } #ifdef SUPPORT_SD_LOCK retval = sd_update_lock_status(chip); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Cmd_Failed; + } #endif scsi_set_resid(srb, 0); @@ -3804,7 +4472,8 @@ SD_Execute_Cmd_Failed: if (!(chip->card_ready & SD_CARD)) set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } int sd_execute_read_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) @@ -3812,35 +4481,39 @@ int sd_execute_read_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) struct sd_info *sd_card = &(chip->sd_card); unsigned int lun = SCSI_LUN(srb); int retval, rsp_len, i; - int cmd13_checkbit = 0, read_err = 0; + bool read_err = false, cmd13_checkbit = false; u8 cmd_idx, rsp_type, bus_width; - u8 send_cmd12 = 0, standby = 0, acmd = 0; + bool standby = false, send_cmd12 = false, acmd = false; u32 data_len; if (!sd_card->sd_pass_thru_en) { set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } if (sd_card->pre_cmd_err) { sd_card->pre_cmd_err = 0; set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } retval = sd_switch_clock(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, TRANSPORT_FAILED); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return TRANSPORT_FAILED; + } cmd_idx = srb->cmnd[2] & 0x3F; if (srb->cmnd[1] & 0x04) - send_cmd12 = 1; + send_cmd12 = true; if (srb->cmnd[1] & 0x02) - standby = 1; + standby = true; if (srb->cmnd[1] & 0x01) - acmd = 1; + acmd = true; data_len = ((u32)srb->cmnd[7] << 16) | ((u32)srb->cmnd[8] << 8) | srb->cmnd[9]; @@ -3848,13 +4521,16 @@ int sd_execute_read_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) retval = get_rsp_type(srb, &rsp_type, &rsp_len); if (retval != STATUS_SUCCESS) { set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } sd_card->last_rsp_type = rsp_type; retval = sd_switch_clock(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, TRANSPORT_FAILED); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return TRANSPORT_FAILED; + } #ifdef SUPPORT_SD_LOCK if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) { @@ -3874,23 +4550,29 @@ int sd_execute_read_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) if (data_len < 512) { retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len, - SD_RSP_TYPE_R1, NULL, 0, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + SD_RSP_TYPE_R1, NULL, 0, false); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; + } } if (standby) { retval = sd_select_card(chip, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; + } } if (acmd) { retval = ext_sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, - SD_RSP_TYPE_R1, NULL, 0, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + SD_RSP_TYPE_R1, NULL, 0, false); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; + } } if (data_len <= 512) { @@ -3909,16 +4591,19 @@ int sd_execute_read_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) cmd[4] = srb->cmnd[6]; buf = kmalloc(data_len, GFP_KERNEL); - if (buf == NULL) - TRACE_RET(chip, TRANSPORT_ERROR); + if (buf == NULL) { + rtsx_trace(chip); + return TRANSPORT_ERROR; + } retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, byte_cnt, blk_cnt, bus_width, buf, data_len, 2000); if (retval != STATUS_SUCCESS) { - read_err = 1; + read_err = true; kfree(buf); rtsx_clear_sd_error(chip); - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; } min_len = min(data_len, scsi_bufflen(srb)); @@ -3964,49 +4649,63 @@ int sd_execute_read_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) scsi_bufflen(srb), scsi_sg_count(srb), DMA_FROM_DEVICE, 10000); if (retval < 0) { - read_err = 1; + read_err = true; rtsx_clear_sd_error(chip); - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; } } else { - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; } retval = ext_sd_get_rsp(chip, rsp_len, sd_card->rsp, rsp_type); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; + } if (standby) { retval = sd_select_card(chip, 1); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; + } } if (send_cmd12) { retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION, - 0, SD_RSP_TYPE_R1b, NULL, 0, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + 0, SD_RSP_TYPE_R1b, NULL, 0, false); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; + } } if (data_len < 512) { retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200, - SD_RSP_TYPE_R1, NULL, 0, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + SD_RSP_TYPE_R1, NULL, 0, false); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; + } retval = rtsx_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; + } retval = rtsx_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; + } } if ((srb->cmnd[1] & 0x02) || (srb->cmnd[1] & 0x04)) - cmd13_checkbit = 1; + cmd13_checkbit = true; for (i = 0; i < 3; i++) { retval = ext_sd_send_cmd_get_rsp(chip, SEND_STATUS, @@ -4016,8 +4715,10 @@ int sd_execute_read_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) if (retval == STATUS_SUCCESS) break; } - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Read_Cmd_Failed; + } scsi_set_resid(srb, 0); return TRANSPORT_GOOD; @@ -4033,7 +4734,8 @@ SD_Execute_Read_Cmd_Failed: if (!(chip->card_ready & SD_CARD)) set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) @@ -4041,9 +4743,9 @@ int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) struct sd_info *sd_card = &(chip->sd_card); unsigned int lun = SCSI_LUN(srb); int retval, rsp_len, i; - int cmd13_checkbit = 0, write_err = 0; + bool write_err = false, cmd13_checkbit = false; u8 cmd_idx, rsp_type; - u8 send_cmd12 = 0, standby = 0, acmd = 0; + bool standby = false, send_cmd12 = false, acmd = false; u32 data_len, arg; #ifdef SUPPORT_SD_LOCK int lock_cmd_fail = 0; @@ -4053,28 +4755,32 @@ int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) if (!sd_card->sd_pass_thru_en) { set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } if (sd_card->pre_cmd_err) { sd_card->pre_cmd_err = 0; set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } retval = sd_switch_clock(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, TRANSPORT_FAILED); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return TRANSPORT_FAILED; + } cmd_idx = srb->cmnd[2] & 0x3F; if (srb->cmnd[1] & 0x04) - send_cmd12 = 1; + send_cmd12 = true; if (srb->cmnd[1] & 0x02) - standby = 1; + standby = true; if (srb->cmnd[1] & 0x01) - acmd = 1; + acmd = true; data_len = ((u32)srb->cmnd[7] << 16) | ((u32)srb->cmnd[8] << 8) | srb->cmnd[9]; @@ -4091,68 +4797,87 @@ int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) retval = get_rsp_type(srb, &rsp_type, &rsp_len); if (retval != STATUS_SUCCESS) { set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } sd_card->last_rsp_type = rsp_type; retval = sd_switch_clock(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, TRANSPORT_FAILED); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return TRANSPORT_FAILED; + } #ifdef SUPPORT_SD_LOCK if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) { if (CHK_MMC_8BIT(sd_card)) { retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_8); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, TRANSPORT_FAILED); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return TRANSPORT_FAILED; + } } else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card)) { retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, TRANSPORT_FAILED); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return TRANSPORT_FAILED; + } } } #else retval = rtsx_write_register(chip, REG_SD_CFG1, 0x03, SD_BUS_WIDTH_4); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, TRANSPORT_FAILED); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return TRANSPORT_FAILED; + } #endif if (data_len < 512) { retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len, - SD_RSP_TYPE_R1, NULL, 0, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + SD_RSP_TYPE_R1, NULL, 0, false); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; + } } if (standby) { retval = sd_select_card(chip, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; + } } if (acmd) { retval = ext_sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr, - SD_RSP_TYPE_R1, NULL, 0, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + SD_RSP_TYPE_R1, NULL, 0, false); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; + } } retval = ext_sd_send_cmd_get_rsp(chip, cmd_idx, arg, rsp_type, - sd_card->rsp, rsp_len, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + sd_card->rsp, rsp_len, false); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; + } if (data_len <= 512) { u16 i; u8 *buf; buf = kmalloc(data_len, GFP_KERNEL); - if (buf == NULL) - TRACE_RET(chip, TRANSPORT_ERROR); + if (buf == NULL) { + rtsx_trace(chip); + return TRANSPORT_ERROR; + } rtsx_stor_get_xfer_buf(buf, data_len, srb); @@ -4170,7 +4895,8 @@ int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) retval = rtsx_send_cmd(chip, 0, 250); if (retval != STATUS_SUCCESS) { kfree(buf); - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; } rtsx_init_cmd(chip); @@ -4181,7 +4907,8 @@ int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) retval = rtsx_send_cmd(chip, 0, 250); if (retval != STATUS_SUCCESS) { kfree(buf); - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; } } else { rtsx_init_cmd(chip); @@ -4192,7 +4919,8 @@ int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) retval = rtsx_send_cmd(chip, 0, 250); if (retval != STATUS_SUCCESS) { kfree(buf); - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; } } @@ -4243,13 +4971,15 @@ int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) DMA_TO_DEVICE, 10000); } else { - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; } if (retval < 0) { - write_err = 1; + write_err = true; rtsx_clear_sd_error(chip); - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; } #ifdef SUPPORT_SD_LOCK @@ -4275,34 +5005,44 @@ int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) if (standby) { retval = sd_select_card(chip, 1); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; + } } if (send_cmd12) { retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION, - 0, SD_RSP_TYPE_R1b, NULL, 0, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + 0, SD_RSP_TYPE_R1b, NULL, 0, false); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; + } } if (data_len < 512) { retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200, - SD_RSP_TYPE_R1, NULL, 0, 0); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + SD_RSP_TYPE_R1, NULL, 0, false); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; + } retval = rtsx_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; + } rtsx_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00); - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; + } } if ((srb->cmnd[1] & 0x02) || (srb->cmnd[1] & 0x04)) - cmd13_checkbit = 1; + cmd13_checkbit = true; for (i = 0; i < 3; i++) { retval = ext_sd_send_cmd_get_rsp(chip, SEND_STATUS, @@ -4312,8 +5052,10 @@ int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) if (retval == STATUS_SUCCESS) break; } - if (retval != STATUS_SUCCESS) - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; + } #ifdef SUPPORT_SD_LOCK if (cmd_idx == LOCK_UNLOCK) { @@ -4339,7 +5081,8 @@ int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) retval = reset_sd(chip); if (retval != STATUS_SUCCESS) { sd_card->sd_lock_status &= ~(SD_UNLOCK_POW_ON | SD_SDR_RST); - TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); + rtsx_trace(chip); + goto SD_Execute_Write_Cmd_Failed; } } @@ -4352,7 +5095,8 @@ int sd_execute_write_data(struct scsi_cmnd *srb, struct rtsx_chip *chip) if (lock_cmd_fail) { scsi_set_resid(srb, 0); set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } #endif /* SUPPORT_SD_LOCK */ @@ -4370,7 +5114,8 @@ SD_Execute_Write_Cmd_Failed: if (!(chip->card_ready & SD_CARD)) set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } int sd_get_cmd_rsp(struct scsi_cmnd *srb, struct rtsx_chip *chip) @@ -4382,20 +5127,23 @@ int sd_get_cmd_rsp(struct scsi_cmnd *srb, struct rtsx_chip *chip) if (!sd_card->sd_pass_thru_en) { set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } if (sd_card->pre_cmd_err) { sd_card->pre_cmd_err = 0; set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } data_len = ((u16)srb->cmnd[7] << 8) | srb->cmnd[8]; if (sd_card->last_rsp_type == SD_RSP_TYPE_R0) { set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } else if (sd_card->last_rsp_type == SD_RSP_TYPE_R2) { count = (data_len < 17) ? data_len : 17; } else { @@ -4420,13 +5168,15 @@ int sd_hw_rst(struct scsi_cmnd *srb, struct rtsx_chip *chip) if (!sd_card->sd_pass_thru_en) { set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } if (sd_card->pre_cmd_err) { sd_card->pre_cmd_err = 0; set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } if ((0x53 != srb->cmnd[2]) || (0x44 != srb->cmnd[3]) || @@ -4434,7 +5184,8 @@ int sd_hw_rst(struct scsi_cmnd *srb, struct rtsx_chip *chip) (0x61 != srb->cmnd[6]) || (0x72 != srb->cmnd[7]) || (0x64 != srb->cmnd[8])) { set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } switch (srb->cmnd[1] & 0x0F) { @@ -4450,7 +5201,8 @@ int sd_hw_rst(struct scsi_cmnd *srb, struct rtsx_chip *chip) #endif set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); sd_card->pre_cmd_err = 1; - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } #ifdef SUPPORT_SD_LOCK sd_card->sd_lock_status &= ~SD_SDR_RST; @@ -4462,13 +5214,15 @@ int sd_hw_rst(struct scsi_cmnd *srb, struct rtsx_chip *chip) if (retval != STATUS_SUCCESS) { set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); sd_card->pre_cmd_err = 1; - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } break; default: set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD); - TRACE_RET(chip, TRANSPORT_FAILED); + rtsx_trace(chip); + return TRANSPORT_FAILED; } scsi_set_resid(srb, 0); @@ -4492,26 +5246,41 @@ int sd_power_off_card3v3(struct rtsx_chip *chip) int retval; retval = disable_card_clock(chip, SD_CARD); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } - RTSX_WRITE_REG(chip, CARD_OE, SD_OUTPUT_EN, 0); + retval = rtsx_write_register(chip, CARD_OE, SD_OUTPUT_EN, 0); + if (retval) { + rtsx_trace(chip); + return retval; + } if (!chip->ft2_fast_mode) { retval = card_power_off(chip, SD_CARD); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } wait_timeout(50); } if (chip->asic_code) { retval = sd_pull_ctl_disable(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } } else { - RTSX_WRITE_REG(chip, FPGA_PULL_CTL, - FPGA_SD_PULL_CTL_BIT | 0x20, FPGA_SD_PULL_CTL_BIT); + retval = rtsx_write_register(chip, FPGA_PULL_CTL, + FPGA_SD_PULL_CTL_BIT | 0x20, + FPGA_SD_PULL_CTL_BIT); + if (retval) { + rtsx_trace(chip); + return retval; + } } return STATUS_SUCCESS; @@ -4538,8 +5307,10 @@ int release_sd_card(struct rtsx_chip *chip) memset(sd_card->raw_scr, 0, 8); retval = sd_power_off_card3v3(chip); - if (retval != STATUS_SUCCESS) - TRACE_RET(chip, STATUS_FAIL); + if (retval != STATUS_SUCCESS) { + rtsx_trace(chip); + return STATUS_FAIL; + } return STATUS_SUCCESS; } |