Commit 2b42bd58 authored by Phillip Potter's avatar Phillip Potter Committed by Greg Kroah-Hartman
Browse files

staging: r8188eu: introduce new os_dep dir for RTL8188eu driver 



This patchset is split in order to keep the file sizes down. This os_dep
directory is part of the newer/better driver from GitHub modified by
Larry Finger. Import this as the basis for all future work going
forward.

Suggested-by: default avatarLarry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: default avatarPhillip Potter <phil@philpotter.co.uk>
Link: https://lore.kernel.org/r/20210727232219.2948-4-phil@philpotter.co.uk


Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 8cd574e6

drivers/staging/r8188eu/os_dep/ioctl_linux.c

0 → 100644
+8178 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/staging/r8188eu/os_dep/mlme_linux.c

0 → 100644
+302 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 * Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of version 2 of the GNU General Public License as

 * published by the Free Software Foundation.

 *

 * 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.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

 *

 *

 ******************************************************************************/



#define _MLME_OSDEP_C_



#include <osdep_service.h>

#include <drv_types.h>

#include <mlme_osdep.h>



#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

void rtw_join_timeout_handler (void *FunctionContext)

#else

void rtw_join_timeout_handler (struct timer_list *t)

#endif

{

#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

	struct adapter *adapter = (struct adapter *)FunctionContext;

#else

	struct adapter *adapter = from_timer(adapter, t, mlmepriv.assoc_timer);

#endif



	_rtw_join_timeout_handler(adapter);

}



#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

void _rtw_scan_timeout_handler (void *FunctionContext)

#else

void _rtw_scan_timeout_handler (struct timer_list *t)

#endif

{

#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

	struct adapter *adapter = (struct adapter *)FunctionContext;

#else

	struct adapter *adapter = from_timer(adapter, t, mlmepriv.scan_to_timer);

#endif



	rtw_scan_timeout_handler(adapter);

}



#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

static void _dynamic_check_timer_handlder(void *FunctionContext)

#else

static void _dynamic_check_timer_handlder(struct timer_list *t)

#endif

{

#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

	struct adapter *adapter = (struct adapter *)FunctionContext;

#else

	struct adapter *adapter = from_timer(adapter, t, mlmepriv.dynamic_chk_timer);

#endif



	if (adapter->registrypriv.mp_mode == 1)

		return;

	rtw_dynamic_check_timer_handlder(adapter);

	_set_timer(&adapter->mlmepriv.dynamic_chk_timer, 2000);

}



void rtw_init_mlme_timer(struct adapter *padapter)

{

	struct	mlme_priv *pmlmepriv = &padapter->mlmepriv;



#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

	_init_timer(&(pmlmepriv->assoc_timer), padapter->pnetdev, rtw_join_timeout_handler, padapter);

	_init_timer(&(pmlmepriv->scan_to_timer), padapter->pnetdev, _rtw_scan_timeout_handler, padapter);

	_init_timer(&(pmlmepriv->dynamic_chk_timer), padapter->pnetdev, _dynamic_check_timer_handlder, padapter);

#else

	timer_setup(&pmlmepriv->assoc_timer, rtw_join_timeout_handler, 0);

	timer_setup(&pmlmepriv->scan_to_timer, _rtw_scan_timeout_handler, 0);

	timer_setup(&pmlmepriv->dynamic_chk_timer, _dynamic_check_timer_handlder, 0);

#endif

}



void rtw_os_indicate_connect(struct adapter *adapter)

{



	rtw_indicate_wx_assoc_event(adapter);

	netif_carrier_on(adapter->pnetdev);

	if (adapter->pid[2] != 0)

		rtw_signal_process(adapter->pid[2], SIGALRM);



}



void rtw_os_indicate_scan_done(struct adapter *padapter, bool aborted)

{

	indicate_wx_scan_complete_event(padapter);

}



static struct rt_pmkid_list backup_pmkid[NUM_PMKID_CACHE];



void rtw_reset_securitypriv(struct adapter *adapter)

