1 /* Copyright (C) 2006, Red Hat, Inc. */
3 #include <linux/types.h>
4 #include <linux/etherdevice.h>
5 #include <linux/ieee80211.h>
6 #include <linux/if_arp.h>
7 #include <net/lib80211.h>
15 static const u8 bssid_any
[ETH_ALEN
] __attribute__ ((aligned (2))) =
16 { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
17 static const u8 bssid_off
[ETH_ALEN
] __attribute__ ((aligned (2))) =
18 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
20 /* The firmware needs the following bits masked out of the beacon-derived
21 * capability field when associating/joining to a BSS:
22 * 9 (QoS), 11 (APSD), 12 (unused), 14 (unused), 15 (unused)
24 #define CAPINFO_MASK (~(0xda00))
27 * 802.11b/g supported bitrates (in 500Kb/s units)
29 u8 lbs_bg_rates
[MAX_RATES
] =
30 { 0x02, 0x04, 0x0b, 0x16, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6c,
35 * @brief This function finds common rates between rates and card rates.
37 * It will fill common rates in rates as output if found.
39 * NOTE: Setting the MSB of the basic rates need to be taken
40 * care, either before or after calling this function
42 * @param priv A pointer to struct lbs_private structure
43 * @param rates the buffer which keeps input and output
44 * @param rates_size the size of rates buffer; new size of buffer on return,
45 * which will be less than or equal to original rates_size
47 * @return 0 on success, or -1 on error
49 static int get_common_rates(struct lbs_private
*priv
,
54 u8 intersection
[MAX_RATES
];
55 u16 intersection_size
;
58 intersection_size
= min_t(u16
, *rates_size
, ARRAY_SIZE(intersection
));
60 /* Allow each rate from 'rates' that is supported by the hardware */
61 for (i
= 0; i
< ARRAY_SIZE(lbs_bg_rates
) && lbs_bg_rates
[i
]; i
++) {
62 for (j
= 0; j
< intersection_size
&& rates
[j
]; j
++) {
63 if (rates
[j
] == lbs_bg_rates
[i
])
64 intersection
[num_rates
++] = rates
[j
];
68 lbs_deb_hex(LBS_DEB_JOIN
, "AP rates ", rates
, *rates_size
);
69 lbs_deb_hex(LBS_DEB_JOIN
, "card rates ", lbs_bg_rates
,
70 ARRAY_SIZE(lbs_bg_rates
));
71 lbs_deb_hex(LBS_DEB_JOIN
, "common rates", intersection
, num_rates
);
72 lbs_deb_join("TX data rate 0x%02x\n", priv
->cur_rate
);
74 if (!priv
->enablehwauto
) {
75 for (i
= 0; i
< num_rates
; i
++) {
76 if (intersection
[i
] == priv
->cur_rate
)
79 lbs_pr_alert("Previously set fixed data rate %#x isn't "
80 "compatible with the network.\n", priv
->cur_rate
);
85 memset(rates
, 0, *rates_size
);
86 *rates_size
= num_rates
;
87 memcpy(rates
, intersection
, num_rates
);
93 * @brief Sets the MSB on basic rates as the firmware requires
95 * Scan through an array and set the MSB for basic data rates.
97 * @param rates buffer of data rates
98 * @param len size of buffer
100 static void lbs_set_basic_rate_flags(u8
*rates
, size_t len
)
104 for (i
= 0; i
< len
; i
++) {
105 if (rates
[i
] == 0x02 || rates
[i
] == 0x04 ||
106 rates
[i
] == 0x0b || rates
[i
] == 0x16)
112 static u8
iw_auth_to_ieee_auth(u8 auth
)
114 if (auth
== IW_AUTH_ALG_OPEN_SYSTEM
)
116 else if (auth
== IW_AUTH_ALG_SHARED_KEY
)
118 else if (auth
== IW_AUTH_ALG_LEAP
)
121 lbs_deb_join("%s: invalid auth alg 0x%X\n", __func__
, auth
);
126 * @brief This function prepares the authenticate command. AUTHENTICATE only
127 * sets the authentication suite for future associations, as the firmware
128 * handles authentication internally during the ASSOCIATE command.
130 * @param priv A pointer to struct lbs_private structure
131 * @param bssid The peer BSSID with which to authenticate
132 * @param auth The authentication mode to use (from wireless.h)
136 static int lbs_set_authentication(struct lbs_private
*priv
, u8 bssid
[6], u8 auth
)
138 struct cmd_ds_802_11_authenticate cmd
;
141 lbs_deb_enter(LBS_DEB_JOIN
);
143 cmd
.hdr
.size
= cpu_to_le16(sizeof(cmd
));
144 memcpy(cmd
.bssid
, bssid
, ETH_ALEN
);
146 cmd
.authtype
= iw_auth_to_ieee_auth(auth
);
148 lbs_deb_join("AUTH_CMD: BSSID %pM, auth 0x%x\n", bssid
, cmd
.authtype
);
150 ret
= lbs_cmd_with_response(priv
, CMD_802_11_AUTHENTICATE
, &cmd
);
152 lbs_deb_leave_args(LBS_DEB_JOIN
, "ret %d", ret
);
157 int lbs_cmd_802_11_set_wep(struct lbs_private
*priv
, uint16_t cmd_action
,
158 struct assoc_request
*assoc
)
160 struct cmd_ds_802_11_set_wep cmd
;
163 lbs_deb_enter(LBS_DEB_CMD
);
165 memset(&cmd
, 0, sizeof(cmd
));
166 cmd
.hdr
.command
= cpu_to_le16(CMD_802_11_SET_WEP
);
167 cmd
.hdr
.size
= cpu_to_le16(sizeof(cmd
));
169 cmd
.action
= cpu_to_le16(cmd_action
);
171 if (cmd_action
== CMD_ACT_ADD
) {
174 /* default tx key index */
175 cmd
.keyindex
= cpu_to_le16(assoc
->wep_tx_keyidx
&
176 CMD_WEP_KEY_INDEX_MASK
);
178 /* Copy key types and material to host command structure */
179 for (i
= 0; i
< 4; i
++) {
180 struct enc_key
*pkey
= &assoc
->wep_keys
[i
];
184 cmd
.keytype
[i
] = CMD_TYPE_WEP_40_BIT
;
185 memmove(cmd
.keymaterial
[i
], pkey
->key
, pkey
->len
);
186 lbs_deb_cmd("SET_WEP: add key %d (40 bit)\n", i
);
188 case KEY_LEN_WEP_104
:
189 cmd
.keytype
[i
] = CMD_TYPE_WEP_104_BIT
;
190 memmove(cmd
.keymaterial
[i
], pkey
->key
, pkey
->len
);
191 lbs_deb_cmd("SET_WEP: add key %d (104 bit)\n", i
);
196 lbs_deb_cmd("SET_WEP: invalid key %d, length %d\n",
203 } else if (cmd_action
== CMD_ACT_REMOVE
) {
204 /* ACT_REMOVE clears _all_ WEP keys */
206 /* default tx key index */
207 cmd
.keyindex
= cpu_to_le16(priv
->wep_tx_keyidx
&
208 CMD_WEP_KEY_INDEX_MASK
);
209 lbs_deb_cmd("SET_WEP: remove key %d\n", priv
->wep_tx_keyidx
);
212 ret
= lbs_cmd_with_response(priv
, CMD_802_11_SET_WEP
, &cmd
);
214 lbs_deb_leave_args(LBS_DEB_CMD
, "ret %d", ret
);
218 int lbs_cmd_802_11_enable_rsn(struct lbs_private
*priv
, uint16_t cmd_action
,
221 struct cmd_ds_802_11_enable_rsn cmd
;
224 lbs_deb_enter(LBS_DEB_CMD
);
226 cmd
.hdr
.size
= cpu_to_le16(sizeof(cmd
));
227 cmd
.action
= cpu_to_le16(cmd_action
);
229 if (cmd_action
== CMD_ACT_GET
)
233 cmd
.enable
= cpu_to_le16(CMD_ENABLE_RSN
);
235 cmd
.enable
= cpu_to_le16(CMD_DISABLE_RSN
);
236 lbs_deb_cmd("ENABLE_RSN: %d\n", *enable
);
239 ret
= lbs_cmd_with_response(priv
, CMD_802_11_ENABLE_RSN
, &cmd
);
240 if (!ret
&& cmd_action
== CMD_ACT_GET
)
241 *enable
= le16_to_cpu(cmd
.enable
);
243 lbs_deb_leave_args(LBS_DEB_CMD
, "ret %d", ret
);
247 static void set_one_wpa_key(struct MrvlIEtype_keyParamSet
*keyparam
,
250 lbs_deb_enter(LBS_DEB_CMD
);
252 if (key
->flags
& KEY_INFO_WPA_ENABLED
)
253 keyparam
->keyinfo
|= cpu_to_le16(KEY_INFO_WPA_ENABLED
);
254 if (key
->flags
& KEY_INFO_WPA_UNICAST
)
255 keyparam
->keyinfo
|= cpu_to_le16(KEY_INFO_WPA_UNICAST
);
256 if (key
->flags
& KEY_INFO_WPA_MCAST
)
257 keyparam
->keyinfo
|= cpu_to_le16(KEY_INFO_WPA_MCAST
);
259 keyparam
->type
= cpu_to_le16(TLV_TYPE_KEY_MATERIAL
);
260 keyparam
->keytypeid
= cpu_to_le16(key
->type
);
261 keyparam
->keylen
= cpu_to_le16(key
->len
);
262 memcpy(keyparam
->key
, key
->key
, key
->len
);
264 /* Length field doesn't include the {type,length} header */
265 keyparam
->length
= cpu_to_le16(sizeof(*keyparam
) - 4);
266 lbs_deb_leave(LBS_DEB_CMD
);
269 int lbs_cmd_802_11_key_material(struct lbs_private
*priv
, uint16_t cmd_action
,
270 struct assoc_request
*assoc
)
272 struct cmd_ds_802_11_key_material cmd
;
276 lbs_deb_enter(LBS_DEB_CMD
);
278 cmd
.action
= cpu_to_le16(cmd_action
);
279 cmd
.hdr
.size
= cpu_to_le16(sizeof(cmd
));
281 if (cmd_action
== CMD_ACT_GET
) {
282 cmd
.hdr
.size
= cpu_to_le16(sizeof(struct cmd_header
) + 2);
284 memset(cmd
.keyParamSet
, 0, sizeof(cmd
.keyParamSet
));
286 if (test_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc
->flags
)) {
287 set_one_wpa_key(&cmd
.keyParamSet
[index
],
288 &assoc
->wpa_unicast_key
);
292 if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc
->flags
)) {
293 set_one_wpa_key(&cmd
.keyParamSet
[index
],
294 &assoc
->wpa_mcast_key
);
298 /* The common header and as many keys as we included */
299 cmd
.hdr
.size
= cpu_to_le16(offsetof(typeof(cmd
),
300 keyParamSet
[index
]));
302 ret
= lbs_cmd_with_response(priv
, CMD_802_11_KEY_MATERIAL
, &cmd
);
303 /* Copy the returned key to driver private data */
304 if (!ret
&& cmd_action
== CMD_ACT_GET
) {
305 void *buf_ptr
= cmd
.keyParamSet
;
306 void *resp_end
= &(&cmd
)[1];
308 while (buf_ptr
< resp_end
) {
309 struct MrvlIEtype_keyParamSet
*keyparam
= buf_ptr
;
311 uint16_t param_set_len
= le16_to_cpu(keyparam
->length
);
312 uint16_t key_len
= le16_to_cpu(keyparam
->keylen
);
313 uint16_t key_flags
= le16_to_cpu(keyparam
->keyinfo
);
314 uint16_t key_type
= le16_to_cpu(keyparam
->keytypeid
);
317 end
= (void *)keyparam
+ sizeof(keyparam
->type
)
318 + sizeof(keyparam
->length
) + param_set_len
;
320 /* Make sure we don't access past the end of the IEs */
324 if (key_flags
& KEY_INFO_WPA_UNICAST
)
325 key
= &priv
->wpa_unicast_key
;
326 else if (key_flags
& KEY_INFO_WPA_MCAST
)
327 key
= &priv
->wpa_mcast_key
;
331 /* Copy returned key into driver */
332 memset(key
, 0, sizeof(struct enc_key
));
333 if (key_len
> sizeof(key
->key
))
335 key
->type
= key_type
;
336 key
->flags
= key_flags
;
338 memcpy(key
->key
, keyparam
->key
, key
->len
);
344 lbs_deb_leave_args(LBS_DEB_CMD
, "ret %d", ret
);
348 static __le16
lbs_rate_to_fw_bitmap(int rate
, int lower_rates_ok
)
368 int i
= lbs_data_rate_to_fw_index(rate
);
370 ratemask
= (0x1fef >> (12 - i
));
373 return cpu_to_le16(ratemask
);
376 int lbs_cmd_802_11_rate_adapt_rateset(struct lbs_private
*priv
,
379 struct cmd_ds_802_11_rate_adapt_rateset cmd
;
382 lbs_deb_enter(LBS_DEB_CMD
);
384 if (!priv
->cur_rate
&& !priv
->enablehwauto
)
387 cmd
.hdr
.size
= cpu_to_le16(sizeof(cmd
));
389 cmd
.action
= cpu_to_le16(cmd_action
);
390 cmd
.enablehwauto
= cpu_to_le16(priv
->enablehwauto
);
391 cmd
.bitmap
= lbs_rate_to_fw_bitmap(priv
->cur_rate
, priv
->enablehwauto
);
392 ret
= lbs_cmd_with_response(priv
, CMD_802_11_RATE_ADAPT_RATESET
, &cmd
);
393 if (!ret
&& cmd_action
== CMD_ACT_GET
)
394 priv
->enablehwauto
= le16_to_cpu(cmd
.enablehwauto
);
396 lbs_deb_leave_args(LBS_DEB_CMD
, "ret %d", ret
);
401 * @brief Set the data rate
403 * @param priv A pointer to struct lbs_private structure
404 * @param rate The desired data rate, or 0 to clear a locked rate
406 * @return 0 on success, error on failure
408 int lbs_set_data_rate(struct lbs_private
*priv
, u8 rate
)
410 struct cmd_ds_802_11_data_rate cmd
;
413 lbs_deb_enter(LBS_DEB_CMD
);
415 memset(&cmd
, 0, sizeof(cmd
));
416 cmd
.hdr
.size
= cpu_to_le16(sizeof(cmd
));
419 cmd
.action
= cpu_to_le16(CMD_ACT_SET_TX_FIX_RATE
);
420 cmd
.rates
[0] = lbs_data_rate_to_fw_index(rate
);
421 if (cmd
.rates
[0] == 0) {
422 lbs_deb_cmd("DATA_RATE: invalid requested rate of"
427 lbs_deb_cmd("DATA_RATE: set fixed 0x%02X\n", cmd
.rates
[0]);
429 cmd
.action
= cpu_to_le16(CMD_ACT_SET_TX_AUTO
);
430 lbs_deb_cmd("DATA_RATE: setting auto\n");
433 ret
= lbs_cmd_with_response(priv
, CMD_802_11_DATA_RATE
, &cmd
);
437 lbs_deb_hex(LBS_DEB_CMD
, "DATA_RATE_RESP", (u8
*) &cmd
, sizeof(cmd
));
439 /* FIXME: get actual rates FW can do if this command actually returns
440 * all data rates supported.
442 priv
->cur_rate
= lbs_fw_index_to_data_rate(cmd
.rates
[0]);
443 lbs_deb_cmd("DATA_RATE: current rate is 0x%02x\n", priv
->cur_rate
);
446 lbs_deb_leave_args(LBS_DEB_CMD
, "ret %d", ret
);
451 int lbs_cmd_802_11_rssi(struct lbs_private
*priv
,
452 struct cmd_ds_command
*cmd
)
455 lbs_deb_enter(LBS_DEB_CMD
);
456 cmd
->command
= cpu_to_le16(CMD_802_11_RSSI
);
457 cmd
->size
= cpu_to_le16(sizeof(struct cmd_ds_802_11_rssi
) +
458 sizeof(struct cmd_header
));
459 cmd
->params
.rssi
.N
= cpu_to_le16(DEFAULT_BCN_AVG_FACTOR
);
461 /* reset Beacon SNR/NF/RSSI values */
462 priv
->SNR
[TYPE_BEACON
][TYPE_NOAVG
] = 0;
463 priv
->SNR
[TYPE_BEACON
][TYPE_AVG
] = 0;
464 priv
->NF
[TYPE_BEACON
][TYPE_NOAVG
] = 0;
465 priv
->NF
[TYPE_BEACON
][TYPE_AVG
] = 0;
466 priv
->RSSI
[TYPE_BEACON
][TYPE_NOAVG
] = 0;
467 priv
->RSSI
[TYPE_BEACON
][TYPE_AVG
] = 0;
469 lbs_deb_leave(LBS_DEB_CMD
);
473 int lbs_ret_802_11_rssi(struct lbs_private
*priv
,
474 struct cmd_ds_command
*resp
)
476 struct cmd_ds_802_11_rssi_rsp
*rssirsp
= &resp
->params
.rssirsp
;
478 lbs_deb_enter(LBS_DEB_CMD
);
480 /* store the non average value */
481 priv
->SNR
[TYPE_BEACON
][TYPE_NOAVG
] = get_unaligned_le16(&rssirsp
->SNR
);
482 priv
->NF
[TYPE_BEACON
][TYPE_NOAVG
] =
483 get_unaligned_le16(&rssirsp
->noisefloor
);
485 priv
->SNR
[TYPE_BEACON
][TYPE_AVG
] = get_unaligned_le16(&rssirsp
->avgSNR
);
486 priv
->NF
[TYPE_BEACON
][TYPE_AVG
] =
487 get_unaligned_le16(&rssirsp
->avgnoisefloor
);
489 priv
->RSSI
[TYPE_BEACON
][TYPE_NOAVG
] =
490 CAL_RSSI(priv
->SNR
[TYPE_BEACON
][TYPE_NOAVG
],
491 priv
->NF
[TYPE_BEACON
][TYPE_NOAVG
]);
493 priv
->RSSI
[TYPE_BEACON
][TYPE_AVG
] =
494 CAL_RSSI(priv
->SNR
[TYPE_BEACON
][TYPE_AVG
] / AVG_SCALE
,
495 priv
->NF
[TYPE_BEACON
][TYPE_AVG
] / AVG_SCALE
);
497 lbs_deb_cmd("RSSI: beacon %d, avg %d\n",
498 priv
->RSSI
[TYPE_BEACON
][TYPE_NOAVG
],
499 priv
->RSSI
[TYPE_BEACON
][TYPE_AVG
]);
501 lbs_deb_leave(LBS_DEB_CMD
);
506 int lbs_cmd_bcn_ctrl(struct lbs_private
*priv
,
507 struct cmd_ds_command
*cmd
,
510 struct cmd_ds_802_11_beacon_control
511 *bcn_ctrl
= &cmd
->params
.bcn_ctrl
;
513 lbs_deb_enter(LBS_DEB_CMD
);
515 cpu_to_le16(sizeof(struct cmd_ds_802_11_beacon_control
)
516 + sizeof(struct cmd_header
));
517 cmd
->command
= cpu_to_le16(CMD_802_11_BEACON_CTRL
);
519 bcn_ctrl
->action
= cpu_to_le16(cmd_action
);
520 bcn_ctrl
->beacon_enable
= cpu_to_le16(priv
->beacon_enable
);
521 bcn_ctrl
->beacon_period
= cpu_to_le16(priv
->beacon_period
);
523 lbs_deb_leave(LBS_DEB_CMD
);
527 int lbs_ret_802_11_bcn_ctrl(struct lbs_private
*priv
,
528 struct cmd_ds_command
*resp
)
530 struct cmd_ds_802_11_beacon_control
*bcn_ctrl
=
531 &resp
->params
.bcn_ctrl
;
533 lbs_deb_enter(LBS_DEB_CMD
);
535 if (bcn_ctrl
->action
== CMD_ACT_GET
) {
536 priv
->beacon_enable
= (u8
) le16_to_cpu(bcn_ctrl
->beacon_enable
);
537 priv
->beacon_period
= le16_to_cpu(bcn_ctrl
->beacon_period
);
540 lbs_deb_enter(LBS_DEB_CMD
);
546 static int lbs_assoc_post(struct lbs_private
*priv
,
547 struct cmd_ds_802_11_associate_response
*resp
)
550 union iwreq_data wrqu
;
551 struct bss_descriptor
*bss
;
554 lbs_deb_enter(LBS_DEB_ASSOC
);
556 if (!priv
->in_progress_assoc_req
) {
557 lbs_deb_assoc("ASSOC_RESP: no in-progress assoc request\n");
561 bss
= &priv
->in_progress_assoc_req
->bss
;
564 * Older FW versions map the IEEE 802.11 Status Code in the association
565 * response to the following values returned in resp->statuscode:
567 * IEEE Status Code Marvell Status Code
568 * 0 -> 0x0000 ASSOC_RESULT_SUCCESS
569 * 13 -> 0x0004 ASSOC_RESULT_AUTH_REFUSED
570 * 14 -> 0x0004 ASSOC_RESULT_AUTH_REFUSED
571 * 15 -> 0x0004 ASSOC_RESULT_AUTH_REFUSED
572 * 16 -> 0x0004 ASSOC_RESULT_AUTH_REFUSED
573 * others -> 0x0003 ASSOC_RESULT_REFUSED
575 * Other response codes:
576 * 0x0001 -> ASSOC_RESULT_INVALID_PARAMETERS (unused)
577 * 0x0002 -> ASSOC_RESULT_TIMEOUT (internal timer expired waiting for
578 * association response from the AP)
581 status_code
= le16_to_cpu(resp
->statuscode
);
582 if (priv
->fwrelease
< 0x09000000) {
583 switch (status_code
) {
587 lbs_deb_assoc("ASSOC_RESP: invalid parameters\n");
590 lbs_deb_assoc("ASSOC_RESP: internal timer "
591 "expired while waiting for the AP\n");
594 lbs_deb_assoc("ASSOC_RESP: association "
598 lbs_deb_assoc("ASSOC_RESP: authentication "
602 lbs_deb_assoc("ASSOC_RESP: failure reason 0x%02x "
603 " unknown\n", status_code
);
607 /* v9+ returns the AP's association response */
608 lbs_deb_assoc("ASSOC_RESP: failure reason 0x%02x\n", status_code
);
612 lbs_mac_event_disconnected(priv
);
617 lbs_deb_hex(LBS_DEB_ASSOC
, "ASSOC_RESP",
618 (void *) (resp
+ sizeof (resp
->hdr
)),
619 le16_to_cpu(resp
->hdr
.size
) - sizeof (resp
->hdr
));
621 /* Send a Media Connected event, according to the Spec */
622 priv
->connect_status
= LBS_CONNECTED
;
624 /* Update current SSID and BSSID */
625 memcpy(&priv
->curbssparams
.ssid
, &bss
->ssid
, IEEE80211_MAX_SSID_LEN
);
626 priv
->curbssparams
.ssid_len
= bss
->ssid_len
;
627 memcpy(priv
->curbssparams
.bssid
, bss
->bssid
, ETH_ALEN
);
629 priv
->SNR
[TYPE_RXPD
][TYPE_AVG
] = 0;
630 priv
->NF
[TYPE_RXPD
][TYPE_AVG
] = 0;
632 memset(priv
->rawSNR
, 0x00, sizeof(priv
->rawSNR
));
633 memset(priv
->rawNF
, 0x00, sizeof(priv
->rawNF
));
637 netif_carrier_on(priv
->dev
);
638 if (!priv
->tx_pending_len
)
639 netif_wake_queue(priv
->dev
);
641 memcpy(wrqu
.ap_addr
.sa_data
, priv
->curbssparams
.bssid
, ETH_ALEN
);
642 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
643 wireless_send_event(priv
->dev
, SIOCGIWAP
, &wrqu
, NULL
);
646 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
651 * @brief This function prepares an association-class command.
653 * @param priv A pointer to struct lbs_private structure
654 * @param assoc_req The association request describing the BSS to associate
655 * or reassociate with
656 * @param command The actual command, either CMD_802_11_ASSOCIATE or
657 * CMD_802_11_REASSOCIATE
661 static int lbs_associate(struct lbs_private
*priv
,
662 struct assoc_request
*assoc_req
,
665 struct cmd_ds_802_11_associate cmd
;
667 struct bss_descriptor
*bss
= &assoc_req
->bss
;
668 u8
*pos
= &(cmd
.iebuf
[0]);
669 u16 tmpcap
, tmplen
, tmpauth
;
670 struct mrvl_ie_ssid_param_set
*ssid
;
671 struct mrvl_ie_ds_param_set
*ds
;
672 struct mrvl_ie_cf_param_set
*cf
;
673 struct mrvl_ie_rates_param_set
*rates
;
674 struct mrvl_ie_rsn_param_set
*rsn
;
675 struct mrvl_ie_auth_type
*auth
;
677 lbs_deb_enter(LBS_DEB_ASSOC
);
679 BUG_ON((command
!= CMD_802_11_ASSOCIATE
) &&
680 (command
!= CMD_802_11_REASSOCIATE
));
682 memset(&cmd
, 0, sizeof(cmd
));
683 cmd
.hdr
.command
= cpu_to_le16(command
);
685 /* Fill in static fields */
686 memcpy(cmd
.bssid
, bss
->bssid
, ETH_ALEN
);
687 cmd
.listeninterval
= cpu_to_le16(MRVDRV_DEFAULT_LISTEN_INTERVAL
);
689 /* Capability info */
690 tmpcap
= (bss
->capability
& CAPINFO_MASK
);
691 if (bss
->mode
== IW_MODE_INFRA
)
692 tmpcap
|= WLAN_CAPABILITY_ESS
;
693 cmd
.capability
= cpu_to_le16(tmpcap
);
694 lbs_deb_assoc("ASSOC_CMD: capability 0x%04x\n", tmpcap
);
697 ssid
= (struct mrvl_ie_ssid_param_set
*) pos
;
698 ssid
->header
.type
= cpu_to_le16(TLV_TYPE_SSID
);
699 tmplen
= bss
->ssid_len
;
700 ssid
->header
.len
= cpu_to_le16(tmplen
);
701 memcpy(ssid
->ssid
, bss
->ssid
, tmplen
);
702 pos
+= sizeof(ssid
->header
) + tmplen
;
704 ds
= (struct mrvl_ie_ds_param_set
*) pos
;
705 ds
->header
.type
= cpu_to_le16(TLV_TYPE_PHY_DS
);
706 ds
->header
.len
= cpu_to_le16(1);
707 ds
->channel
= bss
->phy
.ds
.channel
;
708 pos
+= sizeof(ds
->header
) + 1;
710 cf
= (struct mrvl_ie_cf_param_set
*) pos
;
711 cf
->header
.type
= cpu_to_le16(TLV_TYPE_CF
);
712 tmplen
= sizeof(*cf
) - sizeof (cf
->header
);
713 cf
->header
.len
= cpu_to_le16(tmplen
);
714 /* IE payload should be zeroed, firmware fills it in for us */
717 rates
= (struct mrvl_ie_rates_param_set
*) pos
;
718 rates
->header
.type
= cpu_to_le16(TLV_TYPE_RATES
);
719 tmplen
= min_t(u16
, ARRAY_SIZE(bss
->rates
), MAX_RATES
);
720 memcpy(&rates
->rates
, &bss
->rates
, tmplen
);
721 if (get_common_rates(priv
, rates
->rates
, &tmplen
)) {
725 pos
+= sizeof(rates
->header
) + tmplen
;
726 rates
->header
.len
= cpu_to_le16(tmplen
);
727 lbs_deb_assoc("ASSOC_CMD: num rates %u\n", tmplen
);
729 /* Copy the infra. association rates into Current BSS state structure */
730 memset(&priv
->curbssparams
.rates
, 0, sizeof(priv
->curbssparams
.rates
));
731 memcpy(&priv
->curbssparams
.rates
, &rates
->rates
, tmplen
);
733 /* Set MSB on basic rates as the firmware requires, but _after_
734 * copying to current bss rates.
736 lbs_set_basic_rate_flags(rates
->rates
, tmplen
);
738 /* Firmware v9+ indicate authentication suites as a TLV */
739 if (priv
->fwrelease
>= 0x09000000) {
740 auth
= (struct mrvl_ie_auth_type
*) pos
;
741 auth
->header
.type
= cpu_to_le16(TLV_TYPE_AUTH_TYPE
);
742 auth
->header
.len
= cpu_to_le16(2);
743 tmpauth
= iw_auth_to_ieee_auth(priv
->secinfo
.auth_mode
);
744 auth
->auth
= cpu_to_le16(tmpauth
);
745 pos
+= sizeof(auth
->header
) + 2;
747 lbs_deb_join("AUTH_CMD: BSSID %pM, auth 0x%x\n",
748 bss
->bssid
, priv
->secinfo
.auth_mode
);
752 if (assoc_req
->secinfo
.WPAenabled
|| assoc_req
->secinfo
.WPA2enabled
) {
753 rsn
= (struct mrvl_ie_rsn_param_set
*) pos
;
754 /* WPA_IE or WPA2_IE */
755 rsn
->header
.type
= cpu_to_le16((u16
) assoc_req
->wpa_ie
[0]);
756 tmplen
= (u16
) assoc_req
->wpa_ie
[1];
757 rsn
->header
.len
= cpu_to_le16(tmplen
);
758 memcpy(rsn
->rsnie
, &assoc_req
->wpa_ie
[2], tmplen
);
759 lbs_deb_hex(LBS_DEB_JOIN
, "ASSOC_CMD: WPA/RSN IE", (u8
*) rsn
,
760 sizeof(rsn
->header
) + tmplen
);
761 pos
+= sizeof(rsn
->header
) + tmplen
;
764 cmd
.hdr
.size
= cpu_to_le16((sizeof(cmd
) - sizeof(cmd
.iebuf
)) +
765 (u16
)(pos
- (u8
*) &cmd
.iebuf
));
767 /* update curbssparams */
768 priv
->channel
= bss
->phy
.ds
.channel
;
770 ret
= lbs_cmd_with_response(priv
, command
, &cmd
);
772 ret
= lbs_assoc_post(priv
,
773 (struct cmd_ds_802_11_associate_response
*) &cmd
);
777 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
782 * @brief Associate to a specific BSS discovered in a scan
784 * @param priv A pointer to struct lbs_private structure
785 * @param assoc_req The association request describing the BSS to associate with
787 * @return 0-success, otherwise fail
789 static int lbs_try_associate(struct lbs_private
*priv
,
790 struct assoc_request
*assoc_req
)
793 u8 preamble
= RADIO_PREAMBLE_LONG
;
795 lbs_deb_enter(LBS_DEB_ASSOC
);
797 /* FW v9 and higher indicate authentication suites as a TLV in the
798 * association command, not as a separate authentication command.
800 if (priv
->fwrelease
< 0x09000000) {
801 ret
= lbs_set_authentication(priv
, assoc_req
->bss
.bssid
,
802 priv
->secinfo
.auth_mode
);
807 /* Use short preamble only when both the BSS and firmware support it */
808 if (assoc_req
->bss
.capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
)
809 preamble
= RADIO_PREAMBLE_SHORT
;
811 ret
= lbs_set_radio(priv
, preamble
, 1);
815 ret
= lbs_associate(priv
, assoc_req
, CMD_802_11_ASSOCIATE
);
818 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
822 static int lbs_adhoc_post(struct lbs_private
*priv
,
823 struct cmd_ds_802_11_ad_hoc_result
*resp
)
826 u16 command
= le16_to_cpu(resp
->hdr
.command
);
827 u16 result
= le16_to_cpu(resp
->hdr
.result
);
828 union iwreq_data wrqu
;
829 struct bss_descriptor
*bss
;
830 DECLARE_SSID_BUF(ssid
);
832 lbs_deb_enter(LBS_DEB_JOIN
);
834 if (!priv
->in_progress_assoc_req
) {
835 lbs_deb_join("ADHOC_RESP: no in-progress association "
840 bss
= &priv
->in_progress_assoc_req
->bss
;
843 * Join result code 0 --> SUCCESS
846 lbs_deb_join("ADHOC_RESP: failed (result 0x%X)\n", result
);
847 if (priv
->connect_status
== LBS_CONNECTED
)
848 lbs_mac_event_disconnected(priv
);
853 /* Send a Media Connected event, according to the Spec */
854 priv
->connect_status
= LBS_CONNECTED
;
856 if (command
== CMD_RET(CMD_802_11_AD_HOC_START
)) {
857 /* Update the created network descriptor with the new BSSID */
858 memcpy(bss
->bssid
, resp
->bssid
, ETH_ALEN
);
861 /* Set the BSSID from the joined/started descriptor */
862 memcpy(&priv
->curbssparams
.bssid
, bss
->bssid
, ETH_ALEN
);
864 /* Set the new SSID to current SSID */
865 memcpy(&priv
->curbssparams
.ssid
, &bss
->ssid
, IEEE80211_MAX_SSID_LEN
);
866 priv
->curbssparams
.ssid_len
= bss
->ssid_len
;
868 netif_carrier_on(priv
->dev
);
869 if (!priv
->tx_pending_len
)
870 netif_wake_queue(priv
->dev
);
872 memset(&wrqu
, 0, sizeof(wrqu
));
873 memcpy(wrqu
.ap_addr
.sa_data
, priv
->curbssparams
.bssid
, ETH_ALEN
);
874 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
875 wireless_send_event(priv
->dev
, SIOCGIWAP
, &wrqu
, NULL
);
877 lbs_deb_join("ADHOC_RESP: Joined/started '%s', BSSID %pM, channel %d\n",
878 print_ssid(ssid
, bss
->ssid
, bss
->ssid_len
),
879 priv
->curbssparams
.bssid
,
883 lbs_deb_leave_args(LBS_DEB_JOIN
, "ret %d", ret
);
888 * @brief Join an adhoc network found in a previous scan
890 * @param priv A pointer to struct lbs_private structure
891 * @param assoc_req The association request describing the BSS to join
893 * @return 0 on success, error on failure
895 static int lbs_adhoc_join(struct lbs_private
*priv
,
896 struct assoc_request
*assoc_req
)
898 struct cmd_ds_802_11_ad_hoc_join cmd
;
899 struct bss_descriptor
*bss
= &assoc_req
->bss
;
900 u8 preamble
= RADIO_PREAMBLE_LONG
;
901 DECLARE_SSID_BUF(ssid
);
905 lbs_deb_enter(LBS_DEB_ASSOC
);
907 lbs_deb_join("current SSID '%s', ssid length %u\n",
908 print_ssid(ssid
, priv
->curbssparams
.ssid
,
909 priv
->curbssparams
.ssid_len
),
910 priv
->curbssparams
.ssid_len
);
911 lbs_deb_join("requested ssid '%s', ssid length %u\n",
912 print_ssid(ssid
, bss
->ssid
, bss
->ssid_len
),
915 /* check if the requested SSID is already joined */
916 if (priv
->curbssparams
.ssid_len
&&
917 !lbs_ssid_cmp(priv
->curbssparams
.ssid
,
918 priv
->curbssparams
.ssid_len
,
919 bss
->ssid
, bss
->ssid_len
) &&
920 (priv
->mode
== IW_MODE_ADHOC
) &&
921 (priv
->connect_status
== LBS_CONNECTED
)) {
922 union iwreq_data wrqu
;
924 lbs_deb_join("ADHOC_J_CMD: New ad-hoc SSID is the same as "
925 "current, not attempting to re-join");
927 /* Send the re-association event though, because the association
928 * request really was successful, even if just a null-op.
930 memset(&wrqu
, 0, sizeof(wrqu
));
931 memcpy(wrqu
.ap_addr
.sa_data
, priv
->curbssparams
.bssid
,
933 wrqu
.ap_addr
.sa_family
= ARPHRD_ETHER
;
934 wireless_send_event(priv
->dev
, SIOCGIWAP
, &wrqu
, NULL
);
938 /* Use short preamble only when both the BSS and firmware support it */
939 if (bss
->capability
& WLAN_CAPABILITY_SHORT_PREAMBLE
) {
940 lbs_deb_join("AdhocJoin: Short preamble\n");
941 preamble
= RADIO_PREAMBLE_SHORT
;
944 ret
= lbs_set_radio(priv
, preamble
, 1);
948 lbs_deb_join("AdhocJoin: channel = %d\n", assoc_req
->channel
);
949 lbs_deb_join("AdhocJoin: band = %c\n", assoc_req
->band
);
951 priv
->adhoccreate
= 0;
952 priv
->channel
= bss
->channel
;
954 /* Build the join command */
955 memset(&cmd
, 0, sizeof(cmd
));
956 cmd
.hdr
.size
= cpu_to_le16(sizeof(cmd
));
958 cmd
.bss
.type
= CMD_BSS_TYPE_IBSS
;
959 cmd
.bss
.beaconperiod
= cpu_to_le16(bss
->beaconperiod
);
961 memcpy(&cmd
.bss
.bssid
, &bss
->bssid
, ETH_ALEN
);
962 memcpy(&cmd
.bss
.ssid
, &bss
->ssid
, bss
->ssid_len
);
964 memcpy(&cmd
.bss
.ds
, &bss
->phy
.ds
, sizeof(struct ieee_ie_ds_param_set
));
966 memcpy(&cmd
.bss
.ibss
, &bss
->ss
.ibss
,
967 sizeof(struct ieee_ie_ibss_param_set
));
969 cmd
.bss
.capability
= cpu_to_le16(bss
->capability
& CAPINFO_MASK
);
970 lbs_deb_join("ADHOC_J_CMD: tmpcap=%4X CAPINFO_MASK=%4X\n",
971 bss
->capability
, CAPINFO_MASK
);
973 /* information on BSSID descriptor passed to FW */
974 lbs_deb_join("ADHOC_J_CMD: BSSID = %pM, SSID = '%s'\n",
975 cmd
.bss
.bssid
, cmd
.bss
.ssid
);
977 /* Only v8 and below support setting these */
978 if (priv
->fwrelease
< 0x09000000) {
980 cmd
.failtimeout
= cpu_to_le16(MRVDRV_ASSOCIATION_TIME_OUT
);
982 cmd
.probedelay
= cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME
);
985 /* Copy Data rates from the rates recorded in scan response */
986 memset(cmd
.bss
.rates
, 0, sizeof(cmd
.bss
.rates
));
987 ratesize
= min_t(u16
, ARRAY_SIZE(cmd
.bss
.rates
), ARRAY_SIZE (bss
->rates
));
988 memcpy(cmd
.bss
.rates
, bss
->rates
, ratesize
);
989 if (get_common_rates(priv
, cmd
.bss
.rates
, &ratesize
)) {
990 lbs_deb_join("ADHOC_JOIN: get_common_rates returned error.\n");
995 /* Copy the ad-hoc creation rates into Current BSS state structure */
996 memset(&priv
->curbssparams
.rates
, 0, sizeof(priv
->curbssparams
.rates
));
997 memcpy(&priv
->curbssparams
.rates
, cmd
.bss
.rates
, ratesize
);
999 /* Set MSB on basic rates as the firmware requires, but _after_
1000 * copying to current bss rates.
1002 lbs_set_basic_rate_flags(cmd
.bss
.rates
, ratesize
);
1004 cmd
.bss
.ibss
.atimwindow
= bss
->atimwindow
;
1006 if (assoc_req
->secinfo
.wep_enabled
) {
1007 u16 tmp
= le16_to_cpu(cmd
.bss
.capability
);
1008 tmp
|= WLAN_CAPABILITY_PRIVACY
;
1009 cmd
.bss
.capability
= cpu_to_le16(tmp
);
1012 if (priv
->psmode
== LBS802_11POWERMODEMAX_PSP
) {
1013 __le32 local_ps_mode
= cpu_to_le32(LBS802_11POWERMODECAM
);
1016 ret
= lbs_prepare_and_send_command(priv
, CMD_802_11_PS_MODE
,
1025 ret
= lbs_cmd_with_response(priv
, CMD_802_11_AD_HOC_JOIN
, &cmd
);
1027 ret
= lbs_adhoc_post(priv
,
1028 (struct cmd_ds_802_11_ad_hoc_result
*)&cmd
);
1032 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1037 * @brief Start an Adhoc Network
1039 * @param priv A pointer to struct lbs_private structure
1040 * @param assoc_req The association request describing the BSS to start
1042 * @return 0 on success, error on failure
1044 static int lbs_adhoc_start(struct lbs_private
*priv
,
1045 struct assoc_request
*assoc_req
)
1047 struct cmd_ds_802_11_ad_hoc_start cmd
;
1048 u8 preamble
= RADIO_PREAMBLE_SHORT
;
1049 size_t ratesize
= 0;
1052 DECLARE_SSID_BUF(ssid
);
1054 lbs_deb_enter(LBS_DEB_ASSOC
);
1056 ret
= lbs_set_radio(priv
, preamble
, 1);
1060 /* Build the start command */
1061 memset(&cmd
, 0, sizeof(cmd
));
1062 cmd
.hdr
.size
= cpu_to_le16(sizeof(cmd
));
1064 memcpy(cmd
.ssid
, assoc_req
->ssid
, assoc_req
->ssid_len
);
1066 lbs_deb_join("ADHOC_START: SSID '%s', ssid length %u\n",
1067 print_ssid(ssid
, assoc_req
->ssid
, assoc_req
->ssid_len
),
1068 assoc_req
->ssid_len
);
1070 cmd
.bsstype
= CMD_BSS_TYPE_IBSS
;
1072 if (priv
->beacon_period
== 0)
1073 priv
->beacon_period
= MRVDRV_BEACON_INTERVAL
;
1074 cmd
.beaconperiod
= cpu_to_le16(priv
->beacon_period
);
1076 WARN_ON(!assoc_req
->channel
);
1078 /* set Physical parameter set */
1079 cmd
.ds
.header
.id
= WLAN_EID_DS_PARAMS
;
1080 cmd
.ds
.header
.len
= 1;
1081 cmd
.ds
.channel
= assoc_req
->channel
;
1083 /* set IBSS parameter set */
1084 cmd
.ibss
.header
.id
= WLAN_EID_IBSS_PARAMS
;
1085 cmd
.ibss
.header
.len
= 2;
1086 cmd
.ibss
.atimwindow
= cpu_to_le16(0);
1088 /* set capability info */
1089 tmpcap
= WLAN_CAPABILITY_IBSS
;
1090 if (assoc_req
->secinfo
.wep_enabled
||
1091 assoc_req
->secinfo
.WPAenabled
||
1092 assoc_req
->secinfo
.WPA2enabled
) {
1093 lbs_deb_join("ADHOC_START: WEP/WPA enabled, privacy on\n");
1094 tmpcap
|= WLAN_CAPABILITY_PRIVACY
;
1096 lbs_deb_join("ADHOC_START: WEP disabled, privacy off\n");
1098 cmd
.capability
= cpu_to_le16(tmpcap
);
1100 /* Only v8 and below support setting probe delay */
1101 if (priv
->fwrelease
< 0x09000000)
1102 cmd
.probedelay
= cpu_to_le16(CMD_SCAN_PROBE_DELAY_TIME
);
1104 ratesize
= min(sizeof(cmd
.rates
), sizeof(lbs_bg_rates
));
1105 memcpy(cmd
.rates
, lbs_bg_rates
, ratesize
);
1107 /* Copy the ad-hoc creating rates into Current BSS state structure */
1108 memset(&priv
->curbssparams
.rates
, 0, sizeof(priv
->curbssparams
.rates
));
1109 memcpy(&priv
->curbssparams
.rates
, &cmd
.rates
, ratesize
);
1111 /* Set MSB on basic rates as the firmware requires, but _after_
1112 * copying to current bss rates.
1114 lbs_set_basic_rate_flags(cmd
.rates
, ratesize
);
1116 lbs_deb_join("ADHOC_START: rates=%02x %02x %02x %02x\n",
1117 cmd
.rates
[0], cmd
.rates
[1], cmd
.rates
[2], cmd
.rates
[3]);
1119 lbs_deb_join("ADHOC_START: Starting Ad-Hoc BSS on channel %d, band %d\n",
1120 assoc_req
->channel
, assoc_req
->band
);
1122 priv
->adhoccreate
= 1;
1123 priv
->mode
= IW_MODE_ADHOC
;
1125 ret
= lbs_cmd_with_response(priv
, CMD_802_11_AD_HOC_START
, &cmd
);
1127 ret
= lbs_adhoc_post(priv
,
1128 (struct cmd_ds_802_11_ad_hoc_result
*)&cmd
);
1131 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1136 * @brief Stop and Ad-Hoc network and exit Ad-Hoc mode
1138 * @param priv A pointer to struct lbs_private structure
1139 * @return 0 on success, or an error
1141 int lbs_adhoc_stop(struct lbs_private
*priv
)
1143 struct cmd_ds_802_11_ad_hoc_stop cmd
;
1146 lbs_deb_enter(LBS_DEB_JOIN
);
1148 memset(&cmd
, 0, sizeof (cmd
));
1149 cmd
.hdr
.size
= cpu_to_le16 (sizeof (cmd
));
1151 ret
= lbs_cmd_with_response(priv
, CMD_802_11_AD_HOC_STOP
, &cmd
);
1153 /* Clean up everything even if there was an error */
1154 lbs_mac_event_disconnected(priv
);
1156 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1160 static inline int match_bss_no_security(struct lbs_802_11_security
*secinfo
,
1161 struct bss_descriptor
*match_bss
)
1163 if (!secinfo
->wep_enabled
&& !secinfo
->WPAenabled
1164 && !secinfo
->WPA2enabled
1165 && match_bss
->wpa_ie
[0] != WLAN_EID_GENERIC
1166 && match_bss
->rsn_ie
[0] != WLAN_EID_RSN
1167 && !(match_bss
->capability
& WLAN_CAPABILITY_PRIVACY
))
1173 static inline int match_bss_static_wep(struct lbs_802_11_security
*secinfo
,
1174 struct bss_descriptor
*match_bss
)
1176 if (secinfo
->wep_enabled
&& !secinfo
->WPAenabled
1177 && !secinfo
->WPA2enabled
1178 && (match_bss
->capability
& WLAN_CAPABILITY_PRIVACY
))
1184 static inline int match_bss_wpa(struct lbs_802_11_security
*secinfo
,
1185 struct bss_descriptor
*match_bss
)
1187 if (!secinfo
->wep_enabled
&& secinfo
->WPAenabled
1188 && (match_bss
->wpa_ie
[0] == WLAN_EID_GENERIC
)
1189 /* privacy bit may NOT be set in some APs like LinkSys WRT54G
1190 && (match_bss->capability & WLAN_CAPABILITY_PRIVACY) */
1197 static inline int match_bss_wpa2(struct lbs_802_11_security
*secinfo
,
1198 struct bss_descriptor
*match_bss
)
1200 if (!secinfo
->wep_enabled
&& secinfo
->WPA2enabled
&&
1201 (match_bss
->rsn_ie
[0] == WLAN_EID_RSN
)
1202 /* privacy bit may NOT be set in some APs like LinkSys WRT54G
1203 (match_bss->capability & WLAN_CAPABILITY_PRIVACY) */
1210 static inline int match_bss_dynamic_wep(struct lbs_802_11_security
*secinfo
,
1211 struct bss_descriptor
*match_bss
)
1213 if (!secinfo
->wep_enabled
&& !secinfo
->WPAenabled
1214 && !secinfo
->WPA2enabled
1215 && (match_bss
->wpa_ie
[0] != WLAN_EID_GENERIC
)
1216 && (match_bss
->rsn_ie
[0] != WLAN_EID_RSN
)
1217 && (match_bss
->capability
& WLAN_CAPABILITY_PRIVACY
))
1224 * @brief Check if a scanned network compatible with the driver settings
1226 * WEP WPA WPA2 ad-hoc encrypt Network
1227 * enabled enabled enabled AES mode privacy WPA WPA2 Compatible
1228 * 0 0 0 0 NONE 0 0 0 yes No security
1229 * 1 0 0 0 NONE 1 0 0 yes Static WEP
1230 * 0 1 0 0 x 1x 1 x yes WPA
1231 * 0 0 1 0 x 1x x 1 yes WPA2
1232 * 0 0 0 1 NONE 1 0 0 yes Ad-hoc AES
1233 * 0 0 0 0 !=NONE 1 0 0 yes Dynamic WEP
1236 * @param priv A pointer to struct lbs_private
1237 * @param index Index in scantable to check against current driver settings
1238 * @param mode Network mode: Infrastructure or IBSS
1240 * @return Index in scantable, or error code if negative
1242 static int is_network_compatible(struct lbs_private
*priv
,
1243 struct bss_descriptor
*bss
, uint8_t mode
)
1247 lbs_deb_enter(LBS_DEB_SCAN
);
1249 if (bss
->mode
!= mode
)
1252 matched
= match_bss_no_security(&priv
->secinfo
, bss
);
1255 matched
= match_bss_static_wep(&priv
->secinfo
, bss
);
1258 matched
= match_bss_wpa(&priv
->secinfo
, bss
);
1260 lbs_deb_scan("is_network_compatible() WPA: wpa_ie 0x%x "
1261 "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s "
1262 "privacy 0x%x\n", bss
->wpa_ie
[0], bss
->rsn_ie
[0],
1263 priv
->secinfo
.wep_enabled
? "e" : "d",
1264 priv
->secinfo
.WPAenabled
? "e" : "d",
1265 priv
->secinfo
.WPA2enabled
? "e" : "d",
1266 (bss
->capability
& WLAN_CAPABILITY_PRIVACY
));
1269 matched
= match_bss_wpa2(&priv
->secinfo
, bss
);
1271 lbs_deb_scan("is_network_compatible() WPA2: wpa_ie 0x%x "
1272 "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s "
1273 "privacy 0x%x\n", bss
->wpa_ie
[0], bss
->rsn_ie
[0],
1274 priv
->secinfo
.wep_enabled
? "e" : "d",
1275 priv
->secinfo
.WPAenabled
? "e" : "d",
1276 priv
->secinfo
.WPA2enabled
? "e" : "d",
1277 (bss
->capability
& WLAN_CAPABILITY_PRIVACY
));
1280 matched
= match_bss_dynamic_wep(&priv
->secinfo
, bss
);
1282 lbs_deb_scan("is_network_compatible() dynamic WEP: "
1283 "wpa_ie 0x%x wpa2_ie 0x%x privacy 0x%x\n",
1284 bss
->wpa_ie
[0], bss
->rsn_ie
[0],
1285 (bss
->capability
& WLAN_CAPABILITY_PRIVACY
));
1289 /* bss security settings don't match those configured on card */
1290 lbs_deb_scan("is_network_compatible() FAILED: wpa_ie 0x%x "
1291 "wpa2_ie 0x%x WEP %s WPA %s WPA2 %s privacy 0x%x\n",
1292 bss
->wpa_ie
[0], bss
->rsn_ie
[0],
1293 priv
->secinfo
.wep_enabled
? "e" : "d",
1294 priv
->secinfo
.WPAenabled
? "e" : "d",
1295 priv
->secinfo
.WPA2enabled
? "e" : "d",
1296 (bss
->capability
& WLAN_CAPABILITY_PRIVACY
));
1299 lbs_deb_leave_args(LBS_DEB_SCAN
, "matched: %d", matched
);
1304 * @brief This function finds a specific compatible BSSID in the scan list
1306 * Used in association code
1308 * @param priv A pointer to struct lbs_private
1309 * @param bssid BSSID to find in the scan list
1310 * @param mode Network mode: Infrastructure or IBSS
1312 * @return index in BSSID list, or error return code (< 0)
1314 static struct bss_descriptor
*lbs_find_bssid_in_list(struct lbs_private
*priv
,
1315 uint8_t *bssid
, uint8_t mode
)
1317 struct bss_descriptor
*iter_bss
;
1318 struct bss_descriptor
*found_bss
= NULL
;
1320 lbs_deb_enter(LBS_DEB_SCAN
);
1325 lbs_deb_hex(LBS_DEB_SCAN
, "looking for", bssid
, ETH_ALEN
);
1327 /* Look through the scan table for a compatible match. The loop will
1328 * continue past a matched bssid that is not compatible in case there
1329 * is an AP with multiple SSIDs assigned to the same BSSID
1331 mutex_lock(&priv
->lock
);
1332 list_for_each_entry(iter_bss
, &priv
->network_list
, list
) {
1333 if (compare_ether_addr(iter_bss
->bssid
, bssid
))
1334 continue; /* bssid doesn't match */
1338 if (!is_network_compatible(priv
, iter_bss
, mode
))
1340 found_bss
= iter_bss
;
1343 found_bss
= iter_bss
;
1347 mutex_unlock(&priv
->lock
);
1350 lbs_deb_leave_args(LBS_DEB_SCAN
, "found_bss %p", found_bss
);
1355 * @brief This function finds ssid in ssid list.
1357 * Used in association code
1359 * @param priv A pointer to struct lbs_private
1360 * @param ssid SSID to find in the list
1361 * @param bssid BSSID to qualify the SSID selection (if provided)
1362 * @param mode Network mode: Infrastructure or IBSS
1364 * @return index in BSSID list
1366 static struct bss_descriptor
*lbs_find_ssid_in_list(struct lbs_private
*priv
,
1367 uint8_t *ssid
, uint8_t ssid_len
,
1368 uint8_t *bssid
, uint8_t mode
,
1372 struct bss_descriptor
*iter_bss
= NULL
;
1373 struct bss_descriptor
*found_bss
= NULL
;
1374 struct bss_descriptor
*tmp_oldest
= NULL
;
1376 lbs_deb_enter(LBS_DEB_SCAN
);
1378 mutex_lock(&priv
->lock
);
1380 list_for_each_entry(iter_bss
, &priv
->network_list
, list
) {
1382 (iter_bss
->last_scanned
< tmp_oldest
->last_scanned
))
1383 tmp_oldest
= iter_bss
;
1385 if (lbs_ssid_cmp(iter_bss
->ssid
, iter_bss
->ssid_len
,
1386 ssid
, ssid_len
) != 0)
1387 continue; /* ssid doesn't match */
1388 if (bssid
&& compare_ether_addr(iter_bss
->bssid
, bssid
) != 0)
1389 continue; /* bssid doesn't match */
1390 if ((channel
> 0) && (iter_bss
->channel
!= channel
))
1391 continue; /* channel doesn't match */
1396 if (!is_network_compatible(priv
, iter_bss
, mode
))
1400 /* Found requested BSSID */
1401 found_bss
= iter_bss
;
1405 if (SCAN_RSSI(iter_bss
->rssi
) > bestrssi
) {
1406 bestrssi
= SCAN_RSSI(iter_bss
->rssi
);
1407 found_bss
= iter_bss
;
1412 if (SCAN_RSSI(iter_bss
->rssi
) > bestrssi
) {
1413 bestrssi
= SCAN_RSSI(iter_bss
->rssi
);
1414 found_bss
= iter_bss
;
1421 mutex_unlock(&priv
->lock
);
1422 lbs_deb_leave_args(LBS_DEB_SCAN
, "found_bss %p", found_bss
);
1426 static int assoc_helper_essid(struct lbs_private
*priv
,
1427 struct assoc_request
* assoc_req
)
1430 struct bss_descriptor
* bss
;
1432 DECLARE_SSID_BUF(ssid
);
1434 lbs_deb_enter(LBS_DEB_ASSOC
);
1436 /* FIXME: take channel into account when picking SSIDs if a channel
1440 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
))
1441 channel
= assoc_req
->channel
;
1443 lbs_deb_assoc("SSID '%s' requested\n",
1444 print_ssid(ssid
, assoc_req
->ssid
, assoc_req
->ssid_len
));
1445 if (assoc_req
->mode
== IW_MODE_INFRA
) {
1446 lbs_send_specific_ssid_scan(priv
, assoc_req
->ssid
,
1447 assoc_req
->ssid_len
);
1449 bss
= lbs_find_ssid_in_list(priv
, assoc_req
->ssid
,
1450 assoc_req
->ssid_len
, NULL
, IW_MODE_INFRA
, channel
);
1452 memcpy(&assoc_req
->bss
, bss
, sizeof(struct bss_descriptor
));
1453 ret
= lbs_try_associate(priv
, assoc_req
);
1455 lbs_deb_assoc("SSID not found; cannot associate\n");
1457 } else if (assoc_req
->mode
== IW_MODE_ADHOC
) {
1458 /* Scan for the network, do not save previous results. Stale
1459 * scan data will cause us to join a non-existant adhoc network
1461 lbs_send_specific_ssid_scan(priv
, assoc_req
->ssid
,
1462 assoc_req
->ssid_len
);
1464 /* Search for the requested SSID in the scan table */
1465 bss
= lbs_find_ssid_in_list(priv
, assoc_req
->ssid
,
1466 assoc_req
->ssid_len
, NULL
, IW_MODE_ADHOC
, channel
);
1468 lbs_deb_assoc("SSID found, will join\n");
1469 memcpy(&assoc_req
->bss
, bss
, sizeof(struct bss_descriptor
));
1470 lbs_adhoc_join(priv
, assoc_req
);
1472 /* else send START command */
1473 lbs_deb_assoc("SSID not found, creating adhoc network\n");
1474 memcpy(&assoc_req
->bss
.ssid
, &assoc_req
->ssid
,
1475 IEEE80211_MAX_SSID_LEN
);
1476 assoc_req
->bss
.ssid_len
= assoc_req
->ssid_len
;
1477 lbs_adhoc_start(priv
, assoc_req
);
1481 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1486 static int assoc_helper_bssid(struct lbs_private
*priv
,
1487 struct assoc_request
* assoc_req
)
1490 struct bss_descriptor
* bss
;
1492 lbs_deb_enter_args(LBS_DEB_ASSOC
, "BSSID %pM", assoc_req
->bssid
);
1494 /* Search for index position in list for requested MAC */
1495 bss
= lbs_find_bssid_in_list(priv
, assoc_req
->bssid
,
1498 lbs_deb_assoc("ASSOC: WAP: BSSID %pM not found, "
1499 "cannot associate.\n", assoc_req
->bssid
);
1503 memcpy(&assoc_req
->bss
, bss
, sizeof(struct bss_descriptor
));
1504 if (assoc_req
->mode
== IW_MODE_INFRA
) {
1505 ret
= lbs_try_associate(priv
, assoc_req
);
1506 lbs_deb_assoc("ASSOC: lbs_try_associate(bssid) returned %d\n",
1508 } else if (assoc_req
->mode
== IW_MODE_ADHOC
) {
1509 lbs_adhoc_join(priv
, assoc_req
);
1513 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1518 static int assoc_helper_associate(struct lbs_private
*priv
,
1519 struct assoc_request
* assoc_req
)
1521 int ret
= 0, done
= 0;
1523 lbs_deb_enter(LBS_DEB_ASSOC
);
1525 /* If we're given and 'any' BSSID, try associating based on SSID */
1527 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
1528 if (compare_ether_addr(bssid_any
, assoc_req
->bssid
)
1529 && compare_ether_addr(bssid_off
, assoc_req
->bssid
)) {
1530 ret
= assoc_helper_bssid(priv
, assoc_req
);
1535 if (!done
&& test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
1536 ret
= assoc_helper_essid(priv
, assoc_req
);
1539 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1544 static int assoc_helper_mode(struct lbs_private
*priv
,
1545 struct assoc_request
* assoc_req
)
1549 lbs_deb_enter(LBS_DEB_ASSOC
);
1551 if (assoc_req
->mode
== priv
->mode
)
1554 if (assoc_req
->mode
== IW_MODE_INFRA
) {
1555 if (priv
->psstate
!= PS_STATE_FULL_POWER
)
1556 lbs_ps_wakeup(priv
, CMD_OPTION_WAITFORRSP
);
1557 priv
->psmode
= LBS802_11POWERMODECAM
;
1560 priv
->mode
= assoc_req
->mode
;
1561 ret
= lbs_set_snmp_mib(priv
, SNMP_MIB_OID_BSS_TYPE
,
1562 assoc_req
->mode
== IW_MODE_ADHOC
? 2 : 1);
1565 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1569 static int assoc_helper_channel(struct lbs_private
*priv
,
1570 struct assoc_request
* assoc_req
)
1574 lbs_deb_enter(LBS_DEB_ASSOC
);
1576 ret
= lbs_update_channel(priv
);
1578 lbs_deb_assoc("ASSOC: channel: error getting channel.\n");
1582 if (assoc_req
->channel
== priv
->channel
)
1585 if (priv
->mesh_dev
) {
1586 /* Change mesh channel first; 21.p21 firmware won't let
1587 you change channel otherwise (even though it'll return
1589 lbs_mesh_config(priv
, CMD_ACT_MESH_CONFIG_STOP
,
1590 assoc_req
->channel
);
1593 lbs_deb_assoc("ASSOC: channel: %d -> %d\n",
1594 priv
->channel
, assoc_req
->channel
);
1596 ret
= lbs_set_channel(priv
, assoc_req
->channel
);
1598 lbs_deb_assoc("ASSOC: channel: error setting channel.\n");
1600 /* FIXME: shouldn't need to grab the channel _again_ after setting
1601 * it since the firmware is supposed to return the new channel, but
1603 ret
= lbs_update_channel(priv
);
1605 lbs_deb_assoc("ASSOC: channel: error getting channel.\n");
1609 if (assoc_req
->channel
!= priv
->channel
) {
1610 lbs_deb_assoc("ASSOC: channel: failed to update channel to %d\n",
1611 assoc_req
->channel
);
1615 if ( assoc_req
->secinfo
.wep_enabled
1616 && (assoc_req
->wep_keys
[0].len
1617 || assoc_req
->wep_keys
[1].len
1618 || assoc_req
->wep_keys
[2].len
1619 || assoc_req
->wep_keys
[3].len
)) {
1620 /* Make sure WEP keys are re-sent to firmware */
1621 set_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
);
1624 /* Must restart/rejoin adhoc networks after channel change */
1625 set_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
);
1629 lbs_mesh_config(priv
, CMD_ACT_MESH_CONFIG_START
,
1633 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1638 static int assoc_helper_wep_keys(struct lbs_private
*priv
,
1639 struct assoc_request
*assoc_req
)
1644 lbs_deb_enter(LBS_DEB_ASSOC
);
1646 /* Set or remove WEP keys */
1647 if (assoc_req
->wep_keys
[0].len
|| assoc_req
->wep_keys
[1].len
||
1648 assoc_req
->wep_keys
[2].len
|| assoc_req
->wep_keys
[3].len
)
1649 ret
= lbs_cmd_802_11_set_wep(priv
, CMD_ACT_ADD
, assoc_req
);
1651 ret
= lbs_cmd_802_11_set_wep(priv
, CMD_ACT_REMOVE
, assoc_req
);
1656 /* enable/disable the MAC's WEP packet filter */
1657 if (assoc_req
->secinfo
.wep_enabled
)
1658 priv
->mac_control
|= CMD_ACT_MAC_WEP_ENABLE
;
1660 priv
->mac_control
&= ~CMD_ACT_MAC_WEP_ENABLE
;
1662 lbs_set_mac_control(priv
);
1664 mutex_lock(&priv
->lock
);
1666 /* Copy WEP keys into priv wep key fields */
1667 for (i
= 0; i
< 4; i
++) {
1668 memcpy(&priv
->wep_keys
[i
], &assoc_req
->wep_keys
[i
],
1669 sizeof(struct enc_key
));
1671 priv
->wep_tx_keyidx
= assoc_req
->wep_tx_keyidx
;
1673 mutex_unlock(&priv
->lock
);
1676 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1680 static int assoc_helper_secinfo(struct lbs_private
*priv
,
1681 struct assoc_request
* assoc_req
)
1687 lbs_deb_enter(LBS_DEB_ASSOC
);
1689 memcpy(&priv
->secinfo
, &assoc_req
->secinfo
,
1690 sizeof(struct lbs_802_11_security
));
1692 lbs_set_mac_control(priv
);
1694 /* If RSN is already enabled, don't try to enable it again, since
1695 * ENABLE_RSN resets internal state machines and will clobber the
1696 * 4-way WPA handshake.
1699 /* Get RSN enabled/disabled */
1700 ret
= lbs_cmd_802_11_enable_rsn(priv
, CMD_ACT_GET
, &rsn
);
1702 lbs_deb_assoc("Failed to get RSN status: %d\n", ret
);
1706 /* Don't re-enable RSN if it's already enabled */
1707 do_wpa
= assoc_req
->secinfo
.WPAenabled
|| assoc_req
->secinfo
.WPA2enabled
;
1711 /* Set RSN enabled/disabled */
1712 ret
= lbs_cmd_802_11_enable_rsn(priv
, CMD_ACT_SET
, &do_wpa
);
1715 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1720 static int assoc_helper_wpa_keys(struct lbs_private
*priv
,
1721 struct assoc_request
* assoc_req
)
1724 unsigned int flags
= assoc_req
->flags
;
1726 lbs_deb_enter(LBS_DEB_ASSOC
);
1728 /* Work around older firmware bug where WPA unicast and multicast
1729 * keys must be set independently. Seen in SDIO parts with firmware
1733 if (test_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
)) {
1734 clear_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
);
1735 ret
= lbs_cmd_802_11_key_material(priv
, CMD_ACT_SET
, assoc_req
);
1736 assoc_req
->flags
= flags
;
1742 memcpy(&priv
->wpa_unicast_key
, &assoc_req
->wpa_unicast_key
,
1743 sizeof(struct enc_key
));
1745 if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
)) {
1746 clear_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
);
1748 ret
= lbs_cmd_802_11_key_material(priv
, CMD_ACT_SET
, assoc_req
);
1749 assoc_req
->flags
= flags
;
1751 memcpy(&priv
->wpa_mcast_key
, &assoc_req
->wpa_mcast_key
,
1752 sizeof(struct enc_key
));
1756 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1761 static int assoc_helper_wpa_ie(struct lbs_private
*priv
,
1762 struct assoc_request
* assoc_req
)
1766 lbs_deb_enter(LBS_DEB_ASSOC
);
1768 if (assoc_req
->secinfo
.WPAenabled
|| assoc_req
->secinfo
.WPA2enabled
) {
1769 memcpy(&priv
->wpa_ie
, &assoc_req
->wpa_ie
, assoc_req
->wpa_ie_len
);
1770 priv
->wpa_ie_len
= assoc_req
->wpa_ie_len
;
1772 memset(&priv
->wpa_ie
, 0, MAX_WPA_IE_LEN
);
1773 priv
->wpa_ie_len
= 0;
1776 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1781 static int should_deauth_infrastructure(struct lbs_private
*priv
,
1782 struct assoc_request
* assoc_req
)
1786 if (priv
->connect_status
!= LBS_CONNECTED
)
1789 lbs_deb_enter(LBS_DEB_ASSOC
);
1790 if (test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
1791 lbs_deb_assoc("Deauthenticating due to new SSID\n");
1796 if (test_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
)) {
1797 if (priv
->secinfo
.auth_mode
!= assoc_req
->secinfo
.auth_mode
) {
1798 lbs_deb_assoc("Deauthenticating due to new security\n");
1804 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
1805 lbs_deb_assoc("Deauthenticating due to new BSSID\n");
1810 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
)) {
1811 lbs_deb_assoc("Deauthenticating due to channel switch\n");
1816 /* FIXME: deal with 'auto' mode somehow */
1817 if (test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
)) {
1818 if (assoc_req
->mode
!= IW_MODE_INFRA
) {
1819 lbs_deb_assoc("Deauthenticating due to leaving "
1827 lbs_deb_leave_args(LBS_DEB_ASSOC
, "ret %d", ret
);
1832 static int should_stop_adhoc(struct lbs_private
*priv
,
1833 struct assoc_request
* assoc_req
)
1835 lbs_deb_enter(LBS_DEB_ASSOC
);
1837 if (priv
->connect_status
!= LBS_CONNECTED
)
1840 if (lbs_ssid_cmp(priv
->curbssparams
.ssid
,
1841 priv
->curbssparams
.ssid_len
,
1842 assoc_req
->ssid
, assoc_req
->ssid_len
) != 0)
1845 /* FIXME: deal with 'auto' mode somehow */
1846 if (test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
)) {
1847 if (assoc_req
->mode
!= IW_MODE_ADHOC
)
1851 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
)) {
1852 if (assoc_req
->channel
!= priv
->channel
)
1856 lbs_deb_leave(LBS_DEB_ASSOC
);
1862 * @brief This function finds the best SSID in the Scan List
1864 * Search the scan table for the best SSID that also matches the current
1865 * adapter network preference (infrastructure or adhoc)
1867 * @param priv A pointer to struct lbs_private
1869 * @return index in BSSID list
1871 static struct bss_descriptor
*lbs_find_best_ssid_in_list(
1872 struct lbs_private
*priv
, uint8_t mode
)
1874 uint8_t bestrssi
= 0;
1875 struct bss_descriptor
*iter_bss
;
1876 struct bss_descriptor
*best_bss
= NULL
;
1878 lbs_deb_enter(LBS_DEB_SCAN
);
1880 mutex_lock(&priv
->lock
);
1882 list_for_each_entry(iter_bss
, &priv
->network_list
, list
) {
1886 if (!is_network_compatible(priv
, iter_bss
, mode
))
1888 if (SCAN_RSSI(iter_bss
->rssi
) <= bestrssi
)
1890 bestrssi
= SCAN_RSSI(iter_bss
->rssi
);
1891 best_bss
= iter_bss
;
1895 if (SCAN_RSSI(iter_bss
->rssi
) <= bestrssi
)
1897 bestrssi
= SCAN_RSSI(iter_bss
->rssi
);
1898 best_bss
= iter_bss
;
1903 mutex_unlock(&priv
->lock
);
1904 lbs_deb_leave_args(LBS_DEB_SCAN
, "best_bss %p", best_bss
);
1909 * @brief Find the best AP
1911 * Used from association worker.
1913 * @param priv A pointer to struct lbs_private structure
1914 * @param pSSID A pointer to AP's ssid
1916 * @return 0--success, otherwise--fail
1918 static int lbs_find_best_network_ssid(struct lbs_private
*priv
,
1919 uint8_t *out_ssid
, uint8_t *out_ssid_len
, uint8_t preferred_mode
,
1923 struct bss_descriptor
*found
;
1925 lbs_deb_enter(LBS_DEB_SCAN
);
1927 priv
->scan_ssid_len
= 0;
1928 lbs_scan_networks(priv
, 1);
1929 if (priv
->surpriseremoved
)
1932 found
= lbs_find_best_ssid_in_list(priv
, preferred_mode
);
1933 if (found
&& (found
->ssid_len
> 0)) {
1934 memcpy(out_ssid
, &found
->ssid
, IEEE80211_MAX_SSID_LEN
);
1935 *out_ssid_len
= found
->ssid_len
;
1936 *out_mode
= found
->mode
;
1941 lbs_deb_leave_args(LBS_DEB_SCAN
, "ret %d", ret
);
1946 void lbs_association_worker(struct work_struct
*work
)
1948 struct lbs_private
*priv
= container_of(work
, struct lbs_private
,
1950 struct assoc_request
* assoc_req
= NULL
;
1952 int find_any_ssid
= 0;
1953 DECLARE_SSID_BUF(ssid
);
1955 lbs_deb_enter(LBS_DEB_ASSOC
);
1957 mutex_lock(&priv
->lock
);
1958 assoc_req
= priv
->pending_assoc_req
;
1959 priv
->pending_assoc_req
= NULL
;
1960 priv
->in_progress_assoc_req
= assoc_req
;
1961 mutex_unlock(&priv
->lock
);
1967 "Association Request:\n"
1974 " secinfo: %s%s%s\n"
1977 print_ssid(ssid
, assoc_req
->ssid
, assoc_req
->ssid_len
),
1978 assoc_req
->channel
, assoc_req
->band
, assoc_req
->mode
,
1980 assoc_req
->secinfo
.WPAenabled
? " WPA" : "",
1981 assoc_req
->secinfo
.WPA2enabled
? " WPA2" : "",
1982 assoc_req
->secinfo
.wep_enabled
? " WEP" : "",
1983 assoc_req
->secinfo
.auth_mode
);
1985 /* If 'any' SSID was specified, find an SSID to associate with */
1986 if (test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)
1987 && !assoc_req
->ssid_len
)
1990 /* But don't use 'any' SSID if there's a valid locked BSSID to use */
1991 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
1992 if (compare_ether_addr(assoc_req
->bssid
, bssid_any
)
1993 && compare_ether_addr(assoc_req
->bssid
, bssid_off
))
1997 if (find_any_ssid
) {
1998 u8 new_mode
= assoc_req
->mode
;
2000 ret
= lbs_find_best_network_ssid(priv
, assoc_req
->ssid
,
2001 &assoc_req
->ssid_len
, assoc_req
->mode
, &new_mode
);
2003 lbs_deb_assoc("Could not find best network\n");
2008 /* Ensure we switch to the mode of the AP */
2009 if (assoc_req
->mode
== IW_MODE_AUTO
) {
2010 set_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
);
2011 assoc_req
->mode
= new_mode
;
2016 * Check if the attributes being changing require deauthentication
2017 * from the currently associated infrastructure access point.
2019 if (priv
->mode
== IW_MODE_INFRA
) {
2020 if (should_deauth_infrastructure(priv
, assoc_req
)) {
2021 ret
= lbs_cmd_80211_deauthenticate(priv
,
2022 priv
->curbssparams
.bssid
,
2023 WLAN_REASON_DEAUTH_LEAVING
);
2025 lbs_deb_assoc("Deauthentication due to new "
2026 "configuration request failed: %d\n",
2030 } else if (priv
->mode
== IW_MODE_ADHOC
) {
2031 if (should_stop_adhoc(priv
, assoc_req
)) {
2032 ret
= lbs_adhoc_stop(priv
);
2034 lbs_deb_assoc("Teardown of AdHoc network due to "
2035 "new configuration request failed: %d\n",
2042 /* Send the various configuration bits to the firmware */
2043 if (test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
)) {
2044 ret
= assoc_helper_mode(priv
, assoc_req
);
2049 if (test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
)) {
2050 ret
= assoc_helper_channel(priv
, assoc_req
);
2055 if (test_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
)) {
2056 ret
= assoc_helper_secinfo(priv
, assoc_req
);
2061 if (test_bit(ASSOC_FLAG_WPA_IE
, &assoc_req
->flags
)) {
2062 ret
= assoc_helper_wpa_ie(priv
, assoc_req
);
2067 if (test_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
)
2068 || test_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
)) {
2069 ret
= assoc_helper_wpa_keys(priv
, assoc_req
);
2074 if ( test_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
)
2075 || test_bit(ASSOC_FLAG_WEP_TX_KEYIDX
, &assoc_req
->flags
)) {
2076 ret
= assoc_helper_wep_keys(priv
, assoc_req
);
2082 /* SSID/BSSID should be the _last_ config option set, because they
2083 * trigger the association attempt.
2085 if (test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)
2086 || test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
2089 ret
= assoc_helper_associate(priv
, assoc_req
);
2091 lbs_deb_assoc("ASSOC: association unsuccessful: %d\n",
2096 if (priv
->connect_status
!= LBS_CONNECTED
) {
2097 lbs_deb_assoc("ASSOC: association unsuccessful, "
2103 lbs_deb_assoc("associated to %pM\n",
2104 priv
->curbssparams
.bssid
);
2105 lbs_prepare_and_send_command(priv
,
2107 0, CMD_OPTION_WAITFORRSP
, 0, NULL
);
2115 lbs_deb_assoc("ASSOC: reconfiguration attempt unsuccessful: %d\n",
2119 mutex_lock(&priv
->lock
);
2120 priv
->in_progress_assoc_req
= NULL
;
2121 mutex_unlock(&priv
->lock
);
2125 lbs_deb_leave(LBS_DEB_ASSOC
);
2130 * Caller MUST hold any necessary locks
2132 struct assoc_request
*lbs_get_association_request(struct lbs_private
*priv
)
2134 struct assoc_request
* assoc_req
;
2136 lbs_deb_enter(LBS_DEB_ASSOC
);
2137 if (!priv
->pending_assoc_req
) {
2138 priv
->pending_assoc_req
= kzalloc(sizeof(struct assoc_request
),
2140 if (!priv
->pending_assoc_req
) {
2141 lbs_pr_info("Not enough memory to allocate association"
2147 /* Copy current configuration attributes to the association request,
2148 * but don't overwrite any that are already set.
2150 assoc_req
= priv
->pending_assoc_req
;
2151 if (!test_bit(ASSOC_FLAG_SSID
, &assoc_req
->flags
)) {
2152 memcpy(&assoc_req
->ssid
, &priv
->curbssparams
.ssid
,
2153 IEEE80211_MAX_SSID_LEN
);
2154 assoc_req
->ssid_len
= priv
->curbssparams
.ssid_len
;
2157 if (!test_bit(ASSOC_FLAG_CHANNEL
, &assoc_req
->flags
))
2158 assoc_req
->channel
= priv
->channel
;
2160 if (!test_bit(ASSOC_FLAG_BAND
, &assoc_req
->flags
))
2161 assoc_req
->band
= priv
->curbssparams
.band
;
2163 if (!test_bit(ASSOC_FLAG_MODE
, &assoc_req
->flags
))
2164 assoc_req
->mode
= priv
->mode
;
2166 if (!test_bit(ASSOC_FLAG_BSSID
, &assoc_req
->flags
)) {
2167 memcpy(&assoc_req
->bssid
, priv
->curbssparams
.bssid
,
2171 if (!test_bit(ASSOC_FLAG_WEP_KEYS
, &assoc_req
->flags
)) {
2173 for (i
= 0; i
< 4; i
++) {
2174 memcpy(&assoc_req
->wep_keys
[i
], &priv
->wep_keys
[i
],
2175 sizeof(struct enc_key
));
2179 if (!test_bit(ASSOC_FLAG_WEP_TX_KEYIDX
, &assoc_req
->flags
))
2180 assoc_req
->wep_tx_keyidx
= priv
->wep_tx_keyidx
;
2182 if (!test_bit(ASSOC_FLAG_WPA_MCAST_KEY
, &assoc_req
->flags
)) {
2183 memcpy(&assoc_req
->wpa_mcast_key
, &priv
->wpa_mcast_key
,
2184 sizeof(struct enc_key
));
2187 if (!test_bit(ASSOC_FLAG_WPA_UCAST_KEY
, &assoc_req
->flags
)) {
2188 memcpy(&assoc_req
->wpa_unicast_key
, &priv
->wpa_unicast_key
,
2189 sizeof(struct enc_key
));
2192 if (!test_bit(ASSOC_FLAG_SECINFO
, &assoc_req
->flags
)) {
2193 memcpy(&assoc_req
->secinfo
, &priv
->secinfo
,
2194 sizeof(struct lbs_802_11_security
));
2197 if (!test_bit(ASSOC_FLAG_WPA_IE
, &assoc_req
->flags
)) {
2198 memcpy(&assoc_req
->wpa_ie
, &priv
->wpa_ie
,
2200 assoc_req
->wpa_ie_len
= priv
->wpa_ie_len
;
2203 lbs_deb_leave(LBS_DEB_ASSOC
);
2209 * @brief Deauthenticate from a specific BSS
2211 * @param priv A pointer to struct lbs_private structure
2212 * @param bssid The specific BSS to deauthenticate from
2213 * @param reason The 802.11 sec. 7.3.1.7 Reason Code for deauthenticating
2215 * @return 0 on success, error on failure
2217 int lbs_cmd_80211_deauthenticate(struct lbs_private
*priv
, u8 bssid
[ETH_ALEN
],
2220 struct cmd_ds_802_11_deauthenticate cmd
;
2223 lbs_deb_enter(LBS_DEB_JOIN
);
2225 memset(&cmd
, 0, sizeof(cmd
));
2226 cmd
.hdr
.size
= cpu_to_le16(sizeof(cmd
));
2227 memcpy(cmd
.macaddr
, &bssid
[0], ETH_ALEN
);
2228 cmd
.reasoncode
= cpu_to_le16(reason
);
2230 ret
= lbs_cmd_with_response(priv
, CMD_802_11_DEAUTHENTICATE
, &cmd
);
2232 /* Clean up everything even if there was an error; can't assume that
2233 * we're still authenticated to the AP after trying to deauth.
2235 lbs_mac_event_disconnected(priv
);
2237 lbs_deb_leave(LBS_DEB_JOIN
);