Lines Matching refs:priv
102 int lbs_set_iface_type(struct lbs_private *priv, enum nl80211_iftype type)
108 ret = lbs_set_monitor_mode(priv, 1);
111 if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR)
112 ret = lbs_set_monitor_mode(priv, 0);
114 ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_BSS_TYPE, 1);
117 if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR)
118 ret = lbs_set_monitor_mode(priv, 0);
120 ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_BSS_TYPE, 2);
128 int lbs_start_iface(struct lbs_private *priv)
133 if (priv->power_restore) {
134 ret = priv->power_restore(priv);
141 memcpy(cmd.macadd, priv->current_addr, ETH_ALEN);
143 ret = lbs_cmd_with_response(priv, CMD_802_11_MAC_ADDRESS, &cmd);
149 ret = lbs_set_iface_type(priv, priv->wdev->iftype);
155 ret = lbs_set_11d_domain_info(priv);
161 lbs_update_channel(priv);
163 priv->iface_running = true;
167 if (priv->power_save)
168 priv->power_save(priv);
180 struct lbs_private *priv = dev->ml_priv;
183 if (!priv->iface_running) {
184 ret = lbs_start_iface(priv);
189 spin_lock_irq(&priv->driver_lock);
193 if (!priv->tx_pending_len)
196 spin_unlock_irq(&priv->driver_lock);
202 static bool lbs_command_queue_empty(struct lbs_private *priv)
206 spin_lock_irqsave(&priv->driver_lock, flags);
207 ret = priv->cur_cmd == NULL && list_empty(&priv->cmdpendingq);
208 spin_unlock_irqrestore(&priv->driver_lock, flags);
212 int lbs_stop_iface(struct lbs_private *priv)
217 spin_lock_irqsave(&priv->driver_lock, flags);
218 priv->iface_running = false;
219 dev_kfree_skb_irq(priv->currenttxskb);
220 priv->currenttxskb = NULL;
221 priv->tx_pending_len = 0;
222 spin_unlock_irqrestore(&priv->driver_lock, flags);
224 cancel_work_sync(&priv->mcast_work);
225 del_timer_sync(&priv->tx_lockup_timer);
229 wait_event(priv->waitq, lbs_command_queue_empty(priv));
232 if (priv->power_save)
233 ret = priv->power_save(priv);
246 struct lbs_private *priv = dev->ml_priv;
248 if (priv->connect_status == LBS_CONNECTED)
249 lbs_disconnect(priv, WLAN_REASON_DEAUTH_LEAVING);
251 spin_lock_irq(&priv->driver_lock);
253 spin_unlock_irq(&priv->driver_lock);
255 lbs_update_mcast(priv);
256 cancel_delayed_work_sync(&priv->scan_work);
257 if (priv->scan_req)
258 lbs_scan_done(priv);
260 netif_carrier_off(priv->dev);
262 if (!lbs_iface_active(priv))
263 lbs_stop_iface(priv);
268 void lbs_host_to_card_done(struct lbs_private *priv)
272 spin_lock_irqsave(&priv->driver_lock, flags);
273 del_timer(&priv->tx_lockup_timer);
275 priv->dnld_sent = DNLD_RES_RECEIVED;
278 if (!priv->cur_cmd || priv->tx_pending_len > 0) {
279 if (!priv->wakeup_dev_required)
280 wake_up(&priv->waitq);
283 spin_unlock_irqrestore(&priv->driver_lock, flags);
290 struct lbs_private *priv = dev->ml_priv;
297 if (lbs_iface_active(priv))
301 dev = priv->dev;
303 memcpy(priv->current_addr, phwaddr->sa_data, ETH_ALEN);
305 if (priv->mesh_dev)
306 eth_hw_addr_set(priv->mesh_dev, phwaddr->sa_data);
360 void lbs_update_mcast(struct lbs_private *priv)
365 int old_mac_control = priv->mac_control;
367 if (netif_running(priv->dev))
368 dev_flags |= priv->dev->flags;
369 if (priv->mesh_dev && netif_running(priv->mesh_dev))
370 dev_flags |= priv->mesh_dev->flags;
373 priv->mac_control |= CMD_ACT_MAC_PROMISCUOUS_ENABLE;
374 priv->mac_control &= ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE |
379 priv->mac_control |= CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
380 priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE |
385 /* Once for priv->dev, again for priv->mesh_dev if it exists */
386 nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->dev, 0);
387 if (nr_addrs >= 0 && priv->mesh_dev)
388 nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->mesh_dev, nr_addrs);
400 lbs_cmd_async(priv, CMD_MAC_MULTICAST_ADR, &mcast_cmd.hdr, size);
402 priv->mac_control |= CMD_ACT_MAC_MULTICAST_ENABLE;
404 priv->mac_control &= ~CMD_ACT_MAC_MULTICAST_ENABLE;
406 priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE |
409 if (priv->mac_control != old_mac_control)
410 lbs_set_mac_control(priv);
415 struct lbs_private *priv = container_of(work, struct lbs_private, mcast_work);
416 lbs_update_mcast(priv);
421 struct lbs_private *priv = dev->ml_priv;
423 schedule_work(&priv->mcast_work);
437 struct lbs_private *priv = dev->ml_priv;
447 priv->currenttxskb, priv->dnld_sent);
449 add_wait_queue(&priv->waitq, &wait);
451 spin_lock_irq(&priv->driver_lock);
455 else if (priv->surpriseremoved)
457 else if (priv->psstate == PS_STATE_SLEEP)
459 else if (priv->cmd_timed_out)
461 else if (!priv->fw_ready)
463 else if (priv->dnld_sent)
465 else if (priv->tx_pending_len > 0)
467 else if (priv->resp_len[priv->resp_idx])
469 else if (priv->cur_cmd)
471 else if (!list_empty(&priv->cmdpendingq) &&
472 !(priv->wakeup_dev_required))
474 else if (kfifo_len(&priv->event_fifo))
482 priv->connect_status,
483 priv->psmode, priv->psstate);
484 spin_unlock_irq(&priv->driver_lock);
487 spin_unlock_irq(&priv->driver_lock);
490 priv->currenttxskb, priv->dnld_sent);
493 remove_wait_queue(&priv->waitq, &wait);
496 priv->currenttxskb, priv->dnld_sent);
503 if (priv->surpriseremoved) {
509 priv->currenttxskb, priv->dnld_sent);
512 spin_lock_irq(&priv->driver_lock);
513 resp_idx = priv->resp_idx;
514 if (priv->resp_len[resp_idx]) {
515 spin_unlock_irq(&priv->driver_lock);
516 lbs_process_command_response(priv,
517 priv->resp_buf[resp_idx],
518 priv->resp_len[resp_idx]);
519 spin_lock_irq(&priv->driver_lock);
520 priv->resp_len[resp_idx] = 0;
522 spin_unlock_irq(&priv->driver_lock);
525 spin_lock_irq(&priv->driver_lock);
526 while (kfifo_len(&priv->event_fifo)) {
529 if (kfifo_out(&priv->event_fifo,
533 spin_unlock_irq(&priv->driver_lock);
534 lbs_process_event(priv, event);
535 spin_lock_irq(&priv->driver_lock);
537 spin_unlock_irq(&priv->driver_lock);
539 if (priv->wakeup_dev_required) {
542 if (priv->exit_deep_sleep(priv))
548 if (priv->cmd_timed_out && priv->cur_cmd) {
549 struct cmd_ctrl_node *cmdnode = priv->cur_cmd;
553 lbs_complete_command(priv, cmdnode, -ETIMEDOUT);
557 if (!dev->dismantle && priv->reset_card)
558 priv->reset_card(priv);
560 priv->cmd_timed_out = 0;
562 if (!priv->fw_ready)
566 if (priv->psstate == PS_STATE_PRE_SLEEP &&
567 !priv->dnld_sent && !priv->cur_cmd) {
568 if (priv->connect_status == LBS_CONNECTED) {
571 priv->currenttxskb, priv->dnld_sent,
572 priv->cur_cmd);
574 lbs_ps_confirm_sleep(priv);
581 priv->psstate = PS_STATE_AWAKE;
590 if ((priv->psstate == PS_STATE_SLEEP) ||
591 (priv->psstate == PS_STATE_PRE_SLEEP))
594 if (priv->is_deep_sleep)
598 if (!priv->dnld_sent && !priv->cur_cmd)
599 lbs_execute_next_command(priv);
601 spin_lock_irq(&priv->driver_lock);
602 if (!priv->dnld_sent && priv->tx_pending_len > 0) {
603 int ret = priv->hw_host_to_card(priv, MVMS_DAT,
604 priv->tx_pending_buf,
605 priv->tx_pending_len);
608 priv->dnld_sent = DNLD_RES_RECEIVED;
610 mod_timer(&priv->tx_lockup_timer,
613 priv->tx_pending_len = 0;
614 if (!priv->currenttxskb) {
617 if (priv->connect_status == LBS_CONNECTED)
618 netif_wake_queue(priv->dev);
619 if (priv->mesh_dev &&
620 netif_running(priv->mesh_dev))
621 netif_wake_queue(priv->mesh_dev);
624 spin_unlock_irq(&priv->driver_lock);
627 del_timer(&priv->command_timer);
628 del_timer(&priv->tx_lockup_timer);
629 del_timer(&priv->auto_deepsleep_timer);
638 * @priv: A pointer to &struct lbs_private structure
641 static int lbs_setup_firmware(struct lbs_private *priv)
647 eth_broadcast_addr(priv->current_addr);
648 ret = lbs_update_hw_spec(priv);
653 ret = lbs_get_tx_power(priv, &curlevel, &minlevel, &maxlevel);
655 priv->txpower_cur = curlevel;
656 priv->txpower_min = minlevel;
657 priv->txpower_max = maxlevel;
661 ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_11D_ENABLE, 1);
665 ret = lbs_set_mac_control_sync(priv);
670 int lbs_suspend(struct lbs_private *priv)
674 if (priv->is_deep_sleep) {
675 ret = lbs_set_deep_sleep(priv, 0);
677 netdev_err(priv->dev,
681 priv->deep_sleep_required = 1;
684 ret = lbs_set_host_sleep(priv, 1);
686 netif_device_detach(priv->dev);
687 if (priv->mesh_dev)
688 netif_device_detach(priv->mesh_dev);
694 int lbs_resume(struct lbs_private *priv)
698 ret = lbs_set_host_sleep(priv, 0);
700 netif_device_attach(priv->dev);
701 if (priv->mesh_dev)
702 netif_device_attach(priv->mesh_dev);
704 if (priv->deep_sleep_required) {
705 priv->deep_sleep_required = 0;
706 ret = lbs_set_deep_sleep(priv, 1);
708 netdev_err(priv->dev,
712 if (priv->setup_fw_on_resume)
713 ret = lbs_setup_firmware(priv);
727 struct lbs_private *priv = from_timer(priv, t, command_timer);
730 spin_lock_irqsave(&priv->driver_lock, flags);
732 if (!priv->cur_cmd)
735 netdev_info(priv->dev, "command 0x%04x timed out\n",
736 le16_to_cpu(priv->cur_cmd->cmdbuf->command));
738 priv->cmd_timed_out = 1;
744 if (priv->dnld_sent == DNLD_CMD_SENT)
745 priv->dnld_sent = DNLD_RES_RECEIVED;
747 wake_up(&priv->waitq);
749 spin_unlock_irqrestore(&priv->driver_lock, flags);
761 struct lbs_private *priv = from_timer(priv, t, tx_lockup_timer);
764 spin_lock_irqsave(&priv->driver_lock, flags);
766 netdev_info(priv->dev, "TX lockup detected\n");
767 if (priv->reset_card)
768 priv->reset_card(priv);
770 priv->dnld_sent = DNLD_RES_RECEIVED;
771 wake_up_interruptible(&priv->waitq);
773 spin_unlock_irqrestore(&priv->driver_lock, flags);
784 struct lbs_private *priv = from_timer(priv, t, auto_deepsleep_timer);
786 if (priv->is_activity_detected) {
787 priv->is_activity_detected = 0;
789 if (priv->is_auto_deep_sleep_enabled &&
790 (!priv->wakeup_dev_required) &&
791 (priv->connect_status != LBS_CONNECTED)) {
797 lbs_cmd_async(priv, CMD_802_11_DEEP_SLEEP, &cmd,
801 mod_timer(&priv->auto_deepsleep_timer , jiffies +
802 (priv->auto_deep_sleep_timeout * HZ)/1000);
805 int lbs_enter_auto_deep_sleep(struct lbs_private *priv)
807 priv->is_auto_deep_sleep_enabled = 1;
808 if (priv->is_deep_sleep)
809 priv->wakeup_dev_required = 1;
810 mod_timer(&priv->auto_deepsleep_timer ,
811 jiffies + (priv->auto_deep_sleep_timeout * HZ)/1000);
816 int lbs_exit_auto_deep_sleep(struct lbs_private *priv)
818 priv->is_auto_deep_sleep_enabled = 0;
819 priv->auto_deep_sleep_timeout = 0;
820 del_timer(&priv->auto_deepsleep_timer);
825 static int lbs_init_adapter(struct lbs_private *priv)
829 eth_broadcast_addr(priv->current_addr);
831 priv->connect_status = LBS_DISCONNECTED;
832 priv->channel = DEFAULT_AD_HOC_CHANNEL;
833 priv->mac_control = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON;
834 priv->radio_on = 1;
835 priv->psmode = LBS802_11POWERMODECAM;
836 priv->psstate = PS_STATE_FULL_POWER;
837 priv->is_deep_sleep = 0;
838 priv->is_auto_deep_sleep_enabled = 0;
839 priv->deep_sleep_required = 0;
840 priv->wakeup_dev_required = 0;
841 init_waitqueue_head(&priv->ds_awake_q);
842 init_waitqueue_head(&priv->scan_q);
843 priv->authtype_auto = 1;
844 priv->is_host_sleep_configured = 0;
845 priv->is_host_sleep_activated = 0;
846 init_waitqueue_head(&priv->host_sleep_q);
847 init_waitqueue_head(&priv->fw_waitq);
848 mutex_init(&priv->lock);
850 timer_setup(&priv->command_timer, lbs_cmd_timeout_handler, 0);
851 timer_setup(&priv->tx_lockup_timer, lbs_tx_lockup_handler, 0);
852 timer_setup(&priv->auto_deepsleep_timer, auto_deepsleep_timer_fn, 0);
854 INIT_LIST_HEAD(&priv->cmdfreeq);
855 INIT_LIST_HEAD(&priv->cmdpendingq);
857 spin_lock_init(&priv->driver_lock);
860 if (lbs_allocate_cmd_buffer(priv)) {
865 priv->resp_idx = 0;
866 priv->resp_len[0] = priv->resp_len[1] = 0;
869 ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL);
872 lbs_free_cmd_buffer(priv);
880 static void lbs_free_adapter(struct lbs_private *priv)
882 lbs_free_cmd_buffer(priv);
883 kfifo_free(&priv->event_fifo);
884 del_timer(&priv->command_timer);
885 del_timer(&priv->tx_lockup_timer);
886 del_timer(&priv->auto_deepsleep_timer);
910 struct lbs_private *priv = NULL;
922 priv = wdev_priv(wdev);
923 priv->wdev = wdev;
925 err = lbs_init_adapter(priv);
939 dev->ml_priv = priv;
942 priv->dev = dev;
949 priv->card = card;
954 init_waitqueue_head(&priv->waitq);
955 priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main");
956 if (IS_ERR(priv->main_thread)) {
957 err = PTR_ERR(priv->main_thread);
962 priv->work_thread = create_singlethread_workqueue("lbs_worker");
963 INIT_WORK(&priv->mcast_work, lbs_set_mcast_worker);
965 priv->wol_criteria = EHS_REMOVE_WAKEUP;
966 priv->wol_gpio = 0xff;
967 priv->wol_gap = 20;
968 priv->ehs_remove_supported = true;
970 return priv;
976 lbs_free_adapter(priv);
979 lbs_cfg_free(priv);
987 void lbs_remove_card(struct lbs_private *priv)
989 struct net_device *dev = priv->dev;
991 lbs_remove_mesh(priv);
993 if (priv->wiphy_registered)
994 lbs_scan_deinit(priv);
996 lbs_wait_for_firmware_load(priv);
1002 destroy_workqueue(priv->work_thread);
1005 if (priv->psmode == LBS802_11POWERMODEMAX_PSP) {
1006 priv->psmode = LBS802_11POWERMODECAM;
1011 if (priv->psstate != PS_STATE_FULL_POWER)
1012 lbs_set_ps_mode(priv, PS_MODE_ACTION_EXIT_PS, true);
1015 if (priv->is_deep_sleep) {
1016 priv->is_deep_sleep = 0;
1017 wake_up_interruptible(&priv->ds_awake_q);
1020 priv->is_host_sleep_configured = 0;
1021 priv->is_host_sleep_activated = 0;
1022 wake_up_interruptible(&priv->host_sleep_q);
1025 priv->surpriseremoved = 1;
1026 kthread_stop(priv->main_thread);
1028 lbs_free_adapter(priv);
1029 lbs_cfg_free(priv);
1035 int lbs_rtap_supported(struct lbs_private *priv)
1037 if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V5)
1041 return ((MRVL_FW_MAJOR_REV(priv->fwrelease) >= MRVL_FW_V10) &&
1042 (priv->fwcapinfo & MESH_CAPINFO_ENABLE_MASK));
1046 int lbs_start_card(struct lbs_private *priv)
1048 struct net_device *dev = priv->dev;
1052 ret = lbs_setup_firmware(priv);
1057 lbs_init_mesh(priv);
1061 ret = lbs_cfg_register(priv);
1067 if (lbs_mesh_activated(priv))
1068 lbs_start_mesh(priv);
1070 lbs_debugfs_init_one(priv, dev);
1082 void lbs_stop_card(struct lbs_private *priv)
1086 if (!priv)
1088 dev = priv->dev;
1098 lbs_debugfs_remove_one(priv);
1099 lbs_deinit_mesh(priv);
1105 void lbs_queue_event(struct lbs_private *priv, u32 event)
1109 spin_lock_irqsave(&priv->driver_lock, flags);
1111 if (priv->psstate == PS_STATE_SLEEP)
1112 priv->psstate = PS_STATE_AWAKE;
1114 kfifo_in(&priv->event_fifo, (unsigned char *) &event, sizeof(u32));
1116 wake_up(&priv->waitq);
1118 spin_unlock_irqrestore(&priv->driver_lock, flags);
1122 void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx)
1124 if (priv->psstate == PS_STATE_SLEEP)
1125 priv->psstate = PS_STATE_AWAKE;
1129 priv->resp_idx = resp_idx;
1131 wake_up(&priv->waitq);