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 i, unknown_cmd = 0;
  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                 for (i = 0; i < srb->cmd_len && i < 16; i++)
 323                         dev_dbg(rtsx_dev(chip), " %02x", srb->cmnd[i]);
 324                 dev_dbg(rtsx_dev(chip), "\n");
 325         }
 326 }
 327
 328 void set_sense_type(struct rtsx_chip *chip, unsigned int lun, int sense_type)
 329 {
 330         switch (sense_type) {
 331         case SENSE_TYPE_MEDIA_CHANGE:
 332                 set_sense_data(chip, lun, CUR_ERR, 0x06, 0, 0x28, 0, 0, 0);
 333                 break;
 334
 335         case SENSE_TYPE_MEDIA_NOT_PRESENT:
 336                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x3A, 0, 0, 0);
 337                 break;
 338
 339         case SENSE_TYPE_MEDIA_LBA_OVER_RANGE:
 340                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x21, 0, 0, 0);
 341                 break;
 342
 343         case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT:
 344                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x25, 0, 0, 0);
 345                 break;
 346
 347         case SENSE_TYPE_MEDIA_WRITE_PROTECT:
 348                 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x27, 0, 0, 0);
 349                 break;
 350
 351         case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR:
 352                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x11, 0, 0, 0);
 353                 break;
 354
 355         case SENSE_TYPE_MEDIA_WRITE_ERR:
 356                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x02, 0, 0);
 357                 break;
 358
 359         case SENSE_TYPE_MEDIA_INVALID_CMD_FIELD:
 360                 set_sense_data(chip, lun, CUR_ERR, ILGAL_REQ, 0,
 361                                 ASC_INVLD_CDB, ASCQ_INVLD_CDB, CDB_ILLEGAL, 1);
 362                 break;
 363
 364         case SENSE_TYPE_FORMAT_IN_PROGRESS:
 365                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 0, 0);
 366                 break;
 367
 368         case SENSE_TYPE_FORMAT_CMD_FAILED:
 369                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x31, 0x01, 0, 0);
 370                 break;
 371
 372 #ifdef SUPPORT_MAGIC_GATE
 373         case SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB:
 374                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x02, 0, 0);
 375                 break;
 376
 377         case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN:
 378                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x00, 0, 0);
 379                 break;
 380
 381         case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM:
 382                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x30, 0x00, 0, 0);
 383                 break;
 384
 385         case SENSE_TYPE_MG_WRITE_ERR:
 386                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x00, 0, 0);
 387                 break;
 388 #endif
 389
 390 #ifdef SUPPORT_SD_LOCK
 391         case SENSE_TYPE_MEDIA_READ_FORBIDDEN:
 392                 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x11, 0x13, 0, 0);
 393                 break;
 394 #endif
 395
 396         case SENSE_TYPE_NO_SENSE:
 397         default:
 398                 set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0);
 399                 break;
 400         }
 401 }
 402
 403 void set_sense_data(struct rtsx_chip *chip, unsigned int lun, u8 err_code,
 404                 u8 sense_key, u32 info, u8 asc, u8 ascq, u8 sns_key_info0,
 405                 u16 sns_key_info1)
 406 {
 407         struct sense_data_t *sense = &(chip->sense_buffer[lun]);
 408
 409         sense->err_code = err_code;
 410         sense->sense_key = sense_key;
 411         sense->info[0] = (u8)(info >> 24);
 412         sense->info[1] = (u8)(info >> 16);
 413         sense->info[2] = (u8)(info >> 8);
 414         sense->info[3] = (u8)info;
 415
 416         sense->ad_sense_len = sizeof(struct sense_data_t) - 8;
 417         sense->asc = asc;
 418         sense->ascq = ascq;
 419         if (sns_key_info0 != 0) {
 420                 sense->sns_key_info[0] = SKSV | sns_key_info0;
 421                 sense->sns_key_info[1] = (sns_key_info1 & 0xf0) >> 8;
 422                 sense->sns_key_info[2] = sns_key_info1 & 0x0f;
 423         }
 424 }
 425
 426 static int test_unit_ready(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 427 {
 428         unsigned int lun = SCSI_LUN(srb);
 429
 430         if (!check_card_ready(chip, lun)) {
 431                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 432                 return TRANSPORT_FAILED;
 433         }
 434
 435         if (!(CHK_BIT(chip->lun_mc, lun))) {
 436                 SET_BIT(chip->lun_mc, lun);
 437                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 438                 return TRANSPORT_FAILED;
 439         }
 440
 441 #ifdef SUPPORT_SD_LOCK
 442         if (get_lun_card(chip, SCSI_LUN(srb)) == SD_CARD) {
 443                 struct sd_info *sd_card = &(chip->sd_card);
 444                 if (sd_card->sd_lock_notify) {
 445                         sd_card->sd_lock_notify = 0;
 446                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 447                         return TRANSPORT_FAILED;
 448                 } else if (sd_card->sd_lock_status & SD_LOCKED) {
 449                         set_sense_type(chip, lun,
 450                                 SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 451                         return TRANSPORT_FAILED;
 452                 }
 453         }
 454 #endif
 455
 456         return TRANSPORT_GOOD;
 457 }
 458
 459 static unsigned char formatter_inquiry_str[20] = {
 460         'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K',
 461 #ifdef SUPPORT_MAGIC_GATE
 462         '-', 'M', 'G', /* Byte[47:49] */
 463 #else
 464         0x20, 0x20, 0x20,  /* Byte[47:49] */
 465 #endif
 466
 467 #ifdef SUPPORT_MAGIC_GATE
 468         0x0B,  /* Byte[50]: MG, MS, MSPro, MSXC */
 469 #else
 470         0x09,  /* Byte[50]: MS, MSPro, MSXC */
 471 #endif
 472         0x00,  /* Byte[51]: Category Specific Commands */
 473         0x00,  /* Byte[52]: Access Control and feature */
 474         0x20, 0x20, 0x20, /* Byte[53:55] */
 475 };
 476
 477 static int inquiry(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 478 {
 479         unsigned int lun = SCSI_LUN(srb);
 480         char *inquiry_default = (char *)"Generic-xD/SD/M.S.      1.00 ";
 481         char *inquiry_sdms =    (char *)"Generic-SD/MemoryStick  1.00 ";
 482         char *inquiry_sd =      (char *)"Generic-SD/MMC          1.00 ";
 483         char *inquiry_ms =      (char *)"Generic-MemoryStick     1.00 ";
 484         char *inquiry_string;
 485         unsigned char sendbytes;
 486         unsigned char *buf;
 487         u8 card = get_lun_card(chip, lun);
 488         int pro_formatter_flag = 0;
 489         unsigned char inquiry_buf[] = {
 490                 QULIFIRE|DRCT_ACCESS_DEV,
 491                 RMB_DISC|0x0D,
 492                 0x00,
 493                 0x01,
 494                 0x1f,
 495                 0x02,
 496                 0,
 497                 REL_ADR|WBUS_32|WBUS_16|SYNC|LINKED|CMD_QUE|SFT_RE,
 498         };
 499
 500         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
 501                 if (chip->lun2card[lun] == SD_CARD)
 502                         inquiry_string = inquiry_sd;
 503                 else
 504                         inquiry_string = inquiry_ms;
 505
 506         } else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) {
 507                 inquiry_string = inquiry_sdms;
 508         } else {
 509                 inquiry_string = inquiry_default;
 510         }
 511
 512         buf = vmalloc(scsi_bufflen(srb));
 513         if (buf == NULL)
 514                 TRACE_RET(chip, TRANSPORT_ERROR);
 515
 516 #ifdef SUPPORT_MAGIC_GATE
 517         if ((chip->mspro_formatter_enable) &&
 518                         (chip->lun2card[lun] & MS_CARD))
 519 #else
 520         if (chip->mspro_formatter_enable)
 521 #endif
 522         {
 523                 if (!card || (card == MS_CARD))
 524                         pro_formatter_flag = 1;
 525         }
 526
 527         if (pro_formatter_flag) {
 528                 if (scsi_bufflen(srb) < 56)
 529                         sendbytes = (unsigned char)(scsi_bufflen(srb));
 530                 else
 531                         sendbytes = 56;
 532
 533         } else {
 534                 if (scsi_bufflen(srb) < 36)
 535                         sendbytes = (unsigned char)(scsi_bufflen(srb));
 536                 else
 537                         sendbytes = 36;
 538         }
 539
 540         if (sendbytes > 8) {
 541                 memcpy(buf, inquiry_buf, 8);
 542                 memcpy(buf + 8, inquiry_string, sendbytes - 8);
 543                 if (pro_formatter_flag) {
 544                         /* Additional Length */
 545                         buf[4] = 0x33;
 546                 }
 547         } else {
 548                 memcpy(buf, inquiry_buf, sendbytes);
 549         }
 550
 551         if (pro_formatter_flag) {
 552                 if (sendbytes > 36)
 553                         memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
 554         }
 555
 556         scsi_set_resid(srb, 0);
 557
 558         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
 559         vfree(buf);
 560
 561         return TRANSPORT_GOOD;
 562 }
 563
 564
 565 static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 566 {
 567         unsigned int lun = SCSI_LUN(srb);
 568
 569         scsi_set_resid(srb, scsi_bufflen(srb));
 570
 571         if (srb->cmnd[1] == 1)
 572                 return TRANSPORT_GOOD;
 573
 574         switch (srb->cmnd[0x4]) {
 575         case STOP_MEDIUM:
 576                 /* Media disabled */
 577                 return TRANSPORT_GOOD;
 578
 579         case UNLOAD_MEDIUM:
 580                 /* Media shall be unload */
 581                 if (check_card_ready(chip, lun))
 582                         eject_card(chip, lun);
 583                 return TRANSPORT_GOOD;
 584
 585         case MAKE_MEDIUM_READY:
 586         case LOAD_MEDIUM:
 587                 if (check_card_ready(chip, lun)) {
 588                         return TRANSPORT_GOOD;
 589                 } else {
 590                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 591                         TRACE_RET(chip, TRANSPORT_FAILED);
 592                 }
 593
 594                 break;
 595         }
 596
 597         TRACE_RET(chip, TRANSPORT_ERROR);
 598 }
 599
 600
 601 static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 602 {
 603         int prevent;
 604
 605         prevent = srb->cmnd[4] & 0x1;
 606
 607         scsi_set_resid(srb, 0);
 608
 609         if (prevent) {
 610                 set_sense_type(chip, SCSI_LUN(srb),
 611                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 612                 TRACE_RET(chip, TRANSPORT_FAILED);
 613         }
 614
 615         return TRANSPORT_GOOD;
 616 }
 617
 618
 619 static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 620 {
 621         struct sense_data_t *sense;
 622         unsigned int lun = SCSI_LUN(srb);
 623         struct ms_info *ms_card = &(chip->ms_card);
 624         unsigned char *tmp, *buf;
 625
 626         sense = &(chip->sense_buffer[lun]);
 627
 628         if ((get_lun_card(chip, lun) == MS_CARD) &&
 629                 ms_card->pro_under_formatting) {
 630                 if (ms_card->format_status == FORMAT_SUCCESS) {
 631                         set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 632                         ms_card->pro_under_formatting = 0;
 633                         ms_card->progress = 0;
 634                 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) {
 635                         /* Logical Unit Not Ready Format in Progress */
 636                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
 637                                         0, (u16)(ms_card->progress));
 638                 } else {
 639                         /* Format Command Failed */
 640                         set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
 641                         ms_card->pro_under_formatting = 0;
 642                         ms_card->progress = 0;
 643                 }
 644
 645                 rtsx_set_stat(chip, RTSX_STAT_RUN);
 646         }
 647
 648         buf = vmalloc(scsi_bufflen(srb));
 649         if (buf == NULL)
 650                 TRACE_RET(chip, TRANSPORT_ERROR);
 651
 652         tmp = (unsigned char *)sense;
 653         memcpy(buf, tmp, scsi_bufflen(srb));
 654
 655         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
 656         vfree(buf);
 657
 658         scsi_set_resid(srb, 0);
 659         /* Reset Sense Data */
 660         set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 661         return TRANSPORT_GOOD;
 662 }
 663
 664 static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
 665                 int lun, u8 *buf, int buf_len)
 666 {
 667         struct ms_info *ms_card = &(chip->ms_card);
 668         int sys_info_offset;
 669         int data_size = buf_len;
 670         int support_format = 0;
 671         int i = 0;
 672
 673         if (cmd == MODE_SENSE) {
 674                 sys_info_offset = 8;
 675                 if (data_size > 0x68)
 676                         data_size = 0x68;
 677
 678                 buf[i++] = 0x67;  /* Mode Data Length */
 679         } else {
 680                 sys_info_offset = 12;
 681                 if (data_size > 0x6C)
 682                         data_size = 0x6C;
 683
 684                 buf[i++] = 0x00;  /* Mode Data Length (MSB) */
 685                 buf[i++] = 0x6A;  /* Mode Data Length (LSB) */
 686         }
 687
 688         /* Medium Type Code */
 689         if (check_card_ready(chip, lun)) {
 690                 if (CHK_MSXC(ms_card)) {
 691                         support_format = 1;
 692                         buf[i++] = 0x40;
 693                 } else if (CHK_MSPRO(ms_card)) {
 694                         support_format = 1;
 695                         buf[i++] = 0x20;
 696                 } else {
 697                         buf[i++] = 0x10;
 698                 }
 699
 700                 /* WP */
 701                 if (check_card_wp(chip, lun))
 702                         buf[i++] = 0x80;
 703                 else
 704                         buf[i++] = 0x00;
 705
 706         } else {
 707                 buf[i++] = 0x00;        /* MediaType */
 708                 buf[i++] = 0x00;        /* WP */
 709         }
 710
 711         buf[i++] = 0x00;                /* Reserved */
 712
 713         if (cmd == MODE_SENSE_10) {
 714                 buf[i++] = 0x00;  /* Reserved */
 715                 buf[i++] = 0x00;  /* Block descriptor length(MSB) */
 716                 buf[i++] = 0x00;  /* Block descriptor length(LSB) */
 717
 718                 /* The Following Data is the content of "Page 0x20" */
 719                 if (data_size >= 9)
 720                         buf[i++] = 0x20;                /* Page Code */
 721                 if (data_size >= 10)
 722                         buf[i++] = 0x62;                /* Page Length */
 723                 if (data_size >= 11)
 724                         buf[i++] = 0x00;                /* No Access Control */
 725                 if (data_size >= 12) {
 726                         if (support_format)
 727                                 buf[i++] = 0xC0;        /* SF, SGM */
 728                         else
 729                                 buf[i++] = 0x00;
 730                 }
 731         } else {
 732                 /* The Following Data is the content of "Page 0x20" */
 733                 if (data_size >= 5)
 734                         buf[i++] = 0x20;                /* Page Code */
 735                 if (data_size >= 6)
 736                         buf[i++] = 0x62;                /* Page Length */
 737                 if (data_size >= 7)
 738                         buf[i++] = 0x00;                /* No Access Control */
 739                 if (data_size >= 8) {
 740                         if (support_format)
 741                                 buf[i++] = 0xC0;        /* SF, SGM */
 742                         else
 743                                 buf[i++] = 0x00;
 744                 }
 745         }
 746
 747         if (data_size > sys_info_offset) {
 748                 /* 96 Bytes Attribute Data */
 749                 int len = data_size - sys_info_offset;
 750                 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                 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1573         } else {
1574                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1575                 TRACE_RET(chip, TRANSPORT_FAILED);
1576         }
1577
1578         return TRANSPORT_GOOD;
1579 }
1580
1581 static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1582 {
1583         int retval;
1584         unsigned int lun = SCSI_LUN(srb);
1585         u16 len;
1586
1587         rtsx_disable_aspm(chip);
1588
1589         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1590                 rtsx_exit_ss(chip);
1591                 wait_timeout(100);
1592         }
1593         rtsx_set_stat(chip, RTSX_STAT_RUN);
1594
1595         len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1596         len = min_t(u16, len, scsi_bufflen(srb));
1597
1598         if (srb->sc_data_direction == DMA_FROM_DEVICE)
1599                 dev_dbg(rtsx_dev(chip), "Read from device\n");
1600         else
1601                 dev_dbg(rtsx_dev(chip), "Write to device\n");
1602
1603         retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len,
1604                         scsi_sg_count(srb), srb->sc_data_direction, 1000);
1605         if (retval < 0) {
1606                 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1607                         set_sense_type(chip, lun,
1608                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1609                 else
1610                         set_sense_type(chip, lun,
1611                                 SENSE_TYPE_MEDIA_WRITE_ERR);
1612
1613                 TRACE_RET(chip, TRANSPORT_FAILED);
1614         }
1615         scsi_set_resid(srb, 0);
1616
1617         return TRANSPORT_GOOD;
1618 }
1619
1620 static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1621 {
1622         struct sd_info *sd_card = &(chip->sd_card);
1623         struct ms_info *ms_card = &(chip->ms_card);
1624         int buf_len;
1625         unsigned int lun = SCSI_LUN(srb);
1626         u8 card = get_lun_card(chip, lun);
1627         u8 status[32];
1628 #ifdef SUPPORT_OCP
1629         u8 oc_now_mask = 0, oc_ever_mask = 0;
1630 #endif
1631
1632         memset(status, 0, 32);
1633
1634         status[0] = (u8)(chip->product_id);
1635         status[1] = chip->ic_version;
1636
1637         if (chip->auto_delink_en)
1638                 status[2] = 0x10;
1639         else
1640                 status[2] = 0x00;
1641
1642         status[3] = 20;
1643         status[4] = 10;
1644         status[5] = 05;
1645         status[6] = 21;
1646
1647         if (chip->card_wp)
1648                 status[7] = 0x20;
1649         else
1650                 status[7] = 0x00;
1651
1652 #ifdef SUPPORT_OCP
1653         status[8] = 0;
1654         if (CHECK_LUN_MODE(chip,
1655                 SD_MS_2LUN) && (chip->lun2card[lun] == MS_CARD)) {
1656                 oc_now_mask = MS_OC_NOW;
1657                 oc_ever_mask = MS_OC_EVER;
1658         } else {
1659                 oc_now_mask = SD_OC_NOW;
1660                 oc_ever_mask = SD_OC_EVER;
1661         }
1662
1663         if (chip->ocp_stat & oc_now_mask)
1664                 status[8] |= 0x02;
1665
1666         if (chip->ocp_stat & oc_ever_mask)
1667                 status[8] |= 0x01;
1668 #endif
1669
1670         if (card == SD_CARD) {
1671                 if (CHK_SD(sd_card)) {
1672                         if (CHK_SD_HCXC(sd_card)) {
1673                                 if (sd_card->capacity > 0x4000000)
1674                                         status[0x0E] = 0x02;
1675                                 else
1676                                         status[0x0E] = 0x01;
1677                         } else {
1678                                 status[0x0E] = 0x00;
1679                         }
1680
1681                         if (CHK_SD_SDR104(sd_card))
1682                                 status[0x0F] = 0x03;
1683                         else if (CHK_SD_DDR50(sd_card))
1684                                 status[0x0F] = 0x04;
1685                         else if (CHK_SD_SDR50(sd_card))
1686                                 status[0x0F] = 0x02;
1687                         else if (CHK_SD_HS(sd_card))
1688                                 status[0x0F] = 0x01;
1689                         else
1690                                 status[0x0F] = 0x00;
1691                 } else {
1692                         if (CHK_MMC_SECTOR_MODE(sd_card))
1693                                 status[0x0E] = 0x01;
1694                         else
1695                                 status[0x0E] = 0x00;
1696
1697                         if (CHK_MMC_DDR52(sd_card))
1698                                 status[0x0F] = 0x03;
1699                         else if (CHK_MMC_52M(sd_card))
1700                                 status[0x0F] = 0x02;
1701                         else if (CHK_MMC_26M(sd_card))
1702                                 status[0x0F] = 0x01;
1703                         else
1704                                 status[0x0F] = 0x00;
1705                 }
1706         } else if (card == MS_CARD) {
1707                 if (CHK_MSPRO(ms_card)) {
1708                         if (CHK_MSXC(ms_card))
1709                                 status[0x0E] = 0x01;
1710                         else
1711                                 status[0x0E] = 0x00;
1712
1713                         if (CHK_HG8BIT(ms_card))
1714                                 status[0x0F] = 0x01;
1715                         else
1716                                 status[0x0F] = 0x00;
1717                 }
1718         }
1719
1720 #ifdef SUPPORT_SD_LOCK
1721         if (card == SD_CARD) {
1722                 status[0x17] = 0x80;
1723                 if (sd_card->sd_erase_status)
1724                         status[0x17] |= 0x01;
1725                 if (sd_card->sd_lock_status & SD_LOCKED) {
1726                         status[0x17] |= 0x02;
1727                         status[0x07] |= 0x40;
1728                 }
1729                 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1730                         status[0x17] |= 0x04;
1731         } else {
1732                 status[0x17] = 0x00;
1733         }
1734
1735         dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]);
1736 #endif
1737
1738         status[0x18] = 0x8A;
1739         status[0x1A] = 0x28;
1740 #ifdef SUPPORT_SD_LOCK
1741         status[0x1F] = 0x01;
1742 #endif
1743
1744         buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status));
1745         rtsx_stor_set_xfer_buf(status, buf_len, srb);
1746         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1747
1748         return TRANSPORT_GOOD;
1749 }
1750
1751 static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1752 {
1753         int phy_debug_mode;
1754         int retval;
1755         u16 reg;
1756
1757         if (!CHECK_PID(chip, 0x5208)) {
1758                 set_sense_type(chip, SCSI_LUN(srb),
1759                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1760                 TRACE_RET(chip, TRANSPORT_FAILED);
1761         }
1762
1763         phy_debug_mode = (int)(srb->cmnd[3]);
1764
1765         if (phy_debug_mode) {
1766                 chip->phy_debug_mode = 1;
1767                 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
1768                 if (retval != STATUS_SUCCESS)
1769                         TRACE_RET(chip, TRANSPORT_FAILED);
1770
1771                 rtsx_disable_bus_int(chip);
1772
1773                 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
1774                 if (retval != STATUS_SUCCESS)
1775                         TRACE_RET(chip, TRANSPORT_FAILED);
1776
1777                 reg |= 0x0001;
1778                 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1779                 if (retval != STATUS_SUCCESS)
1780                         TRACE_RET(chip, TRANSPORT_FAILED);
1781         } else {
1782                 chip->phy_debug_mode = 0;
1783                 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1784                 if (retval != STATUS_SUCCESS)
1785                         TRACE_RET(chip, TRANSPORT_FAILED);
1786
1787                 rtsx_enable_bus_int(chip);
1788
1789                 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
1790                 if (retval != STATUS_SUCCESS)
1791                         TRACE_RET(chip, TRANSPORT_FAILED);
1792
1793                 reg &= 0xFFFE;
1794                 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1795                 if (retval != STATUS_SUCCESS)
1796                         TRACE_RET(chip, TRANSPORT_FAILED);
1797         }
1798
1799         return TRANSPORT_GOOD;
1800 }
1801
1802 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1803 {
1804         int retval =  STATUS_SUCCESS;
1805         unsigned int lun = SCSI_LUN(srb);
1806         u8 cmd_type, mask, value, idx;
1807         u16 addr;
1808
1809         rtsx_disable_aspm(chip);
1810
1811         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1812                 rtsx_exit_ss(chip);
1813                 wait_timeout(100);
1814         }
1815         rtsx_set_stat(chip, RTSX_STAT_RUN);
1816
1817         switch (srb->cmnd[3]) {
1818         case INIT_BATCHCMD:
1819                 rtsx_init_cmd(chip);
1820                 break;
1821
1822         case ADD_BATCHCMD:
1823                 cmd_type = srb->cmnd[4];
1824                 if (cmd_type > 2) {
1825                         set_sense_type(chip, lun,
1826                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1827                         TRACE_RET(chip, TRANSPORT_FAILED);
1828                 }
1829                 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1830                 mask = srb->cmnd[7];
1831                 value = srb->cmnd[8];
1832                 rtsx_add_cmd(chip, cmd_type, addr, mask, value);
1833                 break;
1834
1835         case SEND_BATCHCMD:
1836                 retval = rtsx_send_cmd(chip, 0, 1000);
1837                 break;
1838
1839         case GET_BATCHRSP:
1840                 idx = srb->cmnd[4];
1841                 value = *(rtsx_get_cmd_data(chip) + idx);
1842                 if (scsi_bufflen(srb) < 1) {
1843                         set_sense_type(chip, lun,
1844                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1845                         TRACE_RET(chip, TRANSPORT_FAILED);
1846                 }
1847                 rtsx_stor_set_xfer_buf(&value, 1, srb);
1848                 scsi_set_resid(srb, 0);
1849                 break;
1850
1851         default:
1852                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1853                 TRACE_RET(chip, TRANSPORT_FAILED);
1854         }
1855
1856         if (retval != STATUS_SUCCESS) {
1857                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1858                 TRACE_RET(chip, TRANSPORT_FAILED);
1859         }
1860
1861         return TRANSPORT_GOOD;
1862 }
1863
1864 static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1865 {
1866         int result;
1867
1868         switch (srb->cmnd[3]) {
1869         case INIT_BATCHCMD:
1870         case ADD_BATCHCMD:
1871         case SEND_BATCHCMD:
1872         case GET_BATCHRSP:
1873                 result = rw_mem_cmd_buf(srb, chip);
1874                 break;
1875         default:
1876                 result = TRANSPORT_ERROR;
1877         }
1878
1879         return result;
1880 }
1881
1882 static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1883 {
1884         unsigned short addr, len, i;
1885         int retval;
1886         u8 *buf;
1887         u16 val;
1888
1889         rtsx_disable_aspm(chip);
1890
1891         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1892                 rtsx_exit_ss(chip);
1893                 wait_timeout(100);
1894         }
1895         rtsx_set_stat(chip, RTSX_STAT_RUN);
1896
1897         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1898         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1899
1900         if (len % 2)
1901                 len -= len % 2;
1902
1903         if (len) {
1904                 buf = vmalloc(len);
1905                 if (!buf)
1906                         TRACE_RET(chip, TRANSPORT_ERROR);
1907
1908                 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1909                 if (retval != STATUS_SUCCESS) {
1910                         vfree(buf);
1911                         set_sense_type(chip, SCSI_LUN(srb),
1912                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1913                         TRACE_RET(chip, TRANSPORT_FAILED);
1914                 }
1915
1916                 for (i = 0; i < len / 2; i++) {
1917                         retval = rtsx_read_phy_register(chip, addr + i, &val);
1918                         if (retval != STATUS_SUCCESS) {
1919                                 vfree(buf);
1920                                 set_sense_type(chip, SCSI_LUN(srb),
1921                                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1922                                 TRACE_RET(chip, TRANSPORT_FAILED);
1923                         }
1924
1925                         buf[2*i] = (u8)(val >> 8);
1926                         buf[2*i+1] = (u8)val;
1927                 }
1928
1929                 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1930                                         len);
1931                 rtsx_stor_set_xfer_buf(buf, len, srb);
1932                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1933
1934                 vfree(buf);
1935         }
1936
1937         return TRANSPORT_GOOD;
1938 }
1939
1940 static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1941 {
1942         unsigned short addr, len, i;
1943         int retval;
1944         u8 *buf;
1945         u16 val;
1946
1947         rtsx_disable_aspm(chip);
1948
1949         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1950                 rtsx_exit_ss(chip);
1951                 wait_timeout(100);
1952         }
1953         rtsx_set_stat(chip, RTSX_STAT_RUN);
1954
1955         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1956         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1957
1958         if (len % 2)
1959                 len -= len % 2;
1960
1961         if (len) {
1962                 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1963                                         len);
1964
1965                 buf = vmalloc(len);
1966                 if (buf == NULL)
1967                         TRACE_RET(chip, TRANSPORT_ERROR);
1968
1969                 rtsx_stor_get_xfer_buf(buf, len, srb);
1970                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1971
1972                 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1973                 if (retval != STATUS_SUCCESS) {
1974                         vfree(buf);
1975                         set_sense_type(chip, SCSI_LUN(srb),
1976                                 SENSE_TYPE_MEDIA_WRITE_ERR);
1977                         TRACE_RET(chip, TRANSPORT_FAILED);
1978                 }
1979
1980                 for (i = 0; i < len / 2; i++) {
1981                         val = ((u16)buf[2*i] << 8) | buf[2*i+1];
1982                         retval = rtsx_write_phy_register(chip, addr + i, val);
1983                         if (retval != STATUS_SUCCESS) {
1984                                 vfree(buf);
1985                                 set_sense_type(chip, SCSI_LUN(srb),
1986                                         SENSE_TYPE_MEDIA_WRITE_ERR);
1987                                 TRACE_RET(chip, TRANSPORT_FAILED);
1988                         }
1989                 }
1990
1991                 vfree(buf);
1992         }
1993
1994         return TRANSPORT_GOOD;
1995 }
1996
1997 static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1998 {
1999         unsigned short addr;
2000         int retval;
2001         u8 mode;
2002
2003         rtsx_disable_aspm(chip);
2004
2005         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2006                 rtsx_exit_ss(chip);
2007                 wait_timeout(100);
2008         }
2009         rtsx_set_stat(chip, RTSX_STAT_RUN);
2010
2011         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2012         if (retval != STATUS_SUCCESS) {
2013                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2014                 TRACE_RET(chip, TRANSPORT_FAILED);
2015         }
2016
2017         mode = srb->cmnd[3];
2018         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2019
2020         if (mode == 0) {
2021                 retval = spi_erase_eeprom_chip(chip);
2022                 if (retval != STATUS_SUCCESS) {
2023                         set_sense_type(chip, SCSI_LUN(srb),
2024                                 SENSE_TYPE_MEDIA_WRITE_ERR);
2025                         TRACE_RET(chip, TRANSPORT_FAILED);
2026                 }
2027         } else if (mode == 1) {
2028                 retval = spi_erase_eeprom_byte(chip, addr);
2029                 if (retval != STATUS_SUCCESS) {
2030                         set_sense_type(chip, SCSI_LUN(srb),
2031                                 SENSE_TYPE_MEDIA_WRITE_ERR);
2032                         TRACE_RET(chip, TRANSPORT_FAILED);
2033                 }
2034         } else {
2035                 set_sense_type(chip, SCSI_LUN(srb),
2036                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2037                 TRACE_RET(chip, TRANSPORT_FAILED);
2038         }
2039
2040         return TRANSPORT_GOOD;
2041 }
2042
2043 static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2044 {
2045         unsigned short addr, len, i;
2046         int retval;
2047         u8 *buf;
2048
2049         rtsx_disable_aspm(chip);
2050
2051         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2052                 rtsx_exit_ss(chip);
2053                 wait_timeout(100);
2054         }
2055         rtsx_set_stat(chip, RTSX_STAT_RUN);
2056
2057         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2058         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2059
2060         buf = vmalloc(len);
2061         if (!buf)
2062                 TRACE_RET(chip, TRANSPORT_ERROR);
2063
2064         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2065         if (retval != STATUS_SUCCESS) {
2066                 vfree(buf);
2067                 set_sense_type(chip, SCSI_LUN(srb),
2068                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2069                 TRACE_RET(chip, TRANSPORT_FAILED);
2070         }
2071
2072         for (i = 0; i < len; i++) {
2073                 retval = spi_read_eeprom(chip, addr + i, buf + i);
2074                 if (retval != STATUS_SUCCESS) {
2075                         vfree(buf);
2076                         set_sense_type(chip, SCSI_LUN(srb),
2077                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2078                         TRACE_RET(chip, TRANSPORT_FAILED);
2079                 }
2080         }
2081
2082         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2083         rtsx_stor_set_xfer_buf(buf, len, srb);
2084         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2085
2086         vfree(buf);
2087
2088         return TRANSPORT_GOOD;
2089 }
2090
2091 static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2092 {
2093         unsigned short addr, len, i;
2094         int retval;
2095         u8 *buf;
2096
2097         rtsx_disable_aspm(chip);
2098
2099         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2100                 rtsx_exit_ss(chip);
2101                 wait_timeout(100);
2102         }
2103         rtsx_set_stat(chip, RTSX_STAT_RUN);
2104
2105         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2106         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2107
2108         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2109         buf = vmalloc(len);
2110         if (buf == NULL)
2111                 TRACE_RET(chip, TRANSPORT_ERROR);
2112
2113         rtsx_stor_get_xfer_buf(buf, len, srb);
2114         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2115
2116         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2117         if (retval != STATUS_SUCCESS) {
2118                 vfree(buf);
2119                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2120                 TRACE_RET(chip, TRANSPORT_FAILED);
2121         }
2122
2123         for (i = 0; i < len; i++) {
2124                 retval = spi_write_eeprom(chip, addr + i, buf[i]);
2125                 if (retval != STATUS_SUCCESS) {
2126                         vfree(buf);
2127                         set_sense_type(chip, SCSI_LUN(srb),
2128                                 SENSE_TYPE_MEDIA_WRITE_ERR);
2129                         TRACE_RET(chip, TRANSPORT_FAILED);
2130                 }
2131         }
2132
2133         vfree(buf);
2134
2135         return TRANSPORT_GOOD;
2136 }
2137
2138 static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2139 {
2140         int retval;
2141         u8 addr, len, i;
2142         u8 *buf;
2143
2144         rtsx_disable_aspm(chip);
2145
2146         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2147                 rtsx_exit_ss(chip);
2148                 wait_timeout(100);
2149         }
2150         rtsx_set_stat(chip, RTSX_STAT_RUN);
2151
2152         addr = srb->cmnd[4];
2153         len = srb->cmnd[5];
2154
2155         buf = vmalloc(len);
2156         if (!buf)
2157                 TRACE_RET(chip, TRANSPORT_ERROR);
2158
2159         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2160         if (retval != STATUS_SUCCESS) {
2161                 vfree(buf);
2162                 set_sense_type(chip, SCSI_LUN(srb),
2163                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2164                 TRACE_RET(chip, TRANSPORT_FAILED);
2165         }
2166
2167         for (i = 0; i < len; i++) {
2168                 retval = rtsx_read_efuse(chip, addr + i, buf + i);
2169                 if (retval != STATUS_SUCCESS) {
2170                         vfree(buf);
2171                         set_sense_type(chip, SCSI_LUN(srb),
2172                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2173                         TRACE_RET(chip, TRANSPORT_FAILED);
2174                 }
2175         }
2176
2177         len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2178         rtsx_stor_set_xfer_buf(buf, len, srb);
2179         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2180
2181         vfree(buf);
2182
2183         return TRANSPORT_GOOD;
2184 }
2185
2186 static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2187 {
2188         int retval, result = TRANSPORT_GOOD;
2189         u16 val;
2190         u8 addr, len, i;
2191         u8 *buf;
2192
2193         rtsx_disable_aspm(chip);
2194
2195         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2196                 rtsx_exit_ss(chip);
2197                 wait_timeout(100);
2198         }
2199         rtsx_set_stat(chip, RTSX_STAT_RUN);
2200
2201         addr = srb->cmnd[4];
2202         len = srb->cmnd[5];
2203
2204         len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2205         buf = vmalloc(len);
2206         if (buf == NULL)
2207                 TRACE_RET(chip, TRANSPORT_ERROR);
2208
2209         rtsx_stor_get_xfer_buf(buf, len, srb);
2210         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2211
2212         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2213         if (retval != STATUS_SUCCESS) {
2214                 vfree(buf);
2215                 TRACE_RET(chip, TRANSPORT_ERROR);
2216         }
2217
2218         if (chip->asic_code) {
2219                 retval = rtsx_read_phy_register(chip, 0x08, &val);
2220                 if (retval != STATUS_SUCCESS) {
2221                         vfree(buf);
2222                         TRACE_RET(chip, TRANSPORT_ERROR);
2223                 }
2224
2225                 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2226                                         LDO3318_PWR_MASK, LDO_OFF);
2227                 if (retval != STATUS_SUCCESS) {
2228                         vfree(buf);
2229                         TRACE_RET(chip, TRANSPORT_ERROR);
2230                 }
2231
2232                 wait_timeout(600);
2233
2234                 retval = rtsx_write_phy_register(chip, 0x08,
2235                                                 0x4C00 | chip->phy_voltage);
2236                 if (retval != STATUS_SUCCESS) {
2237                         vfree(buf);
2238                         TRACE_RET(chip, TRANSPORT_ERROR);
2239                 }
2240
2241                 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2242                                         LDO3318_PWR_MASK, LDO_ON);
2243                 if (retval != STATUS_SUCCESS) {
2244                         vfree(buf);
2245                         TRACE_RET(chip, TRANSPORT_ERROR);
2246                 }
2247
2248                 wait_timeout(600);
2249         }
2250
2251         retval = card_power_on(chip, SPI_CARD);
2252         if (retval != STATUS_SUCCESS) {
2253                 vfree(buf);
2254                 TRACE_RET(chip, TRANSPORT_ERROR);
2255         }
2256
2257         wait_timeout(50);
2258
2259         for (i = 0; i < len; i++) {
2260                 retval = rtsx_write_efuse(chip, addr + i, buf[i]);
2261                 if (retval != STATUS_SUCCESS) {
2262                         set_sense_type(chip, SCSI_LUN(srb),
2263                                 SENSE_TYPE_MEDIA_WRITE_ERR);
2264                         result = TRANSPORT_FAILED;
2265                         TRACE_GOTO(chip, Exit);
2266                 }
2267         }
2268
2269 Exit:
2270         vfree(buf);
2271
2272         retval = card_power_off(chip, SPI_CARD);
2273         if (retval != STATUS_SUCCESS)
2274                 TRACE_RET(chip, TRANSPORT_ERROR);
2275
2276         if (chip->asic_code) {
2277                 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2278                                         LDO3318_PWR_MASK, LDO_OFF);
2279                 if (retval != STATUS_SUCCESS)
2280                         TRACE_RET(chip, TRANSPORT_ERROR);
2281
2282                 wait_timeout(600);
2283
2284                 retval = rtsx_write_phy_register(chip, 0x08, val);
2285                 if (retval != STATUS_SUCCESS)
2286                         TRACE_RET(chip, TRANSPORT_ERROR);
2287
2288                 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2289                                         LDO3318_PWR_MASK, LDO_ON);
2290                 if (retval != STATUS_SUCCESS)
2291                         TRACE_RET(chip, TRANSPORT_ERROR);
2292         }
2293
2294         return result;
2295 }
2296
2297 static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2298 {
2299         int retval;
2300         u8 func, func_max;
2301         u16 addr, len;
2302         u8 *buf;
2303
2304         rtsx_disable_aspm(chip);
2305
2306         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2307                 rtsx_exit_ss(chip);
2308                 wait_timeout(100);
2309         }
2310         rtsx_set_stat(chip, RTSX_STAT_RUN);
2311
2312         func = srb->cmnd[3];
2313         addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2314         len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2315
2316         dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x, len = %d\n",
2317                 __func__, func, addr, len);
2318
2319         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2320                 func_max = 1;
2321         else
2322                 func_max = 0;
2323
2324         if (func > func_max) {
2325                 set_sense_type(chip, SCSI_LUN(srb),
2326                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2327                 TRACE_RET(chip, TRANSPORT_FAILED);
2328         }
2329
2330         buf = vmalloc(len);
2331         if (!buf)
2332                 TRACE_RET(chip, TRANSPORT_ERROR);
2333
2334         retval = rtsx_read_cfg_seq(chip, func, addr, buf, len);
2335         if (retval != STATUS_SUCCESS) {
2336                 set_sense_type(chip, SCSI_LUN(srb),
2337                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2338                 vfree(buf);
2339                 TRACE_RET(chip, TRANSPORT_FAILED);
2340         }
2341
2342         len = (u16)min_t(unsigned int, scsi_bufflen(srb), len);
2343         rtsx_stor_set_xfer_buf(buf, len, srb);
2344         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2345
2346         vfree(buf);
2347
2348         return TRANSPORT_GOOD;
2349 }
2350
2351 static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2352 {
2353         int retval;
2354         u8 func, func_max;
2355         u16 addr, len;
2356         u8 *buf;
2357
2358         rtsx_disable_aspm(chip);
2359
2360         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2361                 rtsx_exit_ss(chip);
2362                 wait_timeout(100);
2363         }
2364         rtsx_set_stat(chip, RTSX_STAT_RUN);
2365
2366         func = srb->cmnd[3];
2367         addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2368         len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2369
2370         dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x\n",
2371                 __func__, func, addr);
2372
2373         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2374                 func_max = 1;
2375         else
2376                 func_max = 0;
2377
2378         if (func > func_max) {
2379                 set_sense_type(chip, SCSI_LUN(srb),
2380                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2381                 TRACE_RET(chip, TRANSPORT_FAILED);
2382         }
2383
2384         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2385         buf = vmalloc(len);
2386         if (!buf)
2387                 TRACE_RET(chip, TRANSPORT_ERROR);
2388
2389         rtsx_stor_get_xfer_buf(buf, len, srb);
2390         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2391
2392         retval = rtsx_write_cfg_seq(chip, func, addr, buf, len);
2393         if (retval != STATUS_SUCCESS) {
2394                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2395                 vfree(buf);
2396                 TRACE_RET(chip, TRANSPORT_FAILED);
2397         }
2398
2399         vfree(buf);
2400
2401         return TRANSPORT_GOOD;
2402 }
2403
2404 static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2405 {
2406         int result;
2407
2408         switch (srb->cmnd[2]) {
2409         case PP_READ10:
2410         case PP_WRITE10:
2411                 result = read_write(srb, chip);
2412                 break;
2413
2414         case READ_HOST_REG:
2415                 result = read_host_reg(srb, chip);
2416                 break;
2417
2418         case WRITE_HOST_REG:
2419                 result = write_host_reg(srb, chip);
2420                 break;
2421
2422         case GET_VAR:
2423                 result = get_variable(srb, chip);
2424                 break;
2425
2426         case SET_VAR:
2427                 result = set_variable(srb, chip);
2428                 break;
2429
2430         case DMA_READ:
2431         case DMA_WRITE:
2432                 result = dma_access_ring_buffer(srb, chip);
2433                 break;
2434
2435         case READ_PHY:
2436                 result = read_phy_register(srb, chip);
2437                 break;
2438
2439         case WRITE_PHY:
2440                 result = write_phy_register(srb, chip);
2441                 break;
2442
2443         case ERASE_EEPROM2:
2444                 result = erase_eeprom2(srb, chip);
2445                 break;
2446
2447         case READ_EEPROM2:
2448                 result = read_eeprom2(srb, chip);
2449                 break;
2450
2451         case WRITE_EEPROM2:
2452                 result = write_eeprom2(srb, chip);
2453                 break;
2454
2455         case READ_EFUSE:
2456                 result = read_efuse(srb, chip);
2457                 break;
2458
2459         case WRITE_EFUSE:
2460                 result = write_efuse(srb, chip);
2461                 break;
2462
2463         case READ_CFG:
2464                 result = read_cfg_byte(srb, chip);
2465                 break;
2466
2467         case WRITE_CFG:
2468                 result = write_cfg_byte(srb, chip);
2469                 break;
2470
2471         case SET_CHIP_MODE:
2472                 result = set_chip_mode(srb, chip);
2473                 break;
2474
2475         case SUIT_CMD:
2476                 result = suit_cmd(srb, chip);
2477                 break;
2478
2479         case GET_DEV_STATUS:
2480                 result = get_dev_status(srb, chip);
2481                 break;
2482
2483         default:
2484                 set_sense_type(chip, SCSI_LUN(srb),
2485                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2486                 TRACE_RET(chip, TRANSPORT_FAILED);
2487         }
2488
2489         return result;
2490 }
2491
2492
2493 static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2494 {
2495         u8 rtsx_status[16];
2496         int buf_len;
2497         unsigned int lun = SCSI_LUN(srb);
2498
2499         rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2500         rtsx_status[1] = (u8)(chip->vendor_id);
2501
2502         rtsx_status[2] = (u8)(chip->product_id >> 8);
2503         rtsx_status[3] = (u8)(chip->product_id);
2504
2505         rtsx_status[4] = (u8)lun;
2506
2507         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2508                 if (chip->lun2card[lun] == SD_CARD)
2509                         rtsx_status[5] = 2;
2510                 else
2511                         rtsx_status[5] = 3;
2512         } else {
2513                 if (chip->card_exist) {
2514                         if (chip->card_exist & XD_CARD)
2515                                 rtsx_status[5] = 4;
2516                         else if (chip->card_exist & SD_CARD)
2517                                 rtsx_status[5] = 2;
2518                         else if (chip->card_exist & MS_CARD)
2519                                 rtsx_status[5] = 3;
2520                         else
2521                                 rtsx_status[5] = 7;
2522                 } else {
2523                         rtsx_status[5] = 7;
2524                 }
2525         }
2526
2527         if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2528                 rtsx_status[6] = 2;
2529         else
2530                 rtsx_status[6] = 1;
2531
2532         rtsx_status[7] = (u8)(chip->product_id);
2533         rtsx_status[8] = chip->ic_version;
2534
2535         if (check_card_exist(chip, lun))
2536                 rtsx_status[9] = 1;
2537         else
2538                 rtsx_status[9] = 0;
2539
2540         if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2541                 rtsx_status[10] = 0;
2542         else
2543                 rtsx_status[10] = 1;
2544
2545         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2546                 if (chip->lun2card[lun] == SD_CARD)
2547                         rtsx_status[11] = SD_CARD;
2548                 else
2549                         rtsx_status[11] = MS_CARD;
2550         } else {
2551                 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2552         }
2553
2554         if (check_card_ready(chip, lun))
2555                 rtsx_status[12] = 1;
2556         else
2557                 rtsx_status[12] = 0;
2558
2559         if (get_lun_card(chip, lun) == XD_CARD) {
2560                 rtsx_status[13] = 0x40;
2561         } else if (get_lun_card(chip, lun) == SD_CARD) {
2562                 struct sd_info *sd_card = &(chip->sd_card);
2563
2564                 rtsx_status[13] = 0x20;
2565                 if (CHK_SD(sd_card)) {
2566                         if (CHK_SD_HCXC(sd_card))
2567                                 rtsx_status[13] |= 0x04;
2568                         if (CHK_SD_HS(sd_card))
2569                                 rtsx_status[13] |= 0x02;
2570                 } else {
2571                         rtsx_status[13] |= 0x08;
2572                         if (CHK_MMC_52M(sd_card))
2573                                 rtsx_status[13] |= 0x02;
2574                         if (CHK_MMC_SECTOR_MODE(sd_card))
2575                                 rtsx_status[13] |= 0x04;
2576                 }
2577         } else if (get_lun_card(chip, lun) == MS_CARD) {
2578                 struct ms_info *ms_card = &(chip->ms_card);
2579
2580                 if (CHK_MSPRO(ms_card)) {
2581                         rtsx_status[13] = 0x38;
2582                         if (CHK_HG8BIT(ms_card))
2583                                 rtsx_status[13] |= 0x04;
2584 #ifdef SUPPORT_MSXC
2585                         if (CHK_MSXC(ms_card))
2586                                 rtsx_status[13] |= 0x01;
2587 #endif
2588                 } else {
2589                         rtsx_status[13] = 0x30;
2590                 }
2591         } else {
2592                 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2593 #ifdef SUPPORT_SDIO
2594                         if (chip->sd_io && chip->sd_int)
2595                                 rtsx_status[13] = 0x60;
2596                         else
2597                                 rtsx_status[13] = 0x70;
2598 #else
2599                         rtsx_status[13] = 0x70;
2600 #endif
2601                 } else {
2602                         if (chip->lun2card[lun] == SD_CARD)
2603                                 rtsx_status[13] = 0x20;
2604                         else
2605                                 rtsx_status[13] = 0x30;
2606                 }
2607         }
2608
2609         rtsx_status[14] = 0x78;
2610         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2611                 rtsx_status[15] = 0x83;
2612         else
2613                 rtsx_status[15] = 0x82;
2614
2615         buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status));
2616         rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb);
2617         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
2618
2619         return TRANSPORT_GOOD;
2620 }
2621
2622 static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2623 {
2624         unsigned int lun = SCSI_LUN(srb);
2625         u8 card, bus_width;
2626
2627         if (!check_card_ready(chip, lun)) {
2628                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2629                 TRACE_RET(chip, TRANSPORT_FAILED);
2630         }
2631
2632         card = get_lun_card(chip, lun);
2633         if ((card == SD_CARD) || (card == MS_CARD)) {
2634                 bus_width = chip->card_bus_width[lun];
2635         } else {
2636                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2637                 TRACE_RET(chip, TRANSPORT_FAILED);
2638         }
2639
2640         scsi_set_resid(srb, 0);
2641         rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2642
2643         return TRANSPORT_GOOD;
2644 }
2645
2646 static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2647 {
2648         int result;
2649         unsigned int lun = SCSI_LUN(srb);
2650         u8 gpio_dir;
2651
2652         if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) {
2653                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2654                 TRACE_RET(chip, TRANSPORT_FAILED);
2655         }
2656
2657         rtsx_disable_aspm(chip);
2658
2659         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2660                 rtsx_exit_ss(chip);
2661                 wait_timeout(100);
2662         }
2663         rtsx_set_stat(chip, RTSX_STAT_RUN);
2664
2665         rtsx_force_power_on(chip, SSC_PDCTL);
2666
2667         rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2668         rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2669
2670         switch (srb->cmnd[2]) {
2671         case SCSI_SPI_GETSTATUS:
2672                 result = spi_get_status(srb, chip);
2673                 break;
2674
2675         case SCSI_SPI_SETPARAMETER:
2676                 result = spi_set_parameter(srb, chip);
2677                 break;
2678
2679         case SCSI_SPI_READFALSHID:
2680                 result = spi_read_flash_id(srb, chip);
2681                 break;
2682
2683         case SCSI_SPI_READFLASH:
2684                 result = spi_read_flash(srb, chip);
2685                 break;
2686
2687         case SCSI_SPI_WRITEFLASH:
2688                 result = spi_write_flash(srb, chip);
2689                 break;
2690
2691         case SCSI_SPI_WRITEFLASHSTATUS:
2692                 result = spi_write_flash_status(srb, chip);
2693                 break;
2694
2695         case SCSI_SPI_ERASEFLASH:
2696                 result = spi_erase_flash(srb, chip);
2697                 break;
2698
2699         default:
2700                 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2701
2702                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2703                 TRACE_RET(chip, TRANSPORT_FAILED);
2704         }
2705
2706         rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2707
2708         if (result != STATUS_SUCCESS)
2709                 TRACE_RET(chip, TRANSPORT_FAILED);
2710
2711         return TRANSPORT_GOOD;
2712 }
2713
2714 static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2715 {
2716         int result;
2717
2718         switch (srb->cmnd[1]) {
2719         case READ_STATUS:
2720                 result = read_status(srb, chip);
2721                 break;
2722
2723         case READ_MEM:
2724                 result = read_mem(srb, chip);
2725                 break;
2726
2727         case WRITE_MEM:
2728                 result = write_mem(srb, chip);
2729                 break;
2730
2731         case READ_EEPROM:
2732                 result = read_eeprom(srb, chip);
2733                 break;
2734
2735         case WRITE_EEPROM:
2736                 result = write_eeprom(srb, chip);
2737                 break;
2738
2739         case TOGGLE_GPIO:
2740                 result = toggle_gpio_cmd(srb, chip);
2741                 break;
2742
2743         case GET_SD_CSD:
2744                 result = get_sd_csd(srb, chip);
2745                 break;
2746
2747         case GET_BUS_WIDTH:
2748                 result = get_card_bus_width(srb, chip);
2749                 break;
2750
2751 #ifdef _MSG_TRACE
2752         case TRACE_MSG:
2753                 result = trace_msg_cmd(srb, chip);
2754                 break;
2755 #endif
2756
2757         case SCSI_APP_CMD:
2758                 result = app_cmd(srb, chip);
2759                 break;
2760
2761         case SPI_VENDOR_COMMAND:
2762                 result = spi_vendor_cmd(srb, chip);
2763                 break;
2764
2765         default:
2766                 set_sense_type(chip, SCSI_LUN(srb),
2767                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2768                 TRACE_RET(chip, TRANSPORT_FAILED);
2769         }
2770
2771         return result;
2772 }
2773
2774 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2775 void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2776 {
2777         unsigned int lun = SCSI_LUN(srb);
2778         u16 sec_cnt;
2779
2780         if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10))
2781                 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2782         else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6))
2783                 sec_cnt = srb->cmnd[4];
2784         else
2785                 return;
2786
2787         if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2788                 toggle_gpio(chip, LED_GPIO);
2789                 chip->rw_cap[lun] = 0;
2790         } else {
2791                 chip->rw_cap[lun] += sec_cnt;
2792         }
2793 }
2794 #endif
2795
2796 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2797 {
2798         struct ms_info *ms_card = &(chip->ms_card);
2799         unsigned int lun = SCSI_LUN(srb);
2800         int retval, quick_format;
2801
2802         if (get_lun_card(chip, lun) != MS_CARD) {
2803                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2804                 TRACE_RET(chip, TRANSPORT_FAILED);
2805         }
2806
2807         if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) ||
2808                 (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) ||
2809                 (srb->cmnd[7] != 0x74)) {
2810                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2811                 TRACE_RET(chip, TRANSPORT_FAILED);
2812         }
2813
2814         rtsx_disable_aspm(chip);
2815
2816         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2817                 rtsx_exit_ss(chip);
2818                 wait_timeout(100);
2819
2820                 if (!check_card_ready(chip, lun) ||
2821                                 (get_card_size(chip, lun) == 0)) {
2822                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2823                         TRACE_RET(chip, TRANSPORT_FAILED);
2824                 }
2825         }
2826         rtsx_set_stat(chip, RTSX_STAT_RUN);
2827
2828         if (srb->cmnd[8] & 0x01)
2829                 quick_format = 0;
2830         else
2831                 quick_format = 1;
2832
2833         if (!(chip->card_ready & MS_CARD)) {
2834                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2835                 TRACE_RET(chip, TRANSPORT_FAILED);
2836         }
2837
2838         if (chip->card_wp & MS_CARD) {
2839                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2840                 TRACE_RET(chip, TRANSPORT_FAILED);
2841         }
2842
2843         if (!CHK_MSPRO(ms_card)) {
2844                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2845                 TRACE_RET(chip, TRANSPORT_FAILED);
2846         }
2847
2848         retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
2849         if (retval != STATUS_SUCCESS) {
2850                 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
2851                 TRACE_RET(chip, TRANSPORT_FAILED);
2852         }
2853
2854         scsi_set_resid(srb, 0);
2855         return TRANSPORT_GOOD;
2856 }
2857
2858 #ifdef SUPPORT_PCGL_1P18
2859 static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2860 {
2861         struct ms_info *ms_card = &(chip->ms_card);
2862         unsigned int lun = SCSI_LUN(srb);
2863         u8 dev_info_id, data_len;
2864         u8 *buf;
2865         unsigned int buf_len;
2866         int i;
2867
2868         if (!check_card_ready(chip, lun)) {
2869                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2870                 TRACE_RET(chip, TRANSPORT_FAILED);
2871         }
2872         if (get_lun_card(chip, lun) != MS_CARD) {
2873                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2874                 TRACE_RET(chip, TRANSPORT_FAILED);
2875         }
2876
2877         if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
2878                 (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
2879                 (srb->cmnd[7] != 0x44)) {
2880                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2881                 TRACE_RET(chip, TRANSPORT_FAILED);
2882         }
2883
2884         dev_info_id = srb->cmnd[3];
2885         if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
2886                         (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
2887                         !CHK_MSPRO(ms_card)) {
2888                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2889                 TRACE_RET(chip, TRANSPORT_FAILED);
2890         }
2891
2892         if (dev_info_id == 0x15)
2893                 buf_len = data_len = 0x3A;
2894         else
2895                 buf_len = data_len = 0x6A;
2896
2897         buf = kmalloc(buf_len, GFP_KERNEL);
2898         if (!buf)
2899                 TRACE_RET(chip, TRANSPORT_ERROR);
2900
2901         i = 0;
2902         /*  GET Memory Stick Media Information Response Header */
2903         buf[i++] = 0x00;                /* Data length MSB */
2904         buf[i++] = data_len;            /* Data length LSB */
2905         /* Device Information Type Code */
2906         if (CHK_MSXC(ms_card))
2907                 buf[i++] = 0x03;
2908         else
2909                 buf[i++] = 0x02;
2910
2911         /* SGM bit */
2912         buf[i++] = 0x01;
2913         /* Reserved */
2914         buf[i++] = 0x00;
2915         buf[i++] = 0x00;
2916         buf[i++] = 0x00;
2917         /* Number of Device Information */
2918         buf[i++] = 0x01;
2919
2920         /*  Device Information Body */
2921
2922         /* Device Information ID Number */
2923         buf[i++] = dev_info_id;
2924         /* Device Information Length */
2925         if (dev_info_id == 0x15)
2926                 data_len = 0x31;
2927         else
2928                 data_len = 0x61;
2929
2930         buf[i++] = 0x00;                /* Data length MSB */
2931         buf[i++] = data_len;            /* Data length LSB */
2932         /* Valid Bit */
2933         buf[i++] = 0x80;
2934         if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
2935                 /* System Information */
2936                 memcpy(buf+i, ms_card->raw_sys_info, 96);
2937         } else {
2938                 /* Model Name */
2939                 memcpy(buf+i, ms_card->raw_model_name, 48);
2940         }
2941
2942         rtsx_stor_set_xfer_buf(buf, buf_len, srb);
2943
2944         if (dev_info_id == 0x15)
2945                 scsi_set_resid(srb, scsi_bufflen(srb)-0x3C);
2946         else
2947                 scsi_set_resid(srb, scsi_bufflen(srb)-0x6C);
2948
2949         kfree(buf);
2950         return STATUS_SUCCESS;
2951 }
2952 #endif
2953
2954 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2955 {
2956         int retval = TRANSPORT_ERROR;
2957
2958         if (srb->cmnd[2] == MS_FORMAT)
2959                 retval = ms_format_cmnd(srb, chip);
2960 #ifdef SUPPORT_PCGL_1P18
2961         else if (srb->cmnd[2] == GET_MS_INFORMATION)
2962                 retval = get_ms_information(srb, chip);
2963 #endif
2964
2965         return retval;
2966 }
2967
2968 #ifdef SUPPORT_CPRM
2969 static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2970 {
2971         unsigned int lun = SCSI_LUN(srb);
2972         int result;
2973
2974         rtsx_disable_aspm(chip);
2975
2976         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2977                 rtsx_exit_ss(chip);
2978                 wait_timeout(100);
2979         }
2980         rtsx_set_stat(chip, RTSX_STAT_RUN);
2981
2982         sd_cleanup_work(chip);
2983
2984         if (!check_card_ready(chip, lun)) {
2985                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2986                 TRACE_RET(chip, TRANSPORT_FAILED);
2987         }
2988         if (get_lun_card(chip, lun) != SD_CARD) {
2989                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2990                 TRACE_RET(chip, TRANSPORT_FAILED);
2991         }
2992
2993         switch (srb->cmnd[0]) {
2994         case SD_PASS_THRU_MODE:
2995                 result = sd_pass_thru_mode(srb, chip);
2996                 break;
2997
2998         case SD_EXECUTE_NO_DATA:
2999                 result = sd_execute_no_data(srb, chip);
3000                 break;
3001
3002         case SD_EXECUTE_READ:
3003                 result = sd_execute_read_data(srb, chip);
3004                 break;
3005
3006         case SD_EXECUTE_WRITE:
3007                 result = sd_execute_write_data(srb, chip);
3008                 break;
3009
3010         case SD_GET_RSP:
3011                 result = sd_get_cmd_rsp(srb, chip);
3012                 break;
3013
3014         case SD_HW_RST:
3015                 result = sd_hw_rst(srb, chip);
3016                 break;
3017
3018         default:
3019                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3020                 TRACE_RET(chip, TRANSPORT_FAILED);
3021         }
3022
3023         return result;
3024 }
3025 #endif
3026
3027 #ifdef SUPPORT_MAGIC_GATE
3028 static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3029 {
3030         struct ms_info *ms_card = &(chip->ms_card);
3031         unsigned int lun = SCSI_LUN(srb);
3032         int retval;
3033         u8 key_format;
3034
3035         rtsx_disable_aspm(chip);
3036
3037         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3038                 rtsx_exit_ss(chip);
3039                 wait_timeout(100);
3040         }
3041         rtsx_set_stat(chip, RTSX_STAT_RUN);
3042
3043         ms_cleanup_work(chip);
3044
3045         if (!check_card_ready(chip, lun)) {
3046                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3047                 TRACE_RET(chip, TRANSPORT_FAILED);
3048         }
3049         if (get_lun_card(chip, lun) != MS_CARD) {
3050                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3051                 TRACE_RET(chip, TRANSPORT_FAILED);
3052         }
3053
3054         if (srb->cmnd[7] != KC_MG_R_PRO) {
3055                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3056                 TRACE_RET(chip, TRANSPORT_FAILED);
3057         }
3058
3059         if (!CHK_MSPRO(ms_card)) {
3060                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3061                 TRACE_RET(chip, TRANSPORT_FAILED);
3062         }
3063
3064         key_format = srb->cmnd[10] & 0x3F;
3065         dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3066
3067         switch (key_format) {
3068         case KF_GET_LOC_EKB:
3069                 if ((scsi_bufflen(srb) == 0x41C) &&
3070                         (srb->cmnd[8] == 0x04) &&
3071                         (srb->cmnd[9] == 0x1C)) {
3072                         retval = mg_get_local_EKB(srb, chip);
3073                         if (retval != STATUS_SUCCESS)
3074                                 TRACE_RET(chip, TRANSPORT_FAILED);
3075
3076                 } else {
3077                         set_sense_type(chip, lun,
3078                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3079                         TRACE_RET(chip, TRANSPORT_FAILED);
3080                 }
3081                 break;
3082
3083         case KF_RSP_CHG:
3084                 if ((scsi_bufflen(srb) == 0x24) &&
3085                         (srb->cmnd[8] == 0x00) &&
3086                         (srb->cmnd[9] == 0x24)) {
3087                         retval = mg_get_rsp_chg(srb, chip);
3088                         if (retval != STATUS_SUCCESS)
3089                                 TRACE_RET(chip, TRANSPORT_FAILED);
3090
3091                 } else {
3092                         set_sense_type(chip, lun,
3093                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3094                         TRACE_RET(chip, TRANSPORT_FAILED);
3095                 }
3096                 break;
3097
3098         case KF_GET_ICV:
3099                 ms_card->mg_entry_num = srb->cmnd[5];
3100                 if ((scsi_bufflen(srb) == 0x404) &&
3101                         (srb->cmnd[8] == 0x04) &&
3102                         (srb->cmnd[9] == 0x04) &&
3103                         (srb->cmnd[2] == 0x00) &&
3104                         (srb->cmnd[3] == 0x00) &&
3105                         (srb->cmnd[4] == 0x00) &&
3106                         (srb->cmnd[5] < 32)) {
3107                         retval = mg_get_ICV(srb, chip);
3108                         if (retval != STATUS_SUCCESS)
3109                                 TRACE_RET(chip, TRANSPORT_FAILED);
3110
3111                 } else {
3112                         set_sense_type(chip, lun,
3113                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3114                         TRACE_RET(chip, TRANSPORT_FAILED);
3115                 }
3116                 break;
3117
3118         default:
3119                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3120                 TRACE_RET(chip, TRANSPORT_FAILED);
3121         }
3122
3123         scsi_set_resid(srb, 0);
3124         return TRANSPORT_GOOD;
3125 }
3126
3127 static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3128 {
3129         struct ms_info *ms_card = &(chip->ms_card);
3130         unsigned int lun = SCSI_LUN(srb);
3131         int retval;
3132         u8 key_format;
3133
3134         rtsx_disable_aspm(chip);
3135
3136         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3137                 rtsx_exit_ss(chip);
3138                 wait_timeout(100);
3139         }
3140         rtsx_set_stat(chip, RTSX_STAT_RUN);
3141
3142         ms_cleanup_work(chip);
3143
3144         if (!check_card_ready(chip, lun)) {
3145                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3146                 TRACE_RET(chip, TRANSPORT_FAILED);
3147         }
3148         if (check_card_wp(chip, lun)) {
3149                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
3150                 TRACE_RET(chip, TRANSPORT_FAILED);
3151         }
3152         if (get_lun_card(chip, lun) != MS_CARD) {
3153                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3154                 TRACE_RET(chip, TRANSPORT_FAILED);
3155         }
3156
3157         if (srb->cmnd[7] != KC_MG_R_PRO) {
3158                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3159                 TRACE_RET(chip, TRANSPORT_FAILED);
3160         }
3161
3162         if (!CHK_MSPRO(ms_card)) {
3163                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3164                 TRACE_RET(chip, TRANSPORT_FAILED);
3165         }
3166
3167         key_format = srb->cmnd[10] & 0x3F;
3168         dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3169
3170         switch (key_format) {
3171         case KF_SET_LEAF_ID:
3172                 if ((scsi_bufflen(srb) == 0x0C) &&
3173                         (srb->cmnd[8] == 0x00) &&
3174                         (srb->cmnd[9] == 0x0C)) {
3175                         retval = mg_set_leaf_id(srb, chip);
3176                         if (retval != STATUS_SUCCESS)
3177                                 TRACE_RET(chip, TRANSPORT_FAILED);
3178
3179                 } else {
3180                         set_sense_type(chip, lun,
3181                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3182                         TRACE_RET(chip, TRANSPORT_FAILED);
3183                 }
3184                 break;
3185
3186         case KF_CHG_HOST:
3187                 if ((scsi_bufflen(srb) == 0x0C) &&
3188                         (srb->cmnd[8] == 0x00) &&
3189                         (srb->cmnd[9] == 0x0C)) {
3190                         retval = mg_chg(srb, chip);
3191                         if (retval != STATUS_SUCCESS)
3192                                 TRACE_RET(chip, TRANSPORT_FAILED);
3193
3194                 } else {
3195                         set_sense_type(chip, lun,
3196                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3197                         TRACE_RET(chip, TRANSPORT_FAILED);
3198                 }
3199                 break;
3200
3201         case KF_RSP_HOST:
3202                 if ((scsi_bufflen(srb) == 0x0C) &&
3203                         (srb->cmnd[8] == 0x00) &&
3204                         (srb->cmnd[9] == 0x0C)) {
3205                         retval = mg_rsp(srb, chip);
3206                         if (retval != STATUS_SUCCESS)
3207                                 TRACE_RET(chip, TRANSPORT_FAILED);
3208
3209                 } else {
3210                         set_sense_type(chip, lun,
3211                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3212                         TRACE_RET(chip, TRANSPORT_FAILED);
3213                 }
3214                 break;
3215
3216         case KF_SET_ICV:
3217                 ms_card->mg_entry_num = srb->cmnd[5];
3218                 if ((scsi_bufflen(srb) == 0x404) &&
3219                         (srb->cmnd[8] == 0x04) &&
3220                         (srb->cmnd[9] == 0x04) &&
3221                         (srb->cmnd[2] == 0x00) &&
3222                         (srb->cmnd[3] == 0x00) &&
3223                         (srb->cmnd[4] == 0x00) &&
3224                         (srb->cmnd[5] < 32)) {
3225                         retval = mg_set_ICV(srb, chip);
3226                         if (retval != STATUS_SUCCESS)
3227                                 TRACE_RET(chip, TRANSPORT_FAILED);
3228
3229                 } else {
3230                         set_sense_type(chip, lun,
3231                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3232                         TRACE_RET(chip, TRANSPORT_FAILED);
3233                 }
3234                 break;
3235
3236         default:
3237                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3238                 TRACE_RET(chip, TRANSPORT_FAILED);
3239         }
3240
3241         scsi_set_resid(srb, 0);
3242         return TRANSPORT_GOOD;
3243 }
3244 #endif
3245
3246 int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3247 {
3248 #ifdef SUPPORT_SD_LOCK
3249         struct sd_info *sd_card = &(chip->sd_card);
3250 #endif
3251         struct ms_info *ms_card = &(chip->ms_card);
3252         unsigned int lun = SCSI_LUN(srb);
3253         int result;
3254
3255 #ifdef SUPPORT_SD_LOCK
3256         if (sd_card->sd_erase_status) {
3257                 /* Block all SCSI command except for
3258                  * REQUEST_SENSE and rs_ppstatus
3259                  */
3260                 if (!((srb->cmnd[0] == VENDOR_CMND) &&
3261                                 (srb->cmnd[1] == SCSI_APP_CMD) &&
3262                                 (srb->cmnd[2] == GET_DEV_STATUS)) &&
3263                                 (srb->cmnd[0] != REQUEST_SENSE)) {
3264                         /* Logical Unit Not Ready Format in Progress */
3265                         set_sense_data(chip, lun, CUR_ERR,
3266                                        0x02, 0, 0x04, 0x04, 0, 0);
3267                         TRACE_RET(chip, TRANSPORT_FAILED);
3268                 }
3269         }
3270 #endif
3271
3272         if ((get_lun_card(chip, lun) == MS_CARD) &&
3273                         (ms_card->format_status == FORMAT_IN_PROGRESS)) {
3274                 if ((srb->cmnd[0] != REQUEST_SENSE) &&
3275                         (srb->cmnd[0] != INQUIRY)) {
3276                         /* Logical Unit Not Ready Format in Progress */
3277                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
3278                                         0, (u16)(ms_card->progress));
3279                         TRACE_RET(chip, TRANSPORT_FAILED);
3280                 }
3281         }
3282
3283         switch (srb->cmnd[0]) {
3284         case READ_10:
3285         case WRITE_10:
3286         case READ_6:
3287         case WRITE_6:
3288                 result = read_write(srb, chip);
3289 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3290                 led_shine(srb, chip);
3291 #endif
3292                 break;
3293
3294         case TEST_UNIT_READY:
3295                 result = test_unit_ready(srb, chip);
3296                 break;
3297
3298         case INQUIRY:
3299                 result = inquiry(srb, chip);
3300                 break;
3301
3302         case READ_CAPACITY:
3303                 result = read_capacity(srb, chip);
3304                 break;
3305
3306         case START_STOP:
3307                 result = start_stop_unit(srb, chip);
3308                 break;
3309
3310         case ALLOW_MEDIUM_REMOVAL:
3311                 result = allow_medium_removal(srb, chip);
3312                 break;
3313
3314         case REQUEST_SENSE:
3315                 result = request_sense(srb, chip);
3316                 break;
3317
3318         case MODE_SENSE:
3319         case MODE_SENSE_10:
3320                 result = mode_sense(srb, chip);
3321                 break;
3322
3323         case 0x23:
3324                 result = read_format_capacity(srb, chip);
3325                 break;
3326
3327         case VENDOR_CMND:
3328                 result = vendor_cmnd(srb, chip);
3329                 break;
3330
3331         case MS_SP_CMND:
3332                 result = ms_sp_cmnd(srb, chip);
3333                 break;
3334
3335 #ifdef SUPPORT_CPRM
3336         case SD_PASS_THRU_MODE:
3337         case SD_EXECUTE_NO_DATA:
3338         case SD_EXECUTE_READ:
3339         case SD_EXECUTE_WRITE:
3340         case SD_GET_RSP:
3341         case SD_HW_RST:
3342                 result = sd_extention_cmnd(srb, chip);
3343                 break;
3344 #endif
3345
3346 #ifdef SUPPORT_MAGIC_GATE
3347         case CMD_MSPRO_MG_RKEY:
3348                 result = mg_report_key(srb, chip);
3349                 break;
3350
3351         case CMD_MSPRO_MG_SKEY:
3352                 result = mg_send_key(srb, chip);
3353                 break;
3354 #endif
3355
3356         case FORMAT_UNIT:
3357         case MODE_SELECT:
3358         case VERIFY:
3359                 result = TRANSPORT_GOOD;
3360                 break;
3361
3362         default:
3363                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3364                 result = TRANSPORT_FAILED;
3365         }
3366
3367         return result;
3368 }