samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacmn: Fix kernel checkpatch warnings in QDF

Browse Source 
Fix kernel checkpatch warnings in QDF.

Change-Id: Id2f54c6c436bde55b040012fbbe9922cb177461e
CRs-Fixed: 2028128
This commit is contained in:
Srinivas Girigowda
2017-04-03 09:17:46 -07:00
committed by snandini
parent 4831049768
commit 43977f7e6d
23 changed files with 101 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
hif/src/ce/ce_internal.h
View File

@@ -97,7 +97,7 @@ struct CE_ring_state {
unsigned int high_water_mark_nentries;
void *srng_ctx;
void **per_transfer_context;
OS_DMA_MEM_CONTEXT(ce_dmacontext) /* OS Specific DMA context */
OS_DMA_MEM_CONTEXT(ce_dmacontext); /* OS Specific DMA context */
};
/* Copy Engine internal state */

4
hif/src/pcie/if_pci.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2013-2016 The Linux Foundation. All rights reserved.
* Copyright (c) 2013-2017 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@@ -103,7 +103,7 @@ struct hif_pci_pm_stats {
struct hif_msi_info {
void *magic;
dma_addr_t magic_da;
OS_DMA_MEM_CONTEXT(dmacontext)
OS_DMA_MEM_CONTEXT(dmacontext);
};
struct hif_pci_softc {

4
qdf/inc/osdep.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2013-2016 The Linux Foundation. All rights reserved.
* Copyright (c) 2013-2017 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@@ -144,7 +144,7 @@ static inline unsigned char *os_malloc(osdev_t nic_dev,
#define OS_FREE(_p) qdf_mem_free(_p)
#define OS_DMA_MEM_CONTEXT(context) \
dma_addr_t context;
dma_addr_t context
#define OS_GET_DMA_MEM_CONTEXT(var, field) \
&(var->field)

1
qdf/inc/qdf_lock.h
View File

@@ -296,6 +296,7 @@ static inline int qdf_spin_is_locked(qdf_spinlock_t *lock)
static inline int qdf_spin_trylock_bh(qdf_spinlock_t *lock, const char *func)
{
int trylock_return;
BEFORE_TRYLOCK(lock);
trylock_return = __qdf_spin_trylock_bh(&lock->lock);
AFTER_TRYLOCK(lock, trylock_return, func);

11
qdf/inc/qdf_mc_timer.h
View File

@@ -50,7 +50,8 @@
/* Type declarations */
/* qdf Timer callback function prototype (well, actually a prototype for
a pointer to this callback function) */
* a pointer to this callback function)
*/
typedef void (*qdf_mc_timer_callback_t)(void *user_data);
typedef enum {
@@ -250,10 +251,10 @@ unsigned long qdf_mc_timer_get_system_ticks(void);
unsigned long qdf_mc_timer_get_system_time(void);
/**
* qdf_get_monotonic_boottime_ns() - Get kernel boottime in ns
*
* Return: kernel boottime in nano sec
*/
* qdf_get_monotonic_boottime_ns() - Get kernel boottime in ns
*
* Return: kernel boottime in nano sec
*/
s64 qdf_get_monotonic_boottime_ns(void);
/**

2
qdf/inc/qdf_nbuf.h
View File

@@ -761,6 +761,7 @@ qdf_nbuf_alloc_debug(qdf_device_t osdev, qdf_size_t size, int reserve,
uint32_t line_num)
{
qdf_nbuf_t net_buf;
net_buf = __qdf_nbuf_alloc(osdev, size, reserve, align, prio);
/* Store SKB in internal QDF tracking table */
@@ -852,7 +853,6 @@ static inline void qdf_net_buf_debug_acquire_skb(qdf_nbuf_t net_buf,
static inline void qdf_net_buf_debug_release_skb(qdf_nbuf_t net_buf)
{
return;
}
/* Nbuf allocation rouines */

2
qdf/inc/qdf_util.h
View File

@@ -218,6 +218,7 @@ static inline bool qdf_is_macaddr_equal(struct qdf_mac_addr *mac_addr1,
static inline bool qdf_is_macaddr_zero(struct qdf_mac_addr *mac_addr)
{
struct qdf_mac_addr zero_mac_addr = QDF_MAC_ADDR_ZERO_INITIALIZER;
return qdf_is_macaddr_equal(mac_addr, &zero_mac_addr);
}
@@ -508,6 +509,7 @@ static inline uint8_t *qdf_get_u32(uint8_t *ptr, uint32_t *value)
static inline int qdf_get_pwr2(int value)
{
int log2;
if (QDF_IS_PWR2(value))
return value;

6
qdf/linux/src/i_osdep.h
View File

@@ -60,10 +60,7 @@ typedef struct timer_list os_timer_t;
#undef spin_unlock
#undef spin_trylock
#define spin_lock(x) \
do { \
spin_lock_bh(x); \
} while (0)
#define spin_lock(x) spin_lock_bh(x)
#define spin_unlock(x) \
do { \
@@ -136,6 +133,7 @@ typedef struct {
int32_t num_queued;
int32_t mesg_len;
uint8_t *mesg_queue_buf;
STAILQ_HEAD(, _os_mesg_t) mesg_head;
STAILQ_HEAD(, _os_mesg_t) mesg_free_head;
spinlock_t lock;

16
qdf/linux/src/i_qdf_lock.h
View File

@@ -168,6 +168,7 @@ static inline int __qdf_semaphore_acquire_timeout(struct semaphore *m,
unsigned long timeout)
{
unsigned long jiffie_val = msecs_to_jiffies(timeout);
return down_timeout(m, jiffie_val);
}
@@ -258,16 +259,15 @@ static inline int __qdf_spin_is_locked(__qdf_spinlock_t *lock)
*/
static inline int __qdf_spin_trylock_bh(__qdf_spinlock_t *lock)
{
if (likely(irqs_disabled() || in_irq() || in_softirq())) {
if (likely(irqs_disabled() || in_irq() || in_softirq()))
return spin_trylock(&lock->spinlock);
} else {
if (spin_trylock_bh(&lock->spinlock)) {
lock->flags |= QDF_LINUX_UNLOCK_BH;
return 1;
} else {
return 0;
}
if (spin_trylock_bh(&lock->spinlock)) {
lock->flags |= QDF_LINUX_UNLOCK_BH;
return 1;
}
return 0;
}
/**

3
qdf/linux/src/i_qdf_mem.h
View File

@@ -92,6 +92,7 @@ typedef struct __qdf_mempool_ctxt {
size_t elem_size;
void *pool_mem;
u_int32_t mem_size;
STAILQ_HEAD(, mempool_elem) free_list;
spinlock_t lock;
u_int32_t max_elem;
@@ -180,7 +181,7 @@ void __qdf_mempool_destroy(qdf_device_t osdev, __qdf_mempool_t pool);
void *__qdf_mempool_alloc(qdf_device_t osdev, __qdf_mempool_t pool);
void __qdf_mempool_free(qdf_device_t osdev, __qdf_mempool_t pool, void *buf);
#define __qdf_mempool_elem_size(_pool) ((_pool)->elem_size);
#define __qdf_mempool_elem_size(_pool) ((_pool)->elem_size)
#endif
/**

2
qdf/linux/src/i_qdf_module.h
View File

@@ -53,7 +53,7 @@
#define __qdf_virt_module_exit(_x) module_exit(_x)
#define __qdf_virt_module_name(_name) MODULE_LICENSE("Proprietary");
#define __qdf_virt_module_name(_name) MODULE_LICENSE("Proprietary")
#define __qdf_export_symbol(_sym) EXPORT_SYMBOL(_sym)

51
qdf/linux/src/i_qdf_nbuf.h
View File

@@ -427,9 +427,7 @@ struct qdf_nbuf_cb {
(QDF_NBUF_CB_TX_NUM_EXTRA_FRAGS(skb) + 1)
#define __qdf_nbuf_reset_num_frags(skb) \
do { \
QDF_NBUF_CB_TX_NUM_EXTRA_FRAGS(skb) = 0; \
} while (0)
(QDF_NBUF_CB_TX_NUM_EXTRA_FRAGS(skb) = 0)
/**
* end of nbuf->cb access macros
@@ -441,9 +439,7 @@ typedef void (*qdf_nbuf_free_t)(__qdf_nbuf_t);
#define __qdf_nbuf_mapped_paddr_get(skb) QDF_NBUF_CB_PADDR(skb)
#define __qdf_nbuf_mapped_paddr_set(skb, paddr) \
do { \
QDF_NBUF_CB_PADDR(skb) = paddr; \
} while (0)
(QDF_NBUF_CB_PADDR(skb) = paddr)
#define __qdf_nbuf_frag_push_head( \
skb, frag_len, frag_vaddr, frag_paddr) \
@@ -489,9 +485,7 @@ typedef void (*qdf_nbuf_free_t)(__qdf_nbuf_t);
} while (0)
#define __qdf_nbuf_set_vdev_ctx(skb, vdev_ctx) \
do { \
QDF_NBUF_CB_TX_VDEV_CTX((skb)) = (vdev_ctx); \
} while (0)
(QDF_NBUF_CB_TX_VDEV_CTX((skb)) = (vdev_ctx))
#define __qdf_nbuf_get_vdev_ctx(skb) \
QDF_NBUF_CB_TX_VDEV_CTX((skb))
@@ -514,9 +508,7 @@ typedef void (*qdf_nbuf_free_t)(__qdf_nbuf_t);
QDF_NBUF_CB_TX_FTYPE((skb))
#define __qdf_nbuf_set_chfrag_start(skb, val) \
do { \
(QDF_NBUF_CB_TX_EXTRA_FRAG_FLAGS_CHFRAG_START((skb))) = val; \
} while (0)
((QDF_NBUF_CB_TX_EXTRA_FRAG_FLAGS_CHFRAG_START((skb))) = val)
#define __qdf_nbuf_is_chfrag_start(skb) \
(QDF_NBUF_CB_TX_EXTRA_FRAG_FLAGS_CHFRAG_START((skb)))
@@ -530,17 +522,13 @@ typedef void (*qdf_nbuf_free_t)(__qdf_nbuf_t);
(QDF_NBUF_CB_TX_EXTRA_FRAG_FLAGS_CHFRAG_CONT((skb)))
#define __qdf_nbuf_set_chfrag_end(skb, val) \
do { \
(QDF_NBUF_CB_TX_EXTRA_FRAG_FLAGS_CHFRAG_END((skb))) = val; \
} while (0)
((QDF_NBUF_CB_TX_EXTRA_FRAG_FLAGS_CHFRAG_END((skb))) = val)
#define __qdf_nbuf_is_chfrag_end(skb) \
(QDF_NBUF_CB_TX_EXTRA_FRAG_FLAGS_CHFRAG_END((skb)))
#define __qdf_nbuf_trace_set_proto_type(skb, proto_type) \
do { \
QDF_NBUF_CB_TX_PROTO_TYPE(skb) = (proto_type); \
} while (0)
#define __qdf_nbuf_trace_set_proto_type(skb, proto_type) \
(QDF_NBUF_CB_TX_PROTO_TYPE(skb) = (proto_type))
#define __qdf_nbuf_trace_get_proto_type(skb) \
QDF_NBUF_CB_TX_PROTO_TYPE(skb)
@@ -548,25 +536,19 @@ typedef void (*qdf_nbuf_free_t)(__qdf_nbuf_t);
#define __qdf_nbuf_data_attr_get(skb) \
QDF_NBUF_CB_TX_DATA_ATTR(skb)
#define __qdf_nbuf_data_attr_set(skb, data_attr) \
do { \
QDF_NBUF_CB_TX_DATA_ATTR(skb) = (data_attr); \
} while (0)
(QDF_NBUF_CB_TX_DATA_ATTR(skb) = (data_attr))
#define __qdf_nbuf_ipa_owned_get(skb) \
QDF_NBUF_CB_TX_IPA_OWNED(skb)
#define __qdf_nbuf_ipa_owned_set(skb) \
do { \
QDF_NBUF_CB_TX_IPA_OWNED(skb) = 1; \
} while (0)
(QDF_NBUF_CB_TX_IPA_OWNED(skb) = 1)
#define __qdf_nbuf_ipa_priv_get(skb) \
QDF_NBUF_CB_TX_IPA_PRIV(skb)
#define __qdf_nbuf_ipa_priv_set(skb, priv) \
do { \
QDF_NBUF_CB_TX_IPA_PRIV(skb) = (priv); \
} while (0)
(QDF_NBUF_CB_TX_IPA_PRIV(skb) = (priv))
/**
* __qdf_nbuf_num_frags_init() - init extra frags
@@ -1138,9 +1120,7 @@ __qdf_nbuf_set_protocol(struct sk_buff *skb, uint16_t protocol)
}
#define __qdf_nbuf_set_tx_htt2_frm(skb, candi) \
do { \
QDF_NBUF_CB_TX_HL_HTT2_FRM(skb) = (candi); \
} while (0)
(QDF_NBUF_CB_TX_HL_HTT2_FRM(skb) = (candi))
#define __qdf_nbuf_get_tx_htt2_frm(skb) \
QDF_NBUF_CB_TX_HL_HTT2_FRM(skb)
@@ -1449,7 +1429,6 @@ static inline bool __qdf_nbuf_is_queue_empty(__qdf_nbuf_queue_t *qhead)
static inline void
__qdf_nbuf_set_send_complete_flag(struct sk_buff *skb, bool flag)
{
return;
}
/**
@@ -1608,7 +1587,8 @@ static inline void *__qdf_nbuf_transport_header(__qdf_nbuf_t buf)
* @skb: sk buff
*
* Return: TCP MSS size
* */
*
*/
static inline size_t __qdf_nbuf_tcp_tso_size(struct sk_buff *skb)
{
return skb_shinfo(skb)->gso_size;
@@ -1659,6 +1639,7 @@ static inline void *
__qdf_nbuf_get_rx_info(__qdf_nbuf_t nbuf)
{
uint8_t offset = sizeof(struct qdf_nbuf_cb);
return (void *)((uint8_t *)(nbuf->cb) + offset);
}
@@ -1786,9 +1767,9 @@ static inline void __qdf_invalidate_range(void *start, void *end)
static inline void __qdf_invalidate_range(void *start, void *end)
{
/* TODO figure out how to invalidate cache on x86 and other
non-MSM platform */
* non-MSM platform
*/
pr_err("Cache invalidate not yet implemneted for non-MSM platforms\n");
return;
}
#endif

3
qdf/linux/src/i_qdf_util.h
View File

@@ -56,7 +56,7 @@
#endif
#include <qdf_types.h>
#include <asm/io.h>
#include <linux/io.h>
#include <asm/byteorder.h>
#ifdef QCA_PARTNER_PLATFORM
@@ -320,6 +320,7 @@ static inline uint64_t
__qdf_get_totalramsize(void)
{
struct sysinfo meminfo;
si_meminfo(&meminfo);
return MEMINFO_KB(meminfo.totalram);
}

3
qdf/linux/src/qdf_defer.c
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2014-2016 The Linux Foundation. All rights reserved.
* Copyright (c) 2014-2017 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@@ -46,6 +46,7 @@
void __qdf_defer_func(struct work_struct *work)
{
__qdf_work_t *ctx = container_of(work, __qdf_work_t, work);
if (ctx->fn == NULL) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
"No callback registered !!");

1
qdf/linux/src/qdf_event.c
View File

@@ -248,6 +248,7 @@ QDF_STATUS qdf_wait_single_event(qdf_event_t *event, uint32_t timeout)
timeout *= qdf_timer_get_multiplier();
if (timeout) {
long ret;
ret = wait_for_completion_timeout(&event->complete,
msecs_to_jiffies(timeout));
if (0 >= ret)

1
qdf/linux/src/qdf_list.c
View File

@@ -213,6 +213,7 @@ EXPORT_SYMBOL(qdf_list_remove_node);
QDF_STATUS qdf_list_peek_front(qdf_list_t *list, qdf_list_node_t **node2)
{
struct list_head *listptr;
if (list_empty(&list->anchor))
return QDF_STATUS_E_EMPTY;

28
qdf/linux/src/qdf_lock.c
View File

@@ -151,14 +151,14 @@ QDF_STATUS qdf_mutex_acquire(qdf_mutex_t *lock)
lock->refcount++;
lock->state = LOCK_ACQUIRED;
return QDF_STATUS_SUCCESS;
} else {
/* lock is already destroyed */
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
"%s: Lock is already destroyed", __func__);
mutex_unlock(&lock->m_lock);
QDF_ASSERT(0);
return QDF_STATUS_E_FAILURE;
}
/* lock is already destroyed */
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
"%s: Lock is already destroyed", __func__);
mutex_unlock(&lock->m_lock);
QDF_ASSERT(0);
return QDF_STATUS_E_FAILURE;
}
EXPORT_SYMBOL(qdf_mutex_acquire);
@@ -504,8 +504,8 @@ QDF_STATUS qdf_runtime_pm_allow_suspend(qdf_runtime_lock_t lock)
{
void *ol_sc;
int ret;
ol_sc = cds_get_context(QDF_MODULE_ID_HIF);
ol_sc = cds_get_context(QDF_MODULE_ID_HIF);
if (ol_sc == NULL) {
QDF_ASSERT(0);
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
@@ -516,6 +516,7 @@ QDF_STATUS qdf_runtime_pm_allow_suspend(qdf_runtime_lock_t lock)
ret = hif_pm_runtime_allow_suspend(ol_sc, lock);
if (ret)
return QDF_STATUS_E_FAILURE;
return QDF_STATUS_SUCCESS;
}
EXPORT_SYMBOL(qdf_runtime_pm_allow_suspend);
@@ -801,8 +802,9 @@ void qdf_lock_stats_init(void)
__qdf_put_lock_cookie(&lock_cookies[i]);
/* stats must be allocated for the spinlock before the cookie,
otherwise this qdf_lock_list_spinlock wouldnt get intialized
propperly */
* otherwise this qdf_lock_list_spinlock wouldnt get initialized
* properly
*/
qdf_spinlock_create(&qdf_lock_list_spinlock);
qdf_atomic_init(&lock_cookie_get_failures);
qdf_atomic_init(&lock_cookie_untracked_num);
@@ -823,8 +825,9 @@ void qdf_lock_stats_deinit(void)
}
/* allocated separate memory in case the lock memory is freed without
running the deinitialization code. The cookie list will not be
corrupted. */
* running the deinitialization code. The cookie list will not be
* corrupted.
*/
void qdf_lock_stats_cookie_create(struct lock_stats *stats,
const char *func, int line)
{
@@ -832,6 +835,7 @@ void qdf_lock_stats_cookie_create(struct lock_stats *stats,
if (cookie == NULL) {
int count;
qdf_atomic_inc(&lock_cookie_get_failures);
count = qdf_atomic_inc_return(&lock_cookie_untracked_num);
stats->cookie = (void *) DUMMY_LOCK_COOKIE;

8
qdf/linux/src/qdf_mc_timer.c
View File

@@ -93,9 +93,9 @@ void qdf_try_allowing_sleep(QDF_TIMER_TYPE type)
persistent_timer_count--;
if (0 == persistent_timer_count) {
/* since the number of persistent timers has
decreased from 1 to 0, the timer should allow
sleep
*/
* decreased from 1 to 0, the timer should allow
* sleep
*/
}
}
}
@@ -162,7 +162,6 @@ void qdf_mc_timer_manager_init(void)
{
qdf_list_create(&qdf_timer_list, 1000);
qdf_spinlock_create(&qdf_timer_list_lock);
return;
}
EXPORT_SYMBOL(qdf_mc_timer_manager_init);
@@ -705,6 +704,7 @@ EXPORT_SYMBOL(qdf_mc_timer_get_system_ticks);
unsigned long qdf_mc_timer_get_system_time(void)
{
struct timeval tv;
do_gettimeofday(&tv);
return tv.tv_sec * 1000 + tv.tv_usec / 1000;
}

4
qdf/linux/src/qdf_mem.c
View File

@@ -838,6 +838,7 @@ static void qdf_handle_leaked_memory(qdf_list_node_t *node)
static void qdf_mem_debug_clean(void)
{
uint32_t list_size;
list_size = qdf_list_size(&qdf_mem_list);
if (list_size) {
qdf_list_node_t *node;
@@ -861,7 +862,8 @@ static void qdf_mem_debug_clean(void)
if (QDF_STATUS_SUCCESS == qdf_status) {
mem_struct = (struct s_qdf_mem_struct *)node;
/* Take care to log only once multiple memory
leaks from the same place */
* leaks from the same place
*/
if (strcmp(prev_mleak_file,
mem_struct->file_name)
|| (prev_mleak_line_num !=

33
qdf/linux/src/qdf_nbuf.c
View File

@@ -153,6 +153,7 @@ void qdf_nbuf_set_state(qdf_nbuf_t nbuf, uint8_t current_state)
* such as scan commands are not tracked
*/
uint8_t packet_type;
packet_type = QDF_NBUF_CB_TX_PACKET_TRACK(nbuf);
if ((packet_type != QDF_NBUF_TX_PKT_DATA_TRACK) &&
@@ -258,10 +259,9 @@ struct sk_buff *__qdf_nbuf_alloc(qdf_device_t osdev, size_t size, int reserve,
skb = dev_alloc_skb(size);
if (!skb) {
pr_info("ERROR:NBUF alloc failed\n");
if (!skb)
return NULL;
}
memset(skb->cb, 0x0, sizeof(skb->cb));
/*
@@ -331,6 +331,7 @@ QDF_STATUS
__qdf_nbuf_map(qdf_device_t osdev, struct sk_buff *skb, qdf_dma_dir_t dir)
{
struct skb_shared_info *sh = skb_shinfo(skb);
qdf_assert((dir == QDF_DMA_TO_DEVICE)
|| (dir == QDF_DMA_FROM_DEVICE));
@@ -386,7 +387,7 @@ EXPORT_SYMBOL(__qdf_nbuf_unmap);
*
* Return: QDF_STATUS
*/
#if defined(A_SIMOS_DEVHOST) || defined (HIF_USB)
#if defined(A_SIMOS_DEVHOST) || defined(HIF_USB)
QDF_STATUS
__qdf_nbuf_map_single(qdf_device_t osdev, qdf_nbuf_t buf, qdf_dma_dir_t dir)
{
@@ -422,11 +423,10 @@ EXPORT_SYMBOL(__qdf_nbuf_map_single);
*
* Return: none
*/
#if defined(A_SIMOS_DEVHOST) || defined (HIF_USB)
#if defined(A_SIMOS_DEVHOST) || defined(HIF_USB)
void __qdf_nbuf_unmap_single(qdf_device_t osdev, qdf_nbuf_t buf,
qdf_dma_dir_t dir)
{
return;
}
#else
void __qdf_nbuf_unmap_single(qdf_device_t osdev, qdf_nbuf_t buf,
@@ -481,8 +481,6 @@ qdf_nbuf_tx_cksum_t __qdf_nbuf_get_tx_cksum(struct sk_buff *skb)
case CHECKSUM_NONE:
return QDF_NBUF_TX_CKSUM_NONE;
case CHECKSUM_PARTIAL:
/* XXX ADF and Linux checksum don't map with 1-to-1. This is
* not 100% correct */
return QDF_NBUF_TX_CKSUM_TCP_UDP;
case CHECKSUM_COMPLETE:
return QDF_NBUF_TX_CKSUM_TCP_UDP_IP;
@@ -537,7 +535,6 @@ EXPORT_SYMBOL(__qdf_nbuf_get_exemption_type);
void __qdf_nbuf_reg_trace_cb(qdf_nbuf_trace_update_t cb_func_ptr)
{
qdf_trace_update_cb = cb_func_ptr;
return;
}
EXPORT_SYMBOL(__qdf_nbuf_reg_trace_cb);
@@ -1425,8 +1422,6 @@ void qdf_net_buf_debug_init(void)
gp_qdf_net_buf_track_tbl[i] = NULL;
spin_lock_init(&g_qdf_net_buf_track_lock[i]);
}
return;
}
EXPORT_SYMBOL(qdf_net_buf_debug_init);
@@ -1468,8 +1463,6 @@ void qdf_net_buf_debug_exit(void)
if (count)
QDF_BUG(0);
#endif
return;
}
EXPORT_SYMBOL(qdf_net_buf_debug_exit);
@@ -1553,8 +1546,6 @@ void qdf_net_buf_debug_add_node(qdf_nbuf_t net_buf, size_t size,
}
spin_unlock_irqrestore(&g_qdf_net_buf_track_lock[i], irq_flag);
return;
}
EXPORT_SYMBOL(qdf_net_buf_debug_add_node);
@@ -1610,8 +1601,6 @@ done:
} else {
qdf_nbuf_track_free(p_node);
}
return;
}
EXPORT_SYMBOL(qdf_net_buf_debug_delete_node);
@@ -1724,6 +1713,7 @@ static uint8_t __qdf_nbuf_get_tso_cmn_seg_info(qdf_device_t osdev,
if (tso_info->ethproto == htons(ETH_P_IP)) { /* IPv4 */
/* for IPv4, get the IP ID and enable TCP and IP csum */
struct iphdr *ipv4_hdr = ip_hdr(skb);
tso_info->ip_id = ntohs(ipv4_hdr->id);
tso_info->ipv4_csum_en = 1;
tso_info->tcp_ipv4_csum_en = 1;
@@ -1857,8 +1847,6 @@ static inline void __qdf_nbuf_fill_tso_cmn_seg_info(
tso_cmn_info->eit_hdr_len,
curr_seg->seg.tso_flags.tcp_seq_num,
curr_seg->seg.total_len);
}
/**
@@ -2329,7 +2317,6 @@ void
__qdf_nbuf_unmap_nbytes_single(
qdf_device_t osdev, struct sk_buff *buf, qdf_dma_dir_t dir, int nbytes)
{
return;
}
EXPORT_SYMBOL(__qdf_nbuf_unmap_nbytes_single);
@@ -2365,6 +2352,7 @@ __qdf_nbuf_map_nbytes(
int nbytes)
{
struct skb_shared_info *sh = skb_shinfo(skb);
qdf_assert((dir == QDF_DMA_TO_DEVICE) || (dir == QDF_DMA_FROM_DEVICE));
/*
@@ -2454,6 +2442,7 @@ __qdf_nbuf_frag_info(struct sk_buff *skb, qdf_sglist_t *sg)
for (int i = 1; i <= sh->nr_frags; i++) {
skb_frag_t *f = &sh->frags[i - 1];
sg->sg_segs[i].vaddr = (uint8_t *)(page_address(f->page) +
f->page_offset);
sg->sg_segs[i].len = f->size;
@@ -2503,6 +2492,7 @@ __qdf_nbuf_get_frag_size(__qdf_nbuf_t nbuf, uint32_t cur_frag)
{
struct skb_shared_info *sh = skb_shinfo(nbuf);
const skb_frag_t *frag = sh->frags + cur_frag;
return skb_frag_size(frag);
}
EXPORT_SYMBOL(__qdf_nbuf_get_frag_size);
@@ -2534,9 +2524,9 @@ QDF_STATUS __qdf_nbuf_frag_map(
int offset, qdf_dma_dir_t dir, int cur_frag)
{
dma_addr_t paddr, frag_len;
struct skb_shared_info *sh = skb_shinfo(nbuf);
const skb_frag_t *frag = sh->frags + cur_frag;
frag_len = skb_frag_size(frag);
QDF_NBUF_CB_TX_EXTRA_FRAG_PADDR(nbuf) = paddr =
@@ -2892,7 +2882,6 @@ qdf_export_symbol(qdf_nbuf_update_radiotap);
void __qdf_nbuf_reg_free_cb(qdf_nbuf_free_t cb_func_ptr)
{
nbuf_free_cb = cb_func_ptr;
return;
}
/**

4
qdf/linux/src/qdf_perf.c
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2012-2016 The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2017 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@@ -32,7 +32,7 @@
#include <linux/version.h>
#include <linux/kernel.h>
#include <asm/uaccess.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
#include <linux/vmalloc.h>

3
qdf/linux/src/qdf_threads.c
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2014-2016 The Linux Foundation. All rights reserved.
* Copyright (c) 2014-2017 The Linux Foundation. All rights reserved.
*
* Previously licensed under the ISC license by Qualcomm Atheros, Inc.
*
@@ -78,6 +78,7 @@ EXPORT_SYMBOL(qdf_sleep);
void qdf_sleep_us(uint32_t us_interval)
{
unsigned long timeout = usecs_to_jiffies(us_interval) + 1;
if (in_interrupt()) {
QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR,
"%s cannot be called from interrupt context!!!",

20
qdf/linux/src/qdf_trace.c
View File

@@ -159,7 +159,8 @@ void qdf_trace_set_level(QDF_MODULE_ID module, QDF_TRACE_LEVEL level)
QDF_TRACE_LEVEL_NONE;
else
/* set the desired bit in the bit mask for the module trace
* level */
* level
*/
g_qdf_trace_info[module].module_trace_level |=
QDF_TRACE_LEVEL_TO_MODULE_BITMASK(level);
}
@@ -210,24 +211,28 @@ void qdf_trace_set_value(QDF_MODULE_ID module, QDF_TRACE_LEVEL level,
}
/* Treat 'none' differently. NONE means we have to turn off all
the bits in the bit mask so none of the traces appear */
* the bits in the bit mask so none of the traces appear
*/
if (QDF_TRACE_LEVEL_NONE == level) {
g_qdf_trace_info[module].module_trace_level =
QDF_TRACE_LEVEL_NONE;
}
/* Treat 'All' differently. All means we have to turn on all
the bits in the bit mask so all of the traces appear */
* the bits in the bit mask so all of the traces appear
*/
else if (QDF_TRACE_LEVEL_ALL == level) {
g_qdf_trace_info[module].module_trace_level = 0xFFFF;
} else {
if (on)
/* set the desired bit in the bit mask for the module
trace level */
* trace level
*/
g_qdf_trace_info[module].module_trace_level |=
QDF_TRACE_LEVEL_TO_MODULE_BITMASK(level);
else
/* clear the desired bit in the bit mask for the module
trace level */
* trace level
*/
g_qdf_trace_info[module].module_trace_level &=
~(QDF_TRACE_LEVEL_TO_MODULE_BITMASK(level));
}
@@ -381,6 +386,7 @@ EXPORT_SYMBOL(qdf_trace_hex_dump);
void qdf_trace_enable(uint32_t bitmask_of_module_id, uint8_t enable)
{
int i;
if (bitmask_of_module_id) {
for (i = 0; i < QDF_MODULE_ID_MAX; i++) {
if (((bitmask_of_module_id >> i) & 1)) {
@@ -427,6 +433,7 @@ EXPORT_SYMBOL(qdf_trace_enable);
void qdf_trace_init(void)
{
uint8_t i;
g_qdf_trace_data.head = INVALID_QDF_TRACE_ADDR;
g_qdf_trace_data.tail = INVALID_QDF_TRACE_ADDR;
g_qdf_trace_data.num = 0;
@@ -773,7 +780,6 @@ void qdf_dp_trace_set_value(uint8_t proto_bitmap, uint8_t no_of_record,
g_qdf_dp_trace_data.proto_bitmap = proto_bitmap;
g_qdf_dp_trace_data.no_of_record = no_of_record;
g_qdf_dp_trace_data.verbosity = verbosity;
return;
}
EXPORT_SYMBOL(qdf_dp_trace_set_value);
@@ -911,7 +917,6 @@ void qdf_dp_trace_set_track(qdf_nbuf_t nbuf, enum qdf_proto_dir dir)
QDF_NBUF_CB_RX_DP_TRACE(nbuf) = 1;
}
spin_unlock_bh(&l_dp_trace_lock);
return;
}
EXPORT_SYMBOL(qdf_dp_trace_set_track);
#if CONFIG_MCL
@@ -1166,6 +1171,7 @@ static void qdf_dp_add_record(enum QDF_DP_TRACE_ID code, uint8_t *data,
{
struct qdf_dp_trace_record_s *rec = NULL;
int index;
spin_lock_bh(&l_dp_trace_lock);
g_qdf_dp_trace_data.num++;