/* SPDX-License-Identifier: GPL-2.0 */
#include <linux/version.h>
#include "bus_common.h"
#include "sdiohal.h"

void sdiohal_print_list_data(int channel, struct sdiohal_list_t *data_list,
			     const char *func, int loglevel)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct mbuf_t *node;
	int i;
	unsigned short print_len;
	char print_str[64];

	if (!data_list || !data_list->mbuf_head) {
		sdiohal_err("%s, data_list:%p,data_list->mbuf_head:%p",
			    __func__, data_list, data_list->mbuf_head);
		WARN_ON(1);
		return;
	}

	sprintf(print_str, "%s list: ", func);
	node = data_list->mbuf_head;
	for (i = 0; i < data_list->node_num; i++, node = node->next) {
		if (!node)
			break;
		print_len = node->len + SDIO_PUB_HEADER_SIZE;
		if ((channel == p_data->printlog_txchn) ||
		    (channel == p_data->printlog_rxchn)) {
			print_hex_dump(KERN_WARNING, print_str,
				       DUMP_PREFIX_NONE, 16, 1, node->buf,
				       (print_len < SDIOHAL_PRINTF_LEN ?
				       print_len : SDIOHAL_PRINTF_LEN), true);
		} else {
			sdiohal_pr_data(KERN_WARNING, print_str,
					DUMP_PREFIX_NONE, 16, 1, node->buf,
					(print_len < SDIOHAL_PRINTF_LEN ?
					print_len : SDIOHAL_PRINTF_LEN), true,
					loglevel);
		}
	}
}

void sdiohal_print_mbuf_data(int channel, struct mbuf_t *head,
			     struct mbuf_t *tail, int num, const char *func,
			     int loglevel)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct mbuf_t *node;
	int i;
	unsigned short print_len;
	char print_str[64];

	if (!head) {
		WARN_ON(1);
		return;
	}

	sprintf(print_str, "%s mbuf: ", func);

	node = head;
	for (i = 0; i < num; i++, node = node->next) {
		if (!node)
			break;
		print_len = node->len + SDIO_PUB_HEADER_SIZE;
		if ((channel == p_data->printlog_txchn) ||
		    (channel == p_data->printlog_rxchn)) {
			print_hex_dump(KERN_WARNING, print_str,
				       DUMP_PREFIX_NONE, 16, 1, node->buf,
				       (print_len < SDIOHAL_PRINTF_LEN ?
				       print_len : SDIOHAL_PRINTF_LEN), true);
		} else {
			sdiohal_pr_data(KERN_WARNING, print_str,
					DUMP_PREFIX_NONE, 16, 1, node->buf,
					(print_len < SDIOHAL_PRINTF_LEN ?
					print_len : SDIOHAL_PRINTF_LEN), true,
					loglevel);
		}
	}
}

void sdiohal_list_check(struct sdiohal_list_t *data_list,
			const char *func, bool dir)
{
	struct mbuf_t *node;
	int i;

	if (!data_list) {
		WARN_ON(1);
		return;
	}

	sdiohal_pr_list(SDIOHAL_LIST_LEVEL,
			"%s dir:%s data_list:%p node_num:%d,\n",
			func, dir ? "tx" : "rx", data_list,
			data_list->node_num);
	node = data_list->mbuf_head;
	for (i = 0; i < data_list->node_num; i++, node = node->next) {
		WARN_ON(!node);
		sdiohal_pr_list(SDIOHAL_LIST_LEVEL, "%s node:%p buf:%p\n",
				func, node, node->buf);
	}

	if (node) {
		sdiohal_err("%s node:%p buf:%p\n", func, node, node->buf);
		WARN_ON(1);
	}
}

void sdiohal_mbuf_list_check(int channel, struct mbuf_t *head,
			     struct mbuf_t *tail, int num,
			     const char *func, bool dir, int loglevel)
{
	struct mbuf_t *node;
	int i;

	if (!head) {
		WARN_ON(1);
		return;
	}

	sdiohal_pr_list(loglevel, "%s dir:%s chn:%d head:%p tail:%p num:%d\n",
			func, dir ? "tx" : "rx", channel, head, tail, num);
	node = head;
	for (i = 0; i < num; i++, node = node->next) {
		WARN_ON(!node);
		sdiohal_pr_list(SDIOHAL_LIST_LEVEL, "%s node:%p buf:%p\n",
				func, node, node->buf);
	}

	if (node) {
		sdiohal_err("%s node:%p buf:%p\n", func, node, node->buf);
		WARN_ON(1);
	}
}

/* for list manger */
void sdiohal_atomic_add(int count, atomic_t *value)
{
	atomic_add(count, value);
}

void sdiohal_atomic_sub(int count, atomic_t *value)
{
	if (atomic_read(value) == 0)
		return;

	atomic_sub(count, value);
}

/* seam for thread */
void sdiohal_tx_down(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	/* wait_for_completion may cause hung_task_timeout_secs
	 * with message of task blocked for more than 120 seconds.
	 */
	wait_for_completion_interruptible(&p_data->tx_completed);
}

void sdiohal_tx_up(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	complete(&p_data->tx_completed);
}

void sdiohal_rx_down(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	/* wait_for_completion may cause hung_task_timeout_secs
	 * with message of task blocked for more than 120 seconds.
	 */
	wait_for_completion_interruptible(&p_data->rx_completed);
}

void sdiohal_rx_up(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	complete(&p_data->rx_completed);
}

void sdiohal_completion_init(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	init_completion(&p_data->tx_completed);
	init_completion(&p_data->rx_completed);
	init_completion(&p_data->scan_done);
}

void sdiohal_lock_tx_ws(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	if (atomic_read(&p_data->flag_suspending))
		return;

	sdiohal_atomic_add(1, &p_data->tx_wake_flag);
	if (atomic_read(&p_data->tx_wake_flag) > 1)
		return;
	if(sprdwcn_bus_get_wl_wake_host_en() == WL_WAKE_HOST)
		__pm_stay_awake(p_data->tx_ws);
}

