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),
69 if (!adapter->priv[0]) {
70 dev_err(adapter->dev, "%s: failed to alloc priv[0]\n",
77 adapter->priv[0]->adapter = adapter;
78 mwifiex_init_lock_list(adapter);
80 init_timer(&adapter->cmd_timer);
81 adapter->cmd_timer.function = mwifiex_cmd_timeout_func;
82 adapter->cmd_timer.data = (unsigned long) adapter;
87 dev_dbg(adapter->dev, "info: leave mwifiex_register with error\n");
89 for (i = 0; i < adapter->priv_num; i++)
90 kfree(adapter->priv[i]);
98 * This function unregisters the device and performs all the necessary
101 * The following cleanup operations are performed -
103 * - Free beacon buffers
104 * - Free private structures
105 * - Free adapter structure
107 static int mwifiex_unregister(struct mwifiex_adapter *adapter)
111 del_timer(&adapter->cmd_timer);
113 /* Free private structures */
114 for (i = 0; i < adapter->priv_num; i++) {
115 if (adapter->priv[i]) {
116 mwifiex_free_curr_bcn(adapter->priv[i]);
117 kfree(adapter->priv[i]);
128 * This function is the main procedure of the driver and handles various driver
129 * operations. It runs in a loop and provides the core functionalities.
131 * The main responsibilities of this function are -
132 * - Ensure concurrency control
133 * - Handle pending interrupts and call interrupt handlers
134 * - Wake up the card if required
135 * - Handle command responses and call response handlers
136 * - Handle events and call event handlers
137 * - Execute pending commands
138 * - Transmit pending data packets
140 int mwifiex_main_process(struct mwifiex_adapter *adapter)
145 spin_lock_irqsave(&adapter->main_proc_lock, flags);
147 /* Check if already processing */
148 if (adapter->mwifiex_processing) {
149 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
152 adapter->mwifiex_processing = true;
153 spin_unlock_irqrestore(&adapter->main_proc_lock, flags);
157 if ((adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING) ||
158 (adapter->hw_status == MWIFIEX_HW_STATUS_NOT_READY))
161 /* Handle pending interrupt if any */
162 if (adapter->int_status) {
163 if (adapter->hs_activated)
164 mwifiex_process_hs_config(adapter);
165 adapter->if_ops.process_int_status(adapter);
168 /* Need to wake up the card ? */
169 if ((adapter->ps_state == PS_STATE_SLEEP) &&
170 (adapter->pm_wakeup_card_req &&
171 !adapter->pm_wakeup_fw_try) &&
172 (is_command_pending(adapter)
173 || !mwifiex_wmm_lists_empty(adapter))) {
174 adapter->pm_wakeup_fw_try = true;
175 adapter->if_ops.wakeup(adapter);
178 if (IS_CARD_RX_RCVD(adapter)) {
179 adapter->pm_wakeup_fw_try = false;
180 if (adapter->ps_state == PS_STATE_SLEEP)
181 adapter->ps_state = PS_STATE_AWAKE;
183 /* We have tried to wakeup the card already */
184 if (adapter->pm_wakeup_fw_try)
186 if (adapter->ps_state != PS_STATE_AWAKE ||
187 adapter->tx_lock_flag)
190 if (adapter->scan_processing || 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->data_sent &&
240 !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 initializes the hardware and firmware.
298 * The main initialization steps followed are -
299 * - Download the correct firmware to card
300 * - Allocate and initialize the adapter structure
301 * - Initialize the private structures
302 * - Issue the init commands to firmware
304 static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter)
307 struct mwifiex_fw_image fw;
309 memset(&fw, 0, sizeof(struct mwifiex_fw_image));
311 err = request_firmware(&adapter->firmware, adapter->fw_name,
314 dev_err(adapter->dev, "request_firmware() returned"
315 " error code %#x\n", err);
319 fw.fw_buf = (u8 *) adapter->firmware->data;
320 fw.fw_len = adapter->firmware->size;
322 ret = mwifiex_dnld_fw(adapter, &fw);
326 dev_notice(adapter->dev, "WLAN FW is active\n");
328 adapter->init_wait_q_woken = false;
329 ret = mwifiex_init_fw(adapter);
333 adapter->hw_status = MWIFIEX_HW_STATUS_READY;
336 /* Wait for mwifiex_init to complete */
337 wait_event_interruptible(adapter->init_wait_q,
338 adapter->init_wait_q_woken);
339 if (adapter->hw_status != MWIFIEX_HW_STATUS_READY) {
346 if (adapter->firmware)
347 release_firmware(adapter->firmware);
354 * This function fills a driver buffer.
356 * The function associates a given SKB with the provided driver buffer
357 * and also updates some of the SKB parameters, including IP header,
358 * priority and timestamp.
361 mwifiex_fill_buffer(struct sk_buff *skb)
368 eth = (struct ethhdr *) skb->data;
369 switch (eth->h_proto) {
370 case __constant_htons(ETH_P_IP):
372 tid = IPTOS_PREC(iph->tos);
373 pr_debug("data: packet type ETH_P_IP: %04x, tid=%#x prio=%#x\n",
374 eth->h_proto, tid, skb->priority);
376 case __constant_htons(ETH_P_ARP):
377 pr_debug("data: ARP packet: %04x\n", eth->h_proto);
381 /* Offset for TOS field in the IP header */
382 #define IPTOS_OFFSET 5
383 tid = (tid >> IPTOS_OFFSET);
385 /* Record the current time the packet was queued; used to
386 determine the amount of time the packet was queued in
387 the driver before it was sent to the firmware.
388 The delay is then sent along with the packet to the
389 firmware for aggregate delay calculation for stats and
390 MSDU lifetime expiry.
392 do_gettimeofday(&tv);
393 skb->tstamp = timeval_to_ktime(tv);
397 * CFG802.11 network device handler for open.
399 * Starts the data queue.
402 mwifiex_open(struct net_device *dev)
404 netif_tx_start_all_queues(dev);
409 * CFG802.11 network device handler for close.
412 mwifiex_close(struct net_device *dev)
418 * CFG802.11 network device handler for data transmission.
421 mwifiex_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
423 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
424 struct sk_buff *new_skb;
425 struct mwifiex_txinfo *tx_info;
427 dev_dbg(priv->adapter->dev, "data: %lu BSS(%d-%d): Data <= kernel\n",
428 jiffies, priv->bss_type, priv->bss_num);
430 if (priv->adapter->surprise_removed) {
432 priv->stats.tx_dropped++;
435 if (!skb->len || (skb->len > ETH_FRAME_LEN)) {
436 dev_err(priv->adapter->dev, "Tx: bad skb len %d\n", skb->len);
438 priv->stats.tx_dropped++;
441 if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN) {
442 dev_dbg(priv->adapter->dev,
443 "data: Tx: insufficient skb headroom %d\n",
445 /* Insufficient skb headroom - allocate a new skb */
447 skb_realloc_headroom(skb, MWIFIEX_MIN_DATA_HEADER_LEN);
448 if (unlikely(!new_skb)) {
449 dev_err(priv->adapter->dev, "Tx: cannot alloca new_skb\n");
451 priv->stats.tx_dropped++;
456 dev_dbg(priv->adapter->dev, "info: new skb headroomd %d\n",
460 tx_info = MWIFIEX_SKB_TXCB(skb);
461 tx_info->bss_num = priv->bss_num;
462 tx_info->bss_type = priv->bss_type;
463 mwifiex_fill_buffer(skb);
465 mwifiex_wmm_add_buf_txqueue(priv, skb);
466 atomic_inc(&priv->adapter->tx_pending);
468 if (atomic_read(&priv->adapter->tx_pending) >= MAX_TX_PENDING) {
469 mwifiex_set_trans_start(dev);
470 mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter);
473 queue_work(priv->adapter->workqueue, &priv->adapter->main_work);
479 * CFG802.11 network device handler for setting MAC address.
482 mwifiex_set_mac_address(struct net_device *dev, void *addr)
484 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
485 struct sockaddr *hw_addr = addr;
488 memcpy(priv->curr_addr, hw_addr->sa_data, ETH_ALEN);
490 /* Send request to firmware */
491 ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_MAC_ADDRESS,
492 HostCmd_ACT_GEN_SET, 0, NULL);
495 memcpy(priv->netdev->dev_addr, priv->curr_addr, ETH_ALEN);
497 dev_err(priv->adapter->dev, "set mac address failed: ret=%d"
500 memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
506 * CFG802.11 network device handler for setting multicast list.
508 static void mwifiex_set_multicast_list(struct net_device *dev)
510 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
511 struct mwifiex_multicast_list mcast_list;
513 if (dev->flags & IFF_PROMISC) {
514 mcast_list.mode = MWIFIEX_PROMISC_MODE;
515 } else if (dev->flags & IFF_ALLMULTI ||
516 netdev_mc_count(dev) > MWIFIEX_MAX_MULTICAST_LIST_SIZE) {
517 mcast_list.mode = MWIFIEX_ALL_MULTI_MODE;
519 mcast_list.mode = MWIFIEX_MULTICAST_MODE;
520 if (netdev_mc_count(dev))
521 mcast_list.num_multicast_addr =
522 mwifiex_copy_mcast_addr(&mcast_list, dev);
524 mwifiex_request_set_multicast_list(priv, &mcast_list);
528 * CFG802.11 network device handler for transmission timeout.
531 mwifiex_tx_timeout(struct net_device *dev)
533 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
535 dev_err(priv->adapter->dev, "%lu : Tx timeout, bss_type-num = %d-%d\n",
536 jiffies, priv->bss_type, priv->bss_num);
537 mwifiex_set_trans_start(dev);
538 priv->num_tx_timeout++;
542 * CFG802.11 network device handler for statistics retrieval.
544 static struct net_device_stats *mwifiex_get_stats(struct net_device *dev)
546 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev);
551 /* Network device handlers */
552 static const struct net_device_ops mwifiex_netdev_ops = {
553 .ndo_open = mwifiex_open,
554 .ndo_stop = mwifiex_close,
555 .ndo_start_xmit = mwifiex_hard_start_xmit,
556 .ndo_set_mac_address = mwifiex_set_mac_address,
557 .ndo_tx_timeout = mwifiex_tx_timeout,
558 .ndo_get_stats = mwifiex_get_stats,
559 .ndo_set_rx_mode = mwifiex_set_multicast_list,
563 * This function initializes the private structure parameters.
565 * The following wait queues are initialized -
567 * - Command wait queue
568 * - Statistics wait queue
570 * ...and the following default parameters are set -
571 * - Current key index : Set to 0
572 * - Rate index : Set to auto
573 * - Media connected : Set to disconnected
574 * - Adhoc link sensed : Set to false
575 * - Nick name : Set to null
576 * - Number of Tx timeout : Set to 0
577 * - Device address : Set to current address
579 * In addition, the CFG80211 work queue is also created.
581 void mwifiex_init_priv_params(struct mwifiex_private *priv,
582 struct net_device *dev)
584 dev->netdev_ops = &mwifiex_netdev_ops;
585 /* Initialize private structure */
586 priv->current_key_index = 0;
587 priv->media_connected = false;
588 memset(&priv->nick_name, 0, sizeof(priv->nick_name));
589 priv->num_tx_timeout = 0;
590 memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN);
594 * This function check if command is pending.
596 int is_command_pending(struct mwifiex_adapter *adapter)
599 int is_cmd_pend_q_empty;
601 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags);
602 is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q);
603 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags);
605 return !is_cmd_pend_q_empty;
609 * This is the main work queue function.
611 * It handles the main process, which in turn handles the complete
614 static void mwifiex_main_work_queue(struct work_struct *work)
616 struct mwifiex_adapter *adapter =
617 container_of(work, struct mwifiex_adapter, main_work);
619 if (adapter->surprise_removed)
621 mwifiex_main_process(adapter);
625 * This function cancels all works in the queue and destroys
626 * the main workqueue.
629 mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter)
631 flush_workqueue(adapter->workqueue);
632 destroy_workqueue(adapter->workqueue);
633 adapter->workqueue = NULL;
637 * This function adds the card.
639 * This function follows the following major steps to set up the device -
640 * - Initialize software. This includes probing the card, registering
641 * the interface operations table, and allocating/initializing the
643 * - Set up the netlink socket
644 * - Create and start the main work queue
645 * - Register the device
646 * - Initialize firmware and hardware
647 * - Add logical interfaces
650 mwifiex_add_card(void *card, struct semaphore *sem,
651 struct mwifiex_if_ops *if_ops, u8 iface_type)
653 struct mwifiex_adapter *adapter;
655 struct mwifiex_private *priv;
657 if (down_interruptible(sem))
660 if (mwifiex_register(card, if_ops, (void **)&adapter)) {
661 pr_err("%s: software init failed\n", __func__);
665 adapter->iface_type = iface_type;
667 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING;
668 adapter->surprise_removed = false;
669 init_waitqueue_head(&adapter->init_wait_q);
670 adapter->is_suspended = false;
671 adapter->hs_activated = false;
672 init_waitqueue_head(&adapter->hs_activate_wait_q);
673 adapter->cmd_wait_q_required = false;
674 init_waitqueue_head(&adapter->cmd_wait_q.wait);
675 adapter->cmd_wait_q.status = 0;
676 adapter->scan_wait_q_woken = false;
678 adapter->workqueue = create_workqueue("MWIFIEX_WORK_QUEUE");
679 if (!adapter->workqueue)
682 INIT_WORK(&adapter->main_work, mwifiex_main_work_queue);
684 /* Register the device. Fill up the private data structure with relevant
685 information from the card and request for the required IRQ. */
686 if (adapter->if_ops.register_dev(adapter)) {
687 pr_err("%s: failed to register mwifiex device\n", __func__);
688 goto err_registerdev;
691 if (mwifiex_init_hw_fw(adapter)) {
692 pr_err("%s: firmware init failed\n", __func__);
696 priv = adapter->priv[0];
698 if (mwifiex_register_cfg80211(priv) != 0) {
699 dev_err(adapter->dev, "cannot register netdevice"
705 /* Create station interface by default */
706 if (!mwifiex_add_virtual_intf(priv->wdev->wiphy, "mlan%d",
707 NL80211_IFTYPE_STATION, NULL, NULL)) {
709 dev_err(adapter->dev, "cannot create default station"
718 mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1);
719 dev_notice(adapter->dev, "driver_version = %s\n", fmt);
725 mwifiex_del_virtual_intf(priv->wdev->wiphy, priv->netdev);
728 pr_debug("info: %s: unregister device\n", __func__);
729 adapter->if_ops.unregister_dev(adapter);
731 adapter->surprise_removed = true;
732 mwifiex_terminate_workqueue(adapter);
734 if ((adapter->hw_status == MWIFIEX_HW_STATUS_FW_READY) ||
735 (adapter->hw_status == MWIFIEX_HW_STATUS_READY)) {
736 pr_debug("info: %s: shutdown mwifiex\n", __func__);
737 adapter->init_wait_q_woken = false;
739 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
740 wait_event_interruptible(adapter->init_wait_q,
741 adapter->init_wait_q_woken);
744 mwifiex_free_adapter(adapter);
752 EXPORT_SYMBOL_GPL(mwifiex_add_card);
755 * This function removes the card.
757 * This function follows the following major steps to remove the device -
758 * - Stop data traffic
759 * - Shutdown firmware
760 * - Remove the logical interfaces
761 * - Terminate the work queue
762 * - Unregister the device
763 * - Free the adapter structure
765 int mwifiex_remove_card(struct mwifiex_adapter *adapter, struct semaphore *sem)
767 struct mwifiex_private *priv = NULL;
770 if (down_interruptible(sem))
776 adapter->surprise_removed = true;
779 for (i = 0; i < adapter->priv_num; i++) {
780 priv = adapter->priv[i];
781 if (priv && priv->netdev) {
782 if (!netif_queue_stopped(priv->netdev))
783 mwifiex_stop_net_dev_queue(priv->netdev,
785 if (netif_carrier_ok(priv->netdev))
786 netif_carrier_off(priv->netdev);
790 dev_dbg(adapter->dev, "cmd: calling mwifiex_shutdown_drv...\n");
791 adapter->init_wait_q_woken = false;
793 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS)
794 wait_event_interruptible(adapter->init_wait_q,
795 adapter->init_wait_q_woken);
796 dev_dbg(adapter->dev, "cmd: mwifiex_shutdown_drv done\n");
797 if (atomic_read(&adapter->rx_pending) ||
798 atomic_read(&adapter->tx_pending) ||
799 atomic_read(&adapter->cmd_pending)) {
800 dev_err(adapter->dev, "rx_pending=%d, tx_pending=%d, "
802 atomic_read(&adapter->rx_pending),
803 atomic_read(&adapter->tx_pending),
804 atomic_read(&adapter->cmd_pending));
807 for (i = 0; i < adapter->priv_num; i++) {
808 priv = adapter->priv[i];
814 if (priv->wdev && priv->netdev)
815 mwifiex_del_virtual_intf(priv->wdev->wiphy,
820 priv = adapter->priv[0];
825 wiphy_unregister(priv->wdev->wiphy);
826 wiphy_free(priv->wdev->wiphy);
830 mwifiex_terminate_workqueue(adapter);
832 /* Unregister device */
833 dev_dbg(adapter->dev, "info: unregister device\n");
834 adapter->if_ops.unregister_dev(adapter);
835 /* Free adapter structure */
836 dev_dbg(adapter->dev, "info: free adapter\n");
837 mwifiex_free_adapter(adapter);
844 EXPORT_SYMBOL_GPL(mwifiex_remove_card);
847 * This function initializes the module.
849 * The debug FS is also initialized if configured.
852 mwifiex_init_module(void)
854 #ifdef CONFIG_DEBUG_FS
855 mwifiex_debugfs_init();
861 * This function cleans up the module.
863 * The debug FS is removed if available.
866 mwifiex_cleanup_module(void)
868 #ifdef CONFIG_DEBUG_FS
869 mwifiex_debugfs_remove();
873 module_init(mwifiex_init_module);
874 module_exit(mwifiex_cleanup_module);
876 MODULE_AUTHOR("Marvell International Ltd.");
877 MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION);
878 MODULE_VERSION(VERSION);
879 MODULE_LICENSE("GPL v2");