drivers/net/wireless/microchip/wilc1000/netdev.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2012 - 2018 Microchip Technology Inc., and its subsidiaries.
   4  * All rights reserved.
   5  */
   6
   7 #include <linux/irq.h>
   8 #include <linux/kthread.h>
   9 #include <linux/firmware.h>
  10 #include <linux/netdevice.h>
  11 #include <linux/inetdevice.h>
  12
  13 #include "cfg80211.h"
  14 #include "wlan_cfg.h"
  15
  16 #define WILC_MULTICAST_TABLE_SIZE       8
  17
  18 /* latest API version supported */
  19 #define WILC1000_API_VER                1
  20
  21 #define WILC1000_FW_PREFIX              "atmel/wilc1000_wifi_firmware-"
  22 #define __WILC1000_FW(api)              WILC1000_FW_PREFIX #api ".bin"
  23 #define WILC1000_FW(api)                __WILC1000_FW(api)
  24
  25 static irqreturn_t isr_uh_routine(int irq, void *user_data)
  26 {
  27         struct net_device *dev = user_data;
  28         struct wilc_vif *vif = netdev_priv(dev);
  29         struct wilc *wilc = vif->wilc;
  30
  31         if (wilc->close) {
  32                 netdev_err(dev, "Can't handle UH interrupt\n");
  33                 return IRQ_HANDLED;
  34         }
  35         return IRQ_WAKE_THREAD;
  36 }
  37
  38 static irqreturn_t isr_bh_routine(int irq, void *userdata)
  39 {
  40         struct net_device *dev = userdata;
  41         struct wilc_vif *vif = netdev_priv(userdata);
  42         struct wilc *wilc = vif->wilc;
  43
  44         if (wilc->close) {
  45                 netdev_err(dev, "Can't handle BH interrupt\n");
  46                 return IRQ_HANDLED;
  47         }
  48
  49         wilc_handle_isr(wilc);
  50
  51         return IRQ_HANDLED;
  52 }
  53
  54 static int init_irq(struct net_device *dev)
  55 {
  56         struct wilc_vif *vif = netdev_priv(dev);
  57         struct wilc *wl = vif->wilc;
  58         int ret;
  59
  60         ret = request_threaded_irq(wl->dev_irq_num, isr_uh_routine,
  61                                    isr_bh_routine,
  62                                    IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
  63                                    "WILC_IRQ", dev);
  64         if (ret) {
  65                 netdev_err(dev, "Failed to request IRQ [%d]\n", ret);
  66                 return ret;
  67         }
  68         netdev_dbg(dev, "IRQ request succeeded IRQ-NUM= %d\n", wl->dev_irq_num);
  69
  70         return 0;
  71 }
  72
  73 static void deinit_irq(struct net_device *dev)
  74 {
  75         struct wilc_vif *vif = netdev_priv(dev);
  76         struct wilc *wilc = vif->wilc;
  77
  78         /* Deinitialize IRQ */
  79         if (wilc->dev_irq_num)
  80                 free_irq(wilc->dev_irq_num, wilc);
  81 }
  82
  83 void wilc_mac_indicate(struct wilc *wilc)
  84 {
  85         s8 status;
  86
  87         wilc_wlan_cfg_get_val(wilc, WID_STATUS, &status, 1);
  88         if (wilc->mac_status == WILC_MAC_STATUS_INIT) {
  89                 wilc->mac_status = status;
  90                 complete(&wilc->sync_event);
  91         } else {
  92                 wilc->mac_status = status;
  93         }
  94 }
  95
  96 static struct net_device *get_if_handler(struct wilc *wilc, u8 *mac_header)
  97 {
  98         struct net_device *ndev = NULL;
  99         struct wilc_vif *vif;
 100         struct ieee80211_hdr *h = (struct ieee80211_hdr *)mac_header;
 101
 102         list_for_each_entry_rcu(vif, &wilc->vif_list, list) {
 103                 if (vif->mode == WILC_STATION_MODE)
 104                         if (ether_addr_equal_unaligned(h->addr2, vif->bssid)) {
 105                                 ndev = vif->ndev;
 106                                 goto out;
 107                         }
 108                 if (vif->mode == WILC_AP_MODE)
 109                         if (ether_addr_equal_unaligned(h->addr1, vif->bssid)) {
 110                                 ndev = vif->ndev;
 111                                 goto out;
 112                         }
 113         }
 114 out:
 115         return ndev;
 116 }
 117
 118 void wilc_wlan_set_bssid(struct net_device *wilc_netdev, u8 *bssid, u8 mode)
 119 {
 120         struct wilc_vif *vif = netdev_priv(wilc_netdev);
 121
 122         if (bssid)
 123                 ether_addr_copy(vif->bssid, bssid);
 124         else
 125                 eth_zero_addr(vif->bssid);
 126
 127         vif->mode = mode;
 128 }
 129
 130 int wilc_wlan_get_num_conn_ifcs(struct wilc *wilc)
 131 {
 132         int srcu_idx;
 133         u8 ret_val = 0;
 134         struct wilc_vif *vif;
 135
 136         srcu_idx = srcu_read_lock(&wilc->srcu);
 137         list_for_each_entry_rcu(vif, &wilc->vif_list, list) {
 138                 if (!is_zero_ether_addr(vif->bssid))
 139                         ret_val++;
 140         }
 141         srcu_read_unlock(&wilc->srcu, srcu_idx);
 142         return ret_val;
 143 }
 144
 145 static int wilc_txq_task(void *vp)
 146 {
 147         int ret;
 148         u32 txq_count;
 149         struct wilc *wl = vp;
 150
 151         complete(&wl->txq_thread_started);
 152         while (1) {
 153                 wait_for_completion(&wl->txq_event);
 154
 155                 if (wl->close) {
 156                         complete(&wl->txq_thread_started);
 157
 158                         while (!kthread_should_stop())
 159                                 schedule();
 160                         break;
 161                 }
 162                 do {
 163                         ret = wilc_wlan_handle_txq(wl, &txq_count);
 164                         if (txq_count < FLOW_CONTROL_LOWER_THRESHOLD) {
 165                                 int srcu_idx;
 166                                 struct wilc_vif *ifc;
 167
 168                                 srcu_idx = srcu_read_lock(&wl->srcu);
 169                                 list_for_each_entry_rcu(ifc, &wl->vif_list,
 170                                                         list) {
 171                                         if (ifc->mac_opened && ifc->ndev)
 172                                                 netif_wake_queue(ifc->ndev);
 173                                 }
 174                                 srcu_read_unlock(&wl->srcu, srcu_idx);
 175                         }
 176                 } while (ret == WILC_VMM_ENTRY_FULL_RETRY && !wl->close);
 177         }
 178         return 0;
 179 }
 180
 181 static int wilc_wlan_get_firmware(struct net_device *dev)
 182 {
 183         struct wilc_vif *vif = netdev_priv(dev);
 184         struct wilc *wilc = vif->wilc;
 185         int chip_id;
 186         const struct firmware *wilc_fw;
 187         int ret;
 188
 189         chip_id = wilc_get_chipid(wilc, false);
 190
 191         netdev_info(dev, "ChipID [%x] loading firmware [%s]\n", chip_id,
 192                     WILC1000_FW(WILC1000_API_VER));
 193
 194         ret = request_firmware(&wilc_fw, WILC1000_FW(WILC1000_API_VER),
 195                                wilc->dev);
 196         if (ret != 0) {
 197                 netdev_err(dev, "%s - firmware not available\n",
 198                            WILC1000_FW(WILC1000_API_VER));
 199                 return -EINVAL;
 200         }
 201         wilc->firmware = wilc_fw;
 202
 203         return 0;
 204 }
 205
 206 static int wilc_start_firmware(struct net_device *dev)
 207 {
 208         struct wilc_vif *vif = netdev_priv(dev);
 209         struct wilc *wilc = vif->wilc;
 210         int ret = 0;
 211
 212         ret = wilc_wlan_start(wilc);
 213         if (ret)
 214                 return ret;
 215
 216         if (!wait_for_completion_timeout(&wilc->sync_event,
 217                                          msecs_to_jiffies(5000)))
 218                 return -ETIME;
 219
 220         return 0;
 221 }
 222
 223 static int wilc1000_firmware_download(struct net_device *dev)
 224 {
 225         struct wilc_vif *vif = netdev_priv(dev);
 226         struct wilc *wilc = vif->wilc;
 227         int ret = 0;
 228
 229         if (!wilc->firmware) {
 230                 netdev_err(dev, "Firmware buffer is NULL\n");
 231                 return -ENOBUFS;
 232         }
 233
 234         ret = wilc_wlan_firmware_download(wilc, wilc->firmware->data,
 235                                           wilc->firmware->size);
 236         if (ret)
 237                 return ret;
 238
 239         release_firmware(wilc->firmware);
 240         wilc->firmware = NULL;
 241
 242         netdev_dbg(dev, "Download Succeeded\n");
 243
 244         return 0;
 245 }
 246
 247 static int wilc_init_fw_config(struct net_device *dev, struct wilc_vif *vif)
 248 {
 249         struct wilc_priv *priv = &vif->priv;
 250         struct host_if_drv *hif_drv;
 251         u8 b;
 252         u16 hw;
 253         u32 w;
 254
 255         netdev_dbg(dev, "Start configuring Firmware\n");
 256         hif_drv = (struct host_if_drv *)priv->hif_drv;
 257         netdev_dbg(dev, "Host = %p\n", hif_drv);
 258
 259         w = vif->iftype;
 260         cpu_to_le32s(&w);
 261         if (!wilc_wlan_cfg_set(vif, 1, WID_SET_OPERATION_MODE, (u8 *)&w, 4,
 262                                0, 0))
 263                 goto fail;
 264
 265         b = WILC_FW_BSS_TYPE_INFRA;
 266         if (!wilc_wlan_cfg_set(vif, 0, WID_BSS_TYPE, &b, 1, 0, 0))
 267                 goto fail;
 268
 269         b = WILC_FW_TX_RATE_AUTO;
 270         if (!wilc_wlan_cfg_set(vif, 0, WID_CURRENT_TX_RATE, &b, 1, 0, 0))
 271                 goto fail;
 272
 273         b = WILC_FW_OPER_MODE_G_MIXED_11B_2;
 274         if (!wilc_wlan_cfg_set(vif, 0, WID_11G_OPERATING_MODE, &b, 1, 0, 0))
 275                 goto fail;
 276
 277         b = WILC_FW_PREAMBLE_SHORT;
 278         if (!wilc_wlan_cfg_set(vif, 0, WID_PREAMBLE, &b, 1, 0, 0))
 279                 goto fail;
 280
 281         b = WILC_FW_11N_PROT_AUTO;
 282         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_PROT_MECH, &b, 1, 0, 0))
 283                 goto fail;
 284
 285         b = WILC_FW_ACTIVE_SCAN;
 286         if (!wilc_wlan_cfg_set(vif, 0, WID_SCAN_TYPE, &b, 1, 0, 0))
 287                 goto fail;
 288
 289         b = WILC_FW_SITE_SURVEY_OFF;
 290         if (!wilc_wlan_cfg_set(vif, 0, WID_SITE_SURVEY, &b, 1, 0, 0))
 291                 goto fail;
 292
 293         hw = 0xffff;
 294         cpu_to_le16s(&hw);
 295         if (!wilc_wlan_cfg_set(vif, 0, WID_RTS_THRESHOLD, (u8 *)&hw, 2, 0, 0))
 296                 goto fail;
 297
 298         hw = 2346;
 299         cpu_to_le16s(&hw);
 300         if (!wilc_wlan_cfg_set(vif, 0, WID_FRAG_THRESHOLD, (u8 *)&hw, 2, 0, 0))
 301                 goto fail;
 302
 303         b = 0;
 304         if (!wilc_wlan_cfg_set(vif, 0, WID_BCAST_SSID, &b, 1, 0, 0))
 305                 goto fail;
 306
 307         b = 1;
 308         if (!wilc_wlan_cfg_set(vif, 0, WID_QOS_ENABLE, &b, 1, 0, 0))
 309                 goto fail;
 310
 311         b = WILC_FW_NO_POWERSAVE;
 312         if (!wilc_wlan_cfg_set(vif, 0, WID_POWER_MANAGEMENT, &b, 1, 0, 0))
 313                 goto fail;
 314
 315         b = WILC_FW_SEC_NO;
 316         if (!wilc_wlan_cfg_set(vif, 0, WID_11I_MODE, &b, 1, 0, 0))
 317                 goto fail;
 318
 319         b = WILC_FW_AUTH_OPEN_SYSTEM;
 320         if (!wilc_wlan_cfg_set(vif, 0, WID_AUTH_TYPE, &b, 1, 0, 0))
 321                 goto fail;
 322
 323         b = 3;
 324         if (!wilc_wlan_cfg_set(vif, 0, WID_LISTEN_INTERVAL, &b, 1, 0, 0))
 325                 goto fail;
 326
 327         b = 3;
 328         if (!wilc_wlan_cfg_set(vif, 0, WID_DTIM_PERIOD, &b, 1, 0, 0))
 329                 goto fail;
 330
 331         b = WILC_FW_ACK_POLICY_NORMAL;
 332         if (!wilc_wlan_cfg_set(vif, 0, WID_ACK_POLICY, &b, 1, 0, 0))
 333                 goto fail;
 334
 335         b = 0;
 336         if (!wilc_wlan_cfg_set(vif, 0, WID_USER_CONTROL_ON_TX_POWER, &b, 1,
 337                                0, 0))
 338                 goto fail;
 339
 340         b = 48;
 341         if (!wilc_wlan_cfg_set(vif, 0, WID_TX_POWER_LEVEL_11A, &b, 1, 0, 0))
 342                 goto fail;
 343
 344         b = 28;
 345         if (!wilc_wlan_cfg_set(vif, 0, WID_TX_POWER_LEVEL_11B, &b, 1, 0, 0))
 346                 goto fail;
 347
 348         hw = 100;
 349         cpu_to_le16s(&hw);
 350         if (!wilc_wlan_cfg_set(vif, 0, WID_BEACON_INTERVAL, (u8 *)&hw, 2, 0, 0))
 351                 goto fail;
 352
 353         b = WILC_FW_REKEY_POLICY_DISABLE;
 354         if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_POLICY, &b, 1, 0, 0))
 355                 goto fail;
 356
 357         w = 84600;
 358         cpu_to_le32s(&w);
 359         if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_PERIOD, (u8 *)&w, 4, 0, 0))
 360                 goto fail;
 361
 362         w = 500;
 363         cpu_to_le32s(&w);
 364         if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_PACKET_COUNT, (u8 *)&w, 4, 0,
 365                                0))
 366                 goto fail;
 367
 368         b = 1;
 369         if (!wilc_wlan_cfg_set(vif, 0, WID_SHORT_SLOT_ALLOWED, &b, 1, 0,
 370                                0))
 371                 goto fail;
 372
 373         b = WILC_FW_ERP_PROT_SELF_CTS;
 374         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_ERP_PROT_TYPE, &b, 1, 0, 0))
 375                 goto fail;
 376
 377         b = 1;
 378         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_ENABLE, &b, 1, 0, 0))
 379                 goto fail;
 380
 381         b = WILC_FW_11N_OP_MODE_HT_MIXED;
 382         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_OPERATING_MODE, &b, 1, 0, 0))
 383                 goto fail;
 384
 385         b = 1;
 386         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_TXOP_PROT_DISABLE, &b, 1, 0, 0))
 387                 goto fail;
 388
 389         b = WILC_FW_OBBS_NONHT_DETECT_PROTECT_REPORT;
 390         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_OBSS_NONHT_DETECTION, &b, 1,
 391                                0, 0))
 392                 goto fail;
 393
 394         b = WILC_FW_HT_PROT_RTS_CTS_NONHT;
 395         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_HT_PROT_TYPE, &b, 1, 0, 0))
 396                 goto fail;
 397
 398         b = 0;
 399         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_RIFS_PROT_ENABLE, &b, 1, 0,
 400                                0))
 401                 goto fail;
 402
 403         b = 7;
 404         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_CURRENT_TX_MCS, &b, 1, 0, 0))
 405                 goto fail;
 406
 407         b = 1;
 408         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_IMMEDIATE_BA_ENABLED, &b, 1,
 409                                1, 1))
 410                 goto fail;
 411
 412         return 0;
 413
 414 fail:
 415         return -EINVAL;
 416 }
 417
 418 static void wlan_deinitialize_threads(struct net_device *dev)
 419 {
 420         struct wilc_vif *vif = netdev_priv(dev);
 421         struct wilc *wl = vif->wilc;
 422
 423         wl->close = 1;
 424
 425         complete(&wl->txq_event);
 426
 427         if (wl->txq_thread) {
 428                 kthread_stop(wl->txq_thread);
 429                 wl->txq_thread = NULL;
 430         }
 431 }
 432
 433 static void wilc_wlan_deinitialize(struct net_device *dev)
 434 {
 435         struct wilc_vif *vif = netdev_priv(dev);
 436         struct wilc *wl = vif->wilc;
 437
 438         if (!wl) {
 439                 netdev_err(dev, "wl is NULL\n");
 440                 return;
 441         }
 442
 443         if (wl->initialized) {
 444                 netdev_info(dev, "Deinitializing wilc1000...\n");
 445
 446                 if (!wl->dev_irq_num &&
 447                     wl->hif_func->disable_interrupt) {
 448                         mutex_lock(&wl->hif_cs);
 449                         wl->hif_func->disable_interrupt(wl);
 450                         mutex_unlock(&wl->hif_cs);
 451                 }
 452                 complete(&wl->txq_event);
 453
 454                 wlan_deinitialize_threads(dev);
 455                 deinit_irq(dev);
 456
 457                 wilc_wlan_stop(wl, vif);
 458                 wilc_wlan_cleanup(dev);
 459
 460                 wl->initialized = false;
 461
 462                 netdev_dbg(dev, "wilc1000 deinitialization Done\n");
 463         } else {
 464                 netdev_dbg(dev, "wilc1000 is not initialized\n");
 465         }
 466 }
 467
 468 static int wlan_initialize_threads(struct net_device *dev)
 469 {
 470         struct wilc_vif *vif = netdev_priv(dev);
 471         struct wilc *wilc = vif->wilc;
 472
 473         wilc->txq_thread = kthread_run(wilc_txq_task, (void *)wilc,
 474                                        "K_TXQ_TASK");
 475         if (IS_ERR(wilc->txq_thread)) {
 476                 netdev_err(dev, "couldn't create TXQ thread\n");
 477                 wilc->close = 0;
 478                 return PTR_ERR(wilc->txq_thread);
 479         }
 480         wait_for_completion(&wilc->txq_thread_started);
 481
 482         return 0;
 483 }
 484
 485 static int wilc_wlan_initialize(struct net_device *dev, struct wilc_vif *vif)
 486 {
 487         int ret = 0;
 488         struct wilc *wl = vif->wilc;
 489
 490         if (!wl->initialized) {
 491                 wl->mac_status = WILC_MAC_STATUS_INIT;
 492                 wl->close = 0;
 493
 494                 ret = wilc_wlan_init(dev);
 495                 if (ret)
 496                         return ret;
 497
 498                 ret = wlan_initialize_threads(dev);
 499                 if (ret)
 500                         goto fail_wilc_wlan;
 501
 502                 if (wl->dev_irq_num && init_irq(dev)) {
 503                         ret = -EIO;
 504                         goto fail_threads;
 505                 }
 506
 507                 if (!wl->dev_irq_num &&
 508                     wl->hif_func->enable_interrupt &&
 509                     wl->hif_func->enable_interrupt(wl)) {
 510                         ret = -EIO;
 511                         goto fail_irq_init;
 512                 }
 513
 514                 ret = wilc_wlan_get_firmware(dev);
 515                 if (ret)
 516                         goto fail_irq_enable;
 517
 518                 ret = wilc1000_firmware_download(dev);
 519                 if (ret)
 520                         goto fail_irq_enable;
 521
 522                 ret = wilc_start_firmware(dev);
 523                 if (ret)
 524                         goto fail_irq_enable;
 525
 526                 if (wilc_wlan_cfg_get(vif, 1, WID_FIRMWARE_VERSION, 1, 0)) {
 527                         int size;
 528                         char firmware_ver[20];
 529
 530                         size = wilc_wlan_cfg_get_val(wl, WID_FIRMWARE_VERSION,
 531                                                      firmware_ver,
 532                                                      sizeof(firmware_ver));
 533                         firmware_ver[size] = '\0';
 534                         netdev_dbg(dev, "Firmware Ver = %s\n", firmware_ver);
 535                 }
 536
 537                 ret = wilc_init_fw_config(dev, vif);
 538                 if (ret) {
 539                         netdev_err(dev, "Failed to configure firmware\n");
 540                         goto fail_fw_start;
 541                 }
 542                 wl->initialized = true;
 543                 return 0;
 544
 545 fail_fw_start:
 546                 wilc_wlan_stop(wl, vif);
 547
 548 fail_irq_enable:
 549                 if (!wl->dev_irq_num &&
 550                     wl->hif_func->disable_interrupt)
 551                         wl->hif_func->disable_interrupt(wl);
 552 fail_irq_init:
 553                 if (wl->dev_irq_num)
 554                         deinit_irq(dev);
 555 fail_threads:
 556                 wlan_deinitialize_threads(dev);
 557 fail_wilc_wlan:
 558                 wilc_wlan_cleanup(dev);
 559                 netdev_err(dev, "WLAN initialization FAILED\n");
 560         } else {
 561                 netdev_dbg(dev, "wilc1000 already initialized\n");
 562         }
 563         return ret;
 564 }
 565
 566 static int mac_init_fn(struct net_device *ndev)
 567 {
 568         netif_start_queue(ndev);
 569         netif_stop_queue(ndev);
 570
 571         return 0;
 572 }
 573
 574 static int wilc_mac_open(struct net_device *ndev)
 575 {
 576         struct wilc_vif *vif = netdev_priv(ndev);
 577         struct wilc *wl = vif->wilc;
 578         unsigned char mac_add[ETH_ALEN] = {0};
 579         int ret = 0;
 580         struct mgmt_frame_regs mgmt_regs = {};
 581
 582         if (!wl || !wl->dev) {
 583                 netdev_err(ndev, "device not ready\n");
 584                 return -ENODEV;
 585         }
 586
 587         netdev_dbg(ndev, "MAC OPEN[%p]\n", ndev);
 588
 589         ret = wilc_init_host_int(ndev);
 590         if (ret)
 591                 return ret;
 592
 593         ret = wilc_wlan_initialize(ndev, vif);
 594         if (ret) {
 595                 wilc_deinit_host_int(ndev);
 596                 return ret;
 597         }
 598
 599         wilc_set_operation_mode(vif, wilc_get_vif_idx(vif), vif->iftype,
 600                                 vif->idx);
 601         wilc_get_mac_address(vif, mac_add);
 602         netdev_dbg(ndev, "Mac address: %pM\n", mac_add);
 603         ether_addr_copy(ndev->dev_addr, mac_add);
 604
 605         if (!is_valid_ether_addr(ndev->dev_addr)) {
 606                 netdev_err(ndev, "Wrong MAC address\n");
 607                 wilc_deinit_host_int(ndev);
 608                 wilc_wlan_deinitialize(ndev);
 609                 return -EINVAL;
 610         }
 611
 612         mgmt_regs.interface_stypes = vif->mgmt_reg_stypes;
 613         /* so we detect a change */
 614         vif->mgmt_reg_stypes = 0;
 615         wilc_update_mgmt_frame_registrations(vif->ndev->ieee80211_ptr->wiphy,
 616                                              vif->ndev->ieee80211_ptr,
 617                                              &mgmt_regs);
 618         netif_wake_queue(ndev);
 619         wl->open_ifcs++;
 620         vif->mac_opened = 1;
 621         return 0;
 622 }
 623
 624 static struct net_device_stats *mac_stats(struct net_device *dev)
 625 {
 626         struct wilc_vif *vif = netdev_priv(dev);
 627
 628         return &vif->netstats;
 629 }
 630
 631 static int wilc_set_mac_addr(struct net_device *dev, void *p)
 632 {
 633         int result;
 634         struct wilc_vif *vif = netdev_priv(dev);
 635         struct wilc *wilc = vif->wilc;
 636         struct sockaddr *addr = (struct sockaddr *)p;
 637         unsigned char mac_addr[ETH_ALEN];
 638         struct wilc_vif *tmp_vif;
 639         int srcu_idx;
 640
 641         if (!is_valid_ether_addr(addr->sa_data))
 642                 return -EINVAL;
 643
 644         srcu_idx = srcu_read_lock(&wilc->srcu);
 645         list_for_each_entry_rcu(tmp_vif, &wilc->vif_list, list) {
 646                 wilc_get_mac_address(tmp_vif, mac_addr);
 647                 if (ether_addr_equal(addr->sa_data, mac_addr)) {
 648                         if (vif != tmp_vif) {
 649                                 srcu_read_unlock(&wilc->srcu, srcu_idx);
 650                                 return -EINVAL;
 651                         }
 652                         srcu_read_unlock(&wilc->srcu, srcu_idx);
 653                         return 0;
 654                 }
 655         }
 656         srcu_read_unlock(&wilc->srcu, srcu_idx);
 657
 658         result = wilc_set_mac_address(vif, (u8 *)addr->sa_data);
 659         if (result)
 660                 return result;
 661
 662         ether_addr_copy(vif->bssid, addr->sa_data);
 663         ether_addr_copy(vif->ndev->dev_addr, addr->sa_data);
 664
 665         return result;
 666 }
 667
 668 static void wilc_set_multicast_list(struct net_device *dev)
 669 {
 670         struct netdev_hw_addr *ha;
 671         struct wilc_vif *vif = netdev_priv(dev);
 672         int i;
 673         u8 *mc_list;
 674         u8 *cur_mc;
 675
 676         if (dev->flags & IFF_PROMISC)
 677                 return;
 678
 679         if (dev->flags & IFF_ALLMULTI ||
 680             dev->mc.count > WILC_MULTICAST_TABLE_SIZE) {
 681                 wilc_setup_multicast_filter(vif, 0, 0, NULL);
 682                 return;
 683         }
 684
 685         if (dev->mc.count == 0) {
 686                 wilc_setup_multicast_filter(vif, 1, 0, NULL);
 687                 return;
 688         }
 689
 690         mc_list = kmalloc_array(dev->mc.count, ETH_ALEN, GFP_ATOMIC);
 691         if (!mc_list)
 692                 return;
 693
 694         cur_mc = mc_list;
 695         i = 0;
 696         netdev_for_each_mc_addr(ha, dev) {
 697                 memcpy(cur_mc, ha->addr, ETH_ALEN);
 698                 netdev_dbg(dev, "Entry[%d]: %pM\n", i, cur_mc);
 699                 i++;
 700                 cur_mc += ETH_ALEN;
 701         }
 702
 703         if (wilc_setup_multicast_filter(vif, 1, dev->mc.count, mc_list))
 704                 kfree(mc_list);
 705 }
 706
 707 static void wilc_tx_complete(void *priv, int status)
 708 {
 709         struct tx_complete_data *pv_data = priv;
 710
 711         dev_kfree_skb(pv_data->skb);
 712         kfree(pv_data);
 713 }
 714
 715 netdev_tx_t wilc_mac_xmit(struct sk_buff *skb, struct net_device *ndev)
 716 {
 717         struct wilc_vif *vif = netdev_priv(ndev);
 718         struct wilc *wilc = vif->wilc;
 719         struct tx_complete_data *tx_data = NULL;
 720         int queue_count;
 721
 722         if (skb->dev != ndev) {
 723                 netdev_err(ndev, "Packet not destined to this device\n");
 724                 return NETDEV_TX_OK;
 725         }
 726
 727         tx_data = kmalloc(sizeof(*tx_data), GFP_ATOMIC);
 728         if (!tx_data) {
 729                 dev_kfree_skb(skb);
 730                 netif_wake_queue(ndev);
 731                 return NETDEV_TX_OK;
 732         }
 733
 734         tx_data->buff = skb->data;
 735         tx_data->size = skb->len;
 736         tx_data->skb  = skb;
 737
 738         vif->netstats.tx_packets++;
 739         vif->netstats.tx_bytes += tx_data->size;
 740         queue_count = wilc_wlan_txq_add_net_pkt(ndev, (void *)tx_data,
 741                                                 tx_data->buff, tx_data->size,
 742                                                 wilc_tx_complete);
 743
 744         if (queue_count > FLOW_CONTROL_UPPER_THRESHOLD) {
 745                 int srcu_idx;
 746                 struct wilc_vif *vif;
 747
 748                 srcu_idx = srcu_read_lock(&wilc->srcu);
 749                 list_for_each_entry_rcu(vif, &wilc->vif_list, list) {
 750                         if (vif->mac_opened)
 751                                 netif_stop_queue(vif->ndev);
 752                 }
 753                 srcu_read_unlock(&wilc->srcu, srcu_idx);
 754         }
 755
 756         return NETDEV_TX_OK;
 757 }
 758
 759 static int wilc_mac_close(struct net_device *ndev)
 760 {
 761         struct wilc_vif *vif = netdev_priv(ndev);
 762         struct wilc *wl = vif->wilc;
 763
 764         netdev_dbg(ndev, "Mac close\n");
 765
 766         if (wl->open_ifcs > 0)
 767                 wl->open_ifcs--;
 768         else
 769                 return 0;
 770
 771         if (vif->ndev) {
 772                 netif_stop_queue(vif->ndev);
 773
 774                 wilc_deinit_host_int(vif->ndev);
 775         }
 776
 777         if (wl->open_ifcs == 0) {
 778                 netdev_dbg(ndev, "Deinitializing wilc1000\n");
 779                 wl->close = 1;
 780                 wilc_wlan_deinitialize(ndev);
 781         }
 782
 783         vif->mac_opened = 0;
 784
 785         return 0;
 786 }
 787
 788 void wilc_frmw_to_host(struct wilc *wilc, u8 *buff, u32 size,
 789                        u32 pkt_offset)
 790 {
 791         unsigned int frame_len = 0;
 792         int stats;
 793         unsigned char *buff_to_send = NULL;
 794         struct sk_buff *skb;
 795         struct net_device *wilc_netdev;
 796         struct wilc_vif *vif;
 797
 798         if (!wilc)
 799                 return;
 800
 801         wilc_netdev = get_if_handler(wilc, buff);
 802         if (!wilc_netdev)
 803                 return;
 804
 805         buff += pkt_offset;
 806         vif = netdev_priv(wilc_netdev);
 807
 808         if (size > 0) {
 809                 frame_len = size;
 810                 buff_to_send = buff;
 811
 812                 skb = dev_alloc_skb(frame_len);
 813                 if (!skb)
 814                         return;
 815
 816                 skb->dev = wilc_netdev;
 817
 818                 skb_put_data(skb, buff_to_send, frame_len);
 819
 820                 skb->protocol = eth_type_trans(skb, wilc_netdev);
 821                 vif->netstats.rx_packets++;
 822                 vif->netstats.rx_bytes += frame_len;
 823                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 824                 stats = netif_rx(skb);
 825                 netdev_dbg(wilc_netdev, "netif_rx ret value is: %d\n", stats);
 826         }
 827 }
 828
 829 void wilc_wfi_mgmt_rx(struct wilc *wilc, u8 *buff, u32 size)
 830 {
 831         int srcu_idx;
 832         struct wilc_vif *vif;
 833
 834         srcu_idx = srcu_read_lock(&wilc->srcu);
 835         list_for_each_entry_rcu(vif, &wilc->vif_list, list) {
 836                 u16 type = le16_to_cpup((__le16 *)buff);
 837                 u32 type_bit = BIT(type >> 4);
 838
 839                 if (vif->priv.p2p_listen_state &&
 840                     vif->mgmt_reg_stypes & type_bit)
 841                         wilc_wfi_p2p_rx(vif, buff, size);
 842
 843                 if (vif->monitor_flag)
 844                         wilc_wfi_monitor_rx(wilc->monitor_dev, buff, size);
 845         }
 846         srcu_read_unlock(&wilc->srcu, srcu_idx);
 847 }
 848
 849 static const struct net_device_ops wilc_netdev_ops = {
 850         .ndo_init = mac_init_fn,
 851         .ndo_open = wilc_mac_open,
 852         .ndo_stop = wilc_mac_close,
 853         .ndo_set_mac_address = wilc_set_mac_addr,
 854         .ndo_start_xmit = wilc_mac_xmit,
 855         .ndo_get_stats = mac_stats,
 856         .ndo_set_rx_mode  = wilc_set_multicast_list,
 857 };
 858
 859 void wilc_netdev_cleanup(struct wilc *wilc)
 860 {
 861         struct wilc_vif *vif;
 862         int srcu_idx, ifc_cnt = 0;
 863
 864         if (!wilc)
 865                 return;
 866
 867         if (wilc->firmware) {
 868                 release_firmware(wilc->firmware);
 869                 wilc->firmware = NULL;
 870         }
 871
 872         srcu_idx = srcu_read_lock(&wilc->srcu);
 873         list_for_each_entry_rcu(vif, &wilc->vif_list, list) {
 874                 if (vif->ndev)
 875                         unregister_netdev(vif->ndev);
 876         }
 877         srcu_read_unlock(&wilc->srcu, srcu_idx);
 878
 879         wilc_wfi_deinit_mon_interface(wilc, false);
 880         flush_workqueue(wilc->hif_workqueue);
 881         destroy_workqueue(wilc->hif_workqueue);
 882
 883         while (ifc_cnt < WILC_NUM_CONCURRENT_IFC) {
 884                 mutex_lock(&wilc->vif_mutex);
 885                 if (wilc->vif_num <= 0) {
 886                         mutex_unlock(&wilc->vif_mutex);
 887                         break;
 888                 }
 889                 vif = wilc_get_wl_to_vif(wilc);
 890                 if (!IS_ERR(vif))
 891                         list_del_rcu(&vif->list);
 892
 893                 wilc->vif_num--;
 894                 mutex_unlock(&wilc->vif_mutex);
 895                 synchronize_srcu(&wilc->srcu);
 896                 ifc_cnt++;
 897         }
 898
 899         wilc_wlan_cfg_deinit(wilc);
 900         wlan_deinit_locks(wilc);
 901         kfree(wilc->bus_data);
 902         wiphy_unregister(wilc->wiphy);
 903         wiphy_free(wilc->wiphy);
 904 }
 905 EXPORT_SYMBOL_GPL(wilc_netdev_cleanup);
 906
 907 static u8 wilc_get_available_idx(struct wilc *wl)
 908 {
 909         int idx = 0;
 910         struct wilc_vif *vif;
 911         int srcu_idx;
 912
 913         srcu_idx = srcu_read_lock(&wl->srcu);
 914         list_for_each_entry_rcu(vif, &wl->vif_list, list) {
 915                 if (vif->idx == 0)
 916                         idx = 1;
 917                 else
 918                         idx = 0;
 919         }
 920         srcu_read_unlock(&wl->srcu, srcu_idx);
 921         return idx;
 922 }
 923
 924 struct wilc_vif *wilc_netdev_ifc_init(struct wilc *wl, const char *name,
 925                                       int vif_type, enum nl80211_iftype type,
 926                                       bool rtnl_locked)
 927 {
 928         struct net_device *ndev;
 929         struct wilc_vif *vif;
 930         int ret;
 931
 932         ndev = alloc_etherdev(sizeof(*vif));
 933         if (!ndev)
 934                 return ERR_PTR(-ENOMEM);
 935
 936         vif = netdev_priv(ndev);
 937         ndev->ieee80211_ptr = &vif->priv.wdev;
 938         strcpy(ndev->name, name);
 939         vif->wilc = wl;
 940         vif->ndev = ndev;
 941         ndev->ml_priv = vif;
 942
 943         ndev->netdev_ops = &wilc_netdev_ops;
 944
 945         SET_NETDEV_DEV(ndev, wiphy_dev(wl->wiphy));
 946
 947         vif->priv.wdev.wiphy = wl->wiphy;
 948         vif->priv.wdev.netdev = ndev;
 949         vif->priv.wdev.iftype = type;
 950         vif->priv.dev = ndev;
 951
 952         if (rtnl_locked)
 953                 ret = register_netdevice(ndev);
 954         else
 955                 ret = register_netdev(ndev);
 956
 957         if (ret) {
 958                 free_netdev(ndev);
 959                 return ERR_PTR(-EFAULT);
 960         }
 961
 962         ndev->needs_free_netdev = true;
 963         vif->iftype = vif_type;
 964         vif->idx = wilc_get_available_idx(wl);
 965         vif->mac_opened = 0;
 966         mutex_lock(&wl->vif_mutex);
 967         list_add_tail_rcu(&vif->list, &wl->vif_list);
 968         wl->vif_num += 1;
 969         mutex_unlock(&wl->vif_mutex);
 970         synchronize_srcu(&wl->srcu);
 971
 972         return vif;
 973 }
 974
 975 MODULE_LICENSE("GPL");
 976 MODULE_FIRMWARE(WILC1000_FW(WILC1000_API_VER));