{

	u8	backup_index = 0;

	u8	backup_counter = 0x00;

	u32	backup_time = 0;



	if (adapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) {

		/* 802.1x */

		/*  We have to backup the PMK information for WiFi PMK Caching test item. */

		/*  Backup the btkip_countermeasure information. */

		/*  When the countermeasure is trigger, the driver have to disconnect with AP for 60 seconds. */

		memset(&backup_pmkid[0], 0x00, sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE);

		memcpy(&backup_pmkid[0], &adapter->securitypriv.PMKIDList[0], sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE);

		backup_index = adapter->securitypriv.PMKIDIndex;

		backup_counter = adapter->securitypriv.btkip_countermeasure;

		backup_time = adapter->securitypriv.btkip_countermeasure_time;

		memset((unsigned char *)&adapter->securitypriv, 0, sizeof(struct security_priv));



		/*  Restore the PMK information to securitypriv structure for the following connection. */

		memcpy(&adapter->securitypriv.PMKIDList[0],

			    &backup_pmkid[0],

			    sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE);

		adapter->securitypriv.PMKIDIndex = backup_index;

		adapter->securitypriv.btkip_countermeasure = backup_counter;

		adapter->securitypriv.btkip_countermeasure_time = backup_time;

		adapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;

		adapter->securitypriv.ndisencryptstatus = Ndis802_11WEPDisabled;

	} else {

		/* reset values in securitypriv */

		struct security_priv *psec_priv = &adapter->securitypriv;



		psec_priv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;  /* open system */

		psec_priv->dot11PrivacyAlgrthm = _NO_PRIVACY_;

		psec_priv->dot11PrivacyKeyIndex = 0;

		psec_priv->dot118021XGrpPrivacy = _NO_PRIVACY_;

		psec_priv->dot118021XGrpKeyid = 1;

		psec_priv->ndisauthtype = Ndis802_11AuthModeOpen;

		psec_priv->ndisencryptstatus = Ndis802_11WEPDisabled;

	}

}



void rtw_os_indicate_disconnect(struct adapter *adapter)

{



	netif_carrier_off(adapter->pnetdev); /*  Do it first for tx broadcast pkt after disconnection issue! */

	rtw_indicate_wx_disassoc_event(adapter);

	 rtw_reset_securitypriv(adapter);



}



void rtw_report_sec_ie(struct adapter *adapter, u8 authmode, u8 *sec_ie)

{

	uint	len;

	u8	*buff, *p, i;

	union iwreq_data wrqu;



	RT_TRACE(_module_mlme_osdep_c_, _drv_info_,

		 ("+rtw_report_sec_ie, authmode=%d\n", authmode));

	buff = NULL;

	if (authmode == _WPA_IE_ID_) {

		RT_TRACE(_module_mlme_osdep_c_, _drv_info_,

			 ("rtw_report_sec_ie, authmode=%d\n", authmode));

		buff = rtw_malloc(IW_CUSTOM_MAX);

		if (!buff)

			return;

		memset(buff, 0, IW_CUSTOM_MAX);

		p = buff;

		p += sprintf(p, "ASSOCINFO(ReqIEs =");

		len = sec_ie[1]+2;

		len =  (len < IW_CUSTOM_MAX) ? len : IW_CUSTOM_MAX;

		for (i = 0; i < len; i++)

			p += sprintf(p, "%02x", sec_ie[i]);

		p += sprintf(p, ")");

		memset(&wrqu, 0, sizeof(wrqu));

		wrqu.data.length = p-buff;

		wrqu.data.length = (wrqu.data.length < IW_CUSTOM_MAX) ?

				   wrqu.data.length : IW_CUSTOM_MAX;

		wireless_send_event(adapter->pnetdev, IWEVCUSTOM, &wrqu, buff);

		kfree(buff);

	}

}



#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

static void _survey_timer_hdl(void *FunctionContext)

#else

static void _survey_timer_hdl(struct timer_list *t)

#endif

{

#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

	struct adapter *padapter = (struct adapter *)FunctionContext;

#else

	struct adapter *padapter = from_timer(padapter, t, mlmeextpriv.survey_timer);

#endif



	survey_timer_hdl(padapter);

}



#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

static void _link_timer_hdl(void *FunctionContext)

#else

static void _link_timer_hdl(struct timer_list *t)

