Commit | Line | Data |
---|---|---|
dad0d04f FF |
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_mgmt.h" | |
19 | #include "rsi_common.h" | |
20 | ||
21 | static struct bootup_params boot_params_20 = { | |
22 | .magic_number = cpu_to_le16(0x5aa5), | |
23 | .crystal_good_time = 0x0, | |
24 | .valid = cpu_to_le32(VALID_20), | |
25 | .reserved_for_valids = 0x0, | |
26 | .bootup_mode_info = 0x0, | |
27 | .digital_loop_back_params = 0x0, | |
28 | .rtls_timestamp_en = 0x0, | |
29 | .host_spi_intr_cfg = 0x0, | |
30 | .device_clk_info = {{ | |
31 | .pll_config_g = { | |
32 | .tapll_info_g = { | |
33 | .pll_reg_1 = cpu_to_le16((TA_PLL_N_VAL_20 << 8)| | |
34 | (TA_PLL_M_VAL_20)), | |
35 | .pll_reg_2 = cpu_to_le16(TA_PLL_P_VAL_20), | |
36 | }, | |
37 | .pll960_info_g = { | |
38 | .pll_reg_1 = cpu_to_le16((PLL960_P_VAL_20 << 8)| | |
39 | (PLL960_N_VAL_20)), | |
40 | .pll_reg_2 = cpu_to_le16(PLL960_M_VAL_20), | |
41 | .pll_reg_3 = 0x0, | |
42 | }, | |
43 | .afepll_info_g = { | |
44 | .pll_reg = cpu_to_le16(0x9f0), | |
45 | } | |
46 | }, | |
47 | .switch_clk_g = { | |
48 | .switch_clk_info = cpu_to_le16(BIT(3)), | |
49 | .bbp_lmac_clk_reg_val = cpu_to_le16(0x121), | |
50 | .umac_clock_reg_config = 0x0, | |
51 | .qspi_uart_clock_reg_config = 0x0 | |
52 | } | |
53 | }, | |
54 | { | |
55 | .pll_config_g = { | |
56 | .tapll_info_g = { | |
57 | .pll_reg_1 = cpu_to_le16((TA_PLL_N_VAL_20 << 8)| | |
58 | (TA_PLL_M_VAL_20)), | |
59 | .pll_reg_2 = cpu_to_le16(TA_PLL_P_VAL_20), | |
60 | }, | |
61 | .pll960_info_g = { | |
62 | .pll_reg_1 = cpu_to_le16((PLL960_P_VAL_20 << 8)| | |
63 | (PLL960_N_VAL_20)), | |
64 | .pll_reg_2 = cpu_to_le16(PLL960_M_VAL_20), | |
65 | .pll_reg_3 = 0x0, | |
66 | }, | |
67 | .afepll_info_g = { | |
68 | .pll_reg = cpu_to_le16(0x9f0), | |
69 | } | |
70 | }, | |
71 | .switch_clk_g = { | |
72 | .switch_clk_info = 0x0, | |
73 | .bbp_lmac_clk_reg_val = 0x0, | |
74 | .umac_clock_reg_config = 0x0, | |
75 | .qspi_uart_clock_reg_config = 0x0 | |
76 | } | |
77 | }, | |
78 | { | |
79 | .pll_config_g = { | |
80 | .tapll_info_g = { | |
81 | .pll_reg_1 = cpu_to_le16((TA_PLL_N_VAL_20 << 8)| | |
82 | (TA_PLL_M_VAL_20)), | |
83 | .pll_reg_2 = cpu_to_le16(TA_PLL_P_VAL_20), | |
84 | }, | |
85 | .pll960_info_g = { | |
86 | .pll_reg_1 = cpu_to_le16((PLL960_P_VAL_20 << 8)| | |
87 | (PLL960_N_VAL_20)), | |
88 | .pll_reg_2 = cpu_to_le16(PLL960_M_VAL_20), | |
89 | .pll_reg_3 = 0x0, | |
90 | }, | |
91 | .afepll_info_g = { | |
92 | .pll_reg = cpu_to_le16(0x9f0), | |
93 | } | |
94 | }, | |
95 | .switch_clk_g = { | |
96 | .switch_clk_info = 0x0, | |
97 | .bbp_lmac_clk_reg_val = 0x0, | |
98 | .umac_clock_reg_config = 0x0, | |
99 | .qspi_uart_clock_reg_config = 0x0 | |
100 | } | |
101 | } }, | |
102 | .buckboost_wakeup_cnt = 0x0, | |
103 | .pmu_wakeup_wait = 0x0, | |
104 | .shutdown_wait_time = 0x0, | |
105 | .pmu_slp_clkout_sel = 0x0, | |
106 | .wdt_prog_value = 0x0, | |
107 | .wdt_soc_rst_delay = 0x0, | |
108 | .dcdc_operation_mode = 0x0, | |
109 | .soc_reset_wait_cnt = 0x0 | |
110 | }; | |
111 | ||
112 | static struct bootup_params boot_params_40 = { | |
113 | .magic_number = cpu_to_le16(0x5aa5), | |
114 | .crystal_good_time = 0x0, | |
115 | .valid = cpu_to_le32(VALID_40), | |
116 | .reserved_for_valids = 0x0, | |
117 | .bootup_mode_info = 0x0, | |
118 | .digital_loop_back_params = 0x0, | |
119 | .rtls_timestamp_en = 0x0, | |
120 | .host_spi_intr_cfg = 0x0, | |
121 | .device_clk_info = {{ | |
122 | .pll_config_g = { | |
123 | .tapll_info_g = { | |
124 | .pll_reg_1 = cpu_to_le16((TA_PLL_N_VAL_40 << 8)| | |
125 | (TA_PLL_M_VAL_40)), | |
126 | .pll_reg_2 = cpu_to_le16(TA_PLL_P_VAL_40), | |
127 | }, | |
128 | .pll960_info_g = { | |
129 | .pll_reg_1 = cpu_to_le16((PLL960_P_VAL_40 << 8)| | |
130 | (PLL960_N_VAL_40)), | |
131 | .pll_reg_2 = cpu_to_le16(PLL960_M_VAL_40), | |
132 | .pll_reg_3 = 0x0, | |
133 | }, | |
134 | .afepll_info_g = { | |
135 | .pll_reg = cpu_to_le16(0x9f0), | |
136 | } | |
137 | }, | |
138 | .switch_clk_g = { | |
139 | .switch_clk_info = cpu_to_le16(0x09), | |
140 | .bbp_lmac_clk_reg_val = cpu_to_le16(0x1121), | |
141 | .umac_clock_reg_config = cpu_to_le16(0x48), | |
142 | .qspi_uart_clock_reg_config = 0x0 | |
143 | } | |
144 | }, | |
145 | { | |
146 | .pll_config_g = { | |
147 | .tapll_info_g = { | |
148 | .pll_reg_1 = cpu_to_le16((TA_PLL_N_VAL_40 << 8)| | |
149 | (TA_PLL_M_VAL_40)), | |
150 | .pll_reg_2 = cpu_to_le16(TA_PLL_P_VAL_40), | |
151 | }, | |
152 | .pll960_info_g = { | |
153 | .pll_reg_1 = cpu_to_le16((PLL960_P_VAL_40 << 8)| | |
154 | (PLL960_N_VAL_40)), | |
155 | .pll_reg_2 = cpu_to_le16(PLL960_M_VAL_40), | |
156 | .pll_reg_3 = 0x0, | |
157 | }, | |
158 | .afepll_info_g = { | |
159 | .pll_reg = cpu_to_le16(0x9f0), | |
160 | } | |
161 | }, | |
162 | .switch_clk_g = { | |
163 | .switch_clk_info = 0x0, | |
164 | .bbp_lmac_clk_reg_val = 0x0, | |
165 | .umac_clock_reg_config = 0x0, | |
166 | .qspi_uart_clock_reg_config = 0x0 | |
167 | } | |
168 | }, | |
169 | { | |
170 | .pll_config_g = { | |
171 | .tapll_info_g = { | |
172 | .pll_reg_1 = cpu_to_le16((TA_PLL_N_VAL_40 << 8)| | |
173 | (TA_PLL_M_VAL_40)), | |
174 | .pll_reg_2 = cpu_to_le16(TA_PLL_P_VAL_40), | |
175 | }, | |
176 | .pll960_info_g = { | |
177 | .pll_reg_1 = cpu_to_le16((PLL960_P_VAL_40 << 8)| | |
178 | (PLL960_N_VAL_40)), | |
179 | .pll_reg_2 = cpu_to_le16(PLL960_M_VAL_40), | |
180 | .pll_reg_3 = 0x0, | |
181 | }, | |
182 | .afepll_info_g = { | |
183 | .pll_reg = cpu_to_le16(0x9f0), | |
184 | } | |
185 | }, | |
186 | .switch_clk_g = { | |
187 | .switch_clk_info = 0x0, | |
188 | .bbp_lmac_clk_reg_val = 0x0, | |
189 | .umac_clock_reg_config = 0x0, | |
190 | .qspi_uart_clock_reg_config = 0x0 | |
191 | } | |
192 | } }, | |
193 | .buckboost_wakeup_cnt = 0x0, | |
194 | .pmu_wakeup_wait = 0x0, | |
195 | .shutdown_wait_time = 0x0, | |
196 | .pmu_slp_clkout_sel = 0x0, | |
197 | .wdt_prog_value = 0x0, | |
198 | .wdt_soc_rst_delay = 0x0, | |
199 | .dcdc_operation_mode = 0x0, | |
200 | .soc_reset_wait_cnt = 0x0 | |
201 | }; | |
202 | ||
203 | static u16 mcs[] = {13, 26, 39, 52, 78, 104, 117, 130}; | |
204 | ||
205 | /** | |
206 | * rsi_set_default_parameters() - This function sets default parameters. | |
207 | * @common: Pointer to the driver private structure. | |
208 | * | |
209 | * Return: none | |
210 | */ | |
211 | static void rsi_set_default_parameters(struct rsi_common *common) | |
212 | { | |
213 | common->band = IEEE80211_BAND_2GHZ; | |
214 | common->channel_width = BW_20MHZ; | |
215 | common->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD; | |
216 | common->channel = 1; | |
217 | common->min_rate = 0xffff; | |
218 | common->fsm_state = FSM_CARD_NOT_READY; | |
219 | common->iface_down = true; | |
f870a340 | 220 | common->endpoint = EP_2GHZ_20MHZ; |
dad0d04f FF |
221 | } |
222 | ||
223 | /** | |
224 | * rsi_set_contention_vals() - This function sets the contention values for the | |
225 | * backoff procedure. | |
226 | * @common: Pointer to the driver private structure. | |
227 | * | |
228 | * Return: None. | |
229 | */ | |
230 | static void rsi_set_contention_vals(struct rsi_common *common) | |
231 | { | |
232 | u8 ii = 0; | |
233 | ||
234 | for (; ii < NUM_EDCA_QUEUES; ii++) { | |
235 | common->tx_qinfo[ii].wme_params = | |
236 | (((common->edca_params[ii].cw_min / 2) + | |
237 | (common->edca_params[ii].aifs)) * | |
238 | WMM_SHORT_SLOT_TIME + SIFS_DURATION); | |
239 | common->tx_qinfo[ii].weight = common->tx_qinfo[ii].wme_params; | |
240 | common->tx_qinfo[ii].pkt_contended = 0; | |
241 | } | |
242 | } | |
243 | ||
244 | /** | |
245 | * rsi_send_internal_mgmt_frame() - This function sends management frames to | |
246 | * firmware.Also schedules packet to queue | |
247 | * for transmission. | |
248 | * @common: Pointer to the driver private structure. | |
249 | * @skb: Pointer to the socket buffer structure. | |
250 | * | |
251 | * Return: 0 on success, -1 on failure. | |
252 | */ | |
253 | static int rsi_send_internal_mgmt_frame(struct rsi_common *common, | |
254 | struct sk_buff *skb) | |
255 | { | |
256 | struct skb_info *tx_params; | |
257 | ||
258 | if (skb == NULL) { | |
259 | rsi_dbg(ERR_ZONE, "%s: Unable to allocate skb\n", __func__); | |
260 | return -ENOMEM; | |
261 | } | |
262 | tx_params = (struct skb_info *)&IEEE80211_SKB_CB(skb)->driver_data; | |
263 | tx_params->flags |= INTERNAL_MGMT_PKT; | |
264 | skb_queue_tail(&common->tx_queue[MGMT_SOFT_Q], skb); | |
265 | rsi_set_event(&common->tx_thread.event); | |
266 | return 0; | |
267 | } | |
268 | ||
269 | /** | |
270 | * rsi_load_radio_caps() - This function is used to send radio capabilities | |
271 | * values to firmware. | |
272 | * @common: Pointer to the driver private structure. | |
273 | * | |
274 | * Return: 0 on success, corresponding negative error code on failure. | |
275 | */ | |
276 | static int rsi_load_radio_caps(struct rsi_common *common) | |
277 | { | |
278 | struct rsi_radio_caps *radio_caps; | |
279 | struct rsi_hw *adapter = common->priv; | |
280 | struct ieee80211_hw *hw = adapter->hw; | |
281 | u16 inx = 0; | |
282 | u8 ii; | |
283 | u8 radio_id = 0; | |
284 | u16 gc[20] = {0xf0, 0xf0, 0xf0, 0xf0, | |
285 | 0xf0, 0xf0, 0xf0, 0xf0, | |
286 | 0xf0, 0xf0, 0xf0, 0xf0, | |
287 | 0xf0, 0xf0, 0xf0, 0xf0, | |
288 | 0xf0, 0xf0, 0xf0, 0xf0}; | |
289 | struct ieee80211_conf *conf = &hw->conf; | |
290 | struct sk_buff *skb; | |
291 | ||
292 | rsi_dbg(INFO_ZONE, "%s: Sending rate symbol req frame\n", __func__); | |
293 | ||
294 | skb = dev_alloc_skb(sizeof(struct rsi_radio_caps)); | |
295 | ||
296 | if (!skb) { | |
297 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n", | |
298 | __func__); | |
299 | return -ENOMEM; | |
300 | } | |
301 | ||
302 | memset(skb->data, 0, sizeof(struct rsi_radio_caps)); | |
303 | radio_caps = (struct rsi_radio_caps *)skb->data; | |
304 | ||
305 | radio_caps->desc_word[1] = cpu_to_le16(RADIO_CAPABILITIES); | |
306 | radio_caps->desc_word[4] = cpu_to_le16(RSI_RF_TYPE << 8); | |
307 | ||
308 | if (common->channel_width == BW_40MHZ) { | |
309 | radio_caps->desc_word[7] |= cpu_to_le16(RSI_LMAC_CLOCK_80MHZ); | |
310 | radio_caps->desc_word[7] |= cpu_to_le16(RSI_ENABLE_40MHZ); | |
311 | if (common->channel_width) { | |
312 | radio_caps->desc_word[5] = | |
313 | cpu_to_le16(common->channel_width << 12); | |
314 | radio_caps->desc_word[5] |= cpu_to_le16(FULL40M_ENABLE); | |
315 | } | |
316 | ||
317 | if (conf_is_ht40_minus(conf)) { | |
318 | radio_caps->desc_word[5] = 0; | |
319 | radio_caps->desc_word[5] |= | |
320 | cpu_to_le16(LOWER_20_ENABLE); | |
321 | radio_caps->desc_word[5] |= | |
322 | cpu_to_le16(LOWER_20_ENABLE >> 12); | |
323 | } | |
324 | ||
325 | if (conf_is_ht40_plus(conf)) { | |
326 | radio_caps->desc_word[5] = 0; | |
327 | radio_caps->desc_word[5] |= | |
328 | cpu_to_le16(UPPER_20_ENABLE); | |
329 | radio_caps->desc_word[5] |= | |
330 | cpu_to_le16(UPPER_20_ENABLE >> 12); | |
331 | } | |
332 | } | |
333 | ||
4550faac JM |
334 | radio_caps->sifs_tx_11n = cpu_to_le16(SIFS_TX_11N_VALUE); |
335 | radio_caps->sifs_tx_11b = cpu_to_le16(SIFS_TX_11B_VALUE); | |
336 | radio_caps->slot_rx_11n = cpu_to_le16(SHORT_SLOT_VALUE); | |
337 | radio_caps->ofdm_ack_tout = cpu_to_le16(OFDM_ACK_TOUT_VALUE); | |
338 | radio_caps->cck_ack_tout = cpu_to_le16(CCK_ACK_TOUT_VALUE); | |
339 | radio_caps->preamble_type = cpu_to_le16(LONG_PREAMBLE); | |
340 | ||
dad0d04f FF |
341 | radio_caps->desc_word[7] |= cpu_to_le16(radio_id << 8); |
342 | ||
343 | for (ii = 0; ii < MAX_HW_QUEUES; ii++) { | |
344 | radio_caps->qos_params[ii].cont_win_min_q = cpu_to_le16(3); | |
345 | radio_caps->qos_params[ii].cont_win_max_q = cpu_to_le16(0x3f); | |
346 | radio_caps->qos_params[ii].aifsn_val_q = cpu_to_le16(2); | |
347 | radio_caps->qos_params[ii].txop_q = 0; | |
348 | } | |
349 | ||
350 | for (ii = 0; ii < MAX_HW_QUEUES - 4; ii++) { | |
351 | radio_caps->qos_params[ii].cont_win_min_q = | |
352 | cpu_to_le16(common->edca_params[ii].cw_min); | |
353 | radio_caps->qos_params[ii].cont_win_max_q = | |
354 | cpu_to_le16(common->edca_params[ii].cw_max); | |
355 | radio_caps->qos_params[ii].aifsn_val_q = | |
356 | cpu_to_le16((common->edca_params[ii].aifs) << 8); | |
357 | radio_caps->qos_params[ii].txop_q = | |
358 | cpu_to_le16(common->edca_params[ii].txop); | |
359 | } | |
360 | ||
361 | memcpy(&common->rate_pwr[0], &gc[0], 40); | |
362 | for (ii = 0; ii < 20; ii++) | |
363 | radio_caps->gcpd_per_rate[inx++] = | |
364 | cpu_to_le16(common->rate_pwr[ii] & 0x00FF); | |
365 | ||
366 | radio_caps->desc_word[0] = cpu_to_le16((sizeof(struct rsi_radio_caps) - | |
367 | FRAME_DESC_SZ) | | |
368 | (RSI_WIFI_MGMT_Q << 12)); | |
369 | ||
370 | ||
371 | skb_put(skb, (sizeof(struct rsi_radio_caps))); | |
372 | ||
373 | return rsi_send_internal_mgmt_frame(common, skb); | |
374 | } | |
375 | ||
376 | /** | |
377 | * rsi_mgmt_pkt_to_core() - This function is the entry point for Mgmt module. | |
378 | * @common: Pointer to the driver private structure. | |
379 | * @msg: Pointer to received packet. | |
380 | * @msg_len: Length of the recieved packet. | |
381 | * @type: Type of recieved packet. | |
382 | * | |
383 | * Return: 0 on success, -1 on failure. | |
384 | */ | |
385 | static int rsi_mgmt_pkt_to_core(struct rsi_common *common, | |
386 | u8 *msg, | |
387 | s32 msg_len, | |
388 | u8 type) | |
389 | { | |
390 | struct rsi_hw *adapter = common->priv; | |
391 | struct ieee80211_tx_info *info; | |
392 | struct skb_info *rx_params; | |
393 | u8 pad_bytes = msg[4]; | |
394 | u8 pkt_recv; | |
395 | struct sk_buff *skb; | |
396 | char *buffer; | |
397 | ||
398 | if (type == RX_DOT11_MGMT) { | |
399 | if (!adapter->sc_nvifs) | |
400 | return -ENOLINK; | |
401 | ||
402 | msg_len -= pad_bytes; | |
403 | if ((msg_len <= 0) || (!msg)) { | |
5fe1b76a JP |
404 | rsi_dbg(MGMT_RX_ZONE, |
405 | "%s: Invalid rx msg of len = %d\n", | |
dad0d04f FF |
406 | __func__, msg_len); |
407 | return -EINVAL; | |
408 | } | |
409 | ||
410 | skb = dev_alloc_skb(msg_len); | |
411 | if (!skb) { | |
412 | rsi_dbg(ERR_ZONE, "%s: Failed to allocate skb\n", | |
413 | __func__); | |
414 | return -ENOMEM; | |
415 | } | |
416 | ||
417 | buffer = skb_put(skb, msg_len); | |
418 | ||
419 | memcpy(buffer, | |
420 | (u8 *)(msg + FRAME_DESC_SZ + pad_bytes), | |
421 | msg_len); | |
422 | ||
423 | pkt_recv = buffer[0]; | |
424 | ||
425 | info = IEEE80211_SKB_CB(skb); | |
426 | rx_params = (struct skb_info *)info->driver_data; | |
427 | rx_params->rssi = rsi_get_rssi(msg); | |
428 | rx_params->channel = rsi_get_channel(msg); | |
429 | rsi_indicate_pkt_to_os(common, skb); | |
430 | } else { | |
431 | rsi_dbg(MGMT_TX_ZONE, "%s: Internal Packet\n", __func__); | |
432 | } | |
433 | ||
434 | return 0; | |
435 | } | |
436 | ||
437 | /** | |
438 | * rsi_hal_send_sta_notify_frame() - This function sends the station notify | |
439 | * frame to firmware. | |
440 | * @common: Pointer to the driver private structure. | |
441 | * @opmode: Operating mode of device. | |
442 | * @notify_event: Notification about station connection. | |
443 | * @bssid: bssid. | |
444 | * @qos_enable: Qos is enabled. | |
445 | * @aid: Aid (unique for all STA). | |
446 | * | |
447 | * Return: status: 0 on success, corresponding negative error code on failure. | |
448 | */ | |
449 | static int rsi_hal_send_sta_notify_frame(struct rsi_common *common, | |
450 | u8 opmode, | |
451 | u8 notify_event, | |
452 | const unsigned char *bssid, | |
453 | u8 qos_enable, | |
454 | u16 aid) | |
455 | { | |
456 | struct sk_buff *skb = NULL; | |
457 | struct rsi_peer_notify *peer_notify; | |
458 | u16 vap_id = 0; | |
459 | int status; | |
460 | ||
461 | rsi_dbg(MGMT_TX_ZONE, "%s: Sending sta notify frame\n", __func__); | |
462 | ||
463 | skb = dev_alloc_skb(sizeof(struct rsi_peer_notify)); | |
464 | ||
465 | if (!skb) { | |
466 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n", | |
467 | __func__); | |
468 | return -ENOMEM; | |
469 | } | |
470 | ||
471 | memset(skb->data, 0, sizeof(struct rsi_peer_notify)); | |
472 | peer_notify = (struct rsi_peer_notify *)skb->data; | |
473 | ||
474 | peer_notify->command = cpu_to_le16(opmode << 1); | |
475 | ||
476 | switch (notify_event) { | |
477 | case STA_CONNECTED: | |
478 | peer_notify->command |= cpu_to_le16(RSI_ADD_PEER); | |
479 | break; | |
480 | case STA_DISCONNECTED: | |
481 | peer_notify->command |= cpu_to_le16(RSI_DELETE_PEER); | |
482 | break; | |
483 | default: | |
484 | break; | |
485 | } | |
486 | ||
487 | peer_notify->command |= cpu_to_le16((aid & 0xfff) << 4); | |
488 | ether_addr_copy(peer_notify->mac_addr, bssid); | |
489 | ||
490 | peer_notify->sta_flags = cpu_to_le32((qos_enable) ? 1 : 0); | |
491 | ||
492 | peer_notify->desc_word[0] = | |
493 | cpu_to_le16((sizeof(struct rsi_peer_notify) - FRAME_DESC_SZ) | | |
494 | (RSI_WIFI_MGMT_Q << 12)); | |
495 | peer_notify->desc_word[1] = cpu_to_le16(PEER_NOTIFY); | |
496 | peer_notify->desc_word[7] |= cpu_to_le16(vap_id << 8); | |
497 | ||
498 | skb_put(skb, sizeof(struct rsi_peer_notify)); | |
499 | ||
500 | status = rsi_send_internal_mgmt_frame(common, skb); | |
501 | ||
502 | if (!status && qos_enable) { | |
503 | rsi_set_contention_vals(common); | |
504 | status = rsi_load_radio_caps(common); | |
505 | } | |
506 | return status; | |
507 | } | |
508 | ||
509 | /** | |
510 | * rsi_send_aggregation_params_frame() - This function sends the ampdu | |
511 | * indication frame to firmware. | |
512 | * @common: Pointer to the driver private structure. | |
513 | * @tid: traffic identifier. | |
514 | * @ssn: ssn. | |
515 | * @buf_size: buffer size. | |
516 | * @event: notification about station connection. | |
517 | * | |
518 | * Return: 0 on success, corresponding negative error code on failure. | |
519 | */ | |
520 | int rsi_send_aggregation_params_frame(struct rsi_common *common, | |
521 | u16 tid, | |
522 | u16 ssn, | |
523 | u8 buf_size, | |
524 | u8 event) | |
525 | { | |
526 | struct sk_buff *skb = NULL; | |
527 | struct rsi_mac_frame *mgmt_frame; | |
528 | u8 peer_id = 0; | |
529 | ||
530 | skb = dev_alloc_skb(FRAME_DESC_SZ); | |
531 | ||
532 | if (!skb) { | |
533 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n", | |
534 | __func__); | |
535 | return -ENOMEM; | |
536 | } | |
537 | ||
538 | memset(skb->data, 0, FRAME_DESC_SZ); | |
539 | mgmt_frame = (struct rsi_mac_frame *)skb->data; | |
540 | ||
541 | rsi_dbg(MGMT_TX_ZONE, "%s: Sending AMPDU indication frame\n", __func__); | |
542 | ||
543 | mgmt_frame->desc_word[0] = cpu_to_le16(RSI_WIFI_MGMT_Q << 12); | |
544 | mgmt_frame->desc_word[1] = cpu_to_le16(AMPDU_IND); | |
545 | ||
546 | if (event == STA_TX_ADDBA_DONE) { | |
547 | mgmt_frame->desc_word[4] = cpu_to_le16(ssn); | |
548 | mgmt_frame->desc_word[5] = cpu_to_le16(buf_size); | |
549 | mgmt_frame->desc_word[7] = | |
550 | cpu_to_le16((tid | (START_AMPDU_AGGR << 4) | (peer_id << 8))); | |
551 | } else if (event == STA_RX_ADDBA_DONE) { | |
552 | mgmt_frame->desc_word[4] = cpu_to_le16(ssn); | |
553 | mgmt_frame->desc_word[7] = cpu_to_le16(tid | | |
554 | (START_AMPDU_AGGR << 4) | | |
555 | (RX_BA_INDICATION << 5) | | |
556 | (peer_id << 8)); | |
557 | } else if (event == STA_TX_DELBA) { | |
558 | mgmt_frame->desc_word[7] = cpu_to_le16(tid | | |
559 | (STOP_AMPDU_AGGR << 4) | | |
560 | (peer_id << 8)); | |
561 | } else if (event == STA_RX_DELBA) { | |
562 | mgmt_frame->desc_word[7] = cpu_to_le16(tid | | |
563 | (STOP_AMPDU_AGGR << 4) | | |
564 | (RX_BA_INDICATION << 5) | | |
565 | (peer_id << 8)); | |
566 | } | |
567 | ||
568 | skb_put(skb, FRAME_DESC_SZ); | |
569 | ||
570 | return rsi_send_internal_mgmt_frame(common, skb); | |
571 | } | |
572 | ||
573 | /** | |
574 | * rsi_program_bb_rf() - This function starts base band and RF programming. | |
575 | * This is called after initial configurations are done. | |
576 | * @common: Pointer to the driver private structure. | |
577 | * | |
578 | * Return: 0 on success, corresponding negative error code on failure. | |
579 | */ | |
580 | static int rsi_program_bb_rf(struct rsi_common *common) | |
581 | { | |
582 | struct sk_buff *skb; | |
583 | struct rsi_mac_frame *mgmt_frame; | |
584 | ||
585 | rsi_dbg(MGMT_TX_ZONE, "%s: Sending program BB/RF frame\n", __func__); | |
586 | ||
587 | skb = dev_alloc_skb(FRAME_DESC_SZ); | |
588 | if (!skb) { | |
589 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n", | |
590 | __func__); | |
591 | return -ENOMEM; | |
592 | } | |
593 | ||
594 | memset(skb->data, 0, FRAME_DESC_SZ); | |
595 | mgmt_frame = (struct rsi_mac_frame *)skb->data; | |
596 | ||
597 | mgmt_frame->desc_word[0] = cpu_to_le16(RSI_WIFI_MGMT_Q << 12); | |
598 | mgmt_frame->desc_word[1] = cpu_to_le16(BBP_PROG_IN_TA); | |
8701d031 | 599 | mgmt_frame->desc_word[4] = cpu_to_le16(common->endpoint); |
dad0d04f FF |
600 | |
601 | if (common->rf_reset) { | |
602 | mgmt_frame->desc_word[7] = cpu_to_le16(RF_RESET_ENABLE); | |
603 | rsi_dbg(MGMT_TX_ZONE, "%s: ===> RF RESET REQUEST SENT <===\n", | |
604 | __func__); | |
605 | common->rf_reset = 0; | |
606 | } | |
607 | common->bb_rf_prog_count = 1; | |
608 | mgmt_frame->desc_word[7] |= cpu_to_le16(PUT_BBP_RESET | | |
609 | BBP_REG_WRITE | (RSI_RF_TYPE << 4)); | |
610 | skb_put(skb, FRAME_DESC_SZ); | |
611 | ||
612 | return rsi_send_internal_mgmt_frame(common, skb); | |
613 | } | |
614 | ||
615 | /** | |
616 | * rsi_set_vap_capabilities() - This function send vap capability to firmware. | |
617 | * @common: Pointer to the driver private structure. | |
618 | * @opmode: Operating mode of device. | |
619 | * | |
620 | * Return: 0 on success, corresponding negative error code on failure. | |
621 | */ | |
622 | int rsi_set_vap_capabilities(struct rsi_common *common, enum opmode mode) | |
623 | { | |
624 | struct sk_buff *skb = NULL; | |
625 | struct rsi_vap_caps *vap_caps; | |
626 | u16 vap_id = 0; | |
627 | ||
628 | rsi_dbg(MGMT_TX_ZONE, "%s: Sending VAP capabilities frame\n", __func__); | |
629 | ||
630 | skb = dev_alloc_skb(sizeof(struct rsi_vap_caps)); | |
631 | if (!skb) { | |
632 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n", | |
633 | __func__); | |
634 | return -ENOMEM; | |
635 | } | |
636 | ||
637 | memset(skb->data, 0, sizeof(struct rsi_vap_caps)); | |
638 | vap_caps = (struct rsi_vap_caps *)skb->data; | |
639 | ||
640 | vap_caps->desc_word[0] = cpu_to_le16((sizeof(struct rsi_vap_caps) - | |
641 | FRAME_DESC_SZ) | | |
642 | (RSI_WIFI_MGMT_Q << 12)); | |
643 | vap_caps->desc_word[1] = cpu_to_le16(VAP_CAPABILITIES); | |
644 | vap_caps->desc_word[4] = cpu_to_le16(mode | | |
645 | (common->channel_width << 8)); | |
646 | vap_caps->desc_word[7] = cpu_to_le16((vap_id << 8) | | |
647 | (common->mac_id << 4) | | |
648 | common->radio_id); | |
649 | ||
650 | memcpy(vap_caps->mac_addr, common->mac_addr, IEEE80211_ADDR_LEN); | |
651 | vap_caps->keep_alive_period = cpu_to_le16(90); | |
652 | vap_caps->frag_threshold = cpu_to_le16(IEEE80211_MAX_FRAG_THRESHOLD); | |
653 | ||
654 | vap_caps->rts_threshold = cpu_to_le16(common->rts_threshold); | |
655 | vap_caps->default_mgmt_rate = 0; | |
656 | if (conf_is_ht40(&common->priv->hw->conf)) { | |
657 | vap_caps->default_ctrl_rate = | |
658 | cpu_to_le32(RSI_RATE_6 | FULL40M_ENABLE << 16); | |
659 | } else { | |
660 | vap_caps->default_ctrl_rate = cpu_to_le32(RSI_RATE_6); | |
661 | } | |
662 | vap_caps->default_data_rate = 0; | |
663 | vap_caps->beacon_interval = cpu_to_le16(200); | |
664 | vap_caps->dtim_period = cpu_to_le16(4); | |
665 | ||
666 | skb_put(skb, sizeof(*vap_caps)); | |
667 | ||
668 | return rsi_send_internal_mgmt_frame(common, skb); | |
669 | } | |
670 | ||
671 | /** | |
672 | * rsi_hal_load_key() - This function is used to load keys within the firmware. | |
673 | * @common: Pointer to the driver private structure. | |
674 | * @data: Pointer to the key data. | |
675 | * @key_len: Key length to be loaded. | |
676 | * @key_type: Type of key: GROUP/PAIRWISE. | |
677 | * @key_id: Key index. | |
678 | * @cipher: Type of cipher used. | |
679 | * | |
680 | * Return: 0 on success, -1 on failure. | |
681 | */ | |
682 | int rsi_hal_load_key(struct rsi_common *common, | |
683 | u8 *data, | |
684 | u16 key_len, | |
685 | u8 key_type, | |
686 | u8 key_id, | |
687 | u32 cipher) | |
688 | { | |
689 | struct sk_buff *skb = NULL; | |
690 | struct rsi_set_key *set_key; | |
691 | u16 key_descriptor = 0; | |
692 | ||
693 | rsi_dbg(MGMT_TX_ZONE, "%s: Sending load key frame\n", __func__); | |
694 | ||
695 | skb = dev_alloc_skb(sizeof(struct rsi_set_key)); | |
696 | if (!skb) { | |
697 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n", | |
698 | __func__); | |
699 | return -ENOMEM; | |
700 | } | |
701 | ||
702 | memset(skb->data, 0, sizeof(struct rsi_set_key)); | |
703 | set_key = (struct rsi_set_key *)skb->data; | |
704 | ||
705 | if ((cipher == WLAN_CIPHER_SUITE_WEP40) || | |
706 | (cipher == WLAN_CIPHER_SUITE_WEP104)) { | |
707 | key_len += 1; | |
708 | key_descriptor |= BIT(2); | |
709 | if (key_len >= 13) | |
710 | key_descriptor |= BIT(3); | |
711 | } else if (cipher != KEY_TYPE_CLEAR) { | |
712 | key_descriptor |= BIT(4); | |
713 | if (key_type == RSI_PAIRWISE_KEY) | |
714 | key_id = 0; | |
715 | if (cipher == WLAN_CIPHER_SUITE_TKIP) | |
716 | key_descriptor |= BIT(5); | |
717 | } | |
718 | key_descriptor |= (key_type | BIT(13) | (key_id << 14)); | |
719 | ||
720 | set_key->desc_word[0] = cpu_to_le16((sizeof(struct rsi_set_key) - | |
721 | FRAME_DESC_SZ) | | |
722 | (RSI_WIFI_MGMT_Q << 12)); | |
723 | set_key->desc_word[1] = cpu_to_le16(SET_KEY_REQ); | |
724 | set_key->desc_word[4] = cpu_to_le16(key_descriptor); | |
725 | ||
726 | if ((cipher == WLAN_CIPHER_SUITE_WEP40) || | |
727 | (cipher == WLAN_CIPHER_SUITE_WEP104)) { | |
728 | memcpy(&set_key->key[key_id][1], | |
729 | data, | |
730 | key_len * 2); | |
731 | } else { | |
732 | memcpy(&set_key->key[0][0], data, key_len); | |
733 | } | |
734 | ||
735 | memcpy(set_key->tx_mic_key, &data[16], 8); | |
736 | memcpy(set_key->rx_mic_key, &data[24], 8); | |
737 | ||
738 | skb_put(skb, sizeof(struct rsi_set_key)); | |
739 | ||
740 | return rsi_send_internal_mgmt_frame(common, skb); | |
741 | } | |
742 | ||
743 | /* | |
744 | * rsi_load_bootup_params() - This function send bootup params to the firmware. | |
745 | * @common: Pointer to the driver private structure. | |
746 | * | |
747 | * Return: 0 on success, corresponding error code on failure. | |
748 | */ | |
bff37af7 | 749 | static int rsi_load_bootup_params(struct rsi_common *common) |
dad0d04f FF |
750 | { |
751 | struct sk_buff *skb; | |
752 | struct rsi_boot_params *boot_params; | |
753 | ||
754 | rsi_dbg(MGMT_TX_ZONE, "%s: Sending boot params frame\n", __func__); | |
755 | skb = dev_alloc_skb(sizeof(struct rsi_boot_params)); | |
756 | if (!skb) { | |
757 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n", | |
758 | __func__); | |
759 | return -ENOMEM; | |
760 | } | |
761 | ||
762 | memset(skb->data, 0, sizeof(struct rsi_boot_params)); | |
763 | boot_params = (struct rsi_boot_params *)skb->data; | |
764 | ||
765 | rsi_dbg(MGMT_TX_ZONE, "%s:\n", __func__); | |
766 | ||
767 | if (common->channel_width == BW_40MHZ) { | |
768 | memcpy(&boot_params->bootup_params, | |
769 | &boot_params_40, | |
770 | sizeof(struct bootup_params)); | |
771 | rsi_dbg(MGMT_TX_ZONE, "%s: Packet 40MHZ <=== %d\n", __func__, | |
772 | UMAC_CLK_40BW); | |
773 | boot_params->desc_word[7] = cpu_to_le16(UMAC_CLK_40BW); | |
774 | } else { | |
775 | memcpy(&boot_params->bootup_params, | |
776 | &boot_params_20, | |
777 | sizeof(struct bootup_params)); | |
778 | if (boot_params_20.valid != cpu_to_le32(VALID_20)) { | |
779 | boot_params->desc_word[7] = cpu_to_le16(UMAC_CLK_20BW); | |
780 | rsi_dbg(MGMT_TX_ZONE, | |
781 | "%s: Packet 20MHZ <=== %d\n", __func__, | |
782 | UMAC_CLK_20BW); | |
783 | } else { | |
784 | boot_params->desc_word[7] = cpu_to_le16(UMAC_CLK_40MHZ); | |
785 | rsi_dbg(MGMT_TX_ZONE, | |
786 | "%s: Packet 20MHZ <=== %d\n", __func__, | |
787 | UMAC_CLK_40MHZ); | |
788 | } | |
789 | } | |
790 | ||
791 | /** | |
792 | * Bit{0:11} indicates length of the Packet | |
793 | * Bit{12:15} indicates host queue number | |
794 | */ | |
795 | boot_params->desc_word[0] = cpu_to_le16(sizeof(struct bootup_params) | | |
796 | (RSI_WIFI_MGMT_Q << 12)); | |
797 | boot_params->desc_word[1] = cpu_to_le16(BOOTUP_PARAMS_REQUEST); | |
798 | ||
799 | skb_put(skb, sizeof(struct rsi_boot_params)); | |
800 | ||
801 | return rsi_send_internal_mgmt_frame(common, skb); | |
802 | } | |
803 | ||
804 | /** | |
805 | * rsi_send_reset_mac() - This function prepares reset MAC request and sends an | |
806 | * internal management frame to indicate it to firmware. | |
807 | * @common: Pointer to the driver private structure. | |
808 | * | |
809 | * Return: 0 on success, corresponding error code on failure. | |
810 | */ | |
811 | static int rsi_send_reset_mac(struct rsi_common *common) | |
812 | { | |
813 | struct sk_buff *skb; | |
814 | struct rsi_mac_frame *mgmt_frame; | |
815 | ||
816 | rsi_dbg(MGMT_TX_ZONE, "%s: Sending reset MAC frame\n", __func__); | |
817 | ||
818 | skb = dev_alloc_skb(FRAME_DESC_SZ); | |
819 | if (!skb) { | |
820 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n", | |
821 | __func__); | |
822 | return -ENOMEM; | |
823 | } | |
824 | ||
825 | memset(skb->data, 0, FRAME_DESC_SZ); | |
826 | mgmt_frame = (struct rsi_mac_frame *)skb->data; | |
827 | ||
828 | mgmt_frame->desc_word[0] = cpu_to_le16(RSI_WIFI_MGMT_Q << 12); | |
829 | mgmt_frame->desc_word[1] = cpu_to_le16(RESET_MAC_REQ); | |
830 | mgmt_frame->desc_word[4] = cpu_to_le16(RETRY_COUNT << 8); | |
831 | ||
832 | skb_put(skb, FRAME_DESC_SZ); | |
833 | ||
834 | return rsi_send_internal_mgmt_frame(common, skb); | |
835 | } | |
836 | ||
837 | /** | |
838 | * rsi_set_channel() - This function programs the channel. | |
839 | * @common: Pointer to the driver private structure. | |
840 | * @channel: Channel value to be set. | |
841 | * | |
842 | * Return: 0 on success, corresponding error code on failure. | |
843 | */ | |
844 | int rsi_set_channel(struct rsi_common *common, u16 channel) | |
845 | { | |
846 | struct sk_buff *skb = NULL; | |
847 | struct rsi_mac_frame *mgmt_frame; | |
848 | ||
849 | rsi_dbg(MGMT_TX_ZONE, | |
850 | "%s: Sending scan req frame\n", __func__); | |
851 | ||
98ddcbe0 CE |
852 | skb = dev_alloc_skb(FRAME_DESC_SZ); |
853 | if (!skb) { | |
854 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n", | |
855 | __func__); | |
856 | return -ENOMEM; | |
857 | } | |
858 | ||
859 | memset(skb->data, 0, FRAME_DESC_SZ); | |
860 | mgmt_frame = (struct rsi_mac_frame *)skb->data; | |
861 | ||
dad0d04f FF |
862 | mgmt_frame->desc_word[0] = cpu_to_le16(RSI_WIFI_MGMT_Q << 12); |
863 | mgmt_frame->desc_word[1] = cpu_to_le16(SCAN_REQUEST); | |
864 | mgmt_frame->desc_word[4] = cpu_to_le16(channel); | |
865 | ||
866 | mgmt_frame->desc_word[7] = cpu_to_le16(PUT_BBP_RESET | | |
867 | BBP_REG_WRITE | | |
868 | (RSI_RF_TYPE << 4)); | |
869 | ||
870 | mgmt_frame->desc_word[5] = cpu_to_le16(0x01); | |
8701d031 | 871 | mgmt_frame->desc_word[6] = cpu_to_le16(0x12); |
dad0d04f FF |
872 | |
873 | if (common->channel_width == BW_40MHZ) | |
874 | mgmt_frame->desc_word[5] |= cpu_to_le16(0x1 << 8); | |
875 | ||
876 | common->channel = channel; | |
877 | ||
878 | skb_put(skb, FRAME_DESC_SZ); | |
879 | ||
880 | return rsi_send_internal_mgmt_frame(common, skb); | |
881 | } | |
882 | ||
883 | /** | |
884 | * rsi_compare() - This function is used to compare two integers | |
885 | * @a: pointer to the first integer | |
886 | * @b: pointer to the second integer | |
887 | * | |
888 | * Return: 0 if both are equal, -1 if the first is smaller, else 1 | |
889 | */ | |
890 | static int rsi_compare(const void *a, const void *b) | |
891 | { | |
892 | u16 _a = *(const u16 *)(a); | |
893 | u16 _b = *(const u16 *)(b); | |
894 | ||
895 | if (_a > _b) | |
896 | return -1; | |
897 | ||
898 | if (_a < _b) | |
899 | return 1; | |
900 | ||
901 | return 0; | |
902 | } | |
903 | ||
904 | /** | |
905 | * rsi_map_rates() - This function is used to map selected rates to hw rates. | |
906 | * @rate: The standard rate to be mapped. | |
907 | * @offset: Offset that will be returned. | |
908 | * | |
909 | * Return: 0 if it is a mcs rate, else 1 | |
910 | */ | |
911 | static bool rsi_map_rates(u16 rate, int *offset) | |
912 | { | |
913 | int kk; | |
914 | for (kk = 0; kk < ARRAY_SIZE(rsi_mcsrates); kk++) { | |
915 | if (rate == mcs[kk]) { | |
916 | *offset = kk; | |
917 | return false; | |
918 | } | |
919 | } | |
920 | ||
921 | for (kk = 0; kk < ARRAY_SIZE(rsi_rates); kk++) { | |
922 | if (rate == rsi_rates[kk].bitrate / 5) { | |
923 | *offset = kk; | |
924 | break; | |
925 | } | |
926 | } | |
927 | return true; | |
928 | } | |
929 | ||
930 | /** | |
931 | * rsi_send_auto_rate_request() - This function is to set rates for connection | |
932 | * and send autorate request to firmware. | |
933 | * @common: Pointer to the driver private structure. | |
934 | * | |
935 | * Return: 0 on success, corresponding error code on failure. | |
936 | */ | |
937 | static int rsi_send_auto_rate_request(struct rsi_common *common) | |
938 | { | |
939 | struct sk_buff *skb; | |
940 | struct rsi_auto_rate *auto_rate; | |
941 | int ii = 0, jj = 0, kk = 0; | |
942 | struct ieee80211_hw *hw = common->priv->hw; | |
943 | u8 band = hw->conf.chandef.chan->band; | |
944 | u8 num_supported_rates = 0; | |
0d59f526 | 945 | u8 rate_table_offset, rate_offset = 0; |
dad0d04f FF |
946 | u32 rate_bitmap = common->bitrate_mask[band]; |
947 | ||
948 | u16 *selected_rates, min_rate; | |
949 | ||
950 | skb = dev_alloc_skb(sizeof(struct rsi_auto_rate)); | |
951 | if (!skb) { | |
952 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n", | |
953 | __func__); | |
954 | return -ENOMEM; | |
955 | } | |
956 | ||
957 | selected_rates = kmalloc(2 * RSI_TBL_SZ, GFP_KERNEL); | |
958 | if (!selected_rates) { | |
959 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of mem\n", | |
960 | __func__); | |
61698b7e | 961 | dev_kfree_skb(skb); |
dad0d04f FF |
962 | return -ENOMEM; |
963 | } | |
964 | ||
965 | memset(skb->data, 0, sizeof(struct rsi_auto_rate)); | |
966 | memset(selected_rates, 0, 2 * RSI_TBL_SZ); | |
967 | ||
968 | auto_rate = (struct rsi_auto_rate *)skb->data; | |
969 | ||
970 | auto_rate->aarf_rssi = cpu_to_le16(((u16)3 << 6) | (u16)(18 & 0x3f)); | |
971 | auto_rate->collision_tolerance = cpu_to_le16(3); | |
972 | auto_rate->failure_limit = cpu_to_le16(3); | |
973 | auto_rate->initial_boundary = cpu_to_le16(3); | |
974 | auto_rate->max_threshold_limt = cpu_to_le16(27); | |
975 | ||
976 | auto_rate->desc_word[1] = cpu_to_le16(AUTO_RATE_IND); | |
977 | ||
978 | if (common->channel_width == BW_40MHZ) | |
979 | auto_rate->desc_word[7] |= cpu_to_le16(1); | |
980 | ||
0d59f526 JM |
981 | if (band == IEEE80211_BAND_2GHZ) { |
982 | min_rate = RSI_RATE_1; | |
983 | rate_table_offset = 0; | |
984 | } else { | |
985 | min_rate = RSI_RATE_6; | |
986 | rate_table_offset = 4; | |
987 | } | |
dad0d04f FF |
988 | |
989 | for (ii = 0, jj = 0; ii < ARRAY_SIZE(rsi_rates); ii++) { | |
990 | if (rate_bitmap & BIT(ii)) { | |
0d59f526 JM |
991 | selected_rates[jj++] = |
992 | (rsi_rates[ii + rate_table_offset].bitrate / 5); | |
dad0d04f FF |
993 | rate_offset++; |
994 | } | |
995 | } | |
996 | num_supported_rates = jj; | |
997 | ||
998 | if (common->vif_info[0].is_ht) { | |
999 | for (ii = 0; ii < ARRAY_SIZE(mcs); ii++) | |
1000 | selected_rates[jj++] = mcs[ii]; | |
1001 | num_supported_rates += ARRAY_SIZE(mcs); | |
1002 | rate_offset += ARRAY_SIZE(mcs); | |
1003 | } | |
1004 | ||
dad0d04f FF |
1005 | sort(selected_rates, jj, sizeof(u16), &rsi_compare, NULL); |
1006 | ||
1007 | /* mapping the rates to RSI rates */ | |
1008 | for (ii = 0; ii < jj; ii++) { | |
1009 | if (rsi_map_rates(selected_rates[ii], &kk)) { | |
1010 | auto_rate->supported_rates[ii] = | |
1011 | cpu_to_le16(rsi_rates[kk].hw_value); | |
1012 | } else { | |
1013 | auto_rate->supported_rates[ii] = | |
1014 | cpu_to_le16(rsi_mcsrates[kk]); | |
1015 | } | |
1016 | } | |
1017 | ||
1018 | /* loading HT rates in the bottom half of the auto rate table */ | |
1019 | if (common->vif_info[0].is_ht) { | |
dad0d04f FF |
1020 | for (ii = rate_offset, kk = ARRAY_SIZE(rsi_mcsrates) - 1; |
1021 | ii < rate_offset + 2 * ARRAY_SIZE(rsi_mcsrates); ii++) { | |
0d59f526 JM |
1022 | if (common->vif_info[0].sgi || |
1023 | conf_is_ht40(&common->priv->hw->conf)) | |
dad0d04f FF |
1024 | auto_rate->supported_rates[ii++] = |
1025 | cpu_to_le16(rsi_mcsrates[kk] | BIT(9)); | |
1026 | auto_rate->supported_rates[ii] = | |
1027 | cpu_to_le16(rsi_mcsrates[kk--]); | |
1028 | } | |
1029 | ||
0d59f526 | 1030 | for (; ii < (RSI_TBL_SZ - 1); ii++) { |
dad0d04f FF |
1031 | auto_rate->supported_rates[ii] = |
1032 | cpu_to_le16(rsi_mcsrates[0]); | |
1033 | } | |
1034 | } | |
1035 | ||
0d59f526 JM |
1036 | for (; ii < RSI_TBL_SZ; ii++) |
1037 | auto_rate->supported_rates[ii] = min_rate; | |
1038 | ||
dad0d04f FF |
1039 | auto_rate->num_supported_rates = cpu_to_le16(num_supported_rates * 2); |
1040 | auto_rate->moderate_rate_inx = cpu_to_le16(num_supported_rates / 2); | |
1041 | auto_rate->desc_word[7] |= cpu_to_le16(0 << 8); | |
1042 | num_supported_rates *= 2; | |
1043 | ||
1044 | auto_rate->desc_word[0] = cpu_to_le16((sizeof(*auto_rate) - | |
1045 | FRAME_DESC_SZ) | | |
1046 | (RSI_WIFI_MGMT_Q << 12)); | |
1047 | ||
1048 | skb_put(skb, | |
1049 | sizeof(struct rsi_auto_rate)); | |
1050 | kfree(selected_rates); | |
1051 | ||
1052 | return rsi_send_internal_mgmt_frame(common, skb); | |
1053 | } | |
1054 | ||
1055 | /** | |
1056 | * rsi_inform_bss_status() - This function informs about bss status with the | |
1057 | * help of sta notify params by sending an internal | |
1058 | * management frame to firmware. | |
1059 | * @common: Pointer to the driver private structure. | |
1060 | * @status: Bss status type. | |
1061 | * @bssid: Bssid. | |
1062 | * @qos_enable: Qos is enabled. | |
1063 | * @aid: Aid (unique for all STAs). | |
1064 | * | |
1065 | * Return: None. | |
1066 | */ | |
1067 | void rsi_inform_bss_status(struct rsi_common *common, | |
1068 | u8 status, | |
1069 | const unsigned char *bssid, | |
1070 | u8 qos_enable, | |
1071 | u16 aid) | |
1072 | { | |
1073 | if (status) { | |
1074 | rsi_hal_send_sta_notify_frame(common, | |
48d11dc3 | 1075 | RSI_IFTYPE_STATION, |
dad0d04f FF |
1076 | STA_CONNECTED, |
1077 | bssid, | |
1078 | qos_enable, | |
1079 | aid); | |
1080 | if (common->min_rate == 0xffff) | |
1081 | rsi_send_auto_rate_request(common); | |
1082 | } else { | |
1083 | rsi_hal_send_sta_notify_frame(common, | |
48d11dc3 | 1084 | RSI_IFTYPE_STATION, |
dad0d04f FF |
1085 | STA_DISCONNECTED, |
1086 | bssid, | |
1087 | qos_enable, | |
1088 | aid); | |
1089 | } | |
1090 | } | |
1091 | ||
1092 | /** | |
1093 | * rsi_eeprom_read() - This function sends a frame to read the mac address | |
1094 | * from the eeprom. | |
1095 | * @common: Pointer to the driver private structure. | |
1096 | * | |
1097 | * Return: 0 on success, -1 on failure. | |
1098 | */ | |
1099 | static int rsi_eeprom_read(struct rsi_common *common) | |
1100 | { | |
1101 | struct rsi_mac_frame *mgmt_frame; | |
1102 | struct sk_buff *skb; | |
1103 | ||
1104 | rsi_dbg(MGMT_TX_ZONE, "%s: Sending EEPROM read req frame\n", __func__); | |
1105 | ||
1106 | skb = dev_alloc_skb(FRAME_DESC_SZ); | |
1107 | if (!skb) { | |
1108 | rsi_dbg(ERR_ZONE, "%s: Failed in allocation of skb\n", | |
1109 | __func__); | |
1110 | return -ENOMEM; | |
1111 | } | |
1112 | ||
1113 | memset(skb->data, 0, FRAME_DESC_SZ); | |
1114 | mgmt_frame = (struct rsi_mac_frame *)skb->data; | |
1115 | ||
1116 | /* FrameType */ | |
1117 | mgmt_frame->desc_word[1] = cpu_to_le16(EEPROM_READ_TYPE); | |
1118 | mgmt_frame->desc_word[0] = cpu_to_le16(RSI_WIFI_MGMT_Q << 12); | |
1119 | /* Number of bytes to read */ | |
1120 | mgmt_frame->desc_word[3] = cpu_to_le16(ETH_ALEN + | |
1121 | WLAN_MAC_MAGIC_WORD_LEN + | |
1122 | WLAN_HOST_MODE_LEN + | |
1123 | WLAN_FW_VERSION_LEN); | |
1124 | /* Address to read */ | |
1125 | mgmt_frame->desc_word[4] = cpu_to_le16(WLAN_MAC_EEPROM_ADDR); | |
1126 | ||
1127 | skb_put(skb, FRAME_DESC_SZ); | |
1128 | ||
1129 | return rsi_send_internal_mgmt_frame(common, skb); | |
1130 | } | |
1131 | ||
1132 | /** | |
1133 | * rsi_handle_ta_confirm_type() - This function handles the confirm frames. | |
1134 | * @common: Pointer to the driver private structure. | |
1135 | * @msg: Pointer to received packet. | |
1136 | * | |
1137 | * Return: 0 on success, -1 on failure. | |
1138 | */ | |
1139 | static int rsi_handle_ta_confirm_type(struct rsi_common *common, | |
1140 | u8 *msg) | |
1141 | { | |
1142 | u8 sub_type = (msg[15] & 0xff); | |
1143 | ||
1144 | switch (sub_type) { | |
1145 | case BOOTUP_PARAMS_REQUEST: | |
1146 | rsi_dbg(FSM_ZONE, "%s: Boot up params confirm received\n", | |
1147 | __func__); | |
1148 | if (common->fsm_state == FSM_BOOT_PARAMS_SENT) { | |
1149 | if (rsi_eeprom_read(common)) { | |
1150 | common->fsm_state = FSM_CARD_NOT_READY; | |
1151 | goto out; | |
1152 | } else { | |
1153 | common->fsm_state = FSM_EEPROM_READ_MAC_ADDR; | |
1154 | } | |
1155 | } else { | |
1156 | rsi_dbg(ERR_ZONE, | |
1157 | "%s: Received bootup params cfm in %d state\n", | |
1158 | __func__, common->fsm_state); | |
1159 | return 0; | |
1160 | } | |
1161 | break; | |
1162 | ||
1163 | case EEPROM_READ_TYPE: | |
1164 | if (common->fsm_state == FSM_EEPROM_READ_MAC_ADDR) { | |
1165 | if (msg[16] == MAGIC_WORD) { | |
1166 | u8 offset = (FRAME_DESC_SZ + WLAN_HOST_MODE_LEN | |
1167 | + WLAN_MAC_MAGIC_WORD_LEN); | |
1168 | memcpy(common->mac_addr, | |
1169 | &msg[offset], | |
1170 | ETH_ALEN); | |
1171 | memcpy(&common->fw_ver, | |
1172 | &msg[offset + ETH_ALEN], | |
1173 | sizeof(struct version_info)); | |
1174 | ||
1175 | } else { | |
1176 | common->fsm_state = FSM_CARD_NOT_READY; | |
1177 | break; | |
1178 | } | |
1179 | if (rsi_send_reset_mac(common)) | |
1180 | goto out; | |
1181 | else | |
1182 | common->fsm_state = FSM_RESET_MAC_SENT; | |
1183 | } else { | |
1184 | rsi_dbg(ERR_ZONE, | |
1185 | "%s: Received eeprom mac addr in %d state\n", | |
1186 | __func__, common->fsm_state); | |
1187 | return 0; | |
1188 | } | |
1189 | break; | |
1190 | ||
1191 | case RESET_MAC_REQ: | |
1192 | if (common->fsm_state == FSM_RESET_MAC_SENT) { | |
1193 | rsi_dbg(FSM_ZONE, "%s: Reset MAC cfm received\n", | |
1194 | __func__); | |
1195 | ||
1196 | if (rsi_load_radio_caps(common)) | |
1197 | goto out; | |
1198 | else | |
1199 | common->fsm_state = FSM_RADIO_CAPS_SENT; | |
1200 | } else { | |
1201 | rsi_dbg(ERR_ZONE, | |
1202 | "%s: Received reset mac cfm in %d state\n", | |
1203 | __func__, common->fsm_state); | |
1204 | return 0; | |
1205 | } | |
1206 | break; | |
1207 | ||
1208 | case RADIO_CAPABILITIES: | |
1209 | if (common->fsm_state == FSM_RADIO_CAPS_SENT) { | |
1210 | common->rf_reset = 1; | |
1211 | if (rsi_program_bb_rf(common)) { | |
1212 | goto out; | |
1213 | } else { | |
1214 | common->fsm_state = FSM_BB_RF_PROG_SENT; | |
1215 | rsi_dbg(FSM_ZONE, "%s: Radio cap cfm received\n", | |
1216 | __func__); | |
1217 | } | |
1218 | } else { | |
1219 | rsi_dbg(ERR_ZONE, | |
1220 | "%s: Received radio caps cfm in %d state\n", | |
1221 | __func__, common->fsm_state); | |
1222 | return 0; | |
1223 | } | |
1224 | break; | |
1225 | ||
1226 | case BB_PROG_VALUES_REQUEST: | |
1227 | case RF_PROG_VALUES_REQUEST: | |
1228 | case BBP_PROG_IN_TA: | |
1229 | rsi_dbg(FSM_ZONE, "%s: BB/RF cfm received\n", __func__); | |
1230 | if (common->fsm_state == FSM_BB_RF_PROG_SENT) { | |
1231 | common->bb_rf_prog_count--; | |
1232 | if (!common->bb_rf_prog_count) { | |
1233 | common->fsm_state = FSM_MAC_INIT_DONE; | |
1234 | return rsi_mac80211_attach(common); | |
1235 | } | |
1236 | } else { | |
1237 | goto out; | |
1238 | } | |
1239 | break; | |
1240 | ||
1241 | default: | |
1242 | rsi_dbg(INFO_ZONE, "%s: Invalid TA confirm pkt received\n", | |
1243 | __func__); | |
1244 | break; | |
1245 | } | |
1246 | return 0; | |
1247 | out: | |
1248 | rsi_dbg(ERR_ZONE, "%s: Unable to send pkt/Invalid frame received\n", | |
1249 | __func__); | |
1250 | return -EINVAL; | |
1251 | } | |
1252 | ||
1253 | /** | |
1254 | * rsi_mgmt_pkt_recv() - This function processes the management packets | |
1255 | * recieved from the hardware. | |
1256 | * @common: Pointer to the driver private structure. | |
1257 | * @msg: Pointer to the received packet. | |
1258 | * | |
1259 | * Return: 0 on success, -1 on failure. | |
1260 | */ | |
1261 | int rsi_mgmt_pkt_recv(struct rsi_common *common, u8 *msg) | |
1262 | { | |
1263 | s32 msg_len = (le16_to_cpu(*(__le16 *)&msg[0]) & 0x0fff); | |
1264 | u16 msg_type = (msg[2]); | |
bff37af7 | 1265 | int ret; |
dad0d04f FF |
1266 | |
1267 | rsi_dbg(FSM_ZONE, "%s: Msg Len: %d, Msg Type: %4x\n", | |
1268 | __func__, msg_len, msg_type); | |
1269 | ||
1270 | if (msg_type == TA_CONFIRM_TYPE) { | |
1271 | return rsi_handle_ta_confirm_type(common, msg); | |
1272 | } else if (msg_type == CARD_READY_IND) { | |
1273 | rsi_dbg(FSM_ZONE, "%s: Card ready indication received\n", | |
1274 | __func__); | |
1275 | if (common->fsm_state == FSM_CARD_NOT_READY) { | |
1276 | rsi_set_default_parameters(common); | |
1277 | ||
bff37af7 FF |
1278 | ret = rsi_load_bootup_params(common); |
1279 | if (ret) | |
1280 | return ret; | |
dad0d04f FF |
1281 | else |
1282 | common->fsm_state = FSM_BOOT_PARAMS_SENT; | |
1283 | } else { | |
1284 | return -EINVAL; | |
1285 | } | |
1286 | } else if (msg_type == TX_STATUS_IND) { | |
3f3aa2fb | 1287 | if (msg[15] == PROBEREQ_CONFIRM) { |
dad0d04f FF |
1288 | common->mgmt_q_block = false; |
1289 | rsi_dbg(FSM_ZONE, "%s: Probe confirm received\n", | |
1290 | __func__); | |
3f3aa2fb | 1291 | } |
dad0d04f FF |
1292 | } else { |
1293 | return rsi_mgmt_pkt_to_core(common, msg, msg_len, msg_type); | |
1294 | } | |
1295 | return 0; | |
1296 | } |