1 /* 2 * Copyright (c) 2014-2018 The Linux Foundation. All rights reserved. 3 * 4 * Previously licensed under the ISC license by Qualcomm Atheros, Inc. 5 * 6 * 7 * Permission to use, copy, modify, and/or distribute this software for 8 * any purpose with or without fee is hereby granted, provided that the 9 * above copyright notice and this permission notice appear in all 10 * copies. 11 * 12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 13 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 14 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 15 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 16 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 17 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 18 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 19 * PERFORMANCE OF THIS SOFTWARE. 20 */ 21 22 /* 23 * This file was originally distributed by Qualcomm Atheros, Inc. 24 * under proprietary terms before Copyright ownership was assigned 25 * to the Linux Foundation. 26 */ 27 28 /** 29 * DOC: qdf_types.h 30 * QCA driver framework (QDF) basic type definitions 31 */ 32 33 #if !defined(__QDF_TYPES_H) 34 #define __QDF_TYPES_H 35 36 #ifndef CONFIG_MCL 37 #if !defined(__printf) 38 #define __printf(a, b) 39 #endif 40 #endif 41 42 43 /* Include Files */ 44 #include <i_qdf_types.h> 45 #include <stdarg.h> 46 #ifdef TSOSEG_DEBUG 47 #include <qdf_atomic.h> 48 #endif 49 50 /* Preprocessor definitions and constants */ 51 #define QDF_MAX_SGLIST 4 52 53 /** 54 * struct qdf_sglist - scatter-gather list 55 * @nsegs: total number of segments 56 * struct __sg_segs - scatter-gather segment list 57 * @vaddr: Virtual address of the segment 58 * @len: Length of the segment 59 */ 60 typedef struct qdf_sglist { 61 uint32_t nsegs; 62 struct __sg_segs { 63 uint8_t *vaddr; 64 uint32_t len; 65 } sg_segs[QDF_MAX_SGLIST]; 66 } qdf_sglist_t; 67 68 #define QDF_MAX_SCATTER __QDF_MAX_SCATTER 69 #define QDF_NSEC_PER_MSEC __QDF_NSEC_PER_MSEC 70 71 /** 72 * QDF_SWAP_U16 - swap input u16 value 73 * @_x: variable to swap 74 */ 75 #define QDF_SWAP_U16(_x) \ 76 ((((_x) << 8) & 0xFF00) | (((_x) >> 8) & 0x00FF)) 77 78 /** 79 * QDF_SWAP_U32 - swap input u32 value 80 * @_x: variable to swap 81 */ 82 #define QDF_SWAP_U32(_x) \ 83 (((((_x) << 24) & 0xFF000000) | (((_x) >> 24) & 0x000000FF)) | \ 84 ((((_x) << 8) & 0x00FF0000) | (((_x) >> 8) & 0x0000FF00))) 85 86 /* ticks per second */ 87 #define QDF_TICKS_PER_SECOND (1000) 88 89 /** 90 * QDF_ARRAY_SIZE - get array size 91 * @_arr: array variable name 92 */ 93 #define QDF_ARRAY_SIZE(_arr) (sizeof(_arr) / sizeof((_arr)[0])) 94 95 #define QDF_MAX_SCATTER __QDF_MAX_SCATTER 96 97 /** 98 * qdf_packed - denotes structure is packed. 99 */ 100 #define qdf_packed __qdf_packed 101 102 /** 103 * qdf_toupper - char lower to upper. 104 */ 105 #define qdf_toupper __qdf_toupper 106 107 typedef void *qdf_net_handle_t; 108 109 typedef void *qdf_netlink_handle_t; 110 typedef void *qdf_drv_handle_t; 111 typedef void *qdf_os_handle_t; 112 typedef void *qdf_pm_t; 113 114 115 /** 116 * typedef qdf_handle_t - handles opaque to each other 117 */ 118 typedef void *qdf_handle_t; 119 120 /** 121 * typedef qdf_device_t - Platform/bus generic handle. 122 * Used for bus specific functions. 123 */ 124 typedef __qdf_device_t qdf_device_t; 125 126 /* Byte order identifiers */ 127 typedef __qdf_le16_t qdf_le16_t; 128 typedef __qdf_le32_t qdf_le32_t; 129 typedef __qdf_le64_t qdf_le64_t; 130 typedef __qdf_be16_t qdf_be16_t; 131 typedef __qdf_be32_t qdf_be32_t; 132 typedef __qdf_be64_t qdf_be64_t; 133 134 /** 135 * typedef qdf_size_t - size of an object 136 */ 137 typedef __qdf_size_t qdf_size_t; 138 139 /** 140 * typedef __qdf_off_t - offset for API's that need them. 141 */ 142 typedef __qdf_off_t qdf_off_t; 143 144 /** 145 * typedef qdf_dma_map_t - DMA mapping object. 146 */ 147 typedef __qdf_dma_map_t qdf_dma_map_t; 148 149 /** 150 * tyepdef qdf_dma_addr_t - DMA address. 151 */ 152 typedef __qdf_dma_addr_t qdf_dma_addr_t; 153 154 /** 155 * typedef __qdf_dma_size_t - DMA size. 156 */ 157 typedef __qdf_dma_size_t qdf_dma_size_t; 158 159 /** 160 * tyepdef qdf_dma_context_t - DMA context. 161 */ 162 typedef __qdf_dma_context_t qdf_dma_context_t; 163 164 typedef __qdf_mem_info_t qdf_mem_info_t; 165 typedef __sgtable_t sgtable_t; 166 167 /** 168 * pointer to net device 169 */ 170 typedef __qdf_netdev_t qdf_netdev_t; 171 172 /** 173 * struct qdf_dma_map_info - Information inside a DMA map. 174 * @nsegs: total number mapped segments 175 * struct __dma_segs - Information of physical address. 176 * @paddr: physical(dam'able) address of the segment 177 * @len: length of the segment 178 */ 179 typedef struct qdf_dma_map_info { 180 uint32_t nsegs; 181 struct __dma_segs { 182 qdf_dma_addr_t paddr; 183 qdf_dma_size_t len; 184 } dma_segs[QDF_MAX_SCATTER]; 185 } qdf_dmamap_info_t; 186 187 /** 188 * struct qdf_shared_mem - Shared memory resource 189 * @mem_info: memory info struct 190 * @vaddr: virtual address 191 * @sgtable: scatter-gather table 192 * @memctx: dma address 193 */ 194 typedef struct qdf_shared_mem { 195 qdf_mem_info_t mem_info; 196 void *vaddr; 197 sgtable_t sgtable; 198 qdf_dma_mem_context(memctx); 199 } qdf_shared_mem_t; 200 201 #define qdf_iomem_t __qdf_iomem_t; 202 203 /** 204 * typedef enum QDF_TIMER_TYPE - QDF timer type 205 * @QDF_TIMER_TYPE_SW: Deferrable SW timer it will not cause CPU to wake up 206 * on expiry 207 * @QDF_TIMER_TYPE_WAKE_APPS: Non deferrable timer which will cause CPU to 208 * wake up on expiry 209 */ 210 typedef enum { 211 QDF_TIMER_TYPE_SW, 212 QDF_TIMER_TYPE_WAKE_APPS 213 } QDF_TIMER_TYPE; 214 215 /** 216 * tyepdef qdf_resource_type_t - hw resources 217 * @QDF_RESOURCE_TYPE_MEM: memory resource 218 * @QDF_RESOURCE_TYPE_IO: io resource 219 * Define the hw resources the OS has allocated for the device 220 * Note that start defines a mapped area. 221 */ 222 typedef enum { 223 QDF_RESOURCE_TYPE_MEM, 224 QDF_RESOURCE_TYPE_IO, 225 } qdf_resource_type_t; 226 227 /** 228 * tyepdef qdf_resource_t - representation of a h/w resource. 229 * @start: start 230 * @end: end 231 * @type: resource type 232 */ 233 typedef struct { 234 uint64_t start; 235 uint64_t end; 236 qdf_resource_type_t type; 237 } qdf_resource_t; 238 239 /** 240 * typedef qdf_dma_dir_t - DMA directions 241 * @QDF_DMA_BIDIRECTIONAL: bidirectional data 242 * @QDF_DMA_TO_DEVICE: data going from device to memory 243 * @QDF_DMA_FROM_DEVICE: data going from memory to device 244 */ 245 typedef enum { 246 QDF_DMA_BIDIRECTIONAL = __QDF_DMA_BIDIRECTIONAL, 247 QDF_DMA_TO_DEVICE = __QDF_DMA_TO_DEVICE, 248 QDF_DMA_FROM_DEVICE = __QDF_DMA_FROM_DEVICE, 249 } qdf_dma_dir_t; 250 251 /** 252 * enum qdf_driver_type - Indicate the driver type and based on this 253 * do appropriate initialization. 254 * 255 * @QDF_DRIVER_TYPE_PRODUCTION: Driver used in the production 256 * @QDF_DRIVER_TYPE_MFG: Driver used in the Factory 257 * @QDF_DRIVER_TYPE_INVALID: Invalid and unrecognized type 258 * 259 */ 260 enum qdf_driver_type { 261 QDF_DRIVER_TYPE_PRODUCTION = 0, 262 QDF_DRIVER_TYPE_MFG = 1, 263 QDF_DRIVER_TYPE_INVALID = 0x7FFFFFFF 264 }; 265 266 /* work queue(kernel thread)/DPC function callback */ 267 typedef void (*qdf_defer_fn_t)(void *); 268 269 /* 270 * Prototype of the critical region function that is to be 271 * executed with spinlock held and interrupt disalbed 272 */ 273 typedef bool (*qdf_irqlocked_func_t)(void *); 274 275 /* Prototype of timer function */ 276 typedef void (*qdf_timer_func_t)(void *); 277 278 #define qdf_offsetof(type, field) offsetof(type, field) 279 280 /** 281 * typedef enum QDF_MODULE_ID - Debug category level 282 * @QDF_MODULE_ID_TDLS: TDLS 283 * @QDF_MODULE_ID_ACS: auto channel selection 284 * @QDF_MODULE_ID_SCAN_SM: scan state machine 285 * @QDF_MODULE_ID_SCANENTRY: scan entry 286 * @QDF_MODULE_ID_WDS: WDS handling 287 * @QDF_MODULE_ID_ACTION: action management frames 288 * @QDF_MODULE_ID_ROAM: sta mode roaming 289 * @QDF_MODULE_ID_INACT: inactivity handling 290 * @QDF_MODULE_ID_DOTH: 11.h 291 * @QDF_MODULE_ID_IQUE: IQUE features 292 * @QDF_MODULE_ID_WME: WME protocol 293 * @QDF_MODULE_ID_ACL: ACL handling 294 * @QDF_MODULE_ID_WPA: WPA/RSN protocol 295 * @QDF_MODULE_ID_RADKEYS: dump 802.1x keys 296 * @QDF_MODULE_ID_RADDUMP: dump 802.1x radius packets 297 * @QDF_MODULE_ID_RADIUS: 802.1x radius client 298 * @QDF_MODULE_ID_DOT1XSM: 802.1x state machine 299 * @QDF_MODULE_ID_DOT1X: 802.1x authenticator 300 * @QDF_MODULE_ID_POWER: power save handling 301 * @QDF_MODULE_ID_STATS: state machine 302 * @QDF_MODULE_ID_OUTPUT: output handling 303 * @QDF_MODULE_ID_SCAN: scanning 304 * @QDF_MODULE_ID_AUTH: authentication handling 305 * @QDF_MODULE_ID_ASSOC: association handling 306 * @QDF_MODULE_ID_NODE: node handling 307 * @QDF_MODULE_ID_ELEMID: element id parsing 308 * @QDF_MODULE_ID_XRATE: rate set handling 309 * @QDF_MODULE_ID_INPUT: input handling 310 * @QDF_MODULE_ID_CRYPTO: crypto work 311 * @QDF_MODULE_ID_DUMPPKTS: IFF_LINK2 equivalant 312 * @QDF_MODULE_ID_DEBUG: IFF_DEBUG equivalent 313 * @QDF_MODULE_ID_MLME: MLME 314 * @QDF_MODULE_ID_RRM: Radio resource measurement 315 * @QDF_MODULE_ID_WNM: Wireless Network Management 316 * @QDF_MODULE_ID_P2P_PROT: P2P Protocol driver 317 * @QDF_MODULE_ID_PROXYARP: 11v Proxy ARP 318 * @QDF_MODULE_ID_L2TIF: Hotspot 2.0 L2 TIF 319 * @QDF_MODULE_ID_WIFIPOS: WifiPositioning Feature 320 * @QDF_MODULE_ID_WRAP: WRAP or Wireless ProxySTA 321 * @QDF_MODULE_ID_DFS: DFS debug mesg 322 * @QDF_MODULE_ID_TLSHIM: TLSHIM module ID 323 * @QDF_MODULE_ID_WMI: WMI module ID 324 * @QDF_MODULE_ID_HTT: HTT module ID 325 * @QDF_MODULE_ID_HDD: HDD module ID 326 * @QDF_MODULE_ID_SME: SME module ID 327 * @QDF_MODULE_ID_PE: PE module ID 328 * @QDF_MODULE_ID_WMA: WMA module ID 329 * @QDF_MODULE_ID_SYS: SYS module ID 330 * @QDF_MODULE_ID_QDF: QDF module ID 331 * @QDF_MODULE_ID_SAP: SAP module ID 332 * @QDF_MODULE_ID_HDD_SOFTAP: HDD SAP module ID 333 * @QDF_MODULE_ID_HDD_DATA: HDD DATA module ID 334 * @QDF_MODULE_ID_HDD_SAP_DATA: HDD SAP DATA module ID 335 * @QDF_MODULE_ID_HIF: HIF module ID 336 * @QDF_MODULE_ID_HTC: HTC module ID 337 * @QDF_MODULE_ID_TXRX: TXRX module ID 338 * @QDF_MODULE_ID_QDF_DEVICE: QDF DEVICE module ID 339 * @QDF_MODULE_ID_CFG: CFG module ID 340 * @QDF_MODULE_ID_BMI: BMI module ID 341 * @QDF_MODULE_ID_EPPING: EPPING module ID 342 * @QDF_MODULE_ID_QVIT: QVIT module ID 343 * @QDF_MODULE_ID_DP: Data-path module ID 344 * @QDF_MODULE_ID_SOC: SOC module ID 345 * @QDF_MODULE_ID_OS_IF: OS-interface module ID 346 * @QDF_MODULE_ID_TARGET_IF: targer interface module ID 347 * @QDF_MODULE_ID_SCHEDULER: schduler module ID 348 * @QDF_MODULE_ID_MGMT_TXRX: management TX/RX module ID 349 * @QDF_MODULE_ID_SERIALIZATION: serialization module ID 350 * @QDF_MODULE_ID_PMO: PMO (power manager and offloads) Module ID 351 * @QDF_MODULE_ID_P2P: P2P module ID 352 * @QDF_MODULE_ID_POLICY_MGR: Policy Manager module ID 353 * @QDF_MODULE_ID_CONFIG: CFG (configuration) component ID 354 * @QDF_MODULE_ID_REGULATORY: REGULATORY module ID 355 * @QDF_MODULE_ID_NAN: NAN module ID 356 * @QDF_MODULE_ID_SPECTRAL: Spectral module ID 357 * @QDF_MODULE_ID_ROAM_DEBUG: Roam Debug logging 358 * @QDF_MODULE_ID_CDP: Converged Data Path module ID 359 * @QDF_MODULE_ID_DIRECT_BUF_RX: Direct Buffer Receive module ID 360 * @QDF_MODULE_ID_DISA: DISA (encryption test) module ID 361 * @QDF_MODULE_ID_GREEN_AP: Green AP related logging 362 * @QDF_MODULE_ID_FTM: FTM module ID 363 * @QDF_MODULE_ID_EXTAP: Extender AP module ID 364 * @QDF_MODULE_ID_FD: FILS discovery logging 365 * @QDF_MODULE_ID_OCB: OCB module ID 366 * @QDF_MODULE_ID_IPA: IPA module ID 367 * @QDF_MODULE_ID_CP_STATS: Control Plane Statistics ID 368 * @QDF_MODULE_ID_ANY: anything 369 * @QDF_MODULE_ID_MAX: Max place holder module ID 370 */ 371 typedef enum { 372 QDF_MODULE_ID_TDLS = 0, 373 QDF_MODULE_ID_ACS, 374 QDF_MODULE_ID_SCAN_SM, 375 QDF_MODULE_ID_SCANENTRY, 376 QDF_MODULE_ID_WDS, 377 QDF_MODULE_ID_ACTION, 378 QDF_MODULE_ID_ROAM, 379 QDF_MODULE_ID_INACT, 380 QDF_MODULE_ID_DOTH = 8, 381 QDF_MODULE_ID_IQUE, 382 QDF_MODULE_ID_WME, 383 QDF_MODULE_ID_ACL, 384 QDF_MODULE_ID_WPA, 385 QDF_MODULE_ID_RADKEYS, 386 QDF_MODULE_ID_RADDUMP, 387 QDF_MODULE_ID_RADIUS, 388 QDF_MODULE_ID_DOT1XSM = 16, 389 QDF_MODULE_ID_DOT1X, 390 QDF_MODULE_ID_POWER, 391 QDF_MODULE_ID_STATE, 392 QDF_MODULE_ID_OUTPUT, 393 QDF_MODULE_ID_SCAN, 394 QDF_MODULE_ID_AUTH, 395 QDF_MODULE_ID_ASSOC, 396 QDF_MODULE_ID_NODE = 24, 397 QDF_MODULE_ID_ELEMID, 398 QDF_MODULE_ID_XRATE, 399 QDF_MODULE_ID_INPUT, 400 QDF_MODULE_ID_CRYPTO, 401 QDF_MODULE_ID_DUMPPKTS, 402 QDF_MODULE_ID_DEBUG, 403 QDF_MODULE_ID_MLME, 404 QDF_MODULE_ID_RRM = 32, 405 QDF_MODULE_ID_WNM, 406 QDF_MODULE_ID_P2P_PROT, 407 QDF_MODULE_ID_PROXYARP, 408 QDF_MODULE_ID_L2TIF, 409 QDF_MODULE_ID_WIFIPOS, 410 QDF_MODULE_ID_WRAP, 411 QDF_MODULE_ID_DFS, 412 QDF_MODULE_ID_ATF = 40, 413 QDF_MODULE_ID_SPLITMAC, 414 QDF_MODULE_ID_IOCTL, 415 QDF_MODULE_ID_NAC, 416 QDF_MODULE_ID_MESH, 417 QDF_MODULE_ID_MBO, 418 QDF_MODULE_ID_EXTIOCTL_CHANSWITCH, 419 QDF_MODULE_ID_EXTIOCTL_CHANSSCAN, 420 QDF_MODULE_ID_TLSHIM = 48, 421 QDF_MODULE_ID_WMI, 422 QDF_MODULE_ID_HTT, 423 QDF_MODULE_ID_HDD, 424 QDF_MODULE_ID_SME, 425 QDF_MODULE_ID_PE, 426 QDF_MODULE_ID_WMA, 427 QDF_MODULE_ID_SYS, 428 QDF_MODULE_ID_QDF = 56, 429 QDF_MODULE_ID_SAP, 430 QDF_MODULE_ID_HDD_SOFTAP, 431 QDF_MODULE_ID_HDD_DATA, 432 QDF_MODULE_ID_HDD_SAP_DATA, 433 QDF_MODULE_ID_HIF, 434 QDF_MODULE_ID_HTC, 435 QDF_MODULE_ID_TXRX, 436 QDF_MODULE_ID_QDF_DEVICE = 64, 437 QDF_MODULE_ID_CFG, 438 QDF_MODULE_ID_BMI, 439 QDF_MODULE_ID_EPPING, 440 QDF_MODULE_ID_QVIT, 441 QDF_MODULE_ID_DP, 442 QDF_MODULE_ID_SOC, 443 QDF_MODULE_ID_OS_IF, 444 QDF_MODULE_ID_TARGET_IF, 445 QDF_MODULE_ID_SCHEDULER, 446 QDF_MODULE_ID_MGMT_TXRX, 447 QDF_MODULE_ID_SERIALIZATION, 448 QDF_MODULE_ID_PMO, 449 QDF_MODULE_ID_P2P, 450 QDF_MODULE_ID_POLICY_MGR, 451 QDF_MODULE_ID_CONFIG, 452 QDF_MODULE_ID_REGULATORY, 453 QDF_MODULE_ID_SA_API, 454 QDF_MODULE_ID_NAN, 455 QDF_MODULE_ID_OFFCHAN_TXRX, 456 QDF_MODULE_ID_SON, 457 QDF_MODULE_ID_SPECTRAL, 458 QDF_MODULE_ID_OBJ_MGR, 459 QDF_MODULE_ID_NSS, 460 QDF_MODULE_ID_ROAM_DEBUG, 461 QDF_MODULE_ID_CDP, 462 QDF_MODULE_ID_DIRECT_BUF_RX, 463 QDF_MODULE_ID_DISA, 464 QDF_MODULE_ID_GREEN_AP, 465 QDF_MODULE_ID_FTM, 466 QDF_MODULE_ID_EXTAP, 467 QDF_MODULE_ID_FD, 468 QDF_MODULE_ID_OCB, 469 QDF_MODULE_ID_IPA, 470 QDF_MODULE_ID_CP_STATS, 471 QDF_MODULE_ID_ANY, 472 QDF_MODULE_ID_MAX, 473 } QDF_MODULE_ID; 474 475 /** 476 * typedef enum QDF_TRACE_LEVEL - Debug verbose level 477 * @QDF_TRACE_LEVEL_NONE: no trace will be logged. This value is in place 478 * for the qdf_trace_setlevel() to allow the user 479 * to turn off all traces 480 * @QDF_TRACE_LEVEL_FATAL: Indicates fatal error conditions 481 * @QDF_TRACE_LEVEL_ERROR: Indicates error conditions 482 * @QDF_TRACE_LEVEL_WARN: May indicate that an error will occur if action 483 * is not taken 484 * @QDF_TRACE_LEVEL_INFO: Normal operational messages that require no action 485 * @QDF_TRACE_LEVEL_INFO_HIGH: High level operational messages that require 486 * no action 487 * @QDF_TRACE_LEVEL_INFO_MED: Middle level operational messages that require 488 * no action 489 * @QDF_TRACE_LEVEL_INFO_LOW: Low level operational messages that require 490 * no action 491 * @QDF_TRACE_LEVEL_DEBUG: Information useful to developers for debugging 492 * @QDF_TRACE_LEVEL_ALL: All trace levels 493 * @QDF_TRACE_LEVEL_MAX: Max trace level 494 */ 495 typedef enum { 496 QDF_TRACE_LEVEL_NONE, 497 QDF_TRACE_LEVEL_FATAL, 498 QDF_TRACE_LEVEL_ERROR, 499 QDF_TRACE_LEVEL_WARN, 500 QDF_TRACE_LEVEL_INFO, 501 QDF_TRACE_LEVEL_INFO_HIGH, 502 QDF_TRACE_LEVEL_INFO_MED, 503 QDF_TRACE_LEVEL_INFO_LOW, 504 QDF_TRACE_LEVEL_DEBUG, 505 QDF_TRACE_LEVEL_ALL, 506 QDF_TRACE_LEVEL_MAX 507 } QDF_TRACE_LEVEL; 508 509 /** 510 * enum QDF_OPMODE - vdev operating mode 511 * @QDF_STA_MODE: STA mode 512 * @QDF_SAP_MODE: SAP mode 513 * @QDF_P2P_CLIENT_MODE: P2P client mode 514 * @QDF_P2P_GO_MODE: P2P GO mode 515 * @QDF_FTM_MODE: FTM mode 516 * @QDF_IBSS_MODE: IBSS mode 517 * @QDF_MONITOR_MODE: Monitor mode 518 * @QDF_P2P_DEVICE_MODE: P2P device mode 519 * @QDF_OCB_MODE: OCB device mode 520 * @QDF_EPPING_MODE: EPPING device mode 521 * @QDF_QVIT_MODE: QVIT device mode 522 * @QDF_NDI_MODE: NAN datapath mode 523 * @QDF_WDS_MODE: WDS mode 524 * @QDF_BTAMP_MODE: BTAMP mode 525 * @QDF_AHDEMO_MODE: AHDEMO mode 526 * @QDF_MAX_NO_OF_MODE: Max place holder 527 * 528 * These are generic IDs that identify the various roles 529 * in the software system 530 */ 531 enum QDF_OPMODE { 532 QDF_STA_MODE, 533 QDF_SAP_MODE, 534 QDF_P2P_CLIENT_MODE, 535 QDF_P2P_GO_MODE, 536 QDF_FTM_MODE, 537 QDF_IBSS_MODE, 538 QDF_MONITOR_MODE, 539 QDF_P2P_DEVICE_MODE, 540 QDF_OCB_MODE, 541 QDF_EPPING_MODE, 542 QDF_QVIT_MODE, 543 QDF_NDI_MODE, 544 QDF_WDS_MODE, 545 QDF_BTAMP_MODE, 546 QDF_AHDEMO_MODE, 547 QDF_MAX_NO_OF_MODE 548 }; 549 550 /* for backward compatibility with the legacy definition */ 551 #define tQDF_ADAPTER_MODE QDF_OPMODE 552 553 /** 554 * enum QDF_GLOBAL_MODE - global mode when driver is loaded. 555 * 556 * @QDF_GLOBAL_MISSION_MODE: mission mode (STA, SAP...) 557 * @QDF_GLOBAL_MONITOR_MODE: Monitor Mode 558 * @QDF_GLOBAL_FTM_MODE: FTM mode 559 * @QDF_GLOBAL_IBSS_MODE: IBSS mode 560 * @QDF_GLOBAL_EPPING_MODE: EPPING mode 561 * @QDF_GLOBAL_QVIT_MODE: QVIT global mode 562 * @QDF_GLOBAL_MAX_MODE: Max place holder 563 */ 564 enum QDF_GLOBAL_MODE { 565 QDF_GLOBAL_MISSION_MODE, 566 QDF_GLOBAL_MONITOR_MODE = 4, 567 QDF_GLOBAL_FTM_MODE = 5, 568 QDF_GLOBAL_IBSS_MODE = 6, 569 QDF_GLOBAL_COLDBOOT_CALIB_MODE = 7, 570 QDF_GLOBAL_EPPING_MODE = 8, 571 QDF_GLOBAL_QVIT_MODE = 9, 572 QDF_GLOBAL_MAX_MODE 573 }; 574 575 /* for backward compatibility with the legacy definition */ 576 #define tQDF_GLOBAL_CON_MODE QDF_GLOBAL_MODE 577 578 #define QDF_IS_EPPING_ENABLED(mode) (mode == QDF_GLOBAL_EPPING_MODE) 579 580 581 /** 582 * qdf_trace_msg()- logging API 583 * @module: Module identifier. A member of the QDF_MODULE_ID enumeration that 584 * identifies the module issuing the trace message. 585 * @level: Trace level. A member of the QDF_TRACE_LEVEL enumeration indicating 586 * the severity of the condition causing the trace message to be issued. 587 * More severe conditions are more likely to be logged. 588 * @str_format: Format string. The message to be logged. This format string 589 * contains printf-like replacement parameters, which follow this 590 * parameter in the variable argument list. 591 * 592 * Users wishing to add tracing information to their code should use 593 * QDF_TRACE. QDF_TRACE() will compile into a call to qdf_trace_msg() when 594 * tracing is enabled. 595 * 596 * Return: nothing 597 * 598 * implemented in qdf_trace.c 599 */ 600 void __printf(3, 4) qdf_trace_msg(QDF_MODULE_ID module, QDF_TRACE_LEVEL level, 601 char *str_format, ...); 602 /** 603 * qdf_vtrace_msg() - the va_list version of qdf_trace_msg 604 * @module: the calling module's Id 605 * @level: the logging level to log using 606 * @str_format: the log format string 607 * @val: the va_list containing the values to format according to str_format 608 * 609 * Return: None 610 */ 611 void qdf_vtrace_msg(QDF_MODULE_ID module, QDF_TRACE_LEVEL level, 612 char *str_format, va_list val); 613 614 #ifdef CONFIG_MCL 615 #define qdf_print(args...) \ 616 QDF_TRACE(QDF_MODULE_ID_QDF, QDF_TRACE_LEVEL_ERROR, ## args) 617 618 #define qdf_alert(params...) QDF_TRACE_FATAL(QDF_MODULE_ID_QDF, ## params) 619 #define qdf_err(params...) QDF_TRACE_ERROR(QDF_MODULE_ID_QDF, ## params) 620 #define qdf_warn(params...) QDF_TRACE_WARN(QDF_MODULE_ID_QDF, ## params) 621 #define qdf_info(params...) QDF_TRACE_INFO(QDF_MODULE_ID_QDF, ## params) 622 #define qdf_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_QDF, ## params) 623 624 #else /* CONFIG_MCL */ 625 626 #define qdf_print printk 627 #define qdf_alert printk 628 #define qdf_err printk 629 #define qdf_warn printk 630 #define qdf_info printk 631 #define qdf_debug printk 632 633 #endif /* CONFIG_MCL */ 634 635 #define qdf_vprint __qdf_vprint 636 #define qdf_snprint __qdf_snprint 637 638 #define qdf_kstrtoint __qdf_kstrtoint 639 640 #ifdef WLAN_OPEN_P2P_INTERFACE 641 /* This should match with WLAN_MAX_INTERFACES */ 642 #define QDF_MAX_CONCURRENCY_PERSONA (4) 643 #else 644 #define QDF_MAX_CONCURRENCY_PERSONA (3) 645 #endif 646 647 #define QDF_STA_MASK (1 << QDF_STA_MODE) 648 #define QDF_SAP_MASK (1 << QDF_SAP_MODE) 649 #define QDF_P2P_CLIENT_MASK (1 << QDF_P2P_CLIENT_MODE) 650 #define QDF_P2P_GO_MASK (1 << QDF_P2P_GO_MODE) 651 652 #ifdef FEATURE_WLAN_MCC_TO_SCC_SWITCH 653 654 /** 655 * typedef tQDF_MCC_TO_SCC_SWITCH_MODE - MCC to SCC switch mode. 656 * @QDF_MCC_TO_SCC_SWITCH_DISABLE: Disable switch 657 * @QDF_MCC_TO_SCC_SWITCH_ENABLE: Enable switch 658 * @QDF_MCC_TO_SCC_SWITCH_FORCE: Force switch with SAP restart 659 * @QDF_MCC_TO_SCC_SWITCH_FORCE_WITHOUT_DISCONNECTION: Force switch without 660 * restart of SAP 661 * @QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL: Switch using fav channel(s) 662 * without SAP restart 663 * @QDF_MCC_TO_SCC_SWITCH_FORCE_PREFERRED_WITHOUT_DISCONNECTION: Force switch 664 * without SAP restart. MCC is allowed only in below exception cases: 665 * Exception Case-1: When STA is operating on DFS channel. 666 * Exception Case-2: When STA is operating on LTE-CoEx channel. 667 * Exception Case-3: When STA is operating on AP disabled channel. 668 * 669 * @QDF_MCC_TO_SCC_SWITCH_MAX: max switch 670 */ 671 typedef enum { 672 QDF_MCC_TO_SCC_SWITCH_DISABLE = 0, 673 QDF_MCC_TO_SCC_SWITCH_ENABLE, 674 QDF_MCC_TO_SCC_SWITCH_FORCE, 675 QDF_MCC_TO_SCC_SWITCH_FORCE_WITHOUT_DISCONNECTION, 676 QDF_MCC_TO_SCC_SWITCH_WITH_FAVORITE_CHANNEL, 677 QDF_MCC_TO_SCC_SWITCH_FORCE_PREFERRED_WITHOUT_DISCONNECTION, 678 QDF_MCC_TO_SCC_SWITCH_MAX 679 } tQDF_MCC_TO_SCC_SWITCH_MODE; 680 #endif 681 682 #if !defined(NULL) 683 #ifdef __cplusplus 684 #define NULL 0 685 #else 686 #define NULL ((void *)0) 687 #endif 688 #endif 689 690 /** 691 * qdf_bool_parse() - parse the given string as a boolean value 692 * @bool_str: the input boolean string to parse 693 * @out_bool: the output boolean value, populated on success 694 * 695 * 1, y, Y are mapped to true, 0, n, N are mapped to false. 696 * Leading/trailing whitespace is ignored. 697 * 698 * Return: QDF_STATUS 699 */ 700 QDF_STATUS qdf_bool_parse(const char *bool_str, bool *out_bool); 701 702 /** 703 * qdf_int32_parse() - parse the given string as a 32-bit signed integer 704 * @int_str: the input integer string to parse 705 * @out_int: the output integer value, populated on success 706 * 707 * Supports binary (0b), octal (0o), decimal (no prefix), and hexadecimal (0x) 708 * encodings via typical prefix notation. Leading/trailing whitespace is 709 * ignored. 710 * 711 * Return: QDF_STATUS 712 */ 713 QDF_STATUS qdf_int32_parse(const char *int_str, int32_t *out_int); 714 715 /** 716 * qdf_uint32_parse() - parse the given string as a 32-bit unsigned integer 717 * @int_str: the input integer string to parse 718 * @out_int: the output integer value, populated on success 719 * 720 * Supports binary (0b), octal (0o), decimal (no prefix), and hexadecimal (0x) 721 * encodings via typical prefix notation. Leading/trailing whitespace is 722 * ignored. 723 * 724 * Return: QDF_STATUS 725 */ 726 QDF_STATUS qdf_uint32_parse(const char *int_str, uint32_t *out_int); 727 728 /** 729 * qdf_int64_parse() - parse the given string as a 64-bit signed integer 730 * @int_str: the input integer string to parse 731 * @out_int: the output integer value, populated on success 732 * 733 * Supports binary (0b), octal (0o), decimal (no prefix), and hexadecimal (0x) 734 * encodings via typical prefix notation. Leading/trailing whitespace is 735 * ignored. 736 * 737 * Return: QDF_STATUS 738 */ 739 QDF_STATUS qdf_int64_parse(const char *int_str, int64_t *out_int); 740 741 /** 742 * qdf_uint64_parse() - parse the given string as a 64-bit unsigned integer 743 * @int_str: the input integer string to parse 744 * @out_int: the output integer value, populated on success 745 * 746 * Supports binary (0b), octal (0o), decimal (no prefix), and hexadecimal (0x) 747 * encodings via typical prefix notation. Leading/trailing whitespace is 748 * ignored. 749 * 750 * Return: QDF_STATUS 751 */ 752 QDF_STATUS qdf_uint64_parse(const char *int_str, uint64_t *out_int); 753 754 #define QDF_MAC_ADDR_SIZE 6 755 #define QDF_MAC_ADDR_STR "%02x:%02x:%02x:%02x:%02x:%02x" 756 #define QDF_MAC_ADDR_ARRAY(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5] 757 #define QDF_MAC_ADDR_BCAST_INIT { { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } } 758 #define QDF_MAC_ADDR_ZERO_INIT { { 0, 0, 0, 0, 0, 0 } } 759 760 /** 761 * struct qdf_mac_addr - A MAC address 762 * @bytes: the raw address bytes array 763 */ 764 struct qdf_mac_addr { 765 uint8_t bytes[QDF_MAC_ADDR_SIZE]; 766 }; 767 768 /** 769 * qdf_mac_parse() - parse the given string as a MAC address 770 * @mac_str: the input MAC address string to parse 771 * @out_addr: the output MAC address value, populated on success 772 * 773 * A MAC address is a set of 6, colon-delimited, hexadecimal encoded octets. 774 * 775 * E.g. 776 * 00:00:00:00:00:00 (zero address) 777 * ff:ff:ff:ff:ff:ff (broadcast address) 778 * 12:34:56:78:90:ab (an arbitrary address) 779 * 780 * This implementation also accepts MAC addresses without colons. Historically, 781 * other delimiters and groupings have been used to represent MAC addresses, but 782 * these are not supported here. Hexadecimal digits may be in either upper or 783 * lower case. 784 * 785 * Return: QDF_STATUS 786 */ 787 QDF_STATUS qdf_mac_parse(const char *mac_str, struct qdf_mac_addr *out_addr); 788 789 #define QDF_IPV4_ADDR_SIZE 4 790 #define QDF_IPV4_ADDR_STR "%d.%d.%d.%d" 791 #define QDF_IPV4_ADDR_ARRAY(a) (a)[0], (a)[1], (a)[2], (a)[3] 792 #define QDF_IPV4_ADDR_ZERO_INIT { { 0, 0, 0, 0 } } 793 794 /** 795 * struct qdf_ipv4_addr - An IPV4 address 796 * @bytes: the raw address bytes array 797 */ 798 struct qdf_ipv4_addr { 799 uint8_t bytes[QDF_IPV4_ADDR_SIZE]; 800 }; 801 802 /** 803 * qdf_ipv4_parse() - parse the given string as an IPV4 address 804 * @ipv4_str: the input IPV4 address string to parse 805 * @out_addr: the output IPV4 address value, populated on success 806 * 807 * An IPV4 address is a set of 4, dot-delimited, decimal encoded octets. 808 * 809 * E.g. 810 * 0.0.0.0 (wildcard address) 811 * 127.0.0.1 (loopback address) 812 * 255.255.255.255 (broadcast address) 813 * 192.168.0.1 (an arbitrary address) 814 * 815 * Historically, non-decimal encodings have also been used to represent IPV4 816 * addresses, but these are not supported here. 817 * 818 * Return: QDF_STATUS 819 */ 820 QDF_STATUS qdf_ipv4_parse(const char *ipv4_str, struct qdf_ipv4_addr *out_addr); 821 822 #define QDF_IPV6_ADDR_SIZE 16 823 #define QDF_IPV6_ADDR_HEXTET_COUNT 8 824 #define QDF_IPV6_ADDR_STR "%x:%x:%x:%x:%x:%x:%x:%x" 825 #define QDF_IPV6_ADDR_ARRAY(a) \ 826 ((a)[0] << 8) + (a)[1], ((a)[2] << 8) + (a)[3], \ 827 ((a)[4] << 8) + (a)[5], ((a)[6] << 8) + (a)[7], \ 828 ((a)[8] << 8) + (a)[9], ((a)[10] << 8) + (a)[11], \ 829 ((a)[12] << 8) + (a)[13], ((a)[14] << 8) + (a)[15] 830 #define QDF_IPV6_ADDR_ZERO_INIT \ 831 { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } } 832 833 /** 834 * struct qdf_ipv6_addr - An IPV6 address 835 * @bytes: the raw address bytes array 836 */ 837 struct qdf_ipv6_addr { 838 uint8_t bytes[QDF_IPV6_ADDR_SIZE]; 839 }; 840 841 /** 842 * qdf_ipv6_parse() - parse the given string as an IPV6 address 843 * @ipv6_str: the input IPV6 address string to parse 844 * @out_addr: the output IPV6 address value, populated on success 845 * 846 * A hextet is a pair of octets. An IPV6 address is a set of 8, colon-delimited, 847 * hexadecimal encoded hextets. Each hextet may omit leading zeros. One or more 848 * zero-hextets may be "compressed" using a pair of colons ("::"). Up to one 849 * such zero-compression is allowed per address. 850 * 851 * E.g. 852 * 0:0:0:0:0:0:0:0 (unspecified address) 853 * :: (also the unspecified address) 854 * 0:0:0:0:0:0:0:1 (loopback address) 855 * ::1 (also the loopback address) 856 * 900a:ae7::6 (an arbitrary address) 857 * 900a:ae7:0:0:0:0:0:6 (the same arbitrary address) 858 * 859 * Hexadecimal digits may be in either upper or lower case. 860 * 861 * Return: QDF_STATUS 862 */ 863 QDF_STATUS qdf_ipv6_parse(const char *ipv6_str, struct qdf_ipv6_addr *out_addr); 864 865 #define QDF_MAX_NUM_CHAN (128) 866 867 #define QDF_BCAST_MAC_ADDR (0xFF) 868 #define QDF_MCAST_IPV4_MAC_ADDR (0x01) 869 #define QDF_MCAST_IPV6_MAC_ADDR (0x33) 870 871 /** 872 * struct qdf_tso_frag_t - fragments of a single TCP segment 873 * @paddr_low_32: Lower 32 bits of the buffer pointer 874 * @paddr_upper_16: upper 16 bits of the buffer pointer 875 * @length: length of the buffer 876 * @vaddr: virtual address 877 * 878 * This structure holds the fragments of a single TCP segment of a 879 * given jumbo TSO network buffer 880 */ 881 struct qdf_tso_frag_t { 882 uint16_t length; 883 unsigned char *vaddr; 884 qdf_dma_addr_t paddr; 885 }; 886 887 #define FRAG_NUM_MAX 6 888 #define TSO_SEG_MAGIC_COOKIE 0x1EED 889 890 /** 891 * struct qdf_tso_flags_t - TSO specific flags 892 * @tso_enable: Enable transmit segmentation offload 893 * @tcp_flags_mask: Tcp_flag is inserted into the header based 894 * on the mask 895 * @l2_len: L2 length for the msdu 896 * @ip_len: IP length for the msdu 897 * @tcp_seq_num: TCP sequence number 898 * @ip_id: IP identification number 899 * 900 * This structure holds the TSO specific flags extracted from the TSO network 901 * buffer for a given TCP segment 902 */ 903 struct qdf_tso_flags_t { 904 uint32_t tso_enable:1, 905 reserved_0a:6, 906 fin:1, 907 syn:1, 908 rst:1, 909 psh:1, 910 ack:1, 911 urg:1, 912 ece:1, 913 cwr:1, 914 ns:1, 915 tcp_flags_mask:9, 916 reserved_0b:7; 917 918 uint32_t l2_len:16, 919 ip_len:16; 920 921 uint32_t tcp_seq_num; 922 923 uint32_t ip_id:16, 924 ipv4_checksum_en:1, 925 udp_ipv4_checksum_en:1, 926 udp_ipv6_checksum_en:1, 927 tcp_ipv4_checksum_en:1, 928 tcp_ipv6_checksum_en:1, 929 partial_checksum_en:1, 930 reserved_3a:10; 931 932 uint32_t checksum_offset:14, 933 reserved_4a:2, 934 payload_start_offset:14, 935 reserved_4b:2; 936 937 uint32_t payload_end_offset:14, 938 reserved_5:18; 939 }; 940 941 /** 942 * struct qdf_tso_seg_t - single TSO segment 943 * @tso_flags: TSO flags 944 * @num_frags: number of fragments 945 * @total_len: total length of the packet 946 * @tso_frags: array holding the fragments 947 * 948 * This structure holds the information of a single TSO segment of a jumbo 949 * TSO network buffer 950 */ 951 struct qdf_tso_seg_t { 952 struct qdf_tso_flags_t tso_flags; 953 uint32_t num_frags; 954 uint32_t total_len; 955 struct qdf_tso_frag_t tso_frags[FRAG_NUM_MAX]; 956 }; 957 958 /** 959 * TSO seg elem action caller locations: goes into dbg.history below. 960 * Needed to be defined outside of the feature so that 961 * callers can be coded without ifdefs (even if they get 962 * resolved to nothing) 963 */ 964 enum tsoseg_dbg_caller_e { 965 TSOSEG_LOC_UNDEFINED, 966 TSOSEG_LOC_INIT1, 967 TSOSEG_LOC_INIT2, 968 TSOSEG_LOC_FREE, 969 TSOSEG_LOC_ALLOC, 970 TSOSEG_LOC_DEINIT, 971 TSOSEG_LOC_GETINFO, 972 TSOSEG_LOC_FILLHTTSEG, 973 TSOSEG_LOC_FILLCMNSEG, 974 TSOSEG_LOC_PREPARETSO, 975 TSOSEG_LOC_TXPREPLLFAST, 976 TSOSEG_LOC_UNMAPTSO, 977 TSOSEG_LOC_UNMAPLAST, 978 TSOSEG_LOC_FORCE_FREE, 979 }; 980 #ifdef TSOSEG_DEBUG 981 982 /** 983 * WARNING: Don't change the history size without changing the wrap 984 * code in qdf_tso_seg_dbg_record function 985 */ 986 #define MAX_TSO_SEG_ACT_HISTORY 16 987 struct qdf_tso_seg_dbg_history_t { 988 uint64_t ts; 989 short id; 990 }; 991 struct qdf_tso_seg_dbg_t { 992 void *txdesc; /* owner - (ol_txrx_tx_desc_t *) */ 993 qdf_atomic_t cur; /* index of last valid entry */ 994 struct qdf_tso_seg_dbg_history_t h[MAX_TSO_SEG_ACT_HISTORY]; 995 }; 996 #endif /* TSOSEG_DEBUG */ 997 998 /** 999 * qdf_tso_seg_elem_t - tso segment element 1000 * @seg: instance of segment 1001 * @next: pointer to the next segment 1002 */ 1003 struct qdf_tso_seg_elem_t { 1004 struct qdf_tso_seg_t seg; 1005 uint32_t cookie:13, 1006 on_freelist:1, 1007 sent_to_target:1, 1008 force_free:1; 1009 struct qdf_tso_seg_elem_t *next; 1010 #ifdef TSOSEG_DEBUG 1011 struct qdf_tso_seg_dbg_t dbg; 1012 #endif /* TSOSEG_DEBUG */ 1013 }; 1014 1015 /** 1016 * struct qdf_tso_num_seg_t - single element to count for num of seg 1017 * @tso_cmn_num_seg: num of seg in a jumbo skb 1018 * 1019 * This structure holds the information of num of segments of a jumbo 1020 * TSO network buffer. 1021 */ 1022 struct qdf_tso_num_seg_t { 1023 uint32_t tso_cmn_num_seg; 1024 }; 1025 1026 /** 1027 * qdf_tso_num_seg_elem_t - num of tso segment element for jumbo skb 1028 * @num_seg: instance of num of seg 1029 * @next: pointer to the next segment 1030 */ 1031 struct qdf_tso_num_seg_elem_t { 1032 struct qdf_tso_num_seg_t num_seg; 1033 struct qdf_tso_num_seg_elem_t *next; 1034 }; 1035 1036 /** 1037 * struct qdf_tso_info_t - TSO information extracted 1038 * @is_tso: is this is a TSO frame 1039 * @num_segs: number of segments 1040 * @tso_seg_list: list of TSO segments for this jumbo packet 1041 * @curr_seg: segment that is currently being processed 1042 * @tso_num_seg_list: num of tso seg for this jumbo packet 1043 * @msdu_stats_idx: msdu index for tso stats 1044 * 1045 * This structure holds the TSO information extracted after parsing the TSO 1046 * jumbo network buffer. It contains a chain of the TSO segments belonging to 1047 * the jumbo packet 1048 */ 1049 struct qdf_tso_info_t { 1050 uint8_t is_tso; 1051 uint32_t num_segs; 1052 struct qdf_tso_seg_elem_t *tso_seg_list; 1053 struct qdf_tso_seg_elem_t *curr_seg; 1054 struct qdf_tso_num_seg_elem_t *tso_num_seg_list; 1055 uint32_t msdu_stats_idx; 1056 }; 1057 1058 /** 1059 * Used to set classify bit in CE desc. 1060 */ 1061 #define QDF_CE_TX_CLASSIFY_BIT_S 5 1062 1063 /** 1064 * QDF_CE_TX_PKT_TYPE_BIT_S - 2 bits starting at bit 6 in CE desc. 1065 */ 1066 #define QDF_CE_TX_PKT_TYPE_BIT_S 6 1067 1068 /** 1069 * QDF_CE_TX_PKT_OFFSET_BIT_S - 12 bits --> 16-27, in the CE desciptor 1070 * the length of HTT/HTC descriptor 1071 */ 1072 #define QDF_CE_TX_PKT_OFFSET_BIT_S 16 1073 1074 /** 1075 * QDF_CE_TX_PKT_OFFSET_BIT_M - Mask for packet offset in the CE descriptor. 1076 */ 1077 #define QDF_CE_TX_PKT_OFFSET_BIT_M 0x0fff0000 1078 1079 /** 1080 * enum qdf_suspend_type - type of suspend 1081 * @QDF_SYSTEM_SUSPEND: System suspend triggered wlan suspend 1082 * @QDF_RUNTIME_SUSPEND: Runtime pm inactivity timer triggered wlan suspend 1083 */ 1084 enum qdf_suspend_type { 1085 QDF_SYSTEM_SUSPEND, 1086 QDF_RUNTIME_SUSPEND 1087 }; 1088 1089 /** 1090 * enum qdf_hang_reason - host hang/ssr reason 1091 * @CDS_REASON_UNSPECIFIED: Unspecified reason 1092 * @CDS_RX_HASH_NO_ENTRY_FOUND: No Map for the MAC entry for the received frame 1093 * @CDS_PEER_DELETION_TIMEDOUT: peer deletion timeout happened 1094 * @CDS_PEER_UNMAP_TIMEDOUT: peer unmap timeout 1095 * @CDS_SCAN_REQ_EXPIRED: Scan request timed out 1096 * @CDS_SCAN_ATTEMPT_FAILURES: Consecutive Scan attempt failures 1097 * @CDS_GET_MSG_BUFF_FAILURE: Unable to get the message buffer 1098 * @CDS_ACTIVE_LIST_TIMEOUT: Current command processing is timedout 1099 * @CDS_SUSPEND_TIMEOUT: Timeout for an ACK from FW for suspend request 1100 * @CDS_RESUME_TIMEOUT: Timeout for an ACK from FW for resume request 1101 */ 1102 enum qdf_hang_reason { 1103 QDF_REASON_UNSPECIFIED = 0, 1104 QDF_RX_HASH_NO_ENTRY_FOUND = 1, 1105 QDF_PEER_DELETION_TIMEDOUT = 2, 1106 QDF_PEER_UNMAP_TIMEDOUT = 3, 1107 QDF_SCAN_REQ_EXPIRED = 4, 1108 QDF_SCAN_ATTEMPT_FAILURES = 5, 1109 QDF_GET_MSG_BUFF_FAILURE = 6, 1110 QDF_ACTIVE_LIST_TIMEOUT = 7, 1111 QDF_SUSPEND_TIMEOUT = 8, 1112 QDF_RESUME_TIMEOUT = 9, 1113 }; 1114 1115 /** 1116 * enum qdf_stats_verbosity_level - Verbosity levels for stats 1117 * for which want to have different levels 1118 * @QDF_STATS_VERBOSITY_LEVEL_LOW: Stats verbosity level low 1119 * @QDF_STATS_VERBOSITY_LEVEL_HIGH: Stats verbosity level high 1120 */ 1121 enum qdf_stats_verbosity_level { 1122 QDF_STATS_VERBOSITY_LEVEL_LOW, 1123 QDF_STATS_VERBOSITY_LEVEL_HIGH 1124 }; 1125 1126 /** 1127 * enum qdf_clock_id - The clock IDs of the various system clocks 1128 * @QDF_CLOCK_REALTIME: Clock is close to current time of day 1129 * @QDF_CLOCK_MONOTONIC: Clock is absolute elapsed time 1130 */ 1131 enum qdf_clock_id { 1132 QDF_CLOCK_REALTIME = __QDF_CLOCK_REALTIME, 1133 QDF_CLOCK_MONOTONIC = __QDF_CLOCK_MONOTONIC 1134 }; 1135 1136 /** 1137 * enum qdf_hrtimer_mode - Mode arguments of qdf_hrtimer_data_t 1138 * related functions 1139 * @QDF_HRTIMER_MODE_ABS: Time value is absolute 1140 * @QDF_HRTIMER_MODE_REL: Time value is relative to now 1141 * @QDF_HRTIMER_MODE_PINNED: Timer is bound to CPU 1142 */ 1143 enum qdf_hrtimer_mode { 1144 QDF_HRTIMER_MODE_ABS = __QDF_HRTIMER_MODE_ABS, 1145 QDF_HRTIMER_MODE_REL = __QDF_HRTIMER_MODE_REL, 1146 QDF_HRTIMER_MODE_PINNED = __QDF_HRTIMER_MODE_PINNED, 1147 }; 1148 1149 /** 1150 * enum qdf_hrtimer_restart_status - Return values for the 1151 * qdf_hrtimer_data_t callback function 1152 * @QDF_HRTIMER_NORESTART: Timer is not restarted 1153 * @QDF_HRTIMER_RESTART: Timer must be restarted 1154 */ 1155 enum qdf_hrtimer_restart_status { 1156 QDF_HRTIMER_NORESTART = __QDF_HRTIMER_NORESTART, 1157 QDF_HRTIMER_RESTART = __QDF_HRTIMER_RESTART, 1158 }; 1159 1160 /** 1161 * enum qdf_context_mode - Values for the 1162 * hrtimer context 1163 * @QDF_CONTEXT_HARDWARE: Runs in hw interrupt context 1164 * @QDF_CONTEXT_TASKLET: Runs in tasklet context 1165 */ 1166 enum qdf_context_mode { 1167 QDF_CONTEXT_HARDWARE = 0, 1168 QDF_CONTEXT_TASKLET = 1, 1169 }; 1170 1171 #endif /* __QDF_TYPES_H */ 1172