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