#endif

{

#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

	struct adapter *padapter = (struct adapter *)FunctionContext;

#else

	struct adapter *padapter = from_timer(padapter, t, mlmeextpriv.link_timer);

#endif

	link_timer_hdl(padapter);

}



#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

static void _addba_timer_hdl(void *FunctionContext)

#else

static void _addba_timer_hdl(struct timer_list *t)

#endif

{

#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

	struct sta_info *psta = (struct sta_info *)FunctionContext;

#else

	struct sta_info *psta = from_timer(psta, t, addba_retry_timer);

#endif

	addba_timer_hdl(psta);

}



void init_addba_retry_timer(struct adapter *padapter, struct sta_info *psta)

{

#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

	_init_timer(&psta->addba_retry_timer, padapter->pnetdev, _addba_timer_hdl, psta);

#else

	timer_setup(&psta->addba_retry_timer, _addba_timer_hdl, 0);

#endif

}



void init_mlme_ext_timer(struct adapter *padapter)

{

	struct	mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;



#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 15, 0)

	_init_timer(&pmlmeext->survey_timer, padapter->pnetdev, _survey_timer_hdl, padapter);

	_init_timer(&pmlmeext->link_timer, padapter->pnetdev, _link_timer_hdl, padapter);

#else

	timer_setup(&pmlmeext->survey_timer, _survey_timer_hdl, 0);

	timer_setup(&pmlmeext->link_timer, _link_timer_hdl, 0);

#endif

}



#ifdef CONFIG_88EU_AP_MODE



void rtw_indicate_sta_assoc_event(struct adapter *padapter, struct sta_info *psta)

{

	union iwreq_data wrqu;

	struct sta_priv *pstapriv = &padapter->stapriv;



	if (psta == NULL)

		return;



	if (psta->aid > NUM_STA)

		return;



	if (pstapriv->sta_aid[psta->aid - 1] != psta)

		return;



	wrqu.addr.sa_family = ARPHRD_ETHER;



	memcpy(wrqu.addr.sa_data, psta->hwaddr, ETH_ALEN);



	DBG_88E("+rtw_indicate_sta_assoc_event\n");



	wireless_send_event(padapter->pnetdev, IWEVREGISTERED, &wrqu, NULL);

}



void rtw_indicate_sta_disassoc_event(struct adapter *padapter, struct sta_info *psta)

{

	union iwreq_data wrqu;

	struct sta_priv *pstapriv = &padapter->stapriv;



	if (psta == NULL)

		return;



	if (psta->aid > NUM_STA)

		return;



	if (pstapriv->sta_aid[psta->aid - 1] != psta)

		return;



	wrqu.addr.sa_family = ARPHRD_ETHER;



	memcpy(wrqu.addr.sa_data, psta->hwaddr, ETH_ALEN);



	DBG_88E("+rtw_indicate_sta_disassoc_event\n");



	wireless_send_event(padapter->pnetdev, IWEVEXPIRED, &wrqu, NULL);

}



#endif

drivers/staging/r8188eu/os_dep/os_intfs.c

0 → 100644
+1283 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/staging/r8188eu/os_dep/osdep_service.c

0 → 100644
+535 −0
Original line number Diff line number Diff line 
/******************************************************************************

 *

 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of version 2 of the GNU General Public License as

 * published by the Free Software Foundation.

 *

 * 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.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program; if not, write to the Free Software Foundation, Inc.,

 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA

 *

 *

 ******************************************************************************/



#define _OSDEP_SERVICE_C_



#include <osdep_service.h>

#include <drv_types.h>

#include <recv_osdep.h>

#include <linux/vmalloc.h>

#include <rtw_ioctl_set.h>



/*

* Translate the OS dependent @param error_code to OS independent RTW_STATUS_CODE

* @return: one of RTW_STATUS_CODE

*/

inline int RTW_STATUS_CODE(int error_code)

{

	if (error_code >= 0)

		return _SUCCESS;

	return _FAIL;

}



u32 rtw_atoi(u8 *s)

