/*
 *   Driver for KeyStream, KS7010 based SDIO cards.
 *
 *   ks7010_sdio.c
 *   $Id: ks7010_sdio.c 996 2009-09-14 02:54:21Z sekine $
 *
 *   Copyright (C) 2006-2008 KeyStream Corp.
 *   Copyright (C) 2009 Renesas Technology Corp.
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it undr the terms of the GNU General Public License version 2 as
 *   published by the Free Sotware Foundation.
 */

#include <linux/workqueue.h>
#include <asm/atomic.h>
#include <linux/mmc/card.h>
#include <linux/mmc/sdio_func.h>

#include "ks_wlan.h"
#include "ks_wlan_ioctl.h"
#include "ks_debug.h"
#include "ks_hostif.h"

#include "ks7010_sdio.h"

#define KS7010_FUNC_NUM 1
#define KS7010_IO_BLOCK_SIZE 512
#define KS7010_MAX_CLOCK 25000000

static int reg_net = 0;

static const struct sdio_device_id if_sdio_ids[] = {
	{ SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_A, SDIO_DEVICE_ID_KS_7010) },
	{ SDIO_DEVICE(SDIO_VENDOR_ID_KS_CODE_B, SDIO_DEVICE_ID_KS_7010) },
	{ /* all zero */ }
};

struct ks_sdio_model {
        int model;
        const char *firmware;
};

static struct ks_sdio_model ks_sdio_models[] = {
        {
                /* ks7010 */
                .model = 0x10,
                .firmware = "ks7010sd.rom",
        },
};

static int ks7910_sdio_probe(struct sdio_func *function, const struct sdio_device_id *device);
static void ks7910_sdio_remove(struct sdio_func *function);
static void ks7010_rw_function(struct work_struct *work);
static int ks7010_sdio_read( ks_wlan_private *priv, unsigned int address,
			     unsigned char *buffer, int length );
static int ks7010_sdio_write( ks_wlan_private *priv, unsigned int address,
			      unsigned char *buffer, int length );
#ifdef NO_FIRMWARE_CLASS
static char *romfile = ROM_FILE;
module_param(romfile, charp, S_IRUGO);
#endif
/* macro */

#define inc_txqhead(priv) \
        ( priv->tx_dev.qhead = (priv->tx_dev.qhead + 1) % TX_DEVICE_BUFF_SIZE )
#define inc_txqtail(priv) \
        ( priv->tx_dev.qtail = (priv->tx_dev.qtail + 1) % TX_DEVICE_BUFF_SIZE )
#define cnt_txqbody(priv) \
        (((priv->tx_dev.qtail + TX_DEVICE_BUFF_SIZE) - (priv->tx_dev.qhead)) % TX_DEVICE_BUFF_SIZE )

#define inc_rxqhead(priv) \
        ( priv->rx_dev.qhead = (priv->rx_dev.qhead + 1) % RX_DEVICE_BUFF_SIZE )
#define inc_rxqtail(priv) \
        ( priv->rx_dev.qtail = (priv->rx_dev.qtail + 1) % RX_DEVICE_BUFF_SIZE )
#define cnt_rxqbody(priv) \
        (((priv->rx_dev.qtail + RX_DEVICE_BUFF_SIZE) - (priv->rx_dev.qhead)) % RX_DEVICE_BUFF_SIZE )

void ks_wlan_hw_sleep_doze_request(ks_wlan_private *priv)
{
	unsigned char rw_data;
	int retval;

	DPRINTK(4, "\n");

	/* clear request */
	atomic_set(&priv->sleepstatus.doze_request,0);

	if( atomic_read(&priv->sleepstatus.status) == 0){
		rw_data = GCR_B_DOZE;
		retval = ks7010_sdio_write(priv, GCR_B, &rw_data, sizeof(rw_data));
		if(retval){
			DPRINTK(1, " error : GCR_B=%02X\n", rw_data);
			goto out;
		}
		DPRINTK(4, "PMG SET!! : GCR_B=%02X\n", rw_data);
		DPRINTK(3,"sleep_mode=SLP_SLEEP\n");
		atomic_set(&priv->sleepstatus.status, 1);
 		priv->last_doze = jiffies;
	}
	else{
		DPRINTK(1,"sleep_mode=%d\n",priv->sleep_mode);
	}

out:
	priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
	return;
}

void ks_wlan_hw_sleep_wakeup_request(ks_wlan_private *priv)
{
	unsigned char rw_data;
	int retval;

	DPRINTK(4, "\n");

	/* clear request */
	atomic_set(&priv->sleepstatus.wakeup_request,0);

	if( atomic_read(&priv->sleepstatus.status) == 1){
		rw_data = WAKEUP_REQ;
		retval = ks7010_sdio_write(priv, WAKEUP, &rw_data, sizeof(rw_data));
		if(retval){
			DPRINTK(1, " error : WAKEUP=%02X\n", rw_data);
			goto out;
		}
		DPRINTK(4, "wake up : WAKEUP=%02X\n", rw_data);
		atomic_set(&priv->sleepstatus.status, 0);
 		priv->last_wakeup = jiffies;
		++priv->wakeup_count;
	}
	else{
		DPRINTK(1,"sleep_mode=%d\n",priv->sleep_mode);
	}

out:
	priv->sleep_mode = atomic_read(&priv->sleepstatus.status);
	return;
}


