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