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

qcacmn: Remove qdf_handle_t from unused qdf_defer APIs

Browse Source 
There are many QDF APIs require a qdf_handle_t parameter. None of these
APIs actually use the qdf_handle_t parameter, meaning it can be
completely removed. As a step toward globally removing this unused
type, remove qdf_handle_t parameters from unsed qdf_defer APIs.

Change-Id: I0568aa7cbd430abc0d046143482a067d96bf6313
CRs-Fixed: 2112646
This commit is contained in:
Dustin Brown
2017-09-19 11:29:41 -07:00
committed by Nandini Suresh
parent 5fd835b44b
commit f653d16e6c
4 changed files with 73 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
dp/wifi3.0/dp_main.c
View File

@@ -2509,8 +2509,8 @@ static void dp_soc_detach_wifi3(void *txrx_soc)
qdf_atomic_set(&soc->cmn_init_done, 0);
qdf_flush_work(0, &soc->htt_stats.work);
qdf_disable_work(0, &soc->htt_stats.work);
qdf_flush_work(&soc->htt_stats.work);
qdf_disable_work(&soc->htt_stats.work);
/* Free pending htt stats messages */
qdf_nbuf_queue_free(&soc->htt_stats.msg);

80
qdf/inc/qdf_defer.h
View File

@@ -61,38 +61,35 @@ typedef __qdf_bh_t qdf_bh_t;
/**
* qdf_create_bh - creates the bottom half deferred handler
* @hdl: os handle
* @bh: pointer to bottom
* @func: deferred function to run at bottom half interrupt context.
* @arg: argument for the deferred function
* Return: none
*/
static inline void qdf_create_bh(qdf_handle_t hdl, qdf_bh_t *bh,
qdf_defer_fn_t func, void *arg)
static inline void
qdf_create_bh(qdf_bh_t *bh, qdf_defer_fn_t func, void *arg)
{
__qdf_init_bh(hdl, bh, func, arg);
__qdf_init_bh(bh, func, arg);
}
/**
* qdf_sched - schedule a bottom half (DPC)
* @hdl: OS handle
* @bh: pointer to bottom
* Return: none
*/
static inline void qdf_sched_bh(qdf_handle_t hdl, qdf_bh_t *bh)
static inline void qdf_sched_bh(qdf_bh_t *bh)
{
__qdf_sched_bh(hdl, bh);
__qdf_sched_bh(bh);
}
/**
* qdf_destroy_bh - destroy the bh (synchronous)
* @hdl: OS handle
* @bh: pointer to bottom
* Return: none
*/
static inline void qdf_destroy_bh(qdf_handle_t hdl, qdf_bh_t *bh)
static inline void qdf_destroy_bh(qdf_bh_t *bh)
{
__qdf_disable_bh(hdl, bh);
__qdf_disable_bh(bh);
}
/*********************Non-Interrupt Context deferred Execution***************/
@@ -110,23 +107,22 @@ static inline void qdf_destroy_bh(qdf_handle_t hdl, qdf_bh_t *bh)
static inline QDF_STATUS qdf_create_work(qdf_handle_t hdl, qdf_work_t *work,
qdf_defer_fn_t func, void *arg)
{
return __qdf_init_work(hdl, work, func, arg);
return __qdf_init_work(work, func, arg);
}
/**
* qdf_create_delayed_work - create a delayed work/task, This runs in
* non-interrupt context, so can be preempted by H/W & S/W intr
* @hdl: OS handle
* @work: pointer to work
* @func: deferred function to run at bottom half non-interrupt context.
* @arg: argument for the deferred function
* Return: none
*/
static inline void qdf_create_delayed_work(qdf_handle_t hdl,
qdf_delayed_work_t *work,
qdf_defer_fn_t func, void *arg)
static inline void qdf_create_delayed_work(qdf_delayed_work_t *work,
qdf_defer_fn_t func,
void *arg)
{
__qdf_init_delayed_work(hdl, work, func, arg);
__qdf_init_delayed_work(work, func, arg);
}
/**
@@ -165,23 +161,21 @@ static inline qdf_workqueue_t *qdf_create_singlethread_workqueue(char *name)
static inline void
qdf_queue_work(qdf_handle_t hdl, qdf_workqueue_t *wqueue, qdf_work_t *work)
{
return __qdf_queue_work(hdl, wqueue, work);
return __qdf_queue_work(wqueue, work);
}
/**
* qdf_queue_delayed_work - Queue the delayed work/task
* @hdl: OS handle
* @wqueue: pointer to workqueue
* @work: pointer to work
* @delay: delay interval in milliseconds
* Return: none
*/
static inline void qdf_queue_delayed_work(qdf_handle_t hdl,
qdf_workqueue_t *wqueue,
static inline void qdf_queue_delayed_work(qdf_workqueue_t *wqueue,
qdf_delayed_work_t *work,
uint32_t delay)
{
return __qdf_queue_delayed_work(hdl, wqueue, work, delay);
return __qdf_queue_delayed_work(wqueue, work, delay);
}
/**
@@ -193,7 +187,7 @@ static inline void qdf_queue_delayed_work(qdf_handle_t hdl,
static inline void qdf_flush_workqueue(qdf_handle_t hdl,
qdf_workqueue_t *wqueue)
{
return __qdf_flush_workqueue(hdl, wqueue);
return __qdf_flush_workqueue(wqueue);
}
/**
@@ -205,7 +199,7 @@ static inline void qdf_flush_workqueue(qdf_handle_t hdl,
static inline void qdf_destroy_workqueue(qdf_handle_t hdl,
qdf_workqueue_t *wqueue)
{
return __qdf_destroy_workqueue(hdl, wqueue);
return __qdf_destroy_workqueue(wqueue);
}
/**
@@ -216,26 +210,23 @@ static inline void qdf_destroy_workqueue(qdf_handle_t hdl,
*/
static inline void qdf_sched_work(qdf_handle_t hdl, qdf_work_t *work)
{
__qdf_sched_work(hdl, work);
__qdf_sched_work(work);
}
/**
* qdf_sched_delayed_work() - Schedule a delayed task
* @hdl: OS handle
* @work: pointer to delayed work
* @delay: delay interval in milliseconds
* Return: none
*/
static inline void qdf_sched_delayed_work(qdf_handle_t hdl,
qdf_delayed_work_t *work,
uint32_t delay)
static inline void
qdf_sched_delayed_work(qdf_delayed_work_t *work, uint32_t delay)
{
__qdf_sched_delayed_work(hdl, work, delay);
__qdf_sched_delayed_work(work, delay);
}
/**
* qdf_cancel_work() - Cancel a work
* @hdl: OS handle
* @work: pointer to work
*
* Cancel work and wait for its execution to finish.
@@ -248,30 +239,26 @@ static inline void qdf_sched_delayed_work(qdf_handle_t hdl,
*
* Return: true if work was pending, false otherwise
*/
static inline bool qdf_cancel_work(qdf_handle_t hdl,
qdf_work_t *work)
static inline bool qdf_cancel_work(qdf_work_t *work)
{
return __qdf_cancel_work(hdl, work);
return __qdf_cancel_work(work);
}
/**
* qdf_cancel_delayed_work() - Cancel a delayed work
* @hdl: OS handle
* @work: pointer to delayed work
*
* This is qdf_cancel_work for delayed works.
*
* Return: true if work was pending, false otherwise
*/
static inline bool qdf_cancel_delayed_work(qdf_handle_t hdl,
qdf_delayed_work_t *work)
static inline bool qdf_cancel_delayed_work(qdf_delayed_work_t *work)
{
return __qdf_cancel_delayed_work(hdl, work);
return __qdf_cancel_delayed_work(work);
}
/**
* qdf_flush_work - Flush a deferred task on non-interrupt context
* @hdl: OS handle
* @work: pointer to work
*
* Wait until work has finished execution. work is guaranteed to be
@@ -279,35 +266,32 @@ static inline bool qdf_cancel_delayed_work(qdf_handle_t hdl,
*
* Return: none
*/
static inline void qdf_flush_work(qdf_handle_t hdl, qdf_work_t *work)
static inline void qdf_flush_work(qdf_work_t *work)
{
__qdf_flush_work(hdl, work);
__qdf_flush_work(work);
}
/**
* qdf_flush_delayed_work() - Flush a delayed work
* @hdl: OS handle
* @work: pointer to delayed work
*
* This is qdf_flush_work for delayed works.
*
* Return: none
*/
static inline void qdf_flush_delayed_work(qdf_handle_t hdl,
qdf_delayed_work_t *work)
static inline void qdf_flush_delayed_work(qdf_delayed_work_t *work)
{
__qdf_flush_delayed_work(hdl, work);
__qdf_flush_delayed_work(work);
}
/**
* qdf_disable_work - disable the deferred task (synchronous)
* @hdl: OS handle
* @work: pointer to work
* Return: unsigned int
*/
static inline uint32_t qdf_disable_work(qdf_handle_t hdl, qdf_work_t *work)
static inline uint32_t qdf_disable_work(qdf_work_t *work)
{
return __qdf_disable_work(hdl, work);
return __qdf_disable_work(work);
}
/**
@@ -318,7 +302,7 @@ static inline uint32_t qdf_disable_work(qdf_handle_t hdl, qdf_work_t *work)
*/
static inline void qdf_destroy_work(qdf_handle_t hdl, qdf_work_t *work)
{
__qdf_disable_work(hdl, work);
__qdf_disable_work(work);
}
#endif /*_QDF_DEFER_H*/

111
qdf/linux/src/i_qdf_defer.h
View File

@@ -82,15 +82,13 @@ typedef void (*__qdf_bh_fn_t)(unsigned long arg);
/**
* __qdf_init_work - Initialize a work/task queue, This runs in non-interrupt
* context, so can be preempted by H/W & S/W intr
* @hdl: OS handle
* @work: pointer to work
* @func: deferred function to run at bottom half non-interrupt context.
* @arg: argument for the deferred function
* Return: none
*/
static inline QDF_STATUS __qdf_init_work(qdf_handle_t hdl,
__qdf_work_t *work,
qdf_defer_fn_t func, void *arg)
static inline QDF_STATUS
__qdf_init_work(__qdf_work_t *work, qdf_defer_fn_t func, void *arg)
{
/*Initilize func and argument in work struct */
INIT_WORK(&work->work, __qdf_defer_func);
@@ -100,15 +98,14 @@ static inline QDF_STATUS __qdf_init_work(qdf_handle_t hdl,
/**
* __qdf_init_delayed_work - create a work/task, This runs in non-interrupt
* context, so can be preempted by H/W & S/W intr
* @hdl: OS handle
* @work: pointer to work
* @func: deferred function to run at bottom half non-interrupt context.
* @arg: argument for the deferred function
* Return: none
*/
static inline uint32_t __qdf_init_delayed_work(qdf_handle_t hdl,
__qdf_delayed_work_t *work,
qdf_defer_fn_t func, void *arg)
static inline uint32_t __qdf_init_delayed_work(__qdf_delayed_work_t *work,
qdf_defer_fn_t func,
void *arg)
{
INIT_WORK(work, func, arg);
return QDF_STATUS_SUCCESS;
@@ -116,28 +113,24 @@ static inline uint32_t __qdf_init_delayed_work(qdf_handle_t hdl,
/**
* __qdf_queue_work - Queue the work/task
* @hdl: OS handle
* @wqueue: pointer to workqueue
* @work: pointer to work
* Return: none
*/
static inline void __qdf_queue_work(qdf_handle_t hdl,
__qdf_workqueue_t *wqueue,
__qdf_work_t *work)
static inline void
__qdf_queue_work(__qdf_workqueue_t *wqueue, __qdf_work_t *work)
{
queue_work(wqueue, work);
}
/**
* __qdf_queue_delayed_work - Queue the delayed work/task
* @hdl: OS handle
* @wqueue: pointer to workqueue
* @work: pointer to work
* @delay: delay interval
* Return: none
*/
static inline void __qdf_queue_delayed_work(qdf_handle_t hdl,
__qdf_workqueue_t *wqueue,
static inline void __qdf_queue_delayed_work(__qdf_workqueue_t *wqueue,
__qdf_delayed_work_t *work,
uint32_t delay)
{
@@ -146,11 +139,10 @@ static inline void __qdf_queue_delayed_work(qdf_handle_t hdl,
/**
* __qdf_sched_work - Schedule a deferred task on non-interrupt context
* @hdl: OS handle
* @work: pointer to work
* Retrun: none
*/
static inline QDF_STATUS __qdf_sched_work(qdf_handle_t hdl, __qdf_work_t *work)
static inline QDF_STATUS __qdf_sched_work(__qdf_work_t *work)
{
schedule_work(work);
return QDF_STATUS_SUCCESS;
@@ -158,14 +150,12 @@ static inline QDF_STATUS __qdf_sched_work(qdf_handle_t hdl, __qdf_work_t *work)
/**
* __qdf_sched_delayed_work() - Schedule a delayed work
* @hdl: OS handle
* @work: pointer to delayed work
* @delay: delay interval
* Return: none
*/
static inline QDF_STATUS __qdf_sched_delayed_work(qdf_handle_t hdl,
__qdf_delayed_work_t *work,
uint32_t delay)
static inline QDF_STATUS
__qdf_sched_delayed_work(__qdf_delayed_work_t *work, uint32_t delay)
{
schedule_delayed_work(work, msecs_to_jiffies(delay));
return QDF_STATUS_SUCCESS;
@@ -173,35 +163,30 @@ static inline QDF_STATUS __qdf_sched_delayed_work(qdf_handle_t hdl,
/**
* __qdf_cancel_work() - Cancel a work
* @hdl: OS handle
* @work: pointer to work
* Return: true if work was pending, false otherwise
*/
static inline bool __qdf_cancel_work(qdf_handle_t hdl,
__qdf_work_t *work)
static inline bool __qdf_cancel_work(__qdf_work_t *work)
{
return cancel_work_sync(work);
}
/**
* __qdf_cancel_delayed_work() - Cancel a delayed work
* @hdl: OS handle
* @work: pointer to delayed work
* Return: true if work was pending, false otherwise
*/
static inline bool __qdf_cancel_delayed_work(qdf_handle_t hdl,
__qdf_delayed_work_t *work)
static inline bool __qdf_cancel_delayed_work(__qdf_delayed_work_t *work)
{
return cancel_delayed_work_sync(work);
}
/**
* __qdf_flush_work - Flush a deferred task on non-interrupt context
* @hdl: OS handle
* @work: pointer to work
* Return: none
*/
static inline uint32_t __qdf_flush_work(qdf_handle_t hdl, __qdf_work_t *work)
static inline uint32_t __qdf_flush_work(__qdf_work_t *work)
{
flush_work(work);
return QDF_STATUS_SUCCESS;
@@ -209,21 +194,18 @@ static inline uint32_t __qdf_flush_work(qdf_handle_t hdl, __qdf_work_t *work)
/**
* __qdf_flush_delayed_work() - Flush a delayed work
* @hdl: OS handle
* @work: pointer to delayed work
* Return: none
*/
static inline uint32_t __qdf_flush_delayed_work(qdf_handle_t hdl,
__qdf_delayed_work_t *work)
static inline uint32_t __qdf_flush_delayed_work(__qdf_delayed_work_t *work)
{
flush_delayed_work(work);
return QDF_STATUS_SUCCESS;
}
#else
static inline QDF_STATUS __qdf_init_work(qdf_handle_t hdl,
__qdf_work_t *work,
qdf_defer_fn_t func, void *arg)
static inline QDF_STATUS
__qdf_init_work(__qdf_work_t *work, qdf_defer_fn_t func, void *arg)
{
work->fn = func;
work->arg = arg;
@@ -231,9 +213,9 @@ static inline QDF_STATUS __qdf_init_work(qdf_handle_t hdl,
return QDF_STATUS_SUCCESS;
}
static inline uint32_t __qdf_init_delayed_work(qdf_handle_t hdl,
__qdf_delayed_work_t *work,
qdf_defer_fn_t func, void *arg)
static inline uint32_t __qdf_init_delayed_work(__qdf_delayed_work_t *work,
qdf_defer_fn_t func,
void *arg)
{
/*Initilize func and argument in work struct */
work->fn = func;
@@ -242,54 +224,49 @@ static inline uint32_t __qdf_init_delayed_work(qdf_handle_t hdl,
return QDF_STATUS_SUCCESS;
}
static inline void __qdf_queue_work(qdf_handle_t hdl,
__qdf_workqueue_t *wqueue,
__qdf_work_t *work)
static inline void
__qdf_queue_work(__qdf_workqueue_t *wqueue, __qdf_work_t *work)
{
queue_work(wqueue, &work->work);
}
static inline void __qdf_queue_delayed_work(qdf_handle_t hdl,
__qdf_workqueue_t *wqueue,
static inline void __qdf_queue_delayed_work(__qdf_workqueue_t *wqueue,
__qdf_delayed_work_t *work,
uint32_t delay)
{
queue_delayed_work(wqueue, &work->dwork, msecs_to_jiffies(delay));
}
static inline QDF_STATUS __qdf_sched_work(qdf_handle_t hdl, __qdf_work_t *work)
static inline QDF_STATUS __qdf_sched_work(__qdf_work_t *work)
{
schedule_work(&work->work);
return QDF_STATUS_SUCCESS;
}
static inline QDF_STATUS __qdf_sched_delayed_work(qdf_handle_t hdl,
__qdf_delayed_work_t *work,
uint32_t delay)
static inline QDF_STATUS
__qdf_sched_delayed_work(__qdf_delayed_work_t *work, uint32_t delay)
{
schedule_delayed_work(&work->dwork, msecs_to_jiffies(delay));
return QDF_STATUS_SUCCESS;
}
static inline bool __qdf_cancel_work(qdf_handle_t hdl,
__qdf_work_t *work)
static inline bool __qdf_cancel_work(__qdf_work_t *work)
{
return cancel_work_sync(&work->work);
}
static inline bool __qdf_cancel_delayed_work(qdf_handle_t hdl,
__qdf_delayed_work_t *work)
static inline bool __qdf_cancel_delayed_work(__qdf_delayed_work_t *work)
{
return cancel_delayed_work_sync(&work->dwork);
}
static inline uint32_t __qdf_flush_work(qdf_handle_t hdl, __qdf_work_t *work)
static inline uint32_t __qdf_flush_work(__qdf_work_t *work)
{
flush_work(&work->work);
return QDF_STATUS_SUCCESS;
}
static inline uint32_t __qdf_flush_delayed_work(qdf_handle_t hdl,
__qdf_delayed_work_t *work)
static inline uint32_t __qdf_flush_delayed_work(__qdf_delayed_work_t *work)
{
flush_delayed_work(&work->dwork);
return QDF_STATUS_SUCCESS;
@@ -325,39 +302,33 @@ static inline __qdf_workqueue_t *__qdf_create_singlethread_workqueue(char *name)
/**
* __qdf_flush_workqueue - flush the workqueue
* @hdl: OS handle
* @wqueue: pointer to workqueue
* Return: none
*/
static inline void __qdf_flush_workqueue(qdf_handle_t hdl,
__qdf_workqueue_t *wqueue)
static inline void __qdf_flush_workqueue(__qdf_workqueue_t *wqueue)
{
flush_workqueue(wqueue);
}
/**
* __qdf_destroy_workqueue - Destroy the workqueue
* @hdl: OS handle
* @wqueue: pointer to workqueue
* Return: none
*/
static inline void __qdf_destroy_workqueue(qdf_handle_t hdl,
__qdf_workqueue_t *wqueue)
static inline void __qdf_destroy_workqueue(__qdf_workqueue_t *wqueue)
{
destroy_workqueue(wqueue);
}
/**
* __qdf_init_bh - creates the Bottom half deferred handler
* @hdl: OS handle
* @bh: pointer to bottom
* @func: deferred function to run at bottom half interrupt context.
* @arg: argument for the deferred function
* Return: none
*/
static inline QDF_STATUS __qdf_init_bh(qdf_handle_t hdl,
struct tasklet_struct *bh,
qdf_defer_fn_t func, void *arg)
static inline QDF_STATUS
__qdf_init_bh(struct tasklet_struct *bh, qdf_defer_fn_t func, void *arg)
{
tasklet_init(bh, (__qdf_bh_fn_t) func, (unsigned long)arg);
return QDF_STATUS_SUCCESS;
@@ -369,12 +340,10 @@ static inline QDF_STATUS __qdf_init_bh(qdf_handle_t hdl,
/**
* __qdf_sched_bh - schedule a bottom half (DPC)
* @hdl: OS handle
* @bh: pointer to bottom
* Return: none
*/
static inline QDF_STATUS
__qdf_sched_bh(qdf_handle_t hdl, struct tasklet_struct *bh)
static inline QDF_STATUS __qdf_sched_bh(struct tasklet_struct *bh)
{
tasklet_schedule(bh);
return QDF_STATUS_SUCCESS;
@@ -382,12 +351,10 @@ __qdf_sched_bh(qdf_handle_t hdl, struct tasklet_struct *bh)
/**
* __qdf_disable_work - disable the deferred task (synchronous)
* @hdl: OS handle
* @work: pointer to work
* Return: unsigned int
*/
static inline QDF_STATUS
__qdf_disable_work(qdf_handle_t hdl, __qdf_work_t *work)
static inline QDF_STATUS __qdf_disable_work(__qdf_work_t *work)
{
if (cancel_work_sync(&work->work))
return QDF_STATUS_E_ALREADY;
@@ -397,12 +364,10 @@ __qdf_disable_work(qdf_handle_t hdl, __qdf_work_t *work)
/**
* __qdf_disable_bh - destroy the bh (synchronous)
* @hdl: OS handle
* @bh: pointer to bottom
* Return: none
*/
static inline QDF_STATUS
__qdf_disable_bh(qdf_handle_t hdl, struct tasklet_struct *bh)
static inline QDF_STATUS __qdf_disable_bh(struct tasklet_struct *bh)
{
tasklet_kill(bh);
return QDF_STATUS_SUCCESS;

2
umac/cmn_services/policy_mgr/src/wlan_policy_mgr_init_deinit.c
View File

@@ -365,7 +365,7 @@ QDF_STATUS policy_mgr_psoc_close(struct wlan_objmgr_psoc *psoc)
}
if (pm_ctx->sta_ap_intf_check_work_info) {
qdf_cancel_work(0, &pm_ctx->sta_ap_intf_check_work);
qdf_cancel_work(&pm_ctx->sta_ap_intf_check_work);
qdf_mem_free(pm_ctx->sta_ap_intf_check_work_info);
pm_ctx->sta_ap_intf_check_work_info = NULL;
}