UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

staging: rts5139: remove disabled SUPPORT_SD_LOCK code. 

Signed-off-by: Oleksij Rempel <bug-track@fisher-privat.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
This commit is contained in:
Oleksij Rempel 2012-05-04 17:14:30 +02:00 committed by Greg Kroah-Hartman
parent 3d2b3aacac
commit a7f625160f
6 changed files with 0 additions and 434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
drivers/staging/rts5139/rts51x_chip.c
View File

@ -300,33 +300,6 @@ static void rts51x_auto_delink(struct rts51x_chip *chip)
void rts51x_polling_func(struct rts51x_chip *chip) void rts51x_polling_func(struct rts51x_chip *chip)
{ {
#ifdef SUPPORT_SD_LOCK
struct sd_info *sd_card = &(chip->sd_card);
if (sd_card->sd_erase_status) {
if (chip->card_exist & SD_CARD) {
u8 val;
rts51x_read_register(chip, SD_BUS_STAT, &val);
if (val & SD_DAT0_STATUS) {
/* Erase completed */
sd_card->sd_erase_status = SD_NOT_ERASE;
sd_card->sd_lock_notify = 1;
/* SD card should be reinited,
* so we release it here. */
sd_cleanup_work(chip);
release_sd_card(chip);
chip->card_ready &= ~SD_CARD;
chip->card_exist &= ~SD_CARD;
chip->rw_card[chip->card2lun[SD_CARD]] = NULL;
clear_bit(chip->card2lun[SD_CARD],
&(chip->lun_mc));
}
} else {
sd_card->sd_erase_status = SD_NOT_ERASE;
}
}
#endif
rts51x_init_cards(chip); rts51x_init_cards(chip);
@ -923,24 +896,6 @@ void rts51x_pp_status(struct rts51x_chip *chip, unsigned int lun, u8 *status,
status[0x0F] = 0x00; status[0x0F] = 0x00;
} }
} }
#ifdef SUPPORT_SD_LOCK
/* SD Lock/Unlock */
if (card == SD_CARD) {
status[0x17] = 0x80;
if (sd_card->sd_erase_status)
status[0x17] |= 0x01; /* Under erasing */
if (sd_card->sd_lock_status & SD_LOCKED) {
status[0x17] |= 0x02; /* Locked */
status[0x07] |= 0x40; /* Read protected */
}
if (sd_card->sd_lock_status & SD_PWD_EXIST)
status[0x17] |= 0x04; /* Contain PWD */
} else {
status[0x17] = 0x00;
}
RTS51X_DEBUGP("status[0x17] = 0x%x\n", status[0x17]);
#endif
/* Function 0 /* Function 0
* Support Magic Gate, CPRM and PhyRegister R/W */ * Support Magic Gate, CPRM and PhyRegister R/W */
@ -950,12 +905,6 @@ void rts51x_pp_status(struct rts51x_chip *chip, unsigned int lun, u8 *status,
* Support OC LUN status & WP LUN status */ * Support OC LUN status & WP LUN status */
status[0x1A] = 0x28; status[0x1A] = 0x28;
/* Function 7 */
#ifdef SUPPORT_SD_LOCK
/* Support SD Lock/Unlock */
status[0x1F] = 0x01;
#endif
/* Function 2 /* Function 2
* Support OC LUN status & WP LUN status */ * Support OC LUN status & WP LUN status */
status[0x1A] = 0x28; status[0x1A] = 0x28;

13
drivers/staging/rts5139/rts51x_chip.h
View File

@ -39,10 +39,6 @@
#define SUPPORT_CPRM #define SUPPORT_CPRM
#define SUPPORT_MAGIC_GATE #define SUPPORT_MAGIC_GATE
#define SUPPORT_MSXC #define SUPPORT_MSXC
/* { wwang, 2010-07-26
* Add support for SD lock/unlock */
/* #define SUPPORT_SD_LOCK */
/* } wwang, 2010-07-26 */
#ifdef SUPPORT_MAGIC_GA #ifdef SUPPORT_MAGIC_GA
/* Using NORMAL_WRITE instead of AUTO_WRITE to set ICVTE */ /* Using NORMAL_WRITE instead of AUTO_WRITE to set ICVTE */
@ -205,10 +201,6 @@ struct trace_msg_t {
/* WRITE ERROR */ /* WRITE ERROR */
#define SENSE_TYPE_MG_WRITE_ERR 0x0e #define SENSE_TYPE_MG_WRITE_ERR 0x0e
#endif #endif
#ifdef SUPPORT_SD_LOCK
/* FOR Locked SD card */
#define SENSE_TYPE_MEDIA_READ_FORBIDDEN 0x10
#endif
/*---- sense key ----*/ /*---- sense key ----*/
#define ILI 0x20 /* ILI bit is on */ #define ILI 0x20 /* ILI bit is on */
@ -612,11 +604,6 @@ struct sd_info {
u8 sd_reset_fail; /* sangdy2010-07-01 */ u8 sd_reset_fail; /* sangdy2010-07-01 */
u8 sd_send_status_en; u8 sd_send_status_en;
#ifdef SUPPORT_SD_LOCK
u8 sd_lock_status;
u8 sd_erase_status;
u8 sd_lock_notify;
#endif
}; };
#define MODE_512_SEQ 0x01 #define MODE_512_SEQ 0x01

62
drivers/staging/rts5139/rts51x_scsi.c
View File

@ -396,12 +396,6 @@ void set_sense_type(struct rts51x_chip *chip, unsigned int lun, int sense_type)
break; break;
#endif #endif
#ifdef SUPPORT_SD_LOCK
case SENSE_TYPE_MEDIA_READ_FORBIDDEN:
set_sense_data(chip, lun, CUR_ERR, 0x07, 0, 0x11, 0x13, 0, 0);
break;
#endif
case SENSE_TYPE_NO_SENSE: case SENSE_TYPE_NO_SENSE:
default: default:
set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0); set_sense_data(chip, lun, CUR_ERR, 0, 0, 0, 0, 0, 0);
@ -448,20 +442,6 @@ static int test_unit_ready(struct scsi_cmnd *srb, struct rts51x_chip *chip)
set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE); set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
return TRANSPORT_FAILED; return TRANSPORT_FAILED;
} }
#ifdef SUPPORT_SD_LOCK
if (get_lun_card(chip, SCSI_LUN(srb)) == SD_CARD) {
struct sd_info *sd_card = &(chip->sd_card);
if (sd_card->sd_lock_notify) {
sd_card->sd_lock_notify = 0;
set_sense_type(chip, lun, SENSE_TYPE_MEDIA_CHANGE);
return TRANSPORT_FAILED;
} else if (sd_card->sd_lock_status & SD_LOCKED) {
set_sense_type(chip, lun,
SENSE_TYPE_MEDIA_READ_FORBIDDEN);
return TRANSPORT_FAILED;
}
}
#endif
return TRANSPORT_GOOD; return TRANSPORT_GOOD;
} }
@ -797,9 +777,6 @@ static int request_sense(struct scsi_cmnd *srb, struct rts51x_chip *chip)
static int read_write(struct scsi_cmnd *srb, struct rts51x_chip *chip) static int read_write(struct scsi_cmnd *srb, struct rts51x_chip *chip)
{ {
#ifdef SUPPORT_SD_LOCK
struct sd_info *sd_card = &(chip->sd_card);
#endif
unsigned int lun = SCSI_LUN(srb); unsigned int lun = SCSI_LUN(srb);
int retval; int retval;
u32 start_sec; u32 start_sec;
@ -819,25 +796,6 @@ static int read_write(struct scsi_cmnd *srb, struct rts51x_chip *chip)
rts51x_prepare_run(chip); rts51x_prepare_run(chip);
RTS51X_SET_STAT(chip, STAT_RUN); RTS51X_SET_STAT(chip, STAT_RUN);
#ifdef SUPPORT_SD_LOCK
if (sd_card->sd_erase_status) {
/* Accessing to any card is forbidden
* until the erase procedure of SD is completed */
RTS51X_DEBUGP("SD card being erased!\n");
set_sense_type(chip, lun, SENSE_TYPE_MEDIA_READ_FORBIDDEN);
TRACE_RET(chip, TRANSPORT_FAILED);
}
if (get_lun_card(chip, lun) == SD_CARD) {
if (sd_card->sd_lock_status & SD_LOCKED) {
RTS51X_DEBUGP("SD card locked!\n");
set_sense_type(chip, lun,
SENSE_TYPE_MEDIA_READ_FORBIDDEN);
TRACE_RET(chip, TRANSPORT_FAILED);
}
}
#endif
if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) { if ((srb->cmnd[0] == READ_10) || (srb->cmnd[0] == WRITE_10)) {
start_sec = start_sec =
((u32) srb->cmnd[2] << 24) | ((u32) srb->cmnd[2] << 24) |
@ -1863,30 +1821,10 @@ int mg_send_key(struct scsi_cmnd *srb, struct rts51x_chip *chip)
int rts51x_scsi_handler(struct scsi_cmnd *srb, struct rts51x_chip *chip) int rts51x_scsi_handler(struct scsi_cmnd *srb, struct rts51x_chip *chip)
{ {
#ifdef SUPPORT_SD_LOCK
struct sd_info *sd_card = &(chip->sd_card);
#endif
struct ms_info *ms_card = &(chip->ms_card); struct ms_info *ms_card = &(chip->ms_card);
unsigned int lun = SCSI_LUN(srb); unsigned int lun = SCSI_LUN(srb);
int result = TRANSPORT_GOOD; int result = TRANSPORT_GOOD;
#ifdef SUPPORT_SD_LOCK
if (sd_card->sd_erase_status) {
/* Block all SCSI command except for REQUEST_SENSE
* and rs_ppstatus */
if (!
((srb->cmnd[0] == VENDOR_CMND)
&& (srb->cmnd[1] == SCSI_APP_CMD)
&& (srb->cmnd[2] == GET_DEV_STATUS))
&& (srb->cmnd[0] != REQUEST_SENSE)) {
/* Logical Unit Not Ready Format in Progress */
set_sense_data(chip, lun, CUR_ERR, 0x02, 0, 0x04, 0x04,
0, 0);
TRACE_RET(chip, TRANSPORT_FAILED);
}
}
#endif
if ((get_lun_card(chip, lun) == MS_CARD) && if ((get_lun_card(chip, lun) == MS_CARD) &&
(ms_card->format_status == FORMAT_IN_PROGRESS)) { (ms_card->format_status == FORMAT_IN_PROGRESS)) {
if ((srb->cmnd[0] != REQUEST_SENSE) if ((srb->cmnd[0] != REQUEST_SENSE)

126
drivers/staging/rts5139/sd.c
View File

@ -246,12 +246,7 @@ RTY_SEND_CMD:
if (buf[1] & 0x80) if (buf[1] & 0x80)
TRACE_RET(chip, STATUS_FAIL); TRACE_RET(chip, STATUS_FAIL);
} }
#ifdef SUPPORT_SD_LOCK
/* exclude bit25 CARD_IS_LOCKED */
if (buf[1] & 0x7D) {
#else
if (buf[1] & 0x7F) { if (buf[1] & 0x7F) {
#endif
RTS51X_DEBUGP("buf[1]: 0x%02x\n", buf[1]); RTS51X_DEBUGP("buf[1]: 0x%02x\n", buf[1]);
TRACE_RET(chip, STATUS_FAIL); TRACE_RET(chip, STATUS_FAIL);
} }
@ -709,36 +704,6 @@ int sd_select_card(struct rts51x_chip *chip, int select)
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
#ifdef SUPPORT_SD_LOCK
int sd_update_lock_status(struct rts51x_chip *chip)
{
struct sd_info *sd_card = &(chip->sd_card);
int retval;
u8 rsp[5];
retval =
sd_send_cmd_get_rsp(chip, SEND_STATUS, sd_card->sd_addr,
SD_RSP_TYPE_R1, rsp, 5);
if (retval != STATUS_SUCCESS)
TRACE_RET(chip, STATUS_FAIL);
if (rsp[1] & 0x02)
sd_card->sd_lock_status |= SD_LOCKED;
else
sd_card->sd_lock_status &= ~SD_LOCKED;
RTS51X_DEBUGP("sd_card->sd_lock_status = 0x%x\n",
sd_card->sd_lock_status);
if (rsp[1] & 0x01) {
/* LOCK_UNLOCK_FAILED */
TRACE_RET(chip, STATUS_FAIL);
}
return STATUS_SUCCESS;
}
#endif
int sd_wait_currentstate_dataready(struct rts51x_chip *chip, u8 statechk, int sd_wait_currentstate_dataready(struct rts51x_chip *chip, u8 statechk,
u8 rdychk, u16 pollingcnt) u8 rdychk, u16 pollingcnt)
{ {
@ -1197,15 +1162,6 @@ static int sd_switch_function(struct rts51x_chip *chip, u8 bus_width)
RTS51X_DEBUGP("SD_FUNC_GROUP_1: func_to_switch = 0x%02x", RTS51X_DEBUGP("SD_FUNC_GROUP_1: func_to_switch = 0x%02x",
func_to_switch); func_to_switch);
#ifdef SUPPORT_SD_LOCK
if ((sd_card->sd_lock_status & SD_SDR_RST)
&& (DDR50_SUPPORT == func_to_switch)
&& (sd_card->func_group1_mask & SDR50_SUPPORT_MASK)) {
func_to_switch = SDR50_SUPPORT;
RTS51X_DEBUGP("Using SDR50 instead of DDR50 for SD Lock\n");
}
#endif
if (func_to_switch) { if (func_to_switch) {
retval = retval =
sd_check_switch(chip, SD_FUNC_GROUP_1, func_to_switch, sd_check_switch(chip, SD_FUNC_GROUP_1, func_to_switch,
@ -2024,10 +1980,6 @@ Switch_Fail:
k = 0; k = 0;
hi_cap_flow = 0; hi_cap_flow = 0;
support_1v8 = 0; support_1v8 = 0;
#ifdef SUPPORT_SD_LOCK
if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON)
goto SD_UNLOCK_ENTRY;
#endif
retval = sd_prepare_reset(chip); retval = sd_prepare_reset(chip);
if (retval != STATUS_SUCCESS) if (retval != STATUS_SUCCESS)
@ -2190,20 +2142,6 @@ RTY_CMD55:
retval = sd_select_card(chip, 1); retval = sd_select_card(chip, 1);
if (retval != STATUS_SUCCESS) if (retval != STATUS_SUCCESS)
TRACE_RET(chip, retval); TRACE_RET(chip, retval);
#ifdef SUPPORT_SD_LOCK
SD_UNLOCK_ENTRY:
/* Get SD lock status */
retval = sd_update_lock_status(chip);
if (retval != STATUS_SUCCESS)
TRACE_RET(chip, STATUS_FAIL);
if (sd_card->sd_lock_status & SD_LOCKED) {
sd_card->sd_lock_status |= (SD_LOCK_1BIT_MODE | SD_PWD_EXIST);
return STATUS_SUCCESS;
} else if (!(sd_card->sd_lock_status & SD_UNLOCK_POW_ON)) {
sd_card->sd_lock_status &= ~SD_PWD_EXIST;
}
#endif
/* ACMD42 */ /* ACMD42 */
retval = retval =
@ -2294,10 +2232,6 @@ SD_UNLOCK_ENTRY:
if (retval != STATUS_SUCCESS) if (retval != STATUS_SUCCESS)
TRACE_RET(chip, retval); TRACE_RET(chip, retval);
} }
#ifdef SUPPORT_SD_LOCK
/* clear 1 bit mode status */
sd_card->sd_lock_status &= ~SD_LOCK_1BIT_MODE;
#endif
if (CHK_SD30_SPEED(sd_card)) { if (CHK_SD30_SPEED(sd_card)) {
rts51x_write_register(chip, SD30_DRIVE_SEL, SD30_DRIVE_MASK, rts51x_write_register(chip, SD30_DRIVE_SEL, SD30_DRIVE_MASK,
@ -2380,19 +2314,6 @@ SD_UNLOCK_ENTRY:
chip->card_bus_width[chip->card2lun[SD_CARD]] = 4; chip->card_bus_width[chip->card2lun[SD_CARD]] = 4;
#ifdef SUPPORT_SD_LOCK
if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON) {
rts51x_init_cmd(chip);
rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_H, 0xFF, 0x02);
rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_L, 0xFF, 0x00);
retval = rts51x_send_cmd(chip, MODE_C, 100);
if (retval != STATUS_SUCCESS)
TRACE_RET(chip, retval);
}
#endif
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -2587,17 +2508,10 @@ static int mmc_switch_timing_bus(struct rts51x_chip *chip)
sd_card->capacity = sd_card->capacity =
((u32) buf[5] << 24) | ((u32) buf[4] << 16) | ((u32) buf[5] << 24) | ((u32) buf[4] << 16) |
((u32) buf[3] << 8) | ((u32) buf[2]); ((u32) buf[3] << 8) | ((u32) buf[2]);
#ifdef SUPPORT_SD_LOCK
if (!(sd_card->sd_lock_status & SD_SDR_RST) && CHECK_UHS50(chip))
card_type_mask = 0x07;
else
card_type_mask = 0x03;
#else
if (CHECK_UHS50(chip)) if (CHECK_UHS50(chip))
card_type_mask = 0x07; card_type_mask = 0x07;
else else
card_type_mask = 0x03; card_type_mask = 0x03;
#endif
card_type = buf[1] & card_type_mask; card_type = buf[1] & card_type_mask;
if (card_type) { if (card_type) {
@ -2626,15 +2540,9 @@ static int mmc_switch_timing_bus(struct rts51x_chip *chip)
if (mmc_test_switch_bus(chip, MMC_8BIT_BUS) == STATUS_SUCCESS) { if (mmc_test_switch_bus(chip, MMC_8BIT_BUS) == STATUS_SUCCESS) {
SET_MMC_8BIT(sd_card); SET_MMC_8BIT(sd_card);
chip->card_bus_width[chip->card2lun[SD_CARD]] = 8; chip->card_bus_width[chip->card2lun[SD_CARD]] = 8;
#ifdef SUPPORT_SD_LOCK
sd_card->sd_lock_status &= ~SD_LOCK_1BIT_MODE;
#endif
} else if (mmc_test_switch_bus(chip, MMC_4BIT_BUS) == STATUS_SUCCESS) { } else if (mmc_test_switch_bus(chip, MMC_4BIT_BUS) == STATUS_SUCCESS) {
SET_MMC_4BIT(sd_card); SET_MMC_4BIT(sd_card);
chip->card_bus_width[chip->card2lun[SD_CARD]] = 4; chip->card_bus_width[chip->card2lun[SD_CARD]] = 4;
#ifdef SUPPORT_SD_LOCK
sd_card->sd_lock_status &= ~SD_LOCK_1BIT_MODE;
#endif
} else { } else {
CLR_MMC_8BIT(sd_card); CLR_MMC_8BIT(sd_card);
CLR_MMC_4BIT(sd_card); CLR_MMC_4BIT(sd_card);
@ -2652,11 +2560,6 @@ static int reset_mmc(struct rts51x_chip *chip)
u8 change_to_ddr52 = 1; u8 change_to_ddr52 = 1;
u8 cmd[5]; u8 cmd[5];
#ifdef SUPPORT_SD_LOCK
if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON)
goto MMC_UNLOCK_ENTRY;
#endif
MMC_DDR_FAIL: MMC_DDR_FAIL:
retval = sd_prepare_reset(chip); retval = sd_prepare_reset(chip);
@ -2763,13 +2666,6 @@ RTY_MMC_RST:
0); 0);
if (retval != STATUS_SUCCESS) if (retval != STATUS_SUCCESS)
TRACE_RET(chip, retval); TRACE_RET(chip, retval);
#ifdef SUPPORT_SD_LOCK
MMC_UNLOCK_ENTRY:
/* Get SD lock status */
retval = sd_update_lock_status(chip);
if (retval != STATUS_SUCCESS)
TRACE_RET(chip, STATUS_FAIL);
#endif
RTS51X_WRITE_REG(chip, SD_CFG1, SD_CLK_DIVIDE_MASK, SD_CLK_DIVIDE_0); RTS51X_WRITE_REG(chip, SD_CFG1, SD_CLK_DIVIDE_MASK, SD_CLK_DIVIDE_0);
@ -2842,18 +2738,6 @@ MMC_UNLOCK_ENTRY:
} }
} }
} }
#ifdef SUPPORT_SD_LOCK
if (sd_card->sd_lock_status & SD_UNLOCK_POW_ON) {
rts51x_init_cmd(chip);
rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_H, 0xFF, 0x02);
rts51x_add_cmd(chip, WRITE_REG_CMD, SD_BLOCK_CNT_L, 0xFF, 0x00);
retval = rts51x_send_cmd(chip, MODE_C, 100);
if (retval != STATUS_SUCCESS)
TRACE_RET(chip, retval);
}
#endif
retval = rts51x_get_card_status(chip, &(chip->card_status)); retval = rts51x_get_card_status(chip, &(chip->card_status));
if (retval != STATUS_SUCCESS) if (retval != STATUS_SUCCESS)
@ -2879,11 +2763,6 @@ int reset_sd_card(struct rts51x_chip *chip)
sd_card->capacity = 0; sd_card->capacity = 0;
sd_card->sd_switch_fail = 0; sd_card->sd_switch_fail = 0;
#ifdef SUPPORT_SD_LOCK
sd_card->sd_lock_status = 0;
sd_card->sd_erase_status = 0;
#endif
sd_clear_reset_fail(chip); sd_clear_reset_fail(chip);
enable_card_clock(chip, SD_CARD); enable_card_clock(chip, SD_CARD);
@ -3352,11 +3231,6 @@ int release_sd_card(struct rts51x_chip *chip)
chip->card_fail &= ~SD_CARD; chip->card_fail &= ~SD_CARD;
chip->card_wp &= ~SD_CARD; chip->card_wp &= ~SD_CARD;
#ifdef SUPPORT_SD_LOCK
sd_card->sd_lock_status = 0;
sd_card->sd_erase_status = 0;
#endif
memset(sd_card->raw_csd, 0, 16); memset(sd_card->raw_csd, 0, 16);
memset(sd_card->raw_scr, 0, 8); memset(sd_card->raw_scr, 0, 8);

27
drivers/staging/rts5139/sd.h
View File

@ -141,29 +141,6 @@
#define SWITCH_MODE_ERR 0x06 #define SWITCH_MODE_ERR 0x06
#define SWITCH_PASS 0x07 #define SWITCH_PASS 0x07
#ifdef SUPPORT_SD_LOCK
/* CMD42 Parameter */
#define SD_ERASE 0x08
#define SD_LOCK 0x04
#define SD_UNLOCK 0x00
#define SD_CLR_PWD 0x02
#define SD_SET_PWD 0x01
#define SD_PWD_LEN 0x10
/* SD lock unlock Status */
#define SD_LOCKED 0x80 /* Global lock status */
#define SD_LOCK_1BIT_MODE 0x40 /**/
#define SD_PWD_EXIST 0x20
#define SD_UNLOCK_POW_ON 0x01 /**/
#define SD_SDR_RST 0x02 /* Reset SD30 card with current DDR mode to SDR mode. */
/* g_bySDEraseStatus */
#define SD_NOT_ERASE 0x00
#define SD_UNDER_ERASING 0x01
#define SD_COMPLETE_ERASE 0x02
/* SD_RW FAIL status */
#define SD_RW_FORBIDDEN 0x0F /* read/write is forbidden (SD card) */
#endif
/* Function Group Definition */ /* Function Group Definition */
/* Function Group 1 */ /* Function Group 1 */
#define HS_SUPPORT 0x01 #define HS_SUPPORT 0x01
@ -289,10 +266,6 @@ void sd_cleanup_work(struct rts51x_chip *chip);
int sd_power_off_card3v3(struct rts51x_chip *chip); int sd_power_off_card3v3(struct rts51x_chip *chip);
int release_sd_card(struct rts51x_chip *chip); int release_sd_card(struct rts51x_chip *chip);
#ifdef SUPPORT_SD_LOCK
int sd_update_lock_status(struct rts51x_chip *chip);
#endif
#ifdef SUPPORT_CPRM #ifdef SUPPORT_CPRM
extern int reset_sd(struct rts51x_chip *chip); extern int reset_sd(struct rts51x_chip *chip);
extern int sd_check_data0_status(struct rts51x_chip *chip); extern int sd_check_data0_status(struct rts51x_chip *chip);

155
drivers/staging/rts5139/sd_cprm.c
View File

@ -206,11 +206,7 @@ RTY_SEND_CMD:
if (buf[1] & 0x80) if (buf[1] & 0x80)
TRACE_RET(chip, STATUS_FAIL); TRACE_RET(chip, STATUS_FAIL);
} }
#ifdef SUPPORT_SD_LOCK
if (buf[1] & 0x7D) {
#else
if (buf[1] & 0x7F) { if (buf[1] & 0x7F) {
#endif
TRACE_RET(chip, STATUS_FAIL); TRACE_RET(chip, STATUS_FAIL);
} }
if (buf[2] & 0xF8) if (buf[2] & 0xF8)
@ -305,26 +301,8 @@ int ext_sd_execute_no_data(struct rts51x_chip *chip, unsigned int lun,
retval = sd_switch_clock(chip); retval = sd_switch_clock(chip);
if (retval != STATUS_SUCCESS) if (retval != STATUS_SUCCESS)
TRACE_RET(chip, TRANSPORT_FAILED); TRACE_RET(chip, TRANSPORT_FAILED);
#ifdef SUPPORT_SD_LOCK
if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) {
if (CHK_MMC_8BIT(sd_card)) {
retval =
rts51x_write_register(chip, SD_CFG1, 0x03,
SD_BUS_WIDTH_8);
if (retval != STATUS_SUCCESS)
TRACE_RET(chip, TRANSPORT_FAILED);
} else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card)) {
retval =
rts51x_write_register(chip, SD_CFG1, 0x03,
SD_BUS_WIDTH_4);
if (retval != STATUS_SUCCESS)
TRACE_RET(chip, TRANSPORT_FAILED);
}
}
#else
/* Set H/W SD/MMC Bus Width */ /* Set H/W SD/MMC Bus Width */
rts51x_write_register(chip, SD_CFG1, 0x03, SD_BUS_WIDTH_4); rts51x_write_register(chip, SD_CFG1, 0x03, SD_BUS_WIDTH_4);
#endif
if (standby) { if (standby) {
retval = sd_select_card(chip, 0); retval = sd_select_card(chip, 0);
@ -350,12 +328,6 @@ int ext_sd_execute_no_data(struct rts51x_chip *chip, unsigned int lun,
if (retval != STATUS_SUCCESS) if (retval != STATUS_SUCCESS)
TRACE_GOTO(chip, SD_Execute_Cmd_Failed); TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
} }
#ifdef SUPPORT_SD_LOCK
/* Get SD lock status */
retval = sd_update_lock_status(chip);
if (retval != STATUS_SUCCESS)
TRACE_GOTO(chip, SD_Execute_Cmd_Failed);
#endif
return TRANSPORT_GOOD; return TRANSPORT_GOOD;
@ -399,21 +371,7 @@ int ext_sd_execute_read_data(struct rts51x_chip *chip, unsigned int lun,
retval = sd_switch_clock(chip); retval = sd_switch_clock(chip);
if (retval != STATUS_SUCCESS) if (retval != STATUS_SUCCESS)
TRACE_RET(chip, TRANSPORT_FAILED); TRACE_RET(chip, TRANSPORT_FAILED);
#ifdef SUPPORT_SD_LOCK
if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) {
if (CHK_MMC_8BIT(sd_card))
bus_width = SD_BUS_WIDTH_8;
else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card))
bus_width = SD_BUS_WIDTH_4;
else
bus_width = SD_BUS_WIDTH_1;
} else {
bus_width = SD_BUS_WIDTH_4;
}
RTS51X_DEBUGP("bus_width = %d\n", bus_width);
#else
bus_width = SD_BUS_WIDTH_4; bus_width = SD_BUS_WIDTH_4;
#endif
if (data_len < 512) { if (data_len < 512) {
retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len, retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len,
@ -599,11 +557,6 @@ int ext_sd_execute_write_data(struct rts51x_chip *chip, unsigned int lun,
int cmd13_checkbit = 0, write_err = 0; int cmd13_checkbit = 0, write_err = 0;
u8 rsp_type; u8 rsp_type;
u32 i; u32 i;
#ifdef SUPPORT_SD_LOCK
int lock_cmd_fail = 0;
u8 sd_lock_state = 0;
u8 lock_cmd_type = 0;
#endif
if (sd_card->pre_cmd_err) { if (sd_card->pre_cmd_err) {
sd_card->pre_cmd_err = 0; sd_card->pre_cmd_err = 0;
@ -614,12 +567,6 @@ int ext_sd_execute_write_data(struct rts51x_chip *chip, unsigned int lun,
retval = sd_switch_clock(chip); retval = sd_switch_clock(chip);
if (retval != STATUS_SUCCESS) if (retval != STATUS_SUCCESS)
TRACE_RET(chip, STATUS_FAIL); TRACE_RET(chip, STATUS_FAIL);
#ifdef SUPPORT_SD_LOCK
if (cmd_idx == LOCK_UNLOCK) {
sd_lock_state = sd_card->sd_lock_status;
sd_lock_state &= SD_LOCKED;
}
#endif
retval = get_rsp_type(rsp_code, &rsp_type, &rsp_len); retval = get_rsp_type(rsp_code, &rsp_type, &rsp_len);
if (retval != STATUS_SUCCESS) { if (retval != STATUS_SUCCESS) {
@ -631,25 +578,7 @@ int ext_sd_execute_write_data(struct rts51x_chip *chip, unsigned int lun,
retval = sd_switch_clock(chip); retval = sd_switch_clock(chip);
if (retval != STATUS_SUCCESS) if (retval != STATUS_SUCCESS)
TRACE_RET(chip, TRANSPORT_FAILED); TRACE_RET(chip, TRANSPORT_FAILED);
#ifdef SUPPORT_SD_LOCK
if ((sd_card->sd_lock_status & SD_LOCK_1BIT_MODE) == 0) {
if (CHK_MMC_8BIT(sd_card)) {
retval =
rts51x_write_register(chip, SD_CFG1, 0x03,
SD_BUS_WIDTH_8);
if (retval != STATUS_SUCCESS)
TRACE_RET(chip, TRANSPORT_FAILED);
} else if (CHK_SD(sd_card) || CHK_MMC_4BIT(sd_card)) {
retval =
rts51x_write_register(chip, SD_CFG1, 0x03,
SD_BUS_WIDTH_4);
if (retval != STATUS_SUCCESS)
TRACE_RET(chip, TRANSPORT_FAILED);
}
}
#else
rts51x_write_register(chip, SD_CFG1, 0x03, SD_BUS_WIDTH_4); rts51x_write_register(chip, SD_CFG1, 0x03, SD_BUS_WIDTH_4);
#endif
if (data_len < 512) { if (data_len < 512) {
retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len, retval = ext_sd_send_cmd_get_rsp(chip, SET_BLOCKLEN, data_len,
@ -692,10 +621,6 @@ int ext_sd_execute_write_data(struct rts51x_chip *chip, unsigned int lun,
else else
memcpy(buf, data_buf, data_len); memcpy(buf, data_buf, data_len);
#ifdef SUPPORT_SD_LOCK
if (cmd_idx == LOCK_UNLOCK)
lock_cmd_type = buf[0] & 0x0F;
#endif
if (data_len > 256) { if (data_len > 256) {
rts51x_init_cmd(chip); rts51x_init_cmd(chip);
@ -802,29 +727,6 @@ int ext_sd_execute_write_data(struct rts51x_chip *chip, unsigned int lun,
SD_STOP | SD_CLR_ERR); SD_STOP | SD_CLR_ERR);
TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
} }
#ifdef SUPPORT_SD_LOCK
if (cmd_idx == LOCK_UNLOCK) {
if (lock_cmd_type == SD_ERASE) {
sd_card->sd_erase_status = SD_UNDER_ERASING;
scsi_set_resid(srb, 0);
return TRANSPORT_GOOD;
}
rts51x_init_cmd(chip);
rts51x_add_cmd(chip, CHECK_REG_CMD, SD_BUS_STAT, SD_DAT0_STATUS,
SD_DAT0_STATUS);
retval = rts51x_send_cmd(chip, MODE_CR, 250);
if (retval != STATUS_SUCCESS)
TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
rts51x_get_rsp(chip, 1, 200); /* Don't care return value */
retval = sd_update_lock_status(chip);
if (retval != STATUS_SUCCESS) {
RTS51X_DEBUGP("Lock command fail!\n");
lock_cmd_fail = 1;
}
}
#endif /* SUPPORT_SD_LOCK */
if (standby) { if (standby) {
retval = sd_select_card(chip, 1); retval = sd_select_card(chip, 1);
@ -865,51 +767,6 @@ int ext_sd_execute_write_data(struct rts51x_chip *chip, unsigned int lun,
} }
if (retval != STATUS_SUCCESS) if (retval != STATUS_SUCCESS)
TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed); TRACE_GOTO(chip, SD_Execute_Write_Cmd_Failed);
#ifdef SUPPORT_SD_LOCK
if (cmd_idx == LOCK_UNLOCK) {
if (!lock_cmd_fail) {
RTS51X_DEBUGP("lock_cmd_type = 0x%x\n",
lock_cmd_type);
if (lock_cmd_type & SD_CLR_PWD)
sd_card->sd_lock_status &= ~SD_PWD_EXIST;
if (lock_cmd_type & SD_SET_PWD)
sd_card->sd_lock_status |= SD_PWD_EXIST;
}
RTS51X_DEBUGP("sd_lock_state = 0x%x,"
"sd_card->sd_lock_status = 0x%x\n",
sd_lock_state, sd_card->sd_lock_status);
if (sd_lock_state ^ (sd_card->sd_lock_status & SD_LOCKED)) {
sd_card->sd_lock_notify = 1;
if (sd_lock_state) {
if (sd_card->sd_lock_status &
SD_LOCK_1BIT_MODE) {
sd_card->sd_lock_status |=
(SD_UNLOCK_POW_ON | SD_SDR_RST);
if (CHK_SD(sd_card)) {
retval = reset_sd(chip);
if (retval != STATUS_SUCCESS) {
sd_card->sd_lock_status
&= ~(SD_UNLOCK_POW_ON |
SD_SDR_RST);
TRACE_GOTO(chip,
SD_Execute_Write_Cmd_Failed);
}
}
sd_card->sd_lock_status &=
~(SD_UNLOCK_POW_ON | SD_SDR_RST);
}
}
}
}
if (lock_cmd_fail) {
scsi_set_resid(srb, 0);
set_sense_type(chip, lun, SENSE_TYPE_NO_SENSE);
TRACE_RET(chip, TRANSPORT_FAILED);
}
#endif /* SUPPORT_SD_LOCK */
return TRANSPORT_GOOD; return TRANSPORT_GOOD;
@ -1173,24 +1030,12 @@ int sd_hw_rst(struct scsi_cmnd *srb, struct rts51x_chip *chip)
switch (srb->cmnd[1] & 0x0F) { switch (srb->cmnd[1] & 0x0F) {
case 0: case 0:
/* SD Card Power Off -> ON and Initialization */ /* SD Card Power Off -> ON and Initialization */
#ifdef SUPPORT_SD_LOCK
if (0x64 == srb->cmnd[9]) {
/* Command Mode */
sd_card->sd_lock_status |= SD_SDR_RST;
}
#endif /* SUPPORT_SD_LOCK */
retval = reset_sd_card(chip); retval = reset_sd_card(chip);
if (retval != STATUS_SUCCESS) { if (retval != STATUS_SUCCESS) {
#ifdef SUPPORT_SD_LOCK
sd_card->sd_lock_status &= ~SD_SDR_RST;
#endif
set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT); set_sense_type(chip, lun, SENSE_TYPE_MEDIA_NOT_PRESENT);
sd_card->pre_cmd_err = 1; sd_card->pre_cmd_err = 1;
TRACE_RET(chip, TRANSPORT_FAILED); TRACE_RET(chip, TRANSPORT_FAILED);
} }
#ifdef SUPPORT_SD_LOCK
sd_card->sd_lock_status &= ~SD_SDR_RST;
#endif
break; break;
case 1: case 1: