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