void ks_wlan_hw_wakeup_request(ks_wlan_private *priv)
{
	unsigned char rw_data;
	int retval;

	DPRINTK(4, "\n");
	if(atomic_read(&priv->psstatus.status)==PS_SNOOZE){
		rw_data = WAKEUP_REQ;
		retval = ks7010_sdio_write(priv, WAKEUP, &rw_data, sizeof(rw_data));
		if(retval){
			DPRINTK(1, " error : WAKEUP=%02X\n", rw_data);
		}
		DPRINTK(4, "wake up : WAKEUP=%02X\n", rw_data);
 		priv->last_wakeup = jiffies;
		++priv->wakeup_count;
	}
	else{
		DPRINTK(1,"psstatus=%d\n",atomic_read(&priv->psstatus.status));
	}
}

int _ks_wlan_hw_power_save(ks_wlan_private *priv)
{
	int rc=0;
	unsigned char rw_data;
	int retval;

	if(priv->reg.powermgt == POWMGT_ACTIVE_MODE)
		return rc;

	if(priv->reg.operation_mode == MODE_INFRASTRUCTURE &&
	   (priv->connect_status & CONNECT_STATUS_MASK)== CONNECT_STATUS){

		//DPRINTK(1,"psstatus.status=%d\n",atomic_read(&priv->psstatus.status));
	if (priv->dev_state == DEVICE_STATE_SLEEP) {
		switch(atomic_read(&priv->psstatus.status)){
		case PS_SNOOZE: /* 4 */
			break;
		default:
			DPRINTK(5,"\n\
				psstatus.status=%d\n\
				psstatus.confirm_wait=%d\n\
				psstatus.snooze_guard=%d\n\
				cnt_txqbody=%d\n",
				atomic_read(&priv->psstatus.status),
				atomic_read(&priv->psstatus.confirm_wait),
				atomic_read(&priv->psstatus.snooze_guard),
				cnt_txqbody(priv));

			if(!atomic_read(&priv->psstatus.confirm_wait)&&
			   !atomic_read(&priv->psstatus.snooze_guard)&&
			   !cnt_txqbody(priv)){
				retval = ks7010_sdio_read(priv, INT_PENDING, &rw_data, sizeof(rw_data));
				if(retval){
					DPRINTK(1, " error : INT_PENDING=%02X\n", rw_data);
					queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq, 1);
					break;
				}
				if(!rw_data){
					rw_data = GCR_B_DOZE;
					retval = ks7010_sdio_write(priv, GCR_B, &rw_data, sizeof(rw_data));
					if(retval){
						DPRINTK(1, " error : GCR_B=%02X\n", rw_data);
						queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq, 1);
						break;
					}
					DPRINTK(4, "PMG SET!! : GCR_B=%02X\n", rw_data);
					atomic_set(&priv->psstatus.status, PS_SNOOZE);
					DPRINTK(3,"psstatus.status=PS_SNOOZE\n");
				}
				else{
					queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq, 1);
				}
			}
			else{
				queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq, 0);
			}
			break;
		}
	}

	}

	return rc;
}

int ks_wlan_hw_power_save(ks_wlan_private *priv)
{
	queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq, 1);
	return 0;
}

static int ks7010_sdio_read(ks_wlan_private *priv, unsigned int address,
			    unsigned char *buffer, int length)
{
	int rc = -1;
	struct ks_sdio_card *card;

	card = priv->ks_wlan_hw.sdio_card;

	if (length == 1) /* CMD52 */
		*buffer = sdio_readb(card->func, address, &rc);
	else /* CMD53 multi-block transfer */
		rc = sdio_memcpy_fromio(card->func, buffer, address, length);

	if(rc != 0){
		printk("sdio error erorr=%d size=%d\n", rc, length);
		++priv->sdio_error_count;
	}else{
		priv->sdio_error_count=0;
	}

	return rc;
}

static int ks7010_sdio_write(ks_wlan_private *priv, unsigned int address,
			     unsigned char *buffer, int length)
{
	int rc = -1;
	struct ks_sdio_card *card;

	card = priv->ks_wlan_hw.sdio_card;

	if (length == 1) /* CMD52 */
		sdio_writeb(card->func, *buffer, (unsigned int) address,  &rc);
	else 		 /* CMD53 */
		rc = sdio_memcpy_toio(card->func, (unsigned int) address, buffer, length);

	if(rc != 0){
		printk("sdio error erorr=%d size=%d\n", rc, length);
		++priv->sdio_error_count;
	}else{
		priv->sdio_error_count=0;
	}

	return rc;
}

static int enqueue_txdev(ks_wlan_private *priv, unsigned char *p, unsigned long size,
		  void (*complete_handler)(void *arg1, void *arg2),
		  void *arg1, void *arg2 )
{
	struct tx_device_buffer *sp;

	if (priv->dev_state < DEVICE_STATE_BOOT) {
		kfree(p);
		if (complete_handler != NULL)
			(*complete_handler)(arg1, arg2);
		return 1;
	}

	if ((TX_DEVICE_BUFF_SIZE - 1) <=  cnt_txqbody(priv)) {
		/* in case of buffer overflow */
		DPRINTK(1,"tx buffer overflow\n");
		kfree(p);
		if (complete_handler != NULL)
			(*complete_handler)(arg1, arg2);
		return 1;
	}

	sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qtail];
	sp->sendp = p;
	sp->size = size;
	sp->complete_handler = complete_handler;
	sp->arg1 = arg1;
	sp->arg2 = arg2;
	inc_txqtail(priv);

	return 0;
}

