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