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