/*
 * Copyright (C) 2015 Spreadtrum Communications Inc.
 * 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 "bufring.h"
#include "mdbg_type.h"
#include "wcn_log.h"

#define MDBG_RING_LOCK_INIT(ring)		mutex_init(ring->plock)
#define MDBG_RING_LOCK_UNINIT(ring)		mutex_destroy(ring->plock)
#define MDBG_RING_LOCK(ring)			mutex_lock(ring->plock)
#define MDBG_RING_UNLOCK(ring)			mutex_unlock(ring->plock)
#define _MDBG_RING_REMAIN(rp, wp, size)	((u_long)(wp) >= (u_long)(rp) ?\
			((size) - (u_long)(wp) + (u_long)(rp)) :\
			((u_long)(rp) - (u_long)(wp)))

/* valid buf for write */
long int mdbg_ring_free_space(struct mdbg_ring_t *ring)
{
	return (long int)_MDBG_RING_REMAIN(ring->rp,
				ring->wp, ring->size);
}

static char *mdbg_ring_start(struct mdbg_ring_t *ring)
{
	return ring->pbuff;
}

static char *mdbg_ring_end(struct mdbg_ring_t *ring)
{
	return ring->end;
}

bool mdbg_ring_over_loop(struct mdbg_ring_t *ring, u_long len, int rw)
{
	if (rw == MDBG_RING_R) {
		if ((u_long)ring->rp + len > (u_long)mdbg_ring_end(ring)) {
			ring->p_order_flag = 0;
			return true;
		}
		return false;
	}

	if ((u_long)ring->wp + len > (u_long)mdbg_ring_end(ring)) {
		ring->p_order_flag = 1;
		return true;
	}

	return false;
}

struct mdbg_ring_t *mdbg_ring_alloc(long int size)
{
	struct mdbg_ring_t *ring = NULL;

	do {
		if (size < MDBG_RING_MIN_SIZE) {
			MDBG_ERR("size error:%ld", size);
			break;
		}
		ring = kmalloc(sizeof(struct mdbg_ring_t), GFP_KERNEL);
		if (ring == NULL) {
			MDBG_ERR("Ring malloc Failed.");
			break;
		}
		ring->pbuff = kmalloc(size, GFP_KERNEL);
		if (ring->pbuff == NULL) {
			MDBG_ERR("Ring buff malloc Failed.");
			break;
		}
		ring->plock = kmalloc(MDBG_RING_LOCK_SIZE, GFP_KERNEL);
		if (ring->plock == NULL) {
			MDBG_ERR("Ring lock malloc Failed.");
			break;
		}
		MDBG_RING_LOCK_INIT(ring);
		memset(ring->pbuff, 0, size);
		ring->size = size;
		ring->rp = ring->pbuff;
		ring->wp = ring->pbuff;
		ring->end = (char *)(((u_long)ring->pbuff) + (ring->size - 1));
		ring->p_order_flag = 0;

		return ring;
	} while (0);
	mdbg_ring_destroy(ring);

	return NULL;
}

void mdbg_ring_destroy(struct mdbg_ring_t *ring)
{
	if (unlikely(ZERO_OR_NULL_PTR(ring)))
		return;

	MDBG_LOG("ring = %p", ring);
	MDBG_LOG("ring->pbuff = %p", ring->pbuff);
	if (ring != NULL) {
		if (ring->pbuff != NULL) {
			MDBG_LOG("to free ring->pbuff.");
			kfree(ring->pbuff);
			ring->pbuff = NULL;
		}
		if (ring->plock != NULL) {
			MDBG_LOG("to free ring->plock.");
			MDBG_RING_LOCK_UNINIT(ring);
			kfree(ring->plock);
			ring->plock = NULL;
		}
		MDBG_LOG("to free ring.");
		kfree(ring);
		ring = NULL;
	}
}