{

	int num = 0, flag = 0;

	int i;

	for (i = 0; i <= strlen(s); i++) {

		if (s[i] >= '0' && s[i] <= '9')

			num = num * 10 + s[i] - '0';

		else if (s[0] == '-' && i == 0)

			flag = 1;

		else

			break;

	}

	if (flag == 1)

		num = num * -1;

	 return num;

}



inline u8 *_rtw_vmalloc(u32 sz)

{

	u8	*pbuf;

	pbuf = vmalloc(sz);

	return pbuf;

}



inline u8 *_rtw_zvmalloc(u32 sz)

{

	u8	*pbuf;

	pbuf = _rtw_vmalloc(sz);

	if (pbuf != NULL)

		memset(pbuf, 0, sz);

	return pbuf;

}



inline void _rtw_vmfree(u8 *pbuf, u32 sz)

{

	vfree(pbuf);

}



u8 *_rtw_malloc(u32 sz)

{

	u8	*pbuf = NULL;



	pbuf = kmalloc(sz, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);

	return pbuf;

}



u8 *_rtw_zmalloc(u32 sz)

{

	u8	*pbuf = _rtw_malloc(sz);



	if (pbuf != NULL)

		memset(pbuf, 0, sz);

	return pbuf;

}



void *rtw_malloc2d(int h, int w, int size)

{

	int j;



	void **a = (void **)rtw_zmalloc(h*sizeof(void *) + h*w*size);

	if (a == NULL) {

		pr_info("%s: alloc memory fail!\n", __func__);

		return NULL;

	}



	for (j = 0; j < h; j++)

		a[j] = ((char *)(a+h)) + j*w*size;



	return a;

}



void rtw_mfree2d(void *pbuf, int h, int w, int size)

{

	kfree(pbuf);

}



/*

For the following list_xxx operations,

caller must guarantee the atomic context.

Otherwise, there will be racing condition.

*/

/*

Caller must check if the list is empty before calling rtw_list_delete

*/



u32 _rtw_down_sema(struct semaphore *sema)

{

	if (down_interruptible(sema))

		return _FAIL;

	else

		return _SUCCESS;

}



void	_rtw_mutex_init(struct mutex *pmutex)

{

	mutex_init(pmutex);

}



void	_rtw_mutex_free(struct mutex *pmutex)

{

	mutex_destroy(pmutex);

}



void	_rtw_spinlock_free(spinlock_t *plock)

{

}



void	_rtw_init_queue(struct __queue *pqueue)

{

	INIT_LIST_HEAD(&(pqueue->queue));

	spin_lock_init(&(pqueue->lock));

}



inline u32 rtw_systime_to_ms(u32 systime)

{

	return systime * 1000 / HZ;

}



inline u32 rtw_ms_to_systime(u32 ms)

{

	return ms * HZ / 1000;

}



/*  the input parameter start use the same unit as jiffies */

inline s32 rtw_get_passing_time_ms(u32 start)

{

	return rtw_systime_to_ms(jiffies-start);

}



inline s32 rtw_get_time_interval_ms(u32 start, u32 end)

{

	return rtw_systime_to_ms(end-start);

}



void rtw_sleep_schedulable(int ms)

{

	u32 delta;



	delta = (ms * HZ)/1000;/* ms) */

	if (delta == 0)

		delta = 1;/*  1 ms */

	set_current_state(TASK_INTERRUPTIBLE);

	if (schedule_timeout(delta) != 0)

		return;

}



void rtw_msleep_os(int ms)

{

	msleep((unsigned int)ms);

}



void rtw_usleep_os(int us)

{

	if (1 < (us/1000))

		msleep(1);

	else

		msleep((us/1000) + 1);

}



void rtw_mdelay_os(int ms)

{

	mdelay((unsigned long)ms);

}



void rtw_udelay_os(int us)

{

	udelay((unsigned long)us);

}



void rtw_yield_os(void)

{

	yield();

}



#define RTW_SUSPEND_LOCK_NAME "rtw_wifi"



inline void rtw_suspend_lock_init(void)

{

}



inline void rtw_suspend_lock_uninit(void)

{

}



inline void rtw_lock_suspend(void)

{

}



inline void rtw_unlock_suspend(void)

{

}



inline void ATOMIC_SET(ATOMIC_T *v, int i)

