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

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*/