drivers/staging/rts5208/ms.c

   1 /* Driver for Realtek PCI-Express card reader
   2  *
   3  * Copyright(c) 2009-2013 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  *   Wei WANG (wei_wang@realsil.com.cn)
  20  *   Micky Ching (micky_ching@realsil.com.cn)
  21  */
  22
  23 #include <linux/blkdev.h>
  24 #include <linux/kthread.h>
  25 #include <linux/sched.h>
  26 #include <linux/vmalloc.h>
  27
  28 #include "rtsx.h"
  29 #include "rtsx_transport.h"
  30 #include "rtsx_scsi.h"
  31 #include "rtsx_card.h"
  32 #include "ms.h"
  33
  34 static inline void ms_set_err_code(struct rtsx_chip *chip, u8 err_code)
  35 {
  36         struct ms_info *ms_card = &(chip->ms_card);
  37
  38         ms_card->err_code = err_code;
  39 }
  40
  41 static inline int ms_check_err_code(struct rtsx_chip *chip, u8 err_code)
  42 {
  43         struct ms_info *ms_card = &(chip->ms_card);
  44
  45         return (ms_card->err_code == err_code);
  46 }
  47
  48 static int ms_parse_err_code(struct rtsx_chip *chip)
  49 {
  50         TRACE_RET(chip, STATUS_FAIL);
  51 }
  52
  53 static int ms_transfer_tpc(struct rtsx_chip *chip, u8 trans_mode,
  54                         u8 tpc, u8 cnt, u8 cfg)
  55 {
  56         struct ms_info *ms_card = &(chip->ms_card);
  57         int retval;
  58         u8 *ptr;
  59
  60         dev_dbg(rtsx_dev(chip), "%s: tpc = 0x%x\n", __func__, tpc);
  61
  62         rtsx_init_cmd(chip);
  63
  64         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
  65         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
  66         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
  67         rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE,
  68                 0x01, PINGPONG_BUFFER);
  69
  70         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANSFER,
  71                 0xFF, MS_TRANSFER_START | trans_mode);
  72         rtsx_add_cmd(chip, CHECK_REG_CMD, MS_TRANSFER,
  73                 MS_TRANSFER_END, MS_TRANSFER_END);
  74
  75         rtsx_add_cmd(chip, READ_REG_CMD, MS_TRANS_CFG, 0, 0);
  76
  77         retval = rtsx_send_cmd(chip, MS_CARD, 5000);
  78         if (retval < 0) {
  79                 rtsx_clear_ms_error(chip);
  80                 ms_set_err_code(chip, MS_TO_ERROR);
  81                 TRACE_RET(chip, ms_parse_err_code(chip));
  82         }
  83
  84         ptr = rtsx_get_cmd_data(chip) + 1;
  85
  86         if (!(tpc & 0x08)) {            /* Read Packet */
  87                 if (*ptr & MS_CRC16_ERR) {
  88                         ms_set_err_code(chip, MS_CRC16_ERROR);
  89                         TRACE_RET(chip, ms_parse_err_code(chip));
  90                 }
  91         } else {                        /* Write Packet */
  92                 if (CHK_MSPRO(ms_card) && !(*ptr & 0x80)) {
  93                         if (*ptr & (MS_INT_ERR | MS_INT_CMDNK)) {
  94                                 ms_set_err_code(chip, MS_CMD_NK);
  95                                 TRACE_RET(chip, ms_parse_err_code(chip));
  96                         }
  97                 }
  98         }
  99
 100         if (*ptr & MS_RDY_TIMEOUT) {
 101                 rtsx_clear_ms_error(chip);
 102                 ms_set_err_code(chip, MS_TO_ERROR);
 103                 TRACE_RET(chip, ms_parse_err_code(chip));
 104         }
 105
 106         return STATUS_SUCCESS;
 107 }
 108
 109 static int ms_transfer_data(struct rtsx_chip *chip, u8 trans_mode,
 110                         u8 tpc, u16 sec_cnt, u8 cfg, int mode_2k,
 111                         int use_sg, void *buf, int buf_len)
 112 {
 113         int retval;
 114         u8 val, err_code = 0;
 115         enum dma_data_direction dir;
 116
 117         if (!buf || !buf_len)
 118                 TRACE_RET(chip, STATUS_FAIL);
 119
 120         if (trans_mode == MS_TM_AUTO_READ) {
 121                 dir = DMA_FROM_DEVICE;
 122                 err_code = MS_FLASH_READ_ERROR;
 123         } else if (trans_mode == MS_TM_AUTO_WRITE) {
 124                 dir = DMA_TO_DEVICE;
 125                 err_code = MS_FLASH_WRITE_ERROR;
 126         } else {
 127                 TRACE_RET(chip, STATUS_FAIL);
 128         }
 129
 130         rtsx_init_cmd(chip);
 131
 132         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
 133         rtsx_add_cmd(chip, WRITE_REG_CMD,
 134                      MS_SECTOR_CNT_H, 0xFF, (u8)(sec_cnt >> 8));
 135         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_SECTOR_CNT_L, 0xFF, (u8)sec_cnt);
 136         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
 137
 138         if (mode_2k) {
 139                 rtsx_add_cmd(chip, WRITE_REG_CMD,
 140                              MS_CFG, MS_2K_SECTOR_MODE, MS_2K_SECTOR_MODE);
 141         } else {
 142                 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_CFG, MS_2K_SECTOR_MODE, 0);
 143         }
 144
 145         trans_dma_enable(dir, chip, sec_cnt * 512, DMA_512);
 146
 147         rtsx_add_cmd(chip, WRITE_REG_CMD,
 148                      MS_TRANSFER, 0xFF, MS_TRANSFER_START | trans_mode);
 149         rtsx_add_cmd(chip, CHECK_REG_CMD,
 150                      MS_TRANSFER, MS_TRANSFER_END, MS_TRANSFER_END);
 151
 152         rtsx_send_cmd_no_wait(chip);
 153
 154         retval = rtsx_transfer_data(chip, MS_CARD, buf, buf_len,
 155                                     use_sg, dir, chip->mspro_timeout);
 156         if (retval < 0) {
 157                 ms_set_err_code(chip, err_code);
 158                 if (retval == -ETIMEDOUT)
 159                         retval = STATUS_TIMEDOUT;
 160                 else
 161                         retval = STATUS_FAIL;
 162
 163                 TRACE_RET(chip, retval);
 164         }
 165
 166         RTSX_READ_REG(chip, MS_TRANS_CFG, &val);
 167         if (val & (MS_INT_CMDNK | MS_INT_ERR | MS_CRC16_ERR | MS_RDY_TIMEOUT))
 168                 TRACE_RET(chip, STATUS_FAIL);
 169
 170         return STATUS_SUCCESS;
 171 }
 172
 173 static int ms_write_bytes(struct rtsx_chip *chip,
 174                           u8 tpc, u8 cnt, u8 cfg, u8 *data, int data_len)
 175 {
 176         struct ms_info *ms_card = &(chip->ms_card);
 177         int retval, i;
 178
 179         if (!data || (data_len < cnt))
 180                 TRACE_RET(chip, STATUS_ERROR);
 181
 182         rtsx_init_cmd(chip);
 183
 184         for (i = 0; i < cnt; i++) {
 185                 rtsx_add_cmd(chip, WRITE_REG_CMD,
 186                              PPBUF_BASE2 + i, 0xFF, data[i]);
 187         }
 188         if (cnt % 2)
 189                 rtsx_add_cmd(chip, WRITE_REG_CMD, PPBUF_BASE2 + i, 0xFF, 0xFF);
 190
 191         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
 192         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
 193         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
 194         rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE,
 195                 0x01, PINGPONG_BUFFER);
 196
 197         rtsx_add_cmd(chip, WRITE_REG_CMD,
 198                      MS_TRANSFER, 0xFF, MS_TRANSFER_START | MS_TM_WRITE_BYTES);
 199         rtsx_add_cmd(chip, CHECK_REG_CMD,
 200                      MS_TRANSFER, MS_TRANSFER_END, MS_TRANSFER_END);
 201
 202         retval = rtsx_send_cmd(chip, MS_CARD, 5000);
 203         if (retval < 0) {
 204                 u8 val = 0;
 205
 206                 rtsx_read_register(chip, MS_TRANS_CFG, &val);
 207                 dev_dbg(rtsx_dev(chip), "MS_TRANS_CFG: 0x%02x\n", val);
 208
 209                 rtsx_clear_ms_error(chip);
 210
 211                 if (!(tpc & 0x08)) {
 212                         if (val & MS_CRC16_ERR) {
 213                                 ms_set_err_code(chip, MS_CRC16_ERROR);
 214                                 TRACE_RET(chip, ms_parse_err_code(chip));
 215                         }
 216                 } else {
 217                         if (CHK_MSPRO(ms_card) && !(val & 0x80)) {
 218                                 if (val & (MS_INT_ERR | MS_INT_CMDNK)) {
 219                                         ms_set_err_code(chip, MS_CMD_NK);
 220                                         TRACE_RET(chip,
 221                                                 ms_parse_err_code(chip));
 222                                 }
 223                         }
 224                 }
 225
 226                 if (val & MS_RDY_TIMEOUT) {
 227                         ms_set_err_code(chip, MS_TO_ERROR);
 228                         TRACE_RET(chip, ms_parse_err_code(chip));
 229                 }
 230
 231                 ms_set_err_code(chip, MS_TO_ERROR);
 232                 TRACE_RET(chip, ms_parse_err_code(chip));
 233         }
 234
 235         return STATUS_SUCCESS;
 236 }
 237
 238 static int ms_read_bytes(struct rtsx_chip *chip,
 239                         u8 tpc, u8 cnt, u8 cfg, u8 *data, int data_len)
 240 {
 241         struct ms_info *ms_card = &(chip->ms_card);
 242         int retval, i;
 243         u8 *ptr;
 244
 245         if (!data)
 246                 TRACE_RET(chip, STATUS_ERROR);
 247
 248         rtsx_init_cmd(chip);
 249
 250         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC, 0xFF, tpc);
 251         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_BYTE_CNT, 0xFF, cnt);
 252         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, cfg);
 253         rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE,
 254                 0x01, PINGPONG_BUFFER);
 255
 256         rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANSFER, 0xFF,
 257                 MS_TRANSFER_START | MS_TM_READ_BYTES);
 258         rtsx_add_cmd(chip, CHECK_REG_CMD, MS_TRANSFER,
 259                 MS_TRANSFER_END, MS_TRANSFER_END);
 260
 261         for (i = 0; i < data_len - 1; i++)
 262                 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + i, 0, 0);
 263
 264         if (data_len % 2)
 265                 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + data_len, 0, 0);
 266         else
 267                 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + data_len - 1,
 268                         0, 0);
 269
 270         retval = rtsx_send_cmd(chip, MS_CARD, 5000);
 271         if (retval < 0) {
 272                 u8 val = 0;
 273
 274                 rtsx_read_register(chip, MS_TRANS_CFG, &val);
 275                 rtsx_clear_ms_error(chip);
 276
 277                 if (!(tpc & 0x08)) {
 278                         if (val & MS_CRC16_ERR) {
 279                                 ms_set_err_code(chip, MS_CRC16_ERROR);
 280                                 TRACE_RET(chip, ms_parse_err_code(chip));
 281                         }
 282                 } else {
 283                         if (CHK_MSPRO(ms_card) && !(val & 0x80)) {
 284                                 if (val & (MS_INT_ERR | MS_INT_CMDNK)) {
 285                                         ms_set_err_code(chip, MS_CMD_NK);
 286                                         TRACE_RET(chip,
 287                                                 ms_parse_err_code(chip));
 288                                 }
 289                         }
 290                 }
 291
 292                 if (val & MS_RDY_TIMEOUT) {
 293                         ms_set_err_code(chip, MS_TO_ERROR);
 294                         TRACE_RET(chip, ms_parse_err_code(chip));
 295                 }
 296
 297                 ms_set_err_code(chip, MS_TO_ERROR);
 298                 TRACE_RET(chip, ms_parse_err_code(chip));
 299         }
 300
 301         ptr = rtsx_get_cmd_data(chip) + 1;
 302
 303         for (i = 0; i < data_len; i++)
 304                 data[i] = ptr[i];
 305
 306         if ((tpc == PRO_READ_SHORT_DATA) && (data_len == 8)) {
 307                 dev_dbg(rtsx_dev(chip), "Read format progress:\n");
 308                 RTSX_DUMP(ptr, cnt);
 309         }
 310
 311         return STATUS_SUCCESS;
 312 }
 313
 314 static int ms_set_rw_reg_addr(struct rtsx_chip *chip,
 315                 u8 read_start, u8 read_cnt, u8 write_start, u8 write_cnt)
 316 {
 317         int retval, i;
 318         u8 data[4];
 319
 320         data[0] = read_start;
 321         data[1] = read_cnt;
 322         data[2] = write_start;
 323         data[3] = write_cnt;
 324
 325         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
 326                 retval = ms_write_bytes(chip, SET_RW_REG_ADRS, 4,
 327                                         NO_WAIT_INT, data, 4);
 328                 if (retval == STATUS_SUCCESS)
 329                         return STATUS_SUCCESS;
 330                 rtsx_clear_ms_error(chip);
 331         }
 332
 333         TRACE_RET(chip, STATUS_FAIL);
 334 }
 335
 336 static int ms_send_cmd(struct rtsx_chip *chip, u8 cmd, u8 cfg)
 337 {
 338         u8 data[2];
 339
 340         data[0] = cmd;
 341         data[1] = 0;
 342
 343         return ms_write_bytes(chip, PRO_SET_CMD, 1, cfg, data, 1);
 344 }
 345
 346 static int ms_set_init_para(struct rtsx_chip *chip)
 347 {
 348         struct ms_info *ms_card = &(chip->ms_card);
 349         int retval;
 350
 351         if (CHK_HG8BIT(ms_card)) {
 352                 if (chip->asic_code)
 353                         ms_card->ms_clock = chip->asic_ms_hg_clk;
 354                 else
 355                         ms_card->ms_clock = chip->fpga_ms_hg_clk;
 356
 357         } else if (CHK_MSPRO(ms_card) || CHK_MS4BIT(ms_card)) {
 358                 if (chip->asic_code)
 359                         ms_card->ms_clock = chip->asic_ms_4bit_clk;
 360                 else
 361                         ms_card->ms_clock = chip->fpga_ms_4bit_clk;
 362
 363         } else {
 364                 if (chip->asic_code)
 365                         ms_card->ms_clock = chip->asic_ms_1bit_clk;
 366                 else
 367                         ms_card->ms_clock = chip->fpga_ms_1bit_clk;
 368         }
 369
 370         retval = switch_clock(chip, ms_card->ms_clock);
 371         if (retval != STATUS_SUCCESS)
 372                 TRACE_RET(chip, STATUS_FAIL);
 373
 374         retval = select_card(chip, MS_CARD);
 375         if (retval != STATUS_SUCCESS)
 376                 TRACE_RET(chip, STATUS_FAIL);
 377
 378         return STATUS_SUCCESS;
 379 }
 380
 381 static int ms_switch_clock(struct rtsx_chip *chip)
 382 {
 383         struct ms_info *ms_card = &(chip->ms_card);
 384         int retval;
 385
 386         retval = select_card(chip, MS_CARD);
 387         if (retval != STATUS_SUCCESS)
 388                 TRACE_RET(chip, STATUS_FAIL);
 389
 390         retval = switch_clock(chip, ms_card->ms_clock);
 391         if (retval != STATUS_SUCCESS)
 392                 TRACE_RET(chip, STATUS_FAIL);
 393
 394         return STATUS_SUCCESS;
 395 }
 396
 397 static int ms_pull_ctl_disable(struct rtsx_chip *chip)
 398 {
 399         if (CHECK_PID(chip, 0x5208)) {
 400                 RTSX_WRITE_REG(chip, CARD_PULL_CTL1, 0xFF,
 401                         MS_D1_PD | MS_D2_PD | MS_CLK_PD | MS_D6_PD);
 402                 RTSX_WRITE_REG(chip, CARD_PULL_CTL2, 0xFF,
 403                         MS_D3_PD | MS_D0_PD | MS_BS_PD | XD_D4_PD);
 404                 RTSX_WRITE_REG(chip, CARD_PULL_CTL3, 0xFF,
 405                         MS_D7_PD | XD_CE_PD | XD_CLE_PD | XD_CD_PU);
 406                 RTSX_WRITE_REG(chip, CARD_PULL_CTL4, 0xFF,
 407                         XD_RDY_PD | SD_D3_PD | SD_D2_PD | XD_ALE_PD);
 408                 RTSX_WRITE_REG(chip, CARD_PULL_CTL5, 0xFF,
 409                         MS_INS_PU | SD_WP_PD | SD_CD_PU | SD_CMD_PD);
 410                 RTSX_WRITE_REG(chip, CARD_PULL_CTL6, 0xFF,
 411                         MS_D5_PD | MS_D4_PD);
 412         } else if (CHECK_PID(chip, 0x5288)) {
 413                 if (CHECK_BARO_PKG(chip, QFN)) {
 414                         RTSX_WRITE_REG(chip, CARD_PULL_CTL1, 0xFF, 0x55);
 415                         RTSX_WRITE_REG(chip, CARD_PULL_CTL2, 0xFF, 0x55);
 416                         RTSX_WRITE_REG(chip, CARD_PULL_CTL3, 0xFF, 0x4B);
 417                         RTSX_WRITE_REG(chip, CARD_PULL_CTL4, 0xFF, 0x69);
 418                 }
 419         }
 420
 421         return STATUS_SUCCESS;
 422 }
 423
 424 static int ms_pull_ctl_enable(struct rtsx_chip *chip)
 425 {
 426         int retval;
 427
 428         rtsx_init_cmd(chip);
 429
 430         if (CHECK_PID(chip, 0x5208)) {
 431                 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL1, 0xFF,
 432                         MS_D1_PD | MS_D2_PD | MS_CLK_NP | MS_D6_PD);
 433                 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL2, 0xFF,
 434                         MS_D3_PD | MS_D0_PD | MS_BS_NP | XD_D4_PD);
 435                 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL3, 0xFF,
 436                         MS_D7_PD | XD_CE_PD | XD_CLE_PD | XD_CD_PU);
 437                 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL4, 0xFF,
 438                         XD_RDY_PD | SD_D3_PD | SD_D2_PD | XD_ALE_PD);
 439                 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL5, 0xFF,
 440                         MS_INS_PU | SD_WP_PD | SD_CD_PU | SD_CMD_PD);
 441                 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_PULL_CTL6, 0xFF,
 442                         MS_D5_PD | MS_D4_PD);
 443         } else if (CHECK_PID(chip, 0x5288)) {
 444                 if (CHECK_BARO_PKG(chip, QFN)) {
 445                         rtsx_add_cmd(chip, WRITE_REG_CMD,
 446                                      CARD_PULL_CTL1, 0xFF, 0x55);
 447                         rtsx_add_cmd(chip, WRITE_REG_CMD,
 448                                      CARD_PULL_CTL2, 0xFF, 0x45);
 449                         rtsx_add_cmd(chip, WRITE_REG_CMD,
 450                                      CARD_PULL_CTL3, 0xFF, 0x4B);
 451                         rtsx_add_cmd(chip, WRITE_REG_CMD,
 452                                      CARD_PULL_CTL4, 0xFF, 0x29);
 453                 }
 454         }
 455
 456         retval = rtsx_send_cmd(chip, MS_CARD, 100);
 457         if (retval < 0)
 458                 TRACE_RET(chip, STATUS_FAIL);
 459
 460         return STATUS_SUCCESS;
 461 }
 462
 463 static int ms_prepare_reset(struct rtsx_chip *chip)
 464 {
 465         struct ms_info *ms_card = &(chip->ms_card);
 466         int retval;
 467         u8 oc_mask = 0;
 468
 469         ms_card->ms_type = 0;
 470         ms_card->check_ms_flow = 0;
 471         ms_card->switch_8bit_fail = 0;
 472         ms_card->delay_write.delay_write_flag = 0;
 473
 474         ms_card->pro_under_formatting = 0;
 475
 476         retval = ms_power_off_card3v3(chip);
 477         if (retval != STATUS_SUCCESS)
 478                 TRACE_RET(chip, STATUS_FAIL);
 479
 480         if (!chip->ft2_fast_mode)
 481                 wait_timeout(250);
 482
 483         retval = enable_card_clock(chip, MS_CARD);
 484         if (retval != STATUS_SUCCESS)
 485                 TRACE_RET(chip, STATUS_FAIL);
 486
 487         if (chip->asic_code) {
 488                 retval = ms_pull_ctl_enable(chip);
 489                 if (retval != STATUS_SUCCESS)
 490                         TRACE_RET(chip, STATUS_FAIL);
 491         } else {
 492                 RTSX_WRITE_REG(chip, FPGA_PULL_CTL,
 493                         FPGA_MS_PULL_CTL_BIT | 0x20, 0);
 494         }
 495
 496         if (!chip->ft2_fast_mode) {
 497                 retval = card_power_on(chip, MS_CARD);
 498                 if (retval != STATUS_SUCCESS)
 499                         TRACE_RET(chip, STATUS_FAIL);
 500
 501                 wait_timeout(150);
 502
 503 #ifdef SUPPORT_OCP
 504                 if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
 505                         oc_mask = MS_OC_NOW | MS_OC_EVER;
 506                 else
 507                         oc_mask = SD_OC_NOW | SD_OC_EVER;
 508
 509                 if (chip->ocp_stat & oc_mask) {
 510                         dev_dbg(rtsx_dev(chip), "Over current, OCPSTAT is 0x%x\n",
 511                                 chip->ocp_stat);
 512                         TRACE_RET(chip, STATUS_FAIL);
 513                 }
 514 #endif
 515         }
 516
 517         RTSX_WRITE_REG(chip, CARD_OE, MS_OUTPUT_EN, MS_OUTPUT_EN);
 518
 519         if (chip->asic_code) {
 520                 RTSX_WRITE_REG(chip, MS_CFG, 0xFF,
 521                         SAMPLE_TIME_RISING | PUSH_TIME_DEFAULT |
 522                         NO_EXTEND_TOGGLE | MS_BUS_WIDTH_1);
 523         } else {
 524                 RTSX_WRITE_REG(chip, MS_CFG, 0xFF,
 525                         SAMPLE_TIME_FALLING | PUSH_TIME_DEFAULT |
 526                         NO_EXTEND_TOGGLE | MS_BUS_WIDTH_1);
 527         }
 528         RTSX_WRITE_REG(chip, MS_TRANS_CFG,
 529                 0xFF, NO_WAIT_INT | NO_AUTO_READ_INT_REG);
 530         RTSX_WRITE_REG(chip, CARD_STOP,
 531                 MS_STOP | MS_CLR_ERR, MS_STOP | MS_CLR_ERR);
 532
 533         retval = ms_set_init_para(chip);
 534         if (retval != STATUS_SUCCESS)
 535                 TRACE_RET(chip, STATUS_FAIL);
 536
 537         return STATUS_SUCCESS;
 538 }
 539
 540 static int ms_identify_media_type(struct rtsx_chip *chip, int switch_8bit_bus)
 541 {
 542         struct ms_info *ms_card = &(chip->ms_card);
 543         int retval, i;
 544         u8 val;
 545
 546         retval = ms_set_rw_reg_addr(chip, Pro_StatusReg, 6, SystemParm, 1);
 547         if (retval != STATUS_SUCCESS)
 548                 TRACE_RET(chip, STATUS_FAIL);
 549
 550         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
 551                 retval = ms_transfer_tpc(chip, MS_TM_READ_BYTES, READ_REG,
 552                                         6, NO_WAIT_INT);
 553                 if (retval == STATUS_SUCCESS)
 554                         break;
 555         }
 556         if (i == MS_MAX_RETRY_COUNT)
 557                 TRACE_RET(chip, STATUS_FAIL);
 558
 559         RTSX_READ_REG(chip, PPBUF_BASE2 + 2, &val);
 560         dev_dbg(rtsx_dev(chip), "Type register: 0x%x\n", val);
 561         if (val != 0x01) {
 562                 if (val != 0x02)
 563                         ms_card->check_ms_flow = 1;
 564
 565                 TRACE_RET(chip, STATUS_FAIL);
 566         }
 567
 568         RTSX_READ_REG(chip, PPBUF_BASE2 + 4, &val);
 569         dev_dbg(rtsx_dev(chip), "Category register: 0x%x\n", val);
 570         if (val != 0) {
 571                 ms_card->check_ms_flow = 1;
 572                 TRACE_RET(chip, STATUS_FAIL);
 573         }
 574
 575         RTSX_READ_REG(chip, PPBUF_BASE2 + 5, &val);
 576         dev_dbg(rtsx_dev(chip), "Class register: 0x%x\n", val);
 577         if (val == 0) {
 578                 RTSX_READ_REG(chip, PPBUF_BASE2, &val);
 579                 if (val & WRT_PRTCT)
 580                         chip->card_wp |= MS_CARD;
 581                 else
 582                         chip->card_wp &= ~MS_CARD;
 583
 584         } else if ((val == 0x01) || (val == 0x02) || (val == 0x03)) {
 585                 chip->card_wp |= MS_CARD;
 586         } else {
 587                 ms_card->check_ms_flow = 1;
 588                 TRACE_RET(chip, STATUS_FAIL);
 589         }
 590
 591         ms_card->ms_type |= TYPE_MSPRO;
 592
 593         RTSX_READ_REG(chip, PPBUF_BASE2 + 3, &val);
 594         dev_dbg(rtsx_dev(chip), "IF Mode register: 0x%x\n", val);
 595         if (val == 0) {
 596                 ms_card->ms_type &= 0x0F;
 597         } else if (val == 7) {
 598                 if (switch_8bit_bus)
 599                         ms_card->ms_type |= MS_HG;
 600                 else
 601                         ms_card->ms_type &= 0x0F;
 602
 603         } else {
 604                 TRACE_RET(chip, STATUS_FAIL);
 605         }
 606
 607         return STATUS_SUCCESS;
 608 }
 609
 610 static int ms_confirm_cpu_startup(struct rtsx_chip *chip)
 611 {
 612         int retval, i, k;
 613         u8 val;
 614
 615         /* Confirm CPU StartUp */
 616         k = 0;
 617         do {
 618                 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {
 619                         ms_set_err_code(chip, MS_NO_CARD);
 620                         TRACE_RET(chip, STATUS_FAIL);
 621                 }
 622
 623                 for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
 624                         retval = ms_read_bytes(chip, GET_INT, 1,
 625                                         NO_WAIT_INT, &val, 1);
 626                         if (retval == STATUS_SUCCESS)
 627                                 break;
 628                 }
 629                 if (i == MS_MAX_RETRY_COUNT)
 630                         TRACE_RET(chip, STATUS_FAIL);
 631
 632                 if (k > 100)
 633                         TRACE_RET(chip, STATUS_FAIL);
 634
 635                 k++;
 636                 wait_timeout(100);
 637         } while (!(val & INT_REG_CED));
 638
 639         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
 640                 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1);
 641                 if (retval == STATUS_SUCCESS)
 642                         break;
 643         }
 644         if (i == MS_MAX_RETRY_COUNT)
 645                 TRACE_RET(chip, STATUS_FAIL);
 646
 647         if (val & INT_REG_ERR) {
 648                 if (val & INT_REG_CMDNK)
 649                         chip->card_wp |= (MS_CARD);
 650                 else
 651                         TRACE_RET(chip, STATUS_FAIL);
 652         }
 653         /* --  end confirm CPU startup */
 654
 655         return STATUS_SUCCESS;
 656 }
 657
 658 static int ms_switch_parallel_bus(struct rtsx_chip *chip)
 659 {
 660         int retval, i;
 661         u8 data[2];
 662
 663         data[0] = PARALLEL_4BIT_IF;
 664         data[1] = 0;
 665         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
 666                 retval = ms_write_bytes(chip, WRITE_REG, 1, NO_WAIT_INT,
 667                                         data, 2);
 668                 if (retval == STATUS_SUCCESS)
 669                         break;
 670         }
 671         if (retval != STATUS_SUCCESS)
 672                 TRACE_RET(chip, STATUS_FAIL);
 673
 674         return STATUS_SUCCESS;
 675 }
 676
 677 static int ms_switch_8bit_bus(struct rtsx_chip *chip)
 678 {
 679         struct ms_info *ms_card = &(chip->ms_card);
 680         int retval, i;
 681         u8 data[2];
 682
 683         data[0] = PARALLEL_8BIT_IF;
 684         data[1] = 0;
 685         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
 686                 retval = ms_write_bytes(chip, WRITE_REG, 1,
 687                                         NO_WAIT_INT, data, 2);
 688                 if (retval == STATUS_SUCCESS)
 689                         break;
 690         }
 691         if (retval != STATUS_SUCCESS)
 692                 TRACE_RET(chip, STATUS_FAIL);
 693
 694         RTSX_WRITE_REG(chip, MS_CFG, 0x98,
 695                 MS_BUS_WIDTH_8 | SAMPLE_TIME_FALLING);
 696         ms_card->ms_type |= MS_8BIT;
 697         retval = ms_set_init_para(chip);
 698         if (retval != STATUS_SUCCESS)
 699                 TRACE_RET(chip, STATUS_FAIL);
 700
 701         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
 702                 retval = ms_transfer_tpc(chip, MS_TM_READ_BYTES, GET_INT,
 703                                         1, NO_WAIT_INT);
 704                 if (retval != STATUS_SUCCESS)
 705                         TRACE_RET(chip, STATUS_FAIL);
 706         }
 707
 708         return STATUS_SUCCESS;
 709 }
 710
 711 static int ms_pro_reset_flow(struct rtsx_chip *chip, int switch_8bit_bus)
 712 {
 713         struct ms_info *ms_card = &(chip->ms_card);
 714         int retval, i;
 715
 716         for (i = 0; i < 3; i++) {
 717                 retval = ms_prepare_reset(chip);
 718                 if (retval != STATUS_SUCCESS)
 719                         TRACE_RET(chip, STATUS_FAIL);
 720
 721                 retval = ms_identify_media_type(chip, switch_8bit_bus);
 722                 if (retval != STATUS_SUCCESS)
 723                         TRACE_RET(chip, STATUS_FAIL);
 724
 725                 retval = ms_confirm_cpu_startup(chip);
 726                 if (retval != STATUS_SUCCESS)
 727                         TRACE_RET(chip, STATUS_FAIL);
 728
 729                 retval = ms_switch_parallel_bus(chip);
 730                 if (retval != STATUS_SUCCESS) {
 731                         if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {
 732                                 ms_set_err_code(chip, MS_NO_CARD);
 733                                 TRACE_RET(chip, STATUS_FAIL);
 734                         }
 735                         continue;
 736                 } else {
 737                         break;
 738                 }
 739         }
 740
 741         if (retval != STATUS_SUCCESS)
 742                 TRACE_RET(chip, STATUS_FAIL);
 743
 744         /* Switch MS-PRO into Parallel mode */
 745         RTSX_WRITE_REG(chip, MS_CFG, 0x18, MS_BUS_WIDTH_4);
 746         RTSX_WRITE_REG(chip, MS_CFG, PUSH_TIME_ODD, PUSH_TIME_ODD);
 747
 748         retval = ms_set_init_para(chip);
 749         if (retval != STATUS_SUCCESS)
 750                 TRACE_RET(chip, STATUS_FAIL);
 751
 752         /* If MSPro HG Card, We shall try to switch to 8-bit bus */
 753         if (CHK_MSHG(ms_card) && chip->support_ms_8bit && switch_8bit_bus) {
 754                 retval = ms_switch_8bit_bus(chip);
 755                 if (retval != STATUS_SUCCESS) {
 756                         ms_card->switch_8bit_fail = 1;
 757                         TRACE_RET(chip, STATUS_FAIL);
 758                 }
 759         }
 760
 761         return STATUS_SUCCESS;
 762 }
 763
 764 #ifdef XC_POWERCLASS
 765 static int msxc_change_power(struct rtsx_chip *chip, u8 mode)
 766 {
 767         int retval;
 768         u8 buf[6];
 769
 770         ms_cleanup_work(chip);
 771
 772         retval = ms_set_rw_reg_addr(chip, 0, 0, Pro_DataCount1, 6);
 773         if (retval != STATUS_SUCCESS)
 774                 TRACE_RET(chip, STATUS_FAIL);
 775
 776         buf[0] = 0;
 777         buf[1] = mode;
 778         buf[2] = 0;
 779         buf[3] = 0;
 780         buf[4] = 0;
 781         buf[5] = 0;
 782
 783         retval = ms_write_bytes(chip, PRO_WRITE_REG , 6, NO_WAIT_INT, buf, 6);
 784         if (retval != STATUS_SUCCESS)
 785                 TRACE_RET(chip, STATUS_FAIL);
 786
 787         retval = ms_send_cmd(chip, XC_CHG_POWER, WAIT_INT);
 788         if (retval != STATUS_SUCCESS)
 789                 TRACE_RET(chip, STATUS_FAIL);
 790
 791         RTSX_READ_REG(chip, MS_TRANS_CFG, buf);
 792         if (buf[0] & (MS_INT_CMDNK | MS_INT_ERR))
 793                 TRACE_RET(chip, STATUS_FAIL);
 794
 795         return STATUS_SUCCESS;
 796 }
 797 #endif
 798
 799 static int ms_read_attribute_info(struct rtsx_chip *chip)
 800 {
 801         struct ms_info *ms_card = &(chip->ms_card);
 802         int retval, i;
 803         u8 val, *buf, class_code, device_type, sub_class, data[16];
 804         u16 total_blk = 0, blk_size = 0;
 805 #ifdef SUPPORT_MSXC
 806         u32 xc_total_blk = 0, xc_blk_size = 0;
 807 #endif
 808         u32 sys_info_addr = 0, sys_info_size;
 809 #ifdef SUPPORT_PCGL_1P18
 810         u32 model_name_addr = 0, model_name_size;
 811         int found_sys_info = 0, found_model_name = 0;
 812 #endif
 813
 814         retval = ms_set_rw_reg_addr(chip, Pro_IntReg, 2, Pro_SystemParm, 7);
 815         if (retval != STATUS_SUCCESS)
 816                 TRACE_RET(chip, STATUS_FAIL);
 817
 818         if (CHK_MS8BIT(ms_card))
 819                 data[0] = PARALLEL_8BIT_IF;
 820         else
 821                 data[0] = PARALLEL_4BIT_IF;
 822
 823         data[1] = 0;
 824
 825         data[2] = 0x40;
 826         data[3] = 0;
 827         data[4] = 0;
 828         data[5] = 0;
 829         data[6] = 0;
 830         data[7] = 0;
 831
 832         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
 833                 retval = ms_write_bytes(chip, PRO_WRITE_REG, 7, NO_WAIT_INT,
 834                                         data, 8);
 835                 if (retval == STATUS_SUCCESS)
 836                         break;
 837         }
 838         if (retval != STATUS_SUCCESS)
 839                 TRACE_RET(chip, STATUS_FAIL);
 840
 841         buf = kmalloc(64 * 512, GFP_KERNEL);
 842         if (buf == NULL)
 843                 TRACE_RET(chip, STATUS_ERROR);
 844
 845         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
 846                 retval = ms_send_cmd(chip, PRO_READ_ATRB, WAIT_INT);
 847                 if (retval != STATUS_SUCCESS)
 848                         continue;
 849
 850                 retval = rtsx_read_register(chip, MS_TRANS_CFG, &val);
 851                 if (retval != STATUS_SUCCESS) {
 852                         kfree(buf);
 853                         TRACE_RET(chip, STATUS_FAIL);
 854                 }
 855                 if (!(val & MS_INT_BREQ)) {
 856                         kfree(buf);
 857                         TRACE_RET(chip, STATUS_FAIL);
 858                 }
 859                 retval = ms_transfer_data(chip, MS_TM_AUTO_READ,
 860                                         PRO_READ_LONG_DATA, 0x40, WAIT_INT,
 861                                         0, 0, buf, 64 * 512);
 862                 if (retval == STATUS_SUCCESS)
 863                         break;
 864                 else
 865                         rtsx_clear_ms_error(chip);
 866         }
 867         if (retval != STATUS_SUCCESS) {
 868                 kfree(buf);
 869                 TRACE_RET(chip, STATUS_FAIL);
 870         }
 871
 872         i = 0;
 873         do {
 874                 retval = rtsx_read_register(chip, MS_TRANS_CFG, &val);
 875                 if (retval != STATUS_SUCCESS) {
 876                         kfree(buf);
 877                         TRACE_RET(chip, STATUS_FAIL);
 878                 }
 879
 880                 if ((val & MS_INT_CED) || !(val & MS_INT_BREQ))
 881                         break;
 882
 883                 retval = ms_transfer_tpc(chip, MS_TM_NORMAL_READ,
 884                                         PRO_READ_LONG_DATA, 0, WAIT_INT);
 885                 if (retval != STATUS_SUCCESS) {
 886                         kfree(buf);
 887                         TRACE_RET(chip, STATUS_FAIL);
 888                 }
 889
 890                 i++;
 891         } while (i < 1024);
 892
 893         if (retval != STATUS_SUCCESS) {
 894                 kfree(buf);
 895                 TRACE_RET(chip, STATUS_FAIL);
 896         }
 897
 898         if ((buf[0] != 0xa5) && (buf[1] != 0xc3)) {
 899                 /* Signature code is wrong */
 900                 kfree(buf);
 901                 TRACE_RET(chip, STATUS_FAIL);
 902         }
 903
 904         if ((buf[4] < 1) || (buf[4] > 12)) {
 905                 kfree(buf);
 906                 TRACE_RET(chip, STATUS_FAIL);
 907         }
 908
 909         for (i = 0; i < buf[4]; i++) {
 910                 int cur_addr_off = 16 + i * 12;
 911
 912 #ifdef SUPPORT_MSXC
 913                 if ((buf[cur_addr_off + 8] == 0x10) ||
 914                         (buf[cur_addr_off + 8] == 0x13))
 915 #else
 916                 if (buf[cur_addr_off + 8] == 0x10)
 917 #endif
 918                 {
 919                         sys_info_addr = ((u32)buf[cur_addr_off + 0] << 24) |
 920                                 ((u32)buf[cur_addr_off + 1] << 16) |
 921                                 ((u32)buf[cur_addr_off + 2] << 8) |
 922                                 buf[cur_addr_off + 3];
 923                         sys_info_size = ((u32)buf[cur_addr_off + 4] << 24) |
 924                                 ((u32)buf[cur_addr_off + 5] << 16) |
 925                                 ((u32)buf[cur_addr_off + 6] << 8) |
 926                                 buf[cur_addr_off + 7];
 927                         dev_dbg(rtsx_dev(chip), "sys_info_addr = 0x%x, sys_info_size = 0x%x\n",
 928                                 sys_info_addr, sys_info_size);
 929                         if (sys_info_size != 96)  {
 930                                 kfree(buf);
 931                                 TRACE_RET(chip, STATUS_FAIL);
 932                         }
 933                         if (sys_info_addr < 0x1A0) {
 934                                 kfree(buf);
 935                                 TRACE_RET(chip, STATUS_FAIL);
 936                         }
 937                         if ((sys_info_size + sys_info_addr) > 0x8000) {
 938                                 kfree(buf);
 939                                 TRACE_RET(chip, STATUS_FAIL);
 940                         }
 941
 942 #ifdef SUPPORT_MSXC
 943                         if (buf[cur_addr_off + 8] == 0x13)
 944                                 ms_card->ms_type |= MS_XC;
 945 #endif
 946 #ifdef SUPPORT_PCGL_1P18
 947                         found_sys_info = 1;
 948 #else
 949                         break;
 950 #endif
 951                 }
 952 #ifdef SUPPORT_PCGL_1P18
 953                 if (buf[cur_addr_off + 8] == 0x15) {
 954                         model_name_addr = ((u32)buf[cur_addr_off + 0] << 24) |
 955                                 ((u32)buf[cur_addr_off + 1] << 16) |
 956                                 ((u32)buf[cur_addr_off + 2] << 8) |
 957                                 buf[cur_addr_off + 3];
 958                         model_name_size = ((u32)buf[cur_addr_off + 4] << 24) |
 959                                 ((u32)buf[cur_addr_off + 5] << 16) |
 960                                 ((u32)buf[cur_addr_off + 6] << 8) |
 961                                 buf[cur_addr_off + 7];
 962                         dev_dbg(rtsx_dev(chip), "model_name_addr = 0x%x, model_name_size = 0x%x\n",
 963                                 model_name_addr, model_name_size);
 964                         if (model_name_size != 48)  {
 965                                 kfree(buf);
 966                                 TRACE_RET(chip, STATUS_FAIL);
 967                         }
 968                         if (model_name_addr < 0x1A0) {
 969                                 kfree(buf);
 970                                 TRACE_RET(chip, STATUS_FAIL);
 971                         }
 972                         if ((model_name_size + model_name_addr) > 0x8000) {
 973                                 kfree(buf);
 974                                 TRACE_RET(chip, STATUS_FAIL);
 975                         }
 976
 977                         found_model_name = 1;
 978                 }
 979
 980                 if (found_sys_info && found_model_name)
 981                         break;
 982 #endif
 983         }
 984
 985         if (i == buf[4]) {
 986                 kfree(buf);
 987                 TRACE_RET(chip, STATUS_FAIL);
 988         }
 989
 990         class_code =  buf[sys_info_addr + 0];
 991         device_type = buf[sys_info_addr + 56];
 992         sub_class = buf[sys_info_addr + 46];
 993 #ifdef SUPPORT_MSXC
 994         if (CHK_MSXC(ms_card)) {
 995                 xc_total_blk = ((u32)buf[sys_info_addr + 6] << 24) |
 996                                 ((u32)buf[sys_info_addr + 7] << 16) |
 997                                 ((u32)buf[sys_info_addr + 8] << 8) |
 998                                 buf[sys_info_addr + 9];
 999                 xc_blk_size = ((u32)buf[sys_info_addr + 32] << 24) |
1000                                 ((u32)buf[sys_info_addr + 33] << 16) |
1001                                 ((u32)buf[sys_info_addr + 34] << 8) |
1002                                 buf[sys_info_addr + 35];
1003                 dev_dbg(rtsx_dev(chip), "xc_total_blk = 0x%x, xc_blk_size = 0x%x\n",
1004                         xc_total_blk, xc_blk_size);
1005         } else {
1006                 total_blk = ((u16)buf[sys_info_addr + 6] << 8) |
1007                         buf[sys_info_addr + 7];
1008                 blk_size = ((u16)buf[sys_info_addr + 2] << 8) |
1009                         buf[sys_info_addr + 3];
1010                 dev_dbg(rtsx_dev(chip), "total_blk = 0x%x, blk_size = 0x%x\n",
1011                         total_blk, blk_size);
1012         }
1013 #else
1014         total_blk = ((u16)buf[sys_info_addr + 6] << 8) | buf[sys_info_addr + 7];
1015         blk_size = ((u16)buf[sys_info_addr + 2] << 8) | buf[sys_info_addr + 3];
1016         dev_dbg(rtsx_dev(chip), "total_blk = 0x%x, blk_size = 0x%x\n",
1017                 total_blk, blk_size);
1018 #endif
1019
1020         dev_dbg(rtsx_dev(chip), "class_code = 0x%x, device_type = 0x%x, sub_class = 0x%x\n",
1021                 class_code, device_type, sub_class);
1022
1023         memcpy(ms_card->raw_sys_info, buf + sys_info_addr, 96);
1024 #ifdef SUPPORT_PCGL_1P18
1025         memcpy(ms_card->raw_model_name, buf + model_name_addr, 48);
1026 #endif
1027
1028         kfree(buf);
1029
1030 #ifdef SUPPORT_MSXC
1031         if (CHK_MSXC(ms_card)) {
1032                 if (class_code != 0x03)
1033                         TRACE_RET(chip, STATUS_FAIL);
1034         } else {
1035                 if (class_code != 0x02)
1036                         TRACE_RET(chip, STATUS_FAIL);
1037         }
1038 #else
1039         if (class_code != 0x02)
1040                 TRACE_RET(chip, STATUS_FAIL);
1041 #endif
1042
1043         if (device_type != 0x00) {
1044                 if ((device_type == 0x01) || (device_type == 0x02) ||
1045                                 (device_type == 0x03)) {
1046                         chip->card_wp |= MS_CARD;
1047                 } else {
1048                         TRACE_RET(chip, STATUS_FAIL);
1049                 }
1050         }
1051
1052         if (sub_class & 0xC0)
1053                 TRACE_RET(chip, STATUS_FAIL);
1054
1055         dev_dbg(rtsx_dev(chip), "class_code: 0x%x, device_type: 0x%x, sub_class: 0x%x\n",
1056                 class_code, device_type, sub_class);
1057
1058 #ifdef SUPPORT_MSXC
1059         if (CHK_MSXC(ms_card)) {
1060                 chip->capacity[chip->card2lun[MS_CARD]] =
1061                         ms_card->capacity = xc_total_blk * xc_blk_size;
1062         } else {
1063                 chip->capacity[chip->card2lun[MS_CARD]] =
1064                         ms_card->capacity = total_blk * blk_size;
1065         }
1066 #else
1067         ms_card->capacity = total_blk * blk_size;
1068         chip->capacity[chip->card2lun[MS_CARD]] = ms_card->capacity;
1069 #endif
1070
1071         return STATUS_SUCCESS;
1072 }
1073
1074 #ifdef SUPPORT_MAGIC_GATE
1075 static int mg_set_tpc_para_sub(struct rtsx_chip *chip,
1076                         int type, u8 mg_entry_num);
1077 #endif
1078
1079 static int reset_ms_pro(struct rtsx_chip *chip)
1080 {
1081         struct ms_info *ms_card = &(chip->ms_card);
1082         int retval;
1083 #ifdef XC_POWERCLASS
1084         u8 change_power_class;
1085
1086         if (chip->ms_power_class_en & 0x02)
1087                 change_power_class = 2;
1088         else if (chip->ms_power_class_en & 0x01)
1089                 change_power_class = 1;
1090         else
1091                 change_power_class = 0;
1092 #endif
1093
1094 #ifdef XC_POWERCLASS
1095 Retry:
1096 #endif
1097         retval = ms_pro_reset_flow(chip, 1);
1098         if (retval != STATUS_SUCCESS) {
1099                 if (ms_card->switch_8bit_fail) {
1100                         retval = ms_pro_reset_flow(chip, 0);
1101                         if (retval != STATUS_SUCCESS)
1102                                 TRACE_RET(chip, STATUS_FAIL);
1103                 } else {
1104                         TRACE_RET(chip, STATUS_FAIL);
1105                 }
1106         }
1107
1108         retval = ms_read_attribute_info(chip);
1109         if (retval != STATUS_SUCCESS)
1110                 TRACE_RET(chip, STATUS_FAIL);
1111
1112 #ifdef XC_POWERCLASS
1113         if (CHK_HG8BIT(ms_card))
1114                 change_power_class = 0;
1115
1116         if (change_power_class && CHK_MSXC(ms_card)) {
1117                 u8 power_class_en = chip->ms_power_class_en;
1118
1119                 dev_dbg(rtsx_dev(chip), "power_class_en = 0x%x\n",
1120                         power_class_en);
1121                 dev_dbg(rtsx_dev(chip), "change_power_class = %d\n",
1122                         change_power_class);
1123
1124                 if (change_power_class)
1125                         power_class_en &= (1 << (change_power_class - 1));
1126                 else
1127                         power_class_en = 0;
1128
1129                 if (power_class_en) {
1130                         u8 power_class_mode =
1131                                 (ms_card->raw_sys_info[46] & 0x18) >> 3;
1132                         dev_dbg(rtsx_dev(chip), "power_class_mode = 0x%x",
1133                                 power_class_mode);
1134                         if (change_power_class > power_class_mode)
1135                                 change_power_class = power_class_mode;
1136                         if (change_power_class) {
1137                                 retval = msxc_change_power(chip,
1138                                                         change_power_class);
1139                                 if (retval != STATUS_SUCCESS) {
1140                                         change_power_class--;
1141                                         goto Retry;
1142                                 }
1143                         }
1144                 }
1145         }
1146 #endif
1147
1148 #ifdef SUPPORT_MAGIC_GATE
1149         retval = mg_set_tpc_para_sub(chip, 0, 0);
1150         if (retval != STATUS_SUCCESS)
1151                 TRACE_RET(chip, STATUS_FAIL);
1152 #endif
1153
1154         if (CHK_HG8BIT(ms_card))
1155                 chip->card_bus_width[chip->card2lun[MS_CARD]] = 8;
1156         else
1157                 chip->card_bus_width[chip->card2lun[MS_CARD]] = 4;
1158
1159         return STATUS_SUCCESS;
1160 }
1161
1162 static int ms_read_status_reg(struct rtsx_chip *chip)
1163 {
1164         int retval;
1165         u8 val[2];
1166
1167         retval = ms_set_rw_reg_addr(chip, StatusReg0, 2, 0, 0);
1168         if (retval != STATUS_SUCCESS)
1169                 TRACE_RET(chip, STATUS_FAIL);
1170
1171         retval = ms_read_bytes(chip, READ_REG, 2, NO_WAIT_INT, val, 2);
1172         if (retval != STATUS_SUCCESS)
1173                 TRACE_RET(chip, STATUS_FAIL);
1174
1175         if (val[1] & (STS_UCDT | STS_UCEX | STS_UCFG)) {
1176                 ms_set_err_code(chip, MS_FLASH_READ_ERROR);
1177                 TRACE_RET(chip, STATUS_FAIL);
1178         }
1179
1180         return STATUS_SUCCESS;
1181 }
1182
1183
1184 static int ms_read_extra_data(struct rtsx_chip *chip,
1185                 u16 block_addr, u8 page_num, u8 *buf, int buf_len)
1186 {
1187         struct ms_info *ms_card = &(chip->ms_card);
1188         int retval, i;
1189         u8 val, data[10];
1190
1191         retval = ms_set_rw_reg_addr(chip, OverwriteFlag, MS_EXTRA_SIZE,
1192                                 SystemParm, 6);
1193         if (retval != STATUS_SUCCESS)
1194                 TRACE_RET(chip, STATUS_FAIL);
1195
1196         if (CHK_MS4BIT(ms_card)) {
1197                 /* Parallel interface */
1198                 data[0] = 0x88;
1199         } else {
1200                 /* Serial interface */
1201                 data[0] = 0x80;
1202         }
1203         data[1] = 0;
1204         data[2] = (u8)(block_addr >> 8);
1205         data[3] = (u8)block_addr;
1206         data[4] = 0x40;
1207         data[5] = page_num;
1208
1209         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
1210                 retval = ms_write_bytes(chip, WRITE_REG, 6, NO_WAIT_INT,
1211                                         data, 6);
1212                 if (retval == STATUS_SUCCESS)
1213                         break;
1214         }
1215         if (i == MS_MAX_RETRY_COUNT)
1216                 TRACE_RET(chip, STATUS_FAIL);
1217
1218         ms_set_err_code(chip, MS_NO_ERROR);
1219
1220         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
1221                 retval = ms_send_cmd(chip, BLOCK_READ, WAIT_INT);
1222                 if (retval == STATUS_SUCCESS)
1223                         break;
1224         }
1225         if (i == MS_MAX_RETRY_COUNT)
1226                 TRACE_RET(chip, STATUS_FAIL);
1227
1228         ms_set_err_code(chip, MS_NO_ERROR);
1229         retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1);
1230         if (retval != STATUS_SUCCESS)
1231                 TRACE_RET(chip, STATUS_FAIL);
1232
1233         if (val & INT_REG_CMDNK) {
1234                 ms_set_err_code(chip, MS_CMD_NK);
1235                 TRACE_RET(chip, STATUS_FAIL);
1236         }
1237         if (val & INT_REG_CED) {
1238                 if (val & INT_REG_ERR) {
1239                         retval = ms_read_status_reg(chip);
1240                         if (retval != STATUS_SUCCESS)
1241                                 TRACE_RET(chip, STATUS_FAIL);
1242
1243                         retval = ms_set_rw_reg_addr(chip, OverwriteFlag,
1244                                                 MS_EXTRA_SIZE, SystemParm, 6);
1245                         if (retval != STATUS_SUCCESS)
1246                                 TRACE_RET(chip, STATUS_FAIL);
1247                 }
1248         }
1249
1250         retval = ms_read_bytes(chip, READ_REG, MS_EXTRA_SIZE, NO_WAIT_INT,
1251                         data, MS_EXTRA_SIZE);
1252         if (retval != STATUS_SUCCESS)
1253                 TRACE_RET(chip, STATUS_FAIL);
1254
1255         if (buf && buf_len) {
1256                 if (buf_len > MS_EXTRA_SIZE)
1257                         buf_len = MS_EXTRA_SIZE;
1258                 memcpy(buf, data, buf_len);
1259         }
1260
1261         return STATUS_SUCCESS;
1262 }
1263
1264 static int ms_write_extra_data(struct rtsx_chip *chip,
1265                 u16 block_addr, u8 page_num, u8 *buf, int buf_len)
1266 {
1267         struct ms_info *ms_card = &(chip->ms_card);
1268         int retval, i;
1269         u8 val, data[16];
1270
1271         if (!buf || (buf_len < MS_EXTRA_SIZE))
1272                 TRACE_RET(chip, STATUS_FAIL);
1273
1274         retval = ms_set_rw_reg_addr(chip, OverwriteFlag, MS_EXTRA_SIZE,
1275                                 SystemParm, 6 + MS_EXTRA_SIZE);
1276         if (retval != STATUS_SUCCESS)
1277                 TRACE_RET(chip, STATUS_FAIL);
1278
1279         if (CHK_MS4BIT(ms_card))
1280                 data[0] = 0x88;
1281         else
1282                 data[0] = 0x80;
1283
1284         data[1] = 0;
1285         data[2] = (u8)(block_addr >> 8);
1286         data[3] = (u8)block_addr;
1287         data[4] = 0x40;
1288         data[5] = page_num;
1289
1290         for (i = 6; i < MS_EXTRA_SIZE + 6; i++)
1291                 data[i] = buf[i - 6];
1292
1293         retval = ms_write_bytes(chip, WRITE_REG , (6+MS_EXTRA_SIZE),
1294                                 NO_WAIT_INT, data, 16);
1295         if (retval != STATUS_SUCCESS)
1296                 TRACE_RET(chip, STATUS_FAIL);
1297
1298         retval = ms_send_cmd(chip, BLOCK_WRITE, WAIT_INT);
1299         if (retval != STATUS_SUCCESS)
1300                 TRACE_RET(chip, STATUS_FAIL);
1301
1302         ms_set_err_code(chip, MS_NO_ERROR);
1303         retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1);
1304         if (retval != STATUS_SUCCESS)
1305                 TRACE_RET(chip, STATUS_FAIL);
1306
1307         if (val & INT_REG_CMDNK) {
1308                 ms_set_err_code(chip, MS_CMD_NK);
1309                 TRACE_RET(chip, STATUS_FAIL);
1310         }
1311         if (val & INT_REG_CED) {
1312                 if (val & INT_REG_ERR) {
1313                         ms_set_err_code(chip, MS_FLASH_WRITE_ERROR);
1314                         TRACE_RET(chip, STATUS_FAIL);
1315                 }
1316         }
1317
1318         return STATUS_SUCCESS;
1319 }
1320
1321
1322 static int ms_read_page(struct rtsx_chip *chip, u16 block_addr, u8 page_num)
1323 {
1324         struct ms_info *ms_card = &(chip->ms_card);
1325         int retval;
1326         u8 val, data[6];
1327
1328         retval = ms_set_rw_reg_addr(chip, OverwriteFlag, MS_EXTRA_SIZE,
1329                                 SystemParm, 6);
1330         if (retval != STATUS_SUCCESS)
1331                 TRACE_RET(chip, STATUS_FAIL);
1332
1333         if (CHK_MS4BIT(ms_card))
1334                 data[0] = 0x88;
1335         else
1336                 data[0] = 0x80;
1337
1338         data[1] = 0;
1339         data[2] = (u8)(block_addr >> 8);
1340         data[3] = (u8)block_addr;
1341         data[4] = 0x20;
1342         data[5] = page_num;
1343
1344         retval = ms_write_bytes(chip, WRITE_REG , 6, NO_WAIT_INT, data, 6);
1345         if (retval != STATUS_SUCCESS)
1346                 TRACE_RET(chip, STATUS_FAIL);
1347
1348         retval = ms_send_cmd(chip, BLOCK_READ, WAIT_INT);
1349         if (retval != STATUS_SUCCESS)
1350                 TRACE_RET(chip, STATUS_FAIL);
1351
1352         ms_set_err_code(chip, MS_NO_ERROR);
1353         retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1);
1354         if (retval != STATUS_SUCCESS)
1355                 TRACE_RET(chip, STATUS_FAIL);
1356
1357         if (val & INT_REG_CMDNK) {
1358                 ms_set_err_code(chip, MS_CMD_NK);
1359                 TRACE_RET(chip, STATUS_FAIL);
1360         }
1361
1362         if (val & INT_REG_CED) {
1363                 if (val & INT_REG_ERR) {
1364                         if (!(val & INT_REG_BREQ)) {
1365                                 ms_set_err_code(chip,  MS_FLASH_READ_ERROR);
1366                                 TRACE_RET(chip, STATUS_FAIL);
1367                         }
1368                         retval = ms_read_status_reg(chip);
1369                         if (retval != STATUS_SUCCESS)
1370                                 ms_set_err_code(chip,  MS_FLASH_WRITE_ERROR);
1371
1372                 } else {
1373                         if (!(val & INT_REG_BREQ)) {
1374                                 ms_set_err_code(chip, MS_BREQ_ERROR);
1375                                 TRACE_RET(chip, STATUS_FAIL);
1376                         }
1377                 }
1378         }
1379
1380         retval = ms_transfer_tpc(chip, MS_TM_NORMAL_READ, READ_PAGE_DATA,
1381                                 0, NO_WAIT_INT);
1382         if (retval != STATUS_SUCCESS)
1383                 TRACE_RET(chip, STATUS_FAIL);
1384
1385         if (ms_check_err_code(chip, MS_FLASH_WRITE_ERROR))
1386                 TRACE_RET(chip, STATUS_FAIL);
1387
1388         return STATUS_SUCCESS;
1389 }
1390
1391
1392 static int ms_set_bad_block(struct rtsx_chip *chip, u16 phy_blk)
1393 {
1394         struct ms_info *ms_card = &(chip->ms_card);
1395         int retval;
1396         u8 val, data[8], extra[MS_EXTRA_SIZE];
1397
1398         retval = ms_read_extra_data(chip, phy_blk, 0, extra, MS_EXTRA_SIZE);
1399         if (retval != STATUS_SUCCESS)
1400                 TRACE_RET(chip, STATUS_FAIL);
1401
1402         retval = ms_set_rw_reg_addr(chip, OverwriteFlag, MS_EXTRA_SIZE,
1403                                 SystemParm, 7);
1404         if (retval != STATUS_SUCCESS)
1405                 TRACE_RET(chip, STATUS_FAIL);
1406
1407         ms_set_err_code(chip, MS_NO_ERROR);
1408
1409         if (CHK_MS4BIT(ms_card))
1410                 data[0] = 0x88;
1411         else
1412                 data[0] = 0x80;
1413
1414         data[1] = 0;
1415         data[2] = (u8)(phy_blk >> 8);
1416         data[3] = (u8)phy_blk;
1417         data[4] = 0x80;
1418         data[5] = 0;
1419         data[6] = extra[0] & 0x7F;
1420         data[7] = 0xFF;
1421
1422         retval = ms_write_bytes(chip, WRITE_REG, 7, NO_WAIT_INT, data, 7);
1423         if (retval != STATUS_SUCCESS)
1424                 TRACE_RET(chip, STATUS_FAIL);
1425
1426         retval = ms_send_cmd(chip, BLOCK_WRITE, WAIT_INT);
1427         if (retval != STATUS_SUCCESS)
1428                 TRACE_RET(chip, STATUS_FAIL);
1429
1430         ms_set_err_code(chip, MS_NO_ERROR);
1431         retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1);
1432         if (retval != STATUS_SUCCESS)
1433                 TRACE_RET(chip, STATUS_FAIL);
1434
1435         if (val & INT_REG_CMDNK) {
1436                 ms_set_err_code(chip, MS_CMD_NK);
1437                 TRACE_RET(chip, STATUS_FAIL);
1438         }
1439
1440         if (val & INT_REG_CED) {
1441                 if (val & INT_REG_ERR) {
1442                         ms_set_err_code(chip, MS_FLASH_WRITE_ERROR);
1443                         TRACE_RET(chip, STATUS_FAIL);
1444                 }
1445         }
1446
1447         return STATUS_SUCCESS;
1448 }
1449
1450
1451 static int ms_erase_block(struct rtsx_chip *chip, u16 phy_blk)
1452 {
1453         struct ms_info *ms_card = &(chip->ms_card);
1454         int retval, i = 0;
1455         u8 val, data[6];
1456
1457         retval = ms_set_rw_reg_addr(chip, OverwriteFlag, MS_EXTRA_SIZE,
1458                                 SystemParm, 6);
1459         if (retval != STATUS_SUCCESS)
1460                 TRACE_RET(chip, STATUS_FAIL);
1461
1462         ms_set_err_code(chip, MS_NO_ERROR);
1463
1464         if (CHK_MS4BIT(ms_card))
1465                 data[0] = 0x88;
1466         else
1467                 data[0] = 0x80;
1468
1469         data[1] = 0;
1470         data[2] = (u8)(phy_blk >> 8);
1471         data[3] = (u8)phy_blk;
1472         data[4] = 0;
1473         data[5] = 0;
1474
1475         retval = ms_write_bytes(chip, WRITE_REG, 6, NO_WAIT_INT, data, 6);
1476         if (retval != STATUS_SUCCESS)
1477                 TRACE_RET(chip, STATUS_FAIL);
1478
1479 ERASE_RTY:
1480         retval = ms_send_cmd(chip, BLOCK_ERASE, WAIT_INT);
1481         if (retval != STATUS_SUCCESS)
1482                 TRACE_RET(chip, STATUS_FAIL);
1483
1484         ms_set_err_code(chip, MS_NO_ERROR);
1485         retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1);
1486         if (retval != STATUS_SUCCESS)
1487                 TRACE_RET(chip, STATUS_FAIL);
1488
1489         if (val & INT_REG_CMDNK) {
1490                 if (i < 3) {
1491                         i++;
1492                         goto ERASE_RTY;
1493                 }
1494
1495                 ms_set_err_code(chip, MS_CMD_NK);
1496                 ms_set_bad_block(chip, phy_blk);
1497                 TRACE_RET(chip, STATUS_FAIL);
1498         }
1499
1500         if (val & INT_REG_CED) {
1501                 if (val & INT_REG_ERR) {
1502                         ms_set_err_code(chip, MS_FLASH_WRITE_ERROR);
1503                         TRACE_RET(chip, STATUS_FAIL);
1504                 }
1505         }
1506
1507         return STATUS_SUCCESS;
1508 }
1509
1510
1511 static void ms_set_page_status(u16 log_blk, u8 type, u8 *extra, int extra_len)
1512 {
1513         if (!extra || (extra_len < MS_EXTRA_SIZE))
1514                 return;
1515
1516         memset(extra, 0xFF, MS_EXTRA_SIZE);
1517
1518         if (type == setPS_NG) {
1519                 /* set page status as 1:NG,and block status keep 1:OK */
1520                 extra[0] = 0xB8;
1521         } else {
1522                 /* set page status as 0:Data Error,and block status keep 1:OK */
1523                 extra[0] = 0x98;
1524         }
1525
1526         extra[2] = (u8)(log_blk >> 8);
1527         extra[3] = (u8)log_blk;
1528 }
1529
1530 static int ms_init_page(struct rtsx_chip *chip, u16 phy_blk, u16 log_blk,
1531                         u8 start_page, u8 end_page)
1532 {
1533         int retval;
1534         u8 extra[MS_EXTRA_SIZE], i;
1535
1536         memset(extra, 0xff, MS_EXTRA_SIZE);
1537
1538         extra[0] = 0xf8;        /* Block, page OK, data erased */
1539         extra[1] = 0xff;
1540         extra[2] = (u8)(log_blk >> 8);
1541         extra[3] = (u8)log_blk;
1542
1543         for (i = start_page; i < end_page; i++) {
1544                 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {
1545                         ms_set_err_code(chip, MS_NO_CARD);
1546                         TRACE_RET(chip, STATUS_FAIL);
1547                 }
1548
1549                 retval = ms_write_extra_data(chip, phy_blk, i,
1550                                         extra, MS_EXTRA_SIZE);
1551                 if (retval != STATUS_SUCCESS)
1552                         TRACE_RET(chip, STATUS_FAIL);
1553         }
1554
1555         return STATUS_SUCCESS;
1556 }
1557
1558 static int ms_copy_page(struct rtsx_chip *chip, u16 old_blk, u16 new_blk,
1559                 u16 log_blk, u8 start_page, u8 end_page)
1560 {
1561         struct ms_info *ms_card = &(chip->ms_card);
1562         int retval, rty_cnt, uncorrect_flag = 0;
1563         u8 extra[MS_EXTRA_SIZE], val, i, j, data[16];
1564
1565         dev_dbg(rtsx_dev(chip), "Copy page from 0x%x to 0x%x, logical block is 0x%x\n",
1566                 old_blk, new_blk, log_blk);
1567         dev_dbg(rtsx_dev(chip), "start_page = %d, end_page = %d\n",
1568                 start_page, end_page);
1569
1570         retval = ms_read_extra_data(chip, new_blk, 0, extra, MS_EXTRA_SIZE);
1571         if (retval != STATUS_SUCCESS)
1572                 TRACE_RET(chip, STATUS_FAIL);
1573
1574         retval = ms_read_status_reg(chip);
1575         if (retval != STATUS_SUCCESS)
1576                 TRACE_RET(chip, STATUS_FAIL);
1577
1578         RTSX_READ_REG(chip, PPBUF_BASE2, &val);
1579
1580         if (val & BUF_FULL) {
1581                 retval = ms_send_cmd(chip, CLEAR_BUF, WAIT_INT);
1582                 if (retval != STATUS_SUCCESS)
1583                         TRACE_RET(chip, STATUS_FAIL);
1584
1585                 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1);
1586                 if (retval != STATUS_SUCCESS)
1587                         TRACE_RET(chip, STATUS_FAIL);
1588
1589                 if (!(val & INT_REG_CED)) {
1590                         ms_set_err_code(chip, MS_FLASH_WRITE_ERROR);
1591                         TRACE_RET(chip, STATUS_FAIL);
1592                 }
1593         }
1594
1595         for (i = start_page; i < end_page; i++) {
1596                 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {
1597                         ms_set_err_code(chip, MS_NO_CARD);
1598                         TRACE_RET(chip, STATUS_FAIL);
1599                 }
1600
1601                 ms_read_extra_data(chip, old_blk, i, extra, MS_EXTRA_SIZE);
1602
1603                 retval = ms_set_rw_reg_addr(chip, OverwriteFlag,
1604                                         MS_EXTRA_SIZE, SystemParm, 6);
1605                 if (retval != STATUS_SUCCESS)
1606                         TRACE_RET(chip, STATUS_FAIL);
1607
1608                 ms_set_err_code(chip, MS_NO_ERROR);
1609
1610                 if (CHK_MS4BIT(ms_card))
1611                         data[0] = 0x88;
1612                 else
1613                         data[0] = 0x80;
1614
1615                 data[1] = 0;
1616                 data[2] = (u8)(old_blk >> 8);
1617                 data[3] = (u8)old_blk;
1618                 data[4] = 0x20;
1619                 data[5] = i;
1620
1621                 retval = ms_write_bytes(chip, WRITE_REG , 6, NO_WAIT_INT,
1622                                         data, 6);
1623                 if (retval != STATUS_SUCCESS)
1624                         TRACE_RET(chip, STATUS_FAIL);
1625
1626                 retval = ms_send_cmd(chip, BLOCK_READ, WAIT_INT);
1627                 if (retval != STATUS_SUCCESS)
1628                         TRACE_RET(chip, STATUS_FAIL);
1629
1630                 ms_set_err_code(chip, MS_NO_ERROR);
1631                 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1);
1632                 if (retval != STATUS_SUCCESS)
1633                         TRACE_RET(chip, STATUS_FAIL);
1634
1635                 if (val & INT_REG_CMDNK) {
1636                         ms_set_err_code(chip, MS_CMD_NK);
1637                         TRACE_RET(chip, STATUS_FAIL);
1638                 }
1639
1640                 if (val & INT_REG_CED) {
1641                         if (val & INT_REG_ERR) {
1642                                 retval = ms_read_status_reg(chip);
1643                                 if (retval != STATUS_SUCCESS) {
1644                                         uncorrect_flag = 1;
1645                                         dev_dbg(rtsx_dev(chip), "Uncorrectable error\n");
1646                                 } else {
1647                                         uncorrect_flag = 0;
1648                                 }
1649
1650                                 retval = ms_transfer_tpc(chip,
1651                                                         MS_TM_NORMAL_READ,
1652                                                         READ_PAGE_DATA,
1653                                                         0, NO_WAIT_INT);
1654                                 if (retval != STATUS_SUCCESS)
1655                                         TRACE_RET(chip, STATUS_FAIL);
1656
1657                                 if (uncorrect_flag) {
1658                                         ms_set_page_status(log_blk, setPS_NG,
1659                                                         extra, MS_EXTRA_SIZE);
1660                                         if (i == 0)
1661                                                 extra[0] &= 0xEF;
1662
1663                                         ms_write_extra_data(chip, old_blk, i,
1664                                                         extra, MS_EXTRA_SIZE);
1665                                         dev_dbg(rtsx_dev(chip), "page %d : extra[0] = 0x%x\n",
1666                                                 i, extra[0]);
1667                                         MS_SET_BAD_BLOCK_FLG(ms_card);
1668
1669                                         ms_set_page_status(log_blk, setPS_Error,
1670                                                         extra, MS_EXTRA_SIZE);
1671                                         ms_write_extra_data(chip, new_blk, i,
1672                                                         extra, MS_EXTRA_SIZE);
1673                                         continue;
1674                                 }
1675
1676                                 for (rty_cnt = 0; rty_cnt < MS_MAX_RETRY_COUNT;
1677                                      rty_cnt++) {
1678                                         retval = ms_transfer_tpc(
1679                                                 chip,
1680                                                 MS_TM_NORMAL_WRITE,
1681                                                 WRITE_PAGE_DATA,
1682                                                 0, NO_WAIT_INT);
1683                                         if (retval == STATUS_SUCCESS)
1684                                                 break;
1685                                 }
1686                                 if (rty_cnt == MS_MAX_RETRY_COUNT)
1687                                         TRACE_RET(chip, STATUS_FAIL);
1688                         }
1689
1690                         if (!(val & INT_REG_BREQ)) {
1691                                 ms_set_err_code(chip, MS_BREQ_ERROR);
1692                                 TRACE_RET(chip, STATUS_FAIL);
1693                         }
1694                 }
1695
1696                 retval = ms_set_rw_reg_addr(chip, OverwriteFlag,
1697                                 MS_EXTRA_SIZE, SystemParm, (6+MS_EXTRA_SIZE));
1698
1699                 ms_set_err_code(chip, MS_NO_ERROR);
1700
1701                 if (CHK_MS4BIT(ms_card))
1702                         data[0] = 0x88;
1703                 else
1704                         data[0] = 0x80;
1705
1706                 data[1] = 0;
1707                 data[2] = (u8)(new_blk >> 8);
1708                 data[3] = (u8)new_blk;
1709                 data[4] = 0x20;
1710                 data[5] = i;
1711
1712                 if ((extra[0] & 0x60) != 0x60)
1713                         data[6] = extra[0];
1714                 else
1715                         data[6] = 0xF8;
1716
1717                 data[6 + 1] = 0xFF;
1718                 data[6 + 2] = (u8)(log_blk >> 8);
1719                 data[6 + 3] = (u8)log_blk;
1720
1721                 for (j = 4; j <= MS_EXTRA_SIZE; j++)
1722                         data[6 + j] = 0xFF;
1723
1724                 retval = ms_write_bytes(chip, WRITE_REG, (6 + MS_EXTRA_SIZE),
1725                                         NO_WAIT_INT, data, 16);
1726                 if (retval != STATUS_SUCCESS)
1727                         TRACE_RET(chip, STATUS_FAIL);
1728
1729                 retval = ms_send_cmd(chip, BLOCK_WRITE, WAIT_INT);
1730                 if (retval != STATUS_SUCCESS)
1731                         TRACE_RET(chip, STATUS_FAIL);
1732
1733                 ms_set_err_code(chip, MS_NO_ERROR);
1734                 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1);
1735                 if (retval != STATUS_SUCCESS)
1736                         TRACE_RET(chip, STATUS_FAIL);
1737
1738                 if (val & INT_REG_CMDNK) {
1739                         ms_set_err_code(chip, MS_CMD_NK);
1740                         TRACE_RET(chip, STATUS_FAIL);
1741                 }
1742
1743                 if (val & INT_REG_CED) {
1744                         if (val & INT_REG_ERR) {
1745                                 ms_set_err_code(chip, MS_FLASH_WRITE_ERROR);
1746                                 TRACE_RET(chip, STATUS_FAIL);
1747                         }
1748                 }
1749
1750                 if (i == 0) {
1751                         retval = ms_set_rw_reg_addr(chip, OverwriteFlag,
1752                                                 MS_EXTRA_SIZE, SystemParm, 7);
1753                         if (retval != STATUS_SUCCESS)
1754                                 TRACE_RET(chip, STATUS_FAIL);
1755
1756                         ms_set_err_code(chip, MS_NO_ERROR);
1757
1758                         if (CHK_MS4BIT(ms_card))
1759                                 data[0] = 0x88;
1760                         else
1761                                 data[0] = 0x80;
1762
1763                         data[1] = 0;
1764                         data[2] = (u8)(old_blk >> 8);
1765                         data[3] = (u8)old_blk;
1766                         data[4] = 0x80;
1767                         data[5] = 0;
1768                         data[6] = 0xEF;
1769                         data[7] = 0xFF;
1770
1771                         retval = ms_write_bytes(chip, WRITE_REG, 7,
1772                                                 NO_WAIT_INT, data, 8);
1773                         if (retval != STATUS_SUCCESS)
1774                                 TRACE_RET(chip, STATUS_FAIL);
1775
1776                         retval = ms_send_cmd(chip, BLOCK_WRITE, WAIT_INT);
1777                         if (retval != STATUS_SUCCESS)
1778                                 TRACE_RET(chip, STATUS_FAIL);
1779
1780                         ms_set_err_code(chip, MS_NO_ERROR);
1781                         retval = ms_read_bytes(chip, GET_INT, 1,
1782                                         NO_WAIT_INT, &val, 1);
1783                         if (retval != STATUS_SUCCESS)
1784                                 TRACE_RET(chip, STATUS_FAIL);
1785
1786                         if (val & INT_REG_CMDNK) {
1787                                 ms_set_err_code(chip, MS_CMD_NK);
1788                                 TRACE_RET(chip, STATUS_FAIL);
1789                         }
1790
1791                         if (val & INT_REG_CED) {
1792                                 if (val & INT_REG_ERR) {
1793                                         ms_set_err_code(chip,
1794                                                         MS_FLASH_WRITE_ERROR);
1795                                         TRACE_RET(chip, STATUS_FAIL);
1796                                 }
1797                         }
1798                 }
1799         }
1800
1801         return STATUS_SUCCESS;
1802 }
1803
1804
1805 static int reset_ms(struct rtsx_chip *chip)
1806 {
1807         struct ms_info *ms_card = &(chip->ms_card);
1808         int retval;
1809         u16 i, reg_addr, block_size;
1810         u8 val, extra[MS_EXTRA_SIZE], j, *ptr;
1811 #ifndef SUPPORT_MAGIC_GATE
1812         u16 eblock_cnt;
1813 #endif
1814
1815         retval = ms_prepare_reset(chip);
1816         if (retval != STATUS_SUCCESS)
1817                 TRACE_RET(chip, STATUS_FAIL);
1818
1819         ms_card->ms_type |= TYPE_MS;
1820
1821         retval = ms_send_cmd(chip, MS_RESET, NO_WAIT_INT);
1822         if (retval != STATUS_SUCCESS)
1823                 TRACE_RET(chip, STATUS_FAIL);
1824
1825         retval = ms_read_status_reg(chip);
1826         if (retval != STATUS_SUCCESS)
1827                 TRACE_RET(chip, STATUS_FAIL);
1828
1829         RTSX_READ_REG(chip, PPBUF_BASE2, &val);
1830         if (val & WRT_PRTCT)
1831                 chip->card_wp |= MS_CARD;
1832         else
1833                 chip->card_wp &= ~MS_CARD;
1834
1835         i = 0;
1836
1837 RE_SEARCH:
1838         /* Search Boot Block */
1839         while (i < (MAX_DEFECTIVE_BLOCK + 2)) {
1840                 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {
1841                         ms_set_err_code(chip, MS_NO_CARD);
1842                         TRACE_RET(chip, STATUS_FAIL);
1843                 }
1844
1845                 retval = ms_read_extra_data(chip, i, 0, extra, MS_EXTRA_SIZE);
1846                 if (retval != STATUS_SUCCESS) {
1847                         i++;
1848                         continue;
1849                 }
1850
1851                 if (extra[0] & BLOCK_OK) {
1852                         if (!(extra[1] & NOT_BOOT_BLOCK)) {
1853                                 ms_card->boot_block = i;
1854                                 break;
1855                         }
1856                 }
1857                 i++;
1858         }
1859
1860         if (i == (MAX_DEFECTIVE_BLOCK + 2)) {
1861                 dev_dbg(rtsx_dev(chip), "No boot block found!");
1862                 TRACE_RET(chip, STATUS_FAIL);
1863         }
1864
1865         for (j = 0; j < 3; j++) {
1866                 retval = ms_read_page(chip, ms_card->boot_block, j);
1867                 if (retval != STATUS_SUCCESS) {
1868                         if (ms_check_err_code(chip, MS_FLASH_WRITE_ERROR)) {
1869                                 i = ms_card->boot_block + 1;
1870                                 ms_set_err_code(chip, MS_NO_ERROR);
1871                                 goto RE_SEARCH;
1872                         }
1873                 }
1874         }
1875
1876         retval = ms_read_page(chip, ms_card->boot_block, 0);
1877         if (retval != STATUS_SUCCESS)
1878                 TRACE_RET(chip, STATUS_FAIL);
1879
1880         /* Read MS system information as sys_info */
1881         rtsx_init_cmd(chip);
1882
1883         for (i = 0; i < 96; i++)
1884                 rtsx_add_cmd(chip, READ_REG_CMD, PPBUF_BASE2 + 0x1A0 + i, 0, 0);
1885
1886         retval = rtsx_send_cmd(chip, MS_CARD, 100);
1887         if (retval < 0)
1888                 TRACE_RET(chip, STATUS_FAIL);
1889
1890         ptr = rtsx_get_cmd_data(chip);
1891         memcpy(ms_card->raw_sys_info, ptr, 96);
1892
1893         /* Read useful block contents */
1894         rtsx_init_cmd(chip);
1895
1896         rtsx_add_cmd(chip, READ_REG_CMD, HEADER_ID0, 0, 0);
1897         rtsx_add_cmd(chip, READ_REG_CMD, HEADER_ID1, 0, 0);
1898
1899         for (reg_addr = DISABLED_BLOCK0; reg_addr <= DISABLED_BLOCK3;
1900              reg_addr++)
1901                 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0, 0);
1902
1903         for (reg_addr = BLOCK_SIZE_0; reg_addr <= PAGE_SIZE_1; reg_addr++)
1904                 rtsx_add_cmd(chip, READ_REG_CMD, reg_addr, 0, 0);
1905
1906         rtsx_add_cmd(chip, READ_REG_CMD, MS_Device_Type, 0, 0);
1907         rtsx_add_cmd(chip, READ_REG_CMD, MS_4bit_Support, 0, 0);
1908
1909         retval = rtsx_send_cmd(chip, MS_CARD, 100);
1910         if (retval < 0)
1911                 TRACE_RET(chip, STATUS_FAIL);
1912
1913         ptr = rtsx_get_cmd_data(chip);
1914
1915         dev_dbg(rtsx_dev(chip), "Boot block data:\n");
1916         RTSX_DUMP(ptr, 16);
1917
1918         /* Block ID error
1919          * HEADER_ID0, HEADER_ID1
1920          */
1921         if (ptr[0] != 0x00 || ptr[1] != 0x01) {
1922                 i = ms_card->boot_block + 1;
1923                 goto RE_SEARCH;
1924         }
1925
1926         /* Page size error
1927          * PAGE_SIZE_0, PAGE_SIZE_1
1928          */
1929         if (ptr[12] != 0x02 || ptr[13] != 0x00) {
1930                 i = ms_card->boot_block + 1;
1931                 goto RE_SEARCH;
1932         }
1933
1934         if ((ptr[14] == 1) || (ptr[14] == 3))
1935                 chip->card_wp |= MS_CARD;
1936
1937         /* BLOCK_SIZE_0, BLOCK_SIZE_1 */
1938         block_size = ((u16)ptr[6] << 8) | ptr[7];
1939         if (block_size == 0x0010) {
1940                 /* Block size 16KB */
1941                 ms_card->block_shift = 5;
1942                 ms_card->page_off = 0x1F;
1943         } else if (block_size == 0x0008) {
1944                 /* Block size 8KB */
1945                 ms_card->block_shift = 4;
1946                 ms_card->page_off = 0x0F;
1947         }
1948
1949         /* BLOCK_COUNT_0, BLOCK_COUNT_1 */
1950         ms_card->total_block = ((u16)ptr[8] << 8) | ptr[9];
1951
1952 #ifdef SUPPORT_MAGIC_GATE
1953         j = ptr[10];
1954
1955         if (ms_card->block_shift == 4)  { /* 4MB or 8MB */
1956                 if (j < 2)  { /* Effective block for 4MB: 0x1F0 */
1957                         ms_card->capacity = 0x1EE0;
1958                 } else { /* Effective block for 8MB: 0x3E0 */
1959                         ms_card->capacity = 0x3DE0;
1960                 }
1961         } else  { /* 16MB, 32MB, 64MB or 128MB */
1962                 if (j < 5)  { /* Effective block for 16MB: 0x3E0 */
1963                         ms_card->capacity = 0x7BC0;
1964                 } else if (j < 0xA) { /* Effective block for 32MB: 0x7C0 */
1965                         ms_card->capacity = 0xF7C0;
1966                 } else if (j < 0x11) { /* Effective block for 64MB: 0xF80 */
1967                         ms_card->capacity = 0x1EF80;
1968                 } else { /* Effective block for 128MB: 0x1F00 */
1969                         ms_card->capacity = 0x3DF00;
1970                 }
1971         }
1972 #else
1973         /* EBLOCK_COUNT_0, EBLOCK_COUNT_1 */
1974         eblock_cnt = ((u16)ptr[10] << 8) | ptr[11];
1975
1976         ms_card->capacity = ((u32)eblock_cnt - 2) << ms_card->block_shift;
1977 #endif
1978
1979         chip->capacity[chip->card2lun[MS_CARD]] = ms_card->capacity;
1980
1981         /* Switch I/F Mode */
1982         if (ptr[15]) {
1983                 retval = ms_set_rw_reg_addr(chip, 0, 0, SystemParm, 1);
1984                 if (retval != STATUS_SUCCESS)
1985                         TRACE_RET(chip, STATUS_FAIL);
1986
1987                 RTSX_WRITE_REG(chip, PPBUF_BASE2, 0xFF, 0x88);
1988                 RTSX_WRITE_REG(chip, PPBUF_BASE2 + 1, 0xFF, 0);
1989
1990                 retval = ms_transfer_tpc(chip, MS_TM_WRITE_BYTES, WRITE_REG , 1,
1991                                         NO_WAIT_INT);
1992                 if (retval != STATUS_SUCCESS)
1993                         TRACE_RET(chip, STATUS_FAIL);
1994
1995                 RTSX_WRITE_REG(chip, MS_CFG, 0x58 | MS_NO_CHECK_INT,
1996                         MS_BUS_WIDTH_4 | PUSH_TIME_ODD | MS_NO_CHECK_INT);
1997
1998                 ms_card->ms_type |= MS_4BIT;
1999         }
2000
2001         if (CHK_MS4BIT(ms_card))
2002                 chip->card_bus_width[chip->card2lun[MS_CARD]] = 4;
2003         else
2004                 chip->card_bus_width[chip->card2lun[MS_CARD]] = 1;
2005
2006         return STATUS_SUCCESS;
2007 }
2008
2009 static int ms_init_l2p_tbl(struct rtsx_chip *chip)
2010 {
2011         struct ms_info *ms_card = &(chip->ms_card);
2012         int size, i, seg_no, retval;
2013         u16 defect_block, reg_addr;
2014         u8 val1, val2;
2015
2016         ms_card->segment_cnt = ms_card->total_block >> 9;
2017         dev_dbg(rtsx_dev(chip), "ms_card->segment_cnt = %d\n",
2018                 ms_card->segment_cnt);
2019
2020         size = ms_card->segment_cnt * sizeof(struct zone_entry);
2021         ms_card->segment = vzalloc(size);
2022         if (ms_card->segment == NULL)
2023                 TRACE_RET(chip, STATUS_FAIL);
2024
2025         retval = ms_read_page(chip, ms_card->boot_block, 1);
2026         if (retval != STATUS_SUCCESS)
2027                 TRACE_GOTO(chip, INIT_FAIL);
2028
2029         reg_addr = PPBUF_BASE2;
2030         for (i = 0; i < (((ms_card->total_block >> 9) * 10) + 1); i++) {
2031                 retval = rtsx_read_register(chip, reg_addr++, &val1);
2032                 if (retval != STATUS_SUCCESS)
2033                         TRACE_GOTO(chip, INIT_FAIL);
2034
2035                 retval = rtsx_read_register(chip, reg_addr++, &val2);
2036                 if (retval != STATUS_SUCCESS)
2037                         TRACE_GOTO(chip, INIT_FAIL);
2038
2039                 defect_block = ((u16)val1 << 8) | val2;
2040                 if (defect_block == 0xFFFF)
2041                         break;
2042
2043                 seg_no = defect_block / 512;
2044                 ms_card->segment[seg_no].defect_list[ms_card->segment[seg_no].disable_count++] = defect_block;
2045         }
2046
2047         for (i = 0; i < ms_card->segment_cnt; i++) {
2048                 ms_card->segment[i].build_flag = 0;
2049                 ms_card->segment[i].l2p_table = NULL;
2050                 ms_card->segment[i].free_table = NULL;
2051                 ms_card->segment[i].get_index = 0;
2052                 ms_card->segment[i].set_index = 0;
2053                 ms_card->segment[i].unused_blk_cnt = 0;
2054
2055                 dev_dbg(rtsx_dev(chip), "defective block count of segment %d is %d\n",
2056                         i, ms_card->segment[i].disable_count);
2057         }
2058
2059         return STATUS_SUCCESS;
2060
2061 INIT_FAIL:
2062         if (ms_card->segment) {
2063                 vfree(ms_card->segment);
2064                 ms_card->segment = NULL;
2065         }
2066
2067         return STATUS_FAIL;
2068 }
2069
2070 static u16 ms_get_l2p_tbl(struct rtsx_chip *chip, int seg_no, u16 log_off)
2071 {
2072         struct ms_info *ms_card = &(chip->ms_card);
2073         struct zone_entry *segment;
2074
2075         if (ms_card->segment == NULL)
2076                 return 0xFFFF;
2077
2078         segment = &(ms_card->segment[seg_no]);
2079
2080         if (segment->l2p_table)
2081                 return segment->l2p_table[log_off];
2082
2083         return 0xFFFF;
2084 }
2085
2086 static void ms_set_l2p_tbl(struct rtsx_chip *chip,
2087                         int seg_no, u16 log_off, u16 phy_blk)
2088 {
2089         struct ms_info *ms_card = &(chip->ms_card);
2090         struct zone_entry *segment;
2091
2092         if (ms_card->segment == NULL)
2093                 return;
2094
2095         segment = &(ms_card->segment[seg_no]);
2096         if (segment->l2p_table)
2097                 segment->l2p_table[log_off] = phy_blk;
2098 }
2099
2100 static void ms_set_unused_block(struct rtsx_chip *chip, u16 phy_blk)
2101 {
2102         struct ms_info *ms_card = &(chip->ms_card);
2103         struct zone_entry *segment;
2104         int seg_no;
2105
2106         seg_no = (int)phy_blk >> 9;
2107         segment = &(ms_card->segment[seg_no]);
2108
2109         segment->free_table[segment->set_index++] = phy_blk;
2110         if (segment->set_index >= MS_FREE_TABLE_CNT)
2111                 segment->set_index = 0;
2112
2113         segment->unused_blk_cnt++;
2114 }
2115
2116 static u16 ms_get_unused_block(struct rtsx_chip *chip, int seg_no)
2117 {
2118         struct ms_info *ms_card = &(chip->ms_card);
2119         struct zone_entry *segment;
2120         u16 phy_blk;
2121
2122         segment = &(ms_card->segment[seg_no]);
2123
2124         if (segment->unused_blk_cnt <= 0)
2125                 return 0xFFFF;
2126
2127         phy_blk = segment->free_table[segment->get_index];
2128         segment->free_table[segment->get_index++] = 0xFFFF;
2129         if (segment->get_index >= MS_FREE_TABLE_CNT)
2130                 segment->get_index = 0;
2131
2132         segment->unused_blk_cnt--;
2133
2134         return phy_blk;
2135 }
2136
2137 static const unsigned short ms_start_idx[] = {0, 494, 990, 1486, 1982, 2478,
2138                                               2974, 3470, 3966, 4462, 4958,
2139                                               5454, 5950, 6446, 6942, 7438,
2140                                               7934};
2141
2142 static int ms_arbitrate_l2p(struct rtsx_chip *chip, u16 phy_blk,
2143                         u16 log_off, u8 us1, u8 us2)
2144 {
2145         struct ms_info *ms_card = &(chip->ms_card);
2146         struct zone_entry *segment;
2147         int seg_no;
2148         u16 tmp_blk;
2149
2150         seg_no = (int)phy_blk >> 9;
2151         segment = &(ms_card->segment[seg_no]);
2152         tmp_blk = segment->l2p_table[log_off];
2153
2154         if (us1 != us2) {
2155                 if (us1 == 0) {
2156                         if (!(chip->card_wp & MS_CARD))
2157                                 ms_erase_block(chip, tmp_blk);
2158
2159                         ms_set_unused_block(chip, tmp_blk);
2160                         segment->l2p_table[log_off] = phy_blk;
2161                 } else {
2162                         if (!(chip->card_wp & MS_CARD))
2163                                 ms_erase_block(chip, phy_blk);
2164
2165                         ms_set_unused_block(chip, phy_blk);
2166                 }
2167         } else {
2168                 if (phy_blk < tmp_blk) {
2169                         if (!(chip->card_wp & MS_CARD))
2170                                 ms_erase_block(chip, phy_blk);
2171
2172                         ms_set_unused_block(chip, phy_blk);
2173                 } else {
2174                         if (!(chip->card_wp & MS_CARD))
2175                                 ms_erase_block(chip, tmp_blk);
2176
2177                         ms_set_unused_block(chip, tmp_blk);
2178                         segment->l2p_table[log_off] = phy_blk;
2179                 }
2180         }
2181
2182         return STATUS_SUCCESS;
2183 }
2184
2185 static int ms_build_l2p_tbl(struct rtsx_chip *chip, int seg_no)
2186 {
2187         struct ms_info *ms_card = &(chip->ms_card);
2188         struct zone_entry *segment;
2189         int retval, table_size, disable_cnt, defect_flag, i;
2190         u16 start, end, phy_blk, log_blk, tmp_blk;
2191         u8 extra[MS_EXTRA_SIZE], us1, us2;
2192
2193         dev_dbg(rtsx_dev(chip), "ms_build_l2p_tbl: %d\n", seg_no);
2194
2195         if (ms_card->segment == NULL) {
2196                 retval = ms_init_l2p_tbl(chip);
2197                 if (retval != STATUS_SUCCESS)
2198                         TRACE_RET(chip, retval);
2199         }
2200
2201         if (ms_card->segment[seg_no].build_flag) {
2202                 dev_dbg(rtsx_dev(chip), "l2p table of segment %d has been built\n",
2203                         seg_no);
2204                 return STATUS_SUCCESS;
2205         }
2206
2207         if (seg_no == 0)
2208                 table_size = 494;
2209         else
2210                 table_size = 496;
2211
2212         segment = &(ms_card->segment[seg_no]);
2213
2214         if (segment->l2p_table == NULL) {
2215                 segment->l2p_table = vmalloc(table_size * 2);
2216                 if (segment->l2p_table == NULL)
2217                         TRACE_GOTO(chip, BUILD_FAIL);
2218         }
2219         memset((u8 *)(segment->l2p_table), 0xff, table_size * 2);
2220
2221         if (segment->free_table == NULL) {
2222                 segment->free_table = vmalloc(MS_FREE_TABLE_CNT * 2);
2223                 if (segment->free_table == NULL)
2224                         TRACE_GOTO(chip, BUILD_FAIL);
2225         }
2226         memset((u8 *)(segment->free_table), 0xff, MS_FREE_TABLE_CNT * 2);
2227
2228         start = (u16)seg_no << 9;
2229         end = (u16)(seg_no + 1) << 9;
2230
2231         disable_cnt = segment->disable_count;
2232
2233         segment->get_index = segment->set_index = 0;
2234         segment->unused_blk_cnt = 0;
2235
2236         for (phy_blk = start; phy_blk < end; phy_blk++) {
2237                 if (disable_cnt) {
2238                         defect_flag = 0;
2239                         for (i = 0; i < segment->disable_count; i++) {
2240                                 if (phy_blk == segment->defect_list[i]) {
2241                                         defect_flag = 1;
2242                                         break;
2243                                 }
2244                         }
2245                         if (defect_flag) {
2246                                 disable_cnt--;
2247                                 continue;
2248                         }
2249                 }
2250
2251                 retval = ms_read_extra_data(chip, phy_blk, 0,
2252                                         extra, MS_EXTRA_SIZE);
2253                 if (retval != STATUS_SUCCESS) {
2254                         dev_dbg(rtsx_dev(chip), "read extra data fail\n");
2255                         ms_set_bad_block(chip, phy_blk);
2256                         continue;
2257                 }
2258
2259                 if (seg_no == ms_card->segment_cnt - 1) {
2260                         if (!(extra[1] & NOT_TRANSLATION_TABLE)) {
2261                                 if (!(chip->card_wp & MS_CARD)) {
2262                                         retval = ms_erase_block(chip, phy_blk);
2263                                         if (retval != STATUS_SUCCESS)
2264                                                 continue;
2265                                         extra[2] = 0xff;
2266                                         extra[3] = 0xff;
2267                                 }
2268                         }
2269                 }
2270
2271                 if (!(extra[0] & BLOCK_OK))
2272                         continue;
2273                 if (!(extra[1] & NOT_BOOT_BLOCK))
2274                         continue;
2275                 if ((extra[0] & PAGE_OK) != PAGE_OK)
2276                         continue;
2277
2278                 log_blk = ((u16)extra[2] << 8) | extra[3];
2279
2280                 if (log_blk == 0xFFFF) {
2281                         if (!(chip->card_wp & MS_CARD)) {
2282                                 retval = ms_erase_block(chip, phy_blk);
2283                                 if (retval != STATUS_SUCCESS)
2284                                         continue;
2285                         }
2286                         ms_set_unused_block(chip, phy_blk);
2287                         continue;
2288                 }
2289
2290                 if ((log_blk < ms_start_idx[seg_no]) ||
2291                                 (log_blk >= ms_start_idx[seg_no+1])) {
2292                         if (!(chip->card_wp & MS_CARD)) {
2293                                 retval = ms_erase_block(chip, phy_blk);
2294                                 if (retval != STATUS_SUCCESS)
2295                                         continue;
2296                         }
2297                         ms_set_unused_block(chip, phy_blk);
2298                         continue;
2299                 }
2300
2301                 if (segment->l2p_table[log_blk - ms_start_idx[seg_no]] == 0xFFFF) {
2302                         segment->l2p_table[log_blk - ms_start_idx[seg_no]] = phy_blk;
2303                         continue;
2304                 }
2305
2306                 us1 = extra[0] & 0x10;
2307                 tmp_blk = segment->l2p_table[log_blk - ms_start_idx[seg_no]];
2308                 retval = ms_read_extra_data(chip, tmp_blk, 0,
2309                                         extra, MS_EXTRA_SIZE);
2310                 if (retval != STATUS_SUCCESS)
2311                         continue;
2312                 us2 = extra[0] & 0x10;
2313
2314                 (void)ms_arbitrate_l2p(chip, phy_blk,
2315                                 log_blk-ms_start_idx[seg_no], us1, us2);
2316                 continue;
2317         }
2318
2319         segment->build_flag = 1;
2320
2321         dev_dbg(rtsx_dev(chip), "unused block count: %d\n",
2322                 segment->unused_blk_cnt);
2323
2324         /* Logical Address Confirmation Process */
2325         if (seg_no == ms_card->segment_cnt - 1) {
2326                 if (segment->unused_blk_cnt < 2)
2327                         chip->card_wp |= MS_CARD;
2328         } else {
2329                 if (segment->unused_blk_cnt < 1)
2330                         chip->card_wp |= MS_CARD;
2331         }
2332
2333         if (chip->card_wp & MS_CARD)
2334                 return STATUS_SUCCESS;
2335
2336         for (log_blk = ms_start_idx[seg_no];
2337              log_blk < ms_start_idx[seg_no + 1]; log_blk++) {
2338                 if (segment->l2p_table[log_blk-ms_start_idx[seg_no]] == 0xFFFF) {
2339                         phy_blk = ms_get_unused_block(chip, seg_no);
2340                         if (phy_blk == 0xFFFF) {
2341                                 chip->card_wp |= MS_CARD;
2342                                 return STATUS_SUCCESS;
2343                         }
2344                         retval = ms_init_page(chip, phy_blk, log_blk, 0, 1);
2345                         if (retval != STATUS_SUCCESS)
2346                                 TRACE_GOTO(chip, BUILD_FAIL);
2347
2348                         segment->l2p_table[log_blk-ms_start_idx[seg_no]] = phy_blk;
2349                         if (seg_no == ms_card->segment_cnt - 1) {
2350                                 if (segment->unused_blk_cnt < 2) {
2351                                         chip->card_wp |= MS_CARD;
2352                                         return STATUS_SUCCESS;
2353                                 }
2354                         } else {
2355                                 if (segment->unused_blk_cnt < 1) {
2356                                         chip->card_wp |= MS_CARD;
2357                                         return STATUS_SUCCESS;
2358                                 }
2359                         }
2360                 }
2361         }
2362
2363         /* Make boot block be the first normal block */
2364         if (seg_no == 0) {
2365                 for (log_blk = 0; log_blk < 494; log_blk++) {
2366                         tmp_blk = segment->l2p_table[log_blk];
2367                         if (tmp_blk < ms_card->boot_block) {
2368                                 dev_dbg(rtsx_dev(chip), "Boot block is not the first normal block.\n");
2369
2370                                 if (chip->card_wp & MS_CARD)
2371                                         break;
2372
2373                                 phy_blk = ms_get_unused_block(chip, 0);
2374                                 retval = ms_copy_page(chip, tmp_blk, phy_blk,
2375                                                 log_blk, 0, ms_card->page_off + 1);
2376                                 if (retval != STATUS_SUCCESS)
2377                                         TRACE_RET(chip, STATUS_FAIL);
2378
2379                                 segment->l2p_table[log_blk] = phy_blk;
2380
2381                                 retval = ms_set_bad_block(chip, tmp_blk);
2382                                 if (retval != STATUS_SUCCESS)
2383                                         TRACE_RET(chip, STATUS_FAIL);
2384                         }
2385                 }
2386         }
2387
2388         return STATUS_SUCCESS;
2389
2390 BUILD_FAIL:
2391         segment->build_flag = 0;
2392         if (segment->l2p_table) {
2393                 vfree(segment->l2p_table);
2394                 segment->l2p_table = NULL;
2395         }
2396         if (segment->free_table) {
2397                 vfree(segment->free_table);
2398                 segment->free_table = NULL;
2399         }
2400
2401         return STATUS_FAIL;
2402 }
2403
2404
2405 int reset_ms_card(struct rtsx_chip *chip)
2406 {
2407         struct ms_info *ms_card = &(chip->ms_card);
2408         int retval;
2409
2410         memset(ms_card, 0, sizeof(struct ms_info));
2411
2412         retval = enable_card_clock(chip, MS_CARD);
2413         if (retval != STATUS_SUCCESS)
2414                 TRACE_RET(chip, STATUS_FAIL);
2415
2416         retval = select_card(chip, MS_CARD);
2417         if (retval != STATUS_SUCCESS)
2418                 TRACE_RET(chip, STATUS_FAIL);
2419
2420         ms_card->ms_type = 0;
2421
2422         retval = reset_ms_pro(chip);
2423         if (retval != STATUS_SUCCESS) {
2424                 if (ms_card->check_ms_flow) {
2425                         retval = reset_ms(chip);
2426                         if (retval != STATUS_SUCCESS)
2427                                 TRACE_RET(chip, STATUS_FAIL);
2428                 } else {
2429                         TRACE_RET(chip, STATUS_FAIL);
2430                 }
2431         }
2432
2433         retval = ms_set_init_para(chip);
2434         if (retval != STATUS_SUCCESS)
2435                 TRACE_RET(chip, STATUS_FAIL);
2436
2437         if (!CHK_MSPRO(ms_card)) {
2438                 /* Build table for the last segment,
2439                  * to check if L2P table block exists, erasing it
2440                  */
2441                 retval = ms_build_l2p_tbl(chip, ms_card->total_block / 512 - 1);
2442                 if (retval != STATUS_SUCCESS)
2443                         TRACE_RET(chip, STATUS_FAIL);
2444         }
2445
2446         dev_dbg(rtsx_dev(chip), "ms_card->ms_type = 0x%x\n", ms_card->ms_type);
2447
2448         return STATUS_SUCCESS;
2449 }
2450
2451 static int mspro_set_rw_cmd(struct rtsx_chip *chip,
2452                         u32 start_sec, u16 sec_cnt, u8 cmd)
2453 {
2454         int retval, i;
2455         u8 data[8];
2456
2457         data[0] = cmd;
2458         data[1] = (u8)(sec_cnt >> 8);
2459         data[2] = (u8)sec_cnt;
2460         data[3] = (u8)(start_sec >> 24);
2461         data[4] = (u8)(start_sec >> 16);
2462         data[5] = (u8)(start_sec >> 8);
2463         data[6] = (u8)start_sec;
2464         data[7] = 0;
2465
2466         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
2467                 retval = ms_write_bytes(chip, PRO_EX_SET_CMD, 7,
2468                                         WAIT_INT, data, 8);
2469                 if (retval == STATUS_SUCCESS)
2470                         break;
2471         }
2472         if (i == MS_MAX_RETRY_COUNT)
2473                 TRACE_RET(chip, STATUS_FAIL);
2474
2475         return STATUS_SUCCESS;
2476 }
2477
2478
2479 void mspro_stop_seq_mode(struct rtsx_chip *chip)
2480 {
2481         struct ms_info *ms_card = &(chip->ms_card);
2482         int retval;
2483
2484         if (ms_card->seq_mode) {
2485                 retval = ms_switch_clock(chip);
2486                 if (retval != STATUS_SUCCESS)
2487                         return;
2488
2489                 ms_card->seq_mode = 0;
2490                 ms_card->total_sec_cnt = 0;
2491                 ms_send_cmd(chip, PRO_STOP, WAIT_INT);
2492
2493                 rtsx_write_register(chip, RBCTL, RB_FLUSH, RB_FLUSH);
2494         }
2495 }
2496
2497 static inline int ms_auto_tune_clock(struct rtsx_chip *chip)
2498 {
2499         struct ms_info *ms_card = &(chip->ms_card);
2500         int retval;
2501
2502         if (chip->asic_code) {
2503                 if (ms_card->ms_clock > 30)
2504                         ms_card->ms_clock -= 20;
2505         } else {
2506                 if (ms_card->ms_clock == CLK_80)
2507                         ms_card->ms_clock = CLK_60;
2508                 else if (ms_card->ms_clock == CLK_60)
2509                         ms_card->ms_clock = CLK_40;
2510         }
2511
2512         retval = ms_switch_clock(chip);
2513         if (retval != STATUS_SUCCESS)
2514                 TRACE_RET(chip, STATUS_FAIL);
2515
2516         return STATUS_SUCCESS;
2517 }
2518
2519 static int mspro_rw_multi_sector(struct scsi_cmnd *srb,
2520                                 struct rtsx_chip *chip, u32 start_sector,
2521                                 u16 sector_cnt)
2522 {
2523         struct ms_info *ms_card = &(chip->ms_card);
2524         int retval, mode_2k = 0;
2525         u16 count;
2526         u8 val, trans_mode, rw_tpc, rw_cmd;
2527
2528         ms_set_err_code(chip, MS_NO_ERROR);
2529
2530         ms_card->cleanup_counter = 0;
2531
2532         if (CHK_MSHG(ms_card)) {
2533                 if ((start_sector % 4) || (sector_cnt % 4)) {
2534                         if (srb->sc_data_direction == DMA_FROM_DEVICE) {
2535                                 rw_tpc = PRO_READ_LONG_DATA;
2536                                 rw_cmd = PRO_READ_DATA;
2537                         } else {
2538                                 rw_tpc = PRO_WRITE_LONG_DATA;
2539                                 rw_cmd = PRO_WRITE_DATA;
2540                         }
2541                 } else {
2542                         if (srb->sc_data_direction == DMA_FROM_DEVICE) {
2543                                 rw_tpc = PRO_READ_QUAD_DATA;
2544                                 rw_cmd = PRO_READ_2K_DATA;
2545                         } else {
2546                                 rw_tpc = PRO_WRITE_QUAD_DATA;
2547                                 rw_cmd = PRO_WRITE_2K_DATA;
2548                         }
2549                         mode_2k = 1;
2550                 }
2551         } else {
2552                 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
2553                         rw_tpc = PRO_READ_LONG_DATA;
2554                         rw_cmd = PRO_READ_DATA;
2555                 } else {
2556                         rw_tpc = PRO_WRITE_LONG_DATA;
2557                         rw_cmd = PRO_WRITE_DATA;
2558                 }
2559         }
2560
2561         retval = ms_switch_clock(chip);
2562         if (retval != STATUS_SUCCESS)
2563                 TRACE_RET(chip, STATUS_FAIL);
2564
2565         if (srb->sc_data_direction == DMA_FROM_DEVICE)
2566                 trans_mode = MS_TM_AUTO_READ;
2567         else
2568                 trans_mode = MS_TM_AUTO_WRITE;
2569
2570         RTSX_READ_REG(chip, MS_TRANS_CFG, &val);
2571
2572         if (ms_card->seq_mode) {
2573                 if ((ms_card->pre_dir != srb->sc_data_direction)
2574                                 || ((ms_card->pre_sec_addr + ms_card->pre_sec_cnt) != start_sector)
2575                                 || (mode_2k && (ms_card->seq_mode & MODE_512_SEQ))
2576                                 || (!mode_2k && (ms_card->seq_mode & MODE_2K_SEQ))
2577                                 || !(val & MS_INT_BREQ)
2578                                 || ((ms_card->total_sec_cnt + sector_cnt) > 0xFE00)) {
2579                         ms_card->seq_mode = 0;
2580                         ms_card->total_sec_cnt = 0;
2581                         if (val & MS_INT_BREQ) {
2582                                 retval = ms_send_cmd(chip, PRO_STOP, WAIT_INT);
2583                                 if (retval != STATUS_SUCCESS)
2584                                         TRACE_RET(chip, STATUS_FAIL);
2585
2586                                 rtsx_write_register(chip, RBCTL, RB_FLUSH, RB_FLUSH);
2587                         }
2588                 }
2589         }
2590
2591         if (!ms_card->seq_mode) {
2592                 ms_card->total_sec_cnt = 0;
2593                 if (sector_cnt >= SEQ_START_CRITERIA) {
2594                         if ((ms_card->capacity - start_sector) > 0xFE00)
2595                                 count = 0xFE00;
2596                         else
2597                                 count = (u16)(ms_card->capacity - start_sector);
2598
2599                         if (count > sector_cnt) {
2600                                 if (mode_2k)
2601                                         ms_card->seq_mode |= MODE_2K_SEQ;
2602                                 else
2603                                         ms_card->seq_mode |= MODE_512_SEQ;
2604                         }
2605                 } else {
2606                         count = sector_cnt;
2607                 }
2608                 retval = mspro_set_rw_cmd(chip, start_sector, count, rw_cmd);
2609                 if (retval != STATUS_SUCCESS) {
2610                         ms_card->seq_mode = 0;
2611                         TRACE_RET(chip, STATUS_FAIL);
2612                 }
2613         }
2614
2615         retval = ms_transfer_data(chip, trans_mode, rw_tpc, sector_cnt,
2616                                 WAIT_INT, mode_2k, scsi_sg_count(srb),
2617                                 scsi_sglist(srb), scsi_bufflen(srb));
2618         if (retval != STATUS_SUCCESS) {
2619                 ms_card->seq_mode = 0;
2620                 rtsx_read_register(chip, MS_TRANS_CFG, &val);
2621                 rtsx_clear_ms_error(chip);
2622
2623                 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {
2624                         chip->rw_need_retry = 0;
2625                         dev_dbg(rtsx_dev(chip), "No card exist, exit mspro_rw_multi_sector\n");
2626                         TRACE_RET(chip, STATUS_FAIL);
2627                 }
2628
2629                 if (val & MS_INT_BREQ)
2630                         ms_send_cmd(chip, PRO_STOP, WAIT_INT);
2631
2632                 if (val & (MS_CRC16_ERR | MS_RDY_TIMEOUT)) {
2633                         dev_dbg(rtsx_dev(chip), "MSPro CRC error, tune clock!\n");
2634                         chip->rw_need_retry = 1;
2635                         ms_auto_tune_clock(chip);
2636                 }
2637
2638                 TRACE_RET(chip, retval);
2639         }
2640
2641         if (ms_card->seq_mode) {
2642                 ms_card->pre_sec_addr = start_sector;
2643                 ms_card->pre_sec_cnt = sector_cnt;
2644                 ms_card->pre_dir = srb->sc_data_direction;
2645                 ms_card->total_sec_cnt += sector_cnt;
2646         }
2647
2648         return STATUS_SUCCESS;
2649 }
2650
2651 static int mspro_read_format_progress(struct rtsx_chip *chip,
2652                                 const int short_data_len)
2653 {
2654         struct ms_info *ms_card = &(chip->ms_card);
2655         int retval, i;
2656         u32 total_progress, cur_progress;
2657         u8 cnt, tmp;
2658         u8 data[8];
2659
2660         dev_dbg(rtsx_dev(chip), "mspro_read_format_progress, short_data_len = %d\n",
2661                 short_data_len);
2662
2663         retval = ms_switch_clock(chip);
2664         if (retval != STATUS_SUCCESS) {
2665                 ms_card->format_status = FORMAT_FAIL;
2666                 TRACE_RET(chip, STATUS_FAIL);
2667         }
2668
2669         retval = rtsx_read_register(chip, MS_TRANS_CFG, &tmp);
2670         if (retval != STATUS_SUCCESS) {
2671                 ms_card->format_status = FORMAT_FAIL;
2672                 TRACE_RET(chip, STATUS_FAIL);
2673         }
2674
2675         if (!(tmp & MS_INT_BREQ)) {
2676                 if ((tmp & (MS_INT_CED | MS_INT_BREQ | MS_INT_CMDNK | MS_INT_ERR)) == MS_INT_CED) {
2677                         ms_card->format_status = FORMAT_SUCCESS;
2678                         return STATUS_SUCCESS;
2679                 }
2680                 ms_card->format_status = FORMAT_FAIL;
2681                 TRACE_RET(chip, STATUS_FAIL);
2682         }
2683
2684         if (short_data_len >= 256)
2685                 cnt = 0;
2686         else
2687                 cnt = (u8)short_data_len;
2688
2689         retval = rtsx_write_register(chip, MS_CFG, MS_NO_CHECK_INT,
2690                                 MS_NO_CHECK_INT);
2691         if (retval != STATUS_SUCCESS) {
2692                 ms_card->format_status = FORMAT_FAIL;
2693                 TRACE_RET(chip, STATUS_FAIL);
2694         }
2695
2696         retval = ms_read_bytes(chip, PRO_READ_SHORT_DATA, cnt, WAIT_INT,
2697                         data, 8);
2698         if (retval != STATUS_SUCCESS) {
2699                 ms_card->format_status = FORMAT_FAIL;
2700                 TRACE_RET(chip, STATUS_FAIL);
2701         }
2702
2703         total_progress = (data[0] << 24) | (data[1] << 16) |
2704                 (data[2] << 8) | data[3];
2705         cur_progress = (data[4] << 24) | (data[5] << 16) |
2706                 (data[6] << 8) | data[7];
2707
2708         dev_dbg(rtsx_dev(chip), "total_progress = %d, cur_progress = %d\n",
2709                 total_progress, cur_progress);
2710
2711         if (total_progress == 0) {
2712                 ms_card->progress = 0;
2713         } else {
2714                 u64 ulltmp = (u64)cur_progress * (u64)65535;
2715                 do_div(ulltmp, total_progress);
2716                 ms_card->progress = (u16)ulltmp;
2717         }
2718         dev_dbg(rtsx_dev(chip), "progress = %d\n", ms_card->progress);
2719
2720         for (i = 0; i < 5000; i++) {
2721                 retval = rtsx_read_register(chip, MS_TRANS_CFG, &tmp);
2722                 if (retval != STATUS_SUCCESS) {
2723                         ms_card->format_status = FORMAT_FAIL;
2724                         TRACE_RET(chip, STATUS_FAIL);
2725                 }
2726                 if (tmp & (MS_INT_CED | MS_INT_CMDNK |
2727                                 MS_INT_BREQ | MS_INT_ERR))
2728                         break;
2729
2730                 wait_timeout(1);
2731         }
2732
2733         retval = rtsx_write_register(chip, MS_CFG, MS_NO_CHECK_INT, 0);
2734         if (retval != STATUS_SUCCESS) {
2735                 ms_card->format_status = FORMAT_FAIL;
2736                 TRACE_RET(chip, STATUS_FAIL);
2737         }
2738
2739         if (i == 5000) {
2740                 ms_card->format_status = FORMAT_FAIL;
2741                 TRACE_RET(chip, STATUS_FAIL);
2742         }
2743
2744         if (tmp & (MS_INT_CMDNK | MS_INT_ERR)) {
2745                 ms_card->format_status = FORMAT_FAIL;
2746                 TRACE_RET(chip, STATUS_FAIL);
2747         }
2748
2749         if (tmp & MS_INT_CED) {
2750                 ms_card->format_status = FORMAT_SUCCESS;
2751                 ms_card->pro_under_formatting = 0;
2752         } else if (tmp & MS_INT_BREQ) {
2753                 ms_card->format_status = FORMAT_IN_PROGRESS;
2754         } else {
2755                 ms_card->format_status = FORMAT_FAIL;
2756                 ms_card->pro_under_formatting = 0;
2757                 TRACE_RET(chip, STATUS_FAIL);
2758         }
2759
2760         return STATUS_SUCCESS;
2761 }
2762
2763 void mspro_polling_format_status(struct rtsx_chip *chip)
2764 {
2765         struct ms_info *ms_card = &(chip->ms_card);
2766         int i;
2767
2768         if (ms_card->pro_under_formatting &&
2769                 (rtsx_get_stat(chip) != RTSX_STAT_SS)) {
2770                 rtsx_set_stat(chip, RTSX_STAT_RUN);
2771
2772                 for (i = 0; i < 65535; i++) {
2773                         mspro_read_format_progress(chip, MS_SHORT_DATA_LEN);
2774                         if (ms_card->format_status != FORMAT_IN_PROGRESS)
2775                                 break;
2776                 }
2777         }
2778
2779         return;
2780 }
2781
2782 int mspro_format(struct scsi_cmnd *srb, struct rtsx_chip *chip,
2783                 int short_data_len, int quick_format)
2784 {
2785         struct ms_info *ms_card = &(chip->ms_card);
2786         int retval, i;
2787         u8 buf[8], tmp;
2788         u16 para;
2789
2790         retval = ms_switch_clock(chip);
2791         if (retval != STATUS_SUCCESS)
2792                 TRACE_RET(chip, STATUS_FAIL);
2793
2794         retval = ms_set_rw_reg_addr(chip, 0x00, 0x00, Pro_TPCParm, 0x01);
2795         if (retval != STATUS_SUCCESS)
2796                 TRACE_RET(chip, STATUS_FAIL);
2797
2798         memset(buf, 0, 2);
2799         switch (short_data_len) {
2800         case 32:
2801                 buf[0] = 0;
2802                 break;
2803         case 64:
2804                 buf[0] = 1;
2805                 break;
2806         case 128:
2807                 buf[0] = 2;
2808                 break;
2809         case 256:
2810         default:
2811                 buf[0] = 3;
2812                 break;
2813         }
2814
2815         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
2816                 retval = ms_write_bytes(chip, PRO_WRITE_REG, 1,
2817                                         NO_WAIT_INT, buf, 2);
2818                 if (retval == STATUS_SUCCESS)
2819                         break;
2820         }
2821         if (i == MS_MAX_RETRY_COUNT)
2822                 TRACE_RET(chip, STATUS_FAIL);
2823
2824         if (quick_format)
2825                 para = 0x0000;
2826         else
2827                 para = 0x0001;
2828
2829         retval = mspro_set_rw_cmd(chip, 0, para, PRO_FORMAT);
2830         if (retval != STATUS_SUCCESS)
2831                 TRACE_RET(chip, STATUS_FAIL);
2832
2833         RTSX_READ_REG(chip, MS_TRANS_CFG, &tmp);
2834
2835         if (tmp & (MS_INT_CMDNK | MS_INT_ERR))
2836                 TRACE_RET(chip, STATUS_FAIL);
2837
2838         if ((tmp & (MS_INT_BREQ | MS_INT_CED)) == MS_INT_BREQ) {
2839                 ms_card->pro_under_formatting = 1;
2840                 ms_card->progress = 0;
2841                 ms_card->format_status = FORMAT_IN_PROGRESS;
2842                 return STATUS_SUCCESS;
2843         }
2844
2845         if (tmp & MS_INT_CED) {
2846                 ms_card->pro_under_formatting = 0;
2847                 ms_card->progress = 0;
2848                 ms_card->format_status = FORMAT_SUCCESS;
2849                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_NO_SENSE);
2850                 return STATUS_SUCCESS;
2851         }
2852
2853         TRACE_RET(chip, STATUS_FAIL);
2854 }
2855
2856
2857 static int ms_read_multiple_pages(struct rtsx_chip *chip, u16 phy_blk,
2858                                 u16 log_blk, u8 start_page, u8 end_page,
2859                                 u8 *buf, unsigned int *index,
2860                                 unsigned int *offset)
2861 {
2862         struct ms_info *ms_card = &(chip->ms_card);
2863         int retval, i;
2864         u8 extra[MS_EXTRA_SIZE], page_addr, val, trans_cfg, data[6];
2865         u8 *ptr;
2866
2867         retval = ms_read_extra_data(chip, phy_blk, start_page,
2868                                 extra, MS_EXTRA_SIZE);
2869         if (retval == STATUS_SUCCESS) {
2870                 if ((extra[1] & 0x30) != 0x30) {
2871                         ms_set_err_code(chip, MS_FLASH_READ_ERROR);
2872                         TRACE_RET(chip, STATUS_FAIL);
2873                 }
2874         }
2875
2876         retval = ms_set_rw_reg_addr(chip, OverwriteFlag, MS_EXTRA_SIZE,
2877                                 SystemParm, 6);
2878         if (retval != STATUS_SUCCESS)
2879                 TRACE_RET(chip, STATUS_FAIL);
2880
2881         if (CHK_MS4BIT(ms_card))
2882                 data[0] = 0x88;
2883         else
2884                 data[0] = 0x80;
2885
2886         data[1] = 0;
2887         data[2] = (u8)(phy_blk >> 8);
2888         data[3] = (u8)phy_blk;
2889         data[4] = 0;
2890         data[5] = start_page;
2891
2892         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
2893                 retval = ms_write_bytes(chip, WRITE_REG, 6, NO_WAIT_INT,
2894                                         data, 6);
2895                 if (retval == STATUS_SUCCESS)
2896                         break;
2897         }
2898         if (i == MS_MAX_RETRY_COUNT)
2899                 TRACE_RET(chip, STATUS_FAIL);
2900
2901         ms_set_err_code(chip, MS_NO_ERROR);
2902
2903         retval = ms_send_cmd(chip, BLOCK_READ, WAIT_INT);
2904         if (retval != STATUS_SUCCESS)
2905                 TRACE_RET(chip, STATUS_FAIL);
2906
2907         ptr = buf;
2908
2909         for (page_addr = start_page; page_addr < end_page; page_addr++) {
2910                 ms_set_err_code(chip, MS_NO_ERROR);
2911
2912                 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {
2913                         ms_set_err_code(chip, MS_NO_CARD);
2914                         TRACE_RET(chip, STATUS_FAIL);
2915                 }
2916
2917                 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1);
2918                 if (retval != STATUS_SUCCESS)
2919                         TRACE_RET(chip, STATUS_FAIL);
2920
2921                 if (val & INT_REG_CMDNK) {
2922                         ms_set_err_code(chip, MS_CMD_NK);
2923                         TRACE_RET(chip, STATUS_FAIL);
2924                 }
2925                 if (val & INT_REG_ERR) {
2926                         if (val & INT_REG_BREQ) {
2927                                 retval = ms_read_status_reg(chip);
2928                                 if (retval != STATUS_SUCCESS) {
2929                                         if (!(chip->card_wp & MS_CARD)) {
2930                                                 reset_ms(chip);
2931                                                 ms_set_page_status(log_blk, setPS_NG, extra, MS_EXTRA_SIZE);
2932                                                 ms_write_extra_data(chip, phy_blk,
2933                                                                 page_addr, extra, MS_EXTRA_SIZE);
2934                                         }
2935                                         ms_set_err_code(chip, MS_FLASH_READ_ERROR);
2936                                         TRACE_RET(chip, STATUS_FAIL);
2937                                 }
2938                         } else {
2939                                 ms_set_err_code(chip, MS_FLASH_READ_ERROR);
2940                                 TRACE_RET(chip, STATUS_FAIL);
2941                         }
2942                 } else {
2943                         if (!(val & INT_REG_BREQ)) {
2944                                 ms_set_err_code(chip, MS_BREQ_ERROR);
2945                                 TRACE_RET(chip, STATUS_FAIL);
2946                         }
2947                 }
2948
2949                 if (page_addr == (end_page - 1)) {
2950                         if (!(val & INT_REG_CED)) {
2951                                 retval = ms_send_cmd(chip, BLOCK_END, WAIT_INT);
2952                                 if (retval != STATUS_SUCCESS)
2953                                         TRACE_RET(chip, STATUS_FAIL);
2954                         }
2955
2956                         retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT,
2957                                         &val, 1);
2958                         if (retval != STATUS_SUCCESS)
2959                                 TRACE_RET(chip, STATUS_FAIL);
2960
2961                         if (!(val & INT_REG_CED)) {
2962                                 ms_set_err_code(chip, MS_FLASH_READ_ERROR);
2963                                 TRACE_RET(chip, STATUS_FAIL);
2964                         }
2965
2966                         trans_cfg = NO_WAIT_INT;
2967                 } else {
2968                         trans_cfg = WAIT_INT;
2969                 }
2970
2971                 rtsx_init_cmd(chip);
2972
2973                 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC, 0xFF, READ_PAGE_DATA);
2974                 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG,
2975                         0xFF, trans_cfg);
2976                 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE,
2977                         0x01, RING_BUFFER);
2978
2979                 trans_dma_enable(DMA_FROM_DEVICE, chip, 512, DMA_512);
2980
2981                 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANSFER, 0xFF,
2982                                 MS_TRANSFER_START |  MS_TM_NORMAL_READ);
2983                 rtsx_add_cmd(chip, CHECK_REG_CMD, MS_TRANSFER,
2984                         MS_TRANSFER_END, MS_TRANSFER_END);
2985
2986                 rtsx_send_cmd_no_wait(chip);
2987
2988                 retval = rtsx_transfer_data_partial(chip, MS_CARD, ptr,
2989                                                 512, scsi_sg_count(chip->srb),
2990                                                 index, offset, DMA_FROM_DEVICE,
2991                                                 chip->ms_timeout);
2992                 if (retval < 0) {
2993                         if (retval == -ETIMEDOUT) {
2994                                 ms_set_err_code(chip, MS_TO_ERROR);
2995                                 rtsx_clear_ms_error(chip);
2996                                 TRACE_RET(chip, STATUS_TIMEDOUT);
2997                         }
2998
2999                         retval = rtsx_read_register(chip, MS_TRANS_CFG, &val);
3000                         if (retval != STATUS_SUCCESS) {
3001                                 ms_set_err_code(chip, MS_TO_ERROR);
3002                                 rtsx_clear_ms_error(chip);
3003                                 TRACE_RET(chip, STATUS_TIMEDOUT);
3004                         }
3005                         if (val & (MS_CRC16_ERR | MS_RDY_TIMEOUT)) {
3006                                 ms_set_err_code(chip, MS_CRC16_ERROR);
3007                                 rtsx_clear_ms_error(chip);
3008                                 TRACE_RET(chip, STATUS_FAIL);
3009                         }
3010                 }
3011
3012                 if (scsi_sg_count(chip->srb) == 0)
3013                         ptr += 512;
3014         }
3015
3016         return STATUS_SUCCESS;
3017 }
3018
3019 static int ms_write_multiple_pages(struct rtsx_chip *chip, u16 old_blk,
3020                                 u16 new_blk, u16 log_blk, u8 start_page,
3021                                 u8 end_page, u8 *buf, unsigned int *index,
3022                                 unsigned int *offset)
3023 {
3024         struct ms_info *ms_card = &(chip->ms_card);
3025         int retval, i;
3026         u8 page_addr, val, data[16];
3027         u8 *ptr;
3028
3029         if (!start_page) {
3030                 retval = ms_set_rw_reg_addr(chip, OverwriteFlag, MS_EXTRA_SIZE,
3031                                         SystemParm, 7);
3032                 if (retval != STATUS_SUCCESS)
3033                         TRACE_RET(chip, STATUS_FAIL);
3034
3035                 if (CHK_MS4BIT(ms_card))
3036                         data[0] = 0x88;
3037                 else
3038                         data[0] = 0x80;
3039
3040                 data[1] = 0;
3041                 data[2] = (u8)(old_blk >> 8);
3042                 data[3] = (u8)old_blk;
3043                 data[4] = 0x80;
3044                 data[5] = 0;
3045                 data[6] = 0xEF;
3046                 data[7] = 0xFF;
3047
3048                 retval = ms_write_bytes(chip, WRITE_REG, 7, NO_WAIT_INT,
3049                                         data, 8);
3050                 if (retval != STATUS_SUCCESS)
3051                         TRACE_RET(chip, STATUS_FAIL);
3052
3053                 retval = ms_send_cmd(chip, BLOCK_WRITE, WAIT_INT);
3054                 if (retval != STATUS_SUCCESS)
3055                         TRACE_RET(chip, STATUS_FAIL);
3056
3057                 ms_set_err_code(chip, MS_NO_ERROR);
3058                 retval = ms_transfer_tpc(chip, MS_TM_READ_BYTES, GET_INT, 1,
3059                                         NO_WAIT_INT);
3060                 if (retval != STATUS_SUCCESS)
3061                         TRACE_RET(chip, STATUS_FAIL);
3062         }
3063
3064         retval = ms_set_rw_reg_addr(chip, OverwriteFlag, MS_EXTRA_SIZE,
3065                                 SystemParm, (6 + MS_EXTRA_SIZE));
3066         if (retval != STATUS_SUCCESS)
3067                 TRACE_RET(chip, STATUS_FAIL);
3068
3069         ms_set_err_code(chip, MS_NO_ERROR);
3070
3071         if (CHK_MS4BIT(ms_card))
3072                 data[0] = 0x88;
3073         else
3074                 data[0] = 0x80;
3075
3076         data[1] = 0;
3077         data[2] = (u8)(new_blk >> 8);
3078         data[3] = (u8)new_blk;
3079         if ((end_page - start_page) == 1)
3080                 data[4] = 0x20;
3081         else
3082                 data[4] = 0;
3083
3084         data[5] = start_page;
3085         data[6] = 0xF8;
3086         data[7] = 0xFF;
3087         data[8] = (u8)(log_blk >> 8);
3088         data[9] = (u8)log_blk;
3089
3090         for (i = 0x0A; i < 0x10; i++)
3091                 data[i] = 0xFF;
3092
3093         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
3094                 retval = ms_write_bytes(chip, WRITE_REG, 6 + MS_EXTRA_SIZE,
3095                                         NO_WAIT_INT, data, 16);
3096                 if (retval == STATUS_SUCCESS)
3097                         break;
3098         }
3099         if (i == MS_MAX_RETRY_COUNT)
3100                 TRACE_RET(chip, STATUS_FAIL);
3101
3102         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
3103                 retval = ms_send_cmd(chip, BLOCK_WRITE, WAIT_INT);
3104                 if (retval == STATUS_SUCCESS)
3105                         break;
3106         }
3107         if (i == MS_MAX_RETRY_COUNT)
3108                 TRACE_RET(chip, STATUS_FAIL);
3109
3110         retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1);
3111         if (retval != STATUS_SUCCESS)
3112                 TRACE_RET(chip, STATUS_FAIL);
3113
3114         ptr = buf;
3115         for (page_addr = start_page; page_addr < end_page; page_addr++) {
3116                 ms_set_err_code(chip, MS_NO_ERROR);
3117
3118                 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {
3119                         ms_set_err_code(chip, MS_NO_CARD);
3120                         TRACE_RET(chip, STATUS_FAIL);
3121                 }
3122
3123                 if (val & INT_REG_CMDNK) {
3124                         ms_set_err_code(chip, MS_CMD_NK);
3125                         TRACE_RET(chip, STATUS_FAIL);
3126                 }
3127                 if (val & INT_REG_ERR) {
3128                         ms_set_err_code(chip, MS_FLASH_WRITE_ERROR);
3129                         TRACE_RET(chip, STATUS_FAIL);
3130                 }
3131                 if (!(val & INT_REG_BREQ)) {
3132                         ms_set_err_code(chip, MS_BREQ_ERROR);
3133                         TRACE_RET(chip, STATUS_FAIL);
3134                 }
3135
3136                 udelay(30);
3137
3138                 rtsx_init_cmd(chip);
3139
3140                 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC,
3141                         0xFF, WRITE_PAGE_DATA);
3142                 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG,
3143                         0xFF, WAIT_INT);
3144                 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE,
3145                         0x01, RING_BUFFER);
3146
3147                 trans_dma_enable(DMA_TO_DEVICE, chip, 512, DMA_512);
3148
3149                 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANSFER, 0xFF,
3150                                 MS_TRANSFER_START |  MS_TM_NORMAL_WRITE);
3151                 rtsx_add_cmd(chip, CHECK_REG_CMD, MS_TRANSFER,
3152                         MS_TRANSFER_END, MS_TRANSFER_END);
3153
3154                 rtsx_send_cmd_no_wait(chip);
3155
3156                 retval = rtsx_transfer_data_partial(chip, MS_CARD, ptr,
3157                                                 512, scsi_sg_count(chip->srb),
3158                                                 index, offset, DMA_TO_DEVICE,
3159                                                 chip->ms_timeout);
3160                 if (retval < 0) {
3161                         ms_set_err_code(chip, MS_TO_ERROR);
3162                         rtsx_clear_ms_error(chip);
3163
3164                         if (retval == -ETIMEDOUT)
3165                                 TRACE_RET(chip, STATUS_TIMEDOUT);
3166                         else
3167                                 TRACE_RET(chip, STATUS_FAIL);
3168                 }
3169
3170                 retval = ms_read_bytes(chip, GET_INT, 1, NO_WAIT_INT, &val, 1);
3171                 if (retval != STATUS_SUCCESS)
3172                         TRACE_RET(chip, STATUS_FAIL);
3173
3174                 if ((end_page - start_page) == 1) {
3175                         if (!(val & INT_REG_CED)) {
3176                                 ms_set_err_code(chip, MS_FLASH_WRITE_ERROR);
3177                                 TRACE_RET(chip, STATUS_FAIL);
3178                         }
3179                 } else {
3180                         if (page_addr == (end_page - 1)) {
3181                                 if (!(val & INT_REG_CED)) {
3182                                         retval = ms_send_cmd(chip, BLOCK_END,
3183                                                         WAIT_INT);
3184                                         if (retval != STATUS_SUCCESS)
3185                                                 TRACE_RET(chip, STATUS_FAIL);
3186                                 }
3187
3188                                 retval = ms_read_bytes(chip, GET_INT, 1,
3189                                                 NO_WAIT_INT, &val, 1);
3190                                 if (retval != STATUS_SUCCESS)
3191                                         TRACE_RET(chip, STATUS_FAIL);
3192                         }
3193
3194                         if ((page_addr == (end_page - 1)) ||
3195                                 (page_addr == ms_card->page_off)) {
3196                                 if (!(val & INT_REG_CED)) {
3197                                         ms_set_err_code(chip,
3198                                                         MS_FLASH_WRITE_ERROR);
3199                                         TRACE_RET(chip, STATUS_FAIL);
3200                                 }
3201                         }
3202                 }
3203
3204                 if (scsi_sg_count(chip->srb) == 0)
3205                         ptr += 512;
3206         }
3207
3208         return STATUS_SUCCESS;
3209 }
3210
3211
3212 static int ms_finish_write(struct rtsx_chip *chip, u16 old_blk, u16 new_blk,
3213                 u16 log_blk, u8 page_off)
3214 {
3215         struct ms_info *ms_card = &(chip->ms_card);
3216         int retval, seg_no;
3217
3218         retval = ms_copy_page(chip, old_blk, new_blk, log_blk,
3219                         page_off, ms_card->page_off + 1);
3220         if (retval != STATUS_SUCCESS)
3221                 TRACE_RET(chip, STATUS_FAIL);
3222
3223         seg_no = old_blk >> 9;
3224
3225         if (MS_TST_BAD_BLOCK_FLG(ms_card)) {
3226                 MS_CLR_BAD_BLOCK_FLG(ms_card);
3227                 ms_set_bad_block(chip, old_blk);
3228         } else {
3229                 retval = ms_erase_block(chip, old_blk);
3230                 if (retval == STATUS_SUCCESS)
3231                         ms_set_unused_block(chip, old_blk);
3232         }
3233
3234         ms_set_l2p_tbl(chip, seg_no, log_blk - ms_start_idx[seg_no], new_blk);
3235
3236         return STATUS_SUCCESS;
3237 }
3238
3239 static int ms_prepare_write(struct rtsx_chip *chip, u16 old_blk, u16 new_blk,
3240                 u16 log_blk, u8 start_page)
3241 {
3242         int retval;
3243
3244         if (start_page) {
3245                 retval = ms_copy_page(chip, old_blk, new_blk, log_blk,
3246                                 0, start_page);
3247                 if (retval != STATUS_SUCCESS)
3248                         TRACE_RET(chip, STATUS_FAIL);
3249         }
3250
3251         return STATUS_SUCCESS;
3252 }
3253
3254 #ifdef MS_DELAY_WRITE
3255 int ms_delay_write(struct rtsx_chip *chip)
3256 {
3257         struct ms_info *ms_card = &(chip->ms_card);
3258         struct ms_delay_write_tag *delay_write = &(ms_card->delay_write);
3259         int retval;
3260
3261         if (delay_write->delay_write_flag) {
3262                 retval = ms_set_init_para(chip);
3263                 if (retval != STATUS_SUCCESS)
3264                         TRACE_RET(chip, STATUS_FAIL);
3265
3266                 delay_write->delay_write_flag = 0;
3267                 retval = ms_finish_write(chip,
3268                                         delay_write->old_phyblock,
3269                                         delay_write->new_phyblock,
3270                                         delay_write->logblock,
3271                                         delay_write->pageoff);
3272                 if (retval != STATUS_SUCCESS)
3273                         TRACE_RET(chip, STATUS_FAIL);
3274         }
3275
3276         return STATUS_SUCCESS;
3277 }
3278 #endif
3279
3280 static inline void ms_rw_fail(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3281 {
3282         if (srb->sc_data_direction == DMA_FROM_DEVICE)
3283                 set_sense_type(chip, SCSI_LUN(srb),
3284                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
3285         else
3286                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
3287 }
3288
3289 static int ms_rw_multi_sector(struct scsi_cmnd *srb, struct rtsx_chip *chip,
3290                         u32 start_sector, u16 sector_cnt)
3291 {
3292         struct ms_info *ms_card = &(chip->ms_card);
3293         unsigned int lun = SCSI_LUN(srb);
3294         int retval, seg_no;
3295         unsigned int index = 0, offset = 0;
3296         u16 old_blk = 0, new_blk = 0, log_blk, total_sec_cnt = sector_cnt;
3297         u8 start_page, end_page = 0, page_cnt;
3298         u8 *ptr;
3299 #ifdef MS_DELAY_WRITE
3300         struct ms_delay_write_tag *delay_write = &(ms_card->delay_write);
3301 #endif
3302
3303         ms_set_err_code(chip, MS_NO_ERROR);
3304
3305         ms_card->cleanup_counter = 0;
3306
3307         ptr = (u8 *)scsi_sglist(srb);
3308
3309         retval = ms_switch_clock(chip);
3310         if (retval != STATUS_SUCCESS) {
3311                 ms_rw_fail(srb, chip);
3312                 TRACE_RET(chip, STATUS_FAIL);
3313         }
3314
3315         log_blk = (u16)(start_sector >> ms_card->block_shift);
3316         start_page = (u8)(start_sector & ms_card->page_off);
3317
3318         for (seg_no = 0; seg_no < ARRAY_SIZE(ms_start_idx) - 1; seg_no++) {
3319                 if (log_blk < ms_start_idx[seg_no+1])
3320                         break;
3321         }
3322
3323         if (ms_card->segment[seg_no].build_flag == 0) {
3324                 retval = ms_build_l2p_tbl(chip, seg_no);
3325                 if (retval != STATUS_SUCCESS) {
3326                         chip->card_fail |= MS_CARD;
3327                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3328                         TRACE_RET(chip, STATUS_FAIL);
3329                 }
3330         }
3331
3332         if (srb->sc_data_direction == DMA_TO_DEVICE) {
3333 #ifdef MS_DELAY_WRITE
3334                 if (delay_write->delay_write_flag &&
3335                                 (delay_write->logblock == log_blk) &&
3336                                 (start_page > delay_write->pageoff)) {
3337                         delay_write->delay_write_flag = 0;
3338                         retval = ms_copy_page(chip,
3339                                 delay_write->old_phyblock,
3340                                 delay_write->new_phyblock, log_blk,
3341                                 delay_write->pageoff, start_page);
3342                         if (retval != STATUS_SUCCESS) {
3343                                 set_sense_type(chip, lun,
3344                                         SENSE_TYPE_MEDIA_WRITE_ERR);
3345                                 TRACE_RET(chip, STATUS_FAIL);
3346                         }
3347                         old_blk = delay_write->old_phyblock;
3348                         new_blk = delay_write->new_phyblock;
3349                 } else if (delay_write->delay_write_flag &&
3350                                 (delay_write->logblock == log_blk) &&
3351                                 (start_page == delay_write->pageoff)) {
3352                         delay_write->delay_write_flag = 0;
3353                         old_blk = delay_write->old_phyblock;
3354                         new_blk = delay_write->new_phyblock;
3355                 } else {
3356                         retval = ms_delay_write(chip);
3357                         if (retval != STATUS_SUCCESS) {
3358                                 set_sense_type(chip, lun,
3359                                         SENSE_TYPE_MEDIA_WRITE_ERR);
3360                                 TRACE_RET(chip, STATUS_FAIL);
3361                         }
3362 #endif
3363                         old_blk = ms_get_l2p_tbl(chip, seg_no,
3364                                                 log_blk - ms_start_idx[seg_no]);
3365                         new_blk  = ms_get_unused_block(chip, seg_no);
3366                         if ((old_blk == 0xFFFF) || (new_blk == 0xFFFF)) {
3367                                 set_sense_type(chip, lun,
3368                                         SENSE_TYPE_MEDIA_WRITE_ERR);
3369                                 TRACE_RET(chip, STATUS_FAIL);
3370                         }
3371
3372                         retval = ms_prepare_write(chip, old_blk, new_blk,
3373                                                 log_blk, start_page);
3374                         if (retval != STATUS_SUCCESS) {
3375                                 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {
3376                                         set_sense_type(chip, lun,
3377                                                 SENSE_TYPE_MEDIA_NOT_PRESENT);
3378                                         TRACE_RET(chip, STATUS_FAIL);
3379                                 }
3380                                 set_sense_type(chip, lun,
3381                                         SENSE_TYPE_MEDIA_WRITE_ERR);
3382                                 TRACE_RET(chip, STATUS_FAIL);
3383                         }
3384 #ifdef MS_DELAY_WRITE
3385                 }
3386 #endif
3387         } else {
3388 #ifdef MS_DELAY_WRITE
3389                 retval = ms_delay_write(chip);
3390                 if (retval != STATUS_SUCCESS) {
3391                         if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {
3392                                 set_sense_type(chip, lun,
3393                                         SENSE_TYPE_MEDIA_NOT_PRESENT);
3394                                 TRACE_RET(chip, STATUS_FAIL);
3395                         }
3396                         set_sense_type(chip, lun,
3397                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
3398                         TRACE_RET(chip, STATUS_FAIL);
3399                 }
3400 #endif
3401                 old_blk = ms_get_l2p_tbl(chip, seg_no,
3402                                         log_blk - ms_start_idx[seg_no]);
3403                 if (old_blk == 0xFFFF) {
3404                         set_sense_type(chip, lun,
3405                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
3406                         TRACE_RET(chip, STATUS_FAIL);
3407                 }
3408         }
3409
3410         dev_dbg(rtsx_dev(chip), "seg_no = %d, old_blk = 0x%x, new_blk = 0x%x\n",
3411                 seg_no, old_blk, new_blk);
3412
3413         while (total_sec_cnt) {
3414                 if ((start_page + total_sec_cnt) > (ms_card->page_off + 1))
3415                         end_page = ms_card->page_off + 1;
3416                 else
3417                         end_page = start_page + (u8)total_sec_cnt;
3418
3419                 page_cnt = end_page - start_page;
3420
3421                 dev_dbg(rtsx_dev(chip), "start_page = %d, end_page = %d, page_cnt = %d\n",
3422                         start_page, end_page, page_cnt);
3423
3424                 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
3425                         retval = ms_read_multiple_pages(chip,
3426                                 old_blk, log_blk, start_page, end_page,
3427                                 ptr, &index, &offset);
3428                 } else {
3429                         retval = ms_write_multiple_pages(chip, old_blk,
3430                                 new_blk, log_blk, start_page, end_page,
3431                                 ptr, &index, &offset);
3432                 }
3433
3434                 if (retval != STATUS_SUCCESS) {
3435                         toggle_gpio(chip, 1);
3436                         if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {
3437                                 set_sense_type(chip, lun,
3438                                         SENSE_TYPE_MEDIA_NOT_PRESENT);
3439                                 TRACE_RET(chip, STATUS_FAIL);
3440                         }
3441                         ms_rw_fail(srb, chip);
3442                         TRACE_RET(chip, STATUS_FAIL);
3443                 }
3444
3445                 if (srb->sc_data_direction == DMA_TO_DEVICE) {
3446                         if (end_page == (ms_card->page_off + 1)) {
3447                                 retval = ms_erase_block(chip, old_blk);
3448                                 if (retval == STATUS_SUCCESS)
3449                                         ms_set_unused_block(chip, old_blk);
3450
3451                                 ms_set_l2p_tbl(chip, seg_no,
3452                                         log_blk - ms_start_idx[seg_no],
3453                                         new_blk);
3454                         }
3455                 }
3456
3457                 total_sec_cnt -= page_cnt;
3458                 if (scsi_sg_count(srb) == 0)
3459                         ptr += page_cnt * 512;
3460
3461                 if (total_sec_cnt == 0)
3462                         break;
3463
3464                 log_blk++;
3465
3466                 for (seg_no = 0; seg_no < ARRAY_SIZE(ms_start_idx) - 1;
3467                                 seg_no++) {
3468                         if (log_blk < ms_start_idx[seg_no+1])
3469                                 break;
3470                 }
3471
3472                 if (ms_card->segment[seg_no].build_flag == 0) {
3473                         retval = ms_build_l2p_tbl(chip, seg_no);
3474                         if (retval != STATUS_SUCCESS) {
3475                                 chip->card_fail |= MS_CARD;
3476                                 set_sense_type(chip, lun,
3477                                         SENSE_TYPE_MEDIA_NOT_PRESENT);
3478                                 TRACE_RET(chip, STATUS_FAIL);
3479                         }
3480                 }
3481
3482                 old_blk = ms_get_l2p_tbl(chip, seg_no,
3483                                         log_blk - ms_start_idx[seg_no]);
3484                 if (old_blk == 0xFFFF) {
3485                         ms_rw_fail(srb, chip);
3486                         TRACE_RET(chip, STATUS_FAIL);
3487                 }
3488
3489                 if (srb->sc_data_direction == DMA_TO_DEVICE) {
3490                         new_blk = ms_get_unused_block(chip, seg_no);
3491                         if (new_blk == 0xFFFF) {
3492                                 ms_rw_fail(srb, chip);
3493                                 TRACE_RET(chip, STATUS_FAIL);
3494                         }
3495                 }
3496
3497                 dev_dbg(rtsx_dev(chip), "seg_no = %d, old_blk = 0x%x, new_blk = 0x%x\n",
3498                         seg_no, old_blk, new_blk);
3499
3500                 start_page = 0;
3501         }
3502
3503         if (srb->sc_data_direction == DMA_TO_DEVICE) {
3504                 if (end_page < (ms_card->page_off + 1)) {
3505 #ifdef MS_DELAY_WRITE
3506                         delay_write->delay_write_flag = 1;
3507                         delay_write->old_phyblock = old_blk;
3508                         delay_write->new_phyblock = new_blk;
3509                         delay_write->logblock = log_blk;
3510                         delay_write->pageoff = end_page;
3511 #else
3512                         retval = ms_finish_write(chip, old_blk, new_blk,
3513                                                 log_blk, end_page);
3514                         if (retval != STATUS_SUCCESS) {
3515                                 if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {
3516                                         set_sense_type(chip, lun,
3517                                                 SENSE_TYPE_MEDIA_NOT_PRESENT);
3518                                         TRACE_RET(chip, STATUS_FAIL);
3519                                 }
3520
3521                                 ms_rw_fail(srb, chip);
3522                                 TRACE_RET(chip, STATUS_FAIL);
3523                         }
3524 #endif
3525                 }
3526         }
3527
3528         scsi_set_resid(srb, 0);
3529
3530         return STATUS_SUCCESS;
3531 }
3532
3533 int ms_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip,
3534         u32 start_sector, u16 sector_cnt)
3535 {
3536         struct ms_info *ms_card = &(chip->ms_card);
3537         int retval;
3538
3539         if (CHK_MSPRO(ms_card))
3540                 retval = mspro_rw_multi_sector(srb, chip, start_sector,
3541                                         sector_cnt);
3542         else
3543                 retval = ms_rw_multi_sector(srb, chip, start_sector,
3544                                         sector_cnt);
3545
3546         return retval;
3547 }
3548
3549
3550 void ms_free_l2p_tbl(struct rtsx_chip *chip)
3551 {
3552         struct ms_info *ms_card = &(chip->ms_card);
3553         int i = 0;
3554
3555         if (ms_card->segment != NULL) {
3556                 for (i = 0; i < ms_card->segment_cnt; i++) {
3557                         if (ms_card->segment[i].l2p_table != NULL) {
3558                                 vfree(ms_card->segment[i].l2p_table);
3559                                 ms_card->segment[i].l2p_table = NULL;
3560                         }
3561                         if (ms_card->segment[i].free_table != NULL) {
3562                                 vfree(ms_card->segment[i].free_table);
3563                                 ms_card->segment[i].free_table = NULL;
3564                         }
3565                 }
3566                 vfree(ms_card->segment);
3567                 ms_card->segment = NULL;
3568         }
3569 }
3570
3571 #ifdef SUPPORT_MAGIC_GATE
3572
3573 #ifdef READ_BYTES_WAIT_INT
3574 static int ms_poll_int(struct rtsx_chip *chip)
3575 {
3576         int retval;
3577         u8 val;
3578
3579         rtsx_init_cmd(chip);
3580
3581         rtsx_add_cmd(chip, CHECK_REG_CMD, MS_TRANS_CFG, MS_INT_CED, MS_INT_CED);
3582
3583         retval = rtsx_send_cmd(chip, MS_CARD, 5000);
3584         if (retval != STATUS_SUCCESS)
3585                 TRACE_RET(chip, STATUS_FAIL);
3586
3587         val = *rtsx_get_cmd_data(chip);
3588         if (val & MS_INT_ERR)
3589                 TRACE_RET(chip, STATUS_FAIL);
3590
3591         return STATUS_SUCCESS;
3592 }
3593 #endif
3594
3595 #ifdef MS_SAMPLE_INT_ERR
3596 static int check_ms_err(struct rtsx_chip *chip)
3597 {
3598         int retval;
3599         u8 val;
3600
3601         retval = rtsx_read_register(chip, MS_TRANSFER, &val);
3602         if (retval != STATUS_SUCCESS)
3603                 return 1;
3604         if (val & MS_TRANSFER_ERR)
3605                 return 1;
3606
3607         retval = rtsx_read_register(chip, MS_TRANS_CFG, &val);
3608         if (retval != STATUS_SUCCESS)
3609                 return 1;
3610
3611         if (val & (MS_INT_ERR | MS_INT_CMDNK))
3612                 return 1;
3613
3614         return 0;
3615 }
3616 #else
3617 static int check_ms_err(struct rtsx_chip *chip)
3618 {
3619         int retval;
3620         u8 val;
3621
3622         retval = rtsx_read_register(chip, MS_TRANSFER, &val);
3623         if (retval != STATUS_SUCCESS)
3624                 return 1;
3625         if (val & MS_TRANSFER_ERR)
3626                 return 1;
3627
3628         return 0;
3629 }
3630 #endif
3631
3632 static int mg_send_ex_cmd(struct rtsx_chip *chip, u8 cmd, u8 entry_num)
3633 {
3634         int retval, i;
3635         u8 data[8];
3636
3637         data[0] = cmd;
3638         data[1] = 0;
3639         data[2] = 0;
3640         data[3] = 0;
3641         data[4] = 0;
3642         data[5] = 0;
3643         data[6] = entry_num;
3644         data[7] = 0;
3645
3646         for (i = 0; i < MS_MAX_RETRY_COUNT; i++) {
3647                 retval = ms_write_bytes(chip, PRO_EX_SET_CMD, 7, WAIT_INT,
3648                                         data, 8);
3649                 if (retval == STATUS_SUCCESS)
3650                         break;
3651         }
3652         if (i == MS_MAX_RETRY_COUNT)
3653                 TRACE_RET(chip, STATUS_FAIL);
3654
3655         if (check_ms_err(chip)) {
3656                 rtsx_clear_ms_error(chip);
3657                 TRACE_RET(chip, STATUS_FAIL);
3658         }
3659
3660         return STATUS_SUCCESS;
3661 }
3662
3663 static int mg_set_tpc_para_sub(struct rtsx_chip *chip, int type,
3664                         u8 mg_entry_num)
3665 {
3666         int retval;
3667         u8 buf[6];
3668
3669         if (type == 0)
3670                 retval = ms_set_rw_reg_addr(chip, 0, 0, Pro_TPCParm, 1);
3671         else
3672                 retval = ms_set_rw_reg_addr(chip, 0, 0, Pro_DataCount1, 6);
3673
3674         if (retval != STATUS_SUCCESS)
3675                 TRACE_RET(chip, STATUS_FAIL);
3676
3677         buf[0] = 0;
3678         buf[1] = 0;
3679         if (type == 1) {
3680                 buf[2] = 0;
3681                 buf[3] = 0;
3682                 buf[4] = 0;
3683                 buf[5] = mg_entry_num;
3684         }
3685         retval = ms_write_bytes(chip, PRO_WRITE_REG, (type == 0) ? 1 : 6,
3686                                 NO_WAIT_INT, buf, 6);
3687         if (retval != STATUS_SUCCESS)
3688                 TRACE_RET(chip, STATUS_FAIL);
3689
3690         return STATUS_SUCCESS;
3691 }
3692
3693 int mg_set_leaf_id(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3694 {
3695         int retval;
3696         int i;
3697         unsigned int lun = SCSI_LUN(srb);
3698         u8 buf1[32], buf2[12];
3699
3700         if (scsi_bufflen(srb) < 12) {
3701                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3702                 TRACE_RET(chip, STATUS_FAIL);
3703         }
3704
3705         ms_cleanup_work(chip);
3706
3707         retval = ms_switch_clock(chip);
3708         if (retval != STATUS_SUCCESS)
3709                 TRACE_RET(chip, STATUS_FAIL);
3710
3711         retval = mg_send_ex_cmd(chip, MG_SET_LID, 0);
3712         if (retval != STATUS_SUCCESS) {
3713                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB);
3714                 TRACE_RET(chip, STATUS_FAIL);
3715         }
3716
3717         memset(buf1, 0, 32);
3718         rtsx_stor_get_xfer_buf(buf2, min_t(int, 12, scsi_bufflen(srb)), srb);
3719         for (i = 0; i < 8; i++)
3720                 buf1[8+i] = buf2[4+i];
3721
3722         retval = ms_write_bytes(chip, PRO_WRITE_SHORT_DATA, 32, WAIT_INT,
3723                                 buf1, 32);
3724         if (retval != STATUS_SUCCESS) {
3725                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB);
3726                 TRACE_RET(chip, STATUS_FAIL);
3727         }
3728         if (check_ms_err(chip)) {
3729                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB);
3730                 rtsx_clear_ms_error(chip);
3731                 TRACE_RET(chip, STATUS_FAIL);
3732         }
3733
3734         return STATUS_SUCCESS;
3735 }
3736
3737 int mg_get_local_EKB(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3738 {
3739         int retval = STATUS_FAIL;
3740         int bufflen;
3741         unsigned int lun = SCSI_LUN(srb);
3742         u8 *buf = NULL;
3743
3744         ms_cleanup_work(chip);
3745
3746         retval = ms_switch_clock(chip);
3747         if (retval != STATUS_SUCCESS)
3748                 TRACE_RET(chip, STATUS_FAIL);
3749
3750         buf = kmalloc(1540, GFP_KERNEL);
3751         if (!buf)
3752                 TRACE_RET(chip, STATUS_ERROR);
3753
3754         buf[0] = 0x04;
3755         buf[1] = 0x1A;
3756         buf[2] = 0x00;
3757         buf[3] = 0x00;
3758
3759         retval = mg_send_ex_cmd(chip, MG_GET_LEKB, 0);
3760         if (retval != STATUS_SUCCESS) {
3761                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN);
3762                 TRACE_GOTO(chip, GetEKBFinish);
3763         }
3764
3765         retval = ms_transfer_data(chip, MS_TM_AUTO_READ, PRO_READ_LONG_DATA,
3766                                 3, WAIT_INT, 0, 0, buf + 4, 1536);
3767         if (retval != STATUS_SUCCESS) {
3768                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN);
3769                 rtsx_clear_ms_error(chip);
3770                 TRACE_GOTO(chip, GetEKBFinish);
3771         }
3772         if (check_ms_err(chip)) {
3773                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN);
3774                 rtsx_clear_ms_error(chip);
3775                 TRACE_RET(chip, STATUS_FAIL);
3776         }
3777
3778         bufflen = min_t(int, 1052, scsi_bufflen(srb));
3779         rtsx_stor_set_xfer_buf(buf, bufflen, srb);
3780
3781 GetEKBFinish:
3782         kfree(buf);
3783         return retval;
3784 }
3785
3786 int mg_chg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3787 {
3788         struct ms_info *ms_card = &(chip->ms_card);
3789         int retval;
3790         int bufflen;
3791         int i;
3792         unsigned int lun = SCSI_LUN(srb);
3793         u8 buf[32];
3794
3795         ms_cleanup_work(chip);
3796
3797         retval = ms_switch_clock(chip);
3798         if (retval != STATUS_SUCCESS)
3799                 TRACE_RET(chip, STATUS_FAIL);
3800
3801         retval = mg_send_ex_cmd(chip, MG_GET_ID, 0);
3802         if (retval != STATUS_SUCCESS) {
3803                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3804                 TRACE_RET(chip, STATUS_FAIL);
3805         }
3806
3807         retval = ms_read_bytes(chip, PRO_READ_SHORT_DATA, 32, WAIT_INT,
3808                         buf, 32);
3809         if (retval != STATUS_SUCCESS) {
3810                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3811                 TRACE_RET(chip, STATUS_FAIL);
3812         }
3813         if (check_ms_err(chip)) {
3814                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3815                 rtsx_clear_ms_error(chip);
3816                 TRACE_RET(chip, STATUS_FAIL);
3817         }
3818
3819         memcpy(ms_card->magic_gate_id, buf, 16);
3820
3821 #ifdef READ_BYTES_WAIT_INT
3822         retval = ms_poll_int(chip);
3823         if (retval != STATUS_SUCCESS) {
3824                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3825                 TRACE_RET(chip, STATUS_FAIL);
3826         }
3827 #endif
3828
3829         retval = mg_send_ex_cmd(chip, MG_SET_RD, 0);
3830         if (retval != STATUS_SUCCESS) {
3831                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3832                 TRACE_RET(chip, STATUS_FAIL);
3833         }
3834
3835         bufflen = min_t(int, 12, scsi_bufflen(srb));
3836         rtsx_stor_get_xfer_buf(buf, bufflen, srb);
3837
3838         for (i = 0; i < 8; i++)
3839                 buf[i] = buf[4+i];
3840
3841         for (i = 0; i < 24; i++)
3842                 buf[8+i] = 0;
3843
3844         retval = ms_write_bytes(chip, PRO_WRITE_SHORT_DATA,
3845                                 32, WAIT_INT, buf, 32);
3846         if (retval != STATUS_SUCCESS) {
3847                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3848                 TRACE_RET(chip, STATUS_FAIL);
3849         }
3850         if (check_ms_err(chip)) {
3851                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3852                 rtsx_clear_ms_error(chip);
3853                 TRACE_RET(chip, STATUS_FAIL);
3854         }
3855
3856         ms_card->mg_auth = 0;
3857
3858         return STATUS_SUCCESS;
3859 }
3860
3861 int mg_get_rsp_chg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3862 {
3863         struct ms_info *ms_card = &(chip->ms_card);
3864         int retval;
3865         int bufflen;
3866         unsigned int lun = SCSI_LUN(srb);
3867         u8 buf1[32], buf2[36];
3868
3869         ms_cleanup_work(chip);
3870
3871         retval = ms_switch_clock(chip);
3872         if (retval != STATUS_SUCCESS)
3873                 TRACE_RET(chip, STATUS_FAIL);
3874
3875         retval = mg_send_ex_cmd(chip, MG_MAKE_RMS, 0);
3876         if (retval != STATUS_SUCCESS) {
3877                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN);
3878                 TRACE_RET(chip, STATUS_FAIL);
3879         }
3880
3881         retval = ms_read_bytes(chip, PRO_READ_SHORT_DATA, 32, WAIT_INT,
3882                         buf1, 32);
3883         if (retval != STATUS_SUCCESS) {
3884                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN);
3885                 TRACE_RET(chip, STATUS_FAIL);
3886         }
3887         if (check_ms_err(chip)) {
3888                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN);
3889                 rtsx_clear_ms_error(chip);
3890                 TRACE_RET(chip, STATUS_FAIL);
3891         }
3892
3893         buf2[0] = 0x00;
3894         buf2[1] = 0x22;
3895         buf2[2] = 0x00;
3896         buf2[3] = 0x00;
3897
3898         memcpy(buf2 + 4, ms_card->magic_gate_id, 16);
3899         memcpy(buf2 + 20, buf1, 16);
3900
3901         bufflen = min_t(int, 36, scsi_bufflen(srb));
3902         rtsx_stor_set_xfer_buf(buf2, bufflen, srb);
3903
3904 #ifdef READ_BYTES_WAIT_INT
3905         retval = ms_poll_int(chip);
3906         if (retval != STATUS_SUCCESS) {
3907                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN);
3908                 TRACE_RET(chip, STATUS_FAIL);
3909         }
3910 #endif
3911
3912         return STATUS_SUCCESS;
3913 }
3914
3915 int mg_rsp(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3916 {
3917         struct ms_info *ms_card = &(chip->ms_card);
3918         int retval;
3919         int i;
3920         int bufflen;
3921         unsigned int lun = SCSI_LUN(srb);
3922         u8 buf[32];
3923
3924         ms_cleanup_work(chip);
3925
3926         retval = ms_switch_clock(chip);
3927         if (retval != STATUS_SUCCESS)
3928                 TRACE_RET(chip, STATUS_FAIL);
3929
3930         retval = mg_send_ex_cmd(chip, MG_MAKE_KSE, 0);
3931         if (retval != STATUS_SUCCESS) {
3932                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN);
3933                 TRACE_RET(chip, STATUS_FAIL);
3934         }
3935
3936         bufflen = min_t(int, 12, scsi_bufflen(srb));
3937         rtsx_stor_get_xfer_buf(buf, bufflen, srb);
3938
3939         for (i = 0; i < 8; i++)
3940                 buf[i] = buf[4+i];
3941
3942         for (i = 0; i < 24; i++)
3943                 buf[8+i] = 0;
3944
3945         retval = ms_write_bytes(chip, PRO_WRITE_SHORT_DATA, 32, WAIT_INT,
3946                                 buf, 32);
3947         if (retval != STATUS_SUCCESS) {
3948                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN);
3949                 TRACE_RET(chip, STATUS_FAIL);
3950         }
3951         if (check_ms_err(chip)) {
3952                 set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN);
3953                 rtsx_clear_ms_error(chip);
3954                 TRACE_RET(chip, STATUS_FAIL);
3955         }
3956
3957         ms_card->mg_auth = 1;
3958
3959         return STATUS_SUCCESS;
3960 }
3961
3962 int mg_get_ICV(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3963 {
3964         struct ms_info *ms_card = &(chip->ms_card);
3965         int retval;
3966         int bufflen;
3967         unsigned int lun = SCSI_LUN(srb);
3968         u8 *buf = NULL;
3969
3970         ms_cleanup_work(chip);
3971
3972         retval = ms_switch_clock(chip);
3973         if (retval != STATUS_SUCCESS)
3974                 TRACE_RET(chip, STATUS_FAIL);
3975
3976         buf = kmalloc(1028, GFP_KERNEL);
3977         if (!buf)
3978                 TRACE_RET(chip, STATUS_ERROR);
3979
3980         buf[0] = 0x04;
3981         buf[1] = 0x02;
3982         buf[2] = 0x00;
3983         buf[3] = 0x00;
3984
3985         retval = mg_send_ex_cmd(chip, MG_GET_IBD, ms_card->mg_entry_num);
3986         if (retval != STATUS_SUCCESS) {
3987                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
3988                 TRACE_GOTO(chip, GetICVFinish);
3989         }
3990
3991         retval = ms_transfer_data(chip, MS_TM_AUTO_READ, PRO_READ_LONG_DATA,
3992                                 2, WAIT_INT, 0, 0, buf + 4, 1024);
3993         if (retval != STATUS_SUCCESS) {
3994                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
3995                 rtsx_clear_ms_error(chip);
3996                 TRACE_GOTO(chip, GetICVFinish);
3997         }
3998         if (check_ms_err(chip)) {
3999                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
4000                 rtsx_clear_ms_error(chip);
4001                 TRACE_RET(chip, STATUS_FAIL);
4002         }
4003
4004         bufflen = min_t(int, 1028, scsi_bufflen(srb));
4005         rtsx_stor_set_xfer_buf(buf, bufflen, srb);
4006
4007 GetICVFinish:
4008         kfree(buf);
4009         return retval;
4010 }
4011
4012 int mg_set_ICV(struct scsi_cmnd *srb, struct rtsx_chip *chip)
4013 {
4014         struct ms_info *ms_card = &(chip->ms_card);
4015         int retval;
4016         int bufflen;
4017 #ifdef MG_SET_ICV_SLOW
4018         int i;
4019 #endif
4020         unsigned int lun = SCSI_LUN(srb);
4021         u8 *buf = NULL;
4022
4023         ms_cleanup_work(chip);
4024
4025         retval = ms_switch_clock(chip);
4026         if (retval != STATUS_SUCCESS)
4027                 TRACE_RET(chip, STATUS_FAIL);
4028
4029         buf = kmalloc(1028, GFP_KERNEL);
4030         if (!buf)
4031                 TRACE_RET(chip, STATUS_ERROR);
4032
4033         bufflen = min_t(int, 1028, scsi_bufflen(srb));
4034         rtsx_stor_get_xfer_buf(buf, bufflen, srb);
4035
4036         retval = mg_send_ex_cmd(chip, MG_SET_IBD, ms_card->mg_entry_num);
4037         if (retval != STATUS_SUCCESS) {
4038                 if (ms_card->mg_auth == 0) {
4039                         if ((buf[5] & 0xC0) != 0)
4040                                 set_sense_type(chip, lun,
4041                                         SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB);
4042                         else
4043                                 set_sense_type(chip, lun,
4044                                         SENSE_TYPE_MG_WRITE_ERR);
4045                 } else {
4046                         set_sense_type(chip, lun, SENSE_TYPE_MG_WRITE_ERR);
4047                 }
4048                 TRACE_GOTO(chip, SetICVFinish);
4049         }
4050
4051 #ifdef MG_SET_ICV_SLOW
4052         for (i = 0; i < 2; i++) {
4053                 udelay(50);
4054
4055                 rtsx_init_cmd(chip);
4056
4057                 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TPC,
4058                         0xFF, PRO_WRITE_LONG_DATA);
4059                 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANS_CFG, 0xFF, WAIT_INT);
4060                 rtsx_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE,
4061                         0x01, RING_BUFFER);
4062
4063                 trans_dma_enable(DMA_TO_DEVICE, chip, 512, DMA_512);
4064
4065                 rtsx_add_cmd(chip, WRITE_REG_CMD, MS_TRANSFER, 0xFF,
4066                                 MS_TRANSFER_START |  MS_TM_NORMAL_WRITE);
4067                 rtsx_add_cmd(chip, CHECK_REG_CMD, MS_TRANSFER,
4068                         MS_TRANSFER_END, MS_TRANSFER_END);
4069
4070                 rtsx_send_cmd_no_wait(chip);
4071
4072                 retval = rtsx_transfer_data(chip, MS_CARD, buf + 4 + i*512,
4073                                         512, 0, DMA_TO_DEVICE, 3000);
4074                 if ((retval < 0) || check_ms_err(chip)) {
4075                         rtsx_clear_ms_error(chip);
4076                         if (ms_card->mg_auth == 0) {
4077                                 if ((buf[5] & 0xC0) != 0)
4078                                         set_sense_type(chip, lun, SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB);
4079                                 else
4080                                         set_sense_type(chip, lun,
4081                                                 SENSE_TYPE_MG_WRITE_ERR);
4082                         } else {
4083                                 set_sense_type(chip, lun,
4084                                         SENSE_TYPE_MG_WRITE_ERR);
4085                         }
4086                         retval = STATUS_FAIL;
4087                         TRACE_GOTO(chip, SetICVFinish);
4088                 }
4089         }
4090 #else
4091         retval = ms_transfer_data(chip, MS_TM_AUTO_WRITE, PRO_WRITE_LONG_DATA,
4092                                 2, WAIT_INT, 0, 0, buf + 4, 1024);
4093         if ((retval != STATUS_SUCCESS) || check_ms_err(chip)) {
4094                 rtsx_clear_ms_error(chip);
4095                 if (ms_card->mg_auth == 0) {
4096                         if ((buf[5] & 0xC0) != 0)
4097                                 set_sense_type(chip, lun,
4098                                         SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB);
4099                         else
4100                                 set_sense_type(chip, lun,
4101                                         SENSE_TYPE_MG_WRITE_ERR);
4102                 } else {
4103                         set_sense_type(chip, lun, SENSE_TYPE_MG_WRITE_ERR);
4104                 }
4105                 TRACE_GOTO(chip, SetICVFinish);
4106         }
4107 #endif
4108
4109 SetICVFinish:
4110         kfree(buf);
4111         return retval;
4112 }
4113
4114 #endif /* SUPPORT_MAGIC_GATE */
4115
4116 void ms_cleanup_work(struct rtsx_chip *chip)
4117 {
4118         struct ms_info *ms_card = &(chip->ms_card);
4119
4120         if (CHK_MSPRO(ms_card)) {
4121                 if (ms_card->seq_mode) {
4122                         dev_dbg(rtsx_dev(chip), "MS Pro: stop transmission\n");
4123                         mspro_stop_seq_mode(chip);
4124                         ms_card->cleanup_counter = 0;
4125                 }
4126                 if (CHK_MSHG(ms_card)) {
4127                         rtsx_write_register(chip, MS_CFG,
4128                                 MS_2K_SECTOR_MODE, 0x00);
4129                 }
4130         }
4131 #ifdef MS_DELAY_WRITE
4132         else if ((!CHK_MSPRO(ms_card)) && ms_card->delay_write.delay_write_flag) {
4133                 dev_dbg(rtsx_dev(chip), "MS: delay write\n");
4134                 ms_delay_write(chip);
4135                 ms_card->cleanup_counter = 0;
4136         }
4137 #endif
4138 }
4139
4140 int ms_power_off_card3v3(struct rtsx_chip *chip)
4141 {
4142         int retval;
4143
4144         retval = disable_card_clock(chip, MS_CARD);
4145         if (retval != STATUS_SUCCESS)
4146                 TRACE_RET(chip, STATUS_FAIL);
4147
4148         if (chip->asic_code) {
4149                 retval = ms_pull_ctl_disable(chip);
4150                 if (retval != STATUS_SUCCESS)
4151                         TRACE_RET(chip, STATUS_FAIL);
4152         } else {
4153                 RTSX_WRITE_REG(chip, FPGA_PULL_CTL,
4154                         FPGA_MS_PULL_CTL_BIT | 0x20, FPGA_MS_PULL_CTL_BIT);
4155         }
4156         RTSX_WRITE_REG(chip, CARD_OE, MS_OUTPUT_EN, 0);
4157         if (!chip->ft2_fast_mode) {
4158                 retval = card_power_off(chip, MS_CARD);
4159                 if (retval != STATUS_SUCCESS)
4160                         TRACE_RET(chip, STATUS_FAIL);
4161         }
4162
4163         return STATUS_SUCCESS;
4164 }
4165
4166 int release_ms_card(struct rtsx_chip *chip)
4167 {
4168         struct ms_info *ms_card = &(chip->ms_card);
4169         int retval;
4170
4171 #ifdef MS_DELAY_WRITE
4172         ms_card->delay_write.delay_write_flag = 0;
4173 #endif
4174         ms_card->pro_under_formatting = 0;
4175
4176         chip->card_ready &= ~MS_CARD;
4177         chip->card_fail &= ~MS_CARD;
4178         chip->card_wp &= ~MS_CARD;
4179
4180         ms_free_l2p_tbl(chip);
4181
4182         memset(ms_card->raw_sys_info, 0, 96);
4183 #ifdef SUPPORT_PCGL_1P18
4184         memset(ms_card->raw_model_name, 0, 48);
4185 #endif
4186
4187         retval = ms_power_off_card3v3(chip);
4188         if (retval != STATUS_SUCCESS)
4189                 TRACE_RET(chip, STATUS_FAIL);
4190
4191         return STATUS_SUCCESS;
4192 }