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