| /* |
| * Copyright (c) 2013-2016 The Linux Foundation. All rights reserved. |
| * |
| * Previously licensed under the ISC license by Qualcomm Atheros, Inc. |
| * |
| * |
| * Permission to use, copy, modify, and/or distribute this software for |
| * any purpose with or without fee is hereby granted, provided that the |
| * above copyright notice and this permission notice appear in all |
| * copies. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL |
| * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE |
| * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
| * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
| * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER |
| * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR |
| * PERFORMANCE OF THIS SOFTWARE. |
| */ |
| |
| /* |
| * This file was originally distributed by Qualcomm Atheros, Inc. |
| * under proprietary terms before Copyright ownership was assigned |
| * to the Linux Foundation. |
| */ |
| |
| |
| //------------------------------------------------------------------------------ |
| // This file contains the definitions of the basic atheros data types. |
| // It is used to map the data types in atheros files to a platform specific |
| // type. |
| //------------------------------------------------------------------------------ |
| |
| #ifndef _OSAPI_LINUX_H_ |
| #define _OSAPI_LINUX_H_ |
| |
| #ifdef __KERNEL__ |
| |
| #include <linux/version.h> |
| #include <generated/autoconf.h> |
| #include <linux/types.h> |
| #include <linux/kernel.h> |
| #include <linux/string.h> |
| #include <linux/skbuff.h> |
| #include <linux/netdevice.h> |
| #include <linux/jiffies.h> |
| #include <linux/timer.h> |
| #include <linux/delay.h> |
| #include <linux/wait.h> |
| #include <linux/semaphore.h> |
| |
| #include <linux/cache.h> |
| //#include <linux/kthread.h> |
| #include "a_types.h" |
| |
| #ifdef __GNUC__ |
| #ifndef __ATTRIB_PACK |
| #define __ATTRIB_PACK __attribute__ ((packed)) |
| #endif |
| #define __ATTRIB_PRINTF __attribute__ ((format (printf, 1, 2))) |
| #define __ATTRIB_NORETURN __attribute__ ((noreturn)) |
| #else /* Not GCC */ |
| #define __ATTRIB_PACK |
| #define __ATTRIB_PRINTF |
| #define __ATTRIB_NORETURN |
| #endif /* End __GNUC__ */ |
| |
| #define PREPACK |
| #define POSTPACK __ATTRIB_PACK |
| |
| /* |
| * Endianes macros |
| */ |
| #define A_BE2CPU8(x) ntohb(x) |
| #define A_BE2CPU16(x) ntohs(x) |
| #define A_BE2CPU32(x) ntohl(x) |
| |
| #define A_LE2CPU8(x) (x) |
| #define A_LE2CPU16(x) (x) |
| #define A_LE2CPU32(x) (x) |
| |
| #define A_CPU2BE8(x) htonb(x) |
| #define A_CPU2BE16(x) htons(x) |
| #define A_CPU2BE32(x) htonl(x) |
| |
| #define A_MEMCPY(dst, src, len) memcpy((A_UINT8 *)(dst), (src), (len)) |
| #define A_MEMZERO(addr, len) memset(addr, 0, len) |
| #define A_MEMSET(addr, value, size) memset((addr), (value), (size)) |
| #define A_MEMCMP(addr1, addr2, len) memcmp((addr1), (addr2), (len)) |
| |
| #ifdef AR6K_ALLOC_DEBUG |
| #define a_meminfo_add(p, s) __a_meminfo_add(p, s, __func__, __LINE) |
| #define a_mem_trace(ptr) __a_mem_trace(ptr, __func__, __LINE__) |
| void __a_mem_trace(void *ptr, const char *func, int lineno); |
| void __a_meminfo_add(void *ptr, size_t msize, const char *func, int lineno); |
| void a_meminfo_del(void *ptr); |
| void* a_mem_alloc(size_t msize, int type, const char *func, int lineno); |
| void a_mem_free(void *ptr); |
| void a_meminfo_report(int clear); |
| #define A_MALLOC(size) a_mem_alloc((size), GFP_KERNEL, __func__, __LINE__) |
| #define A_MALLOC_NOWAIT(size) a_mem_alloc((size), GFP_ATOMIC, __func__, __LINE__) |
| #define A_FREE(addr) a_mem_free(addr) |
| #define A_NETIF_RX(skb) do { a_meminfo_del(skb); netif_rx(skb); } while (0) |
| #define A_NETIF_RX_NI(skb) do { a_meminfo_del(skb); netif_rx_ni(skb); } while (0) |
| #else |
| #define a_meminfo_report(_c) |
| #define A_MALLOC(size) adf_os_mem_alloc(NULL, size) |
| #define A_MALLOC_NOWAIT(size) kmalloc((size), GFP_ATOMIC) |
| #define a_mem_trace(ptr) |
| #define A_FREE(addr) adf_os_mem_free(addr) |
| #define A_NETIF_RX(skb) netif_rx(skb) |
| #define A_NETIF_RX_NI(skb) netif_rx_ni(skb) |
| #endif |
| |
| #define OS_DMA_MALLOC(size) kmalloc((size), GFP_ATOMIC) |
| #define OS_DMA_FREE(addr) kfree(addr) |
| |
| #define A_VMALLOC(size) vmalloc((size)) |
| #define A_VFREE(addr) vfree(addr) |
| #if defined(ANDROID_ENV) && defined(CONFIG_ANDROID_LOGGER) |
| extern unsigned int enablelogcat; |
| extern int android_logger_lv(void* module, int mask); |
| enum logidx { LOG_MAIN_IDX = 0 }; |
| extern int logger_write(const enum logidx idx, |
| const unsigned char prio, |
| const char __kernel * const tag, |
| const char __kernel * const fmt, |
| ...); |
| #define A_ANDROID_PRINTF(mask, module, tags, args...) do { \ |
| if (enablelogcat) \ |
| logger_write(LOG_MAIN_IDX, android_logger_lv(module, mask), tags, args); \ |
| else \ |
| printk(KERN_ALERT args); \ |
| } while (0) |
| #ifdef WLAN_DEBUG |
| #define A_LOGGER_MODULE_NAME(x) #x |
| #define A_LOGGER(mask, mod, args...) \ |
| A_ANDROID_PRINTF(mask, &GET_ATH_MODULE_DEBUG_VAR_NAME(mod), "ar6k_" A_LOGGER_MODULE_NAME(mod), args); |
| #endif |
| #define A_PRINTF(args...) A_ANDROID_PRINTF(ATH_DEBUG_INFO, NULL, "ar6k_driver", args) |
| #else |
| #define A_LOGGER(mask, mod, args...) printk(args) |
| #define A_PRINTF(args...) printk(args) |
| #endif /* ANDROID */ |
| #define A_PRINTF_LOG(args...) printk(args) |
| #define A_SNPRINTF(buf, len, args...) snprintf (buf, len, args) |
| |
| /* Mutual Exclusion */ |
| typedef spinlock_t A_MUTEX_T; |
| #define A_MUTEX_INIT(mutex) spin_lock_init(mutex) |
| #define A_MUTEX_LOCK(mutex) SPIN_LOCK_BH(mutex) |
| #define A_MUTEX_UNLOCK(mutex) SPIN_UNLOCK_BH(mutex) |
| #define A_IS_MUTEX_VALID(mutex) TRUE /* okay to return true, since A_MUTEX_DELETE does nothing */ |
| #define A_MUTEX_DELETE(mutex) /* spin locks are not kernel resources so nothing to free.. */ |
| |
| /* Get current time in ms adding a constant offset (in ms) */ |
| #define A_GET_MS(offset) \ |
| (((jiffies / HZ) * 1000) + (offset)) |
| |
| /* |
| * Timer Functions |
| */ |
| #define A_MDELAY(msecs) mdelay(msecs) |
| #define A_MSLEEP(msecs) \ |
| { \ |
| set_current_state(TASK_INTERRUPTIBLE); \ |
| schedule_timeout((HZ * (msecs)) / 1000); \ |
| set_current_state(TASK_RUNNING); \ |
| } |
| |
| typedef struct timer_list A_TIMER; |
| |
| #define A_INIT_TIMER(pTimer, pFunction, pArg) do { \ |
| init_timer_deferrable(pTimer); \ |
| (pTimer)->function = (pFunction); \ |
| (pTimer)->data = (unsigned long)(pArg); \ |
| } while (0) |
| |
| /* |
| * Start a Timer that elapses after 'periodMSec' milli-seconds |
| * Support is provided for a one-shot timer. The 'repeatFlag' is |
| * ignored. |
| */ |
| #define A_TIMEOUT_MS(pTimer, periodMSec, repeatFlag) do { \ |
| if (repeatFlag) { \ |
| printk("\n" __FILE__ ":%d: Timer Repeat requested\n",__LINE__); \ |
| panic("Timer Repeat"); \ |
| } \ |
| mod_timer((pTimer), jiffies + HZ * (periodMSec) / 1000); \ |
| } while (0) |
| |
| /* |
| * Cancel the Timer. |
| */ |
| #define A_UNTIMEOUT(pTimer) do { \ |
| del_timer((pTimer)); \ |
| } while (0) |
| |
| #define A_DELETE_TIMER(pTimer) do { \ |
| } while (0) |
| |
| /* |
| * Wait Queue related functions |
| */ |
| typedef wait_queue_head_t A_WAITQUEUE_HEAD; |
| #define A_INIT_WAITQUEUE_HEAD(head) init_waitqueue_head(head) |
| #ifndef wait_event_interruptible_timeout |
| #define __wait_event_interruptible_timeout(wq, condition, ret) \ |
| do { \ |
| wait_queue_t __wait; \ |
| init_waitqueue_entry(&__wait, current); \ |
| \ |
| add_wait_queue(&wq, &__wait); \ |
| for (;;) { \ |
| set_current_state(TASK_INTERRUPTIBLE); \ |
| if (condition) \ |
| break; \ |
| if (!signal_pending(current)) { \ |
| ret = schedule_timeout(ret); \ |
| if (!ret) \ |
| break; \ |
| continue; \ |
| } \ |
| ret = -ERESTARTSYS; \ |
| break; \ |
| } \ |
| current->state = TASK_RUNNING; \ |
| remove_wait_queue(&wq, &__wait); \ |
| } while (0) |
| |
| #define wait_event_interruptible_timeout(wq, condition, timeout) \ |
| ({ \ |
| long __ret = timeout; \ |
| if (!(condition)) \ |
| __wait_event_interruptible_timeout(wq, condition, __ret); \ |
| __ret; \ |
| }) |
| #endif /* wait_event_interruptible_timeout */ |
| |
| #define A_WAIT_EVENT_INTERRUPTIBLE_TIMEOUT(head, condition, timeout) do { \ |
| wait_event_interruptible_timeout(head, condition, timeout); \ |
| } while (0) |
| |
| #define A_WAKE_UP(head) wake_up(head) |
| |
| #ifdef WLAN_DEBUG |
| #ifdef A_SIMOS_DEVHOST |
| extern unsigned int panic_on_assert; |
| #define A_ASSERT(expr) \ |
| if (!(expr)) { \ |
| printk(KERN_ALERT"Debug Assert Caught, File %s, Line: %d, Test:%s \n",__FILE__, __LINE__,#expr); \ |
| if (panic_on_assert) panic(#expr); \ |
| } |
| #else |
| #define A_ASSERT(expr) \ |
| if (!(expr)) { \ |
| printk(KERN_ALERT "Debug Assert Caught, File %s, Line: %d, Test:%s \n",__FILE__, __LINE__,#expr); \ |
| } |
| #endif |
| #else |
| #define A_ASSERT(expr) |
| #endif /* WLAN_DEBUG */ |
| |
| #ifdef ANDROID_ENV |
| struct firmware; |
| int android_request_firmware(const struct firmware **firmware_p, const char *filename, |
| struct device *device); |
| void android_release_firmware(const struct firmware *firmware); |
| #define A_REQUEST_FIRMWARE(_ppf, _pfile, _dev) android_request_firmware(_ppf, _pfile, _dev) |
| #define A_RELEASE_FIRMWARE(_pf) android_release_firmware(_pf) |
| #else |
| #define A_REQUEST_FIRMWARE(_ppf, _pfile, _dev) request_firmware(_ppf, _pfile, _dev) |
| #define A_RELEASE_FIRMWARE(_pf) release_firmware(_pf) |
| #endif |
| |
| /* |
| * Initialization of the network buffer subsystem |
| */ |
| #define A_NETBUF_INIT() |
| |
| /* |
| * Network buffer queue support |
| */ |
| typedef struct sk_buff_head A_NETBUF_QUEUE_T; |
| |
| #define A_NETBUF_QUEUE_INIT(q) \ |
| a_netbuf_queue_init(q) |
| |
| #define A_NETBUF_ENQUEUE(q, pkt) \ |
| a_netbuf_enqueue((q), (pkt)) |
| #define A_NETBUF_PREQUEUE(q, pkt) \ |
| a_netbuf_prequeue((q), (pkt)) |
| #define A_NETBUF_DEQUEUE(q) \ |
| (a_netbuf_dequeue(q)) |
| #define A_NETBUF_QUEUE_SIZE(q) \ |
| a_netbuf_queue_size(q) |
| #define A_NETBUF_QUEUE_EMPTY(q) \ |
| a_netbuf_queue_empty(q) |
| |
| /* |
| * Network buffer support |
| */ |
| #ifdef AR6K_ALLOC_DEBUG |
| #define A_NETBUF_ALLOC(size) \ |
| a_netbuf_alloc(size, __func__, __LINE__) |
| #define A_NETBUF_ALLOC_RAW(size) \ |
| a_netbuf_alloc_raw(size, __func__, __LINE__) |
| #define A_NETBUF_MANAGE(bufPtr) \ |
| a_netbuf_manage(bufPtr, __func__, __LINE__) |
| #define A_NETBUF_UNMANAGE(bufPtr) \ |
| a_netbuf_unmanage(bufPtr) |
| #else |
| #define A_NETBUF_ALLOC(size) \ |
| a_netbuf_alloc(size) |
| #define A_NETBUF_ALLOC_RAW(size) \ |
| a_netbuf_alloc_raw(size) |
| #define A_NETBUF_MANAGE(bufPtr) |
| #define A_NETBUF_UNMANAGE(bufPtr) |
| #endif /* AR6K_ALLOC_DEBUG */ |
| #define A_NETBUF_FREE(bufPtr) \ |
| a_netbuf_free(bufPtr) |
| #define A_NETBUF_LEN(bufPtr) \ |
| a_netbuf_to_len(bufPtr) |
| #define A_NETBUF_PUSH(bufPtr, len) \ |
| a_netbuf_push(bufPtr, len) |
| #define A_NETBUF_PUT(bufPtr, len) \ |
| a_netbuf_put(bufPtr, len) |
| #define A_NETBUF_TRIM(bufPtr,len) \ |
| a_netbuf_trim(bufPtr, len) |
| #define A_NETBUF_PULL(bufPtr, len) \ |
| a_netbuf_pull(bufPtr, len) |
| #define A_NETBUF_HEADROOM(bufPtr)\ |
| a_netbuf_headroom(bufPtr) |
| #define A_NETBUF_SETLEN(bufPtr,len) \ |
| a_netbuf_setlen(bufPtr, len) |
| |
| /* Add data to end of a buffer */ |
| #define A_NETBUF_PUT_DATA(bufPtr, srcPtr, len) \ |
| a_netbuf_put_data(bufPtr, srcPtr, len) |
| |
| /* Add data to start of the buffer */ |
| #define A_NETBUF_PUSH_DATA(bufPtr, srcPtr, len) \ |
| a_netbuf_push_data(bufPtr, srcPtr, len) |
| |
| /* Remove data at start of the buffer */ |
| #define A_NETBUF_PULL_DATA(bufPtr, dstPtr, len) \ |
| a_netbuf_pull_data(bufPtr, dstPtr, len) |
| |
| /* Remove data from the end of the buffer */ |
| #define A_NETBUF_TRIM_DATA(bufPtr, dstPtr, len) \ |
| a_netbuf_trim_data(bufPtr, dstPtr, len) |
| |
| /* View data as "size" contiguous bytes of type "t" */ |
| #define A_NETBUF_VIEW_DATA(bufPtr, t, size) \ |
| (t )( ((struct skbuf *)(bufPtr))->data) |
| |
| /* return the beginning of the headroom for the buffer */ |
| #define A_NETBUF_HEAD(bufPtr) \ |
| ((((struct sk_buff *)(bufPtr))->head)) |
| |
| /* |
| * OS specific network buffer access routines |
| */ |
| #ifdef AR6K_ALLOC_DEBUG |
| void *a_netbuf_alloc(int size, const char *func, int lineno); |
| void *a_netbuf_alloc_raw(int size, const char *func, int lineno); |
| void a_netbuf_manage(void *bufPtr, const char *func, int lineno); |
| void a_netbuf_unmanage(void *bufPtr); |
| #else |
| void *a_netbuf_alloc(int size); |
| void *a_netbuf_alloc_raw(int size); |
| #endif |
| void a_netbuf_free(void *bufPtr); |
| void *a_netbuf_to_data(void *bufPtr); |
| A_UINT32 a_netbuf_to_len(void *bufPtr); |
| A_STATUS a_netbuf_push(void *bufPtr, A_INT32 len); |
| A_STATUS a_netbuf_push_data(void *bufPtr, char *srcPtr, A_INT32 len); |
| A_STATUS a_netbuf_put(void *bufPtr, A_INT32 len); |
| A_STATUS a_netbuf_put_data(void *bufPtr, char *srcPtr, A_INT32 len); |
| A_STATUS a_netbuf_pull(void *bufPtr, A_INT32 len); |
| A_STATUS a_netbuf_pull_data(void *bufPtr, char *dstPtr, A_INT32 len); |
| A_STATUS a_netbuf_trim(void *bufPtr, A_INT32 len); |
| A_STATUS a_netbuf_trim_data(void *bufPtr, char *dstPtr, A_INT32 len); |
| A_STATUS a_netbuf_setlen(void *bufPtr, A_INT32 len); |
| A_INT32 a_netbuf_headroom(void *bufPtr); |
| void a_netbuf_enqueue(A_NETBUF_QUEUE_T *q, void *pkt); |
| void a_netbuf_prequeue(A_NETBUF_QUEUE_T *q, void *pkt); |
| void *a_netbuf_dequeue(A_NETBUF_QUEUE_T *q); |
| int a_netbuf_queue_size(A_NETBUF_QUEUE_T *q); |
| int a_netbuf_queue_empty(A_NETBUF_QUEUE_T *q); |
| int a_netbuf_queue_empty(A_NETBUF_QUEUE_T *q); |
| void a_netbuf_queue_init(A_NETBUF_QUEUE_T *q); |
| |
| /* |
| * Kernel v.s User space functions |
| */ |
| A_UINT32 a_copy_to_user(void *to, const void *from, A_UINT32 n); |
| A_UINT32 a_copy_from_user(void *to, const void *from, A_UINT32 n); |
| |
| /* In linux, WLAN Rx and Tx run in different contexts, so no need to check |
| * for any commands/data queued for WLAN */ |
| #define A_CHECK_DRV_TX() |
| |
| #define A_GET_CACHE_LINE_BYTES() L1_CACHE_BYTES |
| |
| #define A_CACHE_LINE_PAD 128 |
| |
| static inline void *A_ALIGN_TO_CACHE_LINE(void *ptr) { |
| return (void *)L1_CACHE_ALIGN((unsigned long)ptr); |
| } |
| |
| #ifdef QCA_PARTNER_PLATFORM |
| |
| #include "ath_carr_pltfrm.h" |
| |
| #else |
| #define A_PCI_READ32(addr) ioread32((void __iomem *)addr) |
| #define A_PCI_WRITE32(addr, value) iowrite32((u32)(value), (void __iomem *)(addr)) |
| #endif /* QCA_PARTNER_PLATFORM */ |
| |
| typedef struct semaphore A_SEMA; |
| #define A_SEMA_INIT(_sem, _val) sema_init((_sem), (_val)) |
| static __inline__ |
| void A_SEMA_WAKEUP(void *osdev, A_SEMA *sem) |
| { |
| up(sem); |
| } |
| static __inline__ |
| bool A_SEMA_SLEEP(void *osdev, A_SEMA *sem) |
| { |
| return down_timeout(sem, HZ); |
| } |
| |
| |
| typedef struct ieee80211_cb wbuf_context; |
| #define wbuf_get_cb(skb) ((skb)->cb) |
| |
| #else /* __KERNEL__ */ |
| |
| #ifdef __GNUC__ |
| #ifndef __ATTRIB_PACK |
| #define __ATTRIB_PACK __attribute__ ((packed)) |
| #endif |
| #define __ATTRIB_PRINTF __attribute__ ((format (printf, 1, 2))) |
| #define __ATTRIB_NORETURN __attribute__ ((noreturn)) |
| #ifndef INLINE |
| #define INLINE __inline__ |
| #endif |
| #else /* Not GCC */ |
| #define __ATTRIB_PACK |
| #define __ATTRIB_PRINTF |
| #define __ATTRIB_NORETURN |
| #ifndef INLINE |
| #define INLINE __inline |
| #endif |
| #endif /* End __GNUC__ */ |
| |
| #define PREPACK |
| #define POSTPACK __ATTRIB_PACK |
| |
| #define A_MEMCPY(dst, src, len) memcpy((dst), (src), (len)) |
| #define A_MEMSET(addr, value, size) memset((addr), (value), (size)) |
| #define A_MEMZERO(addr, len) memset((addr), 0, (len)) |
| #define A_MEMCMP(addr1, addr2, len) memcmp((addr1), (addr2), (len)) |
| #define A_MALLOC(size) malloc(size) |
| #define A_FREE(addr) free(addr) |
| |
| |
| #ifdef ANDROID |
| #ifndef err |
| #include <errno.h> |
| #define err(_s, args...) do { \ |
| fprintf(stderr, "%s: line %d ", __FILE__, __LINE__); \ |
| fprintf(stderr, args); fprintf(stderr, ": %d\n", errno); \ |
| exit(_s); } while (0) |
| #endif |
| #else |
| #include <err.h> |
| #endif |
| |
| #endif /* __KERNEL__ */ |
| |
| #endif /* _OSAPI_LINUX_H_ */ |