/* write data */
static int write_to_device(ks_wlan_private *priv, unsigned char *buffer, unsigned long size )
{
	int rc,retval;
	unsigned char rw_data;
	struct hostif_hdr *hdr;
	hdr = (struct hostif_hdr *)buffer;
	rc=0;

	DPRINTK(4,"size=%d\n", hdr->size);
	if(hdr->event < HIF_DATA_REQ || HIF_REQ_MAX < hdr->event){
		DPRINTK(1,"unknown event=%04X\n",hdr->event);
		return 0;
	}

	retval = ks7010_sdio_write(priv, DATA_WINDOW, buffer, size);
	if(retval){
		DPRINTK(1, " write error : retval=%d\n", retval);
		return -4;
	}

	rw_data = WRITE_STATUS_BUSY;
	retval = ks7010_sdio_write(priv, WRITE_STATUS, &rw_data, sizeof(rw_data));
	if(retval){
		DPRINTK(1, " error : WRITE_STATUS=%02X\n", rw_data);
		return -3;
	}

	return 0;
}

static void tx_device_task(void *dev)
{
	ks_wlan_private	*priv = (ks_wlan_private *)dev;
	struct tx_device_buffer	*sp;
	int rc = 0;

	DPRINTK(4, "\n");
	if(cnt_txqbody(priv)>0 && atomic_read(&priv->psstatus.status) != PS_SNOOZE){
		sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
		if(priv->dev_state >= DEVICE_STATE_BOOT){
			rc = write_to_device(priv, sp->sendp, sp->size);
			if(rc){
				DPRINTK(1, "write_to_device error !!(%d)\n", rc);
				queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq, 1);
				return;
			}

		}
		kfree(sp->sendp); /* allocated memory free */
		if(sp->complete_handler != NULL) /* TX Complete */
			(*sp->complete_handler)(sp->arg1, sp->arg2);
		inc_txqhead(priv);

		if(cnt_txqbody(priv)>0){
			queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq, 0);
		}
	}
	return;
}

int ks_wlan_hw_tx( ks_wlan_private *priv, void *p, unsigned long size,
		   void (*complete_handler)(void *arg1, void *arg2),
		   void *arg1, void *arg2 )
{
	int result=0;
	struct hostif_hdr *hdr;
	hdr = (struct hostif_hdr *)p;

	if(hdr->event < HIF_DATA_REQ || HIF_REQ_MAX < hdr->event){
		DPRINTK(1,"unknown event=%04X\n",hdr->event);
		return 0;
	}

	/* add event to hostt buffer */
	priv->hostt.buff[priv->hostt.qtail] = hdr->event;
        priv->hostt.qtail = (priv->hostt.qtail + 1) % SME_EVENT_BUFF_SIZE;

	DPRINTK(4, "event=%04X\n",hdr->event);
	spin_lock(&priv->tx_dev.tx_dev_lock);
	result = enqueue_txdev(priv, p, size, complete_handler, arg1, arg2);
	spin_unlock(&priv->tx_dev.tx_dev_lock);

	if(cnt_txqbody(priv)>0){
		queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq, 0);
	}
	return result;
}

static void rx_event_task(unsigned long dev)
{
        ks_wlan_private *priv = (ks_wlan_private *)dev;
	struct rx_device_buffer	*rp;

	DPRINTK(4,"\n");

	if(cnt_rxqbody(priv) > 0 && priv->dev_state >= DEVICE_STATE_BOOT){
		rp = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qhead];
		hostif_receive(priv, rp->data, rp->size);
		inc_rxqhead(priv);

		if(cnt_rxqbody(priv) > 0){
			tasklet_schedule(&priv->ks_wlan_hw.rx_bh_task);
		}
	}

	return;
}

static void ks_wlan_hw_rx(void *dev, uint16_t size)
{
	ks_wlan_private *priv = (ks_wlan_private *)dev;
	int retval;
	struct rx_device_buffer *rx_buffer;
	struct hostif_hdr *hdr;
	unsigned char	read_status;
	unsigned short event=0;

	DPRINTK(4,"\n");

	/* receive data */
	if (cnt_rxqbody(priv) >= (RX_DEVICE_BUFF_SIZE-1)) {
		/* in case of buffer overflow */
		DPRINTK(1,"rx buffer overflow \n");
		goto error_out;
	}
	rx_buffer = &priv->rx_dev.rx_dev_buff[priv->rx_dev.qtail];

	retval = ks7010_sdio_read(priv, DATA_WINDOW, &rx_buffer->data[0], hif_align_size(size));
	if(retval){
		goto error_out;
	}

	/* length check */
	if(size > 2046 || size == 0){

		DPRINTK(5,"-INVAILED DATA dump\n");
		print_buffer(&rx_buffer->data[0],32);

		/* rx_status update */
		read_status = READ_STATUS_IDLE;
		retval = ks7010_sdio_write(priv, READ_STATUS, &read_status, sizeof(read_status));
		if(retval){
			DPRINTK(1, " error : READ_STATUS=%02X\n", read_status);
		}
		goto error_out;
	}

	hdr = (struct hostif_hdr *)&rx_buffer->data[0];
	rx_buffer->size = le16_to_cpu(hdr->size) + sizeof(hdr->size);
	event = hdr->event;
	inc_rxqtail(priv);

	/* read status update */
	read_status = READ_STATUS_IDLE;
	retval = ks7010_sdio_write(priv, READ_STATUS, &read_status, sizeof(read_status));
	if(retval){
		DPRINTK(1, " error : READ_STATUS=%02X\n", read_status);
	}
	DPRINTK(4, "READ_STATUS=%02X\n", read_status);

	if(atomic_read(&priv->psstatus.confirm_wait)){
		if(IS_HIF_CONF(event)){
			DPRINTK(4, "IS_HIF_CONF true !!\n");
			atomic_dec(&priv->psstatus.confirm_wait);
		}
	}

	/* rx_event_task((void *)priv); */
	tasklet_schedule(&priv->ks_wlan_hw.rx_bh_task);

error_out:
	return;
}

