drivers/staging/rts_pstor/rtsx_scsi.c

   1 /* Driver for Realtek PCI-Express card reader
   2  *
   3  * Copyright(c) 2009 Realtek Semiconductor Corp. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2, or (at your option) any
   8  * later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * Author:
  19  *   wwang (wei_wang@realsil.com.cn)
  20  *   No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
  21  */
  22
  23 #include <linux/blkdev.h>
  24 #include <linux/kthread.h>
  25 #include <linux/sched.h>
  26 #include <linux/vmalloc.h>
  27
  28 #include "rtsx.h"
  29 #include "rtsx_transport.h"
  30 #include "rtsx_sys.h"
  31 #include "rtsx_card.h"
  32 #include "rtsx_chip.h"
  33 #include "rtsx_scsi.h"
  34 #include "sd.h"
  35 #include "ms.h"
  36 #include "spi.h"
  37
  38 void scsi_show_command(struct scsi_cmnd *srb)
  39 {
  40         char *what = NULL;
  41         int i, unknown_cmd = 0;
  42
  43         switch (srb->cmnd[0]) {
  44         case TEST_UNIT_READY: what = "TEST_UNIT_READY"; break;
  45         case REZERO_UNIT: what = "REZERO_UNIT"; break;
  46         case REQUEST_SENSE: what = "REQUEST_SENSE"; break;
  47         case FORMAT_UNIT: what = "FORMAT_UNIT"; break;
  48         case READ_BLOCK_LIMITS: what = "READ_BLOCK_LIMITS"; break;
  49         case REASSIGN_BLOCKS: what = "REASSIGN_BLOCKS"; break;
  50         case READ_6: what = "READ_6"; break;
  51         case WRITE_6: what = "WRITE_6"; break;
  52         case SEEK_6: what = "SEEK_6"; break;
  53         case READ_REVERSE: what = "READ_REVERSE"; break;
  54         case WRITE_FILEMARKS: what = "WRITE_FILEMARKS"; break;
  55         case SPACE: what = "SPACE"; break;
  56         case INQUIRY: what = "INQUIRY"; break;
  57         case RECOVER_BUFFERED_DATA: what = "RECOVER_BUFFERED_DATA"; break;
  58         case MODE_SELECT: what = "MODE_SELECT"; break;
  59         case RESERVE: what = "RESERVE"; break;
  60         case RELEASE: what = "RELEASE"; break;
  61         case COPY: what = "COPY"; break;
  62         case ERASE: what = "ERASE"; break;
  63         case MODE_SENSE: what = "MODE_SENSE"; break;
  64         case START_STOP: what = "START_STOP"; break;
  65         case RECEIVE_DIAGNOSTIC: what = "RECEIVE_DIAGNOSTIC"; break;
  66         case SEND_DIAGNOSTIC: what = "SEND_DIAGNOSTIC"; break;
  67         case ALLOW_MEDIUM_REMOVAL: what = "ALLOW_MEDIUM_REMOVAL"; break;
  68         case SET_WINDOW: what = "SET_WINDOW"; break;
  69         case READ_CAPACITY: what = "READ_CAPACITY"; break;
  70         case READ_10: what = "READ_10"; break;
  71         case WRITE_10: what = "WRITE_10"; break;
  72         case SEEK_10: what = "SEEK_10"; break;
  73         case WRITE_VERIFY: what = "WRITE_VERIFY"; break;
  74         case VERIFY: what = "VERIFY"; break;
  75         case SEARCH_HIGH: what = "SEARCH_HIGH"; break;
  76         case SEARCH_EQUAL: what = "SEARCH_EQUAL"; break;
  77         case SEARCH_LOW: what = "SEARCH_LOW"; break;
  78         case SET_LIMITS: what = "SET_LIMITS"; break;
  79         case READ_POSITION: what = "READ_POSITION"; break;
  80         case SYNCHRONIZE_CACHE: what = "SYNCHRONIZE_CACHE"; break;
  81         case LOCK_UNLOCK_CACHE: what = "LOCK_UNLOCK_CACHE"; break;
  82         case READ_DEFECT_DATA: what = "READ_DEFECT_DATA"; break;
  83         case MEDIUM_SCAN: what = "MEDIUM_SCAN"; break;
  84         case COMPARE: what = "COMPARE"; break;
  85         case COPY_VERIFY: what = "COPY_VERIFY"; break;
  86         case WRITE_BUFFER: what = "WRITE_BUFFER"; break;
  87         case READ_BUFFER: what = "READ_BUFFER"; break;
  88         case UPDATE_BLOCK: what = "UPDATE_BLOCK"; break;
  89         case READ_LONG: what = "READ_LONG"; break;
  90         case WRITE_LONG: what = "WRITE_LONG"; break;
  91         case CHANGE_DEFINITION: what = "CHANGE_DEFINITION"; break;
  92         case WRITE_SAME: what = "WRITE_SAME"; break;
  93         case GPCMD_READ_SUBCHANNEL: what = "READ SUBCHANNEL"; break;
  94         case READ_TOC: what = "READ_TOC"; break;
  95         case GPCMD_READ_HEADER: what = "READ HEADER"; break;
  96         case GPCMD_PLAY_AUDIO_10: what = "PLAY AUDIO (10)"; break;
  97         case GPCMD_PLAY_AUDIO_MSF: what = "PLAY AUDIO MSF"; break;
  98         case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
  99                 what = "GET EVENT/STATUS NOTIFICATION"; break;
 100         case GPCMD_PAUSE_RESUME: what = "PAUSE/RESUME"; break;
 101         case LOG_SELECT: what = "LOG_SELECT"; break;
 102         case LOG_SENSE: what = "LOG_SENSE"; break;
 103         case GPCMD_STOP_PLAY_SCAN: what = "STOP PLAY/SCAN"; break;
 104         case GPCMD_READ_DISC_INFO: what = "READ DISC INFORMATION"; break;
 105         case GPCMD_READ_TRACK_RZONE_INFO:
 106                 what = "READ TRACK INFORMATION"; break;
 107         case GPCMD_RESERVE_RZONE_TRACK: what = "RESERVE TRACK"; break;
 108         case GPCMD_SEND_OPC: what = "SEND OPC"; break;
 109         case MODE_SELECT_10: what = "MODE_SELECT_10"; break;
 110         case GPCMD_REPAIR_RZONE_TRACK: what = "REPAIR TRACK"; break;
 111         case 0x59: what = "READ MASTER CUE"; break;
 112         case MODE_SENSE_10: what = "MODE_SENSE_10"; break;
 113         case GPCMD_CLOSE_TRACK: what = "CLOSE TRACK/SESSION"; break;
 114         case 0x5C: what = "READ BUFFER CAPACITY"; break;
 115         case 0x5D: what = "SEND CUE SHEET"; break;
 116         case GPCMD_BLANK: what = "BLANK"; break;
 117         case REPORT_LUNS: what = "REPORT LUNS"; break;
 118         case MOVE_MEDIUM: what = "MOVE_MEDIUM or PLAY AUDIO (12)"; break;
 119         case READ_12: what = "READ_12"; break;
 120         case WRITE_12: what = "WRITE_12"; break;
 121         case WRITE_VERIFY_12: what = "WRITE_VERIFY_12"; break;
 122         case SEARCH_HIGH_12: what = "SEARCH_HIGH_12"; break;
 123         case SEARCH_EQUAL_12: what = "SEARCH_EQUAL_12"; break;
 124         case SEARCH_LOW_12: what = "SEARCH_LOW_12"; break;
 125         case SEND_VOLUME_TAG: what = "SEND_VOLUME_TAG"; break;
 126         case READ_ELEMENT_STATUS: what = "READ_ELEMENT_STATUS"; break;
 127         case GPCMD_READ_CD_MSF: what = "READ CD MSF"; break;
 128         case GPCMD_SCAN: what = "SCAN"; break;
 129         case GPCMD_SET_SPEED: what = "SET CD SPEED"; break;
 130         case GPCMD_MECHANISM_STATUS: what = "MECHANISM STATUS"; break;
 131         case GPCMD_READ_CD: what = "READ CD"; break;
 132         case 0xE1: what = "WRITE CONTINUE"; break;
 133         case WRITE_LONG_2: what = "WRITE_LONG_2"; break;
 134         case VENDOR_CMND: what = "Realtek's vendor command"; break;
 135         default: what = "(unknown command)"; unknown_cmd = 1; break;
 136         }
 137
 138         if (srb->cmnd[0] != TEST_UNIT_READY) {
 139                 RTSX_DEBUGP("Command %s (%d bytes)\n", what, srb->cmd_len);
 140         }
 141         if (unknown_cmd) {
 142                 RTSX_DEBUGP("");
 143                 for (i = 0; i < srb->cmd_len && i < 16; i++)
 144                         RTSX_DEBUGPN(" %02x", srb->cmnd[i]);
 145                 RTSX_DEBUGPN("\n");
 146         }
 147 }
 148
 149 void set_sense_type(struct rtsx_chip *chip, unsigned int lun, int sense_type)
 150 {
 151         switch (sense_type) {
 152         case SENSE_TYPE_MEDIA_CHANGE:
 153                 set_sense_data(chip, lun, CUR_ERR, 0x06, 0, 0x28, 0, 0, 0);
 154                 break;
 155
 156         case SENSE_TYPE_MEDIA_NOT_PRESENT:
 157                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x3A, 0, 0, 0);
 158                 break;
 159
 160         case SENSE_TYPE_MEDIA_LBA_OVER_RANGE:
 161                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x21, 0, 0, 0);
 162                 break;
 163
 164         case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT:
 165                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x25, 0, 0, 0);
 166                 break;
 167
 168         case SENSE_TYPE_MEDIA_WRITE_PROTECT:
 169                 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x27, 0, 0, 0);
 170                 break;
 171
 172         case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR:
 173                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x11, 0, 0, 0);
 174                 break;
 175
 176         case SENSE_TYPE_MEDIA_WRITE_ERR:
 177                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x02, 0, 0);
 178                 break;
 179
 180         case SENSE_TYPE_MEDIA_INVALID_CMD_FIELD:
 181                 set_sense_data(chip, lun, CUR_ERR, ILGAL_REQ, 0,
 182                                 ASC_INVLD_CDB, ASCQ_INVLD_CDB, CDB_ILLEGAL, 1);
 183                 break;
 184
 185         case SENSE_TYPE_FORMAT_IN_PROGRESS:
 186                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 0, 0);
 187                 break;
 188
 189         case SENSE_TYPE_FORMAT_CMD_FAILED:
 190                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x31, 0x01, 0, 0);
 191                 break;
 192
 193 #ifdef SUPPORT_MAGIC_GATE
 194         case SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB:
 195                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x02, 0, 0);
 196                 break;
 197
 198         case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN:
 199                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x00, 0, 0);
 200                 break;
 201
 202         case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM:
 203                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x30, 0x00, 0, 0);
 204                 break;
 205
 206         case SENSE_TYPE_MG_WRITE_ERR:
 207                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x00, 0, 0);
 208                 break;
 209 #endif
 210
 211 #ifdef SUPPORT_SD_LOCK
 212         case SENSE_TYPE_MEDIA_READ_FORBIDDEN:
 213                 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x11, 0x13, 0, 0);
 214                 break;
 215 #endif
 216
 217         case SENSE_TYPE_NO_SENSE:
 218         default:
 219                 set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0);
 220                 break;
 221         }
 222 }
 223
 224 void set_sense_data(struct rtsx_chip *chip, unsigned int lun, u8 err_code, u8 sense_key,
 225                 u32 info, u8 asc, u8 ascq, u8 sns_key_info0, u16 sns_key_info1)
 226 {
 227         struct sense_data_t *sense = &(chip->sense_buffer[lun]);
 228
 229         sense->err_code = err_code;
 230         sense->sense_key = sense_key;
 231         sense->info[0] = (u8)(info >> 24);
 232         sense->info[1] = (u8)(info >> 16);
 233         sense->info[2] = (u8)(info >> 8);
 234         sense->info[3] = (u8)info;
 235
 236         sense->ad_sense_len = sizeof(struct sense_data_t) - 8;
 237         sense->asc = asc;
 238         sense->ascq = ascq;
 239         if (sns_key_info0 != 0) {
 240                 sense->sns_key_info[0] = SKSV | sns_key_info0;
 241                 sense->sns_key_info[1] = (sns_key_info1 & 0xf0) >> 8;
 242                 sense->sns_key_info[2] = sns_key_info1 & 0x0f;
 243         }
 244 }
 245
 246 static int test_unit_ready(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 247 {
 248         unsigned int lun = SCSI_LUN(srb);
 249
 250         if (!check_card_ready(chip, lun)) {
 251                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 252                 return TRANSPORT_FAILED;
 253         }
 254
 255         if (!(CHK_BIT(chip->lun_mc, lun))) {
 256                 SET_BIT(chip->lun_mc, lun);
 257                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 258                 return TRANSPORT_FAILED;
 259         }
 260
 261 #ifdef SUPPORT_SD_LOCK
 262         if (get_lun_card(chip, SCSI_LUN(srb)) == SD_CARD) {
 263                 struct sd_info *sd_card = &(chip->sd_card);
 264                 if (sd_card->sd_lock_notify) {
 265                         sd_card->sd_lock_notify = 0;
 266                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 267                         return TRANSPORT_FAILED;
 268                 } else if (sd_card->sd_lock_status & SD_LOCKED) {
 269                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 270                         return TRANSPORT_FAILED;
 271                 }
 272         }
 273 #endif
 274
 275         return TRANSPORT_GOOD;
 276 }
 277
 278 static unsigned char formatter_inquiry_str[20] = {
 279         'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K',
 280 #ifdef SUPPORT_MAGIC_GATE
 281         '-', 'M', 'G', /* Byte[47:49] */
 282 #else
 283         0x20, 0x20, 0x20,  /* Byte[47:49] */
 284 #endif
 285
 286 #ifdef SUPPORT_MAGIC_GATE
 287         0x0B,  /* Byte[50]: MG, MS, MSPro, MSXC */
 288 #else
 289         0x09,  /* Byte[50]: MS, MSPro, MSXC */
 290 #endif
 291         0x00,  /* Byte[51]: Category Specific Commands */
 292         0x00,  /* Byte[52]: Access Control and feature */
 293         0x20, 0x20, 0x20, /* Byte[53:55] */
 294 };
 295
 296 static int inquiry(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 297 {
 298         unsigned int lun = SCSI_LUN(srb);
 299         char *inquiry_default = (char *)"Generic-xD/SD/M.S.      1.00 ";
 300         char *inquiry_sdms =    (char *)"Generic-SD/MemoryStick  1.00 ";
 301         char *inquiry_sd =      (char *)"Generic-SD/MMC          1.00 ";
 302         char *inquiry_ms =      (char *)"Generic-MemoryStick     1.00 ";
 303         char *inquiry_string;
 304         unsigned char sendbytes;
 305         unsigned char *buf;
 306         u8 card = get_lun_card(chip, lun);
 307         int pro_formatter_flag = 0;
 308         unsigned char inquiry_buf[] = {
 309                 QULIFIRE|DRCT_ACCESS_DEV,
 310                 RMB_DISC|0x0D,
 311                 0x00,
 312                 0x01,
 313                 0x1f,
 314                 0x02,
 315                 0,
 316                 REL_ADR|WBUS_32|WBUS_16|SYNC|LINKED|CMD_QUE|SFT_RE,
 317         };
 318
 319         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
 320                 if (chip->lun2card[lun] == SD_CARD) {
 321                         inquiry_string = inquiry_sd;
 322                 } else {
 323                         inquiry_string = inquiry_ms;
 324                 }
 325         } else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) {
 326                 inquiry_string = inquiry_sdms;
 327         } else {
 328                 inquiry_string = inquiry_default;
 329         }
 330
 331         buf = vmalloc(scsi_bufflen(srb));
 332         if (buf == NULL) {
 333                 TRACE_RET(chip, TRANSPORT_ERROR);
 334         }
 335
 336 #ifdef SUPPORT_MAGIC_GATE
 337         if ((chip->mspro_formatter_enable) &&
 338                         (chip->lun2card[lun] & MS_CARD))
 339 #else
 340         if (chip->mspro_formatter_enable)
 341 #endif
 342         {
 343                 if (!card || (card == MS_CARD)) {
 344                         pro_formatter_flag = 1;
 345                 }
 346         }
 347
 348         if (pro_formatter_flag) {
 349                 if (scsi_bufflen(srb) < 56) {
 350                         sendbytes = (unsigned char)(scsi_bufflen(srb));
 351                 } else {
 352                         sendbytes = 56;
 353                 }
 354         } else {
 355                 if (scsi_bufflen(srb) < 36) {
 356                         sendbytes = (unsigned char)(scsi_bufflen(srb));
 357                 } else {
 358                         sendbytes = 36;
 359                 }
 360         }
 361
 362         if (sendbytes > 8) {
 363                 memcpy(buf, inquiry_buf, 8);
 364                 memcpy(buf + 8, inquiry_string, sendbytes - 8);
 365                 if (pro_formatter_flag) {
 366                         /* Additional Length */
 367                         buf[4] = 0x33;
 368                 }
 369         } else {
 370                 memcpy(buf, inquiry_buf, sendbytes);
 371         }
 372
 373         if (pro_formatter_flag) {
 374                 if (sendbytes > 36) {
 375                         memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
 376                 }
 377         }
 378
 379         scsi_set_resid(srb, 0);
 380
 381         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
 382         vfree(buf);
 383
 384         return TRANSPORT_GOOD;
 385 }
 386
 387
 388 static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 389 {
 390         unsigned int lun = SCSI_LUN(srb);
 391
 392         scsi_set_resid(srb, scsi_bufflen(srb));
 393
 394         if (srb->cmnd[1] == 1)
 395                 return TRANSPORT_GOOD;
 396
 397         switch (srb->cmnd[0x4]) {
 398         case STOP_MEDIUM:
 399                 /* Media disabled */
 400                 return TRANSPORT_GOOD;
 401
 402         case UNLOAD_MEDIUM:
 403                 /* Media shall be unload */
 404                 if (check_card_ready(chip, lun))
 405                         eject_card(chip, lun);
 406                 return TRANSPORT_GOOD;
 407
 408         case MAKE_MEDIUM_READY:
 409         case LOAD_MEDIUM:
 410                 if (check_card_ready(chip, lun)) {
 411                         return TRANSPORT_GOOD;
 412                 } else {
 413                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 414                         TRACE_RET(chip, TRANSPORT_FAILED);
 415                 }
 416
 417                 break;
 418         }
 419
 420         TRACE_RET(chip, TRANSPORT_ERROR);
 421 }
 422
 423
 424 static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 425 {
 426         int prevent;
 427
 428         prevent = srb->cmnd[4] & 0x1;
 429
 430         scsi_set_resid(srb, 0);
 431
 432         if (prevent) {
 433                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 434                 TRACE_RET(chip, TRANSPORT_FAILED);
 435         }
 436
 437         return TRANSPORT_GOOD;
 438 }
 439
 440
 441 static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 442 {
 443         struct sense_data_t *sense;
 444         unsigned int lun = SCSI_LUN(srb);
 445         struct ms_info *ms_card = &(chip->ms_card);
 446         unsigned char *tmp, *buf;
 447
 448         sense = &(chip->sense_buffer[lun]);
 449
 450         if ((get_lun_card(chip, lun) == MS_CARD) && ms_card->pro_under_formatting) {
 451                 if (ms_card->format_status == FORMAT_SUCCESS) {
 452                         set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 453                         ms_card->pro_under_formatting = 0;
 454                         ms_card->progress = 0;
 455                 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) {
 456                         /* Logical Unit Not Ready Format in Progress */
 457                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
 458                                         0, (u16)(ms_card->progress));
 459                 } else {
 460                         /* Format Command Failed */
 461                         set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
 462                         ms_card->pro_under_formatting = 0;
 463                         ms_card->progress = 0;
 464                 }
 465
 466                 rtsx_set_stat(chip, RTSX_STAT_RUN);
 467         }
 468
 469         buf = vmalloc(scsi_bufflen(srb));
 470         if (buf == NULL) {
 471                 TRACE_RET(chip, TRANSPORT_ERROR);
 472         }
 473
 474         tmp = (unsigned char *)sense;
 475         memcpy(buf, tmp, scsi_bufflen(srb));
 476
 477         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
 478         vfree(buf);
 479
 480         scsi_set_resid(srb, 0);
 481         /* Reset Sense Data */
 482         set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 483         return TRANSPORT_GOOD;
 484 }
 485
 486 static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
 487                 int lun, u8 *buf, int buf_len)
 488 {
 489         struct ms_info *ms_card = &(chip->ms_card);
 490         int sys_info_offset;
 491         int data_size = buf_len;
 492         int support_format = 0;
 493         int i = 0;
 494
 495         if (cmd == MODE_SENSE) {
 496                 sys_info_offset = 8;
 497                 if (data_size > 0x68) {
 498                         data_size = 0x68;
 499                 }
 500                 buf[i++] = 0x67;  /* Mode Data Length */
 501         } else {
 502                 sys_info_offset = 12;
 503                 if (data_size > 0x6C) {
 504                         data_size = 0x6C;
 505                 }
 506                 buf[i++] = 0x00;  /* Mode Data Length (MSB) */
 507                 buf[i++] = 0x6A;  /* Mode Data Length (LSB) */
 508         }
 509
 510         /* Medium Type Code */
 511         if (check_card_ready(chip, lun)) {
 512                 if (CHK_MSXC(ms_card)) {
 513                         support_format = 1;
 514                         buf[i++] = 0x40;
 515                 } else if (CHK_MSPRO(ms_card)) {
 516                         support_format = 1;
 517                         buf[i++] = 0x20;
 518                 } else {
 519                         buf[i++] = 0x10;
 520                 }
 521
 522                 /* WP */
 523                 if (check_card_wp(chip, lun)) {
 524                         buf[i++] = 0x80;
 525                 } else {
 526                         buf[i++] = 0x00;
 527                 }
 528         } else {
 529                 buf[i++] = 0x00;        /* MediaType */
 530                 buf[i++] = 0x00;        /* WP */
 531         }
 532
 533         buf[i++] = 0x00;                /* Reserved */
 534
 535         if (cmd == MODE_SENSE_10) {
 536                 buf[i++] = 0x00;  /* Reserved */
 537                 buf[i++] = 0x00;  /* Block descriptor length(MSB) */
 538                 buf[i++] = 0x00;  /* Block descriptor length(LSB) */
 539
 540                 /* The Following Data is the content of "Page 0x20" */
 541                 if (data_size >= 9)
 542                         buf[i++] = 0x20;                /* Page Code */
 543                 if (data_size >= 10)
 544                         buf[i++] = 0x62;                /* Page Length */
 545                 if (data_size >= 11)
 546                         buf[i++] = 0x00;                /* No Access Control */
 547                 if (data_size >= 12) {
 548                         if (support_format) {
 549                                 buf[i++] = 0xC0;        /* SF, SGM */
 550                         } else {
 551                                 buf[i++] = 0x00;
 552                         }
 553                 }
 554         } else {
 555                 /* The Following Data is the content of "Page 0x20" */
 556                 if (data_size >= 5)
 557                         buf[i++] = 0x20;                /* Page Code */
 558                 if (data_size >= 6)
 559                         buf[i++] = 0x62;                /* Page Length */
 560                 if (data_size >= 7)
 561                         buf[i++] = 0x00;                /* No Access Control */
 562                 if (data_size >= 8) {
 563                         if (support_format) {
 564                                 buf[i++] = 0xC0;        /* SF, SGM */
 565                         } else {
 566                                 buf[i++] = 0x00;
 567                         }
 568                 }
 569         }
 570
 571         if (data_size > sys_info_offset) {
 572                 /* 96 Bytes Attribute Data */
 573                 int len = data_size - sys_info_offset;
 574                 len = (len < 96) ? len : 96;
 575
 576                 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
 577         }
 578 }
 579
 580 static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 581 {
 582         unsigned int lun = SCSI_LUN(srb);
 583         unsigned int dataSize;
 584         int status;
 585         int pro_formatter_flag;
 586         unsigned char pageCode, *buf;
 587         u8 card = get_lun_card(chip, lun);
 588
 589 #ifndef SUPPORT_MAGIC_GATE
 590         if (!check_card_ready(chip, lun)) {
 591                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 592                 scsi_set_resid(srb, scsi_bufflen(srb));
 593                 TRACE_RET(chip, TRANSPORT_FAILED);
 594         }
 595 #endif
 596
 597         pro_formatter_flag = 0;
 598         dataSize = 8;
 599 #ifdef SUPPORT_MAGIC_GATE
 600         if ((chip->lun2card[lun] & MS_CARD)) {
 601                 if (!card || (card == MS_CARD)) {
 602                         dataSize = 108;
 603                         if (chip->mspro_formatter_enable) {
 604                                 pro_formatter_flag = 1;
 605                         }
 606                 }
 607         }
 608 #else
 609         if (card == MS_CARD) {
 610                 if (chip->mspro_formatter_enable) {
 611                         pro_formatter_flag = 1;
 612                         dataSize = 108;
 613                 }
 614         }
 615 #endif
 616
 617         buf = kmalloc(dataSize, GFP_KERNEL);
 618         if (buf == NULL) {
 619                 TRACE_RET(chip, TRANSPORT_ERROR);
 620         }
 621
 622         pageCode = srb->cmnd[2] & 0x3f;
 623
 624         if ((pageCode == 0x3F) || (pageCode == 0x1C) ||
 625                 (pageCode == 0x00) ||
 626                 (pro_formatter_flag && (pageCode == 0x20))) {
 627                 if (srb->cmnd[0] == MODE_SENSE) {
 628                         if ((pageCode == 0x3F) || (pageCode == 0x20)) {
 629                                 ms_mode_sense(chip, srb->cmnd[0],
 630                                               lun, buf, dataSize);
 631                         } else {
 632                                 dataSize = 4;
 633                                 buf[0] = 0x03;
 634                                 buf[1] = 0x00;
 635                                 if (check_card_wp(chip, lun)) {
 636                                         buf[2] = 0x80;
 637                                 } else {
 638                                         buf[2] = 0x00;
 639                                 }
 640                                 buf[3] = 0x00;
 641                         }
 642                 } else {
 643                         if ((pageCode == 0x3F) || (pageCode == 0x20)) {
 644                                 ms_mode_sense(chip, srb->cmnd[0],
 645                                               lun, buf, dataSize);
 646                         } else {
 647                                 dataSize = 8;
 648                                 buf[0] = 0x00;
 649                                 buf[1] = 0x06;
 650                                 buf[2] = 0x00;
 651                                 if (check_card_wp(chip, lun)) {
 652                                         buf[3] = 0x80;
 653                                 } else {
 654                                         buf[3] = 0x00;
 655                                 }
 656                                 buf[4] = 0x00;
 657                                 buf[5] = 0x00;
 658                                 buf[6] = 0x00;
 659                                 buf[7] = 0x00;
 660                         }
 661                 }
 662                 status = TRANSPORT_GOOD;
 663         } else {
 664                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 665                 scsi_set_resid(srb, scsi_bufflen(srb));
 666                 status = TRANSPORT_FAILED;
 667         }
 668
 669         if (status == TRANSPORT_GOOD) {
 670                 unsigned int len = min(scsi_bufflen(srb), dataSize);
 671                 rtsx_stor_set_xfer_buf(buf, len, srb);
 672                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
 673         }
 674         kfree(buf);
 675
 676         return status;
 677 }
 678
 679 static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 680 {
 681 #ifdef SUPPORT_SD_LOCK
 682         struct sd_info *sd_card = &(chip->sd_card);
 683 #endif
 684         unsigned int lun = SCSI_LUN(srb);
 685         int retval;
 686         u32 start_sec;
 687         u16 sec_cnt;
 688
 689         rtsx_disable_aspm(chip);
 690
 691         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
 692                 rtsx_exit_ss(chip);
 693                 wait_timeout(100);
 694         }
 695         rtsx_set_stat(chip, RTSX_STAT_RUN);
 696
 697         if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) {
 698                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 699                 TRACE_RET(chip, TRANSPORT_FAILED);
 700         }
 701
 702         if (!(CHK_BIT(chip->lun_mc, lun))) {
 703                 SET_BIT(chip->lun_mc, lun);
 704                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 705                 return TRANSPORT_FAILED;
 706         }
 707
 708 #ifdef SUPPORT_SD_LOCK
 709         if (sd_card->sd_erase_status) {
 710                 /* Accessing to any card is forbidden
 711                  * until the erase procedure of SD is completed
 712                  */
 713                 RTSX_DEBUGP("SD card being erased!\n");
 714                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 715                 TRACE_RET(chip, TRANSPORT_FAILED);
 716         }
 717
 718         if (get_lun_card(chip, lun) == SD_CARD) {
 719                 if (sd_card->sd_lock_status & SD_LOCKED) {
 720                         RTSX_DEBUGP("SD card locked!\n");
 721                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 722                         TRACE_RET(chip, TRANSPORT_FAILED);
 723                 }
 724         }
 725 #endif
 726
 727         if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
 728                 start_sec = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) |
 729                         ((u32)srb->cmnd[4] << 8) | ((u32)srb->cmnd[5]);
 730                 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
 731         } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
 732                 start_sec = ((u32)(srb->cmnd[1] & 0x1F) << 16) |
 733                         ((u32)srb->cmnd[2] << 8) | ((u32)srb->cmnd[3]);
 734                 sec_cnt = srb->cmnd[4];
 735         } else if ((srb->cmnd[0] == VENDOR_CMND) && (srb->cmnd[1] == SCSI_APP_CMD) &&
 736                         ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) {
 737                 start_sec = ((u32)srb->cmnd[4] << 24) | ((u32)srb->cmnd[5] << 16) |
 738                         ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]);
 739                 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10];
 740         } else {
 741                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 742                 TRACE_RET(chip, TRANSPORT_FAILED);
 743         }
 744
 745         /* In some test, we will receive a start_sec like 0xFFFFFFFF.
 746          * In this situation, start_sec + sec_cnt will overflow, so we
 747          * need to judge start_sec at first
 748          */
 749         if ((start_sec > get_card_size(chip, lun)) ||
 750                         ((start_sec + sec_cnt) > get_card_size(chip, lun))) {
 751                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
 752                 TRACE_RET(chip, TRANSPORT_FAILED);
 753         }
 754
 755         if (sec_cnt == 0) {
 756                 scsi_set_resid(srb, 0);
 757                 return TRANSPORT_GOOD;
 758         }
 759
 760         if (chip->rw_fail_cnt[lun] == 3) {
 761                 RTSX_DEBUGP("read/write fail three times in succession\n");
 762                 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
 763                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
 764                 } else {
 765                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
 766                 }
 767                 TRACE_RET(chip, TRANSPORT_FAILED);
 768         }
 769
 770         if (srb->sc_data_direction == DMA_TO_DEVICE) {
 771                 if (check_card_wp(chip, lun)) {
 772                         RTSX_DEBUGP("Write protected card!\n");
 773                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
 774                         TRACE_RET(chip, TRANSPORT_FAILED);
 775                 }
 776                 if (CHECK_PID(chip, 0x5209) && chip->max_payload) {
 777                         u8 val = 0x10 | (chip->max_payload << 5);
 778                         retval = rtsx_write_cfg_dw(chip, 0, 0x78, 0xFF, val);
 779                         if (retval != STATUS_SUCCESS) {
 780                                 TRACE_RET(chip, TRANSPORT_ERROR);
 781                         }
 782                 }
 783         }
 784
 785         retval = card_rw(srb, chip, start_sec, sec_cnt);
 786         if (retval != STATUS_SUCCESS) {
 787                 if (chip->need_release & chip->lun2card[lun]) {
 788                         chip->rw_fail_cnt[lun] = 0;
 789                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 790                 } else {
 791                         chip->rw_fail_cnt[lun]++;
 792                         if (srb->sc_data_direction == DMA_FROM_DEVICE) {
 793                                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
 794                         } else {
 795                                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
 796                         }
 797                 }
 798                 retval = TRANSPORT_FAILED;
 799                 TRACE_GOTO(chip, Exit);
 800         } else {
 801                 chip->rw_fail_cnt[lun] = 0;
 802                 retval = TRANSPORT_GOOD;
 803         }
 804
 805         scsi_set_resid(srb, 0);
 806
 807 Exit:
 808         if (srb->sc_data_direction == DMA_TO_DEVICE) {
 809                 if (CHECK_PID(chip, 0x5209) && chip->max_payload) {
 810                         retval = rtsx_write_cfg_dw(chip, 0, 0x78, 0xFF, 0x10);
 811                         if (retval != STATUS_SUCCESS) {
 812                                 TRACE_RET(chip, TRANSPORT_ERROR);
 813                         }
 814                 }
 815         }
 816
 817         return retval;
 818 }
 819
 820 static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 821 {
 822         unsigned char *buf;
 823         unsigned int lun = SCSI_LUN(srb);
 824         unsigned int buf_len;
 825         u8 card = get_lun_card(chip, lun);
 826         u32 card_size;
 827         int desc_cnt;
 828         int i = 0;
 829
 830         if (!check_card_ready(chip, lun)) {
 831                 if (!chip->mspro_formatter_enable) {
 832                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 833                         TRACE_RET(chip, TRANSPORT_FAILED);
 834                 }
 835         }
 836
 837         buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
 838
 839         buf = kmalloc(buf_len, GFP_KERNEL);
 840         if (buf == NULL) {
 841                 TRACE_RET(chip, TRANSPORT_ERROR);
 842         }
 843
 844         buf[i++] = 0;
 845         buf[i++] = 0;
 846         buf[i++] = 0;
 847
 848         /* Capacity List Length */
 849         if ((buf_len > 12) && chip->mspro_formatter_enable &&
 850                         (chip->lun2card[lun] & MS_CARD) &&
 851                         (!card || (card == MS_CARD))) {
 852                 buf[i++] = 0x10;
 853                 desc_cnt = 2;
 854         } else {
 855                 buf[i++] = 0x08;
 856                 desc_cnt = 1;
 857         }
 858
 859         while (desc_cnt) {
 860                 if (check_card_ready(chip, lun)) {
 861                         card_size = get_card_size(chip, lun);
 862                         buf[i++] = (unsigned char)(card_size >> 24);
 863                         buf[i++] = (unsigned char)(card_size >> 16);
 864                         buf[i++] = (unsigned char)(card_size >> 8);
 865                         buf[i++] = (unsigned char)card_size;
 866
 867                         if (desc_cnt == 2) {
 868                                 buf[i++] = 2;
 869                         } else {
 870                                 buf[i++] = 0;
 871                         }
 872                 } else {
 873                         buf[i++] = 0xFF;
 874                         buf[i++] = 0xFF;
 875                         buf[i++] = 0xFF;
 876                         buf[i++] = 0xFF;
 877
 878                         if (desc_cnt == 2) {
 879                                 buf[i++] = 3;
 880                         } else {
 881                                 buf[i++] = 0;
 882                         }
 883                 }
 884
 885                 buf[i++] = 0x00;
 886                 buf[i++] = 0x02;
 887                 buf[i++] = 0x00;
 888
 889                 desc_cnt--;
 890         }
 891
 892         buf_len = min(scsi_bufflen(srb), buf_len);
 893         rtsx_stor_set_xfer_buf(buf, buf_len, srb);
 894         kfree(buf);
 895
 896         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
 897
 898         return TRANSPORT_GOOD;
 899 }
 900
 901 static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 902 {
 903         unsigned char *buf;
 904         unsigned int lun = SCSI_LUN(srb);
 905         u32 card_size;
 906
 907         if (!check_card_ready(chip, lun)) {
 908                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 909                 TRACE_RET(chip, TRANSPORT_FAILED);
 910         }
 911
 912         if (!(CHK_BIT(chip->lun_mc, lun))) {
 913                 SET_BIT(chip->lun_mc, lun);
 914                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 915                 return TRANSPORT_FAILED;
 916         }
 917
 918         buf = kmalloc(8, GFP_KERNEL);
 919         if (buf == NULL) {
 920                 TRACE_RET(chip, TRANSPORT_ERROR);
 921         }
 922
 923         card_size = get_card_size(chip, lun);
 924         buf[0] = (unsigned char)((card_size - 1) >> 24);
 925         buf[1] = (unsigned char)((card_size - 1) >> 16);
 926         buf[2] = (unsigned char)((card_size - 1) >> 8);
 927         buf[3] = (unsigned char)(card_size - 1);
 928
 929         buf[4] = 0x00;
 930         buf[5] = 0x00;
 931         buf[6] = 0x02;
 932         buf[7] = 0x00;
 933
 934         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
 935         kfree(buf);
 936
 937         scsi_set_resid(srb, 0);
 938
 939         return TRANSPORT_GOOD;
 940 }
 941
 942 static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 943 {
 944         unsigned short len, i;
 945         int retval;
 946         u8 *buf;
 947
 948         rtsx_disable_aspm(chip);
 949
 950         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
 951                 rtsx_exit_ss(chip);
 952                 wait_timeout(100);
 953         }
 954         rtsx_set_stat(chip, RTSX_STAT_RUN);
 955
 956         len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
 957
 958         buf = (u8 *)vmalloc(len);
 959         if (!buf) {
 960                 TRACE_RET(chip, TRANSPORT_ERROR);
 961         }
 962
 963         retval = rtsx_force_power_on(chip, SSC_PDCTL);
 964         if (retval != STATUS_SUCCESS) {
 965                 vfree(buf);
 966                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
 967                 TRACE_RET(chip, TRANSPORT_FAILED);
 968         }
 969
 970         for (i = 0; i < len; i++) {
 971                 retval = spi_read_eeprom(chip, i, buf + i);
 972                 if (retval != STATUS_SUCCESS) {
 973                         vfree(buf);
 974                         set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
 975                         TRACE_RET(chip, TRANSPORT_FAILED);
 976                 }
 977         }
 978
 979         len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
 980         rtsx_stor_set_xfer_buf(buf, len, srb);
 981         scsi_set_resid(srb, scsi_bufflen(srb) - len);
 982
 983         vfree(buf);
 984
 985         return TRANSPORT_GOOD;
 986 }
 987
 988 static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 989 {
 990         unsigned short len, i;
 991         int retval;
 992         u8 *buf;
 993
 994         rtsx_disable_aspm(chip);
 995
 996         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
 997                 rtsx_exit_ss(chip);
 998                 wait_timeout(100);
 999         }