{

	atomic_set(v, i);

}



inline int ATOMIC_READ(ATOMIC_T *v)

{

	return atomic_read(v);

}



inline void ATOMIC_ADD(ATOMIC_T *v, int i)

{

	atomic_add(i, v);

}



inline void ATOMIC_SUB(ATOMIC_T *v, int i)

{

	atomic_sub(i, v);

}



inline void ATOMIC_INC(ATOMIC_T *v)

{

	atomic_inc(v);

}



inline void ATOMIC_DEC(ATOMIC_T *v)

{

	atomic_dec(v);

}



inline int ATOMIC_ADD_RETURN(ATOMIC_T *v, int i)

{

	return atomic_add_return(i, v);

}



inline int ATOMIC_SUB_RETURN(ATOMIC_T *v, int i)

{

	return atomic_sub_return(i, v);

}



inline int ATOMIC_INC_RETURN(ATOMIC_T *v)

{

	return atomic_inc_return(v);

}



inline int ATOMIC_DEC_RETURN(ATOMIC_T *v)

{

	return atomic_dec_return(v);

}



static const struct device_type wlan_type = {

	.name = "wlan",

};



struct net_device *rtw_alloc_etherdev_with_old_priv(int sizeof_priv,

						    void *old_priv)

{

	struct net_device *pnetdev;

	struct rtw_netdev_priv_indicator *pnpi;



	pnetdev = alloc_etherdev_mq(sizeof(struct rtw_netdev_priv_indicator), 4);

	if (!pnetdev)

		goto RETURN;



	pnetdev->dev.type = &wlan_type;

	pnpi = netdev_priv(pnetdev);

	pnpi->priv = old_priv;

	pnpi->sizeof_priv = sizeof_priv;



RETURN:

	return pnetdev;

}



struct net_device *rtw_alloc_etherdev(int sizeof_priv)

{

	struct net_device *pnetdev;

	struct rtw_netdev_priv_indicator *pnpi;



	pnetdev = alloc_etherdev_mq(sizeof(struct rtw_netdev_priv_indicator), 4);

	if (!pnetdev)

		goto RETURN;



	pnpi = netdev_priv(pnetdev);



	pnpi->priv = rtw_zvmalloc(sizeof_priv);

	if (!pnpi->priv) {

		free_netdev(pnetdev);

		pnetdev = NULL;

		goto RETURN;

	}



	pnpi->sizeof_priv = sizeof_priv;

RETURN:

	return pnetdev;

}



void rtw_free_netdev(struct net_device *netdev)

{

	struct rtw_netdev_priv_indicator *pnpi;



	if (!netdev)

		goto RETURN;



	pnpi = netdev_priv(netdev);



	if (!pnpi->priv)

		goto RETURN;



	rtw_vmfree(pnpi->priv, pnpi->sizeof_priv);

	free_netdev(netdev);



RETURN:

	return;

}



int rtw_change_ifname(struct adapter *padapter, const char *ifname)

{

	struct net_device *pnetdev;

	struct net_device *cur_pnetdev;

	struct rereg_nd_name_data *rereg_priv;

	int ret;



	if (!padapter)

		goto error;



	cur_pnetdev = padapter->pnetdev;

	rereg_priv = &padapter->rereg_nd_name_priv;



	/* free the old_pnetdev */

	if (rereg_priv->old_pnetdev) {

		free_netdev(rereg_priv->old_pnetdev);

		rereg_priv->old_pnetdev = NULL;

	}



	if (!rtnl_is_locked())

		unregister_netdev(cur_pnetdev);

	else

		unregister_netdevice(cur_pnetdev);



	rtw_proc_remove_one(cur_pnetdev);



	rereg_priv->old_pnetdev = cur_pnetdev;



	pnetdev = rtw_init_netdev(padapter);

	if (!pnetdev)  {

		ret = -1;

		goto error;

	}



	SET_NETDEV_DEV(pnetdev, dvobj_to_dev(adapter_to_dvobj(padapter)));



	rtw_init_netdev_name(pnetdev, ifname);



	memcpy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);



	if (!rtnl_is_locked())

		ret = register_netdev(pnetdev);

	else

		ret = register_netdevice(pnetdev);

	if (ret != 0) {

		RT_TRACE(_module_hci_intfs_c_, _drv_err_,

			 ("register_netdev() failed\n"));

		goto error;

	}

	rtw_proc_init_one(pnetdev);

	return 0;

