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 0
 887                 if (chip->need_release & chip->lun2card[lun]) {
 888                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 889                 } else {
 890 #endif
 891                 if (srb->sc_data_direction == DMA_FROM_DEVICE) {
 892                         set_sense_type(chip, lun,
 893                                        SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
 894                 } else {
 895                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
 896                 }
 897 #if 0
 898                 }
 899 #endif
 900                 TRACE_RET(chip, TRANSPORT_FAILED);
 901         }
 902
 903         scsi_set_resid(srb, 0);
 904
 905         return TRANSPORT_GOOD;
 906 }
 907
 908 static int read_format_capacity(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 909 {
 910         unsigned char *buf;
 911         unsigned int lun = SCSI_LUN(srb);
 912         unsigned int buf_len;
 913         u8 card = get_lun_card(chip, lun);
 914         int desc_cnt;
 915         int i = 0;
 916
 917         if (!check_card_ready(chip, lun)) {
 918                 if (!chip->option.mspro_formatter_enable) {
 919                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 920                         TRACE_RET(chip, TRANSPORT_FAILED);
 921                 }
 922         }
 923
 924         buf_len = (scsi_bufflen(srb) > 12) ? 0x14 : 12;
 925
 926         buf = kmalloc(buf_len, GFP_KERNEL);
 927         if (buf == NULL)
 928                 TRACE_RET(chip, TRANSPORT_ERROR);
 929
 930         buf[i++] = 0;
 931         buf[i++] = 0;
 932         buf[i++] = 0;
 933
 934         /* Capacity List Length */
 935         if ((buf_len > 12) && chip->option.mspro_formatter_enable &&
 936             (chip->lun2card[lun] & MS_CARD) && (!card || (card == MS_CARD))) {
 937                 buf[i++] = 0x10;
 938                 desc_cnt = 2;
 939         } else {
 940                 buf[i++] = 0x08;
 941                 desc_cnt = 1;
 942         }
 943
 944         while (desc_cnt) {
 945                 if (check_card_ready(chip, lun)) {
 946                         buf[i++] = (unsigned char)((chip->capacity[lun]) >> 24);
 947                         buf[i++] = (unsigned char)((chip->capacity[lun]) >> 16);
 948                         buf[i++] = (unsigned char)((chip->capacity[lun]) >> 8);
 949                         buf[i++] = (unsigned char)(chip->capacity[lun]);
 950
 951                         if (desc_cnt == 2)
 952                                 /* Byte[8]: Descriptor Type: Formatted medium */
 953                                 buf[i++] = 2;
 954                         else
 955                                 buf[i++] = 0;   /* Byte[16] */
 956                 } else {
 957                         buf[i++] = 0xFF;
 958                         buf[i++] = 0xFF;
 959                         buf[i++] = 0xFF;
 960                         buf[i++] = 0xFF;
 961
 962                         if (desc_cnt == 2)
 963                                 /* Byte[8]: Descriptor Type: No medium */
 964                                 buf[i++] = 3;
 965                         else
 966                                 buf[i++] = 0;   /*Byte[16] */
 967                 }
 968
 969                 buf[i++] = 0x00;
 970                 buf[i++] = 0x02;
 971                 buf[i++] = 0x00;
 972
 973                 desc_cnt--;
 974         }
 975
 976         buf_len = min(scsi_bufflen(srb), buf_len);
 977         rts51x_set_xfer_buf(buf, buf_len, srb);
 978         kfree(buf);
 979
 980         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
 981
 982         return TRANSPORT_GOOD;
 983 }
 984
 985 static int read_capacity(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 986 {
 987         unsigned char *buf;
 988         unsigned int lun = SCSI_LUN(srb);
 989
 990         if (!check_card_ready(chip, lun)) {
 991                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 992                 TRACE_RET(chip, TRANSPORT_FAILED);
 993         }
 994
 995         if (!check_lun_mc(chip, lun)) {
 996                 set_lun_mc(chip, lun);
 997                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 998                 return TRANSPORT_FAILED;
 999         }
1000
1001         buf = kmalloc(8, GFP_KERNEL);
1002         if (buf == NULL)
1003                 TRACE_RET(chip, TRANSPORT_ERROR);
1004
1005         buf[0] = (unsigned char)((chip->capacity[lun] - 1) >> 24);
1006         buf[1] = (unsigned char)((chip->capacity[lun] - 1) >> 16);
1007         buf[2] = (unsigned char)((chip->capacity[lun] - 1) >> 8);
1008         buf[3] = (unsigned char)(chip->capacity[lun] - 1);
1009
1010         buf[4] = 0x00;
1011         buf[5] = 0x00;
1012         buf[6] = 0x02;
1013         buf[7] = 0x00;
1014
1015         rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1016         kfree(buf);
1017
1018         scsi_set_resid(srb, 0);
1019
1020         return TRANSPORT_GOOD;
1021 }
1022
1023 static int get_dev_status(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1024 {
1025         unsigned int lun = SCSI_LUN(srb);
1026         unsigned int buf_len;
1027         u8 status[32] = { 0 };
1028
1029         rts51x_pp_status(chip, lun, status, 32);
1030
1031         buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(status));
1032         rts51x_set_xfer_buf(status, buf_len, srb);
1033         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1034
1035         return TRANSPORT_GOOD;
1036 }
1037
1038 static int read_status(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1039 {
1040         u8 rts51x_status[16];
1041         unsigned int buf_len;
1042         unsigned int lun = SCSI_LUN(srb);
1043
1044         rts51x_read_status(chip, lun, rts51x_status, 16);
1045
1046         buf_len = min(scsi_bufflen(srb), (unsigned int)sizeof(rts51x_status));
1047         rts51x_set_xfer_buf(rts51x_status, buf_len, srb);
1048         scsi_set_resid(srb, scsi_bufflen(srb) - buf_len);
1049
1050         return TRANSPORT_GOOD;
1051 }
1052
1053 static int read_mem(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1054 {
1055         unsigned int lun = SCSI_LUN(srb);
1056         unsigned short addr, len, i;
1057         int retval;
1058         u8 *buf;
1059
1060         rts51x_prepare_run(chip);
1061         RTS51X_SET_STAT(chip, STAT_RUN);
1062
1063         addr = ((u16) srb->cmnd[2] << 8) | srb->cmnd[3];
1064         len = ((u16) srb->cmnd[4] << 8) | srb->cmnd[5];
1065
1066         if (addr < 0xe000) {
1067                 RTS51X_DEBUGP("filter!addr=0x%x\n", addr);
1068                 return TRANSPORT_GOOD;
1069         }
1070
1071         buf = vmalloc(len);
1072         if (!buf)
1073                 TRACE_RET(chip, TRANSPORT_ERROR);
1074
1075         for (i = 0; i < len; i++) {
1076                 retval = rts51x_ep0_read_register(chip, addr + i, buf + i);
1077                 if (retval != STATUS_SUCCESS) {
1078                         vfree(buf);
1079                         set_sense_type(chip, lun,
1080                                        SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1081                         TRACE_RET(chip, TRANSPORT_FAILED);
1082                 }
1083         }
1084
1085         len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1086         rts51x_set_xfer_buf(buf, len, srb);
1087         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1088
1089         vfree(buf);
1090
1091         return TRANSPORT_GOOD;
1092 }
1093
1094 static int write_mem(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1095 {
1096         unsigned int lun = SCSI_LUN(srb);
1097         unsigned short addr, len, i;
1098         int retval;
1099         u8 *buf;
1100
1101         rts51x_prepare_run(chip);
1102         RTS51X_SET_STAT(chip, STAT_RUN);
1103
1104         addr = ((u16) srb->cmnd[2] << 8) | srb->cmnd[3];
1105         len = ((u16) srb->cmnd[4] << 8) | srb->cmnd[5];
1106
1107         if (addr < 0xe000) {
1108                 RTS51X_DEBUGP("filter!addr=0x%x\n", addr);
1109                 return TRANSPORT_GOOD;
1110         }
1111
1112         len = (unsigned short)min(scsi_bufflen(srb), (unsigned int)len);
1113         buf = vmalloc(len);
1114         if (!buf)
1115                 TRACE_RET(chip, TRANSPORT_ERROR);
1116
1117         rts51x_get_xfer_buf(buf, len, srb);
1118
1119         for (i = 0; i < len; i++) {
1120                 retval =
1121                     rts51x_ep0_write_register(chip, addr + i, 0xFF, buf[i]);
1122                 if (retval != STATUS_SUCCESS) {
1123                         vfree(buf);
1124                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1125                         TRACE_RET(chip, TRANSPORT_FAILED);
1126                 }
1127         }
1128
1129         vfree(buf);
1130         scsi_set_resid(srb, scsi_bufflen(srb) - len);
1131
1132         return TRANSPORT_GOOD;
1133 }
1134
1135 static int get_sd_csd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1136 {
1137         struct sd_info *sd_card = &(chip->sd_card);
1138         unsigned int lun = SCSI_LUN(srb);
1139
1140         if (!check_card_ready(chip, lun)) {
1141                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1142                 TRACE_RET(chip, TRANSPORT_FAILED);
1143         }
1144
1145         if (get_lun_card(chip, lun) != SD_CARD) {
1146                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1147                 TRACE_RET(chip, TRANSPORT_FAILED);
1148         }
1149
1150         scsi_set_resid(srb, 0);
1151         rts51x_set_xfer_buf(sd_card->raw_csd, scsi_bufflen(srb), srb);
1152
1153         return TRANSPORT_GOOD;
1154 }
1155
1156 static int read_phy_register(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1157 {
1158         int retval;
1159         u8 addr, len, i;
1160         u8 *buf;
1161
1162         rts51x_prepare_run(chip);
1163         RTS51X_SET_STAT(chip, STAT_RUN);
1164
1165         addr = srb->cmnd[5];
1166         len = srb->cmnd[7];
1167
1168         if (len) {
1169                 buf = vmalloc(len);
1170                 if (!buf)
1171                         TRACE_RET(chip, TRANSPORT_ERROR);
1172
1173                 for (i = 0; i < len; i++) {
1174                         retval =
1175                             rts51x_read_phy_register(chip, addr + i, buf + i);
1176                         if (retval != STATUS_SUCCESS) {
1177                                 vfree(buf);
1178                                 set_sense_type(chip, SCSI_LUN(srb),
1179                                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1180                                 TRACE_RET(chip, TRANSPORT_FAILED);
1181                         }
1182                 }
1183
1184                 len = min(scsi_bufflen(srb), (unsigned int)len);
1185                 rts51x_set_xfer_buf(buf, len, srb);
1186                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1187
1188                 vfree(buf);
1189         }
1190
1191         return TRANSPORT_GOOD;
1192 }
1193
1194 static int write_phy_register(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1195 {
1196         int retval;
1197         u8 addr, len, i;
1198         u8 *buf;
1199
1200         rts51x_prepare_run(chip);
1201         RTS51X_SET_STAT(chip, STAT_RUN);
1202
1203         addr = srb->cmnd[5];
1204         len = srb->cmnd[7];
1205
1206         if (len) {
1207                 len = min(scsi_bufflen(srb), (unsigned int)len);
1208
1209                 buf = vmalloc(len);
1210                 if (buf == NULL)
1211                         TRACE_RET(chip, TRANSPORT_ERROR);
1212
1213                 rts51x_get_xfer_buf(buf, len, srb);
1214                 scsi_set_resid(srb, scsi_bufflen(srb) - len);
1215
1216                 for (i = 0; i < len; i++) {
1217                         retval =
1218                             rts51x_write_phy_register(chip, addr + i, buf[i]);
1219                         if (retval != STATUS_SUCCESS) {
1220                                 vfree(buf);
1221                                 set_sense_type(chip, SCSI_LUN(srb),
1222                                                SENSE_TYPE_MEDIA_WRITE_ERR);
1223                                 TRACE_RET(chip, TRANSPORT_FAILED);
1224                         }
1225                 }
1226
1227                 vfree(buf);
1228         }
1229
1230         return TRANSPORT_GOOD;
1231 }
1232
1233 static int get_card_bus_width(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1234 {
1235         unsigned int lun = SCSI_LUN(srb);
1236         u8 card, bus_width;
1237
1238         if (!check_card_ready(chip, lun)) {
1239                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1240                 TRACE_RET(chip, TRANSPORT_FAILED);
1241         }
1242
1243         card = get_lun_card(chip, lun);
1244         if ((card == SD_CARD) || (card == MS_CARD)) {
1245                 bus_width = chip->card_bus_width[lun];
1246         } else {
1247                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1248                 TRACE_RET(chip, TRANSPORT_FAILED);
1249         }
1250
1251         scsi_set_resid(srb, 0);
1252         rts51x_set_xfer_buf(&bus_width, scsi_bufflen(srb), srb);
1253
1254         return TRANSPORT_GOOD;
1255 }
1256
1257 #ifdef _MSG_TRACE
1258 static int trace_msg_cmd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1259 {
1260         unsigned char *buf = NULL;
1261         u8 clear;
1262         unsigned int buf_len;
1263
1264         buf_len =
1265             4 +
1266             ((2 + MSG_FUNC_LEN + MSG_FILE_LEN + TIME_VAL_LEN) * TRACE_ITEM_CNT);
1267
1268         if ((scsi_bufflen(srb) < buf_len) || (scsi_sglist(srb) == NULL)) {
1269                 set_sense_type(chip, SCSI_LUN(srb),
1270                                SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1271                 TRACE_RET(chip, TRANSPORT_FAILED);
1272         }
1273
1274         clear = srb->cmnd[2];
1275
1276         buf = vmalloc(scsi_bufflen(srb));
1277         if (buf == NULL)
1278                 TRACE_RET(chip, TRANSPORT_ERROR);
1279
1280         rts51x_trace_msg(chip, buf, clear);
1281
1282         rts51x_set_xfer_buf(buf, scsi_bufflen(srb), srb);
1283         vfree(buf);
1284
1285         scsi_set_resid(srb, 0);
1286         return TRANSPORT_GOOD;
1287 }
1288 #endif
1289
1290 static int rw_mem_cmd_buf(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1291 {
1292         int retval = STATUS_SUCCESS;
1293         unsigned int lun = SCSI_LUN(srb);
1294         u8 cmd_type, mask, value, idx, mode, len;
1295         u16 addr;
1296         u32 timeout;
1297
1298         rts51x_prepare_run(chip);
1299         RTS51X_SET_STAT(chip, STAT_RUN);
1300
1301         switch (srb->cmnd[3]) {
1302         case INIT_BATCHCMD:
1303                 rts51x_init_cmd(chip);
1304                 break;
1305
1306         case ADD_BATCHCMD:
1307                 cmd_type = srb->cmnd[4];
1308                 if (cmd_type > 2) {
1309                         set_sense_type(chip, lun,
1310                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1311                         TRACE_RET(chip, TRANSPORT_FAILED);
1312                 }
1313                 addr = (srb->cmnd[5] << 8) | srb->cmnd[6];
1314                 mask = srb->cmnd[7];
1315                 value = srb->cmnd[8];
1316                 rts51x_add_cmd(chip, cmd_type, addr, mask, value);
1317                 break;
1318
1319         case SEND_BATCHCMD:
1320                 mode = srb->cmnd[4];
1321                 len = srb->cmnd[5];
1322                 timeout =
1323                     ((u32) srb->cmnd[6] << 24) | ((u32) srb->
1324                                                   cmnd[7] << 16) | ((u32) srb->
1325                                                                     cmnd[8] <<
1326                                                                     8) | ((u32)
1327                                                                           srb->
1328                                                                           cmnd
1329                                                                           [9]);
1330                 retval = rts51x_send_cmd(chip, mode, 1000);
1331                 if (retval != STATUS_SUCCESS) {
1332                         set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1333                         TRACE_RET(chip, TRANSPORT_FAILED);
1334                 }
1335                 if (mode & STAGE_R) {
1336                         retval = rts51x_get_rsp(chip, len, timeout);
1337                         if (retval != STATUS_SUCCESS) {
1338                                 set_sense_type(chip, lun,
1339                                         SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
1340                                 TRACE_RET(chip, TRANSPORT_FAILED);
1341                         }
1342                 }
1343                 break;
1344
1345         case GET_BATCHRSP:
1346                 idx = srb->cmnd[4];
1347                 value = chip->rsp_buf[idx];
1348                 if (scsi_bufflen(srb) < 1) {
1349                         set_sense_type(chip, lun,
1350                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1351                         TRACE_RET(chip, TRANSPORT_FAILED);
1352                 }
1353                 rts51x_set_xfer_buf(&value, 1, srb);
1354                 scsi_set_resid(srb, 0);
1355                 break;
1356
1357         default:
1358                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1359                 TRACE_RET(chip, TRANSPORT_FAILED);
1360         }
1361
1362         if (retval != STATUS_SUCCESS) {
1363                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
1364                 TRACE_RET(chip, TRANSPORT_FAILED);
1365         }
1366
1367         return TRANSPORT_GOOD;
1368 }
1369
1370 static int suit_cmd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1371 {
1372         int result;
1373
1374         switch (srb->cmnd[3]) {
1375         case INIT_BATCHCMD:
1376         case ADD_BATCHCMD:
1377         case SEND_BATCHCMD:
1378         case GET_BATCHRSP:
1379                 result = rw_mem_cmd_buf(srb, chip);
1380                 break;
1381         default:
1382                 result = TRANSPORT_ERROR;
1383         }
1384
1385         return result;
1386 }
1387
1388 static int app_cmd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1389 {
1390         int result;
1391
1392         switch (srb->cmnd[2]) {
1393         case PP_READ10:
1394         case PP_WRITE10:
1395                 result = read_write(srb, chip);
1396                 break;
1397
1398         case SUIT_CMD:
1399                 result = suit_cmd(srb, chip);
1400                 break;
1401
1402         case READ_PHY:
1403                 result = read_phy_register(srb, chip);
1404                 break;
1405
1406         case WRITE_PHY:
1407                 result = write_phy_register(srb, chip);
1408                 break;
1409
1410         case GET_DEV_STATUS:
1411                 result = get_dev_status(srb, chip);
1412                 break;
1413
1414         default:
1415                 set_sense_type(chip, SCSI_LUN(srb),
1416                                SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1417                 TRACE_RET(chip, TRANSPORT_FAILED);
1418         }
1419
1420         return result;
1421 }
1422
1423 static int vendor_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1424 {
1425         int result = TRANSPORT_GOOD;
1426
1427         switch (srb->cmnd[1]) {
1428         case READ_STATUS:
1429                 result = read_status(srb, chip);
1430                 break;
1431
1432         case READ_MEM:
1433                 result = read_mem(srb, chip);
1434                 break;
1435
1436         case WRITE_MEM:
1437                 result = write_mem(srb, chip);
1438                 break;
1439
1440         case GET_BUS_WIDTH:
1441                 result = get_card_bus_width(srb, chip);
1442                 break;
1443
1444         case GET_SD_CSD:
1445                 result = get_sd_csd(srb, chip);
1446                 break;
1447
1448 #ifdef _MSG_TRACE
1449         case TRACE_MSG:
1450                 result = trace_msg_cmd(srb, chip);
1451                 break;
1452 #endif
1453
1454         case SCSI_APP_CMD:
1455                 result = app_cmd(srb, chip);
1456                 break;
1457
1458         default:
1459                 set_sense_type(chip, SCSI_LUN(srb),
1460                                SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1461                 TRACE_RET(chip, TRANSPORT_FAILED);
1462         }
1463
1464         return result;
1465 }
1466
1467 static int ms_format_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1468 {
1469         struct ms_info *ms_card = &(chip->ms_card);
1470         unsigned int lun = SCSI_LUN(srb);
1471         int retval, quick_format;
1472
1473         if (get_lun_card(chip, lun) != MS_CARD) {
1474                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1475                 TRACE_RET(chip, TRANSPORT_FAILED);
1476         }
1477
1478         if ((srb->cmnd[3] != 0x4D) || (srb->cmnd[4] != 0x47)
1479             || (srb->cmnd[5] != 0x66) || (srb->cmnd[6] != 0x6D)
1480             || (srb->cmnd[7] != 0x74)) {
1481                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1482                 TRACE_RET(chip, TRANSPORT_FAILED);
1483         }
1484
1485         if (srb->cmnd[8] & 0x01)
1486                 quick_format = 0;
1487         else
1488                 quick_format = 1;
1489
1490         if (!(chip->card_ready & MS_CARD)) {
1491                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1492                 TRACE_RET(chip, TRANSPORT_FAILED);
1493         }
1494
1495         if (chip->card_wp & MS_CARD) {
1496                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
1497                 TRACE_RET(chip, TRANSPORT_FAILED);
1498         }
1499
1500         if (!CHK_MSPRO(ms_card)) {
1501                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1502                 TRACE_RET(chip, TRANSPORT_FAILED);
1503         }
1504
1505         rts51x_prepare_run(chip);
1506         RTS51X_SET_STAT(chip, STAT_RUN);
1507
1508         retval = mspro_format(srb, chip, MS_SHORT_DATA_LEN, quick_format);
1509         if (retval != STATUS_SUCCESS) {
1510                 set_sense_type(chip, lun, SENSE_TYPE_FORMAT_CMD_FAILED);
1511                 TRACE_RET(chip, TRANSPORT_FAILED);
1512         }
1513
1514         scsi_set_resid(srb, 0);
1515         return TRANSPORT_GOOD;
1516 }
1517
1518 #ifdef SUPPORT_PCGL_1P18
1519 int get_ms_information(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1520 {
1521         struct ms_info *ms_card = &(chip->ms_card);
1522         unsigned int lun = SCSI_LUN(srb);
1523         u8 dev_info_id, data_len;
1524         u8 *buf;
1525         unsigned int buf_len;
1526         int i;
1527
1528         if (!check_card_ready(chip, lun)) {
1529                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1530                 TRACE_RET(chip, TRANSPORT_FAILED);
1531         }
1532         if ((get_lun_card(chip, lun) != MS_CARD)) {
1533                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1534                 TRACE_RET(chip, TRANSPORT_FAILED);
1535         }
1536
1537         if ((srb->cmnd[2] != 0xB0) || (srb->cmnd[4] != 0x4D) ||
1538             (srb->cmnd[5] != 0x53) || (srb->cmnd[6] != 0x49) ||
1539             (srb->cmnd[7] != 0x44)) {
1540                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1541                 TRACE_RET(chip, TRANSPORT_FAILED);
1542         }
1543
1544         dev_info_id = srb->cmnd[3];
1545         if ((CHK_MSXC(ms_card) && (dev_info_id == 0x10)) ||
1546             (!CHK_MSXC(ms_card) && (dev_info_id == 0x13)) ||
1547             !CHK_MSPRO(ms_card)) {
1548                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1549                 TRACE_RET(chip, TRANSPORT_FAILED);
1550         }
1551
1552         if (dev_info_id == 0x15)
1553                 buf_len = data_len = 0x3A;
1554         else
1555                 buf_len = data_len = 0x6A;
1556
1557         buf = kmalloc(buf_len, GFP_KERNEL);
1558         if (!buf)
1559                 TRACE_RET(chip, TRANSPORT_ERROR);
1560
1561         i = 0;
1562         /* GET Memory Stick Media Information Response Header */
1563         buf[i++] = 0x00;        /* Data length MSB */
1564         buf[i++] = data_len;    /* Data length LSB */
1565         /* Device Information Type Code */
1566         if (CHK_MSXC(ms_card))
1567                 buf[i++] = 0x03;
1568         else
1569                 buf[i++] = 0x02;
1570         /* SGM bit */
1571         buf[i++] = 0x01;
1572         /* Reserved */
1573         buf[i++] = 0x00;
1574         buf[i++] = 0x00;
1575         buf[i++] = 0x00;
1576         /* Number of Device Information */
1577         buf[i++] = 0x01;
1578
1579         /*  Device Information Body
1580          *  Device Information ID Number */
1581         buf[i++] = dev_info_id;
1582         /* Device Information Length */
1583         if (dev_info_id == 0x15)
1584                 data_len = 0x31;
1585         else
1586                 data_len = 0x61;
1587         buf[i++] = 0x00;        /* Data length MSB */
1588         buf[i++] = data_len;    /* Data length LSB */
1589         /* Valid Bit */
1590         buf[i++] = 0x80;
1591         if ((dev_info_id == 0x10) || (dev_info_id == 0x13)) {
1592                 /* System Information */
1593                 memcpy(buf + i, ms_card->raw_sys_info, 96);
1594         } else {
1595                 /* Model Name */
1596                 memcpy(buf + i, ms_card->raw_model_name, 48);
1597         }
1598
1599         rts51x_set_xfer_buf(buf, buf_len, srb);
1600
1601         if (dev_info_id == 0x15)
1602                 scsi_set_resid(srb, scsi_bufflen(srb) - 0x3C);
1603         else
1604                 scsi_set_resid(srb, scsi_bufflen(srb) - 0x6C);
1605
1606         kfree(buf);
1607         return STATUS_SUCCESS;
1608 }
1609 #endif
1610
1611 static int ms_sp_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1612 {
1613         int retval = TRANSPORT_ERROR;
1614
1615         if (srb->cmnd[2] == MS_FORMAT)
1616                 retval = ms_format_cmnd(srb, chip);
1617 #ifdef SUPPORT_PCGL_1P18
1618         else if (srb->cmnd[2] == GET_MS_INFORMATION)
1619                 retval = get_ms_information(srb, chip);
1620 #endif
1621
1622         return retval;
1623 }
1624
1625 #ifdef SUPPORT_CPRM
1626 static int sd_extention_cmnd(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1627 {
1628         unsigned int lun = SCSI_LUN(srb);
1629         int result;
1630
1631         rts51x_prepare_run(chip);
1632         RTS51X_SET_STAT(chip, STAT_RUN);
1633
1634         sd_cleanup_work(chip);
1635
1636         if (!check_card_ready(chip, lun)) {
1637                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1638                 TRACE_RET(chip, TRANSPORT_FAILED);
1639         }
1640         if ((get_lun_card(chip, lun) != SD_CARD)) {
1641                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1642                 TRACE_RET(chip, TRANSPORT_FAILED);
1643         }
1644
1645         switch (srb->cmnd[0]) {
1646         case SD_PASS_THRU_MODE:
1647                 result = sd_pass_thru_mode(srb, chip);
1648                 break;
1649
1650         case SD_EXECUTE_NO_DATA:
1651                 result = sd_execute_no_data(srb, chip);
1652                 break;
1653
1654         case SD_EXECUTE_READ:
1655                 result = sd_execute_read_data(srb, chip);
1656                 break;
1657
1658         case SD_EXECUTE_WRITE:
1659                 result = sd_execute_write_data(srb, chip);
1660                 break;
1661
1662         case SD_GET_RSP:
1663                 result = sd_get_cmd_rsp(srb, chip);
1664                 break;
1665
1666         case SD_HW_RST:
1667                 result = sd_hw_rst(srb, chip);
1668                 break;
1669
1670         default:
1671                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1672                 TRACE_RET(chip, TRANSPORT_FAILED);
1673         }
1674
1675         return result;
1676 }
1677 #endif
1678
1679 #ifdef SUPPORT_MAGIC_GATE
1680 int mg_report_key(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1681 {
1682         struct ms_info *ms_card = &(chip->ms_card);
1683         unsigned int lun = SCSI_LUN(srb);
1684         int retval;
1685         u8 key_format;
1686
1687         rts51x_prepare_run(chip);
1688         RTS51X_SET_STAT(chip, STAT_RUN);
1689
1690         ms_cleanup_work(chip);
1691
1692         if (!check_card_ready(chip, lun)) {
1693                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1694                 TRACE_RET(chip, TRANSPORT_FAILED);
1695         }
1696         if ((get_lun_card(chip, lun) != MS_CARD)) {
1697                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1698                 TRACE_RET(chip, TRANSPORT_FAILED);
1699         }
1700
1701         if (srb->cmnd[7] != KC_MG_R_PRO) {
1702                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1703                 TRACE_RET(chip, TRANSPORT_FAILED);
1704         }
1705
1706         if (!CHK_MSPRO(ms_card)) {
1707                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
1708                 TRACE_RET(chip, TRANSPORT_FAILED);
1709         }
1710
1711         key_format = srb->cmnd[10] & 0x3F;
1712
1713         switch (key_format) {
1714         case KF_GET_LOC_EKB:
1715                 if ((scsi_bufflen(srb) == 0x41C) &&
1716                     (srb->cmnd[8] == 0x04) && (srb->cmnd[9] == 0x1C)) {
1717                         retval = mg_get_local_EKB(srb, chip);
1718                         if (retval != STATUS_SUCCESS)
1719                                 TRACE_RET(chip, TRANSPORT_FAILED);
1720                 } else {
1721                         set_sense_type(chip, lun,
1722                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1723                         TRACE_RET(chip, TRANSPORT_FAILED);
1724                 }
1725                 break;
1726
1727         case KF_RSP_CHG:
1728                 if ((scsi_bufflen(srb) == 0x24) &&
1729                     (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x24)) {
1730                         retval = mg_get_rsp_chg(srb, chip);
1731                         if (retval != STATUS_SUCCESS)
1732                                 TRACE_RET(chip, TRANSPORT_FAILED);
1733                 } else {
1734                         set_sense_type(chip, lun,
1735                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1736                         TRACE_RET(chip, TRANSPORT_FAILED);
1737                 }
1738                 break;
1739
1740         case KF_GET_ICV:
1741                 ms_card->mg_entry_num = srb->cmnd[5];
1742                 if ((scsi_bufflen(srb) == 0x404) &&
1743                     (srb->cmnd[8] == 0x04) &&
1744                     (srb->cmnd[9] == 0x04) &&
1745                     (srb->cmnd[2] == 0x00) &&
1746                     (srb->cmnd[3] == 0x00) &&
1747                     (srb->cmnd[4] == 0x00) && (srb->cmnd[5] < 32)) {
1748                         retval = mg_get_ICV(srb, chip);
1749                         if (retval != STATUS_SUCCESS)
1750                                 TRACE_RET(chip, TRANSPORT_FAILED);
1751                 } else {
1752                         set_sense_type(chip, lun,
1753                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1754                         TRACE_RET(chip, TRANSPORT_FAILED);
1755                 }
1756                 break;
1757
1758         default:
1759                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1760                 TRACE_RET(chip, TRANSPORT_FAILED);
1761         }
1762
1763         scsi_set_resid(srb, 0);
1764         return TRANSPORT_GOOD;
1765 }
1766
1767 int mg_send_key(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1768 {
1769         struct ms_info *ms_card = &(chip->ms_card);
1770         unsigned int lun = SCSI_LUN(srb);
1771         int retval;
1772         u8 key_format;
1773
1774         rts51x_prepare_run(chip);
1775         RTS51X_SET_STAT(chip, STAT_RUN);
1776
1777         ms_cleanup_work(chip);
1778
1779         if (!check_card_ready(chip, lun)) {
1780                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1781                 TRACE_RET(chip, TRANSPORT_FAILED);
1782         }
1783         if (check_card_wp(chip, lun)) {
1784                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_PROTECT);
1785                 TRACE_RET(chip, TRANSPORT_FAILED);
1786         }
1787         if ((get_lun_card(chip, lun) != MS_CARD)) {
1788                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_LUN_NOT_SUPPORT);
1789                 TRACE_RET(chip, TRANSPORT_FAILED);
1790         }
1791
1792         if (srb->cmnd[7] != KC_MG_R_PRO) {
1793                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1794                 TRACE_RET(chip, TRANSPORT_FAILED);
1795         }
1796
1797         if (!CHK_MSPRO(ms_card)) {
1798                 set_sense_type(chip, lun, SENSE_TYPE_MG_INCOMPATIBLE_MEDIUM);
1799                 TRACE_RET(chip, TRANSPORT_FAILED);
1800         }
1801
1802         key_format = srb->cmnd[10] & 0x3F;
1803
1804         switch (key_format) {
1805         case KF_SET_LEAF_ID:
1806                 if ((scsi_bufflen(srb) == 0x0C) &&
1807                     (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x0C)) {
1808                         retval = mg_set_leaf_id(srb, chip);
1809                         if (retval != STATUS_SUCCESS)
1810                                 TRACE_RET(chip, TRANSPORT_FAILED);
1811                 } else {
1812                         set_sense_type(chip, lun,
1813                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1814                         TRACE_RET(chip, TRANSPORT_FAILED);
1815                 }
1816                 break;
1817
1818         case KF_CHG_HOST:
1819                 if ((scsi_bufflen(srb) == 0x0C) &&
1820                     (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x0C)) {
1821                         retval = mg_chg(srb, chip);
1822                         if (retval != STATUS_SUCCESS)
1823                                 TRACE_RET(chip, TRANSPORT_FAILED);
1824                 } else {
1825                         set_sense_type(chip, lun,
1826                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1827                         TRACE_RET(chip, TRANSPORT_FAILED);
1828                 }
1829                 break;
1830
1831         case KF_RSP_HOST:
1832                 if ((scsi_bufflen(srb) == 0x0C) &&
1833                     (srb->cmnd[8] == 0x00) && (srb->cmnd[9] == 0x0C)) {
1834                         retval = mg_rsp(srb, chip);
1835                         if (retval != STATUS_SUCCESS)
1836                                 TRACE_RET(chip, TRANSPORT_FAILED);
1837                 } else {
1838                         set_sense_type(chip, lun,
1839                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1840                         TRACE_RET(chip, TRANSPORT_FAILED);
1841                 }
1842                 break;
1843
1844         case KF_SET_ICV:
1845                 ms_card->mg_entry_num = srb->cmnd[5];
1846                 if ((scsi_bufflen(srb) == 0x404) &&
1847                     (srb->cmnd[8] == 0x04) &&
1848                     (srb->cmnd[9] == 0x04) &&
1849                     (srb->cmnd[2] == 0x00) &&
1850                     (srb->cmnd[3] == 0x00) &&
1851                     (srb->cmnd[4] == 0x00) && (srb->cmnd[5] < 32)) {
1852                         retval = mg_set_ICV(srb, chip);
1853                         if (retval != STATUS_SUCCESS)
1854                                 TRACE_RET(chip, TRANSPORT_FAILED);
1855                 } else {
1856                         set_sense_type(chip, lun,
1857                                        SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1858                         TRACE_RET(chip, TRANSPORT_FAILED);
1859                 }
1860                 break;
1861
1862         default:
1863                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1864                 TRACE_RET(chip, TRANSPORT_FAILED);
1865         }
1866
1867         scsi_set_resid(srb, 0);
1868         return TRANSPORT_GOOD;
1869 }
1870 #endif
1871
1872 int rts51x_scsi_handler(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1873 {
1874 #ifdef SUPPORT_SD_LOCK
1875         struct sd_info *sd_card = &(chip->sd_card);
1876 #endif
1877         struct ms_info *ms_card = &(chip->ms_card);
1878         unsigned int lun = SCSI_LUN(srb);
1879         int result = TRANSPORT_GOOD;
1880
1881 #ifdef SUPPORT_SD_LOCK
1882         if (sd_card->sd_erase_status) {
1883                 /* Block all SCSI command except for REQUEST_SENSE
1884                  * and rs_ppstatus */
1885                 if (!
1886                     ((srb->cmnd[0] == VENDOR_CMND)
1887                      && (srb->cmnd[1] == SCSI_APP_CMD)
1888                      && (srb->cmnd[2] == GET_DEV_STATUS))
1889                     && (srb->cmnd[0] != REQUEST_SENSE)) {
1890                         /* Logical Unit Not Ready Format in Progress */
1891                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
1892                                        0, 0);
1893                         TRACE_RET(chip, TRANSPORT_FAILED);
1894                 }
1895         }
1896 #endif
1897
1898         if ((get_lun_card(chip, lun) == MS_CARD) &&
1899             (ms_card->format_status == FORMAT_IN_PROGRESS)) {
1900                 if ((srb->cmnd[0] != REQUEST_SENSE)
1901                     && (srb->cmnd[0] != INQUIRY)) {
1902                         /* Logical Unit Not Ready Format in Progress */
1903                         set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
1904                                        0, (u16) (ms_card->progress));
1905                         TRACE_RET(chip, TRANSPORT_FAILED);
1906                 }
1907         }
1908
1909         switch (srb->cmnd[0]) {
1910         case READ_10:
1911         case WRITE_10:
1912         case READ_6:
1913         case WRITE_6:
1914                 result = read_write(srb, chip);
1915                 break;
1916
1917         case TEST_UNIT_READY:
1918                 result = test_unit_ready(srb, chip);
1919                 break;
1920
1921         case INQUIRY:
1922                 result = inquiry(srb, chip);
1923                 break;
1924
1925         case READ_CAPACITY:
1926                 result = read_capacity(srb, chip);
1927                 break;
1928
1929         case START_STOP:
1930                 result = start_stop_unit(srb, chip);
1931                 break;
1932
1933         case ALLOW_MEDIUM_REMOVAL:
1934                 result = allow_medium_removal(srb, chip);
1935                 break;
1936
1937         case REQUEST_SENSE:
1938                 result = request_sense(srb, chip);
1939                 break;
1940
1941         case MODE_SENSE:
1942         case MODE_SENSE_10:
1943                 result = mode_sense(srb, chip);
1944                 break;
1945
1946         case 0x23:
1947                 result = read_format_capacity(srb, chip);
1948                 break;
1949
1950         case VENDOR_CMND:
1951                 result = vendor_cmnd(srb, chip);
1952                 break;
1953
1954         case MS_SP_CMND:
1955                 result = ms_sp_cmnd(srb, chip);
1956                 break;
1957
1958 #ifdef SUPPORT_CPRM
1959         case SD_PASS_THRU_MODE:
1960         case SD_EXECUTE_NO_DATA:
1961         case SD_EXECUTE_READ:
1962         case SD_EXECUTE_WRITE:
1963         case SD_GET_RSP:
1964         case SD_HW_RST:
1965                 result = sd_extention_cmnd(srb, chip);
1966                 break;
1967 #endif
1968
1969 #ifdef SUPPORT_MAGIC_GATE
1970         case CMD_MSPRO_MG_RKEY:
1971                 result = mg_report_key(srb, chip);
1972                 break;
1973
1974         case CMD_MSPRO_MG_SKEY:
1975                 result = mg_send_key(srb, chip);
1976                 break;
1977 #endif
1978
1979         case FORMAT_UNIT:
1980         case MODE_SELECT:
1981         case VERIFY:
1982                 result = TRANSPORT_GOOD;
1983                 break;
1984
1985         default:
1986                 set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1987                 result = TRANSPORT_FAILED;
1988         }
1989
1990         return result;
1991 }
1992
1993 /***********************************************************************
1994  * Host functions
1995  ***********************************************************************/
1996
1997 const char *host_info(struct Scsi_Host *host)
1998 {
1999         return "SCSI emulation for RTS51xx USB driver-based card reader";
2000 }
2001
2002 int slave_alloc(struct scsi_device *sdev)
2003 {
2004         /*
2005          * Set the INQUIRY transfer length to 36.  We don't use any of
2006          * the extra data and many devices choke if asked for more or
2007          * less than 36 bytes.
2008          */
2009         sdev->inquiry_len = 36;
2010         return 0;
2011 }
2012
2013 int slave_configure(struct scsi_device *sdev)
2014 {
2015         /* Scatter-gather buffers (all but the last) must have a length
2016          * divisible by the bulk maxpacket size.  Otherwise a data packet
2017          * would end up being short, causing a premature end to the data
2018          * transfer.  Since high-speed bulk pipes have a maxpacket size
2019          * of 512, we'll use that as the scsi device queue's DMA alignment
2020          * mask.  Guaranteeing proper alignment of the first buffer will
2021          * have the desired effect because, except at the beginning and
2022          * the end, scatter-gather buffers follow page boundaries. */
2023         blk_queue_dma_alignment(sdev->request_queue, (512 - 1));
2024
2025         /* Set the SCSI level to at least 2.  We'll leave it at 3 if that's
2026          * what is originally reported.  We need this to avoid confusing
2027          * the SCSI layer with devices that report 0 or 1, but need 10-byte
2028          * commands (ala ATAPI devices behind certain bridges, or devices
2029          * which simply have broken INQUIRY data).
2030          *
2031          * NOTE: This means /dev/sg programs (ala cdrecord) will get the
2032          * actual information.  This seems to be the preference for
2033          * programs like that.
2034          *
2035          * NOTE: This also means that /proc/scsi/scsi and sysfs may report
2036          * the actual value or the modified one, depending on where the
2037          * data comes from.
2038          */
2039         if (sdev->scsi_level < SCSI_2)
2040                 sdev->scsi_level = sdev->sdev_target->scsi_level = SCSI_2;
2041
2042         return 0;
2043 }
2044
2045 /***********************************************************************
2046  * /proc/scsi/ functions
2047  ***********************************************************************/
2048
2049 /* we use this macro to help us write into the buffer */
2050 #undef SPRINTF
2051 #define SPRINTF(args...) \
2052         do { if (pos < buffer+length) pos += sprintf(pos, ## args); } while (0)
2053
2054 int proc_info(struct Scsi_Host *host, char *buffer,
2055               char **start, off_t offset, int length, int inout)
2056 {
2057         char *pos = buffer;
2058
2059         /* if someone is sending us data, just throw it away */
2060         if (inout)
2061                 return length;
2062
2063         /* print the controller name */
2064         SPRINTF("   Host scsi%d: %s\n", host->host_no, RTS51X_NAME);
2065
2066         /* print product, vendor, and driver version strings */
2067         SPRINTF("       Vendor: Realtek Corp.\n");
2068         SPRINTF("      Product: RTS51xx USB Card Reader\n");
2069         SPRINTF("      Version: %s\n", DRIVER_VERSION);
2070         SPRINTF("        Build: %s\n", __TIME__);
2071
2072         /*
2073          * Calculate start of next buffer, and return value.
2074          */
2075         *start = buffer + offset;
2076
2077         if ((pos - buffer) < offset)
2078                 return 0;
2079         else if ((pos - buffer - offset) < length)
2080                 return pos - buffer - offset;
2081         else
2082                 return length;
2083 }
2084
2085 /* queue a command */
2086 /* This is always called with scsi_lock(host) held */
2087 int queuecommand_lck(struct scsi_cmnd *srb, void (*done) (struct scsi_cmnd *))
2088 {
2089         struct rts51x_chip *chip = host_to_rts51x(srb->device->host);
2090
2091         /* check for state-transition errors */
2092         if (chip->srb != NULL) {
2093                 RTS51X_DEBUGP("Error in %s: chip->srb = %p\n",
2094                                __func__, chip->srb);
2095                 return SCSI_MLQUEUE_HOST_BUSY;
2096         }
2097
2098         /* fail the command if we are disconnecting */
2099         if (test_bit(FLIDX_DISCONNECTING, &chip->usb->dflags)) {
2100                 RTS51X_DEBUGP("Fail command during disconnect\n");
2101                 srb->result = DID_NO_CONNECT << 16;
2102                 done(srb);
2103                 return 0;
2104         }
2105
2106         /* enqueue the command and wake up the control thread */
2107         srb->scsi_done = done;
2108         chip->srb = srb;
2109         complete(&chip->usb->cmnd_ready);
2110
2111         return 0;
2112 }
2113
2114 #if 0 /* LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 37) */
2115 int queuecommand(struct scsi_cmnd *srb, void (*done) (struct scsi_cmnd *))
2116 {
2117         return queuecommand_lck(srb, done);
2118 }
2119 #else
2120 DEF_SCSI_QCMD(queuecommand)
2121 #endif
2122 /***********************************************************************
2123  * Error handling functions
2124  ***********************************************************************/
2125 /* Command timeout and abort */
2126 int command_abort(struct scsi_cmnd *srb)
2127 {
2128         struct rts51x_chip *chip = host_to_rts51x(srb->device->host);
2129
2130         RTS51X_DEBUGP("%s called\n", __func__);
2131
2132         /* us->srb together with the TIMED_OUT, RESETTING, and ABORTING
2133          * bits are protected by the host lock. */
2134         scsi_lock(rts51x_to_host(chip));
2135
2136         /* Is this command still active? */
2137         if (chip->srb != srb) {
2138                 scsi_unlock(rts51x_to_host(chip));
2139                 RTS51X_DEBUGP("-- nothing to abort\n");
2140                 return FAILED;
2141         }
2142
2143         /* Set the TIMED_OUT bit.  Also set the ABORTING bit, but only if
2144          * a device reset isn't already in progress (to avoid interfering
2145          * with the reset).  Note that we must retain the host lock while
2146          * calling usb_stor_stop_transport(); otherwise it might interfere
2147          * with an auto-reset that begins as soon as we release the lock. */
2148         set_bit(FLIDX_TIMED_OUT, &chip->usb->dflags);
2149         if (!test_bit(FLIDX_RESETTING, &chip->usb->dflags)) {
2150                 set_bit(FLIDX_ABORTING, &chip->usb->dflags);
2151                 /* rts51x_stop_transport(us); */
2152         }
2153         scsi_unlock(rts51x_to_host(chip));
2154
2155         /* Wait for the aborted command to finish */
2156         wait_for_completion(&chip->usb->notify);
2157         return SUCCESS;
2158 }
2159
2160 /* This invokes the transport reset mechanism to reset the state of the
2161  * device */
2162 int device_reset(struct scsi_cmnd *srb)
2163 {
2164         int result = 0;
2165
2166         RTS51X_DEBUGP("%s called\n", __func__);
2167
2168         return result < 0 ? FAILED : SUCCESS;
2169 }
2170
2171 /* Simulate a SCSI bus reset by resetting the device's USB port. */
2172 int bus_reset(struct scsi_cmnd *srb)
2173 {
2174         int result = 0;
2175
2176         RTS51X_DEBUGP("%s called\n", __func__);
2177
2178         return result < 0 ? FAILED : SUCCESS;
2179 }
2180
2181 static const char *rts5139_info(struct Scsi_Host *host)
2182 {
2183         return "SCSI emulation for RTS5139 USB card reader";
2184 }
2185
2186 struct scsi_host_template rts51x_host_template = {
2187         /* basic userland interface stuff */
2188         .name = RTS51X_NAME,
2189         .proc_name = RTS51X_NAME,
2190         .proc_info = proc_info,
2191         .info = rts5139_info,
2192
2193         /* command interface -- queued only */
2194         .queuecommand = queuecommand,
2195
2196         /* error and abort handlers */
2197         .eh_abort_handler = command_abort,
2198         .eh_device_reset_handler = device_reset,
2199         .eh_bus_reset_handler = bus_reset,
2200
2201         /* queue commands only, only one command per LUN */
2202         .can_queue = 1,
2203         .cmd_per_lun = 1,
2204
2205         /* unknown initiator id */
2206         .this_id = -1,
2207
2208         .slave_alloc = slave_alloc,
2209         .slave_configure = slave_configure,
2210
2211         /* lots of sg segments can be handled */
2212         .sg_tablesize = SG_ALL,
2213
2214         /* limit the total size of a transfer to 120 KB */
2215         .max_sectors = 240,
2216
2217         /* merge commands... this seems to help performance, but
2218          * periodically someone should test to see which setting is more
2219          * optimal.
2220          */
2221         .use_clustering = 1,
2222
2223         /* emulated HBA */
2224         .emulated = 1,
2225
2226         /* we do our own delay after a device or bus reset */
2227         .skip_settle_delay = 1,
2228
2229         /* sysfs device attributes */
2230         /* .sdev_attrs = sysfs_device_attr_list, */
2231
2232         /* module management */
2233         .module = THIS_MODULE
2234 };
2235