1/* main.c - (formerly known as dldwd_cs.c, orinoco_cs.c and orinoco.c) 2 * 3 * A driver for Hermes or Prism 2 chipset based PCMCIA wireless 4 * adaptors, with Lucent/Agere, Intersil or Symbol firmware. 5 * 6 * Current maintainers (as of 29 September 2003) are: 7 * Pavel Roskin <proski AT gnu.org> 8 * and David Gibson <hermes AT gibson.dropbear.id.au> 9 * 10 * (C) Copyright David Gibson, IBM Corporation 2001-2003. 11 * Copyright (C) 2000 David Gibson, Linuxcare Australia. 12 * With some help from : 13 * Copyright (C) 2001 Jean Tourrilhes, HP Labs 14 * Copyright (C) 2001 Benjamin Herrenschmidt 15 * 16 * Based on dummy_cs.c 1.27 2000/06/12 21:27:25 17 * 18 * Portions based on wvlan_cs.c 1.0.6, Copyright Andreas Neuhaus <andy 19 * AT fasta.fh-dortmund.de> 20 * http://www.stud.fh-dortmund.de/~andy/wvlan/ 21 * 22 * The contents of this file are subject to the Mozilla Public License 23 * Version 1.1 (the "License"); you may not use this file except in 24 * compliance with the License. You may obtain a copy of the License 25 * at http://www.mozilla.org/MPL/ 26 * 27 * Software distributed under the License is distributed on an "AS IS" 28 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See 29 * the License for the specific language governing rights and 30 * limitations under the License. 31 * 32 * The initial developer of the original code is David A. Hinds 33 * <dahinds AT users.sourceforge.net>. Portions created by David 34 * A. Hinds are Copyright (C) 1999 David A. Hinds. All Rights 35 * Reserved. 36 * 37 * Alternatively, the contents of this file may be used under the 38 * terms of the GNU General Public License version 2 (the "GPL"), in 39 * which case the provisions of the GPL are applicable instead of the 40 * above. If you wish to allow the use of your version of this file 41 * only under the terms of the GPL and not to allow others to use your 42 * version of this file under the MPL, indicate your decision by 43 * deleting the provisions above and replace them with the notice and 44 * other provisions required by the GPL. If you do not delete the 45 * provisions above, a recipient may use your version of this file 46 * under either the MPL or the GPL. */ 47 48/* 49 * TODO 50 * o Handle de-encapsulation within network layer, provide 802.11 51 * headers (patch from Thomas 'Dent' Mirlacher) 52 * o Fix possible races in SPY handling. 53 * o Disconnect wireless extensions from fundamental configuration. 54 * o (maybe) Software WEP support (patch from Stano Meduna). 55 * o (maybe) Use multiple Tx buffers - driver handling queue 56 * rather than firmware. 57 */ 58 59/* Locking and synchronization: 60 * 61 * The basic principle is that everything is serialized through a 62 * single spinlock, priv->lock. The lock is used in user, bh and irq 63 * context, so when taken outside hardirq context it should always be 64 * taken with interrupts disabled. The lock protects both the 65 * hardware and the struct orinoco_private. 66 * 67 * Another flag, priv->hw_unavailable indicates that the hardware is 68 * unavailable for an extended period of time (e.g. suspended, or in 69 * the middle of a hard reset). This flag is protected by the 70 * spinlock. All code which touches the hardware should check the 71 * flag after taking the lock, and if it is set, give up on whatever 72 * they are doing and drop the lock again. The orinoco_lock() 73 * function handles this (it unlocks and returns -EBUSY if 74 * hw_unavailable is non-zero). 75 */ 76 77#define DRIVER_NAME "orinoco" 78 79#include <linux/module.h> 80#include <linux/kernel.h> 81#include <linux/slab.h> 82#include <linux/init.h> 83#include <linux/delay.h> 84#include <linux/device.h> 85#include <linux/netdevice.h> 86#include <linux/etherdevice.h> 87#include <linux/suspend.h> 88#include <linux/if_arp.h> 89#include <linux/wireless.h> 90#include <linux/ieee80211.h> 91#include <net/iw_handler.h> 92#include <net/cfg80211.h> 93 94#include "hermes_rid.h" 95#include "hermes_dld.h" 96#include "hw.h" 97#include "scan.h" 98#include "mic.h" 99#include "fw.h" 100#include "wext.h" 101#include "cfg.h" 102#include "main.h" 103 104#include "orinoco.h" 105 106/********************************************************************/ 107/* Module information */ 108/********************************************************************/ 109 110MODULE_AUTHOR("Pavel Roskin <proski@gnu.org> & " 111 "David Gibson <hermes@gibson.dropbear.id.au>"); 112MODULE_DESCRIPTION("Driver for Lucent Orinoco, Prism II based " 113 "and similar wireless cards"); 114MODULE_LICENSE("Dual MPL/GPL"); 115 116/* Level of debugging. Used in the macros in orinoco.h */ 117#ifdef ORINOCO_DEBUG 118int orinoco_debug = ORINOCO_DEBUG; 119EXPORT_SYMBOL(orinoco_debug); 120module_param(orinoco_debug, int, 0644); 121MODULE_PARM_DESC(orinoco_debug, "Debug level"); 122#endif 123 124static int suppress_linkstatus; /* = 0 */ 125module_param(suppress_linkstatus, bool, 0644); 126MODULE_PARM_DESC(suppress_linkstatus, "Don't log link status changes"); 127 128static int ignore_disconnect; /* = 0 */ 129module_param(ignore_disconnect, int, 0644); 130MODULE_PARM_DESC(ignore_disconnect, 131 "Don't report lost link to the network layer"); 132 133int force_monitor; /* = 0 */ 134module_param(force_monitor, int, 0644); 135MODULE_PARM_DESC(force_monitor, "Allow monitor mode for all firmware versions"); 136 137/********************************************************************/ 138/* Internal constants */ 139/********************************************************************/ 140 141/* 802.2 LLC/SNAP header used for Ethernet encapsulation over 802.11 */ 142static const u8 encaps_hdr[] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00}; 143#define ENCAPS_OVERHEAD (sizeof(encaps_hdr) + 2) 144 145#define ORINOCO_MIN_MTU 256 146#define ORINOCO_MAX_MTU (IEEE80211_MAX_DATA_LEN - ENCAPS_OVERHEAD) 147 148#define MAX_IRQLOOPS_PER_IRQ 10 149#define MAX_IRQLOOPS_PER_JIFFY (20000/HZ) /* Based on a guestimate of 150 * how many events the 151 * device could 152 * legitimately generate */ 153 154#define DUMMY_FID 0xFFFF 155 156/*#define MAX_MULTICAST(priv) (priv->firmware_type == FIRMWARE_TYPE_AGERE ? \ 157 HERMES_MAX_MULTICAST : 0)*/ 158#define MAX_MULTICAST(priv) (HERMES_MAX_MULTICAST) 159 160#define ORINOCO_INTEN (HERMES_EV_RX | HERMES_EV_ALLOC \ 161 | HERMES_EV_TX | HERMES_EV_TXEXC \ 162 | HERMES_EV_WTERR | HERMES_EV_INFO \ 163 | HERMES_EV_INFDROP) 164 165/********************************************************************/ 166/* Data types */ 167/********************************************************************/ 168 169/* Beginning of the Tx descriptor, used in TxExc handling */ 170struct hermes_txexc_data { 171 struct hermes_tx_descriptor desc; 172 __le16 frame_ctl; 173 __le16 duration_id; 174 u8 addr1[ETH_ALEN]; 175} __packed; 176 177/* Rx frame header except compatibility 802.3 header */ 178struct hermes_rx_descriptor { 179 /* Control */ 180 __le16 status; 181 __le32 time; 182 u8 silence; 183 u8 signal; 184 u8 rate; 185 u8 rxflow; 186 __le32 reserved; 187 188 /* 802.11 header */ 189 __le16 frame_ctl; 190 __le16 duration_id; 191 u8 addr1[ETH_ALEN]; 192 u8 addr2[ETH_ALEN]; 193 u8 addr3[ETH_ALEN]; 194 __le16 seq_ctl; 195 u8 addr4[ETH_ALEN]; 196 197 /* Data length */ 198 __le16 data_len; 199} __packed; 200 201struct orinoco_rx_data { 202 struct hermes_rx_descriptor *desc; 203 struct sk_buff *skb; 204 struct list_head list; 205}; 206 207struct orinoco_scan_data { 208 void *buf; 209 size_t len; 210 int type; 211 struct list_head list; 212}; 213 214/********************************************************************/ 215/* Function prototypes */ 216/********************************************************************/ 217 218static int __orinoco_set_multicast_list(struct net_device *dev); 219static int __orinoco_up(struct orinoco_private *priv); 220static int __orinoco_down(struct orinoco_private *priv); 221static int __orinoco_commit(struct orinoco_private *priv); 222 223/********************************************************************/ 224/* Internal helper functions */ 225/********************************************************************/ 226 227void set_port_type(struct orinoco_private *priv) 228{ 229 switch (priv->iw_mode) { 230 case NL80211_IFTYPE_STATION: 231 priv->port_type = 1; 232 priv->createibss = 0; 233 break; 234 case NL80211_IFTYPE_ADHOC: 235 if (priv->prefer_port3) { 236 priv->port_type = 3; 237 priv->createibss = 0; 238 } else { 239 priv->port_type = priv->ibss_port; 240 priv->createibss = 1; 241 } 242 break; 243 case NL80211_IFTYPE_MONITOR: 244 priv->port_type = 3; 245 priv->createibss = 0; 246 break; 247 default: 248 printk(KERN_ERR "%s: Invalid priv->iw_mode in set_port_type()\n", 249 priv->ndev->name); 250 } 251} 252 253/********************************************************************/ 254/* Device methods */ 255/********************************************************************/ 256 257int orinoco_open(struct net_device *dev) 258{ 259 struct orinoco_private *priv = ndev_priv(dev); 260 unsigned long flags; 261 int err; 262 263 if (orinoco_lock(priv, &flags) != 0) 264 return -EBUSY; 265 266 err = __orinoco_up(priv); 267 268 if (!err) 269 priv->open = 1; 270 271 orinoco_unlock(priv, &flags); 272 273 return err; 274} 275EXPORT_SYMBOL(orinoco_open); 276 277int orinoco_stop(struct net_device *dev) 278{ 279 struct orinoco_private *priv = ndev_priv(dev); 280 int err = 0; 281 282 /* We mustn't use orinoco_lock() here, because we need to be 283 able to close the interface even if hw_unavailable is set 284 (e.g. as we're released after a PC Card removal) */ 285 orinoco_lock_irq(priv); 286 287 priv->open = 0; 288 289 err = __orinoco_down(priv); 290 291 orinoco_unlock_irq(priv); 292 293 return err; 294} 295EXPORT_SYMBOL(orinoco_stop); 296 297struct net_device_stats *orinoco_get_stats(struct net_device *dev) 298{ 299 struct orinoco_private *priv = ndev_priv(dev); 300 301 return &priv->stats; 302} 303EXPORT_SYMBOL(orinoco_get_stats); 304 305void orinoco_set_multicast_list(struct net_device *dev) 306{ 307 struct orinoco_private *priv = ndev_priv(dev); 308 unsigned long flags; 309 310 if (orinoco_lock(priv, &flags) != 0) { 311 printk(KERN_DEBUG "%s: orinoco_set_multicast_list() " 312 "called when hw_unavailable\n", dev->name); 313 return; 314 } 315 316 __orinoco_set_multicast_list(dev); 317 orinoco_unlock(priv, &flags); 318} 319EXPORT_SYMBOL(orinoco_set_multicast_list); 320 321int orinoco_change_mtu(struct net_device *dev, int new_mtu) 322{ 323 struct orinoco_private *priv = ndev_priv(dev); 324 325 if ((new_mtu < ORINOCO_MIN_MTU) || (new_mtu > ORINOCO_MAX_MTU)) 326 return -EINVAL; 327 328 /* MTU + encapsulation + header length */ 329 if ((new_mtu + ENCAPS_OVERHEAD + sizeof(struct ieee80211_hdr)) > 330 (priv->nicbuf_size - ETH_HLEN)) 331 return -EINVAL; 332 333 dev->mtu = new_mtu; 334 335 return 0; 336} 337EXPORT_SYMBOL(orinoco_change_mtu); 338 339/********************************************************************/ 340/* Tx path */ 341/********************************************************************/ 342 343/* Add encapsulation and MIC to the existing SKB. 344 * The main xmit routine will then send the whole lot to the card. 345 * Need 8 bytes headroom 346 * Need 8 bytes tailroom 347 * 348 * With encapsulated ethernet II frame 349 * -------- 350 * 803.3 header (14 bytes) 351 * dst[6] 352 * -------- src[6] 353 * 803.3 header (14 bytes) len[2] 354 * dst[6] 803.2 header (8 bytes) 355 * src[6] encaps[6] 356 * len[2] <- leave alone -> len[2] 357 * -------- -------- <-- 0 358 * Payload Payload 359 * ... ... 360 * 361 * -------- -------- 362 * MIC (8 bytes) 363 * -------- 364 * 365 * returns 0 on success, -ENOMEM on error. 366 */ 367int orinoco_process_xmit_skb(struct sk_buff *skb, 368 struct net_device *dev, 369 struct orinoco_private *priv, 370 int *tx_control, 371 u8 *mic_buf) 372{ 373 struct orinoco_tkip_key *key; 374 struct ethhdr *eh; 375 int do_mic; 376 377 key = (struct orinoco_tkip_key *) priv->keys[priv->tx_key].key; 378 379 do_mic = ((priv->encode_alg == ORINOCO_ALG_TKIP) && 380 (key != NULL)); 381 382 if (do_mic) 383 *tx_control |= (priv->tx_key << HERMES_MIC_KEY_ID_SHIFT) | 384 HERMES_TXCTRL_MIC; 385 386 eh = (struct ethhdr *)skb->data; 387 388 /* Encapsulate Ethernet-II frames */ 389 if (ntohs(eh->h_proto) > ETH_DATA_LEN) { /* Ethernet-II frame */ 390 struct header_struct { 391 struct ethhdr eth; /* 802.3 header */ 392 u8 encap[6]; /* 802.2 header */ 393 } __packed hdr; 394 int len = skb->len + sizeof(encaps_hdr) - (2 * ETH_ALEN); 395 396 if (skb_headroom(skb) < ENCAPS_OVERHEAD) { 397 if (net_ratelimit()) 398 printk(KERN_ERR 399 "%s: Not enough headroom for 802.2 headers %d\n", 400 dev->name, skb_headroom(skb)); 401 return -ENOMEM; 402 } 403 404 /* Fill in new header */ 405 memcpy(&hdr.eth, eh, 2 * ETH_ALEN); 406 hdr.eth.h_proto = htons(len); 407 memcpy(hdr.encap, encaps_hdr, sizeof(encaps_hdr)); 408 409 /* Make room for the new header, and copy it in */ 410 eh = (struct ethhdr *) skb_push(skb, ENCAPS_OVERHEAD); 411 memcpy(eh, &hdr, sizeof(hdr)); 412 } 413 414 /* Calculate Michael MIC */ 415 if (do_mic) { 416 size_t len = skb->len - ETH_HLEN; 417 u8 *mic = &mic_buf[0]; 418 419 /* Have to write to an even address, so copy the spare 420 * byte across */ 421 if (skb->len % 2) { 422 *mic = skb->data[skb->len - 1]; 423 mic++; 424 } 425 426 orinoco_mic(priv->tx_tfm_mic, key->tx_mic, 427 eh->h_dest, eh->h_source, 0 /* priority */, 428 skb->data + ETH_HLEN, 429 len, mic); 430 } 431 432 return 0; 433} 434EXPORT_SYMBOL(orinoco_process_xmit_skb); 435 436static netdev_tx_t orinoco_xmit(struct sk_buff *skb, struct net_device *dev) 437{ 438 struct orinoco_private *priv = ndev_priv(dev); 439 struct net_device_stats *stats = &priv->stats; 440 hermes_t *hw = &priv->hw; 441 int err = 0; 442 u16 txfid = priv->txfid; 443 int tx_control; 444 unsigned long flags; 445 u8 mic_buf[MICHAEL_MIC_LEN+1]; 446 447 if (!netif_running(dev)) { 448 printk(KERN_ERR "%s: Tx on stopped device!\n", 449 dev->name); 450 return NETDEV_TX_BUSY; 451 } 452 453 if (netif_queue_stopped(dev)) { 454 printk(KERN_DEBUG "%s: Tx while transmitter busy!\n", 455 dev->name); 456 return NETDEV_TX_BUSY; 457 } 458 459 if (orinoco_lock(priv, &flags) != 0) { 460 printk(KERN_ERR "%s: orinoco_xmit() called while hw_unavailable\n", 461 dev->name); 462 return NETDEV_TX_BUSY; 463 } 464 465 if (!netif_carrier_ok(dev) || 466 (priv->iw_mode == NL80211_IFTYPE_MONITOR)) { 467 /* Oops, the firmware hasn't established a connection, 468 silently drop the packet (this seems to be the 469 safest approach). */ 470 goto drop; 471 } 472 473 /* Check packet length */ 474 if (skb->len < ETH_HLEN) 475 goto drop; 476 477 tx_control = HERMES_TXCTRL_TX_OK | HERMES_TXCTRL_TX_EX; 478 479 err = orinoco_process_xmit_skb(skb, dev, priv, &tx_control, 480 &mic_buf[0]); 481 if (err) 482 goto drop; 483 484 if (priv->has_alt_txcntl) { 485 /* WPA enabled firmwares have tx_cntl at the end of 486 * the 802.11 header. So write zeroed descriptor and 487 * 802.11 header at the same time 488 */ 489 char desc[HERMES_802_3_OFFSET]; 490 __le16 *txcntl = (__le16 *) &desc[HERMES_TXCNTL2_OFFSET]; 491 492 memset(&desc, 0, sizeof(desc)); 493 494 *txcntl = cpu_to_le16(tx_control); 495 err = hw->ops->bap_pwrite(hw, USER_BAP, &desc, sizeof(desc), 496 txfid, 0); 497 if (err) { 498 if (net_ratelimit()) 499 printk(KERN_ERR "%s: Error %d writing Tx " 500 "descriptor to BAP\n", dev->name, err); 501 goto busy; 502 } 503 } else { 504 struct hermes_tx_descriptor desc; 505 506 memset(&desc, 0, sizeof(desc)); 507 508 desc.tx_control = cpu_to_le16(tx_control); 509 err = hw->ops->bap_pwrite(hw, USER_BAP, &desc, sizeof(desc), 510 txfid, 0); 511 if (err) { 512 if (net_ratelimit()) 513 printk(KERN_ERR "%s: Error %d writing Tx " 514 "descriptor to BAP\n", dev->name, err); 515 goto busy; 516 } 517 518 /* Clear the 802.11 header and data length fields - some 519 * firmwares (e.g. Lucent/Agere 8.xx) appear to get confused 520 * if this isn't done. */ 521 hermes_clear_words(hw, HERMES_DATA0, 522 HERMES_802_3_OFFSET - HERMES_802_11_OFFSET); 523 } 524 525 err = hw->ops->bap_pwrite(hw, USER_BAP, skb->data, skb->len, 526 txfid, HERMES_802_3_OFFSET); 527 if (err) { 528 printk(KERN_ERR "%s: Error %d writing packet to BAP\n", 529 dev->name, err); 530 goto busy; 531 } 532 533 if (tx_control & HERMES_TXCTRL_MIC) { 534 size_t offset = HERMES_802_3_OFFSET + skb->len; 535 size_t len = MICHAEL_MIC_LEN; 536 537 if (offset % 2) { 538 offset--; 539 len++; 540 } 541 err = hw->ops->bap_pwrite(hw, USER_BAP, &mic_buf[0], len, 542 txfid, offset); 543 if (err) { 544 printk(KERN_ERR "%s: Error %d writing MIC to BAP\n", 545 dev->name, err); 546 goto busy; 547 } 548 } 549 550 /* Finally, we actually initiate the send */ 551 netif_stop_queue(dev); 552 553 err = hw->ops->cmd_wait(hw, HERMES_CMD_TX | HERMES_CMD_RECL, 554 txfid, NULL); 555 if (err) { 556 netif_start_queue(dev); 557 if (net_ratelimit()) 558 printk(KERN_ERR "%s: Error %d transmitting packet\n", 559 dev->name, err); 560 goto busy; 561 } 562 563 stats->tx_bytes += HERMES_802_3_OFFSET + skb->len; 564 goto ok; 565 566 drop: 567 stats->tx_errors++; 568 stats->tx_dropped++; 569 570 ok: 571 orinoco_unlock(priv, &flags); 572 dev_kfree_skb(skb); 573 return NETDEV_TX_OK; 574 575 busy: 576 if (err == -EIO) 577 schedule_work(&priv->reset_work); 578 orinoco_unlock(priv, &flags); 579 return NETDEV_TX_BUSY; 580} 581 582static void __orinoco_ev_alloc(struct net_device *dev, hermes_t *hw) 583{ 584 struct orinoco_private *priv = ndev_priv(dev); 585 u16 fid = hermes_read_regn(hw, ALLOCFID); 586 587 if (fid != priv->txfid) { 588 if (fid != DUMMY_FID) 589 printk(KERN_WARNING "%s: Allocate event on unexpected fid (%04X)\n", 590 dev->name, fid); 591 return; 592 } 593 594 hermes_write_regn(hw, ALLOCFID, DUMMY_FID); 595} 596 597static void __orinoco_ev_tx(struct net_device *dev, hermes_t *hw) 598{ 599 struct orinoco_private *priv = ndev_priv(dev); 600 struct net_device_stats *stats = &priv->stats; 601 602 stats->tx_packets++; 603 604 netif_wake_queue(dev); 605 606 hermes_write_regn(hw, TXCOMPLFID, DUMMY_FID); 607} 608 609static void __orinoco_ev_txexc(struct net_device *dev, hermes_t *hw) 610{ 611 struct orinoco_private *priv = ndev_priv(dev); 612 struct net_device_stats *stats = &priv->stats; 613 u16 fid = hermes_read_regn(hw, TXCOMPLFID); 614 u16 status; 615 struct hermes_txexc_data hdr; 616 int err = 0; 617 618 if (fid == DUMMY_FID) 619 return; /* Nothing's really happened */ 620 621 /* Read part of the frame header - we need status and addr1 */ 622 err = hw->ops->bap_pread(hw, IRQ_BAP, &hdr, 623 sizeof(struct hermes_txexc_data), 624 fid, 0); 625 626 hermes_write_regn(hw, TXCOMPLFID, DUMMY_FID); 627 stats->tx_errors++; 628 629 if (err) { 630 printk(KERN_WARNING "%s: Unable to read descriptor on Tx error " 631 "(FID=%04X error %d)\n", 632 dev->name, fid, err); 633 return; 634 } 635 636 DEBUG(1, "%s: Tx error, err %d (FID=%04X)\n", dev->name, 637 err, fid); 638 639 /* We produce a TXDROP event only for retry or lifetime 640 * exceeded, because that's the only status that really mean 641 * that this particular node went away. 642 * Other errors means that *we* screwed up. - Jean II */ 643 status = le16_to_cpu(hdr.desc.status); 644 if (status & (HERMES_TXSTAT_RETRYERR | HERMES_TXSTAT_AGEDERR)) { 645 union iwreq_data wrqu; 646 647 /* Copy 802.11 dest address. 648 * We use the 802.11 header because the frame may 649 * not be 802.3 or may be mangled... 650 * In Ad-Hoc mode, it will be the node address. 651 * In managed mode, it will be most likely the AP addr 652 * User space will figure out how to convert it to 653 * whatever it needs (IP address or else). 654 * - Jean II */ 655 memcpy(wrqu.addr.sa_data, hdr.addr1, ETH_ALEN); 656 wrqu.addr.sa_family = ARPHRD_ETHER; 657 658 /* Send event to user space */ 659 wireless_send_event(dev, IWEVTXDROP, &wrqu, NULL); 660 } 661 662 netif_wake_queue(dev); 663} 664 665void orinoco_tx_timeout(struct net_device *dev) 666{ 667 struct orinoco_private *priv = ndev_priv(dev); 668 struct net_device_stats *stats = &priv->stats; 669 struct hermes *hw = &priv->hw; 670 671 printk(KERN_WARNING "%s: Tx timeout! " 672 "ALLOCFID=%04x, TXCOMPLFID=%04x, EVSTAT=%04x\n", 673 dev->name, hermes_read_regn(hw, ALLOCFID), 674 hermes_read_regn(hw, TXCOMPLFID), hermes_read_regn(hw, EVSTAT)); 675 676 stats->tx_errors++; 677 678 schedule_work(&priv->reset_work); 679} 680EXPORT_SYMBOL(orinoco_tx_timeout); 681 682/********************************************************************/ 683/* Rx path (data frames) */ 684/********************************************************************/ 685 686/* Does the frame have a SNAP header indicating it should be 687 * de-encapsulated to Ethernet-II? */ 688static inline int is_ethersnap(void *_hdr) 689{ 690 u8 *hdr = _hdr; 691 692 /* We de-encapsulate all packets which, a) have SNAP headers 693 * (i.e. SSAP=DSAP=0xaa and CTRL=0x3 in the 802.2 LLC header 694 * and where b) the OUI of the SNAP header is 00:00:00 or 695 * 00:00:f8 - we need both because different APs appear to use 696 * different OUIs for some reason */ 697 return (memcmp(hdr, &encaps_hdr, 5) == 0) 698 && ((hdr[5] == 0x00) || (hdr[5] == 0xf8)); 699} 700 701static inline void orinoco_spy_gather(struct net_device *dev, u_char *mac, 702 int level, int noise) 703{ 704 struct iw_quality wstats; 705 wstats.level = level - 0x95; 706 wstats.noise = noise - 0x95; 707 wstats.qual = (level > noise) ? (level - noise) : 0; 708 wstats.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM; 709 /* Update spy records */ 710 wireless_spy_update(dev, mac, &wstats); 711} 712 713static void orinoco_stat_gather(struct net_device *dev, 714 struct sk_buff *skb, 715 struct hermes_rx_descriptor *desc) 716{ 717 struct orinoco_private *priv = ndev_priv(dev); 718 719 /* Using spy support with lots of Rx packets, like in an 720 * infrastructure (AP), will really slow down everything, because 721 * the MAC address must be compared to each entry of the spy list. 722 * If the user really asks for it (set some address in the 723 * spy list), we do it, but he will pay the price. 724 * Note that to get here, you need both WIRELESS_SPY 725 * compiled in AND some addresses in the list !!! 726 */ 727 /* Note : gcc will optimise the whole section away if 728 * WIRELESS_SPY is not defined... - Jean II */ 729 if (SPY_NUMBER(priv)) { 730 orinoco_spy_gather(dev, skb_mac_header(skb) + ETH_ALEN, 731 desc->signal, desc->silence); 732 } 733} 734 735/* 736 * orinoco_rx_monitor - handle received monitor frames. 737 * 738 * Arguments: 739 * dev network device 740 * rxfid received FID 741 * desc rx descriptor of the frame 742 * 743 * Call context: interrupt 744 */ 745static void orinoco_rx_monitor(struct net_device *dev, u16 rxfid, 746 struct hermes_rx_descriptor *desc) 747{ 748 u32 hdrlen = 30; /* return full header by default */ 749 u32 datalen = 0; 750 u16 fc; 751 int err; 752 int len; 753 struct sk_buff *skb; 754 struct orinoco_private *priv = ndev_priv(dev); 755 struct net_device_stats *stats = &priv->stats; 756 hermes_t *hw = &priv->hw; 757 758 len = le16_to_cpu(desc->data_len); 759 760 /* Determine the size of the header and the data */ 761 fc = le16_to_cpu(desc->frame_ctl); 762 switch (fc & IEEE80211_FCTL_FTYPE) { 763 case IEEE80211_FTYPE_DATA: 764 if ((fc & IEEE80211_FCTL_TODS) 765 && (fc & IEEE80211_FCTL_FROMDS)) 766 hdrlen = 30; 767 else 768 hdrlen = 24; 769 datalen = len; 770 break; 771 case IEEE80211_FTYPE_MGMT: 772 hdrlen = 24; 773 datalen = len; 774 break; 775 case IEEE80211_FTYPE_CTL: 776 switch (fc & IEEE80211_FCTL_STYPE) { 777 case IEEE80211_STYPE_PSPOLL: 778 case IEEE80211_STYPE_RTS: 779 case IEEE80211_STYPE_CFEND: 780 case IEEE80211_STYPE_CFENDACK: 781 hdrlen = 16; 782 break; 783 case IEEE80211_STYPE_CTS: 784 case IEEE80211_STYPE_ACK: 785 hdrlen = 10; 786 break; 787 } 788 break; 789 default: 790 /* Unknown frame type */ 791 break; 792 } 793 794 /* sanity check the length */ 795 if (datalen > IEEE80211_MAX_DATA_LEN + 12) { 796 printk(KERN_DEBUG "%s: oversized monitor frame, " 797 "data length = %d\n", dev->name, datalen); 798 stats->rx_length_errors++; 799 goto update_stats; 800 } 801 802 skb = dev_alloc_skb(hdrlen + datalen); 803 if (!skb) { 804 printk(KERN_WARNING "%s: Cannot allocate skb for monitor frame\n", 805 dev->name); 806 goto update_stats; 807 } 808 809 /* Copy the 802.11 header to the skb */ 810 memcpy(skb_put(skb, hdrlen), &(desc->frame_ctl), hdrlen); 811 skb_reset_mac_header(skb); 812 813 /* If any, copy the data from the card to the skb */ 814 if (datalen > 0) { 815 err = hw->ops->bap_pread(hw, IRQ_BAP, skb_put(skb, datalen), 816 ALIGN(datalen, 2), rxfid, 817 HERMES_802_2_OFFSET); 818 if (err) { 819 printk(KERN_ERR "%s: error %d reading monitor frame\n", 820 dev->name, err); 821 goto drop; 822 } 823 } 824 825 skb->dev = dev; 826 skb->ip_summed = CHECKSUM_NONE; 827 skb->pkt_type = PACKET_OTHERHOST; 828 skb->protocol = cpu_to_be16(ETH_P_802_2); 829 830 stats->rx_packets++; 831 stats->rx_bytes += skb->len; 832 833 netif_rx(skb); 834 return; 835 836 drop: 837 dev_kfree_skb_irq(skb); 838 update_stats: 839 stats->rx_errors++; 840 stats->rx_dropped++; 841} 842 843void __orinoco_ev_rx(struct net_device *dev, hermes_t *hw) 844{ 845 struct orinoco_private *priv = ndev_priv(dev); 846 struct net_device_stats *stats = &priv->stats; 847 struct iw_statistics *wstats = &priv->wstats; 848 struct sk_buff *skb = NULL; 849 u16 rxfid, status; 850 int length; 851 struct hermes_rx_descriptor *desc; 852 struct orinoco_rx_data *rx_data; 853 int err; 854 855 desc = kmalloc(sizeof(*desc), GFP_ATOMIC); 856 if (!desc) { 857 printk(KERN_WARNING 858 "%s: Can't allocate space for RX descriptor\n", 859 dev->name); 860 goto update_stats; 861 } 862 863 rxfid = hermes_read_regn(hw, RXFID); 864 865 err = hw->ops->bap_pread(hw, IRQ_BAP, desc, sizeof(*desc), 866 rxfid, 0); 867 if (err) { 868 printk(KERN_ERR "%s: error %d reading Rx descriptor. " 869 "Frame dropped.\n", dev->name, err); 870 goto update_stats; 871 } 872 873 status = le16_to_cpu(desc->status); 874 875 if (status & HERMES_RXSTAT_BADCRC) { 876 DEBUG(1, "%s: Bad CRC on Rx. Frame dropped.\n", 877 dev->name); 878 stats->rx_crc_errors++; 879 goto update_stats; 880 } 881 882 /* Handle frames in monitor mode */ 883 if (priv->iw_mode == NL80211_IFTYPE_MONITOR) { 884 orinoco_rx_monitor(dev, rxfid, desc); 885 goto out; 886 } 887 888 if (status & HERMES_RXSTAT_UNDECRYPTABLE) { 889 DEBUG(1, "%s: Undecryptable frame on Rx. Frame dropped.\n", 890 dev->name); 891 wstats->discard.code++; 892 goto update_stats; 893 } 894 895 length = le16_to_cpu(desc->data_len); 896 897 /* Sanity checks */ 898 if (length < 3) { /* No for even an 802.2 LLC header */ 899 /* At least on Symbol firmware with PCF we get quite a 900 lot of these legitimately - Poll frames with no 901 data. */ 902 goto out; 903 } 904 if (length > IEEE80211_MAX_DATA_LEN) { 905 printk(KERN_WARNING "%s: Oversized frame received (%d bytes)\n", 906 dev->name, length); 907 stats->rx_length_errors++; 908 goto update_stats; 909 } 910 911 /* Payload size does not include Michael MIC. Increase payload 912 * size to read it together with the data. */ 913 if (status & HERMES_RXSTAT_MIC) 914 length += MICHAEL_MIC_LEN; 915 916 /* We need space for the packet data itself, plus an ethernet 917 header, plus 2 bytes so we can align the IP header on a 918 32bit boundary, plus 1 byte so we can read in odd length 919 packets from the card, which has an IO granularity of 16 920 bits */ 921 skb = dev_alloc_skb(length+ETH_HLEN+2+1); 922 if (!skb) { 923 printk(KERN_WARNING "%s: Can't allocate skb for Rx\n", 924 dev->name); 925 goto update_stats; 926 } 927 928 /* We'll prepend the header, so reserve space for it. The worst 929 case is no decapsulation, when 802.3 header is prepended and 930 nothing is removed. 2 is for aligning the IP header. */ 931 skb_reserve(skb, ETH_HLEN + 2); 932 933 err = hw->ops->bap_pread(hw, IRQ_BAP, skb_put(skb, length), 934 ALIGN(length, 2), rxfid, 935 HERMES_802_2_OFFSET); 936 if (err) { 937 printk(KERN_ERR "%s: error %d reading frame. " 938 "Frame dropped.\n", dev->name, err); 939 goto drop; 940 } 941 942 /* Add desc and skb to rx queue */ 943 rx_data = kzalloc(sizeof(*rx_data), GFP_ATOMIC); 944 if (!rx_data) { 945 printk(KERN_WARNING "%s: Can't allocate RX packet\n", 946 dev->name); 947 goto drop; 948 } 949 rx_data->desc = desc; 950 rx_data->skb = skb; 951 list_add_tail(&rx_data->list, &priv->rx_list); 952 tasklet_schedule(&priv->rx_tasklet); 953 954 return; 955 956drop: 957 dev_kfree_skb_irq(skb); 958update_stats: 959 stats->rx_errors++; 960 stats->rx_dropped++; 961out: 962 kfree(desc); 963} 964EXPORT_SYMBOL(__orinoco_ev_rx); 965 966static void orinoco_rx(struct net_device *dev, 967 struct hermes_rx_descriptor *desc, 968 struct sk_buff *skb) 969{ 970 struct orinoco_private *priv = ndev_priv(dev); 971 struct net_device_stats *stats = &priv->stats; 972 u16 status, fc; 973 int length; 974 struct ethhdr *hdr; 975 976 status = le16_to_cpu(desc->status); 977 length = le16_to_cpu(desc->data_len); 978 fc = le16_to_cpu(desc->frame_ctl); 979 980 /* Calculate and check MIC */ 981 if (status & HERMES_RXSTAT_MIC) { 982 struct orinoco_tkip_key *key; 983 int key_id = ((status & HERMES_RXSTAT_MIC_KEY_ID) >> 984 HERMES_MIC_KEY_ID_SHIFT); 985 u8 mic[MICHAEL_MIC_LEN]; 986 u8 *rxmic; 987 u8 *src = (fc & IEEE80211_FCTL_FROMDS) ? 988 desc->addr3 : desc->addr2; 989 990 /* Extract Michael MIC from payload */ 991 rxmic = skb->data + skb->len - MICHAEL_MIC_LEN; 992 993 skb_trim(skb, skb->len - MICHAEL_MIC_LEN); 994 length -= MICHAEL_MIC_LEN; 995 996 key = (struct orinoco_tkip_key *) priv->keys[key_id].key; 997 998 if (!key) { 999 printk(KERN_WARNING "%s: Received encrypted frame from " 1000 "%pM using key %i, but key is not installed\n", 1001 dev->name, src, key_id); 1002 goto drop; 1003 } 1004 1005 orinoco_mic(priv->rx_tfm_mic, key->rx_mic, desc->addr1, src, 1006 0, /* priority or QoS? */ 1007 skb->data, skb->len, &mic[0]); 1008 1009 if (memcmp(mic, rxmic, 1010 MICHAEL_MIC_LEN)) { 1011 union iwreq_data wrqu; 1012 struct iw_michaelmicfailure wxmic; 1013 1014 printk(KERN_WARNING "%s: " 1015 "Invalid Michael MIC in data frame from %pM, " 1016 "using key %i\n", 1017 dev->name, src, key_id); 1018 1019 /* TODO: update stats */ 1020 1021 /* Notify userspace */ 1022 memset(&wxmic, 0, sizeof(wxmic)); 1023 wxmic.flags = key_id & IW_MICFAILURE_KEY_ID; 1024 wxmic.flags |= (desc->addr1[0] & 1) ? 1025 IW_MICFAILURE_GROUP : IW_MICFAILURE_PAIRWISE; 1026 wxmic.src_addr.sa_family = ARPHRD_ETHER; 1027 memcpy(wxmic.src_addr.sa_data, src, ETH_ALEN); 1028 1029 (void) orinoco_hw_get_tkip_iv(priv, key_id, 1030 &wxmic.tsc[0]); 1031 1032 memset(&wrqu, 0, sizeof(wrqu)); 1033 wrqu.data.length = sizeof(wxmic); 1034 wireless_send_event(dev, IWEVMICHAELMICFAILURE, &wrqu, 1035 (char *) &wxmic); 1036 1037 goto drop; 1038 } 1039 } 1040 1041 /* Handle decapsulation 1042 * In most cases, the firmware tell us about SNAP frames. 1043 * For some reason, the SNAP frames sent by LinkSys APs 1044 * are not properly recognised by most firmwares. 1045 * So, check ourselves */ 1046 if (length >= ENCAPS_OVERHEAD && 1047 (((status & HERMES_RXSTAT_MSGTYPE) == HERMES_RXSTAT_1042) || 1048 ((status & HERMES_RXSTAT_MSGTYPE) == HERMES_RXSTAT_TUNNEL) || 1049 is_ethersnap(skb->data))) { 1050 /* These indicate a SNAP within 802.2 LLC within 1051 802.11 frame which we'll need to de-encapsulate to 1052 the original EthernetII frame. */ 1053 hdr = (struct ethhdr *)skb_push(skb, 1054 ETH_HLEN - ENCAPS_OVERHEAD); 1055 } else { 1056 /* 802.3 frame - prepend 802.3 header as is */ 1057 hdr = (struct ethhdr *)skb_push(skb, ETH_HLEN); 1058 hdr->h_proto = htons(length); 1059 } 1060 memcpy(hdr->h_dest, desc->addr1, ETH_ALEN); 1061 if (fc & IEEE80211_FCTL_FROMDS) 1062 memcpy(hdr->h_source, desc->addr3, ETH_ALEN); 1063 else 1064 memcpy(hdr->h_source, desc->addr2, ETH_ALEN); 1065 1066 skb->protocol = eth_type_trans(skb, dev); 1067 skb->ip_summed = CHECKSUM_NONE; 1068 if (fc & IEEE80211_FCTL_TODS) 1069 skb->pkt_type = PACKET_OTHERHOST; 1070 1071 /* Process the wireless stats if needed */ 1072 orinoco_stat_gather(dev, skb, desc); 1073 1074 /* Pass the packet to the networking stack */ 1075 netif_rx(skb); 1076 stats->rx_packets++; 1077 stats->rx_bytes += length; 1078 1079 return; 1080 1081 drop: 1082 dev_kfree_skb(skb); 1083 stats->rx_errors++; 1084 stats->rx_dropped++; 1085} 1086 1087static void orinoco_rx_isr_tasklet(unsigned long data) 1088{ 1089 struct orinoco_private *priv = (struct orinoco_private *) data; 1090 struct net_device *dev = priv->ndev; 1091 struct orinoco_rx_data *rx_data, *temp; 1092 struct hermes_rx_descriptor *desc; 1093 struct sk_buff *skb; 1094 unsigned long flags; 1095 1096 /* orinoco_rx requires the driver lock, and we also need to 1097 * protect priv->rx_list, so just hold the lock over the 1098 * lot. 1099 * 1100 * If orinoco_lock fails, we've unplugged the card. In this 1101 * case just abort. */ 1102 if (orinoco_lock(priv, &flags) != 0) 1103 return; 1104 1105 /* extract desc and skb from queue */ 1106 list_for_each_entry_safe(rx_data, temp, &priv->rx_list, list) { 1107 desc = rx_data->desc; 1108 skb = rx_data->skb; 1109 list_del(&rx_data->list); 1110 kfree(rx_data); 1111 1112 orinoco_rx(dev, desc, skb); 1113 1114 kfree(desc); 1115 } 1116 1117 orinoco_unlock(priv, &flags); 1118} 1119 1120/********************************************************************/ 1121/* Rx path (info frames) */ 1122/********************************************************************/ 1123 1124static void print_linkstatus(struct net_device *dev, u16 status) 1125{ 1126 char *s; 1127 1128 if (suppress_linkstatus) 1129 return; 1130 1131 switch (status) { 1132 case HERMES_LINKSTATUS_NOT_CONNECTED: 1133 s = "Not Connected"; 1134 break; 1135 case HERMES_LINKSTATUS_CONNECTED: 1136 s = "Connected"; 1137 break; 1138 case HERMES_LINKSTATUS_DISCONNECTED: 1139 s = "Disconnected"; 1140 break; 1141 case HERMES_LINKSTATUS_AP_CHANGE: 1142 s = "AP Changed"; 1143 break; 1144 case HERMES_LINKSTATUS_AP_OUT_OF_RANGE: 1145 s = "AP Out of Range"; 1146 break; 1147 case HERMES_LINKSTATUS_AP_IN_RANGE: 1148 s = "AP In Range"; 1149 break; 1150 case HERMES_LINKSTATUS_ASSOC_FAILED: 1151 s = "Association Failed"; 1152 break; 1153 default: 1154 s = "UNKNOWN"; 1155 } 1156 1157 printk(KERN_DEBUG "%s: New link status: %s (%04x)\n", 1158 dev->name, s, status); 1159} 1160 1161/* Search scan results for requested BSSID, join it if found */ 1162static void orinoco_join_ap(struct work_struct *work) 1163{ 1164 struct orinoco_private *priv = 1165 container_of(work, struct orinoco_private, join_work); 1166 struct net_device *dev = priv->ndev; 1167 struct hermes *hw = &priv->hw; 1168 int err; 1169 unsigned long flags; 1170 struct join_req { 1171 u8 bssid[ETH_ALEN]; 1172 __le16 channel; 1173 } __packed req; 1174 const int atom_len = offsetof(struct prism2_scan_apinfo, atim); 1175 struct prism2_scan_apinfo *atom = NULL; 1176 int offset = 4; 1177 int found = 0; 1178 u8 *buf; 1179 u16 len; 1180 1181 /* Allocate buffer for scan results */ 1182 buf = kmalloc(MAX_SCAN_LEN, GFP_KERNEL); 1183 if (!buf) 1184 return; 1185 1186 if (orinoco_lock(priv, &flags) != 0) 1187 goto fail_lock; 1188 1189 /* Sanity checks in case user changed something in the meantime */ 1190 if (!priv->bssid_fixed) 1191 goto out; 1192 1193 if (strlen(priv->desired_essid) == 0) 1194 goto out; 1195 1196 /* Read scan results from the firmware */ 1197 err = hw->ops->read_ltv(hw, USER_BAP, 1198 HERMES_RID_SCANRESULTSTABLE, 1199 MAX_SCAN_LEN, &len, buf); 1200 if (err) { 1201 printk(KERN_ERR "%s: Cannot read scan results\n", 1202 dev->name); 1203 goto out; 1204 } 1205 1206 len = HERMES_RECLEN_TO_BYTES(len); 1207 1208 /* Go through the scan results looking for the channel of the AP 1209 * we were requested to join */ 1210 for (; offset + atom_len <= len; offset += atom_len) { 1211 atom = (struct prism2_scan_apinfo *) (buf + offset); 1212 if (memcmp(&atom->bssid, priv->desired_bssid, ETH_ALEN) == 0) { 1213 found = 1; 1214 break; 1215 } 1216 } 1217 1218 if (!found) { 1219 DEBUG(1, "%s: Requested AP not found in scan results\n", 1220 dev->name); 1221 goto out; 1222 } 1223 1224 memcpy(req.bssid, priv->desired_bssid, ETH_ALEN); 1225 req.channel = atom->channel; /* both are little-endian */ 1226 err = HERMES_WRITE_RECORD(hw, USER_BAP, HERMES_RID_CNFJOINREQUEST, 1227 &req); 1228 if (err) 1229 printk(KERN_ERR "%s: Error issuing join request\n", dev->name); 1230 1231 out: 1232 orinoco_unlock(priv, &flags); 1233 1234 fail_lock: 1235 kfree(buf); 1236} 1237 1238/* Send new BSSID to userspace */ 1239static void orinoco_send_bssid_wevent(struct orinoco_private *priv) 1240{ 1241 struct net_device *dev = priv->ndev; 1242 struct hermes *hw = &priv->hw; 1243 union iwreq_data wrqu; 1244 int err; 1245 1246 err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CURRENTBSSID, 1247 ETH_ALEN, NULL, wrqu.ap_addr.sa_data); 1248 if (err != 0) 1249 return; 1250 1251 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 1252 1253 /* Send event to user space */ 1254 wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL); 1255} 1256 1257static void orinoco_send_assocreqie_wevent(struct orinoco_private *priv) 1258{ 1259 struct net_device *dev = priv->ndev; 1260 struct hermes *hw = &priv->hw; 1261 union iwreq_data wrqu; 1262 int err; 1263 u8 buf[88]; 1264 u8 *ie; 1265 1266 if (!priv->has_wpa) 1267 return; 1268 1269 err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CURRENT_ASSOC_REQ_INFO, 1270 sizeof(buf), NULL, &buf); 1271 if (err != 0) 1272 return; 1273 1274 ie = orinoco_get_wpa_ie(buf, sizeof(buf)); 1275 if (ie) { 1276 int rem = sizeof(buf) - (ie - &buf[0]); 1277 wrqu.data.length = ie[1] + 2; 1278 if (wrqu.data.length > rem) 1279 wrqu.data.length = rem; 1280 1281 if (wrqu.data.length) 1282 /* Send event to user space */ 1283 wireless_send_event(dev, IWEVASSOCREQIE, &wrqu, ie); 1284 } 1285} 1286 1287static void orinoco_send_assocrespie_wevent(struct orinoco_private *priv) 1288{ 1289 struct net_device *dev = priv->ndev; 1290 struct hermes *hw = &priv->hw; 1291 union iwreq_data wrqu; 1292 int err; 1293 u8 buf[88]; /* TODO: verify max size or IW_GENERIC_IE_MAX */ 1294 u8 *ie; 1295 1296 if (!priv->has_wpa) 1297 return; 1298 1299 err = hw->ops->read_ltv(hw, USER_BAP, 1300 HERMES_RID_CURRENT_ASSOC_RESP_INFO, 1301 sizeof(buf), NULL, &buf); 1302 if (err != 0) 1303 return; 1304 1305 ie = orinoco_get_wpa_ie(buf, sizeof(buf)); 1306 if (ie) { 1307 int rem = sizeof(buf) - (ie - &buf[0]); 1308 wrqu.data.length = ie[1] + 2; 1309 if (wrqu.data.length > rem) 1310 wrqu.data.length = rem; 1311 1312 if (wrqu.data.length) 1313 /* Send event to user space */ 1314 wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu, ie); 1315 } 1316} 1317 1318static void orinoco_send_wevents(struct work_struct *work) 1319{ 1320 struct orinoco_private *priv = 1321 container_of(work, struct orinoco_private, wevent_work); 1322 unsigned long flags; 1323 1324 if (orinoco_lock(priv, &flags) != 0) 1325 return; 1326 1327 orinoco_send_assocreqie_wevent(priv); 1328 orinoco_send_assocrespie_wevent(priv); 1329 orinoco_send_bssid_wevent(priv); 1330 1331 orinoco_unlock(priv, &flags); 1332} 1333 1334static void qbuf_scan(struct orinoco_private *priv, void *buf, 1335 int len, int type) 1336{ 1337 struct orinoco_scan_data *sd; 1338 unsigned long flags; 1339 1340 sd = kmalloc(sizeof(*sd), GFP_ATOMIC); 1341 sd->buf = buf; 1342 sd->len = len; 1343 sd->type = type; 1344 1345 spin_lock_irqsave(&priv->scan_lock, flags); 1346 list_add_tail(&sd->list, &priv->scan_list); 1347 spin_unlock_irqrestore(&priv->scan_lock, flags); 1348 1349 schedule_work(&priv->process_scan); 1350} 1351 1352static void qabort_scan(struct orinoco_private *priv) 1353{ 1354 struct orinoco_scan_data *sd; 1355 unsigned long flags; 1356 1357 sd = kmalloc(sizeof(*sd), GFP_ATOMIC); 1358 sd->len = -1; /* Abort */ 1359 1360 spin_lock_irqsave(&priv->scan_lock, flags); 1361 list_add_tail(&sd->list, &priv->scan_list); 1362 spin_unlock_irqrestore(&priv->scan_lock, flags); 1363 1364 schedule_work(&priv->process_scan); 1365} 1366 1367static void orinoco_process_scan_results(struct work_struct *work) 1368{ 1369 struct orinoco_private *priv = 1370 container_of(work, struct orinoco_private, process_scan); 1371 struct orinoco_scan_data *sd, *temp; 1372 unsigned long flags; 1373 void *buf; 1374 int len; 1375 int type; 1376 1377 spin_lock_irqsave(&priv->scan_lock, flags); 1378 list_for_each_entry_safe(sd, temp, &priv->scan_list, list) { 1379 spin_unlock_irqrestore(&priv->scan_lock, flags); 1380 1381 buf = sd->buf; 1382 len = sd->len; 1383 type = sd->type; 1384 1385 list_del(&sd->list); 1386 kfree(sd); 1387 1388 if (len > 0) { 1389 if (type == HERMES_INQ_CHANNELINFO) 1390 orinoco_add_extscan_result(priv, buf, len); 1391 else 1392 orinoco_add_hostscan_results(priv, buf, len); 1393 1394 kfree(buf); 1395 } else if (priv->scan_request) { 1396 /* Either abort or complete the scan */ 1397 cfg80211_scan_done(priv->scan_request, (len < 0)); 1398 priv->scan_request = NULL; 1399 } 1400 1401 spin_lock_irqsave(&priv->scan_lock, flags); 1402 } 1403 spin_unlock_irqrestore(&priv->scan_lock, flags); 1404} 1405 1406void __orinoco_ev_info(struct net_device *dev, hermes_t *hw) 1407{ 1408 struct orinoco_private *priv = ndev_priv(dev); 1409 u16 infofid; 1410 struct { 1411 __le16 len; 1412 __le16 type; 1413 } __packed info; 1414 int len, type; 1415 int err; 1416 1417 /* This is an answer to an INQUIRE command that we did earlier, 1418 * or an information "event" generated by the card 1419 * The controller return to us a pseudo frame containing 1420 * the information in question - Jean II */ 1421 infofid = hermes_read_regn(hw, INFOFID); 1422 1423 /* Read the info frame header - don't try too hard */ 1424 err = hw->ops->bap_pread(hw, IRQ_BAP, &info, sizeof(info), 1425 infofid, 0); 1426 if (err) { 1427 printk(KERN_ERR "%s: error %d reading info frame. " 1428 "Frame dropped.\n", dev->name, err); 1429 return; 1430 } 1431 1432 len = HERMES_RECLEN_TO_BYTES(le16_to_cpu(info.len)); 1433 type = le16_to_cpu(info.type); 1434 1435 switch (type) { 1436 case HERMES_INQ_TALLIES: { 1437 struct hermes_tallies_frame tallies; 1438 struct iw_statistics *wstats = &priv->wstats; 1439 1440 if (len > sizeof(tallies)) { 1441 printk(KERN_WARNING "%s: Tallies frame too long (%d bytes)\n", 1442 dev->name, len); 1443 len = sizeof(tallies); 1444 } 1445 1446 err = hw->ops->bap_pread(hw, IRQ_BAP, &tallies, len, 1447 infofid, sizeof(info)); 1448 if (err) 1449 break; 1450 1451 /* Increment our various counters */ 1452 /* wstats->discard.nwid - no wrong BSSID stuff */ 1453 wstats->discard.code += 1454 le16_to_cpu(tallies.RxWEPUndecryptable); 1455 if (len == sizeof(tallies)) 1456 wstats->discard.code += 1457 le16_to_cpu(tallies.RxDiscards_WEPICVError) + 1458 le16_to_cpu(tallies.RxDiscards_WEPExcluded); 1459 wstats->discard.misc += 1460 le16_to_cpu(tallies.TxDiscardsWrongSA); 1461 wstats->discard.fragment += 1462 le16_to_cpu(tallies.RxMsgInBadMsgFragments); 1463 wstats->discard.retries += 1464 le16_to_cpu(tallies.TxRetryLimitExceeded); 1465 /* wstats->miss.beacon - no match */ 1466 } 1467 break; 1468 case HERMES_INQ_LINKSTATUS: { 1469 struct hermes_linkstatus linkstatus; 1470 u16 newstatus; 1471 int connected; 1472 1473 if (priv->iw_mode == NL80211_IFTYPE_MONITOR) 1474 break; 1475 1476 if (len != sizeof(linkstatus)) { 1477 printk(KERN_WARNING "%s: Unexpected size for linkstatus frame (%d bytes)\n", 1478 dev->name, len); 1479 break; 1480 } 1481 1482 err = hw->ops->bap_pread(hw, IRQ_BAP, &linkstatus, len, 1483 infofid, sizeof(info)); 1484 if (err) 1485 break; 1486 newstatus = le16_to_cpu(linkstatus.linkstatus); 1487 1488 /* Symbol firmware uses "out of range" to signal that 1489 * the hostscan frame can be requested. */ 1490 if (newstatus == HERMES_LINKSTATUS_AP_OUT_OF_RANGE && 1491 priv->firmware_type == FIRMWARE_TYPE_SYMBOL && 1492 priv->has_hostscan && priv->scan_request) { 1493 hermes_inquire(hw, HERMES_INQ_HOSTSCAN_SYMBOL); 1494 break; 1495 } 1496 1497 connected = (newstatus == HERMES_LINKSTATUS_CONNECTED) 1498 || (newstatus == HERMES_LINKSTATUS_AP_CHANGE) 1499 || (newstatus == HERMES_LINKSTATUS_AP_IN_RANGE); 1500 1501 if (connected) 1502 netif_carrier_on(dev); 1503 else if (!ignore_disconnect) 1504 netif_carrier_off(dev); 1505 1506 if (newstatus != priv->last_linkstatus) { 1507 priv->last_linkstatus = newstatus; 1508 print_linkstatus(dev, newstatus); 1509 /* The info frame contains only one word which is the 1510 * status (see hermes.h). The status is pretty boring 1511 * in itself, that's why we export the new BSSID... 1512 * Jean II */ 1513 schedule_work(&priv->wevent_work); 1514 } 1515 } 1516 break; 1517 case HERMES_INQ_SCAN: 1518 if (!priv->scan_request && priv->bssid_fixed && 1519 priv->firmware_type == FIRMWARE_TYPE_INTERSIL) { 1520 schedule_work(&priv->join_work); 1521 break; 1522 } 1523 /* fall through */ 1524 case HERMES_INQ_HOSTSCAN: 1525 case HERMES_INQ_HOSTSCAN_SYMBOL: { 1526 /* Result of a scanning. Contains information about 1527 * cells in the vicinity - Jean II */ 1528 unsigned char *buf; 1529 1530 /* Sanity check */ 1531 if (len > 4096) { 1532 printk(KERN_WARNING "%s: Scan results too large (%d bytes)\n", 1533 dev->name, len); 1534 qabort_scan(priv); 1535 break; 1536 } 1537 1538 /* Allocate buffer for results */ 1539 buf = kmalloc(len, GFP_ATOMIC); 1540 if (buf == NULL) { 1541 /* No memory, so can't printk()... */ 1542 qabort_scan(priv); 1543 break; 1544 } 1545 1546 /* Read scan data */ 1547 err = hw->ops->bap_pread(hw, IRQ_BAP, (void *) buf, len, 1548 infofid, sizeof(info)); 1549 if (err) { 1550 kfree(buf); 1551 qabort_scan(priv); 1552 break; 1553 } 1554 1555#ifdef ORINOCO_DEBUG 1556 { 1557 int i; 1558 printk(KERN_DEBUG "Scan result [%02X", buf[0]); 1559 for (i = 1; i < (len * 2); i++) 1560 printk(":%02X", buf[i]); 1561 printk("]\n"); 1562 } 1563#endif /* ORINOCO_DEBUG */ 1564 1565 qbuf_scan(priv, buf, len, type); 1566 } 1567 break; 1568 case HERMES_INQ_CHANNELINFO: 1569 { 1570 struct agere_ext_scan_info *bss; 1571 1572 if (!priv->scan_request) { 1573 printk(KERN_DEBUG "%s: Got chaninfo without scan, " 1574 "len=%d\n", dev->name, len); 1575 break; 1576 } 1577 1578 /* An empty result indicates that the scan is complete */ 1579 if (len == 0) { 1580 qbuf_scan(priv, NULL, len, type); 1581 break; 1582 } 1583 1584 /* Sanity check */ 1585 else if (len < (offsetof(struct agere_ext_scan_info, 1586 data) + 2)) { 1587 /* Drop this result now so we don't have to 1588 * keep checking later */ 1589 printk(KERN_WARNING 1590 "%s: Ext scan results too short (%d bytes)\n", 1591 dev->name, len); 1592 break; 1593 } 1594 1595 bss = kmalloc(len, GFP_ATOMIC); 1596 if (bss == NULL) 1597 break; 1598 1599 /* Read scan data */ 1600 err = hw->ops->bap_pread(hw, IRQ_BAP, (void *) bss, len, 1601 infofid, sizeof(info)); 1602 if (err) 1603 kfree(bss); 1604 else 1605 qbuf_scan(priv, bss, len, type); 1606 1607 break; 1608 } 1609 case HERMES_INQ_SEC_STAT_AGERE: 1610 /* Security status (Agere specific) */ 1611 /* Ignore this frame for now */ 1612 if (priv->firmware_type == FIRMWARE_TYPE_AGERE) 1613 break; 1614 /* fall through */ 1615 default: 1616 printk(KERN_DEBUG "%s: Unknown information frame received: " 1617 "type 0x%04x, length %d\n", dev->name, type, len); 1618 /* We don't actually do anything about it */ 1619 break; 1620 } 1621} 1622EXPORT_SYMBOL(__orinoco_ev_info); 1623 1624static void __orinoco_ev_infdrop(struct net_device *dev, hermes_t *hw) 1625{ 1626 if (net_ratelimit()) 1627 printk(KERN_DEBUG "%s: Information frame lost.\n", dev->name); 1628} 1629 1630/********************************************************************/ 1631/* Internal hardware control routines */ 1632/********************************************************************/ 1633 1634static int __orinoco_up(struct orinoco_private *priv) 1635{ 1636 struct net_device *dev = priv->ndev; 1637 struct hermes *hw = &priv->hw; 1638 int err; 1639 1640 netif_carrier_off(dev); /* just to make sure */ 1641 1642 err = __orinoco_commit(priv); 1643 if (err) { 1644 printk(KERN_ERR "%s: Error %d configuring card\n", 1645 dev->name, err); 1646 return err; 1647 } 1648 1649 /* Fire things up again */ 1650 hermes_set_irqmask(hw, ORINOCO_INTEN); 1651 err = hermes_enable_port(hw, 0); 1652 if (err) { 1653 printk(KERN_ERR "%s: Error %d enabling MAC port\n", 1654 dev->name, err); 1655 return err; 1656 } 1657 1658 netif_start_queue(dev); 1659 1660 return 0; 1661} 1662 1663static int __orinoco_down(struct orinoco_private *priv) 1664{ 1665 struct net_device *dev = priv->ndev; 1666 struct hermes *hw = &priv->hw; 1667 int err; 1668 1669 netif_stop_queue(dev); 1670 1671 if (!priv->hw_unavailable) { 1672 if (!priv->broken_disableport) { 1673 err = hermes_disable_port(hw, 0); 1674 if (err) { 1675 /* Some firmwares (e.g. Intersil 1.3.x) seem 1676 * to have problems disabling the port, oh 1677 * well, too bad. */ 1678 printk(KERN_WARNING "%s: Error %d disabling MAC port\n", 1679 dev->name, err); 1680 priv->broken_disableport = 1; 1681 } 1682 } 1683 hermes_set_irqmask(hw, 0); 1684 hermes_write_regn(hw, EVACK, 0xffff); 1685 } 1686 1687 /* firmware will have to reassociate */ 1688 netif_carrier_off(dev); 1689 priv->last_linkstatus = 0xffff; 1690 1691 return 0; 1692} 1693 1694static int orinoco_reinit_firmware(struct orinoco_private *priv) 1695{ 1696 struct hermes *hw = &priv->hw; 1697 int err; 1698 1699 err = hw->ops->init(hw); 1700 if (priv->do_fw_download && !err) { 1701 err = orinoco_download(priv); 1702 if (err) 1703 priv->do_fw_download = 0; 1704 } 1705 if (!err) 1706 err = orinoco_hw_allocate_fid(priv); 1707 1708 return err; 1709} 1710 1711static int 1712__orinoco_set_multicast_list(struct net_device *dev) 1713{ 1714 struct orinoco_private *priv = ndev_priv(dev); 1715 int err = 0; 1716 int promisc, mc_count; 1717 1718 /* The Hermes doesn't seem to have an allmulti mode, so we go 1719 * into promiscuous mode and let the upper levels deal. */ 1720 if ((dev->flags & IFF_PROMISC) || (dev->flags & IFF_ALLMULTI) || 1721 (netdev_mc_count(dev) > MAX_MULTICAST(priv))) { 1722 promisc = 1; 1723 mc_count = 0; 1724 } else { 1725 promisc = 0; 1726 mc_count = netdev_mc_count(dev); 1727 } 1728 1729 err = __orinoco_hw_set_multicast_list(priv, dev, mc_count, promisc); 1730 1731 return err; 1732} 1733 1734/* This must be called from user context, without locks held - use 1735 * schedule_work() */ 1736void orinoco_reset(struct work_struct *work) 1737{ 1738 struct orinoco_private *priv = 1739 container_of(work, struct orinoco_private, reset_work); 1740 struct net_device *dev = priv->ndev; 1741 struct hermes *hw = &priv->hw; 1742 int err; 1743 unsigned long flags; 1744 1745 if (orinoco_lock(priv, &flags) != 0) 1746 /* When the hardware becomes available again, whatever 1747 * detects that is responsible for re-initializing 1748 * it. So no need for anything further */ 1749 return; 1750 1751 netif_stop_queue(dev); 1752 1753 /* Shut off interrupts. Depending on what state the hardware 1754 * is in, this might not work, but we'll try anyway */ 1755 hermes_set_irqmask(hw, 0); 1756 hermes_write_regn(hw, EVACK, 0xffff); 1757 1758 priv->hw_unavailable++; 1759 priv->last_linkstatus = 0xffff; /* firmware will have to reassociate */ 1760 netif_carrier_off(dev); 1761 1762 orinoco_unlock(priv, &flags); 1763 1764 /* Scanning support: Notify scan cancellation */ 1765 if (priv->scan_request) { 1766 cfg80211_scan_done(priv->scan_request, 1); 1767 priv->scan_request = NULL; 1768 } 1769 1770 if (priv->hard_reset) { 1771 err = (*priv->hard_reset)(priv); 1772 if (err) { 1773 printk(KERN_ERR "%s: orinoco_reset: Error %d " 1774 "performing hard reset\n", dev->name, err); 1775 goto disable; 1776 } 1777 } 1778 1779 err = orinoco_reinit_firmware(priv); 1780 if (err) { 1781 printk(KERN_ERR "%s: orinoco_reset: Error %d re-initializing firmware\n", 1782 dev->name, err); 1783 goto disable; 1784 } 1785 1786 /* This has to be called from user context */ 1787 orinoco_lock_irq(priv); 1788 1789 priv->hw_unavailable--; 1790 1791 /* priv->open or priv->hw_unavailable might have changed while 1792 * we dropped the lock */ 1793 if (priv->open && (!priv->hw_unavailable)) { 1794 err = __orinoco_up(priv); 1795 if (err) { 1796 printk(KERN_ERR "%s: orinoco_reset: Error %d reenabling card\n", 1797 dev->name, err); 1798 } else 1799 dev->trans_start = jiffies; 1800 } 1801 1802 orinoco_unlock_irq(priv); 1803 1804 return; 1805 disable: 1806 hermes_set_irqmask(hw, 0); 1807 netif_device_detach(dev); 1808 printk(KERN_ERR "%s: Device has been disabled!\n", dev->name); 1809} 1810 1811static int __orinoco_commit(struct orinoco_private *priv) 1812{ 1813 struct net_device *dev = priv->ndev; 1814 int err = 0; 1815 1816 /* If we've called commit, we are reconfiguring or bringing the 1817 * interface up. Maintaining countermeasures across this would 1818 * be confusing, so note that we've disabled them. The port will 1819 * be enabled later in orinoco_commit or __orinoco_up. */ 1820 priv->tkip_cm_active = 0; 1821 1822 err = orinoco_hw_program_rids(priv); 1823 1824 (void) __orinoco_set_multicast_list(dev); 1825 1826 return err; 1827} 1828 1829/* Ensures configuration changes are applied. May result in a reset. 1830 * The caller should hold priv->lock 1831 */ 1832int orinoco_commit(struct orinoco_private *priv) 1833{ 1834 struct net_device *dev = priv->ndev; 1835 hermes_t *hw = &priv->hw; 1836 int err; 1837 1838 if (priv->broken_disableport) { 1839 schedule_work(&priv->reset_work); 1840 return 0; 1841 } 1842 1843 err = hermes_disable_port(hw, 0); 1844 if (err) { 1845 printk(KERN_WARNING "%s: Unable to disable port " 1846 "while reconfiguring card\n", dev->name); 1847 priv->broken_disableport = 1; 1848 goto out; 1849 } 1850 1851 err = __orinoco_commit(priv); 1852 if (err) { 1853 printk(KERN_WARNING "%s: Unable to reconfigure card\n", 1854 dev->name); 1855 goto out; 1856 } 1857 1858 err = hermes_enable_port(hw, 0); 1859 if (err) { 1860 printk(KERN_WARNING "%s: Unable to enable port while reconfiguring card\n", 1861 dev->name); 1862 goto out; 1863 } 1864 1865 out: 1866 if (err) { 1867 printk(KERN_WARNING "%s: Resetting instead...\n", dev->name); 1868 schedule_work(&priv->reset_work); 1869 err = 0; 1870 } 1871 return err; 1872} 1873 1874/********************************************************************/ 1875/* Interrupt handler */ 1876/********************************************************************/ 1877 1878static void __orinoco_ev_tick(struct net_device *dev, hermes_t *hw) 1879{ 1880 printk(KERN_DEBUG "%s: TICK\n", dev->name); 1881} 1882 1883static void __orinoco_ev_wterr(struct net_device *dev, hermes_t *hw) 1884{ 1885 /* This seems to happen a fair bit under load, but ignoring it 1886 seems to work fine...*/ 1887 printk(KERN_DEBUG "%s: MAC controller error (WTERR). Ignoring.\n", 1888 dev->name); 1889} 1890 1891irqreturn_t orinoco_interrupt(int irq, void *dev_id) 1892{ 1893 struct orinoco_private *priv = dev_id; 1894 struct net_device *dev = priv->ndev; 1895 hermes_t *hw = &priv->hw; 1896 int count = MAX_IRQLOOPS_PER_IRQ; 1897 u16 evstat, events; 1898 /* These are used to detect a runaway interrupt situation. 1899 * 1900 * If we get more than MAX_IRQLOOPS_PER_JIFFY iterations in a jiffy, 1901 * we panic and shut down the hardware 1902 */ 1903 /* jiffies value the last time we were called */ 1904 static int last_irq_jiffy; /* = 0 */ 1905 static int loops_this_jiffy; /* = 0 */ 1906 unsigned long flags; 1907 1908 if (orinoco_lock(priv, &flags) != 0) { 1909 /* If hw is unavailable - we don't know if the irq was 1910 * for us or not */ 1911 return IRQ_HANDLED; 1912 } 1913 1914 evstat = hermes_read_regn(hw, EVSTAT); 1915 events = evstat & hw->inten; 1916 if (!events) { 1917 orinoco_unlock(priv, &flags); 1918 return IRQ_NONE; 1919 } 1920 1921 if (jiffies != last_irq_jiffy) 1922 loops_this_jiffy = 0; 1923 last_irq_jiffy = jiffies; 1924 1925 while (events && count--) { 1926 if (++loops_this_jiffy > MAX_IRQLOOPS_PER_JIFFY) { 1927 printk(KERN_WARNING "%s: IRQ handler is looping too " 1928 "much! Resetting.\n", dev->name); 1929 /* Disable interrupts for now */ 1930 hermes_set_irqmask(hw, 0); 1931 schedule_work(&priv->reset_work); 1932 break; 1933 } 1934 1935 /* Check the card hasn't been removed */ 1936 if (!hermes_present(hw)) { 1937 DEBUG(0, "orinoco_interrupt(): card removed\n"); 1938 break; 1939 } 1940 1941 if (events & HERMES_EV_TICK) 1942 __orinoco_ev_tick(dev, hw); 1943 if (events & HERMES_EV_WTERR) 1944 __orinoco_ev_wterr(dev, hw); 1945 if (events & HERMES_EV_INFDROP) 1946 __orinoco_ev_infdrop(dev, hw); 1947 if (events & HERMES_EV_INFO) 1948 __orinoco_ev_info(dev, hw); 1949 if (events & HERMES_EV_RX) 1950 __orinoco_ev_rx(dev, hw); 1951 if (events & HERMES_EV_TXEXC) 1952 __orinoco_ev_txexc(dev, hw); 1953 if (events & HERMES_EV_TX) 1954 __orinoco_ev_tx(dev, hw); 1955 if (events & HERMES_EV_ALLOC) 1956 __orinoco_ev_alloc(dev, hw); 1957 1958 hermes_write_regn(hw, EVACK, evstat); 1959 1960 evstat = hermes_read_regn(hw, EVSTAT); 1961 events = evstat & hw->inten; 1962 }; 1963 1964 orinoco_unlock(priv, &flags); 1965 return IRQ_HANDLED; 1966} 1967EXPORT_SYMBOL(orinoco_interrupt); 1968 1969/********************************************************************/ 1970/* Power management */ 1971/********************************************************************/ 1972#if defined(CONFIG_PM_SLEEP) && !defined(CONFIG_HERMES_CACHE_FW_ON_INIT) 1973static int orinoco_pm_notifier(struct notifier_block *notifier, 1974 unsigned long pm_event, 1975 void *unused) 1976{ 1977 struct orinoco_private *priv = container_of(notifier, 1978 struct orinoco_private, 1979 pm_notifier); 1980 1981 /* All we need to do is cache the firmware before suspend, and 1982 * release it when we come out. 1983 * 1984 * Only need to do this if we're downloading firmware. */ 1985 if (!priv->do_fw_download) 1986 return NOTIFY_DONE; 1987 1988 switch (pm_event) { 1989 case PM_HIBERNATION_PREPARE: 1990 case PM_SUSPEND_PREPARE: 1991 orinoco_cache_fw(priv, 0); 1992 break; 1993 1994 case PM_POST_RESTORE: 1995 /* Restore from hibernation failed. We need to clean 1996 * up in exactly the same way, so fall through. */ 1997 case PM_POST_HIBERNATION: 1998 case PM_POST_SUSPEND: 1999 orinoco_uncache_fw(priv); 2000 break; 2001 2002 case PM_RESTORE_PREPARE: 2003 default: 2004 break; 2005 } 2006 2007 return NOTIFY_DONE; 2008} 2009 2010static void orinoco_register_pm_notifier(struct orinoco_private *priv) 2011{ 2012 priv->pm_notifier.notifier_call = orinoco_pm_notifier; 2013 register_pm_notifier(&priv->pm_notifier); 2014} 2015 2016static void orinoco_unregister_pm_notifier(struct orinoco_private *priv) 2017{ 2018 unregister_pm_notifier(&priv->pm_notifier); 2019} 2020#else /* !PM_SLEEP || HERMES_CACHE_FW_ON_INIT */ 2021#define orinoco_register_pm_notifier(priv) do { } while(0) 2022#define orinoco_unregister_pm_notifier(priv) do { } while(0) 2023#endif 2024 2025/********************************************************************/ 2026/* Initialization */ 2027/********************************************************************/ 2028 2029int orinoco_init(struct orinoco_private *priv) 2030{ 2031 struct device *dev = priv->dev; 2032 struct wiphy *wiphy = priv_to_wiphy(priv); 2033 hermes_t *hw = &priv->hw; 2034 int err = 0; 2035 2036 /* No need to lock, the hw_unavailable flag is already set in 2037 * alloc_orinocodev() */ 2038 priv->nicbuf_size = IEEE80211_MAX_FRAME_LEN + ETH_HLEN; 2039 2040 /* Initialize the firmware */ 2041 err = hw->ops->init(hw); 2042 if (err != 0) { 2043 dev_err(dev, "Failed to initialize firmware (err = %d)\n", 2044 err); 2045 goto out; 2046 } 2047 2048 err = determine_fw_capabilities(priv, wiphy->fw_version, 2049 sizeof(wiphy->fw_version), 2050 &wiphy->hw_version); 2051 if (err != 0) { 2052 dev_err(dev, "Incompatible firmware, aborting\n"); 2053 goto out; 2054 } 2055 2056 if (priv->do_fw_download) { 2057#ifdef CONFIG_HERMES_CACHE_FW_ON_INIT 2058 orinoco_cache_fw(priv, 0); 2059#endif 2060 2061 err = orinoco_download(priv); 2062 if (err) 2063 priv->do_fw_download = 0; 2064 2065 /* Check firmware version again */ 2066 err = determine_fw_capabilities(priv, wiphy->fw_version, 2067 sizeof(wiphy->fw_version), 2068 &wiphy->hw_version); 2069 if (err != 0) { 2070 dev_err(dev, "Incompatible firmware, aborting\n"); 2071 goto out; 2072 } 2073 } 2074 2075 if (priv->has_port3) 2076 dev_info(dev, "Ad-hoc demo mode supported\n"); 2077 if (priv->has_ibss) 2078 dev_info(dev, "IEEE standard IBSS ad-hoc mode supported\n"); 2079 if (priv->has_wep) 2080 dev_info(dev, "WEP supported, %s-bit key\n", 2081 priv->has_big_wep ? "104" : "40"); 2082 if (priv->has_wpa) { 2083 dev_info(dev, "WPA-PSK supported\n"); 2084 if (orinoco_mic_init(priv)) { 2085 dev_err(dev, "Failed to setup MIC crypto algorithm. " 2086 "Disabling WPA support\n"); 2087 priv->has_wpa = 0; 2088 } 2089 } 2090 2091 err = orinoco_hw_read_card_settings(priv, wiphy->perm_addr); 2092 if (err) 2093 goto out; 2094 2095 err = orinoco_hw_allocate_fid(priv); 2096 if (err) { 2097 dev_err(dev, "Failed to allocate NIC buffer!\n"); 2098 goto out; 2099 } 2100 2101 /* Set up the default configuration */ 2102 priv->iw_mode = NL80211_IFTYPE_STATION; 2103 /* By default use IEEE/IBSS ad-hoc mode if we have it */ 2104 priv->prefer_port3 = priv->has_port3 && (!priv->has_ibss); 2105 set_port_type(priv); 2106 priv->channel = 0; /* use firmware default */ 2107 2108 priv->promiscuous = 0; 2109 priv->encode_alg = ORINOCO_ALG_NONE; 2110 priv->tx_key = 0; 2111 priv->wpa_enabled = 0; 2112 priv->tkip_cm_active = 0; 2113 priv->key_mgmt = 0; 2114 priv->wpa_ie_len = 0; 2115 priv->wpa_ie = NULL; 2116 2117 if (orinoco_wiphy_register(wiphy)) { 2118 err = -ENODEV; 2119 goto out; 2120 } 2121 2122 /* Make the hardware available, as long as it hasn't been 2123 * removed elsewhere (e.g. by PCMCIA hot unplug) */ 2124 orinoco_lock_irq(priv); 2125 priv->hw_unavailable--; 2126 orinoco_unlock_irq(priv); 2127 2128 dev_dbg(dev, "Ready\n"); 2129 2130 out: 2131 return err; 2132} 2133EXPORT_SYMBOL(orinoco_init); 2134 2135static const struct net_device_ops orinoco_netdev_ops = { 2136 .ndo_open = orinoco_open, 2137 .ndo_stop = orinoco_stop, 2138 .ndo_start_xmit = orinoco_xmit, 2139 .ndo_set_multicast_list = orinoco_set_multicast_list, 2140 .ndo_change_mtu = orinoco_change_mtu, 2141 .ndo_set_mac_address = eth_mac_addr, 2142 .ndo_validate_addr = eth_validate_addr, 2143 .ndo_tx_timeout = orinoco_tx_timeout, 2144 .ndo_get_stats = orinoco_get_stats, 2145}; 2146 2147/* Allocate private data. 2148 * 2149 * This driver has a number of structures associated with it 2150 * netdev - Net device structure for each network interface 2151 * wiphy - structure associated with wireless phy 2152 * wireless_dev (wdev) - structure for each wireless interface 2153 * hw - structure for hermes chip info 2154 * card - card specific structure for use by the card driver 2155 * (airport, orinoco_cs) 2156 * priv - orinoco private data 2157 * device - generic linux device structure 2158 * 2159 * +---------+ +---------+ 2160 * | wiphy | | netdev | 2161 * | +-------+ | +-------+ 2162 * | | priv | | | wdev | 2163 * | | +-----+ +-+-------+ 2164 * | | | hw | 2165 * | +-+-----+ 2166 * | | card | 2167 * +-+-------+ 2168 * 2169 * priv has a link to netdev and device 2170 * wdev has a link to wiphy 2171 */ 2172struct orinoco_private 2173*alloc_orinocodev(int sizeof_card, 2174 struct device *device, 2175 int (*hard_reset)(struct orinoco_private *), 2176 int (*stop_fw)(struct orinoco_private *, int)) 2177{ 2178 struct orinoco_private *priv; 2179 struct wiphy *wiphy; 2180 2181 /* allocate wiphy 2182 * NOTE: We only support a single virtual interface 2183 * but this may change when monitor mode is added 2184 */ 2185 wiphy = wiphy_new(&orinoco_cfg_ops, 2186 sizeof(struct orinoco_private) + sizeof_card); 2187 if (!wiphy) 2188 return NULL; 2189 2190 priv = wiphy_priv(wiphy); 2191 priv->dev = device; 2192 2193 if (sizeof_card) 2194 priv->card = (void *)((unsigned long)priv 2195 + sizeof(struct orinoco_private)); 2196 else 2197 priv->card = NULL; 2198 2199 orinoco_wiphy_init(wiphy); 2200 2201#ifdef WIRELESS_SPY 2202 priv->wireless_data.spy_data = &priv->spy_data; 2203#endif 2204 2205 /* Set up default callbacks */ 2206 priv->hard_reset = hard_reset; 2207 priv->stop_fw = stop_fw; 2208 2209 spin_lock_init(&priv->lock); 2210 priv->open = 0; 2211 priv->hw_unavailable = 1; /* orinoco_init() must clear this 2212 * before anything else touches the 2213 * hardware */ 2214 INIT_WORK(&priv->reset_work, orinoco_reset); 2215 INIT_WORK(&priv->join_work, orinoco_join_ap); 2216 INIT_WORK(&priv->wevent_work, orinoco_send_wevents); 2217 2218 INIT_LIST_HEAD(&priv->rx_list); 2219 tasklet_init(&priv->rx_tasklet, orinoco_rx_isr_tasklet, 2220 (unsigned long) priv); 2221 2222 spin_lock_init(&priv->scan_lock); 2223 INIT_LIST_HEAD(&priv->scan_list); 2224 INIT_WORK(&priv->process_scan, orinoco_process_scan_results); 2225 2226 priv->last_linkstatus = 0xffff; 2227 2228#if defined(CONFIG_HERMES_CACHE_FW_ON_INIT) || defined(CONFIG_PM_SLEEP) 2229 priv->cached_pri_fw = NULL; 2230 priv->cached_fw = NULL; 2231#endif 2232 2233 /* Register PM notifiers */ 2234 orinoco_register_pm_notifier(priv); 2235 2236 return priv; 2237} 2238EXPORT_SYMBOL(alloc_orinocodev); 2239 2240/* We can only support a single interface. We provide a separate 2241 * function to set it up to distinguish between hardware 2242 * initialisation and interface setup. 2243 * 2244 * The base_addr and irq parameters are passed on to netdev for use 2245 * with SIOCGIFMAP. 2246 */ 2247int orinoco_if_add(struct orinoco_private *priv, 2248 unsigned long base_addr, 2249 unsigned int irq, 2250 const struct net_device_ops *ops) 2251{ 2252 struct wiphy *wiphy = priv_to_wiphy(priv); 2253 struct wireless_dev *wdev; 2254 struct net_device *dev; 2255 int ret; 2256 2257 dev = alloc_etherdev(sizeof(struct wireless_dev)); 2258 2259 if (!dev) 2260 return -ENOMEM; 2261 2262 /* Initialise wireless_dev */ 2263 wdev = netdev_priv(dev); 2264 wdev->wiphy = wiphy; 2265 wdev->iftype = NL80211_IFTYPE_STATION; 2266 2267 /* Setup / override net_device fields */ 2268 dev->ieee80211_ptr = wdev; 2269 dev->watchdog_timeo = HZ; /* 1 second timeout */ 2270 dev->wireless_handlers = &orinoco_handler_def; 2271#ifdef WIRELESS_SPY 2272 dev->wireless_data = &priv->wireless_data; 2273#endif 2274 /* Default to standard ops if not set */ 2275 if (ops) 2276 dev->netdev_ops = ops; 2277 else 2278 dev->netdev_ops = &orinoco_netdev_ops; 2279 2280 /* we use the default eth_mac_addr for setting the MAC addr */ 2281 2282 /* Reserve space in skb for the SNAP header */ 2283 dev->needed_headroom = ENCAPS_OVERHEAD; 2284 2285 netif_carrier_off(dev); 2286 2287 memcpy(dev->dev_addr, wiphy->perm_addr, ETH_ALEN); 2288 memcpy(dev->perm_addr, wiphy->perm_addr, ETH_ALEN); 2289 2290 dev->base_addr = base_addr; 2291 dev->irq = irq; 2292 2293 SET_NETDEV_DEV(dev, priv->dev); 2294 ret = register_netdev(dev); 2295 if (ret) 2296 goto fail; 2297 2298 priv->ndev = dev; 2299 2300 /* Report what we've done */ 2301 dev_dbg(priv->dev, "Registerred interface %s.\n", dev->name); 2302 2303 return 0; 2304 2305 fail: 2306 free_netdev(dev); 2307 return ret; 2308} 2309EXPORT_SYMBOL(orinoco_if_add); 2310 2311void orinoco_if_del(struct orinoco_private *priv) 2312{ 2313 struct net_device *dev = priv->ndev; 2314 2315 unregister_netdev(dev); 2316 free_netdev(dev); 2317} 2318EXPORT_SYMBOL(orinoco_if_del); 2319 2320void free_orinocodev(struct orinoco_private *priv) 2321{ 2322 struct wiphy *wiphy = priv_to_wiphy(priv); 2323 struct orinoco_rx_data *rx_data, *temp; 2324 struct orinoco_scan_data *sd, *sdtemp; 2325 2326 wiphy_unregister(wiphy); 2327 2328 /* If the tasklet is scheduled when we call tasklet_kill it 2329 * will run one final time. However the tasklet will only 2330 * drain priv->rx_list if the hw is still available. */ 2331 tasklet_kill(&priv->rx_tasklet); 2332 2333 /* Explicitly drain priv->rx_list */ 2334 list_for_each_entry_safe(rx_data, temp, &priv->rx_list, list) { 2335 list_del(&rx_data->list); 2336 2337 dev_kfree_skb(rx_data->skb); 2338 kfree(rx_data->desc); 2339 kfree(rx_data); 2340 } 2341 2342 cancel_work_sync(&priv->process_scan); 2343 /* Explicitly drain priv->scan_list */ 2344 list_for_each_entry_safe(sd, sdtemp, &priv->scan_list, list) { 2345 list_del(&sd->list); 2346 2347 if ((sd->len > 0) && sd->buf) 2348 kfree(sd->buf); 2349 kfree(sd); 2350 } 2351 2352 orinoco_unregister_pm_notifier(priv); 2353 orinoco_uncache_fw(priv); 2354 2355 priv->wpa_ie_len = 0; 2356 kfree(priv->wpa_ie); 2357 orinoco_mic_free(priv); 2358 wiphy_free(wiphy); 2359} 2360EXPORT_SYMBOL(free_orinocodev); 2361 2362int orinoco_up(struct orinoco_private *priv) 2363{ 2364 struct net_device *dev = priv->ndev; 2365 unsigned long flags; 2366 int err; 2367 2368 priv->hw.ops->lock_irqsave(&priv->lock, &flags); 2369 2370 err = orinoco_reinit_firmware(priv); 2371 if (err) { 2372 printk(KERN_ERR "%s: Error %d re-initializing firmware\n", 2373 dev->name, err); 2374 goto exit; 2375 } 2376 2377 netif_device_attach(dev); 2378 priv->hw_unavailable--; 2379 2380 if (priv->open && !priv->hw_unavailable) { 2381 err = __orinoco_up(priv); 2382 if (err) 2383 printk(KERN_ERR "%s: Error %d restarting card\n", 2384 dev->name, err); 2385 } 2386 2387exit: 2388 priv->hw.ops->unlock_irqrestore(&priv->lock, &flags); 2389 2390 return 0; 2391} 2392EXPORT_SYMBOL(orinoco_up); 2393 2394void orinoco_down(struct orinoco_private *priv) 2395{ 2396 struct net_device *dev = priv->ndev; 2397 unsigned long flags; 2398 int err; 2399 2400 priv->hw.ops->lock_irqsave(&priv->lock, &flags); 2401 err = __orinoco_down(priv); 2402 if (err) 2403 printk(KERN_WARNING "%s: Error %d downing interface\n", 2404 dev->name, err); 2405 2406 netif_device_detach(dev); 2407 priv->hw_unavailable++; 2408 priv->hw.ops->unlock_irqrestore(&priv->lock, &flags); 2409} 2410EXPORT_SYMBOL(orinoco_down); 2411 2412/********************************************************************/ 2413/* Module initialization */ 2414/********************************************************************/ 2415 2416/* Can't be declared "const" or the whole __initdata section will 2417 * become const */ 2418static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION 2419 " (David Gibson <hermes@gibson.dropbear.id.au>, " 2420 "Pavel Roskin <proski@gnu.org>, et al)"; 2421 2422static int __init init_orinoco(void) 2423{ 2424 printk(KERN_DEBUG "%s\n", version); 2425 return 0; 2426} 2427 2428static void __exit exit_orinoco(void) 2429{ 2430} 2431 2432module_init(init_orinoco); 2433module_exit(exit_orinoco); 2434