static void ks7010_rw_function(struct work_struct *work)
{
	struct hw_info_t *hw;
	struct ks_wlan_private *priv;
	unsigned char rw_data;
	int retval;

	hw = container_of(work, struct hw_info_t, rw_wq.work);
	priv = container_of(hw, struct ks_wlan_private, ks_wlan_hw);

	DPRINTK(4,"\n");


 	/* wiat after DOZE */
 	if(time_after(priv->last_doze + ((30*HZ)/1000), jiffies )){
 		DPRINTK(4, "wait after DOZE \n");
		queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq, 1);
		return;
	}

	/* wiat after WAKEUP */
	while(time_after(priv->last_wakeup + ((30*HZ)/1000), jiffies )){
		DPRINTK(4, "wait after WAKEUP \n");
/*		queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq,
		(priv->last_wakeup + ((30*HZ)/1000) - jiffies));*/
		printk("wake: %lu %lu\n", priv->last_wakeup + (30* HZ)/1000, jiffies);
		msleep(30);
	}

	sdio_claim_host(priv->ks_wlan_hw.sdio_card->func);

	/* power save wakeup */
	if(atomic_read(&priv->psstatus.status)==PS_SNOOZE){
		if(cnt_txqbody(priv)>0){
			ks_wlan_hw_wakeup_request(priv);
			queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq, 1);
		}
		goto err_out;
	}

	/* sleep mode doze */
	if(atomic_read(&priv->sleepstatus.doze_request)==1){
		ks_wlan_hw_sleep_doze_request(priv);
		goto err_out;
	}
	/* sleep mode wakeup */
	if(atomic_read(&priv->sleepstatus.wakeup_request)==1){
		ks_wlan_hw_sleep_wakeup_request(priv);
		goto err_out;
	}

	/* read (WriteStatus/ReadDataSize FN1:00_0014) */
	retval = ks7010_sdio_read(priv, WSTATUS_RSIZE, &rw_data, sizeof(rw_data));
	if(retval){
		DPRINTK(1, " error : WSTATUS_RSIZE=%02X psstatus=%d\n", rw_data,atomic_read(&priv->psstatus.status));
		goto err_out;
	}
	DPRINTK(4, "WSTATUS_RSIZE=%02X\n", rw_data);

	if(rw_data&RSIZE_MASK){ /* Read schedule */
		ks_wlan_hw_rx((void *)priv, (uint16_t)(((rw_data&RSIZE_MASK)<<4)));
	}
	if((rw_data&WSTATUS_MASK)){
		tx_device_task((void *)priv);
	}
	_ks_wlan_hw_power_save(priv);

err_out:
	sdio_release_host(priv->ks_wlan_hw.sdio_card->func);

	return;
}



static void ks_sdio_interrupt(struct sdio_func *func)
{
	int retval;
	struct ks_sdio_card *card;
	ks_wlan_private *priv;
	unsigned char status, rsize, rw_data;

	card = sdio_get_drvdata(func);
	priv = card->priv;
	DPRINTK(4, "\n");

	if(priv->dev_state >= DEVICE_STATE_BOOT){
		retval = ks7010_sdio_read(priv, INT_PENDING, &status, sizeof(status));
		if(retval){
			DPRINTK(1, "read INT_PENDING Failed!!(%d)\n",retval);
			goto intr_out;
		}
		DPRINTK(4, "INT_PENDING=%02X\n", rw_data);

		/* schedule task for interrupt status */
		/* bit7 -> Write General Communication B register */
		/* read (General Communication B register) */
		/* bit5 -> Write Status Idle */
		/* bit2 -> Read Status Busy  */
		if(status&INT_GCR_B || atomic_read(&priv->psstatus.status)==PS_SNOOZE){
			retval = ks7010_sdio_read(priv, GCR_B, &rw_data, sizeof(rw_data));
			if(retval){
				DPRINTK(1, " error : GCR_B=%02X\n", rw_data);
				goto intr_out;
			}
			/* DPRINTK(1, "GCR_B=%02X\n", rw_data); */
			if(rw_data == GCR_B_ACTIVE){
				if(atomic_read(&priv->psstatus.status)==PS_SNOOZE){
					atomic_set(&priv->psstatus.status, PS_WAKEUP);
					priv->wakeup_count=0;
				}
				complete(&priv->psstatus.wakeup_wait);
			}


		}

		do{
			/* read (WriteStatus/ReadDataSize FN1:00_0014) */
			retval = ks7010_sdio_read(priv, WSTATUS_RSIZE, &rw_data, sizeof(rw_data));
			if(retval){
				DPRINTK(1, " error : WSTATUS_RSIZE=%02X\n", rw_data);
				goto intr_out;
			}
			DPRINTK(4, "WSTATUS_RSIZE=%02X\n", rw_data);
			rsize=rw_data&RSIZE_MASK;
			if(rsize){ /* Read schedule */
				ks_wlan_hw_rx((void *)priv, (uint16_t)(((rsize)<<4)));
			}
			if(rw_data&WSTATUS_MASK){
#if 0
				if(status&INT_WRITE_STATUS && !cnt_txqbody(priv)){
					/* dummy write for interrupt clear */
					rw_data =0;
					retval = ks7010_sdio_write(priv, DATA_WINDOW, &rw_data, sizeof(rw_data));
					if (retval) {
						DPRINTK(1, "write DATA_WINDOW Failed!!(%d)\n",retval);
					}
					status &= ~INT_WRITE_STATUS;
				}
				else{
#endif
					if(atomic_read(&priv->psstatus.status)==PS_SNOOZE){
						if(cnt_txqbody(priv)){
							ks_wlan_hw_wakeup_request(priv);
							queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq, &priv->ks_wlan_hw.rw_wq, 1);
							return;
						}
					}
					else{
						tx_device_task((void *)priv);
					}
//				}
			}
		}while(rsize);
	}

intr_out:
	queue_delayed_work(priv->ks_wlan_hw.ks7010sdio_wq,&priv->ks_wlan_hw.rw_wq, 0);
	return;
}

