Lines Matching refs:priv
21 static inline void inc_smeqhead(struct ks_wlan_private *priv)
23 priv->sme_i.qhead = (priv->sme_i.qhead + 1) % SME_EVENT_BUFF_SIZE;
26 static inline void inc_smeqtail(struct ks_wlan_private *priv)
28 priv->sme_i.qtail = (priv->sme_i.qtail + 1) % SME_EVENT_BUFF_SIZE;
31 static inline unsigned int cnt_smeqbody(struct ks_wlan_private *priv)
33 return CIRC_CNT_TO_END(priv->sme_i.qhead, priv->sme_i.qtail,
37 static inline u8 get_byte(struct ks_wlan_private *priv)
41 data = *priv->rxp++;
43 --(priv->rx_size);
47 static inline u16 get_word(struct ks_wlan_private *priv)
51 data = (get_byte(priv) & 0xff);
52 data |= ((get_byte(priv) << 8) & 0xff00);
56 static inline u32 get_dword(struct ks_wlan_private *priv)
60 data = (get_byte(priv) & 0xff);
61 data |= ((get_byte(priv) << 8) & 0x0000ff00);
62 data |= ((get_byte(priv) << 16) & 0x00ff0000);
63 data |= ((get_byte(priv) << 24) & 0xff000000);
69 struct ks_wlan_private *priv;
73 priv = container_of(work, struct ks_wlan_private, wakeup_work);
74 ps_status = atomic_read(&priv->psstatus.status);
77 ks_wlan_hw_wakeup_request(priv);
78 time_left = wait_for_completion_interruptible_timeout(&priv->psstatus.wakeup_wait,
81 netdev_dbg(priv->net_dev, "wake up timeout or interrupted !!!\n");
82 schedule_work(&priv->wakeup_work);
88 static void ks_wlan_do_power_save(struct ks_wlan_private *priv)
90 if (is_connect_status(priv->connect_status))
91 hostif_sme_enqueue(priv, SME_POW_MNGMT_REQUEST);
93 priv->dev_state = DEVICE_STATE_READY;
97 int get_current_ap(struct ks_wlan_private *priv, struct link_ap_info *ap_info)
101 struct net_device *netdev = priv->net_dev;
104 ap = &priv->current_ap;
106 if (is_disconnect_status(priv->connect_status)) {
112 memcpy(ap->ssid.body, priv->reg.ssid.body,
113 priv->reg.ssid.size);
114 ap->ssid.size = priv->reg.ssid.size;
132 (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2)) {
137 (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA)) {
151 if (is_connect_status(priv->connect_status)) {
152 ether_addr_copy(wrqu.ap_addr.sa_data, priv->current_ap.bssid);
153 netdev_dbg(priv->net_dev,
158 netdev_dbg(priv->net_dev, "Link AP\n"
253 int get_ap_information(struct ks_wlan_private *priv, struct ap_info *ap_info,
315 netdev_err(priv->net_dev,
329 int hostif_data_indication_wpa(struct ks_wlan_private *priv,
341 struct wpa_key *key = &priv->wpa.key[key_index];
343 eth_hdr = (struct ether_hdr *)(priv->rxp);
347 netdev_err(priv->net_dev, "invalid data format\n");
348 priv->nstats.rx_errors++;
352 priv->wpa.pairwise_suite == IW_AUTH_CIPHER_TKIP) ||
354 priv->wpa.group_suite == IW_AUTH_CIPHER_TKIP) ||
356 priv->wpa.group_suite == IW_AUTH_CIPHER_TKIP)) &&
360 netdev_dbg(priv->net_dev, "TKIP: protocol=%04X: size=%u\n",
361 eth_proto, priv->rx_size);
364 (priv->rxp) + ((priv->rx_size) - sizeof(recv_mic)),
366 priv->rx_size = priv->rx_size - sizeof(recv_mic);
368 ret = michael_mic(key->rx_mic_key, priv->rxp, priv->rx_size,
374 mic_failure = &priv->wpa.mic_failure;
380 netdev_err(priv->net_dev, "MIC FAILURE\n");
392 priv->wpa.mic_failure.last_failure_time = now;
402 wireless_send_event(priv->net_dev, IWEVCUSTOM, &wrqu,
411 void hostif_data_indication(struct ks_wlan_private *priv)
423 if (priv->rx_size <= ETH_HLEN) {
424 priv->nstats.rx_errors++;
428 auth_type = get_word(priv); /* AuthType */
429 get_word(priv); /* Reserve Area */
431 eth_hdr = (struct ether_hdr *)(priv->rxp);
434 if (ether_addr_equal(&priv->eth_addr[0], eth_hdr->h_source)) {
435 netdev_err(priv->net_dev, "invalid : source is own mac address !!\n");
436 netdev_err(priv->net_dev, "eth_hdrernet->h_dest=%pM\n", eth_hdr->h_source);
437 priv->nstats.rx_errors++;
442 if (auth_type != TYPE_DATA && priv->wpa.rsn_enabled) {
443 ret = hostif_data_indication_wpa(priv, auth_type);
448 if ((priv->connect_status & FORCE_DISCONNECT) ||
449 priv->wpa.mic_failure.failure == 2) {
454 switch (*(priv->rxp + 12)) {
456 rx_ind_size = priv->rx_size - 6;
459 priv->nstats.rx_dropped++;
462 netdev_dbg(priv->net_dev, "SNAP, rx_ind_size = %d\n",
466 skb_put_data(skb, priv->rxp, size);
473 aa1x_hdr = (struct ieee802_1x_hdr *)(priv->rxp + ETHER_HDR_SIZE);
476 rx_ind_size = (priv->rx_size + 2);
479 priv->nstats.rx_dropped++;
482 netdev_dbg(priv->net_dev, "NETBEUI/NetBIOS rx_ind_size=%d\n",
486 skb_put_data(skb, priv->rxp, 12);
494 skb_put_data(skb, priv->rxp + 12, rx_ind_size - 14);
496 aa1x_hdr = (struct ieee802_1x_hdr *)(priv->rxp + 14);
499 netdev_err(priv->net_dev, "invalid data format\n");
500 priv->nstats.rx_errors++;
505 priv->wpa.rsn_enabled)
506 atomic_set(&priv->psstatus.snooze_guard, 1);
509 skb->dev = priv->net_dev;
511 priv->nstats.rx_packets++;
512 priv->nstats.rx_bytes += rx_ind_size;
517 void hostif_mib_get_confirm(struct ks_wlan_private *priv)
519 struct net_device *dev = priv->net_dev;
523 mib_status = get_dword(priv);
524 mib_attribute = get_dword(priv);
525 get_word(priv); /* mib_val_size */
526 get_word(priv); /* mib_val_type */
529 netdev_err(priv->net_dev, "attribute=%08X, status=%08X\n",
536 hostif_sme_enqueue(priv, SME_GET_MAC_ADDRESS);
537 ether_addr_copy(priv->eth_addr, priv->rxp);
538 priv->mac_address_valid = true;
539 eth_hw_addr_set(dev, priv->eth_addr);
540 netdev_info(dev, "MAC ADDRESS = %pM\n", priv->eth_addr);
543 priv->version_size = priv->rx_size;
544 memcpy(priv->firmware_version, priv->rxp, priv->rx_size);
545 priv->firmware_version[priv->rx_size] = '\0';
547 priv->firmware_version);
548 hostif_sme_enqueue(priv, SME_GET_PRODUCT_VERSION);
549 /* wake_up_interruptible_all(&priv->confirm_wait); */
550 complete(&priv->confirm_wait);
553 memcpy(&priv->gain, priv->rxp, sizeof(priv->gain));
554 netdev_dbg(priv->net_dev, "tx_mode=%d, rx_mode=%d, tx_gain=%d, rx_gain=%d\n",
555 priv->gain.tx_mode, priv->gain.rx_mode,
556 priv->gain.tx_gain, priv->gain.rx_gain);
559 memcpy(&priv->eeprom_sum, priv->rxp, sizeof(priv->eeprom_sum));
560 if (priv->eeprom_sum.type != 0 &&
561 priv->eeprom_sum.type != 1) {
565 priv->eeprom_checksum = (priv->eeprom_sum.type == 0) ?
567 (priv->eeprom_sum.result == 0) ?
571 netdev_err(priv->net_dev, "mib_attribute=%08x\n",
578 void hostif_mib_set_confirm(struct ks_wlan_private *priv)
583 mib_status = get_dword(priv);
584 mib_attribute = get_dword(priv);
588 netdev_err(priv->net_dev, "error :: attribute=%08X, status=%08X\n",
594 hostif_sme_enqueue(priv, SME_RTS_THRESHOLD_CONFIRM);
597 hostif_sme_enqueue(priv, SME_FRAGMENTATION_THRESHOLD_CONFIRM);
600 if (!priv->wpa.wpa_enabled)
601 hostif_sme_enqueue(priv, SME_WEP_INDEX_CONFIRM);
604 if (priv->wpa.rsn_enabled)
605 hostif_sme_enqueue(priv, SME_SET_PMK_TSC);
607 hostif_sme_enqueue(priv, SME_WEP_KEY1_CONFIRM);
610 if (priv->wpa.rsn_enabled)
611 hostif_sme_enqueue(priv, SME_SET_GMK1_TSC);
613 hostif_sme_enqueue(priv, SME_WEP_KEY2_CONFIRM);
616 if (priv->wpa.rsn_enabled)
617 hostif_sme_enqueue(priv, SME_SET_GMK2_TSC);
619 hostif_sme_enqueue(priv, SME_WEP_KEY3_CONFIRM);
622 if (!priv->wpa.rsn_enabled)
623 hostif_sme_enqueue(priv, SME_WEP_KEY4_CONFIRM);
626 if (!priv->wpa.rsn_enabled)
627 hostif_sme_enqueue(priv, SME_WEP_FLAG_CONFIRM);
630 hostif_sme_enqueue(priv, SME_RSN_ENABLED_CONFIRM);
633 hostif_sme_enqueue(priv, SME_RSN_MODE_CONFIRM);
636 hostif_sme_enqueue(priv, SME_MULTICAST_REQUEST);
639 hostif_sme_enqueue(priv, SME_MULTICAST_CONFIRM);
642 priv->mac_address_valid = true;
645 hostif_sme_enqueue(priv, SME_RSN_MCAST_CONFIRM);
648 hostif_sme_enqueue(priv, SME_RSN_UCAST_CONFIRM);
651 hostif_sme_enqueue(priv, SME_RSN_AUTH_CONFIRM);
654 if (atomic_read(&priv->psstatus.snooze_guard))
655 atomic_set(&priv->psstatus.snooze_guard, 0);
658 if (atomic_read(&priv->psstatus.snooze_guard))
659 atomic_set(&priv->psstatus.snooze_guard, 0);
673 void hostif_power_mgmt_confirm(struct ks_wlan_private *priv)
675 if (priv->reg.power_mgmt > POWER_MGMT_ACTIVE &&
676 priv->reg.operation_mode == MODE_INFRASTRUCTURE) {
677 atomic_set(&priv->psstatus.confirm_wait, 0);
678 priv->dev_state = DEVICE_STATE_SLEEP;
679 ks_wlan_hw_power_save(priv);
681 priv->dev_state = DEVICE_STATE_READY;
686 void hostif_sleep_confirm(struct ks_wlan_private *priv)
688 atomic_set(&priv->sleepstatus.doze_request, 1);
689 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
693 void hostif_start_confirm(struct ks_wlan_private *priv)
700 if (is_connect_status(priv->connect_status)) {
702 wireless_send_event(priv->net_dev, SIOCGIWAP, &wrqu, NULL);
704 netdev_dbg(priv->net_dev, " scan_ind_count=%d\n", priv->scan_ind_count);
705 hostif_sme_enqueue(priv, SME_START_CONFIRM);
709 void hostif_connect_indication(struct ks_wlan_private *priv)
713 unsigned int old_status = priv->connect_status;
714 struct net_device *netdev = priv->net_dev;
717 connect_code = get_word(priv);
721 if (!(priv->connect_status & FORCE_DISCONNECT))
723 tmp = FORCE_DISCONNECT & priv->connect_status;
724 priv->connect_status = tmp + CONNECT_STATUS;
728 tmp = FORCE_DISCONNECT & priv->connect_status;
729 priv->connect_status = tmp + DISCONNECT_STATUS;
732 netdev_dbg(priv->net_dev, "unknown connect_code=%d :: scan_ind_count=%d\n",
733 connect_code, priv->scan_ind_count);
735 tmp = FORCE_DISCONNECT & priv->connect_status;
736 priv->connect_status = tmp + DISCONNECT_STATUS;
740 get_current_ap(priv, (struct link_ap_info *)priv->rxp);
741 if (is_connect_status(priv->connect_status) &&
744 atomic_set(&priv->psstatus.snooze_guard, 0);
745 atomic_set(&priv->psstatus.confirm_wait, 0);
747 ks_wlan_do_power_save(priv);
752 if (is_disconnect_status(priv->connect_status) &&
755 netdev_dbg(priv->net_dev, "disconnect :: scan_ind_count=%d\n",
756 priv->scan_ind_count);
759 priv->scan_ind_count = 0;
763 void hostif_scan_indication(struct ks_wlan_private *priv)
768 netdev_dbg(priv->net_dev,
769 "scan_ind_count = %d\n", priv->scan_ind_count);
770 ap_info = (struct ap_info *)(priv->rxp);
772 if (priv->scan_ind_count) {
774 for (i = 0; i < priv->aplist.size; i++) {
775 u8 *bssid = priv->aplist.ap[i].bssid;
781 get_ap_information(priv, ap_info,
782 &priv->aplist.ap[i]);
786 priv->scan_ind_count++;
787 if (priv->scan_ind_count < LOCAL_APLIST_MAX + 1) {
788 netdev_dbg(priv->net_dev, " scan_ind_count=%d :: aplist.size=%d\n",
789 priv->scan_ind_count, priv->aplist.size);
790 get_ap_information(priv, (struct ap_info *)(priv->rxp),
791 &priv->aplist.ap[priv->scan_ind_count - 1]);
792 priv->aplist.size = priv->scan_ind_count;
794 netdev_dbg(priv->net_dev, " count over :: scan_ind_count=%d\n",
795 priv->scan_ind_count);
800 void hostif_stop_confirm(struct ks_wlan_private *priv)
803 unsigned int old_status = priv->connect_status;
804 struct net_device *netdev = priv->net_dev;
807 if (priv->dev_state == DEVICE_STATE_SLEEP)
808 priv->dev_state = DEVICE_STATE_READY;
811 if (is_connect_status(priv->connect_status)) {
813 tmp = FORCE_DISCONNECT & priv->connect_status;
814 priv->connect_status = tmp | DISCONNECT_STATUS;
820 if (is_disconnect_status(priv->connect_status) &&
826 priv->scan_ind_count = 0;
829 hostif_sme_enqueue(priv, SME_STOP_CONFIRM);
833 void hostif_ps_adhoc_set_confirm(struct ks_wlan_private *priv)
835 priv->infra_status = 0; /* infrastructure mode cancel */
836 hostif_sme_enqueue(priv, SME_MODE_SET_CONFIRM);
840 void hostif_infrastructure_set_confirm(struct ks_wlan_private *priv)
842 get_word(priv); /* result_code */
843 priv->infra_status = 1; /* infrastructure mode set */
844 hostif_sme_enqueue(priv, SME_MODE_SET_CONFIRM);
848 void hostif_adhoc_set_confirm(struct ks_wlan_private *priv)
850 priv->infra_status = 1; /* infrastructure mode set */
851 hostif_sme_enqueue(priv, SME_MODE_SET_CONFIRM);
855 void hostif_associate_indication(struct ks_wlan_private *priv)
868 assoc_req = (struct association_request *)(priv->rxp);
893 wireless_send_event(priv->net_dev, IWEVCUSTOM, &wrqu, buf);
897 void hostif_bss_scan_confirm(struct ks_wlan_private *priv)
900 struct net_device *dev = priv->net_dev;
903 result_code = get_dword(priv);
904 netdev_dbg(priv->net_dev, "result=%d :: scan_ind_count=%d\n",
905 result_code, priv->scan_ind_count);
907 priv->sme_i.sme_flag &= ~SME_AP_SCAN;
908 hostif_sme_enqueue(priv, SME_BSS_SCAN_CONFIRM);
913 priv->scan_ind_count = 0;
917 void hostif_phy_information_confirm(struct ks_wlan_private *priv)
919 struct iw_statistics *wstats = &priv->wstats;
925 rssi = get_byte(priv);
926 signal = get_byte(priv);
927 get_byte(priv); /* noise */
928 link_speed = get_byte(priv);
929 transmitted_frame_count = get_dword(priv);
930 received_fragment_count = get_dword(priv);
931 failed_count = get_dword(priv);
932 fcs_error_count = get_dword(priv);
934 netdev_dbg(priv->net_dev, "phyinfo confirm rssi=%d signal=%d\n",
936 priv->current_rate = (link_speed & RATE_MASK);
942 netdev_dbg(priv->net_dev, "\n rssi=%u\n"
951 /* wake_up_interruptible_all(&priv->confirm_wait); */
952 complete(&priv->confirm_wait);
956 void hostif_mic_failure_confirm(struct ks_wlan_private *priv)
958 netdev_dbg(priv->net_dev, "mic_failure=%u\n",
959 priv->wpa.mic_failure.failure);
960 hostif_sme_enqueue(priv, SME_MIC_FAILURE_CONFIRM);
964 void hostif_event_check(struct ks_wlan_private *priv)
968 event = get_word(priv);
971 hostif_data_indication(priv);
974 hostif_mib_get_confirm(priv);
977 hostif_mib_set_confirm(priv);
980 hostif_power_mgmt_confirm(priv);
983 hostif_sleep_confirm(priv);
986 hostif_start_confirm(priv);
989 hostif_connect_indication(priv);
992 hostif_stop_confirm(priv);
995 hostif_ps_adhoc_set_confirm(priv);
999 hostif_infrastructure_set_confirm(priv);
1003 hostif_adhoc_set_confirm(priv);
1006 hostif_associate_indication(priv);
1009 hostif_mic_failure_confirm(priv);
1012 hostif_bss_scan_confirm(priv);
1016 hostif_phy_information_confirm(priv);
1019 hostif_scan_indication(priv);
1023 netdev_err(priv->net_dev, "undefined event[%04X]\n", event);
1024 /* wake_up_all(&priv->confirm_wait); */
1025 complete(&priv->confirm_wait);
1030 priv->hostt.buff[priv->hostt.qtail] = event;
1031 priv->hostt.qtail = (priv->hostt.qtail + 1) % SME_EVENT_BUFF_SIZE;
1049 int hostif_data_request(struct ks_wlan_private *priv, struct sk_buff *skb)
1067 netdev_err(priv->net_dev, "bad length skb_len=%d\n", skb_len);
1072 if (is_disconnect_status(priv->connect_status) ||
1073 (priv->connect_status & FORCE_DISCONNECT) ||
1074 priv->wpa.mic_failure.stop) {
1075 if (netif_queue_stopped(priv->net_dev))
1076 netif_wake_queue(priv->net_dev);
1084 if (atomic_read(&priv->psstatus.status) == PS_SNOOZE) {
1085 if (!netif_queue_stopped(priv->net_dev))
1086 netif_stop_queue(priv->net_dev);
1103 if (!ether_addr_equal(&priv->eth_addr[0], eth->h_source)) {
1104 netdev_err(priv->net_dev,
1147 priv->wpa.mic_failure.failure > 0) {
1155 if (priv->wpa.rsn_enabled && priv->wpa.key[0].key_len) {
1158 priv->wpa.key[1].key_len == 0 &&
1159 priv->wpa.key[2].key_len == 0 &&
1160 priv->wpa.key[3].key_len == 0) {
1163 if (priv->wpa.pairwise_suite == IW_AUTH_CIPHER_TKIP) {
1166 ret = michael_mic(priv->wpa.key[0].tx_mic_key,
1178 } else if (priv->wpa.pairwise_suite ==
1197 ret = ks_wlan_hw_tx(priv, pp, hif_align_size(sizeof(*pp) + skb_len),
1202 priv->wpa.mic_failure.failure > 0) {
1205 netdev_err(priv->net_dev,
1207 hostif_sme_enqueue(priv, SME_MIC_FAILURE_REQUEST);
1209 if (priv->wpa.mic_failure.failure == 2)
1210 priv->wpa.mic_failure.stop = 1;
1223 static inline void ps_confirm_wait_inc(struct ks_wlan_private *priv)
1225 if (atomic_read(&priv->psstatus.status) > PS_ACTIVE_SET)
1226 atomic_inc(&priv->psstatus.confirm_wait);
1229 static inline void send_request_to_device(struct ks_wlan_private *priv,
1232 ps_confirm_wait_inc(priv);
1233 ks_wlan_hw_tx(priv, data, size, NULL, NULL);
1236 static void hostif_mib_get_request(struct ks_wlan_private *priv,
1247 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp)));
1250 static void hostif_mib_set_request(struct ks_wlan_private *priv,
1257 if (priv->dev_state < DEVICE_STATE_BOOT)
1269 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp) + size));
1272 static inline void hostif_mib_set_request_int(struct ks_wlan_private *priv,
1278 hostif_mib_set_request(priv, attr, MIB_VALUE_TYPE_INT, &v, size);
1281 static inline void hostif_mib_set_request_bool(struct ks_wlan_private *priv,
1288 hostif_mib_set_request(priv, attr, MIB_VALUE_TYPE_BOOL, &v, size);
1291 static inline void hostif_mib_set_request_ostring(struct ks_wlan_private *priv,
1295 hostif_mib_set_request(priv, attr, MIB_VALUE_TYPE_OSTRING, data, size);
1299 void hostif_start_request(struct ks_wlan_private *priv, unsigned char mode)
1309 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp)));
1311 priv->aplist.size = 0;
1312 priv->scan_ind_count = 0;
1315 static __le16 ks_wlan_cap(struct ks_wlan_private *priv)
1319 if (priv->reg.preamble == SHORT_PREAMBLE)
1324 if (priv->reg.phy_type != D_11B_ONLY_MODE) {
1332 static void init_request(struct ks_wlan_private *priv,
1335 req->phy_type = cpu_to_le16(priv->reg.phy_type);
1336 req->cts_mode = cpu_to_le16(priv->reg.cts_mode);
1337 req->scan_type = cpu_to_le16(priv->reg.scan_type);
1338 req->rate_set.size = priv->reg.rate_set.size;
1339 req->capability = ks_wlan_cap(priv);
1340 memcpy(&req->rate_set.body[0], &priv->reg.rate_set.body[0],
1341 priv->reg.rate_set.size);
1345 void hostif_ps_adhoc_set_request(struct ks_wlan_private *priv)
1353 init_request(priv, &pp->request);
1354 pp->channel = cpu_to_le16(priv->reg.channel);
1356 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp)));
1360 void hostif_infrastructure_set_request(struct ks_wlan_private *priv, int event)
1368 init_request(priv, &pp->request);
1369 pp->ssid.size = priv->reg.ssid.size;
1370 memcpy(&pp->ssid.body[0], &priv->reg.ssid.body[0], priv->reg.ssid.size);
1372 cpu_to_le16(priv->reg.beacon_lost_count);
1373 pp->auth_type = cpu_to_le16(priv->reg.authenticate_type);
1388 if (priv->reg.phy_type == D_11G_ONLY_MODE) {
1395 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp)));
1399 void hostif_adhoc_set_request(struct ks_wlan_private *priv)
1407 init_request(priv, &pp->request);
1408 pp->channel = cpu_to_le16(priv->reg.channel);
1409 pp->ssid.size = priv->reg.ssid.size;
1410 memcpy(&pp->ssid.body[0], &priv->reg.ssid.body[0], priv->reg.ssid.size);
1412 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp)));
1416 void hostif_adhoc_set2_request(struct ks_wlan_private *priv)
1424 init_request(priv, &pp->request);
1425 pp->ssid.size = priv->reg.ssid.size;
1426 memcpy(&pp->ssid.body[0], &priv->reg.ssid.body[0], priv->reg.ssid.size);
1428 pp->channel_list.body[0] = priv->reg.channel;
1430 memcpy(pp->bssid, priv->reg.bssid, ETH_ALEN);
1432 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp)));
1436 void hostif_stop_request(struct ks_wlan_private *priv)
1444 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp)));
1448 void hostif_phy_information_request(struct ks_wlan_private *priv)
1456 if (priv->reg.phy_info_timer) {
1458 pp->time = cpu_to_le16(priv->reg.phy_info_timer);
1464 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp)));
1468 void hostif_power_mgmt_request(struct ks_wlan_private *priv,
1481 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp)));
1485 void hostif_sleep_request(struct ks_wlan_private *priv,
1495 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp)));
1497 atomic_set(&priv->sleepstatus.wakeup_request, 1);
1498 queue_delayed_work(priv->wq, &priv->rw_dwork, 1);
1500 netdev_err(priv->net_dev, "invalid mode %ld\n", (long)mode);
1506 void hostif_bss_scan_request(struct ks_wlan_private *priv,
1533 if (priv->reg.phy_type == D_11G_ONLY_MODE) {
1547 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp)));
1549 priv->aplist.size = 0;
1550 priv->scan_ind_count = 0;
1554 void hostif_mic_failure_request(struct ks_wlan_private *priv,
1566 send_request_to_device(priv, pp, hif_align_size(sizeof(*pp)));
1570 static void devio_rec_ind(struct ks_wlan_private *priv, unsigned char *p,
1573 if (!priv->is_device_open)
1576 spin_lock(&priv->dev_read_lock);
1577 priv->dev_data[atomic_read(&priv->rec_count)] = p;
1578 priv->dev_size[atomic_read(&priv->rec_count)] = size;
1580 if (atomic_read(&priv->event_count) != DEVICE_STOCK_COUNT) {
1582 atomic_inc(&priv->event_count);
1584 atomic_inc(&priv->rec_count);
1585 if (atomic_read(&priv->rec_count) == DEVICE_STOCK_COUNT)
1586 atomic_set(&priv->rec_count, 0);
1588 wake_up_interruptible_all(&priv->devread_wait);
1590 spin_unlock(&priv->dev_read_lock);
1593 void hostif_receive(struct ks_wlan_private *priv, unsigned char *p,
1596 devio_rec_ind(priv, p, size);
1598 priv->rxp = p;
1599 priv->rx_size = size;
1601 if (get_word(priv) == priv->rx_size)
1602 hostif_event_check(priv);
1605 static void hostif_sme_set_wep(struct ks_wlan_private *priv, int type)
1609 hostif_mib_set_request_int(priv, DOT11_WEP_DEFAULT_KEY_ID,
1610 priv->reg.wep_index);
1613 if (priv->wpa.wpa_enabled)
1615 hostif_mib_set_request_ostring(priv,
1617 &priv->reg.wep_key[0].val[0],
1618 priv->reg.wep_key[0].size);
1621 if (priv->wpa.wpa_enabled)
1623 hostif_mib_set_request_ostring(priv,
1625 &priv->reg.wep_key[1].val[0],
1626 priv->reg.wep_key[1].size);
1629 if (priv->wpa.wpa_enabled)
1631 hostif_mib_set_request_ostring(priv,
1633 &priv->reg.wep_key[2].val[0],
1634 priv->reg.wep_key[2].size);
1637 if (priv->wpa.wpa_enabled)
1639 hostif_mib_set_request_ostring(priv,
1641 &priv->reg.wep_key[3].val[0],
1642 priv->reg.wep_key[3].size);
1645 hostif_mib_set_request_bool(priv, DOT11_PRIVACY_INVOKED,
1646 priv->reg.privacy_invoked);
1661 static void hostif_sme_set_rsn(struct ks_wlan_private *priv, int type)
1674 switch (priv->wpa.pairwise_suite) {
1676 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1680 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1684 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1688 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1692 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1701 hostif_mib_set_request_ostring(priv,
1706 switch (priv->wpa.group_suite) {
1708 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1712 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1716 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1720 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1724 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1730 hostif_mib_set_request_ostring(priv,
1737 switch (priv->wpa.key_mgmt_suite) {
1739 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1743 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1747 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1751 buf = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1761 hostif_mib_set_request_ostring(priv,
1766 hostif_mib_set_request_bool(priv, DOT11_RSN_ENABLED,
1767 priv->wpa.rsn_enabled);
1770 mode = (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA2) ?
1772 (priv->wpa.version == IW_AUTH_WPA_VERSION_WPA) ?
1776 hostif_mib_set_request_ostring(priv, LOCAL_RSN_MODE,
1783 void hostif_sme_mode_setup(struct ks_wlan_private *priv)
1790 if (priv->reg.tx_rate == TX_RATE_FULL_AUTO) {
1791 if (priv->reg.phy_type == D_11B_ONLY_MODE) {
1792 priv->reg.rate_set.body[3] = TX_RATE_11M;
1793 priv->reg.rate_set.body[2] = TX_RATE_5M;
1794 priv->reg.rate_set.body[1] = TX_RATE_2M | BASIC_RATE;
1795 priv->reg.rate_set.body[0] = TX_RATE_1M | BASIC_RATE;
1796 priv->reg.rate_set.size = 4;
1798 priv->reg.rate_set.body[11] = TX_RATE_54M;
1799 priv->reg.rate_set.body[10] = TX_RATE_48M;
1800 priv->reg.rate_set.body[9] = TX_RATE_36M;
1801 priv->reg.rate_set.body[8] = TX_RATE_18M;
1802 priv->reg.rate_set.body[7] = TX_RATE_9M;
1803 priv->reg.rate_set.body[6] = TX_RATE_24M | BASIC_RATE;
1804 priv->reg.rate_set.body[5] = TX_RATE_12M | BASIC_RATE;
1805 priv->reg.rate_set.body[4] = TX_RATE_6M | BASIC_RATE;
1806 priv->reg.rate_set.body[3] = TX_RATE_11M | BASIC_RATE;
1807 priv->reg.rate_set.body[2] = TX_RATE_5M | BASIC_RATE;
1808 priv->reg.rate_set.body[1] = TX_RATE_2M | BASIC_RATE;
1809 priv->reg.rate_set.body[0] = TX_RATE_1M | BASIC_RATE;
1810 priv->reg.rate_set.size = 12;
1815 if (priv->reg.phy_type == D_11B_ONLY_MODE) {
1816 for (i = 0; i < priv->reg.rate_set.size; i++) {
1817 if (!is_11b_rate(priv->reg.rate_set.body[i]))
1820 if ((priv->reg.rate_set.body[i] & RATE_MASK) >= TX_RATE_5M) {
1821 rate_octet[i] = priv->reg.rate_set.body[i] &
1824 rate_octet[i] = priv->reg.rate_set.body[i];
1829 for (i = 0; i < priv->reg.rate_set.size; i++) {
1830 if (!is_11bg_rate(priv->reg.rate_set.body[i]))
1833 if (is_ofdm_ext_rate(priv->reg.rate_set.body[i])) {
1834 rate_octet[i] = priv->reg.rate_set.body[i] &
1837 rate_octet[i] = priv->reg.rate_set.body[i];
1843 if (priv->reg.phy_type == D_11G_ONLY_MODE)
1851 priv->reg.rate_set.size = rate_size;
1852 memcpy(&priv->reg.rate_set.body[0], &rate_octet[0], rate_size);
1854 switch (priv->reg.operation_mode) {
1856 hostif_ps_adhoc_set_request(priv);
1859 if (!is_valid_ether_addr((u8 *)priv->reg.bssid)) {
1860 hostif_infrastructure_set_request(priv,
1863 hostif_infrastructure_set_request(priv,
1865 netdev_dbg(priv->net_dev,
1866 "Infra bssid = %pM\n", priv->reg.bssid);
1870 if (!is_valid_ether_addr((u8 *)priv->reg.bssid)) {
1871 hostif_adhoc_set_request(priv);
1873 hostif_adhoc_set2_request(priv);
1874 netdev_dbg(priv->net_dev,
1875 "Adhoc bssid = %pM\n", priv->reg.bssid);
1884 void hostif_sme_multicast_set(struct ks_wlan_private *priv)
1886 struct net_device *dev = priv->net_dev;
1892 spin_lock(&priv->multicast_spin);
1897 hostif_mib_set_request_int(priv, LOCAL_MULTICAST_FILTER,
1904 hostif_mib_set_request_int(priv, LOCAL_MULTICAST_FILTER,
1909 if (priv->sme_i.sme_flag & SME_MULTICAST) {
1915 priv->sme_i.sme_flag &= ~SME_MULTICAST;
1916 hostif_mib_set_request_ostring(priv, LOCAL_MULTICAST_ADDRESS,
1920 priv->sme_i.sme_flag |= SME_MULTICAST;
1921 hostif_mib_set_request_int(priv, LOCAL_MULTICAST_FILTER,
1926 spin_unlock(&priv->multicast_spin);
1929 static void hostif_sme_power_mgmt_set(struct ks_wlan_private *priv)
1933 if (priv->reg.power_mgmt != POWER_MGMT_SAVE1 &&
1934 priv->reg.power_mgmt != POWER_MGMT_SAVE2) {
1939 mode = (priv->reg.operation_mode == MODE_INFRASTRUCTURE) ?
1942 receive_dtims = (priv->reg.operation_mode == MODE_INFRASTRUCTURE &&
1943 priv->reg.power_mgmt == POWER_MGMT_SAVE2);
1946 hostif_power_mgmt_request(priv, mode, wake_up, receive_dtims);
1949 static void hostif_sme_sleep_set(struct ks_wlan_private *priv)
1951 if (priv->sleep_mode != SLP_SLEEP &&
1952 priv->sleep_mode != SLP_ACTIVE)
1955 hostif_sleep_request(priv, priv->sleep_mode);
1959 void hostif_sme_set_key(struct ks_wlan_private *priv, int type)
1963 hostif_mib_set_request_bool(priv, DOT11_PRIVACY_INVOKED,
1964 priv->reg.privacy_invoked);
1967 hostif_mib_set_request_int(priv, DOT11_WEP_DEFAULT_KEY_ID,
1968 priv->wpa.txkey);
1971 hostif_mib_set_request_ostring(priv,
1973 &priv->wpa.key[0].key_val[0],
1974 priv->wpa.key[0].key_len);
1977 hostif_mib_set_request_ostring(priv,
1979 &priv->wpa.key[1].key_val[0],
1980 priv->wpa.key[1].key_len);
1983 hostif_mib_set_request_ostring(priv,
1985 &priv->wpa.key[2].key_val[0],
1986 priv->wpa.key[2].key_len);
1989 hostif_mib_set_request_ostring(priv,
1991 &priv->wpa.key[3].key_val[0],
1992 priv->wpa.key[3].key_len);
1995 hostif_mib_set_request_ostring(priv, DOT11_PMK_TSC,
1996 &priv->wpa.key[0].rx_seq[0],
2000 hostif_mib_set_request_ostring(priv, DOT11_GMK1_TSC,
2001 &priv->wpa.key[1].rx_seq[0],
2005 hostif_mib_set_request_ostring(priv, DOT11_GMK2_TSC,
2006 &priv->wpa.key[2].rx_seq[0],
2013 void hostif_sme_set_pmksa(struct ks_wlan_private *priv)
2026 list_for_each_entry(pmk, &priv->pmklist.head, list) {
2033 pmkcache.size = cpu_to_le16(priv->pmklist.size);
2034 size = sizeof(priv->pmklist.size) +
2035 ((ETH_ALEN + IW_PMKID_LEN) * priv->pmklist.size);
2036 hostif_mib_set_request_ostring(priv, LOCAL_PMK, &pmkcache, size);
2040 static void hostif_sme_execute(struct ks_wlan_private *priv, int event)
2046 if (priv->dev_state == DEVICE_STATE_BOOT)
2047 hostif_mib_get_request(priv, DOT11_MAC_ADDRESS);
2050 hostif_sme_multicast_set(priv);
2053 hostif_mib_set_request_ostring(priv, LOCAL_CURRENTADDRESS,
2054 &priv->eth_addr[0], ETH_ALEN);
2057 hostif_bss_scan_request(priv, priv->reg.scan_type,
2058 priv->scan_ssid, priv->scan_ssid_len);
2061 hostif_sme_power_mgmt_set(priv);
2064 hostif_phy_information_request(priv);
2067 failure = priv->wpa.mic_failure.failure;
2069 netdev_err(priv->net_dev,
2074 hostif_mic_failure_request(priv, failure - 1, (failure == 1) ?
2075 0 : priv->wpa.mic_failure.counter);
2078 if (priv->wpa.mic_failure.failure == 2) {
2079 if (priv->wpa.mic_failure.stop)
2080 priv->wpa.mic_failure.stop = 0;
2081 priv->wpa.mic_failure.failure = 0;
2082 hostif_start_request(priv, priv->reg.operation_mode);
2086 if (priv->dev_state == DEVICE_STATE_BOOT)
2087 hostif_mib_get_request(priv, DOT11_PRODUCT_VERSION);
2090 if (priv->dev_state == DEVICE_STATE_BOOT)
2091 priv->dev_state = DEVICE_STATE_PREINIT;
2094 hostif_stop_request(priv);
2097 hostif_mib_set_request_int(priv, DOT11_RTS_THRESHOLD,
2098 priv->reg.rts);
2101 hostif_mib_set_request_int(priv, DOT11_FRAGMENTATION_THRESHOLD,
2102 priv->reg.fragment);
2110 hostif_sme_set_wep(priv, event);
2117 hostif_sme_set_rsn(priv, event);
2128 hostif_sme_set_key(priv, event);
2131 hostif_sme_set_pmksa(priv);
2134 hostif_mib_set_request_int(priv, LOCAL_WPS_ENABLE,
2135 priv->wps.wps_enabled);
2138 hostif_mib_set_request_ostring(priv, LOCAL_WPS_PROBE_REQ,
2139 priv->wps.ie, priv->wps.ielen);
2142 hostif_sme_mode_setup(priv);
2145 hostif_mib_set_request_ostring(priv, LOCAL_GAIN,
2146 &priv->gain, sizeof(priv->gain));
2149 hostif_mib_get_request(priv, LOCAL_GAIN);
2152 priv->eeprom_checksum = EEPROM_FW_NOT_SUPPORT; /* initialize */
2153 hostif_mib_get_request(priv, LOCAL_EEPROM_SUM);
2156 hostif_start_request(priv, priv->reg.operation_mode);
2160 atomic_set(&priv->psstatus.snooze_guard, 0);
2161 atomic_set(&priv->psstatus.confirm_wait, 0);
2162 if (priv->dev_state == DEVICE_STATE_PREINIT)
2163 priv->dev_state = DEVICE_STATE_INIT;
2164 /* wake_up_interruptible_all(&priv->confirm_wait); */
2165 complete(&priv->confirm_wait);
2168 hostif_sme_sleep_set(priv);
2171 hostif_mib_set_request_int(priv, LOCAL_REGION, priv->region);
2200 struct ks_wlan_private *priv;
2202 priv = container_of(work, struct ks_wlan_private, sme_work);
2204 if (priv->dev_state < DEVICE_STATE_BOOT)
2207 if (cnt_smeqbody(priv) <= 0)
2210 hostif_sme_execute(priv, priv->sme_i.event_buff[priv->sme_i.qhead]);
2211 inc_smeqhead(priv);
2212 if (cnt_smeqbody(priv) > 0)
2213 schedule_work(&priv->sme_work);
2217 void hostif_sme_enqueue(struct ks_wlan_private *priv, u16 event)
2220 if (cnt_smeqbody(priv) < (SME_EVENT_BUFF_SIZE - 1)) {
2221 priv->sme_i.event_buff[priv->sme_i.qtail] = event;
2222 inc_smeqtail(priv);
2225 netdev_err(priv->net_dev, "sme queue buffer overflow\n");
2228 schedule_work(&priv->sme_work);
2231 static inline void hostif_aplist_init(struct ks_wlan_private *priv)
2235 priv->aplist.size = 0;
2236 memset(&priv->aplist.ap[0], 0, size);
2239 static inline void hostif_status_init(struct ks_wlan_private *priv)
2241 priv->infra_status = 0;
2242 priv->current_rate = 4;
2243 priv->connect_status = DISCONNECT_STATUS;
2246 static inline void hostif_sme_init(struct ks_wlan_private *priv)
2248 priv->sme_i.sme_status = SME_IDLE;
2249 priv->sme_i.qhead = 0;
2250 priv->sme_i.qtail = 0;
2251 spin_lock_init(&priv->sme_i.sme_spin);
2252 priv->sme_i.sme_flag = 0;
2253 INIT_WORK(&priv->sme_work, hostif_sme_work);
2256 static inline void hostif_wpa_init(struct ks_wlan_private *priv)
2258 memset(&priv->wpa, 0, sizeof(priv->wpa));
2259 priv->wpa.rsn_enabled = false;
2260 priv->wpa.mic_failure.failure = 0;
2261 priv->wpa.mic_failure.last_failure_time = 0;
2262 priv->wpa.mic_failure.stop = 0;
2265 static inline void hostif_power_save_init(struct ks_wlan_private *priv)
2267 atomic_set(&priv->psstatus.status, PS_NONE);
2268 atomic_set(&priv->psstatus.confirm_wait, 0);
2269 atomic_set(&priv->psstatus.snooze_guard, 0);
2270 init_completion(&priv->psstatus.wakeup_wait);
2271 INIT_WORK(&priv->wakeup_work, ks_wlan_hw_wakeup_task);
2274 static inline void hostif_pmklist_init(struct ks_wlan_private *priv)
2278 memset(&priv->pmklist, 0, sizeof(priv->pmklist));
2279 INIT_LIST_HEAD(&priv->pmklist.head);
2281 INIT_LIST_HEAD(&priv->pmklist.pmk[i].list);
2284 static inline void hostif_counters_init(struct ks_wlan_private *priv)
2286 priv->dev_count = 0;
2287 atomic_set(&priv->event_count, 0);
2288 atomic_set(&priv->rec_count, 0);
2291 int hostif_init(struct ks_wlan_private *priv)
2293 hostif_aplist_init(priv);
2294 hostif_status_init(priv);
2296 spin_lock_init(&priv->multicast_spin);
2297 spin_lock_init(&priv->dev_read_lock);
2298 init_waitqueue_head(&priv->devread_wait);
2300 hostif_counters_init(priv);
2301 hostif_power_save_init(priv);
2302 hostif_wpa_init(priv);
2303 hostif_pmklist_init(priv);
2304 hostif_sme_init(priv);
2309 void hostif_exit(struct ks_wlan_private *priv)
2311 cancel_work_sync(&priv->sme_work);