1 /* 2 * Copyright (c) 2017-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 * DOC: wlan_serialization_utils_i.h 20 * This file defines the prototypes for the utility helper functions 21 * for the serialization component. 22 */ 23 #ifndef __WLAN_SERIALIZATION_UTILS_I_H 24 #define __WLAN_SERIALIZATION_UTILS_I_H 25 /* Include files */ 26 #include "qdf_status.h" 27 #include "qdf_list.h" 28 #include "qdf_mc_timer.h" 29 #include "wlan_objmgr_cmn.h" 30 #include "wlan_objmgr_global_obj.h" 31 #include "wlan_objmgr_psoc_obj.h" 32 #include "wlan_serialization_rules_i.h" 33 #include "wlan_scan_ucfg_api.h" 34 35 /* 36 * Below bit positions are used to identify if a 37 * serialization command is in use or marked for 38 * deletion. 39 * CMD_MARKED_FOR_DELETE - The command is about to be deleted 40 * CMD_IS_ACTIVE - The command is active and currently in use 41 */ 42 #define CMD_MARKED_FOR_DELETE 1 43 #define CMD_IS_ACTIVE 2 44 /** 45 * struct wlan_serialization_timer - Timer used for serialization 46 * @cmd: Cmd to which the timer is linked 47 * @timer: Timer associated with the command 48 * 49 * Timers are allocated statically during init, one each for the 50 * maximum active commands permitted in the system. Once a cmd is 51 * moved from pending list to active list, the timer is activated 52 * and once the cmd is completed, the timer is cancelled. Timer is 53 * also cancelled if the command is aborted 54 * 55 * The timers are maintained per psoc. A timer is associated to 56 * unique combination of pdev, cmd_type and cmd_id. 57 */ 58 struct wlan_serialization_timer { 59 struct wlan_serialization_command *cmd; 60 qdf_mc_timer_t timer; 61 }; 62 63 /** 64 * struct wlan_serialization_command_list - List of commands to be serialized 65 * @node: Node identifier in the list 66 * @cmd: Command to be serialized 67 * @active: flag to check if the node/entry is logically active 68 */ 69 struct wlan_serialization_command_list { 70 qdf_list_node_t node; 71 struct wlan_serialization_command cmd; 72 unsigned long cmd_in_use; 73 }; 74 75 /** 76 * struct wlan_serialization_pdev_priv_obj - pdev obj data for serialization 77 * @active_list: list to hold the non-scan commands currently being executed 78 * @pending_list list: to hold the non-scan commands currently pending 79 * @active_scan_list: list to hold the scan commands currently active 80 * @pending_scan_list: list to hold the scan commands currently pending 81 * @global_cmd_pool_list: list to hold the global buffers 82 * @pdev_ser_list_lock: A per pdev lock to protect the concurrent operations 83 * on the queues. 84 * 85 * Serialization component maintains linked lists to store the commands 86 * sent by other components to get serialized. All the lists are per 87 * pdev. The maximum number of active scans is determined by the firmware. 88 * There is only one non-scan active command per pdev at a time as per the 89 * current software architecture. cmd_ptr holds the memory allocated for 90 * each of the global cmd pool nodes and it is useful in freeing up these 91 * nodes when needed. 92 */ 93 struct wlan_serialization_pdev_priv_obj { 94 qdf_list_t active_list; 95 qdf_list_t pending_list; 96 qdf_list_t active_scan_list; 97 qdf_list_t pending_scan_list; 98 qdf_list_t global_cmd_pool_list; 99 qdf_spinlock_t pdev_ser_list_lock; 100 }; 101 102 /** 103 * struct wlan_serialization_psoc_priv_obj - psoc obj data for serialization 104 * @wlan_serialization_module_state_cb - module level callback 105 * @wlan_serialization_apply_rules_cb - pointer to apply rules on the cmd 106 * @timers - Timers associated with the active commands 107 * @max_axtive_cmds - Maximum active commands allowed 108 * 109 * Serialization component takes a command as input and checks whether to 110 * allow/deny the command. It will use the module level callback registered 111 * by each component to fetch the information needed to apply the rules. 112 * Once the information is available, the rules callback registered for each 113 * command internally by serialization will be applied to determine the 114 * checkpoint for the command. If allowed, command will be put into active/ 115 * pending list and each active command is associated with a timer. 116 */ 117 struct wlan_serialization_psoc_priv_obj { 118 wlan_serialization_comp_info_cb comp_info_cb[ 119 WLAN_SER_CMD_MAX][WLAN_UMAC_COMP_ID_MAX]; 120 wlan_serialization_apply_rules_cb apply_rules_cb[WLAN_SER_CMD_MAX]; 121 struct wlan_serialization_timer *timers; 122 uint8_t max_active_cmds; 123 }; 124 125 /** 126 * wlan_serialization_put_back_to_global_list() - put back cmd in global pool 127 * @queue: queue from which cmd needs to be taken out 128 * @ser_pdev_obj: pdev private object 129 * @cmd_list: cmd which needs to be matched 130 * 131 * command will be taken off from the queue and will be put back to global 132 * pool of free command buffers. 133 * 134 * Return: QDF_STATUS 135 */ 136 QDF_STATUS 137 wlan_serialization_put_back_to_global_list(qdf_list_t *queue, 138 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj, 139 struct wlan_serialization_command_list *cmd_list); 140 /** 141 * wlan_serialization_move_pending_to_active() - to move pending command to 142 * active queue 143 * @cmd_type: cmd type to device to which queue the command needs to go 144 * @ser_pdev_obj: pointer to ser_pdev_obj 145 * 146 * Return: none 147 */ 148 void wlan_serialization_move_pending_to_active( 149 enum wlan_serialization_cmd_type cmd_type, 150 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 151 /** 152 * wlan_serialization_get_pdev_from_cmd() - get pdev from provided cmd 153 * @cmd: pointer to actual command 154 * 155 * This API will get the pointer to pdev through checking type of cmd 156 * 157 * Return: pointer to pdev 158 */ 159 struct wlan_objmgr_pdev* 160 wlan_serialization_get_pdev_from_cmd(struct wlan_serialization_command *cmd); 161 162 /** 163 * wlan_serialization_get_cmd_from_queue() - to extract command from given queue 164 * @queue: pointer to queue 165 * @nnode: next node to extract 166 * @ser_pdev_obj: Serialization PDEV object pointer 167 * 168 * This API will try to extract node from queue which is next to prev node. If 169 * no previous node is given then take out the front node of the queue. 170 * 171 * Return: QDF_STATUS 172 */ 173 QDF_STATUS wlan_serialization_get_cmd_from_queue(qdf_list_t *queue, 174 qdf_list_node_t **nnode, 175 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 176 177 /** 178 * wlan_serialization_is_active_cmd_allowed() - check to see if command 179 * is allowed in active queue 180 * @pdev: pointer to pdev structure 181 * @cmd_type: type of command to check against 182 * 183 * Takes the command type and based on the type, it checks scan command queue 184 * or nonscan command queue to see if active command is allowed or no 185 * 186 * Return: true if allowed else false 187 */ 188 bool wlan_serialization_is_active_cmd_allowed( 189 struct wlan_serialization_command *cmd); 190 191 /** 192 * wlan_serialization_cleanup_all_timers() - to clean-up all timers 193 * 194 * @psoc_ser_ob: pointer to serialization psoc private object 195 * 196 * This API is to cleanup all the timers. it can be used when serialization 197 * module is exiting. it will make sure that if timer is running then it will 198 * stop and destroys the timer 199 * 200 * Return: QDF_STATUS 201 */ 202 QDF_STATUS wlan_serialization_cleanup_all_timers( 203 struct wlan_serialization_psoc_priv_obj *psoc_ser_ob); 204 205 /** 206 * wlan_serialization_find_and_remove_cmd() - to find cmd from queue and remove 207 * @cmd_info: pointer to command related information 208 * 209 * This api will find command from active queue and removes the command 210 * 211 * Return: QDF_STATUS 212 */ 213 QDF_STATUS wlan_serialization_find_and_remove_cmd( 214 struct wlan_serialization_queued_cmd_info *cmd_info); 215 216 /** 217 * wlan_serialization_find_and_cancel_cmd() - to find cmd from queue and cancel 218 * @cmd_info: pointer to command related information 219 * 220 * This api will find command from active queue and pending queue and 221 * removes the command. If it is in active queue then it will notifies the 222 * requester that it is in active queue and from there it expects requester 223 * to send remove command 224 * 225 * Return: wlan_serialization_cmd_status 226 */ 227 enum wlan_serialization_cmd_status 228 wlan_serialization_find_and_cancel_cmd( 229 struct wlan_serialization_queued_cmd_info *cmd_info); 230 /** 231 * wlan_serialization_enqueue_cmd() - Enqueue the cmd to pending/active Queue 232 * @cmd: Command information 233 * @is_cmd_for_active_queue: whether command is for active queue 234 * @cmd_list: command which needs to be inserted in active queue 235 * Return: Status of the serialization request 236 */ 237 enum wlan_serialization_status 238 wlan_serialization_enqueue_cmd( 239 struct wlan_serialization_command *cmd, 240 uint8_t is_cmd_for_active_queue, 241 struct wlan_serialization_command_list **pcmd_list); 242 243 /** 244 * wlan_serialization_dequeue_cmd() - dequeue the cmd to pending/active Queue 245 * @cmd: Command information 246 * @is_cmd_for_active_queue: whether command is for active queue 247 * 248 * Return: Status of the serialization request 249 */ 250 enum wlan_serialization_cmd_status 251 wlan_serialization_dequeue_cmd(struct wlan_serialization_command *cmd, 252 uint8_t is_cmd_for_active_queue); 253 /** 254 * wlan_serialization_find_and_stop_timer() - to find and stop the timer 255 * @psoc: pointer to psoc 256 * @cmd: pointer to actual command 257 * 258 * find the timer associated with command, stop it and destroy it 259 * 260 * Return: QDF_STATUS 261 */ 262 QDF_STATUS 263 wlan_serialization_find_and_stop_timer(struct wlan_objmgr_psoc *psoc, 264 struct wlan_serialization_command *cmd); 265 /** 266 * wlan_serialization_find_and_stop_timer() - to find and start the timer 267 * @psoc: pointer to psoc 268 * @cmd: pointer to actual command 269 * 270 * find the free timer, initialize it, and start it 271 * 272 * Return: QDF_STATUS 273 */ 274 QDF_STATUS 275 wlan_serialization_find_and_start_timer(struct wlan_objmgr_psoc *psoc, 276 struct wlan_serialization_command *cmd); 277 278 /** 279 * wlan_serialization_validate_cmd() - Validate the command 280 * @comp_id: Component ID 281 * @cmd_type: Command Type 282 * 283 * Return: QDF Status 284 */ 285 QDF_STATUS wlan_serialization_validate_cmd( 286 enum wlan_umac_comp_id comp_id, 287 enum wlan_serialization_cmd_type cmd_type); 288 289 /** 290 * wlan_serialization_validate_cmdtype() - Validate the command type 291 * @cmd_type: Command Type 292 * 293 * Return: QDF Status 294 */ 295 QDF_STATUS wlan_serialization_validate_cmdtype( 296 enum wlan_serialization_cmd_type cmd_type); 297 298 299 /** 300 * wlan_serialization_destroy_list() - Release the cmds and destroy list 301 * @ser_pdev_obj: Serialization private pdev object 302 * @list: List to be destroyed 303 * 304 * Return: None 305 */ 306 void wlan_serialization_destroy_list( 307 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj, 308 qdf_list_t *list); 309 310 /** 311 * wlan_serialization_get_psoc_priv_obj() - Return the component private obj 312 * @psoc: Pointer to the PSOC object 313 * 314 * Return: Serialization component's PSOC level private data object 315 */ 316 struct wlan_serialization_psoc_priv_obj *wlan_serialization_get_psoc_priv_obj( 317 struct wlan_objmgr_psoc *psoc); 318 319 /** 320 * wlan_serialization_get_pdev_priv_obj() - Return the component private obj 321 * @psoc: Pointer to the PDEV object 322 * 323 * Return: Serialization component's PDEV level private data object 324 */ 325 struct wlan_serialization_pdev_priv_obj *wlan_serialization_get_pdev_priv_obj( 326 struct wlan_objmgr_pdev *pdev); 327 328 /** 329 * wlan_serialization_get_psoc_obj() - Return the component private obj 330 * @psoc: Pointer to the SERIALIZATION object 331 * 332 * Return: Serialization component's level private data object 333 */ 334 struct wlan_serialization_psoc_priv_obj * 335 wlan_serialization_get_psoc_obj(struct wlan_serialization_command *cmd); 336 337 /** 338 * wlan_serialization_is_cmd_in_vdev_list() - Check Node present in VDEV list 339 * @vdev: Pointer to the VDEV object 340 * @queue: Pointer to the qdf_list_t 341 * 342 * Return: Boolean true or false 343 */ 344 bool 345 wlan_serialization_is_cmd_in_vdev_list( 346 struct wlan_objmgr_vdev *vdev, qdf_list_t *queue); 347 348 /** 349 * wlan_serialization_is_cmd_in_pdev_list() - Check Node present in PDEV list 350 * @pdev: Pointer to the PDEV object 351 * @queue: Pointer to the qdf_list_t 352 * 353 * Return: Boolean true or false 354 */ 355 bool 356 wlan_serialization_is_cmd_in_pdev_list( 357 struct wlan_objmgr_pdev *pdev, qdf_list_t *queue); 358 359 /** 360 * wlan_serialization_is_cmd_in_active_pending() - return cmd status 361 * active/pending queue 362 * @cmd_in_active: CMD in active list 363 * @cmd_in_pending: CMD in pending list 364 * 365 * Return: enum wlan_serialization_cmd_status 366 */ 367 enum wlan_serialization_cmd_status 368 wlan_serialization_is_cmd_in_active_pending(bool cmd_in_active, 369 bool cmd_in_pending); 370 371 /** 372 * wlan_serialization_remove_all_cmd_from_queue() - Remove cmd which matches 373 * @queue: queue from where command needs to be removed 374 * @ser_pdev_obj: pointer to serialization object 375 * @pdev: pointer to pdev 376 * @vdev: pointer to vdev 377 * @cmd: pointer to cmd 378 * @is_active_queue: to check if command matching is for active queue 379 * 380 * This API will remove one or more commands which match the given parameters 381 * interms of argument. For example, if user request all commands to removed 382 * which matches "vdev" then iterate through all commands, find out and remove 383 * command which matches vdev object. 384 * 385 * Return: enum wlan_serialization_cmd_status 386 */ 387 enum wlan_serialization_cmd_status 388 wlan_serialization_remove_all_cmd_from_queue(qdf_list_t *queue, 389 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj, 390 struct wlan_objmgr_pdev *pdev, struct wlan_objmgr_vdev *vdev, 391 struct wlan_serialization_command *cmd, 392 uint8_t is_active_queue); 393 /** 394 * wlan_serialization_is_cmd_present_queue() - Check if same command 395 * is already present active or pending queue 396 * @cmd: pointer to command which we need to find 397 * @is_active_queue: flag to find the command in active or pending queue 398 * 399 * This API will check the given command is already present in active or 400 * pending queue based on flag 401 * If present then return true otherwise false 402 * 403 * Return: true or false 404 */ 405 bool wlan_serialization_is_cmd_present_queue( 406 struct wlan_serialization_command *cmd, 407 uint8_t is_active_queue); 408 409 /** 410 * wlan_serialization_activate_cmd() - activate cmd in active queue 411 * @cmd_list: Command needs to be activated 412 * @ser_pdev_obj: Serialization private pdev object 413 * 414 * Return: None 415 */ 416 void wlan_serialization_activate_cmd( 417 struct wlan_serialization_command_list *cmd_list, 418 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 419 420 /** 421 * wlan_serialization_list_empty() - check if the list is empty 422 * @queue: Queue/List that needs to be checked for emptiness 423 * @ser_pdev_obj: Serialization private pdev object 424 * 425 * Return: true if list is empty and false otherwise 426 */ 427 bool wlan_serialization_list_empty( 428 qdf_list_t *queue, 429 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 430 431 /** 432 * wlan_serialization_list_size() - Find the size of the provided queue 433 * @queue: Queue/List for which the size/length is to be returned 434 * @ser_pdev_obj: Serialization private pdev object 435 * 436 * Return: size/length of the queue/list 437 */ 438 uint32_t wlan_serialization_list_size( 439 qdf_list_t *queue, 440 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 441 /** 442 * wlan_serialization_acquire_lock() - to acquire lock for serialization module 443 * @obj: pdev private object 444 * 445 * This API will acquire lock for serialization module. Mutex or spinlock will 446 * be decided based on the context of the operation. 447 * 448 * Return: QDF_STATUS based on outcome of the operation 449 */ 450 QDF_STATUS 451 wlan_serialization_acquire_lock(struct wlan_serialization_pdev_priv_obj *obj); 452 453 /** 454 * wlan_serialization_release_lock() - to release lock for serialization module 455 * @obj: pdev private object 456 * 457 * This API will release lock for serialization module. Mutex or spinlock will 458 * be decided based on the context of the operation. 459 * 460 * Return: QDF_STATUS based on outcome of the operation 461 */ 462 QDF_STATUS 463 wlan_serialization_release_lock(struct wlan_serialization_pdev_priv_obj *obj); 464 465 /** 466 * wlan_serialization_create_lock() - to create lock for serialization module 467 * @obj: pdev private object 468 * 469 * This API will create a lock for serialization module. 470 * 471 * Return: QDF_STATUS based on outcome of the operation 472 */ 473 QDF_STATUS 474 wlan_serialization_create_lock(struct wlan_serialization_pdev_priv_obj *obj); 475 476 /** 477 * wlan_serialization_destroy_lock() - to destroy lock for serialization module 478 * 479 * This API will destroy a lock for serialization module. 480 * 481 * Return: QDF_STATUS based on outcome of the operation 482 */ 483 QDF_STATUS 484 wlan_serialization_destroy_lock(struct wlan_serialization_pdev_priv_obj *obj); 485 /** 486 * wlan_serialization_match_cmd_scan_id() - Check for a match on given nnode 487 * @nnode: The node on which the matching has to be done 488 * @cmd: Command that needs to be filled if there is a match 489 * @scan_id: Scan ID to be matched 490 * @vdev: VDEV object to be matched 491 * @ser_pdev_obj: Serialization PDEV Object pointer. 492 * 493 * This API will check if the scan ID and VDEV of the given nnode are 494 * matching with the one's that are being passed to this function. 495 * 496 * Return: True if matched,false otherwise. 497 */ 498 bool wlan_serialization_match_cmd_scan_id( 499 qdf_list_node_t *nnode, 500 struct wlan_serialization_command **cmd, 501 uint16_t scan_id, struct wlan_objmgr_vdev *vdev, 502 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 503 /** 504 * wlan_serialization_match_cmd_id_type() - Check for a match on given nnode 505 * @nnode: The node on which the matching has to be done 506 * @cmd: Command that needs to be matched 507 * @ser_pdev_obj: Serialization PDEV Object pointer. 508 * 509 * This API will check if the cmd ID and cmd type of the given nnode are 510 * matching with the one's that are being passed to this function. 511 * 512 * Return: True if matched,false otherwise. 513 */ 514 bool wlan_serialization_match_cmd_id_type( 515 qdf_list_node_t *nnode, 516 struct wlan_serialization_command *cmd, 517 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 518 /** 519 * wlan_serialization_match_cmd_vdev() - Check for a match on given nnode 520 * @nnode: The node on which the matching has to be done 521 * @vdev: VDEV object that needs to be matched 522 * 523 * This API will check if the VDEV object of the given nnode are 524 * matching with the one's that are being passed to this function. 525 * 526 * Return: True if matched,false otherwise. 527 */ 528 bool wlan_serialization_match_cmd_vdev(qdf_list_node_t *nnode, 529 struct wlan_objmgr_vdev *vdev); 530 /** 531 * wlan_serialization_match_cmd_pdev() - Check for a match on given nnode 532 * @nnode: The node on which the matching has to be done 533 * @pdev: VDEV object that needs to be matched 534 * 535 * This API will check if the PDEV object of the given nnode are 536 * matching with the one's that are being passed to this function. 537 * 538 * Return: True if matched,false otherwise. 539 */ 540 bool wlan_serialization_match_cmd_pdev(qdf_list_node_t *nnode, 541 struct wlan_objmgr_pdev *pdev); 542 /** 543 * wlan_serialization_remove_front() - Remove the front node of the list 544 * @list: List from which the node is to be removed 545 * @node: Pointer to store the node that is removed 546 * @ser_pdev_obj: Serialization PDEV Object pointer 547 * 548 * Return: QDF_STATUS Success or Failure 549 */ 550 QDF_STATUS wlan_serialization_remove_front( 551 qdf_list_t *list, 552 qdf_list_node_t **node, 553 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 554 /** 555 * wlan_serialization_remove_node() - Remove the given node from the list 556 * @list: List from which the node is to be removed 557 * @node: Pointer to the node that is to be removed 558 * @ser_pdev_obj: Serialization PDEV Object pointer 559 * 560 * Return: QDF_STATUS Success or Failure 561 */ 562 QDF_STATUS wlan_serialization_remove_node( 563 qdf_list_t *list, 564 qdf_list_node_t *node, 565 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 566 /** 567 * wlan_serialization_insert_front() - Insert a node into the front of the list 568 * @list: List to which the node is to be inserted 569 * @node: Pointer to the node that is to be inserted 570 * @ser_pdev_obj: Serialization PDEV Object pointer 571 * 572 * Return: QDF_STATUS Success or Failure 573 */ 574 QDF_STATUS wlan_serialization_insert_front( 575 qdf_list_t *list, 576 qdf_list_node_t *node, 577 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 578 /** 579 * wlan_serialization_insert_back() - Insert a node into the back of the list 580 * @list: List to which the node is to be inserted 581 * @node: Pointer to the node that is to be inserted 582 * @ser_pdev_obj: Serialization PDEV Object pointer 583 * 584 * Return: QDF_STATUS Success or Failure 585 */ 586 QDF_STATUS wlan_serialization_insert_back( 587 qdf_list_t *list, 588 qdf_list_node_t *node, 589 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 590 /** 591 * wlan_serialization_peek_front() - Peek the front node of the list 592 * @list: List on which the node is to be peeked 593 * @node: Pointer to the store the node that is being peeked 594 * @ser_pdev_obj: Serialization PDEV Object pointer 595 * 596 * Return: QDF_STATUS Success or Failure 597 */ 598 QDF_STATUS wlan_serialization_peek_front( 599 qdf_list_t *list, 600 qdf_list_node_t **node, 601 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 602 /** 603 * wlan_serialization_peek_next() - Peek the next node of the list 604 * @list: List on which the node is to be peeked 605 * @node1: Input node which is previous to the node to be peeked 606 * @node2: Pointer to the store the node that is being peeked 607 * @ser_pdev_obj: Serialization PDEV Object pointer 608 * 609 * Return: QDF_STATUS Success or Failure 610 */ 611 QDF_STATUS wlan_serialization_peek_next( 612 qdf_list_t *list, 613 qdf_list_node_t *node1, 614 qdf_list_node_t **node2, 615 struct wlan_serialization_pdev_priv_obj *ser_pdev_obj); 616 #endif 617