drivers/misc/mediatek/connectivity/conn_soc/common/linux/include/osal.h

   1 /*
   2 * Copyright (C) 2011-2014 MediaTek Inc.
   3 *
   4 * This program is free software: you can redistribute it and/or modify it under the terms of the
   5 * GNU General Public License version 2 as published by the Free Software Foundation.
   6 *
   7 * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
   8 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   9 * See the GNU General Public License for more details.
  10 *
  11 * You should have received a copy of the GNU General Public License along with this program.
  12 * If not, see <http://www.gnu.org/licenses/>.
  13 */
  14
  15 /*! \file
  16     \brief  Declaration of library functions
  17
  18     Any definitions in this file will be shared among GLUE Layer and internal Driver Stack.
  19 */
  20
  21
  22
  23 #ifndef _OSAL_H_
  24 #define _OSAL_H_
  25
  26 #include <osal_typedef.h>
  27 /*******************************************************************************
  28 *                         C O M P I L E R   F L A G S
  29 ********************************************************************************
  30 */
  31
  32 /*******************************************************************************
  33 *                                 M A C R O S
  34 ********************************************************************************
  35 */
  36
  37 #define OS_BIT_OPS_SUPPORT 1
  38
  39 #define _osal_inline_ inline
  40
  41 #define MAX_THREAD_NAME_LEN 16
  42 #define MAX_WAKE_LOCK_NAME_LEN 16
  43 #define OSAL_OP_BUF_SIZE    64
  44 #define OSAL_OP_DATA_SIZE   32
  45 #define DBG_LOG_STR_SIZE    512
  46
  47 #define osal_sizeof(x) sizeof(x)
  48
  49 #define osal_array_size(x) sizeof(x)/sizeof(x[0])
  50
  51 #ifndef NAME_MAX
  52 #define NAME_MAX 256
  53 #endif
  54
  55
  56 #define WMT_OP_BIT(x) (0x1UL << x)
  57 #define WMT_OP_HIF_BIT WMT_OP_BIT(0)
  58
  59
  60 #define RB_SIZE(prb) ((prb)->size)
  61 #define RB_MASK(prb) (RB_SIZE(prb) - 1)
  62 #define RB_COUNT(prb) ((prb)->write - (prb)->read)
  63 #define RB_FULL(prb) (RB_COUNT(prb) >= RB_SIZE(prb))
  64 #define RB_EMPTY(prb) ((prb)->write == (prb)->read)
  65
  66 #define RB_INIT(prb, qsize) \
  67    { \
  68    (prb)->read = (prb)->write = 0; \
  69    (prb)->size = (qsize); \
  70    }
  71
  72 #define RB_PUT(prb, value) \
  73 { \
  74     if (!RB_FULL( prb )) { \
  75         (prb)->queue[ (prb)->write & RB_MASK(prb) ] = value; \
  76         ++((prb)->write); \
  77     } \
  78     else { \
  79         osal_assert(!RB_FULL(prb)); \
  80     } \
  81 }
  82
  83 #define RB_GET(prb, value) \
  84 { \
  85     if (!RB_EMPTY(prb)) { \
  86         value = (prb)->queue[ (prb)->read & RB_MASK(prb) ]; \
  87         ++((prb)->read); \
  88         if (RB_EMPTY(prb)) { \
  89             (prb)->read = (prb)->write = 0; \
  90         } \
  91     } \
  92     else { \
  93         value = NULL; \
  94         osal_assert(!RB_EMPTY(prb)); \
  95     } \
  96 }
  97
  98 /*******************************************************************************
  99 *                    E X T E R N A L   R E F E R E N C E S
 100 ********************************************************************************
 101 */
 102
 103 /*******************************************************************************
 104 *                              C O N S T A N T S
 105 ********************************************************************************
 106 */
 107
 108
 109
 110 /*******************************************************************************
 111 *                             D A T A   T Y P E S
 112 ********************************************************************************
 113 */
 114
 115
 116
 117 typedef VOID  (*P_TIMEOUT_HANDLER)(unsigned long);
 118 typedef INT32 (*P_COND)(VOID *);
 119
 120 typedef struct _OSAL_TIMER_
 121 {
 122     struct timer_list timer;
 123     P_TIMEOUT_HANDLER timeoutHandler;
 124     unsigned long timeroutHandlerData;
 125 }OSAL_TIMER, *P_OSAL_TIMER;
 126
 127 typedef struct _OSAL_UNSLEEPABLE_LOCK_
 128 {
 129     spinlock_t lock;
 130     unsigned long flag;
 131 }OSAL_UNSLEEPABLE_LOCK, *P_OSAL_UNSLEEPABLE_LOCK;
 132
 133 typedef struct _OSAL_SLEEPABLE_LOCK_
 134 {
 135     struct mutex lock;
 136 }OSAL_SLEEPABLE_LOCK, *P_OSAL_SLEEPABLE_LOCK;
 137
 138
 139 typedef struct _OSAL_SIGNAL_
 140 {
 141     struct completion comp;
 142     UINT32 timeoutValue;
 143 }OSAL_SIGNAL, *P_OSAL_SIGNAL;
 144
 145
 146 typedef struct _OSAL_EVENT_
 147 {
 148     wait_queue_head_t waitQueue;
 149 //    VOID *pWaitQueueData;
 150     UINT32 timeoutValue;
 151     INT32 waitFlag;
 152
 153 }OSAL_EVENT, *P_OSAL_EVENT;
 154
 155 typedef struct _OSAL_THREAD_
 156 {
 157     struct task_struct *pThread;
 158     VOID *pThreadFunc;
 159     VOID *pThreadData;
 160     char threadName[MAX_THREAD_NAME_LEN];
 161 }OSAL_THREAD, *P_OSAL_THREAD;
 162
 163 typedef struct _OSAL_FIFO_
 164 {
 165     /*fifo definition*/
 166     VOID  *pFifoBody;
 167     spinlock_t fifoSpinlock;
 168     /*fifo operations*/
 169     INT32 (*FifoInit)(struct _OSAL_FIFO_ *pFifo, UINT8 *buf, UINT32);
 170     INT32 (*FifoDeInit)(struct _OSAL_FIFO_  *pFifo);
 171     INT32 (*FifoReset)(struct _OSAL_FIFO_  *pFifo);
 172     INT32 (*FifoSz)(struct _OSAL_FIFO_  *pFifo);
 173     INT32 (*FifoAvailSz)(struct _OSAL_FIFO_  *pFifo);
 174     INT32 (*FifoLen)(struct _OSAL_FIFO_  *pFifo);
 175     INT32 (*FifoIsEmpty)(struct _OSAL_FIFO_  *pFifo);
 176     INT32 (*FifoIsFull)(struct _OSAL_FIFO_  *pFifo);
 177     INT32 (*FifoDataIn)(struct _OSAL_FIFO_  *pFifo, const VOID *buf, UINT32 len);
 178     INT32 (*FifoDataOut)(struct _OSAL_FIFO_  *pFifo, void *buf, UINT32 len);
 179 } OSAL_FIFO, *P_OSAL_FIFO;
 180
 181 typedef struct firmware osal_firmware;
 182
 183 typedef struct _OSAL_OP_DAT {
 184     UINT32 opId; // Event ID
 185     UINT32 u4InfoBit; // Reserved
 186     SIZE_T au4OpData[OSAL_OP_DATA_SIZE]; // OP Data
 187 } OSAL_OP_DAT, *P_OSAL_OP_DAT;
 188
 189 typedef struct _OSAL_LXOP_ {
 190     OSAL_OP_DAT op;
 191     OSAL_SIGNAL signal;
 192     INT32 result;
 193 } OSAL_OP, *P_OSAL_OP;
 194
 195 typedef struct _OSAL_LXOP_Q {
 196     OSAL_SLEEPABLE_LOCK sLock;
 197     UINT32 write;
 198     UINT32 read;
 199     UINT32 size;
 200     P_OSAL_OP queue[OSAL_OP_BUF_SIZE];
 201 } OSAL_OP_Q, *P_OSAL_OP_Q;
 202
 203 typedef struct _OSAL_WAKE_LOCK_
 204 {
 205    struct wake_lock        wake_lock;
 206    UINT8  name[MAX_WAKE_LOCK_NAME_LEN];
 207 } OSAL_WAKE_LOCK, *P_OSAL_WAKE_LOCK;
 208 #if 1
 209 typedef struct _OSAL_BIT_OP_VAR_
 210 {
 211     unsigned long data;
 212     OSAL_UNSLEEPABLE_LOCK opLock;
 213 }OSAL_BIT_OP_VAR, *P_OSAL_BIT_OP_VAR;
 214 #else
 215 #define OSAL_BIT_OP_VAR unsigned long
 216 #define P_OSAL_BIT_OP_VAR unsigned long *
 217
 218
 219 #endif
 220 typedef UINT32 (*P_OSAL_EVENT_CHECKER)(P_OSAL_THREAD pThread);
 221 /*******************************************************************************
 222 *                            P U B L I C   D A T A
 223 ********************************************************************************
 224 */
 225
 226 /*******************************************************************************
 227 *                           P R I V A T E   D A T A
 228 ********************************************************************************
 229 */
 230
 231
 232
 233
 234
 235 /*******************************************************************************
 236 *                  F U N C T I O N   D E C L A R A T I O N S
 237 ********************************************************************************
 238 */
 239
 240 extern UINT32 osal_strlen(const char *str);
 241 extern INT32 osal_strcmp(const char *dst, const char *src);
 242 extern INT32 osal_strncmp(const char *dst, const char *src, UINT32 len);
 243 extern char * osal_strcpy(char *dst, const char *src);
 244 extern char * osal_strncpy(char *dst, const char *src, UINT32 len);
 245 extern char * osal_strcat(char *dst, const char *src);
 246 extern char * osal_strncat(char *dst, const char *src, UINT32 len);
 247 extern char * osal_strchr(const char *str, UINT8 c);
 248 extern char * osal_strsep(char **str, const char *c);
 249 extern long osal_strtol(const char *str, char **c, UINT32 adecimal);
 250 extern INT32 osal_snprintf(char *buf, UINT32 len, const char*fmt, ...);
 251 extern char *osal_strstr(char *str1, const char *str2);
 252
 253 extern INT32 osal_print(const char *str, ...);
 254 extern INT32 osal_dbg_print(const char *str, ...);
 255
 256
 257 extern INT32 osal_dbg_assert(INT32 expr, const char *file, INT32 line);
 258 extern INT32 osal_sprintf(char *str, const char *format, ...);
 259 extern VOID* osal_malloc(UINT32 size);
 260 extern VOID  osal_free(const VOID *dst);
 261 extern VOID* osal_memset(VOID *buf, INT32 i, UINT32 len);
 262 extern VOID* osal_memcpy(VOID *dst, const VOID *src, UINT32 len);
 263 extern INT32 osal_memcmp(const VOID *buf1, const VOID *buf2, UINT32 len);
 264
 265 extern INT32 osal_sleep_ms(UINT32 ms);
 266 extern INT32 osal_udelay(UINT32 us);
 267 extern INT32 osal_timer_create(P_OSAL_TIMER);
 268 extern INT32 osal_timer_start(P_OSAL_TIMER, UINT32);
 269 extern INT32 osal_timer_stop(P_OSAL_TIMER);
 270 extern INT32 osal_timer_stop_sync(P_OSAL_TIMER pTimer);
 271 extern INT32 osal_timer_modify(P_OSAL_TIMER, UINT32);
 272 extern INT32 osal_timer_delete(P_OSAL_TIMER);
 273
 274 extern INT32  osal_fifo_init(P_OSAL_FIFO pFifo, UINT8 *buffer, UINT32 size);
 275 extern VOID   osal_fifo_deinit(P_OSAL_FIFO pFifo);
 276 extern INT32  osal_fifo_reset(P_OSAL_FIFO pFifo);
 277 extern UINT32 osal_fifo_in(P_OSAL_FIFO pFifo, PUINT8 buffer, UINT32 size);
 278 extern UINT32 osal_fifo_out(P_OSAL_FIFO pFifo, PUINT8 buffer, UINT32 size);
 279 extern UINT32 osal_fifo_len(P_OSAL_FIFO pFifo);
 280 extern UINT32 osal_fifo_sz(P_OSAL_FIFO pFifo);
 281 extern UINT32 osal_fifo_avail(P_OSAL_FIFO pFifo);
 282 extern UINT32 osal_fifo_is_empty(P_OSAL_FIFO pFifo);
 283 extern UINT32 osal_fifo_is_full(P_OSAL_FIFO pFifo);
 284
 285 extern INT32  osal_wake_lock_init(P_OSAL_WAKE_LOCK plock);
 286 extern INT32  osal_wake_lock(P_OSAL_WAKE_LOCK plock);
 287 extern INT32  osal_wake_unlock(P_OSAL_WAKE_LOCK plock);
 288 extern INT32  osal_wake_lock_count(P_OSAL_WAKE_LOCK plock);
 289
 290 #if defined(CONFIG_PROVE_LOCKING)
 291 #define osal_unsleepable_lock_init(l) { spin_lock_init(&((l)->lock));}
 292 #else
 293 extern INT32 osal_unsleepable_lock_init (P_OSAL_UNSLEEPABLE_LOCK );
 294 #endif
 295 extern INT32 osal_lock_unsleepable_lock (P_OSAL_UNSLEEPABLE_LOCK );
 296 extern INT32 osal_unlock_unsleepable_lock (P_OSAL_UNSLEEPABLE_LOCK );
 297 extern INT32 osal_unsleepable_lock_deinit (P_OSAL_UNSLEEPABLE_LOCK );
 298
 299 #if defined(CONFIG_PROVE_LOCKING)
 300 #define osal_sleepable_lock_init(l) { mutex_init(&((l)->lock));}
 301 #else
 302 extern INT32 osal_sleepable_lock_init (P_OSAL_SLEEPABLE_LOCK );
 303 #endif
 304 extern INT32 osal_lock_sleepable_lock (P_OSAL_SLEEPABLE_LOCK );
 305 extern INT32 osal_unlock_sleepable_lock (P_OSAL_SLEEPABLE_LOCK );
 306 extern INT32 osal_sleepable_lock_deinit (P_OSAL_SLEEPABLE_LOCK );
 307
 308 extern INT32 osal_signal_init (P_OSAL_SIGNAL);
 309 extern INT32 osal_wait_for_signal (P_OSAL_SIGNAL);
 310 extern INT32
 311 osal_wait_for_signal_timeout (
 312     P_OSAL_SIGNAL
 313     );
 314 extern INT32
 315 osal_raise_signal (
 316     P_OSAL_SIGNAL
 317     );
 318 extern INT32
 319 osal_signal_deinit (
 320     P_OSAL_SIGNAL
 321     );
 322
 323 extern INT32 osal_event_init(P_OSAL_EVENT);
 324 extern INT32 osal_wait_for_event(P_OSAL_EVENT, P_COND , void *);
 325 extern INT32 osal_wait_for_event_timeout(P_OSAL_EVENT , P_COND , void *);
 326 extern INT32 osal_trigger_event(P_OSAL_EVENT);
 327
 328 extern INT32 osal_event_deinit (P_OSAL_EVENT);
 329
 330 extern INT32 osal_thread_create(P_OSAL_THREAD);
 331 extern INT32 osal_thread_run(P_OSAL_THREAD);
 332 extern INT32 osal_thread_should_stop(P_OSAL_THREAD);
 333 extern INT32 osal_thread_stop(P_OSAL_THREAD);
 334 /*extern INT32 osal_thread_wait_for_event(P_OSAL_THREAD, P_OSAL_EVENT);*/
 335 extern INT32 osal_thread_wait_for_event(P_OSAL_THREAD, P_OSAL_EVENT, P_OSAL_EVENT_CHECKER);
 336 /*check pOsalLxOp and OSAL_THREAD_SHOULD_STOP*/
 337 extern INT32 osal_thread_destroy(P_OSAL_THREAD);
 338
 339 extern INT32 osal_clear_bit(UINT32 bitOffset, P_OSAL_BIT_OP_VAR pData);
 340 extern INT32 osal_set_bit(UINT32 bitOffset, P_OSAL_BIT_OP_VAR pData);
 341 extern INT32 osal_test_bit(UINT32 bitOffset, P_OSAL_BIT_OP_VAR pData);
 342 extern INT32 osal_test_and_clear_bit(UINT32 bitOffset, P_OSAL_BIT_OP_VAR pData);
 343 extern INT32 osal_test_and_set_bit(UINT32 bitOffset, P_OSAL_BIT_OP_VAR pData);
 344
 345 extern INT32 osal_dbg_assert_aee(const char *module, const char *detail_description);
 346 extern INT32 osal_gettimeofday(PINT32 sec, PINT32 usec);
 347 extern INT32 osal_printtimeofday(const PUINT8 prefix);
 348
 349 extern VOID
 350 osal_buffer_dump (
 351     const UINT8 *buf,
 352     const UINT8 *title,
 353     UINT32 len,
 354     UINT32 limit
 355     );
 356
 357 extern UINT32 osal_op_get_id(P_OSAL_OP pOp);
 358 extern MTK_WCN_BOOL osal_op_is_wait_for_signal(P_OSAL_OP pOp);
 359 extern VOID osal_op_raise_signal(P_OSAL_OP pOp, INT32 result);
 360 extern VOID osal_set_op_result(P_OSAL_OP pOp, INT32 result);
 361 extern UINT16 osal_crc16(const UINT8 *buffer, const UINT32 length);
 362 /*******************************************************************************
 363 *                              F U N C T I O N S
 364 ********************************************************************************
 365 */
 366
 367 #define osal_err_print(fmt, arg...) osal_print(KERN_ERR fmt, ##arg)
 368 #define osal_warn_print(fmt, arg...) osal_print(KERN_ERR fmt, ##arg)
 369 #define osal_info_print(fmt, arg...) osal_print(KERN_ERR fmt, ##arg)
 370 #define osal_load_print(fmt, arg...) osal_print(KERN_DEBUG fmt, ##arg)
 371 #define osal_assert(condition) if (!(condition)) {osal_err_print("%s, %d, (%s)\n", __FILE__, __LINE__, #condition);}
 372
 373 #endif /* _OSAL_H_ */
 374