int mdbg_ring_read(struct mdbg_ring_t *ring, void *buf, int len)
{
	int len1, len2 = 0;
	int cont_len = 0;
	int read_len = 0;
	char *pstart = NULL;
	char *pend = NULL;
	static unsigned int total_len;

	if ((buf == NULL) || (ring == NULL) || (len == 0)) {
		MDBG_ERR("Ring Read Failed,Param Error!,buf=%p,ring=%p,len=%d",
			buf, ring, len);
		return -MDBG_ERR_BAD_PARAM;
	}
	MDBG_RING_LOCK(ring);
	cont_len = mdbg_ring_readable_len(ring);
	read_len = cont_len >= len ? len : cont_len;
	pstart = mdbg_ring_start(ring);
	pend = mdbg_ring_end(ring);
	MDBG_LOG("read_len=%d", read_len);
	MDBG_LOG("buf=%p", buf);
	MDBG_LOG("pstart=%p", pstart);
	MDBG_LOG("pend=%p", pend);
	MDBG_LOG("ring->wp = %p", ring->wp);
	MDBG_LOG("ring->rp=%p\n", ring->rp);

	if ((read_len == 0) || (cont_len == 0)) {
		MDBG_LOG("read_len = 0 OR Ring Empty.");
		MDBG_RING_UNLOCK(ring);
		return 0;	/*ring empty*/
	}

	if (mdbg_ring_over_loop(ring, read_len, MDBG_RING_R)) {
		MDBG_LOG("Ring loopover.");
		len1 = pend - ring->rp + 1;
		len2 = read_len - len1;
		if ((uintptr_t)buf > TASK_SIZE) {
			memcpy(buf, ring->rp, len1);
			memcpy((buf + len1), pstart, len2);
		} else {
			if (copy_to_user((void __user *)buf,
				(void *)ring->rp, len1) |
				copy_to_user((void __user *)(buf + len1),
				(void *)pstart, len2)) {
				MDBG_ERR("copy to user error!\n");
				MDBG_RING_UNLOCK(ring);
				return -EFAULT;
			}
		}
		ring->rp = (char *)((u_long)pstart + len2);
	} else{
		/* RP < WP */
		if (ring->p_order_flag == 0) {
			if (((ring->rp + read_len) > ring->wp)
				&& (mdbg_dev->open_count != 0))
				WCN_ERR("read overlay\n");
		}

		if ((uintptr_t)buf > TASK_SIZE)
			memcpy(buf, ring->rp, read_len);
		else
			if (copy_to_user((void __user *)buf,
						(void *)ring->rp, read_len)) {
				MDBG_ERR("copy to user error!\n");
				MDBG_RING_UNLOCK(ring);

				return -EFAULT;
			}
		ring->rp += read_len;
	}
	total_len += read_len;
	wcn_pr_daterate(4, 1, total_len,
			"%s totallen:%u curread:%d wp:%p rp:%p",
			__func__, total_len, read_len,
			ring->wp, ring->rp);
	MDBG_LOG("<-----[read end] read len =%d.\n", read_len);
	MDBG_RING_UNLOCK(ring);

	return read_len;
}

/*
 * read:	Rp = Wp:	empty
 * write:	Wp+1=Rp:	full
 */