void sdiohal_unlock_tx_ws(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	sdiohal_atomic_sub(1, &p_data->tx_wake_flag);
	if (atomic_read(&p_data->tx_wake_flag))
		return;
	if(sprdwcn_bus_get_wl_wake_host_en() == WL_WAKE_HOST)
		__pm_relax(p_data->tx_ws);
}

void sdiohal_lock_rx_ws(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	if (atomic_read(&p_data->flag_suspending) ||
		atomic_read(&p_data->rx_wake_flag))
		return;

	atomic_set(&p_data->rx_wake_flag, 1);

	if(sprdwcn_bus_get_wl_wake_host_en() == WL_WAKE_HOST)
		__pm_stay_awake(p_data->rx_ws);
}

void sdiohal_unlock_rx_ws(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	if (!atomic_read(&p_data->rx_wake_flag))
		return;

	atomic_set(&p_data->rx_wake_flag, 0);

	if(sprdwcn_bus_get_wl_wake_host_en() == WL_WAKE_HOST)
		__pm_relax(p_data->rx_ws);
}

void sdiohal_lock_scan_ws(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	__pm_stay_awake(p_data->scan_ws);
}

void sdiohal_unlock_scan_ws(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	__pm_relax(p_data->scan_ws);
}

void sdiohal_wakelock_init(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	/*wakeup_source pointer*/
	p_data->tx_ws = wakeup_source_create("sdiohal_tx_wakelock");
	wakeup_source_add(p_data->tx_ws);
	p_data->rx_ws = wakeup_source_create("sdiohal_rx_wakelock");
	wakeup_source_add(p_data->rx_ws);
	p_data->scan_ws = wakeup_source_create("sdiohal_scan_wakelock");
	wakeup_source_add(p_data->scan_ws);
}

void sdiohal_wakelock_deinit(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	/*wakeup_source pointer*/
	wakeup_source_remove(p_data->tx_ws);
	wakeup_source_destroy(p_data->tx_ws);
	wakeup_source_remove(p_data->rx_ws);
	wakeup_source_destroy(p_data->rx_ws);
	wakeup_source_remove(p_data->scan_ws);
	wakeup_source_destroy(p_data->scan_ws);
}

/* for callback */
void sdiohal_callback_lock(struct mutex *callback_mutex)
{
	mutex_lock(callback_mutex);
}

void sdiohal_callback_unlock(struct mutex *callback_mutex)
{
	mutex_unlock(callback_mutex);
}

void sdiohal_callback_lock_init(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct mutex *chn_callback = p_data->callback_lock;
	int channel;

	for (channel = 0; channel < SDIO_CHANNEL_NUM; channel++)
		mutex_init(&chn_callback[channel]);
}

void sdiohal_callback_lock_deinit(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct mutex *chn_callback = p_data->callback_lock;
	int channel;

	for (channel = 0; channel < SDIO_CHANNEL_NUM; channel++)
		mutex_destroy(&chn_callback[channel]);
}

void sdiohal_spinlock_init(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	spin_lock_init(&p_data->tx_spinlock);
	spin_lock_init(&p_data->rx_spinlock);
}
/* for sleep */
#if 0
void sdiohal_cp_tx_sleep(enum slp_subsys subsys)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	sdiohal_debug("%s subsys:%d count:%d\n",
		      __func__, subsys,
		      atomic_read(&p_data->tx_wake_cp_count[subsys]));

	sdiohal_atomic_sub(1, &p_data->tx_wake_cp_count[subsys]);
	if (atomic_read(&p_data->tx_wake_cp_count[subsys]))
		return;

	slp_mgr_drv_sleep(subsys, true);
}

void sdiohal_cp_tx_wakeup(enum slp_subsys subsys)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	sdiohal_debug("%s subsys:%d count:%d\n",
		      __func__, subsys,
		      atomic_read(&p_data->tx_wake_cp_count[subsys]));

	sdiohal_atomic_add(1, &p_data->tx_wake_cp_count[subsys]);
	slp_mgr_drv_sleep(subsys, false);
	slp_mgr_wakeup(subsys);
}

void sdiohal_cp_rx_sleep(enum slp_subsys subsys)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	sdiohal_debug("%s subsys:%d count:%d\n",
		      __func__, subsys,
		      atomic_read(&p_data->rx_wake_cp_count[subsys]));

	sdiohal_atomic_sub(1, &p_data->rx_wake_cp_count[subsys]);
	if (atomic_read(&p_data->rx_wake_cp_count[subsys]))
		return;

	slp_mgr_drv_sleep(subsys, true);
}

void sdiohal_cp_rx_wakeup(enum slp_subsys subsys)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	sdiohal_debug("%s subsys:%d count:%d\n",
		      __func__, subsys,
		      atomic_read(&p_data->rx_wake_cp_count[subsys]));

	sdiohal_atomic_add(1, &p_data->rx_wake_cp_count[subsys]);
	slp_mgr_drv_sleep(subsys, false);
	slp_mgr_wakeup(subsys);
}
#endif

void sdiohal_resume_check(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	unsigned int cnt = 0;

	while ((!atomic_read(&p_data->flag_resume)) && (cnt++ < 5000)) {
		if (cnt == 0) {
			sdiohal_err("wait sdio resume %s\n", __func__);
			dump_stack();
		}
		usleep_range(4000, 6000);
	}
}

void sdiohal_resume_wait(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	unsigned int cnt = 0;

	while ((!atomic_read(&p_data->flag_resume)) && (cnt++ < 5000)) {
		sdiohal_err("sleep 5ms wait for sdio resume, %d\n", cnt);
		usleep_range(4000, 6000);
	}
}

void sdiohal_op_enter(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	mutex_lock(&p_data->xmit_lock);
}

void sdiohal_op_leave(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	mutex_unlock(&p_data->xmit_lock);
}

void sdiohal_sdma_enter(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	mutex_lock(&p_data->xmit_sdma);
}

