drivers/net/wireless/ath/ath10k/core.h

   1 /*
   2  * Copyright (c) 2005-2011 Atheros Communications Inc.
   3  * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 #ifndef _CORE_H_
  19 #define _CORE_H_
  20
  21 #include <linux/completion.h>
  22 #include <linux/if_ether.h>
  23 #include <linux/types.h>
  24 #include <linux/pci.h>
  25 #include <linux/uuid.h>
  26 #include <linux/time.h>
  27
  28 #include "htt.h"
  29 #include "htc.h"
  30 #include "hw.h"
  31 #include "targaddrs.h"
  32 #include "wmi.h"
  33 #include "../ath.h"
  34 #include "../regd.h"
  35 #include "../dfs_pattern_detector.h"
  36 #include "spectral.h"
  37 #include "thermal.h"
  38 #include "wow.h"
  39 #include "swap.h"
  40
  41 #define MS(_v, _f) (((_v) & _f##_MASK) >> _f##_LSB)
  42 #define SM(_v, _f) (((_v) << _f##_LSB) & _f##_MASK)
  43 #define WO(_f)      ((_f##_OFFSET) >> 2)
  44
  45 #define ATH10K_SCAN_ID 0
  46 #define WMI_READY_TIMEOUT (5 * HZ)
  47 #define ATH10K_FLUSH_TIMEOUT_HZ (5 * HZ)
  48 #define ATH10K_CONNECTION_LOSS_HZ (3 * HZ)
  49 #define ATH10K_NUM_CHANS 39
  50
  51 /* Antenna noise floor */
  52 #define ATH10K_DEFAULT_NOISE_FLOOR -95
  53
  54 #define ATH10K_MAX_NUM_MGMT_PENDING 128
  55
  56 /* number of failed packets (20 packets with 16 sw reties each) */
  57 #define ATH10K_KICKOUT_THRESHOLD (20 * 16)
  58
  59 /*
  60  * Use insanely high numbers to make sure that the firmware implementation
  61  * won't start, we have the same functionality already in hostapd. Unit
  62  * is seconds.
  63  */
  64 #define ATH10K_KEEPALIVE_MIN_IDLE 3747
  65 #define ATH10K_KEEPALIVE_MAX_IDLE 3895
  66 #define ATH10K_KEEPALIVE_MAX_UNRESPONSIVE 3900
  67
  68 /* NAPI poll budget */
  69 #define ATH10K_NAPI_BUDGET      64
  70 #define ATH10K_NAPI_QUOTA_LIMIT 60
  71
  72 struct ath10k;
  73
  74 enum ath10k_bus {
  75         ATH10K_BUS_PCI,
  76         ATH10K_BUS_AHB,
  77 };
  78
  79 static inline const char *ath10k_bus_str(enum ath10k_bus bus)
  80 {
  81         switch (bus) {
  82         case ATH10K_BUS_PCI:
  83                 return "pci";
  84         case ATH10K_BUS_AHB:
  85                 return "ahb";
  86         }
  87
  88         return "unknown";
  89 }
  90
  91 enum ath10k_skb_flags {
  92         ATH10K_SKB_F_NO_HWCRYPT = BIT(0),
  93         ATH10K_SKB_F_DTIM_ZERO = BIT(1),
  94         ATH10K_SKB_F_DELIVER_CAB = BIT(2),
  95         ATH10K_SKB_F_MGMT = BIT(3),
  96         ATH10K_SKB_F_QOS = BIT(4),
  97 };
  98
  99 struct ath10k_skb_cb {
 100         dma_addr_t paddr;
 101         u8 flags;
 102         u8 eid;
 103         u16 msdu_id;
 104         struct ieee80211_vif *vif;
 105         struct ieee80211_txq *txq;
 106 } __packed;
 107
 108 struct ath10k_skb_rxcb {
 109         dma_addr_t paddr;
 110         struct hlist_node hlist;
 111 };
 112
 113 static inline struct ath10k_skb_cb *ATH10K_SKB_CB(struct sk_buff *skb)
 114 {
 115         BUILD_BUG_ON(sizeof(struct ath10k_skb_cb) >
 116                      IEEE80211_TX_INFO_DRIVER_DATA_SIZE);
 117         return (struct ath10k_skb_cb *)&IEEE80211_SKB_CB(skb)->driver_data;
 118 }
 119
 120 static inline struct ath10k_skb_rxcb *ATH10K_SKB_RXCB(struct sk_buff *skb)
 121 {
 122         BUILD_BUG_ON(sizeof(struct ath10k_skb_rxcb) > sizeof(skb->cb));
 123         return (struct ath10k_skb_rxcb *)skb->cb;
 124 }
 125
 126 #define ATH10K_RXCB_SKB(rxcb) \
 127                 container_of((void *)rxcb, struct sk_buff, cb)
 128
 129 static inline u32 host_interest_item_address(u32 item_offset)
 130 {
 131         return QCA988X_HOST_INTEREST_ADDRESS + item_offset;
 132 }
 133
 134 struct ath10k_bmi {
 135         bool done_sent;
 136 };
 137
 138 struct ath10k_mem_chunk {
 139         void *vaddr;
 140         dma_addr_t paddr;
 141         u32 len;
 142         u32 req_id;
 143 };
 144
 145 struct ath10k_wmi {
 146         enum ath10k_htc_ep_id eid;
 147         struct completion service_ready;
 148         struct completion unified_ready;
 149         struct completion barrier;
 150         wait_queue_head_t tx_credits_wq;
 151         DECLARE_BITMAP(svc_map, WMI_SERVICE_MAX);
 152         struct wmi_cmd_map *cmd;
 153         struct wmi_vdev_param_map *vdev_param;
 154         struct wmi_pdev_param_map *pdev_param;
 155         const struct wmi_ops *ops;
 156         const struct wmi_peer_flags_map *peer_flags;
 157
 158         u32 num_mem_chunks;
 159         u32 rx_decap_mode;
 160         struct ath10k_mem_chunk mem_chunks[WMI_MAX_MEM_REQS];
 161 };
 162
 163 struct ath10k_fw_stats_peer {
 164         struct list_head list;
 165
 166         u8 peer_macaddr[ETH_ALEN];
 167         u32 peer_rssi;
 168         u32 peer_tx_rate;
 169         u32 peer_rx_rate; /* 10x only */
 170         u32 rx_duration;
 171 };
 172
 173 struct ath10k_fw_extd_stats_peer {
 174         struct list_head list;
 175
 176         u8 peer_macaddr[ETH_ALEN];
 177         u32 rx_duration;
 178 };
 179
 180 struct ath10k_fw_stats_vdev {
 181         struct list_head list;
 182
 183         u32 vdev_id;
 184         u32 beacon_snr;
 185         u32 data_snr;
 186         u32 num_tx_frames[4];
 187         u32 num_rx_frames;
 188         u32 num_tx_frames_retries[4];
 189         u32 num_tx_frames_failures[4];
 190         u32 num_rts_fail;
 191         u32 num_rts_success;
 192         u32 num_rx_err;
 193         u32 num_rx_discard;
 194         u32 num_tx_not_acked;
 195         u32 tx_rate_history[10];
 196         u32 beacon_rssi_history[10];
 197 };
 198
 199 struct ath10k_fw_stats_pdev {
 200         struct list_head list;
 201
 202         /* PDEV stats */
 203         s32 ch_noise_floor;
 204         u32 tx_frame_count; /* Cycles spent transmitting frames */
 205         u32 rx_frame_count; /* Cycles spent receiving frames */
 206         u32 rx_clear_count; /* Total channel busy time, evidently */
 207         u32 cycle_count; /* Total on-channel time */
 208         u32 phy_err_count;
 209         u32 chan_tx_power;
 210         u32 ack_rx_bad;
 211         u32 rts_bad;
 212         u32 rts_good;
 213         u32 fcs_bad;
 214         u32 no_beacons;
 215         u32 mib_int_count;
 216
 217         /* PDEV TX stats */
 218         s32 comp_queued;
 219         s32 comp_delivered;
 220         s32 msdu_enqued;
 221         s32 mpdu_enqued;
 222         s32 wmm_drop;
 223         s32 local_enqued;
 224         s32 local_freed;
 225         s32 hw_queued;
 226         s32 hw_reaped;
 227         s32 underrun;
 228         u32 hw_paused;
 229         s32 tx_abort;
 230         s32 mpdus_requed;
 231         u32 tx_ko;
 232         u32 data_rc;
 233         u32 self_triggers;
 234         u32 sw_retry_failure;
 235         u32 illgl_rate_phy_err;
 236         u32 pdev_cont_xretry;
 237         u32 pdev_tx_timeout;
 238         u32 pdev_resets;
 239         u32 phy_underrun;
 240         u32 txop_ovf;
 241         u32 seq_posted;
 242         u32 seq_failed_queueing;
 243         u32 seq_completed;
 244         u32 seq_restarted;
 245         u32 mu_seq_posted;
 246         u32 mpdus_sw_flush;
 247         u32 mpdus_hw_filter;
 248         u32 mpdus_truncated;
 249         u32 mpdus_ack_failed;
 250         u32 mpdus_expired;
 251
 252         /* PDEV RX stats */
 253         s32 mid_ppdu_route_change;
 254         s32 status_rcvd;
 255         s32 r0_frags;
 256         s32 r1_frags;
 257         s32 r2_frags;
 258         s32 r3_frags;
 259         s32 htt_msdus;
 260         s32 htt_mpdus;
 261         s32 loc_msdus;
 262         s32 loc_mpdus;
 263         s32 oversize_amsdu;
 264         s32 phy_errs;
 265         s32 phy_err_drop;
 266         s32 mpdu_errs;
 267         s32 rx_ovfl_errs;
 268 };
 269
 270 struct ath10k_fw_stats {
 271         bool extended;
 272         struct list_head pdevs;
 273         struct list_head vdevs;
 274         struct list_head peers;
 275         struct list_head peers_extd;
 276 };
 277
 278 #define ATH10K_TPC_TABLE_TYPE_FLAG      1
 279 #define ATH10K_TPC_PREAM_TABLE_END      0xFFFF
 280
 281 struct ath10k_tpc_table {
 282         u32 pream_idx[WMI_TPC_RATE_MAX];
 283         u8 rate_code[WMI_TPC_RATE_MAX];
 284         char tpc_value[WMI_TPC_RATE_MAX][WMI_TPC_TX_N_CHAIN * WMI_TPC_BUF_SIZE];
 285 };
 286
 287 struct ath10k_tpc_stats {
 288         u32 reg_domain;
 289         u32 chan_freq;
 290         u32 phy_mode;
 291         u32 twice_antenna_reduction;
 292         u32 twice_max_rd_power;
 293         s32 twice_antenna_gain;
 294         u32 power_limit;
 295         u32 num_tx_chain;
 296         u32 ctl;
 297         u32 rate_max;
 298         u8 flag[WMI_TPC_FLAG];
 299         struct ath10k_tpc_table tpc_table[WMI_TPC_FLAG];
 300 };
 301
 302 struct ath10k_dfs_stats {
 303         u32 phy_errors;
 304         u32 pulses_total;
 305         u32 pulses_detected;
 306         u32 pulses_discarded;
 307         u32 radar_detected;
 308 };
 309
 310 #define ATH10K_MAX_NUM_PEER_IDS (1 << 11) /* htt rx_desc limit */
 311
 312 struct ath10k_peer {
 313         struct list_head list;
 314         struct ieee80211_vif *vif;
 315         struct ieee80211_sta *sta;
 316
 317         int vdev_id;
 318         u8 addr[ETH_ALEN];
 319         DECLARE_BITMAP(peer_ids, ATH10K_MAX_NUM_PEER_IDS);
 320
 321         /* protected by ar->data_lock */
 322         struct ieee80211_key_conf *keys[WMI_MAX_KEY_INDEX + 1];
 323 };
 324
 325 struct ath10k_txq {
 326         struct list_head list;
 327         unsigned long num_fw_queued;
 328         unsigned long num_push_allowed;
 329 };
 330
 331 struct ath10k_sta {
 332         struct ath10k_vif *arvif;
 333
 334         /* the following are protected by ar->data_lock */
 335         u32 changed; /* IEEE80211_RC_* */
 336         u32 bw;
 337         u32 nss;
 338         u32 smps;
 339         u16 peer_id;
 340         struct rate_info txrate;
 341
 342         struct work_struct update_wk;
 343
 344 #ifdef CONFIG_MAC80211_DEBUGFS
 345         /* protected by conf_mutex */
 346         bool aggr_mode;
 347         u64 rx_duration;
 348 #endif
 349 };
 350
 351 #define ATH10K_VDEV_SETUP_TIMEOUT_HZ (5 * HZ)
 352
 353 enum ath10k_beacon_state {
 354         ATH10K_BEACON_SCHEDULED = 0,
 355         ATH10K_BEACON_SENDING,
 356         ATH10K_BEACON_SENT,
 357 };
 358
 359 struct ath10k_vif {
 360         struct list_head list;
 361
 362         u32 vdev_id;
 363         u16 peer_id;
 364         enum wmi_vdev_type vdev_type;
 365         enum wmi_vdev_subtype vdev_subtype;
 366         u32 beacon_interval;
 367         u32 dtim_period;
 368         struct sk_buff *beacon;
 369         /* protected by data_lock */
 370         enum ath10k_beacon_state beacon_state;
 371         void *beacon_buf;
 372         dma_addr_t beacon_paddr;
 373         unsigned long tx_paused; /* arbitrary values defined by target */
 374
 375         struct ath10k *ar;
 376         struct ieee80211_vif *vif;
 377
 378         bool is_started;
 379         bool is_up;
 380         bool spectral_enabled;
 381         bool ps;
 382         u32 aid;
 383         u8 bssid[ETH_ALEN];
 384
 385         struct ieee80211_key_conf *wep_keys[WMI_MAX_KEY_INDEX + 1];
 386         s8 def_wep_key_idx;
 387
 388         u16 tx_seq_no;
 389
 390         union {
 391                 struct {
 392                         u32 uapsd;
 393                 } sta;
 394                 struct {
 395                         /* 512 stations */
 396                         u8 tim_bitmap[64];
 397                         u8 tim_len;
 398                         u32 ssid_len;
 399                         u8 ssid[IEEE80211_MAX_SSID_LEN];
 400                         bool hidden_ssid;
 401                         /* P2P_IE with NoA attribute for P2P_GO case */
 402                         u32 noa_len;
 403                         u8 *noa_data;
 404                 } ap;
 405         } u;
 406
 407         bool use_cts_prot;
 408         bool nohwcrypt;
 409         int num_legacy_stations;
 410         int txpower;
 411         struct wmi_wmm_params_all_arg wmm_params;
 412         struct work_struct ap_csa_work;
 413         struct delayed_work connection_loss_work;
 414         struct cfg80211_bitrate_mask bitrate_mask;
 415 };
 416
 417 struct ath10k_vif_iter {
 418         u32 vdev_id;
 419         struct ath10k_vif *arvif;
 420 };
 421
 422 /* used for crash-dump storage, protected by data-lock */
 423 struct ath10k_fw_crash_data {
 424         bool crashed_since_read;
 425
 426         uuid_le uuid;
 427         struct timespec timestamp;
 428         __le32 registers[REG_DUMP_COUNT_QCA988X];
 429 };
 430
 431 struct ath10k_debug {
 432         struct dentry *debugfs_phy;
 433
 434         struct ath10k_fw_stats fw_stats;
 435         struct completion fw_stats_complete;
 436         bool fw_stats_done;
 437
 438         unsigned long htt_stats_mask;
 439         struct delayed_work htt_stats_dwork;
 440         struct ath10k_dfs_stats dfs_stats;
 441         struct ath_dfs_pool_stats dfs_pool_stats;
 442
 443         /* used for tpc-dump storage, protected by data-lock */
 444         struct ath10k_tpc_stats *tpc_stats;
 445
 446         struct completion tpc_complete;
 447
 448         /* protected by conf_mutex */
 449         u64 fw_dbglog_mask;
 450         u32 fw_dbglog_level;
 451         u32 pktlog_filter;
 452         u32 reg_addr;
 453         u32 nf_cal_period;
 454         void *cal_data;
 455
 456         struct ath10k_fw_crash_data *fw_crash_data;
 457 };
 458
 459 enum ath10k_state {
 460         ATH10K_STATE_OFF = 0,
 461         ATH10K_STATE_ON,
 462
 463         /* When doing firmware recovery the device is first powered down.
 464          * mac80211 is supposed to call in to start() hook later on. It is
 465          * however possible that driver unloading and firmware crash overlap.
 466          * mac80211 can wait on conf_mutex in stop() while the device is
 467          * stopped in ath10k_core_restart() work holding conf_mutex. The state
 468          * RESTARTED means that the device is up and mac80211 has started hw
 469          * reconfiguration. Once mac80211 is done with the reconfiguration we
 470          * set the state to STATE_ON in reconfig_complete(). */
 471         ATH10K_STATE_RESTARTING,
 472         ATH10K_STATE_RESTARTED,
 473
 474         /* The device has crashed while restarting hw. This state is like ON
 475          * but commands are blocked in HTC and -ECOMM response is given. This
 476          * prevents completion timeouts and makes the driver more responsive to
 477          * userspace commands. This is also prevents recursive recovery. */
 478         ATH10K_STATE_WEDGED,
 479
 480         /* factory tests */
 481         ATH10K_STATE_UTF,
 482 };
 483
 484 enum ath10k_firmware_mode {
 485         /* the default mode, standard 802.11 functionality */
 486         ATH10K_FIRMWARE_MODE_NORMAL,
 487
 488         /* factory tests etc */
 489         ATH10K_FIRMWARE_MODE_UTF,
 490 };
 491
 492 enum ath10k_fw_features {
 493         /* wmi_mgmt_rx_hdr contains extra RSSI information */
 494         ATH10K_FW_FEATURE_EXT_WMI_MGMT_RX = 0,
 495
 496         /* Firmware from 10X branch. Deprecated, don't use in new code. */
 497         ATH10K_FW_FEATURE_WMI_10X = 1,
 498
 499         /* firmware support tx frame management over WMI, otherwise it's HTT */
 500         ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX = 2,
 501
 502         /* Firmware does not support P2P */
 503         ATH10K_FW_FEATURE_NO_P2P = 3,
 504
 505         /* Firmware 10.2 feature bit. The ATH10K_FW_FEATURE_WMI_10X feature
 506          * bit is required to be set as well. Deprecated, don't use in new
 507          * code.
 508          */
 509         ATH10K_FW_FEATURE_WMI_10_2 = 4,
 510
 511         /* Some firmware revisions lack proper multi-interface client powersave
 512          * implementation. Enabling PS could result in connection drops,
 513          * traffic stalls, etc.
 514          */
 515         ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT = 5,
 516
 517         /* Some firmware revisions have an incomplete WoWLAN implementation
 518          * despite WMI service bit being advertised. This feature flag is used
 519          * to distinguish whether WoWLAN is really supported or not.
 520          */
 521         ATH10K_FW_FEATURE_WOWLAN_SUPPORT = 6,
 522
 523         /* Don't trust error code from otp.bin */
 524         ATH10K_FW_FEATURE_IGNORE_OTP_RESULT = 7,
 525
 526         /* Some firmware revisions pad 4th hw address to 4 byte boundary making
 527          * it 8 bytes long in Native Wifi Rx decap.
 528          */
 529         ATH10K_FW_FEATURE_NO_NWIFI_DECAP_4ADDR_PADDING = 8,
 530
 531         /* Firmware supports bypassing PLL setting on init. */
 532         ATH10K_FW_FEATURE_SUPPORTS_SKIP_CLOCK_INIT = 9,
 533
 534         /* Raw mode support. If supported, FW supports receiving and trasmitting
 535          * frames in raw mode.
 536          */
 537         ATH10K_FW_FEATURE_RAW_MODE_SUPPORT = 10,
 538
 539         /* Firmware Supports Adaptive CCA*/
 540         ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA = 11,
 541
 542         /* Firmware supports management frame protection */
 543         ATH10K_FW_FEATURE_MFP_SUPPORT = 12,
 544
 545         /* Firmware supports pull-push model where host shares it's software
 546          * queue state with firmware and firmware generates fetch requests
 547          * telling host which queues to dequeue tx from.
 548          *
 549          * Primary function of this is improved MU-MIMO performance with
 550          * multiple clients.
 551          */
 552         ATH10K_FW_FEATURE_PEER_FLOW_CONTROL = 13,
 553
 554         /* Firmware supports BT-Coex without reloading firmware via pdev param.
 555          * To support Bluetooth coexistence pdev param, WMI_COEX_GPIO_SUPPORT of
 556          * extended resource config should be enabled always. This firmware IE
 557          * is used to configure WMI_COEX_GPIO_SUPPORT.
 558          */
 559         ATH10K_FW_FEATURE_BTCOEX_PARAM = 14,
 560
 561         /* Unused flag and proven to be not working, enable this if you want
 562          * to experiment sending NULL func data frames in HTT TX
 563          */
 564         ATH10K_FW_FEATURE_SKIP_NULL_FUNC_WAR = 15,
 565
 566         /* Firmware allow other BSS mesh broadcast/multicast frames without
 567          * creating monitor interface. Appropriate rxfilters are programmed for
 568          * mesh vdev by firmware itself. This feature flags will be used for
 569          * not creating monitor vdev while configuring mesh node.
 570          */
 571         ATH10K_FW_FEATURE_ALLOWS_MESH_BCAST = 16,
 572
 573         /* keep last */
 574         ATH10K_FW_FEATURE_COUNT,
 575 };
 576
 577 enum ath10k_dev_flags {
 578         /* Indicates that ath10k device is during CAC phase of DFS */
 579         ATH10K_CAC_RUNNING,
 580         ATH10K_FLAG_CORE_REGISTERED,
 581
 582         /* Device has crashed and needs to restart. This indicates any pending
 583          * waiters should immediately cancel instead of waiting for a time out.
 584          */
 585         ATH10K_FLAG_CRASH_FLUSH,
 586
 587         /* Use Raw mode instead of native WiFi Tx/Rx encap mode.
 588          * Raw mode supports both hardware and software crypto. Native WiFi only
 589          * supports hardware crypto.
 590          */
 591         ATH10K_FLAG_RAW_MODE,
 592
 593         /* Disable HW crypto engine */
 594         ATH10K_FLAG_HW_CRYPTO_DISABLED,
 595
 596         /* Bluetooth coexistance enabled */
 597         ATH10K_FLAG_BTCOEX,
 598
 599         /* Per Station statistics service */
 600         ATH10K_FLAG_PEER_STATS,
 601 };
 602
 603 enum ath10k_cal_mode {
 604         ATH10K_CAL_MODE_FILE,
 605         ATH10K_CAL_MODE_OTP,
 606         ATH10K_CAL_MODE_DT,
 607         ATH10K_PRE_CAL_MODE_FILE,
 608         ATH10K_PRE_CAL_MODE_DT,
 609         ATH10K_CAL_MODE_EEPROM,
 610 };
 611
 612 enum ath10k_crypt_mode {
 613         /* Only use hardware crypto engine */
 614         ATH10K_CRYPT_MODE_HW,
 615         /* Only use software crypto engine */
 616         ATH10K_CRYPT_MODE_SW,
 617 };
 618
 619 static inline const char *ath10k_cal_mode_str(enum ath10k_cal_mode mode)
 620 {
 621         switch (mode) {
 622         case ATH10K_CAL_MODE_FILE:
 623                 return "file";
 624         case ATH10K_CAL_MODE_OTP:
 625                 return "otp";
 626         case ATH10K_CAL_MODE_DT:
 627                 return "dt";
 628         case ATH10K_PRE_CAL_MODE_FILE:
 629                 return "pre-cal-file";
 630         case ATH10K_PRE_CAL_MODE_DT:
 631                 return "pre-cal-dt";
 632         case ATH10K_CAL_MODE_EEPROM:
 633                 return "eeprom";
 634         }
 635
 636         return "unknown";
 637 }
 638
 639 enum ath10k_scan_state {
 640         ATH10K_SCAN_IDLE,
 641         ATH10K_SCAN_STARTING,
 642         ATH10K_SCAN_RUNNING,
 643         ATH10K_SCAN_ABORTING,
 644 };
 645
 646 static inline const char *ath10k_scan_state_str(enum ath10k_scan_state state)
 647 {
 648         switch (state) {
 649         case ATH10K_SCAN_IDLE:
 650                 return "idle";
 651         case ATH10K_SCAN_STARTING:
 652                 return "starting";
 653         case ATH10K_SCAN_RUNNING:
 654                 return "running";
 655         case ATH10K_SCAN_ABORTING:
 656                 return "aborting";
 657         }
 658
 659         return "unknown";
 660 }
 661
 662 enum ath10k_tx_pause_reason {
 663         ATH10K_TX_PAUSE_Q_FULL,
 664         ATH10K_TX_PAUSE_MAX,
 665 };
 666
 667 struct ath10k_fw_file {
 668         const struct firmware *firmware;
 669
 670         char fw_version[ETHTOOL_FWVERS_LEN];
 671
 672         DECLARE_BITMAP(fw_features, ATH10K_FW_FEATURE_COUNT);
 673
 674         enum ath10k_fw_wmi_op_version wmi_op_version;
 675         enum ath10k_fw_htt_op_version htt_op_version;
 676
 677         const void *firmware_data;
 678         size_t firmware_len;
 679
 680         const void *otp_data;
 681         size_t otp_len;
 682
 683         const void *codeswap_data;
 684         size_t codeswap_len;
 685
 686         /* The original idea of struct ath10k_fw_file was that it only
 687          * contains struct firmware and pointers to various parts (actual
 688          * firmware binary, otp, metadata etc) of the file. This seg_info
 689          * is actually created separate but as this is used similarly as
 690          * the other firmware components it's more convenient to have it
 691          * here.
 692          */
 693         struct ath10k_swap_code_seg_info *firmware_swap_code_seg_info;
 694 };
 695
 696 struct ath10k_fw_components {
 697         const struct firmware *board;
 698         const void *board_data;
 699         size_t board_len;
 700
 701         struct ath10k_fw_file fw_file;
 702 };
 703
 704 struct ath10k_per_peer_tx_stats {
 705         u32     succ_bytes;
 706         u32     retry_bytes;
 707         u32     failed_bytes;
 708         u8      ratecode;
 709         u8      flags;
 710         u16     peer_id;
 711         u16     succ_pkts;
 712         u16     retry_pkts;
 713         u16     failed_pkts;
 714         u16     duration;
 715         u32     reserved1;
 716         u32     reserved2;
 717 };
 718
 719 struct ath10k {
 720         struct ath_common ath_common;
 721         struct ieee80211_hw *hw;
 722         struct ieee80211_ops *ops;
 723         struct device *dev;
 724         u8 mac_addr[ETH_ALEN];
 725
 726         enum ath10k_hw_rev hw_rev;
 727         u16 dev_id;
 728         u32 chip_id;
 729         u32 target_version;
 730         u8 fw_version_major;
 731         u32 fw_version_minor;
 732         u16 fw_version_release;
 733         u16 fw_version_build;
 734         u32 fw_stats_req_mask;
 735         u32 phy_capability;
 736         u32 hw_min_tx_power;
 737         u32 hw_max_tx_power;
 738         u32 hw_eeprom_rd;
 739         u32 ht_cap_info;
 740         u32 vht_cap_info;
 741         u32 num_rf_chains;
 742         u32 max_spatial_stream;
 743         /* protected by conf_mutex */
 744         bool ani_enabled;
 745
 746         bool p2p;
 747
 748         struct {
 749                 enum ath10k_bus bus;
 750                 const struct ath10k_hif_ops *ops;
 751         } hif;
 752
 753         struct completion target_suspend;
 754
 755         const struct ath10k_hw_regs *regs;
 756         const struct ath10k_hw_values *hw_values;
 757         struct ath10k_bmi bmi;
 758         struct ath10k_wmi wmi;
 759         struct ath10k_htc htc;
 760         struct ath10k_htt htt;
 761
 762         struct ath10k_hw_params hw_params;
 763
 764         /* contains the firmware images used with ATH10K_FIRMWARE_MODE_NORMAL */
 765         struct ath10k_fw_components normal_mode_fw;
 766
 767         /* READ-ONLY images of the running firmware, which can be either
 768          * normal or UTF. Do not modify, release etc!
 769          */
 770         const struct ath10k_fw_components *running_fw;
 771
 772         const struct firmware *pre_cal_file;
 773         const struct firmware *cal_file;
 774
 775         struct {
 776                 u32 vendor;
 777                 u32 device;
 778                 u32 subsystem_vendor;
 779                 u32 subsystem_device;
 780
 781                 bool bmi_ids_valid;
 782                 u8 bmi_board_id;
 783                 u8 bmi_chip_id;
 784         } id;
 785
 786         int fw_api;
 787         int bd_api;
 788         enum ath10k_cal_mode cal_mode;
 789
 790         struct {
 791                 struct completion started;
 792                 struct completion completed;
 793                 struct completion on_channel;
 794                 struct delayed_work timeout;
 795                 enum ath10k_scan_state state;
 796                 bool is_roc;
 797                 int vdev_id;
 798                 int roc_freq;
 799                 bool roc_notify;
 800         } scan;
 801
 802         struct {
 803                 struct ieee80211_supported_band sbands[NUM_NL80211_BANDS];
 804         } mac;
 805
 806         /* should never be NULL; needed for regular htt rx */
 807         struct ieee80211_channel *rx_channel;
 808
 809         /* valid during scan; needed for mgmt rx during scan */
 810         struct ieee80211_channel *scan_channel;
 811
 812         /* current operating channel definition */
 813         struct cfg80211_chan_def chandef;
 814
 815         /* currently configured operating channel in firmware */
 816         struct ieee80211_channel *tgt_oper_chan;
 817
 818         unsigned long long free_vdev_map;
 819         struct ath10k_vif *monitor_arvif;
 820         bool monitor;
 821         int monitor_vdev_id;
 822         bool monitor_started;
 823         unsigned int filter_flags;
 824         unsigned long dev_flags;
 825         bool dfs_block_radar_events;
 826
 827         /* protected by conf_mutex */
 828         bool radar_enabled;
 829         int num_started_vdevs;
 830
 831         /* Protected by conf-mutex */
 832         u8 cfg_tx_chainmask;
 833         u8 cfg_rx_chainmask;
 834
 835         struct completion install_key_done;
 836
 837         struct completion vdev_setup_done;
 838
 839         struct workqueue_struct *workqueue;
 840         /* Auxiliary workqueue */
 841         struct workqueue_struct *workqueue_aux;
 842
 843         /* prevents concurrent FW reconfiguration */
 844         struct mutex conf_mutex;
 845
 846         /* protects shared structure data */
 847         spinlock_t data_lock;
 848         /* protects: ar->txqs, artxq->list */
 849         spinlock_t txqs_lock;
 850
 851         struct list_head txqs;
 852         struct list_head arvifs;
 853         struct list_head peers;
 854         struct ath10k_peer *peer_map[ATH10K_MAX_NUM_PEER_IDS];
 855         wait_queue_head_t peer_mapping_wq;
 856
 857         /* protected by conf_mutex */
 858         int num_peers;
 859         int num_stations;
 860
 861         int max_num_peers;
 862         int max_num_stations;
 863         int max_num_vdevs;
 864         int max_num_tdls_vdevs;
 865         int num_active_peers;
 866         int num_tids;
 867
 868         struct work_struct svc_rdy_work;
 869         struct sk_buff *svc_rdy_skb;
 870
 871         struct work_struct offchan_tx_work;
 872         struct sk_buff_head offchan_tx_queue;
 873         struct completion offchan_tx_completed;
 874         struct sk_buff *offchan_tx_skb;
 875
 876         struct work_struct wmi_mgmt_tx_work;
 877         struct sk_buff_head wmi_mgmt_tx_queue;
 878
 879         enum ath10k_state state;
 880
 881         struct work_struct register_work;
 882         struct work_struct restart_work;
 883
 884         /* cycle count is reported twice for each visited channel during scan.
 885          * access protected by data_lock */
 886         u32 survey_last_rx_clear_count;
 887         u32 survey_last_cycle_count;
 888         struct survey_info survey[ATH10K_NUM_CHANS];
 889
 890         /* Channel info events are expected to come in pairs without and with
 891          * COMPLETE flag set respectively for each channel visit during scan.
 892          *
 893          * However there are deviations from this rule. This flag is used to
 894          * avoid reporting garbage data.
 895          */
 896         bool ch_info_can_report_survey;
 897         struct completion bss_survey_done;
 898
 899         struct dfs_pattern_detector *dfs_detector;
 900
 901         unsigned long tx_paused; /* see ATH10K_TX_PAUSE_ */
 902
 903 #ifdef CONFIG_ATH10K_DEBUGFS
 904         struct ath10k_debug debug;
 905         struct {
 906                 /* relay(fs) channel for spectral scan */
 907                 struct rchan *rfs_chan_spec_scan;
 908
 909                 /* spectral_mode and spec_config are protected by conf_mutex */
 910                 enum ath10k_spectral_mode mode;
 911                 struct ath10k_spec_scan config;
 912         } spectral;
 913 #endif
 914
 915         struct {
 916                 /* protected by conf_mutex */
 917                 struct ath10k_fw_components utf_mode_fw;
 918
 919                 /* protected by data_lock */
 920                 bool utf_monitor;
 921         } testmode;
 922
 923         struct {
 924                 /* protected by data_lock */
 925                 u32 fw_crash_counter;
 926                 u32 fw_warm_reset_counter;
 927                 u32 fw_cold_reset_counter;
 928         } stats;
 929
 930         struct ath10k_thermal thermal;
 931         struct ath10k_wow wow;
 932         struct ath10k_per_peer_tx_stats peer_tx_stats;
 933
 934         /* NAPI */
 935         struct net_device napi_dev;
 936         struct napi_struct napi;
 937
 938         struct work_struct set_coverage_class_work;
 939         /* protected by conf_mutex */
 940         struct {
 941                 /* writing also protected by data_lock */
 942                 s16 coverage_class;
 943
 944                 u32 reg_phyclk;
 945                 u32 reg_slottime_conf;
 946                 u32 reg_slottime_orig;
 947                 u32 reg_ack_cts_timeout_conf;
 948                 u32 reg_ack_cts_timeout_orig;
 949         } fw_coverage;
 950
 951         /* must be last */
 952         u8 drv_priv[0] __aligned(sizeof(void *));
 953 };
 954
 955 static inline bool ath10k_peer_stats_enabled(struct ath10k *ar)
 956 {
 957         if (test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags) &&
 958             test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map))
 959                 return true;
 960
 961         return false;
 962 }
 963
 964 struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
 965                                   enum ath10k_bus bus,
 966                                   enum ath10k_hw_rev hw_rev,
 967                                   const struct ath10k_hif_ops *hif_ops);
 968 void ath10k_core_destroy(struct ath10k *ar);
 969 void ath10k_core_get_fw_features_str(struct ath10k *ar,
 970                                      char *buf,
 971                                      size_t max_len);
 972 int ath10k_core_fetch_firmware_api_n(struct ath10k *ar, const char *name,
 973                                      struct ath10k_fw_file *fw_file);
 974
 975 int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode,
 976                       const struct ath10k_fw_components *fw_components);
 977 int ath10k_wait_for_suspend(struct ath10k *ar, u32 suspend_opt);
 978 void ath10k_core_stop(struct ath10k *ar);
 979 int ath10k_core_register(struct ath10k *ar, u32 chip_id);
 980 void ath10k_core_unregister(struct ath10k *ar);
 981
 982 #endif /* _CORE_H_ */