2 * Functions implementing wlan infrastructure and adhoc join routines,
3 * IOCTL handlers as well as command preperation and response routines
4 * for sending adhoc start, adhoc join, and association commands
7 #include <linux/netdevice.h>
8 #include <linux/if_arp.h>
9 #include <linux/wireless.h>
11 #include <net/iw_handler.h>
18 #define AD_HOC_CAP_PRIVACY_ON 1
21 * @brief This function finds out the common rates between rate1 and rate2.
23 * It will fill common rates in rate1 as output if found.
25 * NOTE: Setting the MSB of the basic rates need to be taken
26 * care, either before or after calling this function
28 * @param adapter A pointer to wlan_adapter structure
29 * @param rate1 the buffer which keeps input and output
30 * @param rate1_size the size of rate1 buffer
31 * @param rate2 the buffer which keeps rate2
32 * @param rate2_size the size of rate2 buffer.
36 static int get_common_rates(wlan_adapter * adapter, u8 * rate1,
37 int rate1_size, u8 * rate2, int rate2_size)
44 memset(&tmp, 0, sizeof(tmp));
45 memcpy(&tmp, rate1, min_t(size_t, rate1_size, sizeof(tmp)));
46 memset(rate1, 0, rate1_size);
48 /* Mask the top bit of the original values */
49 for (i = 0; tmp[i] && i < sizeof(tmp); i++)
52 for (i = 0; rate2[i] && i < rate2_size; i++) {
53 /* Check for Card Rate in tmp, excluding the top bit */
54 if (strchr(tmp, rate2[i] & 0x7F)) {
55 /* values match, so copy the Card Rate to rate1 */
60 lbs_dbg_hex("rate1 (AP) rates:", tmp, sizeof(tmp));
61 lbs_dbg_hex("rate2 (Card) rates:", rate2, rate2_size);
62 lbs_dbg_hex("Common rates:", ptr, rate1_size);
63 lbs_pr_debug(1, "Tx datarate is set to 0x%X\n", adapter->datarate);
65 if (!adapter->is_datarate_auto) {
67 if ((*ptr & 0x7f) == adapter->datarate) {
73 lbs_pr_alert( "Previously set fixed data rate %#x isn't "
74 "compatible with the network.\n", adapter->datarate);
85 int libertas_send_deauth(wlan_private * priv)
87 wlan_adapter *adapter = priv->adapter;
90 if (adapter->inframode == wlan802_11infrastructure &&
91 adapter->connect_status == libertas_connected)
92 ret = libertas_send_deauthentication(priv);
99 int libertas_do_adhocstop_ioctl(wlan_private * priv)
101 wlan_adapter *adapter = priv->adapter;
104 if (adapter->inframode == wlan802_11ibss &&
105 adapter->connect_status == libertas_connected)
106 ret = libertas_stop_adhoc_network(priv);
114 * @brief Associate to a specific BSS discovered in a scan
116 * @param priv A pointer to wlan_private structure
117 * @param pbssdesc Pointer to the BSS descriptor to associate with.
119 * @return 0-success, otherwise fail
121 int wlan_associate(wlan_private * priv, struct bss_descriptor * pbssdesc)
123 wlan_adapter *adapter = priv->adapter;
128 ret = libertas_prepare_and_send_command(priv, cmd_802_11_authenticate,
129 0, cmd_option_waitforrsp,
130 0, pbssdesc->macaddress);
137 /* set preamble to firmware */
138 if (adapter->capinfo.shortpreamble && pbssdesc->cap.shortpreamble)
139 adapter->preamble = cmd_type_short_preamble;
141 adapter->preamble = cmd_type_long_preamble;
143 libertas_set_radio_control(priv);
145 ret = libertas_prepare_and_send_command(priv, cmd_802_11_associate,
146 0, cmd_option_waitforrsp, 0, pbssdesc);
153 * @brief Start an Adhoc Network
155 * @param priv A pointer to wlan_private structure
156 * @param adhocssid The ssid of the Adhoc Network
157 * @return 0--success, -1--fail
159 int libertas_start_adhoc_network(wlan_private * priv, struct WLAN_802_11_SSID *adhocssid)
161 wlan_adapter *adapter = priv->adapter;
164 adapter->adhoccreate = 1;
166 if (!adapter->capinfo.shortpreamble) {
167 lbs_pr_debug(1, "AdhocStart: Long preamble\n");
168 adapter->preamble = cmd_type_long_preamble;
170 lbs_pr_debug(1, "AdhocStart: Short preamble\n");
171 adapter->preamble = cmd_type_short_preamble;
174 libertas_set_radio_control(priv);
176 lbs_pr_debug(1, "Adhoc channel = %d\n", adapter->adhocchannel);
177 lbs_pr_debug(1, "curbssparams.channel = %d\n",
178 adapter->curbssparams.channel);
179 lbs_pr_debug(1, "curbssparams.band = %d\n", adapter->curbssparams.band);
181 ret = libertas_prepare_and_send_command(priv, cmd_802_11_ad_hoc_start,
182 0, cmd_option_waitforrsp, 0, adhocssid);
188 * @brief Join an adhoc network found in a previous scan
190 * @param priv A pointer to wlan_private structure
191 * @param pbssdesc Pointer to a BSS descriptor found in a previous scan
194 * @return 0--success, -1--fail
196 int libertas_join_adhoc_network(wlan_private * priv, struct bss_descriptor * pbssdesc)
198 wlan_adapter *adapter = priv->adapter;
201 lbs_pr_debug(1, "libertas_join_adhoc_network: CurBss.ssid =%s\n",
202 adapter->curbssparams.ssid.ssid);
203 lbs_pr_debug(1, "libertas_join_adhoc_network: CurBss.ssid_len =%u\n",
204 adapter->curbssparams.ssid.ssidlength);
205 lbs_pr_debug(1, "libertas_join_adhoc_network: ssid =%s\n", pbssdesc->ssid.ssid);
206 lbs_pr_debug(1, "libertas_join_adhoc_network: ssid len =%u\n",
207 pbssdesc->ssid.ssidlength);
209 /* check if the requested SSID is already joined */
210 if (adapter->curbssparams.ssid.ssidlength
211 && !libertas_SSID_cmp(&pbssdesc->ssid, &adapter->curbssparams.ssid)
212 && (adapter->curbssparams.bssdescriptor.inframode ==
216 "ADHOC_J_CMD: New ad-hoc SSID is the same as current, "
217 "not attempting to re-join");
222 /*Use shortpreamble only when both creator and card supports
224 if (!pbssdesc->cap.shortpreamble || !adapter->capinfo.shortpreamble) {
225 lbs_pr_debug(1, "AdhocJoin: Long preamble\n");
226 adapter->preamble = cmd_type_long_preamble;
228 lbs_pr_debug(1, "AdhocJoin: Short preamble\n");
229 adapter->preamble = cmd_type_short_preamble;
232 libertas_set_radio_control(priv);
234 lbs_pr_debug(1, "curbssparams.channel = %d\n",
235 adapter->curbssparams.channel);
236 lbs_pr_debug(1, "curbssparams.band = %c\n", adapter->curbssparams.band);
238 adapter->adhoccreate = 0;
240 ret = libertas_prepare_and_send_command(priv, cmd_802_11_ad_hoc_join,
241 0, cmd_option_waitforrsp,
242 OID_802_11_SSID, pbssdesc);
247 int libertas_stop_adhoc_network(wlan_private * priv)
249 return libertas_prepare_and_send_command(priv, cmd_802_11_ad_hoc_stop,
250 0, cmd_option_waitforrsp, 0, NULL);
254 * @brief Send Deauthentication Request
256 * @param priv A pointer to wlan_private structure
257 * @return 0--success, -1--fail
259 int libertas_send_deauthentication(wlan_private * priv)
261 return libertas_prepare_and_send_command(priv, cmd_802_11_deauthenticate,
262 0, cmd_option_waitforrsp, 0, NULL);
266 * @brief Set Idle Off
268 * @param priv A pointer to wlan_private structure
269 * @return 0 --success, otherwise fail
271 int libertas_idle_off(wlan_private * priv)
273 wlan_adapter *adapter = priv->adapter;
275 const u8 zeromac[] = { 0, 0, 0, 0, 0, 0 };
280 if (adapter->connect_status == libertas_disconnected) {
281 if (adapter->inframode == wlan802_11infrastructure) {
282 if (memcmp(adapter->previousbssid, zeromac,
283 sizeof(zeromac)) != 0) {
285 lbs_pr_debug(1, "Previous SSID = %s\n",
286 adapter->previousssid.ssid);
287 lbs_pr_debug(1, "Previous BSSID = "
288 "%02x:%02x:%02x:%02x:%02x:%02x:\n",
289 adapter->previousbssid[0],
290 adapter->previousbssid[1],
291 adapter->previousbssid[2],
292 adapter->previousbssid[3],
293 adapter->previousbssid[4],
294 adapter->previousbssid[5]);
296 i = libertas_find_SSID_in_list(adapter,
297 &adapter->previousssid,
298 adapter->previousbssid,
302 libertas_send_specific_BSSID_scan(priv,
306 i = libertas_find_SSID_in_list(adapter,
316 /* If the BSSID could not be found, try just the SSID */
317 i = libertas_find_SSID_in_list(adapter,
325 libertas_send_specific_SSID_scan(priv,
329 i = libertas_find_SSID_in_list(adapter,
343 } else if (adapter->inframode == wlan802_11ibss) {
344 ret = libertas_prepare_and_send_command(priv,
345 cmd_802_11_ad_hoc_start,
347 cmd_option_waitforrsp,
348 0, &adapter->previousssid);
351 /* else it is connected */
353 lbs_pr_debug(1, "\nwlanidle is off");
361 * @param priv A pointer to wlan_private structure
362 * @return 0 --success, otherwise fail
364 int libertas_idle_on(wlan_private * priv)
366 wlan_adapter *adapter = priv->adapter;
369 if (adapter->connect_status == libertas_connected) {
370 if (adapter->inframode == wlan802_11infrastructure) {
371 lbs_pr_debug(1, "Previous SSID = %s\n",
372 adapter->previousssid.ssid);
373 memmove(&adapter->previousssid,
374 &adapter->curbssparams.ssid,
375 sizeof(struct WLAN_802_11_SSID));
376 libertas_send_deauth(priv);
378 } else if (adapter->inframode == wlan802_11ibss) {
379 ret = libertas_stop_adhoc_network(priv);
384 lbs_pr_debug(1, "\nwlanidle is on");
390 * @brief This function prepares command of authenticate.
392 * @param priv A pointer to wlan_private structure
393 * @param cmd A pointer to cmd_ds_command structure
394 * @param pdata_buf Void cast of pointer to a BSSID to authenticate with
398 int libertas_cmd_80211_authenticate(wlan_private * priv,
399 struct cmd_ds_command *cmd,
402 wlan_adapter *adapter = priv->adapter;
403 struct cmd_ds_802_11_authenticate *pauthenticate = &cmd->params.auth;
405 u8 *bssid = pdata_buf;
407 cmd->command = cpu_to_le16(cmd_802_11_authenticate);
408 cmd->size = cpu_to_le16(sizeof(struct cmd_ds_802_11_authenticate)
411 /* translate auth mode to 802.11 defined wire value */
412 switch (adapter->secinfo.auth_mode) {
413 case IW_AUTH_ALG_OPEN_SYSTEM:
414 pauthenticate->authtype = 0x00;
416 case IW_AUTH_ALG_SHARED_KEY:
417 pauthenticate->authtype = 0x01;
419 case IW_AUTH_ALG_LEAP:
420 pauthenticate->authtype = 0x80;
423 lbs_pr_debug(1, "AUTH_CMD: invalid auth alg 0x%X\n",
424 adapter->secinfo.auth_mode);
428 memcpy(pauthenticate->macaddr, bssid, ETH_ALEN);
430 lbs_pr_debug(1, "AUTH_CMD: Bssid is : %x:%x:%x:%x:%x:%x\n",
431 bssid[0], bssid[1], bssid[2], bssid[3], bssid[4], bssid[5]);
438 int libertas_cmd_80211_deauthenticate(wlan_private * priv,
439 struct cmd_ds_command *cmd)
441 wlan_adapter *adapter = priv->adapter;
442 struct cmd_ds_802_11_deauthenticate *dauth = &cmd->params.deauth;
446 cmd->command = cpu_to_le16(cmd_802_11_deauthenticate);
448 cpu_to_le16(sizeof(struct cmd_ds_802_11_deauthenticate) +
451 /* set AP MAC address */
452 memmove(dauth->macaddr, adapter->curbssparams.bssid,
455 /* Reason code 3 = Station is leaving */
456 #define REASON_CODE_STA_LEAVING 3
457 dauth->reasoncode = cpu_to_le16(REASON_CODE_STA_LEAVING);
463 int libertas_cmd_80211_associate(wlan_private * priv,
464 struct cmd_ds_command *cmd, void *pdata_buf)
466 wlan_adapter *adapter = priv->adapter;
467 struct cmd_ds_802_11_associate *passo = &cmd->params.associate;
469 struct bss_descriptor *pbssdesc;
474 struct mrvlietypes_ssidparamset *ssid;
475 struct mrvlietypes_phyparamset *phy;
476 struct mrvlietypes_ssparamset *ss;
477 struct mrvlietypes_ratesparamset *rates;
478 struct mrvlietypes_rsnparamset *rsn;
482 pbssdesc = pdata_buf;
490 cmd->command = cpu_to_le16(cmd_802_11_associate);
492 /* Save so we know which BSS Desc to use in the response handler */
493 adapter->pattemptedbssdesc = pbssdesc;
495 memcpy(passo->peerstaaddr,
496 pbssdesc->macaddress, sizeof(passo->peerstaaddr));
497 pos += sizeof(passo->peerstaaddr);
499 /* set the listen interval */
500 passo->listeninterval = adapter->listeninterval;
502 pos += sizeof(passo->capinfo);
503 pos += sizeof(passo->listeninterval);
504 pos += sizeof(passo->bcnperiod);
505 pos += sizeof(passo->dtimperiod);
507 ssid = (struct mrvlietypes_ssidparamset *) pos;
508 ssid->header.type = cpu_to_le16(TLV_TYPE_SSID);
509 ssid->header.len = pbssdesc->ssid.ssidlength;
510 memcpy(ssid->ssid, pbssdesc->ssid.ssid, ssid->header.len);
511 pos += sizeof(ssid->header) + ssid->header.len;
512 ssid->header.len = cpu_to_le16(ssid->header.len);
514 phy = (struct mrvlietypes_phyparamset *) pos;
515 phy->header.type = cpu_to_le16(TLV_TYPE_PHY_DS);
516 phy->header.len = sizeof(phy->fh_ds.dsparamset);
517 memcpy(&phy->fh_ds.dsparamset,
518 &pbssdesc->phyparamset.dsparamset.currentchan,
519 sizeof(phy->fh_ds.dsparamset));
520 pos += sizeof(phy->header) + phy->header.len;
521 phy->header.len = cpu_to_le16(phy->header.len);
523 ss = (struct mrvlietypes_ssparamset *) pos;
524 ss->header.type = cpu_to_le16(TLV_TYPE_CF);
525 ss->header.len = sizeof(ss->cf_ibss.cfparamset);
526 pos += sizeof(ss->header) + ss->header.len;
527 ss->header.len = cpu_to_le16(ss->header.len);
529 rates = (struct mrvlietypes_ratesparamset *) pos;
530 rates->header.type = cpu_to_le16(TLV_TYPE_RATES);
532 memcpy(&rates->rates, &pbssdesc->libertas_supported_rates, WLAN_SUPPORTED_RATES);
534 card_rates = libertas_supported_rates;
535 card_rates_size = sizeof(libertas_supported_rates);
537 if (get_common_rates(adapter, rates->rates, WLAN_SUPPORTED_RATES,
538 card_rates, card_rates_size)) {
543 rates->header.len = min_t(size_t, strlen(rates->rates), WLAN_SUPPORTED_RATES);
544 adapter->curbssparams.numofrates = rates->header.len;
546 pos += sizeof(rates->header) + rates->header.len;
547 rates->header.len = cpu_to_le16(rates->header.len);
549 if (adapter->secinfo.WPAenabled || adapter->secinfo.WPA2enabled) {
550 rsn = (struct mrvlietypes_rsnparamset *) pos;
551 rsn->header.type = (u16) adapter->wpa_ie[0]; /* WPA_IE or WPA2_IE */
552 rsn->header.type = cpu_to_le16(rsn->header.type);
553 rsn->header.len = (u16) adapter->wpa_ie[1];
554 memcpy(rsn->rsnie, &adapter->wpa_ie[2], rsn->header.len);
555 lbs_dbg_hex("ASSOC_CMD: RSN IE", (u8 *) rsn,
556 sizeof(rsn->header) + rsn->header.len);
557 pos += sizeof(rsn->header) + rsn->header.len;
558 rsn->header.len = cpu_to_le16(rsn->header.len);
561 /* update curbssparams */
562 adapter->curbssparams.channel =
563 (pbssdesc->phyparamset.dsparamset.currentchan);
565 /* Copy the infra. association rates into Current BSS state structure */
566 memcpy(&adapter->curbssparams.datarates, &rates->rates,
567 min_t(size_t, sizeof(adapter->curbssparams.datarates), rates->header.len));
569 lbs_pr_debug(1, "ASSOC_CMD: rates->header.len = %d\n", rates->header.len);
572 if (pbssdesc->inframode == wlan802_11infrastructure) {
573 #define CAPINFO_ESS_MODE 1
574 passo->capinfo.ess = CAPINFO_ESS_MODE;
577 if (libertas_parse_dnld_countryinfo_11d(priv)) {
582 cmd->size = cpu_to_le16((u16) (pos - (u8 *) passo) + S_DS_GEN);
584 /* set the capability info at last */
585 memcpy(&tmpcap, &pbssdesc->cap, sizeof(passo->capinfo));
586 tmpcap &= CAPINFO_MASK;
587 lbs_pr_debug(1, "ASSOC_CMD: tmpcap=%4X CAPINFO_MASK=%4X\n",
588 tmpcap, CAPINFO_MASK);
589 tmpcap = cpu_to_le16(tmpcap);
590 memcpy(&passo->capinfo, &tmpcap, sizeof(passo->capinfo));
597 int libertas_cmd_80211_ad_hoc_start(wlan_private * priv,
598 struct cmd_ds_command *cmd, void *pssid)
600 wlan_adapter *adapter = priv->adapter;
601 struct cmd_ds_802_11_ad_hoc_start *adhs = &cmd->params.ads;
603 int cmdappendsize = 0;
606 struct bss_descriptor *pbssdesc;
607 struct WLAN_802_11_SSID *ssid = pssid;
616 cmd->command = cpu_to_le16(cmd_802_11_ad_hoc_start);
618 pbssdesc = &adapter->curbssparams.bssdescriptor;
619 adapter->pattemptedbssdesc = pbssdesc;
622 * Fill in the parameters for 2 data structures:
623 * 1. cmd_ds_802_11_ad_hoc_start command
624 * 2. adapter->scantable[i]
626 * Driver will fill up SSID, bsstype,IBSS param, Physical Param,
627 * probe delay, and cap info.
629 * Firmware will fill up beacon period, DTIM, Basic rates
630 * and operational rates.
633 memset(adhs->SSID, 0, IW_ESSID_MAX_SIZE);
635 memcpy(adhs->SSID, ssid->ssid, ssid->ssidlength);
637 lbs_pr_debug(1, "ADHOC_S_CMD: SSID = %s\n", adhs->SSID);
639 memset(pbssdesc->ssid.ssid, 0, IW_ESSID_MAX_SIZE);
640 memcpy(pbssdesc->ssid.ssid, ssid->ssid, ssid->ssidlength);
642 pbssdesc->ssid.ssidlength = ssid->ssidlength;
644 /* set the BSS type */
645 adhs->bsstype = cmd_bss_type_ibss;
646 pbssdesc->inframode = wlan802_11ibss;
647 adhs->beaconperiod = adapter->beaconperiod;
649 /* set Physical param set */
650 #define DS_PARA_IE_ID 3
651 #define DS_PARA_IE_LEN 1
653 adhs->phyparamset.dsparamset.elementid = DS_PARA_IE_ID;
654 adhs->phyparamset.dsparamset.len = DS_PARA_IE_LEN;
656 WARN_ON(!adapter->adhocchannel);
658 lbs_pr_debug(1, "ADHOC_S_CMD: Creating ADHOC on channel %d\n",
659 adapter->adhocchannel);
661 adapter->curbssparams.channel = adapter->adhocchannel;
663 pbssdesc->channel = adapter->adhocchannel;
664 adhs->phyparamset.dsparamset.currentchan = adapter->adhocchannel;
666 memcpy(&pbssdesc->phyparamset,
667 &adhs->phyparamset, sizeof(union ieeetypes_phyparamset));
669 /* set IBSS param set */
670 #define IBSS_PARA_IE_ID 6
671 #define IBSS_PARA_IE_LEN 2
673 adhs->ssparamset.ibssparamset.elementid = IBSS_PARA_IE_ID;
674 adhs->ssparamset.ibssparamset.len = IBSS_PARA_IE_LEN;
675 adhs->ssparamset.ibssparamset.atimwindow = adapter->atimwindow;
676 memcpy(&pbssdesc->ssparamset,
677 &adhs->ssparamset, sizeof(union IEEEtypes_ssparamset));
679 /* set capability info */
682 pbssdesc->cap.ibss = 1;
685 adhs->probedelay = cpu_to_le16(cmd_scan_probe_delay_time);
687 /* set up privacy in adapter->scantable[i] */
688 if (adapter->secinfo.wep_enabled) {
689 lbs_pr_debug(1, "ADHOC_S_CMD: WEP enabled, setting privacy on\n");
690 pbssdesc->privacy = wlan802_11privfilter8021xWEP;
691 adhs->cap.privacy = AD_HOC_CAP_PRIVACY_ON;
693 lbs_pr_debug(1, "ADHOC_S_CMD: WEP disabled, setting privacy off\n");
694 pbssdesc->privacy = wlan802_11privfilteracceptall;
697 memset(adhs->datarate, 0, sizeof(adhs->datarate));
699 if (adapter->adhoc_grate_enabled) {
700 memcpy(adhs->datarate, libertas_adhoc_rates_g,
701 min(sizeof(adhs->datarate), sizeof(libertas_adhoc_rates_g)));
703 memcpy(adhs->datarate, libertas_adhoc_rates_b,
704 min(sizeof(adhs->datarate), sizeof(libertas_adhoc_rates_b)));
707 /* Find the last non zero */
708 for (i = 0; i < sizeof(adhs->datarate) && adhs->datarate[i]; i++) ;
710 adapter->curbssparams.numofrates = i;
712 /* Copy the ad-hoc creating rates into Current BSS state structure */
713 memcpy(&adapter->curbssparams.datarates,
714 &adhs->datarate, adapter->curbssparams.numofrates);
716 lbs_pr_debug(1, "ADHOC_S_CMD: rates=%02x %02x %02x %02x \n",
717 adhs->datarate[0], adhs->datarate[1],
718 adhs->datarate[2], adhs->datarate[3]);
720 lbs_pr_debug(1, "ADHOC_S_CMD: AD HOC Start command is ready\n");
722 if (libertas_create_dnld_countryinfo_11d(priv)) {
723 lbs_pr_debug(1, "ADHOC_S_CMD: dnld_countryinfo_11d failed\n");
729 cpu_to_le16(sizeof(struct cmd_ds_802_11_ad_hoc_start)
730 + S_DS_GEN + cmdappendsize);
732 memcpy(&tmpcap, &adhs->cap, sizeof(u16));
733 tmpcap = cpu_to_le16(tmpcap);
734 memcpy(&adhs->cap, &tmpcap, sizeof(u16));
742 int libertas_cmd_80211_ad_hoc_stop(wlan_private * priv,
743 struct cmd_ds_command *cmd)
745 cmd->command = cpu_to_le16(cmd_802_11_ad_hoc_stop);
746 cmd->size = cpu_to_le16(S_DS_GEN);
751 int libertas_cmd_80211_ad_hoc_join(wlan_private * priv,
752 struct cmd_ds_command *cmd, void *pdata_buf)
754 wlan_adapter *adapter = priv->adapter;
755 struct cmd_ds_802_11_ad_hoc_join *padhocjoin = &cmd->params.adj;
756 struct bss_descriptor *pbssdesc = pdata_buf;
757 int cmdappendsize = 0;
766 adapter->pattemptedbssdesc = pbssdesc;
768 cmd->command = cpu_to_le16(cmd_802_11_ad_hoc_join);
770 padhocjoin->bssdescriptor.bsstype = cmd_bss_type_ibss;
772 padhocjoin->bssdescriptor.beaconperiod = pbssdesc->beaconperiod;
774 memcpy(&padhocjoin->bssdescriptor.BSSID,
775 &pbssdesc->macaddress, ETH_ALEN);
777 memcpy(&padhocjoin->bssdescriptor.SSID,
778 &pbssdesc->ssid.ssid, pbssdesc->ssid.ssidlength);
780 memcpy(&padhocjoin->bssdescriptor.phyparamset,
781 &pbssdesc->phyparamset, sizeof(union ieeetypes_phyparamset));
783 memcpy(&padhocjoin->bssdescriptor.ssparamset,
784 &pbssdesc->ssparamset, sizeof(union IEEEtypes_ssparamset));
786 memcpy(&tmpcap, &pbssdesc->cap, sizeof(struct ieeetypes_capinfo));
787 tmpcap &= CAPINFO_MASK;
789 lbs_pr_debug(1, "ADHOC_J_CMD: tmpcap=%4X CAPINFO_MASK=%4X\n",
790 tmpcap, CAPINFO_MASK);
791 memcpy(&padhocjoin->bssdescriptor.cap, &tmpcap,
792 sizeof(struct ieeetypes_capinfo));
794 /* information on BSSID descriptor passed to FW */
796 "ADHOC_J_CMD: BSSID = %2x-%2x-%2x-%2x-%2x-%2x, SSID = %s\n",
797 padhocjoin->bssdescriptor.BSSID[0],
798 padhocjoin->bssdescriptor.BSSID[1],
799 padhocjoin->bssdescriptor.BSSID[2],
800 padhocjoin->bssdescriptor.BSSID[3],
801 padhocjoin->bssdescriptor.BSSID[4],
802 padhocjoin->bssdescriptor.BSSID[5],
803 padhocjoin->bssdescriptor.SSID);
805 lbs_pr_debug(1, "ADHOC_J_CMD: Data Rate = %x\n",
806 (u32) padhocjoin->bssdescriptor.datarates);
809 padhocjoin->failtimeout = cpu_to_le16(MRVDRV_ASSOCIATION_TIME_OUT);
812 padhocjoin->probedelay =
813 cpu_to_le16(cmd_scan_probe_delay_time);
815 /* Copy Data rates from the rates recorded in scan response */
816 memset(padhocjoin->bssdescriptor.datarates, 0,
817 sizeof(padhocjoin->bssdescriptor.datarates));
818 memcpy(padhocjoin->bssdescriptor.datarates, pbssdesc->datarates,
819 min(sizeof(padhocjoin->bssdescriptor.datarates),
820 sizeof(pbssdesc->datarates)));
822 card_rates = libertas_supported_rates;
823 card_rates_size = sizeof(libertas_supported_rates);
825 adapter->curbssparams.channel = pbssdesc->channel;
827 if (get_common_rates(adapter, padhocjoin->bssdescriptor.datarates,
828 sizeof(padhocjoin->bssdescriptor.datarates),
829 card_rates, card_rates_size)) {
830 lbs_pr_debug(1, "ADHOC_J_CMD: get_common_rates returns error.\n");
835 /* Find the last non zero */
836 for (i = 0; i < sizeof(padhocjoin->bssdescriptor.datarates)
837 && padhocjoin->bssdescriptor.datarates[i]; i++) ;
839 adapter->curbssparams.numofrates = i;
842 * Copy the adhoc joining rates to Current BSS State structure
844 memcpy(adapter->curbssparams.datarates,
845 padhocjoin->bssdescriptor.datarates,
846 adapter->curbssparams.numofrates);
848 padhocjoin->bssdescriptor.ssparamset.ibssparamset.atimwindow =
849 cpu_to_le16(pbssdesc->atimwindow);
851 if (adapter->secinfo.wep_enabled) {
852 padhocjoin->bssdescriptor.cap.privacy = AD_HOC_CAP_PRIVACY_ON;
855 if (adapter->psmode == wlan802_11powermodemax_psp) {
857 enum WLAN_802_11_POWER_MODE Localpsmode;
859 Localpsmode = wlan802_11powermodecam;
860 ret = libertas_prepare_and_send_command(priv,
871 if (libertas_parse_dnld_countryinfo_11d(priv)) {
877 cpu_to_le16(sizeof(struct cmd_ds_802_11_ad_hoc_join)
878 + S_DS_GEN + cmdappendsize);
880 memcpy(&tmpcap, &padhocjoin->bssdescriptor.cap,
881 sizeof(struct ieeetypes_capinfo));
882 tmpcap = cpu_to_le16(tmpcap);
884 memcpy(&padhocjoin->bssdescriptor.cap,
885 &tmpcap, sizeof(struct ieeetypes_capinfo));
892 int libertas_ret_80211_associate(wlan_private * priv,
893 struct cmd_ds_command *resp)
895 wlan_adapter *adapter = priv->adapter;
897 union iwreq_data wrqu;
898 struct ieeetypes_assocrsp *passocrsp;
899 struct bss_descriptor *pbssdesc;
903 passocrsp = (struct ieeetypes_assocrsp *) & resp->params;
905 if (passocrsp->statuscode) {
907 libertas_mac_event_disconnected(priv);
910 "ASSOC_RESP: Association failed, status code = %d\n",
911 passocrsp->statuscode);
917 lbs_dbg_hex("ASSOC_RESP:", (void *)&resp->params,
918 le16_to_cpu(resp->size) - S_DS_GEN);
920 /* Send a Media Connected event, according to the Spec */
921 adapter->connect_status = libertas_connected;
923 /* Set the attempted BSSID Index to current */
924 pbssdesc = adapter->pattemptedbssdesc;
926 lbs_pr_debug(1, "ASSOC_RESP: %s\n", pbssdesc->ssid.ssid);
928 /* Set the new SSID to current SSID */
929 memcpy(&adapter->curbssparams.ssid,
930 &pbssdesc->ssid, sizeof(struct WLAN_802_11_SSID));
932 /* Set the new BSSID (AP's MAC address) to current BSSID */
933 memcpy(adapter->curbssparams.bssid,
934 pbssdesc->macaddress, ETH_ALEN);
936 /* Make a copy of current BSSID descriptor */
937 memcpy(&adapter->curbssparams.bssdescriptor,
938 pbssdesc, sizeof(struct bss_descriptor));
940 lbs_pr_debug(1, "ASSOC_RESP: currentpacketfilter is %x\n",
941 adapter->currentpacketfilter);
943 adapter->SNR[TYPE_RXPD][TYPE_AVG] = 0;
944 adapter->NF[TYPE_RXPD][TYPE_AVG] = 0;
946 memset(adapter->rawSNR, 0x00, sizeof(adapter->rawSNR));
947 memset(adapter->rawNF, 0x00, sizeof(adapter->rawNF));
948 adapter->nextSNRNF = 0;
949 adapter->numSNRNF = 0;
951 netif_carrier_on(priv->wlan_dev.netdev);
952 netif_wake_queue(priv->wlan_dev.netdev);
954 lbs_pr_debug(1, "ASSOC_RESP: Associated \n");
956 memcpy(wrqu.ap_addr.sa_data, adapter->curbssparams.bssid, ETH_ALEN);
957 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
958 wireless_send_event(priv->wlan_dev.netdev, SIOCGIWAP, &wrqu, NULL);
965 int libertas_ret_80211_disassociate(wlan_private * priv,
966 struct cmd_ds_command *resp)
970 libertas_mac_event_disconnected(priv);
976 int libertas_ret_80211_ad_hoc_start(wlan_private * priv,
977 struct cmd_ds_command *resp)
979 wlan_adapter *adapter = priv->adapter;
981 u16 command = le16_to_cpu(resp->command);
982 u16 result = le16_to_cpu(resp->result);
983 struct cmd_ds_802_11_ad_hoc_result *padhocresult;
984 union iwreq_data wrqu;
985 struct bss_descriptor *pbssdesc;
989 padhocresult = &resp->params.result;
991 lbs_pr_debug(1, "ADHOC_S_RESP: size = %d\n", le16_to_cpu(resp->size));
992 lbs_pr_debug(1, "ADHOC_S_RESP: command = %x\n", command);
993 lbs_pr_debug(1, "ADHOC_S_RESP: result = %x\n", result);
995 pbssdesc = adapter->pattemptedbssdesc;
998 * Join result code 0 --> SUCCESS
1001 lbs_pr_debug(1, "ADHOC_RESP failed\n");
1002 if (adapter->connect_status == libertas_connected) {
1003 libertas_mac_event_disconnected(priv);
1006 memset(&adapter->curbssparams.bssdescriptor,
1007 0x00, sizeof(adapter->curbssparams.bssdescriptor));
1014 * Now the join cmd should be successful
1015 * If BSSID has changed use SSID to compare instead of BSSID
1017 lbs_pr_debug(1, "ADHOC_J_RESP %s\n", pbssdesc->ssid.ssid);
1019 /* Send a Media Connected event, according to the Spec */
1020 adapter->connect_status = libertas_connected;
1022 if (command == cmd_ret_802_11_ad_hoc_start) {
1023 /* Update the created network descriptor with the new BSSID */
1024 memcpy(pbssdesc->macaddress,
1025 padhocresult->BSSID, ETH_ALEN);
1028 /* Make a copy of current BSSID descriptor, only needed for join since
1029 * the current descriptor is already being used for adhoc start
1031 memmove(&adapter->curbssparams.bssdescriptor,
1032 pbssdesc, sizeof(struct bss_descriptor));
1035 /* Set the BSSID from the joined/started descriptor */
1036 memcpy(&adapter->curbssparams.bssid,
1037 pbssdesc->macaddress, ETH_ALEN);
1039 /* Set the new SSID to current SSID */
1040 memcpy(&adapter->curbssparams.ssid,
1041 &pbssdesc->ssid, sizeof(struct WLAN_802_11_SSID));
1043 netif_carrier_on(priv->wlan_dev.netdev);
1044 netif_wake_queue(priv->wlan_dev.netdev);
1046 memset(&wrqu, 0, sizeof(wrqu));
1047 memcpy(wrqu.ap_addr.sa_data, adapter->curbssparams.bssid, ETH_ALEN);
1048 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1049 wireless_send_event(priv->wlan_dev.netdev, SIOCGIWAP, &wrqu, NULL);
1051 lbs_pr_debug(1, "ADHOC_RESP: - Joined/Started Ad Hoc\n");
1052 lbs_pr_debug(1, "ADHOC_RESP: channel = %d\n", adapter->adhocchannel);
1053 lbs_pr_debug(1, "ADHOC_RESP: BSSID = %02x:%02x:%02x:%02x:%02x:%02x\n",
1054 padhocresult->BSSID[0], padhocresult->BSSID[1],
1055 padhocresult->BSSID[2], padhocresult->BSSID[3],
1056 padhocresult->BSSID[4], padhocresult->BSSID[5]);
1062 int libertas_ret_80211_ad_hoc_stop(wlan_private * priv,
1063 struct cmd_ds_command *resp)
1067 libertas_mac_event_disconnected(priv);