drivers/net/wireless/mediatek/mt76/mt76x02_beacon.c

   1 /*
   2  * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
   3  * Copyright (C) 2018 Lorenzo Bianconi <lorenzo.bianconi83@gmail.com>
   4  * Copyright (C) 2018 Stanislaw Gruszka <stf_xl@wp.pl>
   5  *
   6  * Permission to use, copy, modify, and/or distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include "mt76x02.h"
  20
  21 static void mt76x02_set_beacon_offsets(struct mt76x02_dev *dev)
  22 {
  23         u32 regs[4] = {};
  24         u16 val;
  25         int i;
  26
  27         for (i = 0; i < dev->beacon_ops->nslots; i++) {
  28                 val = i * dev->beacon_ops->slot_size;
  29                 regs[i / 4] |= (val / 64) << (8 * (i % 4));
  30         }
  31
  32         for (i = 0; i < 4; i++)
  33                 mt76_wr(dev, MT_BCN_OFFSET(i), regs[i]);
  34 }
  35
  36 static int
  37 mt76x02_write_beacon(struct mt76x02_dev *dev, int offset, struct sk_buff *skb)
  38 {
  39         int beacon_len = dev->beacon_ops->slot_size;
  40         struct mt76x02_txwi txwi;
  41
  42         if (WARN_ON_ONCE(beacon_len < skb->len + sizeof(struct mt76x02_txwi)))
  43                 return -ENOSPC;
  44
  45         mt76x02_mac_write_txwi(dev, &txwi, skb, NULL, NULL, skb->len);
  46
  47         mt76_wr_copy(dev, offset, &txwi, sizeof(txwi));
  48         offset += sizeof(txwi);
  49
  50         mt76_wr_copy(dev, offset, skb->data, skb->len);
  51         return 0;
  52 }
  53
  54 static int
  55 __mt76x02_mac_set_beacon(struct mt76x02_dev *dev, u8 bcn_idx,
  56                          struct sk_buff *skb)
  57 {
  58         int beacon_len = dev->beacon_ops->slot_size;
  59         int beacon_addr = MT_BEACON_BASE + (beacon_len * bcn_idx);
  60         int ret = 0;
  61         int i;
  62
  63         /* Prevent corrupt transmissions during update */
  64         mt76_set(dev, MT_BCN_BYPASS_MASK, BIT(bcn_idx));
  65
  66         if (skb) {
  67                 ret = mt76x02_write_beacon(dev, beacon_addr, skb);
  68                 if (!ret)
  69                         dev->beacon_data_mask |= BIT(bcn_idx);
  70         } else {
  71                 dev->beacon_data_mask &= ~BIT(bcn_idx);
  72                 for (i = 0; i < beacon_len; i += 4)
  73                         mt76_wr(dev, beacon_addr + i, 0);
  74         }
  75
  76         mt76_wr(dev, MT_BCN_BYPASS_MASK, 0xff00 | ~dev->beacon_data_mask);
  77
  78         return ret;
  79 }
  80
  81 int mt76x02_mac_set_beacon(struct mt76x02_dev *dev, u8 vif_idx,
  82                            struct sk_buff *skb)
  83 {
  84         bool force_update = false;
  85         int bcn_idx = 0;
  86         int i;
  87
  88         for (i = 0; i < ARRAY_SIZE(dev->beacons); i++) {
  89                 if (vif_idx == i) {
  90                         force_update = !!dev->beacons[i] ^ !!skb;
  91
  92                         if (dev->beacons[i])
  93                                 dev_kfree_skb(dev->beacons[i]);
  94
  95                         dev->beacons[i] = skb;
  96                         __mt76x02_mac_set_beacon(dev, bcn_idx, skb);
  97                 } else if (force_update && dev->beacons[i]) {
  98                         __mt76x02_mac_set_beacon(dev, bcn_idx,
  99                                                  dev->beacons[i]);
 100                 }
 101
 102                 bcn_idx += !!dev->beacons[i];
 103         }
 104
 105         for (i = bcn_idx; i < ARRAY_SIZE(dev->beacons); i++) {
 106                 if (!(dev->beacon_data_mask & BIT(i)))
 107                         break;
 108
 109                 __mt76x02_mac_set_beacon(dev, i, NULL);
 110         }
 111
 112         mt76_rmw_field(dev, MT_MAC_BSSID_DW1, MT_MAC_BSSID_DW1_MBEACON_N,
 113                        bcn_idx - 1);
 114         return 0;
 115 }
 116 EXPORT_SYMBOL_GPL(mt76x02_mac_set_beacon);
 117
 118 static void
 119 __mt76x02_mac_set_beacon_enable(struct mt76x02_dev *dev, u8 vif_idx,
 120                                 bool val, struct sk_buff *skb)
 121 {
 122         u8 old_mask = dev->mt76.beacon_mask;
 123         bool en;
 124         u32 reg;
 125
 126         if (val) {
 127                 dev->mt76.beacon_mask |= BIT(vif_idx);
 128                 if (skb)
 129                         mt76x02_mac_set_beacon(dev, vif_idx, skb);
 130         } else {
 131                 dev->mt76.beacon_mask &= ~BIT(vif_idx);
 132                 mt76x02_mac_set_beacon(dev, vif_idx, NULL);
 133         }
 134
 135         if (!!old_mask == !!dev->mt76.beacon_mask)
 136                 return;
 137
 138         en = dev->mt76.beacon_mask;
 139
 140         reg = MT_BEACON_TIME_CFG_BEACON_TX |
 141               MT_BEACON_TIME_CFG_TBTT_EN |
 142               MT_BEACON_TIME_CFG_TIMER_EN;
 143         mt76_rmw(dev, MT_BEACON_TIME_CFG, reg, reg * en);
 144
 145         dev->beacon_ops->beacon_enable(dev, en);
 146 }
 147
 148 void mt76x02_mac_set_beacon_enable(struct mt76x02_dev *dev,
 149                                    struct ieee80211_vif *vif, bool val)
 150 {
 151         u8 vif_idx = ((struct mt76x02_vif *)vif->drv_priv)->idx;
 152         struct sk_buff *skb = NULL;
 153
 154         dev->beacon_ops->pre_tbtt_enable(dev, false);
 155
 156         if (mt76_is_usb(dev))
 157                 skb = ieee80211_beacon_get(mt76_hw(dev), vif);
 158
 159         if (!dev->mt76.beacon_mask)
 160                 dev->tbtt_count = 0;
 161
 162         __mt76x02_mac_set_beacon_enable(dev, vif_idx, val, skb);
 163
 164         dev->beacon_ops->pre_tbtt_enable(dev, true);
 165 }
 166
 167 void
 168 mt76x02_resync_beacon_timer(struct mt76x02_dev *dev)
 169 {
 170         u32 timer_val = dev->mt76.beacon_int << 4;
 171
 172         dev->tbtt_count++;
 173
 174         /*
 175          * Beacon timer drifts by 1us every tick, the timer is configured
 176          * in 1/16 TU (64us) units.
 177          */
 178         if (dev->tbtt_count < 63)
 179                 return;
 180
 181         /*
 182          * The updated beacon interval takes effect after two TBTT, because
 183          * at this point the original interval has already been loaded into
 184          * the next TBTT_TIMER value
 185          */
 186         if (dev->tbtt_count == 63)
 187                 timer_val -= 1;
 188
 189         mt76_rmw_field(dev, MT_BEACON_TIME_CFG,
 190                        MT_BEACON_TIME_CFG_INTVAL, timer_val);
 191
 192         if (dev->tbtt_count >= 64) {
 193                 dev->tbtt_count = 0;
 194                 return;
 195         }
 196 }
 197 EXPORT_SYMBOL_GPL(mt76x02_resync_beacon_timer);
 198
 199 void
 200 mt76x02_update_beacon_iter(void *priv, u8 *mac, struct ieee80211_vif *vif)
 201 {
 202         struct mt76x02_dev *dev = (struct mt76x02_dev *)priv;
 203         struct mt76x02_vif *mvif = (struct mt76x02_vif *)vif->drv_priv;
 204         struct sk_buff *skb = NULL;
 205
 206         if (!(dev->mt76.beacon_mask & BIT(mvif->idx)))
 207                 return;
 208
 209         skb = ieee80211_beacon_get(mt76_hw(dev), vif);
 210         if (!skb)
 211                 return;
 212
 213         mt76x02_mac_set_beacon(dev, mvif->idx, skb);
 214 }
 215 EXPORT_SYMBOL_GPL(mt76x02_update_beacon_iter);
 216
 217 static void
 218 mt76x02_add_buffered_bc(void *priv, u8 *mac, struct ieee80211_vif *vif)
 219 {
 220         struct beacon_bc_data *data = priv;
 221         struct mt76x02_dev *dev = data->dev;
 222         struct mt76x02_vif *mvif = (struct mt76x02_vif *)vif->drv_priv;
 223         struct ieee80211_tx_info *info;
 224         struct sk_buff *skb;
 225
 226         if (!(dev->mt76.beacon_mask & BIT(mvif->idx)))
 227                 return;
 228
 229         skb = ieee80211_get_buffered_bc(mt76_hw(dev), vif);
 230         if (!skb)
 231                 return;
 232
 233         info = IEEE80211_SKB_CB(skb);
 234         info->control.vif = vif;
 235         info->flags |= IEEE80211_TX_CTL_ASSIGN_SEQ;
 236         mt76_skb_set_moredata(skb, true);
 237         __skb_queue_tail(&data->q, skb);
 238         data->tail[mvif->idx] = skb;
 239 }
 240
 241 void
 242 mt76x02_enqueue_buffered_bc(struct mt76x02_dev *dev, struct beacon_bc_data *data,
 243                             int max_nframes)
 244 {
 245         int i, nframes;
 246
 247         data->dev = dev;
 248         __skb_queue_head_init(&data->q);
 249
 250         do {
 251                 nframes = skb_queue_len(&data->q);
 252                 ieee80211_iterate_active_interfaces_atomic(mt76_hw(dev),
 253                         IEEE80211_IFACE_ITER_RESUME_ALL,
 254                         mt76x02_add_buffered_bc, data);
 255         } while (nframes != skb_queue_len(&data->q) &&
 256                  skb_queue_len(&data->q) < max_nframes);
 257
 258         if (!skb_queue_len(&data->q))
 259                 return;
 260
 261         for (i = 0; i < ARRAY_SIZE(data->tail); i++) {
 262                 if (!data->tail[i])
 263                         continue;
 264                 mt76_skb_set_moredata(data->tail[i], false);
 265         }
 266 }
 267 EXPORT_SYMBOL_GPL(mt76x02_enqueue_buffered_bc);
 268
 269 void mt76x02_init_beacon_config(struct mt76x02_dev *dev)
 270 {
 271         int i;
 272
 273         mt76_clear(dev, MT_BEACON_TIME_CFG, (MT_BEACON_TIME_CFG_TIMER_EN |
 274                                              MT_BEACON_TIME_CFG_TBTT_EN |
 275                                              MT_BEACON_TIME_CFG_BEACON_TX));
 276         mt76_set(dev, MT_BEACON_TIME_CFG, MT_BEACON_TIME_CFG_SYNC_MODE);
 277         mt76_wr(dev, MT_BCN_BYPASS_MASK, 0xffff);
 278
 279         for (i = 0; i < 8; i++)
 280                 mt76x02_mac_set_beacon(dev, i, NULL);
 281
 282         mt76x02_set_beacon_offsets(dev);
 283 }
 284 EXPORT_SYMBOL_GPL(mt76x02_init_beacon_config);
 285
 286