drivers/staging/rts5208/rtsx_scsi.c

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