GNU Linux-libre 4.4.300-gnu1
[releases.git] / drivers / net / wireless / rsi / rsi_91x_mac80211.c
1 /**
2  * Copyright (c) 2014 Redpine Signals Inc.
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 <linux/etherdevice.h>
18 #include "rsi_debugfs.h"
19 #include "rsi_mgmt.h"
20 #include "rsi_common.h"
21
22 static const struct ieee80211_channel rsi_2ghz_channels[] = {
23         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2412,
24           .hw_value = 1 }, /* Channel 1 */
25         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2417,
26           .hw_value = 2 }, /* Channel 2 */
27         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2422,
28           .hw_value = 3 }, /* Channel 3 */
29         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2427,
30           .hw_value = 4 }, /* Channel 4 */
31         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2432,
32           .hw_value = 5 }, /* Channel 5 */
33         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2437,
34           .hw_value = 6 }, /* Channel 6 */
35         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2442,
36           .hw_value = 7 }, /* Channel 7 */
37         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2447,
38           .hw_value = 8 }, /* Channel 8 */
39         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2452,
40           .hw_value = 9 }, /* Channel 9 */
41         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2457,
42           .hw_value = 10 }, /* Channel 10 */
43         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2462,
44           .hw_value = 11 }, /* Channel 11 */
45         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2467,
46           .hw_value = 12 }, /* Channel 12 */
47         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2472,
48           .hw_value = 13 }, /* Channel 13 */
49         { .band = IEEE80211_BAND_2GHZ, .center_freq = 2484,
50           .hw_value = 14 }, /* Channel 14 */
51 };
52
53 static const struct ieee80211_channel rsi_5ghz_channels[] = {
54         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5180,
55           .hw_value = 36,  }, /* Channel 36 */
56         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5200,
57           .hw_value = 40, }, /* Channel 40 */
58         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5220,
59           .hw_value = 44, }, /* Channel 44 */
60         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5240,
61           .hw_value = 48, }, /* Channel 48 */
62         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5260,
63           .hw_value = 52, }, /* Channel 52 */
64         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5280,
65           .hw_value = 56, }, /* Channel 56 */
66         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5300,
67           .hw_value = 60, }, /* Channel 60 */
68         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5320,
69           .hw_value = 64, }, /* Channel 64 */
70         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5500,
71           .hw_value = 100, }, /* Channel 100 */
72         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5520,
73           .hw_value = 104, }, /* Channel 104 */
74         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5540,
75           .hw_value = 108, }, /* Channel 108 */
76         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5560,
77           .hw_value = 112, }, /* Channel 112 */
78         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5580,
79           .hw_value = 116, }, /* Channel 116 */
80         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5600,
81           .hw_value = 120, }, /* Channel 120 */
82         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5620,
83           .hw_value = 124, }, /* Channel 124 */
84         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5640,
85           .hw_value = 128, }, /* Channel 128 */
86         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5660,
87           .hw_value = 132, }, /* Channel 132 */
88         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5680,
89           .hw_value = 136, }, /* Channel 136 */
90         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5700,
91           .hw_value = 140, }, /* Channel 140 */
92         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5745,
93           .hw_value = 149, }, /* Channel 149 */
94         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5765,
95           .hw_value = 153, }, /* Channel 153 */
96         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5785,
97           .hw_value = 157, }, /* Channel 157 */
98         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5805,
99           .hw_value = 161, }, /* Channel 161 */
100         { .band = IEEE80211_BAND_5GHZ, .center_freq = 5825,
101           .hw_value = 165, }, /* Channel 165 */
102 };
103
104 struct ieee80211_rate rsi_rates[12] = {
105         { .bitrate = STD_RATE_01  * 5, .hw_value = RSI_RATE_1 },
106         { .bitrate = STD_RATE_02  * 5, .hw_value = RSI_RATE_2 },
107         { .bitrate = STD_RATE_5_5 * 5, .hw_value = RSI_RATE_5_5 },
108         { .bitrate = STD_RATE_11  * 5, .hw_value = RSI_RATE_11 },
109         { .bitrate = STD_RATE_06  * 5, .hw_value = RSI_RATE_6 },
110         { .bitrate = STD_RATE_09  * 5, .hw_value = RSI_RATE_9 },
111         { .bitrate = STD_RATE_12  * 5, .hw_value = RSI_RATE_12 },
112         { .bitrate = STD_RATE_18  * 5, .hw_value = RSI_RATE_18 },
113         { .bitrate = STD_RATE_24  * 5, .hw_value = RSI_RATE_24 },
114         { .bitrate = STD_RATE_36  * 5, .hw_value = RSI_RATE_36 },
115         { .bitrate = STD_RATE_48  * 5, .hw_value = RSI_RATE_48 },
116         { .bitrate = STD_RATE_54  * 5, .hw_value = RSI_RATE_54 },
117 };
118
119 const u16 rsi_mcsrates[8] = {
120         RSI_RATE_MCS0, RSI_RATE_MCS1, RSI_RATE_MCS2, RSI_RATE_MCS3,
121         RSI_RATE_MCS4, RSI_RATE_MCS5, RSI_RATE_MCS6, RSI_RATE_MCS7
122 };
123
124 /**
125  * rsi_is_cipher_wep() -  This function determines if the cipher is WEP or not.
126  * @common: Pointer to the driver private structure.
127  *
128  * Return: If cipher type is WEP, a value of 1 is returned, else 0.
129  */
130
131 bool rsi_is_cipher_wep(struct rsi_common *common)
132 {
133         if (((common->secinfo.gtk_cipher == WLAN_CIPHER_SUITE_WEP104) ||
134              (common->secinfo.gtk_cipher == WLAN_CIPHER_SUITE_WEP40)) &&
135             (!common->secinfo.ptk_cipher))
136                 return true;
137         else
138                 return false;
139 }
140
141 /**
142  * rsi_register_rates_channels() - This function registers channels and rates.
143  * @adapter: Pointer to the adapter structure.
144  * @band: Operating band to be set.
145  *
146  * Return: None.
147  */
148 static void rsi_register_rates_channels(struct rsi_hw *adapter, int band)
149 {
150         struct ieee80211_supported_band *sbands = &adapter->sbands[band];
151         void *channels = NULL;
152
153         if (band == IEEE80211_BAND_2GHZ) {
154                 channels = kmalloc(sizeof(rsi_2ghz_channels), GFP_KERNEL);
155                 memcpy(channels,
156                        rsi_2ghz_channels,
157                        sizeof(rsi_2ghz_channels));
158                 sbands->band = IEEE80211_BAND_2GHZ;
159                 sbands->n_channels = ARRAY_SIZE(rsi_2ghz_channels);
160                 sbands->bitrates = rsi_rates;
161                 sbands->n_bitrates = ARRAY_SIZE(rsi_rates);
162         } else {
163                 channels = kmalloc(sizeof(rsi_5ghz_channels), GFP_KERNEL);
164                 memcpy(channels,
165                        rsi_5ghz_channels,
166                        sizeof(rsi_5ghz_channels));
167                 sbands->band = IEEE80211_BAND_5GHZ;
168                 sbands->n_channels = ARRAY_SIZE(rsi_5ghz_channels);
169                 sbands->bitrates = &rsi_rates[4];
170                 sbands->n_bitrates = ARRAY_SIZE(rsi_rates) - 4;
171         }
172
173         sbands->channels = channels;
174
175         memset(&sbands->ht_cap, 0, sizeof(struct ieee80211_sta_ht_cap));
176         sbands->ht_cap.ht_supported = true;
177         sbands->ht_cap.cap = (IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
178                               IEEE80211_HT_CAP_SGI_20 |
179                               IEEE80211_HT_CAP_SGI_40);
180         sbands->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_16K;
181         sbands->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
182         sbands->ht_cap.mcs.rx_mask[0] = 0xff;
183         sbands->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
184         /* sbands->ht_cap.mcs.rx_highest = 0x82; */
185 }
186
187 /**
188  * rsi_mac80211_detach() - This function is used to de-initialize the
189  *                         Mac80211 stack.
190  * @adapter: Pointer to the adapter structure.
191  *
192  * Return: None.
193  */
194 void rsi_mac80211_detach(struct rsi_hw *adapter)
195 {
196         struct ieee80211_hw *hw = adapter->hw;
197
198         if (hw) {
199                 ieee80211_stop_queues(hw);
200                 ieee80211_unregister_hw(hw);
201                 ieee80211_free_hw(hw);
202                 adapter->hw = NULL;
203         }
204
205         rsi_remove_dbgfs(adapter);
206 }
207 EXPORT_SYMBOL_GPL(rsi_mac80211_detach);
208
209 /**
210  * rsi_indicate_tx_status() - This function indicates the transmit status.
211  * @adapter: Pointer to the adapter structure.
212  * @skb: Pointer to the socket buffer structure.
213  * @status: Status
214  *
215  * Return: None.
216  */
217 void rsi_indicate_tx_status(struct rsi_hw *adapter,
218                             struct sk_buff *skb,
219                             int status)
220 {
221         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
222
223         memset(info->driver_data, 0, IEEE80211_TX_INFO_DRIVER_DATA_SIZE);
224
225         if (!status)
226                 info->flags |= IEEE80211_TX_STAT_ACK;
227
228         ieee80211_tx_status_irqsafe(adapter->hw, skb);
229 }
230
231 /**
232  * rsi_mac80211_tx() - This is the handler that 802.11 module calls for each
233  *                     transmitted frame.SKB contains the buffer starting
234  *                     from the IEEE 802.11 header.
235  * @hw: Pointer to the ieee80211_hw structure.
236  * @control: Pointer to the ieee80211_tx_control structure
237  * @skb: Pointer to the socket buffer structure.
238  *
239  * Return: None
240  */
241 static void rsi_mac80211_tx(struct ieee80211_hw *hw,
242                             struct ieee80211_tx_control *control,
243                             struct sk_buff *skb)
244 {
245         struct rsi_hw *adapter = hw->priv;
246         struct rsi_common *common = adapter->priv;
247
248         rsi_core_xmit(common, skb);
249 }
250
251 /**
252  * rsi_mac80211_start() - This is first handler that 802.11 module calls, since
253  *                        the driver init is complete by then, just
254  *                        returns success.
255  * @hw: Pointer to the ieee80211_hw structure.
256  *
257  * Return: 0 as success.
258  */
259 static int rsi_mac80211_start(struct ieee80211_hw *hw)
260 {
261         struct rsi_hw *adapter = hw->priv;
262         struct rsi_common *common = adapter->priv;
263
264         mutex_lock(&common->mutex);
265         common->iface_down = false;
266         mutex_unlock(&common->mutex);
267
268         return 0;
269 }
270
271 /**
272  * rsi_mac80211_stop() - This is the last handler that 802.11 module calls.
273  * @hw: Pointer to the ieee80211_hw structure.
274  *
275  * Return: None.
276  */
277 static void rsi_mac80211_stop(struct ieee80211_hw *hw)
278 {
279         struct rsi_hw *adapter = hw->priv;
280         struct rsi_common *common = adapter->priv;
281
282         mutex_lock(&common->mutex);
283         common->iface_down = true;
284         mutex_unlock(&common->mutex);
285 }
286
287 /**
288  * rsi_mac80211_add_interface() - This function is called when a netdevice
289  *                                attached to the hardware is enabled.
290  * @hw: Pointer to the ieee80211_hw structure.
291  * @vif: Pointer to the ieee80211_vif structure.
292  *
293  * Return: ret: 0 on success, negative error code on failure.
294  */
295 static int rsi_mac80211_add_interface(struct ieee80211_hw *hw,
296                                       struct ieee80211_vif *vif)
297 {
298         struct rsi_hw *adapter = hw->priv;
299         struct rsi_common *common = adapter->priv;
300         int ret = -EOPNOTSUPP;
301
302         mutex_lock(&common->mutex);
303         switch (vif->type) {
304         case NL80211_IFTYPE_STATION:
305                 if (!adapter->sc_nvifs) {
306                         ++adapter->sc_nvifs;
307                         adapter->vifs[0] = vif;
308                         ret = rsi_set_vap_capabilities(common, STA_OPMODE);
309                 }
310                 break;
311         default:
312                 rsi_dbg(ERR_ZONE,
313                         "%s: Interface type %d not supported\n", __func__,
314                         vif->type);
315         }
316         mutex_unlock(&common->mutex);
317
318         return ret;
319 }
320
321 /**
322  * rsi_mac80211_remove_interface() - This function notifies driver that an
323  *                                   interface is going down.
324  * @hw: Pointer to the ieee80211_hw structure.
325  * @vif: Pointer to the ieee80211_vif structure.
326  *
327  * Return: None.
328  */
329 static void rsi_mac80211_remove_interface(struct ieee80211_hw *hw,
330                                           struct ieee80211_vif *vif)
331 {
332         struct rsi_hw *adapter = hw->priv;
333         struct rsi_common *common = adapter->priv;
334
335         mutex_lock(&common->mutex);
336         if (vif->type == NL80211_IFTYPE_STATION)
337                 adapter->sc_nvifs--;
338
339         if (!memcmp(adapter->vifs[0], vif, sizeof(struct ieee80211_vif)))
340                 adapter->vifs[0] = NULL;
341         mutex_unlock(&common->mutex);
342 }
343
344 /**
345  * rsi_channel_change() - This function is a performs the checks
346  *                        required for changing a channel and sets
347  *                        the channel accordingly.
348  * @hw: Pointer to the ieee80211_hw structure.
349  *
350  * Return: 0 on success, negative error code on failure.
351  */
352 static int rsi_channel_change(struct ieee80211_hw *hw)
353 {
354         struct rsi_hw *adapter = hw->priv;
355         struct rsi_common *common = adapter->priv;
356         int status = -EOPNOTSUPP;
357         struct ieee80211_channel *curchan = hw->conf.chandef.chan;
358         u16 channel = curchan->hw_value;
359         struct ieee80211_bss_conf *bss = &adapter->vifs[0]->bss_conf;
360
361         rsi_dbg(INFO_ZONE,
362                 "%s: Set channel: %d MHz type: %d channel_no %d\n",
363                 __func__, curchan->center_freq,
364                 curchan->flags, channel);
365
366         if (bss->assoc) {
367                 if (!common->hw_data_qs_blocked &&
368                     (rsi_get_connected_channel(adapter) != channel)) {
369                         rsi_dbg(INFO_ZONE, "blk data q %d\n", channel);
370                         if (!rsi_send_block_unblock_frame(common, true))
371                                 common->hw_data_qs_blocked = true;
372                 }
373         }
374
375         status = rsi_band_check(common);
376         if (!status)
377                 status = rsi_set_channel(adapter->priv, channel);
378
379         if (bss->assoc) {
380                 if (common->hw_data_qs_blocked &&
381                     (rsi_get_connected_channel(adapter) == channel)) {
382                         rsi_dbg(INFO_ZONE, "unblk data q %d\n", channel);
383                         if (!rsi_send_block_unblock_frame(common, false))
384                                 common->hw_data_qs_blocked = false;
385                 }
386         } else {
387                 if (common->hw_data_qs_blocked) {
388                         rsi_dbg(INFO_ZONE, "unblk data q %d\n", channel);
389                         if (!rsi_send_block_unblock_frame(common, false))
390                                 common->hw_data_qs_blocked = false;
391                 }
392         }
393
394         return status;
395 }
396
397 /**
398  * rsi_mac80211_config() - This function is a handler for configuration
399  *                         requests. The stack calls this function to
400  *                         change hardware configuration, e.g., channel.
401  * @hw: Pointer to the ieee80211_hw structure.
402  * @changed: Changed flags set.
403  *
404  * Return: 0 on success, negative error code on failure.
405  */
406 static int rsi_mac80211_config(struct ieee80211_hw *hw,
407                                u32 changed)
408 {
409         struct rsi_hw *adapter = hw->priv;
410         struct rsi_common *common = adapter->priv;
411         int status = -EOPNOTSUPP;
412
413         mutex_lock(&common->mutex);
414
415         if (changed & IEEE80211_CONF_CHANGE_CHANNEL)
416                 status = rsi_channel_change(hw);
417
418         mutex_unlock(&common->mutex);
419
420         return status;
421 }
422
423 /**
424  * rsi_get_connected_channel() - This function is used to get the current
425  *                               connected channel number.
426  * @adapter: Pointer to the adapter structure.
427  *
428  * Return: Current connected AP's channel number is returned.
429  */
430 u16 rsi_get_connected_channel(struct rsi_hw *adapter)
431 {
432         struct ieee80211_vif *vif = adapter->vifs[0];
433         if (vif) {
434                 struct ieee80211_bss_conf *bss = &vif->bss_conf;
435                 struct ieee80211_channel *channel = bss->chandef.chan;
436                 return channel->hw_value;
437         }
438
439         return 0;
440 }
441
442 /**
443  * rsi_mac80211_bss_info_changed() - This function is a handler for config
444  *                                   requests related to BSS parameters that
445  *                                   may vary during BSS's lifespan.
446  * @hw: Pointer to the ieee80211_hw structure.
447  * @vif: Pointer to the ieee80211_vif structure.
448  * @bss_conf: Pointer to the ieee80211_bss_conf structure.
449  * @changed: Changed flags set.
450  *
451  * Return: None.
452  */
453 static void rsi_mac80211_bss_info_changed(struct ieee80211_hw *hw,
454                                           struct ieee80211_vif *vif,
455                                           struct ieee80211_bss_conf *bss_conf,
456                                           u32 changed)
457 {
458         struct rsi_hw *adapter = hw->priv;
459         struct rsi_common *common = adapter->priv;
460
461         mutex_lock(&common->mutex);
462         if (changed & BSS_CHANGED_ASSOC) {
463                 rsi_dbg(INFO_ZONE, "%s: Changed Association status: %d\n",
464                         __func__, bss_conf->assoc);
465                 rsi_inform_bss_status(common,
466                                       bss_conf->assoc,
467                                       bss_conf->bssid,
468                                       bss_conf->qos,
469                                       bss_conf->aid);
470         }
471
472         if (changed & BSS_CHANGED_CQM) {
473                 common->cqm_info.last_cqm_event_rssi = 0;
474                 common->cqm_info.rssi_thold = bss_conf->cqm_rssi_thold;
475                 common->cqm_info.rssi_hyst = bss_conf->cqm_rssi_hyst;
476                 rsi_dbg(INFO_ZONE, "RSSI throld & hysteresis are: %d %d\n",
477                         common->cqm_info.rssi_thold,
478                         common->cqm_info.rssi_hyst);
479         }
480         mutex_unlock(&common->mutex);
481 }
482
483 /**
484  * rsi_mac80211_conf_filter() - This function configure the device's RX filter.
485  * @hw: Pointer to the ieee80211_hw structure.
486  * @changed: Changed flags set.
487  * @total_flags: Total initial flags set.
488  * @multicast: Multicast.
489  *
490  * Return: None.
491  */
492 static void rsi_mac80211_conf_filter(struct ieee80211_hw *hw,
493                                      u32 changed_flags,
494                                      u32 *total_flags,
495                                      u64 multicast)
496 {
497         /* Not doing much here as of now */
498         *total_flags &= RSI_SUPP_FILTERS;
499 }
500
501 /**
502  * rsi_mac80211_conf_tx() - This function configures TX queue parameters
503  *                          (EDCF (aifs, cw_min, cw_max), bursting)
504  *                          for a hardware TX queue.
505  * @hw: Pointer to the ieee80211_hw structure
506  * @vif: Pointer to the ieee80211_vif structure.
507  * @queue: Queue number.
508  * @params: Pointer to ieee80211_tx_queue_params structure.
509  *
510  * Return: 0 on success, negative error code on failure.
511  */
512 static int rsi_mac80211_conf_tx(struct ieee80211_hw *hw,
513                                 struct ieee80211_vif *vif, u16 queue,
514                                 const struct ieee80211_tx_queue_params *params)
515 {
516         struct rsi_hw *adapter = hw->priv;
517         struct rsi_common *common = adapter->priv;
518         u8 idx = 0;
519
520         if (queue >= IEEE80211_NUM_ACS)
521                 return 0;
522
523         rsi_dbg(INFO_ZONE,
524                 "%s: Conf queue %d, aifs: %d, cwmin: %d cwmax: %d, txop: %d\n",
525                 __func__, queue, params->aifs,
526                 params->cw_min, params->cw_max, params->txop);
527
528         mutex_lock(&common->mutex);
529         /* Map into the way the f/w expects */
530         switch (queue) {
531         case IEEE80211_AC_VO:
532                 idx = VO_Q;
533                 break;
534         case IEEE80211_AC_VI:
535                 idx = VI_Q;
536                 break;
537         case IEEE80211_AC_BE:
538                 idx = BE_Q;
539                 break;
540         case IEEE80211_AC_BK:
541                 idx = BK_Q;
542                 break;
543         default:
544                 idx = BE_Q;
545                 break;
546         }
547
548         memcpy(&common->edca_params[idx],
549                params,
550                sizeof(struct ieee80211_tx_queue_params));
551         mutex_unlock(&common->mutex);
552
553         return 0;
554 }
555
556 /**
557  * rsi_hal_key_config() - This function loads the keys into the firmware.
558  * @hw: Pointer to the ieee80211_hw structure.
559  * @vif: Pointer to the ieee80211_vif structure.
560  * @key: Pointer to the ieee80211_key_conf structure.
561  *
562  * Return: status: 0 on success, -1 on failure.
563  */
564 static int rsi_hal_key_config(struct ieee80211_hw *hw,
565                               struct ieee80211_vif *vif,
566                               struct ieee80211_key_conf *key)
567 {
568         struct rsi_hw *adapter = hw->priv;
569         int status;
570         u8 key_type;
571
572         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
573                 key_type = RSI_PAIRWISE_KEY;
574         else
575                 key_type = RSI_GROUP_KEY;
576
577         rsi_dbg(ERR_ZONE, "%s: Cipher 0x%x key_type: %d key_len: %d\n",
578                 __func__, key->cipher, key_type, key->keylen);
579
580         if ((key->cipher == WLAN_CIPHER_SUITE_WEP104) ||
581             (key->cipher == WLAN_CIPHER_SUITE_WEP40)) {
582                 status = rsi_hal_load_key(adapter->priv,
583                                           key->key,
584                                           key->keylen,
585                                           RSI_PAIRWISE_KEY,
586                                           key->keyidx,
587                                           key->cipher);
588                 if (status)
589                         return status;
590         }
591         return rsi_hal_load_key(adapter->priv,
592                                 key->key,
593                                 key->keylen,
594                                 key_type,
595                                 key->keyidx,
596                                 key->cipher);
597 }
598
599 /**
600  * rsi_mac80211_set_key() - This function sets type of key to be loaded.
601  * @hw: Pointer to the ieee80211_hw structure.
602  * @cmd: enum set_key_cmd.
603  * @vif: Pointer to the ieee80211_vif structure.
604  * @sta: Pointer to the ieee80211_sta structure.
605  * @key: Pointer to the ieee80211_key_conf structure.
606  *
607  * Return: status: 0 on success, negative error code on failure.
608  */
609 static int rsi_mac80211_set_key(struct ieee80211_hw *hw,
610                                 enum set_key_cmd cmd,
611                                 struct ieee80211_vif *vif,
612                                 struct ieee80211_sta *sta,
613                                 struct ieee80211_key_conf *key)
614 {
615         struct rsi_hw *adapter = hw->priv;
616         struct rsi_common *common = adapter->priv;
617         struct security_info *secinfo = &common->secinfo;
618         int status;
619
620         mutex_lock(&common->mutex);
621         switch (cmd) {
622         case SET_KEY:
623                 secinfo->security_enable = true;
624                 status = rsi_hal_key_config(hw, vif, key);
625                 if (status) {
626                         mutex_unlock(&common->mutex);
627                         return status;
628                 }
629
630                 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
631                         secinfo->ptk_cipher = key->cipher;
632                 else
633                         secinfo->gtk_cipher = key->cipher;
634
635                 key->hw_key_idx = key->keyidx;
636                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
637
638                 rsi_dbg(ERR_ZONE, "%s: RSI set_key\n", __func__);
639                 break;
640
641         case DISABLE_KEY:
642                 secinfo->security_enable = false;
643                 rsi_dbg(ERR_ZONE, "%s: RSI del key\n", __func__);
644                 memset(key, 0, sizeof(struct ieee80211_key_conf));
645                 status = rsi_hal_key_config(hw, vif, key);
646                 break;
647
648         default:
649                 status = -EOPNOTSUPP;
650                 break;
651         }
652
653         mutex_unlock(&common->mutex);
654         return status;
655 }
656
657 /**
658  * rsi_mac80211_ampdu_action() - This function selects the AMPDU action for
659  *                               the corresponding mlme_action flag and
660  *                               informs the f/w regarding this.
661  * @hw: Pointer to the ieee80211_hw structure.
662  * @vif: Pointer to the ieee80211_vif structure.
663  * @params: Pointer to A-MPDU action parameters
664  *
665  * Return: status: 0 on success, negative error code on failure.
666  */
667 static int rsi_mac80211_ampdu_action(struct ieee80211_hw *hw,
668                                      struct ieee80211_vif *vif,
669                                      struct ieee80211_ampdu_params *params)
670 {
671         int status = -EOPNOTSUPP;
672         struct rsi_hw *adapter = hw->priv;
673         struct rsi_common *common = adapter->priv;
674         u16 seq_no = 0;
675         u8 ii = 0;
676         struct ieee80211_sta *sta = params->sta;
677         enum ieee80211_ampdu_mlme_action action = params->action;
678         u16 tid = params->tid;
679         u16 *ssn = &params->ssn;
680         u8 buf_size = params->buf_size;
681
682         for (ii = 0; ii < RSI_MAX_VIFS; ii++) {
683                 if (vif == adapter->vifs[ii])
684                         break;
685         }
686
687         mutex_lock(&common->mutex);
688         rsi_dbg(INFO_ZONE, "%s: AMPDU action %d called\n", __func__, action);
689         if (ssn != NULL)
690                 seq_no = *ssn;
691
692         switch (action) {
693         case IEEE80211_AMPDU_RX_START:
694                 status = rsi_send_aggregation_params_frame(common,
695                                                            tid,
696                                                            seq_no,
697                                                            buf_size,
698                                                            STA_RX_ADDBA_DONE);
699                 break;
700
701         case IEEE80211_AMPDU_RX_STOP:
702                 status = rsi_send_aggregation_params_frame(common,
703                                                            tid,
704                                                            0,
705                                                            buf_size,
706                                                            STA_RX_DELBA);
707                 break;
708
709         case IEEE80211_AMPDU_TX_START:
710                 common->vif_info[ii].seq_start = seq_no;
711                 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
712                 status = 0;
713                 break;
714
715         case IEEE80211_AMPDU_TX_STOP_CONT:
716         case IEEE80211_AMPDU_TX_STOP_FLUSH:
717         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
718                 status = rsi_send_aggregation_params_frame(common,
719                                                            tid,
720                                                            seq_no,
721                                                            buf_size,
722                                                            STA_TX_DELBA);
723                 if (!status)
724                         ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
725                 break;
726
727         case IEEE80211_AMPDU_TX_OPERATIONAL:
728                 status = rsi_send_aggregation_params_frame(common,
729                                                            tid,
730                                                            common->vif_info[ii]
731                                                                 .seq_start,
732                                                            buf_size,
733                                                            STA_TX_ADDBA_DONE);
734                 break;
735
736         default:
737                 rsi_dbg(ERR_ZONE, "%s: Uknown AMPDU action\n", __func__);
738                 break;
739         }
740
741         mutex_unlock(&common->mutex);
742         return status;
743 }
744
745 /**
746  * rsi_mac80211_set_rts_threshold() - This function sets rts threshold value.
747  * @hw: Pointer to the ieee80211_hw structure.
748  * @value: Rts threshold value.
749  *
750  * Return: 0 on success.
751  */
752 static int rsi_mac80211_set_rts_threshold(struct ieee80211_hw *hw,
753                                           u32 value)
754 {
755         struct rsi_hw *adapter = hw->priv;
756         struct rsi_common *common = adapter->priv;
757
758         mutex_lock(&common->mutex);
759         common->rts_threshold = value;
760         mutex_unlock(&common->mutex);
761
762         return 0;
763 }
764
765 /**
766  * rsi_mac80211_set_rate_mask() - This function sets bitrate_mask to be used.
767  * @hw: Pointer to the ieee80211_hw structure
768  * @vif: Pointer to the ieee80211_vif structure.
769  * @mask: Pointer to the cfg80211_bitrate_mask structure.
770  *
771  * Return: 0 on success.
772  */
773 static int rsi_mac80211_set_rate_mask(struct ieee80211_hw *hw,
774                                       struct ieee80211_vif *vif,
775                                       const struct cfg80211_bitrate_mask *mask)
776 {
777         struct rsi_hw *adapter = hw->priv;
778         struct rsi_common *common = adapter->priv;
779         enum ieee80211_band band = hw->conf.chandef.chan->band;
780
781         mutex_lock(&common->mutex);
782         common->fixedrate_mask[band] = 0;
783
784         if (mask->control[band].legacy == 0xfff) {
785                 common->fixedrate_mask[band] =
786                         (mask->control[band].ht_mcs[0] << 12);
787         } else {
788                 common->fixedrate_mask[band] =
789                         mask->control[band].legacy;
790         }
791         mutex_unlock(&common->mutex);
792
793         return 0;
794 }
795
796 /**
797  * rsi_perform_cqm() - This function performs cqm.
798  * @common: Pointer to the driver private structure.
799  * @bssid: pointer to the bssid.
800  * @rssi: RSSI value.
801  */
802 static void rsi_perform_cqm(struct rsi_common *common,
803                             u8 *bssid,
804                             s8 rssi)
805 {
806         struct rsi_hw *adapter = common->priv;
807         s8 last_event = common->cqm_info.last_cqm_event_rssi;
808         int thold = common->cqm_info.rssi_thold;
809         u32 hyst = common->cqm_info.rssi_hyst;
810         enum nl80211_cqm_rssi_threshold_event event;
811
812         if (rssi < thold && (last_event == 0 || rssi < (last_event - hyst)))
813                 event = NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW;
814         else if (rssi > thold &&
815                  (last_event == 0 || rssi > (last_event + hyst)))
816                 event = NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH;
817         else
818                 return;
819
820         common->cqm_info.last_cqm_event_rssi = rssi;
821         rsi_dbg(INFO_ZONE, "CQM: Notifying event: %d\n", event);
822         ieee80211_cqm_rssi_notify(adapter->vifs[0], event, GFP_KERNEL);
823
824         return;
825 }
826
827 /**
828  * rsi_fill_rx_status() - This function fills rx status in
829  *                        ieee80211_rx_status structure.
830  * @hw: Pointer to the ieee80211_hw structure.
831  * @skb: Pointer to the socket buffer structure.
832  * @common: Pointer to the driver private structure.
833  * @rxs: Pointer to the ieee80211_rx_status structure.
834  *
835  * Return: None.
836  */
837 static void rsi_fill_rx_status(struct ieee80211_hw *hw,
838                                struct sk_buff *skb,
839                                struct rsi_common *common,
840                                struct ieee80211_rx_status *rxs)
841 {
842         struct ieee80211_bss_conf *bss = &common->priv->vifs[0]->bss_conf;
843         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
844         struct skb_info *rx_params = (struct skb_info *)info->driver_data;
845         struct ieee80211_hdr *hdr;
846         char rssi = rx_params->rssi;
847         u8 hdrlen = 0;
848         u8 channel = rx_params->channel;
849         s32 freq;
850
851         hdr = ((struct ieee80211_hdr *)(skb->data));
852         hdrlen = ieee80211_hdrlen(hdr->frame_control);
853
854         memset(info, 0, sizeof(struct ieee80211_tx_info));
855
856         rxs->signal = -(rssi);
857
858         rxs->band = common->band;
859
860         freq = ieee80211_channel_to_frequency(channel, rxs->band);
861
862         if (freq)
863                 rxs->freq = freq;
864
865         if (ieee80211_has_protected(hdr->frame_control)) {
866                 if (rsi_is_cipher_wep(common)) {
867                         memmove(skb->data + 4, skb->data, hdrlen);
868                         skb_pull(skb, 4);
869                 } else {
870                         memmove(skb->data + 8, skb->data, hdrlen);
871                         skb_pull(skb, 8);
872                         rxs->flag |= RX_FLAG_MMIC_STRIPPED;
873                 }
874                 rxs->flag |= RX_FLAG_DECRYPTED;
875                 rxs->flag |= RX_FLAG_IV_STRIPPED;
876         }
877
878         /* CQM only for connected AP beacons, the RSSI is a weighted avg */
879         if (bss->assoc && !(memcmp(bss->bssid, hdr->addr2, ETH_ALEN))) {
880                 if (ieee80211_is_beacon(hdr->frame_control))
881                         rsi_perform_cqm(common, hdr->addr2, rxs->signal);
882         }
883
884         return;
885 }
886
887 /**
888  * rsi_indicate_pkt_to_os() - This function sends recieved packet to mac80211.
889  * @common: Pointer to the driver private structure.
890  * @skb: Pointer to the socket buffer structure.
891  *
892  * Return: None.
893  */
894 void rsi_indicate_pkt_to_os(struct rsi_common *common,
895                             struct sk_buff *skb)
896 {
897         struct rsi_hw *adapter = common->priv;
898         struct ieee80211_hw *hw = adapter->hw;
899         struct ieee80211_rx_status *rx_status = IEEE80211_SKB_RXCB(skb);
900
901         if ((common->iface_down) || (!adapter->sc_nvifs)) {
902                 dev_kfree_skb(skb);
903                 return;
904         }
905
906         /* filling in the ieee80211_rx_status flags */
907         rsi_fill_rx_status(hw, skb, common, rx_status);
908
909         ieee80211_rx_irqsafe(hw, skb);
910 }
911
912 static void rsi_set_min_rate(struct ieee80211_hw *hw,
913                              struct ieee80211_sta *sta,
914                              struct rsi_common *common)
915 {
916         u8 band = hw->conf.chandef.chan->band;
917         u8 ii;
918         u32 rate_bitmap;
919         bool matched = false;
920
921         common->bitrate_mask[band] = sta->supp_rates[band];
922
923         rate_bitmap = (common->fixedrate_mask[band] & sta->supp_rates[band]);
924
925         if (rate_bitmap & 0xfff) {
926                 /* Find out the min rate */
927                 for (ii = 0; ii < ARRAY_SIZE(rsi_rates); ii++) {
928                         if (rate_bitmap & BIT(ii)) {
929                                 common->min_rate = rsi_rates[ii].hw_value;
930                                 matched = true;
931                                 break;
932                         }
933                 }
934         }
935
936         common->vif_info[0].is_ht = sta->ht_cap.ht_supported;
937
938         if ((common->vif_info[0].is_ht) && (rate_bitmap >> 12)) {
939                 for (ii = 0; ii < ARRAY_SIZE(rsi_mcsrates); ii++) {
940                         if ((rate_bitmap >> 12) & BIT(ii)) {
941                                 common->min_rate = rsi_mcsrates[ii];
942                                 matched = true;
943                                 break;
944                         }
945                 }
946         }
947
948         if (!matched)
949                 common->min_rate = 0xffff;
950 }
951
952 /**
953  * rsi_mac80211_sta_add() - This function notifies driver about a peer getting
954  *                          connected.
955  * @hw: pointer to the ieee80211_hw structure.
956  * @vif: Pointer to the ieee80211_vif structure.
957  * @sta: Pointer to the ieee80211_sta structure.
958  *
959  * Return: 0 on success, -1 on failure.
960  */
961 static int rsi_mac80211_sta_add(struct ieee80211_hw *hw,
962                                 struct ieee80211_vif *vif,
963                                 struct ieee80211_sta *sta)
964 {
965         struct rsi_hw *adapter = hw->priv;
966         struct rsi_common *common = adapter->priv;
967
968         mutex_lock(&common->mutex);
969
970         rsi_set_min_rate(hw, sta, common);
971
972         if ((sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20) ||
973             (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40)) {
974                 common->vif_info[0].sgi = true;
975         }
976
977         if (sta->ht_cap.ht_supported)
978                 ieee80211_start_tx_ba_session(sta, 0, 0);
979
980         mutex_unlock(&common->mutex);
981
982         return 0;
983 }
984
985 /**
986  * rsi_mac80211_sta_remove() - This function notifies driver about a peer
987  *                             getting disconnected.
988  * @hw: Pointer to the ieee80211_hw structure.
989  * @vif: Pointer to the ieee80211_vif structure.
990  * @sta: Pointer to the ieee80211_sta structure.
991  *
992  * Return: 0 on success, -1 on failure.
993  */
994 static int rsi_mac80211_sta_remove(struct ieee80211_hw *hw,
995                                    struct ieee80211_vif *vif,
996                                    struct ieee80211_sta *sta)
997 {
998         struct rsi_hw *adapter = hw->priv;
999         struct rsi_common *common = adapter->priv;
1000
1001         mutex_lock(&common->mutex);
1002         /* Resetting all the fields to default values */
1003         common->bitrate_mask[IEEE80211_BAND_2GHZ] = 0;
1004         common->bitrate_mask[IEEE80211_BAND_5GHZ] = 0;
1005         common->min_rate = 0xffff;
1006         common->vif_info[0].is_ht = false;
1007         common->vif_info[0].sgi = false;
1008         common->vif_info[0].seq_start = 0;
1009         common->secinfo.ptk_cipher = 0;
1010         common->secinfo.gtk_cipher = 0;
1011         mutex_unlock(&common->mutex);
1012
1013         return 0;
1014 }
1015
1016 static struct ieee80211_ops mac80211_ops = {
1017         .tx = rsi_mac80211_tx,
1018         .start = rsi_mac80211_start,
1019         .stop = rsi_mac80211_stop,
1020         .add_interface = rsi_mac80211_add_interface,
1021         .remove_interface = rsi_mac80211_remove_interface,
1022         .config = rsi_mac80211_config,
1023         .bss_info_changed = rsi_mac80211_bss_info_changed,
1024         .conf_tx = rsi_mac80211_conf_tx,
1025         .configure_filter = rsi_mac80211_conf_filter,
1026         .set_key = rsi_mac80211_set_key,
1027         .set_rts_threshold = rsi_mac80211_set_rts_threshold,
1028         .set_bitrate_mask = rsi_mac80211_set_rate_mask,
1029         .ampdu_action = rsi_mac80211_ampdu_action,
1030         .sta_add = rsi_mac80211_sta_add,
1031         .sta_remove = rsi_mac80211_sta_remove,
1032 };
1033
1034 /**
1035  * rsi_mac80211_attach() - This function is used to initialize Mac80211 stack.
1036  * @common: Pointer to the driver private structure.
1037  *
1038  * Return: 0 on success, -1 on failure.
1039  */
1040 int rsi_mac80211_attach(struct rsi_common *common)
1041 {
1042         int status = 0;
1043         struct ieee80211_hw *hw = NULL;
1044         struct wiphy *wiphy = NULL;
1045         struct rsi_hw *adapter = common->priv;
1046         u8 addr_mask[ETH_ALEN] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x3};
1047
1048         rsi_dbg(INIT_ZONE, "%s: Performing mac80211 attach\n", __func__);
1049
1050         hw = ieee80211_alloc_hw(sizeof(struct rsi_hw), &mac80211_ops);
1051         if (!hw) {
1052                 rsi_dbg(ERR_ZONE, "%s: ieee80211 hw alloc failed\n", __func__);
1053                 return -ENOMEM;
1054         }
1055
1056         wiphy = hw->wiphy;
1057
1058         SET_IEEE80211_DEV(hw, adapter->device);
1059
1060         hw->priv = adapter;
1061         adapter->hw = hw;
1062
1063         ieee80211_hw_set(hw, SIGNAL_DBM);
1064         ieee80211_hw_set(hw, HAS_RATE_CONTROL);
1065         ieee80211_hw_set(hw, AMPDU_AGGREGATION);
1066
1067         hw->queues = MAX_HW_QUEUES;
1068         hw->extra_tx_headroom = RSI_NEEDED_HEADROOM;
1069
1070         hw->max_rates = 1;
1071         hw->max_rate_tries = MAX_RETRIES;
1072
1073         hw->max_tx_aggregation_subframes = 6;
1074         rsi_register_rates_channels(adapter, IEEE80211_BAND_2GHZ);
1075         rsi_register_rates_channels(adapter, IEEE80211_BAND_5GHZ);
1076         hw->rate_control_algorithm = "AARF";
1077
1078         SET_IEEE80211_PERM_ADDR(hw, common->mac_addr);
1079         ether_addr_copy(hw->wiphy->addr_mask, addr_mask);
1080
1081         wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
1082         wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
1083         wiphy->retry_short = RETRY_SHORT;
1084         wiphy->retry_long  = RETRY_LONG;
1085         wiphy->frag_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
1086         wiphy->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
1087         wiphy->flags = 0;
1088
1089         wiphy->available_antennas_rx = 1;
1090         wiphy->available_antennas_tx = 1;
1091         wiphy->bands[IEEE80211_BAND_2GHZ] =
1092                 &adapter->sbands[IEEE80211_BAND_2GHZ];
1093         wiphy->bands[IEEE80211_BAND_5GHZ] =
1094                 &adapter->sbands[IEEE80211_BAND_5GHZ];
1095
1096         status = ieee80211_register_hw(hw);
1097         if (status)
1098                 return status;
1099
1100         return rsi_init_dbgfs(adapter);
1101 }