drivers/staging/rts5139/sd_cprm.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
  31 #include "debug.h"
  32 #include "trace.h"
  33 #include "rts51x.h"
  34 #include "rts51x_transport.h"
  35 #include "rts51x_scsi.h"
  36 #include "rts51x_card.h"
  37 #include "rts51x_chip.h"
  38 #include "sd_cprm.h"
  39 #include "sd.h"
  40
  41 #ifdef SUPPORT_CPRM
  42
  43 static inline int get_rsp_type(u8 rsp_code, u8 *rsp_type, int *rsp_len)
  44 {
  45         if (!rsp_type || !rsp_len)
  46                 return STATUS_FAIL;
  47
  48         switch (rsp_code) {
  49         case 0x03:
  50                 *rsp_type = SD_RSP_TYPE_R0; /* no response */
  51                 *rsp_len = 0;
  52                 break;
  53
  54         case 0x04:
  55                 *rsp_type = SD_RSP_TYPE_R1; /* R1,R6(,R4,R5) */
  56                 *rsp_len = 6;
  57                 break;
  58
  59         case 0x05:
  60                 *rsp_type = SD_RSP_TYPE_R1b;    /* R1b */
  61                 *rsp_len = 6;
  62                 break;
  63
  64         case 0x06:
  65                 *rsp_type = SD_RSP_TYPE_R2;     /* R2 */
  66                 *rsp_len = 17;
  67                 break;
  68
  69         case 0x07:
  70                 *rsp_type = SD_RSP_TYPE_R3;     /* R3 */
  71                 *rsp_len = 6;
  72                 break;
  73
  74         default:
  75                 return STATUS_FAIL;
  76         }
  77
  78         return STATUS_SUCCESS;
  79 }
  80
  81 static int ext_sd_send_cmd_get_rsp(struct rts51x_chip *chip, u8 cmd_idx,
  82                             u32 arg, u8 rsp_type, u8 *rsp, int rsp_len,
  83                             int special_check)
  84 {
  85         int retval;
  86         int timeout = 50;
  87         u16 reg_addr;
  88         u8 buf[17], stat;
  89         int len = 2;
  90         int rty_cnt = 0;
  91
  92         RTS51X_DEBUGP("EXT SD/MMC CMD %d\n", cmd_idx);
  93
  94         if (rsp_type == SD_RSP_TYPE_R1b)
  95                 timeout = 3000;
  96
  97 RTY_SEND_CMD:
  98
  99         rts51x_init_cmd(chip);
 100
 101         rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD0, 0xFF, 0x40 | cmd_idx);
 102         rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD1, 0xFF, (u8) (arg >> 24));
 103         rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD2, 0xFF, (u8) (arg >> 16));
 104         rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD3, 0xFF, (u8) (arg >> 8));
 105         rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD4, 0xFF, (u8) arg);
 106
 107         rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CFG2, 0xFF, rsp_type);
 108         rts51x_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE,
 109                        0x01, PINGPONG_BUFFER);
 110         rts51x_add_cmd(chip, WRITE_REG_CMD, SD_TRANSFER,
 111                        0xFF, SD_TM_CMD_RSP | SD_TRANSFER_START);
 112         rts51x_add_cmd(chip, CHECK_REG_CMD, SD_TRANSFER, SD_TRANSFER_END,
 113                        SD_TRANSFER_END);
 114
 115         rts51x_add_cmd(chip, READ_REG_CMD, SD_STAT1, 0, 0);
 116
 117         if (CHECK_USB(chip, USB_20)) {
 118                 if (rsp_type == SD_RSP_TYPE_R2) {
 119                         for (reg_addr = PPBUF_BASE2;
 120                              reg_addr < PPBUF_BASE2 + 16; reg_addr++) {
 121                                 rts51x_add_cmd(chip, READ_REG_CMD, reg_addr, 0,
 122                                                0);
 123                         }
 124                         len = 19;
 125                 } else if (rsp_type != SD_RSP_TYPE_R0) {
 126                         /* Read data from SD_CMDx registers */
 127                         for (reg_addr = SD_CMD0; reg_addr <= SD_CMD4;
 128                              reg_addr++) {
 129                                 rts51x_add_cmd(chip, READ_REG_CMD, reg_addr, 0,
 130                                                0);
 131                         }
 132                         len = 8;
 133                 } else {
 134                         len = 3;
 135                 }
 136                 rts51x_add_cmd(chip, READ_REG_CMD, SD_CMD5, 0, 0);
 137         } else {
 138                 len = 2;
 139         }
 140
 141         retval = rts51x_send_cmd(chip, MODE_CR, 100);
 142         if (retval != STATUS_SUCCESS)
 143                 TRACE_RET(chip, retval);
 144
 145         retval = rts51x_get_rsp(chip, len, timeout);
 146
 147         if (CHECK_SD_TRANS_FAIL(chip, retval)) {
 148                 rts51x_clear_sd_error(chip);
 149
 150                 if (retval == STATUS_TIMEDOUT) {
 151                         if (rsp_type & SD_WAIT_BUSY_END) {
 152                                 retval = sd_check_data0_status(chip);
 153                                 if (retval != STATUS_SUCCESS)
 154                                         TRACE_RET(chip, retval);
 155                         }
 156                 }
 157                 TRACE_RET(chip, STATUS_FAIL);
 158         }
 159
 160         if (rsp_type == SD_RSP_TYPE_R0)
 161                 return STATUS_SUCCESS;
 162
 163         if (CHECK_USB(chip, USB_20)) {
 164                 rts51x_read_rsp_buf(chip, 2, buf, len - 2);
 165         } else {
 166                 if (rsp_type == SD_RSP_TYPE_R2) {
 167                         reg_addr = PPBUF_BASE2;
 168                         len = 16;
 169                 } else {
 170                         reg_addr = SD_CMD0;
 171                         len = 5;
 172                 }
 173                 retval =
 174                     rts51x_seq_read_register(chip, reg_addr,
 175                                                      (unsigned short)len, buf);
 176                 if (retval != STATUS_SUCCESS)
 177                         TRACE_RET(chip, retval);
 178                 RTS51X_READ_REG(chip, SD_CMD5, buf + len);
 179         }
 180         stat = chip->rsp_buf[1];
 181
 182         if ((buf[0] & 0xC0) != 0)
 183                 TRACE_RET(chip, STATUS_FAIL);
 184
 185         if (!(rsp_type & SD_NO_CHECK_CRC7)) {
 186                 if (stat & SD_CRC7_ERR) {
 187                         if (cmd_idx == WRITE_MULTIPLE_BLOCK)
 188                                 TRACE_RET(chip, STATUS_FAIL);
 189                         if (rty_cnt < SD_MAX_RETRY_COUNT) {
 190                                 wait_timeout(20);
 191                                 rty_cnt++;
 192                                 goto RTY_SEND_CMD;
 193                         } else {
 194                                 TRACE_RET(chip, STATUS_FAIL);
 195                         }
 196                 }
 197         }
 198
 199         if ((cmd_idx == SELECT_CARD) || (cmd_idx == APP_CMD) ||
 200             (cmd_idx == SEND_STATUS) || (cmd_idx == STOP_TRANSMISSION)) {
 201                 if ((cmd_idx != STOP_TRANSMISSION) && (special_check == 0)) {
 202                         if (buf[1] & 0x80)
 203                                 TRACE_RET(chip, STATUS_FAIL);
 204                 }
 205                 if (buf[1] & 0x7F)
 206                         TRACE_RET(chip, STATUS_FAIL);
 207                 if (buf[2] & 0xF8)
 208                         TRACE_RET(chip, STATUS_FAIL);
 209
 210                 if (cmd_idx == SELECT_CARD) {
 211                         if (rsp_type == SD_RSP_TYPE_R2) {
 212                                 if ((buf[3] & 0x1E) != 0x04)
 213                                         TRACE_RET(chip, STATUS_FAIL);
 214                         } else if (rsp_type == SD_RSP_TYPE_R2) {
 215                                 if ((buf[3] & 0x1E) != 0x03)
 216                                         TRACE_RET(chip, STATUS_FAIL);
 217                         }
 218                 }
 219         }
 220
 221         if (rsp && rsp_len)
 222                 memcpy(rsp, buf, rsp_len);
 223
 224         return STATUS_SUCCESS;
 225 }
 226
 227 static int ext_sd_get_rsp(struct rts51x_chip *chip, int len,
 228                         u8 *rsp, u8 rsp_type)
 229 {
 230         int retval, rsp_len;
 231         u16 reg_addr;
 232
 233         if (rsp_type == SD_RSP_TYPE_R0)
 234                 return STATUS_SUCCESS;
 235
 236         rts51x_init_cmd(chip);
 237
 238         if (rsp_type == SD_RSP_TYPE_R2) {
 239                 for (reg_addr = PPBUF_BASE2; reg_addr < PPBUF_BASE2 + 16;
 240                      reg_addr++) {
 241                         rts51x_add_cmd(chip, READ_REG_CMD, reg_addr, 0xFF, 0);
 242                 }
 243                 rsp_len = 17;
 244         } else if (rsp_type != SD_RSP_TYPE_R0) {
 245                 for (reg_addr = SD_CMD0; reg_addr <= SD_CMD4; reg_addr++)
 246                         rts51x_add_cmd(chip, READ_REG_CMD, reg_addr, 0xFF, 0);
 247                 rsp_len = 6;
 248         }
 249         rts51x_add_cmd(chip, READ_REG_CMD, SD_CMD5, 0xFF, 0);
 250
 251         retval = rts51x_send_cmd(chip, MODE_CR, 100);
 252         if (retval != STATUS_SUCCESS)
 253                 TRACE_RET(chip, retval);
 254
 255         retval = rts51x_get_rsp(chip, rsp_len, 100);
 256
 257         if (retval != STATUS_SUCCESS)
 258                 TRACE_RET(chip, retval);
 259
 260         if (rsp) {
 261                 int min_len = (rsp_len < len) ? rsp_len : len;
 262
 263                 memcpy(rsp, rts51x_get_rsp_data(chip), min_len);
 264
 265                 RTS51X_DEBUGP("min_len = %d\n", min_len);
 266                 RTS51X_DEBUGP("Response in cmd buf: 0x%x 0x%x 0x%x 0x%x\n",
 267                                rsp[0], rsp[1], rsp[2], rsp[3]);
 268         }
 269
 270         return STATUS_SUCCESS;
 271 }
 272
 273 int ext_rts51x_sd_execute_no_data(struct rts51x_chip *chip, unsigned int lun,
 274                            u8 cmd_idx, u8 standby, u8 acmd, u8 rsp_code,
 275                            u32 arg)
 276 {
 277         struct sd_info *sd_card = &(chip->sd_card);
 278         int retval, rsp_len;
 279         u8 rsp_type;
 280
 281         retval = rts51x_sd_switch_clock(chip);
 282         if (retval != STATUS_SUCCESS)
 283                 TRACE_RET(chip, TRANSPORT_FAILED);
 284
 285         if (sd_card->pre_cmd_err) {
 286                 sd_card->pre_cmd_err = 0;
 287                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 288                 TRACE_RET(chip, TRANSPORT_FAILED);
 289         }
 290         retval = get_rsp_type(rsp_code, &rsp_type, &rsp_len);
 291         if (retval != STATUS_SUCCESS) {
 292                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 293                 TRACE_RET(chip, TRANSPORT_FAILED);
 294         }
 295         sd_card->last_rsp_type = rsp_type;
 296
 297         retval = rts51x_sd_switch_clock(chip);
 298         if (retval != STATUS_SUCCESS)
 299                 TRACE_RET(chip, TRANSPORT_FAILED);
 300         /* Set H/W SD/MMC Bus Width */
 301         rts51x_write_register(chip, SD_CFG1, 0x03, SD_BUS_WIDTH_4);
 302
 303         if (standby) {
 304                 retval = rts51x_sd_select_card(chip, 0);
 305                 if (retval != STATUS_SUCCESS)
 306                         TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
 307         }
 308
 309         if (acmd) {
 310                 retval =
 311                     ext_sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
 312                                             SD_RSP_TYPE_R1, NULL, 0, 0);
 313                 if (retval != STATUS_SUCCESS)
 314                         TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
 315         }
 316
 317         retval = ext_sd_send_cmd_get_rsp(chip, cmd_idx, arg, rsp_type,
 318                                          sd_card->rsp, rsp_len, 0);
 319         if (retval != STATUS_SUCCESS)
 320                 TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
 321
 322         if (standby) {
 323                 retval = rts51x_sd_select_card(chip, 1);
 324                 if (retval != STATUS_SUCCESS)
 325                         TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
 326         }
 327
 328         return TRANSPORT_GOOD;
 329
 330 SD_Execute_Cmd_Failed:
 331         sd_card->pre_cmd_err = 1;
 332         rts51x_set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 333         rts51x_release_sd_card(chip);
 334         rts51x_do_rts51x_reset_sd_card(chip);
 335         if (!(chip->card_ready & SD_CARD))
 336                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 337
 338         TRACE_RET(chip, TRANSPORT_FAILED);
 339 }
 340
 341 int ext_rts51x_sd_execute_read_data(struct rts51x_chip *chip, unsigned int lun,
 342                              u8 cmd_idx, u8 cmd12, u8 standby,
 343                              u8 acmd, u8 rsp_code, u32 arg, u32 data_len,
 344                              void *data_buf, unsigned int buf_len, int use_sg)
 345 {
 346         struct sd_info *sd_card = &(chip->sd_card);
 347         int retval, rsp_len, i;
 348         int cmd13_checkbit = 0, read_err = 0;
 349         u8 rsp_type, bus_width;
 350
 351         if (sd_card->pre_cmd_err) {
 352                 sd_card->pre_cmd_err = 0;
 353                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 354                 TRACE_RET(chip, TRANSPORT_FAILED);
 355         }
 356
 357         retval = rts51x_sd_switch_clock(chip);
 358         if (retval != STATUS_SUCCESS)
 359                 TRACE_RET(chip, STATUS_FAIL);
 360         retval = get_rsp_type(rsp_code, &rsp_type, &rsp_len);
 361         if (retval != STATUS_SUCCESS) {
 362                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 363                 TRACE_RET(chip, TRANSPORT_FAILED);
 364         }
 365         sd_card->last_rsp_type = rsp_type;
 366
 367         retval = rts51x_sd_switch_clock(chip);
 368         if (retval != STATUS_SUCCESS)
 369                 TRACE_RET(chip, TRANSPORT_FAILED);
 370         bus_width = SD_BUS_WIDTH_4;
 371
 372         if (data_len < 512) {
 373                 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len,
 374                                                  SD_RSP_TYPE_R1, NULL, 0, 0);
 375                 if (retval != STATUS_SUCCESS)
 376                         TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 377         }
 378
 379         if (standby) {
 380                 retval = rts51x_sd_select_card(chip, 0);
 381                 if (retval != STATUS_SUCCESS)
 382                         TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 383         }
 384
 385         if (acmd) {
 386                 retval =
 387                     ext_sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
 388                                             SD_RSP_TYPE_R1, NULL, 0, 0);
 389                 if (retval != STATUS_SUCCESS)
 390                         TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 391         }
 392
 393         if (data_len <= 512) {
 394                 int min_len;
 395                 u8 *buf;
 396                 u16 byte_cnt, blk_cnt;
 397                 u8 cmd[5];
 398                 unsigned int offset = 0;
 399                 void *sg = NULL;
 400
 401                 byte_cnt = (u16) (data_len & 0x3FF);
 402                 blk_cnt = 1;
 403
 404                 cmd[0] = 0x40 | cmd_idx;
 405                 cmd[1] = (u8) (arg >> 24);
 406                 cmd[2] = (u8) (arg >> 16);
 407                 cmd[3] = (u8) (arg >> 8);
 408                 cmd[4] = (u8) arg;
 409
 410                 buf = kmalloc(data_len, GFP_KERNEL);
 411                 if (buf == NULL)
 412                         TRACE_RET(chip, TRANSPORT_ERROR);
 413
 414                 retval = sd_read_data(chip, SD_TM_NORMAL_READ, cmd, 5, byte_cnt,
 415                                       blk_cnt, bus_width, buf, data_len, 2000);
 416                 if (retval != STATUS_SUCCESS) {
 417                         read_err = 1;
 418                         kfree(buf);
 419                         rts51x_write_register(chip, CARD_STOP,
 420                                               SD_STOP | SD_CLR_ERR,
 421                                               SD_STOP | SD_CLR_ERR);
 422                         TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 423                 }
 424
 425                 min_len = min(data_len, buf_len);
 426                 if (use_sg)
 427                         rts51x_access_sglist(buf, min_len, (void *)data_buf,
 428                                              &sg, &offset, TO_XFER_BUF);
 429                 else
 430                         memcpy(data_buf, buf, min_len);
 431
 432                 kfree(buf);
 433         } else if (!(data_len & 0x1FF)) {
 434                 rts51x_init_cmd(chip);
 435                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BYTE_CNT_H, 0xFF, 0x02);
 436                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BYTE_CNT_L, 0xFF, 0x00);
 437                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_H,
 438                                0xFF, (u8) (data_len >> 17));
 439                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_L,
 440                                0xFF, (u8) ((data_len & 0x0001FE00) >> 9));
 441                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD0, 0xFF,
 442                                0x40 | cmd_idx);
 443                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD1, 0xFF,
 444                                (u8) (arg >> 24));
 445                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD2, 0xFF,
 446                                (u8) (arg >> 16));
 447                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD3, 0xFF,
 448                                (u8) (arg >> 8));
 449                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CMD4, 0xFF, (u8) arg);
 450                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CFG1, 0x03, bus_width);
 451                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_CFG2, 0xFF, rsp_type);
 452                 rts51x_trans_dma_enable(DMA_FROM_DEVICE, chip, data_len, DMA_512);
 453                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_TRANSFER, 0xFF,
 454                                SD_TM_AUTO_READ_2 | SD_TRANSFER_START);
 455                 rts51x_add_cmd(chip, CHECK_REG_CMD, SD_TRANSFER,
 456                                SD_TRANSFER_END, SD_TRANSFER_END);
 457                 retval = rts51x_send_cmd(chip, MODE_CDIR, 100);
 458                 if (retval != STATUS_SUCCESS) {
 459                         read_err = 1;
 460                         rts51x_ep0_write_register(chip, CARD_STOP,
 461                                                   SD_STOP | SD_CLR_ERR,
 462                                                   SD_STOP | SD_CLR_ERR);
 463                         TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 464                 }
 465
 466                 retval =
 467                     rts51x_transfer_data_rcc(chip, RCV_BULK_PIPE(chip),
 468                                              data_buf, buf_len, use_sg, NULL,
 469                                              10000, STAGE_DI);
 470                 if (retval != STATUS_SUCCESS) {
 471                         read_err = 1;
 472                         rts51x_ep0_write_register(chip, CARD_STOP,
 473                                                   SD_STOP | SD_CLR_ERR,
 474                                                   SD_STOP | SD_CLR_ERR);
 475                         TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 476                 }
 477                 retval = rts51x_get_rsp(chip, 1, 500);
 478                 if (CHECK_SD_TRANS_FAIL(chip, retval)) {
 479                         read_err = 1;
 480                         rts51x_ep0_write_register(chip, CARD_STOP,
 481                                                   SD_STOP | SD_CLR_ERR,
 482                                                   SD_STOP | SD_CLR_ERR);
 483                         TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 484                 }
 485         } else {
 486                 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 487         }
 488
 489         retval = ext_sd_get_rsp(chip, rsp_len, sd_card->rsp, rsp_type);
 490         if (retval != STATUS_SUCCESS)
 491                 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 492
 493         if (standby) {
 494                 retval = rts51x_sd_select_card(chip, 1);
 495                 if (retval != STATUS_SUCCESS)
 496                         TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 497         }
 498
 499         if (cmd12) {
 500                 retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION,
 501                                                  0, SD_RSP_TYPE_R1b, NULL, 0,
 502                                                  0);
 503                 if (retval != STATUS_SUCCESS)
 504                         TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 505         }
 506
 507         if (data_len < 512) {
 508                 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200,
 509                                                  SD_RSP_TYPE_R1, NULL, 0, 0);
 510                 if (retval != STATUS_SUCCESS)
 511                         TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 512
 513                 rts51x_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02);
 514                 rts51x_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00);
 515         }
 516
 517         if (standby || cmd12)
 518                 cmd13_checkbit = 1;
 519
 520         for (i = 0; i < 3; i++) {
 521                 retval =
 522                     ext_sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
 523                                             SD_RSP_TYPE_R1, NULL, 0,
 524                                             cmd13_checkbit);
 525                 if (retval == STATUS_SUCCESS)
 526                         break;
 527         }
 528         if (retval != STATUS_SUCCESS)
 529                 TRACE_GOTO(chip, SD_Execute_Read_Cmd_Failed);
 530
 531         return TRANSPORT_GOOD;
 532
 533 SD_Execute_Read_Cmd_Failed:
 534         sd_card->pre_cmd_err = 1;
 535         rts51x_set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 536         if (read_err)
 537                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_UNRECOVER_READ_ERR);
 538         rts51x_release_sd_card(chip);
 539         rts51x_do_rts51x_reset_sd_card(chip);
 540         if (!(chip->card_ready & SD_CARD))
 541                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 542
 543         TRACE_RET(chip, TRANSPORT_FAILED);
 544 }
 545
 546 int ext_rts51x_sd_execute_write_data(struct rts51x_chip *chip, unsigned int lun,
 547                               u8 cmd_idx, u8 cmd12, u8 standby, u8 acmd,
 548                               u8 rsp_code, u32 arg, u32 data_len,
 549                               void *data_buf, unsigned int buf_len, int use_sg)
 550 {
 551         struct sd_info *sd_card = &(chip->sd_card);
 552         int retval, rsp_len;
 553         int cmd13_checkbit = 0, write_err = 0;
 554         u8 rsp_type;
 555         u32 i;
 556
 557         if (sd_card->pre_cmd_err) {
 558                 sd_card->pre_cmd_err = 0;
 559                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 560                 TRACE_RET(chip, TRANSPORT_FAILED);
 561         }
 562
 563         retval = rts51x_sd_switch_clock(chip);
 564         if (retval != STATUS_SUCCESS)
 565                 TRACE_RET(chip, STATUS_FAIL);
 566
 567         retval = get_rsp_type(rsp_code, &rsp_type, &rsp_len);
 568         if (retval != STATUS_SUCCESS) {
 569                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 570                 TRACE_RET(chip, TRANSPORT_FAILED);
 571         }
 572         sd_card->last_rsp_type = rsp_type;
 573
 574         retval = rts51x_sd_switch_clock(chip);
 575         if (retval != STATUS_SUCCESS)
 576                 TRACE_RET(chip, TRANSPORT_FAILED);
 577         rts51x_write_register(chip, SD_CFG1, 0x03, SD_BUS_WIDTH_4);
 578
 579         if (data_len < 512) {
 580                 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len,
 581                                                  SD_RSP_TYPE_R1, NULL, 0, 0);
 582                 if (retval != STATUS_SUCCESS)
 583                         TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 584         }
 585
 586         if (standby) {
 587                 retval = rts51x_sd_select_card(chip, 0);
 588                 if (retval != STATUS_SUCCESS)
 589                         TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 590         }
 591
 592         if (acmd) {
 593                 retval =
 594                     ext_sd_send_cmd_get_rsp(chip, APP_CMD, sd_card->sd_addr,
 595                                             SD_RSP_TYPE_R1, NULL, 0, 0);
 596                 if (retval != STATUS_SUCCESS)
 597                         TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 598         }
 599
 600         retval = ext_sd_send_cmd_get_rsp(chip, cmd_idx, arg, rsp_type,
 601                                          sd_card->rsp, rsp_len, 0);
 602         if (retval != STATUS_SUCCESS)
 603                 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 604
 605         if (data_len <= 512) {
 606                 u8 *buf;
 607                 unsigned int offset = 0;
 608                 void *sg = NULL;
 609
 610                 buf = kmalloc(data_len, GFP_KERNEL);
 611                 if (buf == NULL)
 612                         TRACE_RET(chip, TRANSPORT_ERROR);
 613
 614                 if (use_sg)
 615                         rts51x_access_sglist(buf, data_len, (void *)data_buf,
 616                                              &sg, &offset, FROM_XFER_BUF);
 617                 else
 618                         memcpy(buf, data_buf, data_len);
 619
 620
 621                 if (data_len > 256) {
 622                         rts51x_init_cmd(chip);
 623                         for (i = 0; i < 256; i++) {
 624                                 rts51x_add_cmd(chip, WRITE_REG_CMD,
 625                                                (u16) (PPBUF_BASE2 + i), 0xFF,
 626                                                buf[i]);
 627                         }
 628                         retval = rts51x_send_cmd(chip, MODE_C, 250);
 629                         if (retval != STATUS_SUCCESS) {
 630                                 kfree(buf);
 631                                 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 632                         }
 633
 634                         rts51x_init_cmd(chip);
 635                         for (i = 256; i < data_len; i++) {
 636                                 rts51x_add_cmd(chip, WRITE_REG_CMD,
 637                                                (u16) (PPBUF_BASE2 + i), 0xFF,
 638                                                buf[i]);
 639                         }
 640                         retval = rts51x_send_cmd(chip, MODE_C, 250);
 641                         if (retval != STATUS_SUCCESS) {
 642                                 kfree(buf);
 643                                 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 644                         }
 645                 } else {
 646                         rts51x_init_cmd(chip);
 647                         for (i = 0; i < data_len; i++) {
 648                                 rts51x_add_cmd(chip, WRITE_REG_CMD,
 649                                                (u16) (PPBUF_BASE2 + i), 0xFF,
 650                                                buf[i]);
 651                         }
 652                         retval = rts51x_send_cmd(chip, MODE_C, 250);
 653                         if (retval != STATUS_SUCCESS) {
 654                                 kfree(buf);
 655                                 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 656                         }
 657                 }
 658
 659                 kfree(buf);
 660
 661                 rts51x_init_cmd(chip);
 662
 663                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BYTE_CNT_H, 0xFF,
 664                                (u8) ((data_len >> 8) & 0x03));
 665                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BYTE_CNT_L, 0xFF,
 666                                (u8) data_len);
 667                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_H, 0xFF, 0x00);
 668                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_L, 0xFF, 0x01);
 669                 rts51x_add_cmd(chip, WRITE_REG_CMD, CARD_DATA_SOURCE, 0x01,
 670                                PINGPONG_BUFFER);
 671
 672                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_TRANSFER, 0xFF,
 673                                SD_TM_AUTO_WRITE_3 | SD_TRANSFER_START);
 674                 rts51x_add_cmd(chip, CHECK_REG_CMD, SD_TRANSFER,
 675                                SD_TRANSFER_END, SD_TRANSFER_END);
 676
 677                 retval = rts51x_send_cmd(chip, MODE_CR, 100);
 678                 if (retval != STATUS_SUCCESS)
 679                         TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 680
 681                 retval = rts51x_get_rsp(chip, 1, 250);
 682                 if (CHECK_SD_TRANS_FAIL(chip, retval))
 683                         TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 684         } else if (!(data_len & 0x1FF)) {
 685                 rts51x_init_cmd(chip);
 686
 687                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BYTE_CNT_H, 0xFF, 0x02);
 688                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BYTE_CNT_L, 0xFF, 0x00);
 689                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_H,
 690                                0xFF, (u8) (data_len >> 17));
 691                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_L,
 692                                0xFF, (u8) ((data_len & 0x0001FE00) >> 9));
 693
 694                 rts51x_trans_dma_enable(DMA_TO_DEVICE, chip, data_len, DMA_512);
 695
 696                 rts51x_add_cmd(chip, WRITE_REG_CMD, SD_TRANSFER, 0xFF,
 697                                SD_TM_AUTO_WRITE_3 | SD_TRANSFER_START);
 698                 rts51x_add_cmd(chip, CHECK_REG_CMD, SD_TRANSFER,
 699                                SD_TRANSFER_END, SD_TRANSFER_END);
 700
 701                 retval = rts51x_send_cmd(chip, MODE_CDOR, 100);
 702                 if (retval != STATUS_SUCCESS)
 703                         TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 704
 705                 retval =
 706                     rts51x_transfer_data_rcc(chip, SND_BULK_PIPE(chip),
 707                                              data_buf, buf_len, use_sg, NULL,
 708                                              10000, STAGE_DO);
 709                 if (retval != STATUS_SUCCESS)
 710                         TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 711
 712                 retval = rts51x_get_rsp(chip, 1, 10000);
 713                 if (CHECK_SD_TRANS_FAIL(chip, retval))
 714                         TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 715
 716         } else {
 717                 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 718         }
 719
 720         if (retval < 0) {
 721                 write_err = 1;
 722                 rts51x_write_register(chip, CARD_STOP, SD_STOP | SD_CLR_ERR,
 723                                       SD_STOP | SD_CLR_ERR);
 724                 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 725         }
 726
 727         if (standby) {
 728                 retval = rts51x_sd_select_card(chip, 1);
 729                 if (retval != STATUS_SUCCESS)
 730                         TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 731         }
 732
 733         if (cmd12) {
 734                 retval = ext_sd_send_cmd_get_rsp(chip, STOP_TRANSMISSION,
 735                                                  0, SD_RSP_TYPE_R1b, NULL, 0,
 736                                                  0);
 737                 if (retval != STATUS_SUCCESS)
 738                         TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 739         }
 740
 741         if (data_len < 512) {
 742                 retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, 0x200,
 743                                                  SD_RSP_TYPE_R1, NULL, 0, 0);
 744                 if (retval != STATUS_SUCCESS)
 745                         TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 746
 747                 rts51x_write_register(chip, SD_BYTE_CNT_H, 0xFF, 0x02);
 748                 rts51x_write_register(chip, SD_BYTE_CNT_L, 0xFF, 0x00);
 749         }
 750
 751         if (cmd12 || standby) {
 752                 /* There is CMD7 or CMD12 sent before CMD13 */
 753                 cmd13_checkbit = 1;
 754         }
 755
 756         for (i = 0; i < 3; i++) {
 757                 retval =
 758                     ext_sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
 759                                             SD_RSP_TYPE_R1, NULL, 0,
 760                                             cmd13_checkbit);
 761                 if (retval == STATUS_SUCCESS)
 762                         break;
 763         }
 764         if (retval != STATUS_SUCCESS)
 765                 TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
 766
 767         return TRANSPORT_GOOD;
 768
 769 SD_Execute_Write_Cmd_Failed:
 770         sd_card->pre_cmd_err = 1;
 771         rts51x_set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
 772         if (write_err)
 773                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_WRITE_ERR);
 774         rts51x_release_sd_card(chip);
 775         rts51x_do_rts51x_reset_sd_card(chip);
 776         if (!(chip->card_ready & SD_CARD))
 777                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
 778
 779         TRACE_RET(chip, TRANSPORT_FAILED);
 780 }
 781
 782 int rts51x_sd_pass_thru_mode(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 783 {
 784         struct sd_info *sd_card = &(chip->sd_card);
 785         unsigned int lun = SCSI_LUN(srb);
 786         int len;
 787         u8 buf[18] = {
 788                 0x00,
 789                 0x00,
 790                 0x00,
 791                 0x0E,
 792                 0x00,           /* Version Number */
 793                 0x00,           /* WP | Media Type */
 794                 0x00,           /* RCA (Low byte) */
 795                 0x00,           /* RCA (High byte) */
 796                 0x53,           /* 'S' */
 797                 0x44,           /* 'D' */
 798                 0x20,           /* ' ' */
 799                 0x43,           /* 'C' */
 800                 0x61,           /* 'a' */
 801                 0x72,           /* 'r' */
 802                 0x64,           /* 'd' */
 803                 0x00,           /* Max LUN Number */
 804                 0x00,
 805                 0x00,
 806         };
 807
 808         sd_card->pre_cmd_err = 0;
 809
 810         if (!(CHK_BIT(chip->lun_mc, lun))) {
 811                 SET_BIT(chip->lun_mc, lun);
 812                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 813                 TRACE_RET(chip, TRANSPORT_FAILED);
 814         }
 815
 816         if ((0x53 != srb->cmnd[2]) || (0x44 != srb->cmnd[3])
 817             || (0x20 != srb->cmnd[4]) || (0x43 != srb->cmnd[5])
 818             || (0x61 != srb->cmnd[6]) || (0x72 != srb->cmnd[7])
 819             || (0x64 != srb->cmnd[8])) {
 820                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 821                 TRACE_RET(chip, TRANSPORT_FAILED);
 822         }
 823
 824         switch (srb->cmnd[1] & 0x0F) {
 825         case 0:
 826                 sd_card->sd_pass_thru_en = 0;
 827                 break;
 828
 829         case 1:
 830                 sd_card->sd_pass_thru_en = 1;
 831                 break;
 832
 833         default:
 834                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 835                 TRACE_RET(chip, TRANSPORT_FAILED);
 836         }
 837
 838         /* 0x01:SD Memory Card; 0x02:Other Media; 0x03:Illegal Media; */
 839         buf[5] = (1 == CHK_SD(sd_card)) ? 0x01 : 0x02;
 840         if (chip->card_wp & SD_CARD)
 841                 buf[5] |= 0x80;
 842
 843         buf[6] = (u8) (sd_card->sd_addr >> 16);
 844         buf[7] = (u8) (sd_card->sd_addr >> 24);
 845
 846         buf[15] = chip->max_lun;
 847
 848         len = min_t(unsigned, 18, scsi_bufflen(srb));
 849         rts51x_set_xfer_buf(buf, len, srb);
 850
 851         return TRANSPORT_GOOD;
 852 }
 853
 854 int rts51x_sd_execute_no_data(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 855 {
 856         struct sd_info *sd_card = &(chip->sd_card);
 857         unsigned int lun = SCSI_LUN(srb);
 858         int retval;
 859         u8 cmd_idx, rsp_code;
 860         u8 standby = 0, acmd = 0;
 861         u32 arg;
 862
 863         if (!sd_card->sd_pass_thru_en) {
 864                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 865                 TRACE_RET(chip, TRANSPORT_FAILED);
 866         }
 867
 868         cmd_idx = srb->cmnd[2] & 0x3F;
 869         if (srb->cmnd[1] & 0x02)
 870                 standby = 1;
 871         if (srb->cmnd[1] & 0x01)
 872                 acmd = 1;
 873
 874         arg = ((u32) srb->cmnd[3] << 24) | ((u32) srb->cmnd[4] << 16) |
 875             ((u32) srb->cmnd[5] << 8) | srb->cmnd[6];
 876
 877         rsp_code = srb->cmnd[10];
 878
 879         retval =
 880             ext_rts51x_sd_execute_no_data(chip, lun, cmd_idx, standby, acmd, rsp_code,
 881                                    arg);
 882         scsi_set_resid(srb, 0);
 883         return retval;
 884 }
 885
 886 int rts51x_sd_execute_read_data(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 887 {
 888         struct sd_info *sd_card = &(chip->sd_card);
 889         int retval;
 890         unsigned int lun = SCSI_LUN(srb);
 891         u8 cmd_idx, rsp_code, send_cmd12 = 0, standby = 0, acmd = 0;
 892         u32 arg, data_len;
 893
 894         if (!sd_card->sd_pass_thru_en) {
 895                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 896                 TRACE_RET(chip, TRANSPORT_FAILED);
 897         }
 898
 899         cmd_idx = srb->cmnd[2] & 0x3F;
 900         if (srb->cmnd[1] & 0x04)
 901                 send_cmd12 = 1;
 902         if (srb->cmnd[1] & 0x02)
 903                 standby = 1;
 904         if (srb->cmnd[1] & 0x01)
 905                 acmd = 1;
 906
 907         arg = ((u32) srb->cmnd[3] << 24) | ((u32) srb->cmnd[4] << 16) |
 908             ((u32) srb->cmnd[5] << 8) | srb->cmnd[6];
 909
 910         data_len =
 911             ((u32) srb->cmnd[7] << 16) | ((u32) srb->cmnd[8] << 8) |
 912             srb->cmnd[9];
 913         rsp_code = srb->cmnd[10];
 914
 915         retval =
 916             ext_rts51x_sd_execute_read_data(chip, lun, cmd_idx, send_cmd12, standby,
 917                                      acmd, rsp_code, arg, data_len,
 918                                      scsi_sglist(srb), scsi_bufflen(srb),
 919                                      scsi_sg_count(srb));
 920         scsi_set_resid(srb, 0);
 921         return retval;
 922 }
 923
 924 int rts51x_sd_execute_write_data(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 925 {
 926         struct sd_info *sd_card = &(chip->sd_card);
 927         int retval;
 928         unsigned int lun = SCSI_LUN(srb);
 929         u8 cmd_idx, rsp_code, send_cmd12 = 0, standby = 0, acmd = 0;
 930         u32 data_len, arg;
 931
 932         if (!sd_card->sd_pass_thru_en) {
 933                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 934                 TRACE_RET(chip, TRANSPORT_FAILED);
 935         }
 936
 937         cmd_idx = srb->cmnd[2] & 0x3F;
 938         if (srb->cmnd[1] & 0x04)
 939                 send_cmd12 = 1;
 940         if (srb->cmnd[1] & 0x02)
 941                 standby = 1;
 942         if (srb->cmnd[1] & 0x01)
 943                 acmd = 1;
 944
 945         data_len =
 946             ((u32) srb->cmnd[7] << 16) | ((u32) srb->cmnd[8] << 8) |
 947             srb->cmnd[9];
 948         arg =
 949             ((u32) srb->cmnd[3] << 24) | ((u32) srb->cmnd[4] << 16) |
 950             ((u32) srb->cmnd[5] << 8) | srb->cmnd[6];
 951         rsp_code = srb->cmnd[10];
 952
 953         retval =
 954             ext_rts51x_sd_execute_write_data(chip, lun, cmd_idx, send_cmd12, standby,
 955                                       acmd, rsp_code, arg, data_len,
 956                                       scsi_sglist(srb), scsi_bufflen(srb),
 957                                       scsi_sg_count(srb));
 958         scsi_set_resid(srb, 0);
 959         return retval;
 960 }
 961
 962 int rts51x_sd_get_cmd_rsp(struct scsi_cmnd *srb, struct rts51x_chip *chip)
 963 {
 964         struct sd_info *sd_card = &(chip->sd_card);
 965         unsigned int lun = SCSI_LUN(srb);
 966         int count;
 967         u16 data_len;
 968
 969         if (!sd_card->sd_pass_thru_en) {
 970                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 971                 TRACE_RET(chip, TRANSPORT_FAILED);
 972         }
 973
 974         if (sd_card->pre_cmd_err) {
 975                 sd_card->pre_cmd_err = 0;
 976                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
 977                 TRACE_RET(chip, TRANSPORT_FAILED);
 978         }
 979
 980         data_len = ((u16) srb->cmnd[7] << 8) | srb->cmnd[8];
 981
 982         if (sd_card->last_rsp_type == SD_RSP_TYPE_R0) {
 983                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
 984                 TRACE_RET(chip, TRANSPORT_FAILED);
 985         } else if (sd_card->last_rsp_type == SD_RSP_TYPE_R2) {
 986                 count = (data_len < 17) ? data_len : 17;
 987         } else {
 988                 count = (data_len < 6) ? data_len : 6;
 989         }
 990         rts51x_set_xfer_buf(sd_card->rsp, count, srb);
 991
 992         RTS51X_DEBUGP("Response length: %d\n", data_len);
 993         RTS51X_DEBUGP("Response: 0x%x 0x%x 0x%x 0x%x\n",
 994                        sd_card->rsp[0], sd_card->rsp[1], sd_card->rsp[2],
 995                        sd_card->rsp[3]);
 996
 997         scsi_set_resid(srb, 0);
 998         return TRANSPORT_GOOD;
 999 }
1000
1001 int rts51x_sd_hw_rst(struct scsi_cmnd *srb, struct rts51x_chip *chip)
1002 {
1003         struct sd_info *sd_card = &(chip->sd_card);
1004         unsigned int lun = SCSI_LUN(srb);
1005         int retval;
1006
1007         if (!sd_card->sd_pass_thru_en) {
1008                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1009                 TRACE_RET(chip, TRANSPORT_FAILED);
1010         }
1011
1012         if (sd_card->pre_cmd_err) {
1013                 sd_card->pre_cmd_err = 0;
1014                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
1015                 TRACE_RET(chip, TRANSPORT_FAILED);
1016         }
1017
1018         if ((0x53 != srb->cmnd[2]) || (0x44 != srb->cmnd[3])
1019             || (0x20 != srb->cmnd[4]) || (0x43 != srb->cmnd[5])
1020             || (0x61 != srb->cmnd[6]) || (0x72 != srb->cmnd[7])
1021             || (0x64 != srb->cmnd[8])) {
1022                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1023                 TRACE_RET(chip, TRANSPORT_FAILED);
1024         }
1025
1026         switch (srb->cmnd[1] & 0x0F) {
1027         case 0:
1028                 /* SD Card Power Off -> ON and Initialization */
1029                 retval = rts51x_reset_sd_card(chip);
1030                 if (retval != STATUS_SUCCESS) {
1031                         rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1032                         sd_card->pre_cmd_err = 1;
1033                         TRACE_RET(chip, TRANSPORT_FAILED);
1034                 }
1035                 break;
1036
1037         case 1:
1038                 /* reset CMD(CMD0) and Initialization
1039                  * (without SD Card Power Off -> ON) */
1040                 retval = reset_sd(chip);
1041                 if (retval != STATUS_SUCCESS) {
1042                         rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
1043                         sd_card->pre_cmd_err = 1;
1044                         TRACE_RET(chip, TRANSPORT_FAILED);
1045                 }
1046                 break;
1047
1048         default:
1049                 rts51x_set_sense_type(chip, lun, SENSE_TYPE_MEDIA_INVALID_CMD_FIELD);
1050                 TRACE_RET(chip, TRANSPORT_FAILED);
1051         }
1052
1053         scsi_set_resid(srb, 0);
1054         return TRANSPORT_GOOD;
1055 }
1056 #endif