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
 341         struct work_struct update_wk;
 342
 343 #ifdef CONFIG_MAC80211_DEBUGFS
 344         /* protected by conf_mutex */
 345         bool aggr_mode;
 346         u64 rx_duration;
 347 #endif
 348 };
 349
 350 #define ATH10K_VDEV_SETUP_TIMEOUT_HZ (5 * HZ)
 351
 352 enum ath10k_beacon_state {
 353         ATH10K_BEACON_SCHEDULED = 0,
 354         ATH10K_BEACON_SENDING,
 355         ATH10K_BEACON_SENT,
 356 };
 357
 358 struct ath10k_vif {
 359         struct list_head list;
 360
 361         u32 vdev_id;
 362         u16 peer_id;
 363         enum wmi_vdev_type vdev_type;
 364         enum wmi_vdev_subtype vdev_subtype;
 365         u32 beacon_interval;
 366         u32 dtim_period;
 367         struct sk_buff *beacon;
 368         /* protected by data_lock */
 369         enum ath10k_beacon_state beacon_state;
 370         void *beacon_buf;
 371         dma_addr_t beacon_paddr;
 372         unsigned long tx_paused; /* arbitrary values defined by target */
 373
 374         struct ath10k *ar;
 375         struct ieee80211_vif *vif;
 376
 377         bool is_started;
 378         bool is_up;
 379         bool spectral_enabled;
 380         bool ps;
 381         u32 aid;
 382         u8 bssid[ETH_ALEN];
 383
 384         struct ieee80211_key_conf *wep_keys[WMI_MAX_KEY_INDEX + 1];
 385         s8 def_wep_key_idx;
 386
 387         u16 tx_seq_no;
 388
 389         union {
 390                 struct {
 391                         u32 uapsd;
 392                 } sta;
 393                 struct {
 394                         /* 512 stations */
 395                         u8 tim_bitmap[64];
 396                         u8 tim_len;
 397                         u32 ssid_len;
 398                         u8 ssid[IEEE80211_MAX_SSID_LEN];
 399                         bool hidden_ssid;
 400                         /* P2P_IE with NoA attribute for P2P_GO case */
 401                         u32 noa_len;
 402                         u8 *noa_data;
 403                 } ap;
 404         } u;
 405
 406         bool use_cts_prot;
 407         bool nohwcrypt;
 408         int num_legacy_stations;
 409         int txpower;
 410         struct wmi_wmm_params_all_arg wmm_params;
 411         struct work_struct ap_csa_work;
 412         struct delayed_work connection_loss_work;
 413         struct cfg80211_bitrate_mask bitrate_mask;
 414 };
 415
 416 struct ath10k_vif_iter {
 417         u32 vdev_id;
 418         struct ath10k_vif *arvif;
 419 };
 420
 421 /* used for crash-dump storage, protected by data-lock */
 422 struct ath10k_fw_crash_data {
 423         bool crashed_since_read;
 424
 425         uuid_le uuid;
 426         struct timespec timestamp;
 427         __le32 registers[REG_DUMP_COUNT_QCA988X];
 428 };
 429
 430 struct ath10k_debug {
 431         struct dentry *debugfs_phy;
 432
 433         struct ath10k_fw_stats fw_stats;
 434         struct completion fw_stats_complete;
 435         bool fw_stats_done;
 436
 437         unsigned long htt_stats_mask;
 438         struct delayed_work htt_stats_dwork;
 439         struct ath10k_dfs_stats dfs_stats;
 440         struct ath_dfs_pool_stats dfs_pool_stats;
 441
 442         /* used for tpc-dump storage, protected by data-lock */
 443         struct ath10k_tpc_stats *tpc_stats;
 444
 445         struct completion tpc_complete;
 446
 447         /* protected by conf_mutex */
 448         u64 fw_dbglog_mask;
 449         u32 fw_dbglog_level;
 450         u32 pktlog_filter;
 451         u32 reg_addr;
 452         u32 nf_cal_period;
 453
 454         struct ath10k_fw_crash_data *fw_crash_data;
 455 };
 456
 457 enum ath10k_state {
 458         ATH10K_STATE_OFF = 0,
 459         ATH10K_STATE_ON,
 460
 461         /* When doing firmware recovery the device is first powered down.
 462          * mac80211 is supposed to call in to start() hook later on. It is
 463          * however possible that driver unloading and firmware crash overlap.
 464          * mac80211 can wait on conf_mutex in stop() while the device is
 465          * stopped in ath10k_core_restart() work holding conf_mutex. The state
 466          * RESTARTED means that the device is up and mac80211 has started hw
 467          * reconfiguration. Once mac80211 is done with the reconfiguration we
 468          * set the state to STATE_ON in reconfig_complete(). */
 469         ATH10K_STATE_RESTARTING,
 470         ATH10K_STATE_RESTARTED,
 471
 472         /* The device has crashed while restarting hw. This state is like ON
 473          * but commands are blocked in HTC and -ECOMM response is given. This
 474          * prevents completion timeouts and makes the driver more responsive to
 475          * userspace commands. This is also prevents recursive recovery. */
 476         ATH10K_STATE_WEDGED,
 477
 478         /* factory tests */
 479         ATH10K_STATE_UTF,
 480 };
 481
 482 enum ath10k_firmware_mode {
 483         /* the default mode, standard 802.11 functionality */
 484         ATH10K_FIRMWARE_MODE_NORMAL,
 485
 486         /* factory tests etc */
 487         ATH10K_FIRMWARE_MODE_UTF,
 488 };
 489
 490 enum ath10k_fw_features {
 491         /* wmi_mgmt_rx_hdr contains extra RSSI information */
 492         ATH10K_FW_FEATURE_EXT_WMI_MGMT_RX = 0,
 493
 494         /* Firmware from 10X branch. Deprecated, don't use in new code. */
 495         ATH10K_FW_FEATURE_WMI_10X = 1,
 496
 497         /* firmware support tx frame management over WMI, otherwise it's HTT */
 498         ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX = 2,
 499
 500         /* Firmware does not support P2P */
 501         ATH10K_FW_FEATURE_NO_P2P = 3,
 502
 503         /* Firmware 10.2 feature bit. The ATH10K_FW_FEATURE_WMI_10X feature
 504          * bit is required to be set as well. Deprecated, don't use in new
 505          * code.
 506          */
 507         ATH10K_FW_FEATURE_WMI_10_2 = 4,
 508
 509         /* Some firmware revisions lack proper multi-interface client powersave
 510          * implementation. Enabling PS could result in connection drops,
 511          * traffic stalls, etc.
 512          */
 513         ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT = 5,
 514
 515         /* Some firmware revisions have an incomplete WoWLAN implementation
 516          * despite WMI service bit being advertised. This feature flag is used
 517          * to distinguish whether WoWLAN is really supported or not.
 518          */
 519         ATH10K_FW_FEATURE_WOWLAN_SUPPORT = 6,
 520
 521         /* Don't trust error code from otp.bin */
 522         ATH10K_FW_FEATURE_IGNORE_OTP_RESULT = 7,
 523
 524         /* Some firmware revisions pad 4th hw address to 4 byte boundary making
 525          * it 8 bytes long in Native Wifi Rx decap.
 526          */
 527         ATH10K_FW_FEATURE_NO_NWIFI_DECAP_4ADDR_PADDING = 8,
 528
 529         /* Firmware supports bypassing PLL setting on init. */
 530         ATH10K_FW_FEATURE_SUPPORTS_SKIP_CLOCK_INIT = 9,
 531
 532         /* Raw mode support. If supported, FW supports receiving and trasmitting
 533          * frames in raw mode.
 534          */
 535         ATH10K_FW_FEATURE_RAW_MODE_SUPPORT = 10,
 536
 537         /* Firmware Supports Adaptive CCA*/
 538         ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA = 11,
 539
 540         /* Firmware supports management frame protection */
 541         ATH10K_FW_FEATURE_MFP_SUPPORT = 12,
 542
 543         /* Firmware supports pull-push model where host shares it's software
 544          * queue state with firmware and firmware generates fetch requests
 545          * telling host which queues to dequeue tx from.
 546          *
 547          * Primary function of this is improved MU-MIMO performance with
 548          * multiple clients.
 549          */
 550         ATH10K_FW_FEATURE_PEER_FLOW_CONTROL = 13,
 551
 552         /* Firmware supports BT-Coex without reloading firmware via pdev param.
 553          * To support Bluetooth coexistence pdev param, WMI_COEX_GPIO_SUPPORT of
 554          * extended resource config should be enabled always. This firmware IE
 555          * is used to configure WMI_COEX_GPIO_SUPPORT.
 556          */
 557         ATH10K_FW_FEATURE_BTCOEX_PARAM = 14,
 558
 559         /* Older firmware with HTT delivers incorrect tx status for null func
 560          * frames to driver, but this fixed in 10.2 and 10.4 firmware versions.
 561          * Also this workaround results in reporting of incorrect null func
 562          * status for 10.4. This flag is used to skip the workaround.
 563          */
 564         ATH10K_FW_FEATURE_SKIP_NULL_FUNC_WAR = 15,
 565
 566         /* keep last */
 567         ATH10K_FW_FEATURE_COUNT,
 568 };
 569
 570 enum ath10k_dev_flags {
 571         /* Indicates that ath10k device is during CAC phase of DFS */
 572         ATH10K_CAC_RUNNING,
 573         ATH10K_FLAG_CORE_REGISTERED,
 574
 575         /* Device has crashed and needs to restart. This indicates any pending
 576          * waiters should immediately cancel instead of waiting for a time out.
 577          */
 578         ATH10K_FLAG_CRASH_FLUSH,
 579
 580         /* Use Raw mode instead of native WiFi Tx/Rx encap mode.
 581          * Raw mode supports both hardware and software crypto. Native WiFi only
 582          * supports hardware crypto.
 583          */
 584         ATH10K_FLAG_RAW_MODE,
 585
 586         /* Disable HW crypto engine */
 587         ATH10K_FLAG_HW_CRYPTO_DISABLED,
 588
 589         /* Bluetooth coexistance enabled */
 590         ATH10K_FLAG_BTCOEX,
 591
 592         /* Per Station statistics service */
 593         ATH10K_FLAG_PEER_STATS,
 594 };
 595
 596 enum ath10k_cal_mode {
 597         ATH10K_CAL_MODE_FILE,
 598         ATH10K_CAL_MODE_OTP,
 599         ATH10K_CAL_MODE_DT,
 600         ATH10K_PRE_CAL_MODE_FILE,
 601         ATH10K_PRE_CAL_MODE_DT,
 602         ATH10K_CAL_MODE_EEPROM,
 603 };
 604
 605 enum ath10k_crypt_mode {
 606         /* Only use hardware crypto engine */
 607         ATH10K_CRYPT_MODE_HW,
 608         /* Only use software crypto engine */
 609         ATH10K_CRYPT_MODE_SW,
 610 };
 611
 612 static inline const char *ath10k_cal_mode_str(enum ath10k_cal_mode mode)
 613 {
 614         switch (mode) {
 615         case ATH10K_CAL_MODE_FILE:
 616                 return "file";
 617         case ATH10K_CAL_MODE_OTP:
 618                 return "otp";
 619         case ATH10K_CAL_MODE_DT:
 620                 return "dt";
 621         case ATH10K_PRE_CAL_MODE_FILE:
 622                 return "pre-cal-file";
 623         case ATH10K_PRE_CAL_MODE_DT:
 624                 return "pre-cal-dt";
 625         case ATH10K_CAL_MODE_EEPROM:
 626                 return "eeprom";
 627         }
 628
 629         return "unknown";
 630 }
 631
 632 enum ath10k_scan_state {
 633         ATH10K_SCAN_IDLE,
 634         ATH10K_SCAN_STARTING,
 635         ATH10K_SCAN_RUNNING,
 636         ATH10K_SCAN_ABORTING,
 637 };
 638
 639 static inline const char *ath10k_scan_state_str(enum ath10k_scan_state state)
 640 {
 641         switch (state) {
 642         case ATH10K_SCAN_IDLE:
 643                 return "idle";
 644         case ATH10K_SCAN_STARTING:
 645                 return "starting";
 646         case ATH10K_SCAN_RUNNING:
 647                 return "running";
 648         case ATH10K_SCAN_ABORTING:
 649                 return "aborting";
 650         }
 651
 652         return "unknown";
 653 }
 654
 655 enum ath10k_tx_pause_reason {
 656         ATH10K_TX_PAUSE_Q_FULL,
 657         ATH10K_TX_PAUSE_MAX,
 658 };
 659
 660 struct ath10k_fw_file {
 661         const struct firmware *firmware;
 662
 663         char fw_version[ETHTOOL_FWVERS_LEN];
 664
 665         DECLARE_BITMAP(fw_features, ATH10K_FW_FEATURE_COUNT);
 666
 667         enum ath10k_fw_wmi_op_version wmi_op_version;
 668         enum ath10k_fw_htt_op_version htt_op_version;
 669
 670         const void *firmware_data;
 671         size_t firmware_len;
 672
 673         const void *otp_data;
 674         size_t otp_len;
 675
 676         const void *codeswap_data;
 677         size_t codeswap_len;
 678
 679         /* The original idea of struct ath10k_fw_file was that it only
 680          * contains struct firmware and pointers to various parts (actual
 681          * firmware binary, otp, metadata etc) of the file. This seg_info
 682          * is actually created separate but as this is used similarly as
 683          * the other firmware components it's more convenient to have it
 684          * here.
 685          */
 686         struct ath10k_swap_code_seg_info *firmware_swap_code_seg_info;
 687 };
 688
 689 struct ath10k_fw_components {
 690         const struct firmware *board;
 691         const void *board_data;
 692         size_t board_len;
 693
 694         struct ath10k_fw_file fw_file;
 695 };
 696
 697 struct ath10k {
 698         struct ath_common ath_common;
 699         struct ieee80211_hw *hw;
 700         struct ieee80211_ops *ops;
 701         struct device *dev;
 702         u8 mac_addr[ETH_ALEN];
 703
 704         enum ath10k_hw_rev hw_rev;
 705         u16 dev_id;
 706         u32 chip_id;
 707         u32 target_version;
 708         u8 fw_version_major;
 709         u32 fw_version_minor;
 710         u16 fw_version_release;
 711         u16 fw_version_build;
 712         u32 fw_stats_req_mask;
 713         u32 phy_capability;
 714         u32 hw_min_tx_power;
 715         u32 hw_max_tx_power;
 716         u32 ht_cap_info;
 717         u32 vht_cap_info;
 718         u32 num_rf_chains;
 719         u32 max_spatial_stream;
 720         /* protected by conf_mutex */
 721         bool ani_enabled;
 722
 723         bool p2p;
 724
 725         struct {
 726                 enum ath10k_bus bus;
 727                 const struct ath10k_hif_ops *ops;
 728         } hif;
 729
 730         struct completion target_suspend;
 731
 732         const struct ath10k_hw_regs *regs;
 733         const struct ath10k_hw_values *hw_values;
 734         struct ath10k_bmi bmi;
 735         struct ath10k_wmi wmi;
 736         struct ath10k_htc htc;
 737         struct ath10k_htt htt;
 738
 739         struct ath10k_hw_params hw_params;
 740
 741         /* contains the firmware images used with ATH10K_FIRMWARE_MODE_NORMAL */
 742         struct ath10k_fw_components normal_mode_fw;
 743
 744         /* READ-ONLY images of the running firmware, which can be either
 745          * normal or UTF. Do not modify, release etc!
 746          */
 747         const struct ath10k_fw_components *running_fw;
 748
 749         const struct firmware *pre_cal_file;
 750         const struct firmware *cal_file;
 751
 752         struct {
 753                 u32 vendor;
 754                 u32 device;
 755                 u32 subsystem_vendor;
 756                 u32 subsystem_device;
 757
 758                 bool bmi_ids_valid;
 759                 u8 bmi_board_id;
 760                 u8 bmi_chip_id;
 761         } id;
 762
 763         int fw_api;
 764         int bd_api;
 765         enum ath10k_cal_mode cal_mode;
 766
 767         struct {
 768                 struct completion started;
 769                 struct completion completed;
 770                 struct completion on_channel;
 771                 struct delayed_work timeout;
 772                 enum ath10k_scan_state state;
 773                 bool is_roc;
 774                 int vdev_id;
 775                 int roc_freq;
 776                 bool roc_notify;
 777         } scan;
 778
 779         struct {
 780                 struct ieee80211_supported_band sbands[NUM_NL80211_BANDS];
 781         } mac;
 782
 783         /* should never be NULL; needed for regular htt rx */
 784         struct ieee80211_channel *rx_channel;
 785
 786         /* valid during scan; needed for mgmt rx during scan */
 787         struct ieee80211_channel *scan_channel;
 788
 789         /* current operating channel definition */
 790         struct cfg80211_chan_def chandef;
 791
 792         /* currently configured operating channel in firmware */
 793         struct ieee80211_channel *tgt_oper_chan;
 794
 795         unsigned long long free_vdev_map;
 796         struct ath10k_vif *monitor_arvif;
 797         bool monitor;
 798         int monitor_vdev_id;
 799         bool monitor_started;
 800         unsigned int filter_flags;
 801         unsigned long dev_flags;
 802         bool dfs_block_radar_events;
 803
 804         /* protected by conf_mutex */
 805         bool radar_enabled;
 806         int num_started_vdevs;
 807
 808         /* Protected by conf-mutex */
 809         u8 cfg_tx_chainmask;
 810         u8 cfg_rx_chainmask;
 811
 812         struct completion install_key_done;
 813
 814         struct completion vdev_setup_done;
 815
 816         struct workqueue_struct *workqueue;
 817         /* Auxiliary workqueue */
 818         struct workqueue_struct *workqueue_aux;
 819
 820         /* prevents concurrent FW reconfiguration */
 821         struct mutex conf_mutex;
 822
 823         /* protects shared structure data */
 824         spinlock_t data_lock;
 825         /* protects: ar->txqs, artxq->list */
 826         spinlock_t txqs_lock;
 827
 828         struct list_head txqs;
 829         struct list_head arvifs;
 830         struct list_head peers;
 831         struct ath10k_peer *peer_map[ATH10K_MAX_NUM_PEER_IDS];
 832         wait_queue_head_t peer_mapping_wq;
 833
 834         /* protected by conf_mutex */
 835         int num_peers;
 836         int num_stations;
 837
 838         int max_num_peers;
 839         int max_num_stations;
 840         int max_num_vdevs;
 841         int max_num_tdls_vdevs;
 842         int num_active_peers;
 843         int num_tids;
 844
 845         struct work_struct svc_rdy_work;
 846         struct sk_buff *svc_rdy_skb;
 847
 848         struct work_struct offchan_tx_work;
 849         struct sk_buff_head offchan_tx_queue;
 850         struct completion offchan_tx_completed;
 851         struct sk_buff *offchan_tx_skb;
 852
 853         struct work_struct wmi_mgmt_tx_work;
 854         struct sk_buff_head wmi_mgmt_tx_queue;
 855
 856         enum ath10k_state state;
 857
 858         struct work_struct register_work;
 859         struct work_struct restart_work;
 860
 861         /* cycle count is reported twice for each visited channel during scan.
 862          * access protected by data_lock */
 863         u32 survey_last_rx_clear_count;
 864         u32 survey_last_cycle_count;
 865         struct survey_info survey[ATH10K_NUM_CHANS];
 866
 867         /* Channel info events are expected to come in pairs without and with
 868          * COMPLETE flag set respectively for each channel visit during scan.
 869          *
 870          * However there are deviations from this rule. This flag is used to
 871          * avoid reporting garbage data.
 872          */
 873         bool ch_info_can_report_survey;
 874         struct completion bss_survey_done;
 875
 876         struct dfs_pattern_detector *dfs_detector;
 877
 878         unsigned long tx_paused; /* see ATH10K_TX_PAUSE_ */
 879
 880 #ifdef CONFIG_ATH10K_DEBUGFS
 881         struct ath10k_debug debug;
 882         struct {
 883                 /* relay(fs) channel for spectral scan */
 884                 struct rchan *rfs_chan_spec_scan;
 885
 886                 /* spectral_mode and spec_config are protected by conf_mutex */
 887                 enum ath10k_spectral_mode mode;
 888                 struct ath10k_spec_scan config;
 889         } spectral;
 890 #endif
 891
 892         struct {
 893                 /* protected by conf_mutex */
 894                 struct ath10k_fw_components utf_mode_fw;
 895
 896                 /* protected by data_lock */
 897                 bool utf_monitor;
 898         } testmode;
 899
 900         struct {
 901                 /* protected by data_lock */
 902                 u32 fw_crash_counter;
 903                 u32 fw_warm_reset_counter;
 904                 u32 fw_cold_reset_counter;
 905         } stats;
 906
 907         struct ath10k_thermal thermal;
 908         struct ath10k_wow wow;
 909
 910         /* NAPI */
 911         struct net_device napi_dev;
 912         struct napi_struct napi;
 913
 914         /* must be last */
 915         u8 drv_priv[0] __aligned(sizeof(void *));
 916 };
 917
 918 static inline bool ath10k_peer_stats_enabled(struct ath10k *ar)
 919 {
 920         if (test_bit(ATH10K_FLAG_PEER_STATS, &ar->dev_flags) &&
 921             test_bit(WMI_SERVICE_PEER_STATS, ar->wmi.svc_map))
 922                 return true;
 923
 924         return false;
 925 }
 926
 927 struct ath10k *ath10k_core_create(size_t priv_size, struct device *dev,
 928                                   enum ath10k_bus bus,
 929                                   enum ath10k_hw_rev hw_rev,
 930                                   const struct ath10k_hif_ops *hif_ops);
 931 void ath10k_core_destroy(struct ath10k *ar);
 932 void ath10k_core_get_fw_features_str(struct ath10k *ar,
 933                                      char *buf,
 934                                      size_t max_len);
 935 int ath10k_core_fetch_firmware_api_n(struct ath10k *ar, const char *name,
 936                                      struct ath10k_fw_file *fw_file);
 937
 938 int ath10k_core_start(struct ath10k *ar, enum ath10k_firmware_mode mode,
 939                       const struct ath10k_fw_components *fw_components);
 940 int ath10k_wait_for_suspend(struct ath10k *ar, u32 suspend_opt);
 941 void ath10k_core_stop(struct ath10k *ar);
 942 int ath10k_core_register(struct ath10k *ar, u32 chip_id);
 943 void ath10k_core_unregister(struct ath10k *ar);
 944
 945 #endif /* _CORE_H_ */