[net-next-2.6.git] / drivers / staging / otus / wrap_mem.c

/*
 * Copyright (c) 2007-2008 Atheros Communications Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
/*  Module Name : wrap_mem.c                                            */
/*                                                                      */
/*  Abstract                                                            */
/*     This module contains wrapper functions for memory management     */
/*                                                                      */
/*  NOTES                                                               */
/*     Platform dependent.                                              */
/*                                                                      */
/************************************************************************/

#include "oal_dt.h"
#include "usbdrv.h"

#include <linux/netlink.h>
#include <linux/slab.h>
#include <net/iw_handler.h>

/* Memory management */
/* Called to allocate uncached memory, allocated memory must	*/
/* in 4-byte boundary						*/
void *zfwMemAllocate(zdev_t *dev, u32_t size)
{
	void *mem = NULL;
	mem = kmalloc(size, GFP_ATOMIC);
	return mem;
}


/* Called to free allocated memory */
void zfwMemFree(zdev_t *dev, void *mem, u32_t size)
{
	kfree(mem);
	return;
}

void zfwMemoryCopy(u8_t *dst, u8_t *src, u16_t length)
{
	/* u16_t i; */

	memcpy(dst, src, length);
	/*
	 * for(i=0; i<length; i++)
	 * {
	 *	dst[i] = src[i];
	 * }
	 */
	return;
}

void zfwZeroMemory(u8_t *va, u16_t length)
{
	/* u16_t i; */
	memset(va, 0, length);
	/*
	 * for(i=0; i<length; i++)
	 * {
	 *	va[i] = 0;
	 * }
	 */
	return;
}

void zfwMemoryMove(u8_t *dst, u8_t *src, u16_t length)
{
	memcpy(dst, src, length);
	return;
}

u8_t zfwMemoryIsEqual(u8_t *m1, u8_t *m2, u16_t length)
{
	/* u16_t i; */
	int ret;

	ret = memcmp(m1, m2, length);

	return ((ret == 0) ? TRUE : FALSE);
	/*
	 * for(i=0; i<length; i++)
	 *{
	 *	 if ( m1[i] != m2[i] )
	 *	{
	 *		return FALSE;
	 *	}
	 *}
	 *
	 * return TRUE;
	 */
}

/* Leave an empty line below to remove warning message on some compiler */
Commit	Line	Data
4bd43f50 LR	1	/*
	2	* Copyright (c) 2007-2008 Atheros Communications Inc.
	3	*
	4	* Permission to use, copy, modify, and/or distribute this software for any
	5	* purpose with or without fee is hereby granted, provided that the above
	6	* copyright notice and this permission notice appear in all copies.
	7	*
	8	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	9	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	10	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	11	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	12	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	13	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	14	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	15	*/
	16	/* Module Name : wrap_mem.c */
	17	/* */
	18	/* Abstract */
	19	/* This module contains wrapper functions for memory management */
	20	/* */
	21	/* NOTES */
	22	/* Platform dependent. */
	23	/* */
	24	/************************************************************************/
	25
	26	#include "oal_dt.h"
	27	#include "usbdrv.h"
	28
	29	#include <linux/netlink.h>
5a0e3ad6	30	#include <linux/slab.h>
4bd43f50	31	#include <net/iw_handler.h>
4bd43f50 LR	32
4bd43f50 LR	33	/* Memory management */
b767fa1d MT	34	/* Called to allocate uncached memory, allocated memory must */
	35	/* in 4-byte boundary */
	36	void zfwMemAllocate(zdev_t dev, u32_t size)
4bd43f50	37	{
b767fa1d MT	38	void *mem = NULL;
	39	mem = kmalloc(size, GFP_ATOMIC);
	40	return mem;
4bd43f50 LR	41	}
	42
	43
	44	/* Called to free allocated memory */
b767fa1d	45	void zfwMemFree(zdev_t dev, void mem, u32_t size)
4bd43f50	46	{
b767fa1d MT	47	kfree(mem);
b767fa1d MT	48	return;
4bd43f50 LR	49	}
4bd43f50 LR	50
b767fa1d	51	void zfwMemoryCopy(u8_t dst, u8_t src, u16_t length)
4bd43f50	52	{
b767fa1d	53	/* u16_t i; */
4bd43f50	54
b767fa1d MT	55	memcpy(dst, src, length);
	56	/*
	57	* for(i=0; i<length; i++)
	58	* {
	59	* dst[i] = src[i];
	60	* }
	61	*/
	62	return;
4bd43f50 LR	63	}
4bd43f50 LR	64
b767fa1d	65	void zfwZeroMemory(u8_t *va, u16_t length)
4bd43f50	66	{
b767fa1d MT	67	/* u16_t i; */
	68	memset(va, 0, length);
	69	/*
	70	* for(i=0; i<length; i++)
	71	* {
	72	* va[i] = 0;
	73	* }
	74	*/
	75	return;
4bd43f50 LR	76	}
4bd43f50 LR	77
b767fa1d	78	void zfwMemoryMove(u8_t dst, u8_t src, u16_t length)
4bd43f50	79	{
b767fa1d MT	80	memcpy(dst, src, length);
b767fa1d MT	81	return;
4bd43f50 LR	82	}
4bd43f50 LR	83
b767fa1d	84	u8_t zfwMemoryIsEqual(u8_t m1, u8_t m2, u16_t length)
4bd43f50	85	{
b767fa1d MT	86	/* u16_t i; */
b767fa1d MT	87	int ret;
4bd43f50	88
b767fa1d	89	ret = memcmp(m1, m2, length);
4bd43f50	90
b767fa1d MT	91	return ((ret == 0) ? TRUE : FALSE);
	92	/*
	93	* for(i=0; i<length; i++)
	94	*{
	95	* if ( m1[i] != m2[i] )
	96	* {
	97	* return FALSE;
	98	* }
	99	*}
	100	*
	101	* return TRUE;
	102	*/
4bd43f50 LR	103	}
	104
	105	/* Leave an empty line below to remove warning message on some compiler */