drivers/net/wireless/silabs/wfx/wfx.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Common private data.
   4  *
   5  * Copyright (c) 2017-2020, Silicon Laboratories, Inc.
   6  * Copyright (c) 2010, ST-Ericsson
   7  * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
   8  * Copyright 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
   9  */
  10 #ifndef WFX_H
  11 #define WFX_H
  12
  13 #include <linux/completion.h>
  14 #include <linux/workqueue.h>
  15 #include <linux/mutex.h>
  16 #include <linux/nospec.h>
  17 #include <net/mac80211.h>
  18
  19 #include "bh.h"
  20 #include "data_tx.h"
  21 #include "main.h"
  22 #include "queue.h"
  23 #include "hif_tx.h"
  24
  25 #define USEC_PER_TXOP 32 /* see struct ieee80211_tx_queue_params */
  26 #define USEC_PER_TU 1024
  27
  28 struct wfx_hwbus_ops;
  29
  30 struct wfx_dev {
  31         struct wfx_platform_data   pdata;
  32         struct device              *dev;
  33         struct ieee80211_hw        *hw;
  34         struct ieee80211_vif       *vif[2];
  35         struct mac_address         addresses[2];
  36         const struct wfx_hwbus_ops *hwbus_ops;
  37         void                       *hwbus_priv;
  38
  39         u8                         keyset;
  40         struct completion          firmware_ready;
  41         struct wfx_hif_ind_startup hw_caps;
  42         struct wfx_hif             hif;
  43         struct delayed_work        cooling_timeout_work;
  44         bool                       poll_irq;
  45         bool                       chip_frozen;
  46         struct mutex               scan_lock;
  47         struct mutex               conf_mutex;
  48
  49         struct wfx_hif_cmd         hif_cmd;
  50         struct sk_buff_head        tx_pending;
  51         wait_queue_head_t          tx_dequeue;
  52         atomic_t                   tx_lock;
  53
  54         atomic_t                   packet_id;
  55         u32                        key_map;
  56
  57         struct wfx_hif_rx_stats    rx_stats;
  58         struct mutex               rx_stats_lock;
  59         struct wfx_hif_tx_power_loop_info tx_power_loop_info;
  60         struct mutex               tx_power_loop_info_lock;
  61         struct workqueue_struct    *bh_wq;
  62 };
  63
  64 struct wfx_vif {
  65         struct wfx_dev             *wdev;
  66         struct ieee80211_channel   *channel;
  67         int                        id;
  68
  69         u32                        link_id_map;
  70
  71         bool                       after_dtim_tx_allowed;
  72         bool                       join_in_progress;
  73         struct completion          set_pm_mode_complete;
  74
  75         struct delayed_work        beacon_loss_work;
  76
  77         struct wfx_queue           tx_queue[4];
  78         struct wfx_tx_policy_cache tx_policy_cache;
  79         struct work_struct         tx_policy_upload_work;
  80
  81         struct work_struct         update_tim_work;
  82
  83         unsigned long              uapsd_mask;
  84
  85         struct work_struct         scan_work;
  86         struct completion          scan_complete;
  87         int                        scan_nb_chan_done;
  88         bool                       scan_abort;
  89         struct ieee80211_scan_request *scan_req;
  90
  91         struct ieee80211_channel   *remain_on_channel_chan;
  92         int                        remain_on_channel_duration;
  93         struct work_struct         remain_on_channel_work;
  94 };
  95
  96 static inline struct ieee80211_vif *wvif_to_vif(struct wfx_vif *wvif)
  97 {
  98         return container_of((void *)wvif, struct ieee80211_vif, drv_priv);
  99 }
 100
 101 static inline struct wfx_vif *wdev_to_wvif(struct wfx_dev *wdev, int vif_id)
 102 {
 103         if (vif_id >= ARRAY_SIZE(wdev->vif)) {
 104                 dev_dbg(wdev->dev, "requesting non-existent vif: %d\n", vif_id);
 105                 return NULL;
 106         }
 107         vif_id = array_index_nospec(vif_id, ARRAY_SIZE(wdev->vif));
 108         if (!wdev->vif[vif_id])
 109                 return NULL;
 110         return (struct wfx_vif *)wdev->vif[vif_id]->drv_priv;
 111 }
 112
 113 static inline struct wfx_vif *wvif_iterate(struct wfx_dev *wdev, struct wfx_vif *cur)
 114 {
 115         int i;
 116         int mark = 0;
 117         struct wfx_vif *tmp;
 118
 119         if (!cur)
 120                 mark = 1;
 121         for (i = 0; i < ARRAY_SIZE(wdev->vif); i++) {
 122                 tmp = wdev_to_wvif(wdev, i);
 123                 if (mark && tmp)
 124                         return tmp;
 125                 if (tmp == cur)
 126                         mark = 1;
 127         }
 128         return NULL;
 129 }
 130
 131 static inline int wvif_count(struct wfx_dev *wdev)
 132 {
 133         int i;
 134         int ret = 0;
 135         struct wfx_vif *wvif;
 136
 137         for (i = 0; i < ARRAY_SIZE(wdev->vif); i++) {
 138                 wvif = wdev_to_wvif(wdev, i);
 139                 if (wvif)
 140                         ret++;
 141         }
 142         return ret;
 143 }
 144
 145 static inline void memreverse(u8 *src, u8 length)
 146 {
 147         u8 *lo = src;
 148         u8 *hi = src + length - 1;
 149         u8 swap;
 150
 151         while (lo < hi) {
 152                 swap = *lo;
 153                 *lo++ = *hi;
 154                 *hi-- = swap;
 155         }
 156 }
 157
 158 static inline int memzcmp(void *src, unsigned int size)
 159 {
 160         u8 *buf = src;
 161
 162         if (!size)
 163                 return 0;
 164         if (*buf)
 165                 return 1;
 166         return memcmp(buf, buf + 1, size - 1);
 167 }
 168
 169 #endif