1 /* Driver for Realtek PCI-Express card reader
3 * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2, or (at your option) any
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, see <http://www.gnu.org/licenses/>.
19 * Wei WANG (wei_wang@realsil.com.cn)
20 * Micky Ching (micky_ching@realsil.com.cn)
23 #include <linux/blkdev.h>
24 #include <linux/kthread.h>
25 #include <linux/sched.h>
26 #include <linux/workqueue.h>
27 #include <linux/vmalloc.h>
34 static void rtsx_calibration(struct rtsx_chip *chip)
36 rtsx_write_phy_register(chip, 0x1B, 0x135E);
38 rtsx_write_phy_register(chip, 0x00, 0x0280);
39 rtsx_write_phy_register(chip, 0x01, 0x7112);
40 rtsx_write_phy_register(chip, 0x01, 0x7110);
41 rtsx_write_phy_register(chip, 0x01, 0x7112);
42 rtsx_write_phy_register(chip, 0x01, 0x7113);
43 rtsx_write_phy_register(chip, 0x00, 0x0288);
46 void rtsx_disable_card_int(struct rtsx_chip *chip)
48 u32 reg = rtsx_readl(chip, RTSX_BIER);
50 reg &= ~(XD_INT_EN | SD_INT_EN | MS_INT_EN);
51 rtsx_writel(chip, RTSX_BIER, reg);
54 void rtsx_enable_card_int(struct rtsx_chip *chip)
56 u32 reg = rtsx_readl(chip, RTSX_BIER);
59 for (i = 0; i <= chip->max_lun; i++) {
60 if (chip->lun2card[i] & XD_CARD)
62 if (chip->lun2card[i] & SD_CARD)
64 if (chip->lun2card[i] & MS_CARD)
67 if (chip->hw_bypass_sd)
68 reg &= ~((u32)SD_INT_EN);
70 rtsx_writel(chip, RTSX_BIER, reg);
73 void rtsx_enable_bus_int(struct rtsx_chip *chip)
76 #ifndef DISABLE_CARD_INT
80 reg = TRANS_OK_INT_EN | TRANS_FAIL_INT_EN;
82 #ifndef DISABLE_CARD_INT
83 for (i = 0; i <= chip->max_lun; i++) {
84 dev_dbg(rtsx_dev(chip), "lun2card[%d] = 0x%02x\n",
85 i, chip->lun2card[i]);
87 if (chip->lun2card[i] & XD_CARD)
89 if (chip->lun2card[i] & SD_CARD)
91 if (chip->lun2card[i] & MS_CARD)
94 if (chip->hw_bypass_sd)
95 reg &= ~((u32)SD_INT_EN);
98 if (chip->ic_version >= IC_VER_C)
103 if (!chip->adma_mode)
104 reg |= DATA_DONE_INT_EN;
106 /* Enable Bus Interrupt */
107 rtsx_writel(chip, RTSX_BIER, reg);
109 dev_dbg(rtsx_dev(chip), "RTSX_BIER: 0x%08x\n", reg);
112 void rtsx_disable_bus_int(struct rtsx_chip *chip)
114 rtsx_writel(chip, RTSX_BIER, 0);
117 static int rtsx_pre_handle_sdio_old(struct rtsx_chip *chip)
121 if (chip->ignore_sd && CHK_SDIO_EXIST(chip)) {
122 if (chip->asic_code) {
123 retval = rtsx_write_register(chip, CARD_PULL_CTL5,
125 MS_INS_PU | SD_WP_PU | SD_CD_PU | SD_CMD_PU);
131 retval = rtsx_write_register(chip, FPGA_PULL_CTL,
133 FPGA_SD_PULL_CTL_EN);
139 retval = rtsx_write_register(chip, CARD_SHARE_MODE, 0xFF,
146 /* Enable SDIO internal clock */
147 retval = rtsx_write_register(chip, 0xFF2C, 0x01, 0x01);
153 retval = rtsx_write_register(chip, SDIO_CTRL, 0xFF,
154 SDIO_BUS_CTRL | SDIO_CD_CTRL);
163 chip->need_reset |= SD_CARD;
166 return STATUS_SUCCESS;
169 #ifdef HW_AUTO_SWITCH_SD_BUS
170 static int rtsx_pre_handle_sdio_new(struct rtsx_chip *chip)
173 bool sw_bypass_sd = false;
176 if (chip->driver_first_load) {
177 if (CHECK_PID(chip, 0x5288)) {
178 retval = rtsx_read_register(chip, 0xFE5A, &tmp);
185 } else if (CHECK_PID(chip, 0x5208)) {
186 retval = rtsx_read_register(chip, 0xFE70, &tmp);
195 if (chip->sdio_in_charge)
198 dev_dbg(rtsx_dev(chip), "chip->sdio_in_charge = %d\n",
199 chip->sdio_in_charge);
200 dev_dbg(rtsx_dev(chip), "chip->driver_first_load = %d\n",
201 chip->driver_first_load);
202 dev_dbg(rtsx_dev(chip), "sw_bypass_sd = %d\n",
206 u8 cd_toggle_mask = 0;
208 retval = rtsx_read_register(chip, TLPTISTAT, &tmp);
213 cd_toggle_mask = 0x08;
215 if (tmp & cd_toggle_mask) {
216 /* Disable sdio_bus_auto_switch */
217 if (CHECK_PID(chip, 0x5288)) {
218 retval = rtsx_write_register(chip, 0xFE5A,
224 } else if (CHECK_PID(chip, 0x5208)) {
225 retval = rtsx_write_register(chip, 0xFE70,
233 retval = rtsx_write_register(chip, TLPTISTAT, 0xFF,
240 chip->need_reset |= SD_CARD;
242 dev_dbg(rtsx_dev(chip), "Chip inserted with SDIO!\n");
244 if (chip->asic_code) {
245 retval = sd_pull_ctl_enable(chip);
246 if (retval != STATUS_SUCCESS) {
251 retval = rtsx_write_register(chip,
253 FPGA_SD_PULL_CTL_BIT | 0x20,
260 retval = card_share_mode(chip, SD_CARD);
261 if (retval != STATUS_SUCCESS) {
266 /* Enable sdio_bus_auto_switch */
267 if (CHECK_PID(chip, 0x5288)) {
268 retval = rtsx_write_register(chip, 0xFE5A,
274 } else if (CHECK_PID(chip, 0x5208)) {
275 retval = rtsx_write_register(chip, 0xFE70,
283 chip->chip_insert_with_sdio = 1;
287 retval = rtsx_write_register(chip, TLPTISTAT, 0x08, 0x08);
293 chip->need_reset |= SD_CARD;
296 return STATUS_SUCCESS;
300 static int rtsx_reset_aspm(struct rtsx_chip *chip)
304 if (chip->dynamic_aspm) {
305 if (!CHK_SDIO_EXIST(chip) || !CHECK_PID(chip, 0x5288))
306 return STATUS_SUCCESS;
308 ret = rtsx_write_cfg_dw(chip, 2, 0xC0, 0xFF,
309 chip->aspm_l0s_l1_en);
310 if (ret != STATUS_SUCCESS) {
315 return STATUS_SUCCESS;
318 if (CHECK_PID(chip, 0x5208)) {
319 ret = rtsx_write_register(chip, ASPM_FORCE_CTL, 0xFF, 0x3F);
325 ret = rtsx_write_config_byte(chip, LCTLR, chip->aspm_l0s_l1_en);
326 if (ret != STATUS_SUCCESS) {
331 chip->aspm_level[0] = chip->aspm_l0s_l1_en;
332 if (CHK_SDIO_EXIST(chip)) {
333 chip->aspm_level[1] = chip->aspm_l0s_l1_en;
334 ret = rtsx_write_cfg_dw(chip, CHECK_PID(chip, 0x5288) ? 2 : 1,
335 0xC0, 0xFF, chip->aspm_l0s_l1_en);
336 if (ret != STATUS_SUCCESS) {
342 chip->aspm_enabled = 1;
344 return STATUS_SUCCESS;
347 static int rtsx_enable_pcie_intr(struct rtsx_chip *chip)
351 if (!chip->asic_code || !CHECK_PID(chip, 0x5208)) {
352 rtsx_enable_bus_int(chip);
353 return STATUS_SUCCESS;
356 if (chip->phy_debug_mode) {
357 ret = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
362 rtsx_disable_bus_int(chip);
364 rtsx_enable_bus_int(chip);
367 if (chip->ic_version >= IC_VER_D) {
370 ret = rtsx_read_phy_register(chip, 0x00, ®);
371 if (ret != STATUS_SUCCESS) {
378 ret = rtsx_write_phy_register(chip, 0x00, reg);
379 if (ret != STATUS_SUCCESS) {
384 ret = rtsx_read_phy_register(chip, 0x1C, ®);
385 if (ret != STATUS_SUCCESS) {
391 ret = rtsx_write_phy_register(chip, 0x1C, reg);
392 if (ret != STATUS_SUCCESS) {
398 if (chip->driver_first_load && (chip->ic_version < IC_VER_C))
399 rtsx_calibration(chip);
401 return STATUS_SUCCESS;
404 int rtsx_reset_chip(struct rtsx_chip *chip)
408 rtsx_writel(chip, RTSX_HCBAR, chip->host_cmds_addr);
410 rtsx_disable_aspm(chip);
412 retval = rtsx_write_register(chip, HOST_SLEEP_STATE, 0x03, 0x00);
418 /* Disable card clock */
419 retval = rtsx_write_register(chip, CARD_CLK_EN, 0x1E, 0);
426 /* SSC power on, OCD power on */
427 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
428 retval = rtsx_write_register(chip, FPDCTL, OC_POWER_DOWN, 0);
434 retval = rtsx_write_register(chip, FPDCTL, OC_POWER_DOWN,
442 retval = rtsx_write_register(chip, OCPPARA1, OCP_TIME_MASK,
448 retval = rtsx_write_register(chip, OCPPARA2, OCP_THD_MASK,
454 retval = rtsx_write_register(chip, OCPCTL, 0xFF,
455 CARD_OC_INT_EN | CARD_DETECT_EN);
462 retval = rtsx_write_register(chip, FPDCTL, OC_POWER_DOWN,
470 if (!CHECK_PID(chip, 0x5288)) {
471 retval = rtsx_write_register(chip, CARD_GPIO_DIR, 0xFF, 0x03);
479 retval = rtsx_write_register(chip, CARD_GPIO, 0xFF, 0x03);
485 /* Reset delink mode */
486 retval = rtsx_write_register(chip, CHANGE_LINK_STATE, 0x0A, 0);
492 /* Card driving select */
493 retval = rtsx_write_register(chip, CARD_DRIVE_SEL, 0xFF,
494 chip->card_drive_sel);
500 #ifdef LED_AUTO_BLINK
501 retval = rtsx_write_register(chip, CARD_AUTO_BLINK, 0xFF,
502 LED_BLINK_SPEED | BLINK_EN | LED_GPIO0);
509 if (chip->asic_code) {
510 /* Enable SSC Clock */
511 retval = rtsx_write_register(chip, SSC_CTL1, 0xFF,
512 SSC_8X_EN | SSC_SEL_4M);
517 retval = rtsx_write_register(chip, SSC_CTL2, 0xFF, 0x12);
524 /* Disable cd_pwr_save (u_force_rst_core_en=0, u_cd_rst_core_en=0)
526 bit[1] u_cd_rst_core_en rst_value = 0
527 bit[2] u_force_rst_core_en rst_value = 0
528 bit[5] u_mac_phy_rst_n_dbg rst_value = 1
529 bit[4] u_non_sticky_rst_n_dbg rst_value = 0
531 retval = rtsx_write_register(chip, CHANGE_LINK_STATE, 0x16, 0x10);
538 if (chip->aspm_l0s_l1_en) {
539 retval = rtsx_reset_aspm(chip);
540 if (retval != STATUS_SUCCESS) {
545 if (chip->asic_code && CHECK_PID(chip, 0x5208)) {
546 retval = rtsx_write_phy_register(chip, 0x07, 0x0129);
547 if (retval != STATUS_SUCCESS) {
552 retval = rtsx_write_config_byte(chip, LCTLR,
553 chip->aspm_l0s_l1_en);
554 if (retval != STATUS_SUCCESS) {
560 retval = rtsx_write_config_byte(chip, 0x81, 1);
561 if (retval != STATUS_SUCCESS) {
566 if (CHK_SDIO_EXIST(chip)) {
567 retval = rtsx_write_cfg_dw(chip,
568 CHECK_PID(chip, 0x5288) ? 2 : 1,
569 0xC0, 0xFF00, 0x0100);
571 if (retval != STATUS_SUCCESS) {
577 if (CHECK_PID(chip, 0x5288) && !CHK_SDIO_EXIST(chip)) {
578 retval = rtsx_write_cfg_dw(chip, 2, 0xC0, 0xFFFF, 0x0103);
579 if (retval != STATUS_SUCCESS) {
584 retval = rtsx_write_cfg_dw(chip, 2, 0x84, 0xFF, 0x03);
585 if (retval != STATUS_SUCCESS) {
591 retval = rtsx_write_register(chip, IRQSTAT0, LINK_RDY_INT,
598 retval = rtsx_write_register(chip, PERST_GLITCH_WIDTH, 0xFF, 0x80);
604 retval = rtsx_enable_pcie_intr(chip);
605 if (retval != STATUS_SUCCESS) {
610 chip->need_reset = 0;
612 chip->int_reg = rtsx_readl(chip, RTSX_BIPR);
614 if (chip->hw_bypass_sd)
616 dev_dbg(rtsx_dev(chip), "In %s, chip->int_reg = 0x%x\n", __func__,
618 if (chip->int_reg & SD_EXIST) {
619 #ifdef HW_AUTO_SWITCH_SD_BUS
620 if (CHECK_PID(chip, 0x5208) && (chip->ic_version < IC_VER_C))
621 retval = rtsx_pre_handle_sdio_old(chip);
623 retval = rtsx_pre_handle_sdio_new(chip);
625 dev_dbg(rtsx_dev(chip), "chip->need_reset = 0x%x (rtsx_reset_chip)\n",
626 (unsigned int)(chip->need_reset));
627 #else /* HW_AUTO_SWITCH_SD_BUS */
628 retval = rtsx_pre_handle_sdio_old(chip);
629 #endif /* HW_AUTO_SWITCH_SD_BUS */
630 if (retval != STATUS_SUCCESS) {
637 retval = rtsx_write_register(chip, SDIO_CTRL,
638 SDIO_BUS_CTRL | SDIO_CD_CTRL, 0);
646 if (chip->int_reg & XD_EXIST)
647 chip->need_reset |= XD_CARD;
648 if (chip->int_reg & MS_EXIST)
649 chip->need_reset |= MS_CARD;
650 if (chip->int_reg & CARD_EXIST) {
651 retval = rtsx_write_register(chip, SSC_CTL1, SSC_RSTB,
659 dev_dbg(rtsx_dev(chip), "In %s, chip->need_reset = 0x%x\n", __func__,
660 (unsigned int)(chip->need_reset));
662 retval = rtsx_write_register(chip, RCCTL, 0x01, 0x00);
668 if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) {
669 /* Turn off main power when entering S3/S4 state */
670 retval = rtsx_write_register(chip, MAIN_PWR_OFF_CTL, 0x03,
678 if (chip->remote_wakeup_en && !chip->auto_delink_en) {
679 retval = rtsx_write_register(chip, WAKE_SEL_CTL, 0x07, 0x07);
684 if (chip->aux_pwr_exist) {
685 retval = rtsx_write_register(chip, PME_FORCE_CTL,
693 retval = rtsx_write_register(chip, WAKE_SEL_CTL, 0x07, 0x04);
698 retval = rtsx_write_register(chip, PME_FORCE_CTL, 0xFF, 0x30);
705 if (CHECK_PID(chip, 0x5208) && (chip->ic_version >= IC_VER_D)) {
706 retval = rtsx_write_register(chip, PETXCFG, 0x1C, 0x14);
713 if (chip->asic_code && CHECK_PID(chip, 0x5208)) {
714 retval = rtsx_clr_phy_reg_bit(chip, 0x1C, 2);
715 if (retval != STATUS_SUCCESS) {
721 if (chip->ft2_fast_mode) {
722 retval = rtsx_write_register(chip, CARD_PWR_CTL, 0xFF,
723 MS_PARTIAL_POWER_ON | SD_PARTIAL_POWER_ON);
728 udelay(chip->pmos_pwr_on_interval);
729 retval = rtsx_write_register(chip, CARD_PWR_CTL, 0xFF,
730 MS_POWER_ON | SD_POWER_ON);
740 rtsx_reset_detected_cards(chip, 0);
742 chip->driver_first_load = 0;
744 return STATUS_SUCCESS;
747 static inline int check_sd_speed_prior(u32 sd_speed_prior)
749 bool fake_para = false;
752 for (i = 0; i < 4; i++) {
753 u8 tmp = (u8)(sd_speed_prior >> (i*8));
755 if ((tmp < 0x01) || (tmp > 0x04)) {
764 static inline int check_sd_current_prior(u32 sd_current_prior)
766 bool fake_para = false;
769 for (i = 0; i < 4; i++) {
770 u8 tmp = (u8)(sd_current_prior >> (i*8));
781 static int rts5208_init(struct rtsx_chip *chip)
787 retval = rtsx_write_register(chip, CLK_SEL, 0x03, 0x03);
792 retval = rtsx_read_register(chip, CLK_SEL, &val);
797 chip->asic_code = val == 0 ? 1 : 0;
799 if (chip->asic_code) {
800 retval = rtsx_read_phy_register(chip, 0x1C, ®);
801 if (retval != STATUS_SUCCESS) {
806 dev_dbg(rtsx_dev(chip), "Value of phy register 0x1C is 0x%x\n",
808 chip->ic_version = (reg >> 4) & 0x07;
809 chip->phy_debug_mode = reg & PHY_DEBUG_MODE ? 1 : 0;
812 retval = rtsx_read_register(chip, 0xFE80, &val);
817 chip->ic_version = val;
818 chip->phy_debug_mode = 0;
821 retval = rtsx_read_register(chip, PDINFO, &val);
826 dev_dbg(rtsx_dev(chip), "PDINFO: 0x%x\n", val);
827 chip->aux_pwr_exist = val & AUX_PWR_DETECTED ? 1 : 0;
829 retval = rtsx_read_register(chip, 0xFE50, &val);
834 chip->hw_bypass_sd = val & 0x01 ? 1 : 0;
836 rtsx_read_config_byte(chip, 0x0E, &val);
838 SET_SDIO_EXIST(chip);
840 CLR_SDIO_EXIST(chip);
842 if (chip->use_hw_setting) {
843 retval = rtsx_read_register(chip, CHANGE_LINK_STATE, &val);
848 chip->auto_delink_en = val & 0x80 ? 1 : 0;
851 return STATUS_SUCCESS;
854 static int rts5288_init(struct rtsx_chip *chip)
857 u8 val = 0, max_func;
860 retval = rtsx_write_register(chip, CLK_SEL, 0x03, 0x03);
865 retval = rtsx_read_register(chip, CLK_SEL, &val);
870 chip->asic_code = val == 0 ? 1 : 0;
872 chip->ic_version = 0;
873 chip->phy_debug_mode = 0;
875 retval = rtsx_read_register(chip, PDINFO, &val);
880 dev_dbg(rtsx_dev(chip), "PDINFO: 0x%x\n", val);
881 chip->aux_pwr_exist = val & AUX_PWR_DETECTED ? 1 : 0;
883 retval = rtsx_read_register(chip, CARD_SHARE_MODE, &val);
888 dev_dbg(rtsx_dev(chip), "CARD_SHARE_MODE: 0x%x\n", val);
889 chip->baro_pkg = val & 0x04 ? QFN : LQFP;
891 retval = rtsx_read_register(chip, 0xFE5A, &val);
896 chip->hw_bypass_sd = val & 0x10 ? 1 : 0;
898 retval = rtsx_read_cfg_dw(chip, 0, 0x718, &lval);
899 if (retval != STATUS_SUCCESS) {
904 max_func = (u8)((lval >> 29) & 0x07);
905 dev_dbg(rtsx_dev(chip), "Max function number: %d\n", max_func);
906 if (max_func == 0x02)
907 SET_SDIO_EXIST(chip);
909 CLR_SDIO_EXIST(chip);
911 if (chip->use_hw_setting) {
912 retval = rtsx_read_register(chip, CHANGE_LINK_STATE, &val);
917 chip->auto_delink_en = val & 0x80 ? 1 : 0;
919 if (CHECK_BARO_PKG(chip, LQFP))
920 chip->lun_mode = SD_MS_1LUN;
922 chip->lun_mode = DEFAULT_SINGLE;
925 return STATUS_SUCCESS;
928 int rtsx_init_chip(struct rtsx_chip *chip)
930 struct sd_info *sd_card = &chip->sd_card;
931 struct xd_info *xd_card = &chip->xd_card;
932 struct ms_info *ms_card = &chip->ms_card;
936 dev_dbg(rtsx_dev(chip), "Vendor ID: 0x%04x, Product ID: 0x%04x\n",
937 chip->vendor_id, chip->product_id);
939 chip->ic_version = 0;
945 memset(xd_card, 0, sizeof(struct xd_info));
946 memset(sd_card, 0, sizeof(struct sd_info));
947 memset(ms_card, 0, sizeof(struct ms_info));
949 chip->xd_reset_counter = 0;
950 chip->sd_reset_counter = 0;
951 chip->ms_reset_counter = 0;
953 chip->xd_show_cnt = MAX_SHOW_CNT;
954 chip->sd_show_cnt = MAX_SHOW_CNT;
955 chip->ms_show_cnt = MAX_SHOW_CNT;
958 chip->auto_delink_cnt = 0;
959 chip->auto_delink_allowed = 1;
960 rtsx_set_stat(chip, RTSX_STAT_INIT);
962 chip->aspm_enabled = 0;
963 chip->chip_insert_with_sdio = 0;
966 chip->sdio_counter = 0;
968 chip->phy_debug_mode = 0;
969 chip->sdio_func_exist = 0;
970 memset(chip->sdio_raw_data, 0, 12);
972 for (i = 0; i < MAX_ALLOWED_LUN_CNT; i++) {
973 set_sense_type(chip, i, SENSE_TYPE_NO_SENSE);
974 chip->rw_fail_cnt[i] = 0;
977 if (!check_sd_speed_prior(chip->sd_speed_prior))
978 chip->sd_speed_prior = 0x01040203;
980 dev_dbg(rtsx_dev(chip), "sd_speed_prior = 0x%08x\n",
981 chip->sd_speed_prior);
983 if (!check_sd_current_prior(chip->sd_current_prior))
984 chip->sd_current_prior = 0x00010203;
986 dev_dbg(rtsx_dev(chip), "sd_current_prior = 0x%08x\n",
987 chip->sd_current_prior);
989 if ((chip->sd_ddr_tx_phase > 31) || (chip->sd_ddr_tx_phase < 0))
990 chip->sd_ddr_tx_phase = 0;
992 if ((chip->mmc_ddr_tx_phase > 31) || (chip->mmc_ddr_tx_phase < 0))
993 chip->mmc_ddr_tx_phase = 0;
995 retval = rtsx_write_register(chip, FPDCTL, SSC_POWER_DOWN, 0);
1001 retval = rtsx_write_register(chip, CLK_DIV, 0x07, 0x07);
1006 dev_dbg(rtsx_dev(chip), "chip->use_hw_setting = %d\n",
1007 chip->use_hw_setting);
1009 if (CHECK_PID(chip, 0x5208)) {
1010 retval = rts5208_init(chip);
1011 if (retval != STATUS_SUCCESS) {
1016 } else if (CHECK_PID(chip, 0x5288)) {
1017 retval = rts5288_init(chip);
1018 if (retval != STATUS_SUCCESS) {
1024 if (chip->ss_en == 2)
1027 dev_dbg(rtsx_dev(chip), "chip->asic_code = %d\n", chip->asic_code);
1028 dev_dbg(rtsx_dev(chip), "chip->ic_version = 0x%x\n", chip->ic_version);
1029 dev_dbg(rtsx_dev(chip), "chip->phy_debug_mode = %d\n",
1030 chip->phy_debug_mode);
1031 dev_dbg(rtsx_dev(chip), "chip->aux_pwr_exist = %d\n",
1032 chip->aux_pwr_exist);
1033 dev_dbg(rtsx_dev(chip), "chip->sdio_func_exist = %d\n",
1034 chip->sdio_func_exist);
1035 dev_dbg(rtsx_dev(chip), "chip->hw_bypass_sd = %d\n",
1036 chip->hw_bypass_sd);
1037 dev_dbg(rtsx_dev(chip), "chip->aspm_l0s_l1_en = %d\n",
1038 chip->aspm_l0s_l1_en);
1039 dev_dbg(rtsx_dev(chip), "chip->lun_mode = %d\n", chip->lun_mode);
1040 dev_dbg(rtsx_dev(chip), "chip->auto_delink_en = %d\n",
1041 chip->auto_delink_en);
1042 dev_dbg(rtsx_dev(chip), "chip->ss_en = %d\n", chip->ss_en);
1043 dev_dbg(rtsx_dev(chip), "chip->baro_pkg = %d\n", chip->baro_pkg);
1045 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
1046 chip->card2lun[SD_CARD] = 0;
1047 chip->card2lun[MS_CARD] = 1;
1048 chip->card2lun[XD_CARD] = 0xFF;
1049 chip->lun2card[0] = SD_CARD;
1050 chip->lun2card[1] = MS_CARD;
1052 SET_SDIO_IGNORED(chip);
1053 } else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) {
1054 chip->card2lun[SD_CARD] = 0;
1055 chip->card2lun[MS_CARD] = 0;
1056 chip->card2lun[XD_CARD] = 0xFF;
1057 chip->lun2card[0] = SD_CARD | MS_CARD;
1060 chip->card2lun[XD_CARD] = 0;
1061 chip->card2lun[SD_CARD] = 0;
1062 chip->card2lun[MS_CARD] = 0;
1063 chip->lun2card[0] = XD_CARD | SD_CARD | MS_CARD;
1067 retval = rtsx_reset_chip(chip);
1068 if (retval != STATUS_SUCCESS) {
1073 return STATUS_SUCCESS;
1076 void rtsx_release_chip(struct rtsx_chip *chip)
1078 xd_free_l2p_tbl(chip);
1079 ms_free_l2p_tbl(chip);
1080 chip->card_exist = 0;
1081 chip->card_ready = 0;
1084 #if !defined(LED_AUTO_BLINK) && defined(REGULAR_BLINK)
1085 static inline void rtsx_blink_led(struct rtsx_chip *chip)
1087 if (chip->card_exist && chip->blink_led) {
1088 if (chip->led_toggle_counter < LED_TOGGLE_INTERVAL) {
1089 chip->led_toggle_counter++;
1091 chip->led_toggle_counter = 0;
1092 toggle_gpio(chip, LED_GPIO);
1098 static void rtsx_monitor_aspm_config(struct rtsx_chip *chip)
1100 bool reg_changed, maybe_support_aspm;
1102 u8 reg0 = 0, reg1 = 0;
1104 maybe_support_aspm = false;
1105 reg_changed = false;
1106 rtsx_read_config_byte(chip, LCTLR, ®0);
1107 if (chip->aspm_level[0] != reg0) {
1109 chip->aspm_level[0] = reg0;
1111 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
1112 rtsx_read_cfg_dw(chip, 1, 0xC0, &tmp);
1114 if (chip->aspm_level[1] != reg1) {
1116 chip->aspm_level[1] = reg1;
1119 if ((reg0 & 0x03) && (reg1 & 0x03))
1120 maybe_support_aspm = true;
1124 maybe_support_aspm = true;
1128 if (maybe_support_aspm)
1129 chip->aspm_l0s_l1_en = 0x03;
1131 dev_dbg(rtsx_dev(chip), "aspm_level[0] = 0x%02x, aspm_level[1] = 0x%02x\n",
1132 chip->aspm_level[0], chip->aspm_level[1]);
1134 if (chip->aspm_l0s_l1_en) {
1135 chip->aspm_enabled = 1;
1137 chip->aspm_enabled = 0;
1138 chip->sdio_aspm = 0;
1140 rtsx_write_register(chip, ASPM_FORCE_CTL, 0xFF,
1141 0x30 | chip->aspm_level[0] |
1142 (chip->aspm_level[1] << 2));
1146 void rtsx_polling_func(struct rtsx_chip *chip)
1148 #ifdef SUPPORT_SD_LOCK
1149 struct sd_info *sd_card = &chip->sd_card;
1153 if (rtsx_chk_stat(chip, RTSX_STAT_SUSPEND))
1156 if (rtsx_chk_stat(chip, RTSX_STAT_DELINK))
1159 if (chip->polling_config) {
1162 rtsx_read_config_byte(chip, 0, &val);
1165 if (rtsx_chk_stat(chip, RTSX_STAT_SS))
1169 if (chip->ocp_int) {
1170 rtsx_read_register(chip, OCPSTAT, &chip->ocp_stat);
1172 if (chip->card_exist & SD_CARD)
1173 sd_power_off_card3v3(chip);
1174 else if (chip->card_exist & MS_CARD)
1175 ms_power_off_card3v3(chip);
1176 else if (chip->card_exist & XD_CARD)
1177 xd_power_off_card3v3(chip);
1183 #ifdef SUPPORT_SD_LOCK
1184 if (sd_card->sd_erase_status) {
1185 if (chip->card_exist & SD_CARD) {
1188 rtsx_read_register(chip, 0xFD30, &val);
1190 sd_card->sd_erase_status = SD_NOT_ERASE;
1191 sd_card->sd_lock_notify = 1;
1192 chip->need_reinit |= SD_CARD;
1195 sd_card->sd_erase_status = SD_NOT_ERASE;
1200 rtsx_init_cards(chip);
1205 if (CHECK_PID(chip, 0x5288)) {
1208 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
1211 rtsx_read_cfg_dw(chip, 1, 0x04, &val);
1220 if (ss_allowed && !chip->sd_io) {
1221 if (rtsx_get_stat(chip) != RTSX_STAT_IDLE) {
1222 chip->ss_counter = 0;
1224 if (chip->ss_counter <
1225 (chip->ss_idle_period / POLLING_INTERVAL)) {
1228 rtsx_exclusive_enter_ss(chip);
1234 if (CHECK_PID(chip, 0x5208)) {
1235 rtsx_monitor_aspm_config(chip);
1237 #ifdef SUPPORT_SDIO_ASPM
1238 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip) &&
1239 chip->aspm_l0s_l1_en && chip->dynamic_aspm) {
1241 dynamic_configure_sdio_aspm(chip);
1243 if (!chip->sdio_aspm) {
1244 dev_dbg(rtsx_dev(chip), "SDIO enter ASPM!\n");
1245 rtsx_write_register(chip,
1246 ASPM_FORCE_CTL, 0xFC,
1248 (chip->aspm_level[1] << 2));
1249 chip->sdio_aspm = 1;
1256 if (chip->idle_counter < IDLE_MAX_COUNT) {
1257 chip->idle_counter++;
1259 if (rtsx_get_stat(chip) != RTSX_STAT_IDLE) {
1260 dev_dbg(rtsx_dev(chip), "Idle state!\n");
1261 rtsx_set_stat(chip, RTSX_STAT_IDLE);
1263 #if !defined(LED_AUTO_BLINK) && defined(REGULAR_BLINK)
1264 chip->led_toggle_counter = 0;
1266 rtsx_force_power_on(chip, SSC_PDCTL);
1268 turn_off_led(chip, LED_GPIO);
1270 if (chip->auto_power_down && !chip->card_ready &&
1272 rtsx_force_power_down(chip,
1273 SSC_PDCTL | OC_PDCTL);
1277 switch (rtsx_get_stat(chip)) {
1279 #if !defined(LED_AUTO_BLINK) && defined(REGULAR_BLINK)
1280 rtsx_blink_led(chip);
1282 do_remaining_work(chip);
1285 case RTSX_STAT_IDLE:
1286 if (chip->sd_io && !chip->sd_int)
1287 try_to_switch_sdio_ctrl(chip);
1289 rtsx_enable_aspm(chip);
1297 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
1298 if (chip->ocp_stat &
1299 (SD_OC_NOW | SD_OC_EVER | MS_OC_NOW | MS_OC_EVER))
1300 dev_dbg(rtsx_dev(chip), "Over current, OCPSTAT is 0x%x\n",
1303 if (chip->ocp_stat & (SD_OC_NOW | SD_OC_EVER)) {
1304 if (chip->card_exist & SD_CARD) {
1305 rtsx_write_register(chip, CARD_OE, SD_OUTPUT_EN,
1307 card_power_off(chip, SD_CARD);
1308 chip->card_fail |= SD_CARD;
1311 if (chip->ocp_stat & (MS_OC_NOW | MS_OC_EVER)) {
1312 if (chip->card_exist & MS_CARD) {
1313 rtsx_write_register(chip, CARD_OE, MS_OUTPUT_EN,
1315 card_power_off(chip, MS_CARD);
1316 chip->card_fail |= MS_CARD;
1320 if (chip->ocp_stat & (SD_OC_NOW | SD_OC_EVER)) {
1321 dev_dbg(rtsx_dev(chip), "Over current, OCPSTAT is 0x%x\n",
1323 if (chip->card_exist & SD_CARD) {
1324 rtsx_write_register(chip, CARD_OE, SD_OUTPUT_EN,
1326 chip->card_fail |= SD_CARD;
1327 } else if (chip->card_exist & MS_CARD) {
1328 rtsx_write_register(chip, CARD_OE, MS_OUTPUT_EN,
1330 chip->card_fail |= MS_CARD;
1331 } else if (chip->card_exist & XD_CARD) {
1332 rtsx_write_register(chip, CARD_OE, XD_OUTPUT_EN,
1334 chip->card_fail |= XD_CARD;
1336 card_power_off(chip, SD_CARD);
1342 if (chip->auto_delink_en && chip->auto_delink_allowed &&
1343 !chip->card_ready && !chip->card_ejected && !chip->sd_io) {
1344 int enter_L1 = chip->auto_delink_in_L1 && (
1345 chip->aspm_l0s_l1_en || chip->ss_en);
1346 int delink_stage1_cnt = chip->delink_stage1_step;
1347 int delink_stage2_cnt = delink_stage1_cnt +
1348 chip->delink_stage2_step;
1349 int delink_stage3_cnt = delink_stage2_cnt +
1350 chip->delink_stage3_step;
1352 if (chip->auto_delink_cnt <= delink_stage3_cnt) {
1353 if (chip->auto_delink_cnt == delink_stage1_cnt) {
1354 rtsx_set_stat(chip, RTSX_STAT_DELINK);
1356 if (chip->asic_code && CHECK_PID(chip, 0x5208))
1357 rtsx_set_phy_reg_bit(chip, 0x1C, 2);
1359 if (chip->card_exist) {
1360 dev_dbg(rtsx_dev(chip), "False card inserted, do force delink\n");
1363 rtsx_write_register(chip,
1367 rtsx_write_register(chip,
1372 rtsx_enter_L1(chip);
1374 chip->auto_delink_cnt =
1375 delink_stage3_cnt + 1;
1377 dev_dbg(rtsx_dev(chip), "No card inserted, do delink\n");
1380 rtsx_write_register(chip,
1384 rtsx_write_register(chip,
1389 rtsx_enter_L1(chip);
1393 if (chip->auto_delink_cnt == delink_stage2_cnt) {
1394 dev_dbg(rtsx_dev(chip), "Try to do force delink\n");
1399 if (chip->asic_code && CHECK_PID(chip, 0x5208))
1400 rtsx_set_phy_reg_bit(chip, 0x1C, 2);
1402 rtsx_write_register(chip, CHANGE_LINK_STATE,
1406 chip->auto_delink_cnt++;
1409 chip->auto_delink_cnt = 0;
1413 void rtsx_undo_delink(struct rtsx_chip *chip)
1415 chip->auto_delink_allowed = 0;
1416 rtsx_write_register(chip, CHANGE_LINK_STATE, 0x0A, 0x00);
1420 * rtsx_stop_cmd - stop command transfer and DMA transfer
1421 * @chip: Realtek's card reader chip
1422 * @card: flash card type
1424 * Stop command transfer and DMA transfer.
1425 * This function is called in error handler.
1427 void rtsx_stop_cmd(struct rtsx_chip *chip, int card)
1431 for (i = 0; i <= 8; i++) {
1432 int addr = RTSX_HCBAR + i * 4;
1435 reg = rtsx_readl(chip, addr);
1436 dev_dbg(rtsx_dev(chip), "BAR (0x%02x): 0x%08x\n", addr, reg);
1438 rtsx_writel(chip, RTSX_HCBCTLR, STOP_CMD);
1439 rtsx_writel(chip, RTSX_HDBCTLR, STOP_DMA);
1441 for (i = 0; i < 16; i++) {
1442 u16 addr = 0xFE20 + (u16)i;
1445 rtsx_read_register(chip, addr, &val);
1446 dev_dbg(rtsx_dev(chip), "0x%04X: 0x%02x\n", addr, val);
1449 rtsx_write_register(chip, DMACTL, 0x80, 0x80);
1450 rtsx_write_register(chip, RBCTL, 0x80, 0x80);
1453 #define MAX_RW_REG_CNT 1024
1455 int rtsx_write_register(struct rtsx_chip *chip, u16 addr, u8 mask, u8 data)
1460 val |= (u32)(addr & 0x3FFF) << 16;
1461 val |= (u32)mask << 8;
1464 rtsx_writel(chip, RTSX_HAIMR, val);
1466 for (i = 0; i < MAX_RW_REG_CNT; i++) {
1467 val = rtsx_readl(chip, RTSX_HAIMR);
1468 if ((val & (1 << 31)) == 0) {
1469 if (data != (u8)val) {
1474 return STATUS_SUCCESS;
1479 return STATUS_TIMEDOUT;
1482 int rtsx_read_register(struct rtsx_chip *chip, u16 addr, u8 *data)
1490 val |= (u32)(addr & 0x3FFF) << 16;
1492 rtsx_writel(chip, RTSX_HAIMR, val);
1494 for (i = 0; i < MAX_RW_REG_CNT; i++) {
1495 val = rtsx_readl(chip, RTSX_HAIMR);
1496 if ((val & (1 << 31)) == 0)
1500 if (i >= MAX_RW_REG_CNT) {
1502 return STATUS_TIMEDOUT;
1506 *data = (u8)(val & 0xFF);
1508 return STATUS_SUCCESS;
1511 int rtsx_write_cfg_dw(struct rtsx_chip *chip, u8 func_no, u16 addr, u32 mask,
1518 for (i = 0; i < 4; i++) {
1520 retval = rtsx_write_register(chip, CFGDATA0 + i,
1522 (u8)(val & mask & 0xFF));
1534 retval = rtsx_write_register(chip, CFGADDR0, 0xFF, (u8)addr);
1539 retval = rtsx_write_register(chip, CFGADDR1, 0xFF,
1546 retval = rtsx_write_register(chip, CFGRWCTL, 0xFF,
1547 0x80 | mode | ((func_no & 0x03) << 4));
1553 for (i = 0; i < MAX_RW_REG_CNT; i++) {
1554 retval = rtsx_read_register(chip, CFGRWCTL, &tmp);
1559 if ((tmp & 0x80) == 0)
1564 return STATUS_SUCCESS;
1567 int rtsx_read_cfg_dw(struct rtsx_chip *chip, u8 func_no, u16 addr, u32 *val)
1574 retval = rtsx_write_register(chip, CFGADDR0, 0xFF, (u8)addr);
1579 retval = rtsx_write_register(chip, CFGADDR1, 0xFF, (u8)(addr >> 8));
1584 retval = rtsx_write_register(chip, CFGRWCTL, 0xFF,
1585 0x80 | ((func_no & 0x03) << 4));
1591 for (i = 0; i < MAX_RW_REG_CNT; i++) {
1592 retval = rtsx_read_register(chip, CFGRWCTL, &tmp);
1597 if ((tmp & 0x80) == 0)
1601 for (i = 0; i < 4; i++) {
1602 retval = rtsx_read_register(chip, CFGDATA0 + i, &tmp);
1607 data |= (u32)tmp << (i * 8);
1613 return STATUS_SUCCESS;
1616 int rtsx_write_cfg_seq(struct rtsx_chip *chip, u8 func, u16 addr, u8 *buf,
1620 u16 offset = addr % 4;
1621 u16 aligned_addr = addr - offset;
1627 return STATUS_NOMEM;
1630 if ((len + offset) % 4)
1631 dw_len = (len + offset) / 4 + 1;
1633 dw_len = (len + offset) / 4;
1635 dev_dbg(rtsx_dev(chip), "dw_len = %d\n", dw_len);
1637 data = vzalloc(dw_len * 4);
1640 return STATUS_NOMEM;
1643 mask = vzalloc(dw_len * 4);
1647 return STATUS_NOMEM;
1651 for (i = 0; i < len; i++) {
1652 mask[j] |= 0xFF << (offset * 8);
1653 data[j] |= buf[i] << (offset * 8);
1654 if (++offset == 4) {
1660 print_hex_dump_bytes(KBUILD_MODNAME ": ", DUMP_PREFIX_NONE, mask,
1662 print_hex_dump_bytes(KBUILD_MODNAME ": ", DUMP_PREFIX_NONE, data,
1665 for (i = 0; i < dw_len; i++) {
1666 retval = rtsx_write_cfg_dw(chip, func, aligned_addr + i * 4,
1668 if (retval != STATUS_SUCCESS) {
1679 return STATUS_SUCCESS;
1682 int rtsx_read_cfg_seq(struct rtsx_chip *chip, u8 func, u16 addr, u8 *buf,
1686 u16 offset = addr % 4;
1687 u16 aligned_addr = addr - offset;
1691 if ((len + offset) % 4)
1692 dw_len = (len + offset) / 4 + 1;
1694 dw_len = (len + offset) / 4;
1696 dev_dbg(rtsx_dev(chip), "dw_len = %d\n", dw_len);
1698 data = vmalloc(dw_len * 4);
1701 return STATUS_NOMEM;
1704 for (i = 0; i < dw_len; i++) {
1705 retval = rtsx_read_cfg_dw(chip, func, aligned_addr + i * 4,
1707 if (retval != STATUS_SUCCESS) {
1717 for (i = 0; i < len; i++) {
1718 buf[i] = (u8)(data[j] >> (offset * 8));
1719 if (++offset == 4) {
1728 return STATUS_SUCCESS;
1731 int rtsx_write_phy_register(struct rtsx_chip *chip, u8 addr, u16 val)
1734 bool finished = false;
1738 retval = rtsx_write_register(chip, PHYDATA0, 0xFF, (u8)val);
1743 retval = rtsx_write_register(chip, PHYDATA1, 0xFF, (u8)(val >> 8));
1748 retval = rtsx_write_register(chip, PHYADDR, 0xFF, addr);
1753 retval = rtsx_write_register(chip, PHYRWCTL, 0xFF, 0x81);
1759 for (i = 0; i < 100000; i++) {
1760 retval = rtsx_read_register(chip, PHYRWCTL, &tmp);
1765 if (!(tmp & 0x80)) {
1776 return STATUS_SUCCESS;
1779 int rtsx_read_phy_register(struct rtsx_chip *chip, u8 addr, u16 *val)
1782 bool finished = false;
1787 retval = rtsx_write_register(chip, PHYADDR, 0xFF, addr);
1792 retval = rtsx_write_register(chip, PHYRWCTL, 0xFF, 0x80);
1798 for (i = 0; i < 100000; i++) {
1799 retval = rtsx_read_register(chip, PHYRWCTL, &tmp);
1804 if (!(tmp & 0x80)) {
1815 retval = rtsx_read_register(chip, PHYDATA0, &tmp);
1821 retval = rtsx_read_register(chip, PHYDATA1, &tmp);
1826 data |= (u16)tmp << 8;
1831 return STATUS_SUCCESS;
1834 int rtsx_read_efuse(struct rtsx_chip *chip, u8 addr, u8 *val)
1840 retval = rtsx_write_register(chip, EFUSE_CTRL, 0xFF, 0x80 | addr);
1846 for (i = 0; i < 100; i++) {
1847 retval = rtsx_read_register(chip, EFUSE_CTRL, &data);
1859 return STATUS_TIMEDOUT;
1862 retval = rtsx_read_register(chip, EFUSE_DATA, &data);
1870 return STATUS_SUCCESS;
1873 int rtsx_write_efuse(struct rtsx_chip *chip, u8 addr, u8 val)
1877 u8 data = 0, tmp = 0xFF;
1879 for (i = 0; i < 8; i++) {
1880 if (val & (u8)(1 << i))
1883 tmp &= (~(u8)(1 << i));
1884 dev_dbg(rtsx_dev(chip), "Write 0x%x to 0x%x\n", tmp, addr);
1886 retval = rtsx_write_register(chip, EFUSE_DATA, 0xFF, tmp);
1891 retval = rtsx_write_register(chip, EFUSE_CTRL, 0xFF,
1898 for (j = 0; j < 100; j++) {
1899 retval = rtsx_read_register(chip, EFUSE_CTRL, &data);
1911 return STATUS_TIMEDOUT;
1917 return STATUS_SUCCESS;
1920 int rtsx_clr_phy_reg_bit(struct rtsx_chip *chip, u8 reg, u8 bit)
1925 retval = rtsx_read_phy_register(chip, reg, &value);
1926 if (retval != STATUS_SUCCESS) {
1931 if (value & (1 << bit)) {
1932 value &= ~(1 << bit);
1933 retval = rtsx_write_phy_register(chip, reg, value);
1934 if (retval != STATUS_SUCCESS) {
1940 return STATUS_SUCCESS;
1943 int rtsx_set_phy_reg_bit(struct rtsx_chip *chip, u8 reg, u8 bit)
1948 retval = rtsx_read_phy_register(chip, reg, &value);
1949 if (retval != STATUS_SUCCESS) {
1954 if ((value & (1 << bit)) == 0) {
1955 value |= (1 << bit);
1956 retval = rtsx_write_phy_register(chip, reg, value);
1957 if (retval != STATUS_SUCCESS) {
1963 return STATUS_SUCCESS;
1966 int rtsx_check_link_ready(struct rtsx_chip *chip)
1971 retval = rtsx_read_register(chip, IRQSTAT0, &val);
1977 dev_dbg(rtsx_dev(chip), "IRQSTAT0: 0x%x\n", val);
1978 if (val & LINK_RDY_INT) {
1979 dev_dbg(rtsx_dev(chip), "Delinked!\n");
1980 rtsx_write_register(chip, IRQSTAT0, LINK_RDY_INT, LINK_RDY_INT);
1984 return STATUS_SUCCESS;
1987 static void rtsx_handle_pm_dstate(struct rtsx_chip *chip, u8 dstate)
1991 dev_dbg(rtsx_dev(chip), "%04x set pm_dstate to %d\n",
1992 chip->product_id, dstate);
1994 if (CHK_SDIO_EXIST(chip)) {
1997 if (CHECK_PID(chip, 0x5288))
2002 rtsx_read_cfg_dw(chip, func_no, 0x84, &ultmp);
2003 dev_dbg(rtsx_dev(chip), "pm_dstate of function %d: 0x%x\n",
2004 (int)func_no, ultmp);
2005 rtsx_write_cfg_dw(chip, func_no, 0x84, 0xFF, dstate);
2008 rtsx_write_config_byte(chip, 0x44, dstate);
2009 rtsx_write_config_byte(chip, 0x45, 0);
2012 void rtsx_enter_L1(struct rtsx_chip *chip)
2014 rtsx_handle_pm_dstate(chip, 2);
2017 void rtsx_exit_L1(struct rtsx_chip *chip)
2019 rtsx_write_config_byte(chip, 0x44, 0);
2020 rtsx_write_config_byte(chip, 0x45, 0);
2023 void rtsx_enter_ss(struct rtsx_chip *chip)
2025 dev_dbg(rtsx_dev(chip), "Enter Selective Suspend State!\n");
2027 rtsx_write_register(chip, IRQSTAT0, LINK_RDY_INT, LINK_RDY_INT);
2029 if (chip->power_down_in_ss) {
2030 rtsx_power_off_card(chip);
2031 rtsx_force_power_down(chip, SSC_PDCTL | OC_PDCTL);
2034 if (CHK_SDIO_EXIST(chip))
2035 rtsx_write_cfg_dw(chip, CHECK_PID(chip, 0x5288) ? 2 : 1,
2036 0xC0, 0xFF00, 0x0100);
2038 if (chip->auto_delink_en) {
2039 rtsx_write_register(chip, HOST_SLEEP_STATE, 0x01, 0x01);
2041 if (!chip->phy_debug_mode) {
2044 tmp = rtsx_readl(chip, RTSX_BIER);
2046 rtsx_writel(chip, RTSX_BIER, tmp);
2049 rtsx_write_register(chip, CHANGE_LINK_STATE, 0x02, 0);
2052 rtsx_enter_L1(chip);
2054 RTSX_CLR_DELINK(chip);
2055 rtsx_set_stat(chip, RTSX_STAT_SS);
2058 void rtsx_exit_ss(struct rtsx_chip *chip)
2060 dev_dbg(rtsx_dev(chip), "Exit Selective Suspend State!\n");
2064 if (chip->power_down_in_ss) {
2065 rtsx_force_power_on(chip, SSC_PDCTL | OC_PDCTL);
2069 if (RTSX_TST_DELINK(chip)) {
2070 chip->need_reinit = SD_CARD | MS_CARD | XD_CARD;
2071 rtsx_reinit_cards(chip, 1);
2072 RTSX_CLR_DELINK(chip);
2073 } else if (chip->power_down_in_ss) {
2074 chip->need_reinit = SD_CARD | MS_CARD | XD_CARD;
2075 rtsx_reinit_cards(chip, 0);
2079 int rtsx_pre_handle_interrupt(struct rtsx_chip *chip)
2081 u32 status, int_enable;
2082 bool exit_ss = false;
2090 chip->ss_counter = 0;
2091 if (rtsx_get_stat(chip) == RTSX_STAT_SS) {
2094 rtsx_set_stat(chip, RTSX_STAT_RUN);
2098 int_enable = rtsx_readl(chip, RTSX_BIER);
2099 chip->int_reg = rtsx_readl(chip, RTSX_BIPR);
2101 if (((chip->int_reg & int_enable) == 0) ||
2102 (chip->int_reg == 0xFFFFFFFF))
2105 status = chip->int_reg &= (int_enable | 0x7FFFFF);
2107 if (status & CARD_INT) {
2108 chip->auto_delink_cnt = 0;
2110 if (status & SD_INT) {
2111 if (status & SD_EXIST) {
2112 set_bit(SD_NR, &chip->need_reset);
2114 set_bit(SD_NR, &chip->need_release);
2115 chip->sd_reset_counter = 0;
2116 chip->sd_show_cnt = 0;
2117 clear_bit(SD_NR, &chip->need_reset);
2120 /* If multi-luns, it's possible that
2121 when plugging/unplugging one card
2122 there is another card which still
2123 exists in the slot. In this case,
2124 all existed cards should be reset.
2126 if (exit_ss && (status & SD_EXIST))
2127 set_bit(SD_NR, &chip->need_reinit);
2129 if (!CHECK_PID(chip, 0x5288) || CHECK_BARO_PKG(chip, QFN)) {
2130 if (status & XD_INT) {
2131 if (status & XD_EXIST) {
2132 set_bit(XD_NR, &chip->need_reset);
2134 set_bit(XD_NR, &chip->need_release);
2135 chip->xd_reset_counter = 0;
2136 chip->xd_show_cnt = 0;
2137 clear_bit(XD_NR, &chip->need_reset);
2140 if (exit_ss && (status & XD_EXIST))
2141 set_bit(XD_NR, &chip->need_reinit);
2144 if (status & MS_INT) {
2145 if (status & MS_EXIST) {
2146 set_bit(MS_NR, &chip->need_reset);
2148 set_bit(MS_NR, &chip->need_release);
2149 chip->ms_reset_counter = 0;
2150 chip->ms_show_cnt = 0;
2151 clear_bit(MS_NR, &chip->need_reset);
2154 if (exit_ss && (status & MS_EXIST))
2155 set_bit(MS_NR, &chip->need_reinit);
2160 chip->ocp_int = ocp_int & status;
2163 if (chip->sd_io && (chip->int_reg & DATA_DONE_INT))
2164 chip->int_reg &= ~(u32)DATA_DONE_INT;
2166 return STATUS_SUCCESS;
2169 void rtsx_do_before_power_down(struct rtsx_chip *chip, int pm_stat)
2173 dev_dbg(rtsx_dev(chip), "%s, pm_stat = %d\n", __func__, pm_stat);
2175 rtsx_set_stat(chip, RTSX_STAT_SUSPEND);
2177 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2178 if (retval != STATUS_SUCCESS)
2181 rtsx_release_cards(chip);
2182 rtsx_disable_bus_int(chip);
2183 turn_off_led(chip, LED_GPIO);
2185 #ifdef HW_AUTO_SWITCH_SD_BUS
2187 chip->sdio_in_charge = 1;
2188 if (CHECK_PID(chip, 0x5208)) {
2189 rtsx_write_register(chip, TLPTISTAT, 0x08, 0x08);
2190 /* Enable sdio_bus_auto_switch */
2191 rtsx_write_register(chip, 0xFE70, 0x80, 0x80);
2192 } else if (CHECK_PID(chip, 0x5288)) {
2193 rtsx_write_register(chip, TLPTISTAT, 0x08, 0x08);
2194 /* Enable sdio_bus_auto_switch */
2195 rtsx_write_register(chip, 0xFE5A, 0x08, 0x08);
2200 if (CHECK_PID(chip, 0x5208) && (chip->ic_version >= IC_VER_D)) {
2201 /* u_force_clkreq_0 */
2202 rtsx_write_register(chip, PETXCFG, 0x08, 0x08);
2205 if (pm_stat == PM_S1) {
2206 dev_dbg(rtsx_dev(chip), "Host enter S1\n");
2207 rtsx_write_register(chip, HOST_SLEEP_STATE, 0x03,
2209 } else if (pm_stat == PM_S3) {
2210 if (chip->s3_pwr_off_delay > 0)
2211 wait_timeout(chip->s3_pwr_off_delay);
2213 dev_dbg(rtsx_dev(chip), "Host enter S3\n");
2214 rtsx_write_register(chip, HOST_SLEEP_STATE, 0x03,
2218 if (chip->do_delink_before_power_down && chip->auto_delink_en)
2219 rtsx_write_register(chip, CHANGE_LINK_STATE, 0x02, 2);
2221 rtsx_force_power_down(chip, SSC_PDCTL | OC_PDCTL);
2225 chip->card_exist = 0;
2228 void rtsx_enable_aspm(struct rtsx_chip *chip)
2230 if (chip->aspm_l0s_l1_en && chip->dynamic_aspm && !chip->aspm_enabled) {
2231 dev_dbg(rtsx_dev(chip), "Try to enable ASPM\n");
2232 chip->aspm_enabled = 1;
2234 if (chip->asic_code && CHECK_PID(chip, 0x5208))
2235 rtsx_write_phy_register(chip, 0x07, 0);
2236 if (CHECK_PID(chip, 0x5208)) {
2237 rtsx_write_register(chip, ASPM_FORCE_CTL, 0xF3,
2238 0x30 | chip->aspm_level[0]);
2240 rtsx_write_config_byte(chip, LCTLR,
2241 chip->aspm_l0s_l1_en);
2244 if (CHK_SDIO_EXIST(chip)) {
2245 u16 val = chip->aspm_l0s_l1_en | 0x0100;
2247 rtsx_write_cfg_dw(chip, CHECK_PID(chip, 0x5288) ? 2 : 1,
2253 void rtsx_disable_aspm(struct rtsx_chip *chip)
2255 if (CHECK_PID(chip, 0x5208))
2256 rtsx_monitor_aspm_config(chip);
2258 if (chip->aspm_l0s_l1_en && chip->dynamic_aspm && chip->aspm_enabled) {
2259 dev_dbg(rtsx_dev(chip), "Try to disable ASPM\n");
2260 chip->aspm_enabled = 0;
2262 if (chip->asic_code && CHECK_PID(chip, 0x5208))
2263 rtsx_write_phy_register(chip, 0x07, 0x0129);
2264 if (CHECK_PID(chip, 0x5208))
2265 rtsx_write_register(chip, ASPM_FORCE_CTL,
2268 rtsx_write_config_byte(chip, LCTLR, 0x00);
2274 int rtsx_read_ppbuf(struct rtsx_chip *chip, u8 *buf, int buf_len)
2283 return STATUS_ERROR;
2287 reg_addr = PPBUF_BASE2;
2288 for (i = 0; i < buf_len/256; i++) {
2289 rtsx_init_cmd(chip);
2291 for (j = 0; j < 256; j++)
2292 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr++, 0, 0);
2294 retval = rtsx_send_cmd(chip, 0, 250);
2300 memcpy(ptr, rtsx_get_cmd_data(chip), 256);
2305 rtsx_init_cmd(chip);
2307 for (j = 0; j < buf_len%256; j++)
2308 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr++, 0, 0);
2310 retval = rtsx_send_cmd(chip, 0, 250);
2317 memcpy(ptr, rtsx_get_cmd_data(chip), buf_len%256);
2319 return STATUS_SUCCESS;
2322 int rtsx_write_ppbuf(struct rtsx_chip *chip, u8 *buf, int buf_len)
2331 return STATUS_ERROR;
2335 reg_addr = PPBUF_BASE2;
2336 for (i = 0; i < buf_len/256; i++) {
2337 rtsx_init_cmd(chip);
2339 for (j = 0; j < 256; j++) {
2340 rtsx_add_cmd(chip, WRITE_REG_CMD, reg_addr++, 0xFF,
2345 retval = rtsx_send_cmd(chip, 0, 250);
2353 rtsx_init_cmd(chip);
2355 for (j = 0; j < buf_len%256; j++) {
2356 rtsx_add_cmd(chip, WRITE_REG_CMD, reg_addr++, 0xFF,
2361 retval = rtsx_send_cmd(chip, 0, 250);
2368 return STATUS_SUCCESS;
2371 int rtsx_check_chip_exist(struct rtsx_chip *chip)
2373 if (rtsx_readl(chip, 0) == 0xFFFFFFFF) {
2378 return STATUS_SUCCESS;
2381 int rtsx_force_power_on(struct rtsx_chip *chip, u8 ctl)
2386 if (ctl & SSC_PDCTL)
2387 mask |= SSC_POWER_DOWN;
2390 if (ctl & OC_PDCTL) {
2391 mask |= SD_OC_POWER_DOWN;
2392 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2393 mask |= MS_OC_POWER_DOWN;
2398 retval = rtsx_write_register(chip, FPDCTL, mask, 0);
2399 if (retval != STATUS_SUCCESS) {
2404 if (CHECK_PID(chip, 0x5288))
2408 return STATUS_SUCCESS;
2411 int rtsx_force_power_down(struct rtsx_chip *chip, u8 ctl)
2414 u8 mask = 0, val = 0;
2416 if (ctl & SSC_PDCTL)
2417 mask |= SSC_POWER_DOWN;
2420 if (ctl & OC_PDCTL) {
2421 mask |= SD_OC_POWER_DOWN;
2422 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2423 mask |= MS_OC_POWER_DOWN;
2429 retval = rtsx_write_register(chip, FPDCTL, mask, val);
2430 if (retval != STATUS_SUCCESS) {
2436 return STATUS_SUCCESS;