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