1 /* 2 * Copyright (c) 2014-2018 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #if !defined(__SCHEDULER_API_H) 20 #define __SCHEDULER_API_H 21 22 #include <qdf_event.h> 23 #include <qdf_types.h> 24 #include <qdf_lock.h> 25 #include <qdf_mc_timer.h> 26 #include <qdf_status.h> 27 28 /* Controller thread various event masks 29 * MC_POST_EVENT_MASK: wake up thread after posting message 30 * MC_SUSPEND_EVENT_MASK: signal thread to suspend during kernel pm suspend 31 * MC_SHUTDOWN_EVENT_MASK: signal thread to shutdown and exit during unload 32 */ 33 #define MC_POST_EVENT_MASK 0x001 34 #define MC_SUSPEND_EVENT_MASK 0x002 35 #define MC_SHUTDOWN_EVENT_MASK 0x010 36 37 /* 38 * Cookie for timer messages. Note that anyone posting a timer message 39 * has to write the COOKIE in the reserved field of the message. The 40 * timer queue handler relies on this COOKIE 41 */ 42 #define SYS_MSG_COOKIE 0xFACE 43 44 #define scheduler_get_src_id(qid) (((qid) >> 20) & 0x3FF) 45 #define scheduler_get_dest_id(qid) (((qid) >> 10) & 0x3FF) 46 #define scheduler_get_que_id(qid) ((qid) & 0x3FF) 47 #define scheduler_get_qid(src, dest, que_id) ((que_id) | ((dest) << 10) |\ 48 ((src) << 20)) 49 50 typedef enum { 51 SYS_MSG_ID_MC_TIMER, 52 SYS_MSG_ID_FTM_RSP, 53 SYS_MSG_ID_QVIT, 54 SYS_MSG_ID_DATA_STALL_MSG, 55 SYS_MSG_ID_UMAC_STOP, 56 } SYS_MSG_ID; 57 58 /** 59 * struct scheduler_msg: scheduler message structure 60 * @type: message type 61 * @reserved: reserved field 62 * @bodyval: message body val 63 * @bodyptr: message body pointer based on the type either a bodyptr pointer 64 * into memory or bodyval as a 32 bit data is used. bodyptr is always a 65 * freeable pointer, one should always make sure that bodyptr is always 66 * freeable. 67 * Messages should use either bodyptr or bodyval; not both !!! 68 * @callback: callback to be called by scheduler thread once message is posted 69 * and scheduler thread has started processing the message. 70 * @flush_callback: flush callback which will be invoked during driver unload 71 * such that component can release the ref count of common global objects 72 * like PSOC, PDEV, VDEV and PEER. A component needs to populate flush 73 * callback in message body pointer for those messages which have taken ref 74 * count for above mentioned common objects. 75 * @node: list node for queue membership 76 */ 77 struct scheduler_msg { 78 uint16_t type; 79 uint16_t reserved; 80 uint32_t bodyval; 81 void *bodyptr; 82 void *callback; 83 void *flush_callback; 84 qdf_list_node_t node; 85 }; 86 87 typedef QDF_STATUS (*scheduler_msg_process_fn_t) (struct scheduler_msg *msg); 88 typedef void (*hdd_suspend_callback)(void); 89 90 /** 91 * scheduler_init() - initialize control path scheduler 92 * 93 * This API initializes control path scheduler. 94 * 95 * Return: QDF status 96 */ 97 QDF_STATUS scheduler_init(void); 98 99 /** 100 * scheduler_deinit() - de-initialize control path scheduler 101 * 102 * This API de-initializes control path scheduler. 103 * 104 * Return: QDF status 105 */ 106 QDF_STATUS scheduler_deinit(void); 107 108 /** 109 * scheduler_enable() - start the scheduler module 110 * 111 * Ready the scheduler module to service requests, and start the scheduler's 112 * message processing thread. Must only be called after scheduler_init(). 113 * 114 * Return: QDF_STATUS 115 */ 116 QDF_STATUS scheduler_enable(void); 117 118 /** 119 * scheduler_disable() - stop the scheduler module 120 * 121 * Stop the scheduler module from servicing requests, and terminate the 122 * scheduler's message processing thread. Must be called before 123 * scheduler_deinit(). 124 * 125 * Return: QDF_STATUS 126 */ 127 QDF_STATUS scheduler_disable(void); 128 129 /** 130 * scheduler_register_module() - register input module/queue id 131 * @qid: queue id to get registered 132 * @callback: queue message to be called when a message is posted 133 * 134 * Return: QDF status 135 */ 136 QDF_STATUS scheduler_register_module(QDF_MODULE_ID qid, 137 scheduler_msg_process_fn_t callback); 138 139 /** 140 * scheduler_deregister_module() - deregister input module/queue id 141 * @qid: queue id to get deregistered 142 * 143 * Return: QDF status 144 */ 145 QDF_STATUS scheduler_deregister_module(QDF_MODULE_ID qid); 146 147 /** 148 * scheduler_post_msg_by_priority() - post messages by priority 149 * @qid: queue id to which the message has to be posted. 150 * @msg: message pointer 151 * @is_high_priority: set to true for high priority message else false 152 * 153 * Return: QDF status 154 */ 155 QDF_STATUS scheduler_post_msg_by_priority(uint32_t qid, 156 struct scheduler_msg *msg, 157 bool is_high_priority); 158 159 /** 160 * scheduler_post_msg() - post normal messages(no priority) 161 * @qid: queue id to which the message has to be posted. 162 * @msg: message pointer 163 * 164 * Return: QDF status 165 */ 166 static inline QDF_STATUS scheduler_post_msg(uint32_t qid, 167 struct scheduler_msg *msg) 168 { 169 return scheduler_post_msg_by_priority(qid, msg, false); 170 } 171 172 /** 173 * scheduler_post_message() - post normal messages(no priority) 174 * @src_id: Source module of the message 175 * @dest_id: Destination module of the message 176 * @que_id: Queue to which the message has to posted. 177 * @msg: message pointer 178 * 179 * This function will mask the src_id, and destination id to qid of 180 * scheduler_post_msg 181 * Return: QDF status 182 */ 183 static inline QDF_STATUS scheduler_post_message(QDF_MODULE_ID src_id, 184 QDF_MODULE_ID dest_id, 185 QDF_MODULE_ID que_id, 186 struct scheduler_msg *msg) 187 { 188 return scheduler_post_msg(scheduler_get_qid(src_id, dest_id, que_id), 189 msg); 190 } 191 192 /** 193 * scheduler_resume() - resume scheduler thread 194 * 195 * Complete scheduler thread resume wait event such that scheduler 196 * thread can wake up and process message queues 197 * 198 * Return: none 199 */ 200 void scheduler_resume(void); 201 202 /** 203 * scheduler_register_hdd_suspend_callback() - suspend callback to hdd 204 * @callback: hdd callback to be called when controllred thread is suspended 205 * 206 * Return: none 207 */ 208 void scheduler_register_hdd_suspend_callback(hdd_suspend_callback callback); 209 210 /** 211 * scheduler_wake_up_controller_thread() - wake up controller thread 212 * 213 * Wake up controller thread to process a critical message. 214 * 215 * Return: none 216 */ 217 void scheduler_wake_up_controller_thread(void); 218 219 /** 220 * scheduler_set_event_mask() - set given event mask 221 * @event_mask: event mask to set 222 * 223 * Set given event mask such that controller scheduler thread can do 224 * specified work after wake up. 225 * 226 * Return: none 227 */ 228 void scheduler_set_event_mask(uint32_t event_mask); 229 230 /** 231 * scheduler_clear_event_mask() - clear given event mask 232 * @event_mask: event mask to set 233 * 234 * Return: none 235 */ 236 void scheduler_clear_event_mask(uint32_t event_mask); 237 238 /** 239 * scheduler_target_if_mq_handler() - top level message queue handler for 240 * target_if message queue 241 * @msg: pointer to actual message being handled 242 * 243 * Return: none 244 */ 245 QDF_STATUS scheduler_target_if_mq_handler(struct scheduler_msg *msg); 246 247 /** 248 * scheduler_os_if_mq_handler() - top level message queue handler for 249 * os_if message queue 250 * @msg: pointer to actual message being handled 251 * 252 * Return: none 253 */ 254 QDF_STATUS scheduler_os_if_mq_handler(struct scheduler_msg *msg); 255 256 /** 257 * scheduler_timer_q_mq_handler() - top level message queue handler for 258 * timer queue 259 * @msg: pointer to actual message being handled 260 * 261 * Return: none 262 */ 263 QDF_STATUS scheduler_timer_q_mq_handler(struct scheduler_msg *msg); 264 265 /** 266 * scheduler_scan_mq_handler() - top level message queue handler for 267 * scan queue 268 * @msg: pointer to actual message being handled 269 * 270 * Return: QDF status 271 */ 272 QDF_STATUS scheduler_scan_mq_handler(struct scheduler_msg *msg); 273 274 /** 275 * scheduler_register_wma_legacy_handler() - register legacy wma handler 276 * @callback: legacy wma handler to be called for WMA messages 277 * 278 * Return: QDF status 279 */ 280 QDF_STATUS scheduler_register_wma_legacy_handler(scheduler_msg_process_fn_t 281 callback); 282 283 /** 284 * scheduler_register_sys_legacy_handler() - register legacy sys handler 285 * @callback: legacy sys handler to be called for sys messages 286 * 287 * Return: QDF status 288 */ 289 QDF_STATUS scheduler_register_sys_legacy_handler(scheduler_msg_process_fn_t 290 callback); 291 /** 292 * scheduler_deregister_sys_legacy_handler() - deregister legacy sys handler 293 * 294 * Return: QDF status 295 */ 296 QDF_STATUS scheduler_deregister_sys_legacy_handler(void); 297 298 /** 299 * scheduler_deregister_wma_legacy_handler() - deregister legacy wma handler 300 * 301 * Return: QDF status 302 */ 303 QDF_STATUS scheduler_deregister_wma_legacy_handler(void); 304 305 /** 306 * scheduler_mc_timer_callback() - timer callback, gets called at time out 307 * @data: unsigned long, holds the timer object. 308 * 309 * Return: None 310 */ 311 void scheduler_mc_timer_callback(unsigned long data); 312 313 /** 314 * scheduler_get_queue_size() - Get the current size of the scheduler queue 315 * @qid: Queue ID for which the size is requested 316 * @size: Pointer to size where the size would be returned to the caller 317 * 318 * This API finds the size of the scheduler queue for the given Queue ID 319 * 320 * Return: QDF Status 321 */ 322 QDF_STATUS scheduler_get_queue_size(QDF_MODULE_ID qid, uint32_t *size); 323 #endif 324