Lines Matching refs:adapter
58 * - Allocate adapter structure
59 * - Save interface specific operations table in adapter
62 * - Set default adapter structure parameters
71 struct mwifiex_adapter *adapter;
74 adapter = kzalloc(sizeof(struct mwifiex_adapter), GFP_KERNEL);
75 if (!adapter)
78 *padapter = adapter;
79 adapter->dev = dev;
80 adapter->card = card;
82 /* Save interface specific operations in adapter */
83 memmove(&adapter->if_ops, if_ops, sizeof(struct mwifiex_if_ops));
84 adapter->debug_mask = debug_mask;
87 if (adapter->if_ops.init_if)
88 if (adapter->if_ops.init_if(adapter))
91 adapter->priv_num = 0;
95 adapter->priv[i] =
97 if (!adapter->priv[i])
100 adapter->priv[i]->adapter = adapter;
101 adapter->priv_num++;
103 mwifiex_init_lock_list(adapter);
105 timer_setup(&adapter->cmd_timer, mwifiex_cmd_timeout_func, 0);
110 mwifiex_dbg(adapter, ERROR,
113 for (i = 0; i < adapter->priv_num; i++)
114 kfree(adapter->priv[i]);
116 kfree(adapter);
129 * - Free adapter structure
131 static int mwifiex_unregister(struct mwifiex_adapter *adapter)
135 if (adapter->if_ops.cleanup_if)
136 adapter->if_ops.cleanup_if(adapter);
138 del_timer_sync(&adapter->cmd_timer);
141 for (i = 0; i < adapter->priv_num; i++) {
142 if (adapter->priv[i]) {
143 mwifiex_free_curr_bcn(adapter->priv[i]);
144 kfree(adapter->priv[i]);
148 if (adapter->nd_info) {
149 for (i = 0 ; i < adapter->nd_info->n_matches ; i++)
150 kfree(adapter->nd_info->matches[i]);
151 kfree(adapter->nd_info);
152 adapter->nd_info = NULL;
155 kfree(adapter->regd);
157 kfree(adapter);
161 void mwifiex_queue_main_work(struct mwifiex_adapter *adapter)
165 spin_lock_irqsave(&adapter->main_proc_lock, flags);
166 if (adapter->mwifiex_processing) {
167 adapter->more_task_flag = true;
168 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
170 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
171 queue_work(adapter->workqueue, &adapter->main_work);
176 static void mwifiex_queue_rx_work(struct mwifiex_adapter *adapter)
178 spin_lock_bh(&adapter->rx_proc_lock);
179 if (adapter->rx_processing) {
180 spin_unlock_bh(&adapter->rx_proc_lock);
182 spin_unlock_bh(&adapter->rx_proc_lock);
183 queue_work(adapter->rx_workqueue, &adapter->rx_work);
187 static int mwifiex_process_rx(struct mwifiex_adapter *adapter)
192 spin_lock_bh(&adapter->rx_proc_lock);
193 if (adapter->rx_processing || adapter->rx_locked) {
194 spin_unlock_bh(&adapter->rx_proc_lock);
197 adapter->rx_processing = true;
198 spin_unlock_bh(&adapter->rx_proc_lock);
202 while ((skb = skb_dequeue(&adapter->rx_data_q))) {
203 atomic_dec(&adapter->rx_pending);
204 if ((adapter->delay_main_work ||
205 adapter->iface_type == MWIFIEX_USB) &&
206 (atomic_read(&adapter->rx_pending) < LOW_RX_PENDING)) {
207 if (adapter->if_ops.submit_rem_rx_urbs)
208 adapter->if_ops.submit_rem_rx_urbs(adapter);
209 adapter->delay_main_work = false;
210 mwifiex_queue_main_work(adapter);
214 if (adapter->if_ops.deaggr_pkt)
215 adapter->if_ops.deaggr_pkt(adapter, skb);
218 mwifiex_handle_rx_packet(adapter, skb);
221 spin_lock_bh(&adapter->rx_proc_lock);
222 adapter->rx_processing = false;
223 spin_unlock_bh(&adapter->rx_proc_lock);
244 int mwifiex_main_process(struct mwifiex_adapter *adapter)
249 spin_lock_irqsave(&adapter->main_proc_lock, flags);
252 if (adapter->mwifiex_processing || adapter->main_locked) {
253 adapter->more_task_flag = true;
254 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
257 adapter->mwifiex_processing = true;
258 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
262 if (adapter->hw_status == MWIFIEX_HW_STATUS_NOT_READY)
272 if (atomic_read(&adapter->rx_pending) >= HIGH_RX_PENDING &&
273 adapter->iface_type != MWIFIEX_USB) {
274 adapter->delay_main_work = true;
275 mwifiex_queue_rx_work(adapter);
280 if (adapter->int_status) {
281 if (adapter->hs_activated)
282 mwifiex_process_hs_config(adapter);
283 if (adapter->if_ops.process_int_status)
284 adapter->if_ops.process_int_status(adapter);
287 if (adapter->rx_work_enabled && adapter->data_received)
288 mwifiex_queue_rx_work(adapter);
291 if ((adapter->ps_state == PS_STATE_SLEEP) &&
292 (adapter->pm_wakeup_card_req &&
293 !adapter->pm_wakeup_fw_try) &&
294 (is_command_pending(adapter) ||
295 !skb_queue_empty(&adapter->tx_data_q) ||
296 !mwifiex_bypass_txlist_empty(adapter) ||
297 !mwifiex_wmm_lists_empty(adapter))) {
298 adapter->pm_wakeup_fw_try = true;
299 mod_timer(&adapter->wakeup_timer, jiffies + (HZ*3));
300 adapter->if_ops.wakeup(adapter);
304 if (IS_CARD_RX_RCVD(adapter)) {
305 adapter->data_received = false;
306 adapter->pm_wakeup_fw_try = false;
307 del_timer(&adapter->wakeup_timer);
308 if (adapter->ps_state == PS_STATE_SLEEP)
309 adapter->ps_state = PS_STATE_AWAKE;
312 if (adapter->pm_wakeup_fw_try)
314 if (adapter->ps_state == PS_STATE_PRE_SLEEP)
315 mwifiex_check_ps_cond(adapter);
317 if (adapter->ps_state != PS_STATE_AWAKE)
319 if (adapter->tx_lock_flag) {
320 if (adapter->iface_type == MWIFIEX_USB) {
321 if (!adapter->usb_mc_setup)
327 if ((!adapter->scan_chan_gap_enabled &&
328 adapter->scan_processing) || adapter->data_sent ||
330 (mwifiex_get_priv(adapter,
332 (mwifiex_wmm_lists_empty(adapter) &&
333 mwifiex_bypass_txlist_empty(adapter) &&
334 skb_queue_empty(&adapter->tx_data_q))) {
335 if (adapter->cmd_sent || adapter->curr_cmd ||
337 (mwifiex_get_priv(adapter,
339 (!is_command_pending(adapter)))
345 if (adapter->event_received) {
346 adapter->event_received = false;
347 mwifiex_process_event(adapter);
351 if (adapter->cmd_resp_received) {
352 adapter->cmd_resp_received = false;
353 mwifiex_process_cmdresp(adapter);
356 if (adapter->hw_status == MWIFIEX_HW_STATUS_INIT_DONE) {
357 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
358 mwifiex_init_fw_complete(adapter);
364 if (adapter->ps_state == PS_STATE_PRE_SLEEP)
365 mwifiex_check_ps_cond(adapter);
370 if ((adapter->ps_state == PS_STATE_SLEEP) ||
371 (adapter->ps_state == PS_STATE_PRE_SLEEP) ||
372 (adapter->ps_state == PS_STATE_SLEEP_CFM)) {
376 if (adapter->tx_lock_flag) {
377 if (adapter->iface_type == MWIFIEX_USB) {
378 if (!adapter->usb_mc_setup)
384 if (!adapter->cmd_sent && !adapter->curr_cmd &&
386 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA))) {
387 if (mwifiex_exec_next_cmd(adapter) == -1) {
396 if (adapter->iface_type == MWIFIEX_USB &&
397 adapter->usb_mc_setup)
400 if ((adapter->scan_chan_gap_enabled ||
401 !adapter->scan_processing) &&
402 !adapter->data_sent &&
403 !skb_queue_empty(&adapter->tx_data_q)) {
404 mwifiex_process_tx_queue(adapter);
405 if (adapter->hs_activated) {
407 &adapter->work_flags);
410 (adapter, MWIFIEX_BSS_ROLE_ANY),
415 if ((adapter->scan_chan_gap_enabled ||
416 !adapter->scan_processing) &&
417 !adapter->data_sent &&
418 !mwifiex_bypass_txlist_empty(adapter) &&
420 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA))) {
421 mwifiex_process_bypass_tx(adapter);
422 if (adapter->hs_activated) {
424 &adapter->work_flags);
427 (adapter, MWIFIEX_BSS_ROLE_ANY),
432 if ((adapter->scan_chan_gap_enabled ||
433 !adapter->scan_processing) &&
434 !adapter->data_sent && !mwifiex_wmm_lists_empty(adapter) &&
436 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA))) {
437 mwifiex_wmm_process_tx(adapter);
438 if (adapter->hs_activated) {
440 &adapter->work_flags);
443 (adapter, MWIFIEX_BSS_ROLE_ANY),
448 if (adapter->delay_null_pkt && !adapter->cmd_sent &&
449 !adapter->curr_cmd && !is_command_pending(adapter) &&
450 (mwifiex_wmm_lists_empty(adapter) &&
451 mwifiex_bypass_txlist_empty(adapter) &&
452 skb_queue_empty(&adapter->tx_data_q))) {
454 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
457 adapter->delay_null_pkt = false;
458 adapter->ps_state = PS_STATE_SLEEP;
464 spin_lock_irqsave(&adapter->main_proc_lock, flags);
465 if (adapter->more_task_flag) {
466 adapter->more_task_flag = false;
467 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
470 adapter->mwifiex_processing = false;
471 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
478 * This function frees the adapter structure.
483 static void mwifiex_free_adapter(struct mwifiex_adapter *adapter)
485 if (!adapter) {
486 pr_err("%s: adapter is NULL\n", __func__);
490 mwifiex_unregister(adapter);
491 pr_debug("info: %s: free adapter\n", __func__);
498 static void mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter)
500 if (adapter->workqueue) {
501 flush_workqueue(adapter->workqueue);
502 destroy_workqueue(adapter->workqueue);
503 adapter->workqueue = NULL;
506 if (adapter->rx_workqueue) {
507 flush_workqueue(adapter->rx_workqueue);
508 destroy_workqueue(adapter->rx_workqueue);
509 adapter->rx_workqueue = NULL;
524 struct mwifiex_adapter *adapter = context;
528 struct completion *fw_done = adapter->fw_done;
531 mwifiex_dbg(adapter, ERROR,
532 "Failed to get firmware %s\n", adapter->fw_name);
537 adapter->firmware = firmware;
538 fw.fw_buf = (u8 *) adapter->firmware->data;
539 fw.fw_len = adapter->firmware->size;
541 if (adapter->if_ops.dnld_fw) {
542 ret = adapter->if_ops.dnld_fw(adapter, &fw);
544 ret = mwifiex_dnld_fw(adapter, &fw);
550 mwifiex_dbg(adapter, MSG, "WLAN FW is active\n");
553 if ((request_firmware(&adapter->cal_data, cal_data_cfg,
554 adapter->dev)) < 0)
555 mwifiex_dbg(adapter, ERROR,
560 if (adapter->if_ops.enable_int) {
561 if (adapter->if_ops.enable_int(adapter))
565 adapter->init_wait_q_woken = false;
566 ret = mwifiex_init_fw(adapter);
570 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
574 if (!adapter->mfg_mode) {
575 wait_event_interruptible(adapter->init_wait_q,
576 adapter->init_wait_q_woken);
577 if (adapter->hw_status != MWIFIEX_HW_STATUS_READY)
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,
602 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "mlan%d", NET_NAME_ENUM,
605 mwifiex_dbg(adapter, ERROR,
612 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "uap%d", NET_NAME_ENUM,
615 mwifiex_dbg(adapter, ERROR,
623 wdev = mwifiex_add_virtual_intf(adapter->wiphy, "p2p%d", NET_NAME_ENUM,
626 mwifiex_dbg(adapter, ERROR,
634 mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1);
635 mwifiex_dbg(adapter, MSG, "driver_version = %s\n", fmt);
636 adapter->is_up = true;
640 vfree(adapter->chan_stats);
642 wiphy_unregister(adapter->wiphy);
643 wiphy_free(adapter->wiphy);
645 if (adapter->if_ops.disable_int)
646 adapter->if_ops.disable_int(adapter);
648 mwifiex_dbg(adapter, ERROR,
650 if (adapter->if_ops.unregister_dev)
651 adapter->if_ops.unregister_dev(adapter);
653 set_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags);
654 mwifiex_terminate_workqueue(adapter);
656 if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) {
658 mwifiex_shutdown_drv(adapter);
659 mwifiex_free_cmd_buffers(adapter);
664 if (adapter->cal_data) {
665 release_firmware(adapter->cal_data);
666 adapter->cal_data = NULL;
668 if (adapter->firmware) {
669 release_firmware(adapter->firmware);
670 adapter->firmware = NULL;
673 if (adapter->irq_wakeup >= 0)
674 device_init_wakeup(adapter->dev, false);
675 mwifiex_free_adapter(adapter);
692 static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter,
701 if (strlcpy(adapter->fw_name, MFG_FIRMWARE,
702 sizeof(adapter->fw_name)) >=
703 sizeof(adapter->fw_name)) {
710 ret = request_firmware_nowait(THIS_MODULE, 1, adapter->fw_name,
711 adapter->dev, GFP_KERNEL, adapter,
714 ret = request_firmware(&adapter->firmware,
715 adapter->fw_name,
716 adapter->dev);
720 mwifiex_dbg(adapter, ERROR, "request_firmware%s error %d\n",
751 mwifiex_dbg(priv->adapter, INFO,
759 mwifiex_dbg(priv->adapter, INFO,
777 ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) &&
779 mwifiex_dbg(priv->adapter, DATA,
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,
918 priv->adapter->fw_api_ver == MWIFIEX_FW_V15))
932 if (ISSUPP_TDLS_ENABLED(priv->adapter->fw_cap_info) &&
935 if (priv->adapter->auto_tdls && priv->check_tdls_tx)
965 } else if (priv->adapter->priv[0] != priv) {
980 mwifiex_dbg(priv->adapter, ERROR,
1031 mwifiex_dbg(priv->adapter, ERROR,
1038 priv->adapter->if_ops.card_reset) {
1039 mwifiex_dbg(priv->adapter, ERROR,
1042 priv->adapter->if_ops.card_reset(priv->adapter);
1046 void mwifiex_multi_chan_resync(struct mwifiex_adapter *adapter)
1048 struct usb_card_rec *card = adapter->card;
1056 mwifiex_dbg(adapter, WARN, "pending data urb in sys\n");
1063 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
1067 mwifiex_dbg(adapter, ERROR,
1072 void mwifiex_upload_device_dump(struct mwifiex_adapter *adapter)
1077 mwifiex_dbg(adapter, MSG,
1079 dev_coredumpv(adapter->dev, adapter->devdump_data, adapter->devdump_len,
1081 mwifiex_dbg(adapter, MSG,
1085 * after 5 min. Here reset adapter->devdump_data and ->devdump_len
1088 adapter->devdump_data = NULL;
1089 adapter->devdump_len = 0;
1093 void mwifiex_drv_info_dump(struct mwifiex_adapter *adapter)
1104 mwifiex_dbg(adapter, MSG, "===mwifiex driverinfo dump start===\n");
1106 p = adapter->devdump_data;
1111 mwifiex_drv_get_driver_version(adapter, drv_version,
1115 if (adapter->iface_type == MWIFIEX_USB) {
1116 cardp = (struct usb_card_rec *)adapter->card;
1130 atomic_read(&adapter->tx_pending));
1132 atomic_read(&adapter->rx_pending));
1134 if (adapter->iface_type == MWIFIEX_SDIO) {
1135 sdio_card = (struct sdio_mmc_card *)adapter->card;
1142 for (i = 0; i < adapter->priv_num; i++) {
1143 if (!adapter->priv[i] || !adapter->priv[i]->netdev)
1145 priv = adapter->priv[i];
1170 if (adapter->iface_type == MWIFIEX_SDIO ||
1171 adapter->iface_type == MWIFIEX_PCIE) {
1173 adapter->iface_type == MWIFIEX_SDIO ?
1175 if (adapter->if_ops.reg_dump)
1176 p += adapter->if_ops.reg_dump(adapter, p);
1181 for (i = 0; i < adapter->priv_num; i++) {
1182 if (!adapter->priv[i] || !adapter->priv[i]->netdev)
1184 priv = adapter->priv[i];
1194 mwifiex_dbg(adapter, MSG, "===mwifiex driverinfo dump end===\n");
1195 adapter->devdump_len = p - (char *)adapter->devdump_data;
1199 void mwifiex_prepare_fw_dump_info(struct mwifiex_adapter *adapter)
1205 for (idx = 0; idx < adapter->num_mem_types; idx++) {
1207 &adapter->mem_type_mapping_tbl[idx];
1218 if (dump_len + 1 + adapter->devdump_len > MWIFIEX_FW_DUMP_SIZE) {
1220 fw_dump_ptr = vzalloc(dump_len + 1 + adapter->devdump_len);
1221 mwifiex_dbg(adapter, MSG, "Realloc device dump data.\n");
1223 vfree(adapter->devdump_data);
1224 mwifiex_dbg(adapter, ERROR,
1229 memmove(fw_dump_ptr, adapter->devdump_data,
1230 adapter->devdump_len);
1231 vfree(adapter->devdump_data);
1232 adapter->devdump_data = fw_dump_ptr;
1235 fw_dump_ptr = (char *)adapter->devdump_data + adapter->devdump_len;
1237 for (idx = 0; idx < adapter->num_mem_types; idx++) {
1239 &adapter->mem_type_mapping_tbl[idx];
1259 adapter->devdump_len = fw_dump_ptr - (char *)adapter->devdump_data;
1261 for (idx = 0; idx < adapter->num_mem_types; idx++) {
1263 &adapter->mem_type_mapping_tbl[idx];
1341 ether_addr_copy(priv->curr_addr, priv->adapter->perm_addr);
1354 int is_command_pending(struct mwifiex_adapter *adapter)
1358 spin_lock_bh(&adapter->cmd_pending_q_lock);
1359 is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q);
1360 spin_unlock_bh(&adapter->cmd_pending_q_lock);
1372 struct mwifiex_adapter *adapter =
1375 if (test_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags))
1377 mwifiex_process_rx(adapter);
1388 struct mwifiex_adapter *adapter =
1391 if (test_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags))
1393 mwifiex_main_process(adapter);
1397 static void mwifiex_uninit_sw(struct mwifiex_adapter *adapter)
1405 if (adapter->if_ops.disable_int)
1406 adapter->if_ops.disable_int(adapter);
1408 set_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags);
1409 mwifiex_terminate_workqueue(adapter);
1410 adapter->int_status = 0;
1413 for (i = 0; i < adapter->priv_num; i++) {
1414 priv = adapter->priv[i];
1416 mwifiex_stop_net_dev_queue(priv->netdev, adapter);
1423 mwifiex_dbg(adapter, CMD, "cmd: calling mwifiex_shutdown_drv...\n");
1424 mwifiex_shutdown_drv(adapter);
1425 mwifiex_dbg(adapter, CMD, "cmd: mwifiex_shutdown_drv done\n");
1427 if (atomic_read(&adapter->rx_pending) ||
1428 atomic_read(&adapter->tx_pending) ||
1429 atomic_read(&adapter->cmd_pending)) {
1430 mwifiex_dbg(adapter, ERROR,
1433 atomic_read(&adapter->rx_pending),
1434 atomic_read(&adapter->tx_pending),
1435 atomic_read(&adapter->cmd_pending));
1438 for (i = 0; i < adapter->priv_num; i++) {
1439 priv = adapter->priv[i];
1445 mwifiex_del_virtual_intf(adapter->wiphy, &priv->wdev);
1449 wiphy_unregister(adapter->wiphy);
1450 wiphy_free(adapter->wiphy);
1451 adapter->wiphy = NULL;
1453 vfree(adapter->chan_stats);
1454 mwifiex_free_cmd_buffers(adapter);
1460 int mwifiex_shutdown_sw(struct mwifiex_adapter *adapter)
1464 if (!adapter)
1467 wait_for_completion(adapter->fw_done);
1469 reinit_completion(adapter->fw_done);
1471 priv = mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_ANY);
1476 mwifiex_uninit_sw(adapter);
1477 adapter->is_up = false;
1479 if (adapter->if_ops.down_dev)
1480 adapter->if_ops.down_dev(adapter);
1490 mwifiex_reinit_sw(struct mwifiex_adapter *adapter)
1494 mwifiex_init_lock_list(adapter);
1495 if (adapter->if_ops.up_dev)
1496 adapter->if_ops.up_dev(adapter);
1498 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
1499 clear_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags);
1500 init_waitqueue_head(&adapter->init_wait_q);
1501 clear_bit(MWIFIEX_IS_SUSPENDED, &adapter->work_flags);
1502 adapter->hs_activated = false;
1503 clear_bit(MWIFIEX_IS_CMD_TIMEDOUT, &adapter->work_flags);
1504 init_waitqueue_head(&adapter->hs_activate_wait_q);
1505 init_waitqueue_head(&adapter->cmd_wait_q.wait);
1506 adapter->cmd_wait_q.status = 0;
1507 adapter->scan_wait_q_woken = false;
1509 if ((num_possible_cpus() > 1) || adapter->iface_type == MWIFIEX_USB)
1510 adapter->rx_work_enabled = true;
1512 adapter->workqueue =
1515 if (!adapter->workqueue)
1518 INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
1520 if (adapter->rx_work_enabled) {
1521 adapter->rx_workqueue = alloc_workqueue("MWIFIEX_RX_WORK_QUEUE",
1525 if (!adapter->rx_workqueue)
1527 INIT_WORK(&adapter->rx_work, mwifiex_rx_work_queue);
1534 mwifiex_dbg(adapter, INFO, "%s, mwifiex_init_hw_fw()...\n", __func__);
1536 if (mwifiex_init_hw_fw(adapter, false)) {
1537 mwifiex_dbg(adapter, ERROR,
1543 ret = _mwifiex_fw_dpc(adapter->firmware, adapter);
1545 pr_err("Failed to bring up adapter: %d\n", ret);
1548 mwifiex_dbg(adapter, INFO, "%s, successful\n", __func__);
1553 mwifiex_dbg(adapter, ERROR, "info: %s: unregister device\n", __func__);
1554 if (adapter->if_ops.unregister_dev)
1555 adapter->if_ops.unregister_dev(adapter);
1558 set_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags);
1559 mwifiex_terminate_workqueue(adapter);
1560 if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) {
1561 mwifiex_dbg(adapter, ERROR,
1563 mwifiex_shutdown_drv(adapter);
1564 mwifiex_free_cmd_buffers(adapter);
1567 complete_all(adapter->fw_done);
1568 mwifiex_dbg(adapter, INFO, "%s, error\n", __func__);
1576 struct mwifiex_adapter *adapter = priv;
1578 dev_dbg(adapter->dev, "%s: wake by wifi", __func__);
1579 adapter->wake_by_wifi = true;
1583 pm_wakeup_event(adapter->dev, 0);
1589 static void mwifiex_probe_of(struct mwifiex_adapter *adapter)
1592 struct device *dev = adapter->dev;
1597 adapter->dt_node = dev->of_node;
1598 adapter->irq_wakeup = irq_of_parse_and_map(adapter->dt_node, 0);
1599 if (!adapter->irq_wakeup) {
1604 ret = devm_request_irq(dev, adapter->irq_wakeup,
1606 "wifi_wake", adapter);
1609 adapter->irq_wakeup, ret);
1613 disable_irq(adapter->irq_wakeup);
1621 adapter->irq_wakeup = -1;
1630 * adapter structure
1642 struct mwifiex_adapter *adapter;
1644 if (mwifiex_register(card, dev, if_ops, (void **)&adapter)) {
1649 mwifiex_probe_of(adapter);
1651 adapter->iface_type = iface_type;
1652 adapter->fw_done = fw_done;
1654 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
1655 clear_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags);
1656 init_waitqueue_head(&adapter->init_wait_q);
1657 clear_bit(MWIFIEX_IS_SUSPENDED, &adapter->work_flags);
1658 adapter->hs_activated = false;
1659 init_waitqueue_head(&adapter->hs_activate_wait_q);
1660 init_waitqueue_head(&adapter->cmd_wait_q.wait);
1661 adapter->cmd_wait_q.status = 0;
1662 adapter->scan_wait_q_woken = false;
1664 if ((num_possible_cpus() > 1) || adapter->iface_type == MWIFIEX_USB)
1665 adapter->rx_work_enabled = true;
1667 adapter->workqueue =
1670 if (!adapter->workqueue)
1673 INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
1675 if (adapter->rx_work_enabled) {
1676 adapter->rx_workqueue = alloc_workqueue("MWIFIEX_RX_WORK_QUEUE",
1680 if (!adapter->rx_workqueue)
1683 INIT_WORK(&adapter->rx_work, mwifiex_rx_work_queue);
1688 if (adapter->if_ops.register_dev(adapter)) {
1693 if (mwifiex_init_hw_fw(adapter, true)) {
1702 if (adapter->if_ops.unregister_dev)
1703 adapter->if_ops.unregister_dev(adapter);
1705 set_bit(MWIFIEX_SURPRISE_REMOVED, &adapter->work_flags);
1706 mwifiex_terminate_workqueue(adapter);
1707 if (adapter->hw_status == MWIFIEX_HW_STATUS_READY) {
1709 mwifiex_shutdown_drv(adapter);
1710 mwifiex_free_cmd_buffers(adapter);
1713 if (adapter->irq_wakeup >= 0)
1714 device_init_wakeup(adapter->dev, false);
1715 mwifiex_free_adapter(adapter);
1732 * - Free the adapter structure
1734 int mwifiex_remove_card(struct mwifiex_adapter *adapter)
1736 if (!adapter)
1739 if (adapter->is_up)
1740 mwifiex_uninit_sw(adapter);
1742 if (adapter->irq_wakeup >= 0)
1743 device_init_wakeup(adapter->dev, false);
1746 mwifiex_dbg(adapter, INFO,
1748 if (adapter->if_ops.unregister_dev)
1749 adapter->if_ops.unregister_dev(adapter);
1750 /* Free adapter structure */
1751 mwifiex_dbg(adapter, INFO,
1752 "info: free adapter\n");
1753 mwifiex_free_adapter(adapter);
1759 void _mwifiex_dbg(const struct mwifiex_adapter *adapter, int mask,
1765 if (!(adapter->debug_mask & mask))
1773 if (adapter->dev)
1774 dev_info(adapter->dev, "%pV", &vaf);