Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bf6c0d11 authored by Fabio Falzoi's avatar Fabio Falzoi Committed by Greg Kroah-Hartman
Browse files

Staging: rts5208: Replace custom macro with dev_dbg 



Use dev_dbg macro to control tracing verbosity through dynamic debug facility.

Signed-off-by: default avatarFabio Falzoi <fabio.falzoi84@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 9036b4e9

drivers/staging/rts5208/debug.h

deleted100644 → 0
+0 −43
Original line number Diff line number Diff line 
/* Driver for Realtek PCI-Express card reader

 * Header file

 *

 * Copyright(c) 2009-2013 Realtek Semiconductor Corp. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License as published by the

 * Free Software Foundation; either version 2, or (at your option) any

 * later version.

 *

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along

 * with this program; if not, see <http://www.gnu.org/licenses/>.

 *

 * Author:

 *   Wei WANG (wei_wang@realsil.com.cn)

 *   Micky Ching (micky_ching@realsil.com.cn)

 */



#ifndef __REALTEK_RTSX_DEBUG_H

#define __REALTEK_RTSX_DEBUG_H



#include <linux/kernel.h>



#define RTSX_STOR "rts5208: "



#ifdef CONFIG_RTS5208_DEBUG

#define RTSX_DEBUGP(x...) pr_debug(RTSX_STOR x)

#define RTSX_DEBUGPN(x...) pr_debug(x)

#define RTSX_DEBUGPX(x...) printk(x)

#define RTSX_DEBUG(x) x

#else

#define RTSX_DEBUGP(x...)

#define RTSX_DEBUGPN(x...)

#define RTSX_DEBUGPX(x...)

#define RTSX_DEBUG(x)

#endif



#endif   /* __REALTEK_RTSX_DEBUG_H */

drivers/staging/rts5208/ms.c

