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