drivers/staging/rts5139/rts51x_scsi.c

   1 /* Driver for Realtek RTS51xx USB card reader
   2  *
   3  * Copyright(c) 2009 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  *   wwang (wei_wang@realsil.com.cn)
  20  *   No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
  21  * Maintainer:
  22  *   Edwin Rong (edwin_rong@realsil.com.cn)
  23  *   No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
  24  */
  25
  26 #include <linux/blkdev.h>
  27 #include <linux/kthread.h>
  28 #include <linux/sched.h>
  29 #include <linux/slab.h>
  30 #include <linux/vmalloc.h>
  31
  32 #include <scsi/scsi.h>
  33 #include <scsi/scsi_eh.h>
  34 #include <scsi/scsi_device.h>
  35
  36 #include "debug.h"
  37 #include "rts51x.h"
  38 #include "rts51x_chip.h"
  39 #include "rts51x_scsi.h"
  40 #include "rts51x_card.h"
  41 #include "rts51x_transport.h"
  42 #include "rts51x_sys.h"
  43 #include "sd_cprm.h"
  44 #include "ms_mg.h"
  45 #include "trace.h"
  46
  47 void scsi_show_command(struct scsi_cmnd *srb)
  48 {
  49         char *what = NULL;
  50         int i, unknown_cmd = 0;
  51
  52         switch (srb->cmnd[0]) {
  53         case TEST_UNIT_READY:
  54                 what = (char *)"TEST_UNIT_READY";
  55                 break;
  56         case REZERO_UNIT:
  57                 what = (char *)"REZERO_UNIT";
  58                 break;
  59         case REQUEST_SENSE:
  60                 what = (char *)"REQUEST_SENSE";
  61                 break;
  62         case FORMAT_UNIT:
  63                 what = (char *)"FORMAT_UNIT";
  64                 break;
  65         case READ_BLOCK_LIMITS:
  66                 what = (char *)"READ_BLOCK_LIMITS";
  67                 break;
  68         case 0x07:
  69                 what = (char *)"REASSIGN_BLOCKS";
  70                 break;
  71         case READ_6:
  72                 what = (char *)"READ_6";
  73                 break;
  74         case WRITE_6:
  75                 what = (char *)"WRITE_6";
  76                 break;
  77         case SEEK_6:
  78                 what = (char *)"SEEK_6";
  79                 break;
  80         case READ_REVERSE:
  81                 what = (char *)"READ_REVERSE";
  82                 break;
  83         case WRITE_FILEMARKS:
  84                 what = (char *)"WRITE_FILEMARKS";
  85                 break;
  86         case SPACE:
  87                 what = (char *)"SPACE";
  88                 break;
  89         case INQUIRY:
  90                 what = (char *)"INQUIRY";
  91                 break;
  92         case RECOVER_BUFFERED_DATA:
  93                 what = (char *)"RECOVER_BUFFERED_DATA";
  94                 break;
  95         case MODE_SELECT:
  96                 what = (char *)"MODE_SELECT";
  97                 break;
  98         case RESERVE:
  99                 what = (char *)"RESERVE";
 100                 break;
 101         case RELEASE:
 102                 what = (char *)"RELEASE";
 103                 break;
 104         case COPY:
 105                 what = (char *)"COPY";
 106                 break;
 107         case ERASE:
 108                 what = (char *)"ERASE";
 109                 break;
 110         case MODE_SENSE:
 111                 what = (char *)"MODE_SENSE";
 112                 break;
 113         case START_STOP:
 114                 what = (char *)"START_STOP";
 115                 break;
 116         case RECEIVE_DIAGNOSTIC:
 117                 what = (char *)"RECEIVE_DIAGNOSTIC";
 118                 break;
 119         case SEND_DIAGNOSTIC:
 120                 what = (char *)"SEND_DIAGNOSTIC";
 121                 break;
 122         case ALLOW_MEDIUM_REMOVAL:
 123                 what = (char *)"ALLOW_MEDIUM_REMOVAL";
 124                 break;
 125         case SET_WINDOW:
 126                 what = (char *)"SET_WINDOW";
 127                 break;
 128         case READ_CAPACITY:
 129                 what = (char *)"READ_CAPACITY";
 130                 break;
 131         case READ_10:
 132                 what = (char *)"READ_10";
 133                 break;
 134         case WRITE_10:
 135                 what = (char *)"WRITE_10";
 136                 break;
 137         case SEEK_10:
 138                 what = (char *)"SEEK_10";
 139                 break;
 140         case WRITE_VERIFY:
 141                 what = (char *)"WRITE_VERIFY";
 142                 break;
 143         case VERIFY:
 144                 what = (char *)"VERIFY";
 145                 break;
 146         case SEARCH_HIGH:
 147                 what = (char *)"SEARCH_HIGH";
 148                 break;
 149         case SEARCH_EQUAL:
 150                 what = (char *)"SEARCH_EQUAL";
 151                 break;
 152         case SEARCH_LOW:
 153                 what = (char *)"SEARCH_LOW";
 154                 break;
 155         case SET_LIMITS:
 156                 what = (char *)"SET_LIMITS";
 157                 break;
 158         case READ_POSITION:
 159                 what = (char *)"READ_POSITION";
 160                 break;
 161         case SYNCHRONIZE_CACHE:
 162                 what = (char *)"SYNCHRONIZE_CACHE";
 163                 break;
 164         case LOCK_UNLOCK_CACHE:
 165                 what = (char *)"LOCK_UNLOCK_CACHE";
 166                 break;
 167         case READ_DEFECT_DATA:
 168                 what = (char *)"READ_DEFECT_DATA";
 169                 break;
 170         case MEDIUM_SCAN:
 171                 what = (char *)"MEDIUM_SCAN";
 172                 break;
 173         case COMPARE:
 174                 what = (char *)"COMPARE";
 175                 break;
 176         case COPY_VERIFY:
 177                 what = (char *)"COPY_VERIFY";
 178                 break;
 179         case WRITE_BUFFER:
 180                 what = (char *)"WRITE_BUFFER";
 181                 break;
 182         case READ_BUFFER:
 183                 what = (char *)"READ_BUFFER";
 184                 break;
 185         case UPDATE_BLOCK:
 186                 what = (char *)"UPDATE_BLOCK";
 187                 break;
 188         case READ_LONG:
 189                 what = (char *)"READ_LONG";
 190                 break;
 191         case WRITE_LONG:
 192                 what = (char *)"WRITE_LONG";
 193                 break;
 194         case CHANGE_DEFINITION:
 195                 what = (char *)"CHANGE_DEFINITION";
 196                 break;
 197         case WRITE_SAME:
 198                 what = (char *)"WRITE_SAME";
 199                 break;
 200         case GPCMD_READ_SUBCHANNEL:
 201                 what = (char *)"READ SUBCHANNEL";
 202                 break;
 203         case READ_TOC:
 204                 what = (char *)"READ_TOC";
 205                 break;
 206         case GPCMD_READ_HEADER:
 207                 what = (char *)"READ HEADER";
 208                 break;
 209         case GPCMD_PLAY_AUDIO_10:
 210                 what = (char *)"PLAY AUDIO (10)";
 211                 break;
 212         case GPCMD_PLAY_AUDIO_MSF:
 213                 what = (char *)"PLAY AUDIO MSF";
 214                 break;
 215         case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
 216                 what = (char *)"GET EVENT/STATUS NOTIFICATION";
 217                 break;
 218         case GPCMD_PAUSE_RESUME:
 219                 what = (char *)"PAUSE/RESUME";
 220                 break;
 221         case LOG_SELECT:
 222                 what = (char *)"LOG_SELECT";
 223                 break;
 224         case LOG_SENSE:
 225                 what = (char *)"LOG_SENSE";
 226                 break;
 227         case GPCMD_STOP_PLAY_SCAN:
 228                 what = (char *)"STOP PLAY/SCAN";
 229                 break;
 230         case GPCMD_READ_DISC_INFO:
 231                 what = (char *)"READ DISC INFORMATION";
 232                 break;
 233         case GPCMD_READ_TRACK_RZONE_INFO:
 234                 what = (char *)"READ TRACK INFORMATION";
 235                 break;
 236         case GPCMD_RESERVE_RZONE_TRACK:
 237                 what = (char *)"RESERVE TRACK";
 238                 break;
 239         case GPCMD_SEND_OPC:
 240                 what = (char *)"SEND OPC";
 241                 break;
 242         case MODE_SELECT_10:
 243                 what = (char *)"MODE_SELECT_10";
 244                 break;
 245         case GPCMD_REPAIR_RZONE_TRACK:
 246                 what = (char *)"REPAIR TRACK";
 247                 break;
 248         case 0x59:
 249                 what = (char *)"READ MASTER CUE";
 250                 break;
 251         case MODE_SENSE_10:
 252                 what = (char *)"MODE_SENSE_10";
 253                 break;
 254         case GPCMD_CLOSE_TRACK:
 255                 what = (char *)"CLOSE TRACK/SESSION";
 256                 break;
 257         case 0x5C:
 258                 what = (char *)"READ BUFFER CAPACITY";
 259                 break;
 260         case 0x5D:
 261                 what = (char *)"SEND CUE SHEET";
 262                 break;
 263         case GPCMD_BLANK:
 264                 what = (char *)"BLANK";
 265                 break;
 266         case REPORT_LUNS:
 267                 what = (char *)"REPORT LUNS";
 268                 break;
 269         case MOVE_MEDIUM:
 270                 what = (char *)"MOVE_MEDIUM or PLAY AUDIO (12)";
 271                 break;
 272         case READ_12:
 273                 what = (char *)"READ_12";
 274                 break;
 275         case WRITE_12:
 276                 what = (char *)"WRITE_12";
 277                 break;
 278         case WRITE_VERIFY_12:
 279                 what = (char *)"WRITE_VERIFY_12";
 280                 break;
 281         case SEARCH_HIGH_12:
 282                 what = (char *)"SEARCH_HIGH_12";
 283                 break;
 284         case SEARCH_EQUAL_12:
 285                 what = (char *)"SEARCH_EQUAL_12";
 286                 break;
 287         case SEARCH_LOW_12:
 288                 what = (char *)"SEARCH_LOW_12";
 289                 break;
 290         case SEND_VOLUME_TAG:
 291                 what = (char *)"SEND_VOLUME_TAG";
 292                 break;
 293         case READ_ELEMENT_STATUS:
 294                 what = (char *)"READ_ELEMENT_STATUS";
 295                 break;
 296         case GPCMD_READ_CD_MSF:
 297                 what = (char *)"READ CD MSF";
 298                 break;
 299         case GPCMD_SCAN:
 300                 what = (char *)"SCAN";
 301                 break;
 302         case GPCMD_SET_SPEED:
 303                 what = (char *)"SET CD SPEED";
 304                 break;
 305         case GPCMD_MECHANISM_STATUS:
 306                 what = (char *)"MECHANISM STATUS";
 307                 break;
 308         case GPCMD_READ_CD:
 309                 what = (char *)"READ CD";
 310                 break;
 311         case 0xE1:
 312                 what = (char *)"WRITE CONTINUE";
 313                 break;
 314         case WRITE_LONG_2:
 315                 what = (char *)"WRITE_LONG_2";
 316                 break;
 317         case VENDOR_CMND:
 318                 what = (char *)"Realtek's vendor command";
 319                 break;
 320         default:
 321                 what = (char *)"(unknown command)";
 322                 unknown_cmd = 1;
 323                 break;
 324         }
 325
 326         if (srb->cmnd[0] != TEST_UNIT_READY)
 327                 RTS51X_DEBUGP("Command %s (%d bytes)\n", what, srb->cmd_len);
 328         if (unknown_cmd) {
 329                 RTS51X_DEBUGP("");
 330                 for (i = 0; i < srb->cmd_len && i < 16; i++)
 331                         RTS51X_DEBUGPN(" %02x", srb->cmnd[i]);
 332                 RTS51X_DEBUGPN("\n");
 333         }
 334 }
 335
 336 void set_sense_type(struct rts51x_chip *chip, unsigned int lun, int sense_type)
 337 {
 338         switch (sense_type) {
 339         case SENSE_TYPE_MEDIA_CHANGE:
 340                 set_sense_data(chip, lun, CUR_ERR, 0x06, 0, 0x28, 0, 0, 0);
 341                 break;
 342
 343         case SENSE_TYPE_MEDIA_NOT_PRESENT:
 344                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x3A, 0, 0, 0);
 345                 break;
 346
 347         case SENSE_TYPE_MEDIA_LBA_OVER_RANGE:
 348                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x21, 0, 0, 0);
 349                 break;
 350
 351         case SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT:
 352                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x25, 0, 0, 0);
 353                 break;
 354
 355         case SENSE_TYPE_MEDIA_WRITE_PROTECT:
 356                 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x27, 0, 0, 0);
 357                 break;
 358
 359         case SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR:
 360                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x11, 0, 0, 0);
 361                 break;
 362
 363         case SENSE_TYPE_MEDIA_WRITE_ERR:
 364                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x02, 0, 0);
 365                 break;
 366
 367         case SENSE_TYPE_MEDIA_INVALID_CMD_FIELD:
 368                 set_sense_data(chip, lun, CUR_ERR, ILGAL_REQ, 0,
 369                                ASC_INVLD_CDB, ASCQ_INVLD_CDB, CDB_ILLEGAL, 1);
 370                 break;
 371
 372         case SENSE_TYPE_FORMAT_IN_PROGRESS:
 373                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04, 0, 0);
 374                 break;
 375
 376         case SENSE_TYPE_FORMAT_CMD_FAILED:
 377                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x31, 0x01, 0, 0);
 378                 break;
 379
 380 #ifdef SUPPORT_MAGIC_GATE
 381         case SENSE_TYPE_MG_KEY_FAIL_NOT_ESTAB:
 382                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x02, 0, 0);
 383                 break;
 384
 385         case SENSE_TYPE_MG_KEY_FAIL_NOT_AUTHEN:
 386                 set_sense_data(chip, lun, CUR_ERR, 0x05, 0, 0x6F, 0x00, 0, 0);
 387                 break;
 388
 389         case SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM:
 390                 set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x30, 0x00, 0, 0);
 391                 break;
 392
 393         case SENSE_TYPE_MG_WRITE_ERR:
 394                 set_sense_data(chip, lun, CUR_ERR, 0x03, 0, 0x0C, 0x00, 0, 0);
 395                 break;
 396 #endif
 397
 398 #ifdef SUPPORT_SD_LOCK
 399         case SENSE_TYPE_MEDIA_READ_FORBIDDEN:
 400                 set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x11, 0x13, 0, 0);
 401                 break;
 402 #endif
 403
 404         case SENSE_TYPE_NO_SENSE:
 405         default:
 406                 set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0);
 407                 break;
 408         }
 409 }
 410
 411 void set_sense_data(struct rts51x_chip *chip, unsigned int lun, u8 err_code,
 412                     u8 sense_key, u32 info, u8 asc, u8 ascq, u8 sns_key_info0,
 413                     u16 sns_key_info1)
 414 {
 415         struct sense_data_t *sense = &(chip->sense_buffer[lun]);
 416
 417         sense->err_code = err_code;
 418         sense->sense_key = sense_key;
 419         sense->info[0] = (u8) (info >> 24);
 420         sense->info[1] = (u8) (info >> 16);
 421         sense->info[2] = (u8) (info >> 8);
 422         sense->info[3] = (u8) info;
 423
 424         sense->ad_sense_len = sizeof(struct sense_data_t) - 8;
 425         sense->asc = asc;
 426         sense->ascq = ascq;
 427         if (sns_key_info0 != 0) {
 428                 sense->sns_key_info[0] = SKSV | sns_key_info0;
 429                 sense->sns_key_info[1] = (sns_key_info1 & 0xf0) >> 8;
 430                 sense->sns_key_info[2] = sns_key_info1 & 0x0f;
 431         }
 432 }
 433
 434 static int test_unit_ready(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 435 {
 436         unsigned int lun = SCSI_LUN(srb);
 437
 438         rts51x_init_cards(chip);
 439
 440         if (!check_card_ready(chip, lun)) {
 441                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 442                 return TRANSPORT_FAILED;
 443         }
 444
 445         if (!check_lun_mc(chip, lun)) {
 446                 set_lun_mc(chip, lun);
 447                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 448                 return TRANSPORT_FAILED;
 449         }
 450 #ifdef SUPPORT_SD_LOCK
 451         if (get_lun_card(chip, SCSI_LUN(srb)) == SD_CARD) {
 452                 struct sd_info *sd_card = &(chip->sd_card);
 453                 if (sd_card->sd_lock_notify) {
 454                         sd_card->sd_lock_notify = 0;
 455                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 456                         return TRANSPORT_FAILED;
 457                 } else if (sd_card->sd_lock_status & SD_LOCKED) {
 458                         set_sense_type(chip, lun,
 459                                        SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 460                         return TRANSPORT_FAILED;
 461                 }
 462         }
 463 #endif
 464
 465         return TRANSPORT_GOOD;
 466 }
 467
 468 unsigned char formatter_inquiry_str[20] = {
 469         'M', 'E', 'M', 'O', 'R', 'Y', 'S', 'T', 'I', 'C', 'K',
 470         '-', 'M', 'G',          /* Byte[47:49] */
 471         0x0B,                   /* Byte[50]: MG, MS, MSPro, MSXC */
 472         0x00,                   /* Byte[51]: Category Specific Commands */
 473         0x00,                   /* Byte[52]: Access Control and feature */
 474         0x20, 0x20, 0x20,       /* Byte[53:55] */
 475 };
 476
 477 static int inquiry(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 478 {
 479         unsigned int lun = SCSI_LUN(srb);
 480         char *inquiry_default = (char *)"Generic-xD/SD/M.S.      1.00 ";
 481         char *inquiry_string;
 482         unsigned char sendbytes;
 483         unsigned char *buf;
 484         u8 card = get_lun_card(chip, lun);
 485         int pro_formatter_flag = 0;
 486         unsigned char inquiry_buf[] = {
 487                 QULIFIRE | DRCT_ACCESS_DEV,
 488                 RMB_DISC | 0x0D,
 489                 0x00,
 490                 0x01,
 491                 0x1f,
 492                 0x02,
 493                 0,
 494                 REL_ADR | WBUS_32 | WBUS_16 | SYNC | LINKED | CMD_QUE | SFT_RE,
 495         };
 496
 497         inquiry_string = inquiry_default;
 498
 499         buf = vmalloc(scsi_bufflen(srb));
 500         if (buf == NULL)
 501                 TRACE_RET(chip, TRANSPORT_ERROR);
 502
 503         if (MS_FORMATTER_ENABLED(chip) && (get_lun2card(chip, lun) & MS_CARD)) {
 504                 if (!card || (card == MS_CARD))
 505                         pro_formatter_flag = 1;
 506         }
 507
 508         if (pro_formatter_flag) {
 509                 if (scsi_bufflen(srb) < 56)
 510                         sendbytes = (unsigned char)(scsi_bufflen(srb));
 511                 else
 512                         sendbytes = 56;
 513         } else {
 514                 if (scsi_bufflen(srb) < 36)
 515                         sendbytes = (unsigned char)(scsi_bufflen(srb));
 516                 else
 517                         sendbytes = 36;
 518         }
 519
 520         if (sendbytes > 8) {
 521                 memcpy(buf, inquiry_buf, 8);
 522                 memcpy(buf + 8, inquiry_string, sendbytes - 8);
 523                 if (pro_formatter_flag)
 524                         buf[4] = 0x33;  /* Additional Length */
 525         } else {
 526                 memcpy(buf, inquiry_buf, sendbytes);
 527         }
 528
 529         if (pro_formatter_flag) {
 530                 if (sendbytes > 36)
 531                         memcpy(buf + 36, formatter_inquiry_str, sendbytes - 36);
 532         }
 533
 534         scsi_set_resid(srb, 0);
 535
 536         rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
 537         vfree(buf);
 538
 539         return TRANSPORT_GOOD;
 540 }
 541
 542 static int start_stop_unit(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 543 {
 544         unsigned int lun = SCSI_LUN(srb);
 545
 546         scsi_set_resid(srb, scsi_bufflen(srb));
 547
 548         if (srb->cmnd[1] == 1)
 549                 return TRANSPORT_GOOD;
 550
 551         switch (srb->cmnd[0x4]) {
 552         case STOP_MEDIUM:
 553                 /* Media disabled */
 554                 return TRANSPORT_GOOD;
 555
 556         case UNLOAD_MEDIUM:
 557                 /* Media shall be unload */
 558                 if (check_card_ready(chip, lun))
 559                         eject_card(chip, lun);
 560                 return TRANSPORT_GOOD;
 561
 562         case MAKE_MEDIUM_READY:
 563         case LOAD_MEDIUM:
 564                 if (check_card_ready(chip, lun)) {
 565                         return TRANSPORT_GOOD;
 566                 } else {
 567                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 568                         TRACE_RET(chip, TRANSPORT_FAILED);
 569                 }
 570
 571                 break;
 572         }
 573
 574         TRACE_RET(chip, TRANSPORT_ERROR);
 575 }
 576
 577 static int allow_medium_removal(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 578 {
 579         int prevent;
 580
 581         prevent = srb->cmnd[4] & 0x1;
 582
 583         scsi_set_resid(srb, 0);
 584
 585         if (prevent) {
 586                 set_sense_type(chip, SCSI_LUN(srb),
 587                                SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 588                 TRACE_RET(chip, TRANSPORT_FAILED);
 589         }
 590
 591         return TRANSPORT_GOOD;
 592 }
 593
 594 static void ms_mode_sense(struct rts51x_chip *chip, u8 cmd,
 595                           int lun, u8 *buf, int buf_len)
 596 {
 597         struct ms_info *ms_card = &(chip->ms_card);
 598         int sys_info_offset;
 599         int data_size = buf_len;
 600         int support_format = 0;
 601         int i = 0;
 602
 603         if (cmd == MODE_SENSE) {
 604                 sys_info_offset = 8;
 605                 if (data_size > 0x68)
 606                         data_size = 0x68;
 607                 buf[i++] = 0x67;        /* Mode Data Length */
 608         } else {
 609                 sys_info_offset = 12;
 610                 if (data_size > 0x6C)
 611                         data_size = 0x6C;
 612                 buf[i++] = 0x00;        /* Mode Data Length (MSB) */
 613                 buf[i++] = 0x6A;        /* Mode Data Length (LSB) */
 614         }
 615
 616         /* Medium Type Code */
 617         if (check_card_ready(chip, lun)) {
 618                 if (CHK_MSXC(ms_card)) {
 619                         support_format = 1;
 620                         buf[i++] = 0x40;
 621                 } else if (CHK_MSPRO(ms_card)) {
 622                         support_format = 1;
 623                         buf[i++] = 0x20;
 624                 } else {
 625                         buf[i++] = 0x10;
 626                 }
 627
 628                 /* WP */
 629                 if (check_card_wp(chip, lun))
 630                         buf[i++] = 0x80;
 631                 else
 632                         buf[i++] = 0x00;
 633         } else {
 634                 buf[i++] = 0x00;        /* MediaType */
 635                 buf[i++] = 0x00;        /* WP */
 636         }
 637
 638         buf[i++] = 0x00;        /* Reserved */
 639
 640         if (cmd == MODE_SENSE_10) {
 641                 buf[i++] = 0x00;        /* Reserved */
 642                 buf[i++] = 0x00;        /* Block descriptor length(MSB) */
 643                 buf[i++] = 0x00;        /* Block descriptor length(LSB) */
 644
 645                 /* The Following Data is the content of "Page 0x20" */
 646                 if (data_size >= 9)
 647                         buf[i++] = 0x20;        /* Page Code */
 648                 if (data_size >= 10)
 649                         buf[i++] = 0x62;        /* Page Length */
 650                 if (data_size >= 11)
 651                         buf[i++] = 0x00;        /* No Access Control */
 652                 if (data_size >= 12) {
 653                         if (support_format)
 654                                 buf[i++] = 0xC0;        /* SF, SGM */
 655                         else
 656                                 buf[i++] = 0x00;
 657                 }
 658         } else {
 659                 /* The Following Data is the content of "Page 0x20" */
 660                 if (data_size >= 5)
 661                         buf[i++] = 0x20;        /* Page Code */
 662                 if (data_size >= 6)
 663                         buf[i++] = 0x62;        /* Page Length */
 664                 if (data_size >= 7)
 665                         buf[i++] = 0x00;        /* No Access Control */
 666                 if (data_size >= 8) {
 667                         if (support_format)
 668                                 buf[i++] = 0xC0;        /* SF, SGM */
 669                         else
 670                                 buf[i++] = 0x00;
 671                 }
 672         }
 673
 674         if (data_size > sys_info_offset) {
 675                 /* 96 Bytes Attribute Data */
 676                 int len = data_size - sys_info_offset;
 677                 len = (len < 96) ? len : 96;
 678
 679                 memcpy(buf + sys_info_offset, ms_card->raw_sys_info, len);
 680         }
 681 }
 682
 683 static int mode_sense(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 684 {
 685         unsigned int lun = SCSI_LUN(srb);
 686         unsigned int dataSize;
 687         int status;
 688         int pro_formatter_flag;
 689         unsigned char pageCode, *buf;
 690         u8 card = get_lun_card(chip, lun);
 691
 692         if (!check_card_ready(chip, lun)) {
 693                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 694                 scsi_set_resid(srb, scsi_bufflen(srb));
 695                 TRACE_RET(chip, TRANSPORT_FAILED);
 696         }
 697
 698         pro_formatter_flag = 0;
 699         dataSize = 8;
 700         /* In Combo mode, device responses ModeSense command as a MS LUN
 701          * when no card is inserted */
 702         if ((get_lun2card(chip, lun) & MS_CARD)) {
 703                 if (!card || (card == MS_CARD)) {
 704                         dataSize = 108;
 705                         if (chip->option.mspro_formatter_enable)
 706                                 pro_formatter_flag = 1;
 707                 }
 708         }
 709
 710         buf = kmalloc(dataSize, GFP_KERNEL);
 711         if (buf == NULL)
 712                 TRACE_RET(chip, TRANSPORT_ERROR);
 713
 714         pageCode = srb->cmnd[2] & 0x3f;
 715
 716         if ((pageCode == 0x3F) || (pageCode == 0x1C) ||
 717             (pageCode == 0x00) || (pro_formatter_flag && (pageCode == 0x20))) {
 718                 if (srb->cmnd[0] == MODE_SENSE) {
 719                         if ((pageCode == 0x3F) || (pageCode == 0x20)) {
 720                                 ms_mode_sense(chip, srb->cmnd[0], lun, buf,
 721                                               dataSize);
 722                         } else {
 723                                 dataSize = 4;
 724                                 buf[0] = 0x03;
 725                                 buf[1] = 0x00;
 726                                 if (check_card_wp(chip, lun))
 727                                         buf[2] = 0x80;
 728                                 else
 729                                 buf[3] = 0x00;
 730                         }
 731                 } else {
 732                         if ((pageCode == 0x3F) || (pageCode == 0x20)) {
 733                                 ms_mode_sense(chip, srb->cmnd[0], lun, buf,
 734                                               dataSize);
 735                         } else {
 736                                 dataSize = 8;
 737                                 buf[0] = 0x00;
 738                                 buf[1] = 0x06;
 739                                 buf[2] = 0x00;
 740                                 if (check_card_wp(chip, lun))
 741                                         buf[3] = 0x80;
 742                                 else
 743                                         buf[3] = 0x00;
 744                                 buf[4] = 0x00;
 745                                 buf[5] = 0x00;
 746                                 buf[6] = 0x00;
 747                                 buf[7] = 0x00;
 748                         }
 749                 }
 750                 status = TRANSPORT_GOOD;
 751         } else {
 752                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 753                 scsi_set_resid(srb, scsi_bufflen(srb));
 754                 status = TRANSPORT_FAILED;
 755         }
 756
 757         if (status == TRANSPORT_GOOD) {
 758                 unsigned int len = min(scsi_bufflen(srb), dataSize);
 759                 rts51x_set_xfer_buf(buf, len, srb);
 760                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
 761         }
 762         kfree(buf);
 763
 764         return status;
 765 }
 766
 767 static int request_sense(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 768 {
 769         struct sense_data_t *sense;
 770         unsigned int lun = SCSI_LUN(srb);
 771         struct ms_info *ms_card = &(chip->ms_card);
 772         unsigned char *tmp, *buf;
 773
 774         sense = &(chip->sense_buffer[lun]);
 775
 776         if ((get_lun_card(chip, lun) == MS_CARD)
 777             && PRO_UNDER_FORMATTING(ms_card)) {
 778                 mspro_format_sense(chip, lun);
 779         }
 780
 781         buf = vmalloc(scsi_bufflen(srb));
 782         if (buf == NULL)
 783                 TRACE_RET(chip, TRANSPORT_ERROR);
 784
 785         tmp = (unsigned char *)sense;
 786         memcpy(buf, tmp, scsi_bufflen(srb));
 787
 788         rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
 789         vfree(buf);
 790
 791         scsi_set_resid(srb, 0);
 792         /* Reset Sense Data */
 793         set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 794         return TRANSPORT_GOOD;
 795 }
 796
 797 static int read_write(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 798 {
 799 #ifdef SUPPORT_SD_LOCK
 800         struct sd_info *sd_card = &(chip->sd_card);
 801 #endif
 802         unsigned int lun = SCSI_LUN(srb);
 803         int retval;
 804         u32 start_sec;
 805         u16 sec_cnt;
 806
 807         if (!check_card_ready(chip, lun) || (chip->capacity[lun] == 0)) {
 808                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 809                 TRACE_RET(chip, TRANSPORT_FAILED);
 810         }
 811
 812         if (!check_lun_mc(chip, lun)) {
 813                 set_lun_mc(chip, lun);
 814                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 815                 return TRANSPORT_FAILED;
 816         }
 817
 818         rts51x_prepare_run(chip);
 819         RTS51X_SET_STAT(chip, STAT_RUN);
 820
 821 #ifdef SUPPORT_SD_LOCK
 822         if (sd_card->sd_erase_status) {
 823                 /* Accessing to any card is forbidden
 824                  * until the erase procedure of SD is completed */
 825                 RTS51X_DEBUGP("SD card being erased!\n");
 826                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 827                 TRACE_RET(chip, TRANSPORT_FAILED);
 828         }
 829
 830         if (get_lun_card(chip, lun) == SD_CARD) {
 831                 if (sd_card->sd_lock_status & SD_LOCKED) {
 832                         RTS51X_DEBUGP("SD card locked!\n");
 833                         set_sense_type(chip, lun,
 834                                        SENSE_TYPE_MEDIA_READ_FORBIDDEN);
 835                         TRACE_RET(chip, TRANSPORT_FAILED);
 836                 }
 837         }
 838 #endif
 839
 840         if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
 841                 start_sec =
 842                     ((u32) srb->cmnd[2] << 24) |
 843                     ((u32) srb->cmnd[3] << 16) |
 844                     ((u32) srb->cmnd[4] << 8) |
 845                     ((u32) srb->cmnd[5]);
 846                 sec_cnt = ((u16) (srb->cmnd[7]) << 8) | srb->cmnd[8];
 847         } else if ((srb->cmnd[0] == READ_6) || (srb->cmnd[0] == WRITE_6)) {
 848                 start_sec = ((u32) (srb->cmnd[1] & 0x1F) << 16) |
 849                     ((u32) srb->cmnd[2] << 8) | ((u32) srb->cmnd[3]);
 850                 sec_cnt = srb->cmnd[4];
 851         } else if ((srb->cmnd[0] == VENDOR_CMND) &&
 852                         (srb->cmnd[1] == SCSI_APP_CMD) &&
 853                         ((srb->cmnd[2] == PP_READ10) ||
 854                          (srb->cmnd[2] == PP_WRITE10))) {
 855                 start_sec = ((u32) srb->cmnd[4] << 24) |
 856                         ((u32) srb->cmnd[5] << 16) |
 857                         ((u32) srb->cmnd[6] << 8) |
 858                         ((u32) srb->cmnd[7]);
 859                 sec_cnt = ((u16) (srb->cmnd[9]) << 8) | srb->cmnd[10];
 860         } else {
 861                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 862                 TRACE_RET(chip, TRANSPORT_FAILED);
 863         }
 864
 865         if ((start_sec > chip->capacity[lun]) ||
 866             ((start_sec + sec_cnt) > chip->capacity[lun])) {
 867                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LBA_OVER_RANGE);
 868                 TRACE_RET(chip, TRANSPORT_FAILED);
 869         }
 870
 871         if (sec_cnt == 0) {
 872                 scsi_set_resid(srb, 0);
 873                 return TRANSPORT_GOOD;
 874         }
 875
 876         if ((srb->sc_data_direction == DMA_TO_DEVICE)
 877             && check_card_wp(chip, lun)) {
 878                 RTS51X_DEBUGP("Write protected card!\n");
 879                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
 880                 TRACE_RET(chip, TRANSPORT_FAILED);
 881         }
 882
 883         retval = card_rw(srb, chip, start_sec, sec_cnt);
 884         if (retval != STATUS_SUCCESS) {
 885 #if 0
 886                 if (chip->need_release & chip->lun2card[lun]) {
 887                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 888                 } else {
 889 #endif
 890                 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
 891                         set_sense_type(chip, lun,
 892                                        SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
 893                 } else {
 894                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
 895                 }
 896 #if 0
 897                 }
 898 #endif
 899                 TRACE_RET(chip, TRANSPORT_FAILED);
 900         }
 901
 902         scsi_set_resid(srb, 0);
 903
 904         return TRANSPORT_GOOD;
 905 }
 906
 907 static int read_format_capacity(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 908 {
 909         unsigned char *buf;
 910         unsigned int lun = SCSI_LUN(srb);
 911         unsigned int buf_len;
 912         u8 card = get_lun_card(chip, lun);
 913         int desc_cnt;
 914         int i = 0;
 915
 916         if (!check_card_ready(chip, lun)) {
 917                 if (!chip->option.mspro_formatter_enable) {
 918                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 919                         TRACE_RET(chip, TRANSPORT_FAILED);
 920                 }
 921         }
 922
 923         buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
 924
 925         buf = kmalloc(buf_len, GFP_KERNEL);
 926         if (buf == NULL)
 927                 TRACE_RET(chip, TRANSPORT_ERROR);
 928
 929         buf[i++] = 0;
 930         buf[i++] = 0;
 931         buf[i++] = 0;
 932
 933         /* Capacity List Length */
 934         if ((buf_len > 12) && chip->option.mspro_formatter_enable &&
 935             (chip->lun2card[lun] & MS_CARD) && (!card || (card == MS_CARD))) {
 936                 buf[i++] = 0x10;
 937                 desc_cnt = 2;
 938         } else {
 939                 buf[i++] = 0x08;
 940                 desc_cnt = 1;
 941         }
 942
 943         while (desc_cnt) {
 944                 if (check_card_ready(chip, lun)) {
 945                         buf[i++] = (unsigned char)((chip->capacity[lun]) >> 24);
 946                         buf[i++] = (unsigned char)((chip->capacity[lun]) >> 16);
 947                         buf[i++] = (unsigned char)((chip->capacity[lun]) >> 8);
 948                         buf[i++] = (unsigned char)(chip->capacity[lun]);
 949
 950                         if (desc_cnt == 2)
 951                                 /* Byte[8]: Descriptor Type: Formatted medium */
 952                                 buf[i++] = 2;
 953                         else
 954                                 buf[i++] = 0;   /* Byte[16] */
 955                 } else {
 956                         buf[i++] = 0xFF;
 957                         buf[i++] = 0xFF;
 958                         buf[i++] = 0xFF;
 959                         buf[i++] = 0xFF;
 960
 961                         if (desc_cnt == 2)
 962                                 /* Byte[8]: Descriptor Type: No medium */
 963                                 buf[i++] = 3;
 964                         else
 965                                 buf[i++] = 0;   /*Byte[16] */
 966                 }
 967
 968                 buf[i++] = 0x00;
 969                 buf[i++] = 0x02;
 970                 buf[i++] = 0x00;
 971
 972                 desc_cnt--;
 973         }
 974
 975         buf_len = min(scsi_bufflen(srb), buf_len);
 976         rts51x_set_xfer_buf(buf, buf_len, srb);
 977         kfree(buf);
 978
 979         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
 980
 981         return TRANSPORT_GOOD;
 982 }
 983
 984 static int read_capacity(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 985 {
 986         unsigned char *buf;
 987         unsigned int lun = SCSI_LUN(srb);
 988
 989         if (!check_card_ready(chip, lun)) {
 990                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 991                 TRACE_RET(chip, TRANSPORT_FAILED);
 992         }
 993
 994         if (!check_lun_mc(chip, lun)) {
 995                 set_lun_mc(chip, lun);
 996                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 997                 return TRANSPORT_FAILED;
 998         }
 999
1000         buf = kmalloc(8, GFP_KERNEL);
1001         if (buf == NULL)
1002                 TRACE_RET(chip, TRANSPORT_ERROR);
1003
1004         buf[0] = (unsigned char)((chip->capacity[lun] - 1) >> 24);
1005         buf[1] = (unsigned char)((chip->capacity[lun] - 1) >> 16);
1006         buf[2] = (unsigned char)((chip->capacity[lun] - 1) >> 8);
1007         buf[3] = (unsigned char)(chip->capacity[lun] - 1);
1008
1009         buf[4] = 0x00;
1010         buf[5] = 0x00;
1011         buf[6] = 0x02;
1012         buf[7] = 0x00;
1013
1014         rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1015         kfree(buf);
1016
1017         scsi_set_resid(srb, 0);
1018
1019         return TRANSPORT_GOOD;
1020 }
1021
1022 static int get_dev_status(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1023 {
1024         unsigned int lun = SCSI_LUN(srb);
1025         unsigned int buf_len;
1026         u8 status[32] = { 0 };
1027
1028         rts51x_pp_status(chip, lun, status, 32);
1029
1030         buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(status));
1031         rts51x_set_xfer_buf(status, buf_len, srb);
1032         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1033
1034         return TRANSPORT_GOOD;
1035 }
1036
1037 static int read_status(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1038 {
1039         u8 rts51x_status[16];
1040         unsigned int buf_len;
1041         unsigned int lun = SCSI_LUN(srb);
1042
1043         rts51x_read_status(chip, lun, rts51x_status, 16);
1044
1045         buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(rts51x_status));
1046         rts51x_set_xfer_buf(rts51x_status, buf_len, srb);
1047         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1048
1049         return TRANSPORT_GOOD;
1050 }
1051
1052 static int read_mem(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1053 {
1054         unsigned int lun = SCSI_LUN(srb);
1055         unsigned short addr, len, i;
1056         int retval;
1057         u8 *buf;
1058
1059         rts51x_prepare_run(chip);
1060         RTS51X_SET_STAT(chip, STAT_RUN);
1061
1062         addr = ((u16) srb->cmnd[2] << 8) | srb->cmnd[3];
1063         len = ((u16) srb->cmnd[4] << 8) | srb->cmnd[5];
1064
1065         if (addr < 0xe000) {
1066                 RTS51X_DEBUGP("filter!addr=0x%x\n", addr);
1067                 return TRANSPORT_GOOD;
1068         }
1069
1070         buf = vmalloc(len);
1071         if (!buf)
1072                 TRACE_RET(chip, TRANSPORT_ERROR);
1073
1074         for (i = 0; i < len; i++) {
1075                 retval = rts51x_ep0_read_register(chip, addr + i, buf + i);
1076                 if (retval != STATUS_SUCCESS) {
1077                         vfree(buf);
1078                         set_sense_type(chip, lun,
1079                                        SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1080                         TRACE_RET(chip, TRANSPORT_FAILED);
1081                 }
1082         }
1083
1084         len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1085         rts51x_set_xfer_buf(buf, len, srb);
1086         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1087
1088         vfree(buf);
1089
1090         return TRANSPORT_GOOD;
1091 }
1092
1093 static int write_mem(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1094 {
1095         unsigned int lun = SCSI_LUN(srb);
1096         unsigned short addr, len, i;
1097         int retval;
1098         u8 *buf;
1099
1100         rts51x_prepare_run(chip);
1101         RTS51X_SET_STAT(chip, STAT_RUN);
1102
1103         addr = ((u16) srb->cmnd[2] << 8) | srb->cmnd[3];
1104         len = ((u16) srb->cmnd[4] << 8) | srb->cmnd[5];
1105
1106         if (addr < 0xe000) {
1107                 RTS51X_DEBUGP("filter!addr=0x%x\n", addr);
1108                 return TRANSPORT_GOOD;
1109         }
1110
1111         len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1112         buf = vmalloc(len);
1113         if (!buf)
1114                 TRACE_RET(chip, TRANSPORT_ERROR);
1115
1116         rts51x_get_xfer_buf(buf, len, srb);
1117
1118         for (i = 0; i < len; i++) {
1119                 retval =
1120                     rts51x_ep0_write_register(chip, addr + i, 0xFF, buf[i]);
1121                 if (retval != STATUS_SUCCESS) {
1122                         vfree(buf);
1123                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1124                         TRACE_RET(chip, TRANSPORT_FAILED);
1125                 }
1126         }
1127
1128         vfree(buf);
1129         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1130
1131         return TRANSPORT_GOOD;
1132 }
1133
1134 static int get_sd_csd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1135 {
1136         struct sd_info *sd_card = &(chip->sd_card);
1137         unsigned int lun = SCSI_LUN(srb);
1138
1139         if (!check_card_ready(chip, lun)) {
1140                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1141                 TRACE_RET(chip, TRANSPORT_FAILED);
1142         }
1143
1144         if (get_lun_card(chip, lun) != SD_CARD) {
1145                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1146                 TRACE_RET(chip, TRANSPORT_FAILED);
1147         }
1148
1149         scsi_set_resid(srb, 0);
1150         rts51x_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1151
1152         return TRANSPORT_GOOD;
1153 }
1154
1155 static int read_phy_register(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1156 {
1157         int retval;
1158         u8 addr, len, i;
1159         u8 *buf;
1160
1161         rts51x_prepare_run(chip);
1162         RTS51X_SET_STAT(chip, STAT_RUN);
1163
1164         addr = srb->cmnd[5];
1165         len = srb->cmnd[7];
1166
1167         if (len) {
1168                 buf = vmalloc(len);
1169                 if (!buf)
1170                         TRACE_RET(chip, TRANSPORT_ERROR);
1171
1172                 for (i = 0; i < len; i++) {
1173                         retval =
1174                             rts51x_read_phy_register(chip, addr + i, buf + i);
1175                         if (retval != STATUS_SUCCESS) {
1176                                 vfree(buf);
1177                                 set_sense_type(chip, SCSI_LUN(srb),
1178                                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1179                                 TRACE_RET(chip, TRANSPORT_FAILED);
1180                         }
1181                 }
1182
1183                 len = min(scsi_bufflen(srb), (unsigned int)len);
1184                 rts51x_set_xfer_buf(buf, len, srb);
1185                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1186
1187                 vfree(buf);
1188         }
1189
1190         return TRANSPORT_GOOD;
1191 }
1192
1193 static int write_phy_register(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1194 {
1195         int retval;
1196         u8 addr, len, i;
1197         u8 *buf;
1198
1199         rts51x_prepare_run(chip);
1200         RTS51X_SET_STAT(chip, STAT_RUN);
1201
1202         addr = srb->cmnd[5];
1203         len = srb->cmnd[7];
1204
1205         if (len) {
1206                 len = min(scsi_bufflen(srb), (unsigned int)len);
1207
1208                 buf = vmalloc(len);
1209                 if (buf == NULL)
1210                         TRACE_RET(chip, TRANSPORT_ERROR);
1211
1212                 rts51x_get_xfer_buf(buf, len, srb);
1213                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1214
1215                 for (i = 0; i < len; i++) {
1216                         retval =
1217                             rts51x_write_phy_register(chip, addr + i, buf[i]);
1218                         if (retval != STATUS_SUCCESS) {
1219                                 vfree(buf);
1220                                 set_sense_type(chip, SCSI_LUN(srb),
1221                                                SENSE_TYPE_MEDIA_WRITE_ERR);
1222                                 TRACE_RET(chip, TRANSPORT_FAILED);
1223                         }
1224                 }
1225
1226                 vfree(buf);
1227         }
1228
1229         return TRANSPORT_GOOD;
1230 }
1231
1232 static int get_card_bus_width(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1233 {
1234         unsigned int lun = SCSI_LUN(srb);
1235         u8 card, bus_width;
1236
1237         if (!check_card_ready(chip, lun)) {
1238                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1239                 TRACE_RET(chip, TRANSPORT_FAILED);
1240         }
1241
1242         card = get_lun_card(chip, lun);
1243         if ((card == SD_CARD) || (card == MS_CARD)) {
1244                 bus_width = chip->card_bus_width[lun];
1245         } else {
1246                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1247                 TRACE_RET(chip, TRANSPORT_FAILED);
1248         }
1249
1250         scsi_set_resid(srb, 0);
1251         rts51x_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
1252
1253         return TRANSPORT_GOOD;
1254 }
1255
1256 #ifdef _MSG_TRACE
1257 static int trace_msg_cmd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1258 {
1259         unsigned char *buf = NULL;
1260         u8 clear;
1261         unsigned int buf_len;
1262
1263         buf_len =
1264             4 +
1265             ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) * TRACE_ITEM_CNT);
1266
1267         if ((scsi_bufflen(srb) < buf_len) || (scsi_sglist(srb) == NULL)) {
1268                 set_sense_type(chip, SCSI_LUN(srb),
1269                                SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1270                 TRACE_RET(chip, TRANSPORT_FAILED);
1271         }
1272
1273         clear = srb->cmnd[2];
1274
1275         buf = vmalloc(scsi_bufflen(srb));
1276         if (buf == NULL)
1277                 TRACE_RET(chip, TRANSPORT_ERROR);
1278
1279         rts51x_trace_msg(chip, buf, clear);
1280
1281         rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1282         vfree(buf);
1283
1284         scsi_set_resid(srb, 0);
1285         return TRANSPORT_GOOD;
1286 }
1287 #endif
1288
1289 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1290 {
1291         int retval = STATUS_SUCCESS;
1292         unsigned int lun = SCSI_LUN(srb);
1293         u8 cmd_type, mask, value, idx, mode, len;
1294         u16 addr;
1295         u32 timeout;
1296
1297         rts51x_prepare_run(chip);
1298         RTS51X_SET_STAT(chip, STAT_RUN);
1299
1300         switch (srb->cmnd[3]) {
1301         case INIT_BATCHCMD:
1302                 rts51x_init_cmd(chip);
1303                 break;
1304
1305         case ADD_BATCHCMD:
1306                 cmd_type = srb->cmnd[4];
1307                 if (cmd_type > 2) {
1308                         set_sense_type(chip, lun,
1309                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1310                         TRACE_RET(chip, TRANSPORT_FAILED);
1311                 }
1312                 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1313                 mask = srb->cmnd[7];
1314                 value = srb->cmnd[8];
1315                 rts51x_add_cmd(chip, cmd_type, addr, mask, value);
1316                 break;
1317
1318         case SEND_BATCHCMD:
1319                 mode = srb->cmnd[4];
1320                 len = srb->cmnd[5];
1321                 timeout =
1322                     ((u32) srb->cmnd[6] << 24) | ((u32) srb->
1323                                                   cmnd[7] << 16) | ((u32) srb->
1324                                                                     cmnd[8] <<
1325                                                                     8) | ((u32)
1326                                                                           srb->
1327                                                                           cmnd
1328                                                                           [9]);
1329                 retval = rts51x_send_cmd(chip, mode, 1000);
1330                 if (retval != STATUS_SUCCESS) {
1331                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1332                         TRACE_RET(chip, TRANSPORT_FAILED);
1333                 }
1334                 if (mode & STAGE_R) {
1335                         retval = rts51x_get_rsp(chip, len, timeout);
1336                         if (retval != STATUS_SUCCESS) {
1337                                 set_sense_type(chip, lun,
1338                                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1339                                 TRACE_RET(chip, TRANSPORT_FAILED);
1340                         }
1341                 }
1342                 break;
1343
1344         case GET_BATCHRSP:
1345                 idx = srb->cmnd[4];
1346                 value = chip->rsp_buf[idx];
1347                 if (scsi_bufflen(srb) < 1) {
1348                         set_sense_type(chip, lun,
1349                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1350                         TRACE_RET(chip, TRANSPORT_FAILED);
1351                 }
1352                 rts51x_set_xfer_buf(&value, 1, srb);
1353                 scsi_set_resid(srb, 0);
1354                 break;
1355
1356         default:
1357                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1358                 TRACE_RET(chip, TRANSPORT_FAILED);
1359         }
1360
1361         if (retval != STATUS_SUCCESS) {
1362                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1363                 TRACE_RET(chip, TRANSPORT_FAILED);
1364         }
1365
1366         return TRANSPORT_GOOD;
1367 }
1368
1369 static int suit_cmd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1370 {
1371         int result;
1372
1373         switch (srb->cmnd[3]) {
1374         case INIT_BATCHCMD:
1375         case ADD_BATCHCMD:
1376         case SEND_BATCHCMD:
1377         case GET_BATCHRSP:
1378                 result = rw_mem_cmd_buf(srb, chip);
1379                 break;
1380         default:
1381                 result = TRANSPORT_ERROR;
1382         }
1383
1384         return result;
1385 }
1386
1387 static int app_cmd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1388 {
1389         int result;
1390
1391         switch (srb->cmnd[2]) {
1392         case PP_READ10:
1393         case PP_WRITE10:
1394                 result = read_write(srb, chip);
1395                 break;
1396
1397         case SUIT_CMD:
1398                 result = suit_cmd(srb, chip);
1399                 break;
1400
1401         case READ_PHY:
1402                 result = read_phy_register(srb, chip);
1403                 break;
1404
1405         case WRITE_PHY:
1406                 result = write_phy_register(srb, chip);
1407                 break;
1408
1409         case GET_DEV_STATUS:
1410                 result = get_dev_status(srb, chip);
1411                 break;
1412
1413         default:
1414                 set_sense_type(chip, SCSI_LUN(srb),
1415                                SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1416                 TRACE_RET(chip, TRANSPORT_FAILED);
1417         }
1418
1419         return result;
1420 }
1421
1422 static int vendor_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1423 {
1424         int result = TRANSPORT_GOOD;
1425
1426         switch (srb->cmnd[1]) {
1427         case READ_STATUS:
1428                 result = read_status(srb, chip);
1429                 break;
1430
1431         case READ_MEM:
1432                 result = read_mem(srb, chip);
1433                 break;
1434
1435         case WRITE_MEM:
1436                 result = write_mem(srb, chip);
1437                 break;
1438
1439         case GET_BUS_WIDTH:
1440                 result = get_card_bus_width(srb, chip);
1441                 break;
1442
1443         case GET_SD_CSD:
1444                 result = get_sd_csd(srb, chip);
1445                 break;
1446
1447 #ifdef _MSG_TRACE
1448         case TRACE_MSG:
1449                 result = trace_msg_cmd(srb, chip);
1450                 break;
1451 #endif
1452
1453         case SCSI_APP_CMD:
1454                 result = app_cmd(srb, chip);
1455                 break;
1456
1457         default:
1458                 set_sense_type(chip, SCSI_LUN(srb),
1459                                SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1460                 TRACE_RET(chip, TRANSPORT_FAILED);
1461         }
1462
1463         return result;
1464 }
1465
1466 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1467 {
1468         struct ms_info *ms_card = &(chip->ms_card);
1469         unsigned int lun = SCSI_LUN(srb);
1470         int retval, quick_format;
1471
1472         if (get_lun_card(chip, lun) != MS_CARD) {
1473                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1474                 TRACE_RET(chip, TRANSPORT_FAILED);
1475         }
1476
1477         if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47)
1478             || (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D)
1479             || (srb->cmnd[7] != 0x74)) {
1480                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1481                 TRACE_RET(chip, TRANSPORT_FAILED);
1482         }
1483
1484         if (srb->cmnd[8] & 0x01)
1485                 quick_format = 0;
1486         else
1487                 quick_format = 1;
1488
1489         if (!(chip->card_ready & MS_CARD)) {
1490                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1491                 TRACE_RET(chip, TRANSPORT_FAILED);
1492         }
1493
1494         if (chip->card_wp & MS_CARD) {
1495                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
1496                 TRACE_RET(chip, TRANSPORT_FAILED);
1497         }
1498
1499         if (!CHK_MSPRO(ms_card)) {
1500                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1501                 TRACE_RET(chip, TRANSPORT_FAILED);
1502         }
1503
1504         rts51x_prepare_run(chip);
1505         RTS51X_SET_STAT(chip, STAT_RUN);
1506
1507         retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
1508         if (retval != STATUS_SUCCESS) {
1509                 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
1510                 TRACE_RET(chip, TRANSPORT_FAILED);
1511         }
1512
1513         scsi_set_resid(srb, 0);
1514         return TRANSPORT_GOOD;
1515 }
1516
1517 #ifdef SUPPORT_PCGL_1P18
1518 int get_ms_information(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1519 {
1520         struct ms_info *ms_card = &(chip->ms_card);
1521         unsigned int lun = SCSI_LUN(srb);
1522         u8 dev_info_id, data_len;
1523         u8 *buf;
1524         unsigned int buf_len;
1525         int i;
1526
1527         if (!check_card_ready(chip, lun)) {
1528                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1529                 TRACE_RET(chip, TRANSPORT_FAILED);
1530         }
1531         if ((get_lun_card(chip, lun) != MS_CARD)) {
1532                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1533                 TRACE_RET(chip, TRANSPORT_FAILED);
1534         }
1535
1536         if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
1537             (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
1538             (srb->cmnd[7] != 0x44)) {
1539                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1540                 TRACE_RET(chip, TRANSPORT_FAILED);
1541         }
1542
1543         dev_info_id = srb->cmnd[3];
1544         if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
1545             (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
1546             !CHK_MSPRO(ms_card)) {
1547                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1548                 TRACE_RET(chip, TRANSPORT_FAILED);
1549         }
1550
1551         if (dev_info_id == 0x15)
1552                 buf_len = data_len = 0x3A;
1553         else
1554                 buf_len = data_len = 0x6A;
1555
1556         buf = kmalloc(buf_len, GFP_KERNEL);
1557         if (!buf)
1558                 TRACE_RET(chip, TRANSPORT_ERROR);
1559
1560         i = 0;
1561         /* GET Memory Stick Media Information Response Header */
1562         buf[i++] = 0x00;        /* Data length MSB */
1563         buf[i++] = data_len;    /* Data length LSB */
1564         /* Device Information Type Code */
1565         if (CHK_MSXC(ms_card))
1566                 buf[i++] = 0x03;
1567         else
1568                 buf[i++] = 0x02;
1569         /* SGM bit */
1570         buf[i++] = 0x01;
1571         /* Reserved */
1572         buf[i++] = 0x00;
1573         buf[i++] = 0x00;
1574         buf[i++] = 0x00;
1575         /* Number of Device Information */
1576         buf[i++] = 0x01;
1577
1578         /*  Device Information Body
1579          *  Device Information ID Number */
1580         buf[i++] = dev_info_id;
1581         /* Device Information Length */
1582         if (dev_info_id == 0x15)
1583                 data_len = 0x31;
1584         else
1585                 data_len = 0x61;
1586         buf[i++] = 0x00;        /* Data length MSB */
1587         buf[i++] = data_len;    /* Data length LSB */
1588         /* Valid Bit */
1589         buf[i++] = 0x80;
1590         if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
1591                 /* System Information */
1592                 memcpy(buf + i, ms_card->raw_sys_info, 96);
1593         } else {
1594                 /* Model Name */
1595                 memcpy(buf + i, ms_card->raw_model_name, 48);
1596         }
1597
1598         rts51x_set_xfer_buf(buf, buf_len, srb);
1599
1600         if (dev_info_id == 0x15)
1601                 scsi_set_resid(srb, scsi_bufflen(srb) - 0x3C);
1602         else
1603                 scsi_set_resid(srb, scsi_bufflen(srb) - 0x6C);
1604
1605         kfree(buf);
1606         return STATUS_SUCCESS;
1607 }
1608 #endif
1609
1610 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1611 {
1612         int retval = TRANSPORT_ERROR;
1613
1614         if (srb->cmnd[2] == MS_FORMAT)
1615                 retval = ms_format_cmnd(srb, chip);
1616 #ifdef SUPPORT_PCGL_1P18
1617         else if (srb->cmnd[2] == GET_MS_INFORMATION)
1618                 retval = get_ms_information(srb, chip);
1619 #endif
1620
1621         return retval;
1622 }
1623
1624 #ifdef SUPPORT_CPRM
1625 static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1626 {
1627         unsigned int lun = SCSI_LUN(srb);
1628         int result;
1629
1630         rts51x_prepare_run(chip);
1631         RTS51X_SET_STAT(chip, STAT_RUN);
1632
1633         sd_cleanup_work(chip);
1634
1635         if (!check_card_ready(chip, lun)) {
1636                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1637                 TRACE_RET(chip, TRANSPORT_FAILED);
1638         }
1639         if ((get_lun_card(chip, lun) != SD_CARD)) {
1640                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1641                 TRACE_RET(chip, TRANSPORT_FAILED);
1642         }
1643
1644         switch (srb->cmnd[0]) {
1645         case SD_PASS_THRU_MODE:
1646                 result = sd_pass_thru_mode(srb, chip);
1647                 break;
1648
1649         case SD_EXECUTE_NO_DATA:
1650                 result = sd_execute_no_data(srb, chip);
1651                 break;
1652
1653         case SD_EXECUTE_READ:
1654                 result = sd_execute_read_data(srb, chip);
1655                 break;
1656
1657         case SD_EXECUTE_WRITE:
1658                 result = sd_execute_write_data(srb, chip);
1659                 break;
1660
1661         case SD_GET_RSP:
1662                 result = sd_get_cmd_rsp(srb, chip);
1663                 break;
1664
1665         case SD_HW_RST:
1666                 result = sd_hw_rst(srb, chip);
1667                 break;
1668
1669         default:
1670                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1671                 TRACE_RET(chip, TRANSPORT_FAILED);
1672         }
1673
1674         return result;
1675 }
1676 #endif
1677
1678 #ifdef SUPPORT_MAGIC_GATE
1679 int mg_report_key(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1680 {
1681         struct ms_info *ms_card = &(chip->ms_card);
1682         unsigned int lun = SCSI_LUN(srb);
1683         int retval;
1684         u8 key_format;
1685
1686         rts51x_prepare_run(chip);
1687         RTS51X_SET_STAT(chip, STAT_RUN);
1688
1689         ms_cleanup_work(chip);
1690
1691         if (!check_card_ready(chip, lun)) {
1692                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1693                 TRACE_RET(chip, TRANSPORT_FAILED);
1694         }
1695         if ((get_lun_card(chip, lun) != MS_CARD)) {
1696                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1697                 TRACE_RET(chip, TRANSPORT_FAILED);
1698         }
1699
1700         if (srb->cmnd[7] != KC_MG_R_PRO) {
1701                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1702                 TRACE_RET(chip, TRANSPORT_FAILED);
1703         }
1704
1705         if (!CHK_MSPRO(ms_card)) {
1706                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
1707                 TRACE_RET(chip, TRANSPORT_FAILED);
1708         }
1709
1710         key_format = srb->cmnd[10] & 0x3F;
1711
1712         switch (key_format) {
1713         case KF_GET_LOC_EKB:
1714                 if ((scsi_bufflen(srb) == 0x41C) &&
1715                     (srb->cmnd[8] == 0x04) && (srb->cmnd[9] == 0x1C)) {
1716                         retval = mg_get_local_EKB(srb, chip);
1717                         if (retval != STATUS_SUCCESS)
1718                                 TRACE_RET(chip, TRANSPORT_FAILED);
1719                 } else {
1720                         set_sense_type(chip, lun,
1721                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1722                         TRACE_RET(chip, TRANSPORT_FAILED);
1723                 }
1724                 break;
1725
1726         case KF_RSP_CHG:
1727                 if ((scsi_bufflen(srb) == 0x24) &&
1728                     (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x24)) {
1729                         retval = mg_get_rsp_chg(srb, chip);
1730                         if (retval != STATUS_SUCCESS)
1731                                 TRACE_RET(chip, TRANSPORT_FAILED);
1732                 } else {
1733                         set_sense_type(chip, lun,
1734                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1735                         TRACE_RET(chip, TRANSPORT_FAILED);
1736                 }
1737                 break;
1738
1739         case KF_GET_ICV:
1740                 ms_card->mg_entry_num = srb->cmnd[5];
1741                 if ((scsi_bufflen(srb) == 0x404) &&
1742                     (srb->cmnd[8] == 0x04) &&
1743                     (srb->cmnd[9] == 0x04) &&
1744                     (srb->cmnd[2] == 0x00) &&
1745                     (srb->cmnd[3] == 0x00) &&
1746                     (srb->cmnd[4] == 0x00) && (srb->cmnd[5] < 32)) {
1747                         retval = mg_get_ICV(srb, chip);
1748                         if (retval != STATUS_SUCCESS)
1749                                 TRACE_RET(chip, TRANSPORT_FAILED);
1750                 } else {
1751                         set_sense_type(chip, lun,
1752                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1753                         TRACE_RET(chip, TRANSPORT_FAILED);
1754                 }
1755                 break;
1756
1757         default:
1758                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1759                 TRACE_RET(chip, TRANSPORT_FAILED);
1760         }
1761
1762         scsi_set_resid(srb, 0);
1763         return TRANSPORT_GOOD;
1764 }
1765
1766 int mg_send_key(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1767 {
1768         struct ms_info *ms_card = &(chip->ms_card);
1769         unsigned int lun = SCSI_LUN(srb);
1770         int retval;
1771         u8 key_format;
1772
1773         rts51x_prepare_run(chip);
1774         RTS51X_SET_STAT(chip, STAT_RUN);
1775
1776         ms_cleanup_work(chip);
1777
1778         if (!check_card_ready(chip, lun)) {
1779                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1780                 TRACE_RET(chip, TRANSPORT_FAILED);
1781         }
1782         if (check_card_wp(chip, lun)) {
1783                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
1784                 TRACE_RET(chip, TRANSPORT_FAILED);
1785         }
1786         if ((get_lun_card(chip, lun) != MS_CARD)) {
1787                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1788                 TRACE_RET(chip, TRANSPORT_FAILED);
1789         }
1790
1791         if (srb->cmnd[7] != KC_MG_R_PRO) {
1792                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1793                 TRACE_RET(chip, TRANSPORT_FAILED);
1794         }
1795
1796         if (!CHK_MSPRO(ms_card)) {
1797                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
1798                 TRACE_RET(chip, TRANSPORT_FAILED);
1799         }
1800
1801         key_format = srb->cmnd[10] & 0x3F;
1802
1803         switch (key_format) {
1804         case KF_SET_LEAF_ID:
1805                 if ((scsi_bufflen(srb) == 0x0C) &&
1806                     (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x0C)) {
1807                         retval = mg_set_leaf_id(srb, chip);
1808                         if (retval != STATUS_SUCCESS)
1809                                 TRACE_RET(chip, TRANSPORT_FAILED);
1810                 } else {
1811                         set_sense_type(chip, lun,
1812                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1813                         TRACE_RET(chip, TRANSPORT_FAILED);
1814                 }
1815                 break;
1816
1817         case KF_CHG_HOST:
1818                 if ((scsi_bufflen(srb) == 0x0C) &&
1819                     (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x0C)) {
1820                         retval = mg_chg(srb, chip);
1821                         if (retval != STATUS_SUCCESS)
1822                                 TRACE_RET(chip, TRANSPORT_FAILED);
1823                 } else {
1824                         set_sense_type(chip, lun,
1825                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1826                         TRACE_RET(chip, TRANSPORT_FAILED);
1827                 }
1828                 break;
1829
1830         case KF_RSP_HOST:
1831                 if ((scsi_bufflen(srb) == 0x0C) &&
1832                     (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x0C)) {
1833                         retval = mg_rsp(srb, chip);
1834                         if (retval != STATUS_SUCCESS)
1835                                 TRACE_RET(chip, TRANSPORT_FAILED);
1836                 } else {
1837                         set_sense_type(chip, lun,
1838                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1839                         TRACE_RET(chip, TRANSPORT_FAILED);
1840                 }
1841                 break;
1842
1843         case KF_SET_ICV:
1844                 ms_card->mg_entry_num = srb->cmnd[5];
1845                 if ((scsi_bufflen(srb) == 0x404) &&
1846                     (srb->cmnd[8] == 0x04) &&
1847                     (srb->cmnd[9] == 0x04) &&
1848                     (srb->cmnd[2] == 0x00) &&
1849                     (srb->cmnd[3] == 0x00) &&
1850                     (srb->cmnd[4] == 0x00) && (srb->cmnd[5] < 32)) {
1851                         retval = mg_set_ICV(srb, chip);
1852                         if (retval != STATUS_SUCCESS)
1853                                 TRACE_RET(chip, TRANSPORT_FAILED);
1854                 } else {
1855                         set_sense_type(chip, lun,
1856                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1857                         TRACE_RET(chip, TRANSPORT_FAILED);
1858                 }
1859                 break;
1860
1861         default:
1862                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1863                 TRACE_RET(chip, TRANSPORT_FAILED);
1864         }
1865
1866         scsi_set_resid(srb, 0);
1867         return TRANSPORT_GOOD;
1868 }
1869 #endif
1870
1871 int rts51x_scsi_handler(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1872 {
1873 #ifdef SUPPORT_SD_LOCK
1874         struct sd_info *sd_card = &(chip->sd_card);
1875 #endif
1876         struct ms_info *ms_card = &(chip->ms_card);
1877         unsigned int lun = SCSI_LUN(srb);
1878         int result = TRANSPORT_GOOD;
1879
1880 #ifdef SUPPORT_SD_LOCK
1881         if (sd_card->sd_erase_status) {
1882                 /* Block all SCSI command except for REQUEST_SENSE
1883                  * and rs_ppstatus */
1884                 if (!
1885                     ((srb->cmnd[0] == VENDOR_CMND)
1886                      && (srb->cmnd[1] == SCSI_APP_CMD)
1887                      && (srb->cmnd[2] == GET_DEV_STATUS))
1888                     && (srb->cmnd[0] != REQUEST_SENSE)) {
1889                         /* Logical Unit Not Ready Format in Progress */
1890                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
1891                                        0, 0);
1892                         TRACE_RET(chip, TRANSPORT_FAILED);
1893                 }
1894         }
1895 #endif
1896
1897         if ((get_lun_card(chip, lun) == MS_CARD) &&
1898             (ms_card->format_status == FORMAT_IN_PROGRESS)) {
1899                 if ((srb->cmnd[0] != REQUEST_SENSE)
1900                     && (srb->cmnd[0] != INQUIRY)) {
1901                         /* Logical Unit Not Ready Format in Progress */
1902                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
1903                                        0, (u16) (ms_card->progress));
1904                         TRACE_RET(chip, TRANSPORT_FAILED);
1905                 }
1906         }
1907
1908         switch (srb->cmnd[0]) {
1909         case READ_10:
1910         case WRITE_10:
1911         case READ_6:
1912         case WRITE_6:
1913                 result = read_write(srb, chip);
1914                 break;
1915
1916         case TEST_UNIT_READY:
1917                 result = test_unit_ready(srb, chip);
1918                 break;
1919
1920         case INQUIRY:
1921                 result = inquiry(srb, chip);
1922                 break;
1923
1924         case READ_CAPACITY:
1925                 result = read_capacity(srb, chip);
1926                 break;
1927
1928         case START_STOP:
1929                 result = start_stop_unit(srb, chip);
1930                 break;
1931
1932         case ALLOW_MEDIUM_REMOVAL:
1933                 result = allow_medium_removal(srb, chip);
1934                 break;
1935
1936         case REQUEST_SENSE:
1937                 result = request_sense(srb, chip);
1938                 break;
1939
1940         case MODE_SENSE:
1941         case MODE_SENSE_10:
1942                 result = mode_sense(srb, chip);
1943                 break;
1944
1945         case 0x23:
1946                 result = read_format_capacity(srb, chip);
1947                 break;
1948
1949         case VENDOR_CMND:
1950                 result = vendor_cmnd(srb, chip);
1951                 break;
1952
1953         case MS_SP_CMND:
1954                 result = ms_sp_cmnd(srb, chip);
1955                 break;
1956
1957 #ifdef SUPPORT_CPRM
1958         case SD_PASS_THRU_MODE:
1959         case SD_EXECUTE_NO_DATA:
1960         case SD_EXECUTE_READ:
1961         case SD_EXECUTE_WRITE:
1962         case SD_GET_RSP:
1963         case SD_HW_RST:
1964                 result = sd_extention_cmnd(srb, chip);
1965                 break;
1966 #endif
1967
1968 #ifdef SUPPORT_MAGIC_GATE
1969         case CMD_MSPRO_MG_RKEY:
1970                 result = mg_report_key(srb, chip);
1971                 break;
1972
1973         case CMD_MSPRO_MG_SKEY:
1974                 result = mg_send_key(srb, chip);
1975                 break;
1976 #endif
1977
1978         case FORMAT_UNIT:
1979         case MODE_SELECT:
1980         case VERIFY:
1981                 result = TRANSPORT_GOOD;
1982                 break;
1983
1984         default:
1985                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1986                 result = TRANSPORT_FAILED;
1987         }
1988
1989         return result;
1990 }
1991
1992 /***********************************************************************
1993  * Host functions
1994  ***********************************************************************/
1995
1996 const char *host_info(struct Scsi_Host *host)
1997 {
1998         return "SCSI emulation for RTS51xx USB driver-based card reader";
1999 }
2000
2001 int slave_alloc(struct scsi_device *sdev)
2002 {
2003         /*
2004          * Set the INQUIRY transfer length to 36.  We don't use any of
2005          * the extra data and many devices choke if asked for more or
2006          * less than 36 bytes.
2007          */
2008         sdev->inquiry_len = 36;
2009         return 0;
2010 }
2011
2012 int slave_configure(struct scsi_device *sdev)
2013 {
2014         /* Scatter-gather buffers (all but the last) must have a length
2015          * divisible by the bulk maxpacket size.  Otherwise a data packet
2016          * would end up being short, causing a premature end to the data
2017          * transfer.  Since high-speed bulk pipes have a maxpacket size
2018          * of 512, we'll use that as the scsi device queue's DMA alignment
2019          * mask.  Guaranteeing proper alignment of the first buffer will
2020          * have the desired effect because, except at the beginning and
2021          * the end, scatter-gather buffers follow page boundaries. */
2022         blk_queue_dma_alignment(sdev->request_queue, (512 - 1));
2023
2024         /* Set the SCSI level to at least 2.  We'll leave it at 3 if that's
2025          * what is originally reported.  We need this to avoid confusing
2026          * the SCSI layer with devices that report 0 or 1, but need 10-byte
2027          * commands (ala ATAPI devices behind certain bridges, or devices
2028          * which simply have broken INQUIRY data).
2029          *
2030          * NOTE: This means /dev/sg programs (ala cdrecord) will get the
2031          * actual information.  This seems to be the preference for
2032          * programs like that.
2033          *
2034          * NOTE: This also means that /proc/scsi/scsi and sysfs may report
2035          * the actual value or the modified one, depending on where the
2036          * data comes from.
2037          */
2038         if (sdev->scsi_level < SCSI_2)
2039                 sdev->scsi_level = sdev->sdev_target->scsi_level = SCSI_2;
2040
2041         return 0;
2042 }
2043
2044 /***********************************************************************
2045  * /proc/scsi/ functions
2046  ***********************************************************************/
2047
2048 /* we use this macro to help us write into the buffer */
2049 #undef SPRINTF
2050 #define SPRINTF(args...) \
2051         do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
2052
2053 int proc_info(struct Scsi_Host *host, char *buffer,
2054               char **start, off_t offset, int length, int inout)
2055 {
2056         char *pos = buffer;
2057
2058         /* if someone is sending us data, just throw it away */
2059         if (inout)
2060                 return length;
2061
2062         /* print the controller name */
2063         SPRINTF("   Host scsi%d: %s\n", host->host_no, RTS51X_NAME);
2064
2065         /* print product, vendor, and driver version strings */
2066         SPRINTF("       Vendor: Realtek Corp.\n");
2067         SPRINTF("      Product: RTS51xx USB Card Reader\n");
2068         SPRINTF("      Version: %s\n", DRIVER_VERSION);
2069         SPRINTF("        Build: %s\n", __TIME__);
2070
2071         /*
2072          * Calculate start of next buffer, and return value.
2073          */
2074         *start = buffer + offset;
2075
2076         if ((pos - buffer) < offset)
2077                 return 0;
2078         else if ((pos - buffer - offset) < length)
2079                 return pos - buffer - offset;
2080         else
2081                 return length;
2082 }
2083
2084 /* queue a command */
2085 /* This is always called with scsi_lock(host) held */
2086 int queuecommand_lck(struct scsi_cmnd *srb, void (*done) (struct scsi_cmnd *))
2087 {
2088         struct rts51x_chip *chip = host_to_rts51x(srb->device->host);
2089
2090         /* check for state-transition errors */
2091         if (chip->srb != NULL) {
2092                 RTS51X_DEBUGP("Error in %s: chip->srb = %p\n",
2093                                __func__, chip->srb);
2094                 return SCSI_MLQUEUE_HOST_BUSY;
2095         }
2096
2097         /* fail the command if we are disconnecting */
2098         if (test_bit(FLIDX_DISCONNECTING, &chip->usb->dflags)) {
2099                 RTS51X_DEBUGP("Fail command during disconnect\n");
2100                 srb->result = DID_NO_CONNECT << 16;
2101                 done(srb);
2102                 return 0;
2103         }
2104
2105         /* enqueue the command and wake up the control thread */
2106         srb->scsi_done = done;
2107         chip->srb = srb;
2108         complete(&chip->usb->cmnd_ready);
2109
2110         return 0;
2111 }
2112
2113 #if 0 /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 37) */
2114 int queuecommand(struct scsi_cmnd *srb, void (*done) (struct scsi_cmnd *))
2115 {
2116         return queuecommand_lck(srb, done);
2117 }
2118 #else
2119 DEF_SCSI_QCMD(queuecommand)
2120 #endif
2121 /***********************************************************************
2122  * Error handling functions
2123  ***********************************************************************/
2124 /* Command timeout and abort */
2125 int command_abort(struct scsi_cmnd *srb)
2126 {
2127         struct rts51x_chip *chip = host_to_rts51x(srb->device->host);
2128
2129         RTS51X_DEBUGP("%s called\n", __func__);
2130
2131         /* us->srb together with the TIMED_OUT, RESETTING, and ABORTING
2132          * bits are protected by the host lock. */
2133         scsi_lock(rts51x_to_host(chip));
2134
2135         /* Is this command still active? */
2136         if (chip->srb != srb) {
2137                 scsi_unlock(rts51x_to_host(chip));
2138                 RTS51X_DEBUGP("-- nothing to abort\n");
2139                 return FAILED;
2140         }
2141
2142         /* Set the TIMED_OUT bit.  Also set the ABORTING bit, but only if
2143          * a device reset isn't already in progress (to avoid interfering
2144          * with the reset).  Note that we must retain the host lock while
2145          * calling usb_stor_stop_transport(); otherwise it might interfere
2146          * with an auto-reset that begins as soon as we release the lock. */
2147         set_bit(FLIDX_TIMED_OUT, &chip->usb->dflags);
2148         if (!test_bit(FLIDX_RESETTING, &chip->usb->dflags)) {
2149                 set_bit(FLIDX_ABORTING, &chip->usb->dflags);
2150                 /* rts51x_stop_transport(us); */
2151         }
2152         scsi_unlock(rts51x_to_host(chip));
2153
2154         /* Wait for the aborted command to finish */
2155         wait_for_completion(&chip->usb->notify);
2156         return SUCCESS;
2157 }
2158
2159 /* This invokes the transport reset mechanism to reset the state of the
2160  * device */
2161 int device_reset(struct scsi_cmnd *srb)
2162 {
2163         int result = 0;
2164
2165         RTS51X_DEBUGP("%s called\n", __func__);
2166
2167         return result < 0 ? FAILED : SUCCESS;
2168 }
2169
2170 /* Simulate a SCSI bus reset by resetting the device's USB port. */
2171 int bus_reset(struct scsi_cmnd *srb)
2172 {
2173         int result = 0;
2174
2175         RTS51X_DEBUGP("%s called\n", __func__);
2176
2177         return result < 0 ? FAILED : SUCCESS;
2178 }
2179
2180 static const char *rts5139_info(struct Scsi_Host *host)
2181 {
2182         return "SCSI emulation for RTS5139 USB card reader";
2183 }
2184
2185 struct scsi_host_template rts51x_host_template = {
2186         /* basic userland interface stuff */
2187         .name = RTS51X_NAME,
2188         .proc_name = RTS51X_NAME,
2189         .proc_info = proc_info,
2190         .info = rts5139_info,
2191
2192         /* command interface -- queued only */
2193         .queuecommand = queuecommand,
2194
2195         /* error and abort handlers */
2196         .eh_abort_handler = command_abort,
2197         .eh_device_reset_handler = device_reset,
2198         .eh_bus_reset_handler = bus_reset,
2199
2200         /* queue commands only, only one command per LUN */
2201         .can_queue = 1,
2202         .cmd_per_lun = 1,
2203
2204         /* unknown initiator id */
2205         .this_id = -1,
2206
2207         .slave_alloc = slave_alloc,
2208         .slave_configure = slave_configure,
2209
2210         /* lots of sg segments can be handled */
2211         .sg_tablesize = SG_ALL,
2212
2213         /* limit the total size of a transfer to 120 KB */
2214         .max_sectors = 240,
2215
2216         /* merge commands... this seems to help performance, but
2217          * periodically someone should test to see which setting is more
2218          * optimal.
2219          */
2220         .use_clustering = 1,
2221
2222         /* emulated HBA */
2223         .emulated = 1,
2224
2225         /* we do our own delay after a device or bus reset */
2226         .skip_settle_delay = 1,
2227
2228         /* sysfs device attributes */
2229         /* .sdev_attrs = sysfs_device_attr_list, */
2230
2231         /* module management */
2232         .module = THIS_MODULE
2233 };
2234