drivers/staging/rts_pstor/rtsx_chip.c

   1 /* Driver for Realtek PCI-Express card reader
   2  *
   3  * Copyright(c) 2009 Realtek Semiconductor Corp. All rights reserved.
   4  *
   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
   8  * later version.
   9  *
  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.
  14  *
  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/>.
  17  *
  18  * Author:
  19  *   wwang (wei_wang@realsil.com.cn)
  20  *   No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
  21  */
  22
  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>
  28
  29 #include "rtsx.h"
  30 #include "rtsx_transport.h"
  31 #include "rtsx_scsi.h"
  32 #include "rtsx_card.h"
  33 #include "rtsx_chip.h"
  34 #include "rtsx_sys.h"
  35 #include "general.h"
  36
  37 #include "sd.h"
  38 #include "xd.h"
  39 #include "ms.h"
  40
  41 static void rtsx_calibration(struct rtsx_chip *chip)
  42 {
  43         rtsx_write_phy_register(chip, 0x1B, 0x135E);
  44         wait_timeout(10);
  45         rtsx_write_phy_register(chip, 0x00, 0x0280);
  46         rtsx_write_phy_register(chip, 0x01, 0x7112);
  47         rtsx_write_phy_register(chip, 0x01, 0x7110);
  48         rtsx_write_phy_register(chip, 0x01, 0x7112);
  49         rtsx_write_phy_register(chip, 0x01, 0x7113);
  50         rtsx_write_phy_register(chip, 0x00, 0x0288);
  51 }
  52
  53 void rtsx_disable_card_int(struct rtsx_chip *chip)
  54 {
  55         u32 reg = rtsx_readl(chip, RTSX_BIER);
  56
  57         reg &= ~(XD_INT_EN | SD_INT_EN | MS_INT_EN);
  58         rtsx_writel(chip, RTSX_BIER, reg);
  59 }
  60
  61 void rtsx_enable_card_int(struct rtsx_chip *chip)
  62 {
  63         u32 reg = rtsx_readl(chip, RTSX_BIER);
  64         int i;
  65
  66         for (i = 0; i <= chip->max_lun; i++) {
  67                 if (chip->lun2card[i] & XD_CARD)
  68                         reg |= XD_INT_EN;
  69                 if (chip->lun2card[i] & SD_CARD)
  70                         reg |= SD_INT_EN;
  71                 if (chip->lun2card[i] & MS_CARD)
  72                         reg |= MS_INT_EN;
  73         }
  74         if (chip->hw_bypass_sd)
  75                 reg &= ~((u32)SD_INT_EN);
  76
  77         rtsx_writel(chip, RTSX_BIER, reg);
  78 }
  79
  80 void rtsx_enable_bus_int(struct rtsx_chip *chip)
  81 {
  82         u32 reg = 0;
  83 #ifndef DISABLE_CARD_INT
  84         int i;
  85 #endif
  86
  87         reg = TRANS_OK_INT_EN | TRANS_FAIL_INT_EN;
  88
  89 #ifndef DISABLE_CARD_INT
  90         for (i = 0; i <= chip->max_lun; i++) {
  91                 RTSX_DEBUGP("lun2card[%d] = 0x%02x\n", i, chip->lun2card[i]);
  92
  93                 if (chip->lun2card[i] & XD_CARD)
  94                         reg |= XD_INT_EN;
  95                 if (chip->lun2card[i] & SD_CARD)
  96                         reg |= SD_INT_EN;
  97                 if (chip->lun2card[i] & MS_CARD)
  98                         reg |= MS_INT_EN;
  99         }
 100         if (chip->hw_bypass_sd)
 101                 reg &= ~((u32)SD_INT_EN);
 102 #endif
 103
 104         if (chip->ic_version >= IC_VER_C)
 105                 reg |= DELINK_INT_EN;
 106 #ifdef SUPPORT_OCP
 107         if (CHECK_PID(chip, 0x5209)) {
 108                 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
 109                         reg |= MS_OC_INT_EN | SD_OC_INT_EN;
 110                 } else {
 111                         reg |= SD_OC_INT_EN;
 112                 }
 113         } else {
 114                 reg |= OC_INT_EN;
 115         }
 116 #endif
 117         if (!chip->adma_mode)
 118                 reg |= DATA_DONE_INT_EN;
 119
 120         /* Enable Bus Interrupt */
 121         rtsx_writel(chip, RTSX_BIER, reg);
 122
 123         RTSX_DEBUGP("RTSX_BIER: 0x%08x\n", reg);
 124 }
 125
 126 void rtsx_disable_bus_int(struct rtsx_chip *chip)
 127 {
 128         rtsx_writel(chip, RTSX_BIER, 0);
 129 }
 130
 131 static int rtsx_pre_handle_sdio_old(struct rtsx_chip *chip)
 132 {
 133         if (chip->ignore_sd && CHK_SDIO_EXIST(chip)) {
 134                 if (chip->asic_code) {
 135                         RTSX_WRITE_REG(chip, CARD_PULL_CTL5, 0xFF,
 136                                 MS_INS_PU | SD_WP_PU | SD_CD_PU | SD_CMD_PU);
 137                 } else {
 138                         RTSX_WRITE_REG(chip, FPGA_PULL_CTL, 0xFF, FPGA_SD_PULL_CTL_EN);
 139                 }
 140                 RTSX_WRITE_REG(chip, CARD_SHARE_MODE, 0xFF, CARD_SHARE_48_SD);
 141
 142                 /* Enable SDIO internal clock */
 143                 RTSX_WRITE_REG(chip, 0xFF2C, 0x01, 0x01);
 144
 145                 RTSX_WRITE_REG(chip, SDIO_CTRL, 0xFF, SDIO_BUS_CTRL | SDIO_CD_CTRL);
 146
 147                 chip->sd_int = 1;
 148                 chip->sd_io = 1;
 149         } else {
 150                 chip->need_reset |= SD_CARD;
 151         }
 152
 153         return STATUS_SUCCESS;
 154 }
 155
 156 #ifdef HW_AUTO_SWITCH_SD_BUS
 157 static int rtsx_pre_handle_sdio_new(struct rtsx_chip *chip)
 158 {
 159         u8 tmp;
 160         int sw_bypass_sd = 0;
 161         int retval;
 162
 163         if (chip->driver_first_load) {
 164                 if (CHECK_PID(chip, 0x5288)) {
 165                         RTSX_READ_REG(chip, 0xFE5A, &tmp);
 166                         if (tmp & 0x08)
 167                                 sw_bypass_sd = 1;
 168                 } else if (CHECK_PID(chip, 0x5208)) {
 169                         RTSX_READ_REG(chip, 0xFE70, &tmp);
 170                         if (tmp & 0x80)
 171                                 sw_bypass_sd = 1;
 172                 } else if (CHECK_PID(chip, 0x5209)) {
 173                         RTSX_READ_REG(chip, SDIO_CFG, &tmp);
 174                         if (tmp & SDIO_BUS_AUTO_SWITCH)
 175                                 sw_bypass_sd = 1;
 176                 }
 177         } else {
 178                 if (chip->sdio_in_charge)
 179                         sw_bypass_sd = 1;
 180         }
 181         RTSX_DEBUGP("chip->sdio_in_charge = %d\n", chip->sdio_in_charge);
 182         RTSX_DEBUGP("chip->driver_first_load = %d\n", chip->driver_first_load);
 183         RTSX_DEBUGP("sw_bypass_sd = %d\n", sw_bypass_sd);
 184
 185         if (sw_bypass_sd) {
 186                 u8 cd_toggle_mask = 0;
 187
 188                 RTSX_READ_REG(chip, TLPTISTAT, &tmp);
 189                 if (CHECK_PID(chip, 0x5209)) {
 190                         cd_toggle_mask = 0x10;
 191                 } else {
 192                         cd_toggle_mask = 0x08;
 193                 }
 194                 if (tmp & cd_toggle_mask) {
 195                         /* Disable sdio_bus_auto_switch */
 196                         if (CHECK_PID(chip, 0x5288)) {
 197                                 RTSX_WRITE_REG(chip, 0xFE5A, 0x08, 0x00);
 198                         } else if (CHECK_PID(chip, 0x5208)) {
 199                                 RTSX_WRITE_REG(chip, 0xFE70, 0x80, 0x00);
 200                         } else {
 201                                 RTSX_WRITE_REG(chip, SDIO_CFG, SDIO_BUS_AUTO_SWITCH, 0);
 202                         }
 203                         RTSX_WRITE_REG(chip, TLPTISTAT, 0xFF, tmp);
 204
 205                         chip->need_reset |= SD_CARD;
 206                 } else {
 207                         RTSX_DEBUGP("Chip inserted with SDIO!\n");
 208
 209                         if (chip->asic_code) {
 210                                 retval = sd_pull_ctl_enable(chip);
 211                                 if (retval != STATUS_SUCCESS) {
 212                                         TRACE_RET(chip, STATUS_FAIL);
 213                                 }
 214                         } else {
 215                                 RTSX_WRITE_REG(chip, FPGA_PULL_CTL, FPGA_SD_PULL_CTL_BIT | 0x20, 0);
 216                         }
 217                         retval = card_share_mode(chip, SD_CARD);
 218                         if (retval != STATUS_SUCCESS) {
 219                                 TRACE_RET(chip, STATUS_FAIL);
 220                         }
 221
 222                         /* Enable sdio_bus_auto_switch */
 223                         if (CHECK_PID(chip, 0x5288)) {
 224                                 RTSX_WRITE_REG(chip, 0xFE5A, 0x08, 0x08);
 225                         } else if (CHECK_PID(chip, 0x5208)) {
 226                                 RTSX_WRITE_REG(chip, 0xFE70, 0x80, 0x80);
 227                         } else {
 228                                 RTSX_WRITE_REG(chip, SDIO_CFG,
 229                                         SDIO_BUS_AUTO_SWITCH, SDIO_BUS_AUTO_SWITCH);
 230                         }
 231                         chip->chip_insert_with_sdio = 1;
 232                         chip->sd_io = 1;
 233                 }
 234         } else {
 235                 if (CHECK_PID(chip, 0x5209)) {
 236                         RTSX_WRITE_REG(chip, TLPTISTAT, 0x10, 0x10);
 237                 } else {
 238                         RTSX_WRITE_REG(chip, TLPTISTAT, 0x08, 0x08);
 239                 }
 240                 chip->need_reset |= SD_CARD;
 241         }
 242
 243         return STATUS_SUCCESS;
 244 }
 245 #endif
 246
 247 int rtsx_reset_chip(struct rtsx_chip *chip)
 248 {
 249         int retval;
 250
 251         rtsx_writel(chip, RTSX_HCBAR, chip->host_cmds_addr);
 252
 253         rtsx_disable_aspm(chip);
 254
 255         if (CHECK_PID(chip, 0x5209) && chip->asic_code) {
 256                 u16 val;
 257
 258                 /* optimize PHY */
 259                 retval = rtsx_write_phy_register(chip, 0x00, 0xB966);
 260                 if (retval != STATUS_SUCCESS) {
 261                         TRACE_RET(chip, STATUS_FAIL);
 262                 }
 263                 retval = rtsx_write_phy_register(chip, 0x01, 0x713F);
 264                 if (retval != STATUS_SUCCESS) {
 265                         TRACE_RET(chip, STATUS_FAIL);
 266                 }
 267                 retval = rtsx_write_phy_register(chip, 0x03, 0xA549);
 268                 if (retval != STATUS_SUCCESS) {
 269                         TRACE_RET(chip, STATUS_FAIL);
 270                 }
 271                 retval = rtsx_write_phy_register(chip, 0x06, 0xB235);
 272                 if (retval != STATUS_SUCCESS) {
 273                         TRACE_RET(chip, STATUS_FAIL);
 274                 }
 275                 retval = rtsx_write_phy_register(chip, 0x07, 0xEF40);
 276                 if (retval != STATUS_SUCCESS) {
 277                         TRACE_RET(chip, STATUS_FAIL);
 278                 }
 279                 retval = rtsx_write_phy_register(chip, 0x1E, 0xF8EB);
 280                 if (retval != STATUS_SUCCESS) {
 281                         TRACE_RET(chip, STATUS_FAIL);
 282                 }
 283                 retval = rtsx_write_phy_register(chip, 0x19, 0xFE6C);
 284                 if (retval != STATUS_SUCCESS) {
 285                         TRACE_RET(chip, STATUS_FAIL);
 286                 }
 287                 wait_timeout(1);
 288                 retval = rtsx_write_phy_register(chip, 0x0A, 0x05C0);
 289                 if (retval != STATUS_SUCCESS) {
 290                         TRACE_RET(chip, STATUS_FAIL);
 291                 }
 292
 293                 retval = rtsx_write_cfg_dw(chip, 1, 0x110, 0xFFFF, 0xFFFF);
 294                 if (retval != STATUS_SUCCESS) {
 295                         TRACE_RET(chip, STATUS_FAIL);
 296                 }
 297
 298                 retval = rtsx_read_phy_register(chip, 0x08, &val);
 299                 if (retval != STATUS_SUCCESS) {
 300                         TRACE_RET(chip, STATUS_FAIL);
 301                 }
 302                 RTSX_DEBUGP("Read from phy 0x08: 0x%04x\n", val);
 303
 304                 if (chip->phy_voltage) {
 305                         chip->phy_voltage &= 0x3F;
 306                         RTSX_DEBUGP("chip->phy_voltage = 0x%x\n", chip->phy_voltage);
 307                         val &= ~0x3F;
 308                         val |= chip->phy_voltage;
 309                         RTSX_DEBUGP("Write to phy 0x08: 0x%04x\n", val);
 310                         retval = rtsx_write_phy_register(chip, 0x08, val);
 311                         if (retval != STATUS_SUCCESS) {
 312                                 TRACE_RET(chip, STATUS_FAIL);
 313                         }
 314                 } else {
 315                         chip->phy_voltage = (u8)(val & 0x3F);
 316                         RTSX_DEBUGP("Default, chip->phy_voltage = 0x%x\n", chip->phy_voltage);
 317                 }
 318         }
 319
 320         RTSX_WRITE_REG(chip, HOST_SLEEP_STATE, 0x03, 0x00);
 321
 322         /* Disable card clock */
 323         RTSX_WRITE_REG(chip, CARD_CLK_EN, 0x1E, 0);
 324
 325 #ifdef SUPPORT_OCP
 326         /* SSC power on, OCD power on */
 327         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
 328                 RTSX_WRITE_REG(chip, FPDCTL, OC_POWER_DOWN, 0);
 329         } else {
 330                 RTSX_WRITE_REG(chip, FPDCTL, OC_POWER_DOWN, MS_OC_POWER_DOWN);
 331         }
 332         if (CHECK_PID(chip, 0x5209)) {
 333                 RTSX_WRITE_REG(chip, OCPPARA1, SD_OCP_TIME_MASK | MS_OCP_TIME_MASK,
 334                                     SD_OCP_TIME_800 | MS_OCP_TIME_800);
 335                 RTSX_WRITE_REG(chip, OCPPARA2, SD_OCP_THD_MASK | MS_OCP_THD_MASK,
 336                                     chip->sd_400mA_ocp_thd | (chip->ms_ocp_thd << 4));
 337                 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
 338                         RTSX_WRITE_REG(chip, OCPGLITCH, SD_OCP_GLITCH_MASK | MS_OCP_GLITCH_MASK,
 339                                        SD_OCP_GLITCH_10000 | MS_OCP_GLITCH_10000);
 340                 } else {
 341                         RTSX_WRITE_REG(chip, OCPGLITCH, SD_OCP_GLITCH_MASK, SD_OCP_GLITCH_10000);
 342                 }
 343                 RTSX_WRITE_REG(chip, OCPCTL, 0xFF,
 344                                     SD_OCP_INT_EN | SD_DETECT_EN | MS_OCP_INT_EN | MS_DETECT_EN);
 345         } else {
 346                 RTSX_WRITE_REG(chip, OCPPARA1, OCP_TIME_MASK, OCP_TIME_800);
 347                 RTSX_WRITE_REG(chip, OCPPARA2, OCP_THD_MASK, OCP_THD_244_946);
 348                 RTSX_WRITE_REG(chip, OCPCTL, 0xFF, CARD_OC_INT_EN | CARD_DETECT_EN);
 349         }
 350 #else
 351         /* OC power down */
 352         RTSX_WRITE_REG(chip, FPDCTL, OC_POWER_DOWN, OC_POWER_DOWN);
 353 #endif
 354
 355         if (!CHECK_PID(chip, 0x5288)) {
 356                 RTSX_WRITE_REG(chip, CARD_GPIO_DIR, 0xFF, 0x03);
 357         }
 358
 359         /* Turn off LED */
 360         RTSX_WRITE_REG(chip, CARD_GPIO, 0xFF, 0x03);
 361
 362         /* Reset delink mode */
 363         RTSX_WRITE_REG(chip, CHANGE_LINK_STATE, 0x0A, 0);
 364
 365         /* Card driving select */
 366         RTSX_WRITE_REG(chip, CARD_DRIVE_SEL, 0xFF, chip->card_drive_sel);
 367         if (CHECK_PID(chip, 0x5209)) {
 368                 RTSX_WRITE_REG(chip, SD30_DRIVE_SEL, 0x07, chip->sd30_drive_sel_3v3);
 369         }
 370
 371 #ifdef LED_AUTO_BLINK
 372         RTSX_WRITE_REG(chip, CARD_AUTO_BLINK, 0xFF,
 373                         LED_BLINK_SPEED | BLINK_EN | LED_GPIO0);
 374 #endif
 375
 376         if (chip->asic_code) {
 377                 /* Enable SSC Clock */
 378                 RTSX_WRITE_REG(chip, SSC_CTL1, 0xFF, SSC_8X_EN | SSC_SEL_4M);
 379                 RTSX_WRITE_REG(chip, SSC_CTL2, 0xFF, 0x12);
 380         }
 381
 382         /* Disable cd_pwr_save (u_force_rst_core_en=0, u_cd_rst_core_en=0)
 383               0xFE5B
 384               bit[1]    u_cd_rst_core_en        rst_value = 0
 385               bit[2]    u_force_rst_core_en     rst_value = 0
 386               bit[5]    u_mac_phy_rst_n_dbg     rst_value = 1
 387               bit[4]    u_non_sticky_rst_n_dbg  rst_value = 0
 388         */
 389         RTSX_WRITE_REG(chip, CHANGE_LINK_STATE, 0x16, 0x10);
 390
 391         /* Enable ASPM */
 392         if (chip->aspm_l0s_l1_en) {
 393                 if (chip->dynamic_aspm) {
 394                         if (CHK_SDIO_EXIST(chip)) {
 395                                 if (CHECK_PID(chip, 0x5209)) {
 396                                         retval = rtsx_write_cfg_dw(chip, 1, 0xC0, 0xFF, chip->aspm_l0s_l1_en);
 397                                         if (retval != STATUS_SUCCESS) {
 398                                                 TRACE_RET(chip, STATUS_FAIL);
 399                                         }
 400                                 } else if (CHECK_PID(chip, 0x5288)) {
 401                                         retval = rtsx_write_cfg_dw(chip, 2, 0xC0, 0xFF, chip->aspm_l0s_l1_en);
 402                                         if (retval != STATUS_SUCCESS) {
 403                                                 TRACE_RET(chip, STATUS_FAIL);
 404                                         }
 405                                 }
 406                         }
 407                 } else {
 408                         if (CHECK_PID(chip, 0x5208)) {
 409                                 RTSX_WRITE_REG(chip, ASPM_FORCE_CTL, 0xFF, 0x3F);
 410                         }
 411
 412                         retval = rtsx_write_config_byte(chip, LCTLR, chip->aspm_l0s_l1_en);
 413                         if (retval != STATUS_SUCCESS) {
 414                                 TRACE_RET(chip, STATUS_FAIL);
 415                         }
 416                         chip->aspm_level[0] = chip->aspm_l0s_l1_en;
 417                         if (CHK_SDIO_EXIST(chip)) {
 418                                 chip->aspm_level[1] = chip->aspm_l0s_l1_en;
 419                                 if (CHECK_PID(chip, 0x5288)) {
 420                                         retval = rtsx_write_cfg_dw(chip, 2, 0xC0, 0xFF, chip->aspm_l0s_l1_en);
 421                                 } else {
 422                                         retval = rtsx_write_cfg_dw(chip, 1, 0xC0, 0xFF, chip->aspm_l0s_l1_en);
 423                                 }
 424                                 if (retval != STATUS_SUCCESS) {
 425                                         TRACE_RET(chip, STATUS_FAIL);
 426                                 }
 427                         }
 428
 429                         chip->aspm_enabled = 1;
 430                 }
 431         } else {
 432                 if (chip->asic_code && CHECK_PID(chip, 0x5208)) {
 433                         retval = rtsx_write_phy_register(chip, 0x07, 0x0129);
 434                         if (retval != STATUS_SUCCESS) {
 435                                 TRACE_RET(chip, STATUS_FAIL);
 436                         }
 437                 }
 438                 retval = rtsx_write_config_byte(chip, LCTLR, chip->aspm_l0s_l1_en);
 439                 if (retval != STATUS_SUCCESS) {
 440                         TRACE_RET(chip, STATUS_FAIL);
 441                 }
 442         }
 443
 444         retval = rtsx_write_config_byte(chip, 0x81, 1);
 445         if (retval != STATUS_SUCCESS) {
 446                 TRACE_RET(chip, STATUS_FAIL);
 447         }
 448
 449         if (CHK_SDIO_EXIST(chip)) {
 450                 if (CHECK_PID(chip, 0x5288)) {
 451                         retval = rtsx_write_cfg_dw(chip, 2, 0xC0, 0xFF00, 0x0100);
 452                 } else {
 453                         retval = rtsx_write_cfg_dw(chip, 1, 0xC0, 0xFF00, 0x0100);
 454                 }
 455                 if (retval != STATUS_SUCCESS) {
 456                         TRACE_RET(chip, STATUS_FAIL);
 457                 }
 458         }
 459
 460         if (CHECK_PID(chip, 0x5209)) {
 461                 retval = rtsx_write_cfg_dw(chip, 0, 0x70C, 0xFF000000, 0x5B);
 462                 if (retval != STATUS_SUCCESS) {
 463                         TRACE_RET(chip, STATUS_FAIL);
 464                 }
 465         }
 466
 467         if (CHECK_PID(chip, 0x5288)) {
 468                 if (!CHK_SDIO_EXIST(chip)) {
 469                         retval = rtsx_write_cfg_dw(chip, 2, 0xC0, 0xFFFF, 0x0103);
 470                         if (retval != STATUS_SUCCESS) {
 471                                 TRACE_RET(chip, STATUS_FAIL);
 472                         }
 473                         retval = rtsx_write_cfg_dw(chip, 2, 0x84, 0xFF, 0x03);
 474                         if (retval != STATUS_SUCCESS) {
 475                                 TRACE_RET(chip, STATUS_FAIL);
 476                         }
 477                 }
 478         }
 479
 480         RTSX_WRITE_REG(chip, IRQSTAT0, LINK_RDY_INT, LINK_RDY_INT);
 481
 482         RTSX_WRITE_REG(chip, PERST_GLITCH_WIDTH, 0xFF, 0x80);
 483
 484         if (CHECK_PID(chip, 0x5209)) {
 485                 RTSX_WRITE_REG(chip, PWD_SUSPEND_EN, 0xFF, 0xFF);
 486                 RTSX_WRITE_REG(chip, PWR_GATE_CTRL, PWR_GATE_EN, PWR_GATE_EN);
 487         }
 488
 489         /* Enable PCIE interrupt */
 490         if (chip->asic_code) {
 491                 if (CHECK_PID(chip, 0x5208)) {
 492                         if (chip->phy_debug_mode) {
 493                                 RTSX_WRITE_REG(chip, CDRESUMECTL, 0x77, 0);
 494                                 rtsx_disable_bus_int(chip);
 495                         } else {
 496                                 rtsx_enable_bus_int(chip);
 497                         }
 498
 499                         if (chip->ic_version >= IC_VER_D) {
 500                                 u16 reg;
 501                                 retval = rtsx_read_phy_register(chip, 0x00, &reg);
 502                                 if (retval != STATUS_SUCCESS) {
 503                                         TRACE_RET(chip, STATUS_FAIL);
 504                                 }
 505                                 reg &= 0xFE7F;
 506                                 reg |= 0x80;
 507                                 retval = rtsx_write_phy_register(chip, 0x00, reg);
 508                                 if (retval != STATUS_SUCCESS) {
 509                                         TRACE_RET(chip, STATUS_FAIL);
 510                                 }
 511                                 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
 512                                 if (retval != STATUS_SUCCESS) {
 513                                         TRACE_RET(chip, STATUS_FAIL);
 514                                 }
 515                                 reg &= 0xFFF7;
 516                                 retval = rtsx_write_phy_register(chip, 0x1C, reg);
 517                                 if (retval != STATUS_SUCCESS) {
 518                                         TRACE_RET(chip, STATUS_FAIL);
 519                                 }
 520                         }
 521
 522                         if (chip->driver_first_load && (chip->ic_version < IC_VER_C)) {
 523                                 rtsx_calibration(chip);
 524                         }
 525                 } else {
 526                         rtsx_enable_bus_int(chip);
 527                 }
 528         } else {
 529                 rtsx_enable_bus_int(chip);
 530         }
 531
 532 #ifdef HW_INT_WRITE_CLR
 533         if (CHECK_PID(chip, 0x5209)) {
 534                 /* Set interrupt write clear */
 535                 RTSX_WRITE_REG(chip, NFTS_TX_CTRL, 0x02, 0);
 536         }
 537 #endif
 538
 539         chip->need_reset = 0;
 540
 541         chip->int_reg = rtsx_readl(chip, RTSX_BIPR);
 542 #ifdef HW_INT_WRITE_CLR
 543         if (CHECK_PID(chip, 0x5209)) {
 544                 /* Clear interrupt flag */
 545                 rtsx_writel(chip, RTSX_BIPR, chip->int_reg);
 546         }
 547 #endif
 548         if (chip->hw_bypass_sd)
 549                 goto NextCard;
 550         RTSX_DEBUGP("In rtsx_reset_chip, chip->int_reg = 0x%x\n", chip->int_reg);
 551         if (chip->int_reg & SD_EXIST) {
 552 #ifdef HW_AUTO_SWITCH_SD_BUS
 553                 if (CHECK_PID(chip, 0x5208) && (chip->ic_version < IC_VER_C)) {
 554                         retval = rtsx_pre_handle_sdio_old(chip);
 555                 } else {
 556                         retval = rtsx_pre_handle_sdio_new(chip);
 557                 }
 558                 RTSX_DEBUGP("chip->need_reset = 0x%x (rtsx_reset_chip)\n", (unsigned int)(chip->need_reset));
 559 #else  /* HW_AUTO_SWITCH_SD_BUS */
 560                 retval = rtsx_pre_handle_sdio_old(chip);
 561 #endif  /* HW_AUTO_SWITCH_SD_BUS */
 562                 if (retval != STATUS_SUCCESS) {
 563                         TRACE_RET(chip, STATUS_FAIL);
 564                 }
 565         } else {
 566                 chip->sd_io = 0;
 567                 RTSX_WRITE_REG(chip, SDIO_CTRL, SDIO_BUS_CTRL | SDIO_CD_CTRL, 0);
 568         }
 569
 570 NextCard:
 571         if (chip->int_reg & XD_EXIST)
 572                 chip->need_reset |= XD_CARD;
 573         if (chip->int_reg & MS_EXIST)
 574                 chip->need_reset |= MS_CARD;
 575         if (chip->int_reg & CARD_EXIST) {
 576                 RTSX_WRITE_REG(chip, SSC_CTL1, SSC_RSTB, SSC_RSTB);
 577         }
 578
 579         RTSX_DEBUGP("In rtsx_init_chip, chip->need_reset = 0x%x\n", (unsigned int)(chip->need_reset));
 580
 581         RTSX_WRITE_REG(chip, RCCTL, 0x01, 0x00);
 582
 583         if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) {
 584                 /* Turn off main power when entering S3/S4 state */
 585                 RTSX_WRITE_REG(chip, MAIN_PWR_OFF_CTL, 0x03, 0x03);
 586         }
 587
 588         if (chip->remote_wakeup_en && !chip->auto_delink_en) {
 589                 RTSX_WRITE_REG(chip, WAKE_SEL_CTL, 0x07, 0x07);
 590                 if (chip->aux_pwr_exist) {
 591                         RTSX_WRITE_REG(chip, PME_FORCE_CTL, 0xFF, 0x33);
 592                 }
 593         } else {
 594                 RTSX_WRITE_REG(chip, WAKE_SEL_CTL, 0x07, 0x04);
 595                 RTSX_WRITE_REG(chip, PME_FORCE_CTL, 0xFF, 0x30);
 596         }
 597
 598         if (CHECK_PID(chip, 0x5208) && (chip->ic_version >= IC_VER_D)) {
 599                 RTSX_WRITE_REG(chip, PETXCFG, 0x1C, 0x14);
 600         } else if (CHECK_PID(chip, 0x5209)) {
 601                 if (chip->force_clkreq_0) {
 602                         RTSX_WRITE_REG(chip, PETXCFG, 0x08, 0x08);
 603                 } else {
 604                         RTSX_WRITE_REG(chip, PETXCFG, 0x08, 0x00);
 605                 }
 606         }
 607
 608         if (chip->asic_code && CHECK_PID(chip, 0x5208)) {
 609                 retval = rtsx_clr_phy_reg_bit(chip, 0x1C, 2);
 610                 if (retval != STATUS_SUCCESS) {
 611                         TRACE_RET(chip, STATUS_FAIL);
 612                 }
 613         }
 614
 615         if (chip->ft2_fast_mode) {
 616                 RTSX_WRITE_REG(chip, CARD_PWR_CTL, 0xFF, MS_PARTIAL_POWER_ON | SD_PARTIAL_POWER_ON);
 617                 udelay(chip->pmos_pwr_on_interval);
 618                 RTSX_WRITE_REG(chip, CARD_PWR_CTL, 0xFF, MS_POWER_ON | SD_POWER_ON);
 619
 620                 wait_timeout(200);
 621         }
 622
 623         /* Reset card */
 624         rtsx_reset_detected_cards(chip, 0);
 625
 626         chip->driver_first_load = 0;
 627
 628         return STATUS_SUCCESS;
 629 }
 630
 631 static inline int check_sd_speed_prior(u32 sd_speed_prior)
 632 {
 633         int i, fake_para = 0;
 634
 635         for (i = 0; i < 4; i++) {
 636                 u8 tmp = (u8)(sd_speed_prior >> (i*8));
 637                 if ((tmp < 0x01) || (tmp > 0x04)) {
 638                         fake_para = 1;
 639                         break;
 640                 }
 641         }
 642
 643         return !fake_para;
 644 }
 645
 646 static inline int check_sd_current_prior(u32 sd_current_prior)
 647 {
 648         int i, fake_para = 0;
 649
 650         for (i = 0; i < 4; i++) {
 651                 u8 tmp = (u8)(sd_current_prior >> (i*8));
 652                 if (tmp > 0x03) {
 653                         fake_para = 1;
 654                         break;
 655                 }
 656         }
 657
 658         return !fake_para;
 659 }
 660
 661 static int rts5209_init(struct rtsx_chip *chip)
 662 {
 663         int retval;
 664         u32 lval = 0;
 665         u8 val = 0;
 666
 667         val = rtsx_readb(chip, 0x1C);
 668         if ((val & 0x10) == 0) {
 669                 chip->asic_code = 1;
 670         } else {
 671                 chip->asic_code = 0;
 672         }
 673
 674         chip->ic_version = val & 0x0F;
 675         chip->phy_debug_mode = 0;
 676
 677         chip->aux_pwr_exist = 0;
 678
 679         chip->ms_power_class_en = 0x03;
 680
 681         retval = rtsx_read_cfg_dw(chip, 0, 0x724, &lval);
 682         if (retval != STATUS_SUCCESS) {
 683                 TRACE_RET(chip, STATUS_FAIL);
 684         }
 685         RTSX_DEBUGP("dw in 0x724: 0x%x\n", lval);
 686         val = (u8)lval;
 687         if (!(val & 0x80)) {
 688                 if (val & 0x08)
 689                         chip->lun_mode = DEFAULT_SINGLE;
 690                 else
 691                         chip->lun_mode = SD_MS_2LUN;
 692
 693                 if (val & 0x04) {
 694                         SET_SDIO_EXIST(chip);
 695                 } else {
 696                         CLR_SDIO_EXIST(chip);
 697                 }
 698
 699                 if (val & 0x02) {
 700                         chip->hw_bypass_sd = 0;
 701                 } else {
 702                         chip->hw_bypass_sd = 1;
 703                 }
 704         } else {
 705                 SET_SDIO_EXIST(chip);
 706                 chip->hw_bypass_sd = 0;
 707         }
 708
 709         if (chip->use_hw_setting) {
 710                 u8 clk;
 711
 712                 chip->aspm_l0s_l1_en = (val >> 5) & 0x03;
 713
 714                 val = (u8)(lval >> 8);
 715
 716                 clk = (val >> 5) & 0x07;
 717                 if (clk != 0x07) {
 718                         chip->asic_sd_sdr50_clk = 98 - clk * 2;
 719                 }
 720
 721                 if (val & 0x10) {
 722                         chip->auto_delink_en = 1;
 723                 } else {
 724                         chip->auto_delink_en = 0;
 725                 }
 726
 727                 if (chip->ss_en == 2) {
 728                         chip->ss_en = 0;
 729                 } else {
 730                         if (val & 0x08) {
 731                                 chip->ss_en = 1;
 732                         } else {
 733                                 chip->ss_en = 0;
 734                         }
 735                 }
 736
 737                 clk = val & 0x07;
 738                 if (clk != 0x07)
 739                         chip->asic_ms_hg_clk = (59 - clk) * 2;
 740
 741                 val = (u8)(lval >> 16);
 742
 743                 clk = (val >> 6) & 0x03;
 744                 if (clk != 0x03) {
 745                         chip->asic_sd_hs_clk = (49 - clk * 2) * 2;
 746                         chip->asic_mmc_52m_clk = (49 - clk * 2) * 2;
 747                 }
 748
 749                 clk = (val >> 4) & 0x03;
 750                 if (clk != 0x03)
 751                         chip->asic_sd_ddr50_clk = (48 - clk * 2) * 2;
 752
 753                 if (val & 0x01) {
 754                         chip->sdr104_en = 1;
 755                 } else {
 756                         chip->sdr104_en = 0;
 757                 }
 758                 if (val & 0x02) {
 759                         chip->ddr50_en = 1;
 760                 } else {
 761                         chip->ddr50_en = 0;
 762                 }
 763                 if (val & 0x04) {
 764                         chip->sdr50_en = 1;
 765                 } else {
 766                         chip->sdr50_en = 0;
 767                 }
 768
 769                 val = (u8)(lval >> 24);
 770
 771                 clk = (val >> 5) & 0x07;
 772                 if (clk != 0x07)
 773                         chip->asic_sd_sdr104_clk = 206 - clk * 3;
 774
 775                 if (val & 0x10) {
 776                         chip->power_down_in_ss = 1;
 777                 } else {
 778                         chip->power_down_in_ss = 0;
 779                 }
 780
 781                 chip->ms_power_class_en = val & 0x03;
 782         }
 783
 784         if (chip->hp_watch_bios_hotplug && chip->auto_delink_en) {
 785                 u8 reg58, reg5b;
 786
 787                 retval = rtsx_read_pci_cfg_byte(0x00,
 788                                                 0x1C, 0x02, 0x58, &reg58);
 789                 if (retval < 0) {
 790                         return STATUS_SUCCESS;
 791                 }
 792                 retval = rtsx_read_pci_cfg_byte(0x00,
 793                                                 0x1C, 0x02, 0x5B, &reg5b);
 794                 if (retval < 0) {
 795                         return STATUS_SUCCESS;
 796                 }
 797
 798                 RTSX_DEBUGP("reg58 = 0x%x, reg5b = 0x%x\n", reg58, reg5b);
 799
 800                 if ((reg58 == 0x00) && (reg5b == 0x01)) {
 801                         chip->auto_delink_en = 0;
 802                 }
 803         }
 804
 805         return STATUS_SUCCESS;
 806 }
 807
 808 static int rts5208_init(struct rtsx_chip *chip)
 809 {
 810         int retval;
 811         u16 reg = 0;
 812         u8 val = 0;
 813
 814         RTSX_WRITE_REG(chip, CLK_SEL, 0x03, 0x03);
 815         RTSX_READ_REG(chip, CLK_SEL, &val);
 816         if (val == 0) {
 817                 chip->asic_code = 1;
 818         } else {
 819                 chip->asic_code = 0;
 820         }
 821
 822         if (chip->asic_code) {
 823                 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
 824                 if (retval != STATUS_SUCCESS) {
 825                         TRACE_RET(chip, STATUS_FAIL);
 826                 }
 827                 RTSX_DEBUGP("Value of phy register 0x1C is 0x%x\n", reg);
 828                 chip->ic_version = (reg >> 4) & 0x07;
 829                 if (reg & PHY_DEBUG_MODE) {
 830                         chip->phy_debug_mode = 1;
 831                 } else {
 832                         chip->phy_debug_mode = 0;
 833                 }
 834         } else {
 835                 RTSX_READ_REG(chip, 0xFE80, &val);
 836                 chip->ic_version = val;
 837                 chip->phy_debug_mode = 0;
 838         }
 839
 840         RTSX_READ_REG(chip, PDINFO, &val);
 841         RTSX_DEBUGP("PDINFO: 0x%x\n", val);
 842         if (val & AUX_PWR_DETECTED) {
 843                 chip->aux_pwr_exist = 1;
 844         } else {
 845                 chip->aux_pwr_exist = 0;
 846         }
 847
 848         RTSX_READ_REG(chip, 0xFE50, &val);
 849         if (val & 0x01) {
 850                 chip->hw_bypass_sd = 1;
 851         } else {
 852                 chip->hw_bypass_sd = 0;
 853         }
 854
 855         rtsx_read_config_byte(chip, 0x0E, &val);
 856         if (val & 0x80) {
 857                 SET_SDIO_EXIST(chip);
 858         } else {
 859                 CLR_SDIO_EXIST(chip);
 860         }
 861
 862         if (chip->use_hw_setting) {
 863                 RTSX_READ_REG(chip, CHANGE_LINK_STATE, &val);
 864                 if (val & 0x80) {
 865                         chip->auto_delink_en = 1;
 866                 } else {
 867                         chip->auto_delink_en = 0;
 868                 }
 869         }
 870
 871         return STATUS_SUCCESS;
 872 }
 873
 874 static int rts5288_init(struct rtsx_chip *chip)
 875 {
 876         int retval;
 877         u8 val = 0, max_func;
 878         u32 lval = 0;
 879
 880         RTSX_WRITE_REG(chip, CLK_SEL, 0x03, 0x03);
 881         RTSX_READ_REG(chip, CLK_SEL, &val);
 882         if (val == 0) {
 883                 chip->asic_code = 1;
 884         } else {
 885                 chip->asic_code = 0;
 886         }
 887
 888         chip->ic_version = 0;
 889         chip->phy_debug_mode = 0;
 890
 891         RTSX_READ_REG(chip, PDINFO, &val);
 892         RTSX_DEBUGP("PDINFO: 0x%x\n", val);
 893         if (val & AUX_PWR_DETECTED) {
 894                 chip->aux_pwr_exist = 1;
 895         } else {
 896                 chip->aux_pwr_exist = 0;
 897         }
 898
 899         RTSX_READ_REG(chip, CARD_SHARE_MODE, &val);
 900         RTSX_DEBUGP("CARD_SHARE_MODE: 0x%x\n", val);
 901         if (val & 0x04) {
 902                 chip->baro_pkg = QFN;
 903         } else {
 904                 chip->baro_pkg = LQFP;
 905         }
 906
 907         RTSX_READ_REG(chip, 0xFE5A, &val);
 908         if (val & 0x10) {
 909                 chip->hw_bypass_sd = 1;
 910         } else {
 911                 chip->hw_bypass_sd = 0;
 912         }
 913
 914         retval = rtsx_read_cfg_dw(chip, 0, 0x718, &lval);
 915         if (retval != STATUS_SUCCESS) {
 916                 TRACE_RET(chip, STATUS_FAIL);
 917         }
 918         max_func = (u8)((lval >> 29) & 0x07);
 919         RTSX_DEBUGP("Max function number: %d\n", max_func);
 920         if (max_func == 0x02) {
 921                 SET_SDIO_EXIST(chip);
 922         } else {
 923                 CLR_SDIO_EXIST(chip);
 924         }
 925
 926         if (chip->use_hw_setting) {
 927                 RTSX_READ_REG(chip, CHANGE_LINK_STATE, &val);
 928                 if (val & 0x80) {
 929                         chip->auto_delink_en = 1;
 930                 } else {
 931                         chip->auto_delink_en = 0;
 932                 }
 933
 934                 if (CHECK_BARO_PKG(chip, LQFP)) {
 935                         chip->lun_mode = SD_MS_1LUN;
 936                 } else {
 937                         chip->lun_mode = DEFAULT_SINGLE;
 938                 }
 939         }
 940
 941         return STATUS_SUCCESS;
 942 }
 943
 944 int rtsx_init_chip(struct rtsx_chip *chip)
 945 {
 946         struct sd_info *sd_card = &(chip->sd_card);
 947         struct xd_info *xd_card = &(chip->xd_card);
 948         struct ms_info *ms_card = &(chip->ms_card);
 949         int retval;
 950         unsigned int i;
 951
 952         RTSX_DEBUGP("Vendor ID: 0x%04x, Product ID: 0x%04x\n",
 953                      chip->vendor_id, chip->product_id);
 954
 955         chip->ic_version = 0;
 956
 957 #ifdef _MSG_TRACE
 958         chip->msg_idx = 0;
 959 #endif
 960
 961         memset(xd_card, 0, sizeof(struct xd_info));
 962         memset(sd_card, 0, sizeof(struct sd_info));
 963         memset(ms_card, 0, sizeof(struct ms_info));
 964
 965         chip->xd_reset_counter = 0;
 966         chip->sd_reset_counter = 0;
 967         chip->ms_reset_counter = 0;
 968
 969         chip->xd_show_cnt = MAX_SHOW_CNT;
 970         chip->sd_show_cnt = MAX_SHOW_CNT;
 971         chip->ms_show_cnt = MAX_SHOW_CNT;
 972
 973         chip->sd_io = 0;
 974         chip->auto_delink_cnt = 0;
 975         chip->auto_delink_allowed = 1;
 976         rtsx_set_stat(chip, RTSX_STAT_INIT);
 977
 978         chip->aspm_enabled = 0;
 979         chip->chip_insert_with_sdio = 0;
 980         chip->sdio_aspm = 0;
 981         chip->sdio_idle = 0;
 982         chip->sdio_counter = 0;
 983         chip->cur_card = 0;
 984         chip->phy_debug_mode = 0;
 985         chip->sdio_func_exist = 0;
 986         memset(chip->sdio_raw_data, 0, 12);
 987
 988         for (i = 0; i < MAX_ALLOWED_LUN_CNT; i++) {
 989                 set_sense_type(chip, i, SENSE_TYPE_NO_SENSE);
 990                 chip->rw_fail_cnt[i] = 0;
 991         }
 992
 993         if (!check_sd_speed_prior(chip->sd_speed_prior)) {
 994                 chip->sd_speed_prior = 0x01040203;
 995         }
 996         RTSX_DEBUGP("sd_speed_prior = 0x%08x\n", chip->sd_speed_prior);
 997
 998         if (!check_sd_current_prior(chip->sd_current_prior)) {
 999                 chip->sd_current_prior = 0x00010203;
1000         }
1001         RTSX_DEBUGP("sd_current_prior = 0x%08x\n", chip->sd_current_prior);
1002
1003         if ((chip->sd_ddr_tx_phase > 31) || (chip->sd_ddr_tx_phase < 0)) {
1004                 chip->sd_ddr_tx_phase = 0;
1005         }
1006         if ((chip->mmc_ddr_tx_phase > 31) || (chip->mmc_ddr_tx_phase < 0)) {
1007                 chip->mmc_ddr_tx_phase = 0;
1008         }
1009
1010         RTSX_WRITE_REG(chip, FPDCTL, SSC_POWER_DOWN, 0);
1011         wait_timeout(200);
1012         RTSX_WRITE_REG(chip, CLK_DIV, 0x07, 0x07);
1013         RTSX_DEBUGP("chip->use_hw_setting = %d\n", chip->use_hw_setting);
1014
1015         if (CHECK_PID(chip, 0x5209)) {
1016                 retval = rts5209_init(chip);
1017                 if (retval != STATUS_SUCCESS) {
1018                         TRACE_RET(chip, STATUS_FAIL);
1019                 }
1020         } else if (CHECK_PID(chip, 0x5208)) {
1021                 retval = rts5208_init(chip);
1022                 if (retval != STATUS_SUCCESS) {
1023                         TRACE_RET(chip, STATUS_FAIL);
1024                 }
1025         } else if (CHECK_PID(chip, 0x5288)) {
1026                 retval = rts5288_init(chip);
1027                 if (retval != STATUS_SUCCESS) {
1028                         TRACE_RET(chip, STATUS_FAIL);
1029                 }
1030         }
1031
1032         if (chip->ss_en == 2) {
1033                 chip->ss_en = 0;
1034         }
1035
1036         RTSX_DEBUGP("chip->asic_code = %d\n", chip->asic_code);
1037         RTSX_DEBUGP("chip->ic_version = 0x%x\n", chip->ic_version);
1038         RTSX_DEBUGP("chip->phy_debug_mode = %d\n", chip->phy_debug_mode);
1039         RTSX_DEBUGP("chip->aux_pwr_exist = %d\n", chip->aux_pwr_exist);
1040         RTSX_DEBUGP("chip->sdio_func_exist = %d\n", chip->sdio_func_exist);
1041         RTSX_DEBUGP("chip->hw_bypass_sd = %d\n", chip->hw_bypass_sd);
1042         RTSX_DEBUGP("chip->aspm_l0s_l1_en = %d\n", chip->aspm_l0s_l1_en);
1043         RTSX_DEBUGP("chip->lun_mode = %d\n", chip->lun_mode);
1044         RTSX_DEBUGP("chip->auto_delink_en = %d\n", chip->auto_delink_en);
1045         RTSX_DEBUGP("chip->ss_en = %d\n", chip->ss_en);
1046         RTSX_DEBUGP("chip->baro_pkg = %d\n", chip->baro_pkg);
1047
1048         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
1049                 chip->card2lun[SD_CARD] = 0;
1050                 chip->card2lun[MS_CARD] = 1;
1051                 chip->card2lun[XD_CARD] = 0xFF;
1052                 chip->lun2card[0] = SD_CARD;
1053                 chip->lun2card[1] = MS_CARD;
1054                 chip->max_lun = 1;
1055                 SET_SDIO_IGNORED(chip);
1056         } else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) {
1057                 chip->card2lun[SD_CARD] = 0;
1058                 chip->card2lun[MS_CARD] = 0;
1059                 chip->card2lun[XD_CARD] = 0xFF;
1060                 chip->lun2card[0] = SD_CARD | MS_CARD;
1061                 chip->max_lun = 0;
1062         } else {
1063                 chip->card2lun[XD_CARD] = 0;
1064                 chip->card2lun[SD_CARD] = 0;
1065                 chip->card2lun[MS_CARD] = 0;
1066                 chip->lun2card[0] = XD_CARD | SD_CARD | MS_CARD;
1067                 chip->max_lun = 0;
1068         }
1069
1070         retval = rtsx_reset_chip(chip);
1071         if (retval != STATUS_SUCCESS) {
1072                 TRACE_RET(chip, STATUS_FAIL);
1073         }
1074
1075         return STATUS_SUCCESS;
1076 }
1077
1078 void rtsx_release_chip(struct rtsx_chip *chip)
1079 {
1080         xd_free_l2p_tbl(chip);
1081         ms_free_l2p_tbl(chip);
1082         chip->card_exist = 0;
1083         chip->card_ready = 0;
1084 }
1085
1086 #if !defined(LED_AUTO_BLINK) && defined(REGULAR_BLINK)
1087 static inline void rtsx_blink_led(struct rtsx_chip *chip)
1088 {
1089         if (chip->card_exist && chip->blink_led) {
1090                 if (chip->led_toggle_counter < LED_TOGGLE_INTERVAL) {
1091                         chip->led_toggle_counter++;
1092                 } else {
1093                         chip->led_toggle_counter = 0;
1094                         toggle_gpio(chip, LED_GPIO);
1095                 }
1096         }
1097 }
1098 #endif
1099
1100 static void rtsx_monitor_aspm_config(struct rtsx_chip *chip)
1101 {
1102         int maybe_support_aspm, reg_changed;
1103         u32 tmp = 0;
1104         u8 reg0 = 0, reg1 = 0;
1105
1106         maybe_support_aspm = 0;
1107         reg_changed = 0;
1108         rtsx_read_config_byte(chip, LCTLR, &reg0);
1109         if (chip->aspm_level[0] != reg0) {
1110                 reg_changed = 1;
1111                 chip->aspm_level[0] = reg0;
1112         }
1113         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
1114                 rtsx_read_cfg_dw(chip, 1, 0xC0, &tmp);
1115                 reg1 = (u8)tmp;
1116                 if (chip->aspm_level[1] != reg1) {
1117                         reg_changed = 1;
1118                         chip->aspm_level[1] = reg1;
1119                 }
1120
1121                 if ((reg0 & 0x03) && (reg1 & 0x03)) {
1122                         maybe_support_aspm = 1;
1123                 }
1124         } else {
1125                 if (reg0 & 0x03) {
1126                         maybe_support_aspm = 1;
1127                 }
1128         }
1129
1130         if (reg_changed) {
1131                 if (maybe_support_aspm) {
1132                         chip->aspm_l0s_l1_en = 0x03;
1133                 }
1134                 RTSX_DEBUGP("aspm_level[0] = 0x%02x, aspm_level[1] = 0x%02x\n",
1135                               chip->aspm_level[0], chip->aspm_level[1]);
1136
1137                 if (chip->aspm_l0s_l1_en) {
1138                         chip->aspm_enabled = 1;
1139                 } else {
1140                         chip->aspm_enabled = 0;
1141                         chip->sdio_aspm = 0;
1142                 }
1143                 rtsx_write_register(chip, ASPM_FORCE_CTL, 0xFF,
1144                         0x30 | chip->aspm_level[0] | (chip->aspm_level[1] << 2));
1145         }
1146 }
1147
1148 void rtsx_polling_func(struct rtsx_chip *chip)
1149 {
1150 #ifdef SUPPORT_SD_LOCK
1151         struct sd_info *sd_card = &(chip->sd_card);
1152 #endif
1153         int ss_allowed;
1154
1155         if (rtsx_chk_stat(chip, RTSX_STAT_SUSPEND))
1156                 return;
1157
1158         if (rtsx_chk_stat(chip, RTSX_STAT_DELINK))
1159                 goto Delink_Stage;
1160
1161         if (chip->polling_config) {
1162                 u8 val;
1163                 rtsx_read_config_byte(chip, 0, &val);
1164         }
1165
1166         if (rtsx_chk_stat(chip, RTSX_STAT_SS))
1167                 return;
1168
1169 #ifdef SUPPORT_OCP
1170         if (chip->ocp_int) {
1171                 rtsx_read_register(chip, OCPSTAT, &(chip->ocp_stat));
1172
1173                 if (CHECK_PID(chip, 0x5209) &&
1174                                 CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
1175                         if (chip->ocp_int & SD_OC_INT)
1176                                 sd_power_off_card3v3(chip);
1177                         if (chip->ocp_int & MS_OC_INT)
1178                                 ms_power_off_card3v3(chip);
1179                 } else {
1180                         if (chip->card_exist & SD_CARD) {
1181                                 sd_power_off_card3v3(chip);
1182                         } else if (chip->card_exist & MS_CARD) {
1183                                 ms_power_off_card3v3(chip);
1184                         } else if (chip->card_exist & XD_CARD) {
1185                                 xd_power_off_card3v3(chip);
1186                         }
1187                 }
1188
1189                 chip->ocp_int = 0;
1190         }
1191 #endif
1192
1193 #ifdef SUPPORT_SD_LOCK
1194         if (sd_card->sd_erase_status) {
1195                 if (chip->card_exist & SD_CARD) {
1196                         u8 val;
1197                         if (CHECK_PID(chip, 0x5209)) {
1198                                 rtsx_read_register(chip, SD_BUS_STAT, &val);
1199                                 if (val & SD_DAT0_STATUS) {
1200                                         sd_card->sd_erase_status = SD_NOT_ERASE;
1201                                         sd_card->sd_lock_notify = 1;
1202                                         chip->need_reinit |= SD_CARD;
1203                                 }
1204                         } else {
1205                                 rtsx_read_register(chip, 0xFD30, &val);
1206                                 if (val & 0x02) {
1207                                         sd_card->sd_erase_status = SD_NOT_ERASE;
1208                                         sd_card->sd_lock_notify = 1;
1209                                         chip->need_reinit |= SD_CARD;
1210                                 }
1211                         }
1212                 } else {
1213                         sd_card->sd_erase_status = SD_NOT_ERASE;
1214                 }
1215         }
1216 #endif
1217
1218         rtsx_init_cards(chip);
1219
1220         if (chip->ss_en) {
1221                 ss_allowed = 1;
1222
1223                 if (CHECK_PID(chip, 0x5288)) {
1224                         ss_allowed = 0;
1225                 } else {
1226                         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
1227                                 u32 val;
1228                                 rtsx_read_cfg_dw(chip, 1, 0x04, &val);
1229                                 if (val & 0x07) {
1230                                         ss_allowed = 0;
1231                                 }
1232                         }
1233                 }
1234         } else {
1235                 ss_allowed = 0;
1236         }
1237
1238         if (ss_allowed && !chip->sd_io) {
1239                 if (rtsx_get_stat(chip) != RTSX_STAT_IDLE) {
1240                         chip->ss_counter = 0;
1241                 } else {
1242                         if (chip->ss_counter <
1243                                 (chip->ss_idle_period / POLLING_INTERVAL)) {
1244                                 chip->ss_counter++;
1245                         } else {
1246                                 rtsx_exclusive_enter_ss(chip);
1247                                 return;
1248                         }
1249                 }
1250         }
1251
1252         if (CHECK_PID(chip, 0x5208)) {
1253                 rtsx_monitor_aspm_config(chip);
1254
1255 #ifdef SUPPORT_SDIO_ASPM
1256                 if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip) &&
1257                                 chip->aspm_l0s_l1_en && chip->dynamic_aspm) {
1258                         if (chip->sd_io) {
1259                                 dynamic_configure_sdio_aspm(chip);
1260                         } else {
1261                                 if (!chip->sdio_aspm) {
1262                                         RTSX_DEBUGP("SDIO enter ASPM!\n");
1263                                         rtsx_write_register(chip,
1264                                                 ASPM_FORCE_CTL, 0xFC,
1265                                                 0x30 | (chip->aspm_level[1] << 2));
1266                                         chip->sdio_aspm = 1;
1267                                 }
1268                         }
1269                 }
1270 #endif
1271         }
1272
1273         if (chip->idle_counter < IDLE_MAX_COUNT) {
1274                 chip->idle_counter++;
1275         } else {
1276                 if (rtsx_get_stat(chip) != RTSX_STAT_IDLE) {
1277                         RTSX_DEBUGP("Idle state!\n");
1278                         rtsx_set_stat(chip, RTSX_STAT_IDLE);
1279
1280 #if !defined(LED_AUTO_BLINK) && defined(REGULAR_BLINK)
1281                         chip->led_toggle_counter = 0;
1282 #endif
1283                         rtsx_force_power_on(chip, SSC_PDCTL);
1284
1285                         turn_off_led(chip, LED_GPIO);
1286
1287                         if (chip->auto_power_down && !chip->card_ready && !chip->sd_io) {
1288                                 rtsx_force_power_down(chip, SSC_PDCTL | OC_PDCTL);
1289                         }
1290                 }
1291         }
1292
1293         switch (rtsx_get_stat(chip)) {
1294         case RTSX_STAT_RUN:
1295 #if !defined(LED_AUTO_BLINK) && defined(REGULAR_BLINK)
1296                 rtsx_blink_led(chip);
1297 #endif
1298                 do_remaining_work(chip);
1299                 break;
1300
1301         case RTSX_STAT_IDLE:
1302                 if (chip->sd_io && !chip->sd_int) {
1303                         try_to_switch_sdio_ctrl(chip);
1304                 }
1305                 rtsx_enable_aspm(chip);
1306                 break;
1307
1308         default:
1309                 break;
1310         }
1311
1312
1313 #ifdef SUPPORT_OCP
1314         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
1315 #ifdef CONFIG_RTS_PSTOR_DEBUG
1316                 if (chip->ocp_stat & (SD_OC_NOW | SD_OC_EVER | MS_OC_NOW | MS_OC_EVER)) {
1317                         RTSX_DEBUGP("Over current, OCPSTAT is 0x%x\n", chip->ocp_stat);
1318                 }
1319 #endif
1320
1321                 if (chip->ocp_stat & (SD_OC_NOW | SD_OC_EVER)) {
1322                         if (chip->card_exist & SD_CARD) {
1323                                 rtsx_write_register(chip, CARD_OE, SD_OUTPUT_EN, 0);
1324                                 card_power_off(chip, SD_CARD);
1325                                 chip->card_fail |= SD_CARD;
1326                         }
1327                 }
1328                 if (chip->ocp_stat & (MS_OC_NOW | MS_OC_EVER)) {
1329                         if (chip->card_exist & MS_CARD) {
1330                                 rtsx_write_register(chip, CARD_OE, MS_OUTPUT_EN, 0);
1331                                 card_power_off(chip, MS_CARD);
1332                                 chip->card_fail |= MS_CARD;
1333                         }
1334                 }
1335         } else {
1336                 if (chip->ocp_stat & (SD_OC_NOW | SD_OC_EVER)) {
1337                         RTSX_DEBUGP("Over current, OCPSTAT is 0x%x\n", chip->ocp_stat);
1338                         if (chip->card_exist & SD_CARD) {
1339                                 rtsx_write_register(chip, CARD_OE, SD_OUTPUT_EN, 0);
1340                                 chip->card_fail |= SD_CARD;
1341                         } else if (chip->card_exist & MS_CARD) {
1342                                 rtsx_write_register(chip, CARD_OE, MS_OUTPUT_EN, 0);
1343                                 chip->card_fail |= MS_CARD;
1344                         } else if (chip->card_exist & XD_CARD) {
1345                                 rtsx_write_register(chip, CARD_OE, XD_OUTPUT_EN, 0);
1346                                 chip->card_fail |= XD_CARD;
1347                         }
1348                         card_power_off(chip, SD_CARD);
1349                 }
1350         }
1351 #endif
1352
1353 Delink_Stage:
1354         if (chip->auto_delink_en && chip->auto_delink_allowed &&
1355                         !chip->card_ready && !chip->card_ejected && !chip->sd_io) {
1356                 int enter_L1 = chip->auto_delink_in_L1 && (chip->aspm_l0s_l1_en || chip->ss_en);
1357                 int delink_stage1_cnt = chip->delink_stage1_step;
1358                 int delink_stage2_cnt = delink_stage1_cnt + chip->delink_stage2_step;
1359                 int delink_stage3_cnt = delink_stage2_cnt + chip->delink_stage3_step;
1360
1361                 if (chip->auto_delink_cnt <= delink_stage3_cnt) {
1362                         if (chip->auto_delink_cnt == delink_stage1_cnt) {
1363                                 rtsx_set_stat(chip, RTSX_STAT_DELINK);
1364
1365                                 if (chip->asic_code && CHECK_PID(chip, 0x5208)) {
1366                                         rtsx_set_phy_reg_bit(chip, 0x1C, 2);
1367                                 }
1368                                 if (chip->card_exist) {
1369                                         RTSX_DEBUGP("False card inserted, do force delink\n");
1370
1371                                         if (enter_L1) {
1372                                                 rtsx_write_register(chip, HOST_SLEEP_STATE, 0x03, 1);
1373                                         }
1374                                         rtsx_write_register(chip, CHANGE_LINK_STATE, 0x0A, 0x0A);
1375
1376                                         if (enter_L1) {
1377                                                 rtsx_enter_L1(chip);
1378                                         }
1379
1380                                         chip->auto_delink_cnt = delink_stage3_cnt + 1;
1381                                 } else {
1382                                         RTSX_DEBUGP("No card inserted, do delink\n");
1383
1384                                         if (enter_L1) {
1385                                                 rtsx_write_register(chip, HOST_SLEEP_STATE, 0x03, 1);
1386                                         }
1387 #ifdef HW_INT_WRITE_CLR
1388                                         if (CHECK_PID(chip, 0x5209)) {
1389                                                 rtsx_writel(chip, RTSX_BIPR, 0xFFFFFFFF);
1390                                                 RTSX_DEBUGP("RTSX_BIPR: 0x%x\n", rtsx_readl(chip, RTSX_BIPR));
1391                                         }
1392 #endif
1393                                         rtsx_write_register(chip, CHANGE_LINK_STATE, 0x02, 0x02);
1394
1395                                         if (enter_L1) {
1396                                                 rtsx_enter_L1(chip);
1397                                         }
1398                                 }
1399                         }
1400
1401                         if (chip->auto_delink_cnt == delink_stage2_cnt) {
1402                                 RTSX_DEBUGP("Try to do force delink\n");
1403
1404                                 if (enter_L1) {
1405                                         rtsx_exit_L1(chip);
1406                                 }
1407
1408                                 if (chip->asic_code && CHECK_PID(chip, 0x5208)) {
1409                                         rtsx_set_phy_reg_bit(chip, 0x1C, 2);
1410                                 }
1411                                 rtsx_write_register(chip, CHANGE_LINK_STATE, 0x0A, 0x0A);
1412                         }
1413
1414                         chip->auto_delink_cnt++;
1415                 }
1416         } else {
1417                 chip->auto_delink_cnt = 0;
1418         }
1419 }
1420
1421 void rtsx_undo_delink(struct rtsx_chip *chip)
1422 {
1423         chip->auto_delink_allowed = 0;
1424         rtsx_write_register(chip, CHANGE_LINK_STATE, 0x0A, 0x00);
1425 }
1426
1427 /**
1428  * rtsx_stop_cmd - stop command transfer and DMA transfer
1429  * @chip: Realtek's card reader chip
1430  * @card: flash card type
1431  *
1432  * Stop command transfer and DMA transfer.
1433  * This function is called in error handler.
1434  */
1435 void rtsx_stop_cmd(struct rtsx_chip *chip, int card)
1436 {
1437         int i;
1438
1439         for (i = 0; i <= 8; i++) {
1440                 int addr = RTSX_HCBAR + i * 4;
1441                 u32 reg;
1442                 reg = rtsx_readl(chip, addr);
1443                 RTSX_DEBUGP("BAR (0x%02x): 0x%08x\n", addr, reg);
1444         }
1445         rtsx_writel(chip, RTSX_HCBCTLR, STOP_CMD);
1446         rtsx_writel(chip, RTSX_HDBCTLR, STOP_DMA);
1447
1448         for (i = 0; i < 16; i++) {
1449                 u16 addr = 0xFE20 + (u16)i;
1450                 u8 val;
1451                 rtsx_read_register(chip, addr, &val);
1452                 RTSX_DEBUGP("0x%04X: 0x%02x\n", addr, val);
1453         }
1454
1455         rtsx_write_register(chip, DMACTL, 0x80, 0x80);
1456         rtsx_write_register(chip, RBCTL, 0x80, 0x80);
1457 }
1458
1459 #define MAX_RW_REG_CNT          1024
1460
1461 int rtsx_write_register(struct rtsx_chip *chip, u16 addr, u8 mask, u8 data)
1462 {
1463         int i;
1464         u32 val = 3 << 30;
1465
1466         val |= (u32)(addr & 0x3FFF) << 16;
1467         val |= (u32)mask << 8;
1468         val |= (u32)data;
1469
1470         rtsx_writel(chip, RTSX_HAIMR, val);
1471
1472         for (i = 0; i < MAX_RW_REG_CNT; i++) {
1473                 val = rtsx_readl(chip, RTSX_HAIMR);
1474                 if ((val & (1 << 31)) == 0) {
1475                         if (data != (u8)val) {
1476                                 TRACE_RET(chip, STATUS_FAIL);
1477                         }
1478                         return STATUS_SUCCESS;
1479                 }
1480         }
1481
1482         TRACE_RET(chip, STATUS_TIMEDOUT);
1483 }
1484
1485 int rtsx_read_register(struct rtsx_chip *chip, u16 addr, u8 *data)
1486 {
1487         u32 val = 2 << 30;
1488         int i;
1489
1490         if (data) {
1491                 *data = 0;
1492         }
1493
1494         val |= (u32)(addr & 0x3FFF) << 16;
1495
1496         rtsx_writel(chip, RTSX_HAIMR, val);
1497
1498         for (i = 0; i < MAX_RW_REG_CNT; i++) {
1499                 val = rtsx_readl(chip, RTSX_HAIMR);
1500                 if ((val & (1 << 31)) == 0) {
1501                         break;
1502                 }
1503         }
1504
1505         if (i >= MAX_RW_REG_CNT) {
1506                 TRACE_RET(chip, STATUS_TIMEDOUT);
1507         }
1508
1509         if (data) {
1510                 *data = (u8)(val & 0xFF);
1511         }
1512
1513         return STATUS_SUCCESS;
1514 }
1515
1516 int rtsx_write_cfg_dw(struct rtsx_chip *chip, u8 func_no, u16 addr, u32 mask, u32 val)
1517 {
1518         u8 mode = 0, tmp;
1519         int i;
1520
1521         for (i = 0; i < 4; i++) {
1522                 if (mask & 0xFF) {
1523                         RTSX_WRITE_REG(chip, CFGDATA0 + i,
1524                                        0xFF, (u8)(val & mask & 0xFF));
1525                         mode |= (1 << i);
1526                 }
1527                 mask >>= 8;
1528                 val >>= 8;
1529         }
1530
1531         if (mode) {
1532                 RTSX_WRITE_REG(chip, CFGADDR0, 0xFF, (u8)addr);
1533                 RTSX_WRITE_REG(chip, CFGADDR1, 0xFF, (u8)(addr >> 8));
1534
1535                 RTSX_WRITE_REG(chip, CFGRWCTL, 0xFF,
1536                                0x80 | mode | ((func_no & 0x03) << 4));
1537
1538                 for (i = 0; i < MAX_RW_REG_CNT; i++) {
1539                         RTSX_READ_REG(chip, CFGRWCTL, &tmp);
1540                         if ((tmp & 0x80) == 0) {
1541                                 break;
1542                         }
1543                 }
1544         }
1545
1546         return STATUS_SUCCESS;
1547 }
1548
1549 int rtsx_read_cfg_dw(struct rtsx_chip *chip, u8 func_no, u16 addr, u32 *val)
1550 {
1551         int i;
1552         u8 tmp;
1553         u32 data = 0;
1554
1555         RTSX_WRITE_REG(chip, CFGADDR0, 0xFF, (u8)addr);
1556         RTSX_WRITE_REG(chip, CFGADDR1, 0xFF, (u8)(addr >> 8));
1557         RTSX_WRITE_REG(chip, CFGRWCTL, 0xFF, 0x80 | ((func_no & 0x03) << 4));
1558
1559         for (i = 0; i < MAX_RW_REG_CNT; i++) {
1560                 RTSX_READ_REG(chip, CFGRWCTL, &tmp);
1561                 if ((tmp & 0x80) == 0) {
1562                         break;
1563                 }
1564         }
1565
1566         for (i = 0; i < 4; i++) {
1567                 RTSX_READ_REG(chip, CFGDATA0 + i, &tmp);
1568                 data |= (u32)tmp << (i * 8);
1569         }
1570
1571         if (val) {
1572                 *val = data;
1573         }
1574
1575         return STATUS_SUCCESS;
1576 }
1577
1578 int rtsx_write_cfg_seq(struct rtsx_chip *chip, u8 func, u16 addr, u8 *buf, int len)
1579 {
1580         u32 *data, *mask;
1581         u16 offset = addr % 4;
1582         u16 aligned_addr = addr - offset;
1583         int dw_len, i, j;
1584         int retval;
1585
1586         RTSX_DEBUGP("%s\n", __func__);
1587
1588         if (!buf) {
1589                 TRACE_RET(chip, STATUS_NOMEM);
1590         }
1591
1592         if ((len + offset) % 4) {
1593                 dw_len = (len + offset) / 4 + 1;
1594         } else {
1595                 dw_len = (len + offset) / 4;
1596         }
1597         RTSX_DEBUGP("dw_len = %d\n", dw_len);
1598
1599         data = vzalloc(dw_len * 4);
1600         if (!data) {
1601                 TRACE_RET(chip, STATUS_NOMEM);
1602         }
1603
1604         mask = vzalloc(dw_len * 4);
1605         if (!mask) {
1606                 vfree(data);
1607                 TRACE_RET(chip, STATUS_NOMEM);
1608         }
1609
1610         j = 0;
1611         for (i = 0; i < len; i++) {
1612                 mask[j] |= 0xFF << (offset * 8);
1613                 data[j] |= buf[i] << (offset * 8);
1614                 if (++offset == 4) {
1615                         j++;
1616                         offset = 0;
1617                 }
1618         }
1619
1620         RTSX_DUMP(mask, dw_len * 4);
1621         RTSX_DUMP(data, dw_len * 4);
1622
1623         for (i = 0; i < dw_len; i++) {
1624                 retval = rtsx_write_cfg_dw(chip, func, aligned_addr + i * 4, mask[i], data[i]);
1625                 if (retval != STATUS_SUCCESS) {
1626                         vfree(data);
1627                         vfree(mask);
1628                         TRACE_RET(chip, STATUS_FAIL);
1629                 }
1630         }
1631
1632         vfree(data);
1633         vfree(mask);
1634
1635         return STATUS_SUCCESS;
1636 }
1637
1638 int rtsx_read_cfg_seq(struct rtsx_chip *chip, u8 func, u16 addr, u8 *buf, int len)
1639 {
1640         u32 *data;
1641         u16 offset = addr % 4;
1642         u16 aligned_addr = addr - offset;
1643         int dw_len, i, j;
1644         int retval;
1645
1646         RTSX_DEBUGP("%s\n", __func__);
1647
1648         if ((len + offset) % 4) {
1649                 dw_len = (len + offset) / 4 + 1;
1650         } else {
1651                 dw_len = (len + offset) / 4;
1652         }
1653         RTSX_DEBUGP("dw_len = %d\n", dw_len);
1654
1655         data = (u32 *)vmalloc(dw_len * 4);
1656         if (!data) {
1657                 TRACE_RET(chip, STATUS_NOMEM);
1658         }
1659
1660         for (i = 0; i < dw_len; i++) {
1661                 retval = rtsx_read_cfg_dw(chip, func, aligned_addr + i * 4, data + i);
1662                 if (retval != STATUS_SUCCESS) {
1663                         vfree(data);
1664                         TRACE_RET(chip, STATUS_FAIL);
1665                 }
1666         }
1667
1668         if (buf) {
1669                 j = 0;
1670
1671                 for (i = 0; i < len; i++) {
1672                         buf[i] = (u8)(data[j] >> (offset * 8));
1673                         if (++offset == 4) {
1674                                 j++;
1675                                 offset = 0;
1676                         }
1677                 }
1678         }
1679
1680         vfree(data);
1681
1682         return STATUS_SUCCESS;
1683 }
1684
1685 int rtsx_write_phy_register(struct rtsx_chip *chip, u8 addr, u16 val)
1686 {
1687         int i, finished = 0;
1688         u8 tmp;
1689
1690         RTSX_WRITE_REG(chip, PHYDATA0, 0xFF, (u8)val);
1691         RTSX_WRITE_REG(chip, PHYDATA1, 0xFF, (u8)(val >> 8));
1692         RTSX_WRITE_REG(chip, PHYADDR, 0xFF, addr);
1693         RTSX_WRITE_REG(chip, PHYRWCTL, 0xFF, 0x81);
1694
1695         for (i = 0; i < 100000; i++) {
1696                 RTSX_READ_REG(chip, PHYRWCTL, &tmp);
1697                 if (!(tmp & 0x80)) {
1698                         finished = 1;
1699                         break;
1700                 }
1701         }
1702
1703         if (!finished) {
1704                 TRACE_RET(chip, STATUS_FAIL);
1705         }
1706
1707         return STATUS_SUCCESS;
1708 }
1709
1710 int rtsx_read_phy_register(struct rtsx_chip *chip, u8 addr, u16 *val)
1711 {
1712         int i, finished = 0;
1713         u16 data = 0;
1714         u8 tmp;
1715
1716         RTSX_WRITE_REG(chip, PHYADDR, 0xFF, addr);
1717         RTSX_WRITE_REG(chip, PHYRWCTL, 0xFF, 0x80);
1718
1719         for (i = 0; i < 100000; i++) {
1720                 RTSX_READ_REG(chip, PHYRWCTL, &tmp);
1721                 if (!(tmp & 0x80)) {
1722                         finished = 1;
1723                         break;
1724                 }
1725         }
1726
1727         if (!finished) {
1728                 TRACE_RET(chip, STATUS_FAIL);
1729         }
1730
1731         RTSX_READ_REG(chip, PHYDATA0, &tmp);
1732         data = tmp;
1733         RTSX_READ_REG(chip, PHYDATA1, &tmp);
1734         data |= (u16)tmp << 8;
1735
1736         if (val)
1737                 *val = data;
1738
1739         return STATUS_SUCCESS;
1740 }
1741
1742 int rtsx_read_efuse(struct rtsx_chip *chip, u8 addr, u8 *val)
1743 {
1744         int i;
1745         u8 data = 0;
1746
1747         RTSX_WRITE_REG(chip, EFUSE_CTRL, 0xFF, 0x80|addr);
1748
1749         for (i = 0; i < 100; i++) {
1750                 RTSX_READ_REG(chip, EFUSE_CTRL, &data);
1751                 if (!(data & 0x80))
1752                         break;
1753                 udelay(1);
1754         }
1755
1756         if (data & 0x80) {
1757                 TRACE_RET(chip, STATUS_TIMEDOUT);
1758         }
1759
1760         RTSX_READ_REG(chip, EFUSE_DATA, &data);
1761         if (val)
1762                 *val = data;
1763
1764         return STATUS_SUCCESS;
1765 }
1766
1767 int rtsx_write_efuse(struct rtsx_chip *chip, u8 addr, u8 val)
1768 {
1769         int i, j;
1770         u8 data = 0, tmp = 0xFF;
1771
1772         for (i = 0; i < 8; i++) {
1773                 if (val & (u8)(1 << i))
1774                         continue;
1775
1776                 tmp &= (~(u8)(1 << i));
1777                 RTSX_DEBUGP("Write 0x%x to 0x%x\n", tmp, addr);
1778
1779                 RTSX_WRITE_REG(chip, EFUSE_DATA, 0xFF, tmp);
1780                 RTSX_WRITE_REG(chip, EFUSE_CTRL, 0xFF, 0xA0|addr);
1781
1782                 for (j = 0; j < 100; j++) {
1783                         RTSX_READ_REG(chip, EFUSE_CTRL, &data);
1784                         if (!(data & 0x80))
1785                                 break;
1786                         wait_timeout(3);
1787                 }
1788
1789                 if (data & 0x80) {
1790                         TRACE_RET(chip, STATUS_TIMEDOUT);
1791                 }
1792
1793                 wait_timeout(5);
1794         }
1795
1796         return STATUS_SUCCESS;
1797 }
1798
1799 int rtsx_clr_phy_reg_bit(struct rtsx_chip *chip, u8 reg, u8 bit)
1800 {
1801         int retval;
1802         u16 value;
1803
1804         retval = rtsx_read_phy_register(chip, reg, &value);
1805         if (retval != STATUS_SUCCESS) {
1806                 TRACE_RET(chip, STATUS_FAIL);
1807         }
1808         if (value & (1 << bit)) {
1809                 value &= ~(1 << bit);
1810                 retval = rtsx_write_phy_register(chip, reg, value);
1811                 if (retval != STATUS_SUCCESS) {
1812                         TRACE_RET(chip, STATUS_FAIL);
1813                 }
1814         }
1815
1816         return STATUS_SUCCESS;
1817 }
1818
1819 int rtsx_set_phy_reg_bit(struct rtsx_chip *chip, u8 reg, u8 bit)
1820 {
1821         int retval;
1822         u16 value;
1823
1824         retval = rtsx_read_phy_register(chip, reg, &value);
1825         if (retval != STATUS_SUCCESS) {
1826                 TRACE_RET(chip, STATUS_FAIL);
1827         }
1828         if (0 == (value & (1 << bit))) {
1829                 value |= (1 << bit);
1830                 retval = rtsx_write_phy_register(chip, reg, value);
1831                 if (retval != STATUS_SUCCESS) {
1832                         TRACE_RET(chip, STATUS_FAIL);
1833                 }
1834         }
1835
1836         return STATUS_SUCCESS;
1837 }
1838
1839 int rtsx_check_link_ready(struct rtsx_chip *chip)
1840 {
1841         u8 val;
1842
1843         RTSX_READ_REG(chip, IRQSTAT0, &val);
1844
1845         RTSX_DEBUGP("IRQSTAT0: 0x%x\n", val);
1846         if (val & LINK_RDY_INT) {
1847                 RTSX_DEBUGP("Delinked!\n");
1848                 rtsx_write_register(chip, IRQSTAT0, LINK_RDY_INT, LINK_RDY_INT);
1849                 return STATUS_FAIL;
1850         }
1851
1852         return STATUS_SUCCESS;
1853 }
1854
1855 static void rtsx_handle_pm_dstate(struct rtsx_chip *chip, u8 dstate)
1856 {
1857         u32 ultmp;
1858
1859         RTSX_DEBUGP("%04x set pm_dstate to %d\n", chip->product_id, dstate);
1860
1861         if (CHK_SDIO_EXIST(chip)) {
1862                 u8 func_no;
1863
1864                 if (CHECK_PID(chip, 0x5288)) {
1865                         func_no = 2;
1866                 } else {
1867                         func_no = 1;
1868                 }
1869                 rtsx_read_cfg_dw(chip, func_no, 0x84, &ultmp);
1870                 RTSX_DEBUGP("pm_dstate of function %d: 0x%x\n", (int)func_no, ultmp);
1871                 rtsx_write_cfg_dw(chip, func_no, 0x84, 0xFF, dstate);
1872         }
1873
1874         rtsx_write_config_byte(chip, 0x44, dstate);
1875         rtsx_write_config_byte(chip, 0x45, 0);
1876 }
1877
1878 void rtsx_enter_L1(struct rtsx_chip *chip)
1879 {
1880         rtsx_handle_pm_dstate(chip, 2);
1881 }
1882
1883 void rtsx_exit_L1(struct rtsx_chip *chip)
1884 {
1885         rtsx_write_config_byte(chip, 0x44, 0);
1886         rtsx_write_config_byte(chip, 0x45, 0);
1887 }
1888
1889 void rtsx_enter_ss(struct rtsx_chip *chip)
1890 {
1891         RTSX_DEBUGP("Enter Selective Suspend State!\n");
1892
1893         rtsx_write_register(chip, IRQSTAT0, LINK_RDY_INT, LINK_RDY_INT);
1894
1895         if (chip->power_down_in_ss) {
1896                 rtsx_power_off_card(chip);
1897                 rtsx_force_power_down(chip, SSC_PDCTL | OC_PDCTL);
1898         }
1899
1900         if (CHK_SDIO_EXIST(chip)) {
1901                 if (CHECK_PID(chip, 0x5288)) {
1902                         rtsx_write_cfg_dw(chip, 2, 0xC0, 0xFF00, 0x0100);
1903                 } else {
1904                         rtsx_write_cfg_dw(chip, 1, 0xC0, 0xFF00, 0x0100);
1905                 }
1906         }
1907
1908         if (chip->auto_delink_en) {
1909                 rtsx_write_register(chip, HOST_SLEEP_STATE, 0x01, 0x01);
1910         } else {
1911                 if (!chip->phy_debug_mode) {
1912                         u32 tmp;
1913                         tmp = rtsx_readl(chip, RTSX_BIER);
1914                         tmp |= CARD_INT;
1915                         rtsx_writel(chip, RTSX_BIER, tmp);
1916                 }
1917
1918                 rtsx_write_register(chip, CHANGE_LINK_STATE, 0x02, 0);
1919         }
1920
1921         rtsx_enter_L1(chip);
1922
1923         RTSX_CLR_DELINK(chip);
1924         rtsx_set_stat(chip, RTSX_STAT_SS);
1925 }
1926
1927 void rtsx_exit_ss(struct rtsx_chip *chip)
1928 {
1929         RTSX_DEBUGP("Exit Selective Suspend State!\n");
1930
1931         rtsx_exit_L1(chip);
1932
1933         if (chip->power_down_in_ss) {
1934                 rtsx_force_power_on(chip, SSC_PDCTL | OC_PDCTL);
1935                 udelay(1000);
1936         }
1937
1938         if (RTSX_TST_DELINK(chip)) {
1939                 chip->need_reinit = SD_CARD | MS_CARD | XD_CARD;
1940                 rtsx_reinit_cards(chip, 1);
1941                 RTSX_CLR_DELINK(chip);
1942         } else if (chip->power_down_in_ss) {
1943                 chip->need_reinit = SD_CARD | MS_CARD | XD_CARD;
1944                 rtsx_reinit_cards(chip, 0);
1945         }
1946 }
1947
1948 int rtsx_pre_handle_interrupt(struct rtsx_chip *chip)
1949 {
1950         u32 status, int_enable;
1951         int exit_ss = 0;
1952 #ifdef SUPPORT_OCP
1953         u32 ocp_int = 0;
1954
1955         if (CHECK_PID(chip, 0x5209)) {
1956                 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
1957                         ocp_int = MS_OC_INT | SD_OC_INT;
1958                 } else {
1959                         ocp_int = SD_OC_INT;
1960                 }
1961         } else {
1962                 ocp_int = OC_INT;
1963         }
1964 #endif
1965
1966         if (chip->ss_en) {
1967                 chip->ss_counter = 0;
1968                 if (rtsx_get_stat(chip) == RTSX_STAT_SS) {
1969                         exit_ss = 1;
1970                         rtsx_exit_L1(chip);
1971                         rtsx_set_stat(chip, RTSX_STAT_RUN);
1972                 }
1973         }
1974
1975         int_enable = rtsx_readl(chip, RTSX_BIER);
1976         chip->int_reg = rtsx_readl(chip, RTSX_BIPR);
1977
1978 #ifdef HW_INT_WRITE_CLR
1979         if (CHECK_PID(chip, 0x5209)) {
1980                 rtsx_writel(chip, RTSX_BIPR, chip->int_reg);
1981         }
1982 #endif
1983
1984         if (((chip->int_reg & int_enable) == 0) || (chip->int_reg == 0xFFFFFFFF))
1985                 return STATUS_FAIL;
1986
1987         if (!chip->msi_en) {
1988                 if (CHECK_PID(chip, 0x5209)) {
1989                         u8 val;
1990                         rtsx_read_config_byte(chip, 0x05, &val);
1991                         if (val & 0x04) {
1992                                 return STATUS_FAIL;
1993                         }
1994                 }
1995         }
1996
1997         status = chip->int_reg &= (int_enable | 0x7FFFFF);
1998
1999         if (status & CARD_INT) {
2000                 chip->auto_delink_cnt = 0;
2001
2002                 if (status & SD_INT) {
2003                         if (status & SD_EXIST) {
2004                                 set_bit(SD_NR, &(chip->need_reset));
2005                         } else {
2006                                 set_bit(SD_NR, &(chip->need_release));
2007                                 chip->sd_reset_counter = 0;
2008                                 chip->sd_show_cnt = 0;
2009                                 clear_bit(SD_NR, &(chip->need_reset));
2010                         }
2011                 } else {
2012                         /* If multi-luns, it's possible that
2013                            when plugging/unplugging one card
2014                            there is another card which still
2015                            exists in the slot. In this case,
2016                            all existed cards should be reset.
2017                         */
2018                         if (exit_ss && (status & SD_EXIST))
2019                                 set_bit(SD_NR, &(chip->need_reinit));
2020                 }
2021                 if (!CHECK_PID(chip, 0x5288) || CHECK_BARO_PKG(chip, QFN)) {
2022                         if (status & XD_INT) {
2023                                 if (status & XD_EXIST) {
2024                                         set_bit(XD_NR, &(chip->need_reset));
2025                                 } else {
2026                                         set_bit(XD_NR, &(chip->need_release));
2027                                         chip->xd_reset_counter = 0;
2028                                         chip->xd_show_cnt = 0;
2029                                         clear_bit(XD_NR, &(chip->need_reset));
2030                                 }
2031                         } else {
2032                                 if (exit_ss && (status & XD_EXIST))
2033                                         set_bit(XD_NR, &(chip->need_reinit));
2034                         }
2035                 }
2036                 if (status & MS_INT) {
2037                         if (status & MS_EXIST) {
2038                                 set_bit(MS_NR, &(chip->need_reset));
2039                         } else {
2040                                 set_bit(MS_NR, &(chip->need_release));
2041                                 chip->ms_reset_counter = 0;
2042                                 chip->ms_show_cnt = 0;
2043                                 clear_bit(MS_NR, &(chip->need_reset));
2044                         }
2045                 } else {
2046                         if (exit_ss && (status & MS_EXIST))
2047                                 set_bit(MS_NR, &(chip->need_reinit));
2048                 }
2049         }
2050
2051 #ifdef SUPPORT_OCP
2052         chip->ocp_int = ocp_int & status;
2053 #endif
2054
2055         if (chip->sd_io) {
2056                 if (chip->int_reg & DATA_DONE_INT)
2057                         chip->int_reg &= ~(u32)DATA_DONE_INT;
2058         }
2059
2060         return STATUS_SUCCESS;
2061 }
2062
2063 void rtsx_do_before_power_down(struct rtsx_chip *chip, int pm_stat)
2064 {
2065         int retval;
2066
2067         RTSX_DEBUGP("rtsx_do_before_power_down, pm_stat = %d\n", pm_stat);
2068
2069         rtsx_set_stat(chip, RTSX_STAT_SUSPEND);
2070
2071         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2072         if (retval != STATUS_SUCCESS)
2073                 return;
2074
2075         rtsx_release_cards(chip);
2076         rtsx_disable_bus_int(chip);
2077         turn_off_led(chip, LED_GPIO);
2078
2079 #ifdef HW_AUTO_SWITCH_SD_BUS
2080         if (chip->sd_io) {
2081                 chip->sdio_in_charge = 1;
2082                 if (CHECK_PID(chip, 0x5208)) {
2083                         rtsx_write_register(chip, TLPTISTAT, 0x08, 0x08);
2084                         /* Enable sdio_bus_auto_switch */
2085                         rtsx_write_register(chip, 0xFE70, 0x80, 0x80);
2086                 } else if (CHECK_PID(chip, 0x5288)) {
2087                         rtsx_write_register(chip, TLPTISTAT, 0x08, 0x08);
2088                         /* Enable sdio_bus_auto_switch */
2089                         rtsx_write_register(chip, 0xFE5A, 0x08, 0x08);
2090                 } else if (CHECK_PID(chip, 0x5209)) {
2091                         rtsx_write_register(chip, TLPTISTAT, 0x10, 0x10);
2092                         /* Enable sdio_bus_auto_switch */
2093                         rtsx_write_register(chip, SDIO_CFG, SDIO_BUS_AUTO_SWITCH, SDIO_BUS_AUTO_SWITCH);
2094                 }
2095         }
2096 #endif
2097
2098         if (CHECK_PID(chip, 0x5208) && (chip->ic_version >= IC_VER_D)) {
2099                 /* u_force_clkreq_0 */
2100                 rtsx_write_register(chip, PETXCFG, 0x08, 0x08);
2101         } else if (CHECK_PID(chip, 0x5209)) {
2102                 /* u_force_clkreq_0 */
2103                 rtsx_write_register(chip, PETXCFG, 0x08, 0x08);
2104         }
2105
2106         if (pm_stat == PM_S1) {
2107                 RTSX_DEBUGP("Host enter S1\n");
2108                 rtsx_write_register(chip, HOST_SLEEP_STATE, 0x03, HOST_ENTER_S1);
2109         } else if (pm_stat == PM_S3) {
2110                 if (chip->s3_pwr_off_delay > 0) {
2111                         wait_timeout(chip->s3_pwr_off_delay);
2112                 }
2113                 RTSX_DEBUGP("Host enter S3\n");
2114                 rtsx_write_register(chip, HOST_SLEEP_STATE, 0x03, HOST_ENTER_S3);
2115         }
2116
2117         if (chip->do_delink_before_power_down && chip->auto_delink_en) {
2118                 rtsx_write_register(chip, CHANGE_LINK_STATE, 0x02, 2);
2119         }
2120
2121         rtsx_force_power_down(chip, SSC_PDCTL | OC_PDCTL);
2122
2123         chip->cur_clk = 0;
2124         chip->cur_card = 0;
2125         chip->card_exist = 0;
2126 }
2127
2128 void rtsx_enable_aspm(struct rtsx_chip *chip)
2129 {
2130         if (chip->aspm_l0s_l1_en && chip->dynamic_aspm) {
2131                 if (!chip->aspm_enabled) {
2132                         RTSX_DEBUGP("Try to enable ASPM\n");
2133                         chip->aspm_enabled = 1;
2134
2135                         if (chip->asic_code && CHECK_PID(chip, 0x5208))
2136                                 rtsx_write_phy_register(chip, 0x07, 0);
2137                         if (CHECK_PID(chip, 0x5208)) {
2138                                 rtsx_write_register(chip, ASPM_FORCE_CTL, 0xF3,
2139                                         0x30 | chip->aspm_level[0]);
2140                         } else {
2141                                 rtsx_write_config_byte(chip, LCTLR, chip->aspm_l0s_l1_en);
2142                         }
2143
2144                         if (CHK_SDIO_EXIST(chip)) {
2145                                 u16 val = chip->aspm_l0s_l1_en | 0x0100;
2146                                 if (CHECK_PID(chip, 0x5288)) {
2147                                         rtsx_write_cfg_dw(chip, 2, 0xC0, 0xFFFF, val);
2148                                 } else {
2149                                         rtsx_write_cfg_dw(chip, 1, 0xC0, 0xFFFF, val);
2150                                 }
2151                         }
2152                 }
2153         }
2154
2155         return;
2156 }
2157
2158 void rtsx_disable_aspm(struct rtsx_chip *chip)
2159 {
2160         if (CHECK_PID(chip, 0x5208))
2161                 rtsx_monitor_aspm_config(chip);
2162
2163         if (chip->aspm_l0s_l1_en && chip->dynamic_aspm) {
2164                 if (chip->aspm_enabled) {
2165                         RTSX_DEBUGP("Try to disable ASPM\n");
2166                         chip->aspm_enabled = 0;
2167
2168                         if (chip->asic_code && CHECK_PID(chip, 0x5208))
2169                                 rtsx_write_phy_register(chip, 0x07, 0x0129);
2170                         if (CHECK_PID(chip, 0x5208)) {
2171                                 rtsx_write_register(chip, ASPM_FORCE_CTL, 0xF3, 0x30);
2172                         } else {
2173                                 rtsx_write_config_byte(chip, LCTLR, 0x00);
2174                         }
2175                         wait_timeout(1);
2176                 }
2177         }
2178
2179         return;
2180 }
2181
2182 int rtsx_read_ppbuf(struct rtsx_chip *chip, u8 *buf, int buf_len)
2183 {
2184         int retval;
2185         int i, j;
2186         u16 reg_addr;
2187         u8 *ptr;
2188
2189         if (!buf) {
2190                 TRACE_RET(chip, STATUS_ERROR);
2191         }
2192
2193         ptr = buf;
2194         reg_addr = PPBUF_BASE2;
2195         for (i = 0; i < buf_len/256; i++) {
2196                 rtsx_init_cmd(chip);
2197
2198                 for (j = 0; j < 256; j++)
2199                         rtsx_add_cmd(chip, READ_REG_CMD, reg_addr++, 0, 0);
2200
2201                 retval = rtsx_send_cmd(chip, 0, 250);
2202                 if (retval < 0) {
2203                         TRACE_RET(chip, STATUS_FAIL);
2204                 }
2205
2206                 memcpy(ptr, rtsx_get_cmd_data(chip), 256);
2207                 ptr += 256;
2208         }
2209
2210         if (buf_len%256) {
2211                 rtsx_init_cmd(chip);
2212
2213                 for (j = 0; j < buf_len%256; j++)
2214                         rtsx_add_cmd(chip, READ_REG_CMD, reg_addr++, 0, 0);
2215
2216                 retval = rtsx_send_cmd(chip, 0, 250);
2217                 if (retval < 0) {
2218                         TRACE_RET(chip, STATUS_FAIL);
2219                 }
2220         }
2221
2222         memcpy(ptr, rtsx_get_cmd_data(chip), buf_len%256);
2223
2224         return STATUS_SUCCESS;
2225 }
2226
2227 int rtsx_write_ppbuf(struct rtsx_chip *chip, u8 *buf, int buf_len)
2228 {
2229         int retval;
2230         int i, j;
2231         u16 reg_addr;
2232         u8 *ptr;
2233
2234         if (!buf) {
2235                 TRACE_RET(chip, STATUS_ERROR);
2236         }
2237
2238         ptr = buf;
2239         reg_addr = PPBUF_BASE2;
2240         for (i = 0; i < buf_len/256; i++) {
2241                 rtsx_init_cmd(chip);
2242
2243                 for (j = 0; j < 256; j++) {
2244                         rtsx_add_cmd(chip, WRITE_REG_CMD, reg_addr++, 0xFF, *ptr);
2245                         ptr++;
2246                 }
2247
2248                 retval = rtsx_send_cmd(chip, 0, 250);
2249                 if (retval < 0) {
2250                         TRACE_RET(chip, STATUS_FAIL);
2251                 }
2252         }
2253
2254         if (buf_len%256) {
2255                 rtsx_init_cmd(chip);
2256
2257                 for (j = 0; j < buf_len%256; j++) {
2258                         rtsx_add_cmd(chip, WRITE_REG_CMD, reg_addr++, 0xFF, *ptr);
2259                         ptr++;
2260                 }
2261
2262                 retval = rtsx_send_cmd(chip, 0, 250);
2263                 if (retval < 0) {
2264                         TRACE_RET(chip, STATUS_FAIL);
2265                 }
2266         }
2267
2268         return STATUS_SUCCESS;
2269 }
2270
2271 int rtsx_check_chip_exist(struct rtsx_chip *chip)
2272 {
2273         if (rtsx_readl(chip, 0) == 0xFFFFFFFF) {
2274                 TRACE_RET(chip, STATUS_FAIL);
2275         }
2276
2277         return STATUS_SUCCESS;
2278 }
2279
2280 int rtsx_force_power_on(struct rtsx_chip *chip, u8 ctl)
2281 {
2282         int retval;
2283         u8 mask = 0;
2284
2285         if (ctl & SSC_PDCTL)
2286                 mask |= SSC_POWER_DOWN;
2287
2288 #ifdef SUPPORT_OCP
2289         if (ctl & OC_PDCTL) {
2290                 mask |= SD_OC_POWER_DOWN;
2291                 if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2292                         mask |= MS_OC_POWER_DOWN;
2293                 }
2294         }
2295 #endif
2296
2297         if (mask) {
2298                 retval = rtsx_write_register(chip, FPDCTL, mask, 0);
2299                 if (retval != STATUS_SUCCESS) {
2300                         TRACE_RET(chip, STATUS_FAIL);
2301                 }
2302
2303                 if (CHECK_PID(chip, 0x5288))
2304                         wait_timeout(200);
2305         }
2306
2307         return STATUS_SUCCESS;
2308 }
2309
2310 int rtsx_force_power_down(struct rtsx_chip *chip, u8 ctl)
2311 {
2312         int retval;
2313         u8 mask = 0, val = 0;
2314
2315         if (ctl & SSC_PDCTL)
2316                 mask |= SSC_POWER_DOWN;
2317
2318 #ifdef SUPPORT_OCP
2319         if (ctl & OC_PDCTL) {
2320                 mask |= SD_OC_POWER_DOWN;
2321                 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2322                         mask |= MS_OC_POWER_DOWN;
2323         }
2324 #endif
2325
2326         if (mask) {
2327                 val = mask;
2328                 retval = rtsx_write_register(chip, FPDCTL, mask, val);
2329                 if (retval != STATUS_SUCCESS) {
2330                         TRACE_RET(chip, STATUS_FAIL);
2331                 }
2332         }
2333
2334         return STATUS_SUCCESS;
2335 }