drivers/staging/rts5208/rtsx_scsi.c

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