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