drivers/net/wireless/mediatek/mt76/mt76x2/usb_main.c

   1 /*
   2  * Copyright (C) 2018 Lorenzo Bianconi <lorenzo.bianconi83@gmail.com>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "mt76x2u.h"
  18
  19 static int mt76x2u_start(struct ieee80211_hw *hw)
  20 {
  21         struct mt76x02_dev *dev = hw->priv;
  22         int ret;
  23
  24         mutex_lock(&dev->mt76.mutex);
  25
  26         ret = mt76x2u_mac_start(dev);
  27         if (ret)
  28                 goto out;
  29
  30         ieee80211_queue_delayed_work(mt76_hw(dev), &dev->mac_work,
  31                                      MT_CALIBRATE_INTERVAL);
  32         set_bit(MT76_STATE_RUNNING, &dev->mt76.state);
  33
  34 out:
  35         mutex_unlock(&dev->mt76.mutex);
  36         return ret;
  37 }
  38
  39 static void mt76x2u_stop(struct ieee80211_hw *hw)
  40 {
  41         struct mt76x02_dev *dev = hw->priv;
  42
  43         mutex_lock(&dev->mt76.mutex);
  44         clear_bit(MT76_STATE_RUNNING, &dev->mt76.state);
  45         mt76x2u_stop_hw(dev);
  46         mutex_unlock(&dev->mt76.mutex);
  47 }
  48
  49 static int mt76x2u_add_interface(struct ieee80211_hw *hw,
  50                                  struct ieee80211_vif *vif)
  51 {
  52         struct mt76x02_dev *dev = hw->priv;
  53         unsigned int idx = 8;
  54
  55         if (!ether_addr_equal(dev->mt76.macaddr, vif->addr))
  56                 mt76x02_mac_setaddr(dev, vif->addr);
  57
  58         mt76x02_vif_init(dev, vif, idx);
  59         return 0;
  60 }
  61
  62 static int
  63 mt76x2u_set_channel(struct mt76x02_dev *dev,
  64                     struct cfg80211_chan_def *chandef)
  65 {
  66         int err;
  67
  68         cancel_delayed_work_sync(&dev->cal_work);
  69         set_bit(MT76_RESET, &dev->mt76.state);
  70
  71         mt76_set_channel(&dev->mt76);
  72
  73         mt76_clear(dev, MT_TXOP_CTRL_CFG, BIT(20));
  74         mt76_clear(dev, MT_TXOP_HLDR_ET, BIT(1));
  75         mt76x2_mac_stop(dev, false);
  76
  77         err = mt76x2u_phy_set_channel(dev, chandef);
  78
  79         mt76x2u_mac_resume(dev);
  80
  81         clear_bit(MT76_RESET, &dev->mt76.state);
  82         mt76_txq_schedule_all(&dev->mt76);
  83
  84         return err;
  85 }
  86
  87 static int
  88 mt76x2u_config(struct ieee80211_hw *hw, u32 changed)
  89 {
  90         struct mt76x02_dev *dev = hw->priv;
  91         int err = 0;
  92
  93         mutex_lock(&dev->mt76.mutex);
  94
  95         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
  96                 if (!(hw->conf.flags & IEEE80211_CONF_MONITOR))
  97                         dev->mt76.rxfilter |= MT_RX_FILTR_CFG_PROMISC;
  98                 else
  99                         dev->mt76.rxfilter &= ~MT_RX_FILTR_CFG_PROMISC;
 100                 mt76_wr(dev, MT_RX_FILTR_CFG, dev->mt76.rxfilter);
 101         }
 102
 103         if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
 104                 ieee80211_stop_queues(hw);
 105                 err = mt76x2u_set_channel(dev, &hw->conf.chandef);
 106                 ieee80211_wake_queues(hw);
 107         }
 108
 109         if (changed & IEEE80211_CONF_CHANGE_POWER) {
 110                 dev->mt76.txpower_conf = hw->conf.power_level * 2;
 111
 112                 /* convert to per-chain power for 2x2 devices */
 113                 dev->mt76.txpower_conf -= 6;
 114
 115                 if (test_bit(MT76_STATE_RUNNING, &dev->mt76.state))
 116                         mt76x2_phy_set_txpower(dev);
 117         }
 118
 119         mutex_unlock(&dev->mt76.mutex);
 120
 121         return err;
 122 }
 123
 124 const struct ieee80211_ops mt76x2u_ops = {
 125         .tx = mt76x02_tx,
 126         .start = mt76x2u_start,
 127         .stop = mt76x2u_stop,
 128         .add_interface = mt76x2u_add_interface,
 129         .remove_interface = mt76x02_remove_interface,
 130         .sta_state = mt76_sta_state,
 131         .set_key = mt76x02_set_key,
 132         .ampdu_action = mt76x02_ampdu_action,
 133         .config = mt76x2u_config,
 134         .wake_tx_queue = mt76_wake_tx_queue,
 135         .bss_info_changed = mt76x02_bss_info_changed,
 136         .configure_filter = mt76x02_configure_filter,
 137         .conf_tx = mt76x02_conf_tx,
 138         .sw_scan_start = mt76x02_sw_scan,
 139         .sw_scan_complete = mt76x02_sw_scan_complete,
 140         .sta_rate_tbl_update = mt76x02_sta_rate_tbl_update,
 141         .get_txpower = mt76x02_get_txpower,
 142 };