Initial file dump from open source releaseHEADmaster

1 files changed, 1734 insertions, 0 deletions

diff --git a/drivers/misc/sdiodev/sdio_dev.c b/drivers/misc/sdiodev/sdio_dev.c
new file mode 100644
index 00000000..b79a2bdf
--- /dev/null
+++ b/drivers/misc/sdiodev/sdio_dev.c
@@ -0,0 +1,1734 @@
+/*
+ * Copyright (C) 2013 Spreadtrum Communications Inc.
+ *
+ * Filename : sdio_dev.c
+ * Abstract : This file is a implementation for itm sipc command/event function
+ *
+ * Authors	: gaole.zhang
+ *
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+
+ * 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.
+ */
+#include "sdio_dev.h"
+
+#if defined(CONFIG_SDIODEV_TEST)
+
+#include "sdio_dev_test.h"
+
+#endif
+
+static struct mutex    g_sdio_func_lock;
+static struct timeval  ack_irq_time = {0};
+static int             ack_gpio_status = 0;
+
+static int marlin_sdio_probe(struct sdio_func *func, const struct sdio_device_id *id);
+static void marlin_sdio_remove(struct sdio_func *func);
+static int marlin_sdio_suspend(struct device *dev);
+static int marlin_sdio_resume(struct device *dev);
+
+extern void set_bt_pm_func(void *wakeup,void *sleep);
+
+struct sdio_func *sprd_sdio_func[SDIODEV_MAX_FUNCS];
+struct sdio_func sdio_func_0;
+SDIO_CHN_HANDLER sdio_tran_handle[17] = {0};
+
+static struct sdio_data *sdio_data=NULL;
+static int sdio_irq_num;
+static int marlinwake_irq_num;
+
+static int marlin_sdio_ready_irq_num;
+
+
+static struct wake_lock marlin_wakelock;
+static struct wake_lock BT_AP_wakelock;
+
+static struct wake_lock marlinpub_wakelock;
+
+
+static struct work_struct marlin_wq;
+static struct work_struct marlinwake_wq;
+
+static bool ap_sdio_ready = 0;
+static bool have_card = 0;
+static MARLIN_SDIO_READY_T marlin_sdio_ready = {0};
+
+
+
+static const struct sdio_device_id marlin_sdio_ids[] = {
+	{SDIO_DEVICE(MARLIN_VENDOR_ID, MARLIN_DEVICE_ID)},
+	{},
+};
+
+static const struct dev_pm_ops marlin_sdio_pm_ops = {
+	.suspend = marlin_sdio_suspend,
+	.resume	= marlin_sdio_resume,
+};
+
+static struct sdio_driver marlin_sdio_driver = {
+	.probe = marlin_sdio_probe,
+	.remove = marlin_sdio_remove,
+	.name = "marlin_sdio",
+	.id_table = marlin_sdio_ids,
+	.drv = {
+		.pm = &marlin_sdio_pm_ops,
+	},
+};
+
+static struct mmc_host *sdio_dev_host = NULL;
+char *sync_data_ptr = NULL;
+static int gpio_marlin_req_tag = 0;
+static int gpio_marlinwake_tag = 0;
+
+static bool sdio_w_flag = 0;
+//static bool req_marlin_wait_tag = 0; //0: don't wait   1: wait
+//atomic_t req_marlin_wait_tag;
+atomic_t gpioreq_need_pulldown;
+static bool bt_wake_flag = 0;
+
+static bool marlin_bt_wake_flag = 0;
+
+
+static struct completion marlin_ack = {0};
+
+static SLEEP_POLICY_T sleep_para = {0};
+spinlock_t sleep_spinlock ;
+MARLIN_PM_RESUME_WAIT_INIT(marlin_sdio_wait);
+
+/************************************************************************/
+typedef struct
+{
+	struct mutex          func_lock;
+	struct early_suspend  early_suspend;	
+	atomic_t              in_early_suspend;
+	atomic_t              refcnt;
+}mgr_suspend_t;
+
+#define SDIO_OS_LOCK()  do{\
+	if(1 == atomic_read(&g_mgr_suspend.in_early_suspend)) \
+	{\
+		mutex_lock(&(g_mgr_suspend.func_lock));\
+		lock_flag = 1;\
+	}else{\
+		lock_flag = 0;\
+		atomic_inc(&(g_mgr_suspend.refcnt));\
+	}\	
+}while(0)
+
+#define SDIO_OS_UNLOCK() do{\
+	if(lock_flag){\
+		mutex_unlock(&(g_mgr_suspend.func_lock));\	
+	}else{\
+		atomic_dec(&(g_mgr_suspend.refcnt));}\
+}while(0)
+
+
+mgr_suspend_t    g_mgr_suspend = {0};
+
+static void sdio_early_suspend(struct early_suspend *es)
+{
+	unsigned long  timeout;
+	SDIOTRAN_ERR("[%s]enter\n", __func__);
+	timeout = jiffies + msecs_to_jiffies(3000);
+	atomic_set(&g_mgr_suspend.in_early_suspend, 1);
+	while(0 != atomic_read(&(g_mgr_suspend.refcnt)) )
+	{
+		usleep_range(50, 100);
+		if (time_after(jiffies, timeout)) 
+		{
+			SDIOTRAN_ERR("[%s][timeout 3000ms][EEROR]\n", __func__);
+			return;
+		}
+	}
+	SDIOTRAN_ERR("[%s]ok\n", __func__);
+	return;
+}
+
+static void sdio_late_resume(struct early_suspend *es)
+{
+	atomic_set(&g_mgr_suspend.in_early_suspend, 0);
+	SDIOTRAN_ERR("[%s]ok\n", __func__);
+	return;
+}
+
+int mgr_suspend_init(void )
+{
+	int ret;
+	atomic_set(&g_mgr_suspend.refcnt, 0);
+	atomic_set(&g_mgr_suspend.in_early_suspend, 0);
+	mutex_init(&g_mgr_suspend.func_lock);
+	g_mgr_suspend.early_suspend.suspend = sdio_early_suspend;
+	g_mgr_suspend.early_suspend.resume  = sdio_late_resume;	
+	register_early_suspend(&g_mgr_suspend.early_suspend);
+	return 0;
+}
+
+void mgr_suspend_defint(void )
+{
+	unregister_early_suspend(&g_mgr_suspend.early_suspend);
+	return;
+}
+
+/************************************************************************/
+
+static int get_sdio_dev_func(struct sdio_func *func)
+{	
+	if(SDIODEV_MAX_FUNCS <= func->num)
+	{
+		SDIOTRAN_ERR("func num err!!! func num is %d!!!",func->num);
+		return -1;
+	}
+	SDIOTRAN_DEBUG("func num is %d!!!",func->num);
+
+	if (func->num == 1) 
+	{
+		sdio_func_0.num = 0;
+		sdio_func_0.card = func->card;
+		sprd_sdio_func[0] = &sdio_func_0;
+	}	
+
+	sprd_sdio_func[func->num]  = func;
+
+	return 0;
+}
+
+static int free_sdio_dev_func(struct sdio_func *func)
+{
+	if(SDIODEV_MAX_FUNCS <= func->num)
+	{
+		SDIOTRAN_ERR("func num err!!! func num is %d!!!",func->num);
+		return -1;
+	}
+	
+	sprd_sdio_func[0]  = NULL;
+	sprd_sdio_func[func->num] = NULL;
+	sdio_func_0.num = 0;
+	sdio_func_0.card = NULL;
+
+	return 0;
+
+}
+
+static int wakeup_slave_pin_init(void)
+{
+	int ret;
+	ret = gpio_request(sdio_data->wake_out,"marlin_wakeup");
+	if (ret<0)
+	{
+		SDIOTRAN_ERR("req gpio sdio_data->wake_out = %d fail!!!",\
+			sdio_data->wake_out);
+		return ret;
+	}
+	
+	ret = gpio_direction_output(sdio_data->wake_out,0);
+	if (ret)
+	{
+		SDIOTRAN_ERR("sdio_data->wake_out = %d input set fail!!!",\
+			sdio_data->wake_out);
+		return ret;
+	}
+	
+	SDIOTRAN_ERR("req sdio_data->wake_out = %d succ!!!",\
+		sdio_data->wake_out);
+	
+	return ret;
+}
+void gpio_timer_handler(unsigned long data)
+{
+	if(gpio_get_value(sdio_data->wake_ack))
+	{
+		sleep_para.gpio_opt_tag = 1;
+		mod_timer(&(sleep_para.gpio_timer),\
+			jiffies + msecs_to_jiffies(sleep_para.ack_high_time));//   250<300<2000-1500
+		SDIOTRAN_ERR("ack high");
+	}
+	else
+	{
+		sleep_para.gpio_opt_tag = 0;
+		SDIOTRAN_ERR("gpio_opt_tag=0\n" );
+	}
+}
+
+int fwdownload_fin = 0;
+
+int get_sprd_download_fin(void)
+{
+	return fwdownload_fin;
+}
+EXPORT_SYMBOL_GPL(get_sprd_download_fin);
+
+void set_sprd_download_fin(int dl_tag)
+{
+	marlin_sdio_ready.marlin_sdio_init_end_tag = 1;
+	return fwdownload_fin = dl_tag;
+}
+EXPORT_SYMBOL_GPL(set_sprd_download_fin);
+
+unsigned int irq_count_change = 0;
+unsigned int irq_count_change_last = 0;
+bool get_sprd_marlin_status(void)
+{
+	printk(KERN_INFO "irq_count_change:%d\n",irq_count_change);
+	printk(KERN_INFO "irq_count_change_last:%d\n",irq_count_change_last);
+
+	if((irq_count_change == 0)&&(irq_count_change_last == 0))
+		return 1;
+	else if(irq_count_change != irq_count_change_last)
+	{
+		irq_count_change_last = irq_count_change;
+		return 1;
+	}
+	else
+		return 0;
+}
+EXPORT_SYMBOL_GPL(get_sprd_marlin_status);
+
+atomic_t              is_wlan_open;    //0: wlan close,  1: wlan open
+atomic_t              set_marlin_cmplete;    //0: not complete,  1:  complete
+int set_wlan_status(int status)
+{
+	atomic_set(&(is_wlan_open), status);
+	return 0;
+}
+EXPORT_SYMBOL_GPL(set_wlan_status);
+
+/*add start by sam.sun, 20150108, for get the screen status (on or off)	
+			return: 1 screen on	
+			     0 screen off	
+*/	
+#define BRIGHTNESS_PATH "/sys/class/backlight/sprd_backlight/brightness"	
+int get_screen_status(void)	
+{	
+	struct file *file = NULL;	
+	int is_screen_on = 1; 	
+	char * buf; //0~255 	
+	mm_segment_t old_fs;	
+	int size =0;	
+	loff_t pos = 0;	
+
+	file=filp_open(BRIGHTNESS_PATH, O_RDONLY, 0); 	
+	if (IS_ERR(file)) 		
+		SDIOTRAN_ERR("Open file %s failed /n",BRIGHTNESS_PATH);	
+		
+
+	old_fs = get_fs();	
+	set_fs(KERNEL_DS);	
+		
+	buf = (int *)kzalloc(4,GFP_KERNEL);	
+		
+	vfs_read(file, buf, 3, &pos);	
+		
+	size = strlen(buf);	
+
+	if( strncmp(buf,"0",(size-1))==0 )	
+		is_screen_on = 0; //screen off 	224	
+	else	
+		is_screen_on = 1; 	
+
+	//SDIOTRAN_ERR("*brightness is %s, is_screen_on is %d\r",buf, is_screen_on);
+	kfree(buf);	
+	filp_close(file, NULL);	
+	set_fs(old_fs);	
+	return is_screen_on;	
+}	
+/*add end by sam.sun, for get the screen status (on or off)*/
+
+extern bool get_bt_state(void);   // 1: bt open , 0: bt close
+int set_marlin_wakeup(uint32 chn,uint32 user_id)
+{
+	//user_id: wifi=0x1;bt=0x2
+#if !defined(CONFIG_MARLIN_NO_SLEEP)
+
+	int ret;
+	int flags;
+	int screen_status = 1;
+	int bt_state ;
+	SDIOTRAN_DEBUG("entry");
+
+	if(get_sprd_download_fin() != 1)
+	{
+		SDIOTRAN_ERR("marlin unready");
+		return -1;
+	}
+	
+	/* when bt only, marlin will don't stay 2s wakeup;
+	so add for avoid bt ack 250ms high, then in below cases ap don't req cp and send data directly;
+	case1: first open wlan, then user_id = 1;
+	case2: send AT cmd or loop check, then user_id = 3; mdbg module has done re-try action
+	*/
+	if((1 == atomic_read(&(is_wlan_open))) && (1 == user_id) )
+	{
+		if((gpio_get_value(sdio_data->wake_ack)) && (0 == sleep_para.gpio_opt_tag) )
+			msleep(sleep_para.ack_high_time);
+		if(gpio_get_value(sdio_data->wake_ack))
+			SDIOTRAN_ERR("err:bt req delay 300ms\n");
+		atomic_set(&is_wlan_open, 0); // avoid repeat into this func
+	}
+	
+ 	//screen_status = get_screen_status();   // for wifi screen download
+ 	//bt_state = get_bt_state();  
+
+	spin_lock_irqsave(&sleep_spinlock, flags);
+ 	//if((0 == sleep_para.gpio_opt_tag) ||((!screen_status) && (1 == user_id) && (!bt_state)) )
+	if(0 == sleep_para.gpio_opt_tag)
+	{	
+		if(gpio_get_value(sdio_data->wake_ack))  //bt ack 250ms
+		{
+			spin_unlock_irqrestore(&sleep_spinlock, flags);
+			SDIOTRAN_ERR("%d-high,user_id-%d \n", sdio_data->wake_ack,user_id);
+			return -2;
+		}
+		if(0 != ack_gpio_status) //bt ack low,then lose the marlinwake irq
+		{
+			spin_unlock_irqrestore(&sleep_spinlock, flags);
+			SDIOTRAN_ERR("ack_gpio_status-%d\n", ack_gpio_status);
+			return -2;
+		}
+		if(0 == atomic_read(&(set_marlin_cmplete)))  //last wakeup don't complete
+		{
+			spin_unlock_irqrestore(&sleep_spinlock, flags);
+			SDIOTRAN_ERR("set_marlin_complete -%d\n",  set_marlin_cmplete);
+			return -3;
+		}
+		
+		atomic_set(&(set_marlin_cmplete), 0); //invoid re-entry this func.
+		if((0x1 == user_id) ||(0x3 == user_id))
+		{
+			sdio_w_flag = 1;
+		}
+		
+		if(0x2 == user_id)
+		{
+			bt_wake_flag = 1;
+		}
+		atomic_set(&gpioreq_need_pulldown, 1);//sleep_para.gpioreq_need_pulldown = 1;
+
+		gpio_direction_output(sdio_data->wake_out,1);
+		spin_unlock_irqrestore(&sleep_spinlock, flags);
+		
+		SDIOTRAN_ERR("%d-1\n", sdio_data->wake_out );
+		
+		if((0x1 == user_id) ||(0x3 == user_id))
+		{
+			ret = wait_for_completion_timeout( &marlin_ack, msecs_to_jiffies(100) );
+			if (ret == 0){
+				atomic_set(&(set_marlin_cmplete), 1);
+				SDIOTRAN_ERR("marlin chn %d ack timeout, user_id-%d!!!",chn, user_id);
+				return -ETIMEDOUT;//timeout
+			}
+		}
+	}
+	else
+	{
+		spin_unlock_irqrestore(&sleep_spinlock, flags);
+	}
+		
+	atomic_set(&(set_marlin_cmplete), 1);
+#endif
+	return 0;
+}
+EXPORT_SYMBOL_GPL(set_marlin_wakeup);
+
+
+int set_marlin_sleep(uint32 chn,uint32 user_id)
+{
+	//user_id: wifi=0x1;bt=0x2
+#if !defined(CONFIG_MARLIN_NO_SLEEP)
+	SDIOTRAN_DEBUG("entry");
+	if( atomic_read(&gpioreq_need_pulldown) )//if(sleep_para.gpioreq_need_pulldown)
+	{
+		gpio_direction_output(sdio_data->wake_out,0);
+		if((user_id == 0x1) ||(user_id == 0x3))
+		{	
+			sdio_w_flag = 0;
+		}
+		if(user_id == 0x2)
+		{
+			bt_wake_flag = 0;
+		}
+		atomic_set(&gpioreq_need_pulldown, 0);//sleep_para.gpioreq_need_pulldown = 0;
+		SDIOTRAN_ERR("gpio%d-0,user_id-%d\n", sdio_data->wake_out, user_id);
+	}
+#endif
+	return 0;
+}
+EXPORT_SYMBOL_GPL(set_marlin_sleep);
+
+
+/*only idle chn can be used for ap write*/
+int  sdio_dev_chn_idle(uint32 chn)
+{
+	uint32 active_status;
+	uint8  status0,status1;	
+	int err_ret;
+	
+	MARLIN_PM_RESUME_WAIT(marlin_sdio_wait);
+	MARLIN_PM_RESUME_RETURN_ERROR(-1);
+	if(NULL == sprd_sdio_func[SDIODEV_FUNC_0])
+	{
+		SDIOTRAN_ERR("func uninit!!!");
+		return -1;
+	}
+
+	sdio_claim_host(sprd_sdio_func[SDIODEV_FUNC_0]);
+	
+	status0 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x840,&err_ret);
+
+	status1 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x841,&err_ret);
+     
+	sdio_release_host(sprd_sdio_func[SDIODEV_FUNC_0]);
+	
+	active_status = (uint32)(status0) + ((uint32)(status1) << 8);
+
+	if( BIT_0 & ( active_status >> chn )){
+		SDIOTRAN_DEBUG("SDIO channel num = %x is active!!",chn);
+		return 0;	//active
+	}
+	else{
+		SDIOTRAN_DEBUG("SDIO channel num = %x is idle!!",chn);
+		return 1;  //idle
+	}
+}
+EXPORT_SYMBOL_GPL(sdio_dev_chn_idle);
+
+#if defined(CONFIG_SDIODEV_TEST)
+
+/*only active chn can be readed*/
+int  sdio_dev_get_read_chn(void)
+{
+	uint8  rw_flag0,rw_flag1;
+	uint8  status0,status1;
+	uint32 chn_status;
+	uint32 chn_rw_flag;
+	uint32 tmp;
+	int err_ret,read_chn;
+	MARLIN_PM_RESUME_WAIT(marlin_sdio_wait);
+	MARLIN_PM_RESUME_RETURN_ERROR(-1);
+
+	sdio_claim_host(sprd_sdio_func[SDIODEV_FUNC_0]);
+
+	status0 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x840,&err_ret);
+	
+	status1 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x841,&err_ret);
+	
+	rw_flag0 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x842,&err_ret);
+	
+	rw_flag1 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x843,&err_ret);
+
+	sdio_release_host(sprd_sdio_func[SDIODEV_FUNC_0]);
+
+	chn_status = (uint32)(status0) + ((uint32)(status1) << 8);
+	chn_rw_flag = (uint32)(rw_flag0) + ((uint32)(rw_flag1) << 8);
+
+	SDIOTRAN_DEBUG("ap recv: chn_status is 0x%x!!!",chn_status);
+	SDIOTRAN_DEBUG("ap read: chn_rw_flag is 0x%x!!!",chn_rw_flag);
+
+	tmp = (chn_status&(~chn_rw_flag))&(0x0000ffff);
+
+	for(read_chn=0;read_chn<16;read_chn++)
+	{
+		if(BIT_0 & (tmp>>read_chn))
+		{
+		 	return read_chn;
+		}
+	}
+	return -1;
+
+}
+
+
+
+#else
+
+int  sdio_dev_get_read_chn(void)
+{
+	uint8  chn_status;
+	int err_ret;
+	int lock_flag;
+	MARLIN_PM_RESUME_WAIT(marlin_sdio_wait);
+	MARLIN_PM_RESUME_RETURN_ERROR(-1);
+	SDIO_OS_LOCK();//mutex_lock(&g_sdio_func_lock);
+	sdio_claim_host(sprd_sdio_func[SDIODEV_FUNC_0]);
+
+	chn_status = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x841,&err_ret);
+
+	while( chn_status == 0 ){
+		chn_status = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x841,&err_ret);		
+	}
+	
+	sdio_release_host(sprd_sdio_func[SDIODEV_FUNC_0]);
+	SDIO_OS_UNLOCK();//mutex_unlock(&g_sdio_func_lock);
+	SDIOTRAN_DEBUG("ap read: chn_status is 0x%x!!!",chn_status);
+
+	if(chn_status == 0xff)
+	{
+		SDIOTRAN_ERR("Sdio Err!!!chn status 0x%x!!!",chn_status);
+		return -1;
+	}
+	else if(chn_status & SDIO_CHN_8)
+		return 8;
+	else if(chn_status & SDIO_CHN_9)
+		return 9;
+	else if(chn_status & SDIO_CHN_11)
+		return 11;
+	else if(chn_status & SDIO_CHN_12)
+		return 12;
+	else if(chn_status & SDIO_CHN_13)
+		return 13;
+	else if(chn_status & SDIO_CHN_14)
+		return 14;
+	else if(chn_status & SDIO_CHN_15)
+		return 15;
+	else
+	{		
+		SDIOTRAN_ERR("Invalid sdio read chn!!!chn status 0x%x!!!",chn_status);
+		return -1;
+	}
+}
+
+#endif
+EXPORT_SYMBOL_GPL(sdio_dev_get_read_chn);
+
+
+/*ONLY WIFI WILL USE THIS FUNC*/
+int  sdio_chn_status(unsigned short chn, unsigned short *status)
+{
+	unsigned char status0 = 0;
+	unsigned char status1 = 0;	
+	int err_ret;
+	int ret = 0;
+	int lock_flag;
+	SDIOTRAN_DEBUG("ENTRY");
+	MARLIN_PM_RESUME_WAIT(marlin_sdio_wait);
+	MARLIN_PM_RESUME_RETURN_ERROR(-1);
+	if(NULL == sprd_sdio_func[SDIODEV_FUNC_0])
+	{
+		SDIOTRAN_ERR("func err");
+		return -1;
+	}
+	SDIO_OS_LOCK();//mutex_lock(&g_sdio_func_lock);
+	sdio_claim_host(sprd_sdio_func[SDIODEV_FUNC_0]);
+	
+	if (0x00FF & chn) {
+		status0 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x840,&err_ret);
+		if (status0 == 0xFF){
+			SDIOTRAN_ERR("sdio chn reg0 err");
+			ret = -1;
+			}
+	}
+
+	if (0xFF00 & chn) {
+		status1 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x841,&err_ret);   
+		if (status1 == 0xFF){
+			SDIOTRAN_ERR("sdio chn reg1 err");
+			ret = -1;
+			}
+	}
+
+	sdio_release_host(sprd_sdio_func[SDIODEV_FUNC_0]);
+	SDIO_OS_UNLOCK();//mutex_unlock(&g_sdio_func_lock);
+	*status = ( (status0+(status1 << 8)) & chn );
+	
+	return ret;
+}
+EXPORT_SYMBOL_GPL(sdio_chn_status);
+
+int  sdio_dev_get_chn_datalen(uint32 chn)
+{
+	uint32 usedata;
+	uint8  status0,status1,status2;	
+	int err_ret;
+	int lock_flag;
+	MARLIN_PM_RESUME_WAIT(marlin_sdio_wait);
+	MARLIN_PM_RESUME_RETURN_ERROR(-1);
+	if(NULL == sprd_sdio_func[SDIODEV_FUNC_0])
+	{
+		SDIOTRAN_ERR("func uninit!!!");
+		return -1;
+	}
+	SDIO_OS_LOCK();//mutex_lock(&g_sdio_func_lock);
+	sdio_claim_host(sprd_sdio_func[SDIODEV_FUNC_0]);
+
+	status0 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],(0x800+ 4*chn),&err_ret);
+	
+	status1 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],(0x801+ 4*chn),&err_ret);
+	
+	status2 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],(0x802+ 4*chn),&err_ret);
+
+	sdio_release_host(sprd_sdio_func[SDIODEV_FUNC_0]); 
+	SDIO_OS_UNLOCK();//mutex_unlock(&g_sdio_func_lock);
+	usedata = ((uint32)(status0) ) + ((uint32)(status1) << 8) + ((uint32)(status2)  << 16);
+
+	if(status0 == 0xff || status1 == 0xff || status2 == 0xff)
+	{
+		SDIOTRAN_ERR("read err!!!");
+		return -1;
+	}
+
+	return usedata;	
+	
+}
+EXPORT_SYMBOL_GPL(sdio_dev_get_chn_datalen);
+
+
+int sdio_dev_write(uint32 chn,void* data_buf,uint32 count)
+{
+	int ret,data_len;
+	int lock_flag;
+	MARLIN_PM_RESUME_WAIT(marlin_sdio_wait);
+	MARLIN_PM_RESUME_RETURN_ERROR(-1);
+
+	if(NULL == sprd_sdio_func[SDIODEV_FUNC_1])
+	{
+		SDIOTRAN_ERR("func uninit!!!");
+		return -1;
+	}
+
+	if(chn != 0 && chn != 1)
+	{
+		data_len = sdio_dev_get_chn_datalen(chn);
+		if(data_len < count || data_len <= 0)
+		{
+			SDIOTRAN_ERR("chn %d, len %d, cnt %d, err!!!",chn,data_len,count);
+			return -1;
+		}
+	}
+	SDIO_OS_LOCK();//mutex_lock(&g_sdio_func_lock);
+	sdio_claim_host(sprd_sdio_func[SDIODEV_FUNC_1]);	
+
+	ret = sdio_memcpy_toio(sprd_sdio_func[SDIODEV_FUNC_1],chn,data_buf,count);
+	SDIOTRAN_DEBUG("chn %d send ok!!!",chn);
+
+	sdio_release_host(sprd_sdio_func[SDIODEV_FUNC_1]);	
+	SDIO_OS_UNLOCK();//mutex_unlock(&g_sdio_func_lock);
+	return ret;
+
+}
+EXPORT_SYMBOL_GPL(sdio_dev_write);
+
+
+int  sdio_dev_read(uint32 chn,void* read_buf,uint32 *count)
+{
+	int err_ret,data_len;
+	int lock_flag;
+	MARLIN_PM_RESUME_WAIT(marlin_sdio_wait);
+	MARLIN_PM_RESUME_RETURN_ERROR(-1);
+
+	if(NULL == sprd_sdio_func[SDIODEV_FUNC_1])
+	{
+		SDIOTRAN_ERR("func uninit!!!");
+		return -1;
+	}
+
+	data_len = sdio_dev_get_chn_datalen(chn);
+	if(data_len <= 0)
+	{
+		SDIOTRAN_ERR("chn %d,datelen %d err!!!",chn,data_len);
+		return -1;
+	}
+	SDIOTRAN_DEBUG("ap recv chn %d: read_datalen is 0x%x!!!",chn,data_len);
+	
+	SDIO_OS_LOCK();//mutex_lock(&g_sdio_func_lock);
+	sdio_claim_host(sprd_sdio_func[SDIODEV_FUNC_1]);
+	err_ret = sdio_memcpy_fromio(sprd_sdio_func[SDIODEV_FUNC_1],read_buf,chn,data_len);
+	sdio_release_host(sprd_sdio_func[SDIODEV_FUNC_1]);
+	SDIO_OS_UNLOCK();//mutex_unlock(&g_sdio_func_lock);
+	if(NULL != count)
+		*count = data_len;
+
+	return err_ret;
+
+}
+
+EXPORT_SYMBOL_GPL(sdio_dev_read);
+
+int  sdio_read_wlan(uint32 chn,void* read_buf,uint32 *count)
+{
+	int err_ret,data_len;
+	data_len = 16384;
+	MARLIN_PM_RESUME_WAIT(marlin_sdio_wait);
+	MARLIN_PM_RESUME_RETURN_ERROR(-1);
+	if(NULL == sprd_sdio_func[SDIODEV_FUNC_1])
+	{
+		SDIOTRAN_ERR("func uninit!!!");
+		return -1;
+	}
+	sdio_claim_host(sprd_sdio_func[SDIODEV_FUNC_1]);
+	err_ret = sdio_memcpy_fromio(sprd_sdio_func[SDIODEV_FUNC_1],read_buf,chn,data_len);
+	sdio_release_host(sprd_sdio_func[SDIODEV_FUNC_1]);
+	if(NULL != count)
+		*count = data_len;
+	return err_ret;
+
+}
+
+EXPORT_SYMBOL_GPL(sdio_read_wlan);
+
+int sdiodev_readchn_init(uint32 chn,void* callback,bool with_para)
+{
+	SDIOTRAN_DEBUG("Param, chn = %d, callback = %p",chn,callback);
+	if(chn >= INVALID_SDIO_CHN)
+	{
+		SDIOTRAN_ERR("err input chn %d",chn);
+		return -1;
+	}
+	sdio_tran_handle[chn].chn = chn;
+	
+	if(with_para == 1)
+	{
+		sdio_tran_handle[chn].tran_callback_para = callback;		
+		SDIOTRAN_DEBUG("sdio_tran_handle, chn = %d, callback = %p",sdio_tran_handle[chn].chn,sdio_tran_handle[chn].tran_callback_para);
+	}
+	else
+	{
+		sdio_tran_handle[chn].tran_callback = callback;		
+		SDIOTRAN_DEBUG("sdio_tran_handle, chn = %d, callback = %p",sdio_tran_handle[chn].chn,sdio_tran_handle[chn].tran_callback);
+	}	
+	
+	return 0;
+}
+EXPORT_SYMBOL_GPL(sdiodev_readchn_init);
+
+int sdiodev_readchn_uninit(uint32 chn)
+{
+	if(chn >= INVALID_SDIO_CHN)
+	{
+		SDIOTRAN_ERR("err input chn %d",chn);
+		return -1;
+	}
+
+	sdio_tran_handle[chn].chn = INVALID_SDIO_CHN;
+	sdio_tran_handle[chn].tran_callback = NULL;
+	sdio_tran_handle[chn].tran_callback_para = NULL;
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(sdiodev_readchn_uninit);
+
+void invalid_recv_flush(uint32 chn)
+{
+	int len ;
+	char* pbuff = NULL;
+	
+	if(chn < 0 || chn > 15)
+	{
+		SDIOTRAN_ERR("err chn");
+		return;
+	}
+
+	len = sdio_dev_get_chn_datalen(chn);	
+	if(len <= 0){
+		SDIOTRAN_ERR("chn %d, len err %d!!",chn,len);
+		return;
+	}
+	SDIOTRAN_ERR("NO VALID DATA! CHN %d FLUSH! DATALEN %d!",chn,len);	
+	pbuff = kmalloc(len,GFP_KERNEL);
+	if(pbuff){
+		SDIOTRAN_DEBUG("Read to Flush,chn=%d,pbuff=%p,len=%d",chn, pbuff, len);
+		sdio_dev_read(chn, pbuff, NULL);
+		kfree(pbuff);
+	}else{
+		SDIOTRAN_ERR("Kmalloc %d failed!",len);
+	}
+}
+EXPORT_SYMBOL_GPL(invalid_recv_flush);
+
+void flush_blkchn(void)
+{
+	uint8  rw_flag0,rw_flag1;
+	uint8  status0,status1;
+	uint32 chn_status;
+	uint32 chn_rw_flag;
+	uint32 tmp;
+	int err_ret,read_chn;
+	MARLIN_PM_RESUME_WAIT(marlin_sdio_wait);
+	MARLIN_PM_RESUME_RETURN_ERROR(-1);
+
+	sdio_claim_host(sprd_sdio_func[SDIODEV_FUNC_0]);
+
+	status0 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x840,&err_ret);
+	if (status0 == 0xFF){
+		SDIOTRAN_ERR("sdio chn reg0 err");
+		return;
+		}
+		
+	status1 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x841,&err_ret);
+	if (status1 == 0xFF){
+		SDIOTRAN_ERR("sdio chn reg1 err");
+		return;
+		}
+	
+	rw_flag0 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x842,&err_ret);
+	if (rw_flag0 == 0xFF){
+		SDIOTRAN_ERR("sdio RW reg0 err");
+		return;
+		}
+	
+	rw_flag1 = sdio_readb(sprd_sdio_func[SDIODEV_FUNC_0],0x843,&err_ret);
+	if (rw_flag1 == 0xFF){
+		SDIOTRAN_ERR("sdio RW reg1 err");
+		return;
+		}
+
+	sdio_release_host(sprd_sdio_func[SDIODEV_FUNC_0]);
+
+	chn_status = (uint32)(status0) + ((uint32)(status1) << 8);
+	chn_rw_flag = (uint32)(rw_flag0) + ((uint32)(rw_flag1) << 8);
+
+	SDIOTRAN_ERR("chn_status is 0x%x!!!",chn_status);
+	SDIOTRAN_ERR("chn_rw_flag is 0x%x!!!",chn_rw_flag);
+
+	tmp = (chn_status&(~chn_rw_flag))&(0x0000ffff);
+
+	for(read_chn=0;read_chn<16;read_chn++)
+	{
+		if(BIT_0 & (tmp>>read_chn))
+		{
+			SDIOTRAN_ERR("BLK CHN is 0x%x!!!",read_chn);
+			invalid_recv_flush(read_chn);
+		 	return;
+		}
+	}
+
+	SDIOTRAN_ERR("NO BLK CHN!!!");
+	return;	
+
+}
+EXPORT_SYMBOL_GPL(flush_blkchn);
+
+
+int sdiolog_handler(void)
+{
+	if(NULL != sdio_tran_handle[SDIOLOG_CHN].tran_callback)
+	{
+		SDIOTRAN_DEBUG("SDIOLOG_CHN tran_callback=%p",sdio_tran_handle[SDIOLOG_CHN].tran_callback);
+		sdio_tran_handle[SDIOLOG_CHN].tran_callback();
+		return 0;
+	}
+	else
+	{		
+		return -1;
+	}
+}
+
+int sdio_download_handler(void)
+{
+	if(NULL != sdio_tran_handle[DOWNLOAD_CHANNEL_READ].tran_callback)
+	{
+		SDIOTRAN_DEBUG("DOWNLOAD_CHN tran_callback=%p",sdio_tran_handle[DOWNLOAD_CHANNEL_READ].tran_callback);
+		sdio_tran_handle[DOWNLOAD_CHANNEL_READ].tran_callback();
+		return 0;
+	}
+	else
+	{
+		return -1;
+	}
+}
+
+int sdio_pseudo_atc_handler(void)
+{
+	SDIOTRAN_ERR("ENTRY");
+
+	if(NULL != sdio_tran_handle[PSEUDO_ATC_CHANNEL_READ].tran_callback)
+	{
+		SDIOTRAN_ERR("tran_callback=%p",sdio_tran_handle[PSEUDO_ATC_CHANNEL_READ].tran_callback);
+		sdio_tran_handle[PSEUDO_ATC_CHANNEL_READ].tran_callback();
+		return 0;
+	}
+	else
+	{
+		return -1;
+	}
+}
+
+int sdio_pseudo_loopcheck_handler(void)
+{
+	SDIOTRAN_ERR("ENTRY");
+
+	if(NULL != sdio_tran_handle[PSEUDO_ATC_CHANNEL_LOOPCHECK].tran_callback)
+	{
+		SDIOTRAN_ERR("tran_callback=%p",sdio_tran_handle[PSEUDO_ATC_CHANNEL_LOOPCHECK].tran_callback);
+		sdio_tran_handle[PSEUDO_ATC_CHANNEL_LOOPCHECK].tran_callback();
+		return 0;
+	}
+	else
+	{
+		return -1;
+	}
+}
+
+
+int sdio_wifi_handler(uint32 chn)
+{
+	if(NULL != sdio_tran_handle[chn].tran_callback_para)
+	{
+		SDIOTRAN_DEBUG("wifi_handle_chn %d  tran_callback=%p",chn,sdio_tran_handle[chn].tran_callback_para);
+		sdio_tran_handle[chn].tran_callback_para(chn);
+		return 0;
+	}
+	else
+	{
+		return -1;
+	}
+}
+
+int sdio_assertinfo_handler(void)
+{
+	SDIOTRAN_ERR("ENTRY");
+
+	if(NULL != sdio_tran_handle[MARLIN_ASSERTINFO_CHN].tran_callback)
+	{
+		SDIOTRAN_ERR("tran_callback=%p",sdio_tran_handle[MARLIN_ASSERTINFO_CHN].tran_callback);
+		sdio_tran_handle[MARLIN_ASSERTINFO_CHN].tran_callback();
+		return 0;
+	}
+	else
+	{
+		return -1;
+	}
+}
+
+
+static void marlin_workq(void)
+{
+	int read_chn;
+	int ret = 0;
+
+	SDIOTRAN_DEBUG("ENTRY");
+
+#if !defined(CONFIG_SDIODEV_TEST)
+		
+	read_chn = sdio_dev_get_read_chn();
+	switch(read_chn)
+	{
+		case SDIOLOG_CHN:
+			ret = sdiolog_handler();
+			break;
+		case DOWNLOAD_CHANNEL_READ:
+			ret = sdio_download_handler();
+			break;
+		case PSEUDO_ATC_CHANNEL_READ:
+			ret = sdio_pseudo_atc_handler();
+			break;
+		case PSEUDO_ATC_CHANNEL_LOOPCHECK:
+			ret = sdio_pseudo_loopcheck_handler();
+			break;
+		case MARLIN_ASSERTINFO_CHN:
+			ret = sdio_assertinfo_handler();
+			break;
+		case WIFI_CHN_8:
+		case WIFI_CHN_9:
+			ret = sdio_wifi_handler(read_chn);
+			break;
+		default:
+			SDIOTRAN_ERR("no handler for this chn",read_chn);
+			invalid_recv_flush(read_chn);
+	}
+
+	if(-1 == ret)
+		invalid_recv_flush(read_chn);
+
+#else
+
+#if defined(SDIO_TEST_CASE4)
+	case4_workq_handler();
+#endif
+
+#if defined(SDIO_TEST_CASE5)
+	case5_workq_handler();
+#endif
+
+#if defined(SDIO_TEST_CASE6)
+	case6_workq_handler();
+#endif
+
+#if defined(SDIO_TEST_CASE9)
+	case9_workq_handler();
+#endif
+
+#endif//CONFIG_SDIODEV_TEST
+
+	wake_unlock(&marlin_wakelock);
+
+}
+
+
+
+
+static irqreturn_t marlin_irq_handler(int irq, void * para)
+{
+	wake_lock(&marlin_wakelock);
+	irq_set_irq_type(irq,IRQF_TRIGGER_RISING);
+
+	if(get_sprd_download_fin() != 1)
+	{
+		schedule_work(&marlin_wq);
+	}
+	else if(NULL != sdio_tran_handle[WIFI_CHN_8].tran_callback_para)
+	{
+		sdio_tran_handle[WIFI_CHN_8].tran_callback_para(WIFI_CHN_8);
+		wake_unlock(&marlin_wakelock);
+	}
+	else
+		schedule_work(&marlin_wq);
+
+	return IRQ_HANDLED;
+}
+
+static int sdio_dev_intr_init(void)
+{
+	int ret;
+	
+
+	wake_lock_init(&marlin_wakelock, WAKE_LOCK_SUSPEND, "marlin_wakelock");
+	
+	INIT_WORK(&marlin_wq, marlin_workq);	
+
+	ret = gpio_request(sdio_data->data_irq,"marlin_irq");
+	if (ret<0)
+	{
+		SDIOTRAN_ERR("req gpio sdio_data->data_irq = %d fail!!!",\
+			sdio_data->data_irq);
+		return ret;
+	}
+	
+	ret = gpio_direction_input(sdio_data->data_irq);
+	if (ret<0)
+	{
+		SDIOTRAN_ERR("sdio_data->data_irq = %d input set fail!!!",\
+			sdio_data->data_irq);
+		return ret;
+
+	}
+
+	sdio_irq_num = gpio_to_irq(sdio_data->data_irq);
+	
+	ret = request_irq(sdio_irq_num, marlin_irq_handler,IRQF_TRIGGER_RISING |IRQF_NO_SUSPEND, "sdio_dev_intr", NULL );
+	//ret = request_irq(sdio_irq_num, marlin_irq_handler,IRQF_TRIGGER_HIGH | IRQF_ONESHOT |IRQF_NO_SUSPEND, "sdio_dev_intr", NULL );
+	if (ret != 0) {
+		SDIOTRAN_ERR("request irq err!!!gpio is %d!!!",sdio_data->data_irq);
+		return ret;
+	}
+	
+	SDIOTRAN_ERR("ok!!!irq is %d!!!",sdio_irq_num);
+
+	return 0;
+}
+
+static void sdio_dev_intr_uninit(void)
+{
+	disable_irq_nosync(sdio_irq_num);
+	free_irq(sdio_irq_num,NULL);
+	gpio_free(sdio_data->data_irq);
+	gpio_free(sdio_data->wake_out);
+
+	cancel_work_sync(&marlin_wq);
+	//flush_workqueue(&marlin_wq);
+	//destroy_workqueue(&marlin_wq);
+
+	wake_lock_destroy(&marlin_wakelock);
+	
+	SDIOTRAN_ERR("ok!!!");
+
+}
+static void set_apsdiohal_ready(void)
+{
+	ap_sdio_ready = 1;
+}
+
+static void set_apsdiohal_unready(void)
+{
+	ap_sdio_ready = 0;
+}
+
+//return 1 means ap sdiohal ready
+bool get_apsdiohal_status(void)
+{
+	return ap_sdio_ready;
+}
+EXPORT_SYMBOL_GPL(get_apsdiohal_status);
+
+//return 1 means marlin sdiohal ready
+bool get_sdiohal_status(void)
+{
+	return marlin_sdio_ready.marlin_sdio_init_end_tag;
+}
+EXPORT_SYMBOL_GPL(get_sdiohal_status);
+
+static void clear_sdiohal_status(void)
+{
+	marlin_sdio_ready.marlin_sdio_init_start_tag = 0;
+	marlin_sdio_ready.marlin_sdio_init_end_tag = 0;
+}
+
+static irqreturn_t marlinsdio_ready_irq_handler(int irq, void * para)
+{
+	disable_irq_nosync(irq);	
+
+	
+	SDIOTRAN_ERR("entry");
+	
+	if(!marlin_sdio_ready.marlin_sdio_init_start_tag){
+		SDIOTRAN_ERR("start");
+		irq_set_irq_type(irq,IRQF_TRIGGER_LOW);
+		marlin_sdio_ready.marlin_sdio_init_start_tag = 1;}
+	else{
+		SDIOTRAN_ERR("end");
+		irq_set_irq_type(irq,IRQF_TRIGGER_HIGH);
+		marlin_sdio_ready.marlin_sdio_init_end_tag = 1;}
+	
+	if(!marlin_sdio_ready.marlin_sdio_init_end_tag)
+		enable_irq(irq);
+	
+
+	return IRQ_HANDLED;
+
+}
+
+static int marlin_sdio_sync_init(void)
+{
+#if !(defined CONFIG_MACH_SP8730SEEA || defined CONFIG_MACH_SP8730SEEA_QHD)
+	int ret;	
+
+	SDIOTRAN_ERR("entry");
+
+	sci_glb_clr(SPRD_PIN_BASE + sdio_data->rfctl_off,(BIT(3)|BIT(7)|0));
+	sci_glb_set(SPRD_PIN_BASE + sdio_data->rfctl_off,(BIT(4)|BIT(5)|BIT(2)|BIT(6)));
+
+	ret = gpio_request(sdio_data->io_ready,"marlin_sdio_ready_irq");
+	if (ret<0)
+	{
+		SDIOTRAN_ERR("req gpio sdio_data->io_ready = %d fail!!!",\
+			sdio_data->io_ready);
+		return ret;
+	}
+	
+	ret = gpio_direction_input(sdio_data->io_ready);
+	if (ret<0)
+	{
+		SDIOTRAN_ERR("sdio_data->io_ready = %d input set fail!!!",\
+			sdio_data->io_ready);
+		return ret;
+
+	}
+
+	marlin_sdio_ready_irq_num = gpio_to_irq(sdio_data->io_ready);
+	SDIOTRAN_ERR("req irq");
+	ret = request_irq(marlin_sdio_ready_irq_num, marlinsdio_ready_irq_handler,IRQF_TRIGGER_RISING |IRQF_NO_SUSPEND, "m_sdio_ready_intr", NULL );
+	if (ret != 0) {
+		SDIOTRAN_ERR("request irq err!!!gpio is %d!!!",sdio_data->io_ready);
+		return ret;
+	}
+	
+	SDIOTRAN_ERR("ok!!!irq is %d!!!",marlin_sdio_ready_irq_num);
+#endif
+	return 0;
+}
+
+void marlin_sdio_sync_uninit(void)
+{
+	free_irq(marlin_sdio_ready_irq_num,NULL);
+	gpio_free(sdio_data->io_ready);
+#if !(defined CONFIG_MACH_SP8730SEEA || defined CONFIG_MACH_SP8730SEEA_QHD)
+	sci_glb_clr(SPRD_PIN_BASE + sdio_data->rfctl_off,(BIT(4)|BIT(5)|0));
+	sci_glb_set(SPRD_PIN_BASE + sdio_data->rfctl_off,(BIT(4)));
+#endif
+	SDIOTRAN_ERR("ok!!!");
+}
+EXPORT_SYMBOL_GPL(marlin_sdio_sync_uninit);
+
+
+static void marlinack_workq(void)
+{
+	int read_chn;
+	int ret = 0;
+
+	SDIOTRAN_ERR("ENTRY");
+	if(sdio_w_flag == 1)
+		complete(&marlin_ack);
+
+}
+	
+int time_d_value(struct timeval *start, struct timeval *end)
+{
+	return (end->tv_sec - start->tv_sec)*1000000 + (end->tv_usec - start->tv_usec);
+}
+
+static irqreturn_t marlinwake_irq_handler(int irq, void * para)
+{
+	struct timeval cur_time;
+	uint32 gpio_wake_status = 0, usec;
+	//irq_set_irq_type(irq,IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING);
+	gpio_wake_status = gpio_get_value(sdio_data->wake_ack);
+
+	if(get_sprd_download_fin() != 1)
+	{
+		if(!marlin_sdio_ready.marlin_sdio_init_start_tag && gpio_wake_status){
+			SDIOTRAN_ERR("start,g_val=%d",gpio_wake_status);
+			irq_set_irq_type(irq,IRQF_TRIGGER_LOW);
+			marlin_sdio_ready.marlin_sdio_init_start_tag = 1;
+		}
+		else if(!marlin_sdio_ready.marlin_sdio_init_end_tag && (!gpio_wake_status)){
+			SDIOTRAN_ERR("end,g_val=%d",gpio_wake_status);
+			irq_set_irq_type(irq,IRQF_TRIGGER_RISING);
+			marlin_sdio_ready.marlin_sdio_init_end_tag = 1;
+		}
+		else
+		{
+			SDIOTRAN_ERR("marlin gpio0 err interupt,g_val=%d",gpio_wake_status);
+		}	
+	}
+	else
+	{
+	/*add count irq for loopcheck*/
+	irq_count_change++;
+
+	/* avoid gpio jump , so need check the last and cur gpio value.*/	
+	do_gettimeofday(&cur_time);
+	if(ack_gpio_status == gpio_wake_status)
+	{
+	//	usec = time_d_value(&ack_irq_time, &cur_time);
+	//	if(usec < 200)    //means invalid gpio value, so discard
+		{
+			SDIOTRAN_ERR("discard gpio%d irq\n", sdio_data->wake_ack);
+			return IRQ_HANDLED;
+		}
+	//	SDIOTRAN_ERR("gpio%d %d-->%d\n",sdio_data->wake_ack, gpio_wake_status, 1 - gpio_wake_status );
+	//	gpio_wake_status = 1 - gpio_wake_status;
+		
+	}
+	ack_irq_time    = cur_time;
+	ack_gpio_status = gpio_wake_status;
+	SDIOTRAN_ERR("%d-%d\n",sdio_data->wake_ack, gpio_wake_status );
+	
+	if(gpio_wake_status)
+		irq_set_irq_type(irq, IRQ_TYPE_EDGE_FALLING);
+	else
+		irq_set_irq_type(irq, IRQ_TYPE_EDGE_RISING);
+	
+	if(gpio_wake_status)
+	{
+		wake_lock(&marlinpub_wakelock);
+		sleep_para.gpio_up_time = jiffies;
+	}
+	else
+	{
+		wake_unlock(&marlinpub_wakelock);
+		sleep_para.gpio_down_time = jiffies;
+	}
+	
+	if((!gpio_wake_status) && time_after(sleep_para.gpio_down_time,sleep_para.gpio_up_time))
+	{
+		if(jiffies_to_msecs(sleep_para.gpio_down_time -\
+			sleep_para.gpio_up_time)> sleep_para.bt_req_time)
+		{
+			SDIOTRAN_ERR("BT REQ!!!");
+			marlin_bt_wake_flag = 1;
+			wake_lock_timeout(&BT_AP_wakelock, sleep_para.wake_lock_time);    //wsh
+		}
+
+	}
+	
+	//schedule_work(&marlinack_wq);
+	if(gpio_wake_status)
+	{
+		if( atomic_read(&gpioreq_need_pulldown) )//if(sleep_para.gpioreq_need_pulldown)
+		{	
+			sleep_para.gpio_opt_tag = 1;
+			SDIOTRAN_ERR("gpio_opt_tag-1\n");
+			mod_timer(&(sleep_para.gpio_timer), jiffies + msecs_to_jiffies(sleep_para.marlin_waketime) );
+			if(sdio_w_flag == 1)
+			{
+				complete(&marlin_ack);
+				SDIOTRAN_ERR("ack-sem\n");
+				set_marlin_sleep(0xff,0x1);
+			}
+			else
+			{
+				SDIOTRAN_ERR("sdio_w_flag:%d\n", sdio_w_flag);
+				set_marlin_sleep(0xff,0x2);
+			}
+		}
+	}
+	}
+
+	return IRQ_HANDLED;
+}
+
+
+
+static int marlin_wake_intr_init(void)
+{
+	int ret;
+	sdio_w_flag = 0;
+	bt_wake_flag = 0;
+
+	INIT_WORK(&marlinwake_wq, marlinack_workq);	
+
+	init_completion (&marlin_ack);
+
+
+	wake_lock_init(&BT_AP_wakelock, WAKE_LOCK_SUSPEND, "marlinbtup_wakelock");	
+	
+	wake_lock_init(&marlinpub_wakelock, WAKE_LOCK_SUSPEND, "marlinpub_wakelock");	
+	
+	ret = gpio_request(sdio_data->wake_ack,"marlinwake_irq");
+	if (ret<0)
+	{
+		SDIOTRAN_ERR("req gpio sdio_data->wake_ack = %d fail!!!",\
+			sdio_data->wake_ack);
+		return ret;
+	}
+	
+	ret = gpio_direction_input(sdio_data->wake_ack);
+	if (ret<0)
+	{
+		SDIOTRAN_ERR("sdio_data->wake_ack = %d input set fail!!!",\
+			sdio_data->wake_ack);
+		return ret;
+
+	}
+
+	marlinwake_irq_num = gpio_to_irq(sdio_data->wake_ack);
+	
+	ret = request_irq(marlinwake_irq_num, marlinwake_irq_handler,IRQF_TRIGGER_RISING |IRQF_NO_SUSPEND, "marlin_wake_intr", NULL );
+	//ret = request_irq(marlinwake_irq_num, marlinwake_irq_handler,IRQF_TRIGGER_HIGH | IRQF_NO_SUSPEND, "marlin_wake_intr", NULL );
+	if (ret != 0) {
+		SDIOTRAN_ERR("request irq err!!!gpio is %d!!!",sdio_data->wake_ack);
+		return ret;
+	}
+	
+	SDIOTRAN_ERR("ok!!!irq is %d!!!",marlinwake_irq_num);
+
+	return 0;
+}
+
+static void marlin_wake_intr_uninit(void)
+{
+	disable_irq_nosync(marlinwake_irq_num);
+	free_irq(marlinwake_irq_num,NULL);
+	gpio_free(sdio_data->wake_ack);
+
+	
+	cancel_work_sync(&marlinwake_wq);
+	//flush_workqueue(&marlinwake_wq);
+	//destroy_workqueue(&marlinwake_wq);
+
+
+	wake_lock_destroy(&BT_AP_wakelock);
+	wake_lock_destroy(&marlinpub_wakelock);
+
+	SDIOTRAN_ERR("ok!!!");
+
+}
+
+
+
+static void sdio_tran_sync(void)
+{
+
+	int datalen,i,j;
+
+	SDIOTRAN_ERR("entry");
+
+	set_blklen(4);
+
+	while(!sdio_dev_chn_idle(SDIO_SYNC_CHN))
+	{
+		SDIOTRAN_ERR("sync chn is active!!!");
+		//return;
+	}
+
+	while(1)
+	{
+		datalen = sdio_dev_get_chn_datalen(SDIO_SYNC_CHN);
+		if(datalen > 0)
+		{
+			SDIOTRAN_ERR("channel %d len is =%d!!!",SDIO_SYNC_CHN,datalen);
+			break;
+		}
+		else
+			SDIOTRAN_ERR("channel %d len is =%d!!!",SDIO_SYNC_CHN,datalen);
+
+	}
+
+	sync_data_ptr = kmalloc(4,GFP_KERNEL);
+	if (NULL == sync_data_ptr)
+	{
+		SDIOTRAN_ERR("kmalloc sync buf err!!!");
+		return -1;
+	}
+
+	SDIOTRAN_ERR("kmalloc sync buf ok!!!");
+
+	for(i=0;i<4;i++)
+		*(sync_data_ptr+i) = i;
+
+	sdio_dev_write(SDIO_SYNC_CHN,sync_data_ptr,\
+		((datalen > 4) ? 4: datalen));
+
+	kfree(sync_data_ptr);
+
+	set_blklen(512);
+}
+
+
+void set_blklen(int blklen)
+{
+	sdio_claim_host(sprd_sdio_func[1]);
+	sdio_set_block_size(sprd_sdio_func[1], blklen);
+	sdio_release_host(sprd_sdio_func[1]);
+
+	SDIOTRAN_ERR("set blklen = %d!!!",blklen);
+
+}
+
+static void sdio_init_timer(void)
+{
+	init_timer(&sleep_para.gpio_timer);
+	sleep_para.gpio_timer.function = gpio_timer_handler;
+
+#if defined(CONFIG_WCN_EXTENSION)
+	sleep_para.marlin_waketime = 350;
+	sleep_para.bt_req_time = 100;
+	sleep_para.ack_high_time = 200;
+	sleep_para.wake_lock_time = HZ/2;
+#else
+	sleep_para.marlin_waketime = 1500;
+	sleep_para.bt_req_time = 200;
+	sleep_para.ack_high_time = 300;
+	sleep_para.wake_lock_time = HZ*2;
+#endif
+
+	sleep_para.gpio_opt_tag = 0;
+	atomic_set(&gpioreq_need_pulldown, 1);//sleep_para.gpioreq_need_pulldown = 1;
+}
+
+
+static void sdio_uninit_timer(void)
+{
+	del_timer(&sleep_para.gpio_timer);
+	sleep_para.marlin_waketime = 0;
+	sleep_para.bt_req_time = 0;
+	sleep_para.ack_high_time = 0;
+	sleep_para.wake_lock_time = 0;
+	sleep_para.gpio_opt_tag = 0;
+	atomic_set(&gpioreq_need_pulldown, 1);//sleep_para.gpioreq_need_pulldown = 1;
+}
+
+static int marlin_sdio_probe(struct sdio_func *func, const struct sdio_device_id *id)
+{
+	int ret;
+	
+	SDIOTRAN_ERR("sdio drv and dev match!!!");
+	mutex_init(&g_sdio_func_lock);
+	ret = get_sdio_dev_func(func);
+	if(ret < 0)
+	{
+		SDIOTRAN_ERR("get func err!!!\n");
+		return ret;
+	}
+	SDIOTRAN_ERR("get func ok!!!\n");
+
+	/* Enable Function 1 */
+	sdio_claim_host(sprd_sdio_func[1]);
+	ret = sdio_enable_func(sprd_sdio_func[1]);
+	sdio_set_block_size(sprd_sdio_func[1], 512);
+	sdio_release_host(sprd_sdio_func[1]);
+	if (ret < 0) {
+		SDIOTRAN_ERR("enable func1 err!!! ret is %d",ret);
+		return ret;
+	}
+	SDIOTRAN_ERR("enable func1 ok!!!");
+	
+	spin_lock_init(&sleep_spinlock);
+	sdio_init_timer();
+	clear_sdiohal_status();
+	wakeup_slave_pin_init();
+	marlin_wake_intr_init();
+	//marlin_sdio_sync_init();
+//case6
+#if defined(CONFIG_SDIODEV_TEST)
+		gaole_creat_test();
+#endif
+
+	sdio_dev_intr_init();
+
+#if defined(CONFIG_SDIODEV_TEST)
+	sdio_tran_sync();
+#endif
+
+/*case1
+#if defined(CONFIG_SDIODEV_TEST)
+	gaole_creat_test();
+#endif
+*/
+	//set_bt_pm_func(set_marlin_wakeup,set_marlin_sleep);
+
+	set_apsdiohal_ready();
+	have_card = 1;
+	return 0;
+}
+
+static void marlin_sdio_remove(struct sdio_func *func)
+{
+	SDIOTRAN_DEBUG("entry");
+	sdio_uninit_timer();
+	free_sdio_dev_func(func);
+	sdio_dev_intr_uninit();
+	marlin_wake_intr_uninit();
+	//marlin_sdio_sync_uninit();
+	set_apsdiohal_unready();
+	clear_sdiohal_status();
+
+	SDIOTRAN_DEBUG("ok");
+
+}
+
+static int marlin_sdio_suspend(struct device *dev)
+{
+	mutex_lock(&g_mgr_suspend.func_lock);
+	SDIOTRAN_ERR("[%s]enter\n", __func__);
+	
+	gpio_marlin_req_tag = gpio_get_value(sdio_data->data_irq);
+
+	if(gpio_marlin_req_tag)
+		SDIOTRAN_ERR("err marlin_req!!!");
+	else
+		irq_set_irq_type(sdio_irq_num,IRQF_TRIGGER_HIGH);
+
+	gpio_marlinwake_tag = gpio_get_value(sdio_data->wake_ack);
+	
+	if(gpio_marlinwake_tag)
+		SDIOTRAN_ERR("err marlinwake!!!");
+	else
+		irq_set_irq_type(marlinwake_irq_num,IRQF_TRIGGER_HIGH);
+	
+
+	
+	smp_mb();
+	SDIOTRAN_ERR("[%s]ok\n", __func__);
+	return 0;
+}
+static int marlin_sdio_resume(struct device *dev)
+{
+	SDIOTRAN_ERR("[%s]enter\n", __func__);
+	/****************/
+	mutex_unlock(&g_mgr_suspend.func_lock);
+	sleep_para.gpio_opt_tag = 0;
+	set_marlin_wakeup(0, 1);
+	mod_timer(&(sleep_para.gpio_timer),jiffies + msecs_to_jiffies(sleep_para.marlin_waketime));
+	/***************/
+	smp_mb();
+	SDIOTRAN_ERR("[%s]ok\n", __func__);
+	return 0;
+}
+
+static void* sdio_dev_get_host(void) 
+{
+	struct device *dev;
+
+	struct sdhci_host *host;
+
+	struct platform_device *pdev;
+
+	dev = bus_find_device_by_name(&platform_bus_type, NULL, sdio_data->sdhci);
+	if(dev == NULL)
+	{
+		SDIOTRAN_ERR("sdio find dev by name failed!!!");
+		return NULL;
+	}
+
+	pdev  = to_platform_device(dev);
+	if(pdev == NULL)
+	{
+		SDIOTRAN_ERR("sdio dev get platform device failed!!!");
+		return NULL;
+	}
+
+	host = platform_get_drvdata(pdev);	
+	return container_of(host, struct mmc_host, private);
+
+		
+}
+
+void  marlin_sdio_uninit(void)
+{
+	set_sprd_download_fin(0);
+	sdio_unregister_driver(&marlin_sdio_driver);
+	mgr_suspend_defint();
+	sdio_dev_host = NULL;
+	have_card = 0;
+
+	kfree(sdio_data);
+	sdio_data = NULL;
+	SDIOTRAN_ERR("ok");
+}
+
+int marlin_sdio_init(void)
+{
+	int ret;
+	struct device_node *np;
+	SDIOTRAN_ERR("entry");
+	if(have_card == 1){
+		marlin_sdio_uninit();
+	}
+	mgr_suspend_init();
+	//atomic_set(&req_marlin_wait_tag, 0);
+	atomic_set(&gpioreq_need_pulldown, 1);
+	atomic_set(&is_wlan_open, 0);
+	atomic_set(&set_marlin_cmplete, 1);
+
+	sdio_data = kzalloc(sizeof(*sdio_data), GFP_KERNEL);
+	if (!sdio_data)
+		return -ENOMEM;
+	np = of_find_node_by_name(NULL, "sprd-marlin");
+	if (!np) {
+		SDIOTRAN_ERR("sprd-marlin not found");
+		return -1;
+	}
+
+	sdio_data->wake_ack = of_get_gpio(np, 0);
+	sdio_data->data_irq = of_get_gpio(np, 1);
+	sdio_data->wake_out = of_get_gpio(np, 2);
+	sdio_data->io_ready = of_get_gpio(np, 3);
+
+	of_property_read_u32(np, "cp-rfctl-offset", &(sdio_data->rfctl_off));
+
+	ret = of_property_read_string(np, "sdhci-name", &(sdio_data->sdhci));
+	if (ret) {
+		SDIOTRAN_ERR("get sdhci-name failed");
+		return -1;
+	}
+
+	sdio_dev_host = sdio_dev_get_host();
+	if(NULL == sdio_dev_host)
+	{
+		SDIOTRAN_ERR("get host failed!!!");
+		return -1;
+	}
+	SDIOTRAN_ERR("sdio get host ok!!!");
+
+	ret = sdio_register_driver(&marlin_sdio_driver);
+	if(0 != ret) 
+	{
+		SDIOTRAN_ERR("sdio register drv err!!!ret is %d!!!",ret);
+		return -1;
+	}
+	
+	SDIOTRAN_ERR("sdio register drv succ!!!");
+
+	flush_delayed_work(&sdio_dev_host->detect);
+	mmc_detect_change(sdio_dev_host, 0);
+	
+	return ret;
+}
+EXPORT_SYMBOL_GPL(marlin_sdio_init);
+
+