drivers/net/wireless/scsc/dev.c

   1 /****************************************************************************
   2  *
   3  * Copyright (c) 2012 - 2019 Samsung Electronics Co., Ltd. All rights reserved
   4  *
   5  ****************************************************************************/
   6
   7 #include "dev.h"
   8 #include "hip.h"
   9 #include "mgt.h"
  10 #include "debug.h"
  11 #include "udi.h"
  12 #include "hip_bh.h"
  13 #include "cfg80211_ops.h"
  14 #include "netif.h"
  15 #include "procfs.h"
  16 #include "ba.h"
  17 #include "nl80211_vendor.h"
  18
  19 #include "sap_mlme.h"
  20 #include "sap_ma.h"
  21 #include "sap_dbg.h"
  22 #include "sap_test.h"
  23
  24 #ifdef CONFIG_SCSC_WLAN_KIC_OPS
  25 #include "kic.h"
  26 #endif
  27
  28 char *slsi_mib_file = "wlan.hcf";
  29 module_param_named(mib_file, slsi_mib_file, charp, S_IRUGO | S_IWUSR);
  30 MODULE_PARM_DESC(mib_file, "mib data filename");
  31
  32 char *slsi_mib_file2 = "wlan_sw.hcf";
  33 module_param_named(mib_file2, slsi_mib_file2, charp, S_IRUGO | S_IWUSR);
  34 MODULE_PARM_DESC(mib_file2, "sw mib data filename");
  35
  36 static char *local_mib_file = "localmib.hcf";
  37 module_param(local_mib_file, charp, S_IRUGO | S_IWUSR);
  38 MODULE_PARM_DESC(local_mib_file, "local mib data filename (Optional extra mib values)");
  39
  40 static char *maddr_file = "mac.txt";
  41 module_param(maddr_file, charp, S_IRUGO | S_IWUSR);
  42 MODULE_PARM_DESC(maddr_file, "mac address filename");
  43
  44 static bool term_udi_users = true;
  45 module_param(term_udi_users, bool, S_IRUGO | S_IWUSR);
  46 MODULE_PARM_DESC(term_udi_users, "Try to terminate UDI user space users (applications) connected on the cdev (0, 1)");
  47
  48 static int sig_wait_cfm_timeout = 6000;
  49 module_param(sig_wait_cfm_timeout, int, S_IRUGO | S_IWUSR);
  50 MODULE_PARM_DESC(sig_wait_cfm_timeout, "Signal wait timeout in milliseconds (default: 3000)");
  51
  52 static bool lls_disabled;
  53 module_param(lls_disabled, bool, S_IRUGO | S_IWUSR);
  54 MODULE_PARM_DESC(lls_disabled, "Disable LLS: to disable LLS set 1");
  55
  56 static bool gscan_disabled = 0;
  57 module_param(gscan_disabled, bool, S_IRUGO | S_IWUSR);
  58 MODULE_PARM_DESC(gscan_disabled, "Disable gscan: to disable gscan set 1");
  59
  60 static bool llslogs_disabled;
  61 module_param(llslogs_disabled, bool, S_IRUGO | S_IWUSR);
  62 MODULE_PARM_DESC(llslogs_disabled, "Disable llslogs: to disable llslogs set 1");
  63
  64 static bool epno_disabled;
  65 module_param(epno_disabled, bool, S_IRUGO | S_IWUSR);
  66 MODULE_PARM_DESC(epno_disabled, "Disable ePNO: to disable ePNO set 1.\nNote: for ePNO to work gscan should be enabled");
  67
  68 static bool vo_vi_block_ack_disabled;
  69 module_param(vo_vi_block_ack_disabled, bool, S_IRUGO | S_IWUSR);
  70 MODULE_PARM_DESC(vo_vi_block_ack_disabled, "Disable VO VI Block Ack logic added for WMM AC Cert : 5.1.4");
  71
  72 static int max_scan_result_count = 200;
  73 module_param(max_scan_result_count, int, S_IRUGO | S_IWUSR);
  74 MODULE_PARM_DESC(max_scan_result_count, "Max scan results to be reported");
  75 static bool rtt_disabled = 1;
  76 module_param(rtt_disabled, bool, S_IRUGO | S_IWUSR);
  77 MODULE_PARM_DESC(rtt_disabled, "Disable rtt: to disable rtt set 1");
  78
  79 static bool nan_disabled;
  80 module_param(nan_disabled, bool, S_IRUGO | S_IWUSR);
  81 MODULE_PARM_DESC(nan_disabled, "Disable NAN: to disable NAN set 1.");
  82
  83 bool slsi_dev_gscan_supported(void)
  84 {
  85         return !gscan_disabled;
  86 }
  87
  88 bool slsi_dev_rtt_supported(void)
  89 {
  90         return !rtt_disabled;
  91 }
  92
  93 bool slsi_dev_llslogs_supported(void)
  94 {
  95         return !llslogs_disabled;
  96 }
  97
  98 bool slsi_dev_lls_supported(void)
  99 {
 100         return !lls_disabled;
 101 }
 102
 103 bool slsi_dev_epno_supported(void)
 104 {
 105         return !epno_disabled;
 106 }
 107
 108 bool slsi_dev_vo_vi_block_ack(void)
 109 {
 110         return vo_vi_block_ack_disabled;
 111 }
 112
 113 int slsi_dev_get_scan_result_count(void)
 114 {
 115         return max_scan_result_count;
 116 }
 117
 118 int slsi_dev_nan_supported(struct slsi_dev *sdev)
 119 {
 120 #if CONFIG_SCSC_WLAN_MAX_INTERFACES >= 4
 121         if (sdev)
 122                 return sdev->nan_enabled && !nan_disabled;
 123         return false;
 124 #else
 125         return false;
 126 #endif
 127 }
 128
 129 static int slsi_dev_inetaddr_changed(struct notifier_block *nb, unsigned long data, void *arg)
 130 {
 131         struct slsi_dev     *sdev = container_of(nb, struct slsi_dev, inetaddr_notifier);
 132         struct in_ifaddr    *ifa = arg;
 133         struct net_device   *dev = ifa->ifa_dev->dev;
 134         struct wireless_dev *wdev = dev->ieee80211_ptr;
 135         struct netdev_vif   *ndev_vif = netdev_priv(dev);
 136
 137         if (!wdev)
 138                 return NOTIFY_DONE;
 139
 140         if (wdev->wiphy != sdev->wiphy)
 141                 return NOTIFY_DONE;
 142
 143         if (data == NETDEV_DOWN) {
 144                 SLSI_NET_DBG2(dev, SLSI_NETDEV, "Returning 0 for NETDEV_DOWN event\n");
 145                 return 0;
 146         }
 147
 148         SLSI_NET_INFO(dev, "IP: %pI4\n", &ifa->ifa_address);
 149         SLSI_MUTEX_LOCK(ndev_vif->vif_mutex);
 150 #if !defined SLSI_TEST_DEV && defined CONFIG_ANDROID
 151         if (SLSI_IS_VIF_INDEX_WLAN(ndev_vif) && wake_lock_active(&sdev->wlan_wl_roam)) {
 152                 SLSI_NET_DBG2(dev, SLSI_NETDEV, "Releasing the roaming wakelock\n");
 153                 wake_unlock(&sdev->wlan_wl_roam);
 154                 /* If upper layers included wps ie in connect but the actually
 155                  * connection is not for wps, reset the wps flag.
 156                  */
 157                 if (ndev_vif->sta.is_wps) {
 158                         SLSI_NET_DBG1(dev, SLSI_NETDEV,
 159                                       "is_wps set but not wps connection.\n");
 160                         ndev_vif->sta.is_wps = false;
 161                 }
 162         }
 163 #endif
 164         slsi_ip_address_changed(sdev, dev, ifa->ifa_address);
 165         SLSI_MUTEX_UNLOCK(ndev_vif->vif_mutex);
 166         return 0;
 167 }
 168
 169 #ifndef CONFIG_SCSC_WLAN_BLOCK_IPV6
 170 static int slsi_dev_inet6addr_changed(struct notifier_block *nb, unsigned long data, void *arg)
 171 {
 172         struct slsi_dev     *sdev = container_of(nb, struct slsi_dev, inet6addr_notifier);
 173         struct inet6_ifaddr *ifa = arg;
 174         struct net_device   *dev = ifa->idev->dev;
 175         struct wireless_dev *wdev = dev->ieee80211_ptr;
 176         struct netdev_vif   *ndev_vif = netdev_priv(dev);
 177
 178         (void)data; /* unused */
 179
 180         if (!wdev)
 181                 return NOTIFY_DONE;
 182
 183         if (wdev->wiphy != sdev->wiphy)
 184                 return NOTIFY_DONE;
 185
 186         SLSI_NET_INFO(dev, "IPv6: %pI6\n", &ifa->addr.s6_addr);
 187
 188         slsi_spinlock_lock(&ndev_vif->ipv6addr_lock);
 189         memcpy(&ndev_vif->ipv6address, &ifa->addr, sizeof(struct in6_addr));
 190         slsi_spinlock_unlock(&ndev_vif->ipv6addr_lock);
 191
 192         return 0;
 193 }
 194 #endif
 195
 196 void slsi_regd_init(struct slsi_dev *sdev)
 197 {
 198         struct ieee80211_regdomain *slsi_world_regdom_custom = sdev->device_config.domain_info.regdomain;
 199         struct ieee80211_reg_rule  reg_rules[] = {
 200                 /* Channel 1 - 11*/
 201                 REG_RULE(2412 - 10, 2462 + 10, 40, 0, 20, 0),
 202 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 14, 0))
 203                 /* Channel 12 - 13 NO_IR*/
 204                 REG_RULE(2467 - 10, 2472 + 10, 40, 0, 20, NL80211_RRF_NO_IR),
 205 #endif
 206                 /* Channel 36 - 48 */
 207                 REG_RULE(5180 - 10, 5240 + 10, 80, 0, 20, 0),
 208                 /* Channel 52 - 64 */
 209                 REG_RULE(5260 - 10, 5320 + 10, 80, 0, 20, NL80211_RRF_DFS),
 210                 /* Channel 100 - 140 */
 211                 REG_RULE(5500 - 10, 5700 + 10, 80, 0, 20, NL80211_RRF_DFS),
 212                 /* Channel 149 - 165 */
 213                 REG_RULE(5745 - 10, 5825 + 10, 80, 0, 20, 0),
 214         };
 215
 216         int                        i;
 217
 218         SLSI_DBG1_NODEV(SLSI_INIT_DEINIT, "regulatory init\n");
 219         slsi_world_regdom_custom->n_reg_rules = 6;
 220         for (i = 0; i < slsi_world_regdom_custom->n_reg_rules; i++)
 221                 slsi_world_regdom_custom->reg_rules[i] = reg_rules[i];
 222
 223         /* Country code '00' indicates world regulatory domain */
 224         slsi_world_regdom_custom->alpha2[0] = '0';
 225         slsi_world_regdom_custom->alpha2[1] = '0';
 226
 227         wiphy_apply_custom_regulatory(sdev->wiphy, slsi_world_regdom_custom);
 228 }
 229
 230 struct slsi_dev *slsi_dev_attach(struct device *dev, struct scsc_mx *core, struct scsc_service_client *mx_wlan_client)
 231 {
 232         struct slsi_dev *sdev;
 233         int i;
 234
 235         SLSI_DBG1_NODEV(SLSI_INIT_DEINIT, "Add Device\n");
 236
 237         sdev = slsi_cfg80211_new(dev);
 238         if (!sdev) {
 239                 SLSI_ERR_NODEV("No sdev\n");
 240                 return NULL;
 241         }
 242
 243         sdev->mlme_blocked = false;
 244
 245         SLSI_MUTEX_INIT(sdev->netdev_add_remove_mutex);
 246         mutex_init(&sdev->netdev_remove_mutex);
 247         SLSI_MUTEX_INIT(sdev->start_stop_mutex);
 248         SLSI_MUTEX_INIT(sdev->device_config_mutex);
 249         SLSI_MUTEX_INIT(sdev->logger_mutex);
 250
 251         sdev->dev = dev;
 252         sdev->maxwell_core = core;
 253         memcpy(&sdev->mx_wlan_client, mx_wlan_client, sizeof(struct scsc_service_client));
 254
 255         sdev->fail_reported = false;
 256         sdev->p2p_certif = false;
 257         sdev->allow_switch_40_mhz = true;
 258         sdev->allow_switch_80_mhz = true;
 259         sdev->mib[0].mib_file_name = slsi_mib_file;
 260         sdev->mib[1].mib_file_name = slsi_mib_file2;
 261         sdev->local_mib.mib_file_name = local_mib_file;
 262         sdev->maddr_file_name = maddr_file;
 263         sdev->device_config.qos_info = -1;
 264         sdev->acs_channel_switched = false;
 265         memset(&sdev->chip_info_mib, 0xFF, sizeof(struct slsi_chip_info_mib));
 266
 267 #ifdef CONFIG_SCSC_WLAN_WIFI_SHARING
 268         sdev->num_5g_restricted_channels = 0;
 269 #endif
 270
 271 #ifdef CONFIG_SCSC_WLAN_WES_NCHO
 272         sdev->device_config.okc_mode = 0;
 273         sdev->device_config.wes_mode = 0;
 274         sdev->device_config.roam_scan_mode = 0;
 275 #endif
 276
 277         slsi_log_clients_init(sdev);
 278
 279         slsi_wakelock_init(&sdev->wlan_wl, "wlan");
 280         slsi_wakelock_init(&sdev->wlan_wl_mlme, "wlan_mlme");
 281         slsi_wakelock_init(&sdev->wlan_wl_ma, "wlan_ma");
 282 #if !defined SLSI_TEST_DEV && defined CONFIG_ANDROID
 283         wake_lock_init(&sdev->wlan_wl_roam, WAKE_LOCK_SUSPEND, "wlan_roam");
 284 #endif
 285         sdev->recovery_next_state = 0;
 286         init_completion(&sdev->recovery_remove_completion);
 287         init_completion(&sdev->recovery_stop_completion);
 288         init_completion(&sdev->recovery_completed);
 289         sdev->recovery_status = 0;
 290
 291         sdev->term_udi_users         = &term_udi_users;
 292         sdev->sig_wait_cfm_timeout   = &sig_wait_cfm_timeout;
 293         slsi_sig_send_init(&sdev->sig_wait);
 294
 295         for (i = 0; i < SLSI_LLS_AC_MAX; i++)
 296                 atomic_set(&sdev->tx_host_tag[i], ((1 << 2) | i));
 297
 298         if (slsi_skb_work_init(sdev, NULL, &sdev->rx_dbg_sap, "slsi_wlan_rx_dbg_sap", slsi_rx_dbg_sap_work) != 0)
 299                 goto err_if;
 300
 301         if (slsi_netif_init(sdev) != 0) {
 302                 SLSI_ERR(sdev, "Can not create the network interface\n");
 303                 goto err_ctrl_wq_init;
 304         }
 305
 306         if (slsi_hip_init(sdev, dev) != 0) {
 307                 SLSI_ERR(sdev, "slsi_hip_init() Failed\n");
 308                 goto err_netif_init;
 309         }
 310
 311         if (slsi_udi_node_init(sdev, dev) != 0) {
 312                 SLSI_ERR(sdev, "failed to init UDI\n");
 313                 goto err_hip_init;
 314         }
 315
 316         slsi_create_proc_dir(sdev);
 317         slsi_traffic_mon_clients_init(sdev);
 318
 319         /* update regulatory domain */
 320         slsi_regd_init(sdev);
 321
 322 #ifdef CONFIG_SCSC_WLAN_GSCAN_ENABLE
 323         slsi_nl80211_vendor_init(sdev);
 324 #endif
 325
 326         if (slsi_cfg80211_register(sdev) != 0) {
 327                 SLSI_ERR(sdev, "failed to register with cfg80211\n");
 328                 goto err_udi_proc_init;
 329         }
 330
 331 #ifndef CONFIG_SCSC_WLAN_BLOCK_IPV6
 332         sdev->inet6addr_notifier.notifier_call = slsi_dev_inet6addr_changed;
 333         if (register_inet6addr_notifier(&sdev->inet6addr_notifier) != 0) {
 334                 SLSI_ERR(sdev, "failed to register inet6addr_notifier\n");
 335                 goto err_cfg80211_registered;
 336         }
 337 #endif
 338
 339         sdev->inetaddr_notifier.notifier_call = slsi_dev_inetaddr_changed;
 340         if (register_inetaddr_notifier(&sdev->inetaddr_notifier) != 0) {
 341                 SLSI_ERR(sdev, "failed to register inetaddr_notifier\n");
 342 #ifndef CONFIG_SCSC_WLAN_BLOCK_IPV6
 343                 unregister_inet6addr_notifier(&sdev->inet6addr_notifier);
 344 #endif
 345                 goto err_cfg80211_registered;
 346         }
 347
 348 #ifdef SLSI_TEST_DEV
 349         slsi_init_netdev_mac_addr(sdev);
 350 #endif
 351         slsi_rx_ba_init(sdev);
 352
 353         if (slsi_netif_register(sdev, sdev->netdev[SLSI_NET_INDEX_WLAN]) != 0) {
 354                 SLSI_ERR(sdev, "failed to register with wlan netdev\n");
 355                 goto err_inetaddr_registered;
 356         }
 357 #ifdef CONFIG_SCSC_WLAN_STA_ONLY
 358         SLSI_ERR(sdev, "CONFIG_SCSC_WLAN_STA_ONLY: not registering p2p netdev\n");
 359 #else
 360         if (slsi_netif_register(sdev, sdev->netdev[SLSI_NET_INDEX_P2P]) != 0) {
 361                 SLSI_ERR(sdev, "failed to register with p2p netdev\n");
 362                 goto err_wlan_registered;
 363         }
 364 #ifdef CONFIG_SCSC_WLAN_WIFI_SHARING
 365 #if defined(CONFIG_SCSC_WLAN_MHS_STATIC_INTERFACE) || (defined(ANDROID_VERSION) && ANDROID_VERSION >= 90000)
 366         if (slsi_netif_register(sdev, sdev->netdev[SLSI_NET_INDEX_P2PX_SWLAN]) != 0) {
 367                 SLSI_ERR(sdev, "failed to register with p2px_wlan1 netdev\n");
 368                 goto err_p2p_registered;
 369         }
 370         rcu_assign_pointer(sdev->netdev_ap, sdev->netdev[SLSI_NET_INDEX_P2PX_SWLAN]);
 371 #endif
 372 #endif
 373 #if CONFIG_SCSC_WLAN_MAX_INTERFACES >= 4
 374         if (slsi_netif_register(sdev, sdev->netdev[SLSI_NET_INDEX_NAN]) != 0) {
 375                 SLSI_ERR(sdev, "failed to register with NAN netdev\n");
 376 #ifdef CONFIG_SCSC_WLAN_WIFI_SHARING
 377 #if defined(CONFIG_SCSC_WLAN_MHS_STATIC_INTERFACE) || (defined(ANDROID_VERSION) && ANDROID_VERSION >= 90000)
 378                 goto err_p2px_wlan_registered;
 379 #else
 380                 goto err_p2p_registered;
 381 #endif
 382 #else
 383                 goto err_p2p_registered;
 384 #endif
 385         }
 386 #endif
 387 #endif
 388 #ifdef CONFIG_SCSC_WLAN_KIC_OPS
 389         if (wifi_kic_register(sdev) < 0)
 390                 SLSI_ERR(sdev, "failed to register Wi-Fi KIC ops\n");
 391 #endif
 392 #ifdef CONFIG_SCSC_WLAN_ENHANCED_PKT_FILTER
 393         sdev->enhanced_pkt_filter_enabled = true;
 394 #endif
 395         sdev->device_state = SLSI_DEVICE_STATE_STOPPED;
 396         sdev->current_tspec_id = -1;
 397         sdev->tspec_error_code = -1;
 398
 399         /* Driver workqueue used to queue work in different modes (STA/P2P/HS2) */
 400         sdev->device_wq = alloc_ordered_workqueue("slsi_wlan_wq", 0);
 401         if (!sdev->device_wq) {
 402                 SLSI_ERR(sdev, "Cannot allocate workqueue\n");
 403 #if CONFIG_SCSC_WLAN_MAX_INTERFACES >= 4
 404                 goto err_nan_registered;
 405 #else
 406 #ifdef CONFIG_SCSC_WLAN_WIFI_SHARING
 407 #if defined(CONFIG_SCSC_WLAN_MHS_STATIC_INTERFACE) || (defined(ANDROID_VERSION) && ANDROID_VERSION >= 90000)
 408                 goto err_p2px_wlan_registered;
 409 #else
 410                 goto err_p2p_registered;
 411 #endif
 412 #else
 413                 goto err_p2p_registered;
 414 #endif
 415 #endif
 416         }
 417 #ifdef CONFIG_SCSC_WLAN_SILENT_RECOVERY
 418         INIT_WORK(&sdev->recovery_work, slsi_subsystem_reset);
 419 #endif
 420         return sdev;
 421
 422 #if CONFIG_SCSC_WLAN_MAX_INTERFACES >= 4
 423 err_nan_registered:
 424         slsi_netif_remove(sdev, sdev->netdev[SLSI_NET_INDEX_NAN]);
 425 #endif
 426
 427 #ifdef CONFIG_SCSC_WLAN_WIFI_SHARING
 428 #if defined(CONFIG_SCSC_WLAN_MHS_STATIC_INTERFACE) || (defined(ANDROID_VERSION) && ANDROID_VERSION >= 90000)
 429 err_p2px_wlan_registered:
 430         slsi_netif_remove(sdev, sdev->netdev[SLSI_NET_INDEX_P2PX_SWLAN]);
 431         rcu_assign_pointer(sdev->netdev_ap, NULL);
 432 #endif
 433 #endif
 434
 435 err_p2p_registered:
 436         slsi_netif_remove(sdev, sdev->netdev[SLSI_NET_INDEX_P2P]);
 437
 438 err_wlan_registered:
 439         slsi_netif_remove(sdev, sdev->netdev[SLSI_NET_INDEX_WLAN]);
 440
 441 err_inetaddr_registered:
 442         unregister_inetaddr_notifier(&sdev->inetaddr_notifier);
 443 #ifndef CONFIG_SCSC_WLAN_BLOCK_IPV6
 444         unregister_inet6addr_notifier(&sdev->inet6addr_notifier);
 445 #endif
 446
 447 err_cfg80211_registered:
 448         slsi_cfg80211_unregister(sdev);
 449
 450 err_udi_proc_init:
 451         slsi_traffic_mon_clients_deinit(sdev);
 452         slsi_remove_proc_dir(sdev);
 453         slsi_udi_node_deinit(sdev);
 454
 455 err_hip_init:
 456         slsi_hip_deinit(sdev);
 457
 458 err_netif_init:
 459         slsi_netif_deinit(sdev);
 460
 461 err_ctrl_wq_init:
 462         slsi_skb_work_deinit(&sdev->rx_dbg_sap);
 463
 464 err_if:
 465         slsi_wakelock_exit(&sdev->wlan_wl);
 466         slsi_wakelock_exit(&sdev->wlan_wl_mlme);
 467         slsi_wakelock_exit(&sdev->wlan_wl_ma);
 468 #if !defined SLSI_TEST_DEV && defined CONFIG_ANDROID
 469         wake_lock_destroy(&sdev->wlan_wl_roam);
 470 #endif
 471         slsi_cfg80211_free(sdev);
 472         return NULL;
 473 }
 474
 475 void slsi_dev_detach(struct slsi_dev *sdev)
 476 {
 477         SLSI_DBG1(sdev, SLSI_INIT_DEINIT, "Remove Device\n");
 478
 479         slsi_stop(sdev);
 480
 481 #ifdef CONFIG_SCSC_WLAN_KIC_OPS
 482         wifi_kic_unregister();
 483 #endif
 484         complete_all(&sdev->sig_wait.completion);
 485         complete_all(&sdev->recovery_remove_completion);
 486         complete_all(&sdev->recovery_stop_completion);
 487         complete_all(&sdev->recovery_completed);
 488
 489         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "Unregister inetaddr_notifier\n");
 490         unregister_inetaddr_notifier(&sdev->inetaddr_notifier);
 491
 492 #ifndef CONFIG_SCSC_WLAN_BLOCK_IPV6
 493         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "Unregister inet6addr_notifier\n");
 494         unregister_inet6addr_notifier(&sdev->inet6addr_notifier);
 495 #endif
 496
 497         WARN_ON(!sdev->device_wq);
 498         if (sdev->device_wq)
 499                 flush_workqueue(sdev->device_wq);
 500
 501 #ifdef CONFIG_SCSC_WLAN_GSCAN_ENABLE
 502         slsi_nl80211_vendor_deinit(sdev);
 503 #endif
 504
 505         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "Unregister netif\n");
 506         slsi_netif_remove_all(sdev);
 507
 508         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "Unregister cfg80211\n");
 509         slsi_cfg80211_unregister(sdev);
 510
 511         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "Remove proc entries\n");
 512         slsi_remove_proc_dir(sdev);
 513
 514         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "De-initialise the Traffic monitor\n");
 515         slsi_traffic_mon_clients_deinit(sdev);
 516
 517         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "De-initialise the UDI\n");
 518         slsi_log_clients_terminate(sdev);
 519         slsi_udi_node_deinit(sdev);
 520
 521         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "De-initialise Hip\n");
 522         slsi_hip_deinit(sdev);
 523
 524         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "De-initialise netif\n");
 525         slsi_netif_deinit(sdev);
 526
 527         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "De-initialise Regulatory\n");
 528         slsi_regd_deinit(sdev);
 529
 530         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "Stop Work Queues\n");
 531         slsi_skb_work_deinit(&sdev->rx_dbg_sap);
 532
 533         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "Clean up wakelock\n");
 534         slsi_wakelock_exit(&sdev->wlan_wl);
 535         slsi_wakelock_exit(&sdev->wlan_wl_mlme);
 536         slsi_wakelock_exit(&sdev->wlan_wl_ma);
 537 #if !defined SLSI_TEST_DEV && defined CONFIG_ANDROID
 538         wake_lock_destroy(&sdev->wlan_wl_roam);
 539 #endif
 540
 541         SLSI_DBG2(sdev, SLSI_INIT_DEINIT, "Free cfg80211\n");
 542         slsi_cfg80211_free(sdev);
 543
 544         slsi_dbg_track_skb_report();
 545         slsi_dbg_track_skb_reset();
 546 }
 547
 548 int __init slsi_dev_load(void)
 549 {
 550         SLSI_INFO_NODEV("Loading Maxwell Wi-Fi driver\n");
 551
 552         slsi_dbg_track_skb_init();
 553
 554         if (slsi_udi_init())
 555                 SLSI_INFO_NODEV("Failed to init udi - continuing\n");
 556
 557         if (slsi_sm_service_driver_register())
 558                 SLSI_INFO_NODEV("slsi_sm_service_driver_register failed - continuing\n");
 559
 560         /* Register SAPs */
 561         sap_mlme_init();
 562         sap_ma_init();
 563         sap_dbg_init();
 564         sap_test_init();
 565
 566 /* Always create devnode if TW Android P on */
 567 #if defined(ANDROID_VERSION) && ANDROID_VERSION >= 90000
 568         slsi_create_sysfs_macaddr();
 569 #endif
 570         SLSI_INFO_NODEV("--- Maxwell Wi-Fi driver loaded successfully ---\n");
 571         return 0;
 572 }
 573
 574 void __exit slsi_dev_unload(void)
 575 {
 576         SLSI_INFO_NODEV("Unloading Maxwell Wi-Fi driver\n");
 577
 578 #if defined(ANDROID_VERSION) && ANDROID_VERSION >= 90000
 579         slsi_destroy_sysfs_macaddr();
 580 #endif
 581         /* Unregister SAPs */
 582         sap_mlme_deinit();
 583         sap_ma_deinit();
 584         sap_dbg_deinit();
 585         sap_test_deinit();
 586
 587         slsi_sm_service_driver_unregister();
 588
 589         slsi_udi_deinit();
 590
 591         SLSI_INFO_NODEV("--- Maxwell Wi-Fi driver unloaded successfully ---\n");
 592 }
 593
 594 module_init(slsi_dev_load);
 595 module_exit(slsi_dev_unload);
 596
 597 MODULE_DESCRIPTION("mx140 Wi-Fi Driver");
 598 MODULE_AUTHOR("SLSI");
 599 MODULE_LICENSE("GPL and additional rights");