ath9k_htc/target_firmware/magpie_fw_dev/target/adf/adf_os_defer_pvt.h

   1 /*
   2  * Copyright (c) 2013 Qualcomm Atheros, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted (subject to the limitations in the
   7  * disclaimer below) provided that the following conditions are met:
   8  *
   9  *  * Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  *  * Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  *  * Neither the name of Qualcomm Atheros nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific prior written permission.
  20  *
  21  * NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE
  22  * GRANTED BY THIS LICENSE.  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT
  23  * HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED
  24  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  26  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  30  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  31  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  32  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  33  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  */
  35 #ifndef __ADF_OS_DEFER_PVT_H
  36 #define __ADF_OS_DEFER_PVT_H
  37
  38 #include <adf_os_types.h>
  39 #include <cmnos_api.h>
  40 #include "Magpie_api.h"
  41
  42 /*
  43  * Because the real function taked an extra int :(
  44  */
  45 typedef struct {
  46     adf_os_defer_fn_t  caller_fn;
  47     void             *caller_arg;
  48 }__adf_os_defer_ctx_t;
  49
  50 /*
  51  * wrapper around the real task func
  52  */
  53 typedef struct {
  54     //struct task          tsk;
  55     __adf_os_defer_ctx_t ctx;
  56 }__adf_os_defer_t;
  57
  58 //typedef __adf_os_defer_t    __adf_os_bh_t;
  59 typedef A_tasklet_t         __adf_os_bh_t;
  60 typedef __adf_os_defer_t    __adf_os_work_t;
  61
  62 /*
  63  * wrapper function
  64  */
  65 extern void __adf_os_defer_func(void *arg, int pending);
  66
  67 /**
  68  * @brief initiallize the defer function (work or bh)
  69  *
  70  * @param defer
  71  * @param func
  72  * @param arg
  73  */
  74 static inline void __adf_os_init_defer(__adf_os_defer_t  *defer,
  75                                        adf_os_defer_fn_t    func,
  76                                        void              *arg)
  77 {
  78     defer->ctx.caller_fn  = func;
  79     defer->ctx.caller_arg = arg;
  80
  81     //TASK_INIT(&defer->tsk, 0, __adf_os_defer_func, &defer->ctx);
  82 }
  83
  84 static inline void __adf_os_init_work(adf_os_handle_t  hdl,
  85                                                                           __adf_os_work_t       *work,
  86                                                                           adf_os_defer_fn_t     func,
  87                                                                           void                          *arg)
  88 {
  89         __adf_os_init_defer(work, func, arg);
  90 }
  91
  92 static inline void      __adf_os_init_bh(adf_os_handle_t  hdl,
  93                                                                          __adf_os_bh_t          *bh,
  94                                                                          adf_os_defer_fn_t      func,
  95                                                                          void                           *arg)
  96 {
  97         //__adf_os_init_defer(bh, func, arg);
  98         A_TASKLET_INIT_TASK(func, arg, bh);
  99 }
 100 static inline void __adf_os_sched_work(adf_os_handle_t  hdl,
 101                                        __adf_os_work_t  * work)
 102 {
 103     //taskqueue_enqueue(taskqueue_thread, &work->tsk);
 104 }
 105 static inline void __adf_os_disable_work(adf_os_handle_t  hdl,
 106                                          __adf_os_work_t  * work)
 107 {
 108     //taskqueue_drain(taskqueue_thread, &work->tsk);
 109 }
 110
 111 static inline void __adf_os_sched_bh(adf_os_handle_t  hdl,
 112                                        __adf_os_bh_t  * bh)
 113 {
 114     A_TASKLET_SCHEDULE(bh);
 115 }
 116
 117 static inline void __adf_os_disable_bh(adf_os_handle_t  hdl,
 118                                        __adf_os_bh_t  * bh)
 119 {
 120     A_TASKLET_DISABLE(bh);
 121 }
 122
 123 #endif