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