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                 } else {
 590                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 591                         TRACE_RET(chip, TRANSPORT_FAILED);
 592                 }
 593
 594                 break;
 595         }
 596
 597         TRACE_RET(chip, TRANSPORT_ERROR);
 598 }
 599
 600
 601 static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 602 {
 603         int prevent;
 604
 605         prevent = srb->cmnd[4] & 0x1;
 606
 607         scsi_set_resid(srb, 0);
 608
 609         if (prevent) {
 610                 set_sense_type(chip, SCSI_LUN(srb),
 611                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 612                 TRACE_RET(chip, TRANSPORT_FAILED);
 613         }
 614
 615         return TRANSPORT_GOOD;
 616 }
 617
 618
 619 static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 620 {
 621         struct sense_data_t *sense;
 622         unsigned int lun = SCSI_LUN(srb);
 623         struct ms_info *ms_card = &(chip->ms_card);
 624         unsigned char *tmp, *buf;
 625
 626         sense = &(chip->sense_buffer[lun]);
 627
 628         if ((get_lun_card(chip, lun) == MS_CARD) &&
 629                 ms_card->pro_under_formatting) {
 630                 if (ms_card->format_status == FORMAT_SUCCESS) {
 631                         set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 632                         ms_card->pro_under_formatting = 0;
 633                         ms_card->progress = 0;
 634                 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) {
 635                         /* Logical Unit Not Ready Format in Progress */
 636                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
 637                                         0, (u16)(ms_card->progress));
 638                 } else {
 639                         /* Format Command Failed */
 640                         set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
 641                         ms_card->pro_under_formatting = 0;
 642                         ms_card->progress = 0;
 643                 }
 644
 645                 rtsx_set_stat(chip, RTSX_STAT_RUN);
 646         }
 647
 648         buf = vmalloc(scsi_bufflen(srb));
 649         if (buf == NULL)
 650                 TRACE_RET(chip, TRANSPORT_ERROR);
 651
 652         tmp = (unsigned char *)sense;
 653         memcpy(buf, tmp, scsi_bufflen(srb));
 654
 655         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
 656         vfree(buf);
 657
 658         scsi_set_resid(srb, 0);
 659         /* Reset Sense Data */
 660         set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 661         return TRANSPORT_GOOD;
 662 }
 663
 664 static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
 665                 int lun, u8 *buf, int buf_len)
 666 {
 667         struct ms_info *ms_card = &(chip->ms_card);
 668         int sys_info_offset;
 669         int data_size = buf_len;
 670         int support_format = 0;
 671         int i = 0;
 672
 673         if (cmd == MODE_SENSE) {
 674                 sys_info_offset = 8;
 675                 if (data_size > 0x68)
 676                         data_size = 0x68;
 677
 678                 buf[i++] = 0x67;  /* Mode Data Length */
 679         } else {
 680                 sys_info_offset = 12;
 681                 if (data_size > 0x6C)
 682                         data_size = 0x6C;
 683
 684                 buf[i++] = 0x00;  /* Mode Data Length (MSB) */
 685                 buf[i++] = 0x6A;  /* Mode Data Length (LSB) */
 686         }
 687
 688         /* Medium Type Code */
 689         if (check_card_ready(chip, lun)) {
 690                 if (CHK_MSXC(ms_card)) {
 691                         support_format = 1;
 692                         buf[i++] = 0x40;
 693                 } else if (CHK_MSPRO(ms_card)) {
 694                         support_format = 1;
 695                         buf[i++] = 0x20;
 696                 } else {
 697                         buf[i++] = 0x10;
 698                 }
 699
 700                 /* WP */
 701                 if (check_card_wp(chip, lun))
 702                         buf[i++] = 0x80;
 703                 else
 704                         buf[i++] = 0x00;
 705
 706         } else {
 707                 buf[i++] = 0x00;        /* MediaType */
 708                 buf[i++] = 0x00;        /* WP */
 709         }
 710
 711         buf[i++] = 0x00;                /* Reserved */
 712
 713         if (cmd == MODE_SENSE_10) {
 714                 buf[i++] = 0x00;  /* Reserved */
 715                 buf[i++] = 0x00;  /* Block descriptor length(MSB) */
 716                 buf[i++] = 0x00;  /* Block descriptor length(LSB) */
 717
 718                 /* The Following Data is the content of "Page 0x20" */
 719                 if (data_size >= 9)
 720                         buf[i++] = 0x20;                /* Page Code */
 721                 if (data_size >= 10)
 722                         buf[i++] = 0x62;                /* Page Length */
 723                 if (data_size >= 11)
 724                         buf[i++] = 0x00;                /* No Access Control */
 725                 if (data_size >= 12) {
 726                         if (support_format)
 727                                 buf[i++] = 0xC0;        /* SF, SGM */
 728                         else
 729                                 buf[i++] = 0x00;
 730                 }
 731         } else {
 732                 /* The Following Data is the content of "Page 0x20" */
 733                 if (data_size >= 5)
 734                         buf[i++] = 0x20;                /* Page Code */
 735                 if (data_size >= 6)
 736                         buf[i++] = 0x62;                /* Page Length */
 737                 if (data_size >= 7)
 738                         buf[i++] = 0x00;                /* No Access Control */
 739                 if (data_size >= 8) {
 740                         if (support_format)
 741                                 buf[i++] = 0xC0;        /* SF, SGM */
 742                         else
 743                                 buf[i++] = 0x00;
 744                 }
 745         }
 746
 747         if (data_size > sys_info_offset) {
 748                 /* 96 Bytes Attribute Data */
 749                 int len = data_size - sys_info_offset;
 750
 751                 len = (len < 96) ? len : 96;
 752
 753                 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
 754         }
 755 }
 756
 757 static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 758 {
 759         unsigned int lun = SCSI_LUN(srb);
 760         unsigned int dataSize;
 761         int status;
 762         int pro_formatter_flag;
 763         unsigned char pageCode, *buf;
 764         u8 card = get_lun_card(chip, lun);
 765
 766 #ifndef SUPPORT_MAGIC_GATE
 767         if (!check_card_ready(chip, lun)) {
 768                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 769                 scsi_set_resid(srb, scsi_bufflen(srb));
 770                 TRACE_RET(chip, TRANSPORT_FAILED);
 771         }
 772 #endif
 773
 774         pro_formatter_flag = 0;
 775         dataSize = 8;
 776 #ifdef SUPPORT_MAGIC_GATE
 777         if ((chip->lun2card[lun] & MS_CARD)) {
 778                 if (!card || (card == MS_CARD)) {
 779                         dataSize = 108;
 780                         if (chip->mspro_formatter_enable)
 781                                 pro_formatter_flag = 1;
 782                 }
 783         }
 784 #else
 785         if (card == MS_CARD) {
 786                 if (chip->mspro_formatter_enable) {
 787                         pro_formatter_flag = 1;
 788                         dataSize = 108;
 789                 }
 790         }
 791 #endif
 792
 793         buf = kmalloc(dataSize, GFP_KERNEL);
 794         if (buf == NULL)
 795                 TRACE_RET(chip, TRANSPORT_ERROR);
 796
 797         pageCode = srb->cmnd[2] & 0x3f;
 798
 799         if ((pageCode == 0x3F) || (pageCode == 0x1C) ||
 800                 (pageCode == 0x00) ||
 801                 (pro_formatter_flag && (pageCode == 0x20))) {
 802                 if (srb->cmnd[0] == MODE_SENSE) {
 803                         if ((pageCode == 0x3F) || (pageCode == 0x20)) {
 804                                 ms_mode_sense(chip, srb->cmnd[0],
 805                                               lun, buf, dataSize);
 806                         } else {
 807                                 dataSize = 4;
 808                                 buf[0] = 0x03;
 809                                 buf[1] = 0x00;
 810                                 if (check_card_wp(chip, lun))
 811                                         buf[2] = 0x80;
 812                                 else
 813                                         buf[2] = 0x00;
 814
 815                                 buf[3] = 0x00;
 816                         }
 817                 } else {
 818                         if ((pageCode == 0x3F) || (pageCode == 0x20)) {
 819                                 ms_mode_sense(chip, srb->cmnd[0],
 820                                               lun, buf, dataSize);
 821                         } else {
 822                                 dataSize = 8;
 823                                 buf[0] = 0x00;
 824                                 buf[1] = 0x06;
 825                                 buf[2] = 0x00;
 826                                 if (check_card_wp(chip, lun))
 827                                         buf[3] = 0x80;
 828                                 else
 829                                         buf[3] = 0x00;
 830                                 buf[4] = 0x00;
 831                                 buf[5] = 0x00;
 832                                 buf[6] = 0x00;
 833                                 buf[7] = 0x00;
 834                         }
 835                 }
 836                 status = TRANSPORT_GOOD;
 837         } else {
 838                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 839                 scsi_set_resid(srb, scsi_bufflen(srb));
 840                 status = TRANSPORT_FAILED;
 841         }
 842
 843         if (status == TRANSPORT_GOOD) {
 844                 unsigned int len = min_t(unsigned int, scsi_bufflen(srb),
 845                                         dataSize);
 846                 rtsx_stor_set_xfer_buf(buf, len, srb);
 847                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
 848         }
 849         kfree(buf);
 850
 851         return status;
 852 }
 853
 854 static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 855 {
 856 #ifdef SUPPORT_SD_LOCK
 857         struct sd_info *sd_card = &(chip->sd_card);
 858 #endif
 859         unsigned int lun = SCSI_LUN(srb);
 860         int retval;
 861         u32 start_sec;
 862         u16 sec_cnt;
 863
 864         rtsx_disable_aspm(chip);
 865
 866         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
 867                 rtsx_exit_ss(chip);
 868                 wait_timeout(100);
 869         }
 870         rtsx_set_stat(chip, RTSX_STAT_RUN);
 871
 872         if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) {
 873                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 874                 TRACE_RET(chip, TRANSPORT_FAILED);
 875         }
 876
 877         if (!(CHK_BIT(chip->lun_mc, lun))) {
 878                 SET_BIT(chip->lun_mc, lun);
 879                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 880                 return TRANSPORT_FAILED;
 881         }
 882
 883 #ifdef SUPPORT_SD_LOCK
 884         if (sd_card->sd_erase_status) {
 885                 /* Accessing to any card is forbidden
 886                  * until the erase procedure of SD is completed
 887                  */
 888                 dev_dbg(rtsx_dev(chip), "SD card being erased!\n");
 889                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 890                 TRACE_RET(chip, TRANSPORT_FAILED);
 891         }
 892
 893         if (get_lun_card(chip, lun) == SD_CARD) {
 894                 if (sd_card->sd_lock_status & SD_LOCKED) {
 895                         dev_dbg(rtsx_dev(chip), "SD card locked!\n");
 896                         set_sense_type(chip, lun,
 897                                 SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 898                         TRACE_RET(chip, TRANSPORT_FAILED);
 899                 }
 900         }
 901 #endif
 902
 903         if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
 904                 start_sec = ((u32)srb->cmnd[2] << 24) |
 905                         ((u32)srb->cmnd[3] << 16) |
 906                         ((u32)srb->cmnd[4] << 8) | ((u32)srb->cmnd[5]);
 907                 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
 908         } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
 909                 start_sec = ((u32)(srb->cmnd[1] & 0x1F) << 16) |
 910                         ((u32)srb->cmnd[2] << 8) | ((u32)srb->cmnd[3]);
 911                 sec_cnt = srb->cmnd[4];
 912         } else if ((srb->cmnd[0] == VENDOR_CMND) &&
 913                 (srb->cmnd[1] == SCSI_APP_CMD) &&
 914                 ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) {
 915                 start_sec = ((u32)srb->cmnd[4] << 24) |
 916                         ((u32)srb->cmnd[5] << 16) |
 917                         ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]);
 918                 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10];
 919         } else {
 920                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 921                 TRACE_RET(chip, TRANSPORT_FAILED);
 922         }
 923
 924         /* In some test, we will receive a start_sec like 0xFFFFFFFF.
 925          * In this situation, start_sec + sec_cnt will overflow, so we
 926          * need to judge start_sec at first
 927          */
 928         if ((start_sec > get_card_size(chip, lun)) ||
 929                         ((start_sec + sec_cnt) > get_card_size(chip, lun))) {
 930                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
 931                 TRACE_RET(chip, TRANSPORT_FAILED);
 932         }
 933
 934         if (sec_cnt == 0) {
 935                 scsi_set_resid(srb, 0);
 936                 return TRANSPORT_GOOD;
 937         }
 938
 939         if (chip->rw_fail_cnt[lun] == 3) {
 940                 dev_dbg(rtsx_dev(chip), "read/write fail three times in succession\n");
 941                 if (srb->sc_data_direction == DMA_FROM_DEVICE)
 942                         set_sense_type(chip, lun,
 943                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
 944                 else
 945                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
 946
 947                 TRACE_RET(chip, TRANSPORT_FAILED);
 948         }
 949
 950         if (srb->sc_data_direction == DMA_TO_DEVICE) {
 951                 if (check_card_wp(chip, lun)) {
 952                         dev_dbg(rtsx_dev(chip), "Write protected card!\n");
 953                         set_sense_type(chip, lun,
 954                                 SENSE_TYPE_MEDIA_WRITE_PROTECT);
 955                         TRACE_RET(chip, TRANSPORT_FAILED);
 956                 }
 957         }
 958
 959         retval = card_rw(srb, chip, start_sec, sec_cnt);
 960         if (retval != STATUS_SUCCESS) {
 961                 if (chip->need_release & chip->lun2card[lun]) {
 962                         chip->rw_fail_cnt[lun] = 0;
 963                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 964                 } else {
 965                         chip->rw_fail_cnt[lun]++;
 966                         if (srb->sc_data_direction == DMA_FROM_DEVICE)
 967                                 set_sense_type(chip, lun,
 968                                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
 969                         else
 970                                 set_sense_type(chip, lun,
 971                                         SENSE_TYPE_MEDIA_WRITE_ERR);
 972                 }
 973                 retval = TRANSPORT_FAILED;
 974                 TRACE_GOTO(chip, Exit);
 975         } else {
 976                 chip->rw_fail_cnt[lun] = 0;
 977                 retval = TRANSPORT_GOOD;
 978         }
 979
 980         scsi_set_resid(srb, 0);
 981
 982 Exit:
 983         return retval;
 984 }
 985
 986 static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 987 {
 988         unsigned char *buf;
 989         unsigned int lun = SCSI_LUN(srb);
 990         unsigned int buf_len;
 991         u8 card = get_lun_card(chip, lun);
 992         u32 card_size;
 993         int desc_cnt;
 994         int i = 0;
 995
 996         if (!check_card_ready(chip, lun)) {
 997                 if (!chip->mspro_formatter_enable) {
 998                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 999                         TRACE_RET(chip, TRANSPORT_FAILED);
1000                 }
1001         }
1002
1003         buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
1004
1005         buf = kmalloc(buf_len, GFP_KERNEL);
1006         if (buf == NULL)
1007                 TRACE_RET(chip, TRANSPORT_ERROR);
1008
1009         buf[i++] = 0;
1010         buf[i++] = 0;
1011         buf[i++] = 0;
1012
1013         /* Capacity List Length */
1014         if ((buf_len > 12) && chip->mspro_formatter_enable &&
1015                         (chip->lun2card[lun] & MS_CARD) &&
1016                         (!card || (card == MS_CARD))) {
1017                 buf[i++] = 0x10;
1018                 desc_cnt = 2;
1019         } else {
1020                 buf[i++] = 0x08;
1021                 desc_cnt = 1;
1022         }
1023
1024         while (desc_cnt) {
1025                 if (check_card_ready(chip, lun)) {
1026                         card_size = get_card_size(chip, lun);
1027                         buf[i++] = (unsigned char)(card_size >> 24);
1028                         buf[i++] = (unsigned char)(card_size >> 16);
1029                         buf[i++] = (unsigned char)(card_size >> 8);
1030                         buf[i++] = (unsigned char)card_size;
1031
1032                         if (desc_cnt == 2)
1033                                 buf[i++] = 2;
1034                         else
1035                                 buf[i++] = 0;
1036                 } else {
1037                         buf[i++] = 0xFF;
1038                         buf[i++] = 0xFF;
1039                         buf[i++] = 0xFF;
1040                         buf[i++] = 0xFF;
1041
1042                         if (desc_cnt == 2)
1043                                 buf[i++] = 3;
1044                         else
1045                                 buf[i++] = 0;
1046                 }
1047
1048                 buf[i++] = 0x00;
1049                 buf[i++] = 0x02;
1050                 buf[i++] = 0x00;
1051
1052                 desc_cnt--;
1053         }
1054
1055         buf_len = min_t(unsigned int, scsi_bufflen(srb), buf_len);
1056         rtsx_stor_set_xfer_buf(buf, buf_len, srb);
1057         kfree(buf);
1058
1059         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1060
1061         return TRANSPORT_GOOD;
1062 }
1063
1064 static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1065 {
1066         unsigned char *buf;
1067         unsigned int lun = SCSI_LUN(srb);
1068         u32 card_size;
1069
1070         if (!check_card_ready(chip, lun)) {
1071                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1072                 TRACE_RET(chip, TRANSPORT_FAILED);
1073         }
1074
1075         if (!(CHK_BIT(chip->lun_mc, lun))) {
1076                 SET_BIT(chip->lun_mc, lun);
1077                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
1078                 return TRANSPORT_FAILED;
1079         }
1080
1081         buf = kmalloc(8, GFP_KERNEL);
1082         if (buf == NULL)
1083                 TRACE_RET(chip, TRANSPORT_ERROR);
1084
1085         card_size = get_card_size(chip, lun);
1086         buf[0] = (unsigned char)((card_size - 1) >> 24);
1087         buf[1] = (unsigned char)((card_size - 1) >> 16);
1088         buf[2] = (unsigned char)((card_size - 1) >> 8);
1089         buf[3] = (unsigned char)(card_size - 1);
1090
1091         buf[4] = 0x00;
1092         buf[5] = 0x00;
1093         buf[6] = 0x02;
1094         buf[7] = 0x00;
1095
1096         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1097         kfree(buf);
1098
1099         scsi_set_resid(srb, 0);
1100
1101         return TRANSPORT_GOOD;
1102 }
1103
1104 static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1105 {
1106         unsigned short len, i;
1107         int retval;
1108         u8 *buf;
1109
1110         rtsx_disable_aspm(chip);
1111
1112         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1113                 rtsx_exit_ss(chip);
1114                 wait_timeout(100);
1115         }
1116         rtsx_set_stat(chip, RTSX_STAT_RUN);
1117
1118         len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1119
1120         buf = vmalloc(len);
1121         if (!buf)
1122                 TRACE_RET(chip, TRANSPORT_ERROR);
1123
1124         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1125         if (retval != STATUS_SUCCESS) {
1126                 vfree(buf);
1127                 set_sense_type(chip, SCSI_LUN(srb),
1128                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1129                 TRACE_RET(chip, TRANSPORT_FAILED);
1130         }
1131
1132         for (i = 0; i < len; i++) {
1133                 retval = spi_read_eeprom(chip, i, buf + i);
1134                 if (retval != STATUS_SUCCESS) {
1135                         vfree(buf);
1136                         set_sense_type(chip, SCSI_LUN(srb),
1137                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1138                         TRACE_RET(chip, TRANSPORT_FAILED);
1139                 }
1140         }
1141
1142         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1143         rtsx_stor_set_xfer_buf(buf, len, srb);
1144         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1145
1146         vfree(buf);
1147
1148         return TRANSPORT_GOOD;
1149 }
1150
1151 static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1152 {
1153         unsigned short len, i;
1154         int retval;
1155         u8 *buf;
1156
1157         rtsx_disable_aspm(chip);
1158
1159         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1160                 rtsx_exit_ss(chip);
1161                 wait_timeout(100);
1162         }
1163         rtsx_set_stat(chip, RTSX_STAT_RUN);
1164
1165         len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1166
1167         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1168         if (retval != STATUS_SUCCESS) {
1169                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1170                 TRACE_RET(chip, TRANSPORT_FAILED);
1171         }
1172
1173         if (len == 511) {
1174                 retval = spi_erase_eeprom_chip(chip);
1175                 if (retval != STATUS_SUCCESS) {
1176                         set_sense_type(chip, SCSI_LUN(srb),
1177                                 SENSE_TYPE_MEDIA_WRITE_ERR);
1178                         TRACE_RET(chip, TRANSPORT_FAILED);
1179                 }
1180         } else {
1181                 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1182                                         len);
1183                 buf = vmalloc(len);
1184                 if (buf == NULL)
1185                         TRACE_RET(chip, TRANSPORT_ERROR);
1186
1187                 rtsx_stor_get_xfer_buf(buf, len, srb);
1188                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1189
1190                 for (i = 0; i < len; i++) {
1191                         retval = spi_write_eeprom(chip, i, buf[i]);
1192                         if (retval != STATUS_SUCCESS) {
1193                                 vfree(buf);
1194                                 set_sense_type(chip, SCSI_LUN(srb),
1195                                         SENSE_TYPE_MEDIA_WRITE_ERR);
1196                                 TRACE_RET(chip, TRANSPORT_FAILED);
1197                         }
1198                 }
1199
1200                 vfree(buf);
1201         }
1202
1203         return TRANSPORT_GOOD;
1204 }
1205
1206 static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1207 {
1208         unsigned short addr, len, i;
1209         int retval;
1210         u8 *buf;
1211
1212         rtsx_disable_aspm(chip);
1213
1214         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1215                 rtsx_exit_ss(chip);
1216                 wait_timeout(100);
1217         }
1218         rtsx_set_stat(chip, RTSX_STAT_RUN);
1219
1220         addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1221         len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1222
1223         if (addr < 0xFC00) {
1224                 set_sense_type(chip, SCSI_LUN(srb),
1225                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1226                 TRACE_RET(chip, TRANSPORT_FAILED);
1227         }
1228
1229         buf = vmalloc(len);
1230         if (!buf)
1231                 TRACE_RET(chip, TRANSPORT_ERROR);
1232
1233         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1234         if (retval != STATUS_SUCCESS) {
1235                 vfree(buf);
1236                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1237                 TRACE_RET(chip, TRANSPORT_FAILED);
1238         }
1239
1240         for (i = 0; i < len; i++) {
1241                 retval = rtsx_read_register(chip, addr + i, buf + i);
1242                 if (retval != STATUS_SUCCESS) {
1243                         vfree(buf);
1244                         set_sense_type(chip, SCSI_LUN(srb),
1245                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1246                         TRACE_RET(chip, TRANSPORT_FAILED);
1247                 }
1248         }
1249
1250         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1251         rtsx_stor_set_xfer_buf(buf, len, srb);
1252         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1253
1254         vfree(buf);
1255
1256         return TRANSPORT_GOOD;
1257 }
1258
1259 static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1260 {
1261         unsigned short addr, len, i;
1262         int retval;
1263         u8 *buf;
1264
1265         rtsx_disable_aspm(chip);
1266
1267         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1268                 rtsx_exit_ss(chip);
1269                 wait_timeout(100);
1270         }
1271         rtsx_set_stat(chip, RTSX_STAT_RUN);
1272
1273         addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1274         len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1275
1276         if (addr < 0xFC00) {
1277                 set_sense_type(chip, SCSI_LUN(srb),
1278                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1279                 TRACE_RET(chip, TRANSPORT_FAILED);
1280         }
1281
1282         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1283         buf = vmalloc(len);
1284         if (buf == NULL)
1285                 TRACE_RET(chip, TRANSPORT_ERROR);
1286
1287         rtsx_stor_get_xfer_buf(buf, len, srb);
1288         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1289
1290         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1291         if (retval != STATUS_SUCCESS) {
1292                 vfree(buf);
1293                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1294                 TRACE_RET(chip, TRANSPORT_FAILED);
1295         }
1296
1297         for (i = 0; i < len; i++) {
1298                 retval = rtsx_write_register(chip, addr + i, 0xFF, buf[i]);
1299                 if (retval != STATUS_SUCCESS) {
1300                         vfree(buf);
1301                         set_sense_type(chip, SCSI_LUN(srb),
1302                                 SENSE_TYPE_MEDIA_WRITE_ERR);
1303                         TRACE_RET(chip, TRANSPORT_FAILED);
1304                 }
1305         }
1306
1307         vfree(buf);
1308
1309         return TRANSPORT_GOOD;
1310 }
1311
1312 static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1313 {
1314         struct sd_info *sd_card = &(chip->sd_card);
1315         unsigned int lun = SCSI_LUN(srb);
1316
1317         if (!check_card_ready(chip, lun)) {
1318                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1319                 TRACE_RET(chip, TRANSPORT_FAILED);
1320         }
1321
1322         if (get_lun_card(chip, lun) != SD_CARD) {
1323                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1324                 TRACE_RET(chip, TRANSPORT_FAILED);
1325         }
1326
1327         scsi_set_resid(srb, 0);
1328         rtsx_stor_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1329
1330         return TRANSPORT_GOOD;
1331 }
1332
1333 static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1334 {
1335         u8 gpio = srb->cmnd[2];
1336
1337         rtsx_disable_aspm(chip);
1338
1339         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1340                 rtsx_exit_ss(chip);
1341                 wait_timeout(100);
1342         }
1343         rtsx_set_stat(chip, RTSX_STAT_RUN);
1344
1345         if (gpio > 3)
1346                 gpio = 1;
1347         toggle_gpio(chip, gpio);
1348
1349         return TRANSPORT_GOOD;
1350 }
1351
1352 #ifdef _MSG_TRACE
1353 static int trace_msg_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1354 {
1355         unsigned char *ptr, *buf = NULL;
1356         int i, msg_cnt;
1357         u8 clear;
1358         unsigned int buf_len;
1359
1360         buf_len = 4 + ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) *
1361                 TRACE_ITEM_CNT);
1362
1363         if ((scsi_bufflen(srb) < buf_len) || (scsi_sglist(srb) == NULL)) {
1364                 set_sense_type(chip, SCSI_LUN(srb),
1365                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1366                 TRACE_RET(chip, TRANSPORT_FAILED);
1367         }
1368
1369         clear = srb->cmnd[2];
1370
1371         buf = vmalloc(scsi_bufflen(srb));
1372         if (buf == NULL)
1373                 TRACE_RET(chip, TRANSPORT_ERROR);
1374         ptr = buf;
1375
1376         if (chip->trace_msg[chip->msg_idx].valid)
1377                 msg_cnt = TRACE_ITEM_CNT;
1378         else
1379                 msg_cnt = chip->msg_idx;
1380
1381         *(ptr++) = (u8)(msg_cnt >> 24);
1382         *(ptr++) = (u8)(msg_cnt >> 16);
1383         *(ptr++) = (u8)(msg_cnt >> 8);
1384         *(ptr++) = (u8)msg_cnt;
1385         dev_dbg(rtsx_dev(chip), "Trace message count is %d\n", msg_cnt);
1386
1387         for (i = 1; i <= msg_cnt; i++) {
1388                 int j, idx;
1389
1390                 idx = chip->msg_idx - i;
1391                 if (idx < 0)
1392                         idx += TRACE_ITEM_CNT;
1393
1394                 *(ptr++) = (u8)(chip->trace_msg[idx].line >> 8);
1395                 *(ptr++) = (u8)(chip->trace_msg[idx].line);
1396                 for (j = 0; j < MSG_FUNC_LEN; j++)
1397                         *(ptr++) = chip->trace_msg[idx].func[j];
1398
1399                 for (j = 0; j < MSG_FILE_LEN; j++)
1400                         *(ptr++) = chip->trace_msg[idx].file[j];
1401
1402                 for (j = 0; j < TIME_VAL_LEN; j++)
1403                         *(ptr++) = chip->trace_msg[idx].timeval_buf[j];
1404         }
1405
1406         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1407         vfree(buf);
1408
1409         if (clear) {
1410                 chip->msg_idx = 0;
1411                 for (i = 0; i < TRACE_ITEM_CNT; i++)
1412                         chip->trace_msg[i].valid = 0;
1413         }
1414
1415         scsi_set_resid(srb, 0);
1416         return TRANSPORT_GOOD;
1417 }
1418 #endif
1419
1420 static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1421 {
1422         u8 addr, buf[4];
1423         u32 val;
1424         unsigned int len;
1425
1426         rtsx_disable_aspm(chip);
1427
1428         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1429                 rtsx_exit_ss(chip);
1430                 wait_timeout(100);
1431         }
1432         rtsx_set_stat(chip, RTSX_STAT_RUN);
1433
1434         addr = srb->cmnd[4];
1435
1436         val = rtsx_readl(chip, addr);
1437         dev_dbg(rtsx_dev(chip), "Host register (0x%x): 0x%x\n", addr, val);
1438
1439         buf[0] = (u8)(val >> 24);
1440         buf[1] = (u8)(val >> 16);
1441         buf[2] = (u8)(val >> 8);
1442         buf[3] = (u8)val;
1443
1444         len = min_t(unsigned int, scsi_bufflen(srb), 4);
1445         rtsx_stor_set_xfer_buf(buf, len, srb);
1446         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1447
1448         return TRANSPORT_GOOD;
1449 }
1450
1451 static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1452 {
1453         u8 addr, buf[4];
1454         u32 val;
1455         unsigned int len;
1456
1457         rtsx_disable_aspm(chip);
1458
1459         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1460                 rtsx_exit_ss(chip);
1461                 wait_timeout(100);
1462         }
1463         rtsx_set_stat(chip, RTSX_STAT_RUN);
1464
1465         addr = srb->cmnd[4];
1466
1467         len = min_t(unsigned int, scsi_bufflen(srb), 4);
1468         rtsx_stor_get_xfer_buf(buf, len, srb);
1469         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1470
1471         val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2]
1472                                                         << 8) | buf[3];
1473
1474         rtsx_writel(chip, addr, val);
1475
1476         return TRANSPORT_GOOD;
1477 }
1478
1479 static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1480 {
1481         unsigned lun = SCSI_LUN(srb);
1482
1483         if (srb->cmnd[3] == 1) {
1484                 /* Variable Clock */
1485                 struct xd_info *xd_card = &(chip->xd_card);
1486                 struct sd_info *sd_card = &(chip->sd_card);
1487                 struct ms_info *ms_card = &(chip->ms_card);
1488
1489                 switch (srb->cmnd[4]) {
1490                 case XD_CARD:
1491                         xd_card->xd_clock = srb->cmnd[5];
1492                         break;
1493
1494                 case SD_CARD:
1495                         sd_card->sd_clock = srb->cmnd[5];
1496                         break;
1497
1498                 case MS_CARD:
1499                         ms_card->ms_clock = srb->cmnd[5];
1500                         break;
1501
1502                 default:
1503                         set_sense_type(chip, lun,
1504                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1505                         TRACE_RET(chip, TRANSPORT_FAILED);
1506                 }
1507         } else if (srb->cmnd[3] == 2) {
1508                 if (srb->cmnd[4]) {
1509                         chip->blink_led = 1;
1510                 } else {
1511                         int retval;
1512
1513                         chip->blink_led = 0;
1514
1515                         rtsx_disable_aspm(chip);
1516
1517                         if (chip->ss_en &&
1518                                 (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1519                                 rtsx_exit_ss(chip);
1520                                 wait_timeout(100);
1521                         }
1522                         rtsx_set_stat(chip, RTSX_STAT_RUN);
1523
1524                         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1525                         if (retval != STATUS_SUCCESS) {
1526                                 set_sense_type(chip, SCSI_LUN(srb),
1527                                         SENSE_TYPE_MEDIA_WRITE_ERR);
1528                                 TRACE_RET(chip, TRANSPORT_FAILED);
1529                         }
1530
1531                         turn_off_led(chip, LED_GPIO);
1532                 }
1533         } else {
1534                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1535                 TRACE_RET(chip, TRANSPORT_FAILED);
1536         }
1537
1538         return TRANSPORT_GOOD;
1539 }
1540
1541 static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1542 {
1543         unsigned int lun = SCSI_LUN(srb);
1544
1545         if (srb->cmnd[3] == 1) {
1546                 struct xd_info *xd_card = &(chip->xd_card);
1547                 struct sd_info *sd_card = &(chip->sd_card);
1548                 struct ms_info *ms_card = &(chip->ms_card);
1549                 u8 tmp;
1550
1551                 switch (srb->cmnd[4]) {
1552                 case XD_CARD:
1553                         tmp = (u8)(xd_card->xd_clock);
1554                         break;
1555
1556                 case SD_CARD:
1557                         tmp = (u8)(sd_card->sd_clock);
1558                         break;
1559
1560                 case MS_CARD:
1561                         tmp = (u8)(ms_card->ms_clock);
1562                         break;
1563
1564                 default:
1565                         set_sense_type(chip, lun,
1566                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1567                         TRACE_RET(chip, TRANSPORT_FAILED);
1568                 }
1569
1570                 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1571         } else if (srb->cmnd[3] == 2) {
1572                 u8 tmp = chip->blink_led;
1573
1574                 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1575         } else {
1576                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1577                 TRACE_RET(chip, TRANSPORT_FAILED);
1578         }
1579
1580         return TRANSPORT_GOOD;
1581 }
1582
1583 static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1584 {
1585         int retval;
1586         unsigned int lun = SCSI_LUN(srb);
1587         u16 len;
1588
1589         rtsx_disable_aspm(chip);
1590
1591         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1592                 rtsx_exit_ss(chip);
1593                 wait_timeout(100);
1594         }
1595         rtsx_set_stat(chip, RTSX_STAT_RUN);
1596
1597         len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1598         len = min_t(u16, len, scsi_bufflen(srb));
1599
1600         if (srb->sc_data_direction == DMA_FROM_DEVICE)
1601                 dev_dbg(rtsx_dev(chip), "Read from device\n");
1602         else
1603                 dev_dbg(rtsx_dev(chip), "Write to device\n");
1604
1605         retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len,
1606                         scsi_sg_count(srb), srb->sc_data_direction, 1000);
1607         if (retval < 0) {
1608                 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1609                         set_sense_type(chip, lun,
1610                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1611                 else
1612                         set_sense_type(chip, lun,
1613                                 SENSE_TYPE_MEDIA_WRITE_ERR);
1614
1615                 TRACE_RET(chip, TRANSPORT_FAILED);
1616         }
1617         scsi_set_resid(srb, 0);
1618
1619         return TRANSPORT_GOOD;
1620 }
1621
1622 static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1623 {
1624         struct sd_info *sd_card = &(chip->sd_card);
1625         struct ms_info *ms_card = &(chip->ms_card);
1626         int buf_len;
1627         unsigned int lun = SCSI_LUN(srb);
1628         u8 card = get_lun_card(chip, lun);
1629         u8 status[32];
1630 #ifdef SUPPORT_OCP
1631         u8 oc_now_mask = 0, oc_ever_mask = 0;
1632 #endif
1633
1634         memset(status, 0, 32);
1635
1636         status[0] = (u8)(chip->product_id);
1637         status[1] = chip->ic_version;
1638
1639         if (chip->auto_delink_en)
1640                 status[2] = 0x10;
1641         else
1642                 status[2] = 0x00;
1643
1644         status[3] = 20;
1645         status[4] = 10;
1646         status[5] = 05;
1647         status[6] = 21;
1648
1649         if (chip->card_wp)
1650                 status[7] = 0x20;
1651         else
1652                 status[7] = 0x00;
1653
1654 #ifdef SUPPORT_OCP
1655         status[8] = 0;
1656         if (CHECK_LUN_MODE(chip,
1657                 SD_MS_2LUN) && (chip->lun2card[lun] == MS_CARD)) {
1658                 oc_now_mask = MS_OC_NOW;
1659                 oc_ever_mask = MS_OC_EVER;
1660         } else {
1661                 oc_now_mask = SD_OC_NOW;
1662                 oc_ever_mask = SD_OC_EVER;
1663         }
1664
1665         if (chip->ocp_stat & oc_now_mask)
1666                 status[8] |= 0x02;
1667
1668         if (chip->ocp_stat & oc_ever_mask)
1669                 status[8] |= 0x01;
1670 #endif
1671
1672         if (card == SD_CARD) {
1673                 if (CHK_SD(sd_card)) {
1674                         if (CHK_SD_HCXC(sd_card)) {
1675                                 if (sd_card->capacity > 0x4000000)
1676                                         status[0x0E] = 0x02;
1677                                 else
1678                                         status[0x0E] = 0x01;
1679                         } else {
1680                                 status[0x0E] = 0x00;
1681                         }
1682
1683                         if (CHK_SD_SDR104(sd_card))
1684                                 status[0x0F] = 0x03;
1685                         else if (CHK_SD_DDR50(sd_card))
1686                                 status[0x0F] = 0x04;
1687                         else if (CHK_SD_SDR50(sd_card))
1688                                 status[0x0F] = 0x02;
1689                         else if (CHK_SD_HS(sd_card))
1690                                 status[0x0F] = 0x01;
1691                         else
1692                                 status[0x0F] = 0x00;
1693                 } else {
1694                         if (CHK_MMC_SECTOR_MODE(sd_card))
1695                                 status[0x0E] = 0x01;
1696                         else
1697                                 status[0x0E] = 0x00;
1698
1699                         if (CHK_MMC_DDR52(sd_card))
1700                                 status[0x0F] = 0x03;
1701                         else if (CHK_MMC_52M(sd_card))
1702                                 status[0x0F] = 0x02;
1703                         else if (CHK_MMC_26M(sd_card))
1704                                 status[0x0F] = 0x01;
1705                         else
1706                                 status[0x0F] = 0x00;
1707                 }
1708         } else if (card == MS_CARD) {
1709                 if (CHK_MSPRO(ms_card)) {
1710                         if (CHK_MSXC(ms_card))
1711                                 status[0x0E] = 0x01;
1712                         else
1713                                 status[0x0E] = 0x00;
1714
1715                         if (CHK_HG8BIT(ms_card))
1716                                 status[0x0F] = 0x01;
1717                         else
1718                                 status[0x0F] = 0x00;
1719                 }
1720         }
1721
1722 #ifdef SUPPORT_SD_LOCK
1723         if (card == SD_CARD) {
1724                 status[0x17] = 0x80;
1725                 if (sd_card->sd_erase_status)
1726                         status[0x17] |= 0x01;
1727                 if (sd_card->sd_lock_status & SD_LOCKED) {
1728                         status[0x17] |= 0x02;
1729                         status[0x07] |= 0x40;
1730                 }
1731                 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1732                         status[0x17] |= 0x04;
1733         } else {
1734                 status[0x17] = 0x00;
1735         }
1736
1737         dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]);
1738 #endif
1739
1740         status[0x18] = 0x8A;
1741         status[0x1A] = 0x28;
1742 #ifdef SUPPORT_SD_LOCK
1743         status[0x1F] = 0x01;
1744 #endif
1745
1746         buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status));
1747         rtsx_stor_set_xfer_buf(status, buf_len, srb);
1748         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1749
1750         return TRANSPORT_GOOD;
1751 }
1752
1753 static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1754 {
1755         int phy_debug_mode;
1756         int retval;
1757         u16 reg;
1758
1759         if (!CHECK_PID(chip, 0x5208)) {
1760                 set_sense_type(chip, SCSI_LUN(srb),
1761                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1762                 TRACE_RET(chip, TRANSPORT_FAILED);
1763         }
1764
1765         phy_debug_mode = (int)(srb->cmnd[3]);
1766
1767         if (phy_debug_mode) {
1768                 chip->phy_debug_mode = 1;
1769                 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
1770                 if (retval != STATUS_SUCCESS)
1771                         TRACE_RET(chip, TRANSPORT_FAILED);
1772
1773                 rtsx_disable_bus_int(chip);
1774
1775                 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
1776                 if (retval != STATUS_SUCCESS)
1777                         TRACE_RET(chip, TRANSPORT_FAILED);
1778
1779                 reg |= 0x0001;
1780                 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1781                 if (retval != STATUS_SUCCESS)
1782                         TRACE_RET(chip, TRANSPORT_FAILED);
1783         } else {
1784                 chip->phy_debug_mode = 0;
1785                 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1786                 if (retval != STATUS_SUCCESS)
1787                         TRACE_RET(chip, TRANSPORT_FAILED);
1788
1789                 rtsx_enable_bus_int(chip);
1790
1791                 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
1792                 if (retval != STATUS_SUCCESS)
1793                         TRACE_RET(chip, TRANSPORT_FAILED);
1794
1795                 reg &= 0xFFFE;
1796                 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1797                 if (retval != STATUS_SUCCESS)
1798                         TRACE_RET(chip, TRANSPORT_FAILED);
1799         }
1800
1801         return TRANSPORT_GOOD;
1802 }
1803
1804 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1805 {
1806         int retval =  STATUS_SUCCESS;
1807         unsigned int lun = SCSI_LUN(srb);
1808         u8 cmd_type, mask, value, idx;
1809         u16 addr;
1810
1811         rtsx_disable_aspm(chip);
1812
1813         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1814                 rtsx_exit_ss(chip);
1815                 wait_timeout(100);
1816         }
1817         rtsx_set_stat(chip, RTSX_STAT_RUN);
1818
1819         switch (srb->cmnd[3]) {
1820         case INIT_BATCHCMD:
1821                 rtsx_init_cmd(chip);
1822                 break;
1823
1824         case ADD_BATCHCMD:
1825                 cmd_type = srb->cmnd[4];
1826                 if (cmd_type > 2) {
1827                         set_sense_type(chip, lun,
1828                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1829                         TRACE_RET(chip, TRANSPORT_FAILED);
1830                 }
1831                 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1832                 mask = srb->cmnd[7];
1833                 value = srb->cmnd[8];
1834                 rtsx_add_cmd(chip, cmd_type, addr, mask, value);
1835                 break;
1836
1837         case SEND_BATCHCMD:
1838                 retval = rtsx_send_cmd(chip, 0, 1000);
1839                 break;
1840
1841         case GET_BATCHRSP:
1842                 idx = srb->cmnd[4];
1843                 value = *(rtsx_get_cmd_data(chip) + idx);
1844                 if (scsi_bufflen(srb) < 1) {
1845                         set_sense_type(chip, lun,
1846                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1847                         TRACE_RET(chip, TRANSPORT_FAILED);
1848                 }
1849                 rtsx_stor_set_xfer_buf(&value, 1, srb);
1850                 scsi_set_resid(srb, 0);
1851                 break;
1852
1853         default:
1854                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1855                 TRACE_RET(chip, TRANSPORT_FAILED);
1856         }
1857
1858         if (retval != STATUS_SUCCESS) {
1859                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1860                 TRACE_RET(chip, TRANSPORT_FAILED);
1861         }
1862
1863         return TRANSPORT_GOOD;
1864 }
1865
1866 static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1867 {
1868         int result;
1869
1870         switch (srb->cmnd[3]) {
1871         case INIT_BATCHCMD:
1872         case ADD_BATCHCMD:
1873         case SEND_BATCHCMD:
1874         case GET_BATCHRSP:
1875                 result = rw_mem_cmd_buf(srb, chip);
1876                 break;
1877         default:
1878                 result = TRANSPORT_ERROR;
1879         }
1880
1881         return result;
1882 }
1883
1884 static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1885 {
1886         unsigned short addr, len, i;
1887         int retval;
1888         u8 *buf;
1889         u16 val;
1890
1891         rtsx_disable_aspm(chip);
1892
1893         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1894                 rtsx_exit_ss(chip);
1895                 wait_timeout(100);
1896         }
1897         rtsx_set_stat(chip, RTSX_STAT_RUN);
1898
1899         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1900         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1901
1902         if (len % 2)
1903                 len -= len % 2;
1904
1905         if (len) {
1906                 buf = vmalloc(len);
1907                 if (!buf)
1908                         TRACE_RET(chip, TRANSPORT_ERROR);
1909
1910                 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1911                 if (retval != STATUS_SUCCESS) {
1912                         vfree(buf);
1913                         set_sense_type(chip, SCSI_LUN(srb),
1914                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1915                         TRACE_RET(chip, TRANSPORT_FAILED);
1916                 }
1917
1918                 for (i = 0; i < len / 2; i++) {
1919                         retval = rtsx_read_phy_register(chip, addr + i, &val);
1920                         if (retval != STATUS_SUCCESS) {
1921                                 vfree(buf);
1922                                 set_sense_type(chip, SCSI_LUN(srb),
1923                                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1924                                 TRACE_RET(chip, TRANSPORT_FAILED);
1925                         }
1926
1927                         buf[2*i] = (u8)(val >> 8);
1928                         buf[2*i+1] = (u8)val;
1929                 }
1930
1931                 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1932                                         len);
1933                 rtsx_stor_set_xfer_buf(buf, len, srb);
1934                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1935
1936                 vfree(buf);
1937         }
1938
1939         return TRANSPORT_GOOD;
1940 }
1941
1942 static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1943 {
1944         unsigned short addr, len, i;
1945         int retval;
1946         u8 *buf;
1947         u16 val;
1948
1949         rtsx_disable_aspm(chip);
1950
1951         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1952                 rtsx_exit_ss(chip);
1953                 wait_timeout(100);
1954         }
1955         rtsx_set_stat(chip, RTSX_STAT_RUN);
1956
1957         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1958         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1959
1960         if (len % 2)
1961                 len -= len % 2;
1962
1963         if (len) {
1964                 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1965                                         len);
1966
1967                 buf = vmalloc(len);
1968                 if (buf == NULL)
1969                         TRACE_RET(chip, TRANSPORT_ERROR);
1970
1971                 rtsx_stor_get_xfer_buf(buf, len, srb);
1972                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1973
1974                 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1975                 if (retval != STATUS_SUCCESS) {
1976                         vfree(buf);
1977                         set_sense_type(chip, SCSI_LUN(srb),
1978                                 SENSE_TYPE_MEDIA_WRITE_ERR);
1979                         TRACE_RET(chip, TRANSPORT_FAILED);
1980                 }
1981
1982                 for (i = 0; i < len / 2; i++) {
1983                         val = ((u16)buf[2*i] << 8) | buf[2*i+1];
1984                         retval = rtsx_write_phy_register(chip, addr + i, val);
1985                         if (retval != STATUS_SUCCESS) {
1986                                 vfree(buf);
1987                                 set_sense_type(chip, SCSI_LUN(srb),
1988                                         SENSE_TYPE_MEDIA_WRITE_ERR);
1989                                 TRACE_RET(chip, TRANSPORT_FAILED);
1990                         }
1991                 }
1992
1993                 vfree(buf);
1994         }
1995
1996         return TRANSPORT_GOOD;
1997 }
1998
1999 static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2000 {
2001         unsigned short addr;
2002         int retval;
2003         u8 mode;
2004
2005         rtsx_disable_aspm(chip);
2006
2007         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2008                 rtsx_exit_ss(chip);
2009                 wait_timeout(100);
2010         }
2011         rtsx_set_stat(chip, RTSX_STAT_RUN);
2012
2013         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2014         if (retval != STATUS_SUCCESS) {
2015                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2016                 TRACE_RET(chip, TRANSPORT_FAILED);
2017         }
2018
2019         mode = srb->cmnd[3];
2020         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2021
2022         if (mode == 0) {
2023                 retval = spi_erase_eeprom_chip(chip);
2024                 if (retval != STATUS_SUCCESS) {
2025                         set_sense_type(chip, SCSI_LUN(srb),
2026                                 SENSE_TYPE_MEDIA_WRITE_ERR);
2027                         TRACE_RET(chip, TRANSPORT_FAILED);
2028                 }
2029         } else if (mode == 1) {
2030                 retval = spi_erase_eeprom_byte(chip, addr);
2031                 if (retval != STATUS_SUCCESS) {
2032                         set_sense_type(chip, SCSI_LUN(srb),
2033                                 SENSE_TYPE_MEDIA_WRITE_ERR);
2034                         TRACE_RET(chip, TRANSPORT_FAILED);
2035                 }
2036         } else {
2037                 set_sense_type(chip, SCSI_LUN(srb),
2038                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2039                 TRACE_RET(chip, TRANSPORT_FAILED);
2040         }
2041
2042         return TRANSPORT_GOOD;
2043 }
2044
2045 static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2046 {
2047         unsigned short addr, len, i;
2048         int retval;
2049         u8 *buf;
2050
2051         rtsx_disable_aspm(chip);
2052
2053         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2054                 rtsx_exit_ss(chip);
2055                 wait_timeout(100);
2056         }
2057         rtsx_set_stat(chip, RTSX_STAT_RUN);
2058
2059         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2060         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2061
2062         buf = vmalloc(len);
2063         if (!buf)
2064                 TRACE_RET(chip, TRANSPORT_ERROR);
2065
2066         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2067         if (retval != STATUS_SUCCESS) {
2068                 vfree(buf);
2069                 set_sense_type(chip, SCSI_LUN(srb),
2070                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2071                 TRACE_RET(chip, TRANSPORT_FAILED);
2072         }
2073
2074         for (i = 0; i < len; i++) {
2075                 retval = spi_read_eeprom(chip, addr + i, buf + i);
2076                 if (retval != STATUS_SUCCESS) {
2077                         vfree(buf);
2078                         set_sense_type(chip, SCSI_LUN(srb),
2079                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2080                         TRACE_RET(chip, TRANSPORT_FAILED);
2081                 }
2082         }
2083
2084         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2085         rtsx_stor_set_xfer_buf(buf, len, srb);
2086         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2087
2088         vfree(buf);
2089
2090         return TRANSPORT_GOOD;
2091 }
2092
2093 static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2094 {
2095         unsigned short addr, len, i;
2096         int retval;
2097         u8 *buf;
2098
2099         rtsx_disable_aspm(chip);
2100
2101         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2102                 rtsx_exit_ss(chip);
2103                 wait_timeout(100);
2104         }
2105         rtsx_set_stat(chip, RTSX_STAT_RUN);
2106
2107         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2108         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2109
2110         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2111         buf = vmalloc(len);
2112         if (buf == NULL)
2113                 TRACE_RET(chip, TRANSPORT_ERROR);
2114
2115         rtsx_stor_get_xfer_buf(buf, len, srb);
2116         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2117
2118         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2119         if (retval != STATUS_SUCCESS) {
2120                 vfree(buf);
2121                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2122                 TRACE_RET(chip, TRANSPORT_FAILED);
2123         }
2124
2125         for (i = 0; i < len; i++) {
2126                 retval = spi_write_eeprom(chip, addr + i, buf[i]);
2127                 if (retval != STATUS_SUCCESS) {
2128                         vfree(buf);
2129                         set_sense_type(chip, SCSI_LUN(srb),
2130                                 SENSE_TYPE_MEDIA_WRITE_ERR);
2131                         TRACE_RET(chip, TRANSPORT_FAILED);
2132                 }
2133         }
2134
2135         vfree(buf);
2136
2137         return TRANSPORT_GOOD;
2138 }
2139
2140 static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2141 {
2142         int retval;
2143         u8 addr, len, i;
2144         u8 *buf;
2145
2146         rtsx_disable_aspm(chip);
2147
2148         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2149                 rtsx_exit_ss(chip);
2150                 wait_timeout(100);
2151         }
2152         rtsx_set_stat(chip, RTSX_STAT_RUN);
2153
2154         addr = srb->cmnd[4];
2155         len = srb->cmnd[5];
2156
2157         buf = vmalloc(len);
2158         if (!buf)
2159                 TRACE_RET(chip, TRANSPORT_ERROR);
2160
2161         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2162         if (retval != STATUS_SUCCESS) {
2163                 vfree(buf);
2164                 set_sense_type(chip, SCSI_LUN(srb),
2165                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2166                 TRACE_RET(chip, TRANSPORT_FAILED);
2167         }
2168
2169         for (i = 0; i < len; i++) {
2170                 retval = rtsx_read_efuse(chip, addr + i, buf + i);
2171                 if (retval != STATUS_SUCCESS) {
2172                         vfree(buf);
2173                         set_sense_type(chip, SCSI_LUN(srb),
2174                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2175                         TRACE_RET(chip, TRANSPORT_FAILED);
2176                 }
2177         }
2178
2179         len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2180         rtsx_stor_set_xfer_buf(buf, len, srb);
2181         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2182
2183         vfree(buf);
2184
2185         return TRANSPORT_GOOD;
2186 }
2187
2188 static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2189 {
2190         int retval, result = TRANSPORT_GOOD;
2191         u16 val;
2192         u8 addr, len, i;
2193         u8 *buf;
2194
2195         rtsx_disable_aspm(chip);
2196
2197         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2198                 rtsx_exit_ss(chip);
2199                 wait_timeout(100);
2200         }
2201         rtsx_set_stat(chip, RTSX_STAT_RUN);
2202
2203         addr = srb->cmnd[4];
2204         len = srb->cmnd[5];
2205
2206         len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2207         buf = vmalloc(len);
2208         if (buf == NULL)
2209                 TRACE_RET(chip, TRANSPORT_ERROR);
2210
2211         rtsx_stor_get_xfer_buf(buf, len, srb);
2212         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2213
2214         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2215         if (retval != STATUS_SUCCESS) {
2216                 vfree(buf);
2217                 TRACE_RET(chip, TRANSPORT_ERROR);
2218         }
2219
2220         if (chip->asic_code) {
2221                 retval = rtsx_read_phy_register(chip, 0x08, &val);
2222                 if (retval != STATUS_SUCCESS) {
2223                         vfree(buf);
2224                         TRACE_RET(chip, TRANSPORT_ERROR);
2225                 }
2226
2227                 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2228                                         LDO3318_PWR_MASK, LDO_OFF);
2229                 if (retval != STATUS_SUCCESS) {
2230                         vfree(buf);
2231                         TRACE_RET(chip, TRANSPORT_ERROR);
2232                 }
2233
2234                 wait_timeout(600);
2235
2236                 retval = rtsx_write_phy_register(chip, 0x08,
2237                                                 0x4C00 | chip->phy_voltage);
2238                 if (retval != STATUS_SUCCESS) {
2239                         vfree(buf);
2240                         TRACE_RET(chip, TRANSPORT_ERROR);
2241                 }
2242
2243                 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2244                                         LDO3318_PWR_MASK, LDO_ON);
2245                 if (retval != STATUS_SUCCESS) {
2246                         vfree(buf);
2247                         TRACE_RET(chip, TRANSPORT_ERROR);
2248                 }
2249
2250                 wait_timeout(600);
2251         }
2252
2253         retval = card_power_on(chip, SPI_CARD);
2254         if (retval != STATUS_SUCCESS) {
2255                 vfree(buf);
2256                 TRACE_RET(chip, TRANSPORT_ERROR);
2257         }
2258
2259         wait_timeout(50);
2260
2261         for (i = 0; i < len; i++) {
2262                 retval = rtsx_write_efuse(chip, addr + i, buf[i]);
2263                 if (retval != STATUS_SUCCESS) {
2264                         set_sense_type(chip, SCSI_LUN(srb),
2265                                 SENSE_TYPE_MEDIA_WRITE_ERR);
2266                         result = TRANSPORT_FAILED;
2267                         TRACE_GOTO(chip, Exit);
2268                 }
2269         }
2270
2271 Exit:
2272         vfree(buf);
2273
2274         retval = card_power_off(chip, SPI_CARD);
2275         if (retval != STATUS_SUCCESS)
2276                 TRACE_RET(chip, TRANSPORT_ERROR);
2277
2278         if (chip->asic_code) {
2279                 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2280                                         LDO3318_PWR_MASK, LDO_OFF);
2281                 if (retval != STATUS_SUCCESS)
2282                         TRACE_RET(chip, TRANSPORT_ERROR);
2283
2284                 wait_timeout(600);
2285
2286                 retval = rtsx_write_phy_register(chip, 0x08, val);
2287                 if (retval != STATUS_SUCCESS)
2288                         TRACE_RET(chip, TRANSPORT_ERROR);
2289
2290                 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2291                                         LDO3318_PWR_MASK, LDO_ON);
2292                 if (retval != STATUS_SUCCESS)
2293                         TRACE_RET(chip, TRANSPORT_ERROR);
2294         }
2295
2296         return result;
2297 }
2298
2299 static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2300 {
2301         int retval;
2302         u8 func, func_max;
2303         u16 addr, len;
2304         u8 *buf;
2305
2306         rtsx_disable_aspm(chip);
2307
2308         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2309                 rtsx_exit_ss(chip);
2310                 wait_timeout(100);
2311         }
2312         rtsx_set_stat(chip, RTSX_STAT_RUN);
2313
2314         func = srb->cmnd[3];
2315         addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2316         len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2317
2318         dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x, len = %d\n",
2319                 __func__, func, addr, len);
2320
2321         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2322                 func_max = 1;
2323         else
2324                 func_max = 0;
2325
2326         if (func > func_max) {
2327                 set_sense_type(chip, SCSI_LUN(srb),
2328                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2329                 TRACE_RET(chip, TRANSPORT_FAILED);
2330         }
2331
2332         buf = vmalloc(len);
2333         if (!buf)
2334                 TRACE_RET(chip, TRANSPORT_ERROR);
2335
2336         retval = rtsx_read_cfg_seq(chip, func, addr, buf, len);
2337         if (retval != STATUS_SUCCESS) {
2338                 set_sense_type(chip, SCSI_LUN(srb),
2339                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2340                 vfree(buf);
2341                 TRACE_RET(chip, TRANSPORT_FAILED);
2342         }
2343
2344         len = (u16)min_t(unsigned int, scsi_bufflen(srb), len);
2345         rtsx_stor_set_xfer_buf(buf, len, srb);
2346         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2347
2348         vfree(buf);
2349
2350         return TRANSPORT_GOOD;
2351 }
2352
2353 static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2354 {
2355         int retval;
2356         u8 func, func_max;
2357         u16 addr, len;
2358         u8 *buf;
2359
2360         rtsx_disable_aspm(chip);
2361
2362         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2363                 rtsx_exit_ss(chip);
2364                 wait_timeout(100);
2365         }
2366         rtsx_set_stat(chip, RTSX_STAT_RUN);
2367
2368         func = srb->cmnd[3];
2369         addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2370         len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2371
2372         dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x\n",
2373                 __func__, func, addr);
2374
2375         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2376                 func_max = 1;
2377         else
2378                 func_max = 0;
2379
2380         if (func > func_max) {
2381                 set_sense_type(chip, SCSI_LUN(srb),
2382                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2383                 TRACE_RET(chip, TRANSPORT_FAILED);
2384         }
2385
2386         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2387         buf = vmalloc(len);
2388         if (!buf)
2389                 TRACE_RET(chip, TRANSPORT_ERROR);
2390
2391         rtsx_stor_get_xfer_buf(buf, len, srb);
2392         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2393
2394         retval = rtsx_write_cfg_seq(chip, func, addr, buf, len);
2395         if (retval != STATUS_SUCCESS) {
2396                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2397                 vfree(buf);
2398                 TRACE_RET(chip, TRANSPORT_FAILED);
2399         }
2400
2401         vfree(buf);
2402
2403         return TRANSPORT_GOOD;
2404 }
2405
2406 static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2407 {
2408         int result;
2409
2410         switch (srb->cmnd[2]) {
2411         case PP_READ10:
2412         case PP_WRITE10:
2413                 result = read_write(srb, chip);
2414                 break;
2415
2416         case READ_HOST_REG:
2417                 result = read_host_reg(srb, chip);
2418                 break;
2419
2420         case WRITE_HOST_REG:
2421                 result = write_host_reg(srb, chip);
2422                 break;
2423
2424         case GET_VAR:
2425                 result = get_variable(srb, chip);
2426                 break;
2427
2428         case SET_VAR:
2429                 result = set_variable(srb, chip);
2430                 break;
2431
2432         case DMA_READ:
2433         case DMA_WRITE:
2434                 result = dma_access_ring_buffer(srb, chip);
2435                 break;
2436
2437         case READ_PHY:
2438                 result = read_phy_register(srb, chip);
2439                 break;
2440
2441         case WRITE_PHY:
2442                 result = write_phy_register(srb, chip);
2443                 break;
2444
2445         case ERASE_EEPROM2:
2446                 result = erase_eeprom2(srb, chip);
2447                 break;
2448
2449         case READ_EEPROM2:
2450                 result = read_eeprom2(srb, chip);
2451                 break;
2452
2453         case WRITE_EEPROM2:
2454                 result = write_eeprom2(srb, chip);
2455                 break;
2456
2457         case READ_EFUSE:
2458                 result = read_efuse(srb, chip);
2459                 break;
2460
2461         case WRITE_EFUSE:
2462                 result = write_efuse(srb, chip);
2463                 break;
2464
2465         case READ_CFG:
2466                 result = read_cfg_byte(srb, chip);
2467                 break;
2468
2469         case WRITE_CFG:
2470                 result = write_cfg_byte(srb, chip);
2471                 break;
2472
2473         case SET_CHIP_MODE:
2474                 result = set_chip_mode(srb, chip);
2475                 break;
2476
2477         case SUIT_CMD:
2478                 result = suit_cmd(srb, chip);
2479                 break;
2480
2481         case GET_DEV_STATUS:
2482                 result = get_dev_status(srb, chip);
2483                 break;
2484
2485         default:
2486                 set_sense_type(chip, SCSI_LUN(srb),
2487                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2488                 TRACE_RET(chip, TRANSPORT_FAILED);
2489         }
2490
2491         return result;
2492 }
2493
2494
2495 static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2496 {
2497         u8 rtsx_status[16];
2498         int buf_len;
2499         unsigned int lun = SCSI_LUN(srb);
2500
2501         rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2502         rtsx_status[1] = (u8)(chip->vendor_id);
2503
2504         rtsx_status[2] = (u8)(chip->product_id >> 8);
2505         rtsx_status[3] = (u8)(chip->product_id);
2506
2507         rtsx_status[4] = (u8)lun;
2508
2509         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2510                 if (chip->lun2card[lun] == SD_CARD)
2511                         rtsx_status[5] = 2;
2512                 else
2513                         rtsx_status[5] = 3;
2514         } else {
2515                 if (chip->card_exist) {
2516                         if (chip->card_exist & XD_CARD)
2517                                 rtsx_status[5] = 4;
2518                         else if (chip->card_exist & SD_CARD)
2519                                 rtsx_status[5] = 2;
2520                         else if (chip->card_exist & MS_CARD)
2521                                 rtsx_status[5] = 3;
2522                         else
2523                                 rtsx_status[5] = 7;
2524                 } else {
2525                         rtsx_status[5] = 7;
2526                 }
2527         }
2528
2529         if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2530                 rtsx_status[6] = 2;
2531         else
2532                 rtsx_status[6] = 1;
2533
2534         rtsx_status[7] = (u8)(chip->product_id);
2535         rtsx_status[8] = chip->ic_version;
2536
2537         if (check_card_exist(chip, lun))
2538                 rtsx_status[9] = 1;
2539         else
2540                 rtsx_status[9] = 0;
2541
2542         if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2543                 rtsx_status[10] = 0;
2544         else
2545                 rtsx_status[10] = 1;
2546
2547         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2548                 if (chip->lun2card[lun] == SD_CARD)
2549                         rtsx_status[11] = SD_CARD;
2550                 else
2551                         rtsx_status[11] = MS_CARD;
2552         } else {
2553                 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2554         }
2555
2556         if (check_card_ready(chip, lun))
2557                 rtsx_status[12] = 1;
2558         else
2559                 rtsx_status[12] = 0;
2560
2561         if (get_lun_card(chip, lun) == XD_CARD) {
2562                 rtsx_status[13] = 0x40;
2563         } else if (get_lun_card(chip, lun) == SD_CARD) {
2564                 struct sd_info *sd_card = &(chip->sd_card);
2565
2566                 rtsx_status[13] = 0x20;
2567                 if (CHK_SD(sd_card)) {
2568                         if (CHK_SD_HCXC(sd_card))
2569                                 rtsx_status[13] |= 0x04;
2570                         if (CHK_SD_HS(sd_card))
2571                                 rtsx_status[13] |= 0x02;
2572                 } else {
2573                         rtsx_status[13] |= 0x08;
2574                         if (CHK_MMC_52M(sd_card))
2575                                 rtsx_status[13] |= 0x02;
2576                         if (CHK_MMC_SECTOR_MODE(sd_card))
2577                                 rtsx_status[13] |= 0x04;
2578                 }
2579         } else if (get_lun_card(chip, lun) == MS_CARD) {
2580                 struct ms_info *ms_card = &(chip->ms_card);
2581
2582                 if (CHK_MSPRO(ms_card)) {
2583                         rtsx_status[13] = 0x38;
2584                         if (CHK_HG8BIT(ms_card))
2585                                 rtsx_status[13] |= 0x04;
2586 #ifdef SUPPORT_MSXC
2587                         if (CHK_MSXC(ms_card))
2588                                 rtsx_status[13] |= 0x01;
2589 #endif
2590                 } else {
2591                         rtsx_status[13] = 0x30;
2592                 }
2593         } else {
2594                 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2595 #ifdef SUPPORT_SDIO
2596                         if (chip->sd_io && chip->sd_int)
2597                                 rtsx_status[13] = 0x60;
2598                         else
2599                                 rtsx_status[13] = 0x70;
2600 #else
2601                         rtsx_status[13] = 0x70;
2602 #endif
2603                 } else {
2604                         if (chip->lun2card[lun] == SD_CARD)
2605                                 rtsx_status[13] = 0x20;
2606                         else
2607                                 rtsx_status[13] = 0x30;
2608                 }
2609         }
2610
2611         rtsx_status[14] = 0x78;
2612         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2613                 rtsx_status[15] = 0x83;
2614         else
2615                 rtsx_status[15] = 0x82;
2616
2617         buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status));
2618         rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb);
2619         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
2620
2621         return TRANSPORT_GOOD;
2622 }
2623
2624 static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2625 {
2626         unsigned int lun = SCSI_LUN(srb);
2627         u8 card, bus_width;
2628
2629         if (!check_card_ready(chip, lun)) {
2630                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2631                 TRACE_RET(chip, TRANSPORT_FAILED);
2632         }
2633
2634         card = get_lun_card(chip, lun);
2635         if ((card == SD_CARD) || (card == MS_CARD)) {
2636                 bus_width = chip->card_bus_width[lun];
2637         } else {
2638                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2639                 TRACE_RET(chip, TRANSPORT_FAILED);
2640         }
2641
2642         scsi_set_resid(srb, 0);
2643         rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2644
2645         return TRANSPORT_GOOD;
2646 }
2647
2648 static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2649 {
2650         int result;
2651         unsigned int lun = SCSI_LUN(srb);
2652         u8 gpio_dir;
2653
2654         if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) {
2655                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2656                 TRACE_RET(chip, TRANSPORT_FAILED);
2657         }
2658
2659         rtsx_disable_aspm(chip);
2660
2661         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2662                 rtsx_exit_ss(chip);
2663                 wait_timeout(100);
2664         }
2665         rtsx_set_stat(chip, RTSX_STAT_RUN);
2666
2667         rtsx_force_power_on(chip, SSC_PDCTL);
2668
2669         rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2670         rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2671
2672         switch (srb->cmnd[2]) {
2673         case SCSI_SPI_GETSTATUS:
2674                 result = spi_get_status(srb, chip);
2675                 break;
2676
2677         case SCSI_SPI_SETPARAMETER:
2678                 result = spi_set_parameter(srb, chip);
2679                 break;
2680
2681         case SCSI_SPI_READFALSHID:
2682                 result = spi_read_flash_id(srb, chip);
2683                 break;
2684
2685         case SCSI_SPI_READFLASH:
2686                 result = spi_read_flash(srb, chip);
2687                 break;
2688
2689         case SCSI_SPI_WRITEFLASH:
2690                 result = spi_write_flash(srb, chip);
2691                 break;
2692
2693         case SCSI_SPI_WRITEFLASHSTATUS:
2694                 result = spi_write_flash_status(srb, chip);
2695                 break;
2696
2697         case SCSI_SPI_ERASEFLASH:
2698                 result = spi_erase_flash(srb, chip);
2699                 break;
2700
2701         default:
2702                 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2703
2704                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2705                 TRACE_RET(chip, TRANSPORT_FAILED);
2706         }
2707
2708         rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2709
2710         if (result != STATUS_SUCCESS)
2711                 TRACE_RET(chip, TRANSPORT_FAILED);
2712
2713         return TRANSPORT_GOOD;
2714 }
2715
2716 static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2717 {
2718         int result;
2719
2720         switch (srb->cmnd[1]) {
2721         case READ_STATUS:
2722                 result = read_status(srb, chip);
2723                 break;
2724
2725         case READ_MEM:
2726                 result = read_mem(srb, chip);
2727                 break;
2728
2729         case WRITE_MEM:
2730                 result = write_mem(srb, chip);
2731                 break;
2732
2733         case READ_EEPROM:
2734                 result = read_eeprom(srb, chip);
2735                 break;
2736
2737         case WRITE_EEPROM:
2738                 result = write_eeprom(srb, chip);
2739                 break;
2740
2741         case TOGGLE_GPIO:
2742                 result = toggle_gpio_cmd(srb, chip);
2743                 break;
2744
2745         case GET_SD_CSD:
2746                 result = get_sd_csd(srb, chip);
2747                 break;
2748
2749         case GET_BUS_WIDTH:
2750                 result = get_card_bus_width(srb, chip);
2751                 break;
2752
2753 #ifdef _MSG_TRACE
2754         case TRACE_MSG:
2755                 result = trace_msg_cmd(srb, chip);
2756                 break;
2757 #endif
2758
2759         case SCSI_APP_CMD:
2760                 result = app_cmd(srb, chip);
2761                 break;
2762
2763         case SPI_VENDOR_COMMAND:
2764                 result = spi_vendor_cmd(srb, chip);
2765                 break;
2766
2767         default:
2768                 set_sense_type(chip, SCSI_LUN(srb),
2769                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2770                 TRACE_RET(chip, TRANSPORT_FAILED);
2771         }
2772
2773         return result;
2774 }
2775
2776 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2777 void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2778 {
2779         unsigned int lun = SCSI_LUN(srb);
2780         u16 sec_cnt;
2781
2782         if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10))
2783                 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2784         else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6))
2785                 sec_cnt = srb->cmnd[4];
2786         else
2787                 return;
2788
2789         if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2790                 toggle_gpio(chip, LED_GPIO);
2791                 chip->rw_cap[lun] = 0;
2792         } else {
2793                 chip->rw_cap[lun] += sec_cnt;
2794         }
2795 }
2796 #endif
2797
2798 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2799 {
2800         struct ms_info *ms_card = &(chip->ms_card);
2801         unsigned int lun = SCSI_LUN(srb);
2802         int retval, quick_format;
2803
2804         if (get_lun_card(chip, lun) != MS_CARD) {
2805                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2806                 TRACE_RET(chip, TRANSPORT_FAILED);
2807         }
2808
2809         if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) ||
2810                 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) ||
2811                 (srb->cmnd[7] != 0x74)) {
2812                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2813                 TRACE_RET(chip, TRANSPORT_FAILED);
2814         }
2815
2816         rtsx_disable_aspm(chip);
2817
2818         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2819                 rtsx_exit_ss(chip);
2820                 wait_timeout(100);
2821
2822                 if (!check_card_ready(chip, lun) ||
2823                                 (get_card_size(chip, lun) == 0)) {
2824                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2825                         TRACE_RET(chip, TRANSPORT_FAILED);
2826                 }
2827         }
2828         rtsx_set_stat(chip, RTSX_STAT_RUN);
2829
2830         if (srb->cmnd[8] & 0x01)
2831                 quick_format = 0;
2832         else
2833                 quick_format = 1;
2834
2835         if (!(chip->card_ready & MS_CARD)) {
2836                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2837                 TRACE_RET(chip, TRANSPORT_FAILED);
2838         }
2839
2840         if (chip->card_wp & MS_CARD) {
2841                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2842                 TRACE_RET(chip, TRANSPORT_FAILED);
2843         }
2844
2845         if (!CHK_MSPRO(ms_card)) {
2846                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2847                 TRACE_RET(chip, TRANSPORT_FAILED);
2848         }
2849
2850         retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
2851         if (retval != STATUS_SUCCESS) {
2852                 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
2853                 TRACE_RET(chip, TRANSPORT_FAILED);
2854         }
2855
2856         scsi_set_resid(srb, 0);
2857         return TRANSPORT_GOOD;
2858 }
2859
2860 #ifdef SUPPORT_PCGL_1P18
2861 static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2862 {
2863         struct ms_info *ms_card = &(chip->ms_card);
2864         unsigned int lun = SCSI_LUN(srb);
2865         u8 dev_info_id, data_len;
2866         u8 *buf;
2867         unsigned int buf_len;
2868         int i;
2869
2870         if (!check_card_ready(chip, lun)) {
2871                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2872                 TRACE_RET(chip, TRANSPORT_FAILED);
2873         }
2874         if (get_lun_card(chip, lun) != MS_CARD) {
2875                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2876                 TRACE_RET(chip, TRANSPORT_FAILED);
2877         }
2878
2879         if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
2880                 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
2881                 (srb->cmnd[7] != 0x44)) {
2882                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2883                 TRACE_RET(chip, TRANSPORT_FAILED);
2884         }
2885
2886         dev_info_id = srb->cmnd[3];
2887         if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
2888                         (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
2889                         !CHK_MSPRO(ms_card)) {
2890                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2891                 TRACE_RET(chip, TRANSPORT_FAILED);
2892         }
2893
2894         if (dev_info_id == 0x15)
2895                 buf_len = data_len = 0x3A;
2896         else
2897                 buf_len = data_len = 0x6A;
2898
2899         buf = kmalloc(buf_len, GFP_KERNEL);
2900         if (!buf)
2901                 TRACE_RET(chip, TRANSPORT_ERROR);
2902
2903         i = 0;
2904         /*  GET Memory Stick Media Information Response Header */
2905         buf[i++] = 0x00;                /* Data length MSB */
2906         buf[i++] = data_len;            /* Data length LSB */
2907         /* Device Information Type Code */
2908         if (CHK_MSXC(ms_card))
2909                 buf[i++] = 0x03;
2910         else
2911                 buf[i++] = 0x02;
2912
2913         /* SGM bit */
2914         buf[i++] = 0x01;
2915         /* Reserved */
2916         buf[i++] = 0x00;
2917         buf[i++] = 0x00;
2918         buf[i++] = 0x00;
2919         /* Number of Device Information */
2920         buf[i++] = 0x01;
2921
2922         /*  Device Information Body */
2923
2924         /* Device Information ID Number */
2925         buf[i++] = dev_info_id;
2926         /* Device Information Length */
2927         if (dev_info_id == 0x15)
2928                 data_len = 0x31;
2929         else
2930                 data_len = 0x61;
2931
2932         buf[i++] = 0x00;                /* Data length MSB */
2933         buf[i++] = data_len;            /* Data length LSB */
2934         /* Valid Bit */
2935         buf[i++] = 0x80;
2936         if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
2937                 /* System Information */
2938                 memcpy(buf+i, ms_card->raw_sys_info, 96);
2939         } else {
2940                 /* Model Name */
2941                 memcpy(buf+i, ms_card->raw_model_name, 48);
2942         }
2943
2944         rtsx_stor_set_xfer_buf(buf, buf_len, srb);
2945
2946         if (dev_info_id == 0x15)
2947                 scsi_set_resid(srb, scsi_bufflen(srb)-0x3C);
2948         else
2949                 scsi_set_resid(srb, scsi_bufflen(srb)-0x6C);
2950
2951         kfree(buf);
2952         return STATUS_SUCCESS;
2953 }
2954 #endif
2955
2956 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2957 {
2958         int retval = TRANSPORT_ERROR;
2959
2960         if (srb->cmnd[2] == MS_FORMAT)
2961                 retval = ms_format_cmnd(srb, chip);
2962 #ifdef SUPPORT_PCGL_1P18
2963         else if (srb->cmnd[2] == GET_MS_INFORMATION)
2964                 retval = get_ms_information(srb, chip);
2965 #endif
2966
2967         return retval;
2968 }
2969
2970 #ifdef SUPPORT_CPRM
2971 static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2972 {
2973         unsigned int lun = SCSI_LUN(srb);
2974         int result;
2975
2976         rtsx_disable_aspm(chip);
2977
2978         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2979                 rtsx_exit_ss(chip);
2980                 wait_timeout(100);
2981         }
2982         rtsx_set_stat(chip, RTSX_STAT_RUN);
2983
2984         sd_cleanup_work(chip);
2985
2986         if (!check_card_ready(chip, lun)) {
2987                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2988                 TRACE_RET(chip, TRANSPORT_FAILED);
2989         }
2990         if (get_lun_card(chip, lun) != SD_CARD) {
2991                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2992                 TRACE_RET(chip, TRANSPORT_FAILED);
2993         }
2994
2995         switch (srb->cmnd[0]) {
2996         case SD_PASS_THRU_MODE:
2997                 result = sd_pass_thru_mode(srb, chip);
2998                 break;
2999
3000         case SD_EXECUTE_NO_DATA:
3001                 result = sd_execute_no_data(srb, chip);
3002                 break;
3003
3004         case SD_EXECUTE_READ:
3005                 result = sd_execute_read_data(srb, chip);
3006                 break;
3007
3008         case SD_EXECUTE_WRITE:
3009                 result = sd_execute_write_data(srb, chip);
3010                 break;
3011
3012         case SD_GET_RSP:
3013                 result = sd_get_cmd_rsp(srb, chip);
3014                 break;
3015
3016         case SD_HW_RST:
3017                 result = sd_hw_rst(srb, chip);
3018                 break;
3019
3020         default:
3021                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3022                 TRACE_RET(chip, TRANSPORT_FAILED);
3023         }
3024
3025         return result;
3026 }
3027 #endif
3028
3029 #ifdef SUPPORT_MAGIC_GATE
3030 static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3031 {
3032         struct ms_info *ms_card = &(chip->ms_card);
3033         unsigned int lun = SCSI_LUN(srb);
3034         int retval;
3035         u8 key_format;
3036
3037         rtsx_disable_aspm(chip);
3038
3039         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3040                 rtsx_exit_ss(chip);
3041                 wait_timeout(100);
3042         }
3043         rtsx_set_stat(chip, RTSX_STAT_RUN);
3044
3045         ms_cleanup_work(chip);
3046
3047         if (!check_card_ready(chip, lun)) {
3048                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3049                 TRACE_RET(chip, TRANSPORT_FAILED);
3050         }
3051         if (get_lun_card(chip, lun) != MS_CARD) {
3052                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3053                 TRACE_RET(chip, TRANSPORT_FAILED);
3054         }
3055
3056         if (srb->cmnd[7] != KC_MG_R_PRO) {
3057                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3058                 TRACE_RET(chip, TRANSPORT_FAILED);
3059         }
3060
3061         if (!CHK_MSPRO(ms_card)) {
3062                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3063                 TRACE_RET(chip, TRANSPORT_FAILED);
3064         }
3065
3066         key_format = srb->cmnd[10] & 0x3F;
3067         dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3068
3069         switch (key_format) {
3070         case KF_GET_LOC_EKB:
3071                 if ((scsi_bufflen(srb) == 0x41C) &&
3072                         (srb->cmnd[8] == 0x04) &&
3073                         (srb->cmnd[9] == 0x1C)) {
3074                         retval = mg_get_local_EKB(srb, chip);
3075                         if (retval != STATUS_SUCCESS)
3076                                 TRACE_RET(chip, TRANSPORT_FAILED);
3077
3078                 } else {
3079                         set_sense_type(chip, lun,
3080                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3081                         TRACE_RET(chip, TRANSPORT_FAILED);
3082                 }
3083                 break;
3084
3085         case KF_RSP_CHG:
3086                 if ((scsi_bufflen(srb) == 0x24) &&
3087                         (srb->cmnd[8] == 0x00) &&
3088                         (srb->cmnd[9] == 0x24)) {
3089                         retval = mg_get_rsp_chg(srb, chip);
3090                         if (retval != STATUS_SUCCESS)
3091                                 TRACE_RET(chip, TRANSPORT_FAILED);
3092
3093                 } else {
3094                         set_sense_type(chip, lun,
3095                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3096                         TRACE_RET(chip, TRANSPORT_FAILED);
3097                 }
3098                 break;
3099
3100         case KF_GET_ICV:
3101                 ms_card->mg_entry_num = srb->cmnd[5];
3102                 if ((scsi_bufflen(srb) == 0x404) &&
3103                         (srb->cmnd[8] == 0x04) &&
3104                         (srb->cmnd[9] == 0x04) &&
3105                         (srb->cmnd[2] == 0x00) &&
3106                         (srb->cmnd[3] == 0x00) &&
3107                         (srb->cmnd[4] == 0x00) &&
3108                         (srb->cmnd[5] < 32)) {
3109                         retval = mg_get_ICV(srb, chip);
3110                         if (retval != STATUS_SUCCESS)
3111                                 TRACE_RET(chip, TRANSPORT_FAILED);
3112
3113                 } else {
3114                         set_sense_type(chip, lun,
3115                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3116                         TRACE_RET(chip, TRANSPORT_FAILED);
3117                 }
3118                 break;
3119
3120         default:
3121                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3122                 TRACE_RET(chip, TRANSPORT_FAILED);
3123         }
3124
3125         scsi_set_resid(srb, 0);
3126         return TRANSPORT_GOOD;
3127 }
3128
3129 static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3130 {
3131         struct ms_info *ms_card = &(chip->ms_card);
3132         unsigned int lun = SCSI_LUN(srb);
3133         int retval;
3134         u8 key_format;
3135
3136         rtsx_disable_aspm(chip);
3137
3138         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3139                 rtsx_exit_ss(chip);
3140                 wait_timeout(100);
3141         }
3142         rtsx_set_stat(chip, RTSX_STAT_RUN);
3143
3144         ms_cleanup_work(chip);
3145
3146         if (!check_card_ready(chip, lun)) {
3147                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3148                 TRACE_RET(chip, TRANSPORT_FAILED);
3149         }
3150         if (check_card_wp(chip, lun)) {
3151                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
3152                 TRACE_RET(chip, TRANSPORT_FAILED);
3153         }
3154         if (get_lun_card(chip, lun) != MS_CARD) {
3155                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3156                 TRACE_RET(chip, TRANSPORT_FAILED);
3157         }
3158
3159         if (srb->cmnd[7] != KC_MG_R_PRO) {
3160                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3161                 TRACE_RET(chip, TRANSPORT_FAILED);
3162         }
3163
3164         if (!CHK_MSPRO(ms_card)) {
3165                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3166                 TRACE_RET(chip, TRANSPORT_FAILED);
3167         }
3168
3169         key_format = srb->cmnd[10] & 0x3F;
3170         dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3171
3172         switch (key_format) {
3173         case KF_SET_LEAF_ID:
3174                 if ((scsi_bufflen(srb) == 0x0C) &&
3175                         (srb->cmnd[8] == 0x00) &&
3176                         (srb->cmnd[9] == 0x0C)) {
3177                         retval = mg_set_leaf_id(srb, chip);
3178                         if (retval != STATUS_SUCCESS)
3179                                 TRACE_RET(chip, TRANSPORT_FAILED);
3180
3181                 } else {
3182                         set_sense_type(chip, lun,
3183                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3184                         TRACE_RET(chip, TRANSPORT_FAILED);
3185                 }
3186                 break;
3187
3188         case KF_CHG_HOST:
3189                 if ((scsi_bufflen(srb) == 0x0C) &&
3190                         (srb->cmnd[8] == 0x00) &&
3191                         (srb->cmnd[9] == 0x0C)) {
3192                         retval = mg_chg(srb, chip);
3193                         if (retval != STATUS_SUCCESS)
3194                                 TRACE_RET(chip, TRANSPORT_FAILED);
3195
3196                 } else {
3197                         set_sense_type(chip, lun,
3198                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3199                         TRACE_RET(chip, TRANSPORT_FAILED);
3200                 }
3201                 break;
3202
3203         case KF_RSP_HOST:
3204                 if ((scsi_bufflen(srb) == 0x0C) &&
3205                         (srb->cmnd[8] == 0x00) &&
3206                         (srb->cmnd[9] == 0x0C)) {
3207                         retval = mg_rsp(srb, chip);
3208                         if (retval != STATUS_SUCCESS)
3209                                 TRACE_RET(chip, TRANSPORT_FAILED);
3210
3211                 } else {
3212                         set_sense_type(chip, lun,
3213                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3214                         TRACE_RET(chip, TRANSPORT_FAILED);
3215                 }
3216                 break;
3217
3218         case KF_SET_ICV:
3219                 ms_card->mg_entry_num = srb->cmnd[5];
3220                 if ((scsi_bufflen(srb) == 0x404) &&
3221                         (srb->cmnd[8] == 0x04) &&
3222                         (srb->cmnd[9] == 0x04) &&
3223                         (srb->cmnd[2] == 0x00) &&
3224                         (srb->cmnd[3] == 0x00) &&
3225                         (srb->cmnd[4] == 0x00) &&
3226                         (srb->cmnd[5] < 32)) {
3227                         retval = mg_set_ICV(srb, chip);
3228                         if (retval != STATUS_SUCCESS)
3229                                 TRACE_RET(chip, TRANSPORT_FAILED);
3230
3231                 } else {
3232                         set_sense_type(chip, lun,
3233                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3234                         TRACE_RET(chip, TRANSPORT_FAILED);
3235                 }
3236                 break;
3237
3238         default:
3239                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3240                 TRACE_RET(chip, TRANSPORT_FAILED);
3241         }
3242
3243         scsi_set_resid(srb, 0);
3244         return TRANSPORT_GOOD;
3245 }
3246 #endif
3247
3248 int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3249 {
3250 #ifdef SUPPORT_SD_LOCK
3251         struct sd_info *sd_card = &(chip->sd_card);
3252 #endif
3253         struct ms_info *ms_card = &(chip->ms_card);
3254         unsigned int lun = SCSI_LUN(srb);
3255         int result;
3256
3257 #ifdef SUPPORT_SD_LOCK
3258         if (sd_card->sd_erase_status) {
3259                 /* Block all SCSI command except for
3260                  * REQUEST_SENSE and rs_ppstatus
3261                  */
3262                 if (!((srb->cmnd[0] == VENDOR_CMND) &&
3263                                 (srb->cmnd[1] == SCSI_APP_CMD) &&
3264                                 (srb->cmnd[2] == GET_DEV_STATUS)) &&
3265                                 (srb->cmnd[0] != REQUEST_SENSE)) {
3266                         /* Logical Unit Not Ready Format in Progress */
3267                         set_sense_data(chip, lun, CUR_ERR,
3268                                        0x02, 0, 0x04, 0x04, 0, 0);
3269                         TRACE_RET(chip, TRANSPORT_FAILED);
3270                 }
3271         }
3272 #endif
3273
3274         if ((get_lun_card(chip, lun) == MS_CARD) &&
3275                         (ms_card->format_status == FORMAT_IN_PROGRESS)) {
3276                 if ((srb->cmnd[0] != REQUEST_SENSE) &&
3277                         (srb->cmnd[0] != INQUIRY)) {
3278                         /* Logical Unit Not Ready Format in Progress */
3279                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
3280                                         0, (u16)(ms_card->progress));
3281                         TRACE_RET(chip, TRANSPORT_FAILED);
3282                 }
3283         }
3284
3285         switch (srb->cmnd[0]) {
3286         case READ_10:
3287         case WRITE_10:
3288         case READ_6:
3289         case WRITE_6:
3290                 result = read_write(srb, chip);
3291 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3292                 led_shine(srb, chip);
3293 #endif
3294                 break;
3295
3296         case TEST_UNIT_READY:
3297                 result = test_unit_ready(srb, chip);
3298                 break;
3299
3300         case INQUIRY:
3301                 result = inquiry(srb, chip);
3302                 break;
3303
3304         case READ_CAPACITY:
3305                 result = read_capacity(srb, chip);
3306                 break;
3307
3308         case START_STOP:
3309                 result = start_stop_unit(srb, chip);
3310                 break;
3311
3312         case ALLOW_MEDIUM_REMOVAL:
3313                 result = allow_medium_removal(srb, chip);
3314                 break;
3315
3316         case REQUEST_SENSE:
3317                 result = request_sense(srb, chip);
3318                 break;
3319
3320         case MODE_SENSE:
3321         case MODE_SENSE_10:
3322                 result = mode_sense(srb, chip);
3323                 break;
3324
3325         case 0x23:
3326                 result = read_format_capacity(srb, chip);
3327                 break;
3328
3329         case VENDOR_CMND:
3330                 result = vendor_cmnd(srb, chip);
3331                 break;
3332
3333         case MS_SP_CMND:
3334                 result = ms_sp_cmnd(srb, chip);
3335                 break;
3336
3337 #ifdef SUPPORT_CPRM
3338         case SD_PASS_THRU_MODE:
3339         case SD_EXECUTE_NO_DATA:
3340         case SD_EXECUTE_READ:
3341         case SD_EXECUTE_WRITE:
3342         case SD_GET_RSP:
3343         case SD_HW_RST:
3344                 result = sd_extention_cmnd(srb, chip);
3345                 break;
3346 #endif
3347
3348 #ifdef SUPPORT_MAGIC_GATE
3349         case CMD_MSPRO_MG_RKEY:
3350                 result = mg_report_key(srb, chip);
3351                 break;
3352
3353         case CMD_MSPRO_MG_SKEY:
3354                 result = mg_send_key(srb, chip);
3355                 break;
3356 #endif
3357
3358         case FORMAT_UNIT:
3359         case MODE_SELECT:
3360         case VERIFY:
3361                 result = TRANSPORT_GOOD;
3362                 break;
3363
3364         default:
3365                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3366                 result = TRANSPORT_FAILED;
3367         }
3368
3369         return result;
3370 }