#define RT_TAG '1178'
+
/*
* 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)
+inline int RTW_STATUS_CODE(int error_code){
+ if(error_code >=0)
return _SUCCESS;
- switch (error_code) {
+ switch(error_code) {
//case -ETIMEDOUT:
// return RTW_STATUS_TIMEDOUT;
default:
}
}
-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 = _rtw_vmalloc(sz);
if (pbuf != NULL)
memset(pbuf, 0, sz);
+
return pbuf;
}
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)
+ if (pbuf != NULL) {
memset(pbuf, 0, sz);
+ }
+
return pbuf;
}
kfree(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)
- {
- DBG_871X("%s: alloc memory fail!\n", __FUNCTION__);
- 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)
-{
- rtw_mfree((u8 *)pbuf, h*sizeof(void*) + w*h*size);
-}
-
-int _rtw_memcmp(void *dst, void *src, u32 sz)
-{
-//under Linux/GNU/GLibc, the return value of memcmp for two same mem. chunk is 0
- if (!(memcmp(dst, src, sz)))
- return true;
- else
- return false;
-}
-
-void _rtw_init_listhead(_list *list)
-{
- INIT_LIST_HEAD(list);
-}
-
-/*
-For the following list_xxx operations,
-caller must guarantee the atomic context.
-Otherwise, there will be racing condition.
-*/
-u32 rtw_is_list_empty(_list *phead)
-{
- if (list_empty(phead))
- return true;
- else
- return false;
-}
-
-void rtw_list_insert_head(_list *plist, _list *phead)
-{
- list_add(plist, phead);
-}
-
-void rtw_list_insert_tail(_list *plist, _list *phead)
-{
- list_add_tail(plist, phead);
-}
-
-/*
-
-Caller must check if the list is empty before calling rtw_list_delete
-
-*/
-
-
-void _rtw_init_sema(_sema *sema, int init_val)
-{
- sema_init(sema, init_val);
-}
-
-void _rtw_free_sema(_sema *sema)
-{
-}
-
-void _rtw_up_sema(_sema *sema)
-{
- up(sema);
-}
-
-u32 _rtw_down_sema(_sema *sema)
-{
- if (down_interruptible(sema))
- return _FAIL;
- else
- return _SUCCESS;
-}
-
-void _rtw_mutex_init(_mutex *pmutex)
-{
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
- mutex_init(pmutex);
-#else
- init_MUTEX(pmutex);
-#endif
-}
-
-void _rtw_mutex_free(_mutex *pmutex)
-{
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37))
- mutex_destroy(pmutex);
-#endif
-}
-
-void _rtw_spinlock_init(_lock *plock)
-{
- spin_lock_init(plock);
-}
-
-void _rtw_spinlock_free(_lock *plock)
-{
-}
-
-void _rtw_spinlock(_lock *plock)
-{
- spin_lock(plock);
-}
-
-void _rtw_spinunlock(_lock *plock)
-{
- spin_unlock(plock);
-}
-
-void _rtw_spinlock_ex(_lock *plock)
-{
- spin_lock(plock);
-}
-
-void _rtw_spinunlock_ex(_lock *plock)
-{
- spin_unlock(plock);
-}
void _rtw_init_queue(_queue *pqueue)
{
- _rtw_init_listhead(&(pqueue->queue));
-
- _rtw_spinlock_init(&(pqueue->lock));
+ INIT_LIST_HEAD(&(pqueue->queue));
+ spin_lock_init(&(pqueue->lock));
}
-u32 _rtw_queue_empty(_queue *pqueue)
+u32 _rtw_queue_empty(_queue *pqueue)
{
- return (rtw_is_list_empty(&(pqueue->queue)));
+ if (list_empty(&(pqueue->queue)))
+ return _TRUE;
+ else
+ return _FALSE;
}
-u32 rtw_end_of_queue_search(_list *head, _list *plist)
+u32 rtw_end_of_queue_search(struct list_head *head, struct list_head *plist)
{
if (head == plist)
- return true;
+ return _TRUE;
else
- return false;
+ return _FALSE;
}
+
u32 rtw_get_current_time(void)
{
return jiffies;
return rtw_systime_to_ms(end-start);
}
+
void rtw_sleep_schedulable(int ms)
{
u32 delta;
return;
}
-void rtw_msleep_os(int ms)
-{
- msleep((unsigned int)ms);
-}
void rtw_usleep_os(int us)
{
msleep( (us/1000) + 1);
}
+
#ifdef DBG_DELAY_OS
void _rtw_mdelay_os(int ms, const char *func, const int line)
{
- DBG_871X("%s:%d %s(%d)\n", func, line, __FUNCTION__, ms);
+ #if 0
+ if(ms>10)
+ DBG_8723A("%s:%d %s(%d)\n", func, line, __FUNCTION__, ms);
+ rtw_msleep_os(ms);
+ return;
+ #endif
+
+
+ DBG_8723A("%s:%d %s(%d)\n", func, line, __FUNCTION__, ms);
mdelay((unsigned long)ms);
}
-
void _rtw_udelay_os(int us, const char *func, const int line)
{
- DBG_871X("%s:%d %s(%d)\n", func, line, __FUNCTION__, us);
+
+ #if 0
+ if(us > 1000) {
+ DBG_8723A("%s:%d %s(%d)\n", func, line, __FUNCTION__, us);
+ rtw_usleep_os(us);
+ return;
+ }
+ #endif
+
+
+ DBG_8723A("%s:%d %s(%d)\n", func, line, __FUNCTION__, us);
udelay((unsigned long)us);
}
}
#endif
-void rtw_yield_os()
+void rtw_yield_os(void)
{
yield();
}
};
#endif
-inline void rtw_suspend_lock_init()
+inline void rtw_suspend_lock_init(void)
{
#ifdef CONFIG_WAKELOCK
wake_lock_init(&rtw_suspend_lock, WAKE_LOCK_SUSPEND, RTW_SUSPEND_LOCK_NAME);
#endif
}
-inline void rtw_suspend_lock_uninit()
+inline void rtw_suspend_lock_uninit(void)
{
#ifdef CONFIG_WAKELOCK
wake_lock_destroy(&rtw_suspend_lock);
#endif
}
-inline void rtw_lock_suspend()
+inline void rtw_lock_suspend(void)
{
#ifdef CONFIG_WAKELOCK
wake_lock(&rtw_suspend_lock);
#endif
#if defined(CONFIG_WAKELOCK) || defined(CONFIG_ANDROID_POWER)
- //DBG_871X("####%s: suspend_lock_count:%d####\n", __FUNCTION__, rtw_suspend_lock.stat.count);
+ //DBG_8723A("####%s: suspend_lock_count:%d####\n", __FUNCTION__, rtw_suspend_lock.stat.count);
#endif
}
-inline void rtw_unlock_suspend()
+inline void rtw_unlock_suspend(void)
{
#ifdef CONFIG_WAKELOCK
wake_unlock(&rtw_suspend_lock);
#endif
#if defined(CONFIG_WAKELOCK) || defined(CONFIG_ANDROID_POWER)
- //DBG_871X("####%s: suspend_lock_count:%d####\n", __FUNCTION__, rtw_suspend_lock.stat.count);
+ //DBG_8723A("####%s: suspend_lock_count:%d####\n", __FUNCTION__, rtw_suspend_lock.stat.count);
#endif
}
}
#endif //CONFIG_WOWLAN
-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);
-}
-
/*
* 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
struct file *fp;
fp=filp_open(path, flag, mode);
- if (IS_ERR(fp)) {
+ if(IS_ERR(fp)) {
*fpp=NULL;
return PTR_ERR(fp);
}
if (!fp->f_op || !fp->f_op->read)
return -EPERM;
- while (sum<len) {
+ while(sum<len) {
rlen=fp->f_op->read(fp,buf+sum,len-sum, &fp->f_pos);
- if (rlen>0)
+ if(rlen>0)
sum+=rlen;
- else if (0 != rlen)
+ else if(0 != rlen)
return rlen;
else
break;
if (!fp->f_op || !fp->f_op->write)
return -EPERM;
- while (sum<len) {
+ while(sum<len) {
wlen=fp->f_op->write(fp,buf+sum,len-sum, &fp->f_pos);
- if (wlen>0)
+ if(wlen>0)
sum+=wlen;
- else if (0 != wlen)
+ else if(0 != wlen)
return wlen;
else
break;
char buf;
fp=filp_open(path, O_RDONLY, 0);
- if (IS_ERR(fp)) {
+ if(IS_ERR(fp)) {
ret = PTR_ERR(fp);
}
else {
oldfs = get_fs(); set_fs(get_ds());
- if (1!=readFile(fp, &buf, 1))
+ if(1!=readFile(fp, &buf, 1))
ret = PTR_ERR(fp);
set_fs(oldfs);
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",__FUNCTION__, path ,fp);
+ if(path && buf) {
+ if( 0 == (ret=openFile(&fp,path, O_RDONLY, 0)) ){
+ DBG_8723A("%s openFile path:%s fp=%p\n",__FUNCTION__, 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",__FUNCTION__, ret);
+ DBG_8723A("%s readFile, ret:%d\n",__FUNCTION__, ret);
} else {
- DBG_871X("%s openFile path:%s Fail, ret:%d\n",__FUNCTION__, path, ret);
+ DBG_8723A("%s openFile path:%s Fail, ret:%d\n",__FUNCTION__, path, ret);
}
} else {
- DBG_871X("%s NULL pointer\n",__FUNCTION__);
+ DBG_8723A("%s NULL pointer\n",__FUNCTION__);
ret = -EINVAL;
}
return ret;
mm_segment_t oldfs;
struct file *fp;
- if (path && buf) {
- if ( 0 == (ret=openFile(&fp, path, O_CREAT|O_WRONLY, 0666)) ) {
- DBG_871X("%s openFile path:%s fp=%p\n",__FUNCTION__, path ,fp);
+ if(path && buf) {
+ if( 0 == (ret=openFile(&fp, path, O_CREAT|O_WRONLY, 0666)) ) {
+ DBG_8723A("%s openFile path:%s fp=%p\n",__FUNCTION__, path ,fp);
oldfs = get_fs(); set_fs(get_ds());
ret=writeFile(fp, buf, sz);
set_fs(oldfs);
closeFile(fp);
- DBG_871X("%s writeFile, ret:%d\n",__FUNCTION__, ret);
+ DBG_8723A("%s writeFile, ret:%d\n",__FUNCTION__, ret);
} else {
- DBG_871X("%s openFile path:%s Fail, ret:%d\n",__FUNCTION__, path, ret);
+ DBG_8723A("%s openFile path:%s Fail, ret:%d\n",__FUNCTION__, path, ret);
}
} else {
- DBG_871X("%s NULL pointer\n",__FUNCTION__);
+ DBG_8723A("%s NULL pointer\n",__FUNCTION__);
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
+* @return _TRUE or _FALSE
*/
int rtw_is_file_readable(char *path)
{
- if (isFileReadable(path) == 0)
- return true;
+ if(isFileReadable(path) == 0)
+ return _TRUE;
else
- return false;
+ return _FALSE;
}
/*
return ret>=0?ret:0;
}
-#if 1 //#ifdef MEM_ALLOC_REFINE_ADAPTOR
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;
- if (!netdev)
+ if(!netdev)
goto RETURN;
pnpi = netdev_priv(netdev);
- if (!pnpi->priv)
+ if(!pnpi->priv)
goto RETURN;
rtw_vmfree(pnpi->priv, pnpi->sizeof_priv);
int rtw_change_ifname(_adapter *padapter, const char *ifname)
{
struct net_device *pnetdev;
- struct net_device *cur_pnetdev = padapter->pnetdev;
+ struct net_device *cur_pnetdev;
struct rereg_nd_name_data *rereg_priv;
int ret;
- if (!padapter)
+ if(!padapter)
goto error;
+ cur_pnetdev = padapter->pnetdev;
rereg_priv = &padapter->rereg_nd_name_priv;
//free the old_pnetdev
- if (rereg_priv->old_pnetdev) {
+ if(rereg_priv->old_pnetdev) {
free_netdev(rereg_priv->old_pnetdev);
rereg_priv->old_pnetdev = NULL;
}
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
- if (!rtnl_is_locked())
+ if(!rtnl_is_locked())
unregister_netdev(cur_pnetdev);
else
-#endif
unregister_netdevice(cur_pnetdev);
rtw_proc_remove_one(cur_pnetdev);
memcpy(pnetdev->dev_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);
-#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26))
- if (!rtnl_is_locked())
+ if(!rtnl_is_locked())
ret = register_netdev(pnetdev);
else
-#endif
ret = register_netdevice(pnetdev);
if ( ret != 0) {
return -1;
}
-#endif //MEM_ALLOC_REFINE_ADAPTOR
u64 rtw_modular64(u64 x, u64 y)
{
if (ori && ori_len > 0)
_rtw_mfree(ori, ori_len);
}
+
+
+/**
+ * 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_8723A("%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_8723A("%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 = (struct rtw_cbuf *)rtw_malloc(sizeof(*cbuf) + sizeof(void*)*size);
+
+ if (cbuf) {
+ cbuf->write = cbuf->read = 0;
+ cbuf->size = size;
+ }
+
+ return cbuf;
+}
+
+/**
+ * rtw_cbuf_free - free the given rtw_cbuf
+ * @cbuf: pointer of struct rtw_cbuf to free
+ */
+void rtw_cbuf_free(struct rtw_cbuf *cbuf)
+{
+ rtw_mfree((u8*)cbuf, sizeof(*cbuf) + sizeof(void*)*cbuf->size);
+}
OSDN Git Service
