drivers/staging/wilc1000/linux_wlan.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 "wilc_wfi_cfgoperations.h"
  14
  15 bool wilc_enable_ps = true;
  16
  17 static int dev_state_ev_handler(struct notifier_block *this,
  18                                 unsigned long event, void *ptr)
  19 {
  20         struct in_ifaddr *dev_iface = ptr;
  21         struct wilc_priv *priv;
  22         struct host_if_drv *hif_drv;
  23         struct net_device *dev;
  24         u8 *ip_addr_buf;
  25         struct wilc_vif *vif;
  26         u8 null_ip[4] = {0};
  27         char wlan_dev_name[5] = "wlan0";
  28
  29         if (!dev_iface || !dev_iface->ifa_dev || !dev_iface->ifa_dev->dev)
  30                 return NOTIFY_DONE;
  31
  32         if (memcmp(dev_iface->ifa_label, "wlan0", 5) &&
  33             memcmp(dev_iface->ifa_label, "p2p0", 4))
  34                 return NOTIFY_DONE;
  35
  36         dev  = (struct net_device *)dev_iface->ifa_dev->dev;
  37         if (!dev->ieee80211_ptr || !dev->ieee80211_ptr->wiphy)
  38                 return NOTIFY_DONE;
  39
  40         priv = wiphy_priv(dev->ieee80211_ptr->wiphy);
  41         if (!priv)
  42                 return NOTIFY_DONE;
  43
  44         hif_drv = (struct host_if_drv *)priv->hif_drv;
  45         vif = netdev_priv(dev);
  46         if (!vif || !hif_drv)
  47                 return NOTIFY_DONE;
  48
  49         switch (event) {
  50         case NETDEV_UP:
  51                 if (vif->iftype == STATION_MODE || vif->iftype == CLIENT_MODE) {
  52                         hif_drv->ifc_up = 1;
  53                         wilc_optaining_ip = false;
  54                         del_timer(&wilc_during_ip_timer);
  55                 }
  56
  57                 if (wilc_enable_ps)
  58                         wilc_set_power_mgmt(vif, 1, 0);
  59
  60                 netdev_dbg(dev, "[%s] Up IP\n", dev_iface->ifa_label);
  61
  62                 ip_addr_buf = (char *)&dev_iface->ifa_address;
  63                 netdev_dbg(dev, "IP add=%d:%d:%d:%d\n",
  64                            ip_addr_buf[0], ip_addr_buf[1],
  65                            ip_addr_buf[2], ip_addr_buf[3]);
  66                 wilc_setup_ipaddress(vif, ip_addr_buf, vif->idx);
  67
  68                 break;
  69
  70         case NETDEV_DOWN:
  71                 if (vif->iftype == STATION_MODE || vif->iftype == CLIENT_MODE) {
  72                         hif_drv->ifc_up = 0;
  73                         wilc_optaining_ip = false;
  74                 }
  75
  76                 if (memcmp(dev_iface->ifa_label, wlan_dev_name, 5) == 0)
  77                         wilc_set_power_mgmt(vif, 0, 0);
  78
  79                 wilc_resolve_disconnect_aberration(vif);
  80
  81                 netdev_dbg(dev, "[%s] Down IP\n", dev_iface->ifa_label);
  82
  83                 ip_addr_buf = null_ip;
  84                 netdev_dbg(dev, "IP add=%d:%d:%d:%d\n",
  85                            ip_addr_buf[0], ip_addr_buf[1],
  86                            ip_addr_buf[2], ip_addr_buf[3]);
  87
  88                 wilc_setup_ipaddress(vif, ip_addr_buf, vif->idx);
  89
  90                 break;
  91
  92         default:
  93                 break;
  94         }
  95
  96         return NOTIFY_DONE;
  97 }
  98
  99 static irqreturn_t isr_uh_routine(int irq, void *user_data)
 100 {
 101         struct net_device *dev = user_data;
 102         struct wilc_vif *vif = netdev_priv(dev);
 103         struct wilc *wilc = vif->wilc;
 104
 105         if (wilc->close) {
 106                 netdev_err(dev, "Can't handle UH interrupt\n");
 107                 return IRQ_HANDLED;
 108         }
 109         return IRQ_WAKE_THREAD;
 110 }
 111
 112 static irqreturn_t isr_bh_routine(int irq, void *userdata)
 113 {
 114         struct net_device *dev = userdata;
 115         struct wilc_vif *vif = netdev_priv(userdata);
 116         struct wilc *wilc = vif->wilc;
 117
 118         if (wilc->close) {
 119                 netdev_err(dev, "Can't handle BH interrupt\n");
 120                 return IRQ_HANDLED;
 121         }
 122
 123         wilc_handle_isr(wilc);
 124
 125         return IRQ_HANDLED;
 126 }
 127
 128 static int init_irq(struct net_device *dev)
 129 {
 130         int ret = 0;
 131         struct wilc_vif *vif = netdev_priv(dev);
 132         struct wilc *wl = vif->wilc;
 133
 134         ret = gpiod_direction_input(wl->gpio_irq);
 135         if (ret) {
 136                 netdev_err(dev, "could not obtain gpio for WILC_INTR\n");
 137                 return ret;
 138         }
 139
 140         wl->dev_irq_num = gpiod_to_irq(wl->gpio_irq);
 141
 142         ret = request_threaded_irq(wl->dev_irq_num, isr_uh_routine,
 143                                    isr_bh_routine,
 144                                    IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 145                                    "WILC_IRQ", dev);
 146         if (ret < 0)
 147                 netdev_err(dev, "Failed to request IRQ\n");
 148         else
 149                 netdev_dbg(dev, "IRQ request succeeded IRQ-NUM= %d\n",
 150                            wl->dev_irq_num);
 151
 152         return ret;
 153 }
 154
 155 static void deinit_irq(struct net_device *dev)
 156 {
 157         struct wilc_vif *vif = netdev_priv(dev);
 158         struct wilc *wilc = vif->wilc;
 159
 160         /* Deinitialize IRQ */
 161         if (wilc->dev_irq_num)
 162                 free_irq(wilc->dev_irq_num, wilc);
 163 }
 164
 165 void wilc_mac_indicate(struct wilc *wilc)
 166 {
 167         int status;
 168
 169         wilc_wlan_cfg_get_val(WID_STATUS, (unsigned char *)&status, 4);
 170         if (wilc->mac_status == MAC_STATUS_INIT) {
 171                 wilc->mac_status = status;
 172                 complete(&wilc->sync_event);
 173         } else {
 174                 wilc->mac_status = status;
 175         }
 176 }
 177
 178 static struct net_device *get_if_handler(struct wilc *wilc, u8 *mac_header)
 179 {
 180         u8 *bssid, *bssid1;
 181         int i = 0;
 182
 183         bssid = mac_header + 10;
 184         bssid1 = mac_header + 4;
 185
 186         for (i = 0; i < wilc->vif_num; i++) {
 187                 if (wilc->vif[i]->mode == STATION_MODE)
 188                         if (ether_addr_equal_unaligned(bssid,
 189                                                        wilc->vif[i]->bssid))
 190                                 return wilc->vif[i]->ndev;
 191                 if (wilc->vif[i]->mode == AP_MODE)
 192                         if (ether_addr_equal_unaligned(bssid1,
 193                                                        wilc->vif[i]->bssid))
 194                                 return wilc->vif[i]->ndev;
 195         }
 196
 197         return NULL;
 198 }
 199
 200 int wilc_wlan_set_bssid(struct net_device *wilc_netdev, u8 *bssid, u8 mode)
 201 {
 202         struct wilc_vif *vif = netdev_priv(wilc_netdev);
 203
 204         memcpy(vif->bssid, bssid, 6);
 205         vif->mode = mode;
 206
 207         return 0;
 208 }
 209
 210 int wilc_wlan_get_num_conn_ifcs(struct wilc *wilc)
 211 {
 212         u8 i = 0;
 213         u8 null_bssid[6] = {0};
 214         u8 ret_val = 0;
 215
 216         for (i = 0; i < wilc->vif_num; i++)
 217                 if (memcmp(wilc->vif[i]->bssid, null_bssid, 6))
 218                         ret_val++;
 219
 220         return ret_val;
 221 }
 222
 223 static int linux_wlan_txq_task(void *vp)
 224 {
 225         int ret;
 226         u32 txq_count;
 227         struct net_device *dev = vp;
 228         struct wilc_vif *vif = netdev_priv(dev);
 229         struct wilc *wl = vif->wilc;
 230
 231         complete(&wl->txq_thread_started);
 232         while (1) {
 233                 wait_for_completion(&wl->txq_event);
 234
 235                 if (wl->close) {
 236                         complete(&wl->txq_thread_started);
 237
 238                         while (!kthread_should_stop())
 239                                 schedule();
 240                         break;
 241                 }
 242                 do {
 243                         ret = wilc_wlan_handle_txq(dev, &txq_count);
 244                         if (txq_count < FLOW_CONTROL_LOWER_THRESHOLD) {
 245                                 if (netif_queue_stopped(wl->vif[0]->ndev))
 246                                         netif_wake_queue(wl->vif[0]->ndev);
 247                                 if (netif_queue_stopped(wl->vif[1]->ndev))
 248                                         netif_wake_queue(wl->vif[1]->ndev);
 249                         }
 250                 } while (ret == WILC_TX_ERR_NO_BUF && !wl->close);
 251         }
 252         return 0;
 253 }
 254
 255 static int wilc_wlan_get_firmware(struct net_device *dev)
 256 {
 257         struct wilc_vif *vif = netdev_priv(dev);
 258         struct wilc *wilc = vif->wilc;
 259         int chip_id, ret = 0;
 260         const struct firmware *wilc_firmware;
 261         char *firmware;
 262
 263         chip_id = wilc_get_chipid(wilc, false);
 264
 265         if (chip_id < 0x1003a0)
 266                 firmware = FIRMWARE_1002;
 267         else
 268                 firmware = FIRMWARE_1003;
 269
 270         netdev_info(dev, "loading firmware %s\n", firmware);
 271
 272         if (!(&vif->ndev->dev))
 273                 goto fail;
 274
 275         if (reject_firmware(&wilc_firmware, firmware, wilc->dev) != 0) {
 276                 netdev_err(dev, "%s - firmware not available\n", firmware);
 277                 ret = -1;
 278                 goto fail;
 279         }
 280         wilc->firmware = wilc_firmware;
 281
 282 fail:
 283
 284         return ret;
 285 }
 286
 287 static int linux_wlan_start_firmware(struct net_device *dev)
 288 {
 289         struct wilc_vif *vif = netdev_priv(dev);
 290         struct wilc *wilc = vif->wilc;
 291         int ret = 0;
 292
 293         ret = wilc_wlan_start(wilc);
 294         if (ret < 0)
 295                 return ret;
 296
 297         if (!wait_for_completion_timeout(&wilc->sync_event,
 298                                          msecs_to_jiffies(5000)))
 299                 return -ETIME;
 300
 301         return 0;
 302 }
 303
 304 static int wilc1000_firmware_download(struct net_device *dev)
 305 {
 306         struct wilc_vif *vif = netdev_priv(dev);
 307         struct wilc *wilc = vif->wilc;
 308         int ret = 0;
 309
 310         if (!wilc->firmware) {
 311                 netdev_err(dev, "Firmware buffer is NULL\n");
 312                 return -ENOBUFS;
 313         }
 314
 315         ret = wilc_wlan_firmware_download(wilc, wilc->firmware->data,
 316                                           wilc->firmware->size);
 317         if (ret < 0)
 318                 return ret;
 319
 320         release_firmware(wilc->firmware);
 321         wilc->firmware = NULL;
 322
 323         netdev_dbg(dev, "Download Succeeded\n");
 324
 325         return 0;
 326 }
 327
 328 static int linux_wlan_init_test_config(struct net_device *dev,
 329                                        struct wilc_vif *vif)
 330 {
 331         unsigned char c_val[64];
 332         struct wilc *wilc = vif->wilc;
 333         struct wilc_priv *priv;
 334         struct host_if_drv *hif_drv;
 335
 336         netdev_dbg(dev, "Start configuring Firmware\n");
 337         priv = wiphy_priv(dev->ieee80211_ptr->wiphy);
 338         hif_drv = (struct host_if_drv *)priv->hif_drv;
 339         netdev_dbg(dev, "Host = %p\n", hif_drv);
 340         wilc_get_chipid(wilc, false);
 341
 342         *(int *)c_val = 1;
 343
 344         if (!wilc_wlan_cfg_set(vif, 1, WID_SET_DRV_HANDLER, c_val, 4, 0, 0))
 345                 goto fail;
 346
 347         c_val[0] = 0;
 348         if (!wilc_wlan_cfg_set(vif, 0, WID_PC_TEST_MODE, c_val, 1, 0, 0))
 349                 goto fail;
 350
 351         c_val[0] = INFRASTRUCTURE;
 352         if (!wilc_wlan_cfg_set(vif, 0, WID_BSS_TYPE, c_val, 1, 0, 0))
 353                 goto fail;
 354
 355         c_val[0] = AUTORATE;
 356         if (!wilc_wlan_cfg_set(vif, 0, WID_CURRENT_TX_RATE, c_val, 1, 0, 0))
 357                 goto fail;
 358
 359         c_val[0] = G_MIXED_11B_2_MODE;
 360         if (!wilc_wlan_cfg_set(vif, 0, WID_11G_OPERATING_MODE, c_val, 1, 0,
 361                                0))
 362                 goto fail;
 363
 364         c_val[0] = 1;
 365         if (!wilc_wlan_cfg_set(vif, 0, WID_CURRENT_CHANNEL, c_val, 1, 0, 0))
 366                 goto fail;
 367
 368         c_val[0] = G_SHORT_PREAMBLE;
 369         if (!wilc_wlan_cfg_set(vif, 0, WID_PREAMBLE, c_val, 1, 0, 0))
 370                 goto fail;
 371
 372         c_val[0] = AUTO_PROT;
 373         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_PROT_MECH, c_val, 1, 0, 0))
 374                 goto fail;
 375
 376         c_val[0] = ACTIVE_SCAN;
 377         if (!wilc_wlan_cfg_set(vif, 0, WID_SCAN_TYPE, c_val, 1, 0, 0))
 378                 goto fail;
 379
 380         c_val[0] = SITE_SURVEY_OFF;
 381         if (!wilc_wlan_cfg_set(vif, 0, WID_SITE_SURVEY, c_val, 1, 0, 0))
 382                 goto fail;
 383
 384         *((int *)c_val) = 0xffff;
 385         if (!wilc_wlan_cfg_set(vif, 0, WID_RTS_THRESHOLD, c_val, 2, 0, 0))
 386                 goto fail;
 387
 388         *((int *)c_val) = 2346;
 389         if (!wilc_wlan_cfg_set(vif, 0, WID_FRAG_THRESHOLD, c_val, 2, 0, 0))
 390                 goto fail;
 391
 392         c_val[0] = 0;
 393         if (!wilc_wlan_cfg_set(vif, 0, WID_BCAST_SSID, c_val, 1, 0, 0))
 394                 goto fail;
 395
 396         c_val[0] = 1;
 397         if (!wilc_wlan_cfg_set(vif, 0, WID_QOS_ENABLE, c_val, 1, 0, 0))
 398                 goto fail;
 399
 400         c_val[0] = NO_POWERSAVE;
 401         if (!wilc_wlan_cfg_set(vif, 0, WID_POWER_MANAGEMENT, c_val, 1, 0, 0))
 402                 goto fail;
 403
 404         c_val[0] = NO_SECURITY; /* NO_ENCRYPT, 0x79 */
 405         if (!wilc_wlan_cfg_set(vif, 0, WID_11I_MODE, c_val, 1, 0, 0))
 406                 goto fail;
 407
 408         c_val[0] = OPEN_SYSTEM;
 409         if (!wilc_wlan_cfg_set(vif, 0, WID_AUTH_TYPE, c_val, 1, 0, 0))
 410                 goto fail;
 411
 412         strcpy(c_val, "123456790abcdef1234567890");
 413         if (!wilc_wlan_cfg_set(vif, 0, WID_WEP_KEY_VALUE, c_val,
 414                                (strlen(c_val) + 1), 0, 0))
 415                 goto fail;
 416
 417         strcpy(c_val, "12345678");
 418         if (!wilc_wlan_cfg_set(vif, 0, WID_11I_PSK, c_val, (strlen(c_val)), 0,
 419                                0))
 420                 goto fail;
 421
 422         strcpy(c_val, "password");
 423         if (!wilc_wlan_cfg_set(vif, 0, WID_1X_KEY, c_val, (strlen(c_val) + 1),
 424                                0, 0))
 425                 goto fail;
 426
 427         c_val[0] = 192;
 428         c_val[1] = 168;
 429         c_val[2] = 1;
 430         c_val[3] = 112;
 431         if (!wilc_wlan_cfg_set(vif, 0, WID_1X_SERV_ADDR, c_val, 4, 0, 0))
 432                 goto fail;
 433
 434         c_val[0] = 3;
 435         if (!wilc_wlan_cfg_set(vif, 0, WID_LISTEN_INTERVAL, c_val, 1, 0, 0))
 436                 goto fail;
 437
 438         c_val[0] = 3;
 439         if (!wilc_wlan_cfg_set(vif, 0, WID_DTIM_PERIOD, c_val, 1, 0, 0))
 440                 goto fail;
 441
 442         c_val[0] = NORMAL_ACK;
 443         if (!wilc_wlan_cfg_set(vif, 0, WID_ACK_POLICY, c_val, 1, 0, 0))
 444                 goto fail;
 445
 446         c_val[0] = 0;
 447         if (!wilc_wlan_cfg_set(vif, 0, WID_USER_CONTROL_ON_TX_POWER, c_val, 1,
 448                                0, 0))
 449                 goto fail;
 450
 451         c_val[0] = 48;
 452         if (!wilc_wlan_cfg_set(vif, 0, WID_TX_POWER_LEVEL_11A, c_val, 1, 0,
 453                                0))
 454                 goto fail;
 455
 456         c_val[0] = 28;
 457         if (!wilc_wlan_cfg_set(vif, 0, WID_TX_POWER_LEVEL_11B, c_val, 1, 0,
 458                                0))
 459                 goto fail;
 460
 461         *((int *)c_val) = 100;
 462         if (!wilc_wlan_cfg_set(vif, 0, WID_BEACON_INTERVAL, c_val, 2, 0, 0))
 463                 goto fail;
 464
 465         c_val[0] = REKEY_DISABLE;
 466         if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_POLICY, c_val, 1, 0, 0))
 467                 goto fail;
 468
 469         *((int *)c_val) = 84600;
 470         if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_PERIOD, c_val, 4, 0, 0))
 471                 goto fail;
 472
 473         *((int *)c_val) = 500;
 474         if (!wilc_wlan_cfg_set(vif, 0, WID_REKEY_PACKET_COUNT, c_val, 4, 0,
 475                                0))
 476                 goto fail;
 477
 478         c_val[0] = 1;
 479         if (!wilc_wlan_cfg_set(vif, 0, WID_SHORT_SLOT_ALLOWED, c_val, 1, 0,
 480                                0))
 481                 goto fail;
 482
 483         c_val[0] = G_SELF_CTS_PROT;
 484         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_ERP_PROT_TYPE, c_val, 1, 0, 0))
 485                 goto fail;
 486
 487         c_val[0] = 1;
 488         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_ENABLE, c_val, 1, 0, 0))
 489                 goto fail;
 490
 491         c_val[0] = HT_MIXED_MODE;
 492         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_OPERATING_MODE, c_val, 1, 0,
 493                                0))
 494                 goto fail;
 495
 496         c_val[0] = 1;
 497         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_TXOP_PROT_DISABLE, c_val, 1, 0,
 498                                0))
 499                 goto fail;
 500
 501         c_val[0] = DETECT_PROTECT_REPORT;
 502         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_OBSS_NONHT_DETECTION, c_val, 1,
 503                                0, 0))
 504                 goto fail;
 505
 506         c_val[0] = RTS_CTS_NONHT_PROT;
 507         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_HT_PROT_TYPE, c_val, 1, 0, 0))
 508                 goto fail;
 509
 510         c_val[0] = 0;
 511         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_RIFS_PROT_ENABLE, c_val, 1, 0,
 512                                0))
 513                 goto fail;
 514
 515         c_val[0] = MIMO_MODE;
 516         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_SMPS_MODE, c_val, 1, 0, 0))
 517                 goto fail;
 518
 519         c_val[0] = 7;
 520         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_CURRENT_TX_MCS, c_val, 1, 0,
 521                                0))
 522                 goto fail;
 523
 524         c_val[0] = 1;
 525         if (!wilc_wlan_cfg_set(vif, 0, WID_11N_IMMEDIATE_BA_ENABLED, c_val, 1,
 526                                1, 1))
 527                 goto fail;
 528
 529         return 0;
 530
 531 fail:
 532         return -1;
 533 }
 534
 535 static int wlan_deinit_locks(struct net_device *dev)
 536 {
 537         struct wilc_vif *vif = netdev_priv(dev);
 538         struct wilc *wilc = vif->wilc;
 539
 540         mutex_destroy(&wilc->hif_cs);
 541         mutex_destroy(&wilc->rxq_cs);
 542         mutex_destroy(&wilc->txq_add_to_head_cs);
 543
 544         return 0;
 545 }
 546
 547 static void wlan_deinitialize_threads(struct net_device *dev)
 548 {
 549         struct wilc_vif *vif = netdev_priv(dev);
 550         struct wilc *wl = vif->wilc;
 551
 552         wl->close = 1;
 553
 554         complete(&wl->txq_event);
 555
 556         if (wl->txq_thread) {
 557                 kthread_stop(wl->txq_thread);
 558                 wl->txq_thread = NULL;
 559         }
 560 }
 561
 562 static void wilc_wlan_deinitialize(struct net_device *dev)
 563 {
 564         struct wilc_vif *vif = netdev_priv(dev);
 565         struct wilc *wl = vif->wilc;
 566
 567         if (!wl) {
 568                 netdev_err(dev, "wl is NULL\n");
 569                 return;
 570         }
 571
 572         if (wl->initialized) {
 573                 netdev_info(dev, "Deinitializing wilc1000...\n");
 574
 575                 if (!wl->dev_irq_num &&
 576                     wl->hif_func->disable_interrupt) {
 577                         mutex_lock(&wl->hif_cs);
 578                         wl->hif_func->disable_interrupt(wl);
 579                         mutex_unlock(&wl->hif_cs);
 580                 }
 581                 complete(&wl->txq_event);
 582
 583                 wlan_deinitialize_threads(dev);
 584                 deinit_irq(dev);
 585
 586                 wilc_wlan_stop(wl);
 587                 wilc_wlan_cleanup(dev);
 588                 wlan_deinit_locks(dev);
 589
 590                 wl->initialized = false;
 591
 592                 netdev_dbg(dev, "wilc1000 deinitialization Done\n");
 593         } else {
 594                 netdev_dbg(dev, "wilc1000 is not initialized\n");
 595         }
 596 }
 597
 598 static int wlan_init_locks(struct net_device *dev)
 599 {
 600         struct wilc_vif *vif = netdev_priv(dev);
 601         struct wilc *wl = vif->wilc;
 602
 603         mutex_init(&wl->hif_cs);
 604         mutex_init(&wl->rxq_cs);
 605
 606         spin_lock_init(&wl->txq_spinlock);
 607         mutex_init(&wl->txq_add_to_head_cs);
 608
 609         init_completion(&wl->txq_event);
 610
 611         init_completion(&wl->cfg_event);
 612         init_completion(&wl->sync_event);
 613         init_completion(&wl->txq_thread_started);
 614
 615         return 0;
 616 }
 617
 618 static int wlan_initialize_threads(struct net_device *dev)
 619 {
 620         struct wilc_vif *vif = netdev_priv(dev);
 621         struct wilc *wilc = vif->wilc;
 622
 623         wilc->txq_thread = kthread_run(linux_wlan_txq_task, (void *)dev,
 624                                        "K_TXQ_TASK");
 625         if (IS_ERR(wilc->txq_thread)) {
 626                 netdev_err(dev, "couldn't create TXQ thread\n");
 627                 wilc->close = 0;
 628                 return PTR_ERR(wilc->txq_thread);
 629         }
 630         wait_for_completion(&wilc->txq_thread_started);
 631
 632         return 0;
 633 }
 634
 635 static int wilc_wlan_initialize(struct net_device *dev, struct wilc_vif *vif)
 636 {
 637         int ret = 0;
 638         struct wilc *wl = vif->wilc;
 639
 640         if (!wl->initialized) {
 641                 wl->mac_status = MAC_STATUS_INIT;
 642                 wl->close = 0;
 643
 644                 wlan_init_locks(dev);
 645
 646                 ret = wilc_wlan_init(dev);
 647                 if (ret < 0) {
 648                         ret = -EIO;
 649                         goto fail_locks;
 650                 }
 651
 652                 ret = wlan_initialize_threads(dev);
 653                 if (ret < 0) {
 654                         ret = -EIO;
 655                         goto fail_wilc_wlan;
 656                 }
 657
 658                 if (wl->gpio_irq && init_irq(dev)) {
 659                         ret = -EIO;
 660                         goto fail_threads;
 661                 }
 662
 663                 if (!wl->dev_irq_num &&
 664                     wl->hif_func->enable_interrupt &&
 665                     wl->hif_func->enable_interrupt(wl)) {
 666                         ret = -EIO;
 667                         goto fail_irq_init;
 668                 }
 669
 670                 if (wilc_wlan_get_firmware(dev)) {
 671                         ret = -EIO;
 672                         goto fail_irq_enable;
 673                 }
 674
 675                 ret = wilc1000_firmware_download(dev);
 676                 if (ret < 0) {
 677                         ret = -EIO;
 678                         goto fail_irq_enable;
 679                 }
 680
 681                 ret = linux_wlan_start_firmware(dev);
 682                 if (ret < 0) {
 683                         ret = -EIO;
 684                         goto fail_irq_enable;
 685                 }
 686
 687                 if (wilc_wlan_cfg_get(vif, 1, WID_FIRMWARE_VERSION, 1, 0)) {
 688                         int size;
 689                         char firmware_ver[20];
 690
 691                         size = wilc_wlan_cfg_get_val(WID_FIRMWARE_VERSION,
 692                                                      firmware_ver,
 693                                                      sizeof(firmware_ver));
 694                         firmware_ver[size] = '\0';
 695                         netdev_dbg(dev, "Firmware Ver = %s\n", firmware_ver);
 696                 }
 697                 ret = linux_wlan_init_test_config(dev, vif);
 698
 699                 if (ret < 0) {
 700                         netdev_err(dev, "Failed to configure firmware\n");
 701                         ret = -EIO;
 702                         goto fail_fw_start;
 703                 }
 704
 705                 wl->initialized = true;
 706                 return 0;
 707
 708 fail_fw_start:
 709                 wilc_wlan_stop(wl);
 710
 711 fail_irq_enable:
 712                 if (!wl->dev_irq_num &&
 713                     wl->hif_func->disable_interrupt)
 714                         wl->hif_func->disable_interrupt(wl);
 715 fail_irq_init:
 716                 if (wl->dev_irq_num)
 717                         deinit_irq(dev);
 718 fail_threads:
 719                 wlan_deinitialize_threads(dev);
 720 fail_wilc_wlan:
 721                 wilc_wlan_cleanup(dev);
 722 fail_locks:
 723                 wlan_deinit_locks(dev);
 724                 netdev_err(dev, "WLAN initialization FAILED\n");
 725         } else {
 726                 netdev_dbg(dev, "wilc1000 already initialized\n");
 727         }
 728         return ret;
 729 }
 730
 731 static int mac_init_fn(struct net_device *ndev)
 732 {
 733         netif_start_queue(ndev);
 734         netif_stop_queue(ndev);
 735
 736         return 0;
 737 }
 738
 739 static int wilc_mac_open(struct net_device *ndev)
 740 {
 741         struct wilc_vif *vif = netdev_priv(ndev);
 742         struct wilc *wl = vif->wilc;
 743         unsigned char mac_add[ETH_ALEN] = {0};
 744         int ret = 0;
 745         int i = 0;
 746
 747         if (!wl || !wl->dev) {
 748                 netdev_err(ndev, "device not ready\n");
 749                 return -ENODEV;
 750         }
 751
 752         netdev_dbg(ndev, "MAC OPEN[%p]\n", ndev);
 753
 754         ret = wilc_init_host_int(ndev);
 755         if (ret < 0)
 756                 return ret;
 757
 758         ret = wilc_wlan_initialize(ndev, vif);
 759         if (ret < 0) {
 760                 wilc_deinit_host_int(ndev);
 761                 return ret;
 762         }
 763
 764         for (i = 0; i < wl->vif_num; i++) {
 765                 if (ndev == wl->vif[i]->ndev) {
 766                         wilc_set_wfi_drv_handler(vif, wilc_get_vif_idx(vif),
 767                                                  vif->iftype, vif->ifc_id);
 768                         wilc_set_operation_mode(vif, vif->iftype);
 769                         break;
 770                 }
 771         }
 772
 773         wilc_get_mac_address(vif, mac_add);
 774         netdev_dbg(ndev, "Mac address: %pM\n", mac_add);
 775         memcpy(wl->vif[i]->src_addr, mac_add, ETH_ALEN);
 776         memcpy(ndev->dev_addr, wl->vif[i]->src_addr, ETH_ALEN);
 777
 778         if (!is_valid_ether_addr(ndev->dev_addr)) {
 779                 netdev_err(ndev, "Wrong MAC address\n");
 780                 wilc_deinit_host_int(ndev);
 781                 wilc_wlan_deinitialize(ndev);
 782                 return -EINVAL;
 783         }
 784
 785         wilc_mgmt_frame_register(vif->ndev->ieee80211_ptr->wiphy,
 786                                  vif->ndev->ieee80211_ptr,
 787                                  vif->frame_reg[0].type,
 788                                  vif->frame_reg[0].reg);
 789         wilc_mgmt_frame_register(vif->ndev->ieee80211_ptr->wiphy,
 790                                  vif->ndev->ieee80211_ptr,
 791                                  vif->frame_reg[1].type,
 792                                  vif->frame_reg[1].reg);
 793         netif_wake_queue(ndev);
 794         wl->open_ifcs++;
 795         vif->mac_opened = 1;
 796         return 0;
 797 }
 798
 799 static struct net_device_stats *mac_stats(struct net_device *dev)
 800 {
 801         struct wilc_vif *vif = netdev_priv(dev);
 802
 803         return &vif->netstats;
 804 }
 805
 806 static void wilc_set_multicast_list(struct net_device *dev)
 807 {
 808         struct netdev_hw_addr *ha;
 809         struct wilc_vif *vif = netdev_priv(dev);
 810         int i = 0;
 811
 812         if (dev->flags & IFF_PROMISC)
 813                 return;
 814
 815         if (dev->flags & IFF_ALLMULTI ||
 816             dev->mc.count > WILC_MULTICAST_TABLE_SIZE) {
 817                 wilc_setup_multicast_filter(vif, false, 0);
 818                 return;
 819         }
 820
 821         if (dev->mc.count == 0) {
 822                 wilc_setup_multicast_filter(vif, true, 0);
 823                 return;
 824         }
 825
 826         netdev_for_each_mc_addr(ha, dev) {
 827                 memcpy(wilc_multicast_mac_addr_list[i], ha->addr, ETH_ALEN);
 828                 netdev_dbg(dev, "Entry[%d]: %x:%x:%x:%x:%x:%x\n", i,
 829                            wilc_multicast_mac_addr_list[i][0],
 830                            wilc_multicast_mac_addr_list[i][1],
 831                            wilc_multicast_mac_addr_list[i][2],
 832                            wilc_multicast_mac_addr_list[i][3],
 833                            wilc_multicast_mac_addr_list[i][4],
 834                            wilc_multicast_mac_addr_list[i][5]);
 835                 i++;
 836         }
 837
 838         wilc_setup_multicast_filter(vif, true, (dev->mc.count));
 839 }
 840
 841 static void linux_wlan_tx_complete(void *priv, int status)
 842 {
 843         struct tx_complete_data *pv_data = priv;
 844
 845         dev_kfree_skb(pv_data->skb);
 846         kfree(pv_data);
 847 }
 848
 849 netdev_tx_t wilc_mac_xmit(struct sk_buff *skb, struct net_device *ndev)
 850 {
 851         struct wilc_vif *vif = netdev_priv(ndev);
 852         struct wilc *wilc = vif->wilc;
 853         struct tx_complete_data *tx_data = NULL;
 854         int queue_count;
 855         char *udp_buf;
 856         struct iphdr *ih;
 857         struct ethhdr *eth_h;
 858
 859         if (skb->dev != ndev) {
 860                 netdev_err(ndev, "Packet not destined to this device\n");
 861                 return 0;
 862         }
 863
 864         tx_data = kmalloc(sizeof(*tx_data), GFP_ATOMIC);
 865         if (!tx_data) {
 866                 dev_kfree_skb(skb);
 867                 netif_wake_queue(ndev);
 868                 return 0;
 869         }
 870
 871         tx_data->buff = skb->data;
 872         tx_data->size = skb->len;
 873         tx_data->skb  = skb;
 874
 875         eth_h = (struct ethhdr *)(skb->data);
 876         if (eth_h->h_proto == cpu_to_be16(0x8e88))
 877                 netdev_dbg(ndev, "EAPOL transmitted\n");
 878
 879         ih = (struct iphdr *)(skb->data + sizeof(struct ethhdr));
 880
 881         udp_buf = (char *)ih + sizeof(struct iphdr);
 882         if ((udp_buf[1] == 68 && udp_buf[3] == 67) ||
 883             (udp_buf[1] == 67 && udp_buf[3] == 68))
 884                 netdev_dbg(ndev, "DHCP Message transmitted, type:%x %x %x\n",
 885                            udp_buf[248], udp_buf[249], udp_buf[250]);
 886
 887         vif->netstats.tx_packets++;
 888         vif->netstats.tx_bytes += tx_data->size;
 889         tx_data->bssid = wilc->vif[vif->idx]->bssid;
 890         queue_count = wilc_wlan_txq_add_net_pkt(ndev, (void *)tx_data,
 891                                                 tx_data->buff, tx_data->size,
 892                                                 linux_wlan_tx_complete);
 893
 894         if (queue_count > FLOW_CONTROL_UPPER_THRESHOLD) {
 895                 netif_stop_queue(wilc->vif[0]->ndev);
 896                 netif_stop_queue(wilc->vif[1]->ndev);
 897         }
 898
 899         return 0;
 900 }
 901
 902 static int wilc_mac_close(struct net_device *ndev)
 903 {
 904         struct wilc_priv *priv;
 905         struct wilc_vif *vif = netdev_priv(ndev);
 906         struct host_if_drv *hif_drv;
 907         struct wilc *wl;
 908
 909         if (!vif || !vif->ndev || !vif->ndev->ieee80211_ptr ||
 910             !vif->ndev->ieee80211_ptr->wiphy)
 911                 return 0;
 912
 913         priv = wiphy_priv(vif->ndev->ieee80211_ptr->wiphy);
 914         wl = vif->wilc;
 915
 916         if (!priv)
 917                 return 0;
 918
 919         hif_drv = (struct host_if_drv *)priv->hif_drv;
 920
 921         netdev_dbg(ndev, "Mac close\n");
 922
 923         if (!wl)
 924                 return 0;
 925
 926         if (!hif_drv)
 927                 return 0;
 928
 929         if (wl->open_ifcs > 0)
 930                 wl->open_ifcs--;
 931         else
 932                 return 0;
 933
 934         if (vif->ndev) {
 935                 netif_stop_queue(vif->ndev);
 936
 937                 wilc_deinit_host_int(vif->ndev);
 938         }
 939
 940         if (wl->open_ifcs == 0) {
 941                 netdev_dbg(ndev, "Deinitializing wilc1000\n");
 942                 wl->close = 1;
 943                 wilc_wlan_deinitialize(ndev);
 944                 wilc_wfi_deinit_mon_interface();
 945         }
 946
 947         vif->mac_opened = 0;
 948
 949         return 0;
 950 }
 951
 952 void wilc_frmw_to_linux(struct wilc *wilc, u8 *buff, u32 size, u32 pkt_offset)
 953 {
 954         unsigned int frame_len = 0;
 955         int stats;
 956         unsigned char *buff_to_send = NULL;
 957         struct sk_buff *skb;
 958         struct net_device *wilc_netdev;
 959         struct wilc_vif *vif;
 960
 961         if (!wilc)
 962                 return;
 963
 964         wilc_netdev = get_if_handler(wilc, buff);
 965         if (!wilc_netdev)
 966                 return;
 967
 968         buff += pkt_offset;
 969         vif = netdev_priv(wilc_netdev);
 970
 971         if (size > 0) {
 972                 frame_len = size;
 973                 buff_to_send = buff;
 974
 975                 skb = dev_alloc_skb(frame_len);
 976                 if (!skb)
 977                         return;
 978
 979                 skb->dev = wilc_netdev;
 980
 981                 skb_put_data(skb, buff_to_send, frame_len);
 982
 983                 skb->protocol = eth_type_trans(skb, wilc_netdev);
 984                 vif->netstats.rx_packets++;
 985                 vif->netstats.rx_bytes += frame_len;
 986                 skb->ip_summed = CHECKSUM_UNNECESSARY;
 987                 stats = netif_rx(skb);
 988                 netdev_dbg(wilc_netdev, "netif_rx ret value is: %d\n", stats);
 989         }
 990 }
 991
 992 void wilc_wfi_mgmt_rx(struct wilc *wilc, u8 *buff, u32 size)
 993 {
 994         int i = 0;
 995         struct wilc_vif *vif;
 996
 997         for (i = 0; i < wilc->vif_num; i++) {
 998                 vif = netdev_priv(wilc->vif[i]->ndev);
 999                 if (vif->monitor_flag) {
1000                         wilc_wfi_monitor_rx(buff, size);
1001                         return;
1002                 }
1003         }
1004
1005         vif = netdev_priv(wilc->vif[1]->ndev);
1006         if ((buff[0] == vif->frame_reg[0].type && vif->frame_reg[0].reg) ||
1007             (buff[0] == vif->frame_reg[1].type && vif->frame_reg[1].reg))
1008                 wilc_wfi_p2p_rx(wilc->vif[1]->ndev, buff, size);
1009 }
1010
1011 static struct notifier_block g_dev_notifier = {
1012         .notifier_call = dev_state_ev_handler
1013 };
1014
1015 void wilc_netdev_cleanup(struct wilc *wilc)
1016 {
1017         int i;
1018
1019         if (wilc && (wilc->vif[0]->ndev || wilc->vif[1]->ndev))
1020                 unregister_inetaddr_notifier(&g_dev_notifier);
1021
1022         if (wilc && wilc->firmware) {
1023                 release_firmware(wilc->firmware);
1024                 wilc->firmware = NULL;
1025         }
1026
1027         if (wilc && (wilc->vif[0]->ndev || wilc->vif[1]->ndev)) {
1028                 for (i = 0; i < NUM_CONCURRENT_IFC; i++)
1029                         if (wilc->vif[i]->ndev)
1030                                 if (wilc->vif[i]->mac_opened)
1031                                         wilc_mac_close(wilc->vif[i]->ndev);
1032
1033                 for (i = 0; i < NUM_CONCURRENT_IFC; i++) {
1034                         unregister_netdev(wilc->vif[i]->ndev);
1035                         wilc_free_wiphy(wilc->vif[i]->ndev);
1036                         free_netdev(wilc->vif[i]->ndev);
1037                 }
1038         }
1039
1040         kfree(wilc);
1041 }
1042 EXPORT_SYMBOL_GPL(wilc_netdev_cleanup);
1043
1044 static const struct net_device_ops wilc_netdev_ops = {
1045         .ndo_init = mac_init_fn,
1046         .ndo_open = wilc_mac_open,
1047         .ndo_stop = wilc_mac_close,
1048         .ndo_start_xmit = wilc_mac_xmit,
1049         .ndo_get_stats = mac_stats,
1050         .ndo_set_rx_mode  = wilc_set_multicast_list,
1051 };
1052
1053 int wilc_netdev_init(struct wilc **wilc, struct device *dev, int io_type,
1054                      const struct wilc_hif_func *ops)
1055 {
1056         int i, ret;
1057         struct wilc_vif *vif;
1058         struct net_device *ndev;
1059         struct wilc *wl;
1060
1061         wl = kzalloc(sizeof(*wl), GFP_KERNEL);
1062         if (!wl)
1063                 return -ENOMEM;
1064
1065         *wilc = wl;
1066         wl->io_type = io_type;
1067         wl->hif_func = ops;
1068         INIT_LIST_HEAD(&wl->txq_head.list);
1069         INIT_LIST_HEAD(&wl->rxq_head.list);
1070
1071         register_inetaddr_notifier(&g_dev_notifier);
1072
1073         for (i = 0; i < NUM_CONCURRENT_IFC; i++) {
1074                 struct wireless_dev *wdev;
1075
1076                 ndev = alloc_etherdev(sizeof(struct wilc_vif));
1077                 if (!ndev)
1078                         return -ENOMEM;
1079
1080                 vif = netdev_priv(ndev);
1081                 memset(vif, 0, sizeof(struct wilc_vif));
1082
1083                 if (i == 0) {
1084                         strcpy(ndev->name, "wlan%d");
1085                         vif->ifc_id = 1;
1086                 } else {
1087                         strcpy(ndev->name, "p2p%d");
1088                         vif->ifc_id = 0;
1089                 }
1090                 vif->wilc = *wilc;
1091                 vif->ndev = ndev;
1092                 wl->vif[i] = vif;
1093                 wl->vif_num = i + 1;
1094                 vif->idx = i;
1095
1096                 ndev->netdev_ops = &wilc_netdev_ops;
1097
1098                 wdev = wilc_create_wiphy(ndev, dev);
1099
1100                 if (dev)
1101                         SET_NETDEV_DEV(ndev, dev);
1102
1103                 if (!wdev) {
1104                         netdev_err(ndev, "Can't register WILC Wiphy\n");
1105                         return -1;
1106                 }
1107
1108                 vif->ndev->ieee80211_ptr = wdev;
1109                 vif->ndev->ml_priv = vif;
1110                 wdev->netdev = vif->ndev;
1111                 vif->netstats.rx_packets = 0;
1112                 vif->netstats.tx_packets = 0;
1113                 vif->netstats.rx_bytes = 0;
1114                 vif->netstats.tx_bytes = 0;
1115
1116                 ret = register_netdev(ndev);
1117                 if (ret)
1118                         return ret;
1119
1120                 vif->iftype = STATION_MODE;
1121                 vif->mac_opened = 0;
1122         }
1123
1124         return 0;
1125 }
1126 EXPORT_SYMBOL_GPL(wilc_netdev_init);
1127
1128 MODULE_LICENSE("GPL");