int mdbg_ring_write(struct mdbg_ring_t *ring, void *buf, unsigned int len)
{
	int len1, len2 = 0;
	char *pstart = NULL;
	char *pend = NULL;
	static unsigned int total_len;

	MDBG_LOG("-->Ring Write len = %d\n", len);
	if ((ring == NULL) || (buf == NULL) || (len == 0)) {
		MDBG_ERR(
			"Ring Write Failed,Param Error!,buf=%p,ring=%p,len=%d",
			buf, ring, len);

		return -MDBG_ERR_BAD_PARAM;
	}
	pstart = mdbg_ring_start(ring);
	pend = mdbg_ring_end(ring);
	MDBG_LOG("pstart = %p", pstart);
	MDBG_LOG("pend = %p", pend);
	MDBG_LOG("buf = %p", buf);
	MDBG_LOG("len = %d", len);
	MDBG_LOG("ring->wp = %p", ring->wp);
	MDBG_LOG("ring->rp=%p", ring->rp);

	/*
	 * ring buf valid space < len,need to write (buf_space-1)
	 * and then write len-(buf_space-1)
	 */
	if (((mdbg_ring_free_space(ring) - 1) < len)
		&& (mdbg_dev->open_count != 0)) {
		WCN_ERR("log buf is full, Discard the package=%d\n", len);
		wake_up_log_wait();
		return len;
	}

	/* ring buf valid space > len, you can write freely */
	if (mdbg_ring_over_loop(ring, len, MDBG_RING_W)) {
		MDBG_LOG("Ring overloop.");
		len1 = pend - ring->wp + 1;
		len2 = (len - len1) % ring->size;
		if ((uintptr_t)buf > TASK_SIZE) {
			memcpy(ring->wp, buf, len1);
			memcpy(pstart, (buf + len1), len2);
		} else {
			if (copy_from_user((void *)ring->wp,
				(void __user *)buf, len1) |
				copy_from_user((void *)pstart,
					(void __user *)(buf + len1), len2)) {
				MDBG_ERR("%s copy from user error!\n",
						__func__);
				return -EFAULT;
			}
		}
		ring->wp = (char *)((u_long)pstart + len2);

	} else{
		/* RP > WP */
		if ((uintptr_t)buf > TASK_SIZE)
			memcpy(ring->wp, buf, len);
		else
			if (copy_from_user((void *)ring->wp,
						(void __user *)buf, len)) {
				MDBG_ERR("%s copy from user error!\n",
						__func__);
				return -EFAULT;
			}
		ring->wp += len;
	}
	total_len += len;
	wcn_pr_daterate(4, 1, total_len,
			"%s totallen:%u cur_read:%u wp:%p rp:%p",
			__func__, total_len, len, ring->wp, ring->rp);
	MDBG_LOG("<------end len = %d\n", len);

	return len;
}

/* @timeout unit is ms */
int mdbg_ring_write_timeout(struct mdbg_ring_t *ring, void *buf,
			    unsigned int len, unsigned int timeout)
{
	unsigned  int cnt = timeout / 20;

	while (cnt > 0 && (mdbg_ring_free_space(ring) - 1) < len) {
		msleep(20);
		if (--cnt == 0)
			MDBG_ERR("ringbuf is full, tiemout:%u\n",
				 timeout);
	}

	return mdbg_ring_write(ring, buf, len);
}

char *mdbg_ring_write_ext(struct mdbg_ring_t *ring, long int len)
{
	char *wp = NULL;

	MDBG_LOG("ring=%p,ring->wp=%p,len=%ld.", ring, ring->wp, len);

	if ((ring == NULL) || (len == 0)) {
		MDBG_ERR("Ring Write Ext Failed,Param Error!");
		return NULL;
	}

	if (mdbg_ring_over_loop(ring, len, MDBG_RING_R)
			|| mdbg_ring_will_full(ring, len)) {
		MDBG_LOG(
		"Ring Write Ext Failed,Ring State Error!,overloop=%d,full=%d.",
		mdbg_ring_over_loop(ring, len, MDBG_RING_R),
		mdbg_ring_will_full(ring, len));
		return NULL;
	}
	MDBG_RING_LOCK(ring);
	wp = ring->wp;
	ring->wp += len;
	MDBG_LOG("return wp=%p,ring->wp=%p.", wp, ring->wp);
	MDBG_RING_UNLOCK(ring);

	return wp;
}

bool mdbg_ring_will_full(struct mdbg_ring_t *ring, int len)
{
	return (len > mdbg_ring_free_space(ring));
}

/* remain data for read */
long int mdbg_ring_readable_len(struct mdbg_ring_t *ring)
{
	return ring->size - mdbg_ring_free_space(ring);
}

void mdbg_ring_clear(struct mdbg_ring_t *ring)
{
	ring->rp = ring->wp;
}

void mdbg_ring_reset(struct mdbg_ring_t *ring)
{
	ring->wp = ring->pbuff;
	ring->rp = ring->wp;
}

void mdbg_ring_print(struct mdbg_ring_t *ring)
{
	WCN_DEBUG("ring buf status:ring->rp=%p,ring->wp=%p.\n",
				ring->rp, ring->wp);
}