static int trx_device_init( ks_wlan_private *priv )
{
	/* initialize values (tx) */
	priv->tx_dev.qtail = priv->tx_dev.qhead = 0;

	/* initialize values (rx) */
	priv->rx_dev.qtail = priv->rx_dev.qhead = 0;

	/* initialize spinLock (tx,rx) */
	spin_lock_init(&priv->tx_dev.tx_dev_lock);
	spin_lock_init(&priv->rx_dev.rx_dev_lock);

	tasklet_init(&priv->ks_wlan_hw.rx_bh_task, rx_event_task, (unsigned long)priv);

	return 0;
}

static void trx_device_exit( ks_wlan_private *priv )
{
	struct tx_device_buffer	*sp;

	/* tx buffer clear */
	while (cnt_txqbody(priv)>0) {
		sp = &priv->tx_dev.tx_dev_buff[priv->tx_dev.qhead];
		kfree(sp->sendp); /* allocated memory free */
		if (sp->complete_handler != NULL) /* TX Complete */
			(*sp->complete_handler)(sp->arg1, sp->arg2);
		inc_txqhead(priv);
	}

	tasklet_kill(&priv->ks_wlan_hw.rx_bh_task);

	return;
}
static int ks7010_sdio_update_index(ks_wlan_private *priv, u32 index)
{
	int rc=0;
	int retval;
	unsigned char *data_buf;
	data_buf = NULL;

	data_buf = kmalloc(sizeof(u32), GFP_KERNEL);
	if(!data_buf){ rc = 1; goto error_out; }

	memcpy(data_buf, &index, sizeof(index));
	retval = ks7010_sdio_write(priv, WRITE_INDEX, data_buf, sizeof(index));
	if(retval){ rc = 2; goto error_out; }

	retval = ks7010_sdio_write(priv, READ_INDEX, data_buf, sizeof(index));
	if(retval){ rc = 3; goto error_out; }
error_out:
	if(data_buf) kfree(data_buf);
	return rc;
}

#define ROM_BUFF_SIZE (64*1024)
static int ks7010_sdio_data_compare(ks_wlan_private *priv, u32 address,
				    unsigned char *data, unsigned int size)
{
	int rc=0;
	int retval;
	unsigned char *read_buf;
	read_buf = NULL;
	read_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
	if(!read_buf){ rc = 1; goto error_out; }
	retval = ks7010_sdio_read(priv, address, read_buf, size);
	if(retval){ rc = 2; goto error_out; }
	retval = memcmp(data, read_buf, size);

	if(retval){
		DPRINTK(0, "data compare error (%d) \n",retval); rc = 3; goto error_out;
	}
error_out:
	if(read_buf) kfree(read_buf);
	return rc;
}
#ifndef NO_FIRMWARE_CLASS
#include <linux/firmware.h>
#endif
static int ks79xx_upload_firmware(ks_wlan_private *priv, struct ks_sdio_card *card)
{
	unsigned int	size, offset,  n = 0;
	unsigned char	*rom_buf;
	unsigned char rw_data =0;
	int retval, rc=0;
#ifndef NO_FIRMWARE_CLASS
	int length;
	const struct firmware *fw_entry = NULL;
#else
	int orgfsuid, orgfsgid;
	struct file     *srcf;
	mm_segment_t orgfs;
#endif

	rom_buf = NULL;

	/* buffer allocate */
	rom_buf = kmalloc(ROM_BUFF_SIZE, GFP_KERNEL);
	if(!rom_buf){ rc = 3; goto error_out0; }


	sdio_claim_host(card->func);

	/* Firmware running ? */
	retval = ks7010_sdio_read(priv, GCR_A, &rw_data, sizeof(rw_data));
	if(rw_data == GCR_A_RUN){
		DPRINTK( 0, "MAC firmware running ...\n");
		rc = 0;
		goto error_out0;
	}

#ifndef NO_FIRMWARE_CLASS
	if(request_firmware(&fw_entry, priv->reg.rom_file, &priv->ks_wlan_hw.sdio_card->func->dev)!=0){
		DPRINTK(1,"error request_firmware() file=%s\n", priv->reg.rom_file);
		return 1;
	}
	DPRINTK(4,"success request_firmware() file=%s size=%d\n", priv->reg.rom_file, fw_entry->size);
	length = fw_entry->size;
#else
	orgfsuid=current->fsuid;
	orgfsgid=current->fsgid;
	current->fsuid=current->fsgid=0;
	orgfs=get_fs();
	set_fs(KERNEL_DS);

	srcf = filp_open(romfile, O_RDONLY, 0);
	if (IS_ERR(srcf)) {
		DPRINTK(1, "error %ld opening %s\n", -PTR_ERR(srcf),romfile);
		rc = 1;
		goto error_out1;
	}

        if (!(srcf->f_op && srcf->f_op->read)) {
                DPRINTK(1, "%s does not have a read method\n", romfile);
                rc = 2;
                goto error_out2;
        }
#endif

	/* Load Program */
	n = 0;
        do {
#ifndef NO_FIRMWARE_CLASS
		if(length >= ROM_BUFF_SIZE){
			size = ROM_BUFF_SIZE;
			length = length - ROM_BUFF_SIZE;
		}
		else{
			size=length;
			length=0;
		}
		DPRINTK(4, "size = %d\n",size);
		if(size == 0) break;
		memcpy(rom_buf,fw_entry->data+n,size);
#else
		/* The object must have a read method */
		size = srcf->f_op->read(srcf, rom_buf, ROM_BUFF_SIZE, &srcf->f_pos);
		if (size < 0) {
			DPRINTK(1, "Read %s error %d\n", priv->reg.rom_file, -retval);
			rc = 5;
			goto error_out2;
		}
		else if (size == 0) break;
#endif
		/* Update write index */
		offset = n;
		retval = ks7010_sdio_update_index(priv, KS7010_IRAM_ADDRESS+offset);
		if(retval){ rc = 6; goto error_out1; }

		/* Write data */
		retval = ks7010_sdio_write(priv, DATA_WINDOW, rom_buf, size);
		if(retval){ rc = 8; goto error_out1; }

		/* compare */
		retval = ks7010_sdio_data_compare(priv, DATA_WINDOW, rom_buf, size);
		if(retval){ rc = 9; goto error_out1; }
		n += size;

       }while(size);

	/* Remap request */
	rw_data = GCR_A_REMAP;
	retval = ks7010_sdio_write(priv, GCR_A, &rw_data, sizeof(rw_data));
	if(retval){
		rc = 11;
		goto error_out1;
	}
	DPRINTK( 4, " REMAP Request : GCR_A=%02X\n", rw_data);

	/* Firmware running check */
	for (n = 0; n < 50; ++n) {
		mdelay(10);/* wait_ms(10); */
		retval = ks7010_sdio_read(priv, GCR_A, &rw_data, sizeof(rw_data));
		if(retval){ rc = 11; goto error_out1; }
		if(rw_data == GCR_A_RUN) break;
	}
	DPRINTK(4, "firmware wakeup (%d)!!!!\n",n);
	if ((50) <= n) {
		DPRINTK(1, "firmware can't start\n");
                rc = 12;
		goto error_out1;
	}

	rc = 0;

#ifdef NO_FIRMWARE_CLASS
 error_out2:
	retval=filp_close(srcf ,NULL);
	if (retval)
		DPRINTK(1, "error %d closing %s\n", -retval,priv->reg.rom_file);

 error_out1:
	set_fs(orgfs);
	current->fsuid=orgfsuid;
	current->fsgid=orgfsgid;
#else
 error_out1:
	release_firmware(fw_entry);
#endif
 error_out0:
	sdio_release_host(card->func);
	if(rom_buf)
		kfree(rom_buf);
	return rc;
}

