drivers/net/wireless/intersil/hostap/hostap_main.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Host AP (software wireless LAN access point) driver for
   4  * Intersil Prism2/2.5/3 - hostap.o module, common routines
   5  *
   6  * Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
   7  * <j@w1.fi>
   8  * Copyright (c) 2002-2005, Jouni Malinen <j@w1.fi>
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/init.h>
  13 #include <linux/slab.h>
  14 #include <linux/proc_fs.h>
  15 #include <linux/if_arp.h>
  16 #include <linux/delay.h>
  17 #include <linux/random.h>
  18 #include <linux/workqueue.h>
  19 #include <linux/kmod.h>
  20 #include <linux/rtnetlink.h>
  21 #include <linux/wireless.h>
  22 #include <linux/etherdevice.h>
  23 #include <net/net_namespace.h>
  24 #include <net/iw_handler.h>
  25 #include <net/lib80211.h>
  26 #include <linux/uaccess.h>
  27
  28 #include "hostap_wlan.h"
  29 #include "hostap_80211.h"
  30 #include "hostap_ap.h"
  31 #include "hostap.h"
  32
  33 MODULE_AUTHOR("Jouni Malinen");
  34 MODULE_DESCRIPTION("Host AP common routines");
  35 MODULE_LICENSE("GPL");
  36
  37 #define TX_TIMEOUT (2 * HZ)
  38
  39 #define PRISM2_MAX_FRAME_SIZE 2304
  40 #define PRISM2_MIN_MTU 256
  41 /* FIX: */
  42 #define PRISM2_MAX_MTU (PRISM2_MAX_FRAME_SIZE - (6 /* LLC */ + 8 /* WEP */))
  43
  44
  45 struct net_device * hostap_add_interface(struct local_info *local,
  46                                          int type, int rtnl_locked,
  47                                          const char *prefix,
  48                                          const char *name)
  49 {
  50         struct net_device *dev, *mdev;
  51         struct hostap_interface *iface;
  52         int ret;
  53
  54         dev = alloc_etherdev(sizeof(struct hostap_interface));
  55         if (dev == NULL)
  56                 return NULL;
  57
  58         iface = netdev_priv(dev);
  59         iface->dev = dev;
  60         iface->local = local;
  61         iface->type = type;
  62         list_add(&iface->list, &local->hostap_interfaces);
  63
  64         mdev = local->dev;
  65         eth_hw_addr_inherit(dev, mdev);
  66         dev->base_addr = mdev->base_addr;
  67         dev->irq = mdev->irq;
  68         dev->mem_start = mdev->mem_start;
  69         dev->mem_end = mdev->mem_end;
  70
  71         hostap_setup_dev(dev, local, type);
  72         dev->needs_free_netdev = true;
  73
  74         sprintf(dev->name, "%s%s", prefix, name);
  75         if (!rtnl_locked)
  76                 rtnl_lock();
  77
  78         SET_NETDEV_DEV(dev, mdev->dev.parent);
  79         ret = register_netdevice(dev);
  80
  81         if (!rtnl_locked)
  82                 rtnl_unlock();
  83
  84         if (ret < 0) {
  85                 printk(KERN_WARNING "%s: failed to add new netdevice!\n",
  86                        dev->name);
  87                 free_netdev(dev);
  88                 return NULL;
  89         }
  90
  91         printk(KERN_DEBUG "%s: registered netdevice %s\n",
  92                mdev->name, dev->name);
  93
  94         return dev;
  95 }
  96
  97
  98 void hostap_remove_interface(struct net_device *dev, int rtnl_locked,
  99                              int remove_from_list)
 100 {
 101         struct hostap_interface *iface;
 102
 103         if (!dev)
 104                 return;
 105
 106         iface = netdev_priv(dev);
 107
 108         if (remove_from_list) {
 109                 list_del(&iface->list);
 110         }
 111
 112         if (dev == iface->local->ddev)
 113                 iface->local->ddev = NULL;
 114         else if (dev == iface->local->apdev)
 115                 iface->local->apdev = NULL;
 116         else if (dev == iface->local->stadev)
 117                 iface->local->stadev = NULL;
 118
 119         if (rtnl_locked)
 120                 unregister_netdevice(dev);
 121         else
 122                 unregister_netdev(dev);
 123
 124         /* 'dev->needs_free_netdev = true' implies device data, including
 125          * private data, will be freed when the device is removed */
 126 }
 127
 128
 129 static inline int prism2_wds_special_addr(u8 *addr)
 130 {
 131         if (addr[0] || addr[1] || addr[2] || addr[3] || addr[4] || addr[5])
 132                 return 0;
 133
 134         return 1;
 135 }
 136
 137
 138 int prism2_wds_add(local_info_t *local, u8 *remote_addr,
 139                    int rtnl_locked)
 140 {
 141         struct net_device *dev;
 142         struct list_head *ptr;
 143         struct hostap_interface *iface, *empty, *match;
 144
 145         empty = match = NULL;
 146         read_lock_bh(&local->iface_lock);
 147         list_for_each(ptr, &local->hostap_interfaces) {
 148                 iface = list_entry(ptr, struct hostap_interface, list);
 149                 if (iface->type != HOSTAP_INTERFACE_WDS)
 150                         continue;
 151
 152                 if (prism2_wds_special_addr(iface->u.wds.remote_addr))
 153                         empty = iface;
 154                 else if (ether_addr_equal(iface->u.wds.remote_addr, remote_addr)) {
 155                         match = iface;
 156                         break;
 157                 }
 158         }
 159         if (!match && empty && !prism2_wds_special_addr(remote_addr)) {
 160                 /* take pre-allocated entry into use */
 161                 memcpy(empty->u.wds.remote_addr, remote_addr, ETH_ALEN);
 162                 read_unlock_bh(&local->iface_lock);
 163                 printk(KERN_DEBUG "%s: using pre-allocated WDS netdevice %s\n",
 164                        local->dev->name, empty->dev->name);
 165                 return 0;
 166         }
 167         read_unlock_bh(&local->iface_lock);
 168
 169         if (!prism2_wds_special_addr(remote_addr)) {
 170                 if (match)
 171                         return -EEXIST;
 172                 hostap_add_sta(local->ap, remote_addr);
 173         }
 174
 175         if (local->wds_connections >= local->wds_max_connections)
 176                 return -ENOBUFS;
 177
 178         /* verify that there is room for wds# postfix in the interface name */
 179         if (strlen(local->dev->name) >= IFNAMSIZ - 5) {
 180                 printk(KERN_DEBUG "'%s' too long base device name\n",
 181                        local->dev->name);
 182                 return -EINVAL;
 183         }
 184
 185         dev = hostap_add_interface(local, HOSTAP_INTERFACE_WDS, rtnl_locked,
 186                                    local->ddev->name, "wds%d");
 187         if (dev == NULL)
 188                 return -ENOMEM;
 189
 190         iface = netdev_priv(dev);
 191         memcpy(iface->u.wds.remote_addr, remote_addr, ETH_ALEN);
 192
 193         local->wds_connections++;
 194
 195         return 0;
 196 }
 197
 198
 199 int prism2_wds_del(local_info_t *local, u8 *remote_addr,
 200                    int rtnl_locked, int do_not_remove)
 201 {
 202         unsigned long flags;
 203         struct list_head *ptr;
 204         struct hostap_interface *iface, *selected = NULL;
 205
 206         write_lock_irqsave(&local->iface_lock, flags);
 207         list_for_each(ptr, &local->hostap_interfaces) {
 208                 iface = list_entry(ptr, struct hostap_interface, list);
 209                 if (iface->type != HOSTAP_INTERFACE_WDS)
 210                         continue;
 211
 212                 if (ether_addr_equal(iface->u.wds.remote_addr, remote_addr)) {
 213                         selected = iface;
 214                         break;
 215                 }
 216         }
 217         if (selected && !do_not_remove)
 218                 list_del(&selected->list);
 219         write_unlock_irqrestore(&local->iface_lock, flags);
 220
 221         if (selected) {
 222                 if (do_not_remove)
 223                         eth_zero_addr(selected->u.wds.remote_addr);
 224                 else {
 225                         hostap_remove_interface(selected->dev, rtnl_locked, 0);
 226                         local->wds_connections--;
 227                 }
 228         }
 229
 230         return selected ? 0 : -ENODEV;
 231 }
 232
 233
 234 u16 hostap_tx_callback_register(local_info_t *local,
 235                                 void (*func)(struct sk_buff *, int ok, void *),
 236                                 void *data)
 237 {
 238         unsigned long flags;
 239         struct hostap_tx_callback_info *entry;
 240
 241         entry = kmalloc(sizeof(*entry), GFP_KERNEL);
 242         if (entry == NULL)
 243                 return 0;
 244
 245         entry->func = func;
 246         entry->data = data;
 247
 248         spin_lock_irqsave(&local->lock, flags);
 249         entry->idx = local->tx_callback ? local->tx_callback->idx + 1 : 1;
 250         entry->next = local->tx_callback;
 251         local->tx_callback = entry;
 252         spin_unlock_irqrestore(&local->lock, flags);
 253
 254         return entry->idx;
 255 }
 256
 257
 258 int hostap_tx_callback_unregister(local_info_t *local, u16 idx)
 259 {
 260         unsigned long flags;
 261         struct hostap_tx_callback_info *cb, *prev = NULL;
 262
 263         spin_lock_irqsave(&local->lock, flags);
 264         cb = local->tx_callback;
 265         while (cb != NULL && cb->idx != idx) {
 266                 prev = cb;
 267                 cb = cb->next;
 268         }
 269         if (cb) {
 270                 if (prev == NULL)
 271                         local->tx_callback = cb->next;
 272                 else
 273                         prev->next = cb->next;
 274                 kfree(cb);
 275         }
 276         spin_unlock_irqrestore(&local->lock, flags);
 277
 278         return cb ? 0 : -1;
 279 }
 280
 281
 282 /* val is in host byte order */
 283 int hostap_set_word(struct net_device *dev, int rid, u16 val)
 284 {
 285         struct hostap_interface *iface;
 286         __le16 tmp = cpu_to_le16(val);
 287         iface = netdev_priv(dev);
 288         return iface->local->func->set_rid(dev, rid, &tmp, 2);
 289 }
 290
 291
 292 int hostap_set_string(struct net_device *dev, int rid, const char *val)
 293 {
 294         struct hostap_interface *iface;
 295         char buf[MAX_SSID_LEN + 2];
 296         int len;
 297
 298         iface = netdev_priv(dev);
 299         len = strlen(val);
 300         if (len > MAX_SSID_LEN)
 301                 return -1;
 302         memset(buf, 0, sizeof(buf));
 303         buf[0] = len; /* little endian 16 bit word */
 304         memcpy(buf + 2, val, len);
 305
 306         return iface->local->func->set_rid(dev, rid, &buf, MAX_SSID_LEN + 2);
 307 }
 308
 309
 310 u16 hostap_get_porttype(local_info_t *local)
 311 {
 312         if (local->iw_mode == IW_MODE_ADHOC && local->pseudo_adhoc)
 313                 return HFA384X_PORTTYPE_PSEUDO_IBSS;
 314         if (local->iw_mode == IW_MODE_ADHOC)
 315                 return HFA384X_PORTTYPE_IBSS;
 316         if (local->iw_mode == IW_MODE_INFRA)
 317                 return HFA384X_PORTTYPE_BSS;
 318         if (local->iw_mode == IW_MODE_REPEAT)
 319                 return HFA384X_PORTTYPE_WDS;
 320         if (local->iw_mode == IW_MODE_MONITOR)
 321                 return HFA384X_PORTTYPE_PSEUDO_IBSS;
 322         return HFA384X_PORTTYPE_HOSTAP;
 323 }
 324
 325
 326 int hostap_set_encryption(local_info_t *local)
 327 {
 328         u16 val, old_val;
 329         int i, keylen, len, idx;
 330         char keybuf[WEP_KEY_LEN + 1];
 331         enum { NONE, WEP, OTHER } encrypt_type;
 332
 333         idx = local->crypt_info.tx_keyidx;
 334         if (local->crypt_info.crypt[idx] == NULL ||
 335             local->crypt_info.crypt[idx]->ops == NULL)
 336                 encrypt_type = NONE;
 337         else if (strcmp(local->crypt_info.crypt[idx]->ops->name, "WEP") == 0)
 338                 encrypt_type = WEP;
 339         else
 340                 encrypt_type = OTHER;
 341
 342         if (local->func->get_rid(local->dev, HFA384X_RID_CNFWEPFLAGS, &val, 2,
 343                                  1) < 0) {
 344                 printk(KERN_DEBUG "Could not read current WEP flags.\n");
 345                 goto fail;
 346         }
 347         le16_to_cpus(&val);
 348         old_val = val;
 349
 350         if (encrypt_type != NONE || local->privacy_invoked)
 351                 val |= HFA384X_WEPFLAGS_PRIVACYINVOKED;
 352         else
 353                 val &= ~HFA384X_WEPFLAGS_PRIVACYINVOKED;
 354
 355         if (local->open_wep || encrypt_type == NONE ||
 356             ((local->ieee_802_1x || local->wpa) && local->host_decrypt))
 357                 val &= ~HFA384X_WEPFLAGS_EXCLUDEUNENCRYPTED;
 358         else
 359                 val |= HFA384X_WEPFLAGS_EXCLUDEUNENCRYPTED;
 360
 361         if ((encrypt_type != NONE || local->privacy_invoked) &&
 362             (encrypt_type == OTHER || local->host_encrypt))
 363                 val |= HFA384X_WEPFLAGS_HOSTENCRYPT;
 364         else
 365                 val &= ~HFA384X_WEPFLAGS_HOSTENCRYPT;
 366         if ((encrypt_type != NONE || local->privacy_invoked) &&
 367             (encrypt_type == OTHER || local->host_decrypt))
 368                 val |= HFA384X_WEPFLAGS_HOSTDECRYPT;
 369         else
 370                 val &= ~HFA384X_WEPFLAGS_HOSTDECRYPT;
 371
 372         if (val != old_val &&
 373             hostap_set_word(local->dev, HFA384X_RID_CNFWEPFLAGS, val)) {
 374                 printk(KERN_DEBUG "Could not write new WEP flags (0x%x)\n",
 375                        val);
 376                 goto fail;
 377         }
 378
 379         if (encrypt_type != WEP)
 380                 return 0;
 381
 382         /* 104-bit support seems to require that all the keys are set to the
 383          * same keylen */
 384         keylen = 6; /* first 5 octets */
 385         len = local->crypt_info.crypt[idx]->ops->get_key(keybuf, sizeof(keybuf), NULL,
 386                                                            local->crypt_info.crypt[idx]->priv);
 387         if (idx >= 0 && idx < WEP_KEYS && len > 5)
 388                 keylen = WEP_KEY_LEN + 1; /* first 13 octets */
 389
 390         for (i = 0; i < WEP_KEYS; i++) {
 391                 memset(keybuf, 0, sizeof(keybuf));
 392                 if (local->crypt_info.crypt[i]) {
 393                         (void) local->crypt_info.crypt[i]->ops->get_key(
 394                                 keybuf, sizeof(keybuf),
 395                                 NULL, local->crypt_info.crypt[i]->priv);
 396                 }
 397                 if (local->func->set_rid(local->dev,
 398                                          HFA384X_RID_CNFDEFAULTKEY0 + i,
 399                                          keybuf, keylen)) {
 400                         printk(KERN_DEBUG "Could not set key %d (len=%d)\n",
 401                                i, keylen);
 402                         goto fail;
 403                 }
 404         }
 405         if (hostap_set_word(local->dev, HFA384X_RID_CNFWEPDEFAULTKEYID, idx)) {
 406                 printk(KERN_DEBUG "Could not set default keyid %d\n", idx);
 407                 goto fail;
 408         }
 409
 410         return 0;
 411
 412  fail:
 413         printk(KERN_DEBUG "%s: encryption setup failed\n", local->dev->name);
 414         return -1;
 415 }
 416
 417
 418 int hostap_set_antsel(local_info_t *local)
 419 {
 420         u16 val;
 421         int ret = 0;
 422
 423         if (local->antsel_tx != HOSTAP_ANTSEL_DO_NOT_TOUCH &&
 424             local->func->cmd(local->dev, HFA384X_CMDCODE_READMIF,
 425                              HFA386X_CR_TX_CONFIGURE,
 426                              NULL, &val) == 0) {
 427                 val &= ~(BIT(2) | BIT(1));
 428                 switch (local->antsel_tx) {
 429                 case HOSTAP_ANTSEL_DIVERSITY:
 430                         val |= BIT(1);
 431                         break;
 432                 case HOSTAP_ANTSEL_LOW:
 433                         break;
 434                 case HOSTAP_ANTSEL_HIGH:
 435                         val |= BIT(2);
 436                         break;
 437                 }
 438
 439                 if (local->func->cmd(local->dev, HFA384X_CMDCODE_WRITEMIF,
 440                                      HFA386X_CR_TX_CONFIGURE, &val, NULL)) {
 441                         printk(KERN_INFO "%s: setting TX AntSel failed\n",
 442                                local->dev->name);
 443                         ret = -1;
 444                 }
 445         }
 446
 447         if (local->antsel_rx != HOSTAP_ANTSEL_DO_NOT_TOUCH &&
 448             local->func->cmd(local->dev, HFA384X_CMDCODE_READMIF,
 449                              HFA386X_CR_RX_CONFIGURE,
 450                              NULL, &val) == 0) {
 451                 val &= ~(BIT(1) | BIT(0));
 452                 switch (local->antsel_rx) {
 453                 case HOSTAP_ANTSEL_DIVERSITY:
 454                         break;
 455                 case HOSTAP_ANTSEL_LOW:
 456                         val |= BIT(0);
 457                         break;
 458                 case HOSTAP_ANTSEL_HIGH:
 459                         val |= BIT(0) | BIT(1);
 460                         break;
 461                 }
 462
 463                 if (local->func->cmd(local->dev, HFA384X_CMDCODE_WRITEMIF,
 464                                      HFA386X_CR_RX_CONFIGURE, &val, NULL)) {
 465                         printk(KERN_INFO "%s: setting RX AntSel failed\n",
 466                                local->dev->name);
 467                         ret = -1;
 468                 }
 469         }
 470
 471         return ret;
 472 }
 473
 474
 475 int hostap_set_roaming(local_info_t *local)
 476 {
 477         u16 val;
 478
 479         switch (local->host_roaming) {
 480         case 1:
 481                 val = HFA384X_ROAMING_HOST;
 482                 break;
 483         case 2:
 484                 val = HFA384X_ROAMING_DISABLED;
 485                 break;
 486         case 0:
 487         default:
 488                 val = HFA384X_ROAMING_FIRMWARE;
 489                 break;
 490         }
 491
 492         return hostap_set_word(local->dev, HFA384X_RID_CNFROAMINGMODE, val);
 493 }
 494
 495
 496 int hostap_set_auth_algs(local_info_t *local)
 497 {
 498         int val = local->auth_algs;
 499         /* At least STA f/w v0.6.2 seems to have issues with cnfAuthentication
 500          * set to include both Open and Shared Key flags. It tries to use
 501          * Shared Key authentication in that case even if WEP keys are not
 502          * configured.. STA f/w v0.7.6 is able to handle such configuration,
 503          * but it is unknown when this was fixed between 0.6.2 .. 0.7.6. */
 504         if (local->sta_fw_ver < PRISM2_FW_VER(0,7,0) &&
 505             val != PRISM2_AUTH_OPEN && val != PRISM2_AUTH_SHARED_KEY)
 506                 val = PRISM2_AUTH_OPEN;
 507
 508         if (hostap_set_word(local->dev, HFA384X_RID_CNFAUTHENTICATION, val)) {
 509                 printk(KERN_INFO "%s: cnfAuthentication setting to 0x%x "
 510                        "failed\n", local->dev->name, local->auth_algs);
 511                 return -EINVAL;
 512         }
 513
 514         return 0;
 515 }
 516
 517
 518 void hostap_dump_rx_header(const char *name, const struct hfa384x_rx_frame *rx)
 519 {
 520         u16 status, fc;
 521
 522         status = __le16_to_cpu(rx->status);
 523
 524         printk(KERN_DEBUG "%s: RX status=0x%04x (port=%d, type=%d, "
 525                "fcserr=%d) silence=%d signal=%d rate=%d rxflow=%d; "
 526                "jiffies=%ld\n",
 527                name, status, (status >> 8) & 0x07, status >> 13, status & 1,
 528                rx->silence, rx->signal, rx->rate, rx->rxflow, jiffies);
 529
 530         fc = __le16_to_cpu(rx->frame_control);
 531         printk(KERN_DEBUG "   FC=0x%04x (type=%d:%d) dur=0x%04x seq=0x%04x "
 532                "data_len=%d%s%s\n",
 533                fc, (fc & IEEE80211_FCTL_FTYPE) >> 2,
 534                (fc & IEEE80211_FCTL_STYPE) >> 4,
 535                __le16_to_cpu(rx->duration_id), __le16_to_cpu(rx->seq_ctrl),
 536                __le16_to_cpu(rx->data_len),
 537                fc & IEEE80211_FCTL_TODS ? " [ToDS]" : "",
 538                fc & IEEE80211_FCTL_FROMDS ? " [FromDS]" : "");
 539
 540         printk(KERN_DEBUG "   A1=%pM A2=%pM A3=%pM A4=%pM\n",
 541                rx->addr1, rx->addr2, rx->addr3, rx->addr4);
 542
 543         printk(KERN_DEBUG "   dst=%pM src=%pM len=%d\n",
 544                rx->dst_addr, rx->src_addr,
 545                __be16_to_cpu(rx->len));
 546 }
 547
 548
 549 void hostap_dump_tx_header(const char *name, const struct hfa384x_tx_frame *tx)
 550 {
 551         u16 fc;
 552
 553         printk(KERN_DEBUG "%s: TX status=0x%04x retry_count=%d tx_rate=%d "
 554                "tx_control=0x%04x; jiffies=%ld\n",
 555                name, __le16_to_cpu(tx->status), tx->retry_count, tx->tx_rate,
 556                __le16_to_cpu(tx->tx_control), jiffies);
 557
 558         fc = __le16_to_cpu(tx->frame_control);
 559         printk(KERN_DEBUG "   FC=0x%04x (type=%d:%d) dur=0x%04x seq=0x%04x "
 560                "data_len=%d%s%s\n",
 561                fc, (fc & IEEE80211_FCTL_FTYPE) >> 2,
 562                (fc & IEEE80211_FCTL_STYPE) >> 4,
 563                __le16_to_cpu(tx->duration_id), __le16_to_cpu(tx->seq_ctrl),
 564                __le16_to_cpu(tx->data_len),
 565                fc & IEEE80211_FCTL_TODS ? " [ToDS]" : "",
 566                fc & IEEE80211_FCTL_FROMDS ? " [FromDS]" : "");
 567
 568         printk(KERN_DEBUG "   A1=%pM A2=%pM A3=%pM A4=%pM\n",
 569                tx->addr1, tx->addr2, tx->addr3, tx->addr4);
 570
 571         printk(KERN_DEBUG "   dst=%pM src=%pM len=%d\n",
 572                tx->dst_addr, tx->src_addr,
 573                __be16_to_cpu(tx->len));
 574 }
 575
 576
 577 static int hostap_80211_header_parse(const struct sk_buff *skb,
 578                                      unsigned char *haddr)
 579 {
 580         memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN); /* addr2 */
 581         return ETH_ALEN;
 582 }
 583
 584
 585 int hostap_80211_get_hdrlen(__le16 fc)
 586 {
 587         if (ieee80211_is_data(fc) && ieee80211_has_a4 (fc))
 588                 return 30; /* Addr4 */
 589         else if (ieee80211_is_cts(fc) || ieee80211_is_ack(fc))
 590                 return 10;
 591         else if (ieee80211_is_ctl(fc))
 592                 return 16;
 593
 594         return 24;
 595 }
 596
 597
 598 static int prism2_close(struct net_device *dev)
 599 {
 600         struct hostap_interface *iface;
 601         local_info_t *local;
 602
 603         PDEBUG(DEBUG_FLOW, "%s: prism2_close\n", dev->name);
 604
 605         iface = netdev_priv(dev);
 606         local = iface->local;
 607
 608         if (dev == local->ddev) {
 609                 prism2_sta_deauth(local, WLAN_REASON_DEAUTH_LEAVING);
 610         }
 611 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
 612         if (!local->hostapd && dev == local->dev &&
 613             (!local->func->card_present || local->func->card_present(local)) &&
 614             local->hw_ready && local->ap && local->iw_mode == IW_MODE_MASTER)
 615                 hostap_deauth_all_stas(dev, local->ap, 1);
 616 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
 617
 618         if (dev == local->dev) {
 619                 local->func->hw_shutdown(dev, HOSTAP_HW_ENABLE_CMDCOMPL);
 620         }
 621
 622         if (netif_running(dev)) {
 623                 netif_stop_queue(dev);
 624                 netif_device_detach(dev);
 625         }
 626
 627         cancel_work_sync(&local->reset_queue);
 628         cancel_work_sync(&local->set_multicast_list_queue);
 629         cancel_work_sync(&local->set_tim_queue);
 630 #ifndef PRISM2_NO_STATION_MODES
 631         cancel_work_sync(&local->info_queue);
 632 #endif
 633         cancel_work_sync(&local->comms_qual_update);
 634
 635         module_put(local->hw_module);
 636
 637         local->num_dev_open--;
 638
 639         if (dev != local->dev && local->dev->flags & IFF_UP &&
 640             local->master_dev_auto_open && local->num_dev_open == 1) {
 641                 /* Close master radio interface automatically if it was also
 642                  * opened automatically and we are now closing the last
 643                  * remaining non-master device. */
 644                 dev_close(local->dev);
 645         }
 646
 647         return 0;
 648 }
 649
 650
 651 static int prism2_open(struct net_device *dev)
 652 {
 653         struct hostap_interface *iface;
 654         local_info_t *local;
 655
 656         PDEBUG(DEBUG_FLOW, "%s: prism2_open\n", dev->name);
 657
 658         iface = netdev_priv(dev);
 659         local = iface->local;
 660
 661         if (local->no_pri) {
 662                 printk(KERN_DEBUG "%s: could not set interface UP - no PRI "
 663                        "f/w\n", dev->name);
 664                 return -ENODEV;
 665         }
 666
 667         if ((local->func->card_present && !local->func->card_present(local)) ||
 668             local->hw_downloading)
 669                 return -ENODEV;
 670
 671         if (!try_module_get(local->hw_module))
 672                 return -ENODEV;
 673         local->num_dev_open++;
 674
 675         if (!local->dev_enabled && local->func->hw_enable(dev, 1)) {
 676                 printk(KERN_WARNING "%s: could not enable MAC port\n",
 677                        dev->name);
 678                 prism2_close(dev);
 679                 return -ENODEV;
 680         }
 681         if (!local->dev_enabled)
 682                 prism2_callback(local, PRISM2_CALLBACK_ENABLE);
 683         local->dev_enabled = 1;
 684
 685         if (dev != local->dev && !(local->dev->flags & IFF_UP)) {
 686                 /* Master radio interface is needed for all operation, so open
 687                  * it automatically when any virtual net_device is opened. */
 688                 local->master_dev_auto_open = 1;
 689                 dev_open(local->dev, NULL);
 690         }
 691
 692         netif_device_attach(dev);
 693         netif_start_queue(dev);
 694
 695         return 0;
 696 }
 697
 698
 699 static int prism2_set_mac_address(struct net_device *dev, void *p)
 700 {
 701         struct hostap_interface *iface;
 702         local_info_t *local;
 703         struct list_head *ptr;
 704         struct sockaddr *addr = p;
 705
 706         iface = netdev_priv(dev);
 707         local = iface->local;
 708
 709         if (local->func->set_rid(dev, HFA384X_RID_CNFOWNMACADDR, addr->sa_data,
 710                                  ETH_ALEN) < 0 || local->func->reset_port(dev))
 711                 return -EINVAL;
 712
 713         read_lock_bh(&local->iface_lock);
 714         list_for_each(ptr, &local->hostap_interfaces) {
 715                 iface = list_entry(ptr, struct hostap_interface, list);
 716                 memcpy(iface->dev->dev_addr, addr->sa_data, ETH_ALEN);
 717         }
 718         memcpy(local->dev->dev_addr, addr->sa_data, ETH_ALEN);
 719         read_unlock_bh(&local->iface_lock);
 720
 721         return 0;
 722 }
 723
 724
 725 /* TODO: to be further implemented as soon as Prism2 fully supports
 726  *       GroupAddresses and correct documentation is available */
 727 void hostap_set_multicast_list_queue(struct work_struct *work)
 728 {
 729         local_info_t *local =
 730                 container_of(work, local_info_t, set_multicast_list_queue);
 731         struct net_device *dev = local->dev;
 732
 733         if (hostap_set_word(dev, HFA384X_RID_PROMISCUOUSMODE,
 734                             local->is_promisc)) {
 735                 printk(KERN_INFO "%s: %sabling promiscuous mode failed\n",
 736                        dev->name, local->is_promisc ? "en" : "dis");
 737         }
 738 }
 739
 740
 741 static void hostap_set_multicast_list(struct net_device *dev)
 742 {
 743 #if 0
 744         /* FIX: promiscuous mode seems to be causing a lot of problems with
 745          * some station firmware versions (FCSErr frames, invalid MACPort, etc.
 746          * corrupted incoming frames). This code is now commented out while the
 747          * problems are investigated. */
 748         struct hostap_interface *iface;
 749         local_info_t *local;
 750
 751         iface = netdev_priv(dev);
 752         local = iface->local;
 753         if ((dev->flags & IFF_ALLMULTI) || (dev->flags & IFF_PROMISC)) {
 754                 local->is_promisc = 1;
 755         } else {
 756                 local->is_promisc = 0;
 757         }
 758
 759         schedule_work(&local->set_multicast_list_queue);
 760 #endif
 761 }
 762
 763
 764 static void prism2_tx_timeout(struct net_device *dev)
 765 {
 766         struct hostap_interface *iface;
 767         local_info_t *local;
 768         struct hfa384x_regs regs;
 769
 770         iface = netdev_priv(dev);
 771         local = iface->local;
 772
 773         printk(KERN_WARNING "%s Tx timed out! Resetting card\n", dev->name);
 774         netif_stop_queue(local->dev);
 775
 776         local->func->read_regs(dev, &regs);
 777         printk(KERN_DEBUG "%s: CMD=%04x EVSTAT=%04x "
 778                "OFFSET0=%04x OFFSET1=%04x SWSUPPORT0=%04x\n",
 779                dev->name, regs.cmd, regs.evstat, regs.offset0, regs.offset1,
 780                regs.swsupport0);
 781
 782         local->func->schedule_reset(local);
 783 }
 784
 785 const struct header_ops hostap_80211_ops = {
 786         .create         = eth_header,
 787         .cache          = eth_header_cache,
 788         .cache_update   = eth_header_cache_update,
 789         .parse          = hostap_80211_header_parse,
 790 };
 791 EXPORT_SYMBOL(hostap_80211_ops);
 792
 793
 794 static const struct net_device_ops hostap_netdev_ops = {
 795         .ndo_start_xmit         = hostap_data_start_xmit,
 796
 797         .ndo_open               = prism2_open,
 798         .ndo_stop               = prism2_close,
 799         .ndo_do_ioctl           = hostap_ioctl,
 800         .ndo_set_mac_address    = prism2_set_mac_address,
 801         .ndo_set_rx_mode        = hostap_set_multicast_list,
 802         .ndo_tx_timeout         = prism2_tx_timeout,
 803         .ndo_validate_addr      = eth_validate_addr,
 804 };
 805
 806 static const struct net_device_ops hostap_mgmt_netdev_ops = {
 807         .ndo_start_xmit         = hostap_mgmt_start_xmit,
 808
 809         .ndo_open               = prism2_open,
 810         .ndo_stop               = prism2_close,
 811         .ndo_do_ioctl           = hostap_ioctl,
 812         .ndo_set_mac_address    = prism2_set_mac_address,
 813         .ndo_set_rx_mode        = hostap_set_multicast_list,
 814         .ndo_tx_timeout         = prism2_tx_timeout,
 815         .ndo_validate_addr      = eth_validate_addr,
 816 };
 817
 818 static const struct net_device_ops hostap_master_ops = {
 819         .ndo_start_xmit         = hostap_master_start_xmit,
 820
 821         .ndo_open               = prism2_open,
 822         .ndo_stop               = prism2_close,
 823         .ndo_do_ioctl           = hostap_ioctl,
 824         .ndo_set_mac_address    = prism2_set_mac_address,
 825         .ndo_set_rx_mode        = hostap_set_multicast_list,
 826         .ndo_tx_timeout         = prism2_tx_timeout,
 827         .ndo_validate_addr      = eth_validate_addr,
 828 };
 829
 830 void hostap_setup_dev(struct net_device *dev, local_info_t *local,
 831                       int type)
 832 {
 833         struct hostap_interface *iface;
 834
 835         iface = netdev_priv(dev);
 836         ether_setup(dev);
 837         dev->min_mtu = PRISM2_MIN_MTU;
 838         dev->max_mtu = PRISM2_MAX_MTU;
 839         dev->priv_flags &= ~IFF_TX_SKB_SHARING;
 840
 841         /* kernel callbacks */
 842         if (iface) {
 843                 /* Currently, we point to the proper spy_data only on
 844                  * the main_dev. This could be fixed. Jean II */
 845                 iface->wireless_data.spy_data = &iface->spy_data;
 846                 dev->wireless_data = &iface->wireless_data;
 847         }
 848         dev->wireless_handlers = &hostap_iw_handler_def;
 849         dev->watchdog_timeo = TX_TIMEOUT;
 850
 851         switch(type) {
 852         case HOSTAP_INTERFACE_AP:
 853                 dev->priv_flags |= IFF_NO_QUEUE;        /* use main radio device queue */
 854                 dev->netdev_ops = &hostap_mgmt_netdev_ops;
 855                 dev->type = ARPHRD_IEEE80211;
 856                 dev->header_ops = &hostap_80211_ops;
 857                 break;
 858         case HOSTAP_INTERFACE_MASTER:
 859                 dev->netdev_ops = &hostap_master_ops;
 860                 break;
 861         default:
 862                 dev->priv_flags |= IFF_NO_QUEUE;        /* use main radio device queue */
 863                 dev->netdev_ops = &hostap_netdev_ops;
 864         }
 865
 866         dev->mtu = local->mtu;
 867
 868
 869         dev->ethtool_ops = &prism2_ethtool_ops;
 870
 871 }
 872
 873 static int hostap_enable_hostapd(local_info_t *local, int rtnl_locked)
 874 {
 875         struct net_device *dev = local->dev;
 876
 877         if (local->apdev)
 878                 return -EEXIST;
 879
 880         printk(KERN_DEBUG "%s: enabling hostapd mode\n", dev->name);
 881
 882         local->apdev = hostap_add_interface(local, HOSTAP_INTERFACE_AP,
 883                                             rtnl_locked, local->ddev->name,
 884                                             "ap");
 885         if (local->apdev == NULL)
 886                 return -ENOMEM;
 887
 888         return 0;
 889 }
 890
 891
 892 static int hostap_disable_hostapd(local_info_t *local, int rtnl_locked)
 893 {
 894         struct net_device *dev = local->dev;
 895
 896         printk(KERN_DEBUG "%s: disabling hostapd mode\n", dev->name);
 897
 898         hostap_remove_interface(local->apdev, rtnl_locked, 1);
 899         local->apdev = NULL;
 900
 901         return 0;
 902 }
 903
 904
 905 static int hostap_enable_hostapd_sta(local_info_t *local, int rtnl_locked)
 906 {
 907         struct net_device *dev = local->dev;
 908
 909         if (local->stadev)
 910                 return -EEXIST;
 911
 912         printk(KERN_DEBUG "%s: enabling hostapd STA mode\n", dev->name);
 913
 914         local->stadev = hostap_add_interface(local, HOSTAP_INTERFACE_STA,
 915                                              rtnl_locked, local->ddev->name,
 916                                              "sta");
 917         if (local->stadev == NULL)
 918                 return -ENOMEM;
 919
 920         return 0;
 921 }
 922
 923
 924 static int hostap_disable_hostapd_sta(local_info_t *local, int rtnl_locked)
 925 {
 926         struct net_device *dev = local->dev;
 927
 928         printk(KERN_DEBUG "%s: disabling hostapd mode\n", dev->name);
 929
 930         hostap_remove_interface(local->stadev, rtnl_locked, 1);
 931         local->stadev = NULL;
 932
 933         return 0;
 934 }
 935
 936
 937 int hostap_set_hostapd(local_info_t *local, int val, int rtnl_locked)
 938 {
 939         int ret;
 940
 941         if (val < 0 || val > 1)
 942                 return -EINVAL;
 943
 944         if (local->hostapd == val)
 945                 return 0;
 946
 947         if (val) {
 948                 ret = hostap_enable_hostapd(local, rtnl_locked);
 949                 if (ret == 0)
 950                         local->hostapd = 1;
 951         } else {
 952                 local->hostapd = 0;
 953                 ret = hostap_disable_hostapd(local, rtnl_locked);
 954                 if (ret != 0)
 955                         local->hostapd = 1;
 956         }
 957
 958         return ret;
 959 }
 960
 961
 962 int hostap_set_hostapd_sta(local_info_t *local, int val, int rtnl_locked)
 963 {
 964         int ret;
 965
 966         if (val < 0 || val > 1)
 967                 return -EINVAL;
 968
 969         if (local->hostapd_sta == val)
 970                 return 0;
 971
 972         if (val) {
 973                 ret = hostap_enable_hostapd_sta(local, rtnl_locked);
 974                 if (ret == 0)
 975                         local->hostapd_sta = 1;
 976         } else {
 977                 local->hostapd_sta = 0;
 978                 ret = hostap_disable_hostapd_sta(local, rtnl_locked);
 979                 if (ret != 0)
 980                         local->hostapd_sta = 1;
 981         }
 982
 983
 984         return ret;
 985 }
 986
 987
 988 int prism2_update_comms_qual(struct net_device *dev)
 989 {
 990         struct hostap_interface *iface;
 991         local_info_t *local;
 992         int ret = 0;
 993         struct hfa384x_comms_quality sq;
 994
 995         iface = netdev_priv(dev);
 996         local = iface->local;
 997         if (!local->sta_fw_ver)
 998                 ret = -1;
 999         else if (local->sta_fw_ver >= PRISM2_FW_VER(1,3,1)) {
1000                 if (local->func->get_rid(local->dev,
1001                                          HFA384X_RID_DBMCOMMSQUALITY,
1002                                          &sq, sizeof(sq), 1) >= 0) {
1003                         local->comms_qual = (s16) le16_to_cpu(sq.comm_qual);
1004                         local->avg_signal = (s16) le16_to_cpu(sq.signal_level);
1005                         local->avg_noise = (s16) le16_to_cpu(sq.noise_level);
1006                         local->last_comms_qual_update = jiffies;
1007                 } else
1008                         ret = -1;
1009         } else {
1010                 if (local->func->get_rid(local->dev, HFA384X_RID_COMMSQUALITY,
1011                                          &sq, sizeof(sq), 1) >= 0) {
1012                         local->comms_qual = le16_to_cpu(sq.comm_qual);
1013                         local->avg_signal = HFA384X_LEVEL_TO_dBm(
1014                                 le16_to_cpu(sq.signal_level));
1015                         local->avg_noise = HFA384X_LEVEL_TO_dBm(
1016                                 le16_to_cpu(sq.noise_level));
1017                         local->last_comms_qual_update = jiffies;
1018                 } else
1019                         ret = -1;
1020         }
1021
1022         return ret;
1023 }
1024
1025
1026 int prism2_sta_send_mgmt(local_info_t *local, u8 *dst, u16 stype,
1027                          u8 *body, size_t bodylen)
1028 {
1029         struct sk_buff *skb;
1030         struct hostap_ieee80211_mgmt *mgmt;
1031         struct hostap_skb_tx_data *meta;
1032         struct net_device *dev = local->dev;
1033
1034         skb = dev_alloc_skb(IEEE80211_MGMT_HDR_LEN + bodylen);
1035         if (skb == NULL)
1036                 return -ENOMEM;
1037
1038         mgmt = skb_put_zero(skb, IEEE80211_MGMT_HDR_LEN);
1039         mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
1040         memcpy(mgmt->da, dst, ETH_ALEN);
1041         memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
1042         memcpy(mgmt->bssid, dst, ETH_ALEN);
1043         if (body)
1044                 skb_put_data(skb, body, bodylen);
1045
1046         meta = (struct hostap_skb_tx_data *) skb->cb;
1047         memset(meta, 0, sizeof(*meta));
1048         meta->magic = HOSTAP_SKB_TX_DATA_MAGIC;
1049         meta->iface = netdev_priv(dev);
1050
1051         skb->dev = dev;
1052         skb_reset_mac_header(skb);
1053         skb_reset_network_header(skb);
1054         dev_queue_xmit(skb);
1055
1056         return 0;
1057 }
1058
1059
1060 int prism2_sta_deauth(local_info_t *local, u16 reason)
1061 {
1062         union iwreq_data wrqu;
1063         int ret;
1064         __le16 val = cpu_to_le16(reason);
1065
1066         if (local->iw_mode != IW_MODE_INFRA ||
1067             is_zero_ether_addr(local->bssid) ||
1068             ether_addr_equal(local->bssid, "\x44\x44\x44\x44\x44\x44"))
1069                 return 0;
1070
1071         ret = prism2_sta_send_mgmt(local, local->bssid, IEEE80211_STYPE_DEAUTH,
1072                                    (u8 *) &val, 2);
1073         eth_zero_addr(wrqu.ap_addr.sa_data);
1074         wireless_send_event(local->dev, SIOCGIWAP, &wrqu, NULL);
1075         return ret;
1076 }
1077
1078
1079 struct proc_dir_entry *hostap_proc;
1080
1081 static int __init hostap_init(void)
1082 {
1083         if (init_net.proc_net != NULL) {
1084                 hostap_proc = proc_mkdir("hostap", init_net.proc_net);
1085                 if (!hostap_proc)
1086                         printk(KERN_WARNING "Failed to mkdir "
1087                                "/proc/net/hostap\n");
1088         } else
1089                 hostap_proc = NULL;
1090
1091         return 0;
1092 }
1093
1094
1095 static void __exit hostap_exit(void)
1096 {
1097         if (hostap_proc != NULL) {
1098                 hostap_proc = NULL;
1099                 remove_proc_entry("hostap", init_net.proc_net);
1100         }
1101 }
1102
1103
1104 EXPORT_SYMBOL(hostap_set_word);
1105 EXPORT_SYMBOL(hostap_set_string);
1106 EXPORT_SYMBOL(hostap_get_porttype);
1107 EXPORT_SYMBOL(hostap_set_encryption);
1108 EXPORT_SYMBOL(hostap_set_antsel);
1109 EXPORT_SYMBOL(hostap_set_roaming);
1110 EXPORT_SYMBOL(hostap_set_auth_algs);
1111 EXPORT_SYMBOL(hostap_dump_rx_header);
1112 EXPORT_SYMBOL(hostap_dump_tx_header);
1113 EXPORT_SYMBOL(hostap_80211_get_hdrlen);
1114 EXPORT_SYMBOL(hostap_setup_dev);
1115 EXPORT_SYMBOL(hostap_set_multicast_list_queue);
1116 EXPORT_SYMBOL(hostap_set_hostapd);
1117 EXPORT_SYMBOL(hostap_set_hostapd_sta);
1118 EXPORT_SYMBOL(hostap_add_interface);
1119 EXPORT_SYMBOL(hostap_remove_interface);
1120 EXPORT_SYMBOL(prism2_update_comms_qual);
1121
1122 module_init(hostap_init);
1123 module_exit(hostap_exit);