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 27const 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 */ 44static 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(adapter)) 62 goto error; 63 64 adapter->priv_num = 0; 65 66 /* Allocate memory for private structure */ 67 adapter->priv[0] = kzalloc(sizeof(struct mwifiex_private), GFP_KERNEL); 68 if (!adapter->priv[0]) { 69 dev_err(adapter->dev, 70 "%s: failed to alloc priv[0]\n", __func__); 71 goto error; 72 } 73 74 adapter->priv_num++; 75 76 adapter->priv[0]->adapter = adapter; 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 85error: 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 */ 106static 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 */ 139int mwifiex_main_process(struct mwifiex_adapter *adapter) 140{ 141 int ret = 0; 142 unsigned long flags; 143 144 spin_lock_irqsave(&adapter->main_proc_lock, flags); 145 146 /* Check if already processing */ 147 if (adapter->mwifiex_processing) { 148 spin_unlock_irqrestore(&adapter->main_proc_lock, flags); 149 goto exit_main_proc; 150 } else { 151 adapter->mwifiex_processing = true; 152 spin_unlock_irqrestore(&adapter->main_proc_lock, flags); 153 } 154process_start: 155 do { 156 if ((adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING) || 157 (adapter->hw_status == MWIFIEX_HW_STATUS_NOT_READY)) 158 break; 159 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); 165 } 166 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); 175 continue; 176 } 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; 181 } else { 182 /* We have tried to wakeup the card already */ 183 if (adapter->pm_wakeup_fw_try) 184 break; 185 if (adapter->ps_state != PS_STATE_AWAKE || 186 adapter->tx_lock_flag) 187 break; 188 189 if (adapter->scan_processing || adapter->data_sent || 190 mwifiex_wmm_lists_empty(adapter)) { 191 if (adapter->cmd_sent || adapter->curr_cmd || 192 (!is_command_pending(adapter))) 193 break; 194 } 195 } 196 197 /* Check for Cmd Resp */ 198 if (adapter->cmd_resp_received) { 199 adapter->cmd_resp_received = false; 200 mwifiex_process_cmdresp(adapter); 201 202 /* call mwifiex back when init_fw is done */ 203 if (adapter->hw_status == MWIFIEX_HW_STATUS_INIT_DONE) { 204 adapter->hw_status = MWIFIEX_HW_STATUS_READY; 205 mwifiex_init_fw_complete(adapter); 206 } 207 } 208 209 /* Check for event */ 210 if (adapter->event_received) { 211 adapter->event_received = false; 212 mwifiex_process_event(adapter); 213 } 214 215 /* Check if we need to confirm Sleep Request 216 received previously */ 217 if (adapter->ps_state == PS_STATE_PRE_SLEEP) { 218 if (!adapter->cmd_sent && !adapter->curr_cmd) 219 mwifiex_check_ps_cond(adapter); 220 } 221 222 /* * The ps_state may have been changed during processing of 223 * Sleep Request event. 224 */ 225 if ((adapter->ps_state == PS_STATE_SLEEP) || 226 (adapter->ps_state == PS_STATE_PRE_SLEEP) || 227 (adapter->ps_state == PS_STATE_SLEEP_CFM) || 228 adapter->tx_lock_flag) 229 continue; 230 231 if (!adapter->cmd_sent && !adapter->curr_cmd) { 232 if (mwifiex_exec_next_cmd(adapter) == -1) { 233 ret = -1; 234 break; 235 } 236 } 237 238 if (!adapter->scan_processing && !adapter->data_sent && 239 !mwifiex_wmm_lists_empty(adapter)) { 240 mwifiex_wmm_process_tx(adapter); 241 if (adapter->hs_activated) { 242 adapter->is_hs_configured = false; 243 mwifiex_hs_activated_event 244 (mwifiex_get_priv 245 (adapter, MWIFIEX_BSS_ROLE_ANY), 246 false); 247 } 248 } 249 250 if (adapter->delay_null_pkt && !adapter->cmd_sent && 251 !adapter->curr_cmd && !is_command_pending(adapter) && 252 mwifiex_wmm_lists_empty(adapter)) { 253 if (!mwifiex_send_null_packet 254 (mwifiex_get_priv(adapter, MWIFIEX_BSS_ROLE_STA), 255 MWIFIEX_TxPD_POWER_MGMT_NULL_PACKET | 256 MWIFIEX_TxPD_POWER_MGMT_LAST_PACKET)) { 257 adapter->delay_null_pkt = false; 258 adapter->ps_state = PS_STATE_SLEEP; 259 } 260 break; 261 } 262 } while (true); 263 264 if ((adapter->int_status) || IS_CARD_RX_RCVD(adapter)) 265 goto process_start; 266 267 spin_lock_irqsave(&adapter->main_proc_lock, flags); 268 adapter->mwifiex_processing = false; 269 spin_unlock_irqrestore(&adapter->main_proc_lock, flags); 270 271exit_main_proc: 272 if (adapter->hw_status == MWIFIEX_HW_STATUS_CLOSING) 273 mwifiex_shutdown_drv(adapter); 274 return ret; 275} 276 277/* 278 * This function frees the adapter structure. 279 * 280 * Additionally, this closes the netlink socket, frees the timers 281 * and private structures. 282 */ 283static void mwifiex_free_adapter(struct mwifiex_adapter *adapter) 284{ 285 if (!adapter) { 286 pr_err("%s: adapter is NULL\n", __func__); 287 return; 288 } 289 290 mwifiex_unregister(adapter); 291 pr_debug("info: %s: free adapter\n", __func__); 292} 293 294/* 295 * This function initializes the hardware and firmware. 296 * 297 * The main initialization steps followed are - 298 * - Download the correct firmware to card 299 * - Allocate and initialize the adapter structure 300 * - Initialize the private structures 301 * - Issue the init commands to firmware 302 */ 303static int mwifiex_init_hw_fw(struct mwifiex_adapter *adapter) 304{ 305 int ret, err; 306 struct mwifiex_fw_image fw; 307 308 memset(&fw, 0, sizeof(struct mwifiex_fw_image)); 309 310 err = request_firmware(&adapter->firmware, adapter->fw_name, 311 adapter->dev); 312 if (err < 0) { 313 dev_err(adapter->dev, "request_firmware() returned" 314 " error code %#x\n", err); 315 ret = -1; 316 goto done; 317 } 318 fw.fw_buf = (u8 *) adapter->firmware->data; 319 fw.fw_len = adapter->firmware->size; 320 321 ret = mwifiex_dnld_fw(adapter, &fw); 322 if (ret == -1) 323 goto done; 324 325 dev_notice(adapter->dev, "WLAN FW is active\n"); 326 327 adapter->init_wait_q_woken = false; 328 ret = mwifiex_init_fw(adapter); 329 if (ret == -1) { 330 goto done; 331 } else if (!ret) { 332 adapter->hw_status = MWIFIEX_HW_STATUS_READY; 333 goto done; 334 } 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) { 339 ret = -1; 340 goto done; 341 } 342 ret = 0; 343 344done: 345 if (adapter->firmware) 346 release_firmware(adapter->firmware); 347 if (ret) 348 ret = -1; 349 return ret; 350} 351 352/* 353 * This function fills a driver buffer. 354 * 355 * The function associates a given SKB with the provided driver buffer 356 * and also updates some of the SKB parameters, including IP header, 357 * priority and timestamp. 358 */ 359static void 360mwifiex_fill_buffer(struct sk_buff *skb) 361{ 362 struct ethhdr *eth; 363 struct iphdr *iph; 364 struct timeval tv; 365 u8 tid = 0; 366 367 eth = (struct ethhdr *) skb->data; 368 switch (eth->h_proto) { 369 case __constant_htons(ETH_P_IP): 370 iph = ip_hdr(skb); 371 tid = IPTOS_PREC(iph->tos); 372 pr_debug("data: packet type ETH_P_IP: %04x, tid=%#x prio=%#x\n", 373 eth->h_proto, tid, skb->priority); 374 break; 375 case __constant_htons(ETH_P_ARP): 376 pr_debug("data: ARP packet: %04x\n", eth->h_proto); 377 default: 378 break; 379 } 380/* Offset for TOS field in the IP header */ 381#define IPTOS_OFFSET 5 382 tid = (tid >> IPTOS_OFFSET); 383 skb->priority = tid; 384 /* Record the current time the packet was queued; used to 385 determine the amount of time the packet was queued in 386 the driver before it was sent to the firmware. 387 The delay is then sent along with the packet to the 388 firmware for aggregate delay calculation for stats and 389 MSDU lifetime expiry. 390 */ 391 do_gettimeofday(&tv); 392 skb->tstamp = timeval_to_ktime(tv); 393} 394 395/* 396 * CFG802.11 network device handler for open. 397 * 398 * Starts the data queue. 399 */ 400static int 401mwifiex_open(struct net_device *dev) 402{ 403 netif_tx_start_all_queues(dev); 404 return 0; 405} 406 407/* 408 * CFG802.11 network device handler for close. 409 */ 410static int 411mwifiex_close(struct net_device *dev) 412{ 413 return 0; 414} 415 416/* 417 * CFG802.11 network device handler for data transmission. 418 */ 419static int 420mwifiex_hard_start_xmit(struct sk_buff *skb, struct net_device *dev) 421{ 422 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev); 423 struct sk_buff *new_skb; 424 struct mwifiex_txinfo *tx_info; 425 426 dev_dbg(priv->adapter->dev, "data: %lu BSS(%d-%d): Data <= kernel\n", 427 jiffies, priv->bss_type, priv->bss_num); 428 429 if (priv->adapter->surprise_removed) { 430 kfree_skb(skb); 431 priv->stats.tx_dropped++; 432 return 0; 433 } 434 if (!skb->len || (skb->len > ETH_FRAME_LEN)) { 435 dev_err(priv->adapter->dev, "Tx: bad skb len %d\n", skb->len); 436 kfree_skb(skb); 437 priv->stats.tx_dropped++; 438 return 0; 439 } 440 if (skb_headroom(skb) < MWIFIEX_MIN_DATA_HEADER_LEN) { 441 dev_dbg(priv->adapter->dev, 442 "data: Tx: insufficient skb headroom %d\n", 443 skb_headroom(skb)); 444 /* Insufficient skb headroom - allocate a new skb */ 445 new_skb = 446 skb_realloc_headroom(skb, MWIFIEX_MIN_DATA_HEADER_LEN); 447 if (unlikely(!new_skb)) { 448 dev_err(priv->adapter->dev, "Tx: cannot alloca new_skb\n"); 449 kfree_skb(skb); 450 priv->stats.tx_dropped++; 451 return 0; 452 } 453 kfree_skb(skb); 454 skb = new_skb; 455 dev_dbg(priv->adapter->dev, "info: new skb headroomd %d\n", 456 skb_headroom(skb)); 457 } 458 459 tx_info = MWIFIEX_SKB_TXCB(skb); 460 tx_info->bss_num = priv->bss_num; 461 tx_info->bss_type = priv->bss_type; 462 mwifiex_fill_buffer(skb); 463 464 mwifiex_wmm_add_buf_txqueue(priv, skb); 465 atomic_inc(&priv->adapter->tx_pending); 466 467 if (atomic_read(&priv->adapter->tx_pending) >= MAX_TX_PENDING) { 468 mwifiex_set_trans_start(dev); 469 mwifiex_stop_net_dev_queue(priv->netdev, priv->adapter); 470 } 471 472 queue_work(priv->adapter->workqueue, &priv->adapter->main_work); 473 474 return 0; 475} 476 477/* 478 * CFG802.11 network device handler for setting MAC address. 479 */ 480static int 481mwifiex_set_mac_address(struct net_device *dev, void *addr) 482{ 483 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev); 484 struct sockaddr *hw_addr = addr; 485 int ret; 486 487 memcpy(priv->curr_addr, hw_addr->sa_data, ETH_ALEN); 488 489 /* Send request to firmware */ 490 ret = mwifiex_send_cmd_sync(priv, HostCmd_CMD_802_11_MAC_ADDRESS, 491 HostCmd_ACT_GEN_SET, 0, NULL); 492 493 if (!ret) 494 memcpy(priv->netdev->dev_addr, priv->curr_addr, ETH_ALEN); 495 else 496 dev_err(priv->adapter->dev, 497 "set mac address failed: ret=%d\n", ret); 498 499 memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN); 500 501 return ret; 502} 503 504/* 505 * CFG802.11 network device handler for setting multicast list. 506 */ 507static void mwifiex_set_multicast_list(struct net_device *dev) 508{ 509 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev); 510 struct mwifiex_multicast_list mcast_list; 511 512 if (dev->flags & IFF_PROMISC) { 513 mcast_list.mode = MWIFIEX_PROMISC_MODE; 514 } else if (dev->flags & IFF_ALLMULTI || 515 netdev_mc_count(dev) > MWIFIEX_MAX_MULTICAST_LIST_SIZE) { 516 mcast_list.mode = MWIFIEX_ALL_MULTI_MODE; 517 } else { 518 mcast_list.mode = MWIFIEX_MULTICAST_MODE; 519 if (netdev_mc_count(dev)) 520 mcast_list.num_multicast_addr = 521 mwifiex_copy_mcast_addr(&mcast_list, dev); 522 } 523 mwifiex_request_set_multicast_list(priv, &mcast_list); 524} 525 526/* 527 * CFG802.11 network device handler for transmission timeout. 528 */ 529static void 530mwifiex_tx_timeout(struct net_device *dev) 531{ 532 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev); 533 534 dev_err(priv->adapter->dev, "%lu : Tx timeout, bss_type-num = %d-%d\n", 535 jiffies, priv->bss_type, priv->bss_num); 536 mwifiex_set_trans_start(dev); 537 priv->num_tx_timeout++; 538} 539 540/* 541 * CFG802.11 network device handler for statistics retrieval. 542 */ 543static struct net_device_stats *mwifiex_get_stats(struct net_device *dev) 544{ 545 struct mwifiex_private *priv = mwifiex_netdev_get_priv(dev); 546 547 return &priv->stats; 548} 549 550/* Network device handlers */ 551static const struct net_device_ops mwifiex_netdev_ops = { 552 .ndo_open = mwifiex_open, 553 .ndo_stop = mwifiex_close, 554 .ndo_start_xmit = mwifiex_hard_start_xmit, 555 .ndo_set_mac_address = mwifiex_set_mac_address, 556 .ndo_tx_timeout = mwifiex_tx_timeout, 557 .ndo_get_stats = mwifiex_get_stats, 558 .ndo_set_rx_mode = mwifiex_set_multicast_list, 559}; 560 561/* 562 * This function initializes the private structure parameters. 563 * 564 * The following wait queues are initialized - 565 * - IOCTL wait queue 566 * - Command wait queue 567 * - Statistics wait queue 568 * 569 * ...and the following default parameters are set - 570 * - Current key index : Set to 0 571 * - Rate index : Set to auto 572 * - Media connected : Set to disconnected 573 * - Adhoc link sensed : Set to false 574 * - Nick name : Set to null 575 * - Number of Tx timeout : Set to 0 576 * - Device address : Set to current address 577 * 578 * In addition, the CFG80211 work queue is also created. 579 */ 580void mwifiex_init_priv_params(struct mwifiex_private *priv, 581 struct net_device *dev) 582{ 583 dev->netdev_ops = &mwifiex_netdev_ops; 584 /* Initialize private structure */ 585 priv->current_key_index = 0; 586 priv->media_connected = false; 587 memset(&priv->nick_name, 0, sizeof(priv->nick_name)); 588 priv->num_tx_timeout = 0; 589 memcpy(dev->dev_addr, priv->curr_addr, ETH_ALEN); 590} 591 592/* 593 * This function check if command is pending. 594 */ 595int is_command_pending(struct mwifiex_adapter *adapter) 596{ 597 unsigned long flags; 598 int is_cmd_pend_q_empty; 599 600 spin_lock_irqsave(&adapter->cmd_pending_q_lock, flags); 601 is_cmd_pend_q_empty = list_empty(&adapter->cmd_pending_q); 602 spin_unlock_irqrestore(&adapter->cmd_pending_q_lock, flags); 603 604 return !is_cmd_pend_q_empty; 605} 606 607/* 608 * This is the main work queue function. 609 * 610 * It handles the main process, which in turn handles the complete 611 * driver operations. 612 */ 613static void mwifiex_main_work_queue(struct work_struct *work) 614{ 615 struct mwifiex_adapter *adapter = 616 container_of(work, struct mwifiex_adapter, main_work); 617 618 if (adapter->surprise_removed) 619 return; 620 mwifiex_main_process(adapter); 621} 622 623/* 624 * This function cancels all works in the queue and destroys 625 * the main workqueue. 626 */ 627static void 628mwifiex_terminate_workqueue(struct mwifiex_adapter *adapter) 629{ 630 flush_workqueue(adapter->workqueue); 631 destroy_workqueue(adapter->workqueue); 632 adapter->workqueue = NULL; 633} 634 635/* 636 * This function adds the card. 637 * 638 * This function follows the following major steps to set up the device - 639 * - Initialize software. This includes probing the card, registering 640 * the interface operations table, and allocating/initializing the 641 * adapter structure 642 * - Set up the netlink socket 643 * - Create and start the main work queue 644 * - Register the device 645 * - Initialize firmware and hardware 646 * - Add logical interfaces 647 */ 648int 649mwifiex_add_card(void *card, struct semaphore *sem, 650 struct mwifiex_if_ops *if_ops, u8 iface_type) 651{ 652 struct mwifiex_adapter *adapter; 653 char fmt[64]; 654 struct mwifiex_private *priv; 655 656 if (down_interruptible(sem)) 657 goto exit_sem_err; 658 659 if (mwifiex_register(card, if_ops, (void **)&adapter)) { 660 pr_err("%s: software init failed\n", __func__); 661 goto err_init_sw; 662 } 663 664 adapter->iface_type = iface_type; 665 666 adapter->hw_status = MWIFIEX_HW_STATUS_INITIALIZING; 667 adapter->surprise_removed = false; 668 init_waitqueue_head(&adapter->init_wait_q); 669 adapter->is_suspended = false; 670 adapter->hs_activated = false; 671 init_waitqueue_head(&adapter->hs_activate_wait_q); 672 adapter->cmd_wait_q_required = false; 673 init_waitqueue_head(&adapter->cmd_wait_q.wait); 674 adapter->cmd_wait_q.status = 0; 675 adapter->scan_wait_q_woken = false; 676 677 adapter->workqueue = create_workqueue("MWIFIEX_WORK_QUEUE"); 678 if (!adapter->workqueue) 679 goto err_kmalloc; 680 681 INIT_WORK(&adapter->main_work, mwifiex_main_work_queue); 682 683 /* Register the device. Fill up the private data structure with relevant 684 information from the card and request for the required IRQ. */ 685 if (adapter->if_ops.register_dev(adapter)) { 686 pr_err("%s: failed to register mwifiex device\n", __func__); 687 goto err_registerdev; 688 } 689 690 if (mwifiex_init_hw_fw(adapter)) { 691 pr_err("%s: firmware init failed\n", __func__); 692 goto err_init_fw; 693 } 694 695 priv = adapter->priv[0]; 696 697 if (mwifiex_register_cfg80211(priv) != 0) { 698 dev_err(adapter->dev, "cannot register netdevice" 699 " with cfg80211\n"); 700 goto err_init_fw; 701 } 702 703 rtnl_lock(); 704 /* Create station interface by default */ 705 if (!mwifiex_add_virtual_intf(priv->wdev->wiphy, "mlan%d", 706 NL80211_IFTYPE_STATION, NULL, NULL)) { 707 rtnl_unlock(); 708 dev_err(adapter->dev, "cannot create default station" 709 " interface\n"); 710 goto err_add_intf; 711 } 712 713 rtnl_unlock(); 714 715 up(sem); 716 717 mwifiex_drv_get_driver_version(adapter, fmt, sizeof(fmt) - 1); 718 dev_notice(adapter->dev, "driver_version = %s\n", fmt); 719 720 return 0; 721 722err_add_intf: 723 rtnl_lock(); 724 mwifiex_del_virtual_intf(priv->wdev->wiphy, priv->netdev); 725 rtnl_unlock(); 726err_init_fw: 727 pr_debug("info: %s: unregister device\n", __func__); 728 adapter->if_ops.unregister_dev(adapter); 729err_registerdev: 730 adapter->surprise_removed = true; 731 mwifiex_terminate_workqueue(adapter); 732err_kmalloc: 733 if ((adapter->hw_status == MWIFIEX_HW_STATUS_FW_READY) || 734 (adapter->hw_status == MWIFIEX_HW_STATUS_READY)) { 735 pr_debug("info: %s: shutdown mwifiex\n", __func__); 736 adapter->init_wait_q_woken = false; 737 738 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS) 739 wait_event_interruptible(adapter->init_wait_q, 740 adapter->init_wait_q_woken); 741 } 742 743 mwifiex_free_adapter(adapter); 744 745err_init_sw: 746 up(sem); 747 748exit_sem_err: 749 return -1; 750} 751EXPORT_SYMBOL_GPL(mwifiex_add_card); 752 753/* 754 * This function removes the card. 755 * 756 * This function follows the following major steps to remove the device - 757 * - Stop data traffic 758 * - Shutdown firmware 759 * - Remove the logical interfaces 760 * - Terminate the work queue 761 * - Unregister the device 762 * - Free the adapter structure 763 */ 764int mwifiex_remove_card(struct mwifiex_adapter *adapter, struct semaphore *sem) 765{ 766 struct mwifiex_private *priv = NULL; 767 int i; 768 769 if (down_interruptible(sem)) 770 goto exit_sem_err; 771 772 if (!adapter) 773 goto exit_remove; 774 775 adapter->surprise_removed = true; 776 777 /* Stop data */ 778 for (i = 0; i < adapter->priv_num; i++) { 779 priv = adapter->priv[i]; 780 if (priv && priv->netdev) { 781 if (!netif_queue_stopped(priv->netdev)) 782 mwifiex_stop_net_dev_queue(priv->netdev, 783 adapter); 784 if (netif_carrier_ok(priv->netdev)) 785 netif_carrier_off(priv->netdev); 786 } 787 } 788 789 dev_dbg(adapter->dev, "cmd: calling mwifiex_shutdown_drv...\n"); 790 adapter->init_wait_q_woken = false; 791 792 if (mwifiex_shutdown_drv(adapter) == -EINPROGRESS) 793 wait_event_interruptible(adapter->init_wait_q, 794 adapter->init_wait_q_woken); 795 dev_dbg(adapter->dev, "cmd: mwifiex_shutdown_drv done\n"); 796 if (atomic_read(&adapter->rx_pending) || 797 atomic_read(&adapter->tx_pending) || 798 atomic_read(&adapter->cmd_pending)) { 799 dev_err(adapter->dev, "rx_pending=%d, tx_pending=%d, " 800 "cmd_pending=%d\n", 801 atomic_read(&adapter->rx_pending), 802 atomic_read(&adapter->tx_pending), 803 atomic_read(&adapter->cmd_pending)); 804 } 805 806 for (i = 0; i < adapter->priv_num; i++) { 807 priv = adapter->priv[i]; 808 809 if (!priv) 810 continue; 811 812 rtnl_lock(); 813 if (priv->wdev && priv->netdev) 814 mwifiex_del_virtual_intf(priv->wdev->wiphy, 815 priv->netdev); 816 rtnl_unlock(); 817 } 818 819 priv = adapter->priv[0]; 820 if (!priv) 821 goto exit_remove; 822 823 if (priv->wdev) { 824 wiphy_unregister(priv->wdev->wiphy); 825 wiphy_free(priv->wdev->wiphy); 826 kfree(priv->wdev); 827 } 828 829 mwifiex_terminate_workqueue(adapter); 830 831 /* Unregister device */ 832 dev_dbg(adapter->dev, "info: unregister device\n"); 833 adapter->if_ops.unregister_dev(adapter); 834 /* Free adapter structure */ 835 dev_dbg(adapter->dev, "info: free adapter\n"); 836 mwifiex_free_adapter(adapter); 837 838exit_remove: 839 up(sem); 840exit_sem_err: 841 return 0; 842} 843EXPORT_SYMBOL_GPL(mwifiex_remove_card); 844 845/* 846 * This function initializes the module. 847 * 848 * The debug FS is also initialized if configured. 849 */ 850static int 851mwifiex_init_module(void) 852{ 853#ifdef CONFIG_DEBUG_FS 854 mwifiex_debugfs_init(); 855#endif 856 return 0; 857} 858 859/* 860 * This function cleans up the module. 861 * 862 * The debug FS is removed if available. 863 */ 864static void 865mwifiex_cleanup_module(void) 866{ 867#ifdef CONFIG_DEBUG_FS 868 mwifiex_debugfs_remove(); 869#endif 870} 871 872module_init(mwifiex_init_module); 873module_exit(mwifiex_cleanup_module); 874 875MODULE_AUTHOR("Marvell International Ltd."); 876MODULE_DESCRIPTION("Marvell WiFi-Ex Driver version " VERSION); 877MODULE_VERSION(VERSION); 878MODULE_LICENSE("GPL v2"); 879