kernel/drivers/staging/rts5208/rtsx_scsi.c

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