2 * Marvell Wireless LAN device driver: major functions
4 * Copyright (C) 2011, Marvell International Ltd.
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.
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.
27 const char driver_version[] = "mwifiex " VERSION " (%s) ";
30 * This function registers the device and performs all the necessary
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
41 * In case of any errors during inittialization, this function also ensures
42 * proper cleanup before exiting.
44 static int mwifiex_register(void *card, struct mwifiex_if_ops *if_ops,
47 struct mwifiex_adapter *adapter;
50 adapter = kzalloc(sizeof(struct mwifiex_adapter), GFP_KERNEL);
57 /* Save interface specific operations in adapter */
58 memmove(&adapter->if_ops, if_ops, sizeof(struct mwifiex_if_ops));
60 /* card specific initialization has been deferred until now .. */
61 if (adapter->if_ops.init_if(adapter))
64 adapter->priv_num = 0;
66 /* Allocate memory for private structure */
67 adapter->priv[0] = kzalloc(sizeof(struct mwifiex_private), GFP_KERNEL);
68 if (!adapter->priv[0]) {
70 "%s: failed to alloc priv[0]\n", __func__);
76 adapter->priv[0]->adapter = adapter;
77 mwifiex_init_lock_list(adapter);
79 init_timer(&adapter->cmd_timer);
80 adapter->cmd_timer.function = mwifiex_cmd_timeout_func;
81 adapter->cmd_timer.data = (unsigned long) adapter;
86 dev_dbg(adapter->dev, "info: leave mwifiex_register with error\n");
88 for (i = 0; i < adapter->priv_num; i++)
89 kfree(adapter->priv[i]);
97 * This function unregisters the device and performs all the necessary
100 * The following cleanup operations are performed -
102 * - Free beacon buffers
103 * - Free private structures
104 * - Free adapter structure
106 static int mwifiex_unregister(struct mwifiex_adapter *adapter)
110 del_timer(&adapter->cmd_timer);
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]);
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.
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
139 int mwifiex_main_process(struct mwifiex_adapter *adapter)
144 spin_lock_irqsave(&adapter->main_proc_lock, flags);
146 /* Check if already processing */
147 if (adapter->mwifiex_processing) {
148 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
151 adapter->mwifiex_processing = true;
152 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
156 if ((adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING) ||
157 (adapter->hw_status == MWIFIEX_HW_STATUS_NOT_READY))
160 /* Handle pending interrupt if any */
161 if (adapter->int_status) {
162 if (adapter->hs_activated)
163 mwifiex_process_hs_config(adapter);
164 adapter->if_ops.process_int_status(adapter);
167 /* Need to wake up the card ? */
168 if ((adapter->ps_state == PS_STATE_SLEEP) &&
169 (adapter->pm_wakeup_card_req &&
170 !adapter->pm_wakeup_fw_try) &&
171 (is_command_pending(adapter) ||
172 !mwifiex_wmm_lists_empty(adapter))) {
173 adapter->pm_wakeup_fw_try = true;
174 adapter->if_ops.wakeup(adapter);
177 if (IS_CARD_RX_RCVD(adapter)) {
178 adapter->pm_wakeup_fw_try = false;
179 if (adapter->ps_state == PS_STATE_SLEEP)
180 adapter->ps_state = PS_STATE_AWAKE;
182 /* We have tried to wakeup the card already */
183 if (adapter->pm_wakeup_fw_try)
185 if (adapter->ps_state != PS_STATE_AWAKE ||
186 adapter->tx_lock_flag)
189 if ((adapter->scan_processing &&
190 !adapter->scan_delay_cnt) || adapter->data_sent ||
191 mwifiex_wmm_lists_empty(adapter)) {
192 if (adapter->cmd_sent || adapter->curr_cmd ||
193 (!is_command_pending(adapter)))
198 /* Check for Cmd Resp */
199 if (adapter->cmd_resp_received) {
200 adapter->cmd_resp_received = false;
201 mwifiex_process_cmdresp(adapter);
203 /* call mwifiex back when init_fw is done */
204 if (adapter->hw_status == MWIFIEX_HW_STATUS_INIT_DONE) {
205 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
206 mwifiex_init_fw_complete(adapter);
210 /* Check for event */
211 if (adapter->event_received) {
212 adapter->event_received = false;
213 mwifiex_process_event(adapter);
216 /* Check if we need to confirm Sleep Request
217 received previously */
218 if (adapter->ps_state == PS_STATE_PRE_SLEEP) {
219 if (!adapter->cmd_sent && !adapter->curr_cmd)
220 mwifiex_check_ps_cond(adapter);
223 /* * The ps_state may have been changed during processing of
224 * Sleep Request event.
226 if ((adapter->ps_state == PS_STATE_SLEEP) ||
227 (adapter->ps_state == PS_STATE_PRE_SLEEP) ||
228 (adapter->ps_state == PS_STATE_SLEEP_CFM) ||
229 adapter->tx_lock_flag)
232 if (!adapter->cmd_sent && !adapter->curr_cmd) {
233 if (mwifiex_exec_next_cmd(adapter) == -1) {
239 if ((!adapter->scan_processing || adapter->scan_delay_cnt) &&
240 !adapter->data_sent && !mwifiex_wmm_lists_empty(adapter)) {
241 mwifiex_wmm_process_tx(adapter);
242 if (adapter->hs_activated) {
243 adapter->is_hs_configured = false;
244 mwifiex_hs_activated_event
246 (adapter, MWIFIEX_BSS_ROLE_ANY),
251 if (adapter->delay_null_pkt && !adapter->cmd_sent &&
252 !adapter->curr_cmd && !is_command_pending(adapter) &&
253 mwifiex_wmm_lists_empty(adapter)) {
254 if (!mwifiex_send_null_packet
255 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA),
256 MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET |
257 MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET)) {
258 adapter->delay_null_pkt = false;
259 adapter->ps_state = PS_STATE_SLEEP;
265 if ((adapter->int_status) || IS_CARD_RX_RCVD(adapter))
268 spin_lock_irqsave(&adapter->main_proc_lock, flags);
269 adapter->mwifiex_processing = false;
270 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
273 if (adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING)
274 mwifiex_shutdown_drv(adapter);
279 * This function frees the adapter structure.
281 * Additionally, this closes the netlink socket, frees the timers
282 * and private structures.
284 static void mwifiex_free_adapter(struct mwifiex_adapter *adapter)
287 pr_err("%s: adapter is NULL\n", __func__);
291 mwifiex_unregister(adapter);
292 pr_debug("info: %s: free adapter\n", __func__);
296 * This function gets firmware and initializes it.
298 * The main initialization steps followed are -
299 * - Download the correct firmware to card
300 * - Issue the init commands to firmware
302 static void mwifiex_fw_dpc(const struct firmware *firmware, void *context)
306 struct mwifiex_private *priv;
307 struct mwifiex_adapter *adapter = context;
308 struct mwifiex_fw_image fw;
311 dev_err(adapter->dev,
312 "Failed to get firmware %s\n", adapter->fw_name);
316 memset(&fw, 0, sizeof(struct mwifiex_fw_image));
317 adapter->firmware = firmware;
318 fw.fw_buf = (u8 *) adapter->firmware->data;
319 fw.fw_len = adapter->firmware->size;
321 ret = mwifiex_dnld_fw(adapter, &fw);
325 dev_notice(adapter->dev, "WLAN FW is active\n");
327 adapter->init_wait_q_woken = false;
328 ret = mwifiex_init_fw(adapter);
332 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
335 /* Wait for mwifiex_init to complete */
336 wait_event_interruptible(adapter->init_wait_q,
337 adapter->init_wait_q_woken);
338 if (adapter->hw_status != MWIFIEX_HW_STATUS_READY)
341 priv = adapter->priv[0];
342 if (mwifiex_register_cfg80211(priv) != 0) {
343 dev_err(adapter->dev, "cannot register with cfg80211\n");
348 /* Create station interface by default */
349 if (!mwifiex_add_virtual_intf(priv->wdev->wiphy, "mlan%d",
350 NL80211_IFTYPE_STATION, NULL, NULL)) {
351 dev_err(adapter->dev, "cannot create default STA interface\n");
356 mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1);
357 dev_notice(adapter->dev, "driver_version = %s\n", fmt);
361 mwifiex_del_virtual_intf(priv->wdev->wiphy, priv->netdev);
364 pr_debug("info: %s: unregister device\n", __func__);
365 adapter->if_ops.unregister_dev(adapter);
367 release_firmware(adapter->firmware);
368 complete(&adapter->fw_load);
373 * This function initializes the hardware and gets firmware.
375 static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter)
379 init_completion(&adapter->fw_load);
380 ret = request_firmware_nowait(THIS_MODULE, 1, adapter->fw_name,
381 adapter->dev, GFP_KERNEL, adapter,
384 dev_err(adapter->dev,
385 "request_firmware_nowait() returned error %d\n", ret);
390 * This function fills a driver buffer.
392 * The function associates a given SKB with the provided driver buffer
393 * and also updates some of the SKB parameters, including IP header,
394 * priority and timestamp.
397 mwifiex_fill_buffer(struct sk_buff *skb)
404 eth = (struct ethhdr *) skb->data;
405 switch (eth->h_proto) {
406 case __constant_htons(ETH_P_IP):
408 tid = IPTOS_PREC(iph->tos);
409 pr_debug("data: packet type ETH_P_IP: %04x, tid=%#x prio=%#x\n",
410 eth->h_proto, tid, skb->priority);
412 case __constant_htons(ETH_P_ARP):
413 pr_debug("data: ARP packet: %04x\n", eth->h_proto);
417 /* Offset for TOS field in the IP header */
418 #define IPTOS_OFFSET 5
419 tid = (tid >> IPTOS_OFFSET);
421 /* Record the current time the packet was queued; used to
422 determine the amount of time the packet was queued in
423 the driver before it was sent to the firmware.
424 The delay is then sent along with the packet to the
425 firmware for aggregate delay calculation for stats and
426 MSDU lifetime expiry.
428 do_gettimeofday(&tv);
429 skb->tstamp = timeval_to_ktime(tv);
433 * CFG802.11 network device handler for open.
435 * Starts the data queue.
438 mwifiex_open(struct net_device *dev)
440 netif_tx_start_all_queues(dev);
445 * CFG802.11 network device handler for close.
448 mwifiex_close(struct net_device *dev)
454 * CFG802.11 network device handler for data transmission.
457 mwifiex_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
459 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
460 struct sk_buff *new_skb;
461 struct mwifiex_txinfo *tx_info;
463 dev_dbg(priv->adapter->dev, "data: %lu BSS(%d-%d): Data <= kernel\n",
464 jiffies, priv->bss_type, priv->bss_num);
466 if (priv->adapter->surprise_removed) {
468 priv->stats.tx_dropped++;
471 if (!skb->len || (skb->len > ETH_FRAME_LEN)) {
472 dev_err(priv->adapter->dev, "Tx: bad skb len %d\n", skb->len);
474 priv->stats.tx_dropped++;
477 if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN) {
478 dev_dbg(priv->adapter->dev,
479 "data: Tx: insufficient skb headroom %d\n",
481 /* Insufficient skb headroom - allocate a new skb */
483 skb_realloc_headroom(skb, MWIFIEX_MIN_DATA_HEADER_LEN);
484 if (unlikely(!new_skb)) {
485 dev_err(priv->adapter->dev, "Tx: cannot alloca new_skb\n");
487 priv->stats.tx_dropped++;
492 dev_dbg(priv->adapter->dev, "info: new skb headroomd %d\n",
496 tx_info = MWIFIEX_SKB_TXCB(skb);
497 tx_info->bss_num = priv->bss_num;
498 tx_info->bss_type = priv->bss_type;
499 mwifiex_fill_buffer(skb);
501 mwifiex_wmm_add_buf_txqueue(priv, skb);
502 atomic_inc(&priv->adapter->tx_pending);
504 if (atomic_read(&priv->adapter->tx_pending) >= MAX_TX_PENDING) {
505 mwifiex_set_trans_start(dev);
506 mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
509 queue_work(priv->adapter->workqueue, &priv->adapter->main_work);
515 * CFG802.11 network device handler for setting MAC address.
518 mwifiex_set_mac_address(struct net_device *dev, void *addr)
520 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
521 struct sockaddr *hw_addr = addr;
524 memcpy(priv->curr_addr, hw_addr->sa_data, ETH_ALEN);
526 /* Send request to firmware */
527 ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_MAC_ADDRESS,
528 HostCmd_ACT_GEN_SET, 0, NULL);
531 memcpy(priv->netdev->dev_addr, priv->curr_addr, ETH_ALEN);
533 dev_err(priv->adapter->dev,
534 "set mac address failed: ret=%d\n", ret);
536 memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
542 * CFG802.11 network device handler for setting multicast list.
544 static void mwifiex_set_multicast_list(struct net_device *dev)
546 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
547 struct mwifiex_multicast_list mcast_list;
549 if (dev->flags & IFF_PROMISC) {
550 mcast_list.mode = MWIFIEX_PROMISC_MODE;
551 } else if (dev->flags & IFF_ALLMULTI ||
552 netdev_mc_count(dev) > MWIFIEX_MAX_MULTICAST_LIST_SIZE) {
553 mcast_list.mode = MWIFIEX_ALL_MULTI_MODE;
555 mcast_list.mode = MWIFIEX_MULTICAST_MODE;
556 if (netdev_mc_count(dev))
557 mcast_list.num_multicast_addr =
558 mwifiex_copy_mcast_addr(&mcast_list, dev);
560 mwifiex_request_set_multicast_list(priv, &mcast_list);
564 * CFG802.11 network device handler for transmission timeout.
567 mwifiex_tx_timeout(struct net_device *dev)
569 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
571 dev_err(priv->adapter->dev, "%lu : Tx timeout, bss_type-num = %d-%d\n",
572 jiffies, priv->bss_type, priv->bss_num);
573 mwifiex_set_trans_start(dev);
574 priv->num_tx_timeout++;
578 * CFG802.11 network device handler for statistics retrieval.
580 static struct net_device_stats *mwifiex_get_stats(struct net_device *dev)
582 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
587 /* Network device handlers */
588 static const struct net_device_ops mwifiex_netdev_ops = {
589 .ndo_open = mwifiex_open,
590 .ndo_stop = mwifiex_close,
591 .ndo_start_xmit = mwifiex_hard_start_xmit,
592 .ndo_set_mac_address = mwifiex_set_mac_address,
593 .ndo_tx_timeout = mwifiex_tx_timeout,
594 .ndo_get_stats = mwifiex_get_stats,
595 .ndo_set_rx_mode = mwifiex_set_multicast_list,
599 * This function initializes the private structure parameters.
601 * The following wait queues are initialized -
603 * - Command wait queue
604 * - Statistics wait queue
606 * ...and the following default parameters are set -
607 * - Current key index : Set to 0
608 * - Rate index : Set to auto
609 * - Media connected : Set to disconnected
610 * - Adhoc link sensed : Set to false
611 * - Nick name : Set to null
612 * - Number of Tx timeout : Set to 0
613 * - Device address : Set to current address
615 * In addition, the CFG80211 work queue is also created.
617 void mwifiex_init_priv_params(struct mwifiex_private *priv,
618 struct net_device *dev)
620 dev->netdev_ops = &mwifiex_netdev_ops;
621 /* Initialize private structure */
622 priv->current_key_index = 0;
623 priv->media_connected = false;
624 memset(&priv->nick_name, 0, sizeof(priv->nick_name));
625 priv->num_tx_timeout = 0;
626 memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
630 * This function check if command is pending.
632 int is_command_pending(struct mwifiex_adapter *adapter)
635 int is_cmd_pend_q_empty;
637 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
638 is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q);
639 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
641 return !is_cmd_pend_q_empty;
645 * This is the main work queue function.
647 * It handles the main process, which in turn handles the complete
650 static void mwifiex_main_work_queue(struct work_struct *work)
652 struct mwifiex_adapter *adapter =
653 container_of(work, struct mwifiex_adapter, main_work);
655 if (adapter->surprise_removed)
657 mwifiex_main_process(adapter);
661 * This function cancels all works in the queue and destroys
662 * the main workqueue.
665 mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter)
667 flush_workqueue(adapter->workqueue);
668 destroy_workqueue(adapter->workqueue);
669 adapter->workqueue = NULL;
673 * This function adds the card.
675 * This function follows the following major steps to set up the device -
676 * - Initialize software. This includes probing the card, registering
677 * the interface operations table, and allocating/initializing the
679 * - Set up the netlink socket
680 * - Create and start the main work queue
681 * - Register the device
682 * - Initialize firmware and hardware
683 * - Add logical interfaces
686 mwifiex_add_card(void *card, struct semaphore *sem,
687 struct mwifiex_if_ops *if_ops, u8 iface_type)
689 struct mwifiex_adapter *adapter;
691 if (down_interruptible(sem))
694 if (mwifiex_register(card, if_ops, (void **)&adapter)) {
695 pr_err("%s: software init failed\n", __func__);
699 adapter->iface_type = iface_type;
701 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
702 adapter->surprise_removed = false;
703 init_waitqueue_head(&adapter->init_wait_q);
704 adapter->is_suspended = false;
705 adapter->hs_activated = false;
706 init_waitqueue_head(&adapter->hs_activate_wait_q);
707 adapter->cmd_wait_q_required = false;
708 init_waitqueue_head(&adapter->cmd_wait_q.wait);
709 adapter->cmd_wait_q.status = 0;
710 adapter->scan_wait_q_woken = false;
712 adapter->workqueue = create_workqueue("MWIFIEX_WORK_QUEUE");
713 if (!adapter->workqueue)
716 INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
718 /* Register the device. Fill up the private data structure with relevant
719 information from the card and request for the required IRQ. */
720 if (adapter->if_ops.register_dev(adapter)) {
721 pr_err("%s: failed to register mwifiex device\n", __func__);
722 goto err_registerdev;
725 if (mwifiex_init_hw_fw(adapter)) {
726 pr_err("%s: firmware init failed\n", __func__);
734 pr_debug("info: %s: unregister device\n", __func__);
735 adapter->if_ops.unregister_dev(adapter);
737 adapter->surprise_removed = true;
738 mwifiex_terminate_workqueue(adapter);
740 if ((adapter->hw_status == MWIFIEX_HW_STATUS_FW_READY) ||
741 (adapter->hw_status == MWIFIEX_HW_STATUS_READY)) {
742 pr_debug("info: %s: shutdown mwifiex\n", __func__);
743 adapter->init_wait_q_woken = false;
745 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
746 wait_event_interruptible(adapter->init_wait_q,
747 adapter->init_wait_q_woken);
750 mwifiex_free_adapter(adapter);
758 EXPORT_SYMBOL_GPL(mwifiex_add_card);
761 * This function removes the card.
763 * This function follows the following major steps to remove the device -
764 * - Stop data traffic
765 * - Shutdown firmware
766 * - Remove the logical interfaces
767 * - Terminate the work queue
768 * - Unregister the device
769 * - Free the adapter structure
771 int mwifiex_remove_card(struct mwifiex_adapter *adapter, struct semaphore *sem)
773 struct mwifiex_private *priv = NULL;
776 if (down_interruptible(sem))
782 adapter->surprise_removed = true;
785 for (i = 0; i < adapter->priv_num; i++) {
786 priv = adapter->priv[i];
787 if (priv && priv->netdev) {
788 if (!netif_queue_stopped(priv->netdev))
789 mwifiex_stop_net_dev_queue(priv->netdev,
791 if (netif_carrier_ok(priv->netdev))
792 netif_carrier_off(priv->netdev);
796 dev_dbg(adapter->dev, "cmd: calling mwifiex_shutdown_drv...\n");
797 adapter->init_wait_q_woken = false;
799 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
800 wait_event_interruptible(adapter->init_wait_q,
801 adapter->init_wait_q_woken);
802 dev_dbg(adapter->dev, "cmd: mwifiex_shutdown_drv done\n");
803 if (atomic_read(&adapter->rx_pending) ||
804 atomic_read(&adapter->tx_pending) ||
805 atomic_read(&adapter->cmd_pending)) {
806 dev_err(adapter->dev, "rx_pending=%d, tx_pending=%d, "
808 atomic_read(&adapter->rx_pending),
809 atomic_read(&adapter->tx_pending),
810 atomic_read(&adapter->cmd_pending));
813 for (i = 0; i < adapter->priv_num; i++) {
814 priv = adapter->priv[i];
820 if (priv->wdev && priv->netdev)
821 mwifiex_del_virtual_intf(priv->wdev->wiphy,
826 priv = adapter->priv[0];
831 wiphy_unregister(priv->wdev->wiphy);
832 wiphy_free(priv->wdev->wiphy);
836 mwifiex_terminate_workqueue(adapter);
838 /* Unregister device */
839 dev_dbg(adapter->dev, "info: unregister device\n");
840 adapter->if_ops.unregister_dev(adapter);
841 /* Free adapter structure */
842 dev_dbg(adapter->dev, "info: free adapter\n");
843 mwifiex_free_adapter(adapter);
850 EXPORT_SYMBOL_GPL(mwifiex_remove_card);
853 * This function initializes the module.
855 * The debug FS is also initialized if configured.
858 mwifiex_init_module(void)
860 #ifdef CONFIG_DEBUG_FS
861 mwifiex_debugfs_init();
867 * This function cleans up the module.
869 * The debug FS is removed if available.
872 mwifiex_cleanup_module(void)
874 #ifdef CONFIG_DEBUG_FS
875 mwifiex_debugfs_remove();
879 module_init(mwifiex_init_module);
880 module_exit(mwifiex_cleanup_module);
882 MODULE_AUTHOR("Marvell International Ltd.");
883 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION);
884 MODULE_VERSION(VERSION);
885 MODULE_LICENSE("GPL v2");