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

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