+55 −47
Original line number Diff line number Diff line
@@ -57,7 +57,7 @@ static int ms_transfer_tpc(struct rtsx_chip *chip, u8 trans_mode, 
	int retval;

	u8 *ptr;



	RTSX_DEBUGP("ms_transfer_tpc: tpc = 0x%x\n", tpc);

	dev_dbg(rtsx_dev(chip), "%s: tpc = 0x%x\n", __func__, tpc);



	rtsx_init_cmd(chip);
@@ -204,7 +204,7 @@ static int ms_write_bytes(struct rtsx_chip *chip, 
		u8 val = 0;



		rtsx_read_register(chip, MS_TRANS_CFG, &val);

		RTSX_DEBUGP("MS_TRANS_CFG: 0x%02x\n", val);

		dev_dbg(rtsx_dev(chip), "MS_TRANS_CFG: 0x%02x\n", val);



		rtsx_clear_ms_error(chip);
@@ -304,7 +304,7 @@ static int ms_read_bytes(struct rtsx_chip *chip, 
		data[i] = ptr[i];



	if ((tpc == PRO_READ_SHORT_DATA) && (data_len == 8)) {

		RTSX_DEBUGP("Read format progress:\n");

		dev_dbg(rtsx_dev(chip), "Read format progress:\n");

		RTSX_DUMP(ptr, cnt);

	}
@@ -507,7 +507,7 @@ static int ms_prepare_reset(struct rtsx_chip *chip) 
			oc_mask = SD_OC_NOW | SD_OC_EVER;



		if (chip->ocp_stat & oc_mask) {

			RTSX_DEBUGP("Over current, OCPSTAT is 0x%x\n",

			dev_dbg(rtsx_dev(chip), "Over current, OCPSTAT is 0x%x\n",

				chip->ocp_stat);

			TRACE_RET(chip, STATUS_FAIL);

		}
@@ -557,7 +557,7 @@ static int ms_identify_media_type(struct rtsx_chip *chip, int switch_8bit_bus) 
		TRACE_RET(chip, STATUS_FAIL);



	RTSX_READ_REG(chip, PPBUF_BASE2 + 2, &val);

	RTSX_DEBUGP("Type register: 0x%x\n", val);

	dev_dbg(rtsx_dev(chip), "Type register: 0x%x\n", val);

	if (val != 0x01) {

		if (val != 0x02)

			ms_card->check_ms_flow = 1;
@@ -566,14 +566,14 @@ static int ms_identify_media_type(struct rtsx_chip *chip, int switch_8bit_bus) 
	}



	RTSX_READ_REG(chip, PPBUF_BASE2 + 4, &val);

	RTSX_DEBUGP("Category register: 0x%x\n", val);

	dev_dbg(rtsx_dev(chip), "Category register: 0x%x\n", val);

	if (val != 0) {

		ms_card->check_ms_flow = 1;

		TRACE_RET(chip, STATUS_FAIL);

	}



	RTSX_READ_REG(chip, PPBUF_BASE2 + 5, &val);

	RTSX_DEBUGP("Class register: 0x%x\n", val);

	dev_dbg(rtsx_dev(chip), "Class register: 0x%x\n", val);

	if (val == 0) {

		RTSX_READ_REG(chip, PPBUF_BASE2, &val);

		if (val & WRT_PRTCT)
@@ -591,7 +591,7 @@ static int ms_identify_media_type(struct rtsx_chip *chip, int switch_8bit_bus) 
	ms_card->ms_type |= TYPE_MSPRO;



	RTSX_READ_REG(chip, PPBUF_BASE2 + 3, &val);

	RTSX_DEBUGP("IF Mode register: 0x%x\n", val);

	dev_dbg(rtsx_dev(chip), "IF Mode register: 0x%x\n", val);

	if (val == 0) {

		ms_card->ms_type &= 0x0F;

	} else if (val == 7) {
@@ -924,7 +924,7 @@ static int ms_read_attribute_info(struct rtsx_chip *chip) 
				((u32)buf[cur_addr_off + 5] << 16) |

				((u32)buf[cur_addr_off + 6] << 8) |

				buf[cur_addr_off + 7];

			RTSX_DEBUGP("sys_info_addr = 0x%x, sys_info_size = 0x%x\n",

			dev_dbg(rtsx_dev(chip), "sys_info_addr = 0x%x, sys_info_size = 0x%x\n",

				sys_info_addr, sys_info_size);

			if (sys_info_size != 96)  {

				kfree(buf);
@@ -959,7 +959,7 @@ static int ms_read_attribute_info(struct rtsx_chip *chip) 
				((u32)buf[cur_addr_off + 5] << 16) |

				((u32)buf[cur_addr_off + 6] << 8) |

				buf[cur_addr_off + 7];

			RTSX_DEBUGP("model_name_addr = 0x%x, model_name_size = 0x%x\n",

			dev_dbg(rtsx_dev(chip), "model_name_addr = 0x%x, model_name_size = 0x%x\n",

				model_name_addr, model_name_size);

			if (model_name_size != 48)  {

				kfree(buf);
@@ -1000,23 +1000,24 @@ static int ms_read_attribute_info(struct rtsx_chip *chip) 
				((u32)buf[sys_info_addr + 33] << 16) |

				((u32)buf[sys_info_addr + 34] << 8) |

				buf[sys_info_addr + 35];

		RTSX_DEBUGP("xc_total_blk = 0x%x, xc_blk_size = 0x%x\n",

		dev_dbg(rtsx_dev(chip), "xc_total_blk = 0x%x, xc_blk_size = 0x%x\n",

			xc_total_blk, xc_blk_size);

	} else {

		total_blk = ((u16)buf[sys_info_addr + 6] << 8) |

			buf[sys_info_addr + 7];

		blk_size = ((u16)buf[sys_info_addr + 2] << 8) |

			buf[sys_info_addr + 3];

		RTSX_DEBUGP("total_blk = 0x%x, blk_size = 0x%x\n",

		dev_dbg(rtsx_dev(chip), "total_blk = 0x%x, blk_size = 0x%x\n",

			total_blk, blk_size);

	}

#else

	total_blk = ((u16)buf[sys_info_addr + 6] << 8) | buf[sys_info_addr + 7];

	blk_size = ((u16)buf[sys_info_addr + 2] << 8) | buf[sys_info_addr + 3];

	RTSX_DEBUGP("total_blk = 0x%x, blk_size = 0x%x\n", total_blk, blk_size);

	dev_dbg(rtsx_dev(chip), "total_blk = 0x%x, blk_size = 0x%x\n",

		total_blk, blk_size);

#endif



	RTSX_DEBUGP("class_code = 0x%x, device_type = 0x%x, sub_class = 0x%x\n",

	dev_dbg(rtsx_dev(chip), "class_code = 0x%x, device_type = 0x%x, sub_class = 0x%x\n",

		class_code, device_type, sub_class);



	memcpy(ms_card->raw_sys_info, buf + sys_info_addr, 96);
@@ -1051,7 +1052,7 @@ static int ms_read_attribute_info(struct rtsx_chip *chip) 
	if (sub_class & 0xC0)

		TRACE_RET(chip, STATUS_FAIL);



	RTSX_DEBUGP("class_code: 0x%x, device_type: 0x%x, sub_class: 0x%x\n",

	dev_dbg(rtsx_dev(chip), "class_code: 0x%x, device_type: 0x%x, sub_class: 0x%x\n",

		class_code, device_type, sub_class);



#ifdef SUPPORT_MSXC
@@ -1115,8 +1116,10 @@ static int reset_ms_pro(struct rtsx_chip *chip) 
	if (change_power_class && CHK_MSXC(ms_card)) {

		u8 power_class_en = chip->ms_power_class_en;



		RTSX_DEBUGP("power_class_en = 0x%x\n", power_class_en);

		RTSX_DEBUGP("change_power_class = %d\n", change_power_class);

		dev_dbg(rtsx_dev(chip), "power_class_en = 0x%x\n",

			power_class_en);

		dev_dbg(rtsx_dev(chip), "change_power_class = %d\n",

			change_power_class);



		if (change_power_class)

			power_class_en &= (1 << (change_power_class - 1));
@@ -1126,7 +1129,7 @@ static int reset_ms_pro(struct rtsx_chip *chip) 
		if (power_class_en) {

			u8 power_class_mode =

				(ms_card->raw_sys_info[46] & 0x18) >> 3;

			RTSX_DEBUGP("power_class_mode = 0x%x",

			dev_dbg(rtsx_dev(chip), "power_class_mode = 0x%x",

				power_class_mode);

			if (change_power_class > power_class_mode)

				change_power_class = power_class_mode;
@@ -1559,9 +1562,10 @@ static int ms_copy_page(struct rtsx_chip *chip, u16 old_blk, u16 new_blk, 
	int retval, rty_cnt, uncorrect_flag = 0;

	u8 extra[MS_EXTRA_SIZE], val, i, j, data[16];



	RTSX_DEBUGP("Copy page from 0x%x to 0x%x, logical block is 0x%x\n",

	dev_dbg(rtsx_dev(chip), "Copy page from 0x%x to 0x%x, logical block is 0x%x\n",

		old_blk, new_blk, log_blk);

	RTSX_DEBUGP("start_page = %d, end_page = %d\n", start_page, end_page);

	dev_dbg(rtsx_dev(chip), "start_page = %d, end_page = %d\n",

		start_page, end_page);



	retval = ms_read_extra_data(chip, new_blk, 0, extra, MS_EXTRA_SIZE);

	if (retval != STATUS_SUCCESS)
@@ -1638,7 +1642,7 @@ static int ms_copy_page(struct rtsx_chip *chip, u16 old_blk, u16 new_blk, 
				retval = ms_read_status_reg(chip);

				if (retval != STATUS_SUCCESS) {

					uncorrect_flag = 1;

					RTSX_DEBUGP("Uncorrectable error\n");

					dev_dbg(rtsx_dev(chip), "Uncorrectable error\n");

				} else {

					uncorrect_flag = 0;

				}
@@ -1658,7 +1662,8 @@ static int ms_copy_page(struct rtsx_chip *chip, u16 old_blk, u16 new_blk, 


					ms_write_extra_data(chip, old_blk, i,

							extra, MS_EXTRA_SIZE);

					RTSX_DEBUGP("page %d : extra[0] = 0x%x\n", i, extra[0]);

					dev_dbg(rtsx_dev(chip), "page %d : extra[0] = 0x%x\n",

						i, extra[0]);

					MS_SET_BAD_BLOCK_FLG(ms_card);



					ms_set_page_status(log_blk, setPS_Error,
@@ -1853,7 +1858,7 @@ static int reset_ms(struct rtsx_chip *chip) 
	}



	if (i == (MAX_DEFECTIVE_BLOCK + 2)) {

		RTSX_DEBUGP("No boot block found!");

		dev_dbg(rtsx_dev(chip), "No boot block found!");

		TRACE_RET(chip, STATUS_FAIL);

	}
@@ -1907,7 +1912,7 @@ static int reset_ms(struct rtsx_chip *chip) 


	ptr = rtsx_get_cmd_data(chip);



	RTSX_DEBUGP("Boot block data:\n");

	dev_dbg(rtsx_dev(chip), "Boot block data:\n");

	RTSX_DUMP(ptr, 16);



	/* Block ID error
@@ -2009,7 +2014,8 @@ static int ms_init_l2p_tbl(struct rtsx_chip *chip) 
	u8 val1, val2;



	ms_card->segment_cnt = ms_card->total_block >> 9;

	RTSX_DEBUGP("ms_card->segment_cnt = %d\n", ms_card->segment_cnt);

	dev_dbg(rtsx_dev(chip), "ms_card->segment_cnt = %d\n",

		ms_card->segment_cnt);



	size = ms_card->segment_cnt * sizeof(struct zone_entry);

	ms_card->segment = vzalloc(size);
@@ -2046,7 +2052,7 @@ static int ms_init_l2p_tbl(struct rtsx_chip *chip) 
		ms_card->segment[i].set_index = 0;

		ms_card->segment[i].unused_blk_cnt = 0;



		RTSX_DEBUGP("defective block count of segment %d is %d\n",

		dev_dbg(rtsx_dev(chip), "defective block count of segment %d is %d\n",

			i, ms_card->segment[i].disable_count);

	}
@@ -2184,7 +2190,7 @@ static int ms_build_l2p_tbl(struct rtsx_chip *chip, int seg_no) 
	u16 start, end, phy_blk, log_blk, tmp_blk;

	u8 extra[MS_EXTRA_SIZE], us1, us2;



	RTSX_DEBUGP("ms_build_l2p_tbl: %d\n", seg_no);

	dev_dbg(rtsx_dev(chip), "ms_build_l2p_tbl: %d\n", seg_no);



	if (ms_card->segment == NULL) {

		retval = ms_init_l2p_tbl(chip);
@@ -2193,7 +2199,8 @@ static int ms_build_l2p_tbl(struct rtsx_chip *chip, int seg_no) 
	}



	if (ms_card->segment[seg_no].build_flag) {

		RTSX_DEBUGP("l2p table of segment %d has been built\n", seg_no);

		dev_dbg(rtsx_dev(chip), "l2p table of segment %d has been built\n",

			seg_no);

		return STATUS_SUCCESS;

	}
@@ -2244,7 +2251,7 @@ static int ms_build_l2p_tbl(struct rtsx_chip *chip, int seg_no) 
		retval = ms_read_extra_data(chip, phy_blk, 0,

					extra, MS_EXTRA_SIZE);

		if (retval != STATUS_SUCCESS) {

			RTSX_DEBUGP("read extra data fail\n");

			dev_dbg(rtsx_dev(chip), "read extra data fail\n");

			ms_set_bad_block(chip, phy_blk);

			continue;

		}
@@ -2311,7 +2318,8 @@ static int ms_build_l2p_tbl(struct rtsx_chip *chip, int seg_no) 


	segment->build_flag = 1;



	RTSX_DEBUGP("unused block count: %d\n", segment->unused_blk_cnt);

	dev_dbg(rtsx_dev(chip), "unused block count: %d\n",

		segment->unused_blk_cnt);



	/* Logical Address Confirmation Process */

	if (seg_no == ms_card->segment_cnt - 1) {
@@ -2357,7 +2365,7 @@ static int ms_build_l2p_tbl(struct rtsx_chip *chip, int seg_no) 
		for (log_blk = 0; log_blk < 494; log_blk++) {

			tmp_blk = segment->l2p_table[log_blk];

			if (tmp_blk < ms_card->boot_block) {

				RTSX_DEBUGP("Boot block is not the first normal block.\n");

				dev_dbg(rtsx_dev(chip), "Boot block is not the first normal block.\n");



				if (chip->card_wp & MS_CARD)

					break;
@@ -2435,7 +2443,7 @@ int reset_ms_card(struct rtsx_chip *chip) 
			TRACE_RET(chip, STATUS_FAIL);

	}



	RTSX_DEBUGP("ms_card->ms_type = 0x%x\n", ms_card->ms_type);

	dev_dbg(rtsx_dev(chip), "ms_card->ms_type = 0x%x\n", ms_card->ms_type);



	return STATUS_SUCCESS;

}
@@ -2614,7 +2622,7 @@ static int mspro_rw_multi_sector(struct scsi_cmnd *srb, 


		if (detect_card_cd(chip, MS_CARD) != STATUS_SUCCESS) {

			chip->rw_need_retry = 0;

			RTSX_DEBUGP("No card exist, exit mspro_rw_multi_sector\n");

			dev_dbg(rtsx_dev(chip), "No card exist, exit mspro_rw_multi_sector\n");

			TRACE_RET(chip, STATUS_FAIL);

		}
@@ -2622,7 +2630,7 @@ static int mspro_rw_multi_sector(struct scsi_cmnd *srb, 
			ms_send_cmd(chip, PRO_STOP, WAIT_INT);



		if (val & (MS_CRC16_ERR | MS_RDY_TIMEOUT)) {

			RTSX_DEBUGP("MSPro CRC error, tune clock!\n");

			dev_dbg(rtsx_dev(chip), "MSPro CRC error, tune clock!\n");

			chip->rw_need_retry = 1;

			ms_auto_tune_clock(chip);

		}
@@ -2649,7 +2657,7 @@ static int mspro_read_format_progress(struct rtsx_chip *chip, 
	u8 cnt, tmp;

	u8 data[8];



	RTSX_DEBUGP("mspro_read_format_progress, short_data_len = %d\n",

	dev_dbg(rtsx_dev(chip), "mspro_read_format_progress, short_data_len = %d\n",

		short_data_len);



	retval = ms_switch_clock(chip);
@@ -2697,7 +2705,7 @@ static int mspro_read_format_progress(struct rtsx_chip *chip, 
	cur_progress = (data[4] << 24) | (data[5] << 16) |

		(data[6] << 8) | data[7];



	RTSX_DEBUGP("total_progress = %d, cur_progress = %d\n",

	dev_dbg(rtsx_dev(chip), "total_progress = %d, cur_progress = %d\n",

		total_progress, cur_progress);



	if (total_progress == 0) {
@@ -2707,7 +2715,7 @@ static int mspro_read_format_progress(struct rtsx_chip *chip, 
		do_div(ulltmp, total_progress);

		ms_card->progress = (u16)ulltmp;

	}

	RTSX_DEBUGP("progress = %d\n", ms_card->progress);

	dev_dbg(rtsx_dev(chip), "progress = %d\n", ms_card->progress);



	for (i = 0; i < 5000; i++) {

		retval = rtsx_read_register(chip, MS_TRANS_CFG, &tmp);
@@ -3399,7 +3407,7 @@ static int ms_rw_multi_sector(struct scsi_cmnd *srb, struct rtsx_chip *chip, 
		}

	}



	RTSX_DEBUGP("seg_no = %d, old_blk = 0x%x, new_blk = 0x%x\n",

	dev_dbg(rtsx_dev(chip), "seg_no = %d, old_blk = 0x%x, new_blk = 0x%x\n",

		seg_no, old_blk, new_blk);



	while (total_sec_cnt) {
@@ -3410,7 +3418,7 @@ static int ms_rw_multi_sector(struct scsi_cmnd *srb, struct rtsx_chip *chip, 


		page_cnt = end_page - start_page;



		RTSX_DEBUGP("start_page = %d, end_page = %d, page_cnt = %d\n",

		dev_dbg(rtsx_dev(chip), "start_page = %d, end_page = %d, page_cnt = %d\n",

			start_page, end_page, page_cnt);



		if (srb->sc_data_direction == DMA_FROM_DEVICE) {
@@ -3486,7 +3494,7 @@ static int ms_rw_multi_sector(struct scsi_cmnd *srb, struct rtsx_chip *chip, 
			}

		}



		RTSX_DEBUGP("seg_no = %d, old_blk = 0x%x, new_blk = 0x%x\n",

		dev_dbg(rtsx_dev(chip), "seg_no = %d, old_blk = 0x%x, new_blk = 0x%x\n",

			seg_no, old_blk, new_blk);



		start_page = 0;
@@ -4111,7 +4119,7 @@ void ms_cleanup_work(struct rtsx_chip *chip) 


	if (CHK_MSPRO(ms_card)) {

		if (ms_card->seq_mode) {

			RTSX_DEBUGP("MS Pro: stop transmission\n");

			dev_dbg(rtsx_dev(chip), "MS Pro: stop transmission\n");

			mspro_stop_seq_mode(chip);

			ms_card->cleanup_counter = 0;

		}
@@ -4122,7 +4130,7 @@ void ms_cleanup_work(struct rtsx_chip *chip) 
	}

#ifdef MS_DELAY_WRITE

	else if ((!CHK_MSPRO(ms_card)) && ms_card->delay_write.delay_write_flag) {

		RTSX_DEBUGP("MS: delay write\n");

		dev_dbg(rtsx_dev(chip), "MS: delay write\n");

		ms_delay_write(chip);

		ms_card->cleanup_counter = 0;

	}

drivers/staging/rts5208/rtsx.c

+2 −4
Original line number Diff line number Diff line
@@ -20,8 +20,6 @@ 
 *   Micky Ching (micky_ching@realsil.com.cn)

 */



#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt



#include <linux/blkdev.h>

#include <linux/kthread.h>

#include <linux/sched.h>
@@ -478,7 +476,7 @@ static int rtsx_control_thread(void *__dev) 


		/* we've got a command, let's do it! */

		else {

			RTSX_DEBUG(scsi_show_command(chip->srb));

			scsi_show_command(chip);

			rtsx_invoke_transport(chip->srb, chip);

		}
@@ -864,7 +862,7 @@ static int rtsx_probe(struct pci_dev *pci, 
	int err = 0;

	struct task_struct *th;



	RTSX_DEBUGP("Realtek PCI-E card reader detected\n");

	dev_dbg(&pci->dev, "Realtek PCI-E card reader detected\n");



	err = pci_enable_device(pci);

	if (err < 0) {

drivers/staging/rts5208/rtsx.h

+0 −1
Original line number Diff line number Diff line
@@ -46,7 +46,6 @@ 
#include <scsi/scsi_eh.h>

#include <scsi/scsi_host.h>



#include "debug.h"

#include "trace.h"

#include "general.h"

drivers/staging/rts5208/rtsx_card.c

+38 −35
Original line number Diff line number Diff line
@@ -102,7 +102,8 @@ void try_to_switch_sdio_ctrl(struct rtsx_chip *chip) 


	rtsx_read_register(chip, 0xFF34, &reg1);

	rtsx_read_register(chip, 0xFF38, &reg2);

	RTSX_DEBUGP("reg 0xFF34: 0x%x, reg 0xFF38: 0x%x\n", reg1, reg2);

	dev_dbg(rtsx_dev(chip), "reg 0xFF34: 0x%x, reg 0xFF38: 0x%x\n",

		reg1, reg2);

	if ((reg1 & 0xC0) && (reg2 & 0xC0)) {

		chip->sd_int = 1;

		rtsx_write_register(chip, SDIO_CTRL, 0xFF,
@@ -137,14 +138,14 @@ void dynamic_configure_sdio_aspm(struct rtsx_chip *chip) 


	if (chip->sdio_idle) {

		if (!chip->sdio_aspm) {

			RTSX_DEBUGP("SDIO enter ASPM!\n");

			dev_dbg(rtsx_dev(chip), "SDIO enter ASPM!\n");

			rtsx_write_register(chip, ASPM_FORCE_CTL, 0xFC,

					0x30 | (chip->aspm_level[1] << 2));

			chip->sdio_aspm = 1;

		}

	} else {

		if (chip->sdio_aspm) {

			RTSX_DEBUGP("SDIO exit ASPM!\n");

			dev_dbg(rtsx_dev(chip), "SDIO exit ASPM!\n");

			rtsx_write_register(chip, ASPM_FORCE_CTL, 0xFC, 0x30);

			chip->sdio_aspm = 0;

		}
@@ -156,7 +157,7 @@ void do_reset_sd_card(struct rtsx_chip *chip) 
{

	int retval;



	RTSX_DEBUGP("%s: %d, card2lun = 0x%x\n", __func__,

	dev_dbg(rtsx_dev(chip), "%s: %d, card2lun = 0x%x\n", __func__,

		chip->sd_reset_counter, chip->card2lun[SD_CARD]);



	if (chip->card2lun[SD_CARD] >= MAX_ALLOWED_LUN_CNT) {
@@ -210,7 +211,7 @@ void do_reset_xd_card(struct rtsx_chip *chip) 
{

	int retval;



	RTSX_DEBUGP("%s: %d, card2lun = 0x%x\n", __func__,

	dev_dbg(rtsx_dev(chip), "%s: %d, card2lun = 0x%x\n", __func__,

		chip->xd_reset_counter, chip->card2lun[XD_CARD]);



	if (chip->card2lun[XD_CARD] >= MAX_ALLOWED_LUN_CNT) {
@@ -258,7 +259,7 @@ void do_reset_ms_card(struct rtsx_chip *chip) 
{

	int retval;



	RTSX_DEBUGP("%s: %d, card2lun = 0x%x\n", __func__,

	dev_dbg(rtsx_dev(chip), "%s: %d, card2lun = 0x%x\n", __func__,

		chip->ms_reset_counter, chip->card2lun[MS_CARD]);



	if (chip->card2lun[MS_CARD] >= MAX_ALLOWED_LUN_CNT) {
@@ -531,7 +532,7 @@ void card_cd_debounce(struct rtsx_chip *chip, unsigned long *need_reset, 
void rtsx_init_cards(struct rtsx_chip *chip)

{

	if (RTSX_TST_DELINK(chip) && (rtsx_get_stat(chip) != RTSX_STAT_SS)) {

		RTSX_DEBUGP("Reset chip in polling thread!\n");

		dev_dbg(rtsx_dev(chip), "Reset chip in polling thread!\n");

		rtsx_reset_chip(chip);

		RTSX_CLR_DELINK(chip);

	}
@@ -555,7 +556,7 @@ void rtsx_init_cards(struct rtsx_chip *chip) 
		if (!(chip->card_exist & MS_CARD))

			clear_bit(MS_NR, &(chip->need_release));



		RTSX_DEBUGP("chip->need_release = 0x%x\n",

		dev_dbg(rtsx_dev(chip), "chip->need_release = 0x%x\n",

			(unsigned int)(chip->need_release));



#ifdef SUPPORT_OCP
@@ -612,21 +613,22 @@ void rtsx_init_cards(struct rtsx_chip *chip) 
			release_ms_card(chip);

		}



		RTSX_DEBUGP("chip->card_exist = 0x%x\n", chip->card_exist);

		dev_dbg(rtsx_dev(chip), "chip->card_exist = 0x%x\n",

			chip->card_exist);



		if (!chip->card_exist)

			turn_off_led(chip, LED_GPIO);

	}



	if (chip->need_reset) {

		RTSX_DEBUGP("chip->need_reset = 0x%x\n",

		dev_dbg(rtsx_dev(chip), "chip->need_reset = 0x%x\n",

			(unsigned int)(chip->need_reset));



		rtsx_reset_cards(chip);

	}



	if (chip->need_reinit) {

		RTSX_DEBUGP("chip->need_reinit = 0x%x\n",

		dev_dbg(rtsx_dev(chip), "chip->need_reinit = 0x%x\n",

			(unsigned int)(chip->need_reinit));



		rtsx_reinit_cards(chip, 0);
@@ -652,7 +654,7 @@ int switch_ssc_clock(struct rtsx_chip *chip, int clk) 
	max_N = 120;

	max_div = CLK_DIV_4;



	RTSX_DEBUGP("Switch SSC clock to %dMHz (cur_clk = %d)\n",

	dev_dbg(rtsx_dev(chip), "Switch SSC clock to %dMHz (cur_clk = %d)\n",

		clk, chip->cur_clk);



	if ((clk <= 2) || (N > max_N))
@@ -667,7 +669,7 @@ int switch_ssc_clock(struct rtsx_chip *chip, int clk) 
		N = (N + 2) * 2 - 2;

		div++;

	}

	RTSX_DEBUGP("N = %d, div = %d\n", N, div);

	dev_dbg(rtsx_dev(chip), "N = %d, div = %d\n", N, div);



	if (chip->ssc_en) {

		ssc_depth = 0x01;
@@ -678,7 +680,7 @@ int switch_ssc_clock(struct rtsx_chip *chip, int clk) 


	ssc_depth_mask = 0x03;



	RTSX_DEBUGP("ssc_depth = %d\n", ssc_depth);

	dev_dbg(rtsx_dev(chip), "ssc_depth = %d\n", ssc_depth);



	rtsx_init_cmd(chip);

	rtsx_add_cmd(chip, WRITE_REG_CMD, CLK_CTL, CLK_LOW_FREQ, CLK_LOW_FREQ);
@@ -716,77 +718,78 @@ int switch_normal_clock(struct rtsx_chip *chip, int clk) 


	switch (clk) {

	case CLK_20:

		RTSX_DEBUGP("Switch clock to 20MHz\n");

		dev_dbg(rtsx_dev(chip), "Switch clock to 20MHz\n");

		sel = SSC_80;

		div = CLK_DIV_4;

		mcu_cnt = 7;

		break;



	case CLK_30:

		RTSX_DEBUGP("Switch clock to 30MHz\n");

		dev_dbg(rtsx_dev(chip), "Switch clock to 30MHz\n");

		sel = SSC_120;

		div = CLK_DIV_4;

		mcu_cnt = 7;

		break;



	case CLK_40:

		RTSX_DEBUGP("Switch clock to 40MHz\n");

		dev_dbg(rtsx_dev(chip), "Switch clock to 40MHz\n");

		sel = SSC_80;

		div = CLK_DIV_2;

		mcu_cnt = 7;

		break;



	case CLK_50:

		RTSX_DEBUGP("Switch clock to 50MHz\n");

		dev_dbg(rtsx_dev(chip), "Switch clock to 50MHz\n");

		sel = SSC_100;

		div = CLK_DIV_2;

		mcu_cnt = 6;

		break;



	case CLK_60:

		RTSX_DEBUGP("Switch clock to 60MHz\n");

		dev_dbg(rtsx_dev(chip), "Switch clock to 60MHz\n");

		sel = SSC_120;

		div = CLK_DIV_2;

		mcu_cnt = 6;

		break;



	case CLK_80:

		RTSX_DEBUGP("Switch clock to 80MHz\n");

		dev_dbg(rtsx_dev(chip), "Switch clock to 80MHz\n");

		sel = SSC_80;

		div = CLK_DIV_1;

		mcu_cnt = 5;

		break;



	case CLK_100:

		RTSX_DEBUGP("Switch clock to 100MHz\n");

		dev_dbg(rtsx_dev(chip), "Switch clock to 100MHz\n");

		sel = SSC_100;

		div = CLK_DIV_1;

		mcu_cnt = 5;

		break;



	case CLK_120:

		RTSX_DEBUGP("Switch clock to 120MHz\n");

		dev_dbg(rtsx_dev(chip), "Switch clock to 120MHz\n");

		sel = SSC_120;

		div = CLK_DIV_1;

		mcu_cnt = 5;

		break;



	case CLK_150:

		RTSX_DEBUGP("Switch clock to 150MHz\n");

		dev_dbg(rtsx_dev(chip), "Switch clock to 150MHz\n");

		sel = SSC_150;

		div = CLK_DIV_1;

		mcu_cnt = 4;

		break;



	case CLK_200:

		RTSX_DEBUGP("Switch clock to 200MHz\n");

		dev_dbg(rtsx_dev(chip), "Switch clock to 200MHz\n");

		sel = SSC_200;

		div = CLK_DIV_1;

		mcu_cnt = 4;

		break;



	default:

		RTSX_DEBUGP("Try to switch to an illegal clock (%d)\n", clk);

		dev_dbg(rtsx_dev(chip), "Try to switch to an illegal clock (%d)\n",

			clk);

		TRACE_RET(chip, STATUS_FAIL);

	}
@@ -946,7 +949,7 @@ int card_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip, 
				TRACE_RET(chip, STATUS_FAIL);



			if (!chip->rw_need_retry) {

				RTSX_DEBUGP("RW fail, but no need to retry\n");

				dev_dbg(rtsx_dev(chip), "RW fail, but no need to retry\n");

				break;

			}

		} else {
@@ -954,7 +957,7 @@ int card_rw(struct scsi_cmnd *srb, struct rtsx_chip *chip, 
			break;

		}



		RTSX_DEBUGP("Retry RW, (i = %d)\n", i);

		dev_dbg(rtsx_dev(chip), "Retry RW, (i = %d)\n", i);

	}



	return retval;
@@ -1063,7 +1066,7 @@ int detect_card_cd(struct rtsx_chip *chip, int card) 
	} else if (card == XD_CARD) {

		card_cd = XD_EXIST;

	} else {

		RTSX_DEBUGP("Wrong card type: 0x%x\n", card);

		dev_dbg(rtsx_dev(chip), "Wrong card type: 0x%x\n", card);

		TRACE_RET(chip, STATUS_FAIL);

	}