void sdiohal_sdma_leave(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	mutex_unlock(&p_data->xmit_sdma);
}

void sdiohal_mutex_init(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	mutex_init(&p_data->xmit_lock);
	mutex_init(&p_data->xmit_sdma);
}

void sdiohal_mutex_deinit(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	mutex_destroy(&p_data->xmit_lock);
	mutex_destroy(&p_data->xmit_sdma);
}

void sdiohal_sleep_flag_init(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	atomic_set(&p_data->flag_resume, 1);
}

void sdiohal_channel_to_hwtype(int inout, int channel,
	unsigned int *type, unsigned int *subtype)
{
	if (!inout)
		channel -= SDIO_CHN_TX_NUM;
	*type = 0;
	*subtype = channel;

	sdiohal_debug("%s type:%d, subtype:%d\n", __func__, *type, *subtype);
}

int sdiohal_hwtype_to_channel(int inout, unsigned int type,
	unsigned int subtype)
{
	int channel = -1;

	if (inout)
		channel = subtype;
	else
		channel = subtype + SDIO_CHN_TX_NUM;

	sdiohal_debug("%s channel:%d,inout:%d\n", __func__, channel, inout);

	return channel;
}

bool sdiohal_is_tx_list_empty(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	if (atomic_read(&p_data->tx_mbuf_num) != 0)
		return false;

	return true;
}

int sdiohal_tx_packer(struct sdiohal_sendbuf_t *send_buf,
		      struct sdiohal_list_t *data_list,
		      struct mbuf_t *mbuf_node)
{
	if ((!send_buf) || (!data_list) || (!mbuf_node))
		return -EINVAL;

	memcpy(send_buf->buf + send_buf->used_len,
	       mbuf_node->buf, mbuf_node->len + sizeof(struct sdio_puh_t));

	send_buf->used_len += sizeof(struct sdio_puh_t) +
		SDIOHAL_ALIGN_4BYTE(mbuf_node->len);

	return 0;
}

int sdiohal_tx_set_eof(struct sdiohal_sendbuf_t *send_buf,
	unsigned char *eof_buf)
{
	if ((!send_buf) || (!eof_buf))
		return -EINVAL;

	memcpy((void *)(send_buf->buf + send_buf->used_len),
	       (void *)eof_buf, sizeof(struct sdio_puh_t));
	send_buf->used_len += sizeof(struct sdio_puh_t);

	return 0;
}

static int sdiohal_tx_fill_puh(int channel, struct mbuf_t *head,
			       struct mbuf_t *tail, int num)
{
	struct sdio_puh_t *puh = NULL;
	struct mbuf_t *mbuf_node;
	unsigned int type = 0, subtype = 0;
	int inout = 1;
	int i;

	sdiohal_channel_to_hwtype(inout, channel, &type, &subtype);

	mbuf_node = head;
	for (i = 0; i < num; i++, mbuf_node = mbuf_node->next) {
		if (!mbuf_node) {
			sdiohal_err("%s tx fill puh, mbuf ptr error:%p\n",
				    __func__, mbuf_node);

			return -EFAULT;
		}
		puh = (struct sdio_puh_t *)mbuf_node->buf;
		puh->type = type;
		puh->subtype = subtype;
		puh->len = mbuf_node->len;
		puh->eof = 0;
		puh->pad = 0;
	}

	return 0;
}

void sdiohal_tx_list_enq(int channel, struct mbuf_t *head,
			 struct mbuf_t *tail, int num)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	sdiohal_tx_fill_puh(channel, head, tail, num);

	spin_lock_bh(&p_data->tx_spinlock);
	if (atomic_read(&p_data->tx_mbuf_num) == 0)
		p_data->tx_list_head.mbuf_head = head;
	else
		p_data->tx_list_head.mbuf_tail->next = head;
	p_data->tx_list_head.mbuf_tail = tail;
	p_data->tx_list_head.mbuf_tail->next = NULL;
	p_data->tx_list_head.node_num += num;
	sdiohal_atomic_add(num, &p_data->tx_mbuf_num);
	spin_unlock_bh(&p_data->tx_spinlock);
}

void sdiohal_tx_find_data_list(struct sdiohal_list_t *data_list)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct mbuf_t *mbuf_node;
	int num, i;

	spin_lock_bh(&p_data->tx_spinlock);
	num = p_data->tx_list_head.node_num;
	if (num > MAX_CHAIN_NODE_NUM)
		num = MAX_CHAIN_NODE_NUM;

	mbuf_node = p_data->tx_list_head.mbuf_head;
	for (i = 1; i < num; i++)
		mbuf_node = mbuf_node->next;

	data_list->mbuf_head = p_data->tx_list_head.mbuf_head;
	data_list->mbuf_tail = mbuf_node;
	data_list->node_num = num;

	p_data->tx_list_head.node_num -= num;
	sdiohal_atomic_sub(num, &p_data->tx_mbuf_num);
	if (atomic_read(&p_data->tx_mbuf_num) == 0) {
		p_data->tx_list_head.mbuf_head = NULL;
		p_data->tx_list_head.mbuf_tail = NULL;
	} else
		p_data->tx_list_head.mbuf_head = mbuf_node->next;
	data_list->mbuf_tail->next = NULL;
	spin_unlock_bh(&p_data->tx_spinlock);
	sdiohal_list_check(data_list, __func__, SDIOHAL_WRITE);
}

