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