static void card_init_task(struct work_struct *work)
{
	struct hw_info_t *hw;
	struct ks_wlan_private *priv;

	hw = container_of(work, struct hw_info_t, init_task);
	priv = container_of(hw, struct ks_wlan_private, ks_wlan_hw);

	DPRINTK(5,"\ncard_init_task()\n");

	/* init_waitqueue_head(&priv->confirm_wait); */
	init_completion(&priv->confirm_wait);

	DPRINTK(5,"init_completion()\n");

	/* get mac address & firmware version */
	hostif_sme_enqueue(priv, SME_START);

	DPRINTK(5,"hostif_sme_enqueu()\n");

	if(!wait_for_completion_interruptible_timeout(&priv->confirm_wait,5*HZ)){
		DPRINTK(1,"wait time out!! SME_START\n");
	}

	if(priv->mac_address_valid && priv->version_size){
		priv->dev_state = DEVICE_STATE_PREINIT;
	}

	hostif_sme_enqueue(priv, SME_GET_EEPROM_CKSUM);

	/* load initial wireless parameter */
	hostif_sme_enqueue(priv, SME_STOP_REQUEST);

	hostif_sme_enqueue(priv, SME_RTS_THRESHOLD_REQUEST);
	hostif_sme_enqueue(priv, SME_FRAGMENTATION_THRESHOLD_REQUEST);

	hostif_sme_enqueue(priv, SME_WEP_INDEX_REQUEST);
	hostif_sme_enqueue(priv, SME_WEP_KEY1_REQUEST);
	hostif_sme_enqueue(priv, SME_WEP_KEY2_REQUEST);
	hostif_sme_enqueue(priv, SME_WEP_KEY3_REQUEST);
	hostif_sme_enqueue(priv, SME_WEP_KEY4_REQUEST);

	hostif_sme_enqueue(priv, SME_WEP_FLAG_REQUEST);
	hostif_sme_enqueue(priv, SME_RSN_ENABLED_REQUEST);
	hostif_sme_enqueue(priv, SME_MODE_SET_REQUEST);
	hostif_sme_enqueue(priv, SME_START_REQUEST);

	if(!wait_for_completion_interruptible_timeout(&priv->confirm_wait,5*HZ)){
		DPRINTK(1,"wait time out!! wireless parameter set\n");
	}

	if(priv->dev_state >= DEVICE_STATE_PREINIT){
		DPRINTK(1, "DEVICE READY!!\n");
		priv->dev_state = DEVICE_STATE_READY;
		reg_net = register_netdev (priv->net_dev);
		DPRINTK(3, "register_netdev=%d\n",reg_net);
	}
	else {
		DPRINTK(1, "dev_state=%d\n",priv->dev_state);
	}
}

static struct sdio_driver ks7010_sdio_driver = {
	.name		= "ks7910_sdio",
	.id_table	= if_sdio_ids,
	.probe		= ks7910_sdio_probe,
	.remove		= ks7910_sdio_remove,
};


extern int ks_wlan_net_start(struct net_device *dev);
extern int ks_wlan_net_stop(struct net_device *dev);