static int sdiohal_tx_pop_assignment(struct sdiohal_list_t *data_list)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct sdiohal_list_t *tx_list = NULL;
	struct sdio_puh_t *puh = NULL;
	struct mbuf_t *mbuf_node, *mbuf_next;
	int inout = 1, channel = 0;
	unsigned int node_num, i;

	sdiohal_list_check(data_list, __func__, SDIOHAL_WRITE);
	node_num = data_list->node_num;
	mbuf_next = data_list->mbuf_head;
	for (i = 0; i < node_num; i++) {
		mbuf_node = mbuf_next;
		if (!mbuf_node) {
			sdiohal_err("%s tx pop mbuf ptr error:%p\n",
				    __func__, mbuf_node);

			return -EFAULT;
		}
		mbuf_next = mbuf_next->next;
		puh = (struct sdio_puh_t *)mbuf_node->buf;
		channel = sdiohal_hwtype_to_channel(inout,
			puh->type, puh->subtype);
		if (channel >= SDIO_CHN_TX_NUM) {
			sdiohal_err("%s tx pop channel error:%d\n",
				    __func__, channel);
			continue;
		}

		tx_list = p_data->list_tx[channel];
		mbuf_node->next = NULL;
		if (tx_list->node_num == 0)
			tx_list->mbuf_head = mbuf_node;
		else
			tx_list->mbuf_tail->next = mbuf_node;

		tx_list->mbuf_tail = mbuf_node;
		tx_list->type = puh->type;
		tx_list->subtype = puh->subtype;
		tx_list->node_num++;
	}

	return 0;
}

int sdiohal_tx_list_denq(struct sdiohal_list_t *data_list)
{
	struct list_head *list_head, *pos;
	struct sdiohal_list_t *tx_list;
	int channel, inout = 1;
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct mutex *chn_callback = p_data->callback_lock;
	struct mchn_ops_t *sdiohal_ops;

	struct timespec tm_begin, tm_end;
	static long time_total_ns;
	static int times_count;

	sdiohal_tx_pop_assignment(data_list);

	list_head = &p_data->list_tx[0]->head;
	for (pos = list_head; pos->next != list_head; pos = pos->next) {
		tx_list = (struct sdiohal_list_t *)list_entry(pos,
				struct sdiohal_list_t, head);
		if (tx_list->node_num == 0)
			continue;

		sdiohal_list_check(tx_list, __func__, SDIOHAL_WRITE);
		channel = sdiohal_hwtype_to_channel(inout, tx_list->type,
						    tx_list->subtype);
		sdiohal_print_list_data(channel, tx_list, __func__,
					SDIOHAL_NORMAL_LEVEL);
		if (channel >= SDIO_CHN_TX_NUM) {
			sdiohal_err("%s tx pop channel error:%d\n",
				    __func__, channel);
			continue;
		}

		getnstimeofday(&tm_begin);

		sdiohal_callback_lock(&chn_callback[channel]);
		sdiohal_ops = chn_ops(channel);
		sdiohal_mbuf_list_check(channel, tx_list->mbuf_head,
					tx_list->mbuf_tail,
					tx_list->node_num,
					__func__, SDIOHAL_WRITE,
					SDIOHAL_NORMAL_LEVEL);

#if SDIO_DUMP_CHANNEL_DATA
		if (channel == SDIO_DUMP_TX_CHANNEL_NUM) {
			p_data->chntx_denq_old.time =
				p_data->chntx_denq_new.time;
			memcpy(p_data->chntx_denq_old.data_bk,
			       p_data->chntx_denq_new.data_bk,
			       SDIOHAL_PRINTF_LEN);
			memcpy(p_data->chntx_denq_new.data_bk,
			       tx_list->mbuf_tail->buf,
			       SDIOHAL_PRINTF_LEN);
			p_data->chntx_denq_new.time =
				(unsigned int)ktime_to_ms(ktime_get());
		}
#endif

		if (sdiohal_ops && sdiohal_ops->pop_link) {
			sdiohal_ops->pop_link(channel, tx_list->mbuf_head,
					      tx_list->mbuf_tail,
					      tx_list->node_num);
		} else
			sdiohal_err("%s no tx ops channel:%d\n",
				    __func__, channel);

		tx_list->node_num = 0;
		sdiohal_callback_unlock(&chn_callback[channel]);

		getnstimeofday(&tm_end);
		time_total_ns += timespec_to_ns(&tm_end)
			- timespec_to_ns(&tm_begin);
		times_count++;
		if (!(times_count % PERFORMANCE_COUNT)) {
			sdiohal_pr_perf("tx pop callback,avg time:%ld\n",
					(time_total_ns / PERFORMANCE_COUNT));
			time_total_ns = 0;
			times_count = 0;
		}
	}

	return 0;
}

int sdiohal_rx_list_dispatch(void)
{
	struct list_head *list_head, *pos;
	struct sdiohal_list_t *rx_list;
	int inout = 0, channel;
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct mutex *chn_callback = p_data->callback_lock;
	struct mchn_ops_t *sdiohal_ops;

	struct timespec tm_begin, tm_end;
	static long time_total_ns;
	static int times_count;

	if (unlikely(p_data->flag_init != true))
		return -ENODEV;

	list_head = &p_data->list_rx[0]->head;
	for (pos = list_head; pos->next != list_head; pos = pos->next) {
		rx_list = (struct sdiohal_list_t *)list_entry(pos,
				struct sdiohal_list_t, head);
		if (rx_list->node_num == 0)
			continue;

		sdiohal_list_check(rx_list, __func__, SDIOHAL_READ);
		channel = sdiohal_hwtype_to_channel(inout, rx_list->type,
						    rx_list->subtype);
		sdiohal_print_list_data(channel, rx_list, __func__,
					SDIOHAL_NORMAL_LEVEL);
		if (channel >= SDIO_CHANNEL_NUM) {
			sdiohal_err("%s rx pop channel error:%d\n",
				    __func__, channel);
			continue;
		}

		getnstimeofday(&tm_begin);

		sdiohal_callback_lock(&chn_callback[channel]);
		sdiohal_ops = chn_ops(channel);
		sdiohal_mbuf_list_check(channel, rx_list->mbuf_head,
					rx_list->mbuf_tail,
					rx_list->node_num,
					__func__, SDIOHAL_READ,
					SDIOHAL_NORMAL_LEVEL);

#if SDIO_DUMP_CHANNEL_DATA
		if ((channel == SDIO_DUMP_RX_CHANNEL_NUM) &&
		    (rx_list->mbuf_tail->buf[SDIO_PUB_HEADER_SIZE + 1] <
		     SDIO_DUMP_RX_WIFI_EVENT_MIN)) {
			p_data->chnrx_dispatch_old.time =
				p_data->chnrx_dispatch_new.time;
			memcpy(p_data->chnrx_dispatch_old.data_bk,
			       p_data->chnrx_dispatch_new.data_bk,
			       SDIOHAL_PRINTF_LEN);
			memcpy(p_data->chnrx_dispatch_new.data_bk,
			       rx_list->mbuf_tail->buf,
			       SDIOHAL_PRINTF_LEN);
			p_data->chnrx_dispatch_new.time =
				(unsigned int)ktime_to_ms(ktime_get());
		}
#endif

		if (sdiohal_ops && sdiohal_ops->pop_link) {
			sdiohal_ops->pop_link(channel, rx_list->mbuf_head,
					      rx_list->mbuf_tail,
					      rx_list->node_num);
		} else {
			sdiohal_err("%s no rx ops channel:%d\n",
				    __func__, channel);
			sdiohal_rx_list_free(rx_list->mbuf_head,
					     rx_list->mbuf_tail,
					     rx_list->node_num);
		}
		rx_list->node_num = 0;
		sdiohal_callback_unlock(&chn_callback[channel]);

		getnstimeofday(&tm_end);
		time_total_ns += timespec_to_ns(&tm_end)
			- timespec_to_ns(&tm_begin);
		times_count++;
		if (!(times_count % PERFORMANCE_COUNT)) {
			sdiohal_pr_perf("rx pop callback,avg time:%ld\n",
					(time_total_ns / PERFORMANCE_COUNT));
			time_total_ns = 0;
			times_count = 0;
		}
	}

	return 0;
}