error:

	return -1;

}



u64 rtw_modular64(u64 x, u64 y)

{

	return do_div(x, y);

}



u64 rtw_division64(u64 x, u64 y)

{

	do_div(x, y);

	return x;

}



void rtw_buf_free(u8 **buf, u32 *buf_len)

{

	*buf_len = 0;

	kfree(*buf);

	*buf = NULL;

}



void rtw_buf_update(u8 **buf, u32 *buf_len, u8 *src, u32 src_len)

{

	u32 ori_len = 0, dup_len = 0;

	u8 *ori = NULL;

	u8 *dup = NULL;



	if (!buf || !buf_len)

		return;



	if (!src || !src_len)

		goto keep_ori;



	/* duplicate src */

	dup = rtw_malloc(src_len);

	if (dup) {

		dup_len = src_len;

		memcpy(dup, src, dup_len);

	}



keep_ori:

	ori = *buf;

	ori_len = *buf_len;



	/* replace buf with dup */

	*buf_len = 0;

	*buf = dup;

	*buf_len = dup_len;



	/* free ori */

	kfree(ori);

}



/**

 * rtw_cbuf_full - test if cbuf is full

 * @cbuf: pointer of struct rtw_cbuf

 *

 * Returns: true if cbuf is full

 */

inline bool rtw_cbuf_full(struct rtw_cbuf *cbuf)

{

	return (cbuf->write == cbuf->read-1) ? true : false;

}



/**

 * rtw_cbuf_empty - test if cbuf is empty

 * @cbuf: pointer of struct rtw_cbuf

 *

 * Returns: true if cbuf is empty

 */

inline bool rtw_cbuf_empty(struct rtw_cbuf *cbuf)

{

	return (cbuf->write == cbuf->read) ? true : false;

}



/**

 * rtw_cbuf_push - push a pointer into cbuf

 * @cbuf: pointer of struct rtw_cbuf

 * @buf: pointer to push in

 *

 * Lock free operation, be careful of the use scheme

 * Returns: true push success

 */

bool rtw_cbuf_push(struct rtw_cbuf *cbuf, void *buf)

{

	if (rtw_cbuf_full(cbuf))

		return _FAIL;



	if (0)

		DBG_88E("%s on %u\n", __func__, cbuf->write);

	cbuf->bufs[cbuf->write] = buf;

	cbuf->write = (cbuf->write+1)%cbuf->size;



	return _SUCCESS;

}



/**

 * rtw_cbuf_pop - pop a pointer from cbuf

 * @cbuf: pointer of struct rtw_cbuf

 *

 * Lock free operation, be careful of the use scheme

 * Returns: pointer popped out

 */

void *rtw_cbuf_pop(struct rtw_cbuf *cbuf)

{

	void *buf;

	if (rtw_cbuf_empty(cbuf))

		return NULL;



	if (0)

		DBG_88E("%s on %u\n", __func__, cbuf->read);

	buf = cbuf->bufs[cbuf->read];

	cbuf->read = (cbuf->read+1)%cbuf->size;



	return buf;

}



/**

 * rtw_cbuf_alloc - allocate a rtw_cbuf with given size and do initialization

 * @size: size of pointer

 *

 * Returns: pointer of srtuct rtw_cbuf, NULL for allocation failure

 */

struct rtw_cbuf *rtw_cbuf_alloc(u32 size)

{

	struct rtw_cbuf *cbuf;



	cbuf = (struct rtw_cbuf *)rtw_malloc(sizeof(*cbuf) +

	       sizeof(void *)*size);



	if (cbuf) {

		cbuf->write = 0;

		cbuf->read = 0;

		cbuf->size = size;

	}

	return cbuf;

}

drivers/staging/r8188eu/os_dep/recv_linux.c

0 → 100644
+270 −0

File added.

Preview size limit exceeded, changes collapsed.