static int ks7910_sdio_probe(struct sdio_func *func, const struct sdio_device_id *device)
{
	ks_wlan_private *priv;
	struct ks_sdio_card *card;
	struct net_device *netdev;
	unsigned char rw_data;
	int i=0, ret;

	DPRINTK(5, "ks7910_sdio_probe()\n");

	priv = NULL;
	netdev=NULL;


	/* initilize ks_sdio_card */
	card = kzalloc(sizeof(struct ks_sdio_card), GFP_KERNEL);
	if (!card)
		return -ENOMEM;

	card->func  = func;
	card->model = 0x10;
	spin_lock_init(&card->lock);

	/* select model */
	for (i = 0;i < ARRAY_SIZE(ks_sdio_models);i++) {
		if (card->model == ks_sdio_models[i].model)
			break;
	}

	if (i == ARRAY_SIZE(ks_sdio_models)) {
		DPRINTK(5, "unkown card model 0x%x\n", card->model);
		goto error;
	}

	card->firmware = ks_sdio_models[i].firmware;


	/*** Initialize  SDIO ***/
	sdio_claim_host(func);

	/* bus setting  */
	/* Issue config request to override clock rate */

	/* function blocksize set */
	ret = sdio_set_block_size(func, KS7010_IO_BLOCK_SIZE);
	DPRINTK(5, "multi_block=%d sdio_set_block_size()=%d %d\n", func->card->cccr.multi_block, func->cur_blksize,  ret);

	/* Allocate the slot current */

	/* function enable */
	ret = sdio_enable_func(func);
	DPRINTK(5, "sdio_enable_func() %d\n", ret);
	if (ret)
		goto error_free_card;

	/* interrupt disable */
	sdio_writeb(func, 0, INT_ENABLE,  &ret);
	if (ret)
		goto error_free_card;
	sdio_writeb(func, 0xff, INT_PENDING,  &ret);
	if (ret)
		goto error_disable_func;

	/* setup interrupt handler */
	ret = sdio_claim_irq(func, ks_sdio_interrupt);
	if (ret)
		goto error_disable_func;

	sdio_release_host(func);

	sdio_set_drvdata(func, card);

	DPRINTK(5, "class = 0x%X, vendor = 0x%X, "
		"device = 0x%X\n",
		func->class, func->vendor, func->device);


	/* private memory allocate */
	netdev = alloc_etherdev(sizeof(*priv));
	if (netdev == NULL) {
		printk (KERN_ERR "ks79xx : Unable to alloc new net device\n");
		goto error_release_irq;
	}
	if (dev_alloc_name(netdev, netdev->name) < 0) {
		printk (KERN_ERR "ks79xx :  Couldn't get name!\n");
		goto error_free_netdev;
	}

	priv = netdev_priv(netdev);

	card->priv = priv;
	SET_NETDEV_DEV(netdev, &card->func->dev);	/* for create sysfs symlinks */

	/* private memory initialize */
	priv->ks_wlan_hw.sdio_card = card;
	init_completion(&priv->ks_wlan_hw.ks7010_sdio_wait);
	priv->ks_wlan_hw.read_buf = NULL;
	priv->ks_wlan_hw.read_buf = kmalloc(RX_DATA_SIZE, GFP_KERNEL);
	if(!priv->ks_wlan_hw.read_buf){
		goto error_free_netdev;
	}
	priv->dev_state = DEVICE_STATE_PREBOOT;
	priv->net_dev = netdev;
	priv->firmware_version[0] = '\0';
	priv->version_size = 0;
	priv->last_doze = jiffies;	/* set current jiffies */
	priv->last_wakeup = jiffies;
	memset(&priv->nstats, 0, sizeof(priv->nstats));
	memset(&priv->wstats, 0, sizeof(priv->wstats));

	/* sleep mode */
	atomic_set(&priv->sleepstatus.doze_request,0);
	atomic_set(&priv->sleepstatus.wakeup_request,0);
	atomic_set(&priv->sleepstatus.wakeup_request,0);

	trx_device_init(priv);
	hostif_init(priv);
        ks_wlan_net_start(netdev);

	/* Read config file */
	ret = ks_wlan_read_config_file(priv);
	if (ret) {
		printk(KERN_ERR "ks79xx: read configuration file failed !! retern code = %d\n", ret);
		goto error_free_read_buf;
	}

	/* Upload firmware */
	ret = ks79xx_upload_firmware(priv, card); /* firmware load */
	if(ret){
		printk(KERN_ERR "ks79xx: firmware load failed !! retern code = %d\n", ret);
		goto error_free_read_buf;
	}

	/* interrupt setting */
	/* clear Interrupt status write (ARMtoSD_InterruptPending FN1:00_0024) */
	rw_data = 0xff;
	sdio_claim_host(func);
	ret = ks7010_sdio_write(priv, INT_PENDING, &rw_data, sizeof(rw_data));
	sdio_release_host(func);
	if(ret){
		DPRINTK(1, " error : INT_PENDING=%02X\n", rw_data);
	}
	DPRINTK(4, " clear Interrupt : INT_PENDING=%02X\n", rw_data);


	/* enable ks7010sdio interrupt (INT_GCR_B|INT_READ_STATUS|INT_WRITE_STATUS) */
	rw_data = (INT_GCR_B|INT_READ_STATUS|INT_WRITE_STATUS);
	sdio_claim_host(func);
	ret = ks7010_sdio_write(priv, INT_ENABLE, &rw_data, sizeof(rw_data));
	sdio_release_host(func);
	if(ret){
		DPRINTK(1, " error : INT_ENABLE=%02X\n", rw_data);
	}
	DPRINTK(4, " enable Interrupt : INT_ENABLE=%02X\n", rw_data);
	priv->dev_state = DEVICE_STATE_BOOT;

	priv->ks_wlan_hw.ks7010sdio_wq = create_workqueue("ks7010sdio_wq");
	if(!priv->ks_wlan_hw.ks7010sdio_wq){
		DPRINTK(1, "create_workqueue failed !!\n");
		goto error_free_read_buf;
	}

	priv->ks_wlan_hw.ks7010sdio_init = create_singlethread_workqueue("ks7010sdio_init");
	if(!priv->ks_wlan_hw.ks7010sdio_init){
		DPRINTK(1, "create_workqueue failed !!\n");
		goto error_free_sdio_wq;
	}

	INIT_WORK(&priv->ks_wlan_hw.init_task, card_init_task);
	INIT_DELAYED_WORK(&priv->ks_wlan_hw.rw_wq, ks7010_rw_function);

	queue_work(priv->ks_wlan_hw.ks7010sdio_init, &priv->ks_wlan_hw.init_task);

	return 0;

error_free_sdio_wq:
	flush_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);
	destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);
	priv->ks_wlan_hw.ks7010sdio_wq = NULL;
