2 * Marvell Wireless LAN device driver: association and ad-hoc start/join
4 * Copyright (C) 2011-2014, Marvell International Ltd.
6 * This software file (the "File") is distributed by Marvell International
7 * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8 * (the "License"). You may use, redistribute and/or modify this File in
9 * accordance with the terms and conditions of the License, a copy of which
10 * is available by writing to the Free Software Foundation, Inc.,
11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12 * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
14 * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16 * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
17 * this warranty disclaimer.
29 #define CAPINFO_MASK (~(BIT(15) | BIT(14) | BIT(12) | BIT(11) | BIT(9)))
32 * Append a generic IE as a pass through TLV to a TLV buffer.
34 * This function is called from the network join command preparation routine.
36 * If the IE buffer has been setup by the application, this routine appends
37 * the buffer as a pass through TLV type to the request.
40 mwifiex_cmd_append_generic_ie(struct mwifiex_private
*priv
, u8
**buffer
)
43 struct mwifiex_ie_types_header ie_header
;
52 * If there is a generic ie buffer setup, append it to the return
53 * parameter buffer pointer.
55 if (priv
->gen_ie_buf_len
) {
56 dev_dbg(priv
->adapter
->dev
,
57 "info: %s: append generic ie len %d to %p\n",
58 __func__
, priv
->gen_ie_buf_len
, *buffer
);
60 /* Wrap the generic IE buffer with a pass through TLV type */
61 ie_header
.type
= cpu_to_le16(TLV_TYPE_PASSTHROUGH
);
62 ie_header
.len
= cpu_to_le16(priv
->gen_ie_buf_len
);
63 memcpy(*buffer
, &ie_header
, sizeof(ie_header
));
65 /* Increment the return size and the return buffer pointer
67 *buffer
+= sizeof(ie_header
);
68 ret_len
+= sizeof(ie_header
);
70 /* Copy the generic IE buffer to the output buffer, advance
72 memcpy(*buffer
, priv
->gen_ie_buf
, priv
->gen_ie_buf_len
);
74 /* Increment the return size and the return buffer pointer
76 *buffer
+= priv
->gen_ie_buf_len
;
77 ret_len
+= priv
->gen_ie_buf_len
;
79 /* Reset the generic IE buffer */
80 priv
->gen_ie_buf_len
= 0;
83 /* return the length appended to the buffer */
88 * Append TSF tracking info from the scan table for the target AP.
90 * This function is called from the network join command preparation routine.
92 * The TSF table TSF sent to the firmware contains two TSF values:
93 * - The TSF of the target AP from its previous beacon/probe response
94 * - The TSF timestamp of our local MAC at the time we observed the
95 * beacon/probe response.
97 * The firmware uses the timestamp values to set an initial TSF value
98 * in the MAC for the new association after a reassociation attempt.
101 mwifiex_cmd_append_tsf_tlv(struct mwifiex_private
*priv
, u8
**buffer
,
102 struct mwifiex_bssdescriptor
*bss_desc
)
104 struct mwifiex_ie_types_tsf_timestamp tsf_tlv
;
113 memset(&tsf_tlv
, 0x00, sizeof(struct mwifiex_ie_types_tsf_timestamp
));
115 tsf_tlv
.header
.type
= cpu_to_le16(TLV_TYPE_TSFTIMESTAMP
);
116 tsf_tlv
.header
.len
= cpu_to_le16(2 * sizeof(tsf_val
));
118 memcpy(*buffer
, &tsf_tlv
, sizeof(tsf_tlv
.header
));
119 *buffer
+= sizeof(tsf_tlv
.header
);
121 /* TSF at the time when beacon/probe_response was received */
122 tsf_val
= cpu_to_le64(bss_desc
->fw_tsf
);
123 memcpy(*buffer
, &tsf_val
, sizeof(tsf_val
));
124 *buffer
+= sizeof(tsf_val
);
126 tsf_val
= cpu_to_le64(bss_desc
->timestamp
);
128 dev_dbg(priv
->adapter
->dev
,
129 "info: %s: TSF offset calc: %016llx - %016llx\n",
130 __func__
, bss_desc
->timestamp
, bss_desc
->fw_tsf
);
132 memcpy(*buffer
, &tsf_val
, sizeof(tsf_val
));
133 *buffer
+= sizeof(tsf_val
);
135 return sizeof(tsf_tlv
.header
) + (2 * sizeof(tsf_val
));
139 * This function finds out the common rates between rate1 and rate2.
141 * It will fill common rates in rate1 as output if found.
143 * NOTE: Setting the MSB of the basic rates needs to be taken
144 * care of, either before or after calling this function.
146 static int mwifiex_get_common_rates(struct mwifiex_private
*priv
, u8
*rate1
,
147 u32 rate1_size
, u8
*rate2
, u32 rate2_size
)
150 u8
*ptr
= rate1
, *tmp
;
153 tmp
= kmemdup(rate1
, rate1_size
, GFP_KERNEL
);
155 dev_err(priv
->adapter
->dev
, "failed to alloc tmp buf\n");
159 memset(rate1
, 0, rate1_size
);
161 for (i
= 0; i
< rate2_size
&& rate2
[i
]; i
++) {
162 for (j
= 0; j
< rate1_size
&& tmp
[j
]; j
++) {
163 /* Check common rate, excluding the bit for
165 if ((rate2
[i
] & 0x7F) == (tmp
[j
] & 0x7F)) {
172 dev_dbg(priv
->adapter
->dev
, "info: Tx data rate set to %#x\n",
175 if (!priv
->is_data_rate_auto
) {
177 if ((*ptr
& 0x7f) == priv
->data_rate
) {
183 dev_err(priv
->adapter
->dev
, "previously set fixed data rate %#x"
184 " is not compatible with the network\n",
198 * This function creates the intersection of the rates supported by a
199 * target BSS and our adapter settings for use in an assoc/join command.
202 mwifiex_setup_rates_from_bssdesc(struct mwifiex_private
*priv
,
203 struct mwifiex_bssdescriptor
*bss_desc
,
204 u8
*out_rates
, u32
*out_rates_size
)
206 u8 card_rates
[MWIFIEX_SUPPORTED_RATES
];
209 /* Copy AP supported rates */
210 memcpy(out_rates
, bss_desc
->supported_rates
, MWIFIEX_SUPPORTED_RATES
);
211 /* Get the STA supported rates */
212 card_rates_size
= mwifiex_get_active_data_rates(priv
, card_rates
);
213 /* Get the common rates between AP and STA supported rates */
214 if (mwifiex_get_common_rates(priv
, out_rates
, MWIFIEX_SUPPORTED_RATES
,
215 card_rates
, card_rates_size
)) {
217 dev_err(priv
->adapter
->dev
, "%s: cannot get common rates\n",
223 min_t(size_t, strlen(out_rates
), MWIFIEX_SUPPORTED_RATES
);
229 * This function appends a WPS IE. It is called from the network join command
230 * preparation routine.
232 * If the IE buffer has been setup by the application, this routine appends
233 * the buffer as a WPS TLV type to the request.
236 mwifiex_cmd_append_wps_ie(struct mwifiex_private
*priv
, u8
**buffer
)
239 struct mwifiex_ie_types_header ie_header
;
241 if (!buffer
|| !*buffer
)
245 * If there is a wps ie buffer setup, append it to the return
246 * parameter buffer pointer.
248 if (priv
->wps_ie_len
) {
249 dev_dbg(priv
->adapter
->dev
, "cmd: append wps ie %d to %p\n",
250 priv
->wps_ie_len
, *buffer
);
252 /* Wrap the generic IE buffer with a pass through TLV type */
253 ie_header
.type
= cpu_to_le16(TLV_TYPE_MGMT_IE
);
254 ie_header
.len
= cpu_to_le16(priv
->wps_ie_len
);
255 memcpy(*buffer
, &ie_header
, sizeof(ie_header
));
256 *buffer
+= sizeof(ie_header
);
257 retLen
+= sizeof(ie_header
);
259 memcpy(*buffer
, priv
->wps_ie
, priv
->wps_ie_len
);
260 *buffer
+= priv
->wps_ie_len
;
261 retLen
+= priv
->wps_ie_len
;
266 priv
->wps_ie_len
= 0;
271 * This function appends a WAPI IE.
273 * This function is called from the network join command preparation routine.
275 * If the IE buffer has been setup by the application, this routine appends
276 * the buffer as a WAPI TLV type to the request.
279 mwifiex_cmd_append_wapi_ie(struct mwifiex_private
*priv
, u8
**buffer
)
282 struct mwifiex_ie_types_header ie_header
;
291 * If there is a wapi ie buffer setup, append it to the return
292 * parameter buffer pointer.
294 if (priv
->wapi_ie_len
) {
295 dev_dbg(priv
->adapter
->dev
, "cmd: append wapi ie %d to %p\n",
296 priv
->wapi_ie_len
, *buffer
);
298 /* Wrap the generic IE buffer with a pass through TLV type */
299 ie_header
.type
= cpu_to_le16(TLV_TYPE_WAPI_IE
);
300 ie_header
.len
= cpu_to_le16(priv
->wapi_ie_len
);
301 memcpy(*buffer
, &ie_header
, sizeof(ie_header
));
303 /* Increment the return size and the return buffer pointer
305 *buffer
+= sizeof(ie_header
);
306 retLen
+= sizeof(ie_header
);
308 /* Copy the wapi IE buffer to the output buffer, advance
310 memcpy(*buffer
, priv
->wapi_ie
, priv
->wapi_ie_len
);
312 /* Increment the return size and the return buffer pointer
314 *buffer
+= priv
->wapi_ie_len
;
315 retLen
+= priv
->wapi_ie_len
;
318 /* return the length appended to the buffer */
323 * This function appends rsn ie tlv for wpa/wpa2 security modes.
324 * It is called from the network join command preparation routine.
326 static int mwifiex_append_rsn_ie_wpa_wpa2(struct mwifiex_private
*priv
,
329 struct mwifiex_ie_types_rsn_param_set
*rsn_ie_tlv
;
332 if (!buffer
|| !(*buffer
))
335 rsn_ie_tlv
= (struct mwifiex_ie_types_rsn_param_set
*) (*buffer
);
336 rsn_ie_tlv
->header
.type
= cpu_to_le16((u16
) priv
->wpa_ie
[0]);
337 rsn_ie_tlv
->header
.type
= cpu_to_le16(
338 le16_to_cpu(rsn_ie_tlv
->header
.type
) & 0x00FF);
339 rsn_ie_tlv
->header
.len
= cpu_to_le16((u16
) priv
->wpa_ie
[1]);
340 rsn_ie_tlv
->header
.len
= cpu_to_le16(le16_to_cpu(rsn_ie_tlv
->header
.len
)
342 if (le16_to_cpu(rsn_ie_tlv
->header
.len
) <= (sizeof(priv
->wpa_ie
) - 2))
343 memcpy(rsn_ie_tlv
->rsn_ie
, &priv
->wpa_ie
[2],
344 le16_to_cpu(rsn_ie_tlv
->header
.len
));
348 rsn_ie_len
= sizeof(rsn_ie_tlv
->header
) +
349 le16_to_cpu(rsn_ie_tlv
->header
.len
);
350 *buffer
+= rsn_ie_len
;
356 * This function prepares command for association.
358 * This sets the following parameters -
362 * - Capability information
364 * ...and the following TLVs, as required -
369 * - Authentication TLV
373 * - Vendor specific TLV
379 * Preparation also includes -
380 * - Setting command ID and proper size
381 * - Ensuring correct endian-ness
383 int mwifiex_cmd_802_11_associate(struct mwifiex_private
*priv
,
384 struct host_cmd_ds_command
*cmd
,
385 struct mwifiex_bssdescriptor
*bss_desc
)
387 struct host_cmd_ds_802_11_associate
*assoc
= &cmd
->params
.associate
;
388 struct mwifiex_ie_types_ssid_param_set
*ssid_tlv
;
389 struct mwifiex_ie_types_phy_param_set
*phy_tlv
;
390 struct mwifiex_ie_types_ss_param_set
*ss_tlv
;
391 struct mwifiex_ie_types_rates_param_set
*rates_tlv
;
392 struct mwifiex_ie_types_auth_type
*auth_tlv
;
393 struct mwifiex_ie_types_chan_list_param_set
*chan_tlv
;
394 u8 rates
[MWIFIEX_SUPPORTED_RATES
];
402 cmd
->command
= cpu_to_le16(HostCmd_CMD_802_11_ASSOCIATE
);
404 /* Save so we know which BSS Desc to use in the response handler */
405 priv
->attempted_bss_desc
= bss_desc
;
407 memcpy(assoc
->peer_sta_addr
,
408 bss_desc
->mac_address
, sizeof(assoc
->peer_sta_addr
));
409 pos
+= sizeof(assoc
->peer_sta_addr
);
411 /* Set the listen interval */
412 assoc
->listen_interval
= cpu_to_le16(priv
->listen_interval
);
413 /* Set the beacon period */
414 assoc
->beacon_period
= cpu_to_le16(bss_desc
->beacon_period
);
416 pos
+= sizeof(assoc
->cap_info_bitmap
);
417 pos
+= sizeof(assoc
->listen_interval
);
418 pos
+= sizeof(assoc
->beacon_period
);
419 pos
+= sizeof(assoc
->dtim_period
);
421 ssid_tlv
= (struct mwifiex_ie_types_ssid_param_set
*) pos
;
422 ssid_tlv
->header
.type
= cpu_to_le16(WLAN_EID_SSID
);
423 ssid_tlv
->header
.len
= cpu_to_le16((u16
) bss_desc
->ssid
.ssid_len
);
424 memcpy(ssid_tlv
->ssid
, bss_desc
->ssid
.ssid
,
425 le16_to_cpu(ssid_tlv
->header
.len
));
426 pos
+= sizeof(ssid_tlv
->header
) + le16_to_cpu(ssid_tlv
->header
.len
);
428 phy_tlv
= (struct mwifiex_ie_types_phy_param_set
*) pos
;
429 phy_tlv
->header
.type
= cpu_to_le16(WLAN_EID_DS_PARAMS
);
430 phy_tlv
->header
.len
= cpu_to_le16(sizeof(phy_tlv
->fh_ds
.ds_param_set
));
431 memcpy(&phy_tlv
->fh_ds
.ds_param_set
,
432 &bss_desc
->phy_param_set
.ds_param_set
.current_chan
,
433 sizeof(phy_tlv
->fh_ds
.ds_param_set
));
434 pos
+= sizeof(phy_tlv
->header
) + le16_to_cpu(phy_tlv
->header
.len
);
436 ss_tlv
= (struct mwifiex_ie_types_ss_param_set
*) pos
;
437 ss_tlv
->header
.type
= cpu_to_le16(WLAN_EID_CF_PARAMS
);
438 ss_tlv
->header
.len
= cpu_to_le16(sizeof(ss_tlv
->cf_ibss
.cf_param_set
));
439 pos
+= sizeof(ss_tlv
->header
) + le16_to_cpu(ss_tlv
->header
.len
);
441 /* Get the common rates supported between the driver and the BSS Desc */
442 if (mwifiex_setup_rates_from_bssdesc
443 (priv
, bss_desc
, rates
, &rates_size
))
446 /* Save the data rates into Current BSS state structure */
447 priv
->curr_bss_params
.num_of_rates
= rates_size
;
448 memcpy(&priv
->curr_bss_params
.data_rates
, rates
, rates_size
);
450 /* Setup the Rates TLV in the association command */
451 rates_tlv
= (struct mwifiex_ie_types_rates_param_set
*) pos
;
452 rates_tlv
->header
.type
= cpu_to_le16(WLAN_EID_SUPP_RATES
);
453 rates_tlv
->header
.len
= cpu_to_le16((u16
) rates_size
);
454 memcpy(rates_tlv
->rates
, rates
, rates_size
);
455 pos
+= sizeof(rates_tlv
->header
) + rates_size
;
456 dev_dbg(priv
->adapter
->dev
, "info: ASSOC_CMD: rates size = %d\n",
459 /* Add the Authentication type to be used for Auth frames */
460 auth_tlv
= (struct mwifiex_ie_types_auth_type
*) pos
;
461 auth_tlv
->header
.type
= cpu_to_le16(TLV_TYPE_AUTH_TYPE
);
462 auth_tlv
->header
.len
= cpu_to_le16(sizeof(auth_tlv
->auth_type
));
463 if (priv
->sec_info
.wep_enabled
)
464 auth_tlv
->auth_type
= cpu_to_le16(
465 (u16
) priv
->sec_info
.authentication_mode
);
467 auth_tlv
->auth_type
= cpu_to_le16(NL80211_AUTHTYPE_OPEN_SYSTEM
);
469 pos
+= sizeof(auth_tlv
->header
) + le16_to_cpu(auth_tlv
->header
.len
);
471 if (IS_SUPPORT_MULTI_BANDS(priv
->adapter
) &&
472 !(ISSUPP_11NENABLED(priv
->adapter
->fw_cap_info
) &&
473 (!bss_desc
->disable_11n
) &&
474 (priv
->adapter
->config_bands
& BAND_GN
||
475 priv
->adapter
->config_bands
& BAND_AN
) &&
476 (bss_desc
->bcn_ht_cap
)
479 /* Append a channel TLV for the channel the attempted AP was
481 chan_tlv
= (struct mwifiex_ie_types_chan_list_param_set
*) pos
;
482 chan_tlv
->header
.type
= cpu_to_le16(TLV_TYPE_CHANLIST
);
483 chan_tlv
->header
.len
=
484 cpu_to_le16(sizeof(struct mwifiex_chan_scan_param_set
));
486 memset(chan_tlv
->chan_scan_param
, 0x00,
487 sizeof(struct mwifiex_chan_scan_param_set
));
488 chan_tlv
->chan_scan_param
[0].chan_number
=
489 (bss_desc
->phy_param_set
.ds_param_set
.current_chan
);
490 dev_dbg(priv
->adapter
->dev
, "info: Assoc: TLV Chan = %d\n",
491 chan_tlv
->chan_scan_param
[0].chan_number
);
493 chan_tlv
->chan_scan_param
[0].radio_type
=
494 mwifiex_band_to_radio_type((u8
) bss_desc
->bss_band
);
496 dev_dbg(priv
->adapter
->dev
, "info: Assoc: TLV Band = %d\n",
497 chan_tlv
->chan_scan_param
[0].radio_type
);
498 pos
+= sizeof(chan_tlv
->header
) +
499 sizeof(struct mwifiex_chan_scan_param_set
);
502 if (!priv
->wps
.session_enable
) {
503 if (priv
->sec_info
.wpa_enabled
|| priv
->sec_info
.wpa2_enabled
)
504 rsn_ie_len
= mwifiex_append_rsn_ie_wpa_wpa2(priv
, &pos
);
506 if (rsn_ie_len
== -1)
510 if (ISSUPP_11NENABLED(priv
->adapter
->fw_cap_info
) &&
511 (!bss_desc
->disable_11n
) &&
512 (priv
->adapter
->config_bands
& BAND_GN
||
513 priv
->adapter
->config_bands
& BAND_AN
))
514 mwifiex_cmd_append_11n_tlv(priv
, bss_desc
, &pos
);
516 if (ISSUPP_11ACENABLED(priv
->adapter
->fw_cap_info
) &&
517 !bss_desc
->disable_11n
&& !bss_desc
->disable_11ac
&&
518 priv
->adapter
->config_bands
& BAND_AAC
)
519 mwifiex_cmd_append_11ac_tlv(priv
, bss_desc
, &pos
);
521 /* Append vendor specific IE TLV */
522 mwifiex_cmd_append_vsie_tlv(priv
, MWIFIEX_VSIE_MASK_ASSOC
, &pos
);
524 mwifiex_wmm_process_association_req(priv
, &pos
, &bss_desc
->wmm_ie
,
525 bss_desc
->bcn_ht_cap
);
526 if (priv
->sec_info
.wapi_enabled
&& priv
->wapi_ie_len
)
527 mwifiex_cmd_append_wapi_ie(priv
, &pos
);
529 if (priv
->wps
.session_enable
&& priv
->wps_ie_len
)
530 mwifiex_cmd_append_wps_ie(priv
, &pos
);
532 mwifiex_cmd_append_generic_ie(priv
, &pos
);
534 mwifiex_cmd_append_tsf_tlv(priv
, &pos
, bss_desc
);
536 mwifiex_11h_process_join(priv
, &pos
, bss_desc
);
538 cmd
->size
= cpu_to_le16((u16
) (pos
- (u8
*) assoc
) + S_DS_GEN
);
540 /* Set the Capability info at last */
541 tmp_cap
= bss_desc
->cap_info_bitmap
;
543 if (priv
->adapter
->config_bands
== BAND_B
)
544 tmp_cap
&= ~WLAN_CAPABILITY_SHORT_SLOT_TIME
;
546 tmp_cap
&= CAPINFO_MASK
;
547 dev_dbg(priv
->adapter
->dev
, "info: ASSOC_CMD: tmp_cap=%4X CAPINFO_MASK=%4lX\n",
548 tmp_cap
, CAPINFO_MASK
);
549 assoc
->cap_info_bitmap
= cpu_to_le16(tmp_cap
);
555 * Association firmware command response handler
557 * The response buffer for the association command has the following
560 * For cases where an association response was not received (indicated
561 * by the CapInfo and AId field):
563 * .------------------------------------------------------------.
564 * | Header(4 * sizeof(t_u16)): Standard command response hdr |
565 * .------------------------------------------------------------.
566 * | cap_info/Error Return(t_u16): |
567 * | 0xFFFF(-1): Internal error |
568 * | 0xFFFE(-2): Authentication unhandled message |
569 * | 0xFFFD(-3): Authentication refused |
570 * | 0xFFFC(-4): Timeout waiting for AP response |
571 * .------------------------------------------------------------.
572 * | status_code(t_u16): |
573 * | If cap_info is -1: |
574 * | An internal firmware failure prevented the |
575 * | command from being processed. The status_code |
576 * | will be set to 1. |
578 * | If cap_info is -2: |
579 * | An authentication frame was received but was |
580 * | not handled by the firmware. IEEE Status |
581 * | code for the failure is returned. |
583 * | If cap_info is -3: |
584 * | An authentication frame was received and the |
585 * | status_code is the IEEE Status reported in the |
588 * | If cap_info is -4: |
589 * | (1) Association response timeout |
590 * | (2) Authentication response timeout |
591 * .------------------------------------------------------------.
592 * | a_id(t_u16): 0xFFFF |
593 * .------------------------------------------------------------.
596 * For cases where an association response was received, the IEEE
597 * standard association response frame is returned:
599 * .------------------------------------------------------------.
600 * | Header(4 * sizeof(t_u16)): Standard command response hdr |
601 * .------------------------------------------------------------.
602 * | cap_info(t_u16): IEEE Capability |
603 * .------------------------------------------------------------.
604 * | status_code(t_u16): IEEE Status Code |
605 * .------------------------------------------------------------.
606 * | a_id(t_u16): IEEE Association ID |
607 * .------------------------------------------------------------.
608 * | IEEE IEs(variable): Any received IEs comprising the |
609 * | remaining portion of a received |
610 * | association response frame. |
611 * .------------------------------------------------------------.
613 * For simplistic handling, the status_code field can be used to determine
614 * an association success (0) or failure (non-zero).
616 int mwifiex_ret_802_11_associate(struct mwifiex_private
*priv
,
617 struct host_cmd_ds_command
*resp
)
619 struct mwifiex_adapter
*adapter
= priv
->adapter
;
621 struct ieee_types_assoc_rsp
*assoc_rsp
;
622 struct mwifiex_bssdescriptor
*bss_desc
;
623 bool enable_data
= true;
624 u16 cap_info
, status_code
, aid
;
626 assoc_rsp
= (struct ieee_types_assoc_rsp
*) &resp
->params
;
628 cap_info
= le16_to_cpu(assoc_rsp
->cap_info_bitmap
);
629 status_code
= le16_to_cpu(assoc_rsp
->status_code
);
630 aid
= le16_to_cpu(assoc_rsp
->a_id
);
632 if ((aid
& (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
633 dev_err(priv
->adapter
->dev
,
634 "invalid AID value 0x%x; bits 15:14 not set\n",
637 aid
&= ~(BIT(15) | BIT(14));
639 priv
->assoc_rsp_size
= min(le16_to_cpu(resp
->size
) - S_DS_GEN
,
640 sizeof(priv
->assoc_rsp_buf
));
642 memcpy(priv
->assoc_rsp_buf
, &resp
->params
, priv
->assoc_rsp_size
);
644 assoc_rsp
->a_id
= cpu_to_le16(aid
);
647 priv
->adapter
->dbg
.num_cmd_assoc_failure
++;
648 dev_err(priv
->adapter
->dev
,
649 "ASSOC_RESP: failed, status code=%d err=%#x a_id=%#x\n",
650 status_code
, cap_info
, le16_to_cpu(assoc_rsp
->a_id
));
652 if (cap_info
== MWIFIEX_TIMEOUT_FOR_AP_RESP
) {
653 if (status_code
== MWIFIEX_STATUS_CODE_AUTH_TIMEOUT
)
654 ret
= WLAN_STATUS_AUTH_TIMEOUT
;
656 ret
= WLAN_STATUS_UNSPECIFIED_FAILURE
;
664 /* Send a Media Connected event, according to the Spec */
665 priv
->media_connected
= true;
667 priv
->adapter
->ps_state
= PS_STATE_AWAKE
;
668 priv
->adapter
->pps_uapsd_mode
= false;
669 priv
->adapter
->tx_lock_flag
= false;
671 /* Set the attempted BSSID Index to current */
672 bss_desc
= priv
->attempted_bss_desc
;
674 dev_dbg(priv
->adapter
->dev
, "info: ASSOC_RESP: %s\n",
675 bss_desc
->ssid
.ssid
);
677 /* Make a copy of current BSSID descriptor */
678 memcpy(&priv
->curr_bss_params
.bss_descriptor
,
679 bss_desc
, sizeof(struct mwifiex_bssdescriptor
));
681 /* Update curr_bss_params */
682 priv
->curr_bss_params
.bss_descriptor
.channel
683 = bss_desc
->phy_param_set
.ds_param_set
.current_chan
;
685 priv
->curr_bss_params
.band
= (u8
) bss_desc
->bss_band
;
687 if (bss_desc
->wmm_ie
.vend_hdr
.element_id
== WLAN_EID_VENDOR_SPECIFIC
)
688 priv
->curr_bss_params
.wmm_enabled
= true;
690 priv
->curr_bss_params
.wmm_enabled
= false;
692 if ((priv
->wmm_required
|| bss_desc
->bcn_ht_cap
) &&
693 priv
->curr_bss_params
.wmm_enabled
)
694 priv
->wmm_enabled
= true;
696 priv
->wmm_enabled
= false;
698 priv
->curr_bss_params
.wmm_uapsd_enabled
= false;
700 if (priv
->wmm_enabled
)
701 priv
->curr_bss_params
.wmm_uapsd_enabled
702 = ((bss_desc
->wmm_ie
.qos_info_bitmap
&
703 IEEE80211_WMM_IE_AP_QOSINFO_UAPSD
) ? 1 : 0);
705 dev_dbg(priv
->adapter
->dev
, "info: ASSOC_RESP: curr_pkt_filter is %#x\n",
706 priv
->curr_pkt_filter
);
707 if (priv
->sec_info
.wpa_enabled
|| priv
->sec_info
.wpa2_enabled
)
708 priv
->wpa_is_gtk_set
= false;
710 if (priv
->wmm_enabled
) {
711 /* Don't re-enable carrier until we get the WMM_GET_STATUS
715 /* Since WMM is not enabled, setup the queues with the
717 mwifiex_wmm_setup_queue_priorities(priv
, NULL
);
718 mwifiex_wmm_setup_ac_downgrade(priv
);
722 dev_dbg(priv
->adapter
->dev
,
723 "info: post association, re-enabling data flow\n");
725 /* Reset SNR/NF/RSSI values */
726 priv
->data_rssi_last
= 0;
727 priv
->data_nf_last
= 0;
728 priv
->data_rssi_avg
= 0;
729 priv
->data_nf_avg
= 0;
730 priv
->bcn_rssi_last
= 0;
731 priv
->bcn_nf_last
= 0;
732 priv
->bcn_rssi_avg
= 0;
733 priv
->bcn_nf_avg
= 0;
735 priv
->rxpd_htinfo
= 0;
737 mwifiex_save_curr_bcn(priv
);
739 priv
->adapter
->dbg
.num_cmd_assoc_success
++;
741 dev_dbg(priv
->adapter
->dev
, "info: ASSOC_RESP: associated\n");
743 /* Add the ra_list here for infra mode as there will be only 1 ra
745 mwifiex_ralist_add(priv
,
746 priv
->curr_bss_params
.bss_descriptor
.mac_address
);
748 if (!netif_carrier_ok(priv
->netdev
))
749 netif_carrier_on(priv
->netdev
);
750 mwifiex_wake_up_net_dev_queue(priv
->netdev
, adapter
);
752 if (priv
->sec_info
.wpa_enabled
|| priv
->sec_info
.wpa2_enabled
)
753 priv
->scan_block
= true;
756 /* Need to indicate IOCTL complete */
757 if (adapter
->curr_cmd
->wait_q_enabled
) {
759 adapter
->cmd_wait_q
.status
= -1;
761 adapter
->cmd_wait_q
.status
= 0;
768 * This function prepares command for ad-hoc start.
770 * Driver will fill up SSID, BSS mode, IBSS parameters, physical
771 * parameters, probe delay, and capability information. Firmware
772 * will fill up beacon period, basic rates and operational rates.
774 * In addition, the following TLVs are added -
776 * - Vendor specific IE
778 * - HT Capabilities IE
779 * - HT Information IE
781 * Preparation also includes -
782 * - Setting command ID and proper size
783 * - Ensuring correct endian-ness
786 mwifiex_cmd_802_11_ad_hoc_start(struct mwifiex_private
*priv
,
787 struct host_cmd_ds_command
*cmd
,
788 struct cfg80211_ssid
*req_ssid
)
791 struct mwifiex_adapter
*adapter
= priv
->adapter
;
792 struct host_cmd_ds_802_11_ad_hoc_start
*adhoc_start
=
793 &cmd
->params
.adhoc_start
;
794 struct mwifiex_bssdescriptor
*bss_desc
;
795 u32 cmd_append_size
= 0;
798 struct mwifiex_ie_types_chan_list_param_set
*chan_tlv
;
801 struct mwifiex_ie_types_htcap
*ht_cap
;
802 struct mwifiex_ie_types_htinfo
*ht_info
;
803 u8
*pos
= (u8
*) adhoc_start
+
804 sizeof(struct host_cmd_ds_802_11_ad_hoc_start
);
809 cmd
->command
= cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_START
);
811 bss_desc
= &priv
->curr_bss_params
.bss_descriptor
;
812 priv
->attempted_bss_desc
= bss_desc
;
815 * Fill in the parameters for 2 data structures:
816 * 1. struct host_cmd_ds_802_11_ad_hoc_start command
818 * Driver will fill up SSID, bss_mode,IBSS param, Physical Param,
819 * probe delay, and Cap info.
820 * Firmware will fill up beacon period, Basic rates
821 * and operational rates.
824 memset(adhoc_start
->ssid
, 0, IEEE80211_MAX_SSID_LEN
);
826 memcpy(adhoc_start
->ssid
, req_ssid
->ssid
, req_ssid
->ssid_len
);
828 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: SSID = %s\n",
831 memset(bss_desc
->ssid
.ssid
, 0, IEEE80211_MAX_SSID_LEN
);
832 memcpy(bss_desc
->ssid
.ssid
, req_ssid
->ssid
, req_ssid
->ssid_len
);
834 bss_desc
->ssid
.ssid_len
= req_ssid
->ssid_len
;
836 /* Set the BSS mode */
837 adhoc_start
->bss_mode
= HostCmd_BSS_MODE_IBSS
;
838 bss_desc
->bss_mode
= NL80211_IFTYPE_ADHOC
;
839 adhoc_start
->beacon_period
= cpu_to_le16(priv
->beacon_period
);
840 bss_desc
->beacon_period
= priv
->beacon_period
;
842 /* Set Physical param set */
843 /* Parameter IE Id */
844 #define DS_PARA_IE_ID 3
845 /* Parameter IE length */
846 #define DS_PARA_IE_LEN 1
848 adhoc_start
->phy_param_set
.ds_param_set
.element_id
= DS_PARA_IE_ID
;
849 adhoc_start
->phy_param_set
.ds_param_set
.len
= DS_PARA_IE_LEN
;
851 if (!mwifiex_get_cfp(priv
, adapter
->adhoc_start_band
,
852 (u16
) priv
->adhoc_channel
, 0)) {
853 struct mwifiex_chan_freq_power
*cfp
;
854 cfp
= mwifiex_get_cfp(priv
, adapter
->adhoc_start_band
,
855 FIRST_VALID_CHANNEL
, 0);
857 priv
->adhoc_channel
= (u8
) cfp
->channel
;
860 if (!priv
->adhoc_channel
) {
861 dev_err(adapter
->dev
, "ADHOC_S_CMD: adhoc_channel cannot be 0\n");
865 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: creating ADHOC on channel %d\n",
866 priv
->adhoc_channel
);
868 priv
->curr_bss_params
.bss_descriptor
.channel
= priv
->adhoc_channel
;
869 priv
->curr_bss_params
.band
= adapter
->adhoc_start_band
;
871 bss_desc
->channel
= priv
->adhoc_channel
;
872 adhoc_start
->phy_param_set
.ds_param_set
.current_chan
=
875 memcpy(&bss_desc
->phy_param_set
, &adhoc_start
->phy_param_set
,
876 sizeof(union ieee_types_phy_param_set
));
878 /* Set IBSS param set */
879 /* IBSS parameter IE Id */
880 #define IBSS_PARA_IE_ID 6
881 /* IBSS parameter IE length */
882 #define IBSS_PARA_IE_LEN 2
884 adhoc_start
->ss_param_set
.ibss_param_set
.element_id
= IBSS_PARA_IE_ID
;
885 adhoc_start
->ss_param_set
.ibss_param_set
.len
= IBSS_PARA_IE_LEN
;
886 adhoc_start
->ss_param_set
.ibss_param_set
.atim_window
887 = cpu_to_le16(priv
->atim_window
);
888 memcpy(&bss_desc
->ss_param_set
, &adhoc_start
->ss_param_set
,
889 sizeof(union ieee_types_ss_param_set
));
891 /* Set Capability info */
892 bss_desc
->cap_info_bitmap
|= WLAN_CAPABILITY_IBSS
;
893 tmp_cap
= WLAN_CAPABILITY_IBSS
;
895 /* Set up privacy in bss_desc */
896 if (priv
->sec_info
.encryption_mode
) {
897 /* Ad-Hoc capability privacy on */
898 dev_dbg(adapter
->dev
,
899 "info: ADHOC_S_CMD: wep_status set privacy to WEP\n");
900 bss_desc
->privacy
= MWIFIEX_802_11_PRIV_FILTER_8021X_WEP
;
901 tmp_cap
|= WLAN_CAPABILITY_PRIVACY
;
903 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: wep_status NOT set,"
904 " setting privacy to ACCEPT ALL\n");
905 bss_desc
->privacy
= MWIFIEX_802_11_PRIV_FILTER_ACCEPT_ALL
;
908 memset(adhoc_start
->data_rate
, 0, sizeof(adhoc_start
->data_rate
));
909 mwifiex_get_active_data_rates(priv
, adhoc_start
->data_rate
);
910 if ((adapter
->adhoc_start_band
& BAND_G
) &&
911 (priv
->curr_pkt_filter
& HostCmd_ACT_MAC_ADHOC_G_PROTECTION_ON
)) {
912 if (mwifiex_send_cmd(priv
, HostCmd_CMD_MAC_CONTROL
,
913 HostCmd_ACT_GEN_SET
, 0,
914 &priv
->curr_pkt_filter
, false)) {
915 dev_err(adapter
->dev
,
916 "ADHOC_S_CMD: G Protection config failed\n");
920 /* Find the last non zero */
921 for (i
= 0; i
< sizeof(adhoc_start
->data_rate
); i
++)
922 if (!adhoc_start
->data_rate
[i
])
925 priv
->curr_bss_params
.num_of_rates
= i
;
927 /* Copy the ad-hoc creating rates into Current BSS rate structure */
928 memcpy(&priv
->curr_bss_params
.data_rates
,
929 &adhoc_start
->data_rate
, priv
->curr_bss_params
.num_of_rates
);
931 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: rates=%4ph\n",
932 adhoc_start
->data_rate
);
934 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: AD-HOC Start command is ready\n");
936 if (IS_SUPPORT_MULTI_BANDS(adapter
)) {
937 /* Append a channel TLV */
938 chan_tlv
= (struct mwifiex_ie_types_chan_list_param_set
*) pos
;
939 chan_tlv
->header
.type
= cpu_to_le16(TLV_TYPE_CHANLIST
);
940 chan_tlv
->header
.len
=
941 cpu_to_le16(sizeof(struct mwifiex_chan_scan_param_set
));
943 memset(chan_tlv
->chan_scan_param
, 0x00,
944 sizeof(struct mwifiex_chan_scan_param_set
));
945 chan_tlv
->chan_scan_param
[0].chan_number
=
946 (u8
) priv
->curr_bss_params
.bss_descriptor
.channel
;
948 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: TLV Chan = %d\n",
949 chan_tlv
->chan_scan_param
[0].chan_number
);
951 chan_tlv
->chan_scan_param
[0].radio_type
952 = mwifiex_band_to_radio_type(priv
->curr_bss_params
.band
);
953 if (adapter
->adhoc_start_band
& BAND_GN
||
954 adapter
->adhoc_start_band
& BAND_AN
) {
955 if (adapter
->sec_chan_offset
==
956 IEEE80211_HT_PARAM_CHA_SEC_ABOVE
)
957 chan_tlv
->chan_scan_param
[0].radio_type
|=
958 (IEEE80211_HT_PARAM_CHA_SEC_ABOVE
<< 4);
959 else if (adapter
->sec_chan_offset
==
960 IEEE80211_HT_PARAM_CHA_SEC_BELOW
)
961 chan_tlv
->chan_scan_param
[0].radio_type
|=
962 (IEEE80211_HT_PARAM_CHA_SEC_BELOW
<< 4);
964 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: TLV Band = %d\n",
965 chan_tlv
->chan_scan_param
[0].radio_type
);
966 pos
+= sizeof(chan_tlv
->header
) +
967 sizeof(struct mwifiex_chan_scan_param_set
);
969 sizeof(chan_tlv
->header
) +
970 sizeof(struct mwifiex_chan_scan_param_set
);
973 /* Append vendor specific IE TLV */
974 cmd_append_size
+= mwifiex_cmd_append_vsie_tlv(priv
,
975 MWIFIEX_VSIE_MASK_ADHOC
, &pos
);
977 if (priv
->sec_info
.wpa_enabled
) {
978 rsn_ie_len
= mwifiex_append_rsn_ie_wpa_wpa2(priv
, &pos
);
979 if (rsn_ie_len
== -1)
981 cmd_append_size
+= rsn_ie_len
;
984 if (adapter
->adhoc_11n_enabled
) {
985 /* Fill HT CAPABILITY */
986 ht_cap
= (struct mwifiex_ie_types_htcap
*) pos
;
987 memset(ht_cap
, 0, sizeof(struct mwifiex_ie_types_htcap
));
988 ht_cap
->header
.type
= cpu_to_le16(WLAN_EID_HT_CAPABILITY
);
990 cpu_to_le16(sizeof(struct ieee80211_ht_cap
));
991 radio_type
= mwifiex_band_to_radio_type(
992 priv
->adapter
->config_bands
);
993 mwifiex_fill_cap_info(priv
, radio_type
, &ht_cap
->ht_cap
);
995 if (adapter
->sec_chan_offset
==
996 IEEE80211_HT_PARAM_CHA_SEC_NONE
) {
999 tmp_ht_cap
= le16_to_cpu(ht_cap
->ht_cap
.cap_info
);
1000 tmp_ht_cap
&= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
1001 tmp_ht_cap
&= ~IEEE80211_HT_CAP_SGI_40
;
1002 ht_cap
->ht_cap
.cap_info
= cpu_to_le16(tmp_ht_cap
);
1005 pos
+= sizeof(struct mwifiex_ie_types_htcap
);
1006 cmd_append_size
+= sizeof(struct mwifiex_ie_types_htcap
);
1008 /* Fill HT INFORMATION */
1009 ht_info
= (struct mwifiex_ie_types_htinfo
*) pos
;
1010 memset(ht_info
, 0, sizeof(struct mwifiex_ie_types_htinfo
));
1011 ht_info
->header
.type
= cpu_to_le16(WLAN_EID_HT_OPERATION
);
1012 ht_info
->header
.len
=
1013 cpu_to_le16(sizeof(struct ieee80211_ht_operation
));
1015 ht_info
->ht_oper
.primary_chan
=
1016 (u8
) priv
->curr_bss_params
.bss_descriptor
.channel
;
1017 if (adapter
->sec_chan_offset
) {
1018 ht_info
->ht_oper
.ht_param
= adapter
->sec_chan_offset
;
1019 ht_info
->ht_oper
.ht_param
|=
1020 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY
;
1022 ht_info
->ht_oper
.operation_mode
=
1023 cpu_to_le16(IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT
);
1024 ht_info
->ht_oper
.basic_set
[0] = 0xff;
1025 pos
+= sizeof(struct mwifiex_ie_types_htinfo
);
1027 sizeof(struct mwifiex_ie_types_htinfo
);
1031 cpu_to_le16((u16
)(sizeof(struct host_cmd_ds_802_11_ad_hoc_start
)
1032 + S_DS_GEN
+ cmd_append_size
));
1034 if (adapter
->adhoc_start_band
== BAND_B
)
1035 tmp_cap
&= ~WLAN_CAPABILITY_SHORT_SLOT_TIME
;
1037 tmp_cap
|= WLAN_CAPABILITY_SHORT_SLOT_TIME
;
1039 adhoc_start
->cap_info_bitmap
= cpu_to_le16(tmp_cap
);
1045 * This function prepares command for ad-hoc join.
1047 * Most of the parameters are set up by copying from the target BSS descriptor
1048 * from the scan response.
1050 * In addition, the following TLVs are added -
1052 * - Vendor specific IE
1056 * Preparation also includes -
1057 * - Setting command ID and proper size
1058 * - Ensuring correct endian-ness
1061 mwifiex_cmd_802_11_ad_hoc_join(struct mwifiex_private
*priv
,
1062 struct host_cmd_ds_command
*cmd
,
1063 struct mwifiex_bssdescriptor
*bss_desc
)
1066 struct host_cmd_ds_802_11_ad_hoc_join
*adhoc_join
=
1067 &cmd
->params
.adhoc_join
;
1068 struct mwifiex_ie_types_chan_list_param_set
*chan_tlv
;
1069 u32 cmd_append_size
= 0;
1071 u32 i
, rates_size
= 0;
1072 u16 curr_pkt_filter
;
1075 sizeof(struct host_cmd_ds_802_11_ad_hoc_join
);
1077 /* Use G protection */
1078 #define USE_G_PROTECTION 0x02
1079 if (bss_desc
->erp_flags
& USE_G_PROTECTION
) {
1082 curr_pkt_filter
| HostCmd_ACT_MAC_ADHOC_G_PROTECTION_ON
;
1084 if (mwifiex_send_cmd(priv
, HostCmd_CMD_MAC_CONTROL
,
1085 HostCmd_ACT_GEN_SET
, 0,
1086 &curr_pkt_filter
, false)) {
1087 dev_err(priv
->adapter
->dev
,
1088 "ADHOC_J_CMD: G Protection config failed\n");
1093 priv
->attempted_bss_desc
= bss_desc
;
1095 cmd
->command
= cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_JOIN
);
1097 adhoc_join
->bss_descriptor
.bss_mode
= HostCmd_BSS_MODE_IBSS
;
1099 adhoc_join
->bss_descriptor
.beacon_period
1100 = cpu_to_le16(bss_desc
->beacon_period
);
1102 memcpy(&adhoc_join
->bss_descriptor
.bssid
,
1103 &bss_desc
->mac_address
, ETH_ALEN
);
1105 memcpy(&adhoc_join
->bss_descriptor
.ssid
,
1106 &bss_desc
->ssid
.ssid
, bss_desc
->ssid
.ssid_len
);
1108 memcpy(&adhoc_join
->bss_descriptor
.phy_param_set
,
1109 &bss_desc
->phy_param_set
,
1110 sizeof(union ieee_types_phy_param_set
));
1112 memcpy(&adhoc_join
->bss_descriptor
.ss_param_set
,
1113 &bss_desc
->ss_param_set
, sizeof(union ieee_types_ss_param_set
));
1115 tmp_cap
= bss_desc
->cap_info_bitmap
;
1117 tmp_cap
&= CAPINFO_MASK
;
1119 dev_dbg(priv
->adapter
->dev
,
1120 "info: ADHOC_J_CMD: tmp_cap=%4X CAPINFO_MASK=%4lX\n",
1121 tmp_cap
, CAPINFO_MASK
);
1123 /* Information on BSSID descriptor passed to FW */
1124 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_J_CMD: BSSID=%pM, SSID='%s'\n",
1125 adhoc_join
->bss_descriptor
.bssid
,
1126 adhoc_join
->bss_descriptor
.ssid
);
1128 for (i
= 0; i
< MWIFIEX_SUPPORTED_RATES
&&
1129 bss_desc
->supported_rates
[i
]; i
++)
1133 /* Copy Data Rates from the Rates recorded in scan response */
1134 memset(adhoc_join
->bss_descriptor
.data_rates
, 0,
1135 sizeof(adhoc_join
->bss_descriptor
.data_rates
));
1136 memcpy(adhoc_join
->bss_descriptor
.data_rates
,
1137 bss_desc
->supported_rates
, rates_size
);
1139 /* Copy the adhoc join rates into Current BSS state structure */
1140 priv
->curr_bss_params
.num_of_rates
= rates_size
;
1141 memcpy(&priv
->curr_bss_params
.data_rates
, bss_desc
->supported_rates
,
1144 /* Copy the channel information */
1145 priv
->curr_bss_params
.bss_descriptor
.channel
= bss_desc
->channel
;
1146 priv
->curr_bss_params
.band
= (u8
) bss_desc
->bss_band
;
1148 if (priv
->sec_info
.wep_enabled
|| priv
->sec_info
.wpa_enabled
)
1149 tmp_cap
|= WLAN_CAPABILITY_PRIVACY
;
1151 if (IS_SUPPORT_MULTI_BANDS(priv
->adapter
)) {
1152 /* Append a channel TLV */
1153 chan_tlv
= (struct mwifiex_ie_types_chan_list_param_set
*) pos
;
1154 chan_tlv
->header
.type
= cpu_to_le16(TLV_TYPE_CHANLIST
);
1155 chan_tlv
->header
.len
=
1156 cpu_to_le16(sizeof(struct mwifiex_chan_scan_param_set
));
1158 memset(chan_tlv
->chan_scan_param
, 0x00,
1159 sizeof(struct mwifiex_chan_scan_param_set
));
1160 chan_tlv
->chan_scan_param
[0].chan_number
=
1161 (bss_desc
->phy_param_set
.ds_param_set
.current_chan
);
1162 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_J_CMD: TLV Chan=%d\n",
1163 chan_tlv
->chan_scan_param
[0].chan_number
);
1165 chan_tlv
->chan_scan_param
[0].radio_type
=
1166 mwifiex_band_to_radio_type((u8
) bss_desc
->bss_band
);
1168 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_J_CMD: TLV Band=%d\n",
1169 chan_tlv
->chan_scan_param
[0].radio_type
);
1170 pos
+= sizeof(chan_tlv
->header
) +
1171 sizeof(struct mwifiex_chan_scan_param_set
);
1172 cmd_append_size
+= sizeof(chan_tlv
->header
) +
1173 sizeof(struct mwifiex_chan_scan_param_set
);
1176 if (priv
->sec_info
.wpa_enabled
)
1177 rsn_ie_len
= mwifiex_append_rsn_ie_wpa_wpa2(priv
, &pos
);
1178 if (rsn_ie_len
== -1)
1180 cmd_append_size
+= rsn_ie_len
;
1182 if (ISSUPP_11NENABLED(priv
->adapter
->fw_cap_info
))
1183 cmd_append_size
+= mwifiex_cmd_append_11n_tlv(priv
,
1186 /* Append vendor specific IE TLV */
1187 cmd_append_size
+= mwifiex_cmd_append_vsie_tlv(priv
,
1188 MWIFIEX_VSIE_MASK_ADHOC
, &pos
);
1190 cmd
->size
= cpu_to_le16
1191 ((u16
) (sizeof(struct host_cmd_ds_802_11_ad_hoc_join
)
1192 + S_DS_GEN
+ cmd_append_size
));
1194 adhoc_join
->bss_descriptor
.cap_info_bitmap
= cpu_to_le16(tmp_cap
);
1200 * This function handles the command response of ad-hoc start and
1203 * The function generates a device-connected event to notify
1204 * the applications, in case of successful ad-hoc start/join, and
1205 * saves the beacon buffer.
1207 int mwifiex_ret_802_11_ad_hoc(struct mwifiex_private
*priv
,
1208 struct host_cmd_ds_command
*resp
)
1211 struct mwifiex_adapter
*adapter
= priv
->adapter
;
1212 struct host_cmd_ds_802_11_ad_hoc_result
*adhoc_result
;
1213 struct mwifiex_bssdescriptor
*bss_desc
;
1216 adhoc_result
= &resp
->params
.adhoc_result
;
1218 bss_desc
= priv
->attempted_bss_desc
;
1220 /* Join result code 0 --> SUCCESS */
1221 reason_code
= le16_to_cpu(resp
->result
);
1223 dev_err(priv
->adapter
->dev
, "ADHOC_RESP: failed\n");
1224 if (priv
->media_connected
)
1225 mwifiex_reset_connect_state(priv
, reason_code
);
1227 memset(&priv
->curr_bss_params
.bss_descriptor
,
1228 0x00, sizeof(struct mwifiex_bssdescriptor
));
1234 /* Send a Media Connected event, according to the Spec */
1235 priv
->media_connected
= true;
1237 if (le16_to_cpu(resp
->command
) == HostCmd_CMD_802_11_AD_HOC_START
) {
1238 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_S_RESP %s\n",
1239 bss_desc
->ssid
.ssid
);
1241 /* Update the created network descriptor with the new BSSID */
1242 memcpy(bss_desc
->mac_address
,
1243 adhoc_result
->bssid
, ETH_ALEN
);
1245 priv
->adhoc_state
= ADHOC_STARTED
;
1248 * Now the join cmd should be successful.
1249 * If BSSID has changed use SSID to compare instead of BSSID
1251 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_J_RESP %s\n",
1252 bss_desc
->ssid
.ssid
);
1255 * Make a copy of current BSSID descriptor, only needed for
1256 * join since the current descriptor is already being used
1259 memcpy(&priv
->curr_bss_params
.bss_descriptor
,
1260 bss_desc
, sizeof(struct mwifiex_bssdescriptor
));
1262 priv
->adhoc_state
= ADHOC_JOINED
;
1265 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_RESP: channel = %d\n",
1266 priv
->adhoc_channel
);
1267 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_RESP: BSSID = %pM\n",
1268 priv
->curr_bss_params
.bss_descriptor
.mac_address
);
1270 if (!netif_carrier_ok(priv
->netdev
))
1271 netif_carrier_on(priv
->netdev
);
1272 mwifiex_wake_up_net_dev_queue(priv
->netdev
, adapter
);
1274 mwifiex_save_curr_bcn(priv
);
1277 /* Need to indicate IOCTL complete */
1278 if (adapter
->curr_cmd
->wait_q_enabled
) {
1280 adapter
->cmd_wait_q
.status
= -1;
1282 adapter
->cmd_wait_q
.status
= 0;
1290 * This function associates to a specific BSS discovered in a scan.
1292 * It clears any past association response stored for application
1293 * retrieval and calls the command preparation routine to send the
1294 * command to firmware.
1296 int mwifiex_associate(struct mwifiex_private
*priv
,
1297 struct mwifiex_bssdescriptor
*bss_desc
)
1299 /* Return error if the adapter is not STA role or table entry
1300 * is not marked as infra.
1302 if ((GET_BSS_ROLE(priv
) != MWIFIEX_BSS_ROLE_STA
) ||
1303 (bss_desc
->bss_mode
!= NL80211_IFTYPE_STATION
))
1306 if (ISSUPP_11ACENABLED(priv
->adapter
->fw_cap_info
) &&
1307 !bss_desc
->disable_11n
&& !bss_desc
->disable_11ac
&&
1308 priv
->adapter
->config_bands
& BAND_AAC
)
1309 mwifiex_set_11ac_ba_params(priv
);
1311 mwifiex_set_ba_params(priv
);
1313 /* Clear any past association response stored for application
1315 priv
->assoc_rsp_size
= 0;
1317 return mwifiex_send_cmd(priv
, HostCmd_CMD_802_11_ASSOCIATE
,
1318 HostCmd_ACT_GEN_SET
, 0, bss_desc
, true);
1322 * This function starts an ad-hoc network.
1324 * It calls the command preparation routine to send the command to firmware.
1327 mwifiex_adhoc_start(struct mwifiex_private
*priv
,
1328 struct cfg80211_ssid
*adhoc_ssid
)
1330 dev_dbg(priv
->adapter
->dev
, "info: Adhoc Channel = %d\n",
1331 priv
->adhoc_channel
);
1332 dev_dbg(priv
->adapter
->dev
, "info: curr_bss_params.channel = %d\n",
1333 priv
->curr_bss_params
.bss_descriptor
.channel
);
1334 dev_dbg(priv
->adapter
->dev
, "info: curr_bss_params.band = %d\n",
1335 priv
->curr_bss_params
.band
);
1337 if (ISSUPP_11ACENABLED(priv
->adapter
->fw_cap_info
) &&
1338 priv
->adapter
->config_bands
& BAND_AAC
)
1339 mwifiex_set_11ac_ba_params(priv
);
1341 mwifiex_set_ba_params(priv
);
1343 return mwifiex_send_cmd(priv
, HostCmd_CMD_802_11_AD_HOC_START
,
1344 HostCmd_ACT_GEN_SET
, 0, adhoc_ssid
, true);
1348 * This function joins an ad-hoc network found in a previous scan.
1350 * It calls the command preparation routine to send the command to firmware,
1351 * if already not connected to the requested SSID.
1353 int mwifiex_adhoc_join(struct mwifiex_private
*priv
,
1354 struct mwifiex_bssdescriptor
*bss_desc
)
1356 dev_dbg(priv
->adapter
->dev
, "info: adhoc join: curr_bss ssid =%s\n",
1357 priv
->curr_bss_params
.bss_descriptor
.ssid
.ssid
);
1358 dev_dbg(priv
->adapter
->dev
, "info: adhoc join: curr_bss ssid_len =%u\n",
1359 priv
->curr_bss_params
.bss_descriptor
.ssid
.ssid_len
);
1360 dev_dbg(priv
->adapter
->dev
, "info: adhoc join: ssid =%s\n",
1361 bss_desc
->ssid
.ssid
);
1362 dev_dbg(priv
->adapter
->dev
, "info: adhoc join: ssid_len =%u\n",
1363 bss_desc
->ssid
.ssid_len
);
1365 /* Check if the requested SSID is already joined */
1366 if (priv
->curr_bss_params
.bss_descriptor
.ssid
.ssid_len
&&
1367 !mwifiex_ssid_cmp(&bss_desc
->ssid
,
1368 &priv
->curr_bss_params
.bss_descriptor
.ssid
) &&
1369 (priv
->curr_bss_params
.bss_descriptor
.bss_mode
==
1370 NL80211_IFTYPE_ADHOC
)) {
1371 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_J_CMD: new ad-hoc SSID"
1372 " is the same as current; not attempting to re-join\n");
1376 if (ISSUPP_11ACENABLED(priv
->adapter
->fw_cap_info
) &&
1377 !bss_desc
->disable_11n
&& !bss_desc
->disable_11ac
&&
1378 priv
->adapter
->config_bands
& BAND_AAC
)
1379 mwifiex_set_11ac_ba_params(priv
);
1381 mwifiex_set_ba_params(priv
);
1383 dev_dbg(priv
->adapter
->dev
, "info: curr_bss_params.channel = %d\n",
1384 priv
->curr_bss_params
.bss_descriptor
.channel
);
1385 dev_dbg(priv
->adapter
->dev
, "info: curr_bss_params.band = %c\n",
1386 priv
->curr_bss_params
.band
);
1388 return mwifiex_send_cmd(priv
, HostCmd_CMD_802_11_AD_HOC_JOIN
,
1389 HostCmd_ACT_GEN_SET
, 0, bss_desc
, true);
1393 * This function deauthenticates/disconnects from infra network by sending
1394 * deauthentication request.
1396 static int mwifiex_deauthenticate_infra(struct mwifiex_private
*priv
, u8
*mac
)
1398 u8 mac_address
[ETH_ALEN
];
1401 if (!mac
|| is_zero_ether_addr(mac
))
1403 priv
->curr_bss_params
.bss_descriptor
.mac_address
,
1406 memcpy(mac_address
, mac
, ETH_ALEN
);
1408 ret
= mwifiex_send_cmd(priv
, HostCmd_CMD_802_11_DEAUTHENTICATE
,
1409 HostCmd_ACT_GEN_SET
, 0, mac_address
, true);
1415 * This function deauthenticates/disconnects from a BSS.
1417 * In case of infra made, it sends deauthentication request, and
1418 * in case of ad-hoc mode, a stop network request is sent to the firmware.
1419 * In AP mode, a command to stop bss is sent to firmware.
1421 int mwifiex_deauthenticate(struct mwifiex_private
*priv
, u8
*mac
)
1425 if (!priv
->media_connected
)
1428 switch (priv
->bss_mode
) {
1429 case NL80211_IFTYPE_STATION
:
1430 case NL80211_IFTYPE_P2P_CLIENT
:
1431 ret
= mwifiex_deauthenticate_infra(priv
, mac
);
1433 cfg80211_disconnected(priv
->netdev
, 0, NULL
, 0,
1436 case NL80211_IFTYPE_ADHOC
:
1437 return mwifiex_send_cmd(priv
, HostCmd_CMD_802_11_AD_HOC_STOP
,
1438 HostCmd_ACT_GEN_SET
, 0, NULL
, true);
1439 case NL80211_IFTYPE_AP
:
1440 return mwifiex_send_cmd(priv
, HostCmd_CMD_UAP_BSS_STOP
,
1441 HostCmd_ACT_GEN_SET
, 0, NULL
, true);
1449 /* This function deauthenticates/disconnects from all BSS. */
1450 void mwifiex_deauthenticate_all(struct mwifiex_adapter
*adapter
)
1452 struct mwifiex_private
*priv
;
1455 for (i
= 0; i
< adapter
->priv_num
; i
++) {
1456 priv
= adapter
->priv
[i
];
1458 mwifiex_deauthenticate(priv
, NULL
);
1461 EXPORT_SYMBOL_GPL(mwifiex_deauthenticate_all
);
1464 * This function converts band to radio type used in channel TLV.
1467 mwifiex_band_to_radio_type(u8 band
)
1472 case BAND_A
| BAND_AN
:
1473 case BAND_A
| BAND_AN
| BAND_AAC
:
1474 return HostCmd_SCAN_RADIO_TYPE_A
;
1477 case BAND_B
| BAND_G
:
1479 return HostCmd_SCAN_RADIO_TYPE_BG
;