1000         rtsx_set_stat(chip, RTSX_STAT_RUN);
1001
1002         len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1003
1004         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1005         if (retval != STATUS_SUCCESS) {
1006                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1007                 TRACE_RET(chip, TRANSPORT_FAILED);
1008         }
1009
1010         if (len == 511) {
1011                 retval = spi_erase_eeprom_chip(chip);
1012                 if (retval != STATUS_SUCCESS) {
1013                         set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1014                         TRACE_RET(chip, TRANSPORT_FAILED);
1015                 }
1016         } else {
1017                 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1018                 buf = (u8 *)vmalloc(len);
1019                 if (buf == NULL) {
1020                         TRACE_RET(chip, TRANSPORT_ERROR);
1021                 }
1022
1023                 rtsx_stor_get_xfer_buf(buf, len, srb);
1024                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1025
1026                 for (i = 0; i < len; i++) {
1027                         retval = spi_write_eeprom(chip, i, buf[i]);
1028                         if (retval != STATUS_SUCCESS) {
1029                                 vfree(buf);
1030                                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1031                                 TRACE_RET(chip, TRANSPORT_FAILED);
1032                         }
1033                 }
1034
1035                 vfree(buf);
1036         }
1037
1038         return TRANSPORT_GOOD;
1039 }
1040
1041 static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1042 {
1043         unsigned short addr, len, i;
1044         int retval;
1045         u8 *buf;
1046
1047         rtsx_disable_aspm(chip);
1048
1049         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1050                 rtsx_exit_ss(chip);
1051                 wait_timeout(100);
1052         }
1053         rtsx_set_stat(chip, RTSX_STAT_RUN);
1054
1055         addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1056         len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1057
1058         if (addr < 0xFC00) {
1059                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1060                 TRACE_RET(chip, TRANSPORT_FAILED);
1061         }
1062
1063         buf = (u8 *)vmalloc(len);
1064         if (!buf) {
1065                 TRACE_RET(chip, TRANSPORT_ERROR);
1066         }
1067
1068         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1069         if (retval != STATUS_SUCCESS) {
1070                 vfree(buf);
1071                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1072                 TRACE_RET(chip, TRANSPORT_FAILED);
1073         }
1074
1075         for (i = 0; i < len; i++) {
1076                 retval = rtsx_read_register(chip, addr + i, buf + i);
1077                 if (retval != STATUS_SUCCESS) {
1078                         vfree(buf);
1079                         set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1080                         TRACE_RET(chip, TRANSPORT_FAILED);
1081                 }
1082         }
1083
1084         len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1085         rtsx_stor_set_xfer_buf(buf, len, srb);
1086         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1087
1088         vfree(buf);
1089
1090         return TRANSPORT_GOOD;
1091 }
1092
1093 static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1094 {
1095         unsigned short addr, len, i;
1096         int retval;
1097         u8 *buf;
1098
1099         rtsx_disable_aspm(chip);
1100
1101         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1102                 rtsx_exit_ss(chip);
1103                 wait_timeout(100);
1104         }
1105         rtsx_set_stat(chip, RTSX_STAT_RUN);
1106
1107         addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1108         len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1109
1110         if (addr < 0xFC00) {
1111                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1112                 TRACE_RET(chip, TRANSPORT_FAILED);
1113         }
1114
1115         len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1116         buf = (u8 *)vmalloc(len);
1117         if (buf == NULL) {
1118                 TRACE_RET(chip, TRANSPORT_ERROR);
1119         }
1120
1121         rtsx_stor_get_xfer_buf(buf, len, srb);
1122         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1123
1124         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1125         if (retval != STATUS_SUCCESS) {
1126                 vfree(buf);
1127                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1128                 TRACE_RET(chip, TRANSPORT_FAILED);
1129         }
1130
1131         for (i = 0; i < len; i++) {
1132                 retval = rtsx_write_register(chip, addr + i, 0xFF, buf[i]);
1133                 if (retval != STATUS_SUCCESS) {
1134                         vfree(buf);
1135                         set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1136                         TRACE_RET(chip, TRANSPORT_FAILED);
1137                 }
1138         }
1139
1140         vfree(buf);
1141
1142         return TRANSPORT_GOOD;
1143 }
1144
1145 static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1146 {
1147         struct sd_info *sd_card = &(chip->sd_card);
1148         unsigned int lun = SCSI_LUN(srb);
1149
1150         if (!check_card_ready(chip, lun)) {
1151                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1152                 TRACE_RET(chip, TRANSPORT_FAILED);
1153         }
1154
1155         if (get_lun_card(chip, lun) != SD_CARD) {
1156                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1157                 TRACE_RET(chip, TRANSPORT_FAILED);
1158         }
1159
1160         scsi_set_resid(srb, 0);
1161         rtsx_stor_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1162
1163         return TRANSPORT_GOOD;
1164 }
1165
1166 static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1167 {
1168         u8 gpio = srb->cmnd[2];
1169
1170         rtsx_disable_aspm(chip);
1171
1172         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1173                 rtsx_exit_ss(chip);
1174                 wait_timeout(100);
1175         }
1176         rtsx_set_stat(chip, RTSX_STAT_RUN);
1177
1178         if (gpio > 3)
1179                 gpio = 1;
1180         toggle_gpio(chip, gpio);
1181
1182         return TRANSPORT_GOOD;
1183 }
1184
1185 #ifdef _MSG_TRACE
1186 static int trace_msg_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1187 {
1188         unsigned char *ptr, *buf = NULL;
1189         int i, msg_cnt;
1190         u8 clear;
1191         unsigned int buf_len;
1192
1193         buf_len = 4 + ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) * TRACE_ITEM_CNT);
1194
1195         if ((scsi_bufflen(srb) < buf_len) || (scsi_sglist(srb) == NULL)) {
1196                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1197                 TRACE_RET(chip, TRANSPORT_FAILED);
1198         }
1199
1200         clear = srb->cmnd[2];
1201
1202         buf = (unsigned char *)vmalloc(scsi_bufflen(srb));
1203         if (buf == NULL) {
1204                 TRACE_RET(chip, TRANSPORT_ERROR);
1205         }
1206         ptr = buf;
1207
1208         if (chip->trace_msg[chip->msg_idx].valid) {
1209                 msg_cnt = TRACE_ITEM_CNT;
1210         } else {
1211                 msg_cnt = chip->msg_idx;
1212         }
1213         *(ptr++) = (u8)(msg_cnt >> 24);
1214         *(ptr++) = (u8)(msg_cnt >> 16);
1215         *(ptr++) = (u8)(msg_cnt >> 8);
1216         *(ptr++) = (u8)msg_cnt;
1217         RTSX_DEBUGP("Trace message count is %d\n", msg_cnt);
1218
1219         for (i = 1; i <= msg_cnt; i++) {
1220                 int j, idx;
1221
1222                 idx = chip->msg_idx - i;
1223                 if (idx < 0)
1224                         idx += TRACE_ITEM_CNT;
1225
1226                 *(ptr++) = (u8)(chip->trace_msg[idx].line >> 8);
1227                 *(ptr++) = (u8)(chip->trace_msg[idx].line);
1228                 for (j = 0; j < MSG_FUNC_LEN; j++) {
1229                         *(ptr++) = chip->trace_msg[idx].func[j];
1230                 }
1231                 for (j = 0; j < MSG_FILE_LEN; j++) {
1232                         *(ptr++) = chip->trace_msg[idx].file[j];
1233                 }
1234                 for (j = 0; j < TIME_VAL_LEN; j++) {
1235                         *(ptr++) = chip->trace_msg[idx].timeval_buf[j];
1236                 }
1237         }
1238
1239         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1240         vfree(buf);
1241
1242         if (clear) {
1243                 chip->msg_idx = 0;
1244                 for (i = 0; i < TRACE_ITEM_CNT; i++)
1245                         chip->trace_msg[i].valid = 0;
1246         }
1247
1248         scsi_set_resid(srb, 0);
1249         return TRANSPORT_GOOD;
1250 }
1251 #endif
1252
1253 static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1254 {
1255         u8 addr, buf[4];
1256         u32 val;
1257         unsigned int len;
1258
1259         rtsx_disable_aspm(chip);
1260
1261         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1262                 rtsx_exit_ss(chip);
1263                 wait_timeout(100);
1264         }
1265         rtsx_set_stat(chip, RTSX_STAT_RUN);
1266
1267         addr = srb->cmnd[4];
1268
1269         val = rtsx_readl(chip, addr);
1270         RTSX_DEBUGP("Host register (0x%x): 0x%x\n", addr, val);
1271
1272         buf[0] = (u8)(val >> 24);
1273         buf[1] = (u8)(val >> 16);
1274         buf[2] = (u8)(val >> 8);
1275         buf[3] = (u8)val;
1276
1277         len = min(scsi_bufflen(srb), (unsigned int)4);
1278         rtsx_stor_set_xfer_buf(buf, len, srb);
1279         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1280
1281         return TRANSPORT_GOOD;
1282 }
1283
1284 static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1285 {
1286         u8 addr, buf[4];
1287         u32 val;
1288         unsigned int len;
1289
1290         rtsx_disable_aspm(chip);
1291
1292         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1293                 rtsx_exit_ss(chip);
1294                 wait_timeout(100);
1295         }
1296         rtsx_set_stat(chip, RTSX_STAT_RUN);
1297
1298         addr = srb->cmnd[4];
1299
1300         len = min(scsi_bufflen(srb), (unsigned int)4);
1301         rtsx_stor_get_xfer_buf(buf, len, srb);
1302         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1303
1304         val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2] << 8) | buf[3];
1305
1306         rtsx_writel(chip, addr, val);
1307
1308         return TRANSPORT_GOOD;
1309 }
1310
1311 static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1312 {
1313         unsigned lun = SCSI_LUN(srb);
1314
1315         if (srb->cmnd[3] == 1) {
1316                 /* Variable Clock */
1317                 struct xd_info *xd_card = &(chip->xd_card);
1318                 struct sd_info *sd_card = &(chip->sd_card);
1319                 struct ms_info *ms_card = &(chip->ms_card);
1320
1321                 switch (srb->cmnd[4]) {
1322                 case XD_CARD:
1323                         xd_card->xd_clock = srb->cmnd[5];
1324                         break;
1325
1326                 case SD_CARD:
1327                         sd_card->sd_clock = srb->cmnd[5];
1328                         break;
1329
1330                 case MS_CARD:
1331                         ms_card->ms_clock = srb->cmnd[5];
1332                         break;
1333
1334                 default:
1335                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1336                         TRACE_RET(chip, TRANSPORT_FAILED);
1337                 }
1338         } else if (srb->cmnd[3] == 2) {
1339                 if (srb->cmnd[4]) {
1340                         chip->blink_led = 1;
1341                 } else {
1342                         int retval;
1343
1344                         chip->blink_led = 0;
1345
1346                         rtsx_disable_aspm(chip);
1347
1348                         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1349                                 rtsx_exit_ss(chip);
1350                                 wait_timeout(100);
1351                         }
1352                         rtsx_set_stat(chip, RTSX_STAT_RUN);
1353
1354                         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1355                         if (retval != STATUS_SUCCESS) {
1356                                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1357                                 TRACE_RET(chip, TRANSPORT_FAILED);
1358                         }
1359
1360                         turn_off_led(chip, LED_GPIO);
1361                 }
1362         } else {
1363                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1364                 TRACE_RET(chip, TRANSPORT_FAILED);
1365         }
1366
1367         return TRANSPORT_GOOD;
1368 }
1369
1370 static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1371 {
1372         unsigned int lun = SCSI_LUN(srb);
1373
1374         if (srb->cmnd[3] == 1) {
1375                 struct xd_info *xd_card = &(chip->xd_card);
1376                 struct sd_info *sd_card = &(chip->sd_card);
1377                 struct ms_info *ms_card = &(chip->ms_card);
1378                 u8 tmp;
1379
1380                 switch (srb->cmnd[4]) {
1381                 case XD_CARD:
1382                         tmp = (u8)(xd_card->xd_clock);
1383                         break;
1384
1385                 case SD_CARD:
1386                         tmp = (u8)(sd_card->sd_clock);
1387                         break;
1388
1389                 case MS_CARD:
1390                         tmp = (u8)(ms_card->ms_clock);
1391                         break;
1392
1393                 default:
1394                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1395                         TRACE_RET(chip, TRANSPORT_FAILED);
1396                 }
1397
1398                 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1399         } else if (srb->cmnd[3] == 2) {
1400                 u8 tmp = chip->blink_led;
1401                 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1402         } else {
1403                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1404                 TRACE_RET(chip, TRANSPORT_FAILED);
1405         }
1406
1407         return TRANSPORT_GOOD;
1408 }
1409
1410 static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1411 {
1412         int retval;
1413         unsigned int lun = SCSI_LUN(srb);
1414         u16 len;
1415
1416         rtsx_disable_aspm(chip);
1417
1418         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1419                 rtsx_exit_ss(chip);
1420                 wait_timeout(100);
1421         }
1422         rtsx_set_stat(chip, RTSX_STAT_RUN);
1423
1424         len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1425         len = min(len, (u16)scsi_bufflen(srb));
1426
1427         if (srb->sc_data_direction == DMA_FROM_DEVICE) {
1428                 RTSX_DEBUGP("Read from device\n");
1429         } else {
1430                 RTSX_DEBUGP("Write to device\n");
1431         }
1432
1433         retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len,
1434                         scsi_sg_count(srb), srb->sc_data_direction, 1000);
1435         if (retval < 0) {
1436                 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
1437                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1438                 } else {
1439                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1440                 }
1441                 TRACE_RET(chip, TRANSPORT_FAILED);
1442         }
1443         scsi_set_resid(srb, 0);
1444
1445         return TRANSPORT_GOOD;
1446 }
1447
1448 static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1449 {
1450         struct sd_info *sd_card = &(chip->sd_card);
1451         struct ms_info *ms_card = &(chip->ms_card);
1452         int buf_len;
1453         unsigned int lun = SCSI_LUN(srb);
1454         u8 card = get_lun_card(chip, lun);
1455         u8 status[32];
1456 #ifdef SUPPORT_OCP
1457         u8 oc_now_mask = 0, oc_ever_mask = 0;
1458 #endif
1459
1460         memset(status, 0, 32);
1461
1462         status[0] = (u8)(chip->product_id);
1463         status[1] = chip->ic_version;
1464
1465         if (chip->auto_delink_en) {
1466                 status[2] = 0x10;
1467         } else {
1468                 status[2] = 0x00;
1469         }
1470
1471         status[3] = 20;
1472         status[4] = 10;
1473         status[5] = 05;
1474         status[6] = 21;
1475
1476         if (chip->card_wp) {
1477                 status[7] = 0x20;
1478         } else {
1479                 status[7] = 0x00;
1480         }
1481
1482 #ifdef SUPPORT_OCP
1483         status[8] = 0;
1484         if (CHECK_LUN_MODE(chip, SD_MS_2LUN) && (chip->lun2card[lun] == MS_CARD)) {
1485                 oc_now_mask = MS_OC_NOW;
1486                 oc_ever_mask = MS_OC_EVER;
1487         } else {
1488                 oc_now_mask = SD_OC_NOW;
1489                 oc_ever_mask = SD_OC_EVER;
1490         }
1491
1492         if (chip->ocp_stat & oc_now_mask) {
1493                 status[8] |= 0x02;
1494         }
1495         if (chip->ocp_stat & oc_ever_mask) {
1496                 status[8] |= 0x01;
1497         }
1498 #endif
1499
1500         if (card == SD_CARD) {
1501                 if (CHK_SD(sd_card)) {
1502                         if (CHK_SD_HCXC(sd_card)) {
1503                                 if (sd_card->capacity > 0x4000000) {
1504                                         status[0x0E] = 0x02;
1505                                 } else {
1506                                         status[0x0E] = 0x01;
1507                                 }
1508                         } else {
1509                                 status[0x0E] = 0x00;
1510                         }
1511
1512                         if (CHK_SD_SDR104(sd_card)) {
1513                                 status[0x0F] = 0x03;
1514                         } else if (CHK_SD_DDR50(sd_card)) {
1515                                 status[0x0F] = 0x04;
1516                         } else if (CHK_SD_SDR50(sd_card)) {
1517                                 status[0x0F] = 0x02;
1518                         } else if (CHK_SD_HS(sd_card)) {
1519                                 status[0x0F] = 0x01;
1520                         } else {
1521                                 status[0x0F] = 0x00;
1522                         }
1523                 } else {
1524                         if (CHK_MMC_SECTOR_MODE(sd_card)) {
1525                                 status[0x0E] = 0x01;
1526                         } else {
1527                                 status[0x0E] = 0x00;
1528                         }
1529
1530                         if (CHK_MMC_DDR52(sd_card)) {
1531                                 status[0x0F] = 0x03;
1532                         } else if (CHK_MMC_52M(sd_card)) {
1533                                 status[0x0F] = 0x02;
1534                         } else if (CHK_MMC_26M(sd_card)) {
1535                                 status[0x0F] = 0x01;
1536                         } else {
1537                                 status[0x0F] = 0x00;
1538                         }
1539                 }
1540         } else if (card == MS_CARD) {
1541                 if (CHK_MSPRO(ms_card)) {
1542                         if (CHK_MSXC(ms_card)) {
1543                                 status[0x0E] = 0x01;
1544                         } else {
1545                                 status[0x0E] = 0x00;
1546                         }
1547
1548                         if (CHK_HG8BIT(ms_card)) {
1549                                 status[0x0F] = 0x01;
1550                         } else {
1551                                 status[0x0F] = 0x00;
1552                         }
1553                 }
1554         }
1555
1556 #ifdef SUPPORT_SD_LOCK
1557         if (card == SD_CARD) {
1558                 status[0x17] = 0x80;
1559                 if (sd_card->sd_erase_status)
1560                         status[0x17] |= 0x01;
1561                 if (sd_card->sd_lock_status & SD_LOCKED) {
1562                         status[0x17] |= 0x02;
1563                         status[0x07] |= 0x40;
1564                 }
1565                 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1566                         status[0x17] |= 0x04;
1567         } else {
1568                 status[0x17] = 0x00;
1569         }
1570
1571         RTSX_DEBUGP("status[0x17] = 0x%x\n", status[0x17]);
1572 #endif
1573
1574         status[0x18] = 0x8A;
1575         status[0x1A] = 0x28;
1576 #ifdef SUPPORT_SD_LOCK
1577         status[0x1F] = 0x01;
1578 #endif
1579
1580         buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(status));
1581         rtsx_stor_set_xfer_buf(status, buf_len, srb);
1582         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1583
1584         return TRANSPORT_GOOD;
1585 }
1586
1587 static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1588 {
1589         int phy_debug_mode;
1590         int retval;
1591         u16 reg;
1592
1593         if (!CHECK_PID(chip, 0x5208)) {
1594                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1595                 TRACE_RET(chip, TRANSPORT_FAILED);
1596         }
1597
1598         phy_debug_mode = (int)(srb->cmnd[3]);
1599
1600         if (phy_debug_mode) {
1601                 chip->phy_debug_mode = 1;
1602                 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
1603                 if (retval != STATUS_SUCCESS) {
1604                         TRACE_RET(chip, TRANSPORT_FAILED);
1605                 }
1606                 rtsx_disable_bus_int(chip);
1607
1608                 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
1609                 if (retval != STATUS_SUCCESS) {
1610                         TRACE_RET(chip, TRANSPORT_FAILED);
1611                 }
1612                 reg |= 0x0001;
1613                 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1614                 if (retval != STATUS_SUCCESS) {
1615                         TRACE_RET(chip, TRANSPORT_FAILED);
1616                 }
1617         } else {
1618                 chip->phy_debug_mode = 0;
1619                 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1620                 if (retval != STATUS_SUCCESS) {
1621                         TRACE_RET(chip, TRANSPORT_FAILED);
1622                 }
1623                 rtsx_enable_bus_int(chip);
1624
1625                 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
1626                 if (retval != STATUS_SUCCESS) {
1627                         TRACE_RET(chip, TRANSPORT_FAILED);
1628                 }
1629                 reg &= 0xFFFE;
1630                 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1631                 if (retval != STATUS_SUCCESS) {
1632                         TRACE_RET(chip, TRANSPORT_FAILED);
1633                 }
1634         }
1635
1636         return TRANSPORT_GOOD;
1637 }
1638
1639 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1640 {
1641         int retval =  STATUS_SUCCESS;
1642         unsigned int lun = SCSI_LUN(srb);
1643         u8 cmd_type, mask, value, idx;
1644         u16 addr;
1645
1646         rtsx_disable_aspm(chip);
1647
1648         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1649                 rtsx_exit_ss(chip);
1650                 wait_timeout(100);
1651         }
1652         rtsx_set_stat(chip, RTSX_STAT_RUN);
1653
1654         switch (srb->cmnd[3]) {
1655         case INIT_BATCHCMD:
1656                 rtsx_init_cmd(chip);
1657                 break;
1658
1659         case ADD_BATCHCMD:
1660                 cmd_type = srb->cmnd[4];
1661                 if (cmd_type > 2) {
1662                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1663                         TRACE_RET(chip, TRANSPORT_FAILED);
1664                 }
1665                 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1666                 mask = srb->cmnd[7];
1667                 value = srb->cmnd[8];
1668                 rtsx_add_cmd(chip, cmd_type, addr, mask, value);
1669                 break;
1670
1671         case SEND_BATCHCMD:
1672                 retval = rtsx_send_cmd(chip, 0, 1000);
1673                 break;
1674
1675         case GET_BATCHRSP:
1676                 idx = srb->cmnd[4];
1677                 value = *(rtsx_get_cmd_data(chip) + idx);
1678                 if (scsi_bufflen(srb) < 1) {
1679                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1680                         TRACE_RET(chip, TRANSPORT_FAILED);
1681                 }
1682                 rtsx_stor_set_xfer_buf(&value, 1, srb);
1683                 scsi_set_resid(srb, 0);
1684                 break;
1685
1686         default:
1687                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1688                 TRACE_RET(chip, TRANSPORT_FAILED);
1689         }
1690
1691         if (retval != STATUS_SUCCESS) {
1692                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1693                 TRACE_RET(chip, TRANSPORT_FAILED);
1694         }
1695
1696         return TRANSPORT_GOOD;
1697 }
1698
1699 static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1700 {
1701         int result;
1702
1703         switch (srb->cmnd[3]) {
1704         case INIT_BATCHCMD:
1705         case ADD_BATCHCMD:
1706         case SEND_BATCHCMD:
1707         case GET_BATCHRSP:
1708                 result = rw_mem_cmd_buf(srb, chip);
1709                 break;
1710         default:
1711                 result = TRANSPORT_ERROR;
1712         }
1713
1714         return result;
1715 }
1716
1717 static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1718 {
1719         unsigned short addr, len, i;
1720         int retval;
1721         u8 *buf;
1722         u16 val;
1723
1724         rtsx_disable_aspm(chip);
1725
1726         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1727                 rtsx_exit_ss(chip);
1728                 wait_timeout(100);
1729         }
1730         rtsx_set_stat(chip, RTSX_STAT_RUN);
1731
1732         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1733         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1734
1735         if (len % 2)
1736                 len -= len % 2;
1737
1738         if (len) {
1739                 buf = (u8 *)vmalloc(len);
1740                 if (!buf) {
1741                         TRACE_RET(chip, TRANSPORT_ERROR);
1742                 }
1743
1744                 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1745                 if (retval != STATUS_SUCCESS) {
1746                         vfree(buf);
1747                         set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1748                         TRACE_RET(chip, TRANSPORT_FAILED);
1749                 }
1750
1751                 for (i = 0; i < len / 2; i++) {
1752                         retval = rtsx_read_phy_register(chip, addr + i, &val);
1753                         if (retval != STATUS_SUCCESS) {
1754                                 vfree(buf);
1755                                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1756                                 TRACE_RET(chip, TRANSPORT_FAILED);
1757                         }
1758
1759                         buf[2*i] = (u8)(val >> 8);
1760                         buf[2*i+1] = (u8)val;
1761                 }
1762
1763                 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1764                 rtsx_stor_set_xfer_buf(buf, len, srb);
1765                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1766
1767                 vfree(buf);
1768         }
1769
1770         return TRANSPORT_GOOD;
1771 }
1772
1773 static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1774 {
1775         unsigned short addr, len, i;
1776         int retval;
1777         u8 *buf;
1778         u16 val;
1779
1780         rtsx_disable_aspm(chip);
1781
1782         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1783                 rtsx_exit_ss(chip);
1784                 wait_timeout(100);
1785         }
1786         rtsx_set_stat(chip, RTSX_STAT_RUN);
1787
1788         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1789         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1790
1791         if (len % 2)
1792                 len -= len % 2;
1793
1794         if (len) {
1795                 len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1796
1797                 buf = (u8 *)vmalloc(len);
1798                 if (buf == NULL) {
1799                         TRACE_RET(chip, TRANSPORT_ERROR);
1800                 }
1801
1802                 rtsx_stor_get_xfer_buf(buf, len, srb);
1803                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1804
1805                 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1806                 if (retval != STATUS_SUCCESS) {
1807                         vfree(buf);
1808                         set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1809                         TRACE_RET(chip, TRANSPORT_FAILED);
1810                 }
1811
1812                 for (i = 0; i < len / 2; i++) {
1813                         val = ((u16)buf[2*i] << 8) | buf[2*i+1];
1814                         retval = rtsx_write_phy_register(chip, addr + i, val);
1815                         if (retval != STATUS_SUCCESS) {
1816                                 vfree(buf);
1817                                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1818                                 TRACE_RET(chip, TRANSPORT_FAILED);
1819                         }
1820                 }
1821
1822                 vfree(buf);
1823         }
1824
1825         return TRANSPORT_GOOD;
1826 }
1827
1828 static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1829 {
1830         unsigned short addr;
1831         int retval;
1832         u8 mode;
1833
1834         rtsx_disable_aspm(chip);
1835
1836         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1837                 rtsx_exit_ss(chip);
1838                 wait_timeout(100);
1839         }
1840         rtsx_set_stat(chip, RTSX_STAT_RUN);
1841
1842         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1843         if (retval != STATUS_SUCCESS) {
1844                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1845                 TRACE_RET(chip, TRANSPORT_FAILED);
1846         }
1847
1848         mode = srb->cmnd[3];
1849         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1850
1851         if (mode == 0) {
1852                 retval = spi_erase_eeprom_chip(chip);
1853                 if (retval != STATUS_SUCCESS) {
1854                         set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1855                         TRACE_RET(chip, TRANSPORT_FAILED);
1856                 }
1857         } else if (mode == 1) {
1858                 retval = spi_erase_eeprom_byte(chip, addr);
1859                 if (retval != STATUS_SUCCESS) {
1860                         set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1861                         TRACE_RET(chip, TRANSPORT_FAILED);
1862                 }
1863         } else {
1864                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1865                 TRACE_RET(chip, TRANSPORT_FAILED);
1866         }
1867
1868         return TRANSPORT_GOOD;
1869 }
1870
1871 static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1872 {
1873         unsigned short addr, len, i;
1874         int retval;
1875         u8 *buf;
1876
1877         rtsx_disable_aspm(chip);
1878
1879         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1880                 rtsx_exit_ss(chip);
1881                 wait_timeout(100);
1882         }
1883         rtsx_set_stat(chip, RTSX_STAT_RUN);
1884
1885         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1886         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1887
1888         buf = (u8 *)vmalloc(len);
1889         if (!buf) {
1890                 TRACE_RET(chip, TRANSPORT_ERROR);
1891         }
1892
1893         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1894         if (retval != STATUS_SUCCESS) {
1895                 vfree(buf);
1896                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1897                 TRACE_RET(chip, TRANSPORT_FAILED);
1898         }
1899
1900         for (i = 0; i < len; i++) {
1901                 retval = spi_read_eeprom(chip, addr + i, buf + i);
1902                 if (retval != STATUS_SUCCESS) {
1903                         vfree(buf);
1904                         set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1905                         TRACE_RET(chip, TRANSPORT_FAILED);
1906                 }
1907         }
1908
1909         len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1910         rtsx_stor_set_xfer_buf(buf, len, srb);
1911         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1912
1913         vfree(buf);
1914
1915         return TRANSPORT_GOOD;
1916 }
1917
1918 static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1919 {
1920         unsigned short addr, len, i;
1921         int retval;
1922         u8 *buf;
1923
1924         rtsx_disable_aspm(chip);
1925
1926         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1927                 rtsx_exit_ss(chip);
1928                 wait_timeout(100);
1929         }
1930         rtsx_set_stat(chip, RTSX_STAT_RUN);
1931
1932         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1933         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1934
1935         len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1936         buf = (u8 *)vmalloc(len);
1937         if (buf == NULL) {
1938                 TRACE_RET(chip, TRANSPORT_ERROR);
1939         }
1940
1941         rtsx_stor_get_xfer_buf(buf, len, srb);
1942         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1943
1944         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1945         if (retval != STATUS_SUCCESS) {
1946                 vfree(buf);
1947                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1948                 TRACE_RET(chip, TRANSPORT_FAILED);
1949         }
1950
1951         for (i = 0; i < len; i++) {
1952                 retval = spi_write_eeprom(chip, addr + i, buf[i]);
1953                 if (retval != STATUS_SUCCESS) {
1954                         vfree(buf);
1955                         set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1956                         TRACE_RET(chip, TRANSPORT_FAILED);
1957                 }
1958         }
1959
1960         vfree(buf);
1961
1962         return TRANSPORT_GOOD;
1963 }
1964
1965 static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1966 {
1967         int retval;
1968         u8 addr, len, i;
1969         u8 *buf;
1970
1971         rtsx_disable_aspm(chip);
1972
1973         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1974                 rtsx_exit_ss(chip);
1975                 wait_timeout(100);
1976         }
1977         rtsx_set_stat(chip, RTSX_STAT_RUN);
1978
1979         addr = srb->cmnd[4];
1980         len = srb->cmnd[5];
1981
1982         buf = (u8 *)vmalloc(len);
1983         if (!buf) {
1984                 TRACE_RET(chip, TRANSPORT_ERROR);
1985         }
1986
1987         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1988         if (retval != STATUS_SUCCESS) {
1989                 vfree(buf);
1990                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1991                 TRACE_RET(chip, TRANSPORT_FAILED);
1992         }
1993
1994         for (i = 0; i < len; i++) {
1995                 retval = rtsx_read_efuse(chip, addr + i, buf + i);
1996                 if (retval != STATUS_SUCCESS) {
1997                         vfree(buf);
1998                         set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1999                         TRACE_RET(chip, TRANSPORT_FAILED);
2000                 }
2001         }
2002
2003         len = (u8)min(scsi_bufflen(srb), (unsigned int)len);
2004         rtsx_stor_set_xfer_buf(buf, len, srb);
2005         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2006
2007         vfree(buf);
2008
2009         return TRANSPORT_GOOD;
2010 }
2011
2012 static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2013 {
2014         int retval, result = TRANSPORT_GOOD;
2015         u16 val;
2016         u8 addr, len, i;
2017         u8 *buf;
2018
2019         rtsx_disable_aspm(chip);
2020
2021         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2022                 rtsx_exit_ss(chip);
2023                 wait_timeout(100);
2024         }
2025         rtsx_set_stat(chip, RTSX_STAT_RUN);
2026
2027         addr = srb->cmnd[4];
2028         len = srb->cmnd[5];
2029
2030         len = (u8)min(scsi_bufflen(srb), (unsigned int)len);
2031         buf = (u8 *)vmalloc(len);
2032         if (buf == NULL) {
2033                 TRACE_RET(chip, TRANSPORT_ERROR);
2034         }
2035
2036         rtsx_stor_get_xfer_buf(buf, len, srb);
2037         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2038
2039         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2040         if (retval != STATUS_SUCCESS) {
2041                 vfree(buf);
2042                 TRACE_RET(chip, TRANSPORT_ERROR);
2043         }
2044
2045         if (chip->asic_code) {
2046                 retval = rtsx_read_phy_register(chip, 0x08, &val);
2047                 if (retval != STATUS_SUCCESS) {
2048                         vfree(buf);
2049                         TRACE_RET(chip, TRANSPORT_ERROR);
2050                 }
2051
2052                 retval = rtsx_write_register(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_OFF);
2053                 if (retval != STATUS_SUCCESS) {
2054                         vfree(buf);
2055                         TRACE_RET(chip, TRANSPORT_ERROR);
2056                 }
2057
2058                 wait_timeout(600);
2059
2060                 retval = rtsx_write_phy_register(chip, 0x08, 0x4C00 | chip->phy_voltage);
2061                 if (retval != STATUS_SUCCESS) {
2062                         vfree(buf);
2063                         TRACE_RET(chip, TRANSPORT_ERROR);
2064                 }
2065
2066                 retval = rtsx_write_register(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_ON);
2067                 if (retval != STATUS_SUCCESS) {
2068                         vfree(buf);
2069                         TRACE_RET(chip, TRANSPORT_ERROR);
2070                 }
2071
2072                 wait_timeout(600);
2073         }
2074
2075         retval = card_power_on(chip, SPI_CARD);
2076         if (retval != STATUS_SUCCESS) {
2077                 vfree(buf);
2078                 TRACE_RET(chip, TRANSPORT_ERROR);
2079         }
2080
2081         wait_timeout(50);
2082
2083         for (i = 0; i < len; i++) {
2084                 retval = rtsx_write_efuse(chip, addr + i, buf[i]);
2085                 if (retval != STATUS_SUCCESS) {
2086                         set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2087                         result = TRANSPORT_FAILED;
2088                         TRACE_GOTO(chip, Exit);
2089                 }
2090         }
2091
2092 Exit:
2093         vfree(buf);
2094
2095         retval = card_power_off(chip, SPI_CARD);
2096         if (retval != STATUS_SUCCESS) {
2097                 TRACE_RET(chip, TRANSPORT_ERROR);
2098         }
2099
2100         if (chip->asic_code) {
2101                 retval = rtsx_write_register(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_OFF);
2102                 if (retval != STATUS_SUCCESS) {
2103                         TRACE_RET(chip, TRANSPORT_ERROR);
2104                 }
2105
2106                 wait_timeout(600);
2107
2108                 retval = rtsx_write_phy_register(chip, 0x08, val);
2109                 if (retval != STATUS_SUCCESS) {
2110                         TRACE_RET(chip, TRANSPORT_ERROR);
2111                 }
2112
2113                 retval = rtsx_write_register(chip, PWR_GATE_CTRL, LDO3318_PWR_MASK, LDO_ON);
2114                 if (retval != STATUS_SUCCESS) {
2115                         TRACE_RET(chip, TRANSPORT_ERROR);
2116                 }
2117         }
2118
2119         return result;
2120 }
2121
2122 static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2123 {
2124         int retval;
2125         u8 func, func_max;
2126         u16 addr, len;
2127         u8 *buf;
2128
2129         rtsx_disable_aspm(chip);
2130
2131         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2132                 rtsx_exit_ss(chip);
2133                 wait_timeout(100);
2134         }
2135         rtsx_set_stat(chip, RTSX_STAT_RUN);
2136
2137         func = srb->cmnd[3];
2138         addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2139         len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2140
2141         RTSX_DEBUGP("%s: func = %d, addr = 0x%x, len = %d\n", __func__, func, addr, len);
2142
2143         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
2144                 func_max = 1;
2145         } else {
2146                 func_max = 0;
2147         }
2148
2149         if (func > func_max) {
2150                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2151                 TRACE_RET(chip, TRANSPORT_FAILED);
2152         }
2153
2154         buf = (u8 *)vmalloc(len);
2155         if (!buf) {
2156                 TRACE_RET(chip, TRANSPORT_ERROR);
2157         }
2158
2159         retval = rtsx_read_cfg_seq(chip, func, addr, buf, len);
2160         if (retval != STATUS_SUCCESS) {
2161                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2162                 vfree(buf);
2163                 TRACE_RET(chip, TRANSPORT_FAILED);
2164         }
2165
2166         len = (u16)min(scsi_bufflen(srb), (unsigned int)len);
2167         rtsx_stor_set_xfer_buf(buf, len, srb);
2168         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2169
2170         vfree(buf);
2171
2172         return TRANSPORT_GOOD;
2173 }
2174
2175 static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2176 {
2177         int retval;
2178         u8 func, func_max;
2179         u16 addr, len;
2180         u8 *buf;
2181
2182         rtsx_disable_aspm(chip);
2183
2184         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2185                 rtsx_exit_ss(chip);
2186                 wait_timeout(100);
2187         }
2188         rtsx_set_stat(chip, RTSX_STAT_RUN);
2189
2190         func = srb->cmnd[3];
2191         addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2192         len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2193
2194         RTSX_DEBUGP("%s: func = %d, addr = 0x%x\n", __func__, func, addr);
2195
2196         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
2197                 func_max = 1;
2198         } else {
2199                 func_max = 0;
2200         }
2201
2202         if (func > func_max) {
2203                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2204                 TRACE_RET(chip, TRANSPORT_FAILED);
2205         }
2206
2207         len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
2208         buf = (u8 *)vmalloc(len);
2209         if (!buf) {
2210                 TRACE_RET(chip, TRANSPORT_ERROR);
2211         }
2212
2213         rtsx_stor_get_xfer_buf(buf, len, srb);
2214         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2215
2216         retval = rtsx_write_cfg_seq(chip, func, addr, buf, len);
2217         if (retval != STATUS_SUCCESS) {
2218                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2219                 vfree(buf);
2220                 TRACE_RET(chip, TRANSPORT_FAILED);
2221         }
2222
2223         vfree(buf);
2224
2225         return TRANSPORT_GOOD;
2226 }
2227
2228 static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2229 {
2230         int result;
2231
2232         switch (srb->cmnd[2]) {
2233         case PP_READ10:
2234         case PP_WRITE10:
2235                 result = read_write(srb, chip);
2236                 break;
2237
2238         case READ_HOST_REG:
2239                 result = read_host_reg(srb, chip);
2240                 break;
2241
2242         case WRITE_HOST_REG:
2243                 result = write_host_reg(srb, chip);
2244                 break;
2245
2246         case GET_VAR:
2247                 result = get_variable(srb, chip);
2248                 break;
2249
2250         case SET_VAR:
2251                 result = set_variable(srb, chip);
2252                 break;
2253
2254         case DMA_READ:
2255         case DMA_WRITE:
2256                 result = dma_access_ring_buffer(srb, chip);
2257                 break;
2258
2259         case READ_PHY:
2260                 result = read_phy_register(srb, chip);
2261                 break;
2262
2263         case WRITE_PHY:
2264                 result = write_phy_register(srb, chip);
2265                 break;
2266
2267         case ERASE_EEPROM2:
2268                 result = erase_eeprom2(srb, chip);
2269                 break;
2270
2271         case READ_EEPROM2:
2272                 result = read_eeprom2(srb, chip);
2273                 break;
2274
2275         case WRITE_EEPROM2:
2276                 result = write_eeprom2(srb, chip);
2277                 break;
2278
2279         case READ_EFUSE:
2280                 result = read_efuse(srb, chip);
2281                 break;
2282
2283         case WRITE_EFUSE:
2284                 result = write_efuse(srb, chip);
2285                 break;
2286
2287         case READ_CFG:
2288                 result = read_cfg_byte(srb, chip);
2289                 break;
2290
2291         case WRITE_CFG:
2292                 result = write_cfg_byte(srb, chip);
2293                 break;
2294
2295         case SET_CHIP_MODE:
2296                 result = set_chip_mode(srb, chip);
2297                 break;
2298
2299         case SUIT_CMD:
2300                 result = suit_cmd(srb, chip);
2301                 break;
2302
2303         case GET_DEV_STATUS:
2304                 result = get_dev_status(srb, chip);
2305                 break;
2306
2307         default:
2308                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2309                 TRACE_RET(chip, TRANSPORT_FAILED);
2310         }
2311
2312         return result;
2313 }
2314
2315
2316 static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2317 {
2318         u8 rtsx_status[16];
2319         int buf_len;
2320         unsigned int lun = SCSI_LUN(srb);
2321
2322         rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2323         rtsx_status[1] = (u8)(chip->vendor_id);
2324
2325         rtsx_status[2] = (u8)(chip->product_id >> 8);
2326         rtsx_status[3] = (u8)(chip->product_id);
2327
2328         rtsx_status[4] = (u8)lun;
2329
2330         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2331                 if (chip->lun2card[lun] == SD_CARD) {
2332                         rtsx_status[5] = 2;
2333                 } else {
2334                         rtsx_status[5] = 3;
2335                 }
2336         } else {
2337                 if (chip->card_exist) {
2338                         if (chip->card_exist & XD_CARD) {
2339                                 rtsx_status[5] = 4;
2340                         } else if (chip->card_exist & SD_CARD) {
2341                                 rtsx_status[5] = 2;
2342                         } else if (chip->card_exist & MS_CARD) {
2343                                 rtsx_status[5] = 3;
2344                         } else {
2345                                 rtsx_status[5] = 7;
2346                         }
2347                 } else {
2348                         rtsx_status[5] = 7;
2349                 }
2350         }
2351
2352         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2353                 rtsx_status[6] = 2;
2354         } else {
2355                 rtsx_status[6] = 1;
2356         }
2357
2358         rtsx_status[7] = (u8)(chip->product_id);
2359         rtsx_status[8] = chip->ic_version;
2360
2361         if (check_card_exist(chip, lun)) {
2362                 rtsx_status[9] = 1;
2363         } else {
2364                 rtsx_status[9] = 0;
2365         }
2366
2367         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2368                 rtsx_status[10] = 0;
2369         } else {
2370                 rtsx_status[10] = 1;
2371         }
2372
2373         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2374                 if (chip->lun2card[lun] == SD_CARD) {
2375                         rtsx_status[11] = SD_CARD;
2376                 } else {
2377                         rtsx_status[11] = MS_CARD;
2378                 }
2379         } else {
2380                 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2381         }
2382
2383         if (check_card_ready(chip, lun)) {
2384                 rtsx_status[12] = 1;
2385         } else {
2386                 rtsx_status[12] = 0;
2387         }
2388
2389         if (get_lun_card(chip, lun) == XD_CARD) {
2390                 rtsx_status[13] = 0x40;
2391         } else if (get_lun_card(chip, lun) == SD_CARD) {
2392                 struct sd_info *sd_card = &(chip->sd_card);
2393
2394                 rtsx_status[13] = 0x20;
2395                 if (CHK_SD(sd_card)) {
2396                         if (CHK_SD_HCXC(sd_card))
2397                                 rtsx_status[13] |= 0x04;
2398                         if (CHK_SD_HS(sd_card))
2399                                 rtsx_status[13] |= 0x02;
2400                 } else {
2401                         rtsx_status[13] |= 0x08;
2402                         if (CHK_MMC_52M(sd_card))
2403                                 rtsx_status[13] |= 0x02;
2404                         if (CHK_MMC_SECTOR_MODE(sd_card))
2405                                 rtsx_status[13] |= 0x04;
2406                 }
2407         } else if (get_lun_card(chip, lun) == MS_CARD) {
2408                 struct ms_info *ms_card = &(chip->ms_card);
2409
2410                 if (CHK_MSPRO(ms_card)) {
2411                         rtsx_status[13] = 0x38;
2412                         if (CHK_HG8BIT(ms_card))
2413                                 rtsx_status[13] |= 0x04;
2414 #ifdef SUPPORT_MSXC
2415                         if (CHK_MSXC(ms_card))
2416                                 rtsx_status[13] |= 0x01;
2417 #endif
2418                 } else {
2419                         rtsx_status[13] = 0x30;
2420                 }
2421         } else {
2422                 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2423 #ifdef SUPPORT_SDIO
2424                         if (chip->sd_io && chip->sd_int) {
2425                                 rtsx_status[13] = 0x60;
2426                         } else {
2427                                 rtsx_status[13] = 0x70;
2428                         }
2429 #else
2430                         rtsx_status[13] = 0x70;
2431 #endif
2432                 } else {
2433                         if (chip->lun2card[lun] == SD_CARD) {
2434                                 rtsx_status[13] = 0x20;
2435                         } else {
2436                                 rtsx_status[13] = 0x30;
2437                         }
2438                 }
2439         }
2440
2441         rtsx_status[14] = 0x78;
2442         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip)) {
2443                 rtsx_status[15] = 0x83;
2444         } else {
2445                 rtsx_status[15] = 0x82;
2446         }
2447
2448         buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(rtsx_status));
2449         rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb);
2450         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
2451
2452         return TRANSPORT_GOOD;
2453 }
2454
2455 static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2456 {
2457         unsigned int lun = SCSI_LUN(srb);
2458         u8 card, bus_width;
2459
2460         if (!check_card_ready(chip, lun)) {
2461                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2462                 TRACE_RET(chip, TRANSPORT_FAILED);
2463         }
2464
2465         card = get_lun_card(chip, lun);
2466         if ((card == SD_CARD) || (card == MS_CARD)) {
2467                 bus_width = chip->card_bus_width[lun];
2468         } else {
2469                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2470                 TRACE_RET(chip, TRANSPORT_FAILED);
2471         }
2472
2473         scsi_set_resid(srb, 0);
2474         rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2475
2476         return TRANSPORT_GOOD;
2477 }
2478
2479 static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2480 {
2481         int result;
2482         unsigned int lun = SCSI_LUN(srb);
2483         u8 gpio_dir;
2484
2485         if (CHECK_PID(chip, 0x5208) && CHECK_PID(chip, 0x5288)) {
2486                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2487                 TRACE_RET(chip, TRANSPORT_FAILED);
2488         }
2489
2490         rtsx_disable_aspm(chip);
2491
2492         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2493                 rtsx_exit_ss(chip);
2494                 wait_timeout(100);
2495         }
2496         rtsx_set_stat(chip, RTSX_STAT_RUN);
2497
2498         rtsx_force_power_on(chip, SSC_PDCTL);
2499
2500         rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2501         rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2502
2503         switch (srb->cmnd[2]) {
2504         case SCSI_SPI_GETSTATUS:
2505                 result = spi_get_status(srb, chip);
2506                 break;
2507
2508         case SCSI_SPI_SETPARAMETER:
2509                 result = spi_set_parameter(srb, chip);
2510                 break;
2511
2512         case SCSI_SPI_READFALSHID:
2513                 result = spi_read_flash_id(srb, chip);
2514                 break;
2515
2516         case SCSI_SPI_READFLASH:
2517                 result = spi_read_flash(srb, chip);
2518                 break;
2519
2520         case SCSI_SPI_WRITEFLASH:
2521                 result = spi_write_flash(srb, chip);
2522                 break;
2523
2524         case SCSI_SPI_WRITEFLASHSTATUS:
2525                 result = spi_write_flash_status(srb, chip);
2526                 break;
2527
2528         case SCSI_SPI_ERASEFLASH:
2529                 result = spi_erase_flash(srb, chip);
2530                 break;
2531
2532         default:
2533                 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2534
2535                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2536                 TRACE_RET(chip, TRANSPORT_FAILED);
2537         }
2538
2539         rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2540
2541         if (result != STATUS_SUCCESS) {
2542                 TRACE_RET(chip, TRANSPORT_FAILED);
2543         }
2544
2545         return TRANSPORT_GOOD;
2546 }
2547
2548 static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2549 {
2550         int result;
2551
2552         switch (srb->cmnd[1]) {
2553         case READ_STATUS:
2554                 result = read_status(srb, chip);
2555                 break;
2556
2557         case READ_MEM:
2558                 result = read_mem(srb, chip);
2559                 break;
2560
2561         case WRITE_MEM:
2562                 result = write_mem(srb, chip);
2563                 break;
2564
2565         case READ_EEPROM:
2566                 result = read_eeprom(srb, chip);
2567                 break;
2568
2569         case WRITE_EEPROM:
2570                 result = write_eeprom(srb, chip);
2571                 break;
2572
2573         case TOGGLE_GPIO:
2574                 result = toggle_gpio_cmd(srb, chip);
2575                 break;
2576
2577         case GET_SD_CSD:
2578                 result = get_sd_csd(srb, chip);
2579                 break;
2580
2581         case GET_BUS_WIDTH:
2582                 result = get_card_bus_width(srb, chip);
2583                 break;
2584
2585 #ifdef _MSG_TRACE
2586         case TRACE_MSG:
2587                 result = trace_msg_cmd(srb, chip);
2588                 break;
2589 #endif
2590
2591         case SCSI_APP_CMD:
2592                 result = app_cmd(srb, chip);
2593                 break;
2594
2595         case SPI_VENDOR_COMMAND:
2596                 result = spi_vendor_cmd(srb, chip);
2597                 break;
2598
2599         default:
2600                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2601                 TRACE_RET(chip, TRANSPORT_FAILED);
2602         }
2603
2604         return result;
2605 }
2606
2607 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2608 void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2609 {
2610         unsigned int lun = SCSI_LUN(srb);
2611         u16 sec_cnt;
2612
2613         if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
2614                 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2615         } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
2616                 sec_cnt = srb->cmnd[4];
2617         } else {
2618                 return;
2619         }
2620
2621         if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2622                 toggle_gpio(chip, LED_GPIO);
2623                 chip->rw_cap[lun] = 0;
2624         } else {
2625                 chip->rw_cap[lun] += sec_cnt;
2626         }
2627 }
2628 #endif
2629
2630 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2631 {
2632         struct ms_info *ms_card = &(chip->ms_card);
2633         unsigned int lun = SCSI_LUN(srb);
2634         int retval, quick_format;
2635
2636         if (get_lun_card(chip, lun) != MS_CARD) {
2637                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2638                 TRACE_RET(chip, TRANSPORT_FAILED);
2639         }
2640
2641         if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) ||
2642                 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) ||
2643                 (srb->cmnd[7] != 0x74)) {
2644                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2645                 TRACE_RET(chip, TRANSPORT_FAILED);
2646         }
2647
2648         rtsx_disable_aspm(chip);
2649
2650         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2651                 rtsx_exit_ss(chip);
2652                 wait_timeout(100);
2653
2654                 if (!check_card_ready(chip, lun) ||
2655                                 (get_card_size(chip, lun) == 0)) {
2656                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2657                         TRACE_RET(chip, TRANSPORT_FAILED);
2658                 }
2659         }
2660         rtsx_set_stat(chip, RTSX_STAT_RUN);
2661
2662         if (srb->cmnd[8] & 0x01) {
2663                 quick_format = 0;
2664         } else {
2665                 quick_format = 1;
2666         }
2667
2668         if (!(chip->card_ready & MS_CARD)) {
2669                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2670                 TRACE_RET(chip, TRANSPORT_FAILED);
2671         }
2672
2673         if (chip->card_wp & MS_CARD) {
2674                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2675                 TRACE_RET(chip, TRANSPORT_FAILED);
2676         }
2677
2678         if (!CHK_MSPRO(ms_card)) {
2679                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2680                 TRACE_RET(chip, TRANSPORT_FAILED);
2681         }
2682
2683         retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
2684         if (retval != STATUS_SUCCESS) {
2685                 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
2686                 TRACE_RET(chip, TRANSPORT_FAILED);
2687         }
2688
2689         scsi_set_resid(srb, 0);
2690         return TRANSPORT_GOOD;
2691 }
2692
2693 #ifdef SUPPORT_PCGL_1P18
2694 static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2695 {
2696         struct ms_info *ms_card = &(chip->ms_card);
2697         unsigned int lun = SCSI_LUN(srb);
2698         u8 dev_info_id, data_len;
2699         u8 *buf;
2700         unsigned int buf_len;
2701         int i;
2702
2703         if (!check_card_ready(chip, lun)) {
2704                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2705                 TRACE_RET(chip, TRANSPORT_FAILED);
2706         }
2707         if ((get_lun_card(chip, lun) != MS_CARD)) {
2708                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2709                 TRACE_RET(chip, TRANSPORT_FAILED);
2710         }
2711
2712         if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
2713                 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
2714                 (srb->cmnd[7] != 0x44)) {
2715                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2716                 TRACE_RET(chip, TRANSPORT_FAILED);
2717         }
2718
2719         dev_info_id = srb->cmnd[3];
2720         if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
2721                         (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
2722                         !CHK_MSPRO(ms_card)) {
2723                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2724                 TRACE_RET(chip, TRANSPORT_FAILED);
2725         }
2726
2727         if (dev_info_id == 0x15) {
2728                 buf_len = data_len = 0x3A;
2729         } else {
2730                 buf_len = data_len = 0x6A;
2731         }
2732
2733         buf = (u8 *)kmalloc(buf_len, GFP_KERNEL);
2734         if (!buf) {
2735                 TRACE_RET(chip, TRANSPORT_ERROR);
2736         }
2737
2738         i = 0;
2739         /*  GET Memory Stick Media Information Response Header */
2740         buf[i++] = 0x00;                /* Data length MSB */
2741         buf[i++] = data_len;            /* Data length LSB */
2742         /* Device Information Type Code */
2743         if (CHK_MSXC(ms_card)) {
2744                 buf[i++] = 0x03;
2745         } else {
2746                 buf[i++] = 0x02;
2747         }
2748         /* SGM bit */
2749         buf[i++] = 0x01;
2750         /* Reserved */
2751         buf[i++] = 0x00;
2752         buf[i++] = 0x00;
2753         buf[i++] = 0x00;
2754         /* Number of Device Information */
2755         buf[i++] = 0x01;
2756
2757         /*  Device Information Body */
2758
2759         /* Device Information ID Number */
2760         buf[i++] = dev_info_id;
2761         /* Device Information Length */
2762         if (dev_info_id == 0x15) {
2763                 data_len = 0x31;
2764         } else {
2765                 data_len = 0x61;
2766         }
2767         buf[i++] = 0x00;                /* Data length MSB */
2768         buf[i++] = data_len;            /* Data length LSB */
2769         /* Valid Bit */
2770         buf[i++] = 0x80;
2771         if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
2772                 /* System Information */
2773                 memcpy(buf+i, ms_card->raw_sys_info, 96);
2774         } else {
2775                 /* Model Name */
2776                 memcpy(buf+i, ms_card->raw_model_name, 48);
2777         }
2778
2779         rtsx_stor_set_xfer_buf(buf, buf_len, srb);
2780
2781         if (dev_info_id == 0x15) {
2782                 scsi_set_resid(srb, scsi_bufflen(srb)-0x3C);
2783         } else {
2784                 scsi_set_resid(srb, scsi_bufflen(srb)-0x6C);
2785         }
2786
2787         kfree(buf);
2788         return STATUS_SUCCESS;
2789 }
2790 #endif
2791
2792 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2793 {
2794         int retval = TRANSPORT_ERROR;
2795
2796         if (srb->cmnd[2] == MS_FORMAT) {
2797                 retval = ms_format_cmnd(srb, chip);
2798         }
2799 #ifdef SUPPORT_PCGL_1P18
2800         else if (srb->cmnd[2] == GET_MS_INFORMATION) {
2801                 retval = get_ms_information(srb, chip);
2802         }
2803 #endif
2804
2805         return retval;
2806 }
2807
2808 #ifdef SUPPORT_CPRM
2809 static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2810 {
2811         unsigned int lun = SCSI_LUN(srb);
2812         int result;
2813
2814         rtsx_disable_aspm(chip);
2815
2816         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2817                 rtsx_exit_ss(chip);
2818                 wait_timeout(100);
2819         }
2820         rtsx_set_stat(chip, RTSX_STAT_RUN);
2821
2822         sd_cleanup_work(chip);
2823
2824         if (!check_card_ready(chip, lun)) {
2825                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2826                 TRACE_RET(chip, TRANSPORT_FAILED);
2827         }
2828         if ((get_lun_card(chip, lun) != SD_CARD)) {
2829                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2830                 TRACE_RET(chip, TRANSPORT_FAILED);
2831         }
2832
2833         switch (srb->cmnd[0]) {
2834         case SD_PASS_THRU_MODE:
2835                 result = sd_pass_thru_mode(srb, chip);
2836                 break;
2837
2838         case SD_EXECUTE_NO_DATA:
2839                 result = sd_execute_no_data(srb, chip);
2840                 break;
2841
2842         case SD_EXECUTE_READ:
2843                 result = sd_execute_read_data(srb, chip);
2844                 break;
2845
2846         case SD_EXECUTE_WRITE:
2847                 result = sd_execute_write_data(srb, chip);
2848                 break;
2849
2850         case SD_GET_RSP:
2851                 result = sd_get_cmd_rsp(srb, chip);
2852                 break;
2853
2854         case SD_HW_RST:
2855                 result = sd_hw_rst(srb, chip);
2856                 break;
2857
2858         default:
2859                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2860                 TRACE_RET(chip, TRANSPORT_FAILED);
2861         }
2862
2863         return result;
2864 }
2865 #endif
2866
2867 #ifdef SUPPORT_MAGIC_GATE
2868 static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2869 {
2870         struct ms_info *ms_card = &(chip->ms_card);
2871         unsigned int lun = SCSI_LUN(srb);
2872         int retval;
2873         u8 key_format;
2874
2875         RTSX_DEBUGP("--%s--\n", __func__);
2876
2877         rtsx_disable_aspm(chip);
2878
2879         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2880                 rtsx_exit_ss(chip);
2881                 wait_timeout(100);
2882         }
2883         rtsx_set_stat(chip, RTSX_STAT_RUN);
2884
2885         ms_cleanup_work(chip);
2886
2887         if (!check_card_ready(chip, lun)) {
2888                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2889                 TRACE_RET(chip, TRANSPORT_FAILED);
2890         }
2891         if ((get_lun_card(chip, lun) != MS_CARD)) {
2892                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2893                 TRACE_RET(chip, TRANSPORT_FAILED);
2894         }
2895
2896         if (srb->cmnd[7] != KC_MG_R_PRO) {
2897                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2898                 TRACE_RET(chip, TRANSPORT_FAILED);
2899         }
2900
2901         if (!CHK_MSPRO(ms_card)) {
2902                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
2903                 TRACE_RET(chip, TRANSPORT_FAILED);
2904         }
2905
2906         key_format = srb->cmnd[10] & 0x3F;
2907         RTSX_DEBUGP("key_format = 0x%x\n", key_format);
2908
2909         switch (key_format) {
2910         case KF_GET_LOC_EKB:
2911                 if ((scsi_bufflen(srb) == 0x41C) &&
2912                         (srb->cmnd[8] == 0x04) &&
2913                         (srb->cmnd[9] == 0x1C)) {
2914                         retval = mg_get_local_EKB(srb, chip);
2915                         if (retval != STATUS_SUCCESS) {
2916                                 TRACE_RET(chip, TRANSPORT_FAILED);
2917                         }
2918                 } else {
2919                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2920                         TRACE_RET(chip, TRANSPORT_FAILED);
2921                 }
2922                 break;
2923
2924         case KF_RSP_CHG:
2925                 if ((scsi_bufflen(srb) == 0x24) &&
2926                         (srb->cmnd[8] == 0x00) &&
2927                         (srb->cmnd[9] == 0x24)) {
2928                         retval = mg_get_rsp_chg(srb, chip);
2929                         if (retval != STATUS_SUCCESS) {
2930                                 TRACE_RET(chip, TRANSPORT_FAILED);
2931                         }
2932                 } else {
2933                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2934                         TRACE_RET(chip, TRANSPORT_FAILED);
2935                 }
2936                 break;
2937
2938         case KF_GET_ICV:
2939                 ms_card->mg_entry_num = srb->cmnd[5];
2940                 if ((scsi_bufflen(srb) == 0x404) &&
2941                         (srb->cmnd[8] == 0x04) &&
2942                         (srb->cmnd[9] == 0x04) &&
2943                         (srb->cmnd[2] == 0x00) &&
2944                         (srb->cmnd[3] == 0x00) &&
2945                         (srb->cmnd[4] == 0x00) &&
2946                         (srb->cmnd[5] < 32)) {
2947                         retval = mg_get_ICV(srb, chip);
2948                         if (retval != STATUS_SUCCESS) {
2949                                 TRACE_RET(chip, TRANSPORT_FAILED);
2950                         }
2951                 } else {
2952                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2953                         TRACE_RET(chip, TRANSPORT_FAILED);
2954                 }
2955                 break;
2956
2957         default:
2958                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2959                 TRACE_RET(chip, TRANSPORT_FAILED);
2960         }
2961
2962         scsi_set_resid(srb, 0);
2963         return TRANSPORT_GOOD;
2964 }
2965
2966 static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2967 {
2968         struct ms_info *ms_card = &(chip->ms_card);
2969         unsigned int lun = SCSI_LUN(srb);
2970         int retval;
2971         u8 key_format;
2972
2973         RTSX_DEBUGP("--%s--\n", __func__);
2974
2975         rtsx_disable_aspm(chip);
2976
2977         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2978                 rtsx_exit_ss(chip);
2979                 wait_timeout(100);
2980         }
2981         rtsx_set_stat(chip, RTSX_STAT_RUN);
2982
2983         ms_cleanup_work(chip);
2984
2985         if (!check_card_ready(chip, lun)) {
2986                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2987                 TRACE_RET(chip, TRANSPORT_FAILED);
2988         }
2989         if (check_card_wp(chip, lun)) {
2990                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2991                 TRACE_RET(chip, TRANSPORT_FAILED);
2992         }
2993         if ((get_lun_card(chip, lun) != MS_CARD)) {
2994                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2995                 TRACE_RET(chip, TRANSPORT_FAILED);
2996         }
2997
2998         if (srb->cmnd[7] != KC_MG_R_PRO) {
2999                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3000                 TRACE_RET(chip, TRANSPORT_FAILED);
3001         }
3002
3003         if (!CHK_MSPRO(ms_card)) {
3004                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3005                 TRACE_RET(chip, TRANSPORT_FAILED);
3006         }
3007
3008         key_format = srb->cmnd[10] & 0x3F;
3009         RTSX_DEBUGP("key_format = 0x%x\n", key_format);
3010
3011         switch (key_format) {
3012         case KF_SET_LEAF_ID:
3013                 if ((scsi_bufflen(srb) == 0x0C) &&
3014                         (srb->cmnd[8] == 0x00) &&
3015                         (srb->cmnd[9] == 0x0C)) {
3016                         retval = mg_set_leaf_id(srb, chip);
3017                         if (retval != STATUS_SUCCESS) {
3018                                 TRACE_RET(chip, TRANSPORT_FAILED);
3019                         }
3020                 } else {
3021                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3022                         TRACE_RET(chip, TRANSPORT_FAILED);
3023                 }
3024                 break;
3025
3026         case KF_CHG_HOST:
3027                 if ((scsi_bufflen(srb) == 0x0C) &&
3028                         (srb->cmnd[8] == 0x00) &&
3029                         (srb->cmnd[9] == 0x0C)) {
3030                         retval = mg_chg(srb, chip);
3031                         if (retval != STATUS_SUCCESS) {
3032                                 TRACE_RET(chip, TRANSPORT_FAILED);
3033                         }
3034                 } else {
3035                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3036                         TRACE_RET(chip, TRANSPORT_FAILED);
3037                 }
3038                 break;
3039
3040         case KF_RSP_HOST:
3041                 if ((scsi_bufflen(srb) == 0x0C) &&
3042                         (srb->cmnd[8] == 0x00) &&
3043                         (srb->cmnd[9] == 0x0C)) {
3044                         retval = mg_rsp(srb, chip);
3045                         if (retval != STATUS_SUCCESS) {
3046                                 TRACE_RET(chip, TRANSPORT_FAILED);
3047                         }
3048                 } else {
3049                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3050                         TRACE_RET(chip, TRANSPORT_FAILED);
3051                 }
3052                 break;
3053
3054         case KF_SET_ICV:
3055                 ms_card->mg_entry_num = srb->cmnd[5];
3056                 if ((scsi_bufflen(srb) == 0x404) &&
3057                         (srb->cmnd[8] == 0x04) &&
3058                         (srb->cmnd[9] == 0x04) &&
3059                         (srb->cmnd[2] == 0x00) &&
3060                         (srb->cmnd[3] == 0x00) &&
3061                         (srb->cmnd[4] == 0x00) &&
3062                         (srb->cmnd[5] < 32)) {
3063                         retval = mg_set_ICV(srb, chip);
3064                         if (retval != STATUS_SUCCESS) {
3065                                 TRACE_RET(chip, TRANSPORT_FAILED);
3066                         }
3067                 } else {
3068                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3069                         TRACE_RET(chip, TRANSPORT_FAILED);
3070                 }
3071                 break;
3072
3073         default:
3074                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3075                 TRACE_RET(chip, TRANSPORT_FAILED);
3076         }
3077
3078         scsi_set_resid(srb, 0);
3079         return TRANSPORT_GOOD;
3080 }
3081 #endif
3082
3083 int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3084 {
3085 #ifdef SUPPORT_SD_LOCK
3086         struct sd_info *sd_card = &(chip->sd_card);
3087 #endif
3088         struct ms_info *ms_card = &(chip->ms_card);
3089         unsigned int lun = SCSI_LUN(srb);
3090         int result;
3091
3092 #ifdef SUPPORT_SD_LOCK
3093         if (sd_card->sd_erase_status) {
3094                 /* Block all SCSI command except for
3095                  * REQUEST_SENSE and rs_ppstatus
3096                  */
3097                 if (!((srb->cmnd[0] == VENDOR_CMND) &&
3098                                 (srb->cmnd[1] == SCSI_APP_CMD) &&
3099                                 (srb->cmnd[2] == GET_DEV_STATUS)) &&
3100                                 (srb->cmnd[0] != REQUEST_SENSE)) {
3101                         /* Logical Unit Not Ready Format in Progress */
3102                         set_sense_data(chip, lun, CUR_ERR,
3103                                        0x02, 0, 0x04, 0x04, 0, 0);
3104                         TRACE_RET(chip, TRANSPORT_FAILED);
3105                 }
3106         }
3107 #endif
3108
3109         if ((get_lun_card(chip, lun) == MS_CARD) &&
3110                         (ms_card->format_status == FORMAT_IN_PROGRESS)) {
3111                 if ((srb->cmnd[0] != REQUEST_SENSE) && (srb->cmnd[0] != INQUIRY)) {
3112                         /* Logical Unit Not Ready Format in Progress */
3113                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
3114                                         0, (u16)(ms_card->progress));
3115                         TRACE_RET(chip, TRANSPORT_FAILED);
3116                 }
3117         }
3118
3119         switch (srb->cmnd[0]) {
3120         case READ_10:
3121         case WRITE_10:
3122         case READ_6:
3123         case WRITE_6:
3124                 result = read_write(srb, chip);
3125 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3126                 led_shine(srb, chip);
3127 #endif
3128                 break;
3129
3130         case TEST_UNIT_READY:
3131                 result = test_unit_ready(srb, chip);
3132                 break;
3133
3134         case INQUIRY:
3135                 result = inquiry(srb, chip);
3136                 break;
3137
3138         case READ_CAPACITY:
3139                 result = read_capacity(srb, chip);
3140                 break;
3141
3142         case START_STOP:
3143                 result = start_stop_unit(srb, chip);
3144                 break;
3145
3146         case ALLOW_MEDIUM_REMOVAL:
3147                 result = allow_medium_removal(srb, chip);
3148                 break;
3149
3150         case REQUEST_SENSE:
3151                 result = request_sense(srb, chip);
3152                 break;
3153
3154         case MODE_SENSE:
3155         case MODE_SENSE_10:
3156                 result = mode_sense(srb, chip);
3157                 break;
3158
3159         case 0x23:
3160                 result = read_format_capacity(srb, chip);
3161                 break;
3162
3163         case VENDOR_CMND:
3164                 result = vendor_cmnd(srb, chip);
3165                 break;
3166
3167         case MS_SP_CMND:
3168                 result = ms_sp_cmnd(srb, chip);
3169                 break;
3170
3171 #ifdef SUPPORT_CPRM
3172         case SD_PASS_THRU_MODE:
3173         case SD_EXECUTE_NO_DATA:
3174         case SD_EXECUTE_READ:
3175         case SD_EXECUTE_WRITE:
3176         case SD_GET_RSP:
3177         case SD_HW_RST:
3178                 result = sd_extention_cmnd(srb, chip);
3179                 break;
3180 #endif
3181
3182 #ifdef SUPPORT_MAGIC_GATE
3183         case CMD_MSPRO_MG_RKEY:
3184                 result = mg_report_key(srb, chip);
3185                 break;
3186
3187         case CMD_MSPRO_MG_SKEY:
3188                 result = mg_send_key(srb, chip);
3189                 break;
3190 #endif
3191
3192         case FORMAT_UNIT:
3193         case MODE_SELECT:
3194         case VERIFY:
3195                 result = TRANSPORT_GOOD;
3196                 break;
3197
3198         default:
3199                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3200                 result = TRANSPORT_FAILED;
3201         }
3202
3203         return result;
3204 }