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 ([email protected])
  20  *   Micky Ching ([email protected])
  21  */
  22
  23 #include <linux/blkdev.h>
  24 #include <linux/kthread.h>
  25 #include <linux/sched.h>
  26 #include <linux/vmalloc.h>
  27
  28 #include "rtsx.h"
  29 #include "sd.h"
  30 #include "ms.h"
  31 #include "spi.h"
  32
  33 void scsi_show_command(struct rtsx_chip *chip)
  34 {
  35         struct scsi_cmnd *srb = chip->srb;
  36         char *what = NULL;
  37         bool unknown_cmd = false;
  38         int len;
  39
  40         switch (srb->cmnd[0]) {
  41         case TEST_UNIT_READY:
  42                 what = "TEST_UNIT_READY";
  43                 break;
  44         case REZERO_UNIT:
  45                 what = "REZERO_UNIT";
  46                 break;
  47         case REQUEST_SENSE:
  48                 what = "REQUEST_SENSE";
  49                 break;
  50         case FORMAT_UNIT:
  51                 what = "FORMAT_UNIT";
  52                 break;
  53         case READ_BLOCK_LIMITS:
  54                 what = "READ_BLOCK_LIMITS";
  55                 break;
  56         case REASSIGN_BLOCKS:
  57                 what = "REASSIGN_BLOCKS";
  58                 break;
  59         case READ_6:
  60                 what = "READ_6";
  61                 break;
  62         case WRITE_6:
  63                 what = "WRITE_6";
  64                 break;
  65         case SEEK_6:
  66                 what = "SEEK_6";
  67                 break;
  68         case READ_REVERSE:
  69                 what = "READ_REVERSE";
  70                 break;
  71         case WRITE_FILEMARKS:
  72                 what = "WRITE_FILEMARKS";
  73                 break;
  74         case SPACE:
  75                 what = "SPACE";
  76                 break;
  77         case INQUIRY:
  78                 what = "INQUIRY";
  79                 break;
  80         case RECOVER_BUFFERED_DATA:
  81                 what = "RECOVER_BUFFERED_DATA";
  82                 break;
  83         case MODE_SELECT:
  84                 what = "MODE_SELECT";
  85                 break;
  86         case RESERVE:
  87                 what = "RESERVE";
  88                 break;
  89         case RELEASE:
  90                 what = "RELEASE";
  91                 break;
  92         case COPY:
  93                 what = "COPY";
  94                 break;
  95         case ERASE:
  96                 what = "ERASE";
  97                 break;
  98         case MODE_SENSE:
  99                 what = "MODE_SENSE";
 100                 break;
 101         case START_STOP:
 102                 what = "START_STOP";
 103                 break;
 104         case RECEIVE_DIAGNOSTIC:
 105                 what = "RECEIVE_DIAGNOSTIC";
 106                 break;
 107         case SEND_DIAGNOSTIC:
 108                 what = "SEND_DIAGNOSTIC";
 109                 break;
 110         case ALLOW_MEDIUM_REMOVAL:
 111                 what = "ALLOW_MEDIUM_REMOVAL";
 112                 break;
 113         case SET_WINDOW:
 114                 what = "SET_WINDOW";
 115                 break;
 116         case READ_CAPACITY:
 117                 what = "READ_CAPACITY";
 118                 break;
 119         case READ_10:
 120                 what = "READ_10";
 121                 break;
 122         case WRITE_10:
 123                 what = "WRITE_10";
 124                 break;
 125         case SEEK_10:
 126                 what = "SEEK_10";
 127                 break;
 128         case WRITE_VERIFY:
 129                 what = "WRITE_VERIFY";
 130                 break;
 131         case VERIFY:
 132                 what = "VERIFY";
 133                 break;
 134         case SEARCH_HIGH:
 135                 what = "SEARCH_HIGH";
 136                 break;
 137         case SEARCH_EQUAL:
 138                 what = "SEARCH_EQUAL";
 139                 break;
 140         case SEARCH_LOW:
 141                 what = "SEARCH_LOW";
 142                 break;
 143         case SET_LIMITS:
 144                 what = "SET_LIMITS";
 145                 break;
 146         case READ_POSITION:
 147                 what = "READ_POSITION";
 148                 break;
 149         case SYNCHRONIZE_CACHE:
 150                 what = "SYNCHRONIZE_CACHE";
 151                 break;
 152         case LOCK_UNLOCK_CACHE:
 153                 what = "LOCK_UNLOCK_CACHE";
 154                 break;
 155         case READ_DEFECT_DATA:
 156                 what = "READ_DEFECT_DATA";
 157                 break;
 158         case MEDIUM_SCAN:
 159                 what = "MEDIUM_SCAN";
 160                 break;
 161         case COMPARE:
 162                 what = "COMPARE";
 163                 break;
 164         case COPY_VERIFY:
 165                 what = "COPY_VERIFY";
 166                 break;
 167         case WRITE_BUFFER:
 168                 what = "WRITE_BUFFER";
 169                 break;
 170         case READ_BUFFER:
 171                 what = "READ_BUFFER";
 172                 break;
 173         case UPDATE_BLOCK:
 174                 what = "UPDATE_BLOCK";
 175                 break;
 176         case READ_LONG:
 177                 what = "READ_LONG";
 178                 break;
 179         case WRITE_LONG:
 180                 what = "WRITE_LONG";
 181                 break;
 182         case CHANGE_DEFINITION:
 183                 what = "CHANGE_DEFINITION";
 184                 break;
 185         case WRITE_SAME:
 186                 what = "WRITE_SAME";
 187                 break;
 188         case GPCMD_READ_SUBCHANNEL:
 189                 what = "READ SUBCHANNEL";
 190                 break;
 191         case READ_TOC:
 192                 what = "READ_TOC";
 193                 break;
 194         case GPCMD_READ_HEADER:
 195                 what = "READ HEADER";
 196                 break;
 197         case GPCMD_PLAY_AUDIO_10:
 198                 what = "PLAY AUDIO (10)";
 199                 break;
 200         case GPCMD_PLAY_AUDIO_MSF:
 201                 what = "PLAY AUDIO MSF";
 202                 break;
 203         case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
 204                 what = "GET EVENT/STATUS NOTIFICATION";
 205                 break;
 206         case GPCMD_PAUSE_RESUME:
 207                 what = "PAUSE/RESUME";
 208                 break;
 209         case LOG_SELECT:
 210                 what = "LOG_SELECT";
 211                 break;
 212         case LOG_SENSE:
 213                 what = "LOG_SENSE";
 214                 break;
 215         case GPCMD_STOP_PLAY_SCAN:
 216                 what = "STOP PLAY/SCAN";
 217                 break;
 218         case GPCMD_READ_DISC_INFO:
 219                 what = "READ DISC INFORMATION";
 220                 break;
 221         case GPCMD_READ_TRACK_RZONE_INFO:
 222                 what = "READ TRACK INFORMATION";
 223                 break;
 224         case GPCMD_RESERVE_RZONE_TRACK:
 225                 what = "RESERVE TRACK";
 226                 break;
 227         case GPCMD_SEND_OPC:
 228                 what = "SEND OPC";
 229                 break;
 230         case MODE_SELECT_10:
 231                 what = "MODE_SELECT_10";
 232                 break;
 233         case GPCMD_REPAIR_RZONE_TRACK:
 234                 what = "REPAIR TRACK";
 235                 break;
 236         case 0x59:
 237                 what = "READ MASTER CUE";
 238                 break;
 239         case MODE_SENSE_10:
 240                 what = "MODE_SENSE_10";
 241                 break;
 242         case GPCMD_CLOSE_TRACK:
 243                 what = "CLOSE TRACK/SESSION";
 244                 break;
 245         case 0x5C:
 246                 what = "READ BUFFER CAPACITY";
 247                 break;
 248         case 0x5D:
 249                 what = "SEND CUE SHEET";
 250                 break;
 251         case GPCMD_BLANK:
 252                 what = "BLANK";
 253                 break;
 254         case REPORT_LUNS:
 255                 what = "REPORT LUNS";
 256                 break;
 257         case MOVE_MEDIUM:
 258                 what = "MOVE_MEDIUM or PLAY AUDIO (12)";
 259                 break;
 260         case READ_12:
 261                 what = "READ_12";
 262                 break;
 263         case WRITE_12:
 264                 what = "WRITE_12";
 265                 break;
 266         case WRITE_VERIFY_12:
 267                 what = "WRITE_VERIFY_12";
 268                 break;
 269         case SEARCH_HIGH_12:
 270                 what = "SEARCH_HIGH_12";
 271                 break;
 272         case SEARCH_EQUAL_12:
 273                 what = "SEARCH_EQUAL_12";
 274                 break;
 275         case SEARCH_LOW_12:
 276                 what = "SEARCH_LOW_12";
 277                 break;
 278         case SEND_VOLUME_TAG:
 279                 what = "SEND_VOLUME_TAG";
 280                 break;
 281         case READ_ELEMENT_STATUS:
 282                 what = "READ_ELEMENT_STATUS";
 283                 break;
 284         case GPCMD_READ_CD_MSF:
 285                 what = "READ CD MSF";
 286                 break;
 287         case GPCMD_SCAN:
 288                 what = "SCAN";
 289                 break;
 290         case GPCMD_SET_SPEED:
 291                 what = "SET CD SPEED";
 292                 break;
 293         case GPCMD_MECHANISM_STATUS:
 294                 what = "MECHANISM STATUS";
 295                 break;
 296         case GPCMD_READ_CD:
 297                 what = "READ CD";
 298                 break;
 299         case 0xE1:
 300                 what = "WRITE CONTINUE";
 301                 break;
 302         case WRITE_LONG_2:
 303                 what = "WRITE_LONG_2";
 304                 break;
 305         case VENDOR_CMND:
 306                 what = "Realtek's vendor command";
 307                 break;
 308         default:
 309                 what = "(unknown command)";
 310                 unknown_cmd = true;
 311                 break;
 312         }
 313
 314         if (srb->cmnd[0] != TEST_UNIT_READY)
 315                 dev_dbg(rtsx_dev(chip), "Command %s (%d bytes)\n",
 316                         what, srb->cmd_len);
 317
 318         if (unknown_cmd) {
 319                 len = min_t(unsigned short, srb->cmd_len, 16);
 320                 dev_dbg(rtsx_dev(chip), "%*ph\n", len, srb->cmnd);
 321         }
 322 }
 323
 324 void set_sense_type(struct rtsx_chip *chip, unsigned int lun, int sense_type)
 325 {
 326         switch (sense_type) {
 327         case SENSE_TYPE_MEDIA_CHANGE:
 328                 set_sense_data(chip, lun, CUR_ERR, 0x06, 0, 0x28, 0, 0, 0);
 329                 break;
 330
 331         case SENSE_TYPE_MEDIA_NOT_PRESENT:
 332                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x3A, 0, 0, 0);
 333                 break;
 334
 335         case SENSE_TYPE_MEDIA_LBA_OVER_RANGE:
 336                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x21, 0, 0, 0);
 337                 break;
 338
 339         case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT:
 340                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x25, 0, 0, 0);
 341                 break;
 342
 343         case SENSE_TYPE_MEDIA_WRITE_PROTECT:
 344                 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x27, 0, 0, 0);
 345                 break;
 346
 347         case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR:
 348                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x11, 0, 0, 0);
 349                 break;
 350
 351         case SENSE_TYPE_MEDIA_WRITE_ERR:
 352                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x02, 0, 0);
 353                 break;
 354
 355         case SENSE_TYPE_MEDIA_INVALID_CMD_FIELD:
 356                 set_sense_data(chip, lun, CUR_ERR, ILGAL_REQ, 0,
 357                                ASC_INVLD_CDB, ASCQ_INVLD_CDB, CDB_ILLEGAL, 1);
 358                 break;
 359
 360         case SENSE_TYPE_FORMAT_IN_PROGRESS:
 361                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 0, 0);
 362                 break;
 363
 364         case SENSE_TYPE_FORMAT_CMD_FAILED:
 365                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x31, 0x01, 0, 0);
 366                 break;
 367
 368 #ifdef SUPPORT_MAGIC_GATE
 369         case SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB:
 370                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x02, 0, 0);
 371                 break;
 372
 373         case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN:
 374                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x00, 0, 0);
 375                 break;
 376
 377         case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM:
 378                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x30, 0x00, 0, 0);
 379                 break;
 380
 381         case SENSE_TYPE_MG_WRITE_ERR:
 382                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x00, 0, 0);
 383                 break;
 384 #endif
 385
 386 #ifdef SUPPORT_SD_LOCK
 387         case SENSE_TYPE_MEDIA_READ_FORBIDDEN:
 388                 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x11, 0x13, 0, 0);
 389                 break;
 390 #endif
 391
 392         case SENSE_TYPE_NO_SENSE:
 393         default:
 394                 set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0);
 395                 break;
 396         }
 397 }
 398
 399 void set_sense_data(struct rtsx_chip *chip, unsigned int lun, u8 err_code,
 400                     u8 sense_key, u32 info, u8 asc, u8 ascq, u8 sns_key_info0,
 401                 u16 sns_key_info1)
 402 {
 403         struct sense_data_t *sense = &chip->sense_buffer[lun];
 404
 405         sense->err_code = err_code;
 406         sense->sense_key = sense_key;
 407         sense->info[0] = (u8)(info >> 24);
 408         sense->info[1] = (u8)(info >> 16);
 409         sense->info[2] = (u8)(info >> 8);
 410         sense->info[3] = (u8)info;
 411
 412         sense->ad_sense_len = sizeof(struct sense_data_t) - 8;
 413         sense->asc = asc;
 414         sense->ascq = ascq;
 415         if (sns_key_info0 != 0) {
 416                 sense->sns_key_info[0] = SKSV | sns_key_info0;
 417                 sense->sns_key_info[1] = (sns_key_info1 & 0xf0) >> 8;
 418                 sense->sns_key_info[2] = sns_key_info1 & 0x0f;
 419         }
 420 }
 421
 422 static int test_unit_ready(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 423 {
 424         unsigned int lun = SCSI_LUN(srb);
 425
 426         if (!check_card_ready(chip, lun)) {
 427                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 428                 return TRANSPORT_FAILED;
 429         }
 430
 431         if (!(CHK_BIT(chip->lun_mc, lun))) {
 432                 SET_BIT(chip->lun_mc, lun);
 433                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 434                 return TRANSPORT_FAILED;
 435         }
 436
 437 #ifdef SUPPORT_SD_LOCK
 438         if (get_lun_card(chip, SCSI_LUN(srb)) == SD_CARD) {
 439                 struct sd_info *sd_card = &chip->sd_card;
 440
 441                 if (sd_card->sd_lock_notify) {
 442                         sd_card->sd_lock_notify = 0;
 443                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 444                         return TRANSPORT_FAILED;
 445                 } else if (sd_card->sd_lock_status & SD_LOCKED) {
 446                         set_sense_type(chip, lun,
 447                                        SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 448                         return TRANSPORT_FAILED;
 449                 }
 450         }
 451 #endif
 452
 453         return TRANSPORT_GOOD;
 454 }
 455
 456 static unsigned char formatter_inquiry_str[20] = {
 457         'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K',
 458 #ifdef SUPPORT_MAGIC_GATE
 459         '-', 'M', 'G', /* Byte[47:49] */
 460 #else
 461         0x20, 0x20, 0x20,  /* Byte[47:49] */
 462 #endif
 463
 464 #ifdef SUPPORT_MAGIC_GATE
 465         0x0B,  /* Byte[50]: MG, MS, MSPro, MSXC */
 466 #else
 467         0x09,  /* Byte[50]: MS, MSPro, MSXC */
 468 #endif
 469         0x00,  /* Byte[51]: Category Specific Commands */
 470         0x00,  /* Byte[52]: Access Control and feature */
 471         0x20, 0x20, 0x20, /* Byte[53:55] */
 472 };
 473
 474 static int inquiry(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 475 {
 476         unsigned int lun = SCSI_LUN(srb);
 477         char *inquiry_default = (char *)"Generic-xD/SD/M.S.      1.00 ";
 478         char *inquiry_sdms =    (char *)"Generic-SD/MemoryStick  1.00 ";
 479         char *inquiry_sd =      (char *)"Generic-SD/MMC          1.00 ";
 480         char *inquiry_ms =      (char *)"Generic-MemoryStick     1.00 ";
 481         char *inquiry_string;
 482         unsigned char sendbytes;
 483         unsigned char *buf;
 484         u8 card = get_lun_card(chip, lun);
 485         bool pro_formatter_flag = false;
 486         unsigned char inquiry_buf[] = {
 487                 QULIFIRE | DRCT_ACCESS_DEV,
 488                 RMB_DISC | 0x0D,
 489                 0x00,
 490                 0x01,
 491                 0x1f,
 492                 0x02,
 493                 0,
 494                 REL_ADR | WBUS_32 | WBUS_16 | SYNC | LINKED | CMD_QUE | SFT_RE,
 495         };
 496
 497         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
 498                 if (chip->lun2card[lun] == SD_CARD)
 499                         inquiry_string = inquiry_sd;
 500                 else
 501                         inquiry_string = inquiry_ms;
 502
 503         } else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) {
 504                 inquiry_string = inquiry_sdms;
 505         } else {
 506                 inquiry_string = inquiry_default;
 507         }
 508
 509         buf = vmalloc(scsi_bufflen(srb));
 510         if (!buf) {
 511                 rtsx_trace(chip);
 512                 return TRANSPORT_ERROR;
 513         }
 514
 515 #ifdef SUPPORT_MAGIC_GATE
 516         if ((chip->mspro_formatter_enable) &&
 517             (chip->lun2card[lun] & MS_CARD))
 518 #else
 519         if (chip->mspro_formatter_enable)
 520 #endif
 521                 if (!card || (card == MS_CARD))
 522                         pro_formatter_flag = true;
 523
 524         if (pro_formatter_flag) {
 525                 if (scsi_bufflen(srb) < 56)
 526                         sendbytes = (unsigned char)(scsi_bufflen(srb));
 527                 else
 528                         sendbytes = 56;
 529
 530         } else {
 531                 if (scsi_bufflen(srb) < 36)
 532                         sendbytes = (unsigned char)(scsi_bufflen(srb));
 533                 else
 534                         sendbytes = 36;
 535         }
 536
 537         if (sendbytes > 8) {
 538                 memcpy(buf, inquiry_buf, 8);
 539                 strncpy(buf + 8, inquiry_string, sendbytes - 8);
 540                 if (pro_formatter_flag) {
 541                         /* Additional Length */
 542                         buf[4] = 0x33;
 543                 }
 544         } else {
 545                 memcpy(buf, inquiry_buf, sendbytes);
 546         }
 547
 548         if (pro_formatter_flag) {
 549                 if (sendbytes > 36)
 550                         memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
 551         }
 552
 553         scsi_set_resid(srb, 0);
 554
 555         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
 556         vfree(buf);
 557
 558         return TRANSPORT_GOOD;
 559 }
 560
 561 static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 562 {
 563         unsigned int lun = SCSI_LUN(srb);
 564
 565         scsi_set_resid(srb, scsi_bufflen(srb));
 566
 567         if (srb->cmnd[1] == 1)
 568                 return TRANSPORT_GOOD;
 569
 570         switch (srb->cmnd[0x4]) {
 571         case STOP_MEDIUM:
 572                 /* Media disabled */
 573                 return TRANSPORT_GOOD;
 574
 575         case UNLOAD_MEDIUM:
 576                 /* Media shall be unload */
 577                 if (check_card_ready(chip, lun))
 578                         eject_card(chip, lun);
 579                 return TRANSPORT_GOOD;
 580
 581         case MAKE_MEDIUM_READY:
 582         case LOAD_MEDIUM:
 583                 if (check_card_ready(chip, lun))
 584                         return TRANSPORT_GOOD;
 585                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 586                 rtsx_trace(chip);
 587                 return TRANSPORT_FAILED;
 588
 589                 break;
 590         }
 591
 592         rtsx_trace(chip);
 593         return TRANSPORT_ERROR;
 594 }
 595
 596 static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 597 {
 598         int prevent;
 599
 600         prevent = srb->cmnd[4] & 0x1;
 601
 602         scsi_set_resid(srb, 0);
 603
 604         if (prevent) {
 605                 set_sense_type(chip, SCSI_LUN(srb),
 606                                SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 607                 rtsx_trace(chip);
 608                 return TRANSPORT_FAILED;
 609         }
 610
 611         return TRANSPORT_GOOD;
 612 }
 613
 614 static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 615 {
 616         struct sense_data_t *sense;
 617         unsigned int lun = SCSI_LUN(srb);
 618         struct ms_info *ms_card = &chip->ms_card;
 619         unsigned char *tmp, *buf;
 620
 621         sense = &chip->sense_buffer[lun];
 622
 623         if ((get_lun_card(chip, lun) == MS_CARD) &&
 624             ms_card->pro_under_formatting) {
 625                 if (ms_card->format_status == FORMAT_SUCCESS) {
 626                         set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 627                         ms_card->pro_under_formatting = 0;
 628                         ms_card->progress = 0;
 629                 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) {
 630                         /* Logical Unit Not Ready Format in Progress */
 631                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
 632                                        0, (u16)(ms_card->progress));
 633                 } else {
 634                         /* Format Command Failed */
 635                         set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
 636                         ms_card->pro_under_formatting = 0;
 637                         ms_card->progress = 0;
 638                 }
 639
 640                 rtsx_set_stat(chip, RTSX_STAT_RUN);
 641         }
 642
 643         buf = vmalloc(scsi_bufflen(srb));
 644         if (!buf) {
 645                 rtsx_trace(chip);
 646                 return TRANSPORT_ERROR;
 647         }
 648
 649         tmp = (unsigned char *)sense;
 650         memcpy(buf, tmp, scsi_bufflen(srb));
 651
 652         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
 653         vfree(buf);
 654
 655         scsi_set_resid(srb, 0);
 656         /* Reset Sense Data */
 657         set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 658         return TRANSPORT_GOOD;
 659 }
 660
 661 static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
 662                           int lun, u8 *buf, int buf_len)
 663 {
 664         struct ms_info *ms_card = &chip->ms_card;
 665         int sys_info_offset;
 666         int data_size = buf_len;
 667         bool support_format = false;
 668         int i = 0;
 669
 670         if (cmd == MODE_SENSE) {
 671                 sys_info_offset = 8;
 672                 if (data_size > 0x68)
 673                         data_size = 0x68;
 674
 675                 buf[i++] = 0x67;  /* Mode Data Length */
 676         } else {
 677                 sys_info_offset = 12;
 678                 if (data_size > 0x6C)
 679                         data_size = 0x6C;
 680
 681                 buf[i++] = 0x00;  /* Mode Data Length (MSB) */
 682                 buf[i++] = 0x6A;  /* Mode Data Length (LSB) */
 683         }
 684
 685         /* Medium Type Code */
 686         if (check_card_ready(chip, lun)) {
 687                 if (CHK_MSXC(ms_card)) {
 688                         support_format = true;
 689                         buf[i++] = 0x40;
 690                 } else if (CHK_MSPRO(ms_card)) {
 691                         support_format = true;
 692                         buf[i++] = 0x20;
 693                 } else {
 694                         buf[i++] = 0x10;
 695                 }
 696
 697                 /* WP */
 698                 if (check_card_wp(chip, lun))
 699                         buf[i++] = 0x80;
 700                 else
 701                         buf[i++] = 0x00;
 702
 703         } else {
 704                 buf[i++] = 0x00;        /* MediaType */
 705                 buf[i++] = 0x00;        /* WP */
 706         }
 707
 708         buf[i++] = 0x00;                /* Reserved */
 709
 710         if (cmd == MODE_SENSE_10) {
 711                 buf[i++] = 0x00;  /* Reserved */
 712                 buf[i++] = 0x00;  /* Block descriptor length(MSB) */
 713                 buf[i++] = 0x00;  /* Block descriptor length(LSB) */
 714
 715                 /* The Following Data is the content of "Page 0x20" */
 716                 if (data_size >= 9)
 717                         buf[i++] = 0x20;                /* Page Code */
 718                 if (data_size >= 10)
 719                         buf[i++] = 0x62;                /* Page Length */
 720                 if (data_size >= 11)
 721                         buf[i++] = 0x00;                /* No Access Control */
 722                 if (data_size >= 12) {
 723                         if (support_format)
 724                                 buf[i++] = 0xC0;        /* SF, SGM */
 725                         else
 726                                 buf[i++] = 0x00;
 727                 }
 728         } else {
 729                 /* The Following Data is the content of "Page 0x20" */
 730                 if (data_size >= 5)
 731                         buf[i++] = 0x20;                /* Page Code */
 732                 if (data_size >= 6)
 733                         buf[i++] = 0x62;                /* Page Length */
 734                 if (data_size >= 7)
 735                         buf[i++] = 0x00;                /* No Access Control */
 736                 if (data_size >= 8) {
 737                         if (support_format)
 738                                 buf[i++] = 0xC0;        /* SF, SGM */
 739                         else
 740                                 buf[i++] = 0x00;
 741                 }
 742         }
 743
 744         if (data_size > sys_info_offset) {
 745                 /* 96 Bytes Attribute Data */
 746                 int len = data_size - sys_info_offset;
 747
 748                 len = (len < 96) ? len : 96;
 749
 750                 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
 751         }
 752 }
 753
 754 static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 755 {
 756         unsigned int lun = SCSI_LUN(srb);
 757         unsigned int data_size;
 758         int status;
 759         bool pro_formatter_flag;
 760         unsigned char page_code, *buf;
 761         u8 card = get_lun_card(chip, lun);
 762
 763 #ifndef SUPPORT_MAGIC_GATE
 764         if (!check_card_ready(chip, lun)) {
 765                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 766                 scsi_set_resid(srb, scsi_bufflen(srb));
 767                 rtsx_trace(chip);
 768                 return TRANSPORT_FAILED;
 769         }
 770 #endif
 771
 772         pro_formatter_flag = false;
 773         data_size = 8;
 774 #ifdef SUPPORT_MAGIC_GATE
 775         if ((chip->lun2card[lun] & MS_CARD)) {
 776                 if (!card || (card == MS_CARD)) {
 777                         data_size = 108;
 778                         if (chip->mspro_formatter_enable)
 779                                 pro_formatter_flag = true;
 780                 }
 781         }
 782 #else
 783         if (card == MS_CARD) {
 784                 if (chip->mspro_formatter_enable) {
 785                         pro_formatter_flag = true;
 786                         data_size = 108;
 787                 }
 788         }
 789 #endif
 790
 791         buf = kmalloc(data_size, GFP_KERNEL);
 792         if (!buf) {
 793                 rtsx_trace(chip);
 794                 return TRANSPORT_ERROR;
 795         }
 796
 797         page_code = srb->cmnd[2] & 0x3f;
 798
 799         if ((page_code == 0x3F) || (page_code == 0x1C) ||
 800             (page_code == 0x00) ||
 801                 (pro_formatter_flag && (page_code == 0x20))) {
 802                 if (srb->cmnd[0] == MODE_SENSE) {
 803                         if ((page_code == 0x3F) || (page_code == 0x20)) {
 804                                 ms_mode_sense(chip, srb->cmnd[0],
 805                                               lun, buf, data_size);
 806                         } else {
 807                                 data_size = 4;
 808                                 buf[0] = 0x03;
 809                                 buf[1] = 0x00;
 810                                 if (check_card_wp(chip, lun))
 811                                         buf[2] = 0x80;
 812                                 else
 813                                         buf[2] = 0x00;
 814
 815                                 buf[3] = 0x00;
 816                         }
 817                 } else {
 818                         if ((page_code == 0x3F) || (page_code == 0x20)) {
 819                                 ms_mode_sense(chip, srb->cmnd[0],
 820                                               lun, buf, data_size);
 821                         } else {
 822                                 data_size = 8;
 823                                 buf[0] = 0x00;
 824                                 buf[1] = 0x06;
 825                                 buf[2] = 0x00;
 826                                 if (check_card_wp(chip, lun))
 827                                         buf[3] = 0x80;
 828                                 else
 829                                         buf[3] = 0x00;
 830                                 buf[4] = 0x00;
 831                                 buf[5] = 0x00;
 832                                 buf[6] = 0x00;
 833                                 buf[7] = 0x00;
 834                         }
 835                 }
 836                 status = TRANSPORT_GOOD;
 837         } else {
 838                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 839                 scsi_set_resid(srb, scsi_bufflen(srb));
 840                 status = TRANSPORT_FAILED;
 841         }
 842
 843         if (status == TRANSPORT_GOOD) {
 844                 unsigned int len = min_t(unsigned int, scsi_bufflen(srb),
 845                                         data_size);
 846                 rtsx_stor_set_xfer_buf(buf, len, srb);
 847                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
 848         }
 849         kfree(buf);
 850
 851         return status;
 852 }
 853
 854 static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 855 {
 856 #ifdef SUPPORT_SD_LOCK
 857         struct sd_info *sd_card = &chip->sd_card;
 858 #endif
 859         unsigned int lun = SCSI_LUN(srb);
 860         int retval;
 861         u32 start_sec;
 862         u16 sec_cnt;
 863
 864         rtsx_disable_aspm(chip);
 865
 866         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
 867                 rtsx_exit_ss(chip);
 868                 wait_timeout(100);
 869         }
 870         rtsx_set_stat(chip, RTSX_STAT_RUN);
 871
 872         if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) {
 873                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 874                 rtsx_trace(chip);
 875                 return TRANSPORT_FAILED;
 876         }
 877
 878         if (!(CHK_BIT(chip->lun_mc, lun))) {
 879                 SET_BIT(chip->lun_mc, lun);
 880                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 881                 return TRANSPORT_FAILED;
 882         }
 883
 884 #ifdef SUPPORT_SD_LOCK
 885         if (sd_card->sd_erase_status) {
 886                 /* Accessing to any card is forbidden
 887                  * until the erase procedure of SD is completed
 888                  */
 889                 dev_dbg(rtsx_dev(chip), "SD card being erased!\n");
 890                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 891                 rtsx_trace(chip);
 892                 return TRANSPORT_FAILED;
 893         }
 894
 895         if (get_lun_card(chip, lun) == SD_CARD) {
 896                 if (sd_card->sd_lock_status & SD_LOCKED) {
 897                         dev_dbg(rtsx_dev(chip), "SD card locked!\n");
 898                         set_sense_type(chip, lun,
 899                                        SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 900                         rtsx_trace(chip);
 901                         return TRANSPORT_FAILED;
 902                 }
 903         }
 904 #endif
 905
 906         if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
 907                 start_sec = ((u32)srb->cmnd[2] << 24) |
 908                         ((u32)srb->cmnd[3] << 16) |
 909                         ((u32)srb->cmnd[4] << 8) | ((u32)srb->cmnd[5]);
 910                 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
 911         } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
 912                 start_sec = ((u32)(srb->cmnd[1] & 0x1F) << 16) |
 913                         ((u32)srb->cmnd[2] << 8) | ((u32)srb->cmnd[3]);
 914                 sec_cnt = srb->cmnd[4];
 915                 if (sec_cnt == 0)
 916                         sec_cnt = 256;
 917         } else if ((srb->cmnd[0] == VENDOR_CMND) &&
 918                 (srb->cmnd[1] == SCSI_APP_CMD) &&
 919                 ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) {
 920                 start_sec = ((u32)srb->cmnd[4] << 24) |
 921                         ((u32)srb->cmnd[5] << 16) |
 922                         ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]);
 923                 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10];
 924         } else {
 925                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 926                 rtsx_trace(chip);
 927                 return TRANSPORT_FAILED;
 928         }
 929
 930         /* In some test, we will receive a start_sec like 0xFFFFFFFF.
 931          * In this situation, start_sec + sec_cnt will overflow, so we
 932          * need to judge start_sec at first
 933          */
 934         if ((start_sec > get_card_size(chip, lun)) ||
 935             ((start_sec + sec_cnt) > get_card_size(chip, lun))) {
 936                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
 937                 rtsx_trace(chip);
 938                 return TRANSPORT_FAILED;
 939         }
 940
 941         if (sec_cnt == 0) {
 942                 scsi_set_resid(srb, 0);
 943                 return TRANSPORT_GOOD;
 944         }
 945
 946         if (chip->rw_fail_cnt[lun] == 3) {
 947                 dev_dbg(rtsx_dev(chip), "read/write fail three times in succession\n");
 948                 if (srb->sc_data_direction == DMA_FROM_DEVICE)
 949                         set_sense_type(chip, lun,
 950                                        SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
 951                 else
 952                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
 953
 954                 rtsx_trace(chip);
 955                 return TRANSPORT_FAILED;
 956         }
 957
 958         if (srb->sc_data_direction == DMA_TO_DEVICE) {
 959                 if (check_card_wp(chip, lun)) {
 960                         dev_dbg(rtsx_dev(chip), "Write protected card!\n");
 961                         set_sense_type(chip, lun,
 962                                        SENSE_TYPE_MEDIA_WRITE_PROTECT);
 963                         rtsx_trace(chip);
 964                         return TRANSPORT_FAILED;
 965                 }
 966         }
 967
 968         retval = card_rw(srb, chip, start_sec, sec_cnt);
 969         if (retval != STATUS_SUCCESS) {
 970                 if (chip->need_release & chip->lun2card[lun]) {
 971                         chip->rw_fail_cnt[lun] = 0;
 972                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 973                 } else {
 974                         chip->rw_fail_cnt[lun]++;
 975                         if (srb->sc_data_direction == DMA_FROM_DEVICE)
 976                                 set_sense_type
 977                                         (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) {
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) {
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) {
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) {
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)) {
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) {
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 int 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,
1653                                     1000);
1654         if (retval < 0) {
1655                 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1656                         set_sense_type(chip, lun,
1657                                        SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1658                 else
1659                         set_sense_type(chip, lun,
1660                                        SENSE_TYPE_MEDIA_WRITE_ERR);
1661
1662                 rtsx_trace(chip);
1663                 return TRANSPORT_FAILED;
1664         }
1665         scsi_set_resid(srb, 0);
1666
1667         return TRANSPORT_GOOD;
1668 }
1669
1670 static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1671 {
1672         struct sd_info *sd_card = &chip->sd_card;
1673         struct ms_info *ms_card = &chip->ms_card;
1674         int buf_len;
1675         unsigned int lun = SCSI_LUN(srb);
1676         u8 card = get_lun_card(chip, lun);
1677         u8 status[32];
1678 #ifdef SUPPORT_OCP
1679         u8 oc_now_mask = 0, oc_ever_mask = 0;
1680 #endif
1681
1682         memset(status, 0, 32);
1683
1684         status[0] = (u8)(chip->product_id);
1685         status[1] = chip->ic_version;
1686
1687         if (chip->auto_delink_en)
1688                 status[2] = 0x10;
1689         else
1690                 status[2] = 0x00;
1691
1692         status[3] = 20;
1693         status[4] = 10;
1694         status[5] = 05;
1695         status[6] = 21;
1696
1697         if (chip->card_wp)
1698                 status[7] = 0x20;
1699         else
1700                 status[7] = 0x00;
1701
1702 #ifdef SUPPORT_OCP
1703         status[8] = 0;
1704         if (CHECK_LUN_MODE(chip, SD_MS_2LUN) &&
1705             (chip->lun2card[lun] == MS_CARD)) {
1706                 oc_now_mask = MS_OC_NOW;
1707                 oc_ever_mask = MS_OC_EVER;
1708         } else {
1709                 oc_now_mask = SD_OC_NOW;
1710                 oc_ever_mask = SD_OC_EVER;
1711         }
1712
1713         if (chip->ocp_stat & oc_now_mask)
1714                 status[8] |= 0x02;
1715
1716         if (chip->ocp_stat & oc_ever_mask)
1717                 status[8] |= 0x01;
1718 #endif
1719
1720         if (card == SD_CARD) {
1721                 if (CHK_SD(sd_card)) {
1722                         if (CHK_SD_HCXC(sd_card)) {
1723                                 if (sd_card->capacity > 0x4000000)
1724                                         status[0x0E] = 0x02;
1725                                 else
1726                                         status[0x0E] = 0x01;
1727                         } else {
1728                                 status[0x0E] = 0x00;
1729                         }
1730
1731                         if (CHK_SD_SDR104(sd_card))
1732                                 status[0x0F] = 0x03;
1733                         else if (CHK_SD_DDR50(sd_card))
1734                                 status[0x0F] = 0x04;
1735                         else if (CHK_SD_SDR50(sd_card))
1736                                 status[0x0F] = 0x02;
1737                         else if (CHK_SD_HS(sd_card))
1738                                 status[0x0F] = 0x01;
1739                         else
1740                                 status[0x0F] = 0x00;
1741                 } else {
1742                         if (CHK_MMC_SECTOR_MODE(sd_card))
1743                                 status[0x0E] = 0x01;
1744                         else
1745                                 status[0x0E] = 0x00;
1746
1747                         if (CHK_MMC_DDR52(sd_card))
1748                                 status[0x0F] = 0x03;
1749                         else if (CHK_MMC_52M(sd_card))
1750                                 status[0x0F] = 0x02;
1751                         else if (CHK_MMC_26M(sd_card))
1752                                 status[0x0F] = 0x01;
1753                         else
1754                                 status[0x0F] = 0x00;
1755                 }
1756         } else if (card == MS_CARD) {
1757                 if (CHK_MSPRO(ms_card)) {
1758                         if (CHK_MSXC(ms_card))
1759                                 status[0x0E] = 0x01;
1760                         else
1761                                 status[0x0E] = 0x00;
1762
1763                         if (CHK_HG8BIT(ms_card))
1764                                 status[0x0F] = 0x01;
1765                         else
1766                                 status[0x0F] = 0x00;
1767                 }
1768         }
1769
1770 #ifdef SUPPORT_SD_LOCK
1771         if (card == SD_CARD) {
1772                 status[0x17] = 0x80;
1773                 if (sd_card->sd_erase_status)
1774                         status[0x17] |= 0x01;
1775                 if (sd_card->sd_lock_status & SD_LOCKED) {
1776                         status[0x17] |= 0x02;
1777                         status[0x07] |= 0x40;
1778                 }
1779                 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1780                         status[0x17] |= 0x04;
1781         } else {
1782                 status[0x17] = 0x00;
1783         }
1784
1785         dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]);
1786 #endif
1787
1788         status[0x18] = 0x8A;
1789         status[0x1A] = 0x28;
1790 #ifdef SUPPORT_SD_LOCK
1791         status[0x1F] = 0x01;
1792 #endif
1793
1794         buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status));
1795         rtsx_stor_set_xfer_buf(status, buf_len, srb);
1796         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1797
1798         return TRANSPORT_GOOD;
1799 }
1800
1801 static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1802 {
1803         int phy_debug_mode;
1804         int retval;
1805         u16 reg;
1806
1807         if (!CHECK_PID(chip, 0x5208)) {
1808                 set_sense_type(chip, SCSI_LUN(srb),
1809                                SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1810                 rtsx_trace(chip);
1811                 return TRANSPORT_FAILED;
1812         }
1813
1814         phy_debug_mode = (int)(srb->cmnd[3]);
1815
1816         if (phy_debug_mode) {
1817                 chip->phy_debug_mode = 1;
1818                 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
1819                 if (retval != STATUS_SUCCESS) {
1820                         rtsx_trace(chip);
1821                         return TRANSPORT_FAILED;
1822                 }
1823
1824                 rtsx_disable_bus_int(chip);
1825
1826                 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
1827                 if (retval != STATUS_SUCCESS) {
1828                         rtsx_trace(chip);
1829                         return TRANSPORT_FAILED;
1830                 }
1831
1832                 reg |= 0x0001;
1833                 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1834                 if (retval != STATUS_SUCCESS) {
1835                         rtsx_trace(chip);
1836                         return TRANSPORT_FAILED;
1837                 }
1838         } else {
1839                 chip->phy_debug_mode = 0;
1840                 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1841                 if (retval != STATUS_SUCCESS) {
1842                         rtsx_trace(chip);
1843                         return TRANSPORT_FAILED;
1844                 }
1845
1846                 rtsx_enable_bus_int(chip);
1847
1848                 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
1849                 if (retval != STATUS_SUCCESS) {
1850                         rtsx_trace(chip);
1851                         return TRANSPORT_FAILED;
1852                 }
1853
1854                 reg &= 0xFFFE;
1855                 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1856                 if (retval != STATUS_SUCCESS) {
1857                         rtsx_trace(chip);
1858                         return TRANSPORT_FAILED;
1859                 }
1860         }
1861
1862         return TRANSPORT_GOOD;
1863 }
1864
1865 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1866 {
1867         int retval =  STATUS_SUCCESS;
1868         unsigned int lun = SCSI_LUN(srb);
1869         u8 cmd_type, mask, value, idx;
1870         u16 addr;
1871
1872         rtsx_disable_aspm(chip);
1873
1874         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1875                 rtsx_exit_ss(chip);
1876                 wait_timeout(100);
1877         }
1878         rtsx_set_stat(chip, RTSX_STAT_RUN);
1879
1880         switch (srb->cmnd[3]) {
1881         case INIT_BATCHCMD:
1882                 rtsx_init_cmd(chip);
1883                 break;
1884
1885         case ADD_BATCHCMD:
1886                 cmd_type = srb->cmnd[4];
1887                 if (cmd_type > 2) {
1888                         set_sense_type(chip, lun,
1889                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1890                         rtsx_trace(chip);
1891                         return TRANSPORT_FAILED;
1892                 }
1893                 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1894                 mask = srb->cmnd[7];
1895                 value = srb->cmnd[8];
1896                 rtsx_add_cmd(chip, cmd_type, addr, mask, value);
1897                 break;
1898
1899         case SEND_BATCHCMD:
1900                 retval = rtsx_send_cmd(chip, 0, 1000);
1901                 break;
1902
1903         case GET_BATCHRSP:
1904                 idx = srb->cmnd[4];
1905                 value = *(rtsx_get_cmd_data(chip) + idx);
1906                 if (scsi_bufflen(srb) < 1) {
1907                         set_sense_type(chip, lun,
1908                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1909                         rtsx_trace(chip);
1910                         return TRANSPORT_FAILED;
1911                 }
1912                 rtsx_stor_set_xfer_buf(&value, 1, srb);
1913                 scsi_set_resid(srb, 0);
1914                 break;
1915
1916         default:
1917                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1918                 rtsx_trace(chip);
1919                 return TRANSPORT_FAILED;
1920         }
1921
1922         if (retval != STATUS_SUCCESS) {
1923                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1924                 rtsx_trace(chip);
1925                 return TRANSPORT_FAILED;
1926         }
1927
1928         return TRANSPORT_GOOD;
1929 }
1930
1931 static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1932 {
1933         switch (srb->cmnd[3]) {
1934         case INIT_BATCHCMD:
1935         case ADD_BATCHCMD:
1936         case SEND_BATCHCMD:
1937         case GET_BATCHRSP:
1938                 return rw_mem_cmd_buf(srb, chip);
1939         default:
1940                 return TRANSPORT_ERROR;
1941         }
1942 }
1943
1944 static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1945 {
1946         unsigned short addr, len, i;
1947         int retval;
1948         u8 *buf;
1949         u16 val;
1950
1951         rtsx_disable_aspm(chip);
1952
1953         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1954                 rtsx_exit_ss(chip);
1955                 wait_timeout(100);
1956         }
1957         rtsx_set_stat(chip, RTSX_STAT_RUN);
1958
1959         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1960         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1961
1962         if (len % 2)
1963                 len -= len % 2;
1964
1965         if (len) {
1966                 buf = vmalloc(len);
1967                 if (!buf) {
1968                         rtsx_trace(chip);
1969                         return TRANSPORT_ERROR;
1970                 }
1971
1972                 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1973                 if (retval != STATUS_SUCCESS) {
1974                         vfree(buf);
1975                         set_sense_type(chip, SCSI_LUN(srb),
1976                                        SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1977                         rtsx_trace(chip);
1978                         return TRANSPORT_FAILED;
1979                 }
1980
1981                 for (i = 0; i < len / 2; i++) {
1982                         retval = rtsx_read_phy_register(chip, addr + i, &val);
1983                         if (retval != STATUS_SUCCESS) {
1984                                 vfree(buf);
1985                                 set_sense_type
1986                                         (chip, SCSI_LUN(srb),
1987                                          SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1988                                 rtsx_trace(chip);
1989                                 return TRANSPORT_FAILED;
1990                         }
1991
1992                         buf[2 * i] = (u8)(val >> 8);
1993                         buf[2 * i + 1] = (u8)val;
1994                 }
1995
1996                 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1997                                         len);
1998                 rtsx_stor_set_xfer_buf(buf, len, srb);
1999                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2000
2001                 vfree(buf);
2002         }
2003
2004         return TRANSPORT_GOOD;
2005 }
2006
2007 static int write_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2008 {
2009         unsigned short addr, len, i;
2010         int retval;
2011         u8 *buf;
2012         u16 val;
2013
2014         rtsx_disable_aspm(chip);
2015
2016         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2017                 rtsx_exit_ss(chip);
2018                 wait_timeout(100);
2019         }
2020         rtsx_set_stat(chip, RTSX_STAT_RUN);
2021
2022         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2023         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2024
2025         if (len % 2)
2026                 len -= len % 2;
2027
2028         if (len) {
2029                 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
2030                                         len);
2031
2032                 buf = vmalloc(len);
2033                 if (!buf) {
2034                         rtsx_trace(chip);
2035                         return TRANSPORT_ERROR;
2036                 }
2037
2038                 rtsx_stor_get_xfer_buf(buf, len, srb);
2039                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
2040
2041                 retval = rtsx_force_power_on(chip, SSC_PDCTL);
2042                 if (retval != STATUS_SUCCESS) {
2043                         vfree(buf);
2044                         set_sense_type(chip, SCSI_LUN(srb),
2045                                        SENSE_TYPE_MEDIA_WRITE_ERR);
2046                         rtsx_trace(chip);
2047                         return TRANSPORT_FAILED;
2048                 }
2049
2050                 for (i = 0; i < len / 2; i++) {
2051                         val = ((u16)buf[2 * i] << 8) | buf[2 * i + 1];
2052                         retval = rtsx_write_phy_register(chip, addr + i, val);
2053                         if (retval != STATUS_SUCCESS) {
2054                                 vfree(buf);
2055                                 set_sense_type(chip, SCSI_LUN(srb),
2056                                                SENSE_TYPE_MEDIA_WRITE_ERR);
2057                                 rtsx_trace(chip);
2058                                 return TRANSPORT_FAILED;
2059                         }
2060                 }
2061
2062                 vfree(buf);
2063         }
2064
2065         return TRANSPORT_GOOD;
2066 }
2067
2068 static int erase_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2069 {
2070         unsigned short addr;
2071         int retval;
2072         u8 mode;
2073
2074         rtsx_disable_aspm(chip);
2075
2076         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2077                 rtsx_exit_ss(chip);
2078                 wait_timeout(100);
2079         }
2080         rtsx_set_stat(chip, RTSX_STAT_RUN);
2081
2082         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2083         if (retval != STATUS_SUCCESS) {
2084                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2085                 rtsx_trace(chip);
2086                 return TRANSPORT_FAILED;
2087         }
2088
2089         mode = srb->cmnd[3];
2090         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2091
2092         if (mode == 0) {
2093                 retval = spi_erase_eeprom_chip(chip);
2094                 if (retval != STATUS_SUCCESS) {
2095                         set_sense_type(chip, SCSI_LUN(srb),
2096                                        SENSE_TYPE_MEDIA_WRITE_ERR);
2097                         rtsx_trace(chip);
2098                         return TRANSPORT_FAILED;
2099                 }
2100         } else if (mode == 1) {
2101                 retval = spi_erase_eeprom_byte(chip, addr);
2102                 if (retval != STATUS_SUCCESS) {
2103                         set_sense_type(chip, SCSI_LUN(srb),
2104                                        SENSE_TYPE_MEDIA_WRITE_ERR);
2105                         rtsx_trace(chip);
2106                         return TRANSPORT_FAILED;
2107                 }
2108         } else {
2109                 set_sense_type(chip, SCSI_LUN(srb),
2110                                SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2111                 rtsx_trace(chip);
2112                 return TRANSPORT_FAILED;
2113         }
2114
2115         return TRANSPORT_GOOD;
2116 }
2117
2118 static int read_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2119 {
2120         unsigned short addr, len, i;
2121         int retval;
2122         u8 *buf;
2123
2124         rtsx_disable_aspm(chip);
2125
2126         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2127                 rtsx_exit_ss(chip);
2128                 wait_timeout(100);
2129         }
2130         rtsx_set_stat(chip, RTSX_STAT_RUN);
2131
2132         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2133         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2134
2135         buf = vmalloc(len);
2136         if (!buf) {
2137                 rtsx_trace(chip);
2138                 return TRANSPORT_ERROR;
2139         }
2140
2141         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2142         if (retval != STATUS_SUCCESS) {
2143                 vfree(buf);
2144                 set_sense_type(chip, SCSI_LUN(srb),
2145                                SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2146                 rtsx_trace(chip);
2147                 return TRANSPORT_FAILED;
2148         }
2149
2150         for (i = 0; i < len; i++) {
2151                 retval = spi_read_eeprom(chip, addr + i, buf + i);
2152                 if (retval != STATUS_SUCCESS) {
2153                         vfree(buf);
2154                         set_sense_type(chip, SCSI_LUN(srb),
2155                                        SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2156                         rtsx_trace(chip);
2157                         return TRANSPORT_FAILED;
2158                 }
2159         }
2160
2161         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2162         rtsx_stor_set_xfer_buf(buf, len, srb);
2163         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2164
2165         vfree(buf);
2166
2167         return TRANSPORT_GOOD;
2168 }
2169
2170 static int write_eeprom2(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2171 {
2172         unsigned short addr, len, i;
2173         int retval;
2174         u8 *buf;
2175
2176         rtsx_disable_aspm(chip);
2177
2178         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2179                 rtsx_exit_ss(chip);
2180                 wait_timeout(100);
2181         }
2182         rtsx_set_stat(chip, RTSX_STAT_RUN);
2183
2184         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
2185         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
2186
2187         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2188         buf = vmalloc(len);
2189         if (!buf) {
2190                 rtsx_trace(chip);
2191                 return TRANSPORT_ERROR;
2192         }
2193
2194         rtsx_stor_get_xfer_buf(buf, len, srb);
2195         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2196
2197         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2198         if (retval != STATUS_SUCCESS) {
2199                 vfree(buf);
2200                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2201                 rtsx_trace(chip);
2202                 return TRANSPORT_FAILED;
2203         }
2204
2205         for (i = 0; i < len; i++) {
2206                 retval = spi_write_eeprom(chip, addr + i, buf[i]);
2207                 if (retval != STATUS_SUCCESS) {
2208                         vfree(buf);
2209                         set_sense_type(chip, SCSI_LUN(srb),
2210                                        SENSE_TYPE_MEDIA_WRITE_ERR);
2211                         rtsx_trace(chip);
2212                         return TRANSPORT_FAILED;
2213                 }
2214         }
2215
2216         vfree(buf);
2217
2218         return TRANSPORT_GOOD;
2219 }
2220
2221 static int read_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2222 {
2223         int retval;
2224         u8 addr, len, i;
2225         u8 *buf;
2226
2227         rtsx_disable_aspm(chip);
2228
2229         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2230                 rtsx_exit_ss(chip);
2231                 wait_timeout(100);
2232         }
2233         rtsx_set_stat(chip, RTSX_STAT_RUN);
2234
2235         addr = srb->cmnd[4];
2236         len = srb->cmnd[5];
2237
2238         buf = vmalloc(len);
2239         if (!buf) {
2240                 rtsx_trace(chip);
2241                 return TRANSPORT_ERROR;
2242         }
2243
2244         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2245         if (retval != STATUS_SUCCESS) {
2246                 vfree(buf);
2247                 set_sense_type(chip, SCSI_LUN(srb),
2248                                SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2249                 rtsx_trace(chip);
2250                 return TRANSPORT_FAILED;
2251         }
2252
2253         for (i = 0; i < len; i++) {
2254                 retval = rtsx_read_efuse(chip, addr + i, buf + i);
2255                 if (retval != STATUS_SUCCESS) {
2256                         vfree(buf);
2257                         set_sense_type(chip, SCSI_LUN(srb),
2258                                        SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2259                         rtsx_trace(chip);
2260                         return TRANSPORT_FAILED;
2261                 }
2262         }
2263
2264         len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2265         rtsx_stor_set_xfer_buf(buf, len, srb);
2266         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2267
2268         vfree(buf);
2269
2270         return TRANSPORT_GOOD;
2271 }
2272
2273 static int write_efuse(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2274 {
2275         int retval, result = TRANSPORT_GOOD;
2276         u16 val;
2277         u8 addr, len, i;
2278         u8 *buf;
2279
2280         rtsx_disable_aspm(chip);
2281
2282         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2283                 rtsx_exit_ss(chip);
2284                 wait_timeout(100);
2285         }
2286         rtsx_set_stat(chip, RTSX_STAT_RUN);
2287
2288         addr = srb->cmnd[4];
2289         len = srb->cmnd[5];
2290
2291         len = (u8)min_t(unsigned int, scsi_bufflen(srb), len);
2292         buf = vmalloc(len);
2293         if (!buf) {
2294                 rtsx_trace(chip);
2295                 return TRANSPORT_ERROR;
2296         }
2297
2298         rtsx_stor_get_xfer_buf(buf, len, srb);
2299         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2300
2301         retval = rtsx_force_power_on(chip, SSC_PDCTL);
2302         if (retval != STATUS_SUCCESS) {
2303                 vfree(buf);
2304                 rtsx_trace(chip);
2305                 return TRANSPORT_ERROR;
2306         }
2307
2308         if (chip->asic_code) {
2309                 retval = rtsx_read_phy_register(chip, 0x08, &val);
2310                 if (retval != STATUS_SUCCESS) {
2311                         vfree(buf);
2312                         rtsx_trace(chip);
2313                         return TRANSPORT_ERROR;
2314                 }
2315
2316                 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2317                                              LDO3318_PWR_MASK, LDO_OFF);
2318                 if (retval != STATUS_SUCCESS) {
2319                         vfree(buf);
2320                         rtsx_trace(chip);
2321                         return TRANSPORT_ERROR;
2322                 }
2323
2324                 wait_timeout(600);
2325
2326                 retval = rtsx_write_phy_register(chip, 0x08,
2327                                                  0x4C00 | chip->phy_voltage);
2328                 if (retval != STATUS_SUCCESS) {
2329                         vfree(buf);
2330                         rtsx_trace(chip);
2331                         return TRANSPORT_ERROR;
2332                 }
2333
2334                 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2335                                              LDO3318_PWR_MASK, LDO_ON);
2336                 if (retval != STATUS_SUCCESS) {
2337                         vfree(buf);
2338                         rtsx_trace(chip);
2339                         return TRANSPORT_ERROR;
2340                 }
2341
2342                 wait_timeout(600);
2343         }
2344
2345         retval = card_power_on(chip, SPI_CARD);
2346         if (retval != STATUS_SUCCESS) {
2347                 vfree(buf);
2348                 rtsx_trace(chip);
2349                 return TRANSPORT_ERROR;
2350         }
2351
2352         wait_timeout(50);
2353
2354         for (i = 0; i < len; i++) {
2355                 retval = rtsx_write_efuse(chip, addr + i, buf[i]);
2356                 if (retval != STATUS_SUCCESS) {
2357                         set_sense_type(chip, SCSI_LUN(srb),
2358                                        SENSE_TYPE_MEDIA_WRITE_ERR);
2359                         result = TRANSPORT_FAILED;
2360                         rtsx_trace(chip);
2361                         goto exit;
2362                 }
2363         }
2364
2365 exit:
2366         vfree(buf);
2367
2368         retval = card_power_off(chip, SPI_CARD);
2369         if (retval != STATUS_SUCCESS) {
2370                 rtsx_trace(chip);
2371                 return TRANSPORT_ERROR;
2372         }
2373
2374         if (chip->asic_code) {
2375                 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2376                                              LDO3318_PWR_MASK, LDO_OFF);
2377                 if (retval != STATUS_SUCCESS) {
2378                         rtsx_trace(chip);
2379                         return TRANSPORT_ERROR;
2380                 }
2381
2382                 wait_timeout(600);
2383
2384                 retval = rtsx_write_phy_register(chip, 0x08, val);
2385                 if (retval != STATUS_SUCCESS) {
2386                         rtsx_trace(chip);
2387                         return TRANSPORT_ERROR;
2388                 }
2389
2390                 retval = rtsx_write_register(chip, PWR_GATE_CTRL,
2391                                              LDO3318_PWR_MASK, LDO_ON);
2392                 if (retval != STATUS_SUCCESS) {
2393                         rtsx_trace(chip);
2394                         return TRANSPORT_ERROR;
2395                 }
2396         }
2397
2398         return result;
2399 }
2400
2401 static int read_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2402 {
2403         int retval;
2404         bool func_max;
2405         u8 func;
2406         u16 addr, len;
2407         u8 *buf;
2408
2409         rtsx_disable_aspm(chip);
2410
2411         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2412                 rtsx_exit_ss(chip);
2413                 wait_timeout(100);
2414         }
2415         rtsx_set_stat(chip, RTSX_STAT_RUN);
2416
2417         func = srb->cmnd[3];
2418         addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2419         len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2420
2421         dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x, len = %d\n",
2422                 __func__, func, addr, len);
2423
2424         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2425                 func_max = true;
2426         else
2427                 func_max = false;
2428
2429         if (func > func_max) {
2430                 set_sense_type(chip, SCSI_LUN(srb),
2431                                SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2432                 rtsx_trace(chip);
2433                 return TRANSPORT_FAILED;
2434         }
2435
2436         buf = vmalloc(len);
2437         if (!buf) {
2438                 rtsx_trace(chip);
2439                 return TRANSPORT_ERROR;
2440         }
2441
2442         retval = rtsx_read_cfg_seq(chip, func, addr, buf, len);
2443         if (retval != STATUS_SUCCESS) {
2444                 set_sense_type(chip, SCSI_LUN(srb),
2445                                SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2446                 vfree(buf);
2447                 rtsx_trace(chip);
2448                 return TRANSPORT_FAILED;
2449         }
2450
2451         len = (u16)min_t(unsigned int, scsi_bufflen(srb), len);
2452         rtsx_stor_set_xfer_buf(buf, len, srb);
2453         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2454
2455         vfree(buf);
2456
2457         return TRANSPORT_GOOD;
2458 }
2459
2460 static int write_cfg_byte(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2461 {
2462         int retval;
2463         bool func_max;
2464         u8 func;
2465         u16 addr, len;
2466         u8 *buf;
2467
2468         rtsx_disable_aspm(chip);
2469
2470         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2471                 rtsx_exit_ss(chip);
2472                 wait_timeout(100);
2473         }
2474         rtsx_set_stat(chip, RTSX_STAT_RUN);
2475
2476         func = srb->cmnd[3];
2477         addr = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
2478         len = ((u16)(srb->cmnd[6]) << 8) | srb->cmnd[7];
2479
2480         dev_dbg(rtsx_dev(chip), "%s: func = %d, addr = 0x%x\n",
2481                 __func__, func, addr);
2482
2483         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2484                 func_max = true;
2485         else
2486                 func_max = false;
2487
2488         if (func > func_max) {
2489                 set_sense_type(chip, SCSI_LUN(srb),
2490                                SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2491                 rtsx_trace(chip);
2492                 return TRANSPORT_FAILED;
2493         }
2494
2495         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
2496         buf = vmalloc(len);
2497         if (!buf) {
2498                 rtsx_trace(chip);
2499                 return TRANSPORT_ERROR;
2500         }
2501
2502         rtsx_stor_get_xfer_buf(buf, len, srb);
2503         scsi_set_resid(srb, scsi_bufflen(srb) - len);
2504
2505         retval = rtsx_write_cfg_seq(chip, func, addr, buf, len);
2506         if (retval != STATUS_SUCCESS) {
2507                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
2508                 vfree(buf);
2509                 rtsx_trace(chip);
2510                 return TRANSPORT_FAILED;
2511         }
2512
2513         vfree(buf);
2514
2515         return TRANSPORT_GOOD;
2516 }
2517
2518 static int app_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2519 {
2520         int result;
2521
2522         switch (srb->cmnd[2]) {
2523         case PP_READ10:
2524         case PP_WRITE10:
2525                 result = read_write(srb, chip);
2526                 break;
2527
2528         case READ_HOST_REG:
2529                 result = read_host_reg(srb, chip);
2530                 break;
2531
2532         case WRITE_HOST_REG:
2533                 result = write_host_reg(srb, chip);
2534                 break;
2535
2536         case GET_VAR:
2537                 result = get_variable(srb, chip);
2538                 break;
2539
2540         case SET_VAR:
2541                 result = set_variable(srb, chip);
2542                 break;
2543
2544         case DMA_READ:
2545         case DMA_WRITE:
2546                 result = dma_access_ring_buffer(srb, chip);
2547                 break;
2548
2549         case READ_PHY:
2550                 result = read_phy_register(srb, chip);
2551                 break;
2552
2553         case WRITE_PHY:
2554                 result = write_phy_register(srb, chip);
2555                 break;
2556
2557         case ERASE_EEPROM2:
2558                 result = erase_eeprom2(srb, chip);
2559                 break;
2560
2561         case READ_EEPROM2:
2562                 result = read_eeprom2(srb, chip);
2563                 break;
2564
2565         case WRITE_EEPROM2:
2566                 result = write_eeprom2(srb, chip);
2567                 break;
2568
2569         case READ_EFUSE:
2570                 result = read_efuse(srb, chip);
2571                 break;
2572
2573         case WRITE_EFUSE:
2574                 result = write_efuse(srb, chip);
2575                 break;
2576
2577         case READ_CFG:
2578                 result = read_cfg_byte(srb, chip);
2579                 break;
2580
2581         case WRITE_CFG:
2582                 result = write_cfg_byte(srb, chip);
2583                 break;
2584
2585         case SET_CHIP_MODE:
2586                 result = set_chip_mode(srb, chip);
2587                 break;
2588
2589         case SUIT_CMD:
2590                 result = suit_cmd(srb, chip);
2591                 break;
2592
2593         case GET_DEV_STATUS:
2594                 result = get_dev_status(srb, chip);
2595                 break;
2596
2597         default:
2598                 set_sense_type(chip, SCSI_LUN(srb),
2599                                SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2600                 rtsx_trace(chip);
2601                 return TRANSPORT_FAILED;
2602         }
2603
2604         return result;
2605 }
2606
2607 static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2608 {
2609         u8 rtsx_status[16];
2610         int buf_len;
2611         unsigned int lun = SCSI_LUN(srb);
2612
2613         rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2614         rtsx_status[1] = (u8)(chip->vendor_id);
2615
2616         rtsx_status[2] = (u8)(chip->product_id >> 8);
2617         rtsx_status[3] = (u8)(chip->product_id);
2618
2619         rtsx_status[4] = (u8)lun;
2620
2621         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2622                 if (chip->lun2card[lun] == SD_CARD)
2623                         rtsx_status[5] = 2;
2624                 else
2625                         rtsx_status[5] = 3;
2626         } else {
2627                 if (chip->card_exist) {
2628                         if (chip->card_exist & XD_CARD)
2629                                 rtsx_status[5] = 4;
2630                         else if (chip->card_exist & SD_CARD)
2631                                 rtsx_status[5] = 2;
2632                         else if (chip->card_exist & MS_CARD)
2633                                 rtsx_status[5] = 3;
2634                         else
2635                                 rtsx_status[5] = 7;
2636                 } else {
2637                         rtsx_status[5] = 7;
2638                 }
2639         }
2640
2641         if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2642                 rtsx_status[6] = 2;
2643         else
2644                 rtsx_status[6] = 1;
2645
2646         rtsx_status[7] = (u8)(chip->product_id);
2647         rtsx_status[8] = chip->ic_version;
2648
2649         if (check_card_exist(chip, lun))
2650                 rtsx_status[9] = 1;
2651         else
2652                 rtsx_status[9] = 0;
2653
2654         if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2655                 rtsx_status[10] = 0;
2656         else
2657                 rtsx_status[10] = 1;
2658
2659         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2660                 if (chip->lun2card[lun] == SD_CARD)
2661                         rtsx_status[11] = SD_CARD;
2662                 else
2663                         rtsx_status[11] = MS_CARD;
2664         } else {
2665                 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2666         }
2667
2668         if (check_card_ready(chip, lun))
2669                 rtsx_status[12] = 1;
2670         else
2671                 rtsx_status[12] = 0;
2672
2673         if (get_lun_card(chip, lun) == XD_CARD) {
2674                 rtsx_status[13] = 0x40;
2675         } else if (get_lun_card(chip, lun) == SD_CARD) {
2676                 struct sd_info *sd_card = &chip->sd_card;
2677
2678                 rtsx_status[13] = 0x20;
2679                 if (CHK_SD(sd_card)) {
2680                         if (CHK_SD_HCXC(sd_card))
2681                                 rtsx_status[13] |= 0x04;
2682                         if (CHK_SD_HS(sd_card))
2683                                 rtsx_status[13] |= 0x02;
2684                 } else {
2685                         rtsx_status[13] |= 0x08;
2686                         if (CHK_MMC_52M(sd_card))
2687                                 rtsx_status[13] |= 0x02;
2688                         if (CHK_MMC_SECTOR_MODE(sd_card))
2689                                 rtsx_status[13] |= 0x04;
2690                 }
2691         } else if (get_lun_card(chip, lun) == MS_CARD) {
2692                 struct ms_info *ms_card = &chip->ms_card;
2693
2694                 if (CHK_MSPRO(ms_card)) {
2695                         rtsx_status[13] = 0x38;
2696                         if (CHK_HG8BIT(ms_card))
2697                                 rtsx_status[13] |= 0x04;
2698 #ifdef SUPPORT_MSXC
2699                         if (CHK_MSXC(ms_card))
2700                                 rtsx_status[13] |= 0x01;
2701 #endif
2702                 } else {
2703                         rtsx_status[13] = 0x30;
2704                 }
2705         } else {
2706                 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2707 #ifdef SUPPORT_SDIO
2708                         if (chip->sd_io && chip->sd_int)
2709                                 rtsx_status[13] = 0x60;
2710                         else
2711                                 rtsx_status[13] = 0x70;
2712 #else
2713                         rtsx_status[13] = 0x70;
2714 #endif
2715                 } else {
2716                         if (chip->lun2card[lun] == SD_CARD)
2717                                 rtsx_status[13] = 0x20;
2718                         else
2719                                 rtsx_status[13] = 0x30;
2720                 }
2721         }
2722
2723         rtsx_status[14] = 0x78;
2724         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2725                 rtsx_status[15] = 0x83;
2726         else
2727                 rtsx_status[15] = 0x82;
2728
2729         buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status));
2730         rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb);
2731         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
2732
2733         return TRANSPORT_GOOD;
2734 }
2735
2736 static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2737 {
2738         unsigned int lun = SCSI_LUN(srb);
2739         u8 card, bus_width;
2740
2741         if (!check_card_ready(chip, lun)) {
2742                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2743                 rtsx_trace(chip);
2744                 return TRANSPORT_FAILED;
2745         }
2746
2747         card = get_lun_card(chip, lun);
2748         if ((card == SD_CARD) || (card == MS_CARD)) {
2749                 bus_width = chip->card_bus_width[lun];
2750         } else {
2751                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2752                 rtsx_trace(chip);
2753                 return TRANSPORT_FAILED;
2754         }
2755
2756         scsi_set_resid(srb, 0);
2757         rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2758
2759         return TRANSPORT_GOOD;
2760 }
2761
2762 static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2763 {
2764         int result;
2765         unsigned int lun = SCSI_LUN(srb);
2766         u8 gpio_dir;
2767
2768         if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) {
2769                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2770                 rtsx_trace(chip);
2771                 return TRANSPORT_FAILED;
2772         }
2773
2774         rtsx_disable_aspm(chip);
2775
2776         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2777                 rtsx_exit_ss(chip);
2778                 wait_timeout(100);
2779         }
2780         rtsx_set_stat(chip, RTSX_STAT_RUN);
2781
2782         rtsx_force_power_on(chip, SSC_PDCTL);
2783
2784         rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2785         rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2786
2787         switch (srb->cmnd[2]) {
2788         case SCSI_SPI_GETSTATUS:
2789                 result = spi_get_status(srb, chip);
2790                 break;
2791
2792         case SCSI_SPI_SETPARAMETER:
2793                 result = spi_set_parameter(srb, chip);
2794                 break;
2795
2796         case SCSI_SPI_READFALSHID:
2797                 result = spi_read_flash_id(srb, chip);
2798                 break;
2799
2800         case SCSI_SPI_READFLASH:
2801                 result = spi_read_flash(srb, chip);
2802                 break;
2803
2804         case SCSI_SPI_WRITEFLASH:
2805                 result = spi_write_flash(srb, chip);
2806                 break;
2807
2808         case SCSI_SPI_WRITEFLASHSTATUS:
2809                 result = spi_write_flash_status(srb, chip);
2810                 break;
2811
2812         case SCSI_SPI_ERASEFLASH:
2813                 result = spi_erase_flash(srb, chip);
2814                 break;
2815
2816         default:
2817                 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2818
2819                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2820                 rtsx_trace(chip);
2821                 return TRANSPORT_FAILED;
2822         }
2823
2824         rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2825
2826         if (result != STATUS_SUCCESS) {
2827                 rtsx_trace(chip);
2828                 return TRANSPORT_FAILED;
2829         }
2830
2831         return TRANSPORT_GOOD;
2832 }
2833
2834 static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2835 {
2836         int result;
2837
2838         switch (srb->cmnd[1]) {
2839         case READ_STATUS:
2840                 result = read_status(srb, chip);
2841                 break;
2842
2843         case READ_MEM:
2844                 result = read_mem(srb, chip);
2845                 break;
2846
2847         case WRITE_MEM:
2848                 result = write_mem(srb, chip);
2849                 break;
2850
2851         case READ_EEPROM:
2852                 result = read_eeprom(srb, chip);
2853                 break;
2854
2855         case WRITE_EEPROM:
2856                 result = write_eeprom(srb, chip);
2857                 break;
2858
2859         case TOGGLE_GPIO:
2860                 result = toggle_gpio_cmd(srb, chip);
2861                 break;
2862
2863         case GET_SD_CSD:
2864                 result = get_sd_csd(srb, chip);
2865                 break;
2866
2867         case GET_BUS_WIDTH:
2868                 result = get_card_bus_width(srb, chip);
2869                 break;
2870
2871 #ifdef _MSG_TRACE
2872         case TRACE_MSG:
2873                 result = trace_msg_cmd(srb, chip);
2874                 break;
2875 #endif
2876
2877         case SCSI_APP_CMD:
2878                 result = app_cmd(srb, chip);
2879                 break;
2880
2881         case SPI_VENDOR_COMMAND:
2882                 result = spi_vendor_cmd(srb, chip);
2883                 break;
2884
2885         default:
2886                 set_sense_type(chip, SCSI_LUN(srb),
2887                                SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2888                 rtsx_trace(chip);
2889                 return TRANSPORT_FAILED;
2890         }
2891
2892         return result;
2893 }
2894
2895 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2896 void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2897 {
2898         unsigned int lun = SCSI_LUN(srb);
2899         u16 sec_cnt;
2900
2901         if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
2902                 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2903         } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
2904                 sec_cnt = srb->cmnd[4];
2905                 if (sec_cnt == 0)
2906                         sec_cnt = 256;
2907         } else {
2908                 return;
2909         }
2910
2911         if (chip->rw_cap[lun] >= GPIO_TOGGLE_THRESHOLD) {
2912                 toggle_gpio(chip, LED_GPIO);
2913                 chip->rw_cap[lun] = 0;
2914         } else {
2915                 chip->rw_cap[lun] += sec_cnt;
2916         }
2917 }
2918 #endif
2919
2920 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2921 {
2922         struct ms_info *ms_card = &chip->ms_card;
2923         unsigned int lun = SCSI_LUN(srb);
2924         bool quick_format;
2925         int retval;
2926
2927         if (get_lun_card(chip, lun) != MS_CARD) {
2928                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2929                 rtsx_trace(chip);
2930                 return TRANSPORT_FAILED;
2931         }
2932
2933         if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47) ||
2934             (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D) ||
2935                 (srb->cmnd[7] != 0x74)) {
2936                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2937                 rtsx_trace(chip);
2938                 return TRANSPORT_FAILED;
2939         }
2940
2941         rtsx_disable_aspm(chip);
2942
2943         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2944                 rtsx_exit_ss(chip);
2945                 wait_timeout(100);
2946
2947                 if (!check_card_ready(chip, lun) ||
2948                     (get_card_size(chip, lun) == 0)) {
2949                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2950                         rtsx_trace(chip);
2951                         return TRANSPORT_FAILED;
2952                 }
2953         }
2954         rtsx_set_stat(chip, RTSX_STAT_RUN);
2955
2956         if (srb->cmnd[8] & 0x01)
2957                 quick_format = false;
2958         else
2959                 quick_format = true;
2960
2961         if (!(chip->card_ready & MS_CARD)) {
2962                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2963                 rtsx_trace(chip);
2964                 return TRANSPORT_FAILED;
2965         }
2966
2967         if (chip->card_wp & MS_CARD) {
2968                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
2969                 rtsx_trace(chip);
2970                 return TRANSPORT_FAILED;
2971         }
2972
2973         if (!CHK_MSPRO(ms_card)) {
2974                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
2975                 rtsx_trace(chip);
2976                 return TRANSPORT_FAILED;
2977         }
2978
2979         retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
2980         if (retval != STATUS_SUCCESS) {
2981                 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
2982                 rtsx_trace(chip);
2983                 return TRANSPORT_FAILED;
2984         }
2985
2986         scsi_set_resid(srb, 0);
2987         return TRANSPORT_GOOD;
2988 }
2989
2990 #ifdef SUPPORT_PCGL_1P18
2991 static int get_ms_information(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2992 {
2993         struct ms_info *ms_card = &chip->ms_card;
2994         unsigned int lun = SCSI_LUN(srb);
2995         u8 dev_info_id, data_len;
2996         u8 *buf;
2997         unsigned int buf_len;
2998         int i;
2999
3000         if (!check_card_ready(chip, lun)) {
3001                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3002                 rtsx_trace(chip);
3003                 return TRANSPORT_FAILED;
3004         }
3005         if (get_lun_card(chip, lun) != MS_CARD) {
3006                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3007                 rtsx_trace(chip);
3008                 return TRANSPORT_FAILED;
3009         }
3010
3011         if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
3012             (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
3013             (srb->cmnd[7] != 0x44)) {
3014                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3015                 rtsx_trace(chip);
3016                 return TRANSPORT_FAILED;
3017         }
3018
3019         dev_info_id = srb->cmnd[3];
3020         if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
3021             (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
3022             !CHK_MSPRO(ms_card)) {
3023                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3024                 rtsx_trace(chip);
3025                 return TRANSPORT_FAILED;
3026         }
3027
3028         if (dev_info_id == 0x15) {
3029                 buf_len = 0x3A;
3030                 data_len = 0x3A;
3031         } else {
3032                 buf_len = 0x6A;
3033                 data_len = 0x6A;
3034         }
3035
3036         buf = kmalloc(buf_len, GFP_KERNEL);
3037         if (!buf) {
3038                 rtsx_trace(chip);
3039                 return TRANSPORT_ERROR;
3040         }
3041
3042         i = 0;
3043         /*  GET Memory Stick Media Information Response Header */
3044         buf[i++] = 0x00;                /* Data length MSB */
3045         buf[i++] = data_len;            /* Data length LSB */
3046         /* Device Information Type Code */
3047         if (CHK_MSXC(ms_card))
3048                 buf[i++] = 0x03;
3049         else
3050                 buf[i++] = 0x02;
3051
3052         /* SGM bit */
3053         buf[i++] = 0x01;
3054         /* Reserved */
3055         buf[i++] = 0x00;
3056         buf[i++] = 0x00;
3057         buf[i++] = 0x00;
3058         /* Number of Device Information */
3059         buf[i++] = 0x01;
3060
3061         /*  Device Information Body */
3062
3063         /* Device Information ID Number */
3064         buf[i++] = dev_info_id;
3065         /* Device Information Length */
3066         if (dev_info_id == 0x15)
3067                 data_len = 0x31;
3068         else
3069                 data_len = 0x61;
3070
3071         buf[i++] = 0x00;                /* Data length MSB */
3072         buf[i++] = data_len;            /* Data length LSB */
3073         /* Valid Bit */
3074         buf[i++] = 0x80;
3075         if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
3076                 /* System Information */
3077                 memcpy(buf + i, ms_card->raw_sys_info, 96);
3078         } else {
3079                 /* Model Name */
3080                 memcpy(buf + i, ms_card->raw_model_name, 48);
3081         }
3082
3083         rtsx_stor_set_xfer_buf(buf, buf_len, srb);
3084
3085         if (dev_info_id == 0x15)
3086                 scsi_set_resid(srb, scsi_bufflen(srb) - 0x3C);
3087         else
3088                 scsi_set_resid(srb, scsi_bufflen(srb) - 0x6C);
3089
3090         kfree(buf);
3091         return STATUS_SUCCESS;
3092 }
3093 #endif
3094
3095 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3096 {
3097         int retval = TRANSPORT_ERROR;
3098
3099         if (srb->cmnd[2] == MS_FORMAT)
3100                 retval = ms_format_cmnd(srb, chip);
3101 #ifdef SUPPORT_PCGL_1P18
3102         else if (srb->cmnd[2] == GET_MS_INFORMATION)
3103                 retval = get_ms_information(srb, chip);
3104 #endif
3105
3106         return retval;
3107 }
3108
3109 #ifdef SUPPORT_CPRM
3110 static int sd_extension_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3111 {
3112         unsigned int lun = SCSI_LUN(srb);
3113         int result;
3114
3115         rtsx_disable_aspm(chip);
3116
3117         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3118                 rtsx_exit_ss(chip);
3119                 wait_timeout(100);
3120         }
3121         rtsx_set_stat(chip, RTSX_STAT_RUN);
3122
3123         sd_cleanup_work(chip);
3124
3125         if (!check_card_ready(chip, lun)) {
3126                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3127                 rtsx_trace(chip);
3128                 return TRANSPORT_FAILED;
3129         }
3130         if (get_lun_card(chip, lun) != SD_CARD) {
3131                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3132                 rtsx_trace(chip);
3133                 return TRANSPORT_FAILED;
3134         }
3135
3136         switch (srb->cmnd[0]) {
3137         case SD_PASS_THRU_MODE:
3138                 result = sd_pass_thru_mode(srb, chip);
3139                 break;
3140
3141         case SD_EXECUTE_NO_DATA:
3142                 result = sd_execute_no_data(srb, chip);
3143                 break;
3144
3145         case SD_EXECUTE_READ:
3146                 result = sd_execute_read_data(srb, chip);
3147                 break;
3148
3149         case SD_EXECUTE_WRITE:
3150                 result = sd_execute_write_data(srb, chip);
3151                 break;
3152
3153         case SD_GET_RSP:
3154                 result = sd_get_cmd_rsp(srb, chip);
3155                 break;
3156
3157         case SD_HW_RST:
3158                 result = sd_hw_rst(srb, chip);
3159                 break;
3160
3161         default:
3162                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3163                 rtsx_trace(chip);
3164                 return TRANSPORT_FAILED;
3165         }
3166
3167         return result;
3168 }
3169 #endif
3170
3171 #ifdef SUPPORT_MAGIC_GATE
3172 static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3173 {
3174         struct ms_info *ms_card = &chip->ms_card;
3175         unsigned int lun = SCSI_LUN(srb);
3176         int retval;
3177         u8 key_format;
3178
3179         rtsx_disable_aspm(chip);
3180
3181         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3182                 rtsx_exit_ss(chip);
3183                 wait_timeout(100);
3184         }
3185         rtsx_set_stat(chip, RTSX_STAT_RUN);
3186
3187         ms_cleanup_work(chip);
3188
3189         if (!check_card_ready(chip, lun)) {
3190                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3191                 rtsx_trace(chip);
3192                 return TRANSPORT_FAILED;
3193         }
3194         if (get_lun_card(chip, lun) != MS_CARD) {
3195                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3196                 rtsx_trace(chip);
3197                 return TRANSPORT_FAILED;
3198         }
3199
3200         if (srb->cmnd[7] != KC_MG_R_PRO) {
3201                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3202                 rtsx_trace(chip);
3203                 return TRANSPORT_FAILED;
3204         }
3205
3206         if (!CHK_MSPRO(ms_card)) {
3207                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3208                 rtsx_trace(chip);
3209                 return TRANSPORT_FAILED;
3210         }
3211
3212         key_format = srb->cmnd[10] & 0x3F;
3213         dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3214
3215         switch (key_format) {
3216         case KF_GET_LOC_EKB:
3217                 if ((scsi_bufflen(srb) == 0x41C) &&
3218                     (srb->cmnd[8] == 0x04) &&
3219                     (srb->cmnd[9] == 0x1C)) {
3220                         retval = mg_get_local_EKB(srb, chip);
3221                         if (retval != STATUS_SUCCESS) {
3222                                 rtsx_trace(chip);
3223                                 return TRANSPORT_FAILED;
3224                         }
3225
3226                 } else {
3227                         set_sense_type(chip, lun,
3228                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3229                         rtsx_trace(chip);
3230                         return TRANSPORT_FAILED;
3231                 }
3232                 break;
3233
3234         case KF_RSP_CHG:
3235                 if ((scsi_bufflen(srb) == 0x24) &&
3236                     (srb->cmnd[8] == 0x00) &&
3237                     (srb->cmnd[9] == 0x24)) {
3238                         retval = mg_get_rsp_chg(srb, chip);
3239                         if (retval != STATUS_SUCCESS) {
3240                                 rtsx_trace(chip);
3241                                 return TRANSPORT_FAILED;
3242                         }
3243
3244                 } else {
3245                         set_sense_type(chip, lun,
3246                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3247                         rtsx_trace(chip);
3248                         return TRANSPORT_FAILED;
3249                 }
3250                 break;
3251
3252         case KF_GET_ICV:
3253                 ms_card->mg_entry_num = srb->cmnd[5];
3254                 if ((scsi_bufflen(srb) == 0x404) &&
3255                     (srb->cmnd[8] == 0x04) &&
3256                     (srb->cmnd[9] == 0x04) &&
3257                     (srb->cmnd[2] == 0x00) &&
3258                     (srb->cmnd[3] == 0x00) &&
3259                     (srb->cmnd[4] == 0x00) &&
3260                     (srb->cmnd[5] < 32)) {
3261                         retval = mg_get_ICV(srb, chip);
3262                         if (retval != STATUS_SUCCESS) {
3263                                 rtsx_trace(chip);
3264                                 return TRANSPORT_FAILED;
3265                         }
3266
3267                 } else {
3268                         set_sense_type(chip, lun,
3269                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3270                         rtsx_trace(chip);
3271                         return TRANSPORT_FAILED;
3272                 }
3273                 break;
3274
3275         default:
3276                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3277                 rtsx_trace(chip);
3278                 return TRANSPORT_FAILED;
3279         }
3280
3281         scsi_set_resid(srb, 0);
3282         return TRANSPORT_GOOD;
3283 }
3284
3285 static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3286 {
3287         struct ms_info *ms_card = &chip->ms_card;
3288         unsigned int lun = SCSI_LUN(srb);
3289         int retval;
3290         u8 key_format;
3291
3292         rtsx_disable_aspm(chip);
3293
3294         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3295                 rtsx_exit_ss(chip);
3296                 wait_timeout(100);
3297         }
3298         rtsx_set_stat(chip, RTSX_STAT_RUN);
3299
3300         ms_cleanup_work(chip);
3301
3302         if (!check_card_ready(chip, lun)) {
3303                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3304                 rtsx_trace(chip);
3305                 return TRANSPORT_FAILED;
3306         }
3307         if (check_card_wp(chip, lun)) {
3308                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
3309                 rtsx_trace(chip);
3310                 return TRANSPORT_FAILED;
3311         }
3312         if (get_lun_card(chip, lun) != MS_CARD) {
3313                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3314                 rtsx_trace(chip);
3315                 return TRANSPORT_FAILED;
3316         }
3317
3318         if (srb->cmnd[7] != KC_MG_R_PRO) {
3319                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3320                 rtsx_trace(chip);
3321                 return TRANSPORT_FAILED;
3322         }
3323
3324         if (!CHK_MSPRO(ms_card)) {
3325                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3326                 rtsx_trace(chip);
3327                 return TRANSPORT_FAILED;
3328         }
3329
3330         key_format = srb->cmnd[10] & 0x3F;
3331         dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3332
3333         switch (key_format) {
3334         case KF_SET_LEAF_ID:
3335                 if ((scsi_bufflen(srb) == 0x0C) &&
3336                     (srb->cmnd[8] == 0x00) &&
3337                     (srb->cmnd[9] == 0x0C)) {
3338                         retval = mg_set_leaf_id(srb, chip);
3339                         if (retval != STATUS_SUCCESS) {
3340                                 rtsx_trace(chip);
3341                                 return TRANSPORT_FAILED;
3342                         }
3343
3344                 } else {
3345                         set_sense_type(chip, lun,
3346                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3347                         rtsx_trace(chip);
3348                         return TRANSPORT_FAILED;
3349                 }
3350                 break;
3351
3352         case KF_CHG_HOST:
3353                 if ((scsi_bufflen(srb) == 0x0C) &&
3354                     (srb->cmnd[8] == 0x00) &&
3355                     (srb->cmnd[9] == 0x0C)) {
3356                         retval = mg_chg(srb, chip);
3357                         if (retval != STATUS_SUCCESS) {
3358                                 rtsx_trace(chip);
3359                                 return TRANSPORT_FAILED;
3360                         }
3361
3362                 } else {
3363                         set_sense_type(chip, lun,
3364                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3365                         rtsx_trace(chip);
3366                         return TRANSPORT_FAILED;
3367                 }
3368                 break;
3369
3370         case KF_RSP_HOST:
3371                 if ((scsi_bufflen(srb) == 0x0C) &&
3372                     (srb->cmnd[8] == 0x00) &&
3373                     (srb->cmnd[9] == 0x0C)) {
3374                         retval = mg_rsp(srb, chip);
3375                         if (retval != STATUS_SUCCESS) {
3376                                 rtsx_trace(chip);
3377                                 return TRANSPORT_FAILED;
3378                         }
3379
3380                 } else {
3381                         set_sense_type(chip, lun,
3382                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3383                         rtsx_trace(chip);
3384                         return TRANSPORT_FAILED;
3385                 }
3386                 break;
3387
3388         case KF_SET_ICV:
3389                 ms_card->mg_entry_num = srb->cmnd[5];
3390                 if ((scsi_bufflen(srb) == 0x404) &&
3391                     (srb->cmnd[8] == 0x04) &&
3392                     (srb->cmnd[9] == 0x04) &&
3393                     (srb->cmnd[2] == 0x00) &&
3394                     (srb->cmnd[3] == 0x00) &&
3395                     (srb->cmnd[4] == 0x00) &&
3396                     (srb->cmnd[5] < 32)) {
3397                         retval = mg_set_ICV(srb, chip);
3398                         if (retval != STATUS_SUCCESS) {
3399                                 rtsx_trace(chip);
3400                                 return TRANSPORT_FAILED;
3401                         }
3402
3403                 } else {
3404                         set_sense_type(chip, lun,
3405                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3406                         rtsx_trace(chip);
3407                         return TRANSPORT_FAILED;
3408                 }
3409                 break;
3410
3411         default:
3412                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3413                 rtsx_trace(chip);
3414                 return TRANSPORT_FAILED;
3415         }
3416
3417         scsi_set_resid(srb, 0);
3418         return TRANSPORT_GOOD;
3419 }
3420 #endif
3421
3422 int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3423 {
3424 #ifdef SUPPORT_SD_LOCK
3425         struct sd_info *sd_card = &chip->sd_card;
3426 #endif
3427         struct ms_info *ms_card = &chip->ms_card;
3428         unsigned int lun = SCSI_LUN(srb);
3429         int result;
3430
3431 #ifdef SUPPORT_SD_LOCK
3432         if (sd_card->sd_erase_status) {
3433                 /* Block all SCSI command except for
3434                  * REQUEST_SENSE and rs_ppstatus
3435                  */
3436                 if (!((srb->cmnd[0] == VENDOR_CMND) &&
3437                       (srb->cmnd[1] == SCSI_APP_CMD) &&
3438                       (srb->cmnd[2] == GET_DEV_STATUS)) &&
3439                       (srb->cmnd[0] != REQUEST_SENSE)) {
3440                         /* Logical Unit Not Ready Format in Progress */
3441                         set_sense_data(chip, lun, CUR_ERR,
3442                                        0x02, 0, 0x04, 0x04, 0, 0);
3443                         rtsx_trace(chip);
3444                         return TRANSPORT_FAILED;
3445                 }
3446         }
3447 #endif
3448
3449         if ((get_lun_card(chip, lun) == MS_CARD) &&
3450             (ms_card->format_status == FORMAT_IN_PROGRESS)) {
3451                 if ((srb->cmnd[0] != REQUEST_SENSE) &&
3452                     (srb->cmnd[0] != INQUIRY)) {
3453                         /* Logical Unit Not Ready Format in Progress */
3454                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
3455                                        0, (u16)(ms_card->progress));
3456                         rtsx_trace(chip);
3457                         return TRANSPORT_FAILED;
3458                 }
3459         }
3460
3461         switch (srb->cmnd[0]) {
3462         case READ_10:
3463         case WRITE_10:
3464         case READ_6:
3465         case WRITE_6:
3466                 result = read_write(srb, chip);
3467 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3468                 led_shine(srb, chip);
3469 #endif
3470                 break;
3471
3472         case TEST_UNIT_READY:
3473                 result = test_unit_ready(srb, chip);
3474                 break;
3475
3476         case INQUIRY:
3477                 result = inquiry(srb, chip);
3478                 break;
3479
3480         case READ_CAPACITY:
3481                 result = read_capacity(srb, chip);
3482                 break;
3483
3484         case START_STOP:
3485                 result = start_stop_unit(srb, chip);
3486                 break;
3487
3488         case ALLOW_MEDIUM_REMOVAL:
3489                 result = allow_medium_removal(srb, chip);
3490                 break;
3491
3492         case REQUEST_SENSE:
3493                 result = request_sense(srb, chip);
3494                 break;
3495
3496         case MODE_SENSE:
3497         case MODE_SENSE_10:
3498                 result = mode_sense(srb, chip);
3499                 break;
3500
3501         case 0x23:
3502                 result = read_format_capacity(srb, chip);
3503                 break;
3504
3505         case VENDOR_CMND:
3506                 result = vendor_cmnd(srb, chip);
3507                 break;
3508
3509         case MS_SP_CMND:
3510                 result = ms_sp_cmnd(srb, chip);
3511                 break;
3512
3513 #ifdef SUPPORT_CPRM
3514         case SD_PASS_THRU_MODE:
3515         case SD_EXECUTE_NO_DATA:
3516         case SD_EXECUTE_READ:
3517         case SD_EXECUTE_WRITE:
3518         case SD_GET_RSP:
3519         case SD_HW_RST:
3520                 result = sd_extension_cmnd(srb, chip);
3521                 break;
3522 #endif
3523
3524 #ifdef SUPPORT_MAGIC_GATE
3525         case CMD_MSPRO_MG_RKEY:
3526                 result = mg_report_key(srb, chip);
3527                 break;
3528
3529         case CMD_MSPRO_MG_SKEY:
3530                 result = mg_send_key(srb, chip);
3531                 break;
3532 #endif
3533
3534         case FORMAT_UNIT:
3535         case MODE_SELECT:
3536         case VERIFY:
3537                 result = TRANSPORT_GOOD;
3538                 break;
3539
3540         default:
3541                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3542                 result = TRANSPORT_FAILED;
3543         }
3544
3545         return result;
3546 }