2 * Marvell Wireless LAN device driver: association and ad-hoc start/join
4 * Copyright (C) 2011, 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.
28 #define CAPINFO_MASK (~(BIT(15) | BIT(14) | BIT(12) | BIT(11) | BIT(9)))
31 * Append a generic IE as a pass through TLV to a TLV buffer.
33 * This function is called from the network join command preparation routine.
35 * If the IE buffer has been setup by the application, this routine appends
36 * the buffer as a pass through TLV type to the request.
39 mwifiex_cmd_append_generic_ie(struct mwifiex_private
*priv
, u8
**buffer
)
42 struct mwifiex_ie_types_header ie_header
;
51 * If there is a generic ie buffer setup, append it to the return
52 * parameter buffer pointer.
54 if (priv
->gen_ie_buf_len
) {
55 dev_dbg(priv
->adapter
->dev
,
56 "info: %s: append generic ie len %d to %p\n",
57 __func__
, priv
->gen_ie_buf_len
, *buffer
);
59 /* Wrap the generic IE buffer with a pass through TLV type */
60 ie_header
.type
= cpu_to_le16(TLV_TYPE_PASSTHROUGH
);
61 ie_header
.len
= cpu_to_le16(priv
->gen_ie_buf_len
);
62 memcpy(*buffer
, &ie_header
, sizeof(ie_header
));
64 /* Increment the return size and the return buffer pointer
66 *buffer
+= sizeof(ie_header
);
67 ret_len
+= sizeof(ie_header
);
69 /* Copy the generic IE buffer to the output buffer, advance
71 memcpy(*buffer
, priv
->gen_ie_buf
, priv
->gen_ie_buf_len
);
73 /* Increment the return size and the return buffer pointer
75 *buffer
+= priv
->gen_ie_buf_len
;
76 ret_len
+= priv
->gen_ie_buf_len
;
78 /* Reset the generic IE buffer */
79 priv
->gen_ie_buf_len
= 0;
82 /* return the length appended to the buffer */
87 * Append TSF tracking info from the scan table for the target AP.
89 * This function is called from the network join command preparation routine.
91 * The TSF table TSF sent to the firmware contains two TSF values:
92 * - The TSF of the target AP from its previous beacon/probe response
93 * - The TSF timestamp of our local MAC at the time we observed the
94 * beacon/probe response.
96 * The firmware uses the timestamp values to set an initial TSF value
97 * in the MAC for the new association after a reassociation attempt.
100 mwifiex_cmd_append_tsf_tlv(struct mwifiex_private
*priv
, u8
**buffer
,
101 struct mwifiex_bssdescriptor
*bss_desc
)
103 struct mwifiex_ie_types_tsf_timestamp tsf_tlv
;
112 memset(&tsf_tlv
, 0x00, sizeof(struct mwifiex_ie_types_tsf_timestamp
));
114 tsf_tlv
.header
.type
= cpu_to_le16(TLV_TYPE_TSFTIMESTAMP
);
115 tsf_tlv
.header
.len
= cpu_to_le16(2 * sizeof(tsf_val
));
117 memcpy(*buffer
, &tsf_tlv
, sizeof(tsf_tlv
.header
));
118 *buffer
+= sizeof(tsf_tlv
.header
);
120 /* TSF at the time when beacon/probe_response was received */
121 tsf_val
= cpu_to_le64(bss_desc
->network_tsf
);
122 memcpy(*buffer
, &tsf_val
, sizeof(tsf_val
));
123 *buffer
+= sizeof(tsf_val
);
125 memcpy(&tsf_val
, bss_desc
->time_stamp
, sizeof(tsf_val
));
127 dev_dbg(priv
->adapter
->dev
,
128 "info: %s: TSF offset calc: %016llx - %016llx\n",
129 __func__
, tsf_val
, bss_desc
->network_tsf
);
131 memcpy(*buffer
, &tsf_val
, sizeof(tsf_val
));
132 *buffer
+= sizeof(tsf_val
);
134 return sizeof(tsf_tlv
.header
) + (2 * sizeof(tsf_val
));
138 * This function finds out the common rates between rate1 and rate2.
140 * It will fill common rates in rate1 as output if found.
142 * NOTE: Setting the MSB of the basic rates needs to be taken
143 * care of, either before or after calling this function.
145 static int mwifiex_get_common_rates(struct mwifiex_private
*priv
, u8
*rate1
,
146 u32 rate1_size
, u8
*rate2
, u32 rate2_size
)
149 u8
*ptr
= rate1
, *tmp
;
152 tmp
= kmemdup(rate1
, rate1_size
, GFP_KERNEL
);
154 dev_err(priv
->adapter
->dev
, "failed to alloc tmp buf\n");
158 memset(rate1
, 0, rate1_size
);
160 for (i
= 0; rate2
[i
] && i
< rate2_size
; i
++) {
161 for (j
= 0; tmp
[j
] && j
< rate1_size
; j
++) {
162 /* Check common rate, excluding the bit for
164 if ((rate2
[i
] & 0x7F) == (tmp
[j
] & 0x7F)) {
171 dev_dbg(priv
->adapter
->dev
, "info: Tx data rate set to %#x\n",
174 if (!priv
->is_data_rate_auto
) {
176 if ((*ptr
& 0x7f) == priv
->data_rate
) {
182 dev_err(priv
->adapter
->dev
, "previously set fixed data rate %#x"
183 " is not compatible with the network\n",
197 * This function creates the intersection of the rates supported by a
198 * target BSS and our adapter settings for use in an assoc/join command.
201 mwifiex_setup_rates_from_bssdesc(struct mwifiex_private
*priv
,
202 struct mwifiex_bssdescriptor
*bss_desc
,
203 u8
*out_rates
, u32
*out_rates_size
)
205 u8 card_rates
[MWIFIEX_SUPPORTED_RATES
];
208 /* Copy AP supported rates */
209 memcpy(out_rates
, bss_desc
->supported_rates
, MWIFIEX_SUPPORTED_RATES
);
210 /* Get the STA supported rates */
211 card_rates_size
= mwifiex_get_active_data_rates(priv
, card_rates
);
212 /* Get the common rates between AP and STA supported rates */
213 if (mwifiex_get_common_rates(priv
, out_rates
, MWIFIEX_SUPPORTED_RATES
,
214 card_rates
, card_rates_size
)) {
216 dev_err(priv
->adapter
->dev
, "%s: cannot get common rates\n",
222 min_t(size_t, strlen(out_rates
), MWIFIEX_SUPPORTED_RATES
);
228 * This function appends a WAPI IE.
230 * This function is called from the network join command preparation routine.
232 * If the IE buffer has been setup by the application, this routine appends
233 * the buffer as a WAPI TLV type to the request.
236 mwifiex_cmd_append_wapi_ie(struct mwifiex_private
*priv
, u8
**buffer
)
239 struct mwifiex_ie_types_header ie_header
;
248 * If there is a wapi ie buffer setup, append it to the return
249 * parameter buffer pointer.
251 if (priv
->wapi_ie_len
) {
252 dev_dbg(priv
->adapter
->dev
, "cmd: append wapi ie %d to %p\n",
253 priv
->wapi_ie_len
, *buffer
);
255 /* Wrap the generic IE buffer with a pass through TLV type */
256 ie_header
.type
= cpu_to_le16(TLV_TYPE_WAPI_IE
);
257 ie_header
.len
= cpu_to_le16(priv
->wapi_ie_len
);
258 memcpy(*buffer
, &ie_header
, sizeof(ie_header
));
260 /* Increment the return size and the return buffer pointer
262 *buffer
+= sizeof(ie_header
);
263 retLen
+= sizeof(ie_header
);
265 /* Copy the wapi IE buffer to the output buffer, advance
267 memcpy(*buffer
, priv
->wapi_ie
, priv
->wapi_ie_len
);
269 /* Increment the return size and the return buffer pointer
271 *buffer
+= priv
->wapi_ie_len
;
272 retLen
+= priv
->wapi_ie_len
;
275 /* return the length appended to the buffer */
280 * This function appends rsn ie tlv for wpa/wpa2 security modes.
281 * It is called from the network join command preparation routine.
283 static int mwifiex_append_rsn_ie_wpa_wpa2(struct mwifiex_private
*priv
,
286 struct mwifiex_ie_types_rsn_param_set
*rsn_ie_tlv
;
289 if (!buffer
|| !(*buffer
))
292 rsn_ie_tlv
= (struct mwifiex_ie_types_rsn_param_set
*) (*buffer
);
293 rsn_ie_tlv
->header
.type
= cpu_to_le16((u16
) priv
->wpa_ie
[0]);
294 rsn_ie_tlv
->header
.type
= cpu_to_le16(
295 le16_to_cpu(rsn_ie_tlv
->header
.type
) & 0x00FF);
296 rsn_ie_tlv
->header
.len
= cpu_to_le16((u16
) priv
->wpa_ie
[1]);
297 rsn_ie_tlv
->header
.len
= cpu_to_le16(le16_to_cpu(rsn_ie_tlv
->header
.len
)
299 if (le16_to_cpu(rsn_ie_tlv
->header
.len
) <= (sizeof(priv
->wpa_ie
) - 2))
300 memcpy(rsn_ie_tlv
->rsn_ie
, &priv
->wpa_ie
[2],
301 le16_to_cpu(rsn_ie_tlv
->header
.len
));
305 rsn_ie_len
= sizeof(rsn_ie_tlv
->header
) +
306 le16_to_cpu(rsn_ie_tlv
->header
.len
);
307 *buffer
+= rsn_ie_len
;
313 * This function prepares command for association.
315 * This sets the following parameters -
319 * - Capability information
321 * ...and the following TLVs, as required -
326 * - Authentication TLV
330 * - Vendor specific TLV
336 * Preparation also includes -
337 * - Setting command ID and proper size
338 * - Ensuring correct endian-ness
340 int mwifiex_cmd_802_11_associate(struct mwifiex_private
*priv
,
341 struct host_cmd_ds_command
*cmd
,
342 struct mwifiex_bssdescriptor
*bss_desc
)
344 struct host_cmd_ds_802_11_associate
*assoc
= &cmd
->params
.associate
;
345 struct mwifiex_ie_types_ssid_param_set
*ssid_tlv
;
346 struct mwifiex_ie_types_phy_param_set
*phy_tlv
;
347 struct mwifiex_ie_types_ss_param_set
*ss_tlv
;
348 struct mwifiex_ie_types_rates_param_set
*rates_tlv
;
349 struct mwifiex_ie_types_auth_type
*auth_tlv
;
350 struct mwifiex_ie_types_chan_list_param_set
*chan_tlv
;
351 u8 rates
[MWIFIEX_SUPPORTED_RATES
];
359 mwifiex_cfg_tx_buf(priv
, bss_desc
);
361 cmd
->command
= cpu_to_le16(HostCmd_CMD_802_11_ASSOCIATE
);
363 /* Save so we know which BSS Desc to use in the response handler */
364 priv
->attempted_bss_desc
= bss_desc
;
366 memcpy(assoc
->peer_sta_addr
,
367 bss_desc
->mac_address
, sizeof(assoc
->peer_sta_addr
));
368 pos
+= sizeof(assoc
->peer_sta_addr
);
370 /* Set the listen interval */
371 assoc
->listen_interval
= cpu_to_le16(priv
->listen_interval
);
372 /* Set the beacon period */
373 assoc
->beacon_period
= cpu_to_le16(bss_desc
->beacon_period
);
375 pos
+= sizeof(assoc
->cap_info_bitmap
);
376 pos
+= sizeof(assoc
->listen_interval
);
377 pos
+= sizeof(assoc
->beacon_period
);
378 pos
+= sizeof(assoc
->dtim_period
);
380 ssid_tlv
= (struct mwifiex_ie_types_ssid_param_set
*) pos
;
381 ssid_tlv
->header
.type
= cpu_to_le16(WLAN_EID_SSID
);
382 ssid_tlv
->header
.len
= cpu_to_le16((u16
) bss_desc
->ssid
.ssid_len
);
383 memcpy(ssid_tlv
->ssid
, bss_desc
->ssid
.ssid
,
384 le16_to_cpu(ssid_tlv
->header
.len
));
385 pos
+= sizeof(ssid_tlv
->header
) + le16_to_cpu(ssid_tlv
->header
.len
);
387 phy_tlv
= (struct mwifiex_ie_types_phy_param_set
*) pos
;
388 phy_tlv
->header
.type
= cpu_to_le16(WLAN_EID_DS_PARAMS
);
389 phy_tlv
->header
.len
= cpu_to_le16(sizeof(phy_tlv
->fh_ds
.ds_param_set
));
390 memcpy(&phy_tlv
->fh_ds
.ds_param_set
,
391 &bss_desc
->phy_param_set
.ds_param_set
.current_chan
,
392 sizeof(phy_tlv
->fh_ds
.ds_param_set
));
393 pos
+= sizeof(phy_tlv
->header
) + le16_to_cpu(phy_tlv
->header
.len
);
395 ss_tlv
= (struct mwifiex_ie_types_ss_param_set
*) pos
;
396 ss_tlv
->header
.type
= cpu_to_le16(WLAN_EID_CF_PARAMS
);
397 ss_tlv
->header
.len
= cpu_to_le16(sizeof(ss_tlv
->cf_ibss
.cf_param_set
));
398 pos
+= sizeof(ss_tlv
->header
) + le16_to_cpu(ss_tlv
->header
.len
);
400 /* Get the common rates supported between the driver and the BSS Desc */
401 if (mwifiex_setup_rates_from_bssdesc
402 (priv
, bss_desc
, rates
, &rates_size
))
405 /* Save the data rates into Current BSS state structure */
406 priv
->curr_bss_params
.num_of_rates
= rates_size
;
407 memcpy(&priv
->curr_bss_params
.data_rates
, rates
, rates_size
);
409 /* Setup the Rates TLV in the association command */
410 rates_tlv
= (struct mwifiex_ie_types_rates_param_set
*) pos
;
411 rates_tlv
->header
.type
= cpu_to_le16(WLAN_EID_SUPP_RATES
);
412 rates_tlv
->header
.len
= cpu_to_le16((u16
) rates_size
);
413 memcpy(rates_tlv
->rates
, rates
, rates_size
);
414 pos
+= sizeof(rates_tlv
->header
) + rates_size
;
415 dev_dbg(priv
->adapter
->dev
, "info: ASSOC_CMD: rates size = %d\n",
418 /* Add the Authentication type to be used for Auth frames */
419 auth_tlv
= (struct mwifiex_ie_types_auth_type
*) pos
;
420 auth_tlv
->header
.type
= cpu_to_le16(TLV_TYPE_AUTH_TYPE
);
421 auth_tlv
->header
.len
= cpu_to_le16(sizeof(auth_tlv
->auth_type
));
422 if (priv
->sec_info
.wep_enabled
)
423 auth_tlv
->auth_type
= cpu_to_le16(
424 (u16
) priv
->sec_info
.authentication_mode
);
426 auth_tlv
->auth_type
= cpu_to_le16(NL80211_AUTHTYPE_OPEN_SYSTEM
);
428 pos
+= sizeof(auth_tlv
->header
) + le16_to_cpu(auth_tlv
->header
.len
);
430 if (IS_SUPPORT_MULTI_BANDS(priv
->adapter
) &&
431 !(ISSUPP_11NENABLED(priv
->adapter
->fw_cap_info
) &&
432 (!bss_desc
->disable_11n
) &&
433 (priv
->adapter
->config_bands
& BAND_GN
||
434 priv
->adapter
->config_bands
& BAND_AN
) &&
435 (bss_desc
->bcn_ht_cap
)
438 /* Append a channel TLV for the channel the attempted AP was
440 chan_tlv
= (struct mwifiex_ie_types_chan_list_param_set
*) pos
;
441 chan_tlv
->header
.type
= cpu_to_le16(TLV_TYPE_CHANLIST
);
442 chan_tlv
->header
.len
=
443 cpu_to_le16(sizeof(struct mwifiex_chan_scan_param_set
));
445 memset(chan_tlv
->chan_scan_param
, 0x00,
446 sizeof(struct mwifiex_chan_scan_param_set
));
447 chan_tlv
->chan_scan_param
[0].chan_number
=
448 (bss_desc
->phy_param_set
.ds_param_set
.current_chan
);
449 dev_dbg(priv
->adapter
->dev
, "info: Assoc: TLV Chan = %d\n",
450 chan_tlv
->chan_scan_param
[0].chan_number
);
452 chan_tlv
->chan_scan_param
[0].radio_type
=
453 mwifiex_band_to_radio_type((u8
) bss_desc
->bss_band
);
455 dev_dbg(priv
->adapter
->dev
, "info: Assoc: TLV Band = %d\n",
456 chan_tlv
->chan_scan_param
[0].radio_type
);
457 pos
+= sizeof(chan_tlv
->header
) +
458 sizeof(struct mwifiex_chan_scan_param_set
);
461 if (!priv
->wps
.session_enable
) {
462 if (priv
->sec_info
.wpa_enabled
|| priv
->sec_info
.wpa2_enabled
)
463 rsn_ie_len
= mwifiex_append_rsn_ie_wpa_wpa2(priv
, &pos
);
465 if (rsn_ie_len
== -1)
469 if (ISSUPP_11NENABLED(priv
->adapter
->fw_cap_info
) &&
470 (!bss_desc
->disable_11n
) &&
471 (priv
->adapter
->config_bands
& BAND_GN
||
472 priv
->adapter
->config_bands
& BAND_AN
))
473 mwifiex_cmd_append_11n_tlv(priv
, bss_desc
, &pos
);
475 /* Append vendor specific IE TLV */
476 mwifiex_cmd_append_vsie_tlv(priv
, MWIFIEX_VSIE_MASK_ASSOC
, &pos
);
478 mwifiex_wmm_process_association_req(priv
, &pos
, &bss_desc
->wmm_ie
,
479 bss_desc
->bcn_ht_cap
);
480 if (priv
->sec_info
.wapi_enabled
&& priv
->wapi_ie_len
)
481 mwifiex_cmd_append_wapi_ie(priv
, &pos
);
484 mwifiex_cmd_append_generic_ie(priv
, &pos
);
486 mwifiex_cmd_append_tsf_tlv(priv
, &pos
, bss_desc
);
488 cmd
->size
= cpu_to_le16((u16
) (pos
- (u8
*) assoc
) + S_DS_GEN
);
490 /* Set the Capability info at last */
491 tmp_cap
= bss_desc
->cap_info_bitmap
;
493 if (priv
->adapter
->config_bands
== BAND_B
)
494 tmp_cap
&= ~WLAN_CAPABILITY_SHORT_SLOT_TIME
;
496 tmp_cap
&= CAPINFO_MASK
;
497 dev_dbg(priv
->adapter
->dev
, "info: ASSOC_CMD: tmp_cap=%4X CAPINFO_MASK=%4lX\n",
498 tmp_cap
, CAPINFO_MASK
);
499 assoc
->cap_info_bitmap
= cpu_to_le16(tmp_cap
);
505 * Association firmware command response handler
507 * The response buffer for the association command has the following
510 * For cases where an association response was not received (indicated
511 * by the CapInfo and AId field):
513 * .------------------------------------------------------------.
514 * | Header(4 * sizeof(t_u16)): Standard command response hdr |
515 * .------------------------------------------------------------.
516 * | cap_info/Error Return(t_u16): |
517 * | 0xFFFF(-1): Internal error |
518 * | 0xFFFE(-2): Authentication unhandled message |
519 * | 0xFFFD(-3): Authentication refused |
520 * | 0xFFFC(-4): Timeout waiting for AP response |
521 * .------------------------------------------------------------.
522 * | status_code(t_u16): |
523 * | If cap_info is -1: |
524 * | An internal firmware failure prevented the |
525 * | command from being processed. The status_code |
526 * | will be set to 1. |
528 * | If cap_info is -2: |
529 * | An authentication frame was received but was |
530 * | not handled by the firmware. IEEE Status |
531 * | code for the failure is returned. |
533 * | If cap_info is -3: |
534 * | An authentication frame was received and the |
535 * | status_code is the IEEE Status reported in the |
538 * | If cap_info is -4: |
539 * | (1) Association response timeout |
540 * | (2) Authentication response timeout |
541 * .------------------------------------------------------------.
542 * | a_id(t_u16): 0xFFFF |
543 * .------------------------------------------------------------.
546 * For cases where an association response was received, the IEEE
547 * standard association response frame is returned:
549 * .------------------------------------------------------------.
550 * | Header(4 * sizeof(t_u16)): Standard command response hdr |
551 * .------------------------------------------------------------.
552 * | cap_info(t_u16): IEEE Capability |
553 * .------------------------------------------------------------.
554 * | status_code(t_u16): IEEE Status Code |
555 * .------------------------------------------------------------.
556 * | a_id(t_u16): IEEE Association ID |
557 * .------------------------------------------------------------.
558 * | IEEE IEs(variable): Any received IEs comprising the |
559 * | remaining portion of a received |
560 * | association response frame. |
561 * .------------------------------------------------------------.
563 * For simplistic handling, the status_code field can be used to determine
564 * an association success (0) or failure (non-zero).
566 int mwifiex_ret_802_11_associate(struct mwifiex_private
*priv
,
567 struct host_cmd_ds_command
*resp
)
569 struct mwifiex_adapter
*adapter
= priv
->adapter
;
571 struct ieee_types_assoc_rsp
*assoc_rsp
;
572 struct mwifiex_bssdescriptor
*bss_desc
;
573 u8 enable_data
= true;
575 assoc_rsp
= (struct ieee_types_assoc_rsp
*) &resp
->params
;
577 priv
->assoc_rsp_size
= min(le16_to_cpu(resp
->size
) - S_DS_GEN
,
578 sizeof(priv
->assoc_rsp_buf
));
580 memcpy(priv
->assoc_rsp_buf
, &resp
->params
, priv
->assoc_rsp_size
);
582 if (le16_to_cpu(assoc_rsp
->status_code
)) {
583 priv
->adapter
->dbg
.num_cmd_assoc_failure
++;
584 dev_err(priv
->adapter
->dev
,
585 "ASSOC_RESP: failed, status code=%d err=%#x a_id=%#x\n",
586 le16_to_cpu(assoc_rsp
->status_code
),
587 le16_to_cpu(assoc_rsp
->cap_info_bitmap
),
588 le16_to_cpu(assoc_rsp
->a_id
));
590 ret
= le16_to_cpu(assoc_rsp
->status_code
);
594 /* Send a Media Connected event, according to the Spec */
595 priv
->media_connected
= true;
597 priv
->adapter
->ps_state
= PS_STATE_AWAKE
;
598 priv
->adapter
->pps_uapsd_mode
= false;
599 priv
->adapter
->tx_lock_flag
= false;
601 /* Set the attempted BSSID Index to current */
602 bss_desc
= priv
->attempted_bss_desc
;
604 dev_dbg(priv
->adapter
->dev
, "info: ASSOC_RESP: %s\n",
605 bss_desc
->ssid
.ssid
);
607 /* Make a copy of current BSSID descriptor */
608 memcpy(&priv
->curr_bss_params
.bss_descriptor
,
609 bss_desc
, sizeof(struct mwifiex_bssdescriptor
));
611 /* Update curr_bss_params */
612 priv
->curr_bss_params
.bss_descriptor
.channel
613 = bss_desc
->phy_param_set
.ds_param_set
.current_chan
;
615 priv
->curr_bss_params
.band
= (u8
) bss_desc
->bss_band
;
617 if (bss_desc
->wmm_ie
.vend_hdr
.element_id
== WLAN_EID_VENDOR_SPECIFIC
)
618 priv
->curr_bss_params
.wmm_enabled
= true;
620 priv
->curr_bss_params
.wmm_enabled
= false;
622 if ((priv
->wmm_required
|| bss_desc
->bcn_ht_cap
) &&
623 priv
->curr_bss_params
.wmm_enabled
)
624 priv
->wmm_enabled
= true;
626 priv
->wmm_enabled
= false;
628 priv
->curr_bss_params
.wmm_uapsd_enabled
= false;
630 if (priv
->wmm_enabled
)
631 priv
->curr_bss_params
.wmm_uapsd_enabled
632 = ((bss_desc
->wmm_ie
.qos_info_bitmap
&
633 IEEE80211_WMM_IE_AP_QOSINFO_UAPSD
) ? 1 : 0);
635 dev_dbg(priv
->adapter
->dev
, "info: ASSOC_RESP: curr_pkt_filter is %#x\n",
636 priv
->curr_pkt_filter
);
637 if (priv
->sec_info
.wpa_enabled
|| priv
->sec_info
.wpa2_enabled
)
638 priv
->wpa_is_gtk_set
= false;
640 if (priv
->wmm_enabled
) {
641 /* Don't re-enable carrier until we get the WMM_GET_STATUS
645 /* Since WMM is not enabled, setup the queues with the
647 mwifiex_wmm_setup_queue_priorities(priv
, NULL
);
648 mwifiex_wmm_setup_ac_downgrade(priv
);
652 dev_dbg(priv
->adapter
->dev
,
653 "info: post association, re-enabling data flow\n");
655 /* Reset SNR/NF/RSSI values */
656 priv
->data_rssi_last
= 0;
657 priv
->data_nf_last
= 0;
658 priv
->data_rssi_avg
= 0;
659 priv
->data_nf_avg
= 0;
660 priv
->bcn_rssi_last
= 0;
661 priv
->bcn_nf_last
= 0;
662 priv
->bcn_rssi_avg
= 0;
663 priv
->bcn_nf_avg
= 0;
665 priv
->rxpd_htinfo
= 0;
667 mwifiex_save_curr_bcn(priv
);
669 priv
->adapter
->dbg
.num_cmd_assoc_success
++;
671 dev_dbg(priv
->adapter
->dev
, "info: ASSOC_RESP: associated\n");
673 /* Add the ra_list here for infra mode as there will be only 1 ra
675 mwifiex_ralist_add(priv
,
676 priv
->curr_bss_params
.bss_descriptor
.mac_address
);
678 if (!netif_carrier_ok(priv
->netdev
))
679 netif_carrier_on(priv
->netdev
);
680 if (netif_queue_stopped(priv
->netdev
))
681 netif_wake_queue(priv
->netdev
);
683 if (priv
->sec_info
.wpa_enabled
|| priv
->sec_info
.wpa2_enabled
)
684 priv
->scan_block
= true;
687 /* Need to indicate IOCTL complete */
688 if (adapter
->curr_cmd
->wait_q_enabled
) {
690 adapter
->cmd_wait_q
.status
= -1;
692 adapter
->cmd_wait_q
.status
= 0;
699 * This function prepares command for ad-hoc start.
701 * Driver will fill up SSID, BSS mode, IBSS parameters, physical
702 * parameters, probe delay, and capability information. Firmware
703 * will fill up beacon period, basic rates and operational rates.
705 * In addition, the following TLVs are added -
707 * - Vendor specific IE
709 * - HT Capabilities IE
710 * - HT Information IE
712 * Preparation also includes -
713 * - Setting command ID and proper size
714 * - Ensuring correct endian-ness
717 mwifiex_cmd_802_11_ad_hoc_start(struct mwifiex_private
*priv
,
718 struct host_cmd_ds_command
*cmd
,
719 struct cfg80211_ssid
*req_ssid
)
722 struct mwifiex_adapter
*adapter
= priv
->adapter
;
723 struct host_cmd_ds_802_11_ad_hoc_start
*adhoc_start
=
724 &cmd
->params
.adhoc_start
;
725 struct mwifiex_bssdescriptor
*bss_desc
;
726 u32 cmd_append_size
= 0;
729 struct mwifiex_ie_types_chan_list_param_set
*chan_tlv
;
732 struct mwifiex_ie_types_htcap
*ht_cap
;
733 struct mwifiex_ie_types_htinfo
*ht_info
;
734 u8
*pos
= (u8
*) adhoc_start
+
735 sizeof(struct host_cmd_ds_802_11_ad_hoc_start
);
740 cmd
->command
= cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_START
);
742 bss_desc
= &priv
->curr_bss_params
.bss_descriptor
;
743 priv
->attempted_bss_desc
= bss_desc
;
746 * Fill in the parameters for 2 data structures:
747 * 1. struct host_cmd_ds_802_11_ad_hoc_start command
749 * Driver will fill up SSID, bss_mode,IBSS param, Physical Param,
750 * probe delay, and Cap info.
751 * Firmware will fill up beacon period, Basic rates
752 * and operational rates.
755 memset(adhoc_start
->ssid
, 0, IEEE80211_MAX_SSID_LEN
);
757 memcpy(adhoc_start
->ssid
, req_ssid
->ssid
, req_ssid
->ssid_len
);
759 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: SSID = %s\n",
762 memset(bss_desc
->ssid
.ssid
, 0, IEEE80211_MAX_SSID_LEN
);
763 memcpy(bss_desc
->ssid
.ssid
, req_ssid
->ssid
, req_ssid
->ssid_len
);
765 bss_desc
->ssid
.ssid_len
= req_ssid
->ssid_len
;
767 /* Set the BSS mode */
768 adhoc_start
->bss_mode
= HostCmd_BSS_MODE_IBSS
;
769 bss_desc
->bss_mode
= NL80211_IFTYPE_ADHOC
;
770 adhoc_start
->beacon_period
= cpu_to_le16(priv
->beacon_period
);
771 bss_desc
->beacon_period
= priv
->beacon_period
;
773 /* Set Physical param set */
774 /* Parameter IE Id */
775 #define DS_PARA_IE_ID 3
776 /* Parameter IE length */
777 #define DS_PARA_IE_LEN 1
779 adhoc_start
->phy_param_set
.ds_param_set
.element_id
= DS_PARA_IE_ID
;
780 adhoc_start
->phy_param_set
.ds_param_set
.len
= DS_PARA_IE_LEN
;
782 if (!mwifiex_get_cfp(priv
, adapter
->adhoc_start_band
,
783 (u16
) priv
->adhoc_channel
, 0)) {
784 struct mwifiex_chan_freq_power
*cfp
;
785 cfp
= mwifiex_get_cfp(priv
, adapter
->adhoc_start_band
,
786 FIRST_VALID_CHANNEL
, 0);
788 priv
->adhoc_channel
= (u8
) cfp
->channel
;
791 if (!priv
->adhoc_channel
) {
792 dev_err(adapter
->dev
, "ADHOC_S_CMD: adhoc_channel cannot be 0\n");
796 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: creating ADHOC on channel %d\n",
797 priv
->adhoc_channel
);
799 priv
->curr_bss_params
.bss_descriptor
.channel
= priv
->adhoc_channel
;
800 priv
->curr_bss_params
.band
= adapter
->adhoc_start_band
;
802 bss_desc
->channel
= priv
->adhoc_channel
;
803 adhoc_start
->phy_param_set
.ds_param_set
.current_chan
=
806 memcpy(&bss_desc
->phy_param_set
, &adhoc_start
->phy_param_set
,
807 sizeof(union ieee_types_phy_param_set
));
809 /* Set IBSS param set */
810 /* IBSS parameter IE Id */
811 #define IBSS_PARA_IE_ID 6
812 /* IBSS parameter IE length */
813 #define IBSS_PARA_IE_LEN 2
815 adhoc_start
->ss_param_set
.ibss_param_set
.element_id
= IBSS_PARA_IE_ID
;
816 adhoc_start
->ss_param_set
.ibss_param_set
.len
= IBSS_PARA_IE_LEN
;
817 adhoc_start
->ss_param_set
.ibss_param_set
.atim_window
818 = cpu_to_le16(priv
->atim_window
);
819 memcpy(&bss_desc
->ss_param_set
, &adhoc_start
->ss_param_set
,
820 sizeof(union ieee_types_ss_param_set
));
822 /* Set Capability info */
823 bss_desc
->cap_info_bitmap
|= WLAN_CAPABILITY_IBSS
;
824 tmp_cap
= le16_to_cpu(adhoc_start
->cap_info_bitmap
);
825 tmp_cap
&= ~WLAN_CAPABILITY_ESS
;
826 tmp_cap
|= WLAN_CAPABILITY_IBSS
;
828 /* Set up privacy in bss_desc */
829 if (priv
->sec_info
.encryption_mode
) {
830 /* Ad-Hoc capability privacy on */
831 dev_dbg(adapter
->dev
,
832 "info: ADHOC_S_CMD: wep_status set privacy to WEP\n");
833 bss_desc
->privacy
= MWIFIEX_802_11_PRIV_FILTER_8021X_WEP
;
834 tmp_cap
|= WLAN_CAPABILITY_PRIVACY
;
836 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: wep_status NOT set,"
837 " setting privacy to ACCEPT ALL\n");
838 bss_desc
->privacy
= MWIFIEX_802_11_PRIV_FILTER_ACCEPT_ALL
;
841 memset(adhoc_start
->data_rate
, 0, sizeof(adhoc_start
->data_rate
));
842 mwifiex_get_active_data_rates(priv
, adhoc_start
->data_rate
);
843 if ((adapter
->adhoc_start_band
& BAND_G
) &&
844 (priv
->curr_pkt_filter
& HostCmd_ACT_MAC_ADHOC_G_PROTECTION_ON
)) {
845 if (mwifiex_send_cmd_async(priv
, HostCmd_CMD_MAC_CONTROL
,
846 HostCmd_ACT_GEN_SET
, 0,
847 &priv
->curr_pkt_filter
)) {
848 dev_err(adapter
->dev
,
849 "ADHOC_S_CMD: G Protection config failed\n");
853 /* Find the last non zero */
854 for (i
= 0; i
< sizeof(adhoc_start
->data_rate
); i
++)
855 if (!adhoc_start
->data_rate
[i
])
858 priv
->curr_bss_params
.num_of_rates
= i
;
860 /* Copy the ad-hoc creating rates into Current BSS rate structure */
861 memcpy(&priv
->curr_bss_params
.data_rates
,
862 &adhoc_start
->data_rate
, priv
->curr_bss_params
.num_of_rates
);
864 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: rates=%02x %02x %02x %02x\n",
865 adhoc_start
->data_rate
[0], adhoc_start
->data_rate
[1],
866 adhoc_start
->data_rate
[2], adhoc_start
->data_rate
[3]);
868 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: AD-HOC Start command is ready\n");
870 if (IS_SUPPORT_MULTI_BANDS(adapter
)) {
871 /* Append a channel TLV */
872 chan_tlv
= (struct mwifiex_ie_types_chan_list_param_set
*) pos
;
873 chan_tlv
->header
.type
= cpu_to_le16(TLV_TYPE_CHANLIST
);
874 chan_tlv
->header
.len
=
875 cpu_to_le16(sizeof(struct mwifiex_chan_scan_param_set
));
877 memset(chan_tlv
->chan_scan_param
, 0x00,
878 sizeof(struct mwifiex_chan_scan_param_set
));
879 chan_tlv
->chan_scan_param
[0].chan_number
=
880 (u8
) priv
->curr_bss_params
.bss_descriptor
.channel
;
882 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: TLV Chan = %d\n",
883 chan_tlv
->chan_scan_param
[0].chan_number
);
885 chan_tlv
->chan_scan_param
[0].radio_type
886 = mwifiex_band_to_radio_type(priv
->curr_bss_params
.band
);
887 if (adapter
->adhoc_start_band
& BAND_GN
||
888 adapter
->adhoc_start_band
& BAND_AN
) {
889 if (adapter
->sec_chan_offset
==
890 IEEE80211_HT_PARAM_CHA_SEC_ABOVE
)
891 chan_tlv
->chan_scan_param
[0].radio_type
|=
892 (IEEE80211_HT_PARAM_CHA_SEC_ABOVE
<< 4);
893 else if (adapter
->sec_chan_offset
==
894 IEEE80211_HT_PARAM_CHA_SEC_ABOVE
)
895 chan_tlv
->chan_scan_param
[0].radio_type
|=
896 (IEEE80211_HT_PARAM_CHA_SEC_BELOW
<< 4);
898 dev_dbg(adapter
->dev
, "info: ADHOC_S_CMD: TLV Band = %d\n",
899 chan_tlv
->chan_scan_param
[0].radio_type
);
900 pos
+= sizeof(chan_tlv
->header
) +
901 sizeof(struct mwifiex_chan_scan_param_set
);
903 sizeof(chan_tlv
->header
) +
904 sizeof(struct mwifiex_chan_scan_param_set
);
907 /* Append vendor specific IE TLV */
908 cmd_append_size
+= mwifiex_cmd_append_vsie_tlv(priv
,
909 MWIFIEX_VSIE_MASK_ADHOC
, &pos
);
911 if (priv
->sec_info
.wpa_enabled
) {
912 rsn_ie_len
= mwifiex_append_rsn_ie_wpa_wpa2(priv
, &pos
);
913 if (rsn_ie_len
== -1)
915 cmd_append_size
+= rsn_ie_len
;
918 if (adapter
->adhoc_11n_enabled
) {
919 /* Fill HT CAPABILITY */
920 ht_cap
= (struct mwifiex_ie_types_htcap
*) pos
;
921 memset(ht_cap
, 0, sizeof(struct mwifiex_ie_types_htcap
));
922 ht_cap
->header
.type
= cpu_to_le16(WLAN_EID_HT_CAPABILITY
);
924 cpu_to_le16(sizeof(struct ieee80211_ht_cap
));
925 radio_type
= mwifiex_band_to_radio_type(
926 priv
->adapter
->config_bands
);
927 mwifiex_fill_cap_info(priv
, radio_type
, ht_cap
);
929 pos
+= sizeof(struct mwifiex_ie_types_htcap
);
930 cmd_append_size
+= sizeof(struct mwifiex_ie_types_htcap
);
932 /* Fill HT INFORMATION */
933 ht_info
= (struct mwifiex_ie_types_htinfo
*) pos
;
934 memset(ht_info
, 0, sizeof(struct mwifiex_ie_types_htinfo
));
935 ht_info
->header
.type
= cpu_to_le16(WLAN_EID_HT_INFORMATION
);
936 ht_info
->header
.len
=
937 cpu_to_le16(sizeof(struct ieee80211_ht_info
));
939 ht_info
->ht_info
.control_chan
=
940 (u8
) priv
->curr_bss_params
.bss_descriptor
.channel
;
941 if (adapter
->sec_chan_offset
) {
942 ht_info
->ht_info
.ht_param
= adapter
->sec_chan_offset
;
943 ht_info
->ht_info
.ht_param
|=
944 IEEE80211_HT_PARAM_CHAN_WIDTH_ANY
;
946 ht_info
->ht_info
.operation_mode
=
947 cpu_to_le16(IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT
);
948 ht_info
->ht_info
.basic_set
[0] = 0xff;
949 pos
+= sizeof(struct mwifiex_ie_types_htinfo
);
951 sizeof(struct mwifiex_ie_types_htinfo
);
955 cpu_to_le16((u16
)(sizeof(struct host_cmd_ds_802_11_ad_hoc_start
)
956 + S_DS_GEN
+ cmd_append_size
));
958 if (adapter
->adhoc_start_band
== BAND_B
)
959 tmp_cap
&= ~WLAN_CAPABILITY_SHORT_SLOT_TIME
;
961 tmp_cap
|= WLAN_CAPABILITY_SHORT_SLOT_TIME
;
963 adhoc_start
->cap_info_bitmap
= cpu_to_le16(tmp_cap
);
969 * This function prepares command for ad-hoc join.
971 * Most of the parameters are set up by copying from the target BSS descriptor
972 * from the scan response.
974 * In addition, the following TLVs are added -
976 * - Vendor specific IE
980 * Preparation also includes -
981 * - Setting command ID and proper size
982 * - Ensuring correct endian-ness
985 mwifiex_cmd_802_11_ad_hoc_join(struct mwifiex_private
*priv
,
986 struct host_cmd_ds_command
*cmd
,
987 struct mwifiex_bssdescriptor
*bss_desc
)
990 struct host_cmd_ds_802_11_ad_hoc_join
*adhoc_join
=
991 &cmd
->params
.adhoc_join
;
992 struct mwifiex_ie_types_chan_list_param_set
*chan_tlv
;
993 u32 cmd_append_size
= 0;
995 u32 i
, rates_size
= 0;
999 sizeof(struct host_cmd_ds_802_11_ad_hoc_join
);
1001 /* Use G protection */
1002 #define USE_G_PROTECTION 0x02
1003 if (bss_desc
->erp_flags
& USE_G_PROTECTION
) {
1006 curr_pkt_filter
| HostCmd_ACT_MAC_ADHOC_G_PROTECTION_ON
;
1008 if (mwifiex_send_cmd_async(priv
, HostCmd_CMD_MAC_CONTROL
,
1009 HostCmd_ACT_GEN_SET
, 0,
1010 &curr_pkt_filter
)) {
1011 dev_err(priv
->adapter
->dev
,
1012 "ADHOC_J_CMD: G Protection config failed\n");
1017 priv
->attempted_bss_desc
= bss_desc
;
1019 cmd
->command
= cpu_to_le16(HostCmd_CMD_802_11_AD_HOC_JOIN
);
1021 adhoc_join
->bss_descriptor
.bss_mode
= HostCmd_BSS_MODE_IBSS
;
1023 adhoc_join
->bss_descriptor
.beacon_period
1024 = cpu_to_le16(bss_desc
->beacon_period
);
1026 memcpy(&adhoc_join
->bss_descriptor
.bssid
,
1027 &bss_desc
->mac_address
, ETH_ALEN
);
1029 memcpy(&adhoc_join
->bss_descriptor
.ssid
,
1030 &bss_desc
->ssid
.ssid
, bss_desc
->ssid
.ssid_len
);
1032 memcpy(&adhoc_join
->bss_descriptor
.phy_param_set
,
1033 &bss_desc
->phy_param_set
,
1034 sizeof(union ieee_types_phy_param_set
));
1036 memcpy(&adhoc_join
->bss_descriptor
.ss_param_set
,
1037 &bss_desc
->ss_param_set
, sizeof(union ieee_types_ss_param_set
));
1039 tmp_cap
= bss_desc
->cap_info_bitmap
;
1041 tmp_cap
&= CAPINFO_MASK
;
1043 dev_dbg(priv
->adapter
->dev
,
1044 "info: ADHOC_J_CMD: tmp_cap=%4X CAPINFO_MASK=%4lX\n",
1045 tmp_cap
, CAPINFO_MASK
);
1047 /* Information on BSSID descriptor passed to FW */
1048 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_J_CMD: BSSID=%pM, SSID='%s'\n",
1049 adhoc_join
->bss_descriptor
.bssid
,
1050 adhoc_join
->bss_descriptor
.ssid
);
1052 for (i
= 0; bss_desc
->supported_rates
[i
] &&
1053 i
< MWIFIEX_SUPPORTED_RATES
;
1058 /* Copy Data Rates from the Rates recorded in scan response */
1059 memset(adhoc_join
->bss_descriptor
.data_rates
, 0,
1060 sizeof(adhoc_join
->bss_descriptor
.data_rates
));
1061 memcpy(adhoc_join
->bss_descriptor
.data_rates
,
1062 bss_desc
->supported_rates
, rates_size
);
1064 /* Copy the adhoc join rates into Current BSS state structure */
1065 priv
->curr_bss_params
.num_of_rates
= rates_size
;
1066 memcpy(&priv
->curr_bss_params
.data_rates
, bss_desc
->supported_rates
,
1069 /* Copy the channel information */
1070 priv
->curr_bss_params
.bss_descriptor
.channel
= bss_desc
->channel
;
1071 priv
->curr_bss_params
.band
= (u8
) bss_desc
->bss_band
;
1073 if (priv
->sec_info
.wep_enabled
|| priv
->sec_info
.wpa_enabled
)
1074 tmp_cap
|= WLAN_CAPABILITY_PRIVACY
;
1076 if (IS_SUPPORT_MULTI_BANDS(priv
->adapter
)) {
1077 /* Append a channel TLV */
1078 chan_tlv
= (struct mwifiex_ie_types_chan_list_param_set
*) pos
;
1079 chan_tlv
->header
.type
= cpu_to_le16(TLV_TYPE_CHANLIST
);
1080 chan_tlv
->header
.len
=
1081 cpu_to_le16(sizeof(struct mwifiex_chan_scan_param_set
));
1083 memset(chan_tlv
->chan_scan_param
, 0x00,
1084 sizeof(struct mwifiex_chan_scan_param_set
));
1085 chan_tlv
->chan_scan_param
[0].chan_number
=
1086 (bss_desc
->phy_param_set
.ds_param_set
.current_chan
);
1087 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_J_CMD: TLV Chan=%d\n",
1088 chan_tlv
->chan_scan_param
[0].chan_number
);
1090 chan_tlv
->chan_scan_param
[0].radio_type
=
1091 mwifiex_band_to_radio_type((u8
) bss_desc
->bss_band
);
1093 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_J_CMD: TLV Band=%d\n",
1094 chan_tlv
->chan_scan_param
[0].radio_type
);
1095 pos
+= sizeof(chan_tlv
->header
) +
1096 sizeof(struct mwifiex_chan_scan_param_set
);
1097 cmd_append_size
+= sizeof(chan_tlv
->header
) +
1098 sizeof(struct mwifiex_chan_scan_param_set
);
1101 if (priv
->sec_info
.wpa_enabled
)
1102 rsn_ie_len
= mwifiex_append_rsn_ie_wpa_wpa2(priv
, &pos
);
1103 if (rsn_ie_len
== -1)
1105 cmd_append_size
+= rsn_ie_len
;
1107 if (ISSUPP_11NENABLED(priv
->adapter
->fw_cap_info
))
1108 cmd_append_size
+= mwifiex_cmd_append_11n_tlv(priv
,
1111 /* Append vendor specific IE TLV */
1112 cmd_append_size
+= mwifiex_cmd_append_vsie_tlv(priv
,
1113 MWIFIEX_VSIE_MASK_ADHOC
, &pos
);
1115 cmd
->size
= cpu_to_le16
1116 ((u16
) (sizeof(struct host_cmd_ds_802_11_ad_hoc_join
)
1117 + S_DS_GEN
+ cmd_append_size
));
1119 adhoc_join
->bss_descriptor
.cap_info_bitmap
= cpu_to_le16(tmp_cap
);
1125 * This function handles the command response of ad-hoc start and
1128 * The function generates a device-connected event to notify
1129 * the applications, in case of successful ad-hoc start/join, and
1130 * saves the beacon buffer.
1132 int mwifiex_ret_802_11_ad_hoc(struct mwifiex_private
*priv
,
1133 struct host_cmd_ds_command
*resp
)
1136 struct mwifiex_adapter
*adapter
= priv
->adapter
;
1137 struct host_cmd_ds_802_11_ad_hoc_result
*adhoc_result
;
1138 struct mwifiex_bssdescriptor
*bss_desc
;
1140 adhoc_result
= &resp
->params
.adhoc_result
;
1142 bss_desc
= priv
->attempted_bss_desc
;
1144 /* Join result code 0 --> SUCCESS */
1145 if (le16_to_cpu(resp
->result
)) {
1146 dev_err(priv
->adapter
->dev
, "ADHOC_RESP: failed\n");
1147 if (priv
->media_connected
)
1148 mwifiex_reset_connect_state(priv
);
1150 memset(&priv
->curr_bss_params
.bss_descriptor
,
1151 0x00, sizeof(struct mwifiex_bssdescriptor
));
1157 /* Send a Media Connected event, according to the Spec */
1158 priv
->media_connected
= true;
1160 if (le16_to_cpu(resp
->command
) == HostCmd_CMD_802_11_AD_HOC_START
) {
1161 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_S_RESP %s\n",
1162 bss_desc
->ssid
.ssid
);
1164 /* Update the created network descriptor with the new BSSID */
1165 memcpy(bss_desc
->mac_address
,
1166 adhoc_result
->bssid
, ETH_ALEN
);
1168 priv
->adhoc_state
= ADHOC_STARTED
;
1171 * Now the join cmd should be successful.
1172 * If BSSID has changed use SSID to compare instead of BSSID
1174 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_J_RESP %s\n",
1175 bss_desc
->ssid
.ssid
);
1178 * Make a copy of current BSSID descriptor, only needed for
1179 * join since the current descriptor is already being used
1182 memcpy(&priv
->curr_bss_params
.bss_descriptor
,
1183 bss_desc
, sizeof(struct mwifiex_bssdescriptor
));
1185 priv
->adhoc_state
= ADHOC_JOINED
;
1188 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_RESP: channel = %d\n",
1189 priv
->adhoc_channel
);
1190 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_RESP: BSSID = %pM\n",
1191 priv
->curr_bss_params
.bss_descriptor
.mac_address
);
1193 if (!netif_carrier_ok(priv
->netdev
))
1194 netif_carrier_on(priv
->netdev
);
1195 if (netif_queue_stopped(priv
->netdev
))
1196 netif_wake_queue(priv
->netdev
);
1198 mwifiex_save_curr_bcn(priv
);
1201 /* Need to indicate IOCTL complete */
1202 if (adapter
->curr_cmd
->wait_q_enabled
) {
1204 adapter
->cmd_wait_q
.status
= -1;
1206 adapter
->cmd_wait_q
.status
= 0;
1214 * This function associates to a specific BSS discovered in a scan.
1216 * It clears any past association response stored for application
1217 * retrieval and calls the command preparation routine to send the
1218 * command to firmware.
1220 int mwifiex_associate(struct mwifiex_private
*priv
,
1221 struct mwifiex_bssdescriptor
*bss_desc
)
1223 u8 current_bssid
[ETH_ALEN
];
1225 /* Return error if the adapter or table entry is not marked as infra */
1226 if ((priv
->bss_mode
!= NL80211_IFTYPE_STATION
) ||
1227 (bss_desc
->bss_mode
!= NL80211_IFTYPE_STATION
))
1230 memcpy(¤t_bssid
,
1231 &priv
->curr_bss_params
.bss_descriptor
.mac_address
,
1232 sizeof(current_bssid
));
1234 /* Clear any past association response stored for application
1236 priv
->assoc_rsp_size
= 0;
1238 return mwifiex_send_cmd_sync(priv
, HostCmd_CMD_802_11_ASSOCIATE
,
1239 HostCmd_ACT_GEN_SET
, 0, bss_desc
);
1243 * This function starts an ad-hoc network.
1245 * It calls the command preparation routine to send the command to firmware.
1248 mwifiex_adhoc_start(struct mwifiex_private
*priv
,
1249 struct cfg80211_ssid
*adhoc_ssid
)
1251 dev_dbg(priv
->adapter
->dev
, "info: Adhoc Channel = %d\n",
1252 priv
->adhoc_channel
);
1253 dev_dbg(priv
->adapter
->dev
, "info: curr_bss_params.channel = %d\n",
1254 priv
->curr_bss_params
.bss_descriptor
.channel
);
1255 dev_dbg(priv
->adapter
->dev
, "info: curr_bss_params.band = %d\n",
1256 priv
->curr_bss_params
.band
);
1258 return mwifiex_send_cmd_sync(priv
, HostCmd_CMD_802_11_AD_HOC_START
,
1259 HostCmd_ACT_GEN_SET
, 0, adhoc_ssid
);
1263 * This function joins an ad-hoc network found in a previous scan.
1265 * It calls the command preparation routine to send the command to firmware,
1266 * if already not connected to the requested SSID.
1268 int mwifiex_adhoc_join(struct mwifiex_private
*priv
,
1269 struct mwifiex_bssdescriptor
*bss_desc
)
1271 dev_dbg(priv
->adapter
->dev
, "info: adhoc join: curr_bss ssid =%s\n",
1272 priv
->curr_bss_params
.bss_descriptor
.ssid
.ssid
);
1273 dev_dbg(priv
->adapter
->dev
, "info: adhoc join: curr_bss ssid_len =%u\n",
1274 priv
->curr_bss_params
.bss_descriptor
.ssid
.ssid_len
);
1275 dev_dbg(priv
->adapter
->dev
, "info: adhoc join: ssid =%s\n",
1276 bss_desc
->ssid
.ssid
);
1277 dev_dbg(priv
->adapter
->dev
, "info: adhoc join: ssid_len =%u\n",
1278 bss_desc
->ssid
.ssid_len
);
1280 /* Check if the requested SSID is already joined */
1281 if (priv
->curr_bss_params
.bss_descriptor
.ssid
.ssid_len
&&
1282 !mwifiex_ssid_cmp(&bss_desc
->ssid
,
1283 &priv
->curr_bss_params
.bss_descriptor
.ssid
) &&
1284 (priv
->curr_bss_params
.bss_descriptor
.bss_mode
==
1285 NL80211_IFTYPE_ADHOC
)) {
1286 dev_dbg(priv
->adapter
->dev
, "info: ADHOC_J_CMD: new ad-hoc SSID"
1287 " is the same as current; not attempting to re-join\n");
1291 dev_dbg(priv
->adapter
->dev
, "info: curr_bss_params.channel = %d\n",
1292 priv
->curr_bss_params
.bss_descriptor
.channel
);
1293 dev_dbg(priv
->adapter
->dev
, "info: curr_bss_params.band = %c\n",
1294 priv
->curr_bss_params
.band
);
1296 return mwifiex_send_cmd_sync(priv
, HostCmd_CMD_802_11_AD_HOC_JOIN
,
1297 HostCmd_ACT_GEN_SET
, 0, bss_desc
);
1301 * This function deauthenticates/disconnects from infra network by sending
1302 * deauthentication request.
1304 static int mwifiex_deauthenticate_infra(struct mwifiex_private
*priv
, u8
*mac
)
1306 u8 mac_address
[ETH_ALEN
];
1308 u8 zero_mac
[ETH_ALEN
] = { 0, 0, 0, 0, 0, 0 };
1311 if (!memcmp(mac
, zero_mac
, sizeof(zero_mac
)))
1312 memcpy((u8
*) &mac_address
,
1313 (u8
*) &priv
->curr_bss_params
.bss_descriptor
.
1314 mac_address
, ETH_ALEN
);
1316 memcpy((u8
*) &mac_address
, (u8
*) mac
, ETH_ALEN
);
1318 memcpy((u8
*) &mac_address
, (u8
*) &priv
->curr_bss_params
.
1319 bss_descriptor
.mac_address
, ETH_ALEN
);
1322 ret
= mwifiex_send_cmd_sync(priv
, HostCmd_CMD_802_11_DEAUTHENTICATE
,
1323 HostCmd_ACT_GEN_SET
, 0, &mac_address
);
1329 * This function deauthenticates/disconnects from a BSS.
1331 * In case of infra made, it sends deauthentication request, and
1332 * in case of ad-hoc mode, a stop network request is sent to the firmware.
1334 int mwifiex_deauthenticate(struct mwifiex_private
*priv
, u8
*mac
)
1338 if (priv
->media_connected
) {
1339 if (priv
->bss_mode
== NL80211_IFTYPE_STATION
) {
1340 ret
= mwifiex_deauthenticate_infra(priv
, mac
);
1341 } else if (priv
->bss_mode
== NL80211_IFTYPE_ADHOC
) {
1342 ret
= mwifiex_send_cmd_sync(priv
,
1343 HostCmd_CMD_802_11_AD_HOC_STOP
,
1344 HostCmd_ACT_GEN_SET
, 0, NULL
);
1350 EXPORT_SYMBOL_GPL(mwifiex_deauthenticate
);
1353 * This function converts band to radio type used in channel TLV.
1356 mwifiex_band_to_radio_type(u8 band
)
1361 case BAND_A
| BAND_AN
:
1362 return HostCmd_SCAN_RADIO_TYPE_A
;
1365 case BAND_B
| BAND_G
:
1367 return HostCmd_SCAN_RADIO_TYPE_BG
;