Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
main.c
Go to the documentation of this file.
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 
110 MODULE_AUTHOR("Pavel Roskin <[email protected]> & "
111  "David Gibson <[email protected]>");
112 MODULE_DESCRIPTION("Driver for Lucent Orinoco, Prism II based "
113  "and similar wireless cards");
114 MODULE_LICENSE("Dual MPL/GPL");
115 
116 /* Level of debugging. Used in the macros in orinoco.h */
117 #ifdef ORINOCO_DEBUG
118 int orinoco_debug = ORINOCO_DEBUG;
119 EXPORT_SYMBOL(orinoco_debug);
120 module_param(orinoco_debug, int, 0644);
121 MODULE_PARM_DESC(orinoco_debug, "Debug level");
122 #endif
123 
124 static bool suppress_linkstatus; /* = 0 */
125 module_param(suppress_linkstatus, bool, 0644);
126 MODULE_PARM_DESC(suppress_linkstatus, "Don't log link status changes");
127 
128 static int ignore_disconnect; /* = 0 */
129 module_param(ignore_disconnect, int, 0644);
130 MODULE_PARM_DESC(ignore_disconnect,
131  "Don't report lost link to the network layer");
132 
133 int force_monitor; /* = 0 */
134 module_param(force_monitor, int, 0644);
135 MODULE_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 */
142 static 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
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 /********************************************************************/
169 /* Beginning of the Tx descriptor, used in TxExc handling */
174  u8 addr1[ETH_ALEN];
176 
177 /* Rx frame header except compatibility 802.3 header */
179  /* Control */
184  u8 rate;
185  u8 rxflow;
188  /* 802.11 header */
193  u8 addr3[ETH_ALEN];
194  __le16 seq_ctl;
196 
197  /* Data length */
202  struct hermes_rx_descriptor *desc;
203  struct sk_buff *skb;
204  struct list_head list;
205 };
208  void *buf;
209  size_t len;
210  int type;
211  struct list_head list;
212 };
213 
214 /********************************************************************/
215 /* Function prototypes */
216 /********************************************************************/
217 
218 static int __orinoco_set_multicast_list(struct net_device *dev);
219 static int __orinoco_up(struct orinoco_private *priv);
220 static int __orinoco_down(struct orinoco_private *priv);
221 static int __orinoco_commit(struct orinoco_private *priv);
222 
223 /********************************************************************/
224 /* Internal helper functions */
225 /********************************************************************/
226 
227 void set_port_type(struct orinoco_private *priv)
228 {
229  switch (priv->iw_mode) {
231  priv->port_type = 1;
232  priv->createibss = 0;
233  break;
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;
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 
257 int 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 }
276 
277 int 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 }
296 
298 {
299  struct orinoco_private *priv = ndev_priv(dev);
300 
301  return &priv->stats;
302 }
304 
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 }
320 
321 int 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 }
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  */
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) |
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())
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 }
435 
436 static 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  struct hermes *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 
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  */
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,
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 
582 static void __orinoco_ev_alloc(struct net_device *dev, struct hermes *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 
597 static void __orinoco_ev_tx(struct net_device *dev, struct hermes *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 
607 }
608 
609 static void __orinoco_ev_txexc(struct net_device *dev, struct hermes *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 
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);
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 
665 void 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),
675 
676  stats->tx_errors++;
677 
678  schedule_work(&priv->reset_work);
679 }
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? */
688 static 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 
701 static 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 
713 static 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  */
745 static 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  struct hermes *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) {
764  if ((fc & IEEE80211_FCTL_TODS)
765  && (fc & IEEE80211_FCTL_FROMDS))
766  hdrlen = 30;
767  else
768  hdrlen = 24;
769  datalen = len;
770  break;
772  hdrlen = 24;
773  datalen = len;
774  break;
775  case IEEE80211_FTYPE_CTL:
776  switch (fc & IEEE80211_FCTL_STYPE) {
778  case IEEE80211_STYPE_RTS:
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,
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;
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 
843 void __orinoco_ev_rx(struct net_device *dev, struct hermes *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) {
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,
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  goto drop;
946 
947  rx_data->desc = desc;
948  rx_data->skb = skb;
949  list_add_tail(&rx_data->list, &priv->rx_list);
950  tasklet_schedule(&priv->rx_tasklet);
951 
952  return;
953 
954 drop:
955  dev_kfree_skb_irq(skb);
957  stats->rx_errors++;
958  stats->rx_dropped++;
959 out:
960  kfree(desc);
961 }
963 
964 static void orinoco_rx(struct net_device *dev,
965  struct hermes_rx_descriptor *desc,
966  struct sk_buff *skb)
967 {
968  struct orinoco_private *priv = ndev_priv(dev);
969  struct net_device_stats *stats = &priv->stats;
970  u16 status, fc;
971  int length;
972  struct ethhdr *hdr;
973 
974  status = le16_to_cpu(desc->status);
975  length = le16_to_cpu(desc->data_len);
976  fc = le16_to_cpu(desc->frame_ctl);
977 
978  /* Calculate and check MIC */
979  if (status & HERMES_RXSTAT_MIC) {
980  struct orinoco_tkip_key *key;
981  int key_id = ((status & HERMES_RXSTAT_MIC_KEY_ID) >>
984  u8 *rxmic;
985  u8 *src = (fc & IEEE80211_FCTL_FROMDS) ?
986  desc->addr3 : desc->addr2;
987 
988  /* Extract Michael MIC from payload */
989  rxmic = skb->data + skb->len - MICHAEL_MIC_LEN;
990 
991  skb_trim(skb, skb->len - MICHAEL_MIC_LEN);
992  length -= MICHAEL_MIC_LEN;
993 
994  key = (struct orinoco_tkip_key *) priv->keys[key_id].key;
995 
996  if (!key) {
997  printk(KERN_WARNING "%s: Received encrypted frame from "
998  "%pM using key %i, but key is not installed\n",
999  dev->name, src, key_id);
1000  goto drop;
1001  }
1002 
1003  orinoco_mic(priv->rx_tfm_mic, key->rx_mic, desc->addr1, src,
1004  0, /* priority or QoS? */
1005  skb->data, skb->len, &mic[0]);
1006 
1007  if (memcmp(mic, rxmic,
1008  MICHAEL_MIC_LEN)) {
1009  union iwreq_data wrqu;
1010  struct iw_michaelmicfailure wxmic;
1011 
1012  printk(KERN_WARNING "%s: "
1013  "Invalid Michael MIC in data frame from %pM, "
1014  "using key %i\n",
1015  dev->name, src, key_id);
1016 
1017  /* TODO: update stats */
1018 
1019  /* Notify userspace */
1020  memset(&wxmic, 0, sizeof(wxmic));
1021  wxmic.flags = key_id & IW_MICFAILURE_KEY_ID;
1022  wxmic.flags |= (desc->addr1[0] & 1) ?
1024  wxmic.src_addr.sa_family = ARPHRD_ETHER;
1025  memcpy(wxmic.src_addr.sa_data, src, ETH_ALEN);
1026 
1027  (void) orinoco_hw_get_tkip_iv(priv, key_id,
1028  &wxmic.tsc[0]);
1029 
1030  memset(&wrqu, 0, sizeof(wrqu));
1031  wrqu.data.length = sizeof(wxmic);
1033  (char *) &wxmic);
1034 
1035  goto drop;
1036  }
1037  }
1038 
1039  /* Handle decapsulation
1040  * In most cases, the firmware tell us about SNAP frames.
1041  * For some reason, the SNAP frames sent by LinkSys APs
1042  * are not properly recognised by most firmwares.
1043  * So, check ourselves */
1044  if (length >= ENCAPS_OVERHEAD &&
1045  (((status & HERMES_RXSTAT_MSGTYPE) == HERMES_RXSTAT_1042) ||
1046  ((status & HERMES_RXSTAT_MSGTYPE) == HERMES_RXSTAT_TUNNEL) ||
1047  is_ethersnap(skb->data))) {
1048  /* These indicate a SNAP within 802.2 LLC within
1049  802.11 frame which we'll need to de-encapsulate to
1050  the original EthernetII frame. */
1051  hdr = (struct ethhdr *)skb_push(skb,
1053  } else {
1054  /* 802.3 frame - prepend 802.3 header as is */
1055  hdr = (struct ethhdr *)skb_push(skb, ETH_HLEN);
1056  hdr->h_proto = htons(length);
1057  }
1058  memcpy(hdr->h_dest, desc->addr1, ETH_ALEN);
1059  if (fc & IEEE80211_FCTL_FROMDS)
1060  memcpy(hdr->h_source, desc->addr3, ETH_ALEN);
1061  else
1062  memcpy(hdr->h_source, desc->addr2, ETH_ALEN);
1063 
1064  skb->protocol = eth_type_trans(skb, dev);
1065  skb->ip_summed = CHECKSUM_NONE;
1066  if (fc & IEEE80211_FCTL_TODS)
1067  skb->pkt_type = PACKET_OTHERHOST;
1068 
1069  /* Process the wireless stats if needed */
1070  orinoco_stat_gather(dev, skb, desc);
1071 
1072  /* Pass the packet to the networking stack */
1073  netif_rx(skb);
1074  stats->rx_packets++;
1075  stats->rx_bytes += length;
1076 
1077  return;
1078 
1079  drop:
1080  dev_kfree_skb(skb);
1081  stats->rx_errors++;
1082  stats->rx_dropped++;
1083 }
1084 
1085 static void orinoco_rx_isr_tasklet(unsigned long data)
1086 {
1087  struct orinoco_private *priv = (struct orinoco_private *) data;
1088  struct net_device *dev = priv->ndev;
1089  struct orinoco_rx_data *rx_data, *temp;
1090  struct hermes_rx_descriptor *desc;
1091  struct sk_buff *skb;
1092  unsigned long flags;
1093 
1094  /* orinoco_rx requires the driver lock, and we also need to
1095  * protect priv->rx_list, so just hold the lock over the
1096  * lot.
1097  *
1098  * If orinoco_lock fails, we've unplugged the card. In this
1099  * case just abort. */
1100  if (orinoco_lock(priv, &flags) != 0)
1101  return;
1102 
1103  /* extract desc and skb from queue */
1104  list_for_each_entry_safe(rx_data, temp, &priv->rx_list, list) {
1105  desc = rx_data->desc;
1106  skb = rx_data->skb;
1107  list_del(&rx_data->list);
1108  kfree(rx_data);
1109 
1110  orinoco_rx(dev, desc, skb);
1111 
1112  kfree(desc);
1113  }
1114 
1115  orinoco_unlock(priv, &flags);
1116 }
1117 
1118 /********************************************************************/
1119 /* Rx path (info frames) */
1120 /********************************************************************/
1121 
1122 static void print_linkstatus(struct net_device *dev, u16 status)
1123 {
1124  char *s;
1125 
1126  if (suppress_linkstatus)
1127  return;
1128 
1129  switch (status) {
1131  s = "Not Connected";
1132  break;
1134  s = "Connected";
1135  break;
1137  s = "Disconnected";
1138  break;
1140  s = "AP Changed";
1141  break;
1143  s = "AP Out of Range";
1144  break;
1146  s = "AP In Range";
1147  break;
1149  s = "Association Failed";
1150  break;
1151  default:
1152  s = "UNKNOWN";
1153  }
1154 
1155  printk(KERN_DEBUG "%s: New link status: %s (%04x)\n",
1156  dev->name, s, status);
1157 }
1158 
1159 /* Search scan results for requested BSSID, join it if found */
1160 static void orinoco_join_ap(struct work_struct *work)
1161 {
1162  struct orinoco_private *priv =
1163  container_of(work, struct orinoco_private, join_work);
1164  struct net_device *dev = priv->ndev;
1165  struct hermes *hw = &priv->hw;
1166  int err;
1167  unsigned long flags;
1168  struct join_req {
1169  u8 bssid[ETH_ALEN];
1170  __le16 channel;
1171  } __packed req;
1172  const int atom_len = offsetof(struct prism2_scan_apinfo, atim);
1173  struct prism2_scan_apinfo *atom = NULL;
1174  int offset = 4;
1175  int found = 0;
1176  u8 *buf;
1177  u16 len;
1178 
1179  /* Allocate buffer for scan results */
1181  if (!buf)
1182  return;
1183 
1184  if (orinoco_lock(priv, &flags) != 0)
1185  goto fail_lock;
1186 
1187  /* Sanity checks in case user changed something in the meantime */
1188  if (!priv->bssid_fixed)
1189  goto out;
1190 
1191  if (strlen(priv->desired_essid) == 0)
1192  goto out;
1193 
1194  /* Read scan results from the firmware */
1195  err = hw->ops->read_ltv(hw, USER_BAP,
1197  MAX_SCAN_LEN, &len, buf);
1198  if (err) {
1199  printk(KERN_ERR "%s: Cannot read scan results\n",
1200  dev->name);
1201  goto out;
1202  }
1203 
1204  len = HERMES_RECLEN_TO_BYTES(len);
1205 
1206  /* Go through the scan results looking for the channel of the AP
1207  * we were requested to join */
1208  for (; offset + atom_len <= len; offset += atom_len) {
1209  atom = (struct prism2_scan_apinfo *) (buf + offset);
1210  if (memcmp(&atom->bssid, priv->desired_bssid, ETH_ALEN) == 0) {
1211  found = 1;
1212  break;
1213  }
1214  }
1215 
1216  if (!found) {
1217  DEBUG(1, "%s: Requested AP not found in scan results\n",
1218  dev->name);
1219  goto out;
1220  }
1221 
1222  memcpy(req.bssid, priv->desired_bssid, ETH_ALEN);
1223  req.channel = atom->channel; /* both are little-endian */
1225  &req);
1226  if (err)
1227  printk(KERN_ERR "%s: Error issuing join request\n", dev->name);
1228 
1229  out:
1230  orinoco_unlock(priv, &flags);
1231 
1232  fail_lock:
1233  kfree(buf);
1234 }
1235 
1236 /* Send new BSSID to userspace */
1237 static void orinoco_send_bssid_wevent(struct orinoco_private *priv)
1238 {
1239  struct net_device *dev = priv->ndev;
1240  struct hermes *hw = &priv->hw;
1241  union iwreq_data wrqu;
1242  int err;
1243 
1244  err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CURRENTBSSID,
1245  ETH_ALEN, NULL, wrqu.ap_addr.sa_data);
1246  if (err != 0)
1247  return;
1248 
1249  wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1250 
1251  /* Send event to user space */
1252  wireless_send_event(dev, SIOCGIWAP, &wrqu, NULL);
1253 }
1254 
1255 static void orinoco_send_assocreqie_wevent(struct orinoco_private *priv)
1256 {
1257  struct net_device *dev = priv->ndev;
1258  struct hermes *hw = &priv->hw;
1259  union iwreq_data wrqu;
1260  int err;
1261  u8 buf[88];
1262  u8 *ie;
1263 
1264  if (!priv->has_wpa)
1265  return;
1266 
1267  err = hw->ops->read_ltv(hw, USER_BAP, HERMES_RID_CURRENT_ASSOC_REQ_INFO,
1268  sizeof(buf), NULL, &buf);
1269  if (err != 0)
1270  return;
1271 
1272  ie = orinoco_get_wpa_ie(buf, sizeof(buf));
1273  if (ie) {
1274  int rem = sizeof(buf) - (ie - &buf[0]);
1275  wrqu.data.length = ie[1] + 2;
1276  if (wrqu.data.length > rem)
1277  wrqu.data.length = rem;
1278 
1279  if (wrqu.data.length)
1280  /* Send event to user space */
1281  wireless_send_event(dev, IWEVASSOCREQIE, &wrqu, ie);
1282  }
1283 }
1284 
1285 static void orinoco_send_assocrespie_wevent(struct orinoco_private *priv)
1286 {
1287  struct net_device *dev = priv->ndev;
1288  struct hermes *hw = &priv->hw;
1289  union iwreq_data wrqu;
1290  int err;
1291  u8 buf[88]; /* TODO: verify max size or IW_GENERIC_IE_MAX */
1292  u8 *ie;
1293 
1294  if (!priv->has_wpa)
1295  return;
1296 
1297  err = hw->ops->read_ltv(hw, USER_BAP,
1299  sizeof(buf), NULL, &buf);
1300  if (err != 0)
1301  return;
1302 
1303  ie = orinoco_get_wpa_ie(buf, sizeof(buf));
1304  if (ie) {
1305  int rem = sizeof(buf) - (ie - &buf[0]);
1306  wrqu.data.length = ie[1] + 2;
1307  if (wrqu.data.length > rem)
1308  wrqu.data.length = rem;
1309 
1310  if (wrqu.data.length)
1311  /* Send event to user space */
1312  wireless_send_event(dev, IWEVASSOCRESPIE, &wrqu, ie);
1313  }
1314 }
1315 
1316 static void orinoco_send_wevents(struct work_struct *work)
1317 {
1318  struct orinoco_private *priv =
1319  container_of(work, struct orinoco_private, wevent_work);
1320  unsigned long flags;
1321 
1322  if (orinoco_lock(priv, &flags) != 0)
1323  return;
1324 
1325  orinoco_send_assocreqie_wevent(priv);
1326  orinoco_send_assocrespie_wevent(priv);
1327  orinoco_send_bssid_wevent(priv);
1328 
1329  orinoco_unlock(priv, &flags);
1330 }
1331 
1332 static void qbuf_scan(struct orinoco_private *priv, void *buf,
1333  int len, int type)
1334 {
1335  struct orinoco_scan_data *sd;
1336  unsigned long flags;
1337 
1338  sd = kmalloc(sizeof(*sd), GFP_ATOMIC);
1339  if (!sd) {
1340  printk(KERN_ERR "%s: failed to alloc memory\n", __func__);
1341  return;
1342  }
1343  sd->buf = buf;
1344  sd->len = len;
1345  sd->type = type;
1346 
1347  spin_lock_irqsave(&priv->scan_lock, flags);
1348  list_add_tail(&sd->list, &priv->scan_list);
1349  spin_unlock_irqrestore(&priv->scan_lock, flags);
1350 
1351  schedule_work(&priv->process_scan);
1352 }
1353 
1354 static void qabort_scan(struct orinoco_private *priv)
1355 {
1356  struct orinoco_scan_data *sd;
1357  unsigned long flags;
1358 
1359  sd = kmalloc(sizeof(*sd), GFP_ATOMIC);
1360  if (!sd) {
1361  printk(KERN_ERR "%s: failed to alloc memory\n", __func__);
1362  return;
1363  }
1364  sd->len = -1; /* Abort */
1365 
1366  spin_lock_irqsave(&priv->scan_lock, flags);
1367  list_add_tail(&sd->list, &priv->scan_list);
1368  spin_unlock_irqrestore(&priv->scan_lock, flags);
1369 
1370  schedule_work(&priv->process_scan);
1371 }
1372 
1373 static void orinoco_process_scan_results(struct work_struct *work)
1374 {
1375  struct orinoco_private *priv =
1376  container_of(work, struct orinoco_private, process_scan);
1377  struct orinoco_scan_data *sd, *temp;
1378  unsigned long flags;
1379  void *buf;
1380  int len;
1381  int type;
1382 
1383  spin_lock_irqsave(&priv->scan_lock, flags);
1384  list_for_each_entry_safe(sd, temp, &priv->scan_list, list) {
1385 
1386  buf = sd->buf;
1387  len = sd->len;
1388  type = sd->type;
1389 
1390  list_del(&sd->list);
1391  spin_unlock_irqrestore(&priv->scan_lock, flags);
1392  kfree(sd);
1393 
1394  if (len > 0) {
1395  if (type == HERMES_INQ_CHANNELINFO)
1396  orinoco_add_extscan_result(priv, buf, len);
1397  else
1398  orinoco_add_hostscan_results(priv, buf, len);
1399 
1400  kfree(buf);
1401  } else {
1402  /* Either abort or complete the scan */
1403  orinoco_scan_done(priv, (len < 0));
1404  }
1405 
1406  spin_lock_irqsave(&priv->scan_lock, flags);
1407  }
1408  spin_unlock_irqrestore(&priv->scan_lock, flags);
1409 }
1410 
1411 void __orinoco_ev_info(struct net_device *dev, struct hermes *hw)
1412 {
1413  struct orinoco_private *priv = ndev_priv(dev);
1414  u16 infofid;
1415  struct {
1416  __le16 len;
1417  __le16 type;
1418  } __packed info;
1419  int len, type;
1420  int err;
1421 
1422  /* This is an answer to an INQUIRE command that we did earlier,
1423  * or an information "event" generated by the card
1424  * The controller return to us a pseudo frame containing
1425  * the information in question - Jean II */
1426  infofid = hermes_read_regn(hw, INFOFID);
1427 
1428  /* Read the info frame header - don't try too hard */
1429  err = hw->ops->bap_pread(hw, IRQ_BAP, &info, sizeof(info),
1430  infofid, 0);
1431  if (err) {
1432  printk(KERN_ERR "%s: error %d reading info frame. "
1433  "Frame dropped.\n", dev->name, err);
1434  return;
1435  }
1436 
1437  len = HERMES_RECLEN_TO_BYTES(le16_to_cpu(info.len));
1438  type = le16_to_cpu(info.type);
1439 
1440  switch (type) {
1441  case HERMES_INQ_TALLIES: {
1442  struct hermes_tallies_frame tallies;
1443  struct iw_statistics *wstats = &priv->wstats;
1444 
1445  if (len > sizeof(tallies)) {
1446  printk(KERN_WARNING "%s: Tallies frame too long (%d bytes)\n",
1447  dev->name, len);
1448  len = sizeof(tallies);
1449  }
1450 
1451  err = hw->ops->bap_pread(hw, IRQ_BAP, &tallies, len,
1452  infofid, sizeof(info));
1453  if (err)
1454  break;
1455 
1456  /* Increment our various counters */
1457  /* wstats->discard.nwid - no wrong BSSID stuff */
1458  wstats->discard.code +=
1459  le16_to_cpu(tallies.RxWEPUndecryptable);
1460  if (len == sizeof(tallies))
1461  wstats->discard.code +=
1462  le16_to_cpu(tallies.RxDiscards_WEPICVError) +
1463  le16_to_cpu(tallies.RxDiscards_WEPExcluded);
1464  wstats->discard.misc +=
1465  le16_to_cpu(tallies.TxDiscardsWrongSA);
1466  wstats->discard.fragment +=
1467  le16_to_cpu(tallies.RxMsgInBadMsgFragments);
1468  wstats->discard.retries +=
1469  le16_to_cpu(tallies.TxRetryLimitExceeded);
1470  /* wstats->miss.beacon - no match */
1471  }
1472  break;
1473  case HERMES_INQ_LINKSTATUS: {
1475  u16 newstatus;
1476  int connected;
1477 
1478  if (priv->iw_mode == NL80211_IFTYPE_MONITOR)
1479  break;
1480 
1481  if (len != sizeof(linkstatus)) {
1482  printk(KERN_WARNING "%s: Unexpected size for linkstatus frame (%d bytes)\n",
1483  dev->name, len);
1484  break;
1485  }
1486 
1487  err = hw->ops->bap_pread(hw, IRQ_BAP, &linkstatus, len,
1488  infofid, sizeof(info));
1489  if (err)
1490  break;
1491  newstatus = le16_to_cpu(linkstatus.linkstatus);
1492 
1493  /* Symbol firmware uses "out of range" to signal that
1494  * the hostscan frame can be requested. */
1495  if (newstatus == HERMES_LINKSTATUS_AP_OUT_OF_RANGE &&
1497  priv->has_hostscan && priv->scan_request) {
1498  hermes_inquire(hw, HERMES_INQ_HOSTSCAN_SYMBOL);
1499  break;
1500  }
1501 
1502  connected = (newstatus == HERMES_LINKSTATUS_CONNECTED)
1503  || (newstatus == HERMES_LINKSTATUS_AP_CHANGE)
1504  || (newstatus == HERMES_LINKSTATUS_AP_IN_RANGE);
1505 
1506  if (connected)
1507  netif_carrier_on(dev);
1508  else if (!ignore_disconnect)
1509  netif_carrier_off(dev);
1510 
1511  if (newstatus != priv->last_linkstatus) {
1512  priv->last_linkstatus = newstatus;
1513  print_linkstatus(dev, newstatus);
1514  /* The info frame contains only one word which is the
1515  * status (see hermes.h). The status is pretty boring
1516  * in itself, that's why we export the new BSSID...
1517  * Jean II */
1518  schedule_work(&priv->wevent_work);
1519  }
1520  }
1521  break;
1522  case HERMES_INQ_SCAN:
1523  if (!priv->scan_request && priv->bssid_fixed &&
1525  schedule_work(&priv->join_work);
1526  break;
1527  }
1528  /* fall through */
1529  case HERMES_INQ_HOSTSCAN:
1531  /* Result of a scanning. Contains information about
1532  * cells in the vicinity - Jean II */
1533  unsigned char *buf;
1534 
1535  /* Sanity check */
1536  if (len > 4096) {
1537  printk(KERN_WARNING "%s: Scan results too large (%d bytes)\n",
1538  dev->name, len);
1539  qabort_scan(priv);
1540  break;
1541  }
1542 
1543  /* Allocate buffer for results */
1544  buf = kmalloc(len, GFP_ATOMIC);
1545  if (buf == NULL) {
1546  /* No memory, so can't printk()... */
1547  qabort_scan(priv);
1548  break;
1549  }
1550 
1551  /* Read scan data */
1552  err = hw->ops->bap_pread(hw, IRQ_BAP, (void *) buf, len,
1553  infofid, sizeof(info));
1554  if (err) {
1555  kfree(buf);
1556  qabort_scan(priv);
1557  break;
1558  }
1559 
1560 #ifdef ORINOCO_DEBUG
1561  {
1562  int i;
1563  printk(KERN_DEBUG "Scan result [%02X", buf[0]);
1564  for (i = 1; i < (len * 2); i++)
1565  printk(":%02X", buf[i]);
1566  printk("]\n");
1567  }
1568 #endif /* ORINOCO_DEBUG */
1569 
1570  qbuf_scan(priv, buf, len, type);
1571  }
1572  break;
1574  {
1575  struct agere_ext_scan_info *bss;
1576 
1577  if (!priv->scan_request) {
1578  printk(KERN_DEBUG "%s: Got chaninfo without scan, "
1579  "len=%d\n", dev->name, len);
1580  break;
1581  }
1582 
1583  /* An empty result indicates that the scan is complete */
1584  if (len == 0) {
1585  qbuf_scan(priv, NULL, len, type);
1586  break;
1587  }
1588 
1589  /* Sanity check */
1590  else if (len < (offsetof(struct agere_ext_scan_info,
1591  data) + 2)) {
1592  /* Drop this result now so we don't have to
1593  * keep checking later */
1595  "%s: Ext scan results too short (%d bytes)\n",
1596  dev->name, len);
1597  break;
1598  }
1599 
1600  bss = kmalloc(len, GFP_ATOMIC);
1601  if (bss == NULL)
1602  break;
1603 
1604  /* Read scan data */
1605  err = hw->ops->bap_pread(hw, IRQ_BAP, (void *) bss, len,
1606  infofid, sizeof(info));
1607  if (err)
1608  kfree(bss);
1609  else
1610  qbuf_scan(priv, bss, len, type);
1611 
1612  break;
1613  }
1615  /* Security status (Agere specific) */
1616  /* Ignore this frame for now */
1617  if (priv->firmware_type == FIRMWARE_TYPE_AGERE)
1618  break;
1619  /* fall through */
1620  default:
1621  printk(KERN_DEBUG "%s: Unknown information frame received: "
1622  "type 0x%04x, length %d\n", dev->name, type, len);
1623  /* We don't actually do anything about it */
1624  break;
1625  }
1626 }
1628 
1629 static void __orinoco_ev_infdrop(struct net_device *dev, struct hermes *hw)
1630 {
1631  if (net_ratelimit())
1632  printk(KERN_DEBUG "%s: Information frame lost.\n", dev->name);
1633 }
1634 
1635 /********************************************************************/
1636 /* Internal hardware control routines */
1637 /********************************************************************/
1638 
1639 static int __orinoco_up(struct orinoco_private *priv)
1640 {
1641  struct net_device *dev = priv->ndev;
1642  struct hermes *hw = &priv->hw;
1643  int err;
1644 
1645  netif_carrier_off(dev); /* just to make sure */
1646 
1647  err = __orinoco_commit(priv);
1648  if (err) {
1649  printk(KERN_ERR "%s: Error %d configuring card\n",
1650  dev->name, err);
1651  return err;
1652  }
1653 
1654  /* Fire things up again */
1655  hermes_set_irqmask(hw, ORINOCO_INTEN);
1656  err = hermes_enable_port(hw, 0);
1657  if (err) {
1658  printk(KERN_ERR "%s: Error %d enabling MAC port\n",
1659  dev->name, err);
1660  return err;
1661  }
1662 
1663  netif_start_queue(dev);
1664 
1665  return 0;
1666 }
1667 
1668 static int __orinoco_down(struct orinoco_private *priv)
1669 {
1670  struct net_device *dev = priv->ndev;
1671  struct hermes *hw = &priv->hw;
1672  int err;
1673 
1674  netif_stop_queue(dev);
1675 
1676  if (!priv->hw_unavailable) {
1677  if (!priv->broken_disableport) {
1678  err = hermes_disable_port(hw, 0);
1679  if (err) {
1680  /* Some firmwares (e.g. Intersil 1.3.x) seem
1681  * to have problems disabling the port, oh
1682  * well, too bad. */
1683  printk(KERN_WARNING "%s: Error %d disabling MAC port\n",
1684  dev->name, err);
1685  priv->broken_disableport = 1;
1686  }
1687  }
1688  hermes_set_irqmask(hw, 0);
1689  hermes_write_regn(hw, EVACK, 0xffff);
1690  }
1691 
1692  orinoco_scan_done(priv, true);
1693 
1694  /* firmware will have to reassociate */
1695  netif_carrier_off(dev);
1696  priv->last_linkstatus = 0xffff;
1697 
1698  return 0;
1699 }
1700 
1701 static int orinoco_reinit_firmware(struct orinoco_private *priv)
1702 {
1703  struct hermes *hw = &priv->hw;
1704  int err;
1705 
1706  err = hw->ops->init(hw);
1707  if (priv->do_fw_download && !err) {
1708  err = orinoco_download(priv);
1709  if (err)
1710  priv->do_fw_download = 0;
1711  }
1712  if (!err)
1713  err = orinoco_hw_allocate_fid(priv);
1714 
1715  return err;
1716 }
1717 
1718 static int
1719 __orinoco_set_multicast_list(struct net_device *dev)
1720 {
1721  struct orinoco_private *priv = ndev_priv(dev);
1722  int err = 0;
1723  int promisc, mc_count;
1724 
1725  /* The Hermes doesn't seem to have an allmulti mode, so we go
1726  * into promiscuous mode and let the upper levels deal. */
1727  if ((dev->flags & IFF_PROMISC) || (dev->flags & IFF_ALLMULTI) ||
1728  (netdev_mc_count(dev) > MAX_MULTICAST(priv))) {
1729  promisc = 1;
1730  mc_count = 0;
1731  } else {
1732  promisc = 0;
1733  mc_count = netdev_mc_count(dev);
1734  }
1735 
1736  err = __orinoco_hw_set_multicast_list(priv, dev, mc_count, promisc);
1737 
1738  return err;
1739 }
1741 /* This must be called from user context, without locks held - use
1742  * schedule_work() */
1743 void orinoco_reset(struct work_struct *work)
1744 {
1745  struct orinoco_private *priv =
1746  container_of(work, struct orinoco_private, reset_work);
1747  struct net_device *dev = priv->ndev;
1748  struct hermes *hw = &priv->hw;
1749  int err;
1750  unsigned long flags;
1751 
1752  if (orinoco_lock(priv, &flags) != 0)
1753  /* When the hardware becomes available again, whatever
1754  * detects that is responsible for re-initializing
1755  * it. So no need for anything further */
1756  return;
1757 
1758  netif_stop_queue(dev);
1759 
1760  /* Shut off interrupts. Depending on what state the hardware
1761  * is in, this might not work, but we'll try anyway */
1762  hermes_set_irqmask(hw, 0);
1763  hermes_write_regn(hw, EVACK, 0xffff);
1764 
1765  priv->hw_unavailable++;
1766  priv->last_linkstatus = 0xffff; /* firmware will have to reassociate */
1767  netif_carrier_off(dev);
1768 
1769  orinoco_unlock(priv, &flags);
1770 
1771  /* Scanning support: Notify scan cancellation */
1772  orinoco_scan_done(priv, true);
1773 
1774  if (priv->hard_reset) {
1775  err = (*priv->hard_reset)(priv);
1776  if (err) {
1777  printk(KERN_ERR "%s: orinoco_reset: Error %d "
1778  "performing hard reset\n", dev->name, err);
1779  goto disable;
1780  }
1781  }
1782 
1783  err = orinoco_reinit_firmware(priv);
1784  if (err) {
1785  printk(KERN_ERR "%s: orinoco_reset: Error %d re-initializing firmware\n",
1786  dev->name, err);
1787  goto disable;
1788  }
1789 
1790  /* This has to be called from user context */
1791  orinoco_lock_irq(priv);
1792 
1793  priv->hw_unavailable--;
1794 
1795  /* priv->open or priv->hw_unavailable might have changed while
1796  * we dropped the lock */
1797  if (priv->open && (!priv->hw_unavailable)) {
1798  err = __orinoco_up(priv);
1799  if (err) {
1800  printk(KERN_ERR "%s: orinoco_reset: Error %d reenabling card\n",
1801  dev->name, err);
1802  } else
1803  dev->trans_start = jiffies;
1804  }
1805 
1806  orinoco_unlock_irq(priv);
1807 
1808  return;
1809  disable:
1810  hermes_set_irqmask(hw, 0);
1811  netif_device_detach(dev);
1812  printk(KERN_ERR "%s: Device has been disabled!\n", dev->name);
1813 }
1814 
1815 static int __orinoco_commit(struct orinoco_private *priv)
1816 {
1817  struct net_device *dev = priv->ndev;
1818  int err = 0;
1819 
1820  /* If we've called commit, we are reconfiguring or bringing the
1821  * interface up. Maintaining countermeasures across this would
1822  * be confusing, so note that we've disabled them. The port will
1823  * be enabled later in orinoco_commit or __orinoco_up. */
1824  priv->tkip_cm_active = 0;
1825 
1826  err = orinoco_hw_program_rids(priv);
1827 
1828  /* FIXME: what about netif_tx_lock */
1829  (void) __orinoco_set_multicast_list(dev);
1830 
1831  return err;
1832 }
1833 
1834 /* Ensures configuration changes are applied. May result in a reset.
1835  * The caller should hold priv->lock
1836  */
1837 int orinoco_commit(struct orinoco_private *priv)
1838 {
1839  struct net_device *dev = priv->ndev;
1840  struct hermes *hw = &priv->hw;
1841  int err;
1842 
1843  if (priv->broken_disableport) {
1844  schedule_work(&priv->reset_work);
1845  return 0;
1846  }
1847 
1848  err = hermes_disable_port(hw, 0);
1849  if (err) {
1850  printk(KERN_WARNING "%s: Unable to disable port "
1851  "while reconfiguring card\n", dev->name);
1852  priv->broken_disableport = 1;
1853  goto out;
1854  }
1855 
1856  err = __orinoco_commit(priv);
1857  if (err) {
1858  printk(KERN_WARNING "%s: Unable to reconfigure card\n",
1859  dev->name);
1860  goto out;
1861  }
1862 
1863  err = hermes_enable_port(hw, 0);
1864  if (err) {
1865  printk(KERN_WARNING "%s: Unable to enable port while reconfiguring card\n",
1866  dev->name);
1867  goto out;
1868  }
1869 
1870  out:
1871  if (err) {
1872  printk(KERN_WARNING "%s: Resetting instead...\n", dev->name);
1873  schedule_work(&priv->reset_work);
1874  err = 0;
1875  }
1876  return err;
1877 }
1878 
1879 /********************************************************************/
1880 /* Interrupt handler */
1881 /********************************************************************/
1882 
1883 static void __orinoco_ev_tick(struct net_device *dev, struct hermes *hw)
1884 {
1885  printk(KERN_DEBUG "%s: TICK\n", dev->name);
1886 }
1887 
1888 static void __orinoco_ev_wterr(struct net_device *dev, struct hermes *hw)
1889 {
1890  /* This seems to happen a fair bit under load, but ignoring it
1891  seems to work fine...*/
1892  printk(KERN_DEBUG "%s: MAC controller error (WTERR). Ignoring.\n",
1893  dev->name);
1894 }
1895 
1896 irqreturn_t orinoco_interrupt(int irq, void *dev_id)
1897 {
1898  struct orinoco_private *priv = dev_id;
1899  struct net_device *dev = priv->ndev;
1900  struct hermes *hw = &priv->hw;
1902  u16 evstat, events;
1903  /* These are used to detect a runaway interrupt situation.
1904  *
1905  * If we get more than MAX_IRQLOOPS_PER_JIFFY iterations in a jiffy,
1906  * we panic and shut down the hardware
1907  */
1908  /* jiffies value the last time we were called */
1909  static int last_irq_jiffy; /* = 0 */
1910  static int loops_this_jiffy; /* = 0 */
1911  unsigned long flags;
1912 
1913  if (orinoco_lock(priv, &flags) != 0) {
1914  /* If hw is unavailable - we don't know if the irq was
1915  * for us or not */
1916  return IRQ_HANDLED;
1917  }
1918 
1919  evstat = hermes_read_regn(hw, EVSTAT);
1920  events = evstat & hw->inten;
1921  if (!events) {
1922  orinoco_unlock(priv, &flags);
1923  return IRQ_NONE;
1924  }
1925 
1926  if (jiffies != last_irq_jiffy)
1927  loops_this_jiffy = 0;
1928  last_irq_jiffy = jiffies;
1929 
1930  while (events && count--) {
1931  if (++loops_this_jiffy > MAX_IRQLOOPS_PER_JIFFY) {
1932  printk(KERN_WARNING "%s: IRQ handler is looping too "
1933  "much! Resetting.\n", dev->name);
1934  /* Disable interrupts for now */
1935  hermes_set_irqmask(hw, 0);
1936  schedule_work(&priv->reset_work);
1937  break;
1938  }
1939 
1940  /* Check the card hasn't been removed */
1941  if (!hermes_present(hw)) {
1942  DEBUG(0, "orinoco_interrupt(): card removed\n");
1943  break;
1944  }
1945 
1946  if (events & HERMES_EV_TICK)
1947  __orinoco_ev_tick(dev, hw);
1948  if (events & HERMES_EV_WTERR)
1949  __orinoco_ev_wterr(dev, hw);
1950  if (events & HERMES_EV_INFDROP)
1951  __orinoco_ev_infdrop(dev, hw);
1952  if (events & HERMES_EV_INFO)
1953  __orinoco_ev_info(dev, hw);
1954  if (events & HERMES_EV_RX)
1955  __orinoco_ev_rx(dev, hw);
1956  if (events & HERMES_EV_TXEXC)
1957  __orinoco_ev_txexc(dev, hw);
1958  if (events & HERMES_EV_TX)
1959  __orinoco_ev_tx(dev, hw);
1960  if (events & HERMES_EV_ALLOC)
1961  __orinoco_ev_alloc(dev, hw);
1962 
1963  hermes_write_regn(hw, EVACK, evstat);
1964 
1965  evstat = hermes_read_regn(hw, EVSTAT);
1966  events = evstat & hw->inten;
1967  }
1968 
1969  orinoco_unlock(priv, &flags);
1970  return IRQ_HANDLED;
1971 }
1973 
1974 /********************************************************************/
1975 /* Power management */
1976 /********************************************************************/
1977 #if defined(CONFIG_PM_SLEEP) && !defined(CONFIG_HERMES_CACHE_FW_ON_INIT)
1978 static int orinoco_pm_notifier(struct notifier_block *notifier,
1979  unsigned long pm_event,
1980  void *unused)
1981 {
1982  struct orinoco_private *priv = container_of(notifier,
1983  struct orinoco_private,
1984  pm_notifier);
1985 
1986  /* All we need to do is cache the firmware before suspend, and
1987  * release it when we come out.
1988  *
1989  * Only need to do this if we're downloading firmware. */
1990  if (!priv->do_fw_download)
1991  return NOTIFY_DONE;
1992 
1993  switch (pm_event) {
1995  case PM_SUSPEND_PREPARE:
1996  orinoco_cache_fw(priv, 0);
1997  break;
1998 
1999  case PM_POST_RESTORE:
2000  /* Restore from hibernation failed. We need to clean
2001  * up in exactly the same way, so fall through. */
2002  case PM_POST_HIBERNATION:
2003  case PM_POST_SUSPEND:
2004  orinoco_uncache_fw(priv);
2005  break;
2006 
2007  case PM_RESTORE_PREPARE:
2008  default:
2009  break;
2010  }
2011 
2012  return NOTIFY_DONE;
2013 }
2014 
2015 static void orinoco_register_pm_notifier(struct orinoco_private *priv)
2016 {
2017  priv->pm_notifier.notifier_call = orinoco_pm_notifier;
2018  register_pm_notifier(&priv->pm_notifier);
2019 }
2020 
2021 static void orinoco_unregister_pm_notifier(struct orinoco_private *priv)
2022 {
2023  unregister_pm_notifier(&priv->pm_notifier);
2025 #else /* !PM_SLEEP || HERMES_CACHE_FW_ON_INIT */
2026 #define orinoco_register_pm_notifier(priv) do { } while (0)
2027 #define orinoco_unregister_pm_notifier(priv) do { } while (0)
2028 #endif
2029 
2030 /********************************************************************/
2031 /* Initialization */
2032 /********************************************************************/
2033 
2034 int orinoco_init(struct orinoco_private *priv)
2035 {
2036  struct device *dev = priv->dev;
2037  struct wiphy *wiphy = priv_to_wiphy(priv);
2038  struct hermes *hw = &priv->hw;
2039  int err = 0;
2040 
2041  /* No need to lock, the hw_unavailable flag is already set in
2042  * alloc_orinocodev() */
2044 
2045  /* Initialize the firmware */
2046  err = hw->ops->init(hw);
2047  if (err != 0) {
2048  dev_err(dev, "Failed to initialize firmware (err = %d)\n",
2049  err);
2050  goto out;
2051  }
2052 
2053  err = determine_fw_capabilities(priv, wiphy->fw_version,
2054  sizeof(wiphy->fw_version),
2055  &wiphy->hw_version);
2056  if (err != 0) {
2057  dev_err(dev, "Incompatible firmware, aborting\n");
2058  goto out;
2059  }
2060 
2061  if (priv->do_fw_download) {
2062 #ifdef CONFIG_HERMES_CACHE_FW_ON_INIT
2063  orinoco_cache_fw(priv, 0);
2064 #endif
2065 
2066  err = orinoco_download(priv);
2067  if (err)
2068  priv->do_fw_download = 0;
2069 
2070  /* Check firmware version again */
2071  err = determine_fw_capabilities(priv, wiphy->fw_version,
2072  sizeof(wiphy->fw_version),
2073  &wiphy->hw_version);
2074  if (err != 0) {
2075  dev_err(dev, "Incompatible firmware, aborting\n");
2076  goto out;
2077  }
2078  }
2079 
2080  if (priv->has_port3)
2081  dev_info(dev, "Ad-hoc demo mode supported\n");
2082  if (priv->has_ibss)
2083  dev_info(dev, "IEEE standard IBSS ad-hoc mode supported\n");
2084  if (priv->has_wep)
2085  dev_info(dev, "WEP supported, %s-bit key\n",
2086  priv->has_big_wep ? "104" : "40");
2087  if (priv->has_wpa) {
2088  dev_info(dev, "WPA-PSK supported\n");
2089  if (orinoco_mic_init(priv)) {
2090  dev_err(dev, "Failed to setup MIC crypto algorithm. "
2091  "Disabling WPA support\n");
2092  priv->has_wpa = 0;
2093  }
2094  }
2095 
2096  err = orinoco_hw_read_card_settings(priv, wiphy->perm_addr);
2097  if (err)
2098  goto out;
2099 
2100  err = orinoco_hw_allocate_fid(priv);
2101  if (err) {
2102  dev_err(dev, "Failed to allocate NIC buffer!\n");
2103  goto out;
2104  }
2105 
2106  /* Set up the default configuration */
2108  /* By default use IEEE/IBSS ad-hoc mode if we have it */
2109  priv->prefer_port3 = priv->has_port3 && (!priv->has_ibss);
2110  set_port_type(priv);
2111  priv->channel = 0; /* use firmware default */
2112 
2113  priv->promiscuous = 0;
2114  priv->encode_alg = ORINOCO_ALG_NONE;
2115  priv->tx_key = 0;
2116  priv->wpa_enabled = 0;
2117  priv->tkip_cm_active = 0;
2118  priv->key_mgmt = 0;
2119  priv->wpa_ie_len = 0;
2120  priv->wpa_ie = NULL;
2121 
2122  if (orinoco_wiphy_register(wiphy)) {
2123  err = -ENODEV;
2124  goto out;
2125  }
2126 
2127  /* Make the hardware available, as long as it hasn't been
2128  * removed elsewhere (e.g. by PCMCIA hot unplug) */
2129  orinoco_lock_irq(priv);
2130  priv->hw_unavailable--;
2131  orinoco_unlock_irq(priv);
2132 
2133  dev_dbg(dev, "Ready\n");
2134 
2135  out:
2136  return err;
2137 }
2139 
2140 static const struct net_device_ops orinoco_netdev_ops = {
2141  .ndo_open = orinoco_open,
2142  .ndo_stop = orinoco_stop,
2143  .ndo_start_xmit = orinoco_xmit,
2144  .ndo_set_rx_mode = orinoco_set_multicast_list,
2145  .ndo_change_mtu = orinoco_change_mtu,
2146  .ndo_set_mac_address = eth_mac_addr,
2147  .ndo_validate_addr = eth_validate_addr,
2148  .ndo_tx_timeout = orinoco_tx_timeout,
2149  .ndo_get_stats = orinoco_get_stats,
2150 };
2151 
2152 /* Allocate private data.
2153  *
2154  * This driver has a number of structures associated with it
2155  * netdev - Net device structure for each network interface
2156  * wiphy - structure associated with wireless phy
2157  * wireless_dev (wdev) - structure for each wireless interface
2158  * hw - structure for hermes chip info
2159  * card - card specific structure for use by the card driver
2160  * (airport, orinoco_cs)
2161  * priv - orinoco private data
2162  * device - generic linux device structure
2163  *
2164  * +---------+ +---------+
2165  * | wiphy | | netdev |
2166  * | +-------+ | +-------+
2167  * | | priv | | | wdev |
2168  * | | +-----+ +-+-------+
2169  * | | | hw |
2170  * | +-+-----+
2171  * | | card |
2172  * +-+-------+
2173  *
2174  * priv has a link to netdev and device
2175  * wdev has a link to wiphy
2176  */
2177 struct orinoco_private
2178 *alloc_orinocodev(int sizeof_card,
2179  struct device *device,
2180  int (*hard_reset)(struct orinoco_private *),
2181  int (*stop_fw)(struct orinoco_private *, int))
2182 {
2183  struct orinoco_private *priv;
2184  struct wiphy *wiphy;
2185 
2186  /* allocate wiphy
2187  * NOTE: We only support a single virtual interface
2188  * but this may change when monitor mode is added
2189  */
2190  wiphy = wiphy_new(&orinoco_cfg_ops,
2191  sizeof(struct orinoco_private) + sizeof_card);
2192  if (!wiphy)
2193  return NULL;
2194 
2195  priv = wiphy_priv(wiphy);
2196  priv->dev = device;
2197 
2198  if (sizeof_card)
2199  priv->card = (void *)((unsigned long)priv
2200  + sizeof(struct orinoco_private));
2201  else
2202  priv->card = NULL;
2203 
2204  orinoco_wiphy_init(wiphy);
2205 
2206 #ifdef WIRELESS_SPY
2207  priv->wireless_data.spy_data = &priv->spy_data;
2208 #endif
2209 
2210  /* Set up default callbacks */
2211  priv->hard_reset = hard_reset;
2212  priv->stop_fw = stop_fw;
2213 
2214  spin_lock_init(&priv->lock);
2215  priv->open = 0;
2216  priv->hw_unavailable = 1; /* orinoco_init() must clear this
2217  * before anything else touches the
2218  * hardware */
2220  INIT_WORK(&priv->join_work, orinoco_join_ap);
2221  INIT_WORK(&priv->wevent_work, orinoco_send_wevents);
2222 
2223  INIT_LIST_HEAD(&priv->rx_list);
2224  tasklet_init(&priv->rx_tasklet, orinoco_rx_isr_tasklet,
2225  (unsigned long) priv);
2226 
2227  spin_lock_init(&priv->scan_lock);
2228  INIT_LIST_HEAD(&priv->scan_list);
2229  INIT_WORK(&priv->process_scan, orinoco_process_scan_results);
2230 
2231  priv->last_linkstatus = 0xffff;
2232 
2233 #if defined(CONFIG_HERMES_CACHE_FW_ON_INIT) || defined(CONFIG_PM_SLEEP)
2234  priv->cached_pri_fw = NULL;
2235  priv->cached_fw = NULL;
2236 #endif
2237 
2238  /* Register PM notifiers */
2240 
2241  return priv;
2242 }
2244 
2245 /* We can only support a single interface. We provide a separate
2246  * function to set it up to distinguish between hardware
2247  * initialisation and interface setup.
2248  *
2249  * The base_addr and irq parameters are passed on to netdev for use
2250  * with SIOCGIFMAP.
2251  */
2252 int orinoco_if_add(struct orinoco_private *priv,
2253  unsigned long base_addr,
2254  unsigned int irq,
2255  const struct net_device_ops *ops)
2256 {
2257  struct wiphy *wiphy = priv_to_wiphy(priv);
2258  struct wireless_dev *wdev;
2259  struct net_device *dev;
2260  int ret;
2261 
2262  dev = alloc_etherdev(sizeof(struct wireless_dev));
2263 
2264  if (!dev)
2265  return -ENOMEM;
2266 
2267  /* Initialise wireless_dev */
2268  wdev = netdev_priv(dev);
2269  wdev->wiphy = wiphy;
2271 
2272  /* Setup / override net_device fields */
2273  dev->ieee80211_ptr = wdev;
2274  dev->watchdog_timeo = HZ; /* 1 second timeout */
2275  dev->wireless_handlers = &orinoco_handler_def;
2276 #ifdef WIRELESS_SPY
2277  dev->wireless_data = &priv->wireless_data;
2278 #endif
2279  /* Default to standard ops if not set */
2280  if (ops)
2281  dev->netdev_ops = ops;
2282  else
2283  dev->netdev_ops = &orinoco_netdev_ops;
2284 
2285  /* we use the default eth_mac_addr for setting the MAC addr */
2286 
2287  /* Reserve space in skb for the SNAP header */
2289 
2290  netif_carrier_off(dev);
2291 
2292  memcpy(dev->dev_addr, wiphy->perm_addr, ETH_ALEN);
2293  memcpy(dev->perm_addr, wiphy->perm_addr, ETH_ALEN);
2294 
2295  dev->base_addr = base_addr;
2296  dev->irq = irq;
2297 
2298  SET_NETDEV_DEV(dev, priv->dev);
2299  ret = register_netdev(dev);
2300  if (ret)
2301  goto fail;
2302 
2303  priv->ndev = dev;
2304 
2305  /* Report what we've done */
2306  dev_dbg(priv->dev, "Registerred interface %s.\n", dev->name);
2307 
2308  return 0;
2309 
2310  fail:
2311  free_netdev(dev);
2312  return ret;
2315 
2316 void orinoco_if_del(struct orinoco_private *priv)
2317 {
2318  struct net_device *dev = priv->ndev;
2319 
2320  unregister_netdev(dev);
2321  free_netdev(dev);
2324 
2325 void free_orinocodev(struct orinoco_private *priv)
2326 {
2327  struct wiphy *wiphy = priv_to_wiphy(priv);
2328  struct orinoco_rx_data *rx_data, *temp;
2329  struct orinoco_scan_data *sd, *sdtemp;
2330 
2331  wiphy_unregister(wiphy);
2332 
2333  /* If the tasklet is scheduled when we call tasklet_kill it
2334  * will run one final time. However the tasklet will only
2335  * drain priv->rx_list if the hw is still available. */
2336  tasklet_kill(&priv->rx_tasklet);
2337 
2338  /* Explicitly drain priv->rx_list */
2339  list_for_each_entry_safe(rx_data, temp, &priv->rx_list, list) {
2340  list_del(&rx_data->list);
2341 
2342  dev_kfree_skb(rx_data->skb);
2343  kfree(rx_data->desc);
2344  kfree(rx_data);
2345  }
2346 
2348  /* Explicitly drain priv->scan_list */
2349  list_for_each_entry_safe(sd, sdtemp, &priv->scan_list, list) {
2350  list_del(&sd->list);
2351 
2352  if ((sd->len > 0) && sd->buf)
2353  kfree(sd->buf);
2354  kfree(sd);
2355  }
2356 
2358  orinoco_uncache_fw(priv);
2359 
2360  priv->wpa_ie_len = 0;
2361  kfree(priv->wpa_ie);
2362  orinoco_mic_free(priv);
2363  wiphy_free(wiphy);
2366 
2367 int orinoco_up(struct orinoco_private *priv)
2368 {
2369  struct net_device *dev = priv->ndev;
2370  unsigned long flags;
2371  int err;
2372 
2373  priv->hw.ops->lock_irqsave(&priv->lock, &flags);
2374 
2375  err = orinoco_reinit_firmware(priv);
2376  if (err) {
2377  printk(KERN_ERR "%s: Error %d re-initializing firmware\n",
2378  dev->name, err);
2379  goto exit;
2380  }
2381 
2382  netif_device_attach(dev);
2383  priv->hw_unavailable--;
2384 
2385  if (priv->open && !priv->hw_unavailable) {
2386  err = __orinoco_up(priv);
2387  if (err)
2388  printk(KERN_ERR "%s: Error %d restarting card\n",
2389  dev->name, err);
2390  }
2391 
2392 exit:
2393  priv->hw.ops->unlock_irqrestore(&priv->lock, &flags);
2394 
2395  return 0;
2398 
2399 void orinoco_down(struct orinoco_private *priv)
2400 {
2401  struct net_device *dev = priv->ndev;
2402  unsigned long flags;
2403  int err;
2404 
2405  priv->hw.ops->lock_irqsave(&priv->lock, &flags);
2406  err = __orinoco_down(priv);
2407  if (err)
2408  printk(KERN_WARNING "%s: Error %d downing interface\n",
2409  dev->name, err);
2410 
2411  netif_device_detach(dev);
2412  priv->hw_unavailable++;
2413  priv->hw.ops->unlock_irqrestore(&priv->lock, &flags);
2414 }
2416 
2417 /********************************************************************/
2418 /* Module initialization */
2419 /********************************************************************/
2420 
2421 /* Can't be declared "const" or the whole __initdata section will
2422  * become const */
2423 static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
2424  " (David Gibson <[email protected]>, "
2425  "Pavel Roskin <[email protected]>, et al)";
2426 
2427 static int __init init_orinoco(void)
2428 {
2429  printk(KERN_DEBUG "%s\n", version);
2430  return 0;
2431 }
2432 
2433 static void __exit exit_orinoco(void)
2434 {
2435 }
2436 
2437 module_init(init_orinoco);
2438 module_exit(exit_orinoco);