Lines Matching defs:priv
82 int lbs_set_iface_type(struct lbs_private *priv, enum nl80211_iftype type)
88 ret = lbs_set_monitor_mode(priv, 1);
91 if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR)
92 ret = lbs_set_monitor_mode(priv, 0);
94 ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_BSS_TYPE, 1);
97 if (priv->wdev->iftype == NL80211_IFTYPE_MONITOR)
98 ret = lbs_set_monitor_mode(priv, 0);
100 ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_BSS_TYPE, 2);
108 int lbs_start_iface(struct lbs_private *priv)
113 if (priv->power_restore) {
114 ret = priv->power_restore(priv);
121 memcpy(cmd.macadd, priv->current_addr, ETH_ALEN);
123 ret = lbs_cmd_with_response(priv, CMD_802_11_MAC_ADDRESS, &cmd);
129 ret = lbs_set_iface_type(priv, priv->wdev->iftype);
135 ret = lbs_set_11d_domain_info(priv);
141 lbs_update_channel(priv);
143 priv->iface_running = true;
147 if (priv->power_save)
148 priv->power_save(priv);
160 struct lbs_private *priv = dev->ml_priv;
163 if (!priv->iface_running) {
164 ret = lbs_start_iface(priv);
169 spin_lock_irq(&priv->driver_lock);
173 if (!priv->tx_pending_len)
176 spin_unlock_irq(&priv->driver_lock);
182 static bool lbs_command_queue_empty(struct lbs_private *priv)
186 spin_lock_irqsave(&priv->driver_lock, flags);
187 ret = priv->cur_cmd == NULL && list_empty(&priv->cmdpendingq);
188 spin_unlock_irqrestore(&priv->driver_lock, flags);
192 int lbs_stop_iface(struct lbs_private *priv)
197 spin_lock_irqsave(&priv->driver_lock, flags);
198 priv->iface_running = false;
199 dev_kfree_skb_irq(priv->currenttxskb);
200 priv->currenttxskb = NULL;
201 priv->tx_pending_len = 0;
202 spin_unlock_irqrestore(&priv->driver_lock, flags);
204 cancel_work_sync(&priv->mcast_work);
205 timer_delete_sync(&priv->tx_lockup_timer);
209 wait_event(priv->waitq, lbs_command_queue_empty(priv));
212 if (priv->power_save)
213 ret = priv->power_save(priv);
226 struct lbs_private *priv = dev->ml_priv;
228 if (priv->connect_status == LBS_CONNECTED)
229 lbs_disconnect(priv, WLAN_REASON_DEAUTH_LEAVING);
231 spin_lock_irq(&priv->driver_lock);
233 spin_unlock_irq(&priv->driver_lock);
235 lbs_update_mcast(priv);
236 cancel_delayed_work_sync(&priv->scan_work);
237 if (priv->scan_req)
238 lbs_scan_done(priv);
240 netif_carrier_off(priv->dev);
242 if (!lbs_iface_active(priv))
243 lbs_stop_iface(priv);
248 void lbs_host_to_card_done(struct lbs_private *priv)
252 spin_lock_irqsave(&priv->driver_lock, flags);
253 timer_delete(&priv->tx_lockup_timer);
255 priv->dnld_sent = DNLD_RES_RECEIVED;
258 if (!priv->cur_cmd || priv->tx_pending_len > 0) {
259 wake_up(&priv->waitq);
262 spin_unlock_irqrestore(&priv->driver_lock, flags);
269 struct lbs_private *priv = dev->ml_priv;
276 if (lbs_iface_active(priv))
280 dev = priv->dev;
282 memcpy(priv->current_addr, phwaddr->sa_data, ETH_ALEN);
284 if (priv->mesh_dev)
285 eth_hw_addr_set(priv->mesh_dev, phwaddr->sa_data);
339 void lbs_update_mcast(struct lbs_private *priv)
344 int old_mac_control = priv->mac_control;
346 if (netif_running(priv->dev))
347 dev_flags |= priv->dev->flags;
348 if (priv->mesh_dev && netif_running(priv->mesh_dev))
349 dev_flags |= priv->mesh_dev->flags;
352 priv->mac_control |= CMD_ACT_MAC_PROMISCUOUS_ENABLE;
353 priv->mac_control &= ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE |
358 priv->mac_control |= CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
359 priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE |
364 /* Once for priv->dev, again for priv->mesh_dev if it exists */
365 nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->dev, 0);
366 if (nr_addrs >= 0 && priv->mesh_dev)
367 nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->mesh_dev, nr_addrs);
379 lbs_cmd_async(priv, CMD_MAC_MULTICAST_ADR, &mcast_cmd.hdr, size);
381 priv->mac_control |= CMD_ACT_MAC_MULTICAST_ENABLE;
383 priv->mac_control &= ~CMD_ACT_MAC_MULTICAST_ENABLE;
385 priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE |
388 if (priv->mac_control != old_mac_control)
389 lbs_set_mac_control(priv);
394 struct lbs_private *priv = container_of(work, struct lbs_private, mcast_work);
395 lbs_update_mcast(priv);
400 struct lbs_private *priv = dev->ml_priv;
402 schedule_work(&priv->mcast_work);
416 struct lbs_private *priv = dev->ml_priv;
426 priv->currenttxskb, priv->dnld_sent);
428 add_wait_queue(&priv->waitq, &wait);
430 spin_lock_irq(&priv->driver_lock);
434 else if (priv->surpriseremoved)
436 else if (priv->psstate == PS_STATE_SLEEP)
438 else if (priv->cmd_timed_out)
440 else if (!priv->fw_ready)
442 else if (priv->dnld_sent)
444 else if (priv->tx_pending_len > 0)
446 else if (priv->resp_len[priv->resp_idx])
448 else if (priv->cur_cmd)
450 else if (!list_empty(&priv->cmdpendingq))
452 else if (kfifo_len(&priv->event_fifo))
460 priv->connect_status,
461 priv->psmode, priv->psstate);
462 spin_unlock_irq(&priv->driver_lock);
465 spin_unlock_irq(&priv->driver_lock);
468 priv->currenttxskb, priv->dnld_sent);
471 remove_wait_queue(&priv->waitq, &wait);
474 priv->currenttxskb, priv->dnld_sent);
481 if (priv->surpriseremoved) {
487 priv->currenttxskb, priv->dnld_sent);
490 spin_lock_irq(&priv->driver_lock);
491 resp_idx = priv->resp_idx;
492 if (priv->resp_len[resp_idx]) {
493 spin_unlock_irq(&priv->driver_lock);
494 lbs_process_command_response(priv,
495 priv->resp_buf[resp_idx],
496 priv->resp_len[resp_idx]);
497 spin_lock_irq(&priv->driver_lock);
498 priv->resp_len[resp_idx] = 0;
500 spin_unlock_irq(&priv->driver_lock);
503 spin_lock_irq(&priv->driver_lock);
504 while (kfifo_len(&priv->event_fifo)) {
507 if (kfifo_out(&priv->event_fifo,
511 spin_unlock_irq(&priv->driver_lock);
512 lbs_process_event(priv, event);
513 spin_lock_irq(&priv->driver_lock);
515 spin_unlock_irq(&priv->driver_lock);
518 if (priv->cmd_timed_out && priv->cur_cmd) {
519 struct cmd_ctrl_node *cmdnode = priv->cur_cmd;
523 lbs_complete_command(priv, cmdnode, -ETIMEDOUT);
527 if (!dev->dismantle && priv->reset_card)
528 priv->reset_card(priv);
530 priv->cmd_timed_out = 0;
532 if (!priv->fw_ready)
536 if (priv->psstate == PS_STATE_PRE_SLEEP &&
537 !priv->dnld_sent && !priv->cur_cmd) {
538 if (priv->connect_status == LBS_CONNECTED) {
541 priv->currenttxskb, priv->dnld_sent,
542 priv->cur_cmd);
544 lbs_ps_confirm_sleep(priv);
551 priv->psstate = PS_STATE_AWAKE;
560 if ((priv->psstate == PS_STATE_SLEEP) ||
561 (priv->psstate == PS_STATE_PRE_SLEEP))
564 if (priv->is_deep_sleep)
568 if (!priv->dnld_sent && !priv->cur_cmd)
569 lbs_execute_next_command(priv);
571 spin_lock_irq(&priv->driver_lock);
572 if (!priv->dnld_sent && priv->tx_pending_len > 0) {
573 int ret = priv->hw_host_to_card(priv, MVMS_DAT,
574 priv->tx_pending_buf,
575 priv->tx_pending_len);
578 priv->dnld_sent = DNLD_RES_RECEIVED;
580 mod_timer(&priv->tx_lockup_timer,
583 priv->tx_pending_len = 0;
584 if (!priv->currenttxskb) {
587 if (priv->connect_status == LBS_CONNECTED)
588 netif_wake_queue(priv->dev);
589 if (priv->mesh_dev &&
590 netif_running(priv->mesh_dev))
591 netif_wake_queue(priv->mesh_dev);
594 spin_unlock_irq(&priv->driver_lock);
597 timer_delete(&priv->command_timer);
598 timer_delete(&priv->tx_lockup_timer);
607 * @priv: A pointer to &struct lbs_private structure
610 static int lbs_setup_firmware(struct lbs_private *priv)
616 eth_broadcast_addr(priv->current_addr);
617 ret = lbs_update_hw_spec(priv);
622 ret = lbs_get_tx_power(priv, &curlevel, &minlevel, &maxlevel);
624 priv->txpower_cur = curlevel;
625 priv->txpower_min = minlevel;
626 priv->txpower_max = maxlevel;
630 ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_11D_ENABLE, 1);
634 ret = lbs_set_mac_control_sync(priv);
639 int lbs_suspend(struct lbs_private *priv)
643 if (priv->is_deep_sleep) {
644 ret = lbs_set_deep_sleep(priv, 0);
646 netdev_err(priv->dev,
650 priv->deep_sleep_required = 1;
653 ret = lbs_set_host_sleep(priv, 1);
655 netif_device_detach(priv->dev);
656 if (priv->mesh_dev)
657 netif_device_detach(priv->mesh_dev);
663 int lbs_resume(struct lbs_private *priv)
667 ret = lbs_set_host_sleep(priv, 0);
669 netif_device_attach(priv->dev);
670 if (priv->mesh_dev)
671 netif_device_attach(priv->mesh_dev);
673 if (priv->deep_sleep_required) {
674 priv->deep_sleep_required = 0;
675 ret = lbs_set_deep_sleep(priv, 1);
677 netdev_err(priv->dev,
681 if (priv->setup_fw_on_resume)
682 ret = lbs_setup_firmware(priv);
696 struct lbs_private *priv = timer_container_of(priv, t, command_timer);
699 spin_lock_irqsave(&priv->driver_lock, flags);
701 if (!priv->cur_cmd)
704 netdev_info(priv->dev, "command 0x%04x timed out\n",
705 le16_to_cpu(priv->cur_cmd->cmdbuf->command));
707 priv->cmd_timed_out = 1;
713 if (priv->dnld_sent == DNLD_CMD_SENT)
714 priv->dnld_sent = DNLD_RES_RECEIVED;
716 wake_up(&priv->waitq);
718 spin_unlock_irqrestore(&priv->driver_lock, flags);
730 struct lbs_private *priv = timer_container_of(priv, t,
734 spin_lock_irqsave(&priv->driver_lock, flags);
736 netdev_info(priv->dev, "TX lockup detected\n");
737 if (priv->reset_card)
738 priv->reset_card(priv);
740 priv->dnld_sent = DNLD_RES_RECEIVED;
741 wake_up_interruptible(&priv->waitq);
743 spin_unlock_irqrestore(&priv->driver_lock, flags);
746 static int lbs_init_adapter(struct lbs_private *priv)
750 eth_broadcast_addr(priv->current_addr);
752 priv->connect_status = LBS_DISCONNECTED;
753 priv->channel = DEFAULT_AD_HOC_CHANNEL;
754 priv->mac_control = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON;
755 priv->radio_on = 1;
756 priv->psmode = LBS802_11POWERMODECAM;
757 priv->psstate = PS_STATE_FULL_POWER;
758 priv->is_deep_sleep = 0;
759 priv->deep_sleep_required = 0;
760 init_waitqueue_head(&priv->ds_awake_q);
761 init_waitqueue_head(&priv->scan_q);
762 priv->authtype_auto = 1;
763 priv->is_host_sleep_configured = 0;
764 priv->is_host_sleep_activated = 0;
765 init_waitqueue_head(&priv->host_sleep_q);
766 init_waitqueue_head(&priv->fw_waitq);
767 mutex_init(&priv->lock);
769 timer_setup(&priv->command_timer, lbs_cmd_timeout_handler, 0);
770 timer_setup(&priv->tx_lockup_timer, lbs_tx_lockup_handler, 0);
772 INIT_LIST_HEAD(&priv->cmdfreeq);
773 INIT_LIST_HEAD(&priv->cmdpendingq);
775 spin_lock_init(&priv->driver_lock);
778 if (lbs_allocate_cmd_buffer(priv)) {
783 priv->resp_idx = 0;
784 priv->resp_len[0] = priv->resp_len[1] = 0;
787 ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL);
790 lbs_free_cmd_buffer(priv);
798 static void lbs_free_adapter(struct lbs_private *priv)
800 lbs_free_cmd_buffer(priv);
801 kfifo_free(&priv->event_fifo);
802 timer_delete(&priv->command_timer);
803 timer_delete(&priv->tx_lockup_timer);
827 struct lbs_private *priv = NULL;
839 priv = wdev_priv(wdev);
840 priv->wdev = wdev;
842 err = lbs_init_adapter(priv);
856 dev->ml_priv = priv;
859 priv->dev = dev;
866 priv->card = card;
871 init_waitqueue_head(&priv->waitq);
872 priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main");
873 if (IS_ERR(priv->main_thread)) {
874 err = PTR_ERR(priv->main_thread);
879 priv->work_thread = create_singlethread_workqueue("lbs_worker");
880 INIT_WORK(&priv->mcast_work, lbs_set_mcast_worker);
882 priv->wol_criteria = EHS_REMOVE_WAKEUP;
883 priv->wol_gpio = 0xff;
884 priv->wol_gap = 20;
885 priv->ehs_remove_supported = true;
887 return priv;
893 lbs_free_adapter(priv);
896 lbs_cfg_free(priv);
904 void lbs_remove_card(struct lbs_private *priv)
906 struct net_device *dev = priv->dev;
908 lbs_remove_mesh(priv);
910 if (priv->wiphy_registered)
911 lbs_scan_deinit(priv);
913 lbs_wait_for_firmware_load(priv);
919 destroy_workqueue(priv->work_thread);
922 if (priv->psmode == LBS802_11POWERMODEMAX_PSP) {
923 priv->psmode = LBS802_11POWERMODECAM;
928 if (priv->psstate != PS_STATE_FULL_POWER)
929 lbs_set_ps_mode(priv, PS_MODE_ACTION_EXIT_PS, true);
932 if (priv->is_deep_sleep) {
933 priv->is_deep_sleep = 0;
934 wake_up_interruptible(&priv->ds_awake_q);
937 priv->is_host_sleep_configured = 0;
938 priv->is_host_sleep_activated = 0;
939 wake_up_interruptible(&priv->host_sleep_q);
942 priv->surpriseremoved = 1;
943 kthread_stop(priv->main_thread);
945 lbs_free_adapter(priv);
946 lbs_cfg_free(priv);
952 int lbs_rtap_supported(struct lbs_private *priv)
954 if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V5)
958 return ((MRVL_FW_MAJOR_REV(priv->fwrelease) >= MRVL_FW_V10) &&
959 (priv->fwcapinfo & MESH_CAPINFO_ENABLE_MASK));
963 int lbs_start_card(struct lbs_private *priv)
965 struct net_device *dev = priv->dev;
969 ret = lbs_setup_firmware(priv);
974 lbs_init_mesh(priv);
978 ret = lbs_cfg_register(priv);
984 if (lbs_mesh_activated(priv))
985 lbs_start_mesh(priv);
987 lbs_debugfs_init_one(priv, dev);
999 void lbs_stop_card(struct lbs_private *priv)
1003 if (!priv)
1005 dev = priv->dev;
1015 lbs_debugfs_remove_one(priv);
1016 lbs_deinit_mesh(priv);
1022 void lbs_queue_event(struct lbs_private *priv, u32 event)
1026 spin_lock_irqsave(&priv->driver_lock, flags);
1028 if (priv->psstate == PS_STATE_SLEEP)
1029 priv->psstate = PS_STATE_AWAKE;
1031 kfifo_in(&priv->event_fifo, (unsigned char *) &event, sizeof(u32));
1033 wake_up(&priv->waitq);
1035 spin_unlock_irqrestore(&priv->driver_lock, flags);
1039 void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx)
1041 if (priv->psstate == PS_STATE_SLEEP)
1042 priv->psstate = PS_STATE_AWAKE;
1046 priv->resp_idx = resp_idx;
1048 wake_up(&priv->waitq);