Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
main.c
Go to the documentation of this file.
1 /*
2  * Marvell Wireless LAN device driver: major functions
3  *
4  * Copyright (C) 2011, Marvell International Ltd.
5  *
6  * This software file (the "File") is distributed by Marvell International
7  * Ltd. under the terms of the GNU General Public License Version 2, June 1991
8  * (the "License"). You may use, redistribute and/or modify this File in
9  * accordance with the terms and conditions of the License, a copy of which
10  * is available by writing to the Free Software Foundation, Inc.,
11  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
12  * worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
13  *
14  * THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
16  * ARE EXPRESSLY DISCLAIMED. The License provides additional details about
17  * this warranty disclaimer.
18  */
19 
20 #include "main.h"
21 #include "wmm.h"
22 #include "cfg80211.h"
23 #include "11n.h"
24 
25 #define VERSION "1.0"
26 
27 const char driver_version[] = "mwifiex " VERSION " (%s) ";
28 
29 /*
30  * This function registers the device and performs all the necessary
31  * initializations.
32  *
33  * The following initialization operations are performed -
34  * - Allocate adapter structure
35  * - Save interface specific operations table in adapter
36  * - Call interface specific initialization routine
37  * - Allocate private structures
38  * - Set default adapter structure parameters
39  * - Initialize locks
40  *
41  * In case of any errors during inittialization, this function also ensures
42  * proper cleanup before exiting.
43  */
44 static int mwifiex_register(void *card, struct mwifiex_if_ops *if_ops,
45  void **padapter)
46 {
47  struct mwifiex_adapter *adapter;
48  int i;
49 
50  adapter = kzalloc(sizeof(struct mwifiex_adapter), GFP_KERNEL);
51  if (!adapter)
52  return -ENOMEM;
53 
54  *padapter = adapter;
55  adapter->card = card;
56 
57  /* Save interface specific operations in adapter */
58  memmove(&adapter->if_ops, if_ops, sizeof(struct mwifiex_if_ops));
59 
60  /* card specific initialization has been deferred until now .. */
61  if (adapter->if_ops.init_if)
62  if (adapter->if_ops.init_if(adapter))
63  goto error;
64 
65  adapter->priv_num = 0;
66 
67  for (i = 0; i < MWIFIEX_MAX_BSS_NUM; i++) {
68  /* Allocate memory for private structure */
69  adapter->priv[i] =
70  kzalloc(sizeof(struct mwifiex_private), GFP_KERNEL);
71  if (!adapter->priv[i])
72  goto error;
73 
74  adapter->priv[i]->adapter = adapter;
75  adapter->priv_num++;
76  }
77  mwifiex_init_lock_list(adapter);
78 
79  init_timer(&adapter->cmd_timer);
80  adapter->cmd_timer.function = mwifiex_cmd_timeout_func;
81  adapter->cmd_timer.data = (unsigned long) adapter;
82 
83  return 0;
84 
85 error:
86  dev_dbg(adapter->dev, "info: leave mwifiex_register with error\n");
87 
88  for (i = 0; i < adapter->priv_num; i++)
89  kfree(adapter->priv[i]);
90 
91  kfree(adapter);
92 
93  return -1;
94 }
95 
96 /*
97  * This function unregisters the device and performs all the necessary
98  * cleanups.
99  *
100  * The following cleanup operations are performed -
101  * - Free the timers
102  * - Free beacon buffers
103  * - Free private structures
104  * - Free adapter structure
105  */
106 static int mwifiex_unregister(struct mwifiex_adapter *adapter)
107 {
108  s32 i;
109 
110  del_timer(&adapter->cmd_timer);
111 
112  /* Free private structures */
113  for (i = 0; i < adapter->priv_num; i++) {
114  if (adapter->priv[i]) {
115  mwifiex_free_curr_bcn(adapter->priv[i]);
116  kfree(adapter->priv[i]);
117  }
118  }
119 
120  kfree(adapter);
121  return 0;
122 }
123 
124 /*
125  * The main process.
126  *
127  * This function is the main procedure of the driver and handles various driver
128  * operations. It runs in a loop and provides the core functionalities.
129  *
130  * The main responsibilities of this function are -
131  * - Ensure concurrency control
132  * - Handle pending interrupts and call interrupt handlers
133  * - Wake up the card if required
134  * - Handle command responses and call response handlers
135  * - Handle events and call event handlers
136  * - Execute pending commands
137  * - Transmit pending data packets
138  */
140 {
141  int ret = 0;
142  unsigned long flags;
143  struct sk_buff *skb;
144 
145  spin_lock_irqsave(&adapter->main_proc_lock, flags);
146 
147  /* Check if already processing */
148  if (adapter->mwifiex_processing) {
149  spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
150  goto exit_main_proc;
151  } else {
152  adapter->mwifiex_processing = true;
153  spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
154  }
155 process_start:
156  do {
157  if ((adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING) ||
159  break;
160 
161  /* Handle pending interrupt if any */
162  if (adapter->int_status) {
163  if (adapter->hs_activated)
164  mwifiex_process_hs_config(adapter);
165  if (adapter->if_ops.process_int_status)
166  adapter->if_ops.process_int_status(adapter);
167  }
168 
169  /* Need to wake up the card ? */
170  if ((adapter->ps_state == PS_STATE_SLEEP) &&
171  (adapter->pm_wakeup_card_req &&
172  !adapter->pm_wakeup_fw_try) &&
173  (is_command_pending(adapter) ||
174  !mwifiex_wmm_lists_empty(adapter))) {
175  adapter->pm_wakeup_fw_try = true;
176  adapter->if_ops.wakeup(adapter);
177  continue;
178  }
179 
180  if (IS_CARD_RX_RCVD(adapter)) {
181  adapter->pm_wakeup_fw_try = false;
182  if (adapter->ps_state == PS_STATE_SLEEP)
183  adapter->ps_state = PS_STATE_AWAKE;
184  } else {
185  /* We have tried to wakeup the card already */
186  if (adapter->pm_wakeup_fw_try)
187  break;
188  if (adapter->ps_state != PS_STATE_AWAKE ||
189  adapter->tx_lock_flag)
190  break;
191 
192  if ((adapter->scan_processing &&
193  !adapter->scan_delay_cnt) || adapter->data_sent ||
194  mwifiex_wmm_lists_empty(adapter)) {
195  if (adapter->cmd_sent || adapter->curr_cmd ||
196  (!is_command_pending(adapter)))
197  break;
198  }
199  }
200 
201  /* Check Rx data for USB */
202  if (adapter->iface_type == MWIFIEX_USB)
203  while ((skb = skb_dequeue(&adapter->usb_rx_data_q)))
204  mwifiex_handle_rx_packet(adapter, skb);
205 
206  /* Check for Cmd Resp */
207  if (adapter->cmd_resp_received) {
208  adapter->cmd_resp_received = false;
209  mwifiex_process_cmdresp(adapter);
210 
211  /* call mwifiex back when init_fw is done */
212  if (adapter->hw_status == MWIFIEX_HW_STATUS_INIT_DONE) {
214  mwifiex_init_fw_complete(adapter);
215  }
216  }
217 
218  /* Check for event */
219  if (adapter->event_received) {
220  adapter->event_received = false;
221  mwifiex_process_event(adapter);
222  }
223 
224  /* Check if we need to confirm Sleep Request
225  received previously */
226  if (adapter->ps_state == PS_STATE_PRE_SLEEP) {
227  if (!adapter->cmd_sent && !adapter->curr_cmd)
228  mwifiex_check_ps_cond(adapter);
229  }
230 
231  /* * The ps_state may have been changed during processing of
232  * Sleep Request event.
233  */
234  if ((adapter->ps_state == PS_STATE_SLEEP) ||
235  (adapter->ps_state == PS_STATE_PRE_SLEEP) ||
236  (adapter->ps_state == PS_STATE_SLEEP_CFM) ||
237  adapter->tx_lock_flag)
238  continue;
239 
240  if (!adapter->cmd_sent && !adapter->curr_cmd) {
241  if (mwifiex_exec_next_cmd(adapter) == -1) {
242  ret = -1;
243  break;
244  }
245  }
246 
247  if ((!adapter->scan_processing || adapter->scan_delay_cnt) &&
248  !adapter->data_sent && !mwifiex_wmm_lists_empty(adapter)) {
249  mwifiex_wmm_process_tx(adapter);
250  if (adapter->hs_activated) {
251  adapter->is_hs_configured = false;
253  (mwifiex_get_priv
254  (adapter, MWIFIEX_BSS_ROLE_ANY),
255  false);
256  }
257  }
258 
259  if (adapter->delay_null_pkt && !adapter->cmd_sent &&
260  !adapter->curr_cmd && !is_command_pending(adapter) &&
261  mwifiex_wmm_lists_empty(adapter)) {
263  (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
266  adapter->delay_null_pkt = false;
267  adapter->ps_state = PS_STATE_SLEEP;
268  }
269  break;
270  }
271  } while (true);
272 
273  if ((adapter->int_status) || IS_CARD_RX_RCVD(adapter))
274  goto process_start;
275 
276  spin_lock_irqsave(&adapter->main_proc_lock, flags);
277  adapter->mwifiex_processing = false;
278  spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
279 
280 exit_main_proc:
281  if (adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING)
282  mwifiex_shutdown_drv(adapter);
283  return ret;
284 }
285 
286 /*
287  * This function frees the adapter structure.
288  *
289  * Additionally, this closes the netlink socket, frees the timers
290  * and private structures.
291  */
292 static void mwifiex_free_adapter(struct mwifiex_adapter *adapter)
293 {
294  if (!adapter) {
295  pr_err("%s: adapter is NULL\n", __func__);
296  return;
297  }
298 
299  mwifiex_unregister(adapter);
300  pr_debug("info: %s: free adapter\n", __func__);
301 }
302 
303 /*
304  * This function gets firmware and initializes it.
305  *
306  * The main initialization steps followed are -
307  * - Download the correct firmware to card
308  * - Issue the init commands to firmware
309  */
310 static void mwifiex_fw_dpc(const struct firmware *firmware, void *context)
311 {
312  int ret;
313  char fmt[64];
314  struct mwifiex_private *priv;
315  struct mwifiex_adapter *adapter = context;
316  struct mwifiex_fw_image fw;
317 
318  if (!firmware) {
319  dev_err(adapter->dev,
320  "Failed to get firmware %s\n", adapter->fw_name);
321  goto done;
322  }
323 
324  memset(&fw, 0, sizeof(struct mwifiex_fw_image));
325  adapter->firmware = firmware;
326  fw.fw_buf = (u8 *) adapter->firmware->data;
327  fw.fw_len = adapter->firmware->size;
328 
329  if (adapter->if_ops.dnld_fw)
330  ret = adapter->if_ops.dnld_fw(adapter, &fw);
331  else
332  ret = mwifiex_dnld_fw(adapter, &fw);
333  if (ret == -1)
334  goto done;
335 
336  dev_notice(adapter->dev, "WLAN FW is active\n");
337 
338  adapter->init_wait_q_woken = false;
339  ret = mwifiex_init_fw(adapter);
340  if (ret == -1) {
341  goto done;
342  } else if (!ret) {
344  goto done;
345  }
346  /* Wait for mwifiex_init to complete */
348  adapter->init_wait_q_woken);
349  if (adapter->hw_status != MWIFIEX_HW_STATUS_READY)
350  goto done;
351 
352  priv = adapter->priv[MWIFIEX_BSS_ROLE_STA];
353  if (mwifiex_register_cfg80211(adapter)) {
354  dev_err(adapter->dev, "cannot register with cfg80211\n");
355  goto err_init_fw;
356  }
357 
358  rtnl_lock();
359  /* Create station interface by default */
360  if (!mwifiex_add_virtual_intf(adapter->wiphy, "mlan%d",
362  dev_err(adapter->dev, "cannot create default STA interface\n");
363  goto err_add_intf;
364  }
365 
366  /* Create AP interface by default */
367  if (!mwifiex_add_virtual_intf(adapter->wiphy, "uap%d",
369  dev_err(adapter->dev, "cannot create default AP interface\n");
370  goto err_add_intf;
371  }
372 
373  /* Create P2P interface by default */
374  if (!mwifiex_add_virtual_intf(adapter->wiphy, "p2p%d",
376  dev_err(adapter->dev, "cannot create default P2P interface\n");
377  goto err_add_intf;
378  }
379  rtnl_unlock();
380 
381  mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1);
382  dev_notice(adapter->dev, "driver_version = %s\n", fmt);
383  goto done;
384 
385 err_add_intf:
386  mwifiex_del_virtual_intf(adapter->wiphy, priv->wdev);
387  rtnl_unlock();
388 err_init_fw:
389  pr_debug("info: %s: unregister device\n", __func__);
390  adapter->if_ops.unregister_dev(adapter);
391 done:
392  release_firmware(adapter->firmware);
393  complete(&adapter->fw_load);
394  return;
395 }
396 
397 /*
398  * This function initializes the hardware and gets firmware.
399  */
400 static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter)
401 {
402  int ret;
403 
404  init_completion(&adapter->fw_load);
405  ret = request_firmware_nowait(THIS_MODULE, 1, adapter->fw_name,
406  adapter->dev, GFP_KERNEL, adapter,
407  mwifiex_fw_dpc);
408  if (ret < 0)
409  dev_err(adapter->dev,
410  "request_firmware_nowait() returned error %d\n", ret);
411  return ret;
412 }
413 
414 /*
415  * This function fills a driver buffer.
416  *
417  * The function associates a given SKB with the provided driver buffer
418  * and also updates some of the SKB parameters, including IP header,
419  * priority and timestamp.
420  */
421 static void
422 mwifiex_fill_buffer(struct sk_buff *skb)
423 {
424  struct ethhdr *eth;
425  struct iphdr *iph;
426  struct timeval tv;
427  u8 tid = 0;
428 
429  eth = (struct ethhdr *) skb->data;
430  switch (eth->h_proto) {
432  iph = ip_hdr(skb);
433  tid = IPTOS_PREC(iph->tos);
434  pr_debug("data: packet type ETH_P_IP: %04x, tid=%#x prio=%#x\n",
435  eth->h_proto, tid, skb->priority);
436  break;
438  pr_debug("data: ARP packet: %04x\n", eth->h_proto);
439  default:
440  break;
441  }
442 /* Offset for TOS field in the IP header */
443 #define IPTOS_OFFSET 5
444  tid = (tid >> IPTOS_OFFSET);
445  skb->priority = tid;
446  /* Record the current time the packet was queued; used to
447  determine the amount of time the packet was queued in
448  the driver before it was sent to the firmware.
449  The delay is then sent along with the packet to the
450  firmware for aggregate delay calculation for stats and
451  MSDU lifetime expiry.
452  */
453  do_gettimeofday(&tv);
454  skb->tstamp = timeval_to_ktime(tv);
455 }
456 
457 /*
458  * CFG802.11 network device handler for open.
459  *
460  * Starts the data queue.
461  */
462 static int
463 mwifiex_open(struct net_device *dev)
464 {
465  netif_tx_start_all_queues(dev);
466  return 0;
467 }
468 
469 /*
470  * CFG802.11 network device handler for close.
471  */
472 static int
473 mwifiex_close(struct net_device *dev)
474 {
475  return 0;
476 }
477 
478 /*
479  * Add buffer into wmm tx queue and queue work to transmit it.
480  */
481 int mwifiex_queue_tx_pkt(struct mwifiex_private *priv, struct sk_buff *skb)
482 {
483  mwifiex_wmm_add_buf_txqueue(priv, skb);
484  atomic_inc(&priv->adapter->tx_pending);
485 
486  if (priv->adapter->scan_delay_cnt)
487  atomic_set(&priv->adapter->is_tx_received, true);
488 
489  if (atomic_read(&priv->adapter->tx_pending) >= MAX_TX_PENDING) {
492  }
493 
494  queue_work(priv->adapter->workqueue, &priv->adapter->main_work);
495 
496  return 0;
497 }
498 
499 /*
500  * CFG802.11 network device handler for data transmission.
501  */
502 static int
503 mwifiex_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
504 {
505  struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
506  struct sk_buff *new_skb;
507  struct mwifiex_txinfo *tx_info;
508 
509  dev_dbg(priv->adapter->dev, "data: %lu BSS(%d-%d): Data <= kernel\n",
510  jiffies, priv->bss_type, priv->bss_num);
511 
512  if (priv->adapter->surprise_removed) {
513  kfree_skb(skb);
514  priv->stats.tx_dropped++;
515  return 0;
516  }
517  if (!skb->len || (skb->len > ETH_FRAME_LEN)) {
518  dev_err(priv->adapter->dev, "Tx: bad skb len %d\n", skb->len);
519  kfree_skb(skb);
520  priv->stats.tx_dropped++;
521  return 0;
522  }
523  if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN) {
524  dev_dbg(priv->adapter->dev,
525  "data: Tx: insufficient skb headroom %d\n",
526  skb_headroom(skb));
527  /* Insufficient skb headroom - allocate a new skb */
528  new_skb =
530  if (unlikely(!new_skb)) {
531  dev_err(priv->adapter->dev, "Tx: cannot alloca new_skb\n");
532  kfree_skb(skb);
533  priv->stats.tx_dropped++;
534  return 0;
535  }
536  kfree_skb(skb);
537  skb = new_skb;
538  dev_dbg(priv->adapter->dev, "info: new skb headroomd %d\n",
539  skb_headroom(skb));
540  }
541 
542  tx_info = MWIFIEX_SKB_TXCB(skb);
543  tx_info->bss_num = priv->bss_num;
544  tx_info->bss_type = priv->bss_type;
545  mwifiex_fill_buffer(skb);
546 
547  mwifiex_queue_tx_pkt(priv, skb);
548 
549  return 0;
550 }
551 
552 /*
553  * CFG802.11 network device handler for setting MAC address.
554  */
555 static int
556 mwifiex_set_mac_address(struct net_device *dev, void *addr)
557 {
558  struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
559  struct sockaddr *hw_addr = addr;
560  int ret;
561 
562  memcpy(priv->curr_addr, hw_addr->sa_data, ETH_ALEN);
563 
564  /* Send request to firmware */
567 
568  if (!ret)
569  memcpy(priv->netdev->dev_addr, priv->curr_addr, ETH_ALEN);
570  else
571  dev_err(priv->adapter->dev,
572  "set mac address failed: ret=%d\n", ret);
573 
574  memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
575 
576  return ret;
577 }
578 
579 /*
580  * CFG802.11 network device handler for setting multicast list.
581  */
582 static void mwifiex_set_multicast_list(struct net_device *dev)
583 {
584  struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
585  struct mwifiex_multicast_list mcast_list;
586 
587  if (dev->flags & IFF_PROMISC) {
588  mcast_list.mode = MWIFIEX_PROMISC_MODE;
589  } else if (dev->flags & IFF_ALLMULTI ||
591  mcast_list.mode = MWIFIEX_ALL_MULTI_MODE;
592  } else {
593  mcast_list.mode = MWIFIEX_MULTICAST_MODE;
594  if (netdev_mc_count(dev))
595  mcast_list.num_multicast_addr =
596  mwifiex_copy_mcast_addr(&mcast_list, dev);
597  }
598  mwifiex_request_set_multicast_list(priv, &mcast_list);
599 }
600 
601 /*
602  * CFG802.11 network device handler for transmission timeout.
603  */
604 static void
605 mwifiex_tx_timeout(struct net_device *dev)
606 {
607  struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
608 
609  dev_err(priv->adapter->dev, "%lu : Tx timeout, bss_type-num = %d-%d\n",
610  jiffies, priv->bss_type, priv->bss_num);
612  priv->num_tx_timeout++;
613 }
614 
615 /*
616  * CFG802.11 network device handler for statistics retrieval.
617  */
618 static struct net_device_stats *mwifiex_get_stats(struct net_device *dev)
619 {
620  struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
621 
622  return &priv->stats;
623 }
624 
625 /* Network device handlers */
626 static const struct net_device_ops mwifiex_netdev_ops = {
627  .ndo_open = mwifiex_open,
628  .ndo_stop = mwifiex_close,
629  .ndo_start_xmit = mwifiex_hard_start_xmit,
630  .ndo_set_mac_address = mwifiex_set_mac_address,
631  .ndo_tx_timeout = mwifiex_tx_timeout,
632  .ndo_get_stats = mwifiex_get_stats,
633  .ndo_set_rx_mode = mwifiex_set_multicast_list,
634 };
635 
636 /*
637  * This function initializes the private structure parameters.
638  *
639  * The following wait queues are initialized -
640  * - IOCTL wait queue
641  * - Command wait queue
642  * - Statistics wait queue
643  *
644  * ...and the following default parameters are set -
645  * - Current key index : Set to 0
646  * - Rate index : Set to auto
647  * - Media connected : Set to disconnected
648  * - Adhoc link sensed : Set to false
649  * - Nick name : Set to null
650  * - Number of Tx timeout : Set to 0
651  * - Device address : Set to current address
652  *
653  * In addition, the CFG80211 work queue is also created.
654  */
656  struct net_device *dev)
657 {
658  dev->netdev_ops = &mwifiex_netdev_ops;
659  /* Initialize private structure */
660  priv->current_key_index = 0;
661  priv->media_connected = false;
662  memset(&priv->nick_name, 0, sizeof(priv->nick_name));
663  memset(priv->mgmt_ie, 0,
664  sizeof(struct mwifiex_ie) * MAX_MGMT_IE_INDEX);
669  priv->num_tx_timeout = 0;
670  memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
671 }
672 
673 /*
674  * This function check if command is pending.
675  */
677 {
678  unsigned long flags;
679  int is_cmd_pend_q_empty;
680 
681  spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
682  is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q);
683  spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
684 
685  return !is_cmd_pend_q_empty;
686 }
687 
688 /*
689  * This is the main work queue function.
690  *
691  * It handles the main process, which in turn handles the complete
692  * driver operations.
693  */
694 static void mwifiex_main_work_queue(struct work_struct *work)
695 {
696  struct mwifiex_adapter *adapter =
697  container_of(work, struct mwifiex_adapter, main_work);
698 
699  if (adapter->surprise_removed)
700  return;
701  mwifiex_main_process(adapter);
702 }
703 
704 /*
705  * This function cancels all works in the queue and destroys
706  * the main workqueue.
707  */
708 static void
709 mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter)
710 {
711  flush_workqueue(adapter->workqueue);
712  destroy_workqueue(adapter->workqueue);
713  adapter->workqueue = NULL;
714 }
715 
716 /*
717  * This function adds the card.
718  *
719  * This function follows the following major steps to set up the device -
720  * - Initialize software. This includes probing the card, registering
721  * the interface operations table, and allocating/initializing the
722  * adapter structure
723  * - Set up the netlink socket
724  * - Create and start the main work queue
725  * - Register the device
726  * - Initialize firmware and hardware
727  * - Add logical interfaces
728  */
729 int
732 {
733  struct mwifiex_adapter *adapter;
734 
735  if (down_interruptible(sem))
736  goto exit_sem_err;
737 
738  if (mwifiex_register(card, if_ops, (void **)&adapter)) {
739  pr_err("%s: software init failed\n", __func__);
740  goto err_init_sw;
741  }
742 
743  adapter->iface_type = iface_type;
744 
746  adapter->surprise_removed = false;
747  init_waitqueue_head(&adapter->init_wait_q);
748  adapter->is_suspended = false;
749  adapter->hs_activated = false;
751  adapter->cmd_wait_q_required = false;
752  init_waitqueue_head(&adapter->cmd_wait_q.wait);
753  adapter->cmd_wait_q.status = 0;
754  adapter->scan_wait_q_woken = false;
755 
756  adapter->workqueue = create_workqueue("MWIFIEX_WORK_QUEUE");
757  if (!adapter->workqueue)
758  goto err_kmalloc;
759 
760  INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
761 
762  /* Register the device. Fill up the private data structure with relevant
763  information from the card and request for the required IRQ. */
764  if (adapter->if_ops.register_dev(adapter)) {
765  pr_err("%s: failed to register mwifiex device\n", __func__);
766  goto err_registerdev;
767  }
768 
769  if (mwifiex_init_hw_fw(adapter)) {
770  pr_err("%s: firmware init failed\n", __func__);
771  goto err_init_fw;
772  }
773 
774  up(sem);
775  return 0;
776 
777 err_init_fw:
778  pr_debug("info: %s: unregister device\n", __func__);
779  if (adapter->if_ops.unregister_dev)
780  adapter->if_ops.unregister_dev(adapter);
781 err_registerdev:
782  adapter->surprise_removed = true;
783  mwifiex_terminate_workqueue(adapter);
784 err_kmalloc:
785  if ((adapter->hw_status == MWIFIEX_HW_STATUS_FW_READY) ||
786  (adapter->hw_status == MWIFIEX_HW_STATUS_READY)) {
787  pr_debug("info: %s: shutdown mwifiex\n", __func__);
788  adapter->init_wait_q_woken = false;
789 
790  if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
792  adapter->init_wait_q_woken);
793  }
794 
795  mwifiex_free_adapter(adapter);
796 
797 err_init_sw:
798  up(sem);
799 
800 exit_sem_err:
801  return -1;
802 }
804 
805 /*
806  * This function removes the card.
807  *
808  * This function follows the following major steps to remove the device -
809  * - Stop data traffic
810  * - Shutdown firmware
811  * - Remove the logical interfaces
812  * - Terminate the work queue
813  * - Unregister the device
814  * - Free the adapter structure
815  */
816 int mwifiex_remove_card(struct mwifiex_adapter *adapter, struct semaphore *sem)
817 {
818  struct mwifiex_private *priv = NULL;
819  int i;
820 
821  if (down_interruptible(sem))
822  goto exit_sem_err;
823 
824  if (!adapter)
825  goto exit_remove;
826 
827  adapter->surprise_removed = true;
828 
829  /* Stop data */
830  for (i = 0; i < adapter->priv_num; i++) {
831  priv = adapter->priv[i];
832  if (priv && priv->netdev) {
833  if (!netif_queue_stopped(priv->netdev))
835  adapter);
836  if (netif_carrier_ok(priv->netdev))
837  netif_carrier_off(priv->netdev);
838  }
839  }
840 
841  dev_dbg(adapter->dev, "cmd: calling mwifiex_shutdown_drv...\n");
842  adapter->init_wait_q_woken = false;
843 
844  if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
846  adapter->init_wait_q_woken);
847  dev_dbg(adapter->dev, "cmd: mwifiex_shutdown_drv done\n");
848  if (atomic_read(&adapter->rx_pending) ||
849  atomic_read(&adapter->tx_pending) ||
850  atomic_read(&adapter->cmd_pending)) {
851  dev_err(adapter->dev, "rx_pending=%d, tx_pending=%d, "
852  "cmd_pending=%d\n",
853  atomic_read(&adapter->rx_pending),
854  atomic_read(&adapter->tx_pending),
855  atomic_read(&adapter->cmd_pending));
856  }
857 
858  for (i = 0; i < adapter->priv_num; i++) {
859  priv = adapter->priv[i];
860 
861  if (!priv)
862  continue;
863 
864  rtnl_lock();
865  if (priv->wdev && priv->netdev)
866  mwifiex_del_virtual_intf(adapter->wiphy, priv->wdev);
867  rtnl_unlock();
868  }
869 
870  priv = adapter->priv[0];
871  if (!priv || !priv->wdev)
872  goto exit_remove;
873 
874  wiphy_unregister(priv->wdev->wiphy);
875  wiphy_free(priv->wdev->wiphy);
876 
877  for (i = 0; i < adapter->priv_num; i++) {
878  priv = adapter->priv[i];
879  if (priv)
880  kfree(priv->wdev);
881  }
882 
883  mwifiex_terminate_workqueue(adapter);
884 
885  /* Unregister device */
886  dev_dbg(adapter->dev, "info: unregister device\n");
887  if (adapter->if_ops.unregister_dev)
888  adapter->if_ops.unregister_dev(adapter);
889  /* Free adapter structure */
890  dev_dbg(adapter->dev, "info: free adapter\n");
891  mwifiex_free_adapter(adapter);
892 
893 exit_remove:
894  up(sem);
895 exit_sem_err:
896  return 0;
897 }
899 
900 /*
901  * This function initializes the module.
902  *
903  * The debug FS is also initialized if configured.
904  */
905 static int
906 mwifiex_init_module(void)
907 {
908 #ifdef CONFIG_DEBUG_FS
910 #endif
911  return 0;
912 }
913 
914 /*
915  * This function cleans up the module.
916  *
917  * The debug FS is removed if available.
918  */
919 static void
920 mwifiex_cleanup_module(void)
921 {
922 #ifdef CONFIG_DEBUG_FS
924 #endif
925 }
926 
927 module_init(mwifiex_init_module);
928 module_exit(mwifiex_cleanup_module);
929 
930 MODULE_AUTHOR("Marvell International Ltd.");
931 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION);
933 MODULE_LICENSE("GPL v2");