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, ®s); 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); 1124