Pileus Git - ~andy/linux/blob - drivers/staging/rtl8712/osdep_service.h

   1 /******************************************************************************
   2  *
   3  * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of version 2 of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12  * more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along with
  15  * this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17  *
  18  * Modifications for inclusion into the Linux staging tree are
  19  * Copyright(c) 2010 Larry Finger. All rights reserved.
  20  *
  21  * Contact information:
  22  * WLAN FAE <wlanfae@realtek.com>
  23  * Larry Finger <Larry.Finger@lwfinger.net>
  24  *
  25  ******************************************************************************/
  26 #ifndef __OSDEP_SERVICE_H_
  27 #define __OSDEP_SERVICE_H_
  28
  29 #define _SUCCESS        1
  30 #define _FAIL           0
  31
  32 #include <linux/spinlock.h>
  33
  34 #include <linux/interrupt.h>
  35 #include <linux/semaphore.h>
  36 #include <linux/sched.h>
  37 #include <linux/sem.h>
  38 #include <linux/netdevice.h>
  39 #include <linux/etherdevice.h>
  40 #include <net/iw_handler.h>
  41 #include <linux/proc_fs.h>      /* Necessary because we use the proc fs */
  42
  43 #include "basic_types.h"
  44
  45 struct  __queue {
  46         struct  list_head       queue;
  47         spinlock_t lock;
  48 };
  49
  50 #define _pkt struct sk_buff
  51 #define _buffer unsigned char
  52 #define thread_exit() complete_and_exit(NULL, 0)
  53 #define _workitem struct work_struct
  54
  55 #define _init_queue(pqueue)                             \
  56         do {                                            \
  57                 _init_listhead(&((pqueue)->queue));     \
  58                 spin_lock_init(&((pqueue)->lock));      \
  59         } while (0)
  60
  61 static inline struct list_head *get_next(struct list_head *list)
  62 {
  63         return list->next;
  64 }
  65
  66 static inline struct list_head *get_list_head(struct  __queue *queue)
  67 {
  68         return &(queue->queue);
  69 }
  70
  71 #define LIST_CONTAINOR(ptr, type, member) \
  72         ((type *)((char *)(ptr)-(SIZE_T)(&((type *)0)->member)))
  73
  74 static inline void list_delete(struct list_head *plist)
  75 {
  76         list_del_init(plist);
  77 }
  78
  79 static inline void _init_timer(struct timer_list *ptimer,
  80                                struct  net_device *padapter,
  81                                void *pfunc, void *cntx)
  82 {
  83         ptimer->function = pfunc;
  84         ptimer->data = (addr_t)cntx;
  85         init_timer(ptimer);
  86 }
  87
  88 static inline void _set_timer(struct timer_list *ptimer, u32 delay_time)
  89 {
  90         mod_timer(ptimer, (jiffies+(delay_time*HZ/1000)));
  91 }
  92
  93 static inline void _cancel_timer(struct timer_list *ptimer, u8 *bcancelled)
  94 {
  95         del_timer(ptimer);
  96         *bcancelled = true; /*true ==1; false==0*/
  97 }
  98
  99 static inline void _init_workitem(_workitem *pwork, void *pfunc, void *cntx)
 100 {
 101         INIT_WORK(pwork, pfunc);
 102 }
 103
 104 static inline void _set_workitem(_workitem *pwork)
 105 {
 106         schedule_work(pwork);
 107 }
 108
 109 #ifndef BIT
 110         #define BIT(x)  (1 << (x))
 111 #endif
 112
 113 /*
 114 For the following list_xxx operations,
 115 caller must guarantee the atomic context.
 116 Otherwise, there will be racing condition.
 117 */
 118 static inline u32 is_list_empty(struct list_head *phead)
 119 {
 120         if (list_empty(phead))
 121                 return true;
 122         else
 123                 return false;
 124 }
 125
 126 static inline void list_insert_tail(struct list_head *plist,
 127                                     struct list_head *phead)
 128 {
 129         list_add_tail(plist, phead);
 130 }
 131
 132 static inline u32 _down_sema(struct semaphore *sema)
 133 {
 134         if (down_interruptible(sema))
 135                 return _FAIL;
 136         else
 137                 return _SUCCESS;
 138 }
 139
 140 static inline void _init_listhead(struct list_head *list)
 141 {
 142         INIT_LIST_HEAD(list);
 143 }
 144
 145 static inline u32 _queue_empty(struct  __queue *pqueue)
 146 {
 147         return is_list_empty(&(pqueue->queue));
 148 }
 149
 150 static inline u32 end_of_queue_search(struct list_head *head, struct list_head *plist)
 151 {
 152         if (head == plist)
 153                 return true;
 154         else
 155                 return false;
 156 }
 157
 158 static inline void sleep_schedulable(int ms)
 159 {
 160         u32 delta;
 161
 162         delta = (ms * HZ) / 1000;/*(ms)*/
 163         if (delta == 0)
 164                 delta = 1;/* 1 ms */
 165         set_current_state(TASK_INTERRUPTIBLE);
 166         if (schedule_timeout(delta) != 0)
 167                 return ;
 168 }
 169
 170 static inline u8 *_malloc(u32 sz)
 171 {
 172         return  kmalloc(sz, GFP_ATOMIC);
 173 }
 174
 175 static inline unsigned char _cancel_timer_ex(struct timer_list *ptimer)
 176 {
 177         return del_timer(ptimer);
 178 }
 179
 180 static inline void thread_enter(void *context)
 181 {
 182         allow_signal(SIGTERM);
 183 }
 184
 185 static inline void flush_signals_thread(void)
 186 {
 187         if (signal_pending(current))
 188                 flush_signals(current);
 189 }
 190
 191 static inline u32 _RND8(u32 sz)
 192 {
 193         return ((sz >> 3) + ((sz & 7) ? 1 : 0)) << 3;
 194 }
 195
 196 static inline u32 _RND128(u32 sz)
 197 {
 198         return ((sz >> 7) + ((sz & 127) ? 1 : 0)) << 7;
 199 }
 200
 201 static inline u32 _RND256(u32 sz)
 202 {
 203         return ((sz >> 8) + ((sz & 255) ? 1 : 0)) << 8;
 204 }
 205
 206 static inline u32 _RND512(u32 sz)
 207 {
 208         return ((sz >> 9) + ((sz & 511) ? 1 : 0)) << 9;
 209 }
 210
 211 #endif
 212