drivers/staging/rts5208/rtsx_scsi.c

   1 /* Driver for Realtek PCI-Express card reader
   2  *
   3  * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2, or (at your option) any
   8  * later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, see <http://www.gnu.org/licenses/>.
  17  *
  18  * Author:
  19  *   Wei WANG (wei_wang@realsil.com.cn)
  20  *   Micky Ching (micky_ching@realsil.com.cn)
  21  */
  22
  23 #include <linux/blkdev.h>
  24 #include <linux/kthread.h>
  25 #include <linux/sched.h>
  26 #include <linux/vmalloc.h>
  27
  28 #include "rtsx.h"
  29 #include "sd.h"
  30 #include "ms.h"
  31 #include "spi.h"
  32
  33 void scsi_show_command(struct rtsx_chip *chip)
  34 {
  35         struct scsi_cmnd *srb = chip->srb;
  36         char *what = NULL;
  37         bool unknown_cmd = false;
  38         int len;
  39
  40         switch (srb->cmnd[0]) {
  41         case TEST_UNIT_READY:
  42                 what = "TEST_UNIT_READY";
  43                 break;
  44         case REZERO_UNIT:
  45                 what = "REZERO_UNIT";
  46                 break;
  47         case REQUEST_SENSE:
  48                 what = "REQUEST_SENSE";
  49                 break;
  50         case FORMAT_UNIT:
  51                 what = "FORMAT_UNIT";
  52                 break;
  53         case READ_BLOCK_LIMITS:
  54                 what = "READ_BLOCK_LIMITS";
  55                 break;
  56         case REASSIGN_BLOCKS:
  57                 what = "REASSIGN_BLOCKS";
  58                 break;
  59         case READ_6:
  60                 what = "READ_6";
  61                 break;
  62         case WRITE_6:
  63                 what = "WRITE_6";
  64                 break;
  65         case SEEK_6:
  66                 what = "SEEK_6";
  67                 break;
  68         case READ_REVERSE:
  69                 what = "READ_REVERSE";
  70                 break;
  71         case WRITE_FILEMARKS:
  72                 what = "WRITE_FILEMARKS";
  73                 break;
  74         case SPACE:
  75                 what = "SPACE";
  76                 break;
  77         case INQUIRY:
  78                 what = "INQUIRY";
  79                 break;
  80         case RECOVER_BUFFERED_DATA:
  81                 what = "RECOVER_BUFFERED_DATA";
  82                 break;
  83         case MODE_SELECT:
  84                 what = "MODE_SELECT";
  85                 break;
  86         case RESERVE:
  87                 what = "RESERVE";
  88                 break;
  89         case RELEASE:
  90                 what = "RELEASE";
  91                 break;
  92         case COPY:
  93                 what = "COPY";
  94                 break;
  95         case ERASE:
  96                 what = "ERASE";
  97                 break;
  98         case MODE_SENSE:
  99                 what = "MODE_SENSE";
 100                 break;
 101         case START_STOP:
 102                 what = "START_STOP";
 103                 break;
 104         case RECEIVE_DIAGNOSTIC:
 105                 what = "RECEIVE_DIAGNOSTIC";
 106                 break;
 107         case SEND_DIAGNOSTIC:
 108                 what = "SEND_DIAGNOSTIC";
 109                 break;
 110         case ALLOW_MEDIUM_REMOVAL:
 111                 what = "ALLOW_MEDIUM_REMOVAL";
 112                 break;
 113         case SET_WINDOW:
 114                 what = "SET_WINDOW";
 115                 break;
 116         case READ_CAPACITY:
 117                 what = "READ_CAPACITY";
 118                 break;
 119         case READ_10:
 120                 what = "READ_10";
 121                 break;
 122         case WRITE_10:
 123                 what = "WRITE_10";
 124                 break;
 125         case SEEK_10:
 126                 what = "SEEK_10";
 127                 break;
 128         case WRITE_VERIFY:
 129                 what = "WRITE_VERIFY";
 130                 break;
 131         case VERIFY:
 132                 what = "VERIFY";
 133                 break;
 134         case SEARCH_HIGH:
 135                 what = "SEARCH_HIGH";
 136                 break;
 137         case SEARCH_EQUAL:
 138                 what = "SEARCH_EQUAL";
 139                 break;
 140         case SEARCH_LOW:
 141                 what = "SEARCH_LOW";
 142                 break;
 143         case SET_LIMITS:
 144                 what = "SET_LIMITS";
 145                 break;
 146         case READ_POSITION:
 147                 what = "READ_POSITION";
 148                 break;
 149         case SYNCHRONIZE_CACHE:
 150                 what = "SYNCHRONIZE_CACHE";
 151                 break;
 152         case LOCK_UNLOCK_CACHE:
 153                 what = "LOCK_UNLOCK_CACHE";
 154                 break;
 155         case READ_DEFECT_DATA:
 156                 what = "READ_DEFECT_DATA";
 157                 break;
 158         case MEDIUM_SCAN:
 159                 what = "MEDIUM_SCAN";
 160                 break;
 161         case COMPARE:
 162                 what = "COMPARE";
 163                 break;
 164         case COPY_VERIFY:
 165                 what = "COPY_VERIFY";
 166                 break;
 167         case WRITE_BUFFER:
 168                 what = "WRITE_BUFFER";
 169                 break;
 170         case READ_BUFFER:
 171                 what = "READ_BUFFER";
 172                 break;
 173         case UPDATE_BLOCK:
 174                 what = "UPDATE_BLOCK";
 175                 break;
 176         case READ_LONG:
 177                 what = "READ_LONG";
 178                 break;
 179         case WRITE_LONG:
 180                 what = "WRITE_LONG";
 181                 break;
 182         case CHANGE_DEFINITION:
 183                 what = "CHANGE_DEFINITION";
 184                 break;
 185         case WRITE_SAME:
 186                 what = "WRITE_SAME";
 187                 break;
 188         case GPCMD_READ_SUBCHANNEL:
 189                 what = "READ SUBCHANNEL";
 190                 break;
 191         case READ_TOC:
 192                 what = "READ_TOC";
 193                 break;
 194         case GPCMD_READ_HEADER:
 195                 what = "READ HEADER";
 196                 break;
 197         case GPCMD_PLAY_AUDIO_10:
 198                 what = "PLAY AUDIO (10)";
 199                 break;
 200         case GPCMD_PLAY_AUDIO_MSF:
 201                 what = "PLAY AUDIO MSF";
 202                 break;
 203         case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
 204                 what = "GET EVENT/STATUS NOTIFICATION";
 205                 break;
 206         case GPCMD_PAUSE_RESUME:
 207                 what = "PAUSE/RESUME";
 208                 break;
 209         case LOG_SELECT:
 210                 what = "LOG_SELECT";
 211                 break;
 212         case LOG_SENSE:
 213                 what = "LOG_SENSE";
 214                 break;
 215         case GPCMD_STOP_PLAY_SCAN:
 216                 what = "STOP PLAY/SCAN";
 217                 break;
 218         case GPCMD_READ_DISC_INFO:
 219                 what = "READ DISC INFORMATION";
 220                 break;
 221         case GPCMD_READ_TRACK_RZONE_INFO:
 222                 what = "READ TRACK INFORMATION";
 223                 break;
 224         case GPCMD_RESERVE_RZONE_TRACK:
 225                 what = "RESERVE TRACK";
 226                 break;
 227         case GPCMD_SEND_OPC:
 228                 what = "SEND OPC";
 229                 break;
 230         case MODE_SELECT_10:
 231                 what = "MODE_SELECT_10";
 232                 break;
 233         case GPCMD_REPAIR_RZONE_TRACK:
 234                 what = "REPAIR TRACK";
 235                 break;
 236         case 0x59:
 237                 what = "READ MASTER CUE";
 238                 break;
 239         case MODE_SENSE_10:
 240                 what = "MODE_SENSE_10";
 241                 break;
 242         case GPCMD_CLOSE_TRACK:
 243                 what = "CLOSE TRACK/SESSION";
 244                 break;
 245         case 0x5C:
 246                 what = "READ BUFFER CAPACITY";
 247                 break;
 248         case 0x5D:
 249                 what = "SEND CUE SHEET";
 250                 break;
 251         case GPCMD_BLANK:
 252                 what = "BLANK";
 253                 break;
 254         case REPORT_LUNS:
 255                 what = "REPORT LUNS";
 256                 break;
 257         case MOVE_MEDIUM:
 258                 what = "MOVE_MEDIUM or PLAY AUDIO (12)";
 259                 break;
 260         case READ_12:
 261                 what = "READ_12";
 262                 break;
 263         case WRITE_12:
 264                 what = "WRITE_12";
 265                 break;
 266         case WRITE_VERIFY_12:
 267                 what = "WRITE_VERIFY_12";
 268                 break;
 269         case SEARCH_HIGH_12:
 270                 what = "SEARCH_HIGH_12";
 271                 break;
 272         case SEARCH_EQUAL_12:
 273                 what = "SEARCH_EQUAL_12";
 274                 break;
 275         case SEARCH_LOW_12:
 276                 what = "SEARCH_LOW_12";
 277                 break;
 278         case SEND_VOLUME_TAG:
 279                 what = "SEND_VOLUME_TAG";
 280                 break;
 281         case READ_ELEMENT_STATUS:
 282                 what = "READ_ELEMENT_STATUS";
 283                 break;
 284         case GPCMD_READ_CD_MSF:
 285                 what = "READ CD MSF";
 286                 break;
 287         case GPCMD_SCAN:
 288                 what = "SCAN";
 289                 break;
 290         case GPCMD_SET_SPEED:
 291                 what = "SET CD SPEED";
 292                 break;
 293         case GPCMD_MECHANISM_STATUS:
 294                 what = "MECHANISM STATUS";
 295                 break;
 296         case GPCMD_READ_CD:
 297                 what = "READ CD";
 298                 break;
 299         case 0xE1:
 300                 what = "WRITE CONTINUE";
 301                 break;
 302         case WRITE_LONG_2:
 303                 what = "WRITE_LONG_2";
 304                 break;
 305         case VENDOR_CMND:
 306                 what = "Realtek's vendor command";
 307                 break;
 308         default:
 309                 what = "(unknown command)";
 310                 unknown_cmd = true;
 311                 break;
 312         }
 313
 314         if (srb->cmnd[0] != TEST_UNIT_READY)
 315                 dev_dbg(rtsx_dev(chip), "Command %s (%d bytes)\n",
 316                         what, srb->cmd_len);
 317
 318         if (unknown_cmd) {
 319                 len = min_t(unsigned short, srb->cmd_len, 16);
 320                 dev_dbg(rtsx_dev(chip), "%*ph\n", len, srb->cmnd);
 321         }
 322 }
 323
 324 void set_sense_type(struct rtsx_chip *chip, unsigned int lun, int sense_type)
 325 {
 326         switch (sense_type) {
 327         case SENSE_TYPE_MEDIA_CHANGE:
 328                 set_sense_data(chip, lun, CUR_ERR, 0x06, 0, 0x28, 0, 0, 0);
 329                 break;
 330
 331         case SENSE_TYPE_MEDIA_NOT_PRESENT:
 332                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x3A, 0, 0, 0);
 333                 break;
 334
 335         case SENSE_TYPE_MEDIA_LBA_OVER_RANGE:
 336                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x21, 0, 0, 0);
 337                 break;
 338
 339         case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT:
 340                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x25, 0, 0, 0);
 341                 break;
 342
 343         case SENSE_TYPE_MEDIA_WRITE_PROTECT:
 344                 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x27, 0, 0, 0);
 345                 break;
 346
 347         case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR:
 348                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x11, 0, 0, 0);
 349                 break;
 350
 351         case SENSE_TYPE_MEDIA_WRITE_ERR:
 352                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x02, 0, 0);
 353                 break;
 354
 355         case SENSE_TYPE_MEDIA_INVALID_CMD_FIELD:
 356                 set_sense_data(chip, lun, CUR_ERR, ILGAL_REQ, 0,
 357                                 ASC_INVLD_CDB, ASCQ_INVLD_CDB, CDB_ILLEGAL, 1);
 358                 break;
 359
 360         case SENSE_TYPE_FORMAT_IN_PROGRESS:
 361                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 0, 0);
 362                 break;
 363
 364         case SENSE_TYPE_FORMAT_CMD_FAILED:
 365                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x31, 0x01, 0, 0);
 366                 break;
 367
 368 #ifdef SUPPORT_MAGIC_GATE
 369         case SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB:
 370                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x02, 0, 0);
 371                 break;
 372
 373         case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN:
 374                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x00, 0, 0);
 375                 break;
 376
 377         case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM:
 378                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x30, 0x00, 0, 0);
 379                 break;
 380
 381         case SENSE_TYPE_MG_WRITE_ERR:
 382                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x00, 0, 0);
 383                 break;
 384 #endif
 385
 386 #ifdef SUPPORT_SD_LOCK
 387         case SENSE_TYPE_MEDIA_READ_FORBIDDEN:
 388                 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x11, 0x13, 0, 0);
 389                 break;
 390 #endif
 391
 392         case SENSE_TYPE_NO_SENSE:
 393         default:
 394                 set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0);
 395                 break;
 396         }
 397 }
 398
 399 void set_sense_data(struct rtsx_chip *chip, unsigned int lun, u8 err_code,
 400                 u8 sense_key, u32 info, u8 asc, u8 ascq, u8 sns_key_info0,
 401                 u16 sns_key_info1)
 402 {
 403         struct sense_data_t *sense = &(chip->sense_buffer[lun]);
 404
 405         sense->err_code = err_code;
 406         sense->sense_key = sense_key;
 407         sense->info[0] = (u8)(info >> 24);
 408         sense->info[1] = (u8)(info >> 16);
 409         sense->info[2] = (u8)(info >> 8);
 410         sense->info[3] = (u8)info;
 411
 412         sense->ad_sense_len = sizeof(struct sense_data_t) - 8;
 413         sense->asc = asc;
 414         sense->ascq = ascq;
 415         if (sns_key_info0 != 0) {
 416                 sense->sns_key_info[0] = SKSV | sns_key_info0;
 417                 sense->sns_key_info[1] = (sns_key_info1 & 0xf0) >> 8;
 418                 sense->sns_key_info[2] = sns_key_info1 & 0x0f;
 419         }
 420 }
 421
 422 static int test_unit_ready(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 423 {
 424         unsigned int lun = SCSI_LUN(srb);
 425
 426         if (!check_card_ready(chip, lun)) {
 427                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 428                 return TRANSPORT_FAILED;
 429         }
 430
 431         if (!(CHK_BIT(chip->lun_mc, lun))) {
 432                 SET_BIT(chip->lun_mc, lun);
 433                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 434                 return TRANSPORT_FAILED;
 435         }
 436
 437 #ifdef SUPPORT_SD_LOCK
 438         if (get_lun_card(chip, SCSI_LUN(srb)) == SD_CARD) {
 439                 struct sd_info *sd_card = &(chip->sd_card);
 440
 441                 if (sd_card->sd_lock_notify) {
 442                         sd_card->sd_lock_notify = 0;
 443                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 444                         return TRANSPORT_FAILED;
 445                 } else if (sd_card->sd_lock_status & SD_LOCKED) {
 446                         set_sense_type(chip, lun,
 447                                 SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 448                         return TRANSPORT_FAILED;
 449                 }
 450         }
 451 #endif
 452
 453         return TRANSPORT_GOOD;
 454 }
 455
 456 static unsigned char formatter_inquiry_str[20] = {
 457         'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K',
 458 #ifdef SUPPORT_MAGIC_GATE
 459         '-', 'M', 'G', /* Byte[47:49] */
 460 #else
 461         0x20, 0x20, 0x20,  /* Byte[47:49] */
 462 #endif
 463
 464 #ifdef SUPPORT_MAGIC_GATE
 465         0x0B,  /* Byte[50]: MG, MS, MSPro, MSXC */
 466 #else
 467         0x09,  /* Byte[50]: MS, MSPro, MSXC */
 468 #endif
 469         0x00,  /* Byte[51]: Category Specific Commands */
 470         0x00,  /* Byte[52]: Access Control and feature */
 471         0x20, 0x20, 0x20, /* Byte[53:55] */
 472 };
 473
 474 static int inquiry(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 475 {
 476         unsigned int lun = SCSI_LUN(srb);
 477         char *inquiry_default = (char *)"Generic-xD/SD/M.S.      1.00 ";
 478         char *inquiry_sdms =    (char *)"Generic-SD/MemoryStick  1.00 ";
 479         char *inquiry_sd =      (char *)"Generic-SD/MMC          1.00 ";
 480         char *inquiry_ms =      (char *)"Generic-MemoryStick     1.00 ";
 481         char *inquiry_string;
 482         unsigned char sendbytes;
 483         unsigned char *buf;
 484         u8 card = get_lun_card(chip, lun);
 485         bool pro_formatter_flag = false;
 486         unsigned char inquiry_buf[] = {
 487                 QULIFIRE|DRCT_ACCESS_DEV,
 488                 RMB_DISC|0x0D,
 489                 0x00,
 490                 0x01,
 491                 0x1f,
 492                 0x02,
 493                 0,
 494                 REL_ADR|WBUS_32|WBUS_16|SYNC|LINKED|CMD_QUE|SFT_RE,
 495         };
 496
 497         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
 498                 if (chip->lun2card[lun] == SD_CARD)
 499                         inquiry_string = inquiry_sd;
 500                 else
 501                         inquiry_string = inquiry_ms;
 502
 503         } else if (CHECK_LUN_MODE(chip, SD_MS_1LUN)) {
 504                 inquiry_string = inquiry_sdms;
 505         } else {
 506                 inquiry_string = inquiry_default;
 507         }
 508
 509         buf = vmalloc(scsi_bufflen(srb));
 510         if (buf == NULL) {
 511                 rtsx_trace(chip);
 512                 return TRANSPORT_ERROR;
 513         }
 514
 515 #ifdef SUPPORT_MAGIC_GATE
 516         if ((chip->mspro_formatter_enable) &&
 517                         (chip->lun2card[lun] & MS_CARD))
 518 #else
 519         if (chip->mspro_formatter_enable)
 520 #endif
 521                 if (!card || (card == MS_CARD))
 522                         pro_formatter_flag = true;
 523
 524         if (pro_formatter_flag) {
 525                 if (scsi_bufflen(srb) < 56)
 526                         sendbytes = (unsigned char)(scsi_bufflen(srb));
 527                 else
 528                         sendbytes = 56;
 529
 530         } else {
 531                 if (scsi_bufflen(srb) < 36)
 532                         sendbytes = (unsigned char)(scsi_bufflen(srb));
 533                 else
 534                         sendbytes = 36;
 535         }
 536
 537         if (sendbytes > 8) {
 538                 memcpy(buf, inquiry_buf, 8);
 539                 memcpy(buf + 8, inquiry_string, sendbytes - 8);
 540                 if (pro_formatter_flag) {
 541                         /* Additional Length */
 542                         buf[4] = 0x33;
 543                 }
 544         } else {
 545                 memcpy(buf, inquiry_buf, sendbytes);
 546         }
 547
 548         if (pro_formatter_flag) {
 549                 if (sendbytes > 36)
 550                         memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
 551         }
 552
 553         scsi_set_resid(srb, 0);
 554
 555         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
 556         vfree(buf);
 557
 558         return TRANSPORT_GOOD;
 559 }
 560
 561
 562 static int start_stop_unit(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 563 {
 564         unsigned int lun = SCSI_LUN(srb);
 565
 566         scsi_set_resid(srb, scsi_bufflen(srb));
 567
 568         if (srb->cmnd[1] == 1)
 569                 return TRANSPORT_GOOD;
 570
 571         switch (srb->cmnd[0x4]) {
 572         case STOP_MEDIUM:
 573                 /* Media disabled */
 574                 return TRANSPORT_GOOD;
 575
 576         case UNLOAD_MEDIUM:
 577                 /* Media shall be unload */
 578                 if (check_card_ready(chip, lun))
 579                         eject_card(chip, lun);
 580                 return TRANSPORT_GOOD;
 581
 582         case MAKE_MEDIUM_READY:
 583         case LOAD_MEDIUM:
 584                 if (check_card_ready(chip, lun))
 585                         return TRANSPORT_GOOD;
 586                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 587                 rtsx_trace(chip);
 588                 return TRANSPORT_FAILED;
 589
 590                 break;
 591         }
 592
 593         rtsx_trace(chip);
 594         return TRANSPORT_ERROR;
 595 }
 596
 597
 598 static int allow_medium_removal(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 599 {
 600         int prevent;
 601
 602         prevent = srb->cmnd[4] & 0x1;
 603
 604         scsi_set_resid(srb, 0);
 605
 606         if (prevent) {
 607                 set_sense_type(chip, SCSI_LUN(srb),
 608                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 609                 rtsx_trace(chip);
 610                 return TRANSPORT_FAILED;
 611         }
 612
 613         return TRANSPORT_GOOD;
 614 }
 615
 616
 617 static int request_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 618 {
 619         struct sense_data_t *sense;
 620         unsigned int lun = SCSI_LUN(srb);
 621         struct ms_info *ms_card = &(chip->ms_card);
 622         unsigned char *tmp, *buf;
 623
 624         sense = &(chip->sense_buffer[lun]);
 625
 626         if ((get_lun_card(chip, lun) == MS_CARD) &&
 627                 ms_card->pro_under_formatting) {
 628                 if (ms_card->format_status == FORMAT_SUCCESS) {
 629                         set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 630                         ms_card->pro_under_formatting = 0;
 631                         ms_card->progress = 0;
 632                 } else if (ms_card->format_status == FORMAT_IN_PROGRESS) {
 633                         /* Logical Unit Not Ready Format in Progress */
 634                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
 635                                         0, (u16)(ms_card->progress));
 636                 } else {
 637                         /* Format Command Failed */
 638                         set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
 639                         ms_card->pro_under_formatting = 0;
 640                         ms_card->progress = 0;
 641                 }
 642
 643                 rtsx_set_stat(chip, RTSX_STAT_RUN);
 644         }
 645
 646         buf = vmalloc(scsi_bufflen(srb));
 647         if (buf == NULL) {
 648                 rtsx_trace(chip);
 649                 return TRANSPORT_ERROR;
 650         }
 651
 652         tmp = (unsigned char *)sense;
 653         memcpy(buf, tmp, scsi_bufflen(srb));
 654
 655         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
 656         vfree(buf);
 657
 658         scsi_set_resid(srb, 0);
 659         /* Reset Sense Data */
 660         set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 661         return TRANSPORT_GOOD;
 662 }
 663
 664 static void ms_mode_sense(struct rtsx_chip *chip, u8 cmd,
 665                 int lun, u8 *buf, int buf_len)
 666 {
 667         struct ms_info *ms_card = &(chip->ms_card);
 668         int sys_info_offset;
 669         int data_size = buf_len;
 670         bool support_format = false;
 671         int i = 0;
 672
 673         if (cmd == MODE_SENSE) {
 674                 sys_info_offset = 8;
 675                 if (data_size > 0x68)
 676                         data_size = 0x68;
 677
 678                 buf[i++] = 0x67;  /* Mode Data Length */
 679         } else {
 680                 sys_info_offset = 12;
 681                 if (data_size > 0x6C)
 682                         data_size = 0x6C;
 683
 684                 buf[i++] = 0x00;  /* Mode Data Length (MSB) */
 685                 buf[i++] = 0x6A;  /* Mode Data Length (LSB) */
 686         }
 687
 688         /* Medium Type Code */
 689         if (check_card_ready(chip, lun)) {
 690                 if (CHK_MSXC(ms_card)) {
 691                         support_format = true;
 692                         buf[i++] = 0x40;
 693                 } else if (CHK_MSPRO(ms_card)) {
 694                         support_format = true;
 695                         buf[i++] = 0x20;
 696                 } else {
 697                         buf[i++] = 0x10;
 698                 }
 699
 700                 /* WP */
 701                 if (check_card_wp(chip, lun))
 702                         buf[i++] = 0x80;
 703                 else
 704                         buf[i++] = 0x00;
 705
 706         } else {
 707                 buf[i++] = 0x00;        /* MediaType */
 708                 buf[i++] = 0x00;        /* WP */
 709         }
 710
 711         buf[i++] = 0x00;                /* Reserved */
 712
 713         if (cmd == MODE_SENSE_10) {
 714                 buf[i++] = 0x00;  /* Reserved */
 715                 buf[i++] = 0x00;  /* Block descriptor length(MSB) */
 716                 buf[i++] = 0x00;  /* Block descriptor length(LSB) */
 717
 718                 /* The Following Data is the content of "Page 0x20" */
 719                 if (data_size >= 9)
 720                         buf[i++] = 0x20;                /* Page Code */
 721                 if (data_size >= 10)
 722                         buf[i++] = 0x62;                /* Page Length */
 723                 if (data_size >= 11)
 724                         buf[i++] = 0x00;                /* No Access Control */
 725                 if (data_size >= 12) {
 726                         if (support_format)
 727                                 buf[i++] = 0xC0;        /* SF, SGM */
 728                         else
 729                                 buf[i++] = 0x00;
 730                 }
 731         } else {
 732                 /* The Following Data is the content of "Page 0x20" */
 733                 if (data_size >= 5)
 734                         buf[i++] = 0x20;                /* Page Code */
 735                 if (data_size >= 6)
 736                         buf[i++] = 0x62;                /* Page Length */
 737                 if (data_size >= 7)
 738                         buf[i++] = 0x00;                /* No Access Control */
 739                 if (data_size >= 8) {
 740                         if (support_format)
 741                                 buf[i++] = 0xC0;        /* SF, SGM */
 742                         else
 743                                 buf[i++] = 0x00;
 744                 }
 745         }
 746
 747         if (data_size > sys_info_offset) {
 748                 /* 96 Bytes Attribute Data */
 749                 int len = data_size - sys_info_offset;
 750
 751                 len = (len < 96) ? len : 96;
 752
 753                 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
 754         }
 755 }
 756
 757 static int mode_sense(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 758 {
 759         unsigned int lun = SCSI_LUN(srb);
 760         unsigned int dataSize;
 761         int status;
 762         bool pro_formatter_flag;
 763         unsigned char pageCode, *buf;
 764         u8 card = get_lun_card(chip, lun);
 765
 766 #ifndef SUPPORT_MAGIC_GATE
 767         if (!check_card_ready(chip, lun)) {
 768                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 769                 scsi_set_resid(srb, scsi_bufflen(srb));
 770                 rtsx_trace(chip);
 771                 return TRANSPORT_FAILED;
 772         }
 773 #endif
 774
 775         pro_formatter_flag = false;
 776         dataSize = 8;
 777 #ifdef SUPPORT_MAGIC_GATE
 778         if ((chip->lun2card[lun] & MS_CARD)) {
 779                 if (!card || (card == MS_CARD)) {
 780                         dataSize = 108;
 781                         if (chip->mspro_formatter_enable)
 782                                 pro_formatter_flag = true;
 783                 }
 784         }
 785 #else
 786         if (card == MS_CARD) {
 787                 if (chip->mspro_formatter_enable) {
 788                         pro_formatter_flag = true;
 789                         dataSize = 108;
 790                 }
 791         }
 792 #endif
 793
 794         buf = kmalloc(dataSize, GFP_KERNEL);
 795         if (buf == NULL) {
 796                 rtsx_trace(chip);
 797                 return TRANSPORT_ERROR;
 798         }
 799
 800         pageCode = srb->cmnd[2] & 0x3f;
 801
 802         if ((pageCode == 0x3F) || (pageCode == 0x1C) ||
 803                 (pageCode == 0x00) ||
 804                 (pro_formatter_flag && (pageCode == 0x20))) {
 805                 if (srb->cmnd[0] == MODE_SENSE) {
 806                         if ((pageCode == 0x3F) || (pageCode == 0x20)) {
 807                                 ms_mode_sense(chip, srb->cmnd[0],
 808                                               lun, buf, dataSize);
 809                         } else {
 810                                 dataSize = 4;
 811                                 buf[0] = 0x03;
 812                                 buf[1] = 0x00;
 813                                 if (check_card_wp(chip, lun))
 814                                         buf[2] = 0x80;
 815                                 else
 816                                         buf[2] = 0x00;
 817
 818                                 buf[3] = 0x00;
 819                         }
 820                 } else {
 821                         if ((pageCode == 0x3F) || (pageCode == 0x20)) {
 822                                 ms_mode_sense(chip, srb->cmnd[0],
 823                                               lun, buf, dataSize);
 824                         } else {
 825                                 dataSize = 8;
 826                                 buf[0] = 0x00;
 827                                 buf[1] = 0x06;
 828                                 buf[2] = 0x00;
 829                                 if (check_card_wp(chip, lun))
 830                                         buf[3] = 0x80;
 831                                 else
 832                                         buf[3] = 0x00;
 833                                 buf[4] = 0x00;
 834                                 buf[5] = 0x00;
 835                                 buf[6] = 0x00;
 836                                 buf[7] = 0x00;
 837                         }
 838                 }
 839                 status = TRANSPORT_GOOD;
 840         } else {
 841                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 842                 scsi_set_resid(srb, scsi_bufflen(srb));
 843                 status = TRANSPORT_FAILED;
 844         }
 845
 846         if (status == TRANSPORT_GOOD) {
 847                 unsigned int len = min_t(unsigned int, scsi_bufflen(srb),
 848                                         dataSize);
 849                 rtsx_stor_set_xfer_buf(buf, len, srb);
 850                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
 851         }
 852         kfree(buf);
 853
 854         return status;
 855 }
 856
 857 static int read_write(struct scsi_cmnd *srb, struct rtsx_chip *chip)
 858 {
 859 #ifdef SUPPORT_SD_LOCK
 860         struct sd_info *sd_card = &(chip->sd_card);
 861 #endif
 862         unsigned int lun = SCSI_LUN(srb);
 863         int retval;
 864         u32 start_sec;
 865         u16 sec_cnt;
 866
 867         rtsx_disable_aspm(chip);
 868
 869         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
 870                 rtsx_exit_ss(chip);
 871                 wait_timeout(100);
 872         }
 873         rtsx_set_stat(chip, RTSX_STAT_RUN);
 874
 875         if (!check_card_ready(chip, lun) || (get_card_size(chip, lun) == 0)) {
 876                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 877                 rtsx_trace(chip);
 878                 return TRANSPORT_FAILED;
 879         }
 880
 881         if (!(CHK_BIT(chip->lun_mc, lun))) {
 882                 SET_BIT(chip->lun_mc, lun);
 883                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 884                 return TRANSPORT_FAILED;
 885         }
 886
 887 #ifdef SUPPORT_SD_LOCK
 888         if (sd_card->sd_erase_status) {
 889                 /* Accessing to any card is forbidden
 890                  * until the erase procedure of SD is completed
 891                  */
 892                 dev_dbg(rtsx_dev(chip), "SD card being erased!\n");
 893                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 894                 rtsx_trace(chip);
 895                 return TRANSPORT_FAILED;
 896         }
 897
 898         if (get_lun_card(chip, lun) == SD_CARD) {
 899                 if (sd_card->sd_lock_status & SD_LOCKED) {
 900                         dev_dbg(rtsx_dev(chip), "SD card locked!\n");
 901                         set_sense_type(chip, lun,
 902                                 SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 903                         rtsx_trace(chip);
 904                         return TRANSPORT_FAILED;
 905                 }
 906         }
 907 #endif
 908
 909         if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
 910                 start_sec = ((u32)srb->cmnd[2] << 24) |
 911                         ((u32)srb->cmnd[3] << 16) |
 912                         ((u32)srb->cmnd[4] << 8) | ((u32)srb->cmnd[5]);
 913                 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
 914         } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
 915                 start_sec = ((u32)(srb->cmnd[1] & 0x1F) << 16) |
 916                         ((u32)srb->cmnd[2] << 8) | ((u32)srb->cmnd[3]);
 917                 sec_cnt = srb->cmnd[4];
 918                 if (sec_cnt == 0)
 919                         sec_cnt = 256;
 920         } else if ((srb->cmnd[0] == VENDOR_CMND) &&
 921                 (srb->cmnd[1] == SCSI_APP_CMD) &&
 922                 ((srb->cmnd[2] == PP_READ10) || (srb->cmnd[2] == PP_WRITE10))) {
 923                 start_sec = ((u32)srb->cmnd[4] << 24) |
 924                         ((u32)srb->cmnd[5] << 16) |
 925                         ((u32)srb->cmnd[6] << 8) | ((u32)srb->cmnd[7]);
 926                 sec_cnt = ((u16)(srb->cmnd[9]) << 8) | srb->cmnd[10];
 927         } else {
 928                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 929                 rtsx_trace(chip);
 930                 return TRANSPORT_FAILED;
 931         }
 932
 933         /* In some test, we will receive a start_sec like 0xFFFFFFFF.
 934          * In this situation, start_sec + sec_cnt will overflow, so we
 935          * need to judge start_sec at first
 936          */
 937         if ((start_sec > get_card_size(chip, lun)) ||
 938                         ((start_sec + sec_cnt) > get_card_size(chip, lun))) {
 939                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
 940                 rtsx_trace(chip);
 941                 return TRANSPORT_FAILED;
 942         }
 943
 944         if (sec_cnt == 0) {
 945                 scsi_set_resid(srb, 0);
 946                 return TRANSPORT_GOOD;
 947         }
 948
 949         if (chip->rw_fail_cnt[lun] == 3) {
 950                 dev_dbg(rtsx_dev(chip), "read/write fail three times in succession\n");
 951                 if (srb->sc_data_direction == DMA_FROM_DEVICE)
 952                         set_sense_type(chip, lun,
 953                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
 954                 else
 955                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
 956
 957                 rtsx_trace(chip);
 958                 return TRANSPORT_FAILED;
 959         }
 960
 961         if (srb->sc_data_direction == DMA_TO_DEVICE) {
 962                 if (check_card_wp(chip, lun)) {
 963                         dev_dbg(rtsx_dev(chip), "Write protected card!\n");
 964                         set_sense_type(chip, lun,
 965                                 SENSE_TYPE_MEDIA_WRITE_PROTECT);
 966                         rtsx_trace(chip);
 967                         return TRANSPORT_FAILED;
 968                 }
 969         }
 970
 971         retval = card_rw(srb, chip, start_sec, sec_cnt);
 972         if (retval != STATUS_SUCCESS) {
 973                 if (chip->need_release & chip->lun2card[lun]) {
 974                         chip->rw_fail_cnt[lun] = 0;
 975                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 976                 } else {
 977                         chip->rw_fail_cnt[lun]++;
 978                         if (srb->sc_data_direction == DMA_FROM_DEVICE)
 979                                 set_sense_type(chip, lun,
 980                                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
 981                         else
 982                                 set_sense_type(chip, lun,
 983                                         SENSE_TYPE_MEDIA_WRITE_ERR);
 984                 }
 985                 retval = TRANSPORT_FAILED;
 986                 rtsx_trace(chip);
 987                 goto Exit;
 988         } else {
 989                 chip->rw_fail_cnt[lun] = 0;
 990                 retval = TRANSPORT_GOOD;
 991         }
 992
 993         scsi_set_resid(srb, 0);
 994
 995 Exit:
 996         return retval;
 997 }
 998
 999 static int read_format_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1000 {
1001         unsigned char *buf;
1002         unsigned int lun = SCSI_LUN(srb);
1003         unsigned int buf_len;
1004         u8 card = get_lun_card(chip, lun);
1005         u32 card_size;
1006         int desc_cnt;
1007         int i = 0;
1008
1009         if (!check_card_ready(chip, lun)) {
1010                 if (!chip->mspro_formatter_enable) {
1011                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1012                         rtsx_trace(chip);
1013                         return TRANSPORT_FAILED;
1014                 }
1015         }
1016
1017         buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
1018
1019         buf = kmalloc(buf_len, GFP_KERNEL);
1020         if (buf == NULL) {
1021                 rtsx_trace(chip);
1022                 return TRANSPORT_ERROR;
1023         }
1024
1025         buf[i++] = 0;
1026         buf[i++] = 0;
1027         buf[i++] = 0;
1028
1029         /* Capacity List Length */
1030         if ((buf_len > 12) && chip->mspro_formatter_enable &&
1031                         (chip->lun2card[lun] & MS_CARD) &&
1032                         (!card || (card == MS_CARD))) {
1033                 buf[i++] = 0x10;
1034                 desc_cnt = 2;
1035         } else {
1036                 buf[i++] = 0x08;
1037                 desc_cnt = 1;
1038         }
1039
1040         while (desc_cnt) {
1041                 if (check_card_ready(chip, lun)) {
1042                         card_size = get_card_size(chip, lun);
1043                         buf[i++] = (unsigned char)(card_size >> 24);
1044                         buf[i++] = (unsigned char)(card_size >> 16);
1045                         buf[i++] = (unsigned char)(card_size >> 8);
1046                         buf[i++] = (unsigned char)card_size;
1047
1048                         if (desc_cnt == 2)
1049                                 buf[i++] = 2;
1050                         else
1051                                 buf[i++] = 0;
1052                 } else {
1053                         buf[i++] = 0xFF;
1054                         buf[i++] = 0xFF;
1055                         buf[i++] = 0xFF;
1056                         buf[i++] = 0xFF;
1057
1058                         if (desc_cnt == 2)
1059                                 buf[i++] = 3;
1060                         else
1061                                 buf[i++] = 0;
1062                 }
1063
1064                 buf[i++] = 0x00;
1065                 buf[i++] = 0x02;
1066                 buf[i++] = 0x00;
1067
1068                 desc_cnt--;
1069         }
1070
1071         buf_len = min_t(unsigned int, scsi_bufflen(srb), buf_len);
1072         rtsx_stor_set_xfer_buf(buf, buf_len, srb);
1073         kfree(buf);
1074
1075         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1076
1077         return TRANSPORT_GOOD;
1078 }
1079
1080 static int read_capacity(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1081 {
1082         unsigned char *buf;
1083         unsigned int lun = SCSI_LUN(srb);
1084         u32 card_size;
1085
1086         if (!check_card_ready(chip, lun)) {
1087                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1088                 rtsx_trace(chip);
1089                 return TRANSPORT_FAILED;
1090         }
1091
1092         if (!(CHK_BIT(chip->lun_mc, lun))) {
1093                 SET_BIT(chip->lun_mc, lun);
1094                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
1095                 return TRANSPORT_FAILED;
1096         }
1097
1098         buf = kmalloc(8, GFP_KERNEL);
1099         if (buf == NULL) {
1100                 rtsx_trace(chip);
1101                 return TRANSPORT_ERROR;
1102         }
1103
1104         card_size = get_card_size(chip, lun);
1105         buf[0] = (unsigned char)((card_size - 1) >> 24);
1106         buf[1] = (unsigned char)((card_size - 1) >> 16);
1107         buf[2] = (unsigned char)((card_size - 1) >> 8);
1108         buf[3] = (unsigned char)(card_size - 1);
1109
1110         buf[4] = 0x00;
1111         buf[5] = 0x00;
1112         buf[6] = 0x02;
1113         buf[7] = 0x00;
1114
1115         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1116         kfree(buf);
1117
1118         scsi_set_resid(srb, 0);
1119
1120         return TRANSPORT_GOOD;
1121 }
1122
1123 static int read_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1124 {
1125         unsigned short len, i;
1126         int retval;
1127         u8 *buf;
1128
1129         rtsx_disable_aspm(chip);
1130
1131         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1132                 rtsx_exit_ss(chip);
1133                 wait_timeout(100);
1134         }
1135         rtsx_set_stat(chip, RTSX_STAT_RUN);
1136
1137         len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1138
1139         buf = vmalloc(len);
1140         if (!buf) {
1141                 rtsx_trace(chip);
1142                 return TRANSPORT_ERROR;
1143         }
1144
1145         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1146         if (retval != STATUS_SUCCESS) {
1147                 vfree(buf);
1148                 set_sense_type(chip, SCSI_LUN(srb),
1149                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1150                 rtsx_trace(chip);
1151                 return TRANSPORT_FAILED;
1152         }
1153
1154         for (i = 0; i < len; i++) {
1155                 retval = spi_read_eeprom(chip, i, buf + i);
1156                 if (retval != STATUS_SUCCESS) {
1157                         vfree(buf);
1158                         set_sense_type(chip, SCSI_LUN(srb),
1159                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1160                         rtsx_trace(chip);
1161                         return TRANSPORT_FAILED;
1162                 }
1163         }
1164
1165         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1166         rtsx_stor_set_xfer_buf(buf, len, srb);
1167         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1168
1169         vfree(buf);
1170
1171         return TRANSPORT_GOOD;
1172 }
1173
1174 static int write_eeprom(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1175 {
1176         unsigned short len, i;
1177         int retval;
1178         u8 *buf;
1179
1180         rtsx_disable_aspm(chip);
1181
1182         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1183                 rtsx_exit_ss(chip);
1184                 wait_timeout(100);
1185         }
1186         rtsx_set_stat(chip, RTSX_STAT_RUN);
1187
1188         len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1189
1190         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1191         if (retval != STATUS_SUCCESS) {
1192                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1193                 rtsx_trace(chip);
1194                 return TRANSPORT_FAILED;
1195         }
1196
1197         if (len == 511) {
1198                 retval = spi_erase_eeprom_chip(chip);
1199                 if (retval != STATUS_SUCCESS) {
1200                         set_sense_type(chip, SCSI_LUN(srb),
1201                                 SENSE_TYPE_MEDIA_WRITE_ERR);
1202                         rtsx_trace(chip);
1203                         return TRANSPORT_FAILED;
1204                 }
1205         } else {
1206                 len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb),
1207                                         len);
1208                 buf = vmalloc(len);
1209                 if (buf == NULL) {
1210                         rtsx_trace(chip);
1211                         return TRANSPORT_ERROR;
1212                 }
1213
1214                 rtsx_stor_get_xfer_buf(buf, len, srb);
1215                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1216
1217                 for (i = 0; i < len; i++) {
1218                         retval = spi_write_eeprom(chip, i, buf[i]);
1219                         if (retval != STATUS_SUCCESS) {
1220                                 vfree(buf);
1221                                 set_sense_type(chip, SCSI_LUN(srb),
1222                                         SENSE_TYPE_MEDIA_WRITE_ERR);
1223                                 rtsx_trace(chip);
1224                                 return TRANSPORT_FAILED;
1225                         }
1226                 }
1227
1228                 vfree(buf);
1229         }
1230
1231         return TRANSPORT_GOOD;
1232 }
1233
1234 static int read_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1235 {
1236         unsigned short addr, len, i;
1237         int retval;
1238         u8 *buf;
1239
1240         rtsx_disable_aspm(chip);
1241
1242         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1243                 rtsx_exit_ss(chip);
1244                 wait_timeout(100);
1245         }
1246         rtsx_set_stat(chip, RTSX_STAT_RUN);
1247
1248         addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1249         len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1250
1251         if (addr < 0xFC00) {
1252                 set_sense_type(chip, SCSI_LUN(srb),
1253                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1254                 rtsx_trace(chip);
1255                 return TRANSPORT_FAILED;
1256         }
1257
1258         buf = vmalloc(len);
1259         if (!buf) {
1260                 rtsx_trace(chip);
1261                 return TRANSPORT_ERROR;
1262         }
1263
1264         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1265         if (retval != STATUS_SUCCESS) {
1266                 vfree(buf);
1267                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1268                 rtsx_trace(chip);
1269                 return TRANSPORT_FAILED;
1270         }
1271
1272         for (i = 0; i < len; i++) {
1273                 retval = rtsx_read_register(chip, addr + i, buf + i);
1274                 if (retval != STATUS_SUCCESS) {
1275                         vfree(buf);
1276                         set_sense_type(chip, SCSI_LUN(srb),
1277                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1278                         rtsx_trace(chip);
1279                         return TRANSPORT_FAILED;
1280                 }
1281         }
1282
1283         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1284         rtsx_stor_set_xfer_buf(buf, len, srb);
1285         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1286
1287         vfree(buf);
1288
1289         return TRANSPORT_GOOD;
1290 }
1291
1292 static int write_mem(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1293 {
1294         unsigned short addr, len, i;
1295         int retval;
1296         u8 *buf;
1297
1298         rtsx_disable_aspm(chip);
1299
1300         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1301                 rtsx_exit_ss(chip);
1302                 wait_timeout(100);
1303         }
1304         rtsx_set_stat(chip, RTSX_STAT_RUN);
1305
1306         addr = ((u16)srb->cmnd[2] << 8) | srb->cmnd[3];
1307         len = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1308
1309         if (addr < 0xFC00) {
1310                 set_sense_type(chip, SCSI_LUN(srb),
1311                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1312                 rtsx_trace(chip);
1313                 return TRANSPORT_FAILED;
1314         }
1315
1316         len = (unsigned short)min_t(unsigned int, scsi_bufflen(srb), len);
1317         buf = vmalloc(len);
1318         if (buf == NULL) {
1319                 rtsx_trace(chip);
1320                 return TRANSPORT_ERROR;
1321         }
1322
1323         rtsx_stor_get_xfer_buf(buf, len, srb);
1324         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1325
1326         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1327         if (retval != STATUS_SUCCESS) {
1328                 vfree(buf);
1329                 set_sense_type(chip, SCSI_LUN(srb), SENSE_TYPE_MEDIA_WRITE_ERR);
1330                 rtsx_trace(chip);
1331                 return TRANSPORT_FAILED;
1332         }
1333
1334         for (i = 0; i < len; i++) {
1335                 retval = rtsx_write_register(chip, addr + i, 0xFF, buf[i]);
1336                 if (retval != STATUS_SUCCESS) {
1337                         vfree(buf);
1338                         set_sense_type(chip, SCSI_LUN(srb),
1339                                 SENSE_TYPE_MEDIA_WRITE_ERR);
1340                         rtsx_trace(chip);
1341                         return TRANSPORT_FAILED;
1342                 }
1343         }
1344
1345         vfree(buf);
1346
1347         return TRANSPORT_GOOD;
1348 }
1349
1350 static int get_sd_csd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1351 {
1352         struct sd_info *sd_card = &(chip->sd_card);
1353         unsigned int lun = SCSI_LUN(srb);
1354
1355         if (!check_card_ready(chip, lun)) {
1356                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1357                 rtsx_trace(chip);
1358                 return TRANSPORT_FAILED;
1359         }
1360
1361         if (get_lun_card(chip, lun) != SD_CARD) {
1362                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1363                 rtsx_trace(chip);
1364                 return TRANSPORT_FAILED;
1365         }
1366
1367         scsi_set_resid(srb, 0);
1368         rtsx_stor_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1369
1370         return TRANSPORT_GOOD;
1371 }
1372
1373 static int toggle_gpio_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1374 {
1375         u8 gpio = srb->cmnd[2];
1376
1377         rtsx_disable_aspm(chip);
1378
1379         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1380                 rtsx_exit_ss(chip);
1381                 wait_timeout(100);
1382         }
1383         rtsx_set_stat(chip, RTSX_STAT_RUN);
1384
1385         if (gpio > 3)
1386                 gpio = 1;
1387         toggle_gpio(chip, gpio);
1388
1389         return TRANSPORT_GOOD;
1390 }
1391
1392 #ifdef _MSG_TRACE
1393 static int trace_msg_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1394 {
1395         unsigned char *ptr, *buf = NULL;
1396         int i, msg_cnt;
1397         u8 clear;
1398         unsigned int buf_len;
1399
1400         buf_len = 4 + ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) *
1401                 TRACE_ITEM_CNT);
1402
1403         if ((scsi_bufflen(srb) < buf_len) || (scsi_sglist(srb) == NULL)) {
1404                 set_sense_type(chip, SCSI_LUN(srb),
1405                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1406                 rtsx_trace(chip);
1407                 return TRANSPORT_FAILED;
1408         }
1409
1410         clear = srb->cmnd[2];
1411
1412         buf = vmalloc(scsi_bufflen(srb));
1413         if (buf == NULL) {
1414                 rtsx_trace(chip);
1415                 return TRANSPORT_ERROR;
1416         }
1417         ptr = buf;
1418
1419         if (chip->trace_msg[chip->msg_idx].valid)
1420                 msg_cnt = TRACE_ITEM_CNT;
1421         else
1422                 msg_cnt = chip->msg_idx;
1423
1424         *(ptr++) = (u8)(msg_cnt >> 24);
1425         *(ptr++) = (u8)(msg_cnt >> 16);
1426         *(ptr++) = (u8)(msg_cnt >> 8);
1427         *(ptr++) = (u8)msg_cnt;
1428         dev_dbg(rtsx_dev(chip), "Trace message count is %d\n", msg_cnt);
1429
1430         for (i = 1; i <= msg_cnt; i++) {
1431                 int j, idx;
1432
1433                 idx = chip->msg_idx - i;
1434                 if (idx < 0)
1435                         idx += TRACE_ITEM_CNT;
1436
1437                 *(ptr++) = (u8)(chip->trace_msg[idx].line >> 8);
1438                 *(ptr++) = (u8)(chip->trace_msg[idx].line);
1439                 for (j = 0; j < MSG_FUNC_LEN; j++)
1440                         *(ptr++) = chip->trace_msg[idx].func[j];
1441
1442                 for (j = 0; j < MSG_FILE_LEN; j++)
1443                         *(ptr++) = chip->trace_msg[idx].file[j];
1444
1445                 for (j = 0; j < TIME_VAL_LEN; j++)
1446                         *(ptr++) = chip->trace_msg[idx].timeval_buf[j];
1447         }
1448
1449         rtsx_stor_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1450         vfree(buf);
1451
1452         if (clear) {
1453                 chip->msg_idx = 0;
1454                 for (i = 0; i < TRACE_ITEM_CNT; i++)
1455                         chip->trace_msg[i].valid = 0;
1456         }
1457
1458         scsi_set_resid(srb, 0);
1459         return TRANSPORT_GOOD;
1460 }
1461 #endif
1462
1463 static int read_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1464 {
1465         u8 addr, buf[4];
1466         u32 val;
1467         unsigned int len;
1468
1469         rtsx_disable_aspm(chip);
1470
1471         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1472                 rtsx_exit_ss(chip);
1473                 wait_timeout(100);
1474         }
1475         rtsx_set_stat(chip, RTSX_STAT_RUN);
1476
1477         addr = srb->cmnd[4];
1478
1479         val = rtsx_readl(chip, addr);
1480         dev_dbg(rtsx_dev(chip), "Host register (0x%x): 0x%x\n", addr, val);
1481
1482         buf[0] = (u8)(val >> 24);
1483         buf[1] = (u8)(val >> 16);
1484         buf[2] = (u8)(val >> 8);
1485         buf[3] = (u8)val;
1486
1487         len = min_t(unsigned int, scsi_bufflen(srb), 4);
1488         rtsx_stor_set_xfer_buf(buf, len, srb);
1489         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1490
1491         return TRANSPORT_GOOD;
1492 }
1493
1494 static int write_host_reg(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1495 {
1496         u8 addr, buf[4];
1497         u32 val;
1498         unsigned int len;
1499
1500         rtsx_disable_aspm(chip);
1501
1502         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1503                 rtsx_exit_ss(chip);
1504                 wait_timeout(100);
1505         }
1506         rtsx_set_stat(chip, RTSX_STAT_RUN);
1507
1508         addr = srb->cmnd[4];
1509
1510         len = min_t(unsigned int, scsi_bufflen(srb), 4);
1511         rtsx_stor_get_xfer_buf(buf, len, srb);
1512         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1513
1514         val = ((u32)buf[0] << 24) | ((u32)buf[1] << 16) | ((u32)buf[2]
1515                                                         << 8) | buf[3];
1516
1517         rtsx_writel(chip, addr, val);
1518
1519         return TRANSPORT_GOOD;
1520 }
1521
1522 static int set_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1523 {
1524         unsigned lun = SCSI_LUN(srb);
1525
1526         if (srb->cmnd[3] == 1) {
1527                 /* Variable Clock */
1528                 struct xd_info *xd_card = &(chip->xd_card);
1529                 struct sd_info *sd_card = &(chip->sd_card);
1530                 struct ms_info *ms_card = &(chip->ms_card);
1531
1532                 switch (srb->cmnd[4]) {
1533                 case XD_CARD:
1534                         xd_card->xd_clock = srb->cmnd[5];
1535                         break;
1536
1537                 case SD_CARD:
1538                         sd_card->sd_clock = srb->cmnd[5];
1539                         break;
1540
1541                 case MS_CARD:
1542                         ms_card->ms_clock = srb->cmnd[5];
1543                         break;
1544
1545                 default:
1546                         set_sense_type(chip, lun,
1547                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1548                         rtsx_trace(chip);
1549                         return TRANSPORT_FAILED;
1550                 }
1551         } else if (srb->cmnd[3] == 2) {
1552                 if (srb->cmnd[4]) {
1553                         chip->blink_led = 1;
1554                 } else {
1555                         int retval;
1556
1557                         chip->blink_led = 0;
1558
1559                         rtsx_disable_aspm(chip);
1560
1561                         if (chip->ss_en &&
1562                                 (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1563                                 rtsx_exit_ss(chip);
1564                                 wait_timeout(100);
1565                         }
1566                         rtsx_set_stat(chip, RTSX_STAT_RUN);
1567
1568                         retval = rtsx_force_power_on(chip, SSC_PDCTL);
1569                         if (retval != STATUS_SUCCESS) {
1570                                 set_sense_type(chip, SCSI_LUN(srb),
1571                                         SENSE_TYPE_MEDIA_WRITE_ERR);
1572                                 rtsx_trace(chip);
1573                                 return TRANSPORT_FAILED;
1574                         }
1575
1576                         turn_off_led(chip, LED_GPIO);
1577                 }
1578         } else {
1579                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1580                 rtsx_trace(chip);
1581                 return TRANSPORT_FAILED;
1582         }
1583
1584         return TRANSPORT_GOOD;
1585 }
1586
1587 static int get_variable(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1588 {
1589         unsigned int lun = SCSI_LUN(srb);
1590
1591         if (srb->cmnd[3] == 1) {
1592                 struct xd_info *xd_card = &(chip->xd_card);
1593                 struct sd_info *sd_card = &(chip->sd_card);
1594                 struct ms_info *ms_card = &(chip->ms_card);
1595                 u8 tmp;
1596
1597                 switch (srb->cmnd[4]) {
1598                 case XD_CARD:
1599                         tmp = (u8)(xd_card->xd_clock);
1600                         break;
1601
1602                 case SD_CARD:
1603                         tmp = (u8)(sd_card->sd_clock);
1604                         break;
1605
1606                 case MS_CARD:
1607                         tmp = (u8)(ms_card->ms_clock);
1608                         break;
1609
1610                 default:
1611                         set_sense_type(chip, lun,
1612                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1613                         rtsx_trace(chip);
1614                         return TRANSPORT_FAILED;
1615                 }
1616
1617                 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1618         } else if (srb->cmnd[3] == 2) {
1619                 u8 tmp = chip->blink_led;
1620
1621                 rtsx_stor_set_xfer_buf(&tmp, 1, srb);
1622         } else {
1623                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1624                 rtsx_trace(chip);
1625                 return TRANSPORT_FAILED;
1626         }
1627
1628         return TRANSPORT_GOOD;
1629 }
1630
1631 static int dma_access_ring_buffer(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1632 {
1633         int retval;
1634         unsigned int lun = SCSI_LUN(srb);
1635         u16 len;
1636
1637         rtsx_disable_aspm(chip);
1638
1639         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1640                 rtsx_exit_ss(chip);
1641                 wait_timeout(100);
1642         }
1643         rtsx_set_stat(chip, RTSX_STAT_RUN);
1644
1645         len = ((u16)(srb->cmnd[4]) << 8) | srb->cmnd[5];
1646         len = min_t(u16, len, scsi_bufflen(srb));
1647
1648         if (srb->sc_data_direction == DMA_FROM_DEVICE)
1649                 dev_dbg(rtsx_dev(chip), "Read from device\n");
1650         else
1651                 dev_dbg(rtsx_dev(chip), "Write to device\n");
1652
1653         retval = rtsx_transfer_data(chip, 0, scsi_sglist(srb), len,
1654                         scsi_sg_count(srb), srb->sc_data_direction, 1000);
1655         if (retval < 0) {
1656                 if (srb->sc_data_direction == DMA_FROM_DEVICE)
1657                         set_sense_type(chip, lun,
1658                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1659                 else
1660                         set_sense_type(chip, lun,
1661                                 SENSE_TYPE_MEDIA_WRITE_ERR);
1662
1663                 rtsx_trace(chip);
1664                 return TRANSPORT_FAILED;
1665         }
1666         scsi_set_resid(srb, 0);
1667
1668         return TRANSPORT_GOOD;
1669 }
1670
1671 static int get_dev_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1672 {
1673         struct sd_info *sd_card = &(chip->sd_card);
1674         struct ms_info *ms_card = &(chip->ms_card);
1675         int buf_len;
1676         unsigned int lun = SCSI_LUN(srb);
1677         u8 card = get_lun_card(chip, lun);
1678         u8 status[32];
1679 #ifdef SUPPORT_OCP
1680         u8 oc_now_mask = 0, oc_ever_mask = 0;
1681 #endif
1682
1683         memset(status, 0, 32);
1684
1685         status[0] = (u8)(chip->product_id);
1686         status[1] = chip->ic_version;
1687
1688         if (chip->auto_delink_en)
1689                 status[2] = 0x10;
1690         else
1691                 status[2] = 0x00;
1692
1693         status[3] = 20;
1694         status[4] = 10;
1695         status[5] = 05;
1696         status[6] = 21;
1697
1698         if (chip->card_wp)
1699                 status[7] = 0x20;
1700         else
1701                 status[7] = 0x00;
1702
1703 #ifdef SUPPORT_OCP
1704         status[8] = 0;
1705         if (CHECK_LUN_MODE(chip,
1706                 SD_MS_2LUN) && (chip->lun2card[lun] == MS_CARD)) {
1707                 oc_now_mask = MS_OC_NOW;
1708                 oc_ever_mask = MS_OC_EVER;
1709         } else {
1710                 oc_now_mask = SD_OC_NOW;
1711                 oc_ever_mask = SD_OC_EVER;
1712         }
1713
1714         if (chip->ocp_stat & oc_now_mask)
1715                 status[8] |= 0x02;
1716
1717         if (chip->ocp_stat & oc_ever_mask)
1718                 status[8] |= 0x01;
1719 #endif
1720
1721         if (card == SD_CARD) {
1722                 if (CHK_SD(sd_card)) {
1723                         if (CHK_SD_HCXC(sd_card)) {
1724                                 if (sd_card->capacity > 0x4000000)
1725                                         status[0x0E] = 0x02;
1726                                 else
1727                                         status[0x0E] = 0x01;
1728                         } else {
1729                                 status[0x0E] = 0x00;
1730                         }
1731
1732                         if (CHK_SD_SDR104(sd_card))
1733                                 status[0x0F] = 0x03;
1734                         else if (CHK_SD_DDR50(sd_card))
1735                                 status[0x0F] = 0x04;
1736                         else if (CHK_SD_SDR50(sd_card))
1737                                 status[0x0F] = 0x02;
1738                         else if (CHK_SD_HS(sd_card))
1739                                 status[0x0F] = 0x01;
1740                         else
1741                                 status[0x0F] = 0x00;
1742                 } else {
1743                         if (CHK_MMC_SECTOR_MODE(sd_card))
1744                                 status[0x0E] = 0x01;
1745                         else
1746                                 status[0x0E] = 0x00;
1747
1748                         if (CHK_MMC_DDR52(sd_card))
1749                                 status[0x0F] = 0x03;
1750                         else if (CHK_MMC_52M(sd_card))
1751                                 status[0x0F] = 0x02;
1752                         else if (CHK_MMC_26M(sd_card))
1753                                 status[0x0F] = 0x01;
1754                         else
1755                                 status[0x0F] = 0x00;
1756                 }
1757         } else if (card == MS_CARD) {
1758                 if (CHK_MSPRO(ms_card)) {
1759                         if (CHK_MSXC(ms_card))
1760                                 status[0x0E] = 0x01;
1761                         else
1762                                 status[0x0E] = 0x00;
1763
1764                         if (CHK_HG8BIT(ms_card))
1765                                 status[0x0F] = 0x01;
1766                         else
1767                                 status[0x0F] = 0x00;
1768                 }
1769         }
1770
1771 #ifdef SUPPORT_SD_LOCK
1772         if (card == SD_CARD) {
1773                 status[0x17] = 0x80;
1774                 if (sd_card->sd_erase_status)
1775                         status[0x17] |= 0x01;
1776                 if (sd_card->sd_lock_status & SD_LOCKED) {
1777                         status[0x17] |= 0x02;
1778                         status[0x07] |= 0x40;
1779                 }
1780                 if (sd_card->sd_lock_status & SD_PWD_EXIST)
1781                         status[0x17] |= 0x04;
1782         } else {
1783                 status[0x17] = 0x00;
1784         }
1785
1786         dev_dbg(rtsx_dev(chip), "status[0x17] = 0x%x\n", status[0x17]);
1787 #endif
1788
1789         status[0x18] = 0x8A;
1790         status[0x1A] = 0x28;
1791 #ifdef SUPPORT_SD_LOCK
1792         status[0x1F] = 0x01;
1793 #endif
1794
1795         buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(status));
1796         rtsx_stor_set_xfer_buf(status, buf_len, srb);
1797         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1798
1799         return TRANSPORT_GOOD;
1800 }
1801
1802 static int set_chip_mode(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1803 {
1804         int phy_debug_mode;
1805         int retval;
1806         u16 reg;
1807
1808         if (!CHECK_PID(chip, 0x5208)) {
1809                 set_sense_type(chip, SCSI_LUN(srb),
1810                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1811                 rtsx_trace(chip);
1812                 return TRANSPORT_FAILED;
1813         }
1814
1815         phy_debug_mode = (int)(srb->cmnd[3]);
1816
1817         if (phy_debug_mode) {
1818                 chip->phy_debug_mode = 1;
1819                 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0);
1820                 if (retval != STATUS_SUCCESS) {
1821                         rtsx_trace(chip);
1822                         return TRANSPORT_FAILED;
1823                 }
1824
1825                 rtsx_disable_bus_int(chip);
1826
1827                 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
1828                 if (retval != STATUS_SUCCESS) {
1829                         rtsx_trace(chip);
1830                         return TRANSPORT_FAILED;
1831                 }
1832
1833                 reg |= 0x0001;
1834                 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1835                 if (retval != STATUS_SUCCESS) {
1836                         rtsx_trace(chip);
1837                         return TRANSPORT_FAILED;
1838                 }
1839         } else {
1840                 chip->phy_debug_mode = 0;
1841                 retval = rtsx_write_register(chip, CDRESUMECTL, 0x77, 0x77);
1842                 if (retval != STATUS_SUCCESS) {
1843                         rtsx_trace(chip);
1844                         return TRANSPORT_FAILED;
1845                 }
1846
1847                 rtsx_enable_bus_int(chip);
1848
1849                 retval = rtsx_read_phy_register(chip, 0x1C, &reg);
1850                 if (retval != STATUS_SUCCESS) {
1851                         rtsx_trace(chip);
1852                         return TRANSPORT_FAILED;
1853                 }
1854
1855                 reg &= 0xFFFE;
1856                 retval = rtsx_write_phy_register(chip, 0x1C, reg);
1857                 if (retval != STATUS_SUCCESS) {
1858                         rtsx_trace(chip);
1859                         return TRANSPORT_FAILED;
1860                 }
1861         }
1862
1863         return TRANSPORT_GOOD;
1864 }
1865
1866 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1867 {
1868         int retval =  STATUS_SUCCESS;
1869         unsigned int lun = SCSI_LUN(srb);
1870         u8 cmd_type, mask, value, idx;
1871         u16 addr;
1872
1873         rtsx_disable_aspm(chip);
1874
1875         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1876                 rtsx_exit_ss(chip);
1877                 wait_timeout(100);
1878         }
1879         rtsx_set_stat(chip, RTSX_STAT_RUN);
1880
1881         switch (srb->cmnd[3]) {
1882         case INIT_BATCHCMD:
1883                 rtsx_init_cmd(chip);
1884                 break;
1885
1886         case ADD_BATCHCMD:
1887                 cmd_type = srb->cmnd[4];
1888                 if (cmd_type > 2) {
1889                         set_sense_type(chip, lun,
1890                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1891                         rtsx_trace(chip);
1892                         return TRANSPORT_FAILED;
1893                 }
1894                 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1895                 mask = srb->cmnd[7];
1896                 value = srb->cmnd[8];
1897                 rtsx_add_cmd(chip, cmd_type, addr, mask, value);
1898                 break;
1899
1900         case SEND_BATCHCMD:
1901                 retval = rtsx_send_cmd(chip, 0, 1000);
1902                 break;
1903
1904         case GET_BATCHRSP:
1905                 idx = srb->cmnd[4];
1906                 value = *(rtsx_get_cmd_data(chip) + idx);
1907                 if (scsi_bufflen(srb) < 1) {
1908                         set_sense_type(chip, lun,
1909                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1910                         rtsx_trace(chip);
1911                         return TRANSPORT_FAILED;
1912                 }
1913                 rtsx_stor_set_xfer_buf(&value, 1, srb);
1914                 scsi_set_resid(srb, 0);
1915                 break;
1916
1917         default:
1918                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1919                 rtsx_trace(chip);
1920                 return TRANSPORT_FAILED;
1921         }
1922
1923         if (retval != STATUS_SUCCESS) {
1924                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1925                 rtsx_trace(chip);
1926                 return TRANSPORT_FAILED;
1927         }
1928
1929         return TRANSPORT_GOOD;
1930 }
1931
1932 static int suit_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1933 {
1934         switch (srb->cmnd[3]) {
1935         case INIT_BATCHCMD:
1936         case ADD_BATCHCMD:
1937         case SEND_BATCHCMD:
1938         case GET_BATCHRSP:
1939                 return rw_mem_cmd_buf(srb, chip);
1940         default:
1941                 return TRANSPORT_ERROR;
1942         }
1943 }
1944
1945 static int read_phy_register(struct scsi_cmnd *srb, struct rtsx_chip *chip)
1946 {
1947         unsigned short addr, len, i;
1948         int retval;
1949         u8 *buf;
1950         u16 val;
1951
1952         rtsx_disable_aspm(chip);
1953
1954         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
1955                 rtsx_exit_ss(chip);
1956                 wait_timeout(100);
1957         }
1958         rtsx_set_stat(chip, RTSX_STAT_RUN);
1959
1960         addr = ((u16)srb->cmnd[4] << 8) | srb->cmnd[5];
1961         len = ((u16)srb->cmnd[6] << 8) | srb->cmnd[7];
1962
1963         if (len % 2)
1964                 len -= len % 2;
1965
1966         if (len) {
1967                 buf = vmalloc(len);
1968                 if (!buf) {
1969                         rtsx_trace(chip);
1970                         return TRANSPORT_ERROR;
1971                 }
1972
1973                 retval = rtsx_force_power_on(chip, SSC_PDCTL);
1974                 if (retval != STATUS_SUCCESS) {
1975                         vfree(buf);
1976                         set_sense_type(chip, SCSI_LUN(srb),
1977                                 SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1978                         rtsx_trace(chip);
1979                         return TRANSPORT_FAILED;
1980                 }
1981
1982                 for (i = 0; i < len / 2; i++) {
1983                         retval = rtsx_read_phy_register(chip, addr + i, &val);
1984                         if (retval != STATUS_SUCCESS) {
1985                                 vfree(buf);
1986                                 set_sense_type(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 == NULL) {
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 == NULL) {
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 == NULL) {
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
2608 static int read_status(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2609 {
2610         u8 rtsx_status[16];
2611         int buf_len;
2612         unsigned int lun = SCSI_LUN(srb);
2613
2614         rtsx_status[0] = (u8)(chip->vendor_id >> 8);
2615         rtsx_status[1] = (u8)(chip->vendor_id);
2616
2617         rtsx_status[2] = (u8)(chip->product_id >> 8);
2618         rtsx_status[3] = (u8)(chip->product_id);
2619
2620         rtsx_status[4] = (u8)lun;
2621
2622         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2623                 if (chip->lun2card[lun] == SD_CARD)
2624                         rtsx_status[5] = 2;
2625                 else
2626                         rtsx_status[5] = 3;
2627         } else {
2628                 if (chip->card_exist) {
2629                         if (chip->card_exist & XD_CARD)
2630                                 rtsx_status[5] = 4;
2631                         else if (chip->card_exist & SD_CARD)
2632                                 rtsx_status[5] = 2;
2633                         else if (chip->card_exist & MS_CARD)
2634                                 rtsx_status[5] = 3;
2635                         else
2636                                 rtsx_status[5] = 7;
2637                 } else {
2638                         rtsx_status[5] = 7;
2639                 }
2640         }
2641
2642         if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2643                 rtsx_status[6] = 2;
2644         else
2645                 rtsx_status[6] = 1;
2646
2647         rtsx_status[7] = (u8)(chip->product_id);
2648         rtsx_status[8] = chip->ic_version;
2649
2650         if (check_card_exist(chip, lun))
2651                 rtsx_status[9] = 1;
2652         else
2653                 rtsx_status[9] = 0;
2654
2655         if (CHECK_LUN_MODE(chip, SD_MS_2LUN))
2656                 rtsx_status[10] = 0;
2657         else
2658                 rtsx_status[10] = 1;
2659
2660         if (CHECK_LUN_MODE(chip, SD_MS_2LUN)) {
2661                 if (chip->lun2card[lun] == SD_CARD)
2662                         rtsx_status[11] = SD_CARD;
2663                 else
2664                         rtsx_status[11] = MS_CARD;
2665         } else {
2666                 rtsx_status[11] = XD_CARD | SD_CARD | MS_CARD;
2667         }
2668
2669         if (check_card_ready(chip, lun))
2670                 rtsx_status[12] = 1;
2671         else
2672                 rtsx_status[12] = 0;
2673
2674         if (get_lun_card(chip, lun) == XD_CARD) {
2675                 rtsx_status[13] = 0x40;
2676         } else if (get_lun_card(chip, lun) == SD_CARD) {
2677                 struct sd_info *sd_card = &(chip->sd_card);
2678
2679                 rtsx_status[13] = 0x20;
2680                 if (CHK_SD(sd_card)) {
2681                         if (CHK_SD_HCXC(sd_card))
2682                                 rtsx_status[13] |= 0x04;
2683                         if (CHK_SD_HS(sd_card))
2684                                 rtsx_status[13] |= 0x02;
2685                 } else {
2686                         rtsx_status[13] |= 0x08;
2687                         if (CHK_MMC_52M(sd_card))
2688                                 rtsx_status[13] |= 0x02;
2689                         if (CHK_MMC_SECTOR_MODE(sd_card))
2690                                 rtsx_status[13] |= 0x04;
2691                 }
2692         } else if (get_lun_card(chip, lun) == MS_CARD) {
2693                 struct ms_info *ms_card = &(chip->ms_card);
2694
2695                 if (CHK_MSPRO(ms_card)) {
2696                         rtsx_status[13] = 0x38;
2697                         if (CHK_HG8BIT(ms_card))
2698                                 rtsx_status[13] |= 0x04;
2699 #ifdef SUPPORT_MSXC
2700                         if (CHK_MSXC(ms_card))
2701                                 rtsx_status[13] |= 0x01;
2702 #endif
2703                 } else {
2704                         rtsx_status[13] = 0x30;
2705                 }
2706         } else {
2707                 if (CHECK_LUN_MODE(chip, DEFAULT_SINGLE)) {
2708 #ifdef SUPPORT_SDIO
2709                         if (chip->sd_io && chip->sd_int)
2710                                 rtsx_status[13] = 0x60;
2711                         else
2712                                 rtsx_status[13] = 0x70;
2713 #else
2714                         rtsx_status[13] = 0x70;
2715 #endif
2716                 } else {
2717                         if (chip->lun2card[lun] == SD_CARD)
2718                                 rtsx_status[13] = 0x20;
2719                         else
2720                                 rtsx_status[13] = 0x30;
2721                 }
2722         }
2723
2724         rtsx_status[14] = 0x78;
2725         if (CHK_SDIO_EXIST(chip) && !CHK_SDIO_IGNORED(chip))
2726                 rtsx_status[15] = 0x83;
2727         else
2728                 rtsx_status[15] = 0x82;
2729
2730         buf_len = min_t(unsigned int, scsi_bufflen(srb), sizeof(rtsx_status));
2731         rtsx_stor_set_xfer_buf(rtsx_status, buf_len, srb);
2732         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
2733
2734         return TRANSPORT_GOOD;
2735 }
2736
2737 static int get_card_bus_width(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2738 {
2739         unsigned int lun = SCSI_LUN(srb);
2740         u8 card, bus_width;
2741
2742         if (!check_card_ready(chip, lun)) {
2743                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
2744                 rtsx_trace(chip);
2745                 return TRANSPORT_FAILED;
2746         }
2747
2748         card = get_lun_card(chip, lun);
2749         if ((card == SD_CARD) || (card == MS_CARD)) {
2750                 bus_width = chip->card_bus_width[lun];
2751         } else {
2752                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
2753                 rtsx_trace(chip);
2754                 return TRANSPORT_FAILED;
2755         }
2756
2757         scsi_set_resid(srb, 0);
2758         rtsx_stor_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
2759
2760         return TRANSPORT_GOOD;
2761 }
2762
2763 static int spi_vendor_cmd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2764 {
2765         int result;
2766         unsigned int lun = SCSI_LUN(srb);
2767         u8 gpio_dir;
2768
2769         if (CHECK_PID(chip, 0x5208) || CHECK_PID(chip, 0x5288)) {
2770                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2771                 rtsx_trace(chip);
2772                 return TRANSPORT_FAILED;
2773         }
2774
2775         rtsx_disable_aspm(chip);
2776
2777         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
2778                 rtsx_exit_ss(chip);
2779                 wait_timeout(100);
2780         }
2781         rtsx_set_stat(chip, RTSX_STAT_RUN);
2782
2783         rtsx_force_power_on(chip, SSC_PDCTL);
2784
2785         rtsx_read_register(chip, CARD_GPIO_DIR, &gpio_dir);
2786         rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir & 0x06);
2787
2788         switch (srb->cmnd[2]) {
2789         case SCSI_SPI_GETSTATUS:
2790                 result = spi_get_status(srb, chip);
2791                 break;
2792
2793         case SCSI_SPI_SETPARAMETER:
2794                 result = spi_set_parameter(srb, chip);
2795                 break;
2796
2797         case SCSI_SPI_READFALSHID:
2798                 result = spi_read_flash_id(srb, chip);
2799                 break;
2800
2801         case SCSI_SPI_READFLASH:
2802                 result = spi_read_flash(srb, chip);
2803                 break;
2804
2805         case SCSI_SPI_WRITEFLASH:
2806                 result = spi_write_flash(srb, chip);
2807                 break;
2808
2809         case SCSI_SPI_WRITEFLASHSTATUS:
2810                 result = spi_write_flash_status(srb, chip);
2811                 break;
2812
2813         case SCSI_SPI_ERASEFLASH:
2814                 result = spi_erase_flash(srb, chip);
2815                 break;
2816
2817         default:
2818                 rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2819
2820                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2821                 rtsx_trace(chip);
2822                 return TRANSPORT_FAILED;
2823         }
2824
2825         rtsx_write_register(chip, CARD_GPIO_DIR, 0x07, gpio_dir);
2826
2827         if (result != STATUS_SUCCESS) {
2828                 rtsx_trace(chip);
2829                 return TRANSPORT_FAILED;
2830         }
2831
2832         return TRANSPORT_GOOD;
2833 }
2834
2835 static int vendor_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2836 {
2837         int result;
2838
2839         switch (srb->cmnd[1]) {
2840         case READ_STATUS:
2841                 result = read_status(srb, chip);
2842                 break;
2843
2844         case READ_MEM:
2845                 result = read_mem(srb, chip);
2846                 break;
2847
2848         case WRITE_MEM:
2849                 result = write_mem(srb, chip);
2850                 break;
2851
2852         case READ_EEPROM:
2853                 result = read_eeprom(srb, chip);
2854                 break;
2855
2856         case WRITE_EEPROM:
2857                 result = write_eeprom(srb, chip);
2858                 break;
2859
2860         case TOGGLE_GPIO:
2861                 result = toggle_gpio_cmd(srb, chip);
2862                 break;
2863
2864         case GET_SD_CSD:
2865                 result = get_sd_csd(srb, chip);
2866                 break;
2867
2868         case GET_BUS_WIDTH:
2869                 result = get_card_bus_width(srb, chip);
2870                 break;
2871
2872 #ifdef _MSG_TRACE
2873         case TRACE_MSG:
2874                 result = trace_msg_cmd(srb, chip);
2875                 break;
2876 #endif
2877
2878         case SCSI_APP_CMD:
2879                 result = app_cmd(srb, chip);
2880                 break;
2881
2882         case SPI_VENDOR_COMMAND:
2883                 result = spi_vendor_cmd(srb, chip);
2884                 break;
2885
2886         default:
2887                 set_sense_type(chip, SCSI_LUN(srb),
2888                         SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
2889                 rtsx_trace(chip);
2890                 return TRANSPORT_FAILED;
2891         }
2892
2893         return result;
2894 }
2895
2896 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
2897 void led_shine(struct scsi_cmnd *srb, struct rtsx_chip *chip)
2898 {
2899         unsigned int lun = SCSI_LUN(srb);
2900         u16 sec_cnt;
2901
2902         if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10))
2903                 sec_cnt = ((u16)(srb->cmnd[7]) << 8) | srb->cmnd[8];
2904         else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
2905                 sec_cnt = srb->cmnd[4];
2906                 if (sec_cnt == 0)
2907                         sec_cnt = 256;
2908         } else
2909                 return;
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 = data_len = 0x3A;
3030         else
3031                 buf_len = data_len = 0x6A;
3032
3033         buf = kmalloc(buf_len, GFP_KERNEL);
3034         if (!buf) {
3035                 rtsx_trace(chip);
3036                 return TRANSPORT_ERROR;
3037         }
3038
3039         i = 0;
3040         /*  GET Memory Stick Media Information Response Header */
3041         buf[i++] = 0x00;                /* Data length MSB */
3042         buf[i++] = data_len;            /* Data length LSB */
3043         /* Device Information Type Code */
3044         if (CHK_MSXC(ms_card))
3045                 buf[i++] = 0x03;
3046         else
3047                 buf[i++] = 0x02;
3048
3049         /* SGM bit */
3050         buf[i++] = 0x01;
3051         /* Reserved */
3052         buf[i++] = 0x00;
3053         buf[i++] = 0x00;
3054         buf[i++] = 0x00;
3055         /* Number of Device Information */
3056         buf[i++] = 0x01;
3057
3058         /*  Device Information Body */
3059
3060         /* Device Information ID Number */
3061         buf[i++] = dev_info_id;
3062         /* Device Information Length */
3063         if (dev_info_id == 0x15)
3064                 data_len = 0x31;
3065         else
3066                 data_len = 0x61;
3067
3068         buf[i++] = 0x00;                /* Data length MSB */
3069         buf[i++] = data_len;            /* Data length LSB */
3070         /* Valid Bit */
3071         buf[i++] = 0x80;
3072         if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
3073                 /* System Information */
3074                 memcpy(buf+i, ms_card->raw_sys_info, 96);
3075         } else {
3076                 /* Model Name */
3077                 memcpy(buf+i, ms_card->raw_model_name, 48);
3078         }
3079
3080         rtsx_stor_set_xfer_buf(buf, buf_len, srb);
3081
3082         if (dev_info_id == 0x15)
3083                 scsi_set_resid(srb, scsi_bufflen(srb)-0x3C);
3084         else
3085                 scsi_set_resid(srb, scsi_bufflen(srb)-0x6C);
3086
3087         kfree(buf);
3088         return STATUS_SUCCESS;
3089 }
3090 #endif
3091
3092 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3093 {
3094         int retval = TRANSPORT_ERROR;
3095
3096         if (srb->cmnd[2] == MS_FORMAT)
3097                 retval = ms_format_cmnd(srb, chip);
3098 #ifdef SUPPORT_PCGL_1P18
3099         else if (srb->cmnd[2] == GET_MS_INFORMATION)
3100                 retval = get_ms_information(srb, chip);
3101 #endif
3102
3103         return retval;
3104 }
3105
3106 #ifdef SUPPORT_CPRM
3107 static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3108 {
3109         unsigned int lun = SCSI_LUN(srb);
3110         int result;
3111
3112         rtsx_disable_aspm(chip);
3113
3114         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3115                 rtsx_exit_ss(chip);
3116                 wait_timeout(100);
3117         }
3118         rtsx_set_stat(chip, RTSX_STAT_RUN);
3119
3120         sd_cleanup_work(chip);
3121
3122         if (!check_card_ready(chip, lun)) {
3123                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3124                 rtsx_trace(chip);
3125                 return TRANSPORT_FAILED;
3126         }
3127         if (get_lun_card(chip, lun) != SD_CARD) {
3128                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3129                 rtsx_trace(chip);
3130                 return TRANSPORT_FAILED;
3131         }
3132
3133         switch (srb->cmnd[0]) {
3134         case SD_PASS_THRU_MODE:
3135                 result = sd_pass_thru_mode(srb, chip);
3136                 break;
3137
3138         case SD_EXECUTE_NO_DATA:
3139                 result = sd_execute_no_data(srb, chip);
3140                 break;
3141
3142         case SD_EXECUTE_READ:
3143                 result = sd_execute_read_data(srb, chip);
3144                 break;
3145
3146         case SD_EXECUTE_WRITE:
3147                 result = sd_execute_write_data(srb, chip);
3148                 break;
3149
3150         case SD_GET_RSP:
3151                 result = sd_get_cmd_rsp(srb, chip);
3152                 break;
3153
3154         case SD_HW_RST:
3155                 result = sd_hw_rst(srb, chip);
3156                 break;
3157
3158         default:
3159                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3160                 rtsx_trace(chip);
3161                 return TRANSPORT_FAILED;
3162         }
3163
3164         return result;
3165 }
3166 #endif
3167
3168 #ifdef SUPPORT_MAGIC_GATE
3169 static int mg_report_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3170 {
3171         struct ms_info *ms_card = &(chip->ms_card);
3172         unsigned int lun = SCSI_LUN(srb);
3173         int retval;
3174         u8 key_format;
3175
3176         rtsx_disable_aspm(chip);
3177
3178         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3179                 rtsx_exit_ss(chip);
3180                 wait_timeout(100);
3181         }
3182         rtsx_set_stat(chip, RTSX_STAT_RUN);
3183
3184         ms_cleanup_work(chip);
3185
3186         if (!check_card_ready(chip, lun)) {
3187                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3188                 rtsx_trace(chip);
3189                 return TRANSPORT_FAILED;
3190         }
3191         if (get_lun_card(chip, lun) != MS_CARD) {
3192                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3193                 rtsx_trace(chip);
3194                 return TRANSPORT_FAILED;
3195         }
3196
3197         if (srb->cmnd[7] != KC_MG_R_PRO) {
3198                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3199                 rtsx_trace(chip);
3200                 return TRANSPORT_FAILED;
3201         }
3202
3203         if (!CHK_MSPRO(ms_card)) {
3204                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3205                 rtsx_trace(chip);
3206                 return TRANSPORT_FAILED;
3207         }
3208
3209         key_format = srb->cmnd[10] & 0x3F;
3210         dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3211
3212         switch (key_format) {
3213         case KF_GET_LOC_EKB:
3214                 if ((scsi_bufflen(srb) == 0x41C) &&
3215                         (srb->cmnd[8] == 0x04) &&
3216                         (srb->cmnd[9] == 0x1C)) {
3217                         retval = mg_get_local_EKB(srb, chip);
3218                         if (retval != STATUS_SUCCESS) {
3219                                 rtsx_trace(chip);
3220                                 return TRANSPORT_FAILED;
3221                         }
3222
3223                 } else {
3224                         set_sense_type(chip, lun,
3225                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3226                         rtsx_trace(chip);
3227                         return TRANSPORT_FAILED;
3228                 }
3229                 break;
3230
3231         case KF_RSP_CHG:
3232                 if ((scsi_bufflen(srb) == 0x24) &&
3233                         (srb->cmnd[8] == 0x00) &&
3234                         (srb->cmnd[9] == 0x24)) {
3235                         retval = mg_get_rsp_chg(srb, chip);
3236                         if (retval != STATUS_SUCCESS) {
3237                                 rtsx_trace(chip);
3238                                 return TRANSPORT_FAILED;
3239                         }
3240
3241                 } else {
3242                         set_sense_type(chip, lun,
3243                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3244                         rtsx_trace(chip);
3245                         return TRANSPORT_FAILED;
3246                 }
3247                 break;
3248
3249         case KF_GET_ICV:
3250                 ms_card->mg_entry_num = srb->cmnd[5];
3251                 if ((scsi_bufflen(srb) == 0x404) &&
3252                         (srb->cmnd[8] == 0x04) &&
3253                         (srb->cmnd[9] == 0x04) &&
3254                         (srb->cmnd[2] == 0x00) &&
3255                         (srb->cmnd[3] == 0x00) &&
3256                         (srb->cmnd[4] == 0x00) &&
3257                         (srb->cmnd[5] < 32)) {
3258                         retval = mg_get_ICV(srb, chip);
3259                         if (retval != STATUS_SUCCESS) {
3260                                 rtsx_trace(chip);
3261                                 return TRANSPORT_FAILED;
3262                         }
3263
3264                 } else {
3265                         set_sense_type(chip, lun,
3266                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3267                         rtsx_trace(chip);
3268                         return TRANSPORT_FAILED;
3269                 }
3270                 break;
3271
3272         default:
3273                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3274                 rtsx_trace(chip);
3275                 return TRANSPORT_FAILED;
3276         }
3277
3278         scsi_set_resid(srb, 0);
3279         return TRANSPORT_GOOD;
3280 }
3281
3282 static int mg_send_key(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3283 {
3284         struct ms_info *ms_card = &(chip->ms_card);
3285         unsigned int lun = SCSI_LUN(srb);
3286         int retval;
3287         u8 key_format;
3288
3289         rtsx_disable_aspm(chip);
3290
3291         if (chip->ss_en && (rtsx_get_stat(chip) == RTSX_STAT_SS)) {
3292                 rtsx_exit_ss(chip);
3293                 wait_timeout(100);
3294         }
3295         rtsx_set_stat(chip, RTSX_STAT_RUN);
3296
3297         ms_cleanup_work(chip);
3298
3299         if (!check_card_ready(chip, lun)) {
3300                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
3301                 rtsx_trace(chip);
3302                 return TRANSPORT_FAILED;
3303         }
3304         if (check_card_wp(chip, lun)) {
3305                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
3306                 rtsx_trace(chip);
3307                 return TRANSPORT_FAILED;
3308         }
3309         if (get_lun_card(chip, lun) != MS_CARD) {
3310                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
3311                 rtsx_trace(chip);
3312                 return TRANSPORT_FAILED;
3313         }
3314
3315         if (srb->cmnd[7] != KC_MG_R_PRO) {
3316                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3317                 rtsx_trace(chip);
3318                 return TRANSPORT_FAILED;
3319         }
3320
3321         if (!CHK_MSPRO(ms_card)) {
3322                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
3323                 rtsx_trace(chip);
3324                 return TRANSPORT_FAILED;
3325         }
3326
3327         key_format = srb->cmnd[10] & 0x3F;
3328         dev_dbg(rtsx_dev(chip), "key_format = 0x%x\n", key_format);
3329
3330         switch (key_format) {
3331         case KF_SET_LEAF_ID:
3332                 if ((scsi_bufflen(srb) == 0x0C) &&
3333                         (srb->cmnd[8] == 0x00) &&
3334                         (srb->cmnd[9] == 0x0C)) {
3335                         retval = mg_set_leaf_id(srb, chip);
3336                         if (retval != STATUS_SUCCESS) {
3337                                 rtsx_trace(chip);
3338                                 return TRANSPORT_FAILED;
3339                         }
3340
3341                 } else {
3342                         set_sense_type(chip, lun,
3343                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3344                         rtsx_trace(chip);
3345                         return TRANSPORT_FAILED;
3346                 }
3347                 break;
3348
3349         case KF_CHG_HOST:
3350                 if ((scsi_bufflen(srb) == 0x0C) &&
3351                         (srb->cmnd[8] == 0x00) &&
3352                         (srb->cmnd[9] == 0x0C)) {
3353                         retval = mg_chg(srb, chip);
3354                         if (retval != STATUS_SUCCESS) {
3355                                 rtsx_trace(chip);
3356                                 return TRANSPORT_FAILED;
3357                         }
3358
3359                 } else {
3360                         set_sense_type(chip, lun,
3361                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3362                         rtsx_trace(chip);
3363                         return TRANSPORT_FAILED;
3364                 }
3365                 break;
3366
3367         case KF_RSP_HOST:
3368                 if ((scsi_bufflen(srb) == 0x0C) &&
3369                         (srb->cmnd[8] == 0x00) &&
3370                         (srb->cmnd[9] == 0x0C)) {
3371                         retval = mg_rsp(srb, chip);
3372                         if (retval != STATUS_SUCCESS) {
3373                                 rtsx_trace(chip);
3374                                 return TRANSPORT_FAILED;
3375                         }
3376
3377                 } else {
3378                         set_sense_type(chip, lun,
3379                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3380                         rtsx_trace(chip);
3381                         return TRANSPORT_FAILED;
3382                 }
3383                 break;
3384
3385         case KF_SET_ICV:
3386                 ms_card->mg_entry_num = srb->cmnd[5];
3387                 if ((scsi_bufflen(srb) == 0x404) &&
3388                         (srb->cmnd[8] == 0x04) &&
3389                         (srb->cmnd[9] == 0x04) &&
3390                         (srb->cmnd[2] == 0x00) &&
3391                         (srb->cmnd[3] == 0x00) &&
3392                         (srb->cmnd[4] == 0x00) &&
3393                         (srb->cmnd[5] < 32)) {
3394                         retval = mg_set_ICV(srb, chip);
3395                         if (retval != STATUS_SUCCESS) {
3396                                 rtsx_trace(chip);
3397                                 return TRANSPORT_FAILED;
3398                         }
3399
3400                 } else {
3401                         set_sense_type(chip, lun,
3402                                 SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3403                         rtsx_trace(chip);
3404                         return TRANSPORT_FAILED;
3405                 }
3406                 break;
3407
3408         default:
3409                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3410                 rtsx_trace(chip);
3411                 return TRANSPORT_FAILED;
3412         }
3413
3414         scsi_set_resid(srb, 0);
3415         return TRANSPORT_GOOD;
3416 }
3417 #endif
3418
3419 int rtsx_scsi_handler(struct scsi_cmnd *srb, struct rtsx_chip *chip)
3420 {
3421 #ifdef SUPPORT_SD_LOCK
3422         struct sd_info *sd_card = &(chip->sd_card);
3423 #endif
3424         struct ms_info *ms_card = &(chip->ms_card);
3425         unsigned int lun = SCSI_LUN(srb);
3426         int result;
3427
3428 #ifdef SUPPORT_SD_LOCK
3429         if (sd_card->sd_erase_status) {
3430                 /* Block all SCSI command except for
3431                  * REQUEST_SENSE and rs_ppstatus
3432                  */
3433                 if (!((srb->cmnd[0] == VENDOR_CMND) &&
3434                                 (srb->cmnd[1] == SCSI_APP_CMD) &&
3435                                 (srb->cmnd[2] == GET_DEV_STATUS)) &&
3436                                 (srb->cmnd[0] != REQUEST_SENSE)) {
3437                         /* Logical Unit Not Ready Format in Progress */
3438                         set_sense_data(chip, lun, CUR_ERR,
3439                                        0x02, 0, 0x04, 0x04, 0, 0);
3440                         rtsx_trace(chip);
3441                         return TRANSPORT_FAILED;
3442                 }
3443         }
3444 #endif
3445
3446         if ((get_lun_card(chip, lun) == MS_CARD) &&
3447                         (ms_card->format_status == FORMAT_IN_PROGRESS)) {
3448                 if ((srb->cmnd[0] != REQUEST_SENSE) &&
3449                         (srb->cmnd[0] != INQUIRY)) {
3450                         /* Logical Unit Not Ready Format in Progress */
3451                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
3452                                         0, (u16)(ms_card->progress));
3453                         rtsx_trace(chip);
3454                         return TRANSPORT_FAILED;
3455                 }
3456         }
3457
3458         switch (srb->cmnd[0]) {
3459         case READ_10:
3460         case WRITE_10:
3461         case READ_6:
3462         case WRITE_6:
3463                 result = read_write(srb, chip);
3464 #if !defined(LED_AUTO_BLINK) && !defined(REGULAR_BLINK)
3465                 led_shine(srb, chip);
3466 #endif
3467                 break;
3468
3469         case TEST_UNIT_READY:
3470                 result = test_unit_ready(srb, chip);
3471                 break;
3472
3473         case INQUIRY:
3474                 result = inquiry(srb, chip);
3475                 break;
3476
3477         case READ_CAPACITY:
3478                 result = read_capacity(srb, chip);
3479                 break;
3480
3481         case START_STOP:
3482                 result = start_stop_unit(srb, chip);
3483                 break;
3484
3485         case ALLOW_MEDIUM_REMOVAL:
3486                 result = allow_medium_removal(srb, chip);
3487                 break;
3488
3489         case REQUEST_SENSE:
3490                 result = request_sense(srb, chip);
3491                 break;
3492
3493         case MODE_SENSE:
3494         case MODE_SENSE_10:
3495                 result = mode_sense(srb, chip);
3496                 break;
3497
3498         case 0x23:
3499                 result = read_format_capacity(srb, chip);
3500                 break;
3501
3502         case VENDOR_CMND:
3503                 result = vendor_cmnd(srb, chip);
3504                 break;
3505
3506         case MS_SP_CMND:
3507                 result = ms_sp_cmnd(srb, chip);
3508                 break;
3509
3510 #ifdef SUPPORT_CPRM
3511         case SD_PASS_THRU_MODE:
3512         case SD_EXECUTE_NO_DATA:
3513         case SD_EXECUTE_READ:
3514         case SD_EXECUTE_WRITE:
3515         case SD_GET_RSP:
3516         case SD_HW_RST:
3517                 result = sd_extention_cmnd(srb, chip);
3518                 break;
3519 #endif
3520
3521 #ifdef SUPPORT_MAGIC_GATE
3522         case CMD_MSPRO_MG_RKEY:
3523                 result = mg_report_key(srb, chip);
3524                 break;
3525
3526         case CMD_MSPRO_MG_SKEY:
3527                 result = mg_send_key(srb, chip);
3528                 break;
3529 #endif
3530
3531         case FORMAT_UNIT:
3532         case MODE_SELECT:
3533         case VERIFY:
3534                 result = TRANSPORT_GOOD;
3535                 break;
3536
3537         default:
3538                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
3539                 result = TRANSPORT_FAILED;
3540         }
3541
3542         return result;
3543 }