error_free_read_buf:
	kfree(priv->ks_wlan_hw.read_buf);
	priv->ks_wlan_hw.read_buf = NULL;
error_free_netdev:
	free_netdev(priv->net_dev);
	card->priv = NULL;
error_release_irq:
	sdio_claim_host(func);
	sdio_release_irq(func);
error_disable_func:
	sdio_disable_func(func);
error_free_card:
	sdio_release_host(func);
	sdio_set_drvdata(func, NULL);
	kfree(card);
error:
	return -ENODEV;
}

static void ks7910_sdio_remove(struct sdio_func *func)
{
	int ret;
	struct ks_sdio_card *card;
	struct ks_wlan_private *priv;
	struct net_device *netdev;
	DPRINTK(1, "ks7910_sdio_remove()\n");

	card = sdio_get_drvdata(func);

	if(card == NULL)
		return;

	DPRINTK(1, "priv = card->priv\n");
	priv = card->priv;
	netdev = priv->net_dev;
	if(priv){
		ks_wlan_net_stop(netdev);
		DPRINTK(1, "ks_wlan_net_stop\n");

		/* interrupt disable */
		sdio_claim_host(func);
		sdio_writeb(func, 0, INT_ENABLE,  &ret);
		sdio_writeb(func, 0xff, INT_PENDING,  &ret);
		sdio_release_host(func);
		DPRINTK(1, "interrupt disable\n");

		/* send stop request to MAC */
		{
			struct hostif_stop_request_t *pp;
			pp = (struct hostif_stop_request_t *)kzalloc(hif_align_size(sizeof(*pp)), GFP_KERNEL );
			if (pp==NULL) {
				DPRINTK(3,"allocate memory failed..\n");
				return; /* to do goto ni suru*/
			}
			pp->header.size	= cpu_to_le16((uint16_t)(sizeof(*pp)-sizeof(pp->header.size)));
			pp->header.event = cpu_to_le16((uint16_t)HIF_STOP_REQ);

			sdio_claim_host(func);
			write_to_device(priv, (unsigned char *) pp, hif_align_size(sizeof(*pp)));
			sdio_release_host(func);
			kfree(pp);
		}
		DPRINTK(1, "STOP Req\n");

		if(priv->ks_wlan_hw.ks7010sdio_wq){
			flush_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);
			destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);
		}
		DPRINTK(1, "destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_wq);\n");

		if(priv->ks_wlan_hw.ks7010sdio_init){
			flush_workqueue(priv->ks_wlan_hw.ks7010sdio_init);
			destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_init);
		}
		DPRINTK(1, "destroy_workqueue(priv->ks_wlan_hw.ks7010sdio_init);\n");

		hostif_exit(priv);
		DPRINTK(1, "hostif_exit\n");

		if(!reg_net)
			unregister_netdev(netdev);
		DPRINTK(1, "unregister_netdev\n");

		trx_device_exit(priv);
		if(priv->ks_wlan_hw.read_buf){
			kfree(priv->ks_wlan_hw.read_buf);
		}
		free_netdev(priv->net_dev);
		card->priv = NULL;
	}

	sdio_claim_host(func);
	sdio_release_irq(func);
	DPRINTK(1, "sdio_release_irq()\n");
	sdio_disable_func(func);
	DPRINTK(1, "sdio_disable_func()\n");
	sdio_release_host(func);

	sdio_set_drvdata(func, NULL);

	kfree(card);
	DPRINTK(1, "kfree()\n");


	DPRINTK(5," Bye !!\n");
	return;
}

static int __init ks7010_sdio_init( void )
{
	int status;
	printk(KERN_INFO "ks7010_sdio : %s %s\n" ,__DATE__,__TIME__);

	/* register with bus driver core */
	status = sdio_register_driver(&ks7010_sdio_driver);
	if(status != 0){
		DPRINTK(1,"ks79xx_sdio : failed to register with bus driver, %d\n", status );
	}
	return status;
}

static void __exit ks7010_sdio_exit( void )
{
	DPRINTK(5," \n");
	sdio_unregister_driver(&ks7010_sdio_driver);
	return;
}

module_init(ks7010_sdio_init);
module_exit(ks7010_sdio_exit);

MODULE_AUTHOR("Qi-Hardware based on KeyStream driver");
MODULE_DESCRIPTION("Driver for KeyStream, KS7010 based SDIO cards. ");
#ifdef MODULE_LICENSE
MODULE_LICENSE("GPL");
#endif
MODULE_SUPPORTED_DEVICE("KS7910");
