Lines Matching full:adapter
47 * - Allocate adapter structure
48 * - Save interface specific operations table in adapter
51 * - Set default adapter structure parameters
60 struct mwifiex_adapter *adapter;
63 adapter = kzalloc(sizeof(struct mwifiex_adapter), GFP_KERNEL);
64 if (!adapter)
67 *padapter = adapter;
68 adapter->dev = dev;
69 adapter->card = card;
71 /* Save interface specific operations in adapter */
72 memmove(&adapter->if_ops, if_ops, sizeof(struct mwifiex_if_ops));
73 adapter->debug_mask = debug_mask;
76 if (adapter->if_ops.init_if)
77 if (adapter->if_ops.init_if(adapter))
80 adapter->priv_num = 0;
84 adapter->priv[i] =
86 if (!adapter->priv[i])
89 adapter->priv[i]->adapter = adapter;
90 adapter->priv_num++;
92 mwifiex_init_lock_list(adapter);
94 timer_setup(&adapter->cmd_timer, mwifiex_cmd_timeout_func, 0);
99 mwifiex_dbg(adapter, ERROR,
102 for (i = 0; i < adapter->priv_num; i++)
103 kfree(adapter->priv[i]);
105 kfree(adapter);
118 * - Free adapter structure
120 static int mwifiex_unregister(struct mwifiex_adapter *adapter)
124 if (adapter->if_ops.cleanup_if)
125 adapter->if_ops.cleanup_if(adapter);
127 timer_shutdown_sync(&adapter->cmd_timer);
130 for (i = 0; i < adapter->priv_num; i++) {
131 mwifiex_free_curr_bcn(adapter->priv[i]);
132 kfree(adapter->priv[i]);
135 if (adapter->nd_info) {
136 for (i = 0 ; i < adapter->nd_info->n_matches ; i++)
137 kfree(adapter->nd_info->matches[i]);
138 kfree(adapter->nd_info);
139 adapter->nd_info = NULL;
142 kfree(adapter->regd);
144 kfree(adapter);
148 void mwifiex_queue_main_work(struct mwifiex_adapter *adapter)
152 spin_lock_irqsave(&adapter->main_proc_lock, flags);
153 if (adapter->mwifiex_processing) {
154 adapter->more_task_flag = true;
155 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
157 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
158 queue_work(adapter->workqueue, &adapter->main_work);
163 static void mwifiex_queue_rx_work(struct mwifiex_adapter *adapter)
165 spin_lock_bh(&adapter->rx_proc_lock);
166 if (adapter->rx_processing) {
167 spin_unlock_bh(&adapter->rx_proc_lock);
169 spin_unlock_bh(&adapter->rx_proc_lock);
170 queue_work(adapter->rx_workqueue, &adapter->rx_work);
174 static int mwifiex_process_rx(struct mwifiex_adapter *adapter)
179 spin_lock_bh(&adapter->rx_proc_lock);
180 if (adapter->rx_processing || adapter->rx_locked) {
181 spin_unlock_bh(&adapter->rx_proc_lock);
184 adapter->rx_processing = true;
185 spin_unlock_bh(&adapter->rx_proc_lock);
189 while ((skb = skb_dequeue(&adapter->rx_data_q))) {
190 atomic_dec(&adapter->rx_pending);
191 if ((adapter->delay_main_work ||
192 adapter->iface_type == MWIFIEX_USB) &&
193 (atomic_read(&adapter->rx_pending) < LOW_RX_PENDING)) {
194 if (adapter->if_ops.submit_rem_rx_urbs)
195 adapter->if_ops.submit_rem_rx_urbs(adapter);
196 adapter->delay_main_work = false;
197 mwifiex_queue_main_work(adapter);
201 if (adapter->if_ops.deaggr_pkt)
202 adapter->if_ops.deaggr_pkt(adapter, skb);
205 mwifiex_handle_rx_packet(adapter, skb);
208 spin_lock_bh(&adapter->rx_proc_lock);
209 adapter->rx_processing = false;
210 spin_unlock_bh(&adapter->rx_proc_lock);
216 static void maybe_quirk_fw_disable_ds(struct mwifiex_adapter *adapter)
218 struct mwifiex_private *priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA);
221 if (test_and_set_bit(MWIFIEX_IS_REQUESTING_FW_VEREXT, &adapter->work_flags))
228 mwifiex_dbg(priv->adapter, MSG,
248 int mwifiex_main_process(struct mwifiex_adapter *adapter)
253 spin_lock_irqsave(&adapter->main_proc_lock, flags);
256 if (adapter->mwifiex_processing || adapter->main_locked) {
257 adapter->more_task_flag = true;
258 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
261 adapter->mwifiex_processing = true;
262 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
266 if (adapter->hw_status == MWIFIEX_HW_STATUS_NOT_READY)
276 if (atomic_read(&adapter->rx_pending) >= HIGH_RX_PENDING &&
277 adapter->iface_type != MWIFIEX_USB) {
278 adapter->delay_main_work = true;
279 mwifiex_queue_rx_work(adapter);
284 if (adapter->int_status) {
285 if (adapter->hs_activated)
286 mwifiex_process_hs_config(adapter);
287 if (adapter->if_ops.process_int_status)
288 adapter->if_ops.process_int_status(adapter);
291 if (adapter->rx_work_enabled && adapter->data_received)
292 mwifiex_queue_rx_work(adapter);
295 if ((adapter->ps_state == PS_STATE_SLEEP) &&
296 (adapter->pm_wakeup_card_req &&
297 !adapter->pm_wakeup_fw_try) &&
298 (is_command_pending(adapter) ||
299 !skb_queue_empty(&adapter->tx_data_q) ||
300 !mwifiex_bypass_txlist_empty(adapter) ||
301 !mwifiex_wmm_lists_empty(adapter))) {
302 adapter->pm_wakeup_fw_try = true;
303 mod_timer(&adapter->wakeup_timer, jiffies + (HZ*3));
304 adapter->if_ops.wakeup(adapter);
308 if (IS_CARD_RX_RCVD(adapter)) {
309 adapter->data_received = false;
310 adapter->pm_wakeup_fw_try = false;
311 timer_delete(&adapter->wakeup_timer);
312 if (adapter->ps_state == PS_STATE_SLEEP)
313 adapter->ps_state = PS_STATE_AWAKE;
316 if (adapter->pm_wakeup_fw_try)
318 if (adapter->ps_state == PS_STATE_PRE_SLEEP)
319 mwifiex_check_ps_cond(adapter);
321 if (adapter->ps_state != PS_STATE_AWAKE)
323 if (adapter->tx_lock_flag) {
324 if (adapter->iface_type == MWIFIEX_USB) {
325 if (!adapter->usb_mc_setup)
331 if ((!adapter->scan_chan_gap_enabled &&
332 adapter->scan_processing) || adapter->data_sent ||
334 (mwifiex_get_priv(adapter,
336 (mwifiex_wmm_lists_empty(adapter) &&
337 mwifiex_bypass_txlist_empty(adapter) &&
338 skb_queue_empty(&adapter->tx_data_q))) {
339 if (adapter->cmd_sent || adapter->curr_cmd ||
341 (mwifiex_get_priv(adapter,
343 (!is_command_pending(adapter)))
349 if (adapter->event_received) {
350 adapter->event_received = false;
351 mwifiex_process_event(adapter);
355 if (adapter->cmd_resp_received) {
356 adapter->cmd_resp_received = false;
357 mwifiex_process_cmdresp(adapter);
362 if (adapter->ps_state == PS_STATE_PRE_SLEEP)
363 mwifiex_check_ps_cond(adapter);
368 if ((adapter->ps_state == PS_STATE_SLEEP) ||
369 (adapter->ps_state == PS_STATE_PRE_SLEEP) ||
370 (adapter->ps_state == PS_STATE_SLEEP_CFM)) {
374 if (adapter->tx_lock_flag) {
375 if (adapter->iface_type == MWIFIEX_USB) {
376 if (!adapter->usb_mc_setup)
382 if (!adapter->cmd_sent && !adapter->curr_cmd &&
384 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA))) {
385 if (mwifiex_exec_next_cmd(adapter) == -1) {
394 if (adapter->iface_type == MWIFIEX_USB &&
395 adapter->usb_mc_setup)
398 if ((adapter->scan_chan_gap_enabled ||
399 !adapter->scan_processing) &&
400 !adapter->data_sent &&
401 !skb_queue_empty(&adapter->tx_data_q)) {
402 if (adapter->hs_activated_manually) {
403 mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY),
405 adapter->hs_activated_manually = false;
408 mwifiex_process_tx_queue(adapter);
409 if (adapter->hs_activated) {
411 &adapter->work_flags);
412 mwifiex_hs_activated_event(adapter, false);
416 if ((adapter->scan_chan_gap_enabled ||
417 !adapter->scan_processing) &&
418 !adapter->data_sent &&
419 !mwifiex_bypass_txlist_empty(adapter) &&
421 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA))) {
422 if (adapter->hs_activated_manually) {
423 mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY),
425 adapter->hs_activated_manually = false;
428 mwifiex_process_bypass_tx(adapter);
429 if (adapter->hs_activated) {
431 &adapter->work_flags);
432 mwifiex_hs_activated_event(adapter, false);
436 if ((adapter->scan_chan_gap_enabled ||
437 !adapter->scan_processing) &&
438 !adapter->data_sent && !mwifiex_wmm_lists_empty(adapter) &&
440 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA))) {
441 if (adapter->hs_activated_manually) {
442 mwifiex_cancel_hs(mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY),
444 adapter->hs_activated_manually = false;
447 mwifiex_wmm_process_tx(adapter);
448 if (adapter->hs_activated) {
450 &adapter->work_flags);
451 mwifiex_hs_activated_event(adapter, false);
455 if (adapter->delay_null_pkt && !adapter->cmd_sent &&
456 !adapter->curr_cmd && !is_command_pending(adapter) &&
457 (mwifiex_wmm_lists_empty(adapter) &&
458 mwifiex_bypass_txlist_empty(adapter) &&
459 skb_queue_empty(&adapter->tx_data_q))) {
461 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
464 adapter->delay_null_pkt = false;
465 adapter->ps_state = PS_STATE_SLEEP;
471 spin_lock_irqsave(&adapter->main_proc_lock, flags);
472 if (adapter->more_task_flag) {
473 adapter->more_task_flag = false;
474 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
477 adapter->mwifiex_processing = false;
478 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
485 * This function frees the adapter structure.
490 static void mwifiex_free_adapter(struct mwifiex_adapter *adapter)
492 if (!adapter) {
493 pr_err("%s: adapter is NULL\n", __func__);
497 mwifiex_unregister(adapter);
498 pr_debug("info: %s: free adapter\n", __func__);
505 static void mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter)
507 if (adapter->workqueue) {
508 destroy_workqueue(adapter->workqueue);
509 adapter->workqueue = NULL;
512 if (adapter->rx_workqueue) {
513 destroy_workqueue(adapter->rx_workqueue);
514 adapter->rx_workqueue = NULL;
517 if (adapter->host_mlme_workqueue) {
518 destroy_workqueue(adapter->host_mlme_workqueue);
519 adapter->host_mlme_workqueue = NULL;
534 struct mwifiex_adapter *adapter = context;
538 struct completion *fw_done = adapter->fw_done;
541 mwifiex_dbg(adapter, ERROR,
542 "Failed to get firmware %s\n", adapter->fw_name);
547 adapter->firmware = firmware;
548 fw.fw_buf = (u8 *) adapter->firmware->data;
549 fw.fw_len = adapter->firmware->size;
551 if (adapter->if_ops.dnld_fw) {
552 ret = adapter->if_ops.dnld_fw(adapter, &fw);
554 ret = mwifiex_dnld_fw(adapter, &fw);
560 mwifiex_dbg(adapter, MSG, "WLAN FW is active\n");
563 if ((request_firmware(&adapter->cal_data, cal_data_cfg,
564 adapter->dev)) < 0)
565 mwifiex_dbg(adapter, ERROR,
570 if (adapter->if_ops.enable_int) {
571 if (adapter->if_ops.enable_int(adapter))
575 ret = mwifiex_init_fw(adapter);
579 maybe_quirk_fw_disable_ds(adapter);
581 if (!adapter->wiphy) {
582 if (mwifiex_register_cfg80211(adapter)) {
583 mwifiex_dbg(adapter, ERROR,
589 if (mwifiex_init_channel_scan_gap(adapter)) {
590 mwifiex_dbg(adapter, ERROR,
601 wiphy_lock(adapter->wiphy);
603 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "mlan%d", NET_NAME_ENUM,
606 mwifiex_dbg(adapter, ERROR,
608 wiphy_unlock(adapter->wiphy);
614 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "uap%d", NET_NAME_ENUM,
617 mwifiex_dbg(adapter, ERROR,
619 wiphy_unlock(adapter->wiphy);
626 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "p2p%d", NET_NAME_ENUM,
629 mwifiex_dbg(adapter, ERROR,
631 wiphy_unlock(adapter->wiphy);
636 wiphy_unlock(adapter->wiphy);
639 mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1);
640 mwifiex_dbg(adapter, MSG, "driver_version = %s\n", fmt);
641 adapter->is_up = true;
645 vfree(adapter->chan_stats);
647 wiphy_unregister(adapter->wiphy);
648 wiphy_free(adapter->wiphy);
650 if (adapter->if_ops.disable_int)
651 adapter->if_ops.disable_int(adapter);
653 mwifiex_dbg(adapter, ERROR,
655 if (adapter->if_ops.unregister_dev)
656 adapter->if_ops.unregister_dev(adapter);
658 set_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags);
659 mwifiex_terminate_workqueue(adapter);
661 if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) {
663 mwifiex_shutdown_drv(adapter);
664 mwifiex_free_cmd_buffers(adapter);
669 if (adapter->firmware) {
670 release_firmware(adapter->firmware);
671 adapter->firmware = NULL;
674 if (adapter->irq_wakeup >= 0)
675 device_init_wakeup(adapter->dev, false);
676 mwifiex_free_adapter(adapter);
693 static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter,
702 strscpy(adapter->fw_name, MFG_FIRMWARE,
703 sizeof(adapter->fw_name));
706 ret = request_firmware_nowait(THIS_MODULE, 1, adapter->fw_name,
707 adapter->dev, GFP_KERNEL, adapter,
710 ret = request_firmware(&adapter->firmware,
711 adapter->fw_name,
712 adapter->dev);
716 mwifiex_dbg(adapter, ERROR, "request_firmware%s error %d\n",
747 mwifiex_dbg(priv->adapter, INFO,
755 mwifiex_dbg(priv->adapter, INFO,
773 ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) &&
775 mwifiex_dbg(priv->adapter, DATA,
780 mwifiex_dbg(priv->adapter, MSG,
800 mwifiex_dbg(priv->adapter, DATA,
806 atomic_inc(&priv->adapter->tx_pending);
807 atomic_inc(&priv->adapter->bypass_tx_pending);
810 atomic_inc(&priv->adapter->tx_pending);
814 mwifiex_queue_main_work(priv->adapter);
871 mwifiex_dbg(priv->adapter, DATA,
875 if (test_bit(MWIFIEX_SURPRISE_REMOVED, &priv->adapter->work_flags)) {
881 mwifiex_dbg(priv->adapter, ERROR,
888 mwifiex_dbg(priv->adapter, DATA,
895 mwifiex_dbg(priv->adapter, ERROR,
903 mwifiex_dbg(priv->adapter, INFO,
917 priv->adapter->fw_api_ver == MWIFIEX_FW_V15))
931 if (ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) &&
934 if (priv->adapter->auto_tdls && priv->check_tdls_tx)
964 } else if (priv->adapter->priv[0] != priv) {
979 mwifiex_dbg(priv->adapter, ERROR,
1030 mwifiex_dbg(priv->adapter, ERROR,
1037 priv->adapter->if_ops.card_reset) {
1038 mwifiex_dbg(priv->adapter, ERROR,
1041 priv->adapter->if_ops.card_reset(priv->adapter);
1045 void mwifiex_multi_chan_resync(struct mwifiex_adapter *adapter)
1047 struct usb_card_rec *card = adapter->card;
1055 mwifiex_dbg(adapter, WARN, "pending data urb in sys\n");
1062 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
1066 mwifiex_dbg(adapter, ERROR,
1071 void mwifiex_upload_device_dump(struct mwifiex_adapter *adapter)
1076 mwifiex_dbg(adapter, MSG,
1078 dev_coredumpv(adapter->dev, adapter->devdump_data, adapter->devdump_len,
1080 mwifiex_dbg(adapter, MSG,
1084 * after 5 min. Here reset adapter->devdump_data and ->devdump_len
1087 adapter->devdump_data = NULL;
1088 adapter->devdump_len = 0;
1092 void mwifiex_drv_info_dump(struct mwifiex_adapter *adapter)
1103 mwifiex_dbg(adapter, MSG, "===mwifiex driverinfo dump start===\n");
1105 p = adapter->devdump_data;
1110 mwifiex_drv_get_driver_version(adapter, drv_version,
1114 if (adapter->iface_type == MWIFIEX_USB) {
1115 cardp = (struct usb_card_rec *)adapter->card;
1129 atomic_read(&adapter->tx_pending));
1131 atomic_read(&adapter->rx_pending));
1133 if (adapter->iface_type == MWIFIEX_SDIO) {
1134 sdio_card = (struct sdio_mmc_card *)adapter->card;
1141 for (i = 0; i < adapter->priv_num; i++) {
1142 if (!adapter->priv[i]->netdev)
1144 priv = adapter->priv[i];
1169 if (adapter->iface_type == MWIFIEX_SDIO ||
1170 adapter->iface_type == MWIFIEX_PCIE) {
1172 adapter->iface_type == MWIFIEX_SDIO ?
1174 if (adapter->if_ops.reg_dump)
1175 p += adapter->if_ops.reg_dump(adapter, p);
1180 for (i = 0; i < adapter->priv_num; i++) {
1181 if (!adapter->priv[i]->netdev)
1183 priv = adapter->priv[i];
1193 mwifiex_dbg(adapter, MSG, "===mwifiex driverinfo dump end===\n");
1194 adapter->devdump_len = p - (char *)adapter->devdump_data;
1198 void mwifiex_prepare_fw_dump_info(struct mwifiex_adapter *adapter)
1204 for (idx = 0; idx < adapter->num_mem_types; idx++) {
1206 &adapter->mem_type_mapping_tbl[idx];
1217 if (dump_len + 1 + adapter->devdump_len > MWIFIEX_FW_DUMP_SIZE) {
1219 fw_dump_ptr = vzalloc(dump_len + 1 + adapter->devdump_len);
1220 mwifiex_dbg(adapter, MSG, "Realloc device dump data.\n");
1222 vfree(adapter->devdump_data);
1223 mwifiex_dbg(adapter, ERROR,
1228 memmove(fw_dump_ptr, adapter->devdump_data,
1229 adapter->devdump_len);
1230 vfree(adapter->devdump_data);
1231 adapter->devdump_data = fw_dump_ptr;
1234 fw_dump_ptr = (char *)adapter->devdump_data + adapter->devdump_len;
1236 for (idx = 0; idx < adapter->num_mem_types; idx++) {
1238 &adapter->mem_type_mapping_tbl[idx];
1258 adapter->devdump_len = fw_dump_ptr - (char *)adapter->devdump_data;
1260 for (idx = 0; idx < adapter->num_mem_types; idx++) {
1262 &adapter->mem_type_mapping_tbl[idx];
1340 ether_addr_copy(priv->curr_addr, priv->adapter->perm_addr);
1353 int is_command_pending(struct mwifiex_adapter *adapter)
1357 spin_lock_bh(&adapter->cmd_pending_q_lock);
1358 is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q);
1359 spin_unlock_bh(&adapter->cmd_pending_q_lock);
1369 struct mwifiex_adapter *adapter =
1372 if (test_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags))
1376 if (adapter->host_mlme_link_lost) {
1377 if (adapter->priv_link_lost) {
1378 mwifiex_reset_connect_state(adapter->priv_link_lost,
1381 adapter->priv_link_lost = NULL;
1383 adapter->host_mlme_link_lost = false;
1387 if (adapter->assoc_resp_received) {
1388 mwifiex_process_assoc_resp(adapter);
1389 adapter->assoc_resp_received = false;
1400 struct mwifiex_adapter *adapter =
1403 if (test_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags))
1405 mwifiex_process_rx(adapter);
1416 struct mwifiex_adapter *adapter =
1419 if (test_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags))
1421 mwifiex_main_process(adapter);
1425 static void mwifiex_uninit_sw(struct mwifiex_adapter *adapter)
1433 if (adapter->if_ops.disable_int)
1434 adapter->if_ops.disable_int(adapter);
1436 set_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags);
1437 mwifiex_terminate_workqueue(adapter);
1438 adapter->int_status = 0;
1441 for (i = 0; i < adapter->priv_num; i++) {
1442 priv = adapter->priv[i];
1444 mwifiex_stop_net_dev_queue(priv->netdev, adapter);
1451 mwifiex_dbg(adapter, CMD, "cmd: calling mwifiex_shutdown_drv...\n");
1452 mwifiex_shutdown_drv(adapter);
1453 mwifiex_dbg(adapter, CMD, "cmd: mwifiex_shutdown_drv done\n");
1455 if (atomic_read(&adapter->rx_pending) ||
1456 atomic_read(&adapter->tx_pending) ||
1457 atomic_read(&adapter->cmd_pending)) {
1458 mwifiex_dbg(adapter, ERROR,
1461 atomic_read(&adapter->rx_pending),
1462 atomic_read(&adapter->tx_pending),
1463 atomic_read(&adapter->cmd_pending));
1466 for (i = 0; i < adapter->priv_num; i++) {
1467 priv = adapter->priv[i];
1477 wiphy_lock(adapter->wiphy);
1478 mwifiex_del_virtual_intf(adapter->wiphy, &priv->wdev);
1479 wiphy_unlock(adapter->wiphy);
1484 wiphy_unregister(adapter->wiphy);
1485 wiphy_free(adapter->wiphy);
1486 adapter->wiphy = NULL;
1488 vfree(adapter->chan_stats);
1489 mwifiex_free_cmd_buffers(adapter);
1493 * This function can be used for shutting down the adapter SW.
1495 int mwifiex_shutdown_sw(struct mwifiex_adapter *adapter)
1499 if (!adapter)
1502 wait_for_completion(adapter->fw_done);
1504 reinit_completion(adapter->fw_done);
1506 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
1511 mwifiex_uninit_sw(adapter);
1512 adapter->is_up = false;
1514 if (adapter->if_ops.down_dev)
1515 adapter->if_ops.down_dev(adapter);
1521 /* This function can be used for reinitting the adapter SW. Required
1525 mwifiex_reinit_sw(struct mwifiex_adapter *adapter)
1529 mwifiex_init_lock_list(adapter);
1530 if (adapter->if_ops.up_dev)
1531 adapter->if_ops.up_dev(adapter);
1533 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
1534 clear_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags);
1535 clear_bit(MWIFIEX_IS_SUSPENDED, &adapter->work_flags);
1536 adapter->hs_activated = false;
1537 clear_bit(MWIFIEX_IS_CMD_TIMEDOUT, &adapter->work_flags);
1538 init_waitqueue_head(&adapter->hs_activate_wait_q);
1539 init_waitqueue_head(&adapter->cmd_wait_q.wait);
1540 adapter->cmd_wait_q.status = 0;
1541 adapter->scan_wait_q_woken = false;
1543 if ((num_possible_cpus() > 1) || adapter->iface_type == MWIFIEX_USB)
1544 adapter->rx_work_enabled = true;
1546 adapter->workqueue =
1549 if (!adapter->workqueue)
1552 INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
1554 if (adapter->rx_work_enabled) {
1555 adapter->rx_workqueue = alloc_workqueue("MWIFIEX_RX_WORK_QUEUE",
1559 if (!adapter->rx_workqueue)
1561 INIT_WORK(&adapter->rx_work, mwifiex_rx_work_queue);
1564 if (adapter->host_mlme_enabled) {
1565 adapter->host_mlme_workqueue =
1570 if (!adapter->host_mlme_workqueue)
1572 INIT_WORK(&adapter->host_mlme_work,
1580 mwifiex_dbg(adapter, INFO, "%s, mwifiex_init_hw_fw()...\n", __func__);
1582 if (mwifiex_init_hw_fw(adapter, false)) {
1583 mwifiex_dbg(adapter, ERROR,
1589 ret = _mwifiex_fw_dpc(adapter->firmware, adapter);
1591 pr_err("Failed to bring up adapter: %d\n", ret);
1594 mwifiex_dbg(adapter, INFO, "%s, successful\n", __func__);
1599 mwifiex_dbg(adapter, ERROR, "info: %s: unregister device\n", __func__);
1600 if (adapter->if_ops.unregister_dev)
1601 adapter->if_ops.unregister_dev(adapter);
1604 set_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags);
1605 mwifiex_terminate_workqueue(adapter);
1606 if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) {
1607 mwifiex_dbg(adapter, ERROR,
1609 mwifiex_shutdown_drv(adapter);
1610 mwifiex_free_cmd_buffers(adapter);
1613 complete_all(adapter->fw_done);
1614 mwifiex_dbg(adapter, INFO, "%s, error\n", __func__);
1622 struct mwifiex_adapter *adapter = priv;
1624 dev_dbg(adapter->dev, "%s: wake by wifi", __func__);
1625 adapter->wake_by_wifi = true;
1629 pm_wakeup_event(adapter->dev, 0);
1635 static void mwifiex_probe_of(struct mwifiex_adapter *adapter)
1638 struct device *dev = adapter->dev;
1643 adapter->dt_node = dev->of_node;
1644 adapter->irq_wakeup = irq_of_parse_and_map(adapter->dt_node, 0);
1645 if (!adapter->irq_wakeup) {
1650 ret = devm_request_irq(dev, adapter->irq_wakeup,
1653 "wifi_wake", adapter);
1656 adapter->irq_wakeup, ret);
1667 adapter->irq_wakeup = -1;
1676 * adapter structure
1688 struct mwifiex_adapter *adapter;
1690 if (mwifiex_register(card, dev, if_ops, (void **)&adapter)) {
1695 mwifiex_probe_of(adapter);
1697 adapter->iface_type = iface_type;
1698 adapter->fw_done = fw_done;
1700 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
1701 clear_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags);
1702 clear_bit(MWIFIEX_IS_SUSPENDED, &adapter->work_flags);
1703 adapter->hs_activated = false;
1704 init_waitqueue_head(&adapter->hs_activate_wait_q);
1705 init_waitqueue_head(&adapter->cmd_wait_q.wait);
1706 adapter->cmd_wait_q.status = 0;
1707 adapter->scan_wait_q_woken = false;
1709 if ((num_possible_cpus() > 1) || adapter->iface_type == MWIFIEX_USB)
1710 adapter->rx_work_enabled = true;
1712 adapter->workqueue =
1715 if (!adapter->workqueue)
1718 INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
1720 if (adapter->rx_work_enabled) {
1721 adapter->rx_workqueue = alloc_workqueue("MWIFIEX_RX_WORK_QUEUE",
1725 if (!adapter->rx_workqueue)
1728 INIT_WORK(&adapter->rx_work, mwifiex_rx_work_queue);
1733 if (adapter->if_ops.register_dev(adapter)) {
1738 if (adapter->host_mlme_enabled) {
1739 adapter->host_mlme_workqueue =
1744 if (!adapter->host_mlme_workqueue)
1746 INIT_WORK(&adapter->host_mlme_work,
1750 if (mwifiex_init_hw_fw(adapter, true)) {
1759 if (adapter->if_ops.unregister_dev)
1760 adapter->if_ops.unregister_dev(adapter);
1762 set_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags);
1763 mwifiex_terminate_workqueue(adapter);
1764 if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) {
1766 mwifiex_shutdown_drv(adapter);
1767 mwifiex_free_cmd_buffers(adapter);
1770 if (adapter->irq_wakeup >= 0)
1771 device_init_wakeup(adapter->dev, false);
1772 mwifiex_free_adapter(adapter);
1789 * - Free the adapter structure
1791 int mwifiex_remove_card(struct mwifiex_adapter *adapter)
1793 if (!adapter)
1796 if (adapter->is_up)
1797 mwifiex_uninit_sw(adapter);
1799 if (adapter->irq_wakeup >= 0)
1800 device_init_wakeup(adapter->dev, false);
1803 mwifiex_dbg(adapter, INFO,
1805 if (adapter->if_ops.unregister_dev)
1806 adapter->if_ops.unregister_dev(adapter);
1807 /* Free adapter structure */
1808 mwifiex_dbg(adapter, INFO,
1809 "info: free adapter\n");
1810 mwifiex_free_adapter(adapter);
1816 void _mwifiex_dbg(const struct mwifiex_adapter *adapter, int mask,
1822 if (!(adapter->debug_mask & mask))
1830 if (adapter->dev)
1831 dev_info(adapter->dev, "%pV", &vaf);