// SPDX-License-Identifier: GPL-2.0
|
/******************************************************************************
|
*
|
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
|
*
|
******************************************************************************/
|
|
|
#define _OSDEP_SERVICE_C_
|
|
#include <drv_types.h>
|
#include <rtw_debug.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;
|
}
|
|
void *_rtw_malloc(u32 sz)
|
{
|
return kmalloc(sz, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
|
}
|
|
void *_rtw_zmalloc(u32 sz)
|
{
|
void *pbuf = _rtw_malloc(sz);
|
|
if (pbuf)
|
memset(pbuf, 0, sz);
|
|
return pbuf;
|
}
|
|
inline struct sk_buff *_rtw_skb_alloc(u32 sz)
|
{
|
return __dev_alloc_skb(sz, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
|
}
|
|
inline struct sk_buff *_rtw_skb_copy(const struct sk_buff *skb)
|
{
|
return skb_copy(skb, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
|
}
|
|
inline struct sk_buff *_rtw_skb_clone(struct sk_buff *skb)
|
{
|
return skb_clone(skb, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
|
}
|
|
inline int _rtw_netif_rx(_nic_hdl ndev, struct sk_buff *skb)
|
{
|
skb->dev = ndev;
|
return netif_rx(skb);
|
}
|
|
void _rtw_init_queue(struct __queue *pqueue)
|
{
|
INIT_LIST_HEAD(&(pqueue->queue));
|
|
spin_lock_init(&(pqueue->lock));
|
}
|
|
/*
|
* Open a file with the specific @param path, @param flag, @param mode
|
* @param fpp the pointer of struct file pointer to get struct file pointer while file opening is success
|
* @param path the path of the file to open
|
* @param flag file operation flags, please refer to linux document
|
* @param mode please refer to linux document
|
* @return Linux specific error code
|
*/
|
static int openFile(struct file **fpp, char *path, int flag, int mode)
|
{
|
struct file *fp;
|
|
fp =filp_open(path, flag, mode);
|
if (IS_ERR(fp)) {
|
*fpp = NULL;
|
return PTR_ERR(fp);
|
}
|
else {
|
*fpp =fp;
|
return 0;
|
}
|
}
|
|
/*
|
* Close the file with the specific @param fp
|
* @param fp the pointer of struct file to close
|
* @return always 0
|
*/
|
static int closeFile(struct file *fp)
|
{
|
filp_close(fp, NULL);
|
return 0;
|
}
|
|
static int readFile(struct file *fp, char *buf, int len)
|
{
|
int rlen = 0, sum = 0;
|
|
if (!fp->f_op || !fp->f_op->read)
|
return -EPERM;
|
|
while (sum<len) {
|
rlen =fp->f_op->read(fp, (char __force __user *)buf+sum, len-sum, &fp->f_pos);
|
if (rlen>0)
|
sum+=rlen;
|
else if (0 != rlen)
|
return rlen;
|
else
|
break;
|
}
|
|
return sum;
|
|
}
|
|
/*
|
* Test if the specifi @param path is a file and readable
|
* @param path the path of the file to test
|
* @return Linux specific error code
|
*/
|
static int isFileReadable(char *path)
|
{
|
struct file *fp;
|
int ret = 0;
|
mm_segment_t oldfs;
|
char buf;
|
|
fp =filp_open(path, O_RDONLY, 0);
|
if (IS_ERR(fp)) {
|
ret = PTR_ERR(fp);
|
}
|
else {
|
oldfs = get_fs(); set_fs(get_ds());
|
|
if (1!=readFile(fp, &buf, 1))
|
ret = -EINVAL;
|
|
set_fs(oldfs);
|
filp_close(fp, NULL);
|
}
|
return ret;
|
}
|
|
/*
|
* Open the file with @param path and retrive the file content into memory starting from @param buf for @param sz at most
|
* @param path the path of the file to open and read
|
* @param buf the starting address of the buffer to store file content
|
* @param sz how many bytes to read at most
|
* @return the byte we've read, or Linux specific error code
|
*/
|
static int retriveFromFile(char *path, u8 *buf, u32 sz)
|
{
|
int ret =-1;
|
mm_segment_t oldfs;
|
struct file *fp;
|
|
if (path && buf) {
|
if (0 == (ret =openFile(&fp, path, O_RDONLY, 0))) {
|
DBG_871X("%s openFile path:%s fp =%p\n", __func__, path , fp);
|
|
oldfs = get_fs(); set_fs(get_ds());
|
ret =readFile(fp, buf, sz);
|
set_fs(oldfs);
|
closeFile(fp);
|
|
DBG_871X("%s readFile, ret:%d\n", __func__, ret);
|
|
} else {
|
DBG_871X("%s openFile path:%s Fail, ret:%d\n", __func__, path, ret);
|
}
|
} else {
|
DBG_871X("%s NULL pointer\n", __func__);
|
ret = -EINVAL;
|
}
|
return ret;
|
}
|
|
/*
|
* Test if the specifi @param path is a file and readable
|
* @param path the path of the file to test
|
* @return true or false
|
*/
|
int rtw_is_file_readable(char *path)
|
{
|
if (isFileReadable(path) == 0)
|
return true;
|
else
|
return false;
|
}
|
|
/*
|
* Open the file with @param path and retrive the file content into memory starting from @param buf for @param sz at most
|
* @param path the path of the file to open and read
|
* @param buf the starting address of the buffer to store file content
|
* @param sz how many bytes to read at most
|
* @return the byte we've read
|
*/
|
int rtw_retrive_from_file(char *path, u8 *buf, u32 sz)
|
{
|
int ret =retriveFromFile(path, buf, sz);
|
return ret>= 0?ret:0;
|
}
|
|
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;
|
|
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 = vzalloc(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;
|
|
vfree(pnpi->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);
|
|
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;
|
}
|
|
return 0;
|
|
error:
|
|
return -1;
|
|
}
|
|
u64 rtw_modular64(u64 x, u64 y)
|
{
|
return do_div(x, y);
|
}
|
|
void rtw_buf_free(u8 **buf, u32 *buf_len)
|
{
|
u32 ori_len;
|
|
if (!buf || !buf_len)
|
return;
|
|
ori_len = *buf_len;
|
|
if (*buf) {
|
*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 */
|
if (ori && ori_len > 0)
|
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;
|
|
DBG_871X("%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;
|
|
DBG_871X("%s on %u\n", __func__, cbuf->read);
|
buf = cbuf->bufs[cbuf->read];
|
cbuf->read = (cbuf->read+1)%cbuf->size;
|
|
return buf;
|
}
|
|
/**
|
* rtw_cbuf_alloc - allocte 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 = rtw_malloc(sizeof(*cbuf) + sizeof(void *) * size);
|
|
if (cbuf) {
|
cbuf->write = cbuf->read = 0;
|
cbuf->size = size;
|
}
|
|
return cbuf;
|
}
|