struct sdiohal_list_t *sdiohal_get_rx_channel_list(int channel)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	if (unlikely(p_data->flag_init != true))  {
		sdiohal_err("%s sdiohal not init\n", __func__);
		return NULL;
	}

	channel -= SDIO_CHN_TX_NUM;
	if (channel >= SDIO_CHN_RX_NUM) {
		sdiohal_err("%s rx error channel:%d\n", __func__, channel);
		return NULL;
	}

	return p_data->list_rx[channel];
}

int sdiohal_rx_list_free(struct mbuf_t *mbuf_head,
			 struct mbuf_t *mbuf_tail, int num)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	void *data = NULL;
	struct mbuf_t *mbuf_node;
	int i;

	mbuf_node = mbuf_head;
	for (i = 0; i < num; i++, mbuf_node = mbuf_node->next) {
		if (mbuf_node->buf) {
			data = mbuf_node->buf;
			sdiohal_debug("%s, before put page addr:%p,count:%d\n",
				__func__, virt_to_head_page(data),
#if KERNEL_VERSION(4, 7, 0) <= LINUX_VERSION_CODE
				atomic_read(
					&virt_to_head_page(data)->_refcount));
#else
				atomic_read(&virt_to_head_page(data)->_count));
#endif
			put_page(virt_to_head_page(data));
			/* After put_page, count will be subtracted 1. */
			sdiohal_debug("%s, after put page addr:%p,count:%d\n",
				__func__, virt_to_head_page(data),
#if KERNEL_VERSION(4, 7, 0) <= LINUX_VERSION_CODE
				atomic_read(
					&virt_to_head_page(data)->_refcount));
#else
				atomic_read(&virt_to_head_page(data)->_count));
#endif

			mbuf_node->buf = NULL;
		}
		mbuf_node->len = 0;
	}

	spin_lock_bh(&p_data->rx_spinlock);
	if (p_data->list_rx_buf.node_num == 0)
		p_data->list_rx_buf.mbuf_head = mbuf_head;
	else
		p_data->list_rx_buf.mbuf_tail->next = mbuf_head;
	p_data->list_rx_buf.mbuf_tail = mbuf_tail;
	p_data->list_rx_buf.node_num += num;
	spin_unlock_bh(&p_data->rx_spinlock);

	return 0;
}

/*
 * fragsz: size of frag need to alloc
 * gfp_mask: GFP mask
 * ignore_alloc_fail:
 *	If alloc_pages fail (size < fragsz), not put_page, fill alloc_size.
 *	For example:
 *	Need to alloc fragsz = 0x32000, but alloc 0x20000 mem actually.
 *	ignore_alloc_fail=1: alloc_size=0x20000;
 *	ignore_alloc_fail=0: put_page and return fail.
 * alloc_size: alloc mem size actually.
 */
static void *sdiohal_alloc_frag(unsigned int fragsz, gfp_t gfp_mask,
	unsigned char ignore_alloc_fail, unsigned int *alloc_size)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct sdiohal_frag_mg *frag_ctl;
	void *data = NULL;
	int order;
	unsigned long flags;

	if (ignore_alloc_fail)
		*alloc_size = fragsz;

	local_irq_save(flags);
	frag_ctl = &p_data->frag_ctl;
	if (unlikely(!frag_ctl->frag.page)) {
refill:
#if (BITS_PER_LONG > 32) || (PAGE_SIZE >= 65536)
		order = SDIOHAL_FRAG_PAGE_MAX_ORDER;
#else
		order = SDIOHAL_FRAG_PAGE_MAX_ORDER_32_BIT;
#endif
		/*GFP_KERNEL allow sleep, so not in interrupt; sdma changed,adma not*/
		if (gfp_mask & GFP_KERNEL)
			local_irq_restore(flags);
		for (; ;) {
			gfp_t gfp = gfp_mask;

			if (order)
				gfp |= __GFP_COMP;
			/* alloc_pages will initialize count to 1. */
			frag_ctl->frag.page = alloc_pages(gfp, order);
			if (likely(frag_ctl->frag.page))
				break;
			if (--order < 0) {
				if(gfp_mask & GFP_KERNEL)
					goto fail1;
				else
					goto fail;
			}
		}
		if (gfp_mask & GFP_KERNEL)
			local_irq_save(flags);
		frag_ctl->frag.size = PAGE_SIZE << order;
		if (frag_ctl->frag.size < fragsz) {
			sdiohal_info("BITS_PER_LONG=%d,PAGE_SIZE=%ld,order=%d\n",
				     BITS_PER_LONG, PAGE_SIZE, order);
			sdiohal_info("alloc 0x%x mem, need:0x%x\n",
				     frag_ctl->frag.size, fragsz);
			if (ignore_alloc_fail) {
				/* alloc fail, not put_page, fill frag size. */
				*alloc_size = frag_ctl->frag.size;
			} else {
				put_page(frag_ctl->frag.page);
				goto fail;
			}
		}

		/*
		 * Even if we own the page, we do not use atomic_set().
		 * This would break get_page_unless_zero() users.
		 */
		atomic_add(SDIOHAL_PAGECNT_MAX_BIAS - 1,
#if KERNEL_VERSION(4, 7, 0) <= LINUX_VERSION_CODE
			   &frag_ctl->frag.page->_refcount);
#else
			   &frag_ctl->frag.page->_count);
#endif
		frag_ctl->pagecnt_bias = SDIOHAL_PAGECNT_MAX_BIAS;
		frag_ctl->frag.offset = 0;
	}

	if (frag_ctl->frag.offset + fragsz > frag_ctl->frag.size) {
#if KERNEL_VERSION(4, 7, 0) <= LINUX_VERSION_CODE
		if (atomic_read(&frag_ctl->frag.page->_refcount) !=
			frag_ctl->pagecnt_bias)
#else
		if (atomic_read(&frag_ctl->frag.page->_count) !=
			frag_ctl->pagecnt_bias)
#endif
		{
			if (!atomic_sub_and_test(frag_ctl->pagecnt_bias,
#if KERNEL_VERSION(4, 7, 0) <= LINUX_VERSION_CODE
				&frag_ctl->frag.page->_refcount))
#else
				&frag_ctl->frag.page->_count))
#endif
				goto refill;
			/* OK, page count is 0, we can safely set it */
#if KERNEL_VERSION(4, 7, 0) <= LINUX_VERSION_CODE
			atomic_set(&frag_ctl->frag.page->_refcount,
				   SDIOHAL_PAGECNT_MAX_BIAS);
#else
			atomic_set(&frag_ctl->frag.page->_count,
				   SDIOHAL_PAGECNT_MAX_BIAS);
#endif
		} else {
			atomic_add(SDIOHAL_PAGECNT_MAX_BIAS -
				frag_ctl->pagecnt_bias,
#if KERNEL_VERSION(4, 7, 0) <= LINUX_VERSION_CODE
				&frag_ctl->frag.page->_refcount);
#else
				&frag_ctl->frag.page->_count);
#endif
		}
		if (ignore_alloc_fail && (frag_ctl->frag.size < fragsz))
		    *alloc_size = frag_ctl->frag.size;
		frag_ctl->pagecnt_bias = SDIOHAL_PAGECNT_MAX_BIAS;
		frag_ctl->frag.offset = 0;
	}

	data = page_address(frag_ctl->frag.page) + frag_ctl->frag.offset;
	if (ignore_alloc_fail && (frag_ctl->frag.size < fragsz))
		frag_ctl->frag.offset += *alloc_size;
	else
		frag_ctl->frag.offset += fragsz;
	if (p_data->adma_rx_enable)
		frag_ctl->pagecnt_bias--;

	local_irq_restore(flags);
	return data;
fail:
	local_irq_restore(flags);
fail1:
	sdiohal_err("alloc mem fail\n");
	return NULL;
}

/* mbuf node no data buf pointer */
struct sdiohal_list_t *sdiohal_get_rx_mbuf_node(int num)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct sdiohal_list_t *idle_list;
	struct mbuf_t *mbuf_head, *mbuf_tail;
	int i;

	if (num == 0) {
		sdiohal_err("num err:%d\n", num);
		goto err;
	}

	if (num > p_data->list_rx_buf.node_num) {
		sdiohal_err("no rx mbuf node, need num:%d, list node num:%d\n",
			    num, p_data->list_rx_buf.node_num);
		goto err;
	}

	idle_list = kzalloc(sizeof(struct sdiohal_list_t), GFP_KERNEL);
	if (!idle_list)
		goto err;

	spin_lock_bh(&p_data->rx_spinlock);
	mbuf_head = mbuf_tail = p_data->list_rx_buf.mbuf_head;
	for (i = 1; i < num; i++)
		mbuf_tail = mbuf_tail->next;

	p_data->list_rx_buf.node_num -= num;
	if (p_data->list_rx_buf.node_num == 0) {
		p_data->list_rx_buf.mbuf_head = NULL;
		p_data->list_rx_buf.mbuf_tail = NULL;
	} else
		p_data->list_rx_buf.mbuf_head = mbuf_tail->next;

	idle_list->mbuf_head = mbuf_head;
	idle_list->mbuf_tail = mbuf_tail;
	idle_list->mbuf_tail->next = NULL;
	idle_list->node_num = num;
	spin_unlock_bh(&p_data->rx_spinlock);

	return idle_list;

err:
	return NULL;
}

/* for adma,mbuf list had data buf pointer */
struct sdiohal_list_t *sdiohal_get_rx_mbuf_list(int num)
{
	struct sdiohal_list_t *idle_list;
	struct mbuf_t *mbuf_temp;
	int i;

	idle_list = sdiohal_get_rx_mbuf_node(num);
	if (!idle_list)
		goto err;

	mbuf_temp = idle_list->mbuf_head;
	for (i = 0; i < num; i++) {
		mbuf_temp->buf = sdiohal_alloc_frag(MAX_MBUF_SIZE,
#if KERNEL_VERSION(4, 14, 0) <= LINUX_VERSION_CODE
			GFP_ATOMIC,
#else
			GFP_ATOMIC | __GFP_COLD,
#endif
			0, NULL);
		if (!mbuf_temp->buf) {
			sdiohal_rx_list_free(idle_list->mbuf_head,
					     idle_list->mbuf_tail, num);
			kfree(idle_list);
			goto err;
		}
		WARN_ON(((unsigned long int)mbuf_temp->buf) % 64);
		mbuf_temp = mbuf_temp->next;
	}

	sdiohal_list_check(idle_list, __func__, SDIOHAL_READ);

	return idle_list;
err:
	return NULL;
}

/* for normal dma idle buf */
void *sdiohal_get_rx_free_buf(unsigned int *alloc_size, unsigned int read_len)
{
	void *p;
	unsigned int fragsz;

	fragsz = read_len;

/*
 * GFP_ATOMIC is not sleep forever, requirement is high;
 * GFP_KERNEL is nornal way, allow sleep;
 *__GFP_COLD
 */
	p = sdiohal_alloc_frag(fragsz, GFP_KERNEL, 1, alloc_size);

	WARN_ON(((unsigned long int)p) % 64);

	return p;
}

static int sdiohal_alloc_rx_mbuf_nodes(int num)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct mbuf_t *mbuf_node, *mbuf_temp = NULL;
	int i;

	for (i = 0; i < num; i++) {
		mbuf_node = kzalloc(sizeof(struct mbuf_t), GFP_KERNEL);
		if(!mbuf_node)
			return -ENOMEM;
		if (i == 0) {
			p_data->list_rx_buf.mbuf_head = mbuf_node;
			p_data->list_rx_buf.mbuf_tail = mbuf_node;
		} else
			mbuf_temp->next = mbuf_node;

		mbuf_temp = mbuf_node;
		p_data->list_rx_buf.node_num++;
	}
	mbuf_temp->next = NULL;
	p_data->list_rx_buf.mbuf_tail = mbuf_temp;

	return 0;
}

static void sdiohal_rx_buf_init(void)
{
	sdiohal_alloc_rx_mbuf_nodes(SDIOHAL_RX_NODE_NUM);
}

static int sdiohal_free_rx_mbuf_nodes(int num)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct mbuf_t *mbuf_node = NULL, *mbuf_temp = NULL;
	int i;

	mbuf_temp = p_data->list_rx_buf.mbuf_head;
	for (i = 0; i < num; i++) {
		if (mbuf_temp->next)
			mbuf_node = mbuf_temp->next;
		mbuf_temp->next = NULL;
		kfree(mbuf_temp);
		mbuf_temp = mbuf_node;
	}

	p_data->list_rx_buf.mbuf_head = NULL;
	p_data->list_rx_buf.mbuf_tail = NULL;
	p_data->list_rx_buf.node_num = 0;

	return 0;
}

static void sdiohal_rx_buf_deinit(void)
{
	sdiohal_free_rx_mbuf_nodes(SDIOHAL_RX_NODE_NUM);
}

int sdiohal_list_push(int channel, struct mbuf_t *head,
		      struct mbuf_t *tail, int num)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct timespec tm_begin, tm_end;
	static long time_total_ns;
	static int times_count;
	struct mbuf_t *mbuf_node;
	int i;

	getnstimeofday(&tm_begin);

	if (unlikely(p_data->flag_init != true))
		return -ENODEV;

	if (unlikely(p_data->card_dump_flag == true))
		return -ENODEV;

	sdiohal_mbuf_list_check(channel, head, tail, num, __func__,
				(channel < SDIO_CHN_TX_NUM ?
				SDIOHAL_WRITE : SDIOHAL_READ),
				(channel < SDIO_CHN_TX_NUM ?
				SDIOHAL_NORMAL_LEVEL :
				SDIOHAL_LIST_LEVEL));
	if ((channel < 0) || (channel >= SDIO_CHANNEL_NUM) ||
		(!head) || (!tail) || (num <= 0)) {
		sdiohal_err("%s Invalid argument\n", __func__);
		dump_stack();
		return -EINVAL;
	}

	mbuf_node = head;
	for (i = 0; i < num; i++, mbuf_node = mbuf_node->next) {
		if (!mbuf_node) {
			sdiohal_err("%s mbuf list error\n", __func__);
			dump_stack();
			return -EFAULT;
		}
	}

	if (channel < SDIO_CHN_TX_NUM) {
		if (!atomic_read(&p_data->flag_resume)) {
			sdiohal_err("%s chn=%d, in suspend, can't send data\n",
				    __func__, channel);
			return -EFAULT;
		}
		sdiohal_print_mbuf_data(channel, head, tail, num,
					__func__, SDIOHAL_DATA_LEVEL);

#if SDIO_DUMP_CHANNEL_DATA
		if (channel == SDIO_DUMP_TX_CHANNEL_NUM) {
			p_data->chntx_push_old.time =
				p_data->chntx_push_new.time;
			memcpy(p_data->chntx_push_old.data_bk,
			       p_data->chntx_push_new.data_bk,
			       SDIOHAL_PRINTF_LEN);
			memcpy(p_data->chntx_push_new.data_bk,
			       tail->buf,
			       SDIOHAL_PRINTF_LEN);
			p_data->chntx_push_new.time =
				(unsigned int)ktime_to_ms(ktime_get());
		}
#endif

		sdiohal_tx_list_enq(channel, head, tail, num);

		getnstimeofday(&tm_end);
		time_total_ns += timespec_to_ns(&tm_end)
			- timespec_to_ns(&tm_begin);
		times_count++;
		if (!(times_count % PERFORMANCE_COUNT)) {
			sdiohal_pr_perf("tx avg time:%ld\n",
					(time_total_ns / PERFORMANCE_COUNT));
			time_total_ns = 0;
			times_count = 0;
		}
		getnstimeofday(&p_data->tm_begin_sch);

		sdiohal_tx_up();
	} else
		sdiohal_rx_list_free(head, tail, num);

	return 0;
}

/* tx send (write) directly not through sdio tx thread and
 * not calling tx_pop callback when working in sdma mode.
 */
int sdiohal_list_direct_write(int channel, struct mbuf_t *head,
			      struct mbuf_t *tail, int num)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	struct sdiohal_list_t data_list;

	sdiohal_lock_tx_ws();
	sdiohal_resume_check();
	sdiohal_cp_tx_wakeup(PACKER_DT_TX);
	sdiohal_tx_fill_puh(channel, head, tail, num);

	data_list.mbuf_head = head;
	data_list.mbuf_tail = tail;
	data_list.node_num = num;
	data_list.mbuf_tail->next = NULL;

	if (p_data->adma_tx_enable)
		sdiohal_adma_pt_write(&data_list);
	else
		sdiohal_tx_data_list_send(&data_list, false);

	sdiohal_cp_tx_sleep(PACKER_DT_TX);
	sdiohal_unlock_tx_ws();

	return 0;
}

static int sdiohal_list_init(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	unsigned int channel = 0;

	for (channel = 0; channel < SDIO_TX_LIST_NUM; channel++) {
		p_data->list_tx[channel] =
			kzalloc(sizeof(struct sdiohal_list_t), GFP_KERNEL);
		if (!p_data->list_tx[channel])
			return -ENOMEM;

		if (channel == 0)
			INIT_LIST_HEAD(&p_data->list_tx[channel]->head);
		else
			list_add_tail(&p_data->list_tx[channel]->head,
				&p_data->list_tx[0]->head);
		p_data->list_tx[channel]->node_num = 0;
		p_data->list_tx[channel]->mbuf_head = NULL;
	}

	for (channel = 0; channel < SDIO_RX_LIST_NUM; channel++) {
		p_data->list_rx[channel] =
			kzalloc(sizeof(struct sdiohal_list_t), GFP_KERNEL);
		if (!p_data->list_rx[channel])
			return -ENOMEM;

		if (channel == 0)
			INIT_LIST_HEAD(&p_data->list_rx[channel]->head);
		else
			list_add_tail(&p_data->list_rx[channel]->head,
				&p_data->list_rx[0]->head);
		p_data->list_rx[channel]->node_num = 0;
		p_data->list_rx[channel]->mbuf_head = NULL;
	}

	return 0;
}

static void sdiohal_list_deinit(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();
	unsigned int channel = 0;
	struct list_head *pos, *next;

	for (channel = 0; channel < SDIO_TX_LIST_NUM; channel++) {
		list_for_each_safe(pos, next, &p_data->list_tx[channel]->head) {
			list_del_init(pos);
		}
		kfree(p_data->list_tx[channel]);
	}

	for (channel = 0; channel < SDIO_RX_LIST_NUM; channel++) {
		list_for_each_safe(pos, next, &p_data->list_rx[channel]->head) {
			list_del_init(pos);
		}
		kfree(p_data->list_rx[channel]);
	}
}

static int sdiohal_tx_sendbuf_init(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	p_data->send_buf.buf =
		kzalloc(SDIOHAL_TX_SENDBUF_LEN, GFP_KERNEL);
	if (!p_data->send_buf.buf)
		return -ENOMEM;

	return 0;
}

static void sdiohal_tx_sendbuf_deinit(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	kfree(p_data->send_buf.buf);
	p_data->send_buf.buf = NULL;
	p_data->send_buf.retry_buf = NULL;
}

void sdiohal_tx_init_retrybuf(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	p_data->send_buf.retry_buf = p_data->send_buf.buf;
	p_data->send_buf.retry_len = p_data->send_buf.used_len;
}

static int sdiohal_eof_buf_init(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	struct sdio_puh_t *puh = NULL;

	p_data->eof_buf = kzalloc(MAX_MBUF_SIZE, GFP_KERNEL);
	if (!p_data->eof_buf)
		return -ENOMEM;

	puh = (struct sdio_puh_t *)(p_data->eof_buf);
	puh->type = 0;
	puh->subtype = 0;
	puh->len = 0;
	puh->eof = 1;
	puh->pad = 0;

	return 0;
}

static void sdiohal_eof_buf_deinit(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	kfree(p_data->eof_buf);
}

static int sdiohal_dtbs_buf_init(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	p_data->dtbs_buf = kzalloc(MAX_MBUF_SIZE, GFP_KERNEL);
	if (!p_data->dtbs_buf) {
		sdiohal_err("dtbs buf alloc fail\n");
		return -ENOMEM;
	}

	return 0;
}

static int sdiohal_dtbs_buf_deinit(void)
{
	struct sdiohal_data_t *p_data = sdiohal_get_data();

	kfree(p_data->dtbs_buf);
	p_data->dtbs_buf = NULL;

	return 0;
}

int sdiohal_misc_init(void)
{
	int ret = 0;

	sdiohal_completion_init();
	sdiohal_wakelock_init();
	sdiohal_callback_lock_init();
	sdiohal_spinlock_init();
	sdiohal_sleep_flag_init();
	sdiohal_mutex_init();
	sdiohal_rx_buf_init();
	sdiohal_dtbs_buf_init();
	ret = sdiohal_list_init();
	if (ret < 0)
		sdiohal_err("alloc list err\n");
	sdiohal_tx_sendbuf_init();
	ret = sdiohal_eof_buf_init();

	sdiohal_err(" sdio, BITS =%u, PageSize =%lu, order=%u, %u\n",
		BITS_PER_LONG, PAGE_SIZE, SDIOHAL_FRAG_PAGE_MAX_ORDER, SDIOHAL_FRAG_PAGE_MAX_ORDER_32_BIT);

	return ret;
}

void sdiohal_misc_deinit(void)
{
	sdiohal_eof_buf_deinit();
	sdiohal_tx_sendbuf_deinit();
	sdiohal_list_deinit();
	sdiohal_dtbs_buf_deinit();
	sdiohal_rx_buf_deinit();
	sdiohal_mutex_deinit();
	sdiohal_callback_lock_deinit();
	sdiohal_wakelock_deinit();
}