![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to orinoco.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / wireless|
Return to orinoco.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / pcmcia-cs / wireless |
1.1 root 1: /* orinoco.c 0.13e - (formerly known as dldwd_cs.c and orinoco_cs.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: * Copyright (C) 2000 David Gibson, Linuxcare Australia <[email protected]>
7: * With some help from :
8: * Copyright (C) 2001 Jean Tourrilhes, HP Labs <[email protected]>
9: * Copyright (C) 2001 Benjamin Herrenschmidt <[email protected]>
10: *
11: * Based on dummy_cs.c 1.27 2000/06/12 21:27:25
12: *
13: * Portions based on wvlan_cs.c 1.0.6, Copyright Andreas Neuhaus <[email protected]>
14: * http://www.fasta.fh-dortmund.de/users/andy/wvlan/
15: *
16: * The contents of this file are subject to the Mozilla Public License
17: * Version 1.1 (the "License"); you may not use this file except in
18: * compliance with the License. You may obtain a copy of the License
19: * at http://www.mozilla.org/MPL/
20: *
21: * Software distributed under the License is distributed on an "AS IS"
22: * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
23: * the License for the specific language governing rights and
24: * limitations under the License.
25: *
26: * The initial developer of the original code is David A. Hinds
27: * <[email protected]>. Portions created by David
28: * A. Hinds are Copyright (C) 1999 David A. Hinds. All Rights
29: * Reserved.
30: *
31: * Alternatively, the contents of this file may be used under the
32: * terms of the GNU General Public License version 2 (the "GPL"), in
33: * which case the provisions of the GPL are applicable instead of the
34: * above. If you wish to allow the use of your version of this file
35: * only under the terms of the GPL and not to allow others to use your
36: * version of this file under the MPL, indicate your decision by
37: * deleting the provisions above and replace them with the notice and
38: * other provisions required by the GPL. If you do not delete the
39: * provisions above, a recipient may use your version of this file
40: * under either the MPL or the GPL. */
41:
42: /*
43: * v0.01 -> v0.02 - 21/3/2001 - Jean II
44: * o Allow to use regular ethX device name instead of dldwdX
45: * o Warning on IBSS with ESSID=any for firmware 6.06
46: * o Put proper range.throughput values (optimistic)
47: * o IWSPY support (IOCTL and stat gather in Rx path)
48: * o Allow setting frequency in Ad-Hoc mode
49: * o Disable WEP setting if !has_wep to work on old firmware
50: * o Fix txpower range
51: * o Start adding support for Samsung/Compaq firmware
52: *
53: * v0.02 -> v0.03 - 23/3/2001 - Jean II
54: * o Start adding Symbol support - need to check all that
55: * o Fix Prism2/Symbol WEP to accept 128 bits keys
56: * o Add Symbol WEP (add authentication type)
57: * o Add Prism2/Symbol rate
58: * o Add PM timeout (holdover duration)
59: * o Enable "iwconfig eth0 key off" and friends (toggle flags)
60: * o Enable "iwconfig eth0 power unicast/all" (toggle flags)
61: * o Try with an intel card. It report firmware 1.01, behave like
62: * an antiquated firmware, however on windows it says 2.00. Yuck !
63: * o Workaround firmware bug in allocate buffer (Intel 1.01)
64: * o Finish external renaming to orinoco...
65: * o Testing with various Wavelan firmwares
66: *
67: * v0.03 -> v0.04 - 30/3/2001 - Jean II
68: * o Update to Wireless 11 -> add retry limit/lifetime support
69: * o Tested with a D-Link DWL 650 card, fill in firmware support
70: * o Warning on Vcc mismatch (D-Link 3.3v card in Lucent 5v only slot)
71: * o Fixed the Prims2 WEP bugs that I introduced in v0.03 :-(
72: * It work on D-Link *only* after a tcpdump. Weird...
73: * And still doesn't work on Intel card. Grrrr...
74: * o Update the mode after a setport3
75: * o Add preamble setting for Symbol cards (not yet enabled)
76: * o Don't complain as much about Symbol cards...
77: *
78: * v0.04 -> v0.04b - 22/4/2001 - David Gibson
79: * o Removed the 'eth' parameter - always use ethXX as the
80: * interface name instead of dldwdXX. The other was racy
81: * anyway.
82: * o Clean up RID definitions in hermes.h, other cleanups
83: *
84: * v0.04b -> v0.04c - 24/4/2001 - Jean II
85: * o Tim Hurley <[email protected]> reported a D-Link card
86: * with vendor 02 and firmware 0.08. Added in the capabilities...
87: * o Tested Lucent firmware 7.28, everything works...
88: *
89: * v0.04c -> v0.05 - 3/5/2001 - Benjamin Herrenschmidt
90: * o Spin-off Pcmcia code. This file is renamed orinoco.c,
91: * and orinoco_cs.c now contains only the Pcmcia specific stuff
92: * o Add Airport driver support on top of orinoco.c (see airport.c)
93: *
94: * v0.05 -> v0.05a - 4/5/2001 - Jean II
95: * o Revert to old Pcmcia code to fix breakage of Ben's changes...
96: *
97: * v0.05a -> v0.05b - 4/5/2001 - Jean II
98: * o add module parameter 'ignore_cis_vcc' for D-Link @ 5V
99: * o D-Link firmware doesn't support multicast. We just print a few
100: * error messages, but otherwise everything works...
101: * o For David : set/getport3 works fine, just upgrade iwpriv...
102: *
103: * v0.05b -> v0.05c - 5/5/2001 - Benjamin Herrenschmidt
104: * o Adapt airport.c to latest changes in orinoco.c
105: * o Remove deferred power enabling code
106: *
107: * v0.05c -> v0.05d - 5/5/2001 - Jean II
108: * o Workaround to SNAP decapsulate frame from LinkSys AP
109: * original patch from : Dong Liu <[email protected]>
110: * (note : the memcmp bug was mine - fixed)
111: * o Remove set_retry stuff, no firmware support it (bloat--).
112: *
113: * v0.05d -> v0.06 - 25/5/2001 - Jean II
114: * Original patch from "Hong Lin" <[email protected]>,
115: * "Ian Kinner" <[email protected]>
116: * and "David Smith" <[email protected]>
117: * o Init of priv->tx_rate_ctrl in firmware specific section.
118: * o Prism2/Symbol rate, upto should be 0xF and not 0x15. Doh !
119: * o Spectrum card always need cor_reset (for every reset)
120: * o Fix cor_reset to not lose bit 7 in the register
121: * o flush_stale_links to remove zombie Pcmcia instances
122: * o Ack previous hermes event before reset
123: * Me (with my little hands)
124: * o Allow orinoco.c to call cor_reset via priv->card_reset_handler
125: * o Add priv->need_card_reset to toggle this feature
126: * o Fix various buglets when setting WEP in Symbol firmware
127: * Now, encryption is fully functional on Symbol cards. Youpi !
128: *
129: * v0.06 -> v0.06b - 25/5/2001 - Jean II
130: * o IBSS on Symbol use port_mode = 4. Please don't ask...
131: *
132: * v0.06b -> v0.06c - 29/5/2001 - Jean II
133: * o Show first spy address in /proc/net/wireless for IBSS mode as well
134: *
135: * v0.06c -> v0.06d - 6/7/2001 - David Gibson
136: * o Change a bunch of KERN_INFO messages to KERN_DEBUG, as per Linus'
137: * wishes to reduce the number of unecessary messages.
138: * o Removed bogus message on CRC error.
139: * o Merged fixeds for v0.08 Prism 2 firmware from William Waghorn
140: * <[email protected]>
141: * o Slight cleanup/re-arrangement of firmware detection code.
142: *
143: * v0.06d -> v0.06e - 1/8/2001 - David Gibson
144: * o Removed some redundant global initializers (orinoco_cs.c).
145: * o Added some module metadataa
146: *
147: * v0.06e -> v0.06f - 14/8/2001 - David Gibson
148: * o Wording fix to license
149: * o Added a 'use_alternate_encaps' module parameter for APs which need an
150: * oui of 00:00:00. We really need a better way of handling this, but
151: * the module flag is better than nothing for now.
152: *
153: * v0.06f -> v0.07 - 20/8/2001 - David Gibson
154: * o Removed BAP error retries from hermes_bap_seek(). For Tx we now
155: * let the upper layers handle the retry, we retry explicitly in the
156: * Rx path, but don't make as much noise about it.
157: * o Firmware detection cleanups.
158: *
159: * v0.07 -> v0.07a - 1/10/3001 - Jean II
160: * o Add code to read Symbol firmware revision, inspired by latest code
161: * in Spectrum24 by Lee John Keyser-Allen - Thanks Lee !
162: * o Thanks to Jared Valentine <[email protected]> for "providing" me
163: * a 3Com card with a recent firmware, fill out Symbol firmware
164: * capabilities of latest rev (2.20), as well as older Symbol cards.
165: * o Disable Power Management in newer Symbol firmware, the API
166: * has changed (documentation needed).
167: *
168: * v0.07a -> v0.08 - 3/10/2001 - David Gibson
169: * o Fixed a possible buffer overrun found by the Stanford checker (in
170: * dldwd_ioctl_setiwencode()). Can only be called by root anyway, so not
171: * a big problem.
172: * o Turned has_big_wep on for Intersil cards. That's not true for all of
173: * them but we should at least let the capable ones try.
174: * o Wait for BUSY to clear at the beginning of hermes_bap_seek(). I
175: * realised that my assumption that the driver's serialization
176: * would prevent the BAP being busy on entry was possibly false, because
177: * things other than seeks may make the BAP busy.
178: * o Use "alternate" (oui 00:00:00) encapsulation by default.
179: * Setting use_old_encaps will mimic the old behaviour, but I think we
180: * will be able to eliminate this.
181: * o Don't try to make __initdata const (the version string). This can't
182: * work because of the way the __initdata sectioning works.
183: * o Added MODULE_LICENSE tags.
184: * o Support for PLX (transparent PCMCIA->PCI brdge) cards.
185: * o Changed to using the new type-facist min/max.
186: *
187: * v0.08 -> v0.08a - 9/10/2001 - David Gibson
188: * o Inserted some missing acknowledgements/info into the Changelog.
189: * o Fixed some bugs in the normalisation of signel level reporting.
190: * o Fixed bad bug in WEP key handling on Intersil and Symbol firmware,
191: * which led to an instant crash on big-endian machines.
192: *
193: * v0.08a -> v0.08b - 20/11/2001 - David Gibson
194: * o Lots of cleanup and bugfixes in orinoco_plx.c
195: * o Cleanup to handling of Tx rate setting.
196: * o Removed support for old encapsulation method.
197: * o Removed old "dldwd" names.
198: * o Split RID constants into a new file hermes_rid.h
199: * o Renamed RID constants to match linux-wlan-ng and prism2.o
200: * o Bugfixes in hermes.c
201: * o Poke the PLX's INTCSR register, so it actually starts
202: * generating interrupts. These cards might actually work now.
203: * o Update to wireless extensions v12 (Jean II)
204: * o Support for tallies and inquire command (Jean II)
205: * o Airport updates for newer PPC kernels (BenH)
206: *
207: * v0.08b -> v0.09 - 21/12/2001 - David Gibson
208: * o Some new PCI IDs for PLX cards.
209: * o Removed broken attempt to do ALLMULTI reception. Just use
210: * promiscuous mode instead
211: * o Preliminary work for list-AP (Jean II)
212: * o Airport updates from (BenH)
213: * o Eliminated racy hw_ready stuff
214: * o Fixed generation of fake events in irq handler. This should
215: * finally kill the EIO problems (Jean II & dgibson)
216: * o Fixed breakage of bitrate set/get on Agere firmware (Jean II)
217: *
218: * v0.09 -> v0.09a - 2/1/2002 - David Gibson
219: * o Fixed stupid mistake in multicast list handling, triggering
220: * a BUG()
221: *
222: * v0.09a -> v0.09b - 16/1/2002 - David Gibson
223: * o Fixed even stupider mistake in new interrupt handling, which
224: * seriously broke things on big-endian machines.
225: * o Removed a bunch of redundant includes and exports.
226: * o Removed a redundant MOD_{INC,DEC}_USE_COUNT pair in airport.c
227: * o Don't attempt to do hardware level multicast reception on
228: * Intersil firmware, just go promisc instead.
229: * o Typo fixed in hermes_issue_cmd()
230: * o Eliminated WIRELESS_SPY #ifdefs
231: * o Status code reported on Tx exceptions
232: * o Moved netif_wake_queue() from ALLOC interrupts to TX and TXEXC
233: * interrupts, which should fix the timeouts we're seeing.
234: *
235: * v0.09b -> v0.10 - 25 Feb 2002 - David Gibson
236: * o Removed nested structures used for header parsing, so the
237: * driver should now work without hackery on ARM
238: * o Fix for WEP handling on Intersil (Hawk Newton)
239: * o Eliminated the /proc/hermes/ethXX/regs debugging file. It
240: * was never very useful.
241: * o Make Rx errors less noisy.
242: *
243: * v0.10 -> v0.11 - 5 Apr 2002 - David Gibson
244: * o Laid the groundwork in hermes.[ch] for devices which map
245: * into PCI memory space rather than IO space.
246: * o Fixed bug in multicast handling (cleared multicast list when
247: * leaving promiscuous mode).
248: * o Relegated Tx error messages to debug.
249: * o Cleaned up / corrected handling of allocation lengths.
250: * o Set OWNSSID in IBSS mode for WinXP interoperability (jimc).
251: * o Change to using alloc_etherdev() for structure allocations.
252: * o Check for and drop undersized packets.
253: * o Fixed a race in stopping/waking the queue. This should fix
254: * the timeout problems (Pavel Roskin)
255: * o Reverted to netif_wake_queue() on the ALLOC event.
256: * o Fixes for recent Symbol firmwares which lack AP density
257: * (Pavel Roskin).
258: *
259: * v0.11 -> v0.11a - 29 Apr 2002 - David Gibson
260: * o Handle different register spacing, necessary for Prism 2.5
261: * PCI adaptors (Steve Hill).
262: * o Cleaned up initialization of card structures in orinoco_cs
263: * and airport. Removed card->priv field.
264: * o Make response structure optional for hermes_docmd_wait()
265: * Pavel Roskin)
266: * o Added PCI id for Nortel emobility to orinoco_plx.c.
267: * o Cleanup to handling of Symbol's allocation bug. (Pavel Roskin)
268: * o Cleanups to firmware capability detection.
269: * o Arrange for orinoco_pci.c to override firmware detection.
270: * We should be able to support the PCI Intersil cards now.
271: * o Cleanup handling of reset_cor and hard_reset (Pavel Roskin).
272: * o Remove erroneous use of USER_BAP in the TxExc handler (Jouni
273: * Malinen).
274: * o Makefile changes for better integration into David Hinds
275: * pcmcia-cs package.
276: *
277: * v0.11a -> v0.11b - 1 May 2002 - David Gibson
278: * o Better error reporting in orinoco_plx_init_one()
279: * o Fixed multiple bad kfree() bugs introduced by the
280: * alloc_orinocodev() changes.
281: *
282: * v0.11b -> v0.12 - 19 Jun 2002 - David Gibson
283: * o Support changing the MAC address.
284: * o Correct display of Intersil firmware revision numbers.
285: * o Entirely revised locking scheme. Should be both simpler and
286: * better.
287: * o Merged some common code in orinoco_plx, orinoco_pci and
288: * airport by creating orinoco_default_{open,stop,reset}()
289: * which are used as the dev->open, dev->stop, priv->reset
290: * callbacks if none are specified when alloc_orinocodev() is
291: * called.
292: * o Removed orinoco_plx_interrupt() and orinoco_pci_interrupt().
293: * They didn't do anything.
294: *
295: * v0.12 -> v0.12a - 4 Jul 2002 - David Gibson
296: * o Some rearrangement of code.
297: * o Numerous fixups to locking and rest handling, particularly
298: * for PCMCIA.
299: * o This allows open and stop net_device methods to be in
300: * orinoco.c now, rather than in the init modules.
301: * o In orinoco_cs.c link->priv now points to the struct
302: * net_device not to the struct orinoco_private.
303: * o Added a check for undersized SNAP frames, which could cause
304: * crashes.
305: *
306: * v0.12a -> v0.12b - 11 Jul 2002 - David Gibson
307: * o Fix hw->num_init testing code, so num_init is actually
308: * incremented.
309: * o Fix very stupid bug in orinoco_cs which broke compile with
310: * CONFIG_SMP.
311: * o Squashed a warning.
312: *
313: * v0.12b -> v0.12c - 26 Jul 2002 - David Gibson
314: * o Change to C9X style designated initializers.
315: * o Add support for 3Com AirConnect PCI.
316: * o No longer ignore the hard_reset argument to
317: * alloc_orinocodev(). Oops.
318: *
319: * v0.12c -> v0.13beta1 - 13 Sep 2002 - David Gibson
320: * o Revert the broken 0.12* locking scheme and go to a new yet
321: * simpler scheme.
322: * o Do firmware resets only in orinoco_init() and when waking
323: * the card from hard sleep.
324: *
325: * v0.13beta1 -> v0.13 - 27 Sep 2002 - David Gibson
326: * o Re-introduced full resets (via schedule_task()) on Tx
327: * timeout.
328: *
329: * v0.13 -> v0.13a - 30 Sep 2002 - David Gibson
330: * o Minor cleanups to info frame handling. Add basic support
331: * for linkstatus info frames.
332: * o Include required kernel headers in orinoco.h, to avoid
333: * compile problems.
334: *
335: * v0.13a -> v0.13b - 10 Feb 2003 - David Gibson
336: * o Implemented hard reset for Airport cards
337: * o Experimental suspend/resume implementation for orinoco_pci
338: * o Abolished /proc debugging support, replaced with a debugging
339: * iwpriv. Now it's ugly and simple instead of ugly and complex.
340: * o Bugfix in hermes.c if the firmware returned a record length
341: * of 0, we could go clobbering memory.
342: * o Bugfix in orinoco_stop() - it used to fail if hw_unavailable
343: * was set, which was usually true on PCMCIA hot removes.
344: * o Track LINKSTATUS messages, silently drop Tx packets before
345: * we are connected (avoids cofusing the firmware), and only
346: * give LINKSTATUS printk()s if the status has changed.
347: *
348: * v0.13b -> v0.13c - 11 Mar 2003 - David Gibson
349: * o Cleanup: use dev instead of priv in various places.
350: * o Bug fix: Don't ReleaseConfiguration on RESET_PHYSICAL event
351: * if we're in the middle of a (driver initiated) hard reset.
352: * o Bug fix: ETH_ZLEN is supposed to include the header
353: * (Dionysus Blazakis & Manish Karir)
354: * o Convert to using workqueues instead of taskqueues (and
355: * backwards compatibility macros for pre 2.5.41 kernels).
356: * o Drop redundant (I think...) MOD_{INC,DEC}_USE_COUNT in
357: * airport.c
358: * o New orinoco_tmd.c init module from Joerg Dorchain for
359: * TMD7160 based PCI to PCMCIA bridges (similar to
360: * orinoco_plx.c).
361: *
362: * v0.13c -> v0.13d - 22 Apr 2003 - David Gibson
363: * o Make hw_unavailable a counter, rather than just a flag, this
364: * is necessary to avoid some races (such as a card being
365: * removed in the middle of orinoco_reset().
366: * o Restore Release/RequestConfiguration in the PCMCIA event handler
367: * when dealing with a driver initiated hard reset. This is
368: * necessary to prevent hangs due to a spurious interrupt while
369: * the reset is in progress.
370: * o Clear the 802.11 header when transmitting, even though we
371: * don't use it. This fixes a long standing bug on some
372: * firmwares, which seem to get confused if that isn't done.
373: * o Be less eager to de-encapsulate SNAP frames, only do so if
374: * the OUI is 00:00:00 or 00:00:f8, leave others alone. The old
375: * behaviour broke CDP (Cisco Discovery Protocol).
376: * o Use dev instead of priv for free_irq() as well as
377: * request_irq() (oops).
378: * o Attempt to reset rather than giving up if we get too many
379: * IRQs.
380: * o Changed semantics of __orinoco_down() so it can be called
381: * safely with hw_unavailable set. It also now clears the
382: * linkstatus (since we're going to have to reassociate).
383: *
384: * v0.13d -> v0.13e - 12 May 2003 - David Gibson
385: * o Support for post-2.5.68 return values from irq handler.
386: * o Fixed bug where underlength packets would be double counted
387: * in the rx_dropped statistics.
388: * o Provided a module parameter to suppress linkstatus messages.
389: *
390: * TODO
391: * o New wireless extensions API (patch from Moustafa
392: * Youssef, updated by Jim Carter and Pavel Roskin).
393: * o Handle de-encapsulation within network layer, provide 802.11
394: * headers (patch from Thomas 'Dent' Mirlacher)
395: * o RF monitor mode support
396: * o Fix possible races in SPY handling.
397: * o Disconnect wireless extensions from fundamental configuration.
398: * o (maybe) Software WEP support (patch from Stano Meduna).
399: * o (maybe) Use multiple Tx buffers - driver handling queue
400: * rather than firmware. */
401:
402: /* Locking and synchronization:
403: *
404: * The basic principle is that everything is serialized through a
405: * single spinlock, priv->lock. The lock is used in user, bh and irq
406: * context, so when taken outside hardirq context it should always be
407: * taken with interrupts disabled. The lock protects both the
408: * hardware and the struct orinoco_private.
409: *
410: * Another flag, priv->hw_unavailable indicates that the hardware is
411: * unavailable for an extended period of time (e.g. suspended, or in
412: * the middle of a hard reset). This flag is protected by the
413: * spinlock. All code which touches the hardware should check the
414: * flag after taking the lock, and if it is set, give up on whatever
415: * they are doing and drop the lock again. The orinoco_lock()
416: * function handles this (it unlocks and returns -EBUSY if
417: * hw_unavailable is non-zero). */
418:
419: #include <linux/config.h>
420:
421: #include <linux/module.h>
422: #include <linux/kernel.h>
423: #include <linux/init.h>
424: #include <linux/ptrace.h>
425: #include <linux/slab.h>
426: #include <linux/string.h>
427: #include <linux/timer.h>
428: #include <linux/ioport.h>
429: #include <linux/netdevice.h>
430: #include <linux/if_arp.h>
431: #include <linux/etherdevice.h>
432: #include <linux/wireless.h>
433:
434: #include <asm/uaccess.h>
435: #include <asm/io.h>
436: #include <asm/system.h>
437:
438: #include "hermes.h"
439: #include "hermes_rid.h"
440: #include "orinoco.h"
441: #include "ieee802_11.h"
442:
443: /********************************************************************/
444: /* Module information */
445: /********************************************************************/
446:
447: MODULE_AUTHOR("David Gibson <[email protected]>");
448: MODULE_DESCRIPTION("Driver for Lucent Orinoco, Prism II based and similar wireless cards");
449: #ifdef MODULE_LICENSE
450: MODULE_LICENSE("Dual MPL/GPL");
451: #endif
452:
453: /* Level of debugging. Used in the macros in orinoco.h */
454: #ifdef ORINOCO_DEBUG
455: int orinoco_debug = ORINOCO_DEBUG;
456: MODULE_PARM(orinoco_debug, "i");
457: EXPORT_SYMBOL(orinoco_debug);
458: #endif
459:
460: static int suppress_linkstatus; /* = 0 */
461: MODULE_PARM(suppress_linkstatus, "i");
462:
463: /********************************************************************/
464: /* Compile time configuration and compatibility stuff */
465: /********************************************************************/
466:
467: /* Wireless extensions backwards compatibility */
468: #ifndef SIOCIWFIRSTPRIV
469: #define SIOCIWFIRSTPRIV SIOCDEVPRIVATE
470: #endif /* SIOCIWFIRSTPRIV */
471: #ifndef SIOCIWLASTPRIV
472: #define SIOCIWLASTPRIV SIOCDEVPRIVATE+0xF
473: #endif /* SIOCIWLASTPRIV */
474:
475: /* We do this this way to avoid ifdefs in the actual code */
476: #ifdef WIRELESS_SPY
477: #define SPY_NUMBER(priv) (priv->spy_number)
478: #else
479: #define SPY_NUMBER(priv) 0
480: #endif /* WIRELESS_SPY */
481:
482: /********************************************************************/
483: /* Internal constants */
484: /********************************************************************/
485:
486: #define ORINOCO_MIN_MTU 256
487: #define ORINOCO_MAX_MTU (IEEE802_11_DATA_LEN - ENCAPS_OVERHEAD)
488:
489: #define SYMBOL_MAX_VER_LEN (14)
490: #define USER_BAP 0
491: #define IRQ_BAP 1
492: #define MAX_IRQLOOPS_PER_IRQ 10
493: #define MAX_IRQLOOPS_PER_JIFFY (20000/HZ) /* Based on a guestimate of
494: * how many events the
495: * device could
496: * legitimately generate */
497: #define SMALL_KEY_SIZE 5
498: #define LARGE_KEY_SIZE 13
499: #define TX_NICBUF_SIZE_BUG 1585 /* Bug in Symbol firmware */
500:
501: #define DUMMY_FID 0xFFFF
502:
503: #define RUP_EVEN(a) (((a) + 1) & (~1))
504:
505: /*#define MAX_MULTICAST(priv) (priv->firmware_type == FIRMWARE_TYPE_AGERE ? \
506: HERMES_MAX_MULTICAST : 0)*/
507: #define MAX_MULTICAST(priv) (HERMES_MAX_MULTICAST)
508:
509: /*
510: * MACH related stuff...
511: */
512:
513: #ifdef MACH
514:
515: #undef copy_to_user
516: #define copy_to_user(a,b,c) (memcpy(a,b,c), 0)
517:
518: #define verify_area(a,b,c) (0)
519: #define copy_from_user(a,b,c) (memcpy(a,b,c), 0)
520:
521: #endif
522:
523: /********************************************************************/
524: /* Data tables */
525: /********************************************************************/
526:
527: /* The frequency of each channel in MHz */
528: const long channel_frequency[] = {
529: 2412, 2417, 2422, 2427, 2432, 2437, 2442,
530: 2447, 2452, 2457, 2462, 2467, 2472, 2484
531: };
532: #define NUM_CHANNELS ( sizeof(channel_frequency) / sizeof(channel_frequency[0]) )
533:
534: /* This tables gives the actual meanings of the bitrate IDs returned by the firmware. */
535: struct {
536: int bitrate; /* in 100s of kilobits */
537: int automatic;
538: u16 agere_txratectrl;
539: u16 intersil_txratectrl;
540: } bitrate_table[] = {
541: {110, 1, 3, 15}, /* Entry 0 is the default */
542: {10, 0, 1, 1},
543: {10, 1, 1, 1},
544: {20, 0, 2, 2},
545: {20, 1, 6, 3},
546: {55, 0, 4, 4},
547: {55, 1, 7, 7},
548: {110, 0, 5, 8},
549: };
550: #define BITRATE_TABLE_SIZE (sizeof(bitrate_table) / sizeof(bitrate_table[0]))
551:
552: /********************************************************************/
553: /* Data types */
554: /********************************************************************/
555:
556: struct header_struct {
557: /* 802.3 */
558: u8 dest[ETH_ALEN];
559: u8 src[ETH_ALEN];
560: u16 len;
561: /* 802.2 */
562: u8 dsap;
563: u8 ssap;
564: u8 ctrl;
565: /* SNAP */
566: u8 oui[3];
567: u16 ethertype;
568: } __attribute__ ((packed));
569:
570: /* 802.2 LLC/SNAP header used for Ethernet encapsulation over 802.11 */
571: u8 encaps_hdr[] = {0xaa, 0xaa, 0x03, 0x00, 0x00, 0x00};
572:
573: #define ENCAPS_OVERHEAD (sizeof(encaps_hdr) + 2)
574:
575: /********************************************************************/
576: /* Function prototypes */
577: /********************************************************************/
578:
579: static void orinoco_stat_gather(struct net_device *dev,
580: struct sk_buff *skb,
581: struct hermes_rx_descriptor *desc);
582:
583: static struct net_device_stats *orinoco_get_stats(struct net_device *dev);
584: static struct iw_statistics *orinoco_get_wireless_stats(struct net_device *dev);
585:
586: /* Hardware control routines */
587:
588: static int __orinoco_program_rids(struct net_device *dev);
589:
590: static int __orinoco_hw_set_bitrate(struct orinoco_private *priv);
591: static int __orinoco_hw_setup_wep(struct orinoco_private *priv);
592: static int orinoco_hw_get_bssid(struct orinoco_private *priv, char buf[ETH_ALEN]);
593: static int orinoco_hw_get_essid(struct orinoco_private *priv, int *active,
594: char buf[IW_ESSID_MAX_SIZE+1]);
595: static long orinoco_hw_get_freq(struct orinoco_private *priv);
596: static int orinoco_hw_get_bitratelist(struct orinoco_private *priv, int *numrates,
597: s32 *rates, int max);
598: static void __orinoco_set_multicast_list(struct net_device *dev);
599:
600: /* Interrupt handling routines */
601: static void __orinoco_ev_tick(struct net_device *dev, hermes_t *hw);
602: static void __orinoco_ev_wterr(struct net_device *dev, hermes_t *hw);
603: static void __orinoco_ev_infdrop(struct net_device *dev, hermes_t *hw);
604: static void __orinoco_ev_info(struct net_device *dev, hermes_t *hw);
605: static void __orinoco_ev_rx(struct net_device *dev, hermes_t *hw);
606: static void __orinoco_ev_txexc(struct net_device *dev, hermes_t *hw);
607: static void __orinoco_ev_tx(struct net_device *dev, hermes_t *hw);
608: static void __orinoco_ev_alloc(struct net_device *dev, hermes_t *hw);
609:
610: /* ioctl() routines */
611: static int orinoco_debug_dump_recs(struct net_device *dev);
612:
613: /********************************************************************/
614: /* Function prototypes */
615: /********************************************************************/
616:
617: int __orinoco_up(struct net_device *dev)
618: {
619: struct orinoco_private *priv = dev->priv;
620: struct hermes *hw = &priv->hw;
621: int err;
622:
623: err = __orinoco_program_rids(dev);
624: if (err) {
625: printk(KERN_ERR "%s: Error %d configuring card\n",
626: dev->name, err);
627: return err;
628: }
629:
630: /* Fire things up again */
631: hermes_set_irqmask(hw, ORINOCO_INTEN);
632: err = hermes_enable_port(hw, 0);
633: if (err) {
634: printk(KERN_ERR "%s: Error %d enabling MAC port\n",
635: dev->name, err);
636: return err;
637: }
638:
639: netif_start_queue(dev);
640: netif_mark_up(dev);
641:
642: return 0;
643: }
644:
645: int __orinoco_down(struct net_device *dev)
646: {
647: struct orinoco_private *priv = dev->priv;
648: struct hermes *hw = &priv->hw;
649: int err;
650:
651: netif_stop_queue(dev);
652: netif_mark_down(dev);
653:
654: if (! priv->hw_unavailable) {
655: if (! priv->broken_disableport) {
656: err = hermes_disable_port(hw, 0);
657: if (err) {
658: /* Some firmwares (e.g. Intersil 1.3.x) seem
659: * to have problems disabling the port, oh
660: * well, too bad. */
661: printk(KERN_WARNING "%s: Error %d disabling MAC port\n",
662: dev->name, err);
663: priv->broken_disableport = 1;
664: }
665: }
666: hermes_set_irqmask(hw, 0);
667: hermes_write_regn(hw, EVACK, 0xffff);
668: }
669:
670: /* firmware will have to reassociate */
671: priv->last_linkstatus = 0xffff;
672: priv->connected = 0;
673:
674: return 0;
675: }
676:
677: int orinoco_reinit_firmware(struct net_device *dev)
678: {
679: struct orinoco_private *priv = dev->priv;
680: struct hermes *hw = &priv->hw;
681: int err;
682:
683: err = hermes_init(hw);
684: if (err)
685: return err;
686:
687: err = hermes_allocate(hw, priv->nicbuf_size, &priv->txfid);
688: if (err == -EIO) {
689: /* Try workaround for old Symbol firmware bug */
690: printk(KERN_WARNING "%s: firmware ALLOC bug detected "
691: "(old Symbol firmware?). Trying to work around... ",
692: dev->name);
693:
694: priv->nicbuf_size = TX_NICBUF_SIZE_BUG;
695: err = hermes_allocate(hw, priv->nicbuf_size, &priv->txfid);
696: if (err)
697: printk("failed!\n");
698: else
699: printk("ok.\n");
700: }
701:
702: return err;
703: }
704:
705: static int orinoco_open(struct net_device *dev)
706: {
707: struct orinoco_private *priv = dev->priv;
708: unsigned long flags;
709: int err;
710:
711: err = orinoco_lock(priv, &flags);
712: if (err)
713: return err;
714:
715: err = __orinoco_up(dev);
716:
717: if (! err)
718: priv->open = 1;
719:
720: orinoco_unlock(priv, &flags);
721:
722: return err;
723: }
724:
725: int orinoco_stop(struct net_device *dev)
726: {
727: struct orinoco_private *priv = dev->priv;
728: int err = 0;
729:
730: /* We mustn't use orinoco_lock() here, because we need to be
731: able to close the interface even if hw_unavailable is set
732: (e.g. as we're released after a PC Card removal) */
733: spin_lock_irq(&priv->lock);
734:
735: priv->open = 0;
736:
737: err = __orinoco_down(dev);
738:
739: spin_unlock_irq(&priv->lock);
740:
741: return err;
742: }
743:
744: static int __orinoco_program_rids(struct net_device *dev)
745: {
746: struct orinoco_private *priv = dev->priv;
747: hermes_t *hw = &priv->hw;
748: int err;
749: struct hermes_idstring idbuf;
750:
751: /* Set the MAC address */
752: err = hermes_write_ltv(hw, USER_BAP, HERMES_RID_CNFOWNMACADDR,
753: HERMES_BYTES_TO_RECLEN(ETH_ALEN), dev->dev_addr);
754: if (err) {
755: printk(KERN_ERR "%s: Error %d setting MAC address\n", dev->name, err);
756: return err;
757: }
758:
759: /* Set up the link mode */
760: err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFPORTTYPE, priv->port_type);
761: if (err) {
762: printk(KERN_ERR "%s: Error %d setting port type\n", dev->name, err);
763: return err;
764: }
765: /* Set the channel/frequency */
766: if (priv->channel == 0) {
767: printk(KERN_DEBUG "%s: Channel is 0 in __orinoco_program_rids()\n", dev->name);
768: if (priv->createibss)
769: priv->channel = 10;
770: }
771: err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFOWNCHANNEL, priv->channel);
772: if (err) {
773: printk(KERN_ERR "%s: Error %d setting channel\n", dev->name, err);
774: return err;
775: }
776:
777: if (priv->has_ibss) {
778: err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFCREATEIBSS,
779: priv->createibss);
780: if (err) {
781: printk(KERN_ERR "%s: Error %d setting CREATEIBSS\n", dev->name, err);
782: return err;
783: }
784:
785: if ((strlen(priv->desired_essid) == 0) && (priv->createibss)
786: && (!priv->has_ibss_any)) {
787: printk(KERN_WARNING "%s: This firmware requires an \
788: ESSID in IBSS-Ad-Hoc mode.\n", dev->name);
789: /* With wvlan_cs, in this case, we would crash.
790: * hopefully, this driver will behave better...
791: * Jean II */
792: }
793: }
794:
795: /* Set the desired ESSID */
796: idbuf.len = cpu_to_le16(strlen(priv->desired_essid));
797: memcpy(&idbuf.val, priv->desired_essid, sizeof(idbuf.val));
798: /* WinXP wants partner to configure OWNSSID even in IBSS mode. (jimc) */
799: err = hermes_write_ltv(hw, USER_BAP, HERMES_RID_CNFOWNSSID,
800: HERMES_BYTES_TO_RECLEN(strlen(priv->desired_essid)+2),
801: &idbuf);
802: if (err) {
803: printk(KERN_ERR "%s: Error %d setting OWNSSID\n", dev->name, err);
804: return err;
805: }
806: err = hermes_write_ltv(hw, USER_BAP, HERMES_RID_CNFDESIREDSSID,
807: HERMES_BYTES_TO_RECLEN(strlen(priv->desired_essid)+2),
808: &idbuf);
809: if (err) {
810: printk(KERN_ERR "%s: Error %d setting DESIREDSSID\n", dev->name, err);
811: return err;
812: }
813:
814: /* Set the station name */
815: idbuf.len = cpu_to_le16(strlen(priv->nick));
816: memcpy(&idbuf.val, priv->nick, sizeof(idbuf.val));
817: err = hermes_write_ltv(hw, USER_BAP, HERMES_RID_CNFOWNNAME,
818: HERMES_BYTES_TO_RECLEN(strlen(priv->nick)+2),
819: &idbuf);
820: if (err) {
821: printk(KERN_ERR "%s: Error %d setting nickname\n", dev->name, err);
822: return err;
823: }
824:
825: /* Set AP density */
826: if (priv->has_sensitivity) {
827: err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFSYSTEMSCALE,
828: priv->ap_density);
829: if (err) {
830: printk(KERN_WARNING "%s: Error %d setting SYSTEMSCALE. "
831: "Disabling sensitivity control\n", dev->name, err);
832:
833: priv->has_sensitivity = 0;
834: }
835: }
836:
837: /* Set RTS threshold */
838: err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFRTSTHRESHOLD, priv->rts_thresh);
839: if (err) {
840: printk(KERN_ERR "%s: Error %d setting RTS threshold\n", dev->name, err);
841: return err;
842: }
843:
844: /* Set fragmentation threshold or MWO robustness */
845: if (priv->has_mwo)
846: err = hermes_write_wordrec(hw, USER_BAP,
847: HERMES_RID_CNFMWOROBUST_AGERE,
848: priv->mwo_robust);
849: else
850: err = hermes_write_wordrec(hw, USER_BAP,
851: HERMES_RID_CNFFRAGMENTATIONTHRESHOLD,
852: priv->frag_thresh);
853: if (err) {
854: printk(KERN_ERR "%s: Error %d setting framentation\n", dev->name, err);
855: return err;
856: }
857:
858: /* Set bitrate */
859: err = __orinoco_hw_set_bitrate(priv);
860: if (err) {
861: printk(KERN_ERR "%s: Error %d setting bitrate\n", dev->name, err);
862: return err;
863: }
864:
865: /* Set power management */
866: if (priv->has_pm) {
867: err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFPMENABLED,
868: priv->pm_on);
869: if (err) {
870: printk(KERN_ERR "%s: Error %d setting up PM\n",
871: dev->name, err);
872: return err;
873: }
874:
875: err = hermes_write_wordrec(hw, USER_BAP,
876: HERMES_RID_CNFMULTICASTRECEIVE,
877: priv->pm_mcast);
878: if (err) {
879: printk(KERN_ERR "%s: Error %d setting up PM\n",
880: dev->name, err);
881: return err;
882: }
883: err = hermes_write_wordrec(hw, USER_BAP,
884: HERMES_RID_CNFMAXSLEEPDURATION,
885: priv->pm_period);
886: if (err) {
887: printk(KERN_ERR "%s: Error %d setting up PM\n",
888: dev->name, err);
889: return err;
890: }
891: err = hermes_write_wordrec(hw, USER_BAP,
892: HERMES_RID_CNFPMHOLDOVERDURATION,
893: priv->pm_timeout);
894: if (err) {
895: printk(KERN_ERR "%s: Error %d setting up PM\n",
896: dev->name, err);
897: return err;
898: }
899: }
900:
901: /* Set preamble - only for Symbol so far... */
902: if (priv->has_preamble) {
903: err = hermes_write_wordrec(hw, USER_BAP,
904: HERMES_RID_CNFPREAMBLE_SYMBOL,
905: priv->preamble);
906: if (err) {
907: printk(KERN_ERR "%s: Error %d setting preamble\n",
908: dev->name, err);
909: return err;
910: }
911: }
912:
913: /* Set up encryption */
914: if (priv->has_wep) {
915: err = __orinoco_hw_setup_wep(priv);
916: if (err) {
917: printk(KERN_ERR "%s: Error %d activating WEP\n",
918: dev->name, err);
919: return err;
920: }
921: }
922:
923: /* Set promiscuity / multicast*/
924: priv->promiscuous = 0;
925: priv->mc_count = 0;
926: __orinoco_set_multicast_list(dev); /* FIXME: what about the xmit_lock */
927:
928: return 0;
929: }
930:
931: /* xyzzy */
932: static int orinoco_reconfigure(struct net_device *dev)
933: {
934: struct orinoco_private *priv = dev->priv;
935: struct hermes *hw = &priv->hw;
936: unsigned long flags;
937: int err = 0;
938:
939: if (priv->broken_disableport) {
940: schedule_work(&priv->reset_work);
941: return 0;
942: }
943:
944: err = orinoco_lock(priv, &flags);
945: if (err)
946: return err;
947:
948:
949: err = hermes_disable_port(hw, 0);
950: if (err) {
951: printk(KERN_WARNING "%s: Unable to disable port while reconfiguring card\n",
952: dev->name);
953: priv->broken_disableport = 1;
954: goto out;
955: }
956:
957: err = __orinoco_program_rids(dev);
958: if (err) {
959: printk(KERN_WARNING "%s: Unable to reconfigure card\n",
960: dev->name);
961: goto out;
962: }
963:
964: err = hermes_enable_port(hw, 0);
965: if (err) {
966: printk(KERN_WARNING "%s: Unable to enable port while reconfiguring card\n",
967: dev->name);
968: goto out;
969: }
970:
971: out:
972: if (err) {
973: printk(KERN_WARNING "%s: Resetting instead...\n", dev->name);
974: schedule_work(&priv->reset_work);
975: err = 0;
976: }
977:
978: orinoco_unlock(priv, &flags);
979: return err;
980:
981: }
982:
983: /* This must be called from user context, without locks held - use
984: * schedule_work() */
985: static void orinoco_reset(struct net_device *dev)
986: {
987: struct orinoco_private *priv = dev->priv;
988: struct hermes *hw = &priv->hw;
989: int err;
990: unsigned long flags;
991:
992: err = orinoco_lock(priv, &flags);
993: if (err)
994: /* When the hardware becomes available again, whatever
995: * detects that is responsible for re-initializing
996: * it. So no need for anything further*/
997: return;
998:
999: netif_stop_queue(dev);
1000:
1001: /* Shut off interrupts. Depending on what state the hardware
1002: * is in, this might not work, but we'll try anyway */
1003: hermes_set_irqmask(hw, 0);
1004: hermes_write_regn(hw, EVACK, 0xffff);
1005:
1006: priv->hw_unavailable++;
1007: priv->last_linkstatus = 0xffff; /* firmware will have to reassociate */
1008: priv->connected = 0;
1009:
1010: orinoco_unlock(priv, &flags);
1011:
1012: if (priv->hard_reset)
1013: err = (*priv->hard_reset)(priv);
1014: if (err) {
1015: printk(KERN_ERR "%s: orinoco_reset: Error %d performing hard reset\n",
1016: dev->name, err);
1017: /* FIXME: shutdown of some sort */
1018: return;
1019: }
1020:
1021: err = orinoco_reinit_firmware(dev);
1022: if (err) {
1023: printk(KERN_ERR "%s: orinoco_reset: Error %d re-initializing firmware\n",
1024: dev->name, err);
1025: return;
1026: }
1027:
1028: spin_lock_irq(&priv->lock); /* This has to be called from user context */
1029:
1030: priv->hw_unavailable--;
1031:
1032: /* priv->open or priv->hw_unavailable might have changed while
1033: * we dropped the lock */
1034: if (priv->open && (! priv->hw_unavailable)) {
1035: err = __orinoco_up(dev);
1036: if (err) {
1037: printk(KERN_ERR "%s: orinoco_reset: Error %d reenabling card\n",
1038: dev->name, err);
1039: } else
1040: dev->trans_start = jiffies;
1041: }
1042:
1043: spin_unlock_irq(&priv->lock);
1044:
1045: return;
1046: }
1047:
1048: /********************************************************************/
1049: /* Internal helper functions */
1050: /********************************************************************/
1051:
1052: static inline void
1053: set_port_type(struct orinoco_private *priv)
1054: {
1055: switch (priv->iw_mode) {
1056: case IW_MODE_INFRA:
1057: priv->port_type = 1;
1058: priv->createibss = 0;
1059: break;
1060: case IW_MODE_ADHOC:
1061: if (priv->prefer_port3) {
1062: priv->port_type = 3;
1063: priv->createibss = 0;
1064: } else {
1065: priv->port_type = priv->ibss_port;
1066: priv->createibss = 1;
1067: }
1068: break;
1069: default:
1070: printk(KERN_ERR "%s: Invalid priv->iw_mode in set_port_type()\n",
1071: priv->ndev->name);
1072: }
1073: }
1074:
1075: /* Does the frame have a SNAP header indicating it should be
1076: * de-encapsulated to Ethernet-II? */
1077: static inline int
1078: is_ethersnap(struct header_struct *hdr)
1079: {
1080: /* We de-encapsulate all packets which, a) have SNAP headers
1081: * (i.e. SSAP=DSAP=0xaa and CTRL=0x3 in the 802.2 LLC header
1082: * and where b) the OUI of the SNAP header is 00:00:00 or
1083: * 00:00:f8 - we need both because different APs appear to use
1084: * different OUIs for some reason */
1085: return (memcmp(&hdr->dsap, &encaps_hdr, 5) == 0)
1086: && ( (hdr->oui[2] == 0x00) || (hdr->oui[2] == 0xf8) );
1087: }
1088:
1089: static void
1090: orinoco_set_multicast_list(struct net_device *dev)
1091: {
1092: struct orinoco_private *priv = dev->priv;
1093: unsigned long flags;
1094:
1095: if (orinoco_lock(priv, &flags) != 0) {
1096: printk(KERN_DEBUG "%s: orinoco_set_multicast_list() "
1097: "called when hw_unavailable\n", dev->name);
1098: return;
1099: }
1100:
1101: __orinoco_set_multicast_list(dev);
1102: orinoco_unlock(priv, &flags);
1103: }
1104:
1105: /********************************************************************/
1106: /* Hardware control functions */
1107: /********************************************************************/
1108:
1109:
1110: static int __orinoco_hw_set_bitrate(struct orinoco_private *priv)
1111: {
1112: hermes_t *hw = &priv->hw;
1113: int err = 0;
1114:
1115: if (priv->bitratemode >= BITRATE_TABLE_SIZE) {
1116: printk(KERN_ERR "%s: BUG: Invalid bitrate mode %d\n",
1117: priv->ndev->name, priv->bitratemode);
1118: return -EINVAL;
1119: }
1120:
1121: switch (priv->firmware_type) {
1122: case FIRMWARE_TYPE_AGERE:
1123: err = hermes_write_wordrec(hw, USER_BAP,
1124: HERMES_RID_CNFTXRATECONTROL,
1125: bitrate_table[priv->bitratemode].agere_txratectrl);
1126: break;
1127: case FIRMWARE_TYPE_INTERSIL:
1128: case FIRMWARE_TYPE_SYMBOL:
1129: err = hermes_write_wordrec(hw, USER_BAP,
1130: HERMES_RID_CNFTXRATECONTROL,
1131: bitrate_table[priv->bitratemode].intersil_txratectrl);
1132: break;
1133: default:
1134: BUG();
1135: }
1136:
1137: return err;
1138: }
1139:
1140:
1141: static int __orinoco_hw_setup_wep(struct orinoco_private *priv)
1142: {
1143: hermes_t *hw = &priv->hw;
1144: int err = 0;
1145: int master_wep_flag;
1146: int auth_flag;
1147:
1148: switch (priv->firmware_type) {
1149: case FIRMWARE_TYPE_AGERE: /* Agere style WEP */
1150: if (priv->wep_on) {
1151: err = hermes_write_wordrec(hw, USER_BAP,
1152: HERMES_RID_CNFTXKEY_AGERE,
1153: priv->tx_key);
1154: if (err)
1155: return err;
1156:
1157: err = HERMES_WRITE_RECORD(hw, USER_BAP,
1158: HERMES_RID_CNFWEPKEYS_AGERE,
1159: &priv->keys);
1160: if (err)
1161: return err;
1162: }
1163: err = hermes_write_wordrec(hw, USER_BAP,
1164: HERMES_RID_CNFWEPENABLED_AGERE,
1165: priv->wep_on);
1166: if (err)
1167: return err;
1168: break;
1169:
1170: case FIRMWARE_TYPE_INTERSIL: /* Intersil style WEP */
1171: case FIRMWARE_TYPE_SYMBOL: /* Symbol style WEP */
1172: master_wep_flag = 0; /* Off */
1173: if (priv->wep_on) {
1174: int keylen;
1175: int i;
1176:
1177: /* Fudge around firmware weirdness */
1178: keylen = le16_to_cpu(priv->keys[priv->tx_key].len);
1179:
1180: /* Write all 4 keys */
1181: for(i = 0; i < ORINOCO_MAX_KEYS; i++) {
1182: /* int keylen = le16_to_cpu(priv->keys[i].len); */
1183:
1184: if (keylen > LARGE_KEY_SIZE) {
1185: printk(KERN_ERR "%s: BUG: Key %d has oversize length %d.\n",
1186: priv->ndev->name, i, keylen);
1187: return -E2BIG;
1188: }
1189:
1190: err = hermes_write_ltv(hw, USER_BAP,
1191: HERMES_RID_CNFDEFAULTKEY0 + i,
1192: HERMES_BYTES_TO_RECLEN(keylen),
1193: priv->keys[i].data);
1194: if (err)
1195: return err;
1196: }
1197:
1198: /* Write the index of the key used in transmission */
1199: err = hermes_write_wordrec(hw, USER_BAP, HERMES_RID_CNFWEPDEFAULTKEYID,
1200: priv->tx_key);
1201: if (err)
1202: return err;
1203:
1204: if (priv->wep_restrict) {
1205: auth_flag = 2;
1206: master_wep_flag = 3;
1207: } else {
1208: /* Authentication is where Intersil and Symbol
1209: * firmware differ... */
1210: auth_flag = 1;
1211: if (priv->firmware_type == FIRMWARE_TYPE_SYMBOL)
1212: master_wep_flag = 3; /* Symbol */
1213: else
1214: master_wep_flag = 1; /* Intersil */
1215: }
1216:
1217:
1218: err = hermes_write_wordrec(hw, USER_BAP,
1219: HERMES_RID_CNFAUTHENTICATION, auth_flag);
1220: if (err)
1221: return err;
1222: }
1223:
1224: /* Master WEP setting : on/off */
1225: err = hermes_write_wordrec(hw, USER_BAP,
1226: HERMES_RID_CNFWEPFLAGS_INTERSIL,
1227: master_wep_flag);
1228: if (err)
1229: return err;
1230:
1231: break;
1232:
1233: default:
1234: if (priv->wep_on) {
1235: printk(KERN_ERR "%s: WEP enabled, although not supported!\n",
1236: priv->ndev->name);
1237: return -EINVAL;
1238: }
1239: }
1240:
1241: return 0;
1242: }
1243:
1244: static int orinoco_hw_get_bssid(struct orinoco_private *priv,
1245: char buf[ETH_ALEN])
1246: {
1247: hermes_t *hw = &priv->hw;
1248: int err = 0;
1249: unsigned long flags;
1250:
1251: err = orinoco_lock(priv, &flags);
1252: if (err)
1253: return err;
1254:
1255: err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_CURRENTBSSID,
1256: ETH_ALEN, NULL, buf);
1257:
1258: orinoco_unlock(priv, &flags);
1259:
1260: return err;
1261: }
1262:
1263: static int orinoco_hw_get_essid(struct orinoco_private *priv, int *active,
1264: char buf[IW_ESSID_MAX_SIZE+1])
1265: {
1266: hermes_t *hw = &priv->hw;
1267: int err = 0;
1268: struct hermes_idstring essidbuf;
1269: char *p = (char *)(&essidbuf.val);
1270: int len;
1271: unsigned long flags;
1272:
1273: err = orinoco_lock(priv, &flags);
1274: if (err)
1275: return err;
1276:
1277: if (strlen(priv->desired_essid) > 0) {
1278: /* We read the desired SSID from the hardware rather
1279: than from priv->desired_essid, just in case the
1280: firmware is allowed to change it on us. I'm not
1281: sure about this */
1282: /* My guess is that the OWNSSID should always be whatever
1283: * we set to the card, whereas CURRENT_SSID is the one that
1284: * may change... - Jean II */
1285: u16 rid;
1286:
1287: *active = 1;
1288:
1289: rid = (priv->port_type == 3) ? HERMES_RID_CNFOWNSSID :
1290: HERMES_RID_CNFDESIREDSSID;
1291:
1292: err = hermes_read_ltv(hw, USER_BAP, rid, sizeof(essidbuf),
1293: NULL, &essidbuf);
1294: if (err)
1295: goto fail_unlock;
1296: } else {
1297: *active = 0;
1298:
1299: err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_CURRENTSSID,
1300: sizeof(essidbuf), NULL, &essidbuf);
1301: if (err)
1302: goto fail_unlock;
1303: }
1304:
1305: len = le16_to_cpu(essidbuf.len);
1306:
1307: memset(buf, 0, IW_ESSID_MAX_SIZE+1);
1308: memcpy(buf, p, len);
1309: buf[len] = '\0';
1310:
1311: fail_unlock:
1312: orinoco_unlock(priv, &flags);
1313:
1314: return err;
1315: }
1316:
1317: static long orinoco_hw_get_freq(struct orinoco_private *priv)
1318: {
1319:
1320: hermes_t *hw = &priv->hw;
1321: int err = 0;
1322: u16 channel;
1323: long freq = 0;
1324: unsigned long flags;
1325:
1326: err = orinoco_lock(priv, &flags);
1327: if (err)
1328: return err;
1329:
1330: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CURRENTCHANNEL, &channel);
1331: if (err)
1332: goto out;
1333:
1334: /* Intersil firmware 1.3.5 returns 0 when the interface is down */
1335: if (channel == 0) {
1336: err = -EBUSY;
1337: goto out;
1338: }
1339:
1340: if ( (channel < 1) || (channel > NUM_CHANNELS) ) {
1341: printk(KERN_WARNING "%s: Channel out of range (%d)!\n",
1342: priv->ndev->name, channel);
1343: err = -EBUSY;
1344: goto out;
1345:
1346: }
1347: freq = channel_frequency[channel-1] * 100000;
1348:
1349: out:
1350: orinoco_unlock(priv, &flags);
1351:
1352: if (err > 0)
1353: err = -EBUSY;
1354: return err ? err : freq;
1355: }
1356:
1357: static int orinoco_hw_get_bitratelist(struct orinoco_private *priv,
1358: int *numrates, s32 *rates, int max)
1359: {
1360: hermes_t *hw = &priv->hw;
1361: struct hermes_idstring list;
1362: unsigned char *p = (unsigned char *)&list.val;
1363: int err = 0;
1364: int num;
1365: int i;
1366: unsigned long flags;
1367:
1368: err = orinoco_lock(priv, &flags);
1369: if (err)
1370: return err;
1371:
1372: err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_SUPPORTEDDATARATES,
1373: sizeof(list), NULL, &list);
1374: orinoco_unlock(priv, &flags);
1375:
1376: if (err)
1377: return err;
1378:
1379: num = le16_to_cpu(list.len);
1380: *numrates = num;
1381: num = min(num, max);
1382:
1383: for (i = 0; i < num; i++) {
1384: rates[i] = (p[i] & 0x7f) * 500000; /* convert to bps */
1385: }
1386:
1387: return 0;
1388: }
1389:
1390: #if 0
1391: static void show_rx_frame(struct orinoco_rxframe_hdr *frame)
1392: {
1393: printk(KERN_DEBUG "RX descriptor:\n");
1394: printk(KERN_DEBUG " status = 0x%04x\n", frame->desc.status);
1395: printk(KERN_DEBUG " time = 0x%08x\n", frame->desc.time);
1396: printk(KERN_DEBUG " silence = 0x%02x\n", frame->desc.silence);
1397: printk(KERN_DEBUG " signal = 0x%02x\n", frame->desc.signal);
1398: printk(KERN_DEBUG " rate = 0x%02x\n", frame->desc.rate);
1399: printk(KERN_DEBUG " rxflow = 0x%02x\n", frame->desc.rxflow);
1400: printk(KERN_DEBUG " reserved = 0x%08x\n", frame->desc.reserved);
1401:
1402: printk(KERN_DEBUG "IEEE 802.11 header:\n");
1403: printk(KERN_DEBUG " frame_ctl = 0x%04x\n",
1404: frame->p80211.frame_ctl);
1405: printk(KERN_DEBUG " duration_id = 0x%04x\n",
1406: frame->p80211.duration_id);
1407: printk(KERN_DEBUG " addr1 = %02x:%02x:%02x:%02x:%02x:%02x\n",
1408: frame->p80211.addr1[0], frame->p80211.addr1[1],
1409: frame->p80211.addr1[2], frame->p80211.addr1[3],
1410: frame->p80211.addr1[4], frame->p80211.addr1[5]);
1411: printk(KERN_DEBUG " addr2 = %02x:%02x:%02x:%02x:%02x:%02x\n",
1412: frame->p80211.addr2[0], frame->p80211.addr2[1],
1413: frame->p80211.addr2[2], frame->p80211.addr2[3],
1414: frame->p80211.addr2[4], frame->p80211.addr2[5]);
1415: printk(KERN_DEBUG " addr3 = %02x:%02x:%02x:%02x:%02x:%02x\n",
1416: frame->p80211.addr3[0], frame->p80211.addr3[1],
1417: frame->p80211.addr3[2], frame->p80211.addr3[3],
1418: frame->p80211.addr3[4], frame->p80211.addr3[5]);
1419: printk(KERN_DEBUG " seq_ctl = 0x%04x\n",
1420: frame->p80211.seq_ctl);
1421: printk(KERN_DEBUG " addr4 = %02x:%02x:%02x:%02x:%02x:%02x\n",
1422: frame->p80211.addr4[0], frame->p80211.addr4[1],
1423: frame->p80211.addr4[2], frame->p80211.addr4[3],
1424: frame->p80211.addr4[4], frame->p80211.addr4[5]);
1425: printk(KERN_DEBUG " data_len = 0x%04x\n",
1426: frame->p80211.data_len);
1427:
1428: printk(KERN_DEBUG "IEEE 802.3 header:\n");
1429: printk(KERN_DEBUG " dest = %02x:%02x:%02x:%02x:%02x:%02x\n",
1430: frame->p8023.h_dest[0], frame->p8023.h_dest[1],
1431: frame->p8023.h_dest[2], frame->p8023.h_dest[3],
1432: frame->p8023.h_dest[4], frame->p8023.h_dest[5]);
1433: printk(KERN_DEBUG " src = %02x:%02x:%02x:%02x:%02x:%02x\n",
1434: frame->p8023.h_source[0], frame->p8023.h_source[1],
1435: frame->p8023.h_source[2], frame->p8023.h_source[3],
1436: frame->p8023.h_source[4], frame->p8023.h_source[5]);
1437: printk(KERN_DEBUG " len = 0x%04x\n", frame->p8023.h_proto);
1438:
1439: printk(KERN_DEBUG "IEEE 802.2 LLC/SNAP header:\n");
1440: printk(KERN_DEBUG " DSAP = 0x%02x\n", frame->p8022.dsap);
1441: printk(KERN_DEBUG " SSAP = 0x%02x\n", frame->p8022.ssap);
1442: printk(KERN_DEBUG " ctrl = 0x%02x\n", frame->p8022.ctrl);
1443: printk(KERN_DEBUG " OUI = %02x:%02x:%02x\n",
1444: frame->p8022.oui[0], frame->p8022.oui[1], frame->p8022.oui[2]);
1445: printk(KERN_DEBUG " ethertype = 0x%04x\n", frame->ethertype);
1446: }
1447: #endif /* 0 */
1448:
1449: /*
1450: * Interrupt handler
1451: */
1452: irqreturn_t orinoco_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1453: {
1454: struct net_device *dev = (struct net_device *)dev_id;
1455: struct orinoco_private *priv = dev->priv;
1456: hermes_t *hw = &priv->hw;
1457: int count = MAX_IRQLOOPS_PER_IRQ;
1458: u16 evstat, events;
1459: /* These are used to detect a runaway interrupt situation */
1460: /* If we get more than MAX_IRQLOOPS_PER_JIFFY iterations in a jiffy,
1461: * we panic and shut down the hardware */
1462: static int last_irq_jiffy = 0; /* jiffies value the last time we were called */
1463: static int loops_this_jiffy = 0;
1464: unsigned long flags;
1465:
1466: if (orinoco_lock(priv, &flags) != 0) {
1467: /* If hw is unavailable - we don't know if the irq was
1468: * for us or not */
1469: return IRQ_HANDLED;
1470: }
1471:
1472: evstat = hermes_read_regn(hw, EVSTAT);
1473: events = evstat & hw->inten;
1474: if (! events) {
1475: orinoco_unlock(priv, &flags);
1476: return IRQ_NONE;
1477: }
1478:
1479: if (jiffies != last_irq_jiffy)
1480: loops_this_jiffy = 0;
1481: last_irq_jiffy = jiffies;
1482:
1483: while (events && count--) {
1484: if (++loops_this_jiffy > MAX_IRQLOOPS_PER_JIFFY) {
1485: printk(KERN_WARNING "%s: IRQ handler is looping too "
1486: "much! Resetting.\n", dev->name);
1487: /* Disable interrupts for now */
1488: hermes_set_irqmask(hw, 0);
1489: schedule_work(&priv->reset_work);
1490: break;
1491: }
1492:
1493: /* Check the card hasn't been removed */
1494: if (! hermes_present(hw)) {
1495: DEBUG(0, "orinoco_interrupt(): card removed\n");
1496: break;
1497: }
1498:
1499: if (events & HERMES_EV_TICK)
1500: __orinoco_ev_tick(dev, hw);
1501: if (events & HERMES_EV_WTERR)
1502: __orinoco_ev_wterr(dev, hw);
1503: if (events & HERMES_EV_INFDROP)
1504: __orinoco_ev_infdrop(dev, hw);
1505: if (events & HERMES_EV_INFO)
1506: __orinoco_ev_info(dev, hw);
1507: if (events & HERMES_EV_RX)
1508: __orinoco_ev_rx(dev, hw);
1509: if (events & HERMES_EV_TXEXC)
1510: __orinoco_ev_txexc(dev, hw);
1511: if (events & HERMES_EV_TX)
1512: __orinoco_ev_tx(dev, hw);
1513: if (events & HERMES_EV_ALLOC)
1514: __orinoco_ev_alloc(dev, hw);
1515:
1516: hermes_write_regn(hw, EVACK, events);
1517:
1518: evstat = hermes_read_regn(hw, EVSTAT);
1519: events = evstat & hw->inten;
1520: };
1521:
1522: orinoco_unlock(priv, &flags);
1523: return IRQ_HANDLED;
1524: }
1525:
1526: static void __orinoco_ev_tick(struct net_device *dev, hermes_t *hw)
1527: {
1528: printk(KERN_DEBUG "%s: TICK\n", dev->name);
1529: }
1530:
1531: static void __orinoco_ev_wterr(struct net_device *dev, hermes_t *hw)
1532: {
1533: /* This seems to happen a fair bit under load, but ignoring it
1534: seems to work fine...*/
1535: printk(KERN_DEBUG "%s: MAC controller error (WTERR). Ignoring.\n",
1536: dev->name);
1537: }
1538:
1539: static void __orinoco_ev_infdrop(struct net_device *dev, hermes_t *hw)
1540: {
1541: printk(KERN_WARNING "%s: Information frame lost.\n", dev->name);
1542: }
1543:
1544: static void print_linkstatus(struct net_device *dev, u16 status)
1545: {
1546: char * s;
1547:
1548: if (suppress_linkstatus)
1549: return;
1550:
1551: switch (status) {
1552: case HERMES_LINKSTATUS_NOT_CONNECTED:
1553: s = "Not Connected";
1554: break;
1555: case HERMES_LINKSTATUS_CONNECTED:
1556: s = "Connected";
1557: break;
1558: case HERMES_LINKSTATUS_DISCONNECTED:
1559: s = "Disconnected";
1560: break;
1561: case HERMES_LINKSTATUS_AP_CHANGE:
1562: s = "AP Changed";
1563: break;
1564: case HERMES_LINKSTATUS_AP_OUT_OF_RANGE:
1565: s = "AP Out of Range";
1566: break;
1567: case HERMES_LINKSTATUS_AP_IN_RANGE:
1568: s = "AP In Range";
1569: break;
1570: case HERMES_LINKSTATUS_ASSOC_FAILED:
1571: s = "Association Failed";
1572: break;
1573: default:
1574: s = "UNKNOWN";
1575: }
1576:
1577: printk(KERN_INFO "%s: New link status: %s (%04x)\n",
1578: dev->name, s, status);
1579: }
1580:
1581: static void __orinoco_ev_info(struct net_device *dev, hermes_t *hw)
1582: {
1583: struct orinoco_private *priv = dev->priv;
1584: u16 infofid;
1585: struct {
1586: u16 len;
1587: u16 type;
1588: } __attribute__ ((packed)) info;
1589: int len, type;
1590: int err;
1591:
1592: /* This is an answer to an INQUIRE command that we did earlier,
1593: * or an information "event" generated by the card
1594: * The controller return to us a pseudo frame containing
1595: * the information in question - Jean II */
1596: infofid = hermes_read_regn(hw, INFOFID);
1597:
1598: /* Read the info frame header - don't try too hard */
1599: err = hermes_bap_pread(hw, IRQ_BAP, &info, sizeof(info),
1600: infofid, 0);
1601: if (err) {
1602: printk(KERN_ERR "%s: error %d reading info frame. "
1603: "Frame dropped.\n", dev->name, err);
1604: return;
1605: }
1606:
1607: len = HERMES_RECLEN_TO_BYTES(le16_to_cpu(info.len));
1608: type = le16_to_cpu(info.type);
1609:
1610: switch (type) {
1611: case HERMES_INQ_TALLIES: {
1612: struct hermes_tallies_frame tallies;
1613: struct iw_statistics *wstats = &priv->wstats;
1614:
1615: if (len > sizeof(tallies)) {
1616: printk(KERN_WARNING "%s: Tallies frame too long (%d bytes)\n",
1617: dev->name, len);
1618: len = sizeof(tallies);
1619: }
1620:
1621: /* Read directly the data (no seek) */
1622: hermes_read_words(hw, HERMES_DATA1, (void *) &tallies,
1623: len / 2); /* FIXME: blech! */
1624:
1625: /* Increment our various counters */
1626: /* wstats->discard.nwid - no wrong BSSID stuff */
1627: wstats->discard.code +=
1628: le16_to_cpu(tallies.RxWEPUndecryptable);
1629: if (len == sizeof(tallies))
1630: wstats->discard.code +=
1631: le16_to_cpu(tallies.RxDiscards_WEPICVError) +
1632: le16_to_cpu(tallies.RxDiscards_WEPExcluded);
1633: wstats->discard.misc +=
1634: le16_to_cpu(tallies.TxDiscardsWrongSA);
1635: #if WIRELESS_EXT > 11
1636: wstats->discard.fragment +=
1637: le16_to_cpu(tallies.RxMsgInBadMsgFragments);
1638: wstats->discard.retries +=
1639: le16_to_cpu(tallies.TxRetryLimitExceeded);
1640: /* wstats->miss.beacon - no match */
1641: #endif /* WIRELESS_EXT > 11 */
1642: }
1643: break;
1644: case HERMES_INQ_LINKSTATUS: {
1645: struct hermes_linkstatus linkstatus;
1646: u16 newstatus;
1647:
1648: if (len != sizeof(linkstatus)) {
1649: printk(KERN_WARNING "%s: Unexpected size for linkstatus frame (%d bytes)\n",
1650: dev->name, len);
1651: break;
1652: }
1653:
1654: hermes_read_words(hw, HERMES_DATA1, (void *) &linkstatus,
1655: len / 2);
1656: newstatus = le16_to_cpu(linkstatus.linkstatus);
1657:
1658: if ( (newstatus == HERMES_LINKSTATUS_CONNECTED)
1659: || (newstatus == HERMES_LINKSTATUS_AP_CHANGE)
1660: || (newstatus == HERMES_LINKSTATUS_AP_IN_RANGE) )
1661: priv->connected = 1;
1662: else if ( (newstatus == HERMES_LINKSTATUS_NOT_CONNECTED)
1663: || (newstatus == HERMES_LINKSTATUS_DISCONNECTED)
1664: || (newstatus == HERMES_LINKSTATUS_AP_OUT_OF_RANGE)
1665: || (newstatus == HERMES_LINKSTATUS_ASSOC_FAILED) )
1666: priv->connected = 0;
1667:
1668: if (newstatus != priv->last_linkstatus)
1669: print_linkstatus(dev, newstatus);
1670:
1671: priv->last_linkstatus = newstatus;
1672: }
1673: break;
1674: default:
1675: printk(KERN_DEBUG "%s: Unknown information frame received (type %04x).\n",
1676: dev->name, type);
1677: /* We don't actually do anything about it */
1678: break;
1679: }
1680: }
1681:
1682: static void __orinoco_ev_rx(struct net_device *dev, hermes_t *hw)
1683: {
1684: struct orinoco_private *priv = dev->priv;
1685: struct net_device_stats *stats = &priv->stats;
1686: struct iw_statistics *wstats = &priv->wstats;
1687: struct sk_buff *skb = NULL;
1688: u16 rxfid, status;
1689: int length, data_len, data_off;
1690: char *p;
1691: struct hermes_rx_descriptor desc;
1692: struct header_struct hdr;
1693: struct ethhdr *eh;
1694: int err;
1695:
1696: rxfid = hermes_read_regn(hw, RXFID);
1697:
1698: err = hermes_bap_pread(hw, IRQ_BAP, &desc, sizeof(desc),
1699: rxfid, 0);
1700: if (err) {
1701: printk(KERN_ERR "%s: error %d reading Rx descriptor. "
1702: "Frame dropped.\n", dev->name, err);
1703: stats->rx_errors++;
1704: goto drop;
1705: }
1706:
1707: status = le16_to_cpu(desc.status);
1708:
1709: if (status & HERMES_RXSTAT_ERR) {
1710: if (status & HERMES_RXSTAT_UNDECRYPTABLE) {
1711: wstats->discard.code++;
1712: DEBUG(1, "%s: Undecryptable frame on Rx. Frame dropped.\n",
1713: dev->name);
1714: } else {
1715: stats->rx_crc_errors++;
1716: DEBUG(1, "%s: Bad CRC on Rx. Frame dropped.\n", dev->name);
1717: }
1718: stats->rx_errors++;
1719: goto drop;
1720: }
1721:
1722: /* For now we ignore the 802.11 header completely, assuming
1723: that the card's firmware has handled anything vital */
1724:
1725: err = hermes_bap_pread(hw, IRQ_BAP, &hdr, sizeof(hdr),
1726: rxfid, HERMES_802_3_OFFSET);
1727: if (err) {
1728: printk(KERN_ERR "%s: error %d reading frame header. "
1729: "Frame dropped.\n", dev->name, err);
1730: stats->rx_errors++;
1731: goto drop;
1732: }
1733:
1734: length = ntohs(hdr.len);
1735:
1736: /* Sanity checks */
1737: if (length < 3) { /* No for even an 802.2 LLC header */
1738: /* At least on Symbol firmware with PCF we get quite a
1739: lot of these legitimately - Poll frames with no
1740: data. */
1741: stats->rx_dropped++;
1742: goto drop;
1743: }
1744: if (length > IEEE802_11_DATA_LEN) {
1745: printk(KERN_WARNING "%s: Oversized frame received (%d bytes)\n",
1746: dev->name, length);
1747: stats->rx_length_errors++;
1748: stats->rx_errors++;
1749: goto drop;
1750: }
1751:
1752: /* We need space for the packet data itself, plus an ethernet
1753: header, plus 2 bytes so we can align the IP header on a
1754: 32bit boundary, plus 1 byte so we can read in odd length
1755: packets from the card, which has an IO granularity of 16
1756: bits */
1757: skb = dev_alloc_skb(length+ETH_HLEN+2+1);
1758: if (!skb) {
1759: printk(KERN_WARNING "%s: Can't allocate skb for Rx\n",
1760: dev->name);
1761: goto drop;
1762: }
1763:
1764: skb_reserve(skb, 2); /* This way the IP header is aligned */
1765:
1766: /* Handle decapsulation
1767: * In most cases, the firmware tell us about SNAP frames.
1768: * For some reason, the SNAP frames sent by LinkSys APs
1769: * are not properly recognised by most firmwares.
1770: * So, check ourselves */
1771: if(((status & HERMES_RXSTAT_MSGTYPE) == HERMES_RXSTAT_1042) ||
1772: ((status & HERMES_RXSTAT_MSGTYPE) == HERMES_RXSTAT_TUNNEL) ||
1773: is_ethersnap(&hdr)) {
1774: /* These indicate a SNAP within 802.2 LLC within
1775: 802.11 frame which we'll need to de-encapsulate to
1776: the original EthernetII frame. */
1777:
1778: if (length < ENCAPS_OVERHEAD) { /* No room for full LLC+SNAP */
1779: stats->rx_length_errors++;
1780: goto drop;
1781: }
1782:
1783: /* Remove SNAP header, reconstruct EthernetII frame */
1784: data_len = length - ENCAPS_OVERHEAD;
1785: data_off = HERMES_802_3_OFFSET + sizeof(hdr);
1786:
1787: eh = (struct ethhdr *)skb_put(skb, ETH_HLEN);
1788:
1789: memcpy(eh, &hdr, 2 * ETH_ALEN);
1790: eh->h_proto = hdr.ethertype;
1791: } else {
1792: /* All other cases indicate a genuine 802.3 frame. No
1793: decapsulation needed. We just throw the whole
1794: thing in, and hope the protocol layer can deal with
1795: it as 802.3 */
1796: data_len = length;
1797: data_off = HERMES_802_3_OFFSET;
1798: /* FIXME: we re-read from the card data we already read here */
1799: }
1800:
1801: p = skb_put(skb, data_len);
1802: err = hermes_bap_pread(hw, IRQ_BAP, p, RUP_EVEN(data_len),
1803: rxfid, data_off);
1804: if (err) {
1805: printk(KERN_ERR "%s: error %d reading frame. "
1806: "Frame dropped.\n", dev->name, err);
1807: stats->rx_errors++;
1808: goto drop;
1809: }
1810:
1811: dev->last_rx = jiffies;
1812: skb->dev = dev;
1813: skb->protocol = eth_type_trans(skb, dev);
1814: skb->ip_summed = CHECKSUM_NONE;
1815:
1816: /* Process the wireless stats if needed */
1817: orinoco_stat_gather(dev, skb, &desc);
1818:
1819: /* Pass the packet to the networking stack */
1820: netif_rx(skb);
1821: stats->rx_packets++;
1822:
1823: return;
1824:
1825: drop:
1826: stats->rx_dropped++;
1827:
1828: if (skb)
1829: dev_kfree_skb_irq(skb);
1830: return;
1831: }
1832:
1833: static void __orinoco_ev_txexc(struct net_device *dev, hermes_t *hw)
1834: {
1835: struct orinoco_private *priv = dev->priv;
1836: struct net_device_stats *stats = &priv->stats;
1837: u16 fid = hermes_read_regn(hw, TXCOMPLFID);
1838: struct hermes_tx_descriptor desc;
1839: int err = 0;
1840:
1841: if (fid == DUMMY_FID)
1842: return; /* Nothing's really happened */
1843:
1844: err = hermes_bap_pread(hw, IRQ_BAP, &desc, sizeof(desc), fid, 0);
1845: if (err) {
1846: printk(KERN_WARNING "%s: Unable to read descriptor on Tx error "
1847: "(FID=%04X error %d)\n",
1848: dev->name, fid, err);
1849: } else {
1850: DEBUG(1, "%s: Tx error, status %d\n",
1851: dev->name, le16_to_cpu(desc.status));
1852: }
1853:
1854: stats->tx_errors++;
1855:
1856: hermes_write_regn(hw, TXCOMPLFID, DUMMY_FID);
1857: }
1858:
1859: static void __orinoco_ev_tx(struct net_device *dev, hermes_t *hw)
1860: {
1861: struct orinoco_private *priv = dev->priv;
1862: struct net_device_stats *stats = &priv->stats;
1863:
1864: stats->tx_packets++;
1865:
1866: hermes_write_regn(hw, TXCOMPLFID, DUMMY_FID);
1867: }
1868:
1869: static void __orinoco_ev_alloc(struct net_device *dev, hermes_t *hw)
1870: {
1871: struct orinoco_private *priv = dev->priv;
1872:
1873: u16 fid = hermes_read_regn(hw, ALLOCFID);
1874:
1875: if (fid != priv->txfid) {
1876: if (fid != DUMMY_FID)
1877: printk(KERN_WARNING "%s: Allocate event on unexpected fid (%04X)\n",
1878: dev->name, fid);
1879: return;
1880: } else {
1881: netif_wake_queue(dev);
1882: }
1883:
1884: hermes_write_regn(hw, ALLOCFID, DUMMY_FID);
1885: }
1886:
1887: struct sta_id {
1888: u16 id, variant, major, minor;
1889: } __attribute__ ((packed));
1890:
1891: static int determine_firmware_type(struct net_device *dev, struct sta_id *sta_id)
1892: {
1893: /* FIXME: this is fundamentally broken */
1894: unsigned int firmver = ((u32)sta_id->major << 16) | sta_id->minor;
1895:
1896: if (sta_id->variant == 1)
1897: return FIRMWARE_TYPE_AGERE;
1898: else if ((sta_id->variant == 2) &&
1899: ((firmver == 0x10001) || (firmver == 0x20001)))
1900: return FIRMWARE_TYPE_SYMBOL;
1901: else
1902: return FIRMWARE_TYPE_INTERSIL;
1903: }
1904:
1905: static void determine_firmware(struct net_device *dev)
1906: {
1907: struct orinoco_private *priv = dev->priv;
1908: hermes_t *hw = &priv->hw;
1909: int err;
1910: struct sta_id sta_id;
1911: unsigned int firmver;
1912: char tmp[SYMBOL_MAX_VER_LEN+1];
1913:
1914: /* Get the firmware version */
1915: err = HERMES_READ_RECORD(hw, USER_BAP, HERMES_RID_STAID, &sta_id);
1916: if (err) {
1917: printk(KERN_WARNING "%s: Error %d reading firmware info. Wildly guessing capabilities...\n",
1918: dev->name, err);
1919: memset(&sta_id, 0, sizeof(sta_id));
1920: }
1921: le16_to_cpus(&sta_id.id);
1922: le16_to_cpus(&sta_id.variant);
1923: le16_to_cpus(&sta_id.major);
1924: le16_to_cpus(&sta_id.minor);
1925:
1926: printk(KERN_DEBUG "%s: Station identity %04x:%04x:%04x:%04x\n",
1927: dev->name, sta_id.id, sta_id.variant,
1928: sta_id.major, sta_id.minor);
1929:
1930: if (! priv->firmware_type)
1931: priv->firmware_type = determine_firmware_type(dev, &sta_id);
1932:
1933: /* Default capabilities */
1934: priv->has_sensitivity = 1;
1935: priv->has_mwo = 0;
1936: priv->has_preamble = 0;
1937: priv->has_port3 = 1;
1938: priv->has_ibss = 1;
1939: priv->has_ibss_any = 0;
1940: priv->has_wep = 0;
1941: priv->has_big_wep = 0;
1942:
1943: /* Determine capabilities from the firmware version */
1944: switch (priv->firmware_type) {
1945: case FIRMWARE_TYPE_AGERE:
1946: /* Lucent Wavelan IEEE, Lucent Orinoco, Cabletron RoamAbout,
1947: ELSA, Melco, HP, IBM, Dell 1150, Compaq 110/210 */
1948: printk(KERN_DEBUG "%s: Looks like a Lucent/Agere firmware "
1949: "version %d.%02d\n", dev->name,
1950: sta_id.major, sta_id.minor);
1951:
1952: firmver = ((unsigned long)sta_id.major << 16) | sta_id.minor;
1953:
1954: priv->has_ibss = (firmver >= 0x60006);
1955: priv->has_ibss_any = (firmver >= 0x60010);
1956: priv->has_wep = (firmver >= 0x40020);
1957: priv->has_big_wep = 1; /* FIXME: this is wrong - how do we tell
1958: Gold cards from the others? */
1959: priv->has_mwo = (firmver >= 0x60000);
1960: priv->has_pm = (firmver >= 0x40020); /* Don't work in 7.52 ? */
1961: priv->ibss_port = 1;
1962:
1963: /* Tested with Agere firmware :
1964: * 1.16 ; 4.08 ; 4.52 ; 6.04 ; 6.16 ; 7.28 => Jean II
1965: * Tested CableTron firmware : 4.32 => Anton */
1966: break;
1967: case FIRMWARE_TYPE_SYMBOL:
1968: /* Symbol , 3Com AirConnect, Intel, Ericsson WLAN */
1969: /* Intel MAC : 00:02:B3:* */
1970: /* 3Com MAC : 00:50:DA:* */
1971: memset(tmp, 0, sizeof(tmp));
1972: /* Get the Symbol firmware version */
1973: err = hermes_read_ltv(hw, USER_BAP,
1974: HERMES_RID_SECONDARYVERSION_SYMBOL,
1975: SYMBOL_MAX_VER_LEN, NULL, &tmp);
1976: if (err) {
1977: printk(KERN_WARNING
1978: "%s: Error %d reading Symbol firmware info. Wildly guessing capabilities...\n",
1979: dev->name, err);
1980: firmver = 0;
1981: tmp[0] = '\0';
1982: } else {
1983: /* The firmware revision is a string, the format is
1984: * something like : "V2.20-01".
1985: * Quick and dirty parsing... - Jean II
1986: */
1987: firmver = ((tmp[1] - '0') << 16) | ((tmp[3] - '0') << 12)
1988: | ((tmp[4] - '0') << 8) | ((tmp[6] - '0') << 4)
1989: | (tmp[7] - '0');
1990:
1991: tmp[SYMBOL_MAX_VER_LEN] = '\0';
1992: }
1993:
1994: printk(KERN_DEBUG "%s: Looks like a Symbol firmware "
1995: "version [%s] (parsing to %X)\n", dev->name,
1996: tmp, firmver);
1997:
1998: priv->has_ibss = (firmver >= 0x20000);
1999: priv->has_wep = (firmver >= 0x15012);
2000: priv->has_big_wep = (firmver >= 0x20000);
2001: priv->has_pm = (firmver >= 0x20000) && (firmver < 0x22000);
2002: priv->has_preamble = (firmver >= 0x20000);
2003: priv->ibss_port = 4;
2004: /* Tested with Intel firmware : 0x20015 => Jean II */
2005: /* Tested with 3Com firmware : 0x15012 & 0x22001 => Jean II */
2006: break;
2007: case FIRMWARE_TYPE_INTERSIL:
2008: /* D-Link, Linksys, Adtron, ZoomAir, and many others...
2009: * Samsung, Compaq 100/200 and Proxim are slightly
2010: * different and less well tested */
2011: /* D-Link MAC : 00:40:05:* */
2012: /* Addtron MAC : 00:90:D1:* */
2013: printk(KERN_DEBUG "%s: Looks like an Intersil firmware "
2014: "version %d.%d.%d\n", dev->name,
2015: sta_id.major, sta_id.minor, sta_id.variant);
2016:
2017: firmver = ((unsigned long)sta_id.major << 16) |
2018: ((unsigned long)sta_id.minor << 8) | sta_id.variant;
2019:
2020: priv->has_ibss = (firmver >= 0x000700); /* FIXME */
2021: priv->has_big_wep = priv->has_wep = (firmver >= 0x000800);
2022: priv->has_pm = (firmver >= 0x000700);
2023:
2024: if (firmver >= 0x000800)
2025: priv->ibss_port = 0;
2026: else {
2027: printk(KERN_NOTICE "%s: Intersil firmware earlier "
2028: "than v0.8.x - several features not supported\n",
2029: dev->name);
2030: priv->ibss_port = 1;
2031: }
2032: break;
2033: default:
2034: break;
2035: }
2036: }
2037:
2038: /*
2039: * struct net_device methods
2040: */
2041:
2042: static int
2043: orinoco_init(struct net_device *dev)
2044: {
2045: struct orinoco_private *priv = dev->priv;
2046: hermes_t *hw = &priv->hw;
2047: int err = 0;
2048: struct hermes_idstring nickbuf;
2049: u16 reclen;
2050: int len;
2051:
2052: TRACE_ENTER(dev->name);
2053:
2054: /* No need to lock, the hw_unavailable flag is already set in
2055: * alloc_orinocodev() */
2056: priv->nicbuf_size = IEEE802_11_FRAME_LEN + ETH_HLEN;
2057:
2058: /* Initialize the firmware */
2059: err = hermes_init(hw);
2060: if (err != 0) {
2061: printk(KERN_ERR "%s: failed to initialize firmware (err = %d)\n",
2062: dev->name, err);
2063: goto out;
2064: }
2065:
2066: determine_firmware(dev);
2067:
2068: if (priv->has_port3)
2069: printk(KERN_DEBUG "%s: Ad-hoc demo mode supported\n", dev->name);
2070: if (priv->has_ibss)
2071: printk(KERN_DEBUG "%s: IEEE standard IBSS ad-hoc mode supported\n",
2072: dev->name);
2073: if (priv->has_wep) {
2074: printk(KERN_DEBUG "%s: WEP supported, ", dev->name);
2075: if (priv->has_big_wep)
2076: printk("104-bit key\n");
2077: else
2078: printk("40-bit key\n");
2079: }
2080:
2081: /* Get the MAC address */
2082: err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_CNFOWNMACADDR,
2083: ETH_ALEN, NULL, dev->dev_addr);
2084: if (err) {
2085: printk(KERN_WARNING "%s: failed to read MAC address!\n",
2086: dev->name);
2087: goto out;
2088: }
2089:
2090: printk(KERN_DEBUG "%s: MAC address %02X:%02X:%02X:%02X:%02X:%02X\n",
2091: dev->name, dev->dev_addr[0], dev->dev_addr[1],
2092: dev->dev_addr[2], dev->dev_addr[3], dev->dev_addr[4],
2093: dev->dev_addr[5]);
2094:
2095: /* Get the station name */
2096: err = hermes_read_ltv(hw, USER_BAP, HERMES_RID_CNFOWNNAME,
2097: sizeof(nickbuf), &reclen, &nickbuf);
2098: if (err) {
2099: printk(KERN_ERR "%s: failed to read station name\n",
2100: dev->name);
2101: goto out;
2102: }
2103: if (nickbuf.len)
2104: len = min(IW_ESSID_MAX_SIZE, (int)le16_to_cpu(nickbuf.len));
2105: else
2106: len = min(IW_ESSID_MAX_SIZE, 2 * reclen);
2107: memcpy(priv->nick, &nickbuf.val, len);
2108: priv->nick[len] = '\0';
2109:
2110: printk(KERN_DEBUG "%s: Station name \"%s\"\n", dev->name, priv->nick);
2111:
2112: /* Get allowed channels */
2113: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CHANNELLIST,
2114: &priv->channel_mask);
2115: if (err) {
2116: printk(KERN_ERR "%s: failed to read channel list!\n",
2117: dev->name);
2118: goto out;
2119: }
2120:
2121: /* Get initial AP density */
2122: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFSYSTEMSCALE,
2123: &priv->ap_density);
2124: if (err || priv->ap_density < 1 || priv->ap_density > 3) {
2125: priv->has_sensitivity = 0;
2126: }
2127:
2128: /* Get initial RTS threshold */
2129: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFRTSTHRESHOLD,
2130: &priv->rts_thresh);
2131: if (err) {
2132: printk(KERN_ERR "%s: failed to read RTS threshold!\n", dev->name);
2133: goto out;
2134: }
2135:
2136: /* Get initial fragmentation settings */
2137: if (priv->has_mwo)
2138: err = hermes_read_wordrec(hw, USER_BAP,
2139: HERMES_RID_CNFMWOROBUST_AGERE,
2140: &priv->mwo_robust);
2141: else
2142: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFFRAGMENTATIONTHRESHOLD,
2143: &priv->frag_thresh);
2144: if (err) {
2145: printk(KERN_ERR "%s: failed to read fragmentation settings!\n", dev->name);
2146: goto out;
2147: }
2148:
2149: /* Power management setup */
2150: if (priv->has_pm) {
2151: priv->pm_on = 0;
2152: priv->pm_mcast = 1;
2153: err = hermes_read_wordrec(hw, USER_BAP,
2154: HERMES_RID_CNFMAXSLEEPDURATION,
2155: &priv->pm_period);
2156: if (err) {
2157: printk(KERN_ERR "%s: failed to read power management period!\n",
2158: dev->name);
2159: goto out;
2160: }
2161: err = hermes_read_wordrec(hw, USER_BAP,
2162: HERMES_RID_CNFPMHOLDOVERDURATION,
2163: &priv->pm_timeout);
2164: if (err) {
2165: printk(KERN_ERR "%s: failed to read power management timeout!\n",
2166: dev->name);
2167: goto out;
2168: }
2169: }
2170:
2171: /* Preamble setup */
2172: if (priv->has_preamble) {
2173: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFPREAMBLE_SYMBOL,
2174: &priv->preamble);
2175: if (err)
2176: goto out;
2177: }
2178:
2179: /* Set up the default configuration */
2180: priv->iw_mode = IW_MODE_INFRA;
2181: /* By default use IEEE/IBSS ad-hoc mode if we have it */
2182: priv->prefer_port3 = priv->has_port3 && (! priv->has_ibss);
2183: set_port_type(priv);
2184: priv->channel = 10; /* default channel, more-or-less arbitrary */
2185:
2186: priv->promiscuous = 0;
2187: priv->wep_on = 0;
2188: priv->tx_key = 0;
2189:
2190: err = hermes_allocate(hw, priv->nicbuf_size, &priv->txfid);
2191: if (err == -EIO) {
2192: /* Try workaround for old Symbol firmware bug */
2193: printk(KERN_WARNING "%s: firmware ALLOC bug detected "
2194: "(old Symbol firmware?). Trying to work around... ",
2195: dev->name);
2196:
2197: priv->nicbuf_size = TX_NICBUF_SIZE_BUG;
2198: err = hermes_allocate(hw, priv->nicbuf_size, &priv->txfid);
2199: if (err)
2200: printk("failed!\n");
2201: else
2202: printk("ok.\n");
2203: }
2204: if (err) {
2205: printk("%s: Error %d allocating Tx buffer\n", dev->name, err);
2206: goto out;
2207: }
2208:
2209: /* Make the hardware available, as long as it hasn't been
2210: * removed elsewhere (e.g. by PCMCIA hot unplug) */
2211: spin_lock_irq(&priv->lock);
2212: priv->hw_unavailable--;
2213: spin_unlock_irq(&priv->lock);
2214:
2215: printk(KERN_DEBUG "%s: ready\n", dev->name);
2216:
2217: out:
2218: TRACE_EXIT(dev->name);
2219: return err;
2220: }
2221:
2222: struct net_device_stats *
2223: orinoco_get_stats(struct net_device *dev)
2224: {
2225: struct orinoco_private *priv = dev->priv;
2226:
2227: return &priv->stats;
2228: }
2229:
2230: struct iw_statistics *
2231: orinoco_get_wireless_stats(struct net_device *dev)
2232: {
2233: struct orinoco_private *priv = dev->priv;
2234: hermes_t *hw = &priv->hw;
2235: struct iw_statistics *wstats = &priv->wstats;
2236: int err = 0;
2237: unsigned long flags;
2238:
2239: if (! netif_device_present(dev)) {
2240: printk(KERN_WARNING "%s: get_wireless_stats() called while device not present\n",
2241: dev->name);
2242: return NULL; /* FIXME: Can we do better than this? */
2243: }
2244:
2245: err = orinoco_lock(priv, &flags);
2246: if (err)
2247: return NULL; /* FIXME: Erg, we've been signalled, how
2248: * do we propagate this back up? */
2249:
2250: if (priv->iw_mode == IW_MODE_ADHOC) {
2251: memset(&wstats->qual, 0, sizeof(wstats->qual));
2252: /* If a spy address is defined, we report stats of the
2253: * first spy address - Jean II */
2254: if (SPY_NUMBER(priv)) {
2255: wstats->qual.qual = priv->spy_stat[0].qual;
2256: wstats->qual.level = priv->spy_stat[0].level;
2257: wstats->qual.noise = priv->spy_stat[0].noise;
2258: wstats->qual.updated = priv->spy_stat[0].updated;
2259: }
2260: } else {
2261: struct {
2262: u16 qual, signal, noise;
2263: } __attribute__ ((packed)) cq;
2264:
2265: err = HERMES_READ_RECORD(hw, USER_BAP,
2266: HERMES_RID_COMMSQUALITY, &cq);
2267:
2268: wstats->qual.qual = (int)le16_to_cpu(cq.qual);
2269: wstats->qual.level = (int)le16_to_cpu(cq.signal) - 0x95;
2270: wstats->qual.noise = (int)le16_to_cpu(cq.noise) - 0x95;
2271: wstats->qual.updated = 7;
2272: }
2273:
2274: /* We can't really wait for the tallies inquiry command to
2275: * complete, so we just use the previous results and trigger
2276: * a new tallies inquiry command for next time - Jean II */
2277: /* FIXME: We're in user context (I think?), so we should just
2278: wait for the tallies to come through */
2279: err = hermes_inquire(hw, HERMES_INQ_TALLIES);
2280:
2281: orinoco_unlock(priv, &flags);
2282:
2283: if (err)
2284: return NULL;
2285:
2286: return wstats;
2287: }
2288:
2289: static inline void orinoco_spy_gather(struct net_device *dev, u_char *mac,
2290: int level, int noise)
2291: {
2292: struct orinoco_private *priv = (struct orinoco_private *)dev->priv;
2293: int i;
2294:
2295: /* Gather wireless spy statistics: for each packet, compare the
2296: * source address with out list, and if match, get the stats... */
2297: for (i = 0; i < priv->spy_number; i++)
2298: if (!memcmp(mac, priv->spy_address[i], ETH_ALEN)) {
2299: priv->spy_stat[i].level = level - 0x95;
2300: priv->spy_stat[i].noise = noise - 0x95;
2301: priv->spy_stat[i].qual = (level > noise) ? (level - noise) : 0;
2302: priv->spy_stat[i].updated = 7;
2303: }
2304: }
2305:
2306: void
2307: orinoco_stat_gather(struct net_device *dev,
2308: struct sk_buff *skb,
2309: struct hermes_rx_descriptor *desc)
2310: {
2311: struct orinoco_private *priv = (struct orinoco_private *)dev->priv;
2312:
2313: /* Using spy support with lots of Rx packets, like in an
2314: * infrastructure (AP), will really slow down everything, because
2315: * the MAC address must be compared to each entry of the spy list.
2316: * If the user really asks for it (set some address in the
2317: * spy list), we do it, but he will pay the price.
2318: * Note that to get here, you need both WIRELESS_SPY
2319: * compiled in AND some addresses in the list !!!
2320: */
2321: /* Note : gcc will optimise the whole section away if
2322: * WIRELESS_SPY is not defined... - Jean II */
2323: if (SPY_NUMBER(priv)) {
2324: orinoco_spy_gather(dev, skb->mac.raw + ETH_ALEN,
2325: desc->signal, desc->silence);
2326: }
2327: }
2328:
2329: static int
2330: orinoco_xmit(struct sk_buff *skb, struct net_device *dev)
2331: {
2332: struct orinoco_private *priv = (struct orinoco_private *)dev->priv;
2333: struct net_device_stats *stats = &priv->stats;
2334: hermes_t *hw = &priv->hw;
2335: int err = 0;
2336: u16 txfid = priv->txfid;
2337: char *p;
2338: struct ethhdr *eh;
2339: int len, data_len, data_off;
2340: struct hermes_tx_descriptor desc;
2341: unsigned long flags;
2342:
2343: TRACE_ENTER(dev->name);
2344:
2345: if (! netif_running(dev)) {
2346: printk(KERN_ERR "%s: Tx on stopped device!\n",
2347: dev->name);
2348: TRACE_EXIT(dev->name);
2349: return 1;
2350: }
2351:
2352: if (netif_queue_stopped(dev)) {
2353: printk(KERN_DEBUG "%s: Tx while transmitter busy!\n",
2354: dev->name);
2355: TRACE_EXIT(dev->name);
2356: return 1;
2357: }
2358:
2359: if (orinoco_lock(priv, &flags) != 0) {
2360: printk(KERN_ERR "%s: orinoco_xmit() called while hw_unavailable\n",
2361: dev->name);
2362: TRACE_EXIT(dev->name);
2363: /* BUG(); */
2364: return 1;
2365: }
2366:
2367: if (! priv->connected) {
2368: /* Oops, the firmware hasn't established a connection,
2369: silently drop the packet (this seems to be the
2370: safest approach). */
2371: stats->tx_errors++;
2372: orinoco_unlock(priv, &flags);
2373: dev_kfree_skb(skb, FREE_WRITE);
2374: TRACE_EXIT(dev->name);
2375: return 0;
2376: }
2377:
2378: /* Length of the packet body */
2379: /* FIXME: what if the skb is smaller than this? */
2380: len = max_t(int,skb->len - ETH_HLEN, ETH_ZLEN - ETH_HLEN);
2381:
2382: eh = (struct ethhdr *)skb->data;
2383:
2384: memset(&desc, 0, sizeof(desc));
2385: desc.tx_control = cpu_to_le16(HERMES_TXCTRL_TX_OK | HERMES_TXCTRL_TX_EX);
2386: err = hermes_bap_pwrite(hw, USER_BAP, &desc, sizeof(desc), txfid, 0);
2387: if (err) {
2388: printk(KERN_ERR "%s: Error %d writing Tx descriptor to BAP\n",
2389: dev->name, err);
2390: stats->tx_errors++;
2391: goto fail;
2392: }
2393:
2394: /* Clear the 802.11 header and data length fields - some
2395: * firmwares (e.g. Lucent/Agere 8.xx) appear to get confused
2396: * if this isn't done. */
2397: hermes_clear_words(hw, HERMES_DATA0,
2398: HERMES_802_3_OFFSET - HERMES_802_11_OFFSET);
2399:
2400: /* Encapsulate Ethernet-II frames */
2401: if (ntohs(eh->h_proto) > 1500) { /* Ethernet-II frame */
2402: struct header_struct hdr;
2403: data_len = len;
2404: data_off = HERMES_802_3_OFFSET + sizeof(hdr);
2405: p = skb->data + ETH_HLEN;
2406:
2407: /* 802.3 header */
2408: memcpy(hdr.dest, eh->h_dest, ETH_ALEN);
2409: memcpy(hdr.src, eh->h_source, ETH_ALEN);
2410: hdr.len = htons(data_len + ENCAPS_OVERHEAD);
2411:
2412: /* 802.2 header */
2413: memcpy(&hdr.dsap, &encaps_hdr, sizeof(encaps_hdr));
2414:
2415: hdr.ethertype = eh->h_proto;
2416: err = hermes_bap_pwrite(hw, USER_BAP, &hdr, sizeof(hdr),
2417: txfid, HERMES_802_3_OFFSET);
2418: if (err) {
2419: printk(KERN_ERR "%s: Error %d writing packet header to BAP\n",
2420: dev->name, err);
2421: stats->tx_errors++;
2422: goto fail;
2423: }
2424: } else { /* IEEE 802.3 frame */
2425: data_len = len + ETH_HLEN;
2426: data_off = HERMES_802_3_OFFSET;
2427: p = skb->data;
2428: }
2429:
2430: /* Round up for odd length packets */
2431: err = hermes_bap_pwrite(hw, USER_BAP, p, RUP_EVEN(data_len), txfid, data_off);
2432: if (err) {
2433: printk(KERN_ERR "%s: Error %d writing packet to BAP\n",
2434: dev->name, err);
2435: stats->tx_errors++;
2436: goto fail;
2437: }
2438:
2439: /* Finally, we actually initiate the send */
2440: netif_stop_queue(dev);
2441:
2442: err = hermes_docmd_wait(hw, HERMES_CMD_TX | HERMES_CMD_RECL, txfid, NULL);
2443: if (err) {
2444: netif_start_queue(dev);
2445: printk(KERN_ERR "%s: Error %d transmitting packet\n", dev->name, err);
2446: stats->tx_errors++;
2447: goto fail;
2448: }
2449:
2450: dev->trans_start = jiffies;
2451:
2452: orinoco_unlock(priv, &flags);
2453:
2454: DEV_KFREE_SKB(skb);
2455:
2456: TRACE_EXIT(dev->name);
2457:
2458: return 0;
2459: fail:
2460: TRACE_EXIT(dev->name);
2461:
2462: orinoco_unlock(priv, &flags);
2463: return err;
2464: }
2465:
2466: #ifdef HAVE_TX_TIMEOUT
2467: static void
2468: orinoco_tx_timeout(struct net_device *dev)
2469: {
2470: struct orinoco_private *priv = (struct orinoco_private *)dev->priv;
2471: struct net_device_stats *stats = &priv->stats;
2472: struct hermes *hw = &priv->hw;
2473:
2474: printk(KERN_WARNING "%s: Tx timeout! "
2475: "ALLOCFID=%04x, TXCOMPLFID=%04x, EVSTAT=%04x\n",
2476: dev->name, hermes_read_regn(hw, ALLOCFID),
2477: hermes_read_regn(hw, TXCOMPLFID), hermes_read_regn(hw, EVSTAT));
2478:
2479: stats->tx_errors++;
2480:
2481: schedule_work(&priv->reset_work);
2482: }
2483: #endif
2484:
2485: static int
2486: orinoco_change_mtu(struct net_device *dev, int new_mtu)
2487: {
2488: struct orinoco_private *priv = dev->priv;
2489:
2490: if ( (new_mtu < ORINOCO_MIN_MTU) || (new_mtu > ORINOCO_MAX_MTU) )
2491: return -EINVAL;
2492:
2493: if ( (new_mtu + ENCAPS_OVERHEAD + IEEE802_11_HLEN) >
2494: (priv->nicbuf_size - ETH_HLEN) )
2495: return -EINVAL;
2496:
2497: dev->mtu = new_mtu;
2498:
2499: return 0;
2500: }
2501:
2502: /* FIXME: return int? */
2503: static void
2504: __orinoco_set_multicast_list(struct net_device *dev)
2505: {
2506: struct orinoco_private *priv = dev->priv;
2507: hermes_t *hw = &priv->hw;
2508: int err = 0;
2509: int promisc, mc_count;
2510:
2511: /* The Hermes doesn't seem to have an allmulti mode, so we go
2512: * into promiscuous mode and let the upper levels deal. */
2513: if ( (dev->flags & IFF_PROMISC) || (dev->flags & IFF_ALLMULTI) ||
2514: (dev->mc_count > MAX_MULTICAST(priv)) ) {
2515: promisc = 1;
2516: mc_count = 0;
2517: } else {
2518: promisc = 0;
2519: mc_count = dev->mc_count;
2520: }
2521:
2522: if (promisc != priv->promiscuous) {
2523: err = hermes_write_wordrec(hw, USER_BAP,
2524: HERMES_RID_CNFPROMISCUOUSMODE,
2525: promisc);
2526: if (err) {
2527: printk(KERN_ERR "%s: Error %d setting PROMISCUOUSMODE to 1.\n",
2528: dev->name, err);
2529: } else
2530: priv->promiscuous = promisc;
2531: }
2532:
2533: if (! promisc && (mc_count || priv->mc_count) ) {
2534: struct dev_mc_list *p = dev->mc_list;
2535: hermes_multicast_t mclist;
2536: int i;
2537:
2538: for (i = 0; i < mc_count; i++) {
2539: /* Paranoia: */
2540: if (! p)
2541: BUG(); /* Multicast list shorter than mc_count */
2542: if (p->dmi_addrlen != ETH_ALEN)
2543: BUG(); /* Bad address size in multicast list */
2544:
2545: memcpy(mclist.addr[i], p->dmi_addr, ETH_ALEN);
2546: p = p->next;
2547: }
2548:
2549: if (p)
2550: printk(KERN_WARNING "Multicast list is longer than mc_count\n");
2551:
2552: err = hermes_write_ltv(hw, USER_BAP, HERMES_RID_CNFGROUPADDRESSES,
2553: HERMES_BYTES_TO_RECLEN(priv->mc_count * ETH_ALEN),
2554: &mclist);
2555: if (err)
2556: printk(KERN_ERR "%s: Error %d setting multicast list.\n",
2557: dev->name, err);
2558: else
2559: priv->mc_count = mc_count;
2560: }
2561:
2562: /* Since we can set the promiscuous flag when it wasn't asked
2563: for, make sure the net_device knows about it. */
2564: if (priv->promiscuous)
2565: dev->flags |= IFF_PROMISC;
2566: else
2567: dev->flags &= ~IFF_PROMISC;
2568: }
2569:
2570: /********************************************************************/
2571: /* Wireless extensions support */
2572: /********************************************************************/
2573:
2574: static int orinoco_ioctl_getiwrange(struct net_device *dev, struct iw_point *rrq)
2575: {
2576: struct orinoco_private *priv = dev->priv;
2577: int err = 0;
2578: int mode;
2579: struct iw_range range;
2580: int numrates;
2581: int i, k;
2582: unsigned long flags;
2583:
2584: TRACE_ENTER(dev->name);
2585:
2586: err = verify_area(VERIFY_WRITE, rrq->pointer, sizeof(range));
2587: if (err)
2588: return err;
2589:
2590: rrq->length = sizeof(range);
2591:
2592: err = orinoco_lock(priv, &flags);
2593: if (err)
2594: return err;
2595:
2596: mode = priv->iw_mode;
2597: orinoco_unlock(priv, &flags);
2598:
2599: memset(&range, 0, sizeof(range));
2600:
2601: /* Much of this shamelessly taken from wvlan_cs.c. No idea
2602: * what it all means -dgibson */
2603: #if WIRELESS_EXT > 10
2604: range.we_version_compiled = WIRELESS_EXT;
2605: range.we_version_source = 11;
2606: #endif /* WIRELESS_EXT > 10 */
2607:
2608: range.min_nwid = range.max_nwid = 0; /* We don't use nwids */
2609:
2610: /* Set available channels/frequencies */
2611: range.num_channels = NUM_CHANNELS;
2612: k = 0;
2613: for (i = 0; i < NUM_CHANNELS; i++) {
2614: if (priv->channel_mask & (1 << i)) {
2615: range.freq[k].i = i + 1;
2616: range.freq[k].m = channel_frequency[i] * 100000;
2617: range.freq[k].e = 1;
2618: k++;
2619: }
2620:
2621: if (k >= IW_MAX_FREQUENCIES)
2622: break;
2623: }
2624: range.num_frequency = k;
2625:
2626: range.sensitivity = 3;
2627:
2628: if ((mode == IW_MODE_ADHOC) && (priv->spy_number == 0)){
2629: /* Quality stats meaningless in ad-hoc mode */
2630: range.max_qual.qual = 0;
2631: range.max_qual.level = 0;
2632: range.max_qual.noise = 0;
2633: #if WIRELESS_EXT > 11
2634: range.avg_qual.qual = 0;
2635: range.avg_qual.level = 0;
2636: range.avg_qual.noise = 0;
2637: #endif /* WIRELESS_EXT > 11 */
2638:
2639: } else {
2640: range.max_qual.qual = 0x8b - 0x2f;
2641: range.max_qual.level = 0x2f - 0x95 - 1;
2642: range.max_qual.noise = 0x2f - 0x95 - 1;
2643: #if WIRELESS_EXT > 11
2644: /* Need to get better values */
2645: range.avg_qual.qual = 0x24;
2646: range.avg_qual.level = 0xC2;
2647: range.avg_qual.noise = 0x9E;
2648: #endif /* WIRELESS_EXT > 11 */
2649: }
2650:
2651: err = orinoco_hw_get_bitratelist(priv, &numrates,
2652: range.bitrate, IW_MAX_BITRATES);
2653: if (err)
2654: return err;
2655: range.num_bitrates = numrates;
2656:
2657: /* Set an indication of the max TCP throughput in bit/s that we can
2658: * expect using this interface. May be use for QoS stuff...
2659: * Jean II */
2660: if(numrates > 2)
2661: range.throughput = 5 * 1000 * 1000; /* ~5 Mb/s */
2662: else
2663: range.throughput = 1.5 * 1000 * 1000; /* ~1.5 Mb/s */
2664:
2665: range.min_rts = 0;
2666: range.max_rts = 2347;
2667: range.min_frag = 256;
2668: range.max_frag = 2346;
2669:
2670: err = orinoco_lock(priv, &flags);
2671: if (err)
2672: return err;
2673: if (priv->has_wep) {
2674: range.max_encoding_tokens = ORINOCO_MAX_KEYS;
2675:
2676: range.encoding_size[0] = SMALL_KEY_SIZE;
2677: range.num_encoding_sizes = 1;
2678:
2679: if (priv->has_big_wep) {
2680: range.encoding_size[1] = LARGE_KEY_SIZE;
2681: range.num_encoding_sizes = 2;
2682: }
2683: } else {
2684: range.num_encoding_sizes = 0;
2685: range.max_encoding_tokens = 0;
2686: }
2687: orinoco_unlock(priv, &flags);
2688:
2689: range.min_pmp = 0;
2690: range.max_pmp = 65535000;
2691: range.min_pmt = 0;
2692: range.max_pmt = 65535 * 1000; /* ??? */
2693: range.pmp_flags = IW_POWER_PERIOD;
2694: range.pmt_flags = IW_POWER_TIMEOUT;
2695: range.pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_UNICAST_R;
2696:
2697: range.num_txpower = 1;
2698: range.txpower[0] = 15; /* 15dBm */
2699: range.txpower_capa = IW_TXPOW_DBM;
2700:
2701: #if WIRELESS_EXT > 10
2702: range.retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
2703: range.retry_flags = IW_RETRY_LIMIT;
2704: range.r_time_flags = IW_RETRY_LIFETIME;
2705: range.min_retry = 0;
2706: range.max_retry = 65535; /* ??? */
2707: range.min_r_time = 0;
2708: range.max_r_time = 65535 * 1000; /* ??? */
2709: #endif /* WIRELESS_EXT > 10 */
2710:
2711: if (copy_to_user(rrq->pointer, &range, sizeof(range)))
2712: return -EFAULT;
2713:
2714: TRACE_EXIT(dev->name);
2715:
2716: return 0;
2717: }
2718:
2719: static int orinoco_ioctl_setiwencode(struct net_device *dev, struct iw_point *erq)
2720: {
2721: struct orinoco_private *priv = dev->priv;
2722: int index = (erq->flags & IW_ENCODE_INDEX) - 1;
2723: int setindex = priv->tx_key;
2724: int enable = priv->wep_on;
2725: int restricted = priv->wep_restrict;
2726: u16 xlen = 0;
2727: int err = 0;
2728: char keybuf[ORINOCO_MAX_KEY_SIZE];
2729: unsigned long flags;
2730:
2731: if (erq->pointer) {
2732: /* We actually have a key to set */
2733: if ( (erq->length < SMALL_KEY_SIZE) || (erq->length > ORINOCO_MAX_KEY_SIZE) )
2734: return -EINVAL;
2735:
2736: if (copy_from_user(keybuf, erq->pointer, erq->length))
2737: return -EFAULT;
2738: }
2739:
2740: err = orinoco_lock(priv, &flags);
2741: if (err)
2742: return err;
2743:
2744: if (erq->pointer) {
2745: if (erq->length > ORINOCO_MAX_KEY_SIZE) {
2746: err = -E2BIG;
2747: goto out;
2748: }
2749:
2750: if ( (erq->length > LARGE_KEY_SIZE)
2751: || ( ! priv->has_big_wep && (erq->length > SMALL_KEY_SIZE)) ) {
2752: err = -EINVAL;
2753: goto out;
2754: }
2755:
2756: if ((index < 0) || (index >= ORINOCO_MAX_KEYS))
2757: index = priv->tx_key;
2758:
2759: if (erq->length > SMALL_KEY_SIZE) {
2760: xlen = LARGE_KEY_SIZE;
2761: } else if (erq->length > 0) {
2762: xlen = SMALL_KEY_SIZE;
2763: } else
2764: xlen = 0;
2765:
2766: /* Switch on WEP if off */
2767: if ((!enable) && (xlen > 0)) {
2768: setindex = index;
2769: enable = 1;
2770: }
2771: } else {
2772: /* Important note : if the user do "iwconfig eth0 enc off",
2773: * we will arrive there with an index of -1. This is valid
2774: * but need to be taken care off... Jean II */
2775: if ((index < 0) || (index >= ORINOCO_MAX_KEYS)) {
2776: if((index != -1) || (erq->flags == 0)) {
2777: err = -EINVAL;
2778: goto out;
2779: }
2780: } else {
2781: /* Set the index : Check that the key is valid */
2782: if(priv->keys[index].len == 0) {
2783: err = -EINVAL;
2784: goto out;
2785: }
2786: setindex = index;
2787: }
2788: }
2789:
2790: if (erq->flags & IW_ENCODE_DISABLED)
2791: enable = 0;
2792: /* Only for Prism2 & Symbol cards (so far) - Jean II */
2793: if (erq->flags & IW_ENCODE_OPEN)
2794: restricted = 0;
2795: if (erq->flags & IW_ENCODE_RESTRICTED)
2796: restricted = 1;
2797:
2798: if (erq->pointer) {
2799: priv->keys[index].len = cpu_to_le16(xlen);
2800: memset(priv->keys[index].data, 0, sizeof(priv->keys[index].data));
2801: memcpy(priv->keys[index].data, keybuf, erq->length);
2802: }
2803: priv->tx_key = setindex;
2804: priv->wep_on = enable;
2805: priv->wep_restrict = restricted;
2806:
2807:
2808: out:
2809: orinoco_unlock(priv, &flags);
2810:
2811: return err;
2812: }
2813:
2814: static int orinoco_ioctl_getiwencode(struct net_device *dev, struct iw_point *erq)
2815: {
2816: struct orinoco_private *priv = dev->priv;
2817: int index = (erq->flags & IW_ENCODE_INDEX) - 1;
2818: u16 xlen = 0;
2819: char keybuf[ORINOCO_MAX_KEY_SIZE];
2820: int err;
2821: unsigned long flags;
2822:
2823: err = orinoco_lock(priv, &flags);
2824: if (err)
2825: return err;
2826:
2827: if ((index < 0) || (index >= ORINOCO_MAX_KEYS))
2828: index = priv->tx_key;
2829:
2830: erq->flags = 0;
2831: if (! priv->wep_on)
2832: erq->flags |= IW_ENCODE_DISABLED;
2833: erq->flags |= index + 1;
2834:
2835: /* Only for symbol cards - Jean II */
2836: if (priv->firmware_type != FIRMWARE_TYPE_AGERE) {
2837: if(priv->wep_restrict)
2838: erq->flags |= IW_ENCODE_RESTRICTED;
2839: else
2840: erq->flags |= IW_ENCODE_OPEN;
2841: }
2842:
2843: xlen = le16_to_cpu(priv->keys[index].len);
2844:
2845: erq->length = xlen;
2846:
2847: if (erq->pointer) {
2848: memcpy(keybuf, priv->keys[index].data, ORINOCO_MAX_KEY_SIZE);
2849: }
2850:
2851: orinoco_unlock(priv, &flags);
2852:
2853: if (erq->pointer) {
2854: if (copy_to_user(erq->pointer, keybuf, xlen))
2855: return -EFAULT;
2856: }
2857:
2858: return 0;
2859: }
2860:
2861: static int orinoco_ioctl_setessid(struct net_device *dev, struct iw_point *erq)
2862: {
2863: struct orinoco_private *priv = dev->priv;
2864: char essidbuf[IW_ESSID_MAX_SIZE+1];
2865: int err;
2866: unsigned long flags;
2867:
2868: /* Note : ESSID is ignored in Ad-Hoc demo mode, but we can set it
2869: * anyway... - Jean II */
2870:
2871: memset(&essidbuf, 0, sizeof(essidbuf));
2872:
2873: if (erq->flags) {
2874: if (erq->length > IW_ESSID_MAX_SIZE)
2875: return -E2BIG;
2876:
2877: if (copy_from_user(&essidbuf, erq->pointer, erq->length))
2878: return -EFAULT;
2879:
2880: essidbuf[erq->length] = '\0';
2881: }
2882:
2883: err = orinoco_lock(priv, &flags);
2884: if (err)
2885: return err;
2886:
2887: memcpy(priv->desired_essid, essidbuf, sizeof(priv->desired_essid));
2888:
2889: orinoco_unlock(priv, &flags);
2890:
2891: return 0;
2892: }
2893:
2894: static int orinoco_ioctl_getessid(struct net_device *dev, struct iw_point *erq)
2895: {
2896: struct orinoco_private *priv = dev->priv;
2897: char essidbuf[IW_ESSID_MAX_SIZE+1];
2898: int active;
2899: int err = 0;
2900: unsigned long flags;
2901:
2902: TRACE_ENTER(dev->name);
2903:
2904: if (netif_running(dev)) {
2905: err = orinoco_hw_get_essid(priv, &active, essidbuf);
2906: if (err)
2907: return err;
2908: } else {
2909: err = orinoco_lock(priv, &flags);
2910: if (err)
2911: return err;
2912: memcpy(essidbuf, priv->desired_essid, sizeof(essidbuf));
2913: orinoco_unlock(priv, &flags);
2914: }
2915:
2916: erq->flags = 1;
2917: erq->length = strlen(essidbuf) + 1;
2918: if (erq->pointer)
2919: if (copy_to_user(erq->pointer, essidbuf, erq->length))
2920: return -EFAULT;
2921:
2922: TRACE_EXIT(dev->name);
2923:
2924: return 0;
2925: }
2926:
2927: static int orinoco_ioctl_setnick(struct net_device *dev, struct iw_point *nrq)
2928: {
2929: struct orinoco_private *priv = dev->priv;
2930: char nickbuf[IW_ESSID_MAX_SIZE+1];
2931: int err;
2932: unsigned long flags;
2933:
2934: if (nrq->length > IW_ESSID_MAX_SIZE)
2935: return -E2BIG;
2936:
2937: memset(nickbuf, 0, sizeof(nickbuf));
2938:
2939: if (copy_from_user(nickbuf, nrq->pointer, nrq->length))
2940: return -EFAULT;
2941:
2942: nickbuf[nrq->length] = '\0';
2943:
2944: err = orinoco_lock(priv, &flags);
2945: if (err)
2946: return err;
2947:
2948: memcpy(priv->nick, nickbuf, sizeof(priv->nick));
2949:
2950: orinoco_unlock(priv, &flags);
2951:
2952: return 0;
2953: }
2954:
2955: static int orinoco_ioctl_getnick(struct net_device *dev, struct iw_point *nrq)
2956: {
2957: struct orinoco_private *priv = dev->priv;
2958: char nickbuf[IW_ESSID_MAX_SIZE+1];
2959: int err;
2960: unsigned long flags;
2961:
2962: err = orinoco_lock(priv, &flags);
2963: if (err)
2964: return err;
2965:
2966: memcpy(nickbuf, priv->nick, IW_ESSID_MAX_SIZE+1);
2967: orinoco_unlock(priv, &flags);
2968:
2969: nrq->length = strlen(nickbuf)+1;
2970:
2971: #ifdef MACH
2972: if(! nrq->pointer) {
2973: printk(KERN_INFO "orinoco_ioctl_getnick: no nrq pointer.\n");
2974: return -EFAULT;
2975: }
2976: #endif
2977:
2978: if (copy_to_user(nrq->pointer, nickbuf, sizeof(nickbuf)))
2979: return -EFAULT;
2980:
2981: return 0;
2982: }
2983:
2984: static int orinoco_ioctl_setfreq(struct net_device *dev, struct iw_freq *frq)
2985: {
2986: struct orinoco_private *priv = dev->priv;
2987: int chan = -1;
2988: int err;
2989: unsigned long flags;
2990:
2991: /* We can only use this in Ad-Hoc demo mode to set the operating
2992: * frequency, or in IBSS mode to set the frequency where the IBSS
2993: * will be created - Jean II */
2994: if (priv->iw_mode != IW_MODE_ADHOC)
2995: return -EOPNOTSUPP;
2996:
2997: if ( (frq->e == 0) && (frq->m <= 1000) ) {
2998: /* Setting by channel number */
2999: chan = frq->m;
3000: } else {
3001: /* Setting by frequency - search the table */
3002: int mult = 1;
3003: int i;
3004:
3005: for (i = 0; i < (6 - frq->e); i++)
3006: mult *= 10;
3007:
3008: for (i = 0; i < NUM_CHANNELS; i++)
3009: if (frq->m == (channel_frequency[i] * mult))
3010: chan = i+1;
3011: }
3012:
3013: if ( (chan < 1) || (chan > NUM_CHANNELS) ||
3014: ! (priv->channel_mask & (1 << (chan-1)) ) )
3015: return -EINVAL;
3016:
3017: err = orinoco_lock(priv, &flags);
3018: if (err)
3019: return err;
3020: priv->channel = chan;
3021: orinoco_unlock(priv, &flags);
3022:
3023: return 0;
3024: }
3025:
3026: static int orinoco_ioctl_getsens(struct net_device *dev, struct iw_param *srq)
3027: {
3028: struct orinoco_private *priv = dev->priv;
3029: hermes_t *hw = &priv->hw;
3030: u16 val;
3031: int err;
3032: unsigned long flags;
3033:
3034: if (!priv->has_sensitivity)
3035: return -EOPNOTSUPP;
3036:
3037: err = orinoco_lock(priv, &flags);
3038: if (err)
3039: return err;
3040: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFSYSTEMSCALE, &val);
3041: orinoco_unlock(priv, &flags);
3042:
3043: if (err)
3044: return err;
3045:
3046: srq->value = val;
3047: srq->fixed = 0; /* auto */
3048:
3049: return 0;
3050: }
3051:
3052: static int orinoco_ioctl_setsens(struct net_device *dev, struct iw_param *srq)
3053: {
3054: struct orinoco_private *priv = dev->priv;
3055: int val = srq->value;
3056: int err;
3057: unsigned long flags;
3058:
3059: if (!priv->has_sensitivity)
3060: return -EOPNOTSUPP;
3061:
3062: if ((val < 1) || (val > 3))
3063: return -EINVAL;
3064:
3065: err = orinoco_lock(priv, &flags);
3066: if (err)
3067: return err;
3068: priv->ap_density = val;
3069: orinoco_unlock(priv, &flags);
3070:
3071: return 0;
3072: }
3073:
3074: static int orinoco_ioctl_setrts(struct net_device *dev, struct iw_param *rrq)
3075: {
3076: struct orinoco_private *priv = dev->priv;
3077: int val = rrq->value;
3078: int err;
3079: unsigned long flags;
3080:
3081: if (rrq->disabled)
3082: val = 2347;
3083:
3084: if ( (val < 0) || (val > 2347) )
3085: return -EINVAL;
3086:
3087: err = orinoco_lock(priv, &flags);
3088: if (err)
3089: return err;
3090:
3091: priv->rts_thresh = val;
3092: orinoco_unlock(priv, &flags);
3093:
3094: return 0;
3095: }
3096:
3097: static int orinoco_ioctl_setfrag(struct net_device *dev, struct iw_param *frq)
3098: {
3099: struct orinoco_private *priv = dev->priv;
3100: int err = 0;
3101: unsigned long flags;
3102:
3103: err = orinoco_lock(priv, &flags);
3104: if (err)
3105: return err;
3106:
3107: if (priv->has_mwo) {
3108: if (frq->disabled)
3109: priv->mwo_robust = 0;
3110: else {
3111: if (frq->fixed)
3112: printk(KERN_WARNING "%s: Fixed fragmentation not \
3113: supported on this firmware. Using MWO robust instead.\n", dev->name);
3114: priv->mwo_robust = 1;
3115: }
3116: } else {
3117: if (frq->disabled)
3118: priv->frag_thresh = 2346;
3119: else {
3120: if ( (frq->value < 256) || (frq->value > 2346) )
3121: err = -EINVAL;
3122: else
3123: priv->frag_thresh = frq->value & ~0x1; /* must be even */
3124: }
3125: }
3126:
3127: orinoco_unlock(priv, &flags);
3128:
3129: return err;
3130: }
3131:
3132: static int orinoco_ioctl_getfrag(struct net_device *dev, struct iw_param *frq)
3133: {
3134: struct orinoco_private *priv = dev->priv;
3135: hermes_t *hw = &priv->hw;
3136: int err = 0;
3137: u16 val;
3138: unsigned long flags;
3139:
3140: err = orinoco_lock(priv, &flags);
3141: if (err)
3142: return err;
3143:
3144: if (priv->has_mwo) {
3145: err = hermes_read_wordrec(hw, USER_BAP,
3146: HERMES_RID_CNFMWOROBUST_AGERE,
3147: &val);
3148: if (err)
3149: val = 0;
3150:
3151: frq->value = val ? 2347 : 0;
3152: frq->disabled = ! val;
3153: frq->fixed = 0;
3154: } else {
3155: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFFRAGMENTATIONTHRESHOLD,
3156: &val);
3157: if (err)
3158: val = 0;
3159:
3160: frq->value = val;
3161: frq->disabled = (val >= 2346);
3162: frq->fixed = 1;
3163: }
3164:
3165: orinoco_unlock(priv, &flags);
3166:
3167: return err;
3168: }
3169:
3170: static int orinoco_ioctl_setrate(struct net_device *dev, struct iw_param *rrq)
3171: {
3172: struct orinoco_private *priv = dev->priv;
3173: int err = 0;
3174: int ratemode = -1;
3175: int bitrate; /* 100s of kilobits */
3176: int i;
3177: unsigned long flags;
3178:
3179: /* As the user space doesn't know our highest rate, it uses -1
3180: * to ask us to set the highest rate. Test it using "iwconfig
3181: * ethX rate auto" - Jean II */
3182: if (rrq->value == -1)
3183: bitrate = 110;
3184: else {
3185: if (rrq->value % 100000)
3186: return -EINVAL;
3187: bitrate = rrq->value / 100000;
3188: }
3189:
3190: if ( (bitrate != 10) && (bitrate != 20) &&
3191: (bitrate != 55) && (bitrate != 110) )
3192: return -EINVAL;
3193:
3194: for (i = 0; i < BITRATE_TABLE_SIZE; i++)
3195: if ( (bitrate_table[i].bitrate == bitrate) &&
3196: (bitrate_table[i].automatic == ! rrq->fixed) ) {
3197: ratemode = i;
3198: break;
3199: }
3200:
3201: if (ratemode == -1)
3202: return -EINVAL;
3203:
3204: err = orinoco_lock(priv, &flags);
3205: if (err)
3206: return err;
3207: priv->bitratemode = ratemode;
3208: orinoco_unlock(priv, &flags);
3209:
3210: return err;
3211: }
3212:
3213: static int orinoco_ioctl_getrate(struct net_device *dev, struct iw_param *rrq)
3214: {
3215: struct orinoco_private *priv = dev->priv;
3216: hermes_t *hw = &priv->hw;
3217: int err = 0;
3218: int ratemode;
3219: int i;
3220: u16 val;
3221: unsigned long flags;
3222:
3223: err = orinoco_lock(priv, &flags);
3224: if (err)
3225: return err;
3226:
3227: ratemode = priv->bitratemode;
3228:
3229: if ( (ratemode < 0) || (ratemode >= BITRATE_TABLE_SIZE) )
3230: BUG();
3231:
3232: rrq->value = bitrate_table[ratemode].bitrate * 100000;
3233: rrq->fixed = ! bitrate_table[ratemode].automatic;
3234: rrq->disabled = 0;
3235:
3236: /* If the interface is running we try to find more about the
3237: current mode */
3238: if (netif_running(dev)) {
3239: err = hermes_read_wordrec(hw, USER_BAP,
3240: HERMES_RID_CURRENTTXRATE, &val);
3241: if (err)
3242: goto out;
3243:
3244: switch (priv->firmware_type) {
3245: case FIRMWARE_TYPE_AGERE: /* Lucent style rate */
3246: /* Note : in Lucent firmware, the return value of
3247: * HERMES_RID_CURRENTTXRATE is the bitrate in Mb/s,
3248: * and therefore is totally different from the
3249: * encoding of HERMES_RID_CNFTXRATECONTROL.
3250: * Don't forget that 6Mb/s is really 5.5Mb/s */
3251: if (val == 6)
3252: rrq->value = 5500000;
3253: else
3254: rrq->value = val * 1000000;
3255: break;
3256: case FIRMWARE_TYPE_INTERSIL: /* Intersil style rate */
3257: case FIRMWARE_TYPE_SYMBOL: /* Symbol style rate */
3258: for (i = 0; i < BITRATE_TABLE_SIZE; i++)
3259: if (bitrate_table[i].intersil_txratectrl == val) {
3260: ratemode = i;
3261: break;
3262: }
3263: if (i >= BITRATE_TABLE_SIZE)
3264: printk(KERN_INFO "%s: Unable to determine current bitrate (0x%04hx)\n",
3265: dev->name, val);
3266:
3267: rrq->value = bitrate_table[ratemode].bitrate * 100000;
3268: break;
3269: default:
3270: BUG();
3271: }
3272: }
3273:
3274: out:
3275: orinoco_unlock(priv, &flags);
3276:
3277: return err;
3278: }
3279:
3280: static int orinoco_ioctl_setpower(struct net_device *dev, struct iw_param *prq)
3281: {
3282: struct orinoco_private *priv = dev->priv;
3283: int err = 0;
3284: unsigned long flags;
3285:
3286: err = orinoco_lock(priv, &flags);
3287: if (err)
3288: return err;
3289:
3290: if (prq->disabled) {
3291: priv->pm_on = 0;
3292: } else {
3293: switch (prq->flags & IW_POWER_MODE) {
3294: case IW_POWER_UNICAST_R:
3295: priv->pm_mcast = 0;
3296: priv->pm_on = 1;
3297: break;
3298: case IW_POWER_ALL_R:
3299: priv->pm_mcast = 1;
3300: priv->pm_on = 1;
3301: break;
3302: case IW_POWER_ON:
3303: /* No flags : but we may have a value - Jean II */
3304: break;
3305: default:
3306: err = -EINVAL;
3307: }
3308: if (err)
3309: goto out;
3310:
3311: if (prq->flags & IW_POWER_TIMEOUT) {
3312: priv->pm_on = 1;
3313: priv->pm_timeout = prq->value / 1000;
3314: }
3315: if (prq->flags & IW_POWER_PERIOD) {
3316: priv->pm_on = 1;
3317: priv->pm_period = prq->value / 1000;
3318: }
3319: /* It's valid to not have a value if we are just toggling
3320: * the flags... Jean II */
3321: if(!priv->pm_on) {
3322: err = -EINVAL;
3323: goto out;
3324: }
3325: }
3326:
3327: out:
3328: orinoco_unlock(priv, &flags);
3329:
3330: return err;
3331: }
3332:
3333: static int orinoco_ioctl_getpower(struct net_device *dev, struct iw_param *prq)
3334: {
3335: struct orinoco_private *priv = dev->priv;
3336: hermes_t *hw = &priv->hw;
3337: int err = 0;
3338: u16 enable, period, timeout, mcast;
3339: unsigned long flags;
3340:
3341: err = orinoco_lock(priv, &flags);
3342: if (err)
3343: return err;
3344:
3345: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFPMENABLED, &enable);
3346: if (err)
3347: goto out;
3348:
3349: err = hermes_read_wordrec(hw, USER_BAP,
3350: HERMES_RID_CNFMAXSLEEPDURATION, &period);
3351: if (err)
3352: goto out;
3353:
3354: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFPMHOLDOVERDURATION, &timeout);
3355: if (err)
3356: goto out;
3357:
3358: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_CNFMULTICASTRECEIVE, &mcast);
3359: if (err)
3360: goto out;
3361:
3362: prq->disabled = !enable;
3363: /* Note : by default, display the period */
3364: if ((prq->flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
3365: prq->flags = IW_POWER_TIMEOUT;
3366: prq->value = timeout * 1000;
3367: } else {
3368: prq->flags = IW_POWER_PERIOD;
3369: prq->value = period * 1000;
3370: }
3371: if (mcast)
3372: prq->flags |= IW_POWER_ALL_R;
3373: else
3374: prq->flags |= IW_POWER_UNICAST_R;
3375:
3376: out:
3377: orinoco_unlock(priv, &flags);
3378:
3379: return err;
3380: }
3381:
3382: #if WIRELESS_EXT > 10
3383: static int orinoco_ioctl_getretry(struct net_device *dev, struct iw_param *rrq)
3384: {
3385: struct orinoco_private *priv = dev->priv;
3386: hermes_t *hw = &priv->hw;
3387: int err = 0;
3388: u16 short_limit, long_limit, lifetime;
3389: unsigned long flags;
3390:
3391: err = orinoco_lock(priv, &flags);
3392: if (err)
3393: return err;
3394:
3395: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_SHORTRETRYLIMIT,
3396: &short_limit);
3397: if (err)
3398: goto out;
3399:
3400: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_LONGRETRYLIMIT,
3401: &long_limit);
3402: if (err)
3403: goto out;
3404:
3405: err = hermes_read_wordrec(hw, USER_BAP, HERMES_RID_MAXTRANSMITLIFETIME,
3406: &lifetime);
3407: if (err)
3408: goto out;
3409:
3410: rrq->disabled = 0; /* Can't be disabled */
3411:
3412: /* Note : by default, display the retry number */
3413: if ((rrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
3414: rrq->flags = IW_RETRY_LIFETIME;
3415: rrq->value = lifetime * 1000; /* ??? */
3416: } else {
3417: /* By default, display the min number */
3418: if ((rrq->flags & IW_RETRY_MAX)) {
3419: rrq->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
3420: rrq->value = long_limit;
3421: } else {
3422: rrq->flags = IW_RETRY_LIMIT;
3423: rrq->value = short_limit;
3424: if(short_limit != long_limit)
3425: rrq->flags |= IW_RETRY_MIN;
3426: }
3427: }
3428:
3429: out:
3430: orinoco_unlock(priv, &flags);
3431:
3432: return err;
3433: }
3434: #endif /* WIRELESS_EXT > 10 */
3435:
3436: static int orinoco_ioctl_setibssport(struct net_device *dev, struct iwreq *wrq)
3437: {
3438: struct orinoco_private *priv = dev->priv;
3439: int val = *( (int *) wrq->u.name );
3440: int err;
3441: unsigned long flags;
3442:
3443: err = orinoco_lock(priv, &flags);
3444: if (err)
3445: return err;
3446:
3447: priv->ibss_port = val ;
3448:
3449: /* Actually update the mode we are using */
3450: set_port_type(priv);
3451:
3452: orinoco_unlock(priv, &flags);
3453: return 0;
3454: }
3455:
3456: static int orinoco_ioctl_getibssport(struct net_device *dev, struct iwreq *wrq)
3457: {
3458: struct orinoco_private *priv = dev->priv;
3459: int *val = (int *)wrq->u.name;
3460: int err;
3461: unsigned long flags;
3462:
3463: err = orinoco_lock(priv, &flags);
3464: if (err)
3465: return err;
3466:
3467: *val = priv->ibss_port;
3468: orinoco_unlock(priv, &flags);
3469:
3470: return 0;
3471: }
3472:
3473: static int orinoco_ioctl_setport3(struct net_device *dev, struct iwreq *wrq)
3474: {
3475: struct orinoco_private *priv = dev->priv;
3476: int val = *( (int *) wrq->u.name );
3477: int err = 0;
3478: unsigned long flags;
3479:
3480: err = orinoco_lock(priv, &flags);
3481: if (err)
3482: return err;
3483:
3484: switch (val) {
3485: case 0: /* Try to do IEEE ad-hoc mode */
3486: if (! priv->has_ibss) {
3487: err = -EINVAL;
3488: break;
3489: }
3490: priv->prefer_port3 = 0;
3491:
3492: break;
3493:
3494: case 1: /* Try to do Lucent proprietary ad-hoc mode */
3495: if (! priv->has_port3) {
3496: err = -EINVAL;
3497: break;
3498: }
3499: priv->prefer_port3 = 1;
3500: break;
3501:
3502: default:
3503: err = -EINVAL;
3504: }
3505:
3506: if (! err)
3507: /* Actually update the mode we are using */
3508: set_port_type(priv);
3509:
3510: orinoco_unlock(priv, &flags);
3511:
3512: return err;
3513: }
3514:
3515: static int orinoco_ioctl_getport3(struct net_device *dev, struct iwreq *wrq)
3516: {
3517: struct orinoco_private *priv = dev->priv;
3518: int *val = (int *)wrq->u.name;
3519: int err;
3520: unsigned long flags;
3521:
3522: err = orinoco_lock(priv, &flags);
3523: if (err)
3524: return err;
3525:
3526: *val = priv->prefer_port3;
3527: orinoco_unlock(priv, &flags);
3528:
3529: return 0;
3530: }
3531:
3532: /* Spy is used for link quality/strength measurements in Ad-Hoc mode
3533: * Jean II */
3534: static int orinoco_ioctl_setspy(struct net_device *dev, struct iw_point *srq)
3535: {
3536: struct orinoco_private *priv = dev->priv;
3537: struct sockaddr address[IW_MAX_SPY];
3538: int number = srq->length;
3539: int i;
3540: int err = 0;
3541: unsigned long flags;
3542:
3543: /* Check the number of addresses */
3544: if (number > IW_MAX_SPY)
3545: return -E2BIG;
3546:
3547: /* Get the data in the driver */
3548: if (srq->pointer) {
3549: if (copy_from_user(address, srq->pointer,
3550: sizeof(struct sockaddr) * number))
3551: return -EFAULT;
3552: }
3553:
3554: /* Make sure nobody mess with the structure while we do */
3555: err = orinoco_lock(priv, &flags);
3556: if (err)
3557: return err;
3558:
3559: /* orinoco_lock() doesn't disable interrupts, so make sure the
3560: * interrupt rx path don't get confused while we copy */
3561: priv->spy_number = 0;
3562:
3563: if (number > 0) {
3564: /* Extract the addresses */
3565: for (i = 0; i < number; i++)
3566: memcpy(priv->spy_address[i], address[i].sa_data,
3567: ETH_ALEN);
3568: /* Reset stats */
3569: memset(priv->spy_stat, 0,
3570: sizeof(struct iw_quality) * IW_MAX_SPY);
3571: /* Set number of addresses */
3572: priv->spy_number = number;
3573: }
3574:
3575: /* Now, let the others play */
3576: orinoco_unlock(priv, &flags);
3577:
3578: return err;
3579: }
3580:
3581: static int orinoco_ioctl_getspy(struct net_device *dev, struct iw_point *srq)
3582: {
3583: struct orinoco_private *priv = dev->priv;
3584: struct sockaddr address[IW_MAX_SPY];
3585: struct iw_quality spy_stat[IW_MAX_SPY];
3586: int number;
3587: int i;
3588: int err;
3589: unsigned long flags;
3590:
3591: err = orinoco_lock(priv, &flags);
3592: if (err)
3593: return err;
3594:
3595: number = priv->spy_number;
3596: if ((number > 0) && (srq->pointer)) {
3597: /* Create address struct */
3598: for (i = 0; i < number; i++) {
3599: memcpy(address[i].sa_data, priv->spy_address[i],
3600: ETH_ALEN);
3601: address[i].sa_family = AF_UNIX;
3602: }
3603: /* Copy stats */
3604: /* In theory, we should disable irqs while copying the stats
3605: * because the rx path migh update it in the middle...
3606: * Bah, who care ? - Jean II */
3607: memcpy(&spy_stat, priv->spy_stat,
3608: sizeof(struct iw_quality) * IW_MAX_SPY);
3609: for (i=0; i < number; i++)
3610: priv->spy_stat[i].updated = 0;
3611: }
3612:
3613: orinoco_unlock(priv, &flags);
3614:
3615: /* Push stuff to user space */
3616: srq->length = number;
3617: if(copy_to_user(srq->pointer, address,
3618: sizeof(struct sockaddr) * number))
3619: return -EFAULT;
3620: if(copy_to_user(srq->pointer + (sizeof(struct sockaddr)*number),
3621: &spy_stat, sizeof(struct iw_quality) * number))
3622: return -EFAULT;
3623:
3624: return 0;
3625: }
3626:
3627: static int
3628: orinoco_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3629: {
3630: struct orinoco_private *priv = dev->priv;
3631: struct iwreq *wrq = (struct iwreq *)rq;
3632: int err = 0;
3633: int tmp;
3634: int changed = 0;
3635: unsigned long flags;
3636:
3637: TRACE_ENTER(dev->name);
3638:
3639: /* In theory, we could allow most of the the SET stuff to be
3640: * done. In practice, the lapse of time at startup when the
3641: * card is not ready is very short, so why bother... Note
3642: * that netif_device_present is different from up/down
3643: * (ifconfig), when the device is not yet up, it is usually
3644: * already ready... Jean II */
3645: if (! netif_device_present(dev))
3646: return -ENODEV;
3647:
3648: switch (cmd) {
3649: case SIOCGIWNAME:
3650: strcpy(wrq->u.name, "IEEE 802.11-DS");
3651: break;
3652:
3653: case SIOCGIWAP:
3654: wrq->u.ap_addr.sa_family = ARPHRD_ETHER;
3655: err = orinoco_hw_get_bssid(priv, wrq->u.ap_addr.sa_data);
3656: break;
3657:
3658: case SIOCGIWRANGE:
3659: err = orinoco_ioctl_getiwrange(dev, &wrq->u.data);
3660: break;
3661:
3662: case SIOCSIWMODE:
3663: err = orinoco_lock(priv, &flags);
3664: if (err)
3665: return err;
3666: switch (wrq->u.mode) {
3667: case IW_MODE_ADHOC:
3668: if (! (priv->has_ibss || priv->has_port3) )
3669: err = -EINVAL;
3670: else {
3671: priv->iw_mode = IW_MODE_ADHOC;
3672: changed = 1;
3673: }
3674: break;
3675:
3676: case IW_MODE_INFRA:
3677: priv->iw_mode = IW_MODE_INFRA;
3678: changed = 1;
3679: break;
3680:
3681: default:
3682: err = -EINVAL;
3683: break;
3684: }
3685: set_port_type(priv);
3686: orinoco_unlock(priv, &flags);
3687: break;
3688:
3689: case SIOCGIWMODE:
3690: err = orinoco_lock(priv, &flags);
3691: if (err)
3692: return err;
3693: wrq->u.mode = priv->iw_mode;
3694: orinoco_unlock(priv, &flags);
3695: break;
3696:
3697: case SIOCSIWENCODE:
3698: if (! priv->has_wep) {
3699: err = -EOPNOTSUPP;
3700: break;
3701: }
3702:
3703: err = orinoco_ioctl_setiwencode(dev, &wrq->u.encoding);
3704: if (! err)
3705: changed = 1;
3706: break;
3707:
3708: case SIOCGIWENCODE:
3709: if (! priv->has_wep) {
3710: err = -EOPNOTSUPP;
3711: break;
3712: }
3713:
3714: if (! capable(CAP_NET_ADMIN)) {
3715: err = -EPERM;
3716: break;
3717: }
3718:
3719: err = orinoco_ioctl_getiwencode(dev, &wrq->u.encoding);
3720: break;
3721:
3722: case SIOCSIWESSID:
3723: err = orinoco_ioctl_setessid(dev, &wrq->u.essid);
3724: if (! err)
3725: changed = 1;
3726: break;
3727:
3728: case SIOCGIWESSID:
3729: err = orinoco_ioctl_getessid(dev, &wrq->u.essid);
3730: break;
3731:
3732: case SIOCSIWNICKN:
3733: err = orinoco_ioctl_setnick(dev, &wrq->u.data);
3734: if (! err)
3735: changed = 1;
3736: break;
3737:
3738: case SIOCGIWNICKN:
3739: err = orinoco_ioctl_getnick(dev, &wrq->u.data);
3740: break;
3741:
3742: case SIOCGIWFREQ:
3743: tmp = orinoco_hw_get_freq(priv);
3744: if (tmp < 0) {
3745: err = tmp;
3746: } else {
3747: wrq->u.freq.m = tmp;
3748: wrq->u.freq.e = 1;
3749: }
3750: break;
3751:
3752: case SIOCSIWFREQ:
3753: err = orinoco_ioctl_setfreq(dev, &wrq->u.freq);
3754: if (! err)
3755: changed = 1;
3756: break;
3757:
3758: case SIOCGIWSENS:
3759: err = orinoco_ioctl_getsens(dev, &wrq->u.sens);
3760: break;
3761:
3762: case SIOCSIWSENS:
3763: err = orinoco_ioctl_setsens(dev, &wrq->u.sens);
3764: if (! err)
3765: changed = 1;
3766: break;
3767:
3768: case SIOCGIWRTS:
3769: wrq->u.rts.value = priv->rts_thresh;
3770: wrq->u.rts.disabled = (wrq->u.rts.value == 2347);
3771: wrq->u.rts.fixed = 1;
3772: break;
3773:
3774: case SIOCSIWRTS:
3775: err = orinoco_ioctl_setrts(dev, &wrq->u.rts);
3776: if (! err)
3777: changed = 1;
3778: break;
3779:
3780: case SIOCSIWFRAG:
3781: err = orinoco_ioctl_setfrag(dev, &wrq->u.frag);
3782: if (! err)
3783: changed = 1;
3784: break;
3785:
3786: case SIOCGIWFRAG:
3787: err = orinoco_ioctl_getfrag(dev, &wrq->u.frag);
3788: break;
3789:
3790: case SIOCSIWRATE:
3791: err = orinoco_ioctl_setrate(dev, &wrq->u.bitrate);
3792: if (! err)
3793: changed = 1;
3794: break;
3795:
3796: case SIOCGIWRATE:
3797: err = orinoco_ioctl_getrate(dev, &wrq->u.bitrate);
3798: break;
3799:
3800: case SIOCSIWPOWER:
3801: err = orinoco_ioctl_setpower(dev, &wrq->u.power);
3802: if (! err)
3803: changed = 1;
3804: break;
3805:
3806: case SIOCGIWPOWER:
3807: err = orinoco_ioctl_getpower(dev, &wrq->u.power);
3808: break;
3809:
3810: case SIOCGIWTXPOW:
3811: /* The card only supports one tx power, so this is easy */
3812: wrq->u.txpower.value = 15; /* dBm */
3813: wrq->u.txpower.fixed = 1;
3814: wrq->u.txpower.disabled = 0;
3815: wrq->u.txpower.flags = IW_TXPOW_DBM;
3816: break;
3817:
3818: #if WIRELESS_EXT > 10
3819: case SIOCSIWRETRY:
3820: err = -EOPNOTSUPP;
3821: break;
3822:
3823: case SIOCGIWRETRY:
3824: err = orinoco_ioctl_getretry(dev, &wrq->u.retry);
3825: break;
3826: #endif /* WIRELESS_EXT > 10 */
3827:
3828: case SIOCSIWSPY:
3829: err = orinoco_ioctl_setspy(dev, &wrq->u.data);
3830: break;
3831:
3832: case SIOCGIWSPY:
3833: err = orinoco_ioctl_getspy(dev, &wrq->u.data);
3834: break;
3835:
3836: case SIOCGIWPRIV:
3837: if (wrq->u.data.pointer) {
3838: struct iw_priv_args privtab[] = {
3839: { SIOCIWFIRSTPRIV + 0x0, 0, 0, "force_reset" },
3840: { SIOCIWFIRSTPRIV + 0x1, 0, 0, "card_reset" },
3841: { SIOCIWFIRSTPRIV + 0x2,
3842: IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
3843: 0, "set_port3" },
3844: { SIOCIWFIRSTPRIV + 0x3, 0,
3845: IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
3846: "get_port3" },
3847: { SIOCIWFIRSTPRIV + 0x4,
3848: IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
3849: 0, "set_preamble" },
3850: { SIOCIWFIRSTPRIV + 0x5, 0,
3851: IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
3852: "get_preamble" },
3853: { SIOCIWFIRSTPRIV + 0x6,
3854: IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
3855: 0, "set_ibssport" },
3856: { SIOCIWFIRSTPRIV + 0x7, 0,
3857: IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
3858: "get_ibssport" },
3859: { SIOCIWLASTPRIV, 0, 0, "dump_recs" },
3860: };
3861:
3862: err = verify_area(VERIFY_WRITE, wrq->u.data.pointer, sizeof(privtab));
3863: if (err)
3864: break;
3865:
3866: wrq->u.data.length = sizeof(privtab) / sizeof(privtab[0]);
3867: if (copy_to_user(wrq->u.data.pointer, privtab, sizeof(privtab)))
3868: err = -EFAULT;
3869: }
3870: break;
3871:
3872: case SIOCIWFIRSTPRIV + 0x0: /* force_reset */
3873: case SIOCIWFIRSTPRIV + 0x1: /* card_reset */
3874: if (! capable(CAP_NET_ADMIN)) {
3875: err = -EPERM;
3876: break;
3877: }
3878:
3879: printk(KERN_DEBUG "%s: Force scheduling reset!\n", dev->name);
3880:
3881: schedule_work(&priv->reset_work);
3882: break;
3883:
3884: case SIOCIWFIRSTPRIV + 0x2: /* set_port3 */
3885: if (! capable(CAP_NET_ADMIN)) {
3886: err = -EPERM;
3887: break;
3888: }
3889:
3890: err = orinoco_ioctl_setport3(dev, wrq);
3891: if (! err)
3892: changed = 1;
3893: break;
3894:
3895: case SIOCIWFIRSTPRIV + 0x3: /* get_port3 */
3896: err = orinoco_ioctl_getport3(dev, wrq);
3897: break;
3898:
3899: case SIOCIWFIRSTPRIV + 0x4: /* set_preamble */
3900: if (! capable(CAP_NET_ADMIN)) {
3901: err = -EPERM;
3902: break;
3903: }
3904:
3905: /* 802.11b has recently defined some short preamble.
3906: * Basically, the Phy header has been reduced in size.
3907: * This increase performance, especially at high rates
3908: * (the preamble is transmitted at 1Mb/s), unfortunately
3909: * this give compatibility troubles... - Jean II */
3910: if(priv->has_preamble) {
3911: int val = *( (int *) wrq->u.name );
3912:
3913: err = orinoco_lock(priv, &flags);
3914: if (err)
3915: return err;
3916: if (val)
3917: priv->preamble = 1;
3918: else
3919: priv->preamble = 0;
3920: orinoco_unlock(priv, &flags);
3921: changed = 1;
3922: } else
3923: err = -EOPNOTSUPP;
3924: break;
3925:
3926: case SIOCIWFIRSTPRIV + 0x5: /* get_preamble */
3927: if(priv->has_preamble) {
3928: int *val = (int *)wrq->u.name;
3929:
3930: err = orinoco_lock(priv, &flags);
3931: if (err)
3932: return err;
3933: *val = priv->preamble;
3934: orinoco_unlock(priv, &flags);
3935: } else
3936: err = -EOPNOTSUPP;
3937: break;
3938: case SIOCIWFIRSTPRIV + 0x6: /* set_ibssport */
3939: if (! capable(CAP_NET_ADMIN)) {
3940: err = -EPERM;
3941: break;
3942: }
3943:
3944: err = orinoco_ioctl_setibssport(dev, wrq);
3945: if (! err)
3946: changed = 1;
3947: break;
3948:
3949: case SIOCIWFIRSTPRIV + 0x7: /* get_ibssport */
3950: err = orinoco_ioctl_getibssport(dev, wrq);
3951: break;
3952:
3953: case SIOCIWLASTPRIV:
3954: err = orinoco_debug_dump_recs(dev);
3955: if (err)
3956: printk(KERN_ERR "%s: Unable to dump records (%d)\n",
3957: dev->name, err);
3958: break;
3959:
3960:
3961: default:
3962: err = -EOPNOTSUPP;
3963: }
3964:
3965: if (! err && changed && netif_running(dev)) {
3966: err = orinoco_reconfigure(dev);
3967: }
3968:
3969: TRACE_EXIT(dev->name);
3970:
3971: return err;
3972: }
3973:
3974: struct {
3975: u16 rid;
3976: char *name;
3977: int displaytype;
3978: #define DISPLAY_WORDS 0
3979: #define DISPLAY_BYTES 1
3980: #define DISPLAY_STRING 2
3981: #define DISPLAY_XSTRING 3
3982: } record_table[] = {
3983: #define DEBUG_REC(name,type) { HERMES_RID_##name, #name, DISPLAY_##type }
3984: DEBUG_REC(CNFPORTTYPE,WORDS),
3985: DEBUG_REC(CNFOWNMACADDR,BYTES),
3986: DEBUG_REC(CNFDESIREDSSID,STRING),
3987: DEBUG_REC(CNFOWNCHANNEL,WORDS),
3988: DEBUG_REC(CNFOWNSSID,STRING),
3989: DEBUG_REC(CNFOWNATIMWINDOW,WORDS),
3990: DEBUG_REC(CNFSYSTEMSCALE,WORDS),
3991: DEBUG_REC(CNFMAXDATALEN,WORDS),
3992: DEBUG_REC(CNFPMENABLED,WORDS),
3993: DEBUG_REC(CNFPMEPS,WORDS),
3994: DEBUG_REC(CNFMULTICASTRECEIVE,WORDS),
3995: DEBUG_REC(CNFMAXSLEEPDURATION,WORDS),
3996: DEBUG_REC(CNFPMHOLDOVERDURATION,WORDS),
3997: DEBUG_REC(CNFOWNNAME,STRING),
3998: DEBUG_REC(CNFOWNDTIMPERIOD,WORDS),
3999: DEBUG_REC(CNFMULTICASTPMBUFFERING,WORDS),
4000: DEBUG_REC(CNFWEPENABLED_AGERE,WORDS),
4001: DEBUG_REC(CNFMANDATORYBSSID_SYMBOL,WORDS),
4002: DEBUG_REC(CNFWEPDEFAULTKEYID,WORDS),
4003: DEBUG_REC(CNFDEFAULTKEY0,BYTES),
4004: DEBUG_REC(CNFDEFAULTKEY1,BYTES),
4005: DEBUG_REC(CNFMWOROBUST_AGERE,WORDS),
4006: DEBUG_REC(CNFDEFAULTKEY2,BYTES),
4007: DEBUG_REC(CNFDEFAULTKEY3,BYTES),
4008: DEBUG_REC(CNFWEPFLAGS_INTERSIL,WORDS),
4009: DEBUG_REC(CNFWEPKEYMAPPINGTABLE,WORDS),
4010: DEBUG_REC(CNFAUTHENTICATION,WORDS),
4011: DEBUG_REC(CNFMAXASSOCSTA,WORDS),
4012: DEBUG_REC(CNFKEYLENGTH_SYMBOL,WORDS),
4013: DEBUG_REC(CNFTXCONTROL,WORDS),
4014: DEBUG_REC(CNFROAMINGMODE,WORDS),
4015: DEBUG_REC(CNFHOSTAUTHENTICATION,WORDS),
4016: DEBUG_REC(CNFRCVCRCERROR,WORDS),
4017: DEBUG_REC(CNFMMLIFE,WORDS),
4018: DEBUG_REC(CNFALTRETRYCOUNT,WORDS),
4019: DEBUG_REC(CNFBEACONINT,WORDS),
4020: DEBUG_REC(CNFAPPCFINFO,WORDS),
4021: DEBUG_REC(CNFSTAPCFINFO,WORDS),
4022: DEBUG_REC(CNFPRIORITYQUSAGE,WORDS),
4023: DEBUG_REC(CNFTIMCTRL,WORDS),
4024: DEBUG_REC(CNFTHIRTY2TALLY,WORDS),
4025: DEBUG_REC(CNFENHSECURITY,WORDS),
4026: DEBUG_REC(CNFGROUPADDRESSES,BYTES),
4027: DEBUG_REC(CNFCREATEIBSS,WORDS),
4028: DEBUG_REC(CNFFRAGMENTATIONTHRESHOLD,WORDS),
4029: DEBUG_REC(CNFRTSTHRESHOLD,WORDS),
4030: DEBUG_REC(CNFTXRATECONTROL,WORDS),
4031: DEBUG_REC(CNFPROMISCUOUSMODE,WORDS),
4032: DEBUG_REC(CNFBASICRATES_SYMBOL,WORDS),
4033: DEBUG_REC(CNFPREAMBLE_SYMBOL,WORDS),
4034: DEBUG_REC(CNFSHORTPREAMBLE,WORDS),
4035: DEBUG_REC(CNFWEPKEYS_AGERE,BYTES),
4036: DEBUG_REC(CNFEXCLUDELONGPREAMBLE,WORDS),
4037: DEBUG_REC(CNFTXKEY_AGERE,WORDS),
4038: DEBUG_REC(CNFAUTHENTICATIONRSPTO,WORDS),
4039: DEBUG_REC(CNFBASICRATES,WORDS),
4040: DEBUG_REC(CNFSUPPORTEDRATES,WORDS),
4041: DEBUG_REC(CNFTICKTIME,WORDS),
4042: DEBUG_REC(CNFSCANREQUEST,WORDS),
4043: DEBUG_REC(CNFJOINREQUEST,WORDS),
4044: DEBUG_REC(CNFAUTHENTICATESTATION,WORDS),
4045: DEBUG_REC(CNFCHANNELINFOREQUEST,WORDS),
4046: DEBUG_REC(MAXLOADTIME,WORDS),
4047: DEBUG_REC(DOWNLOADBUFFER,WORDS),
4048: DEBUG_REC(PRIID,WORDS),
4049: DEBUG_REC(PRISUPRANGE,WORDS),
4050: DEBUG_REC(CFIACTRANGES,WORDS),
4051: DEBUG_REC(NICSERNUM,XSTRING),
4052: DEBUG_REC(NICID,WORDS),
4053: DEBUG_REC(MFISUPRANGE,WORDS),
4054: DEBUG_REC(CFISUPRANGE,WORDS),
4055: DEBUG_REC(CHANNELLIST,WORDS),
4056: DEBUG_REC(REGULATORYDOMAINS,WORDS),
4057: DEBUG_REC(TEMPTYPE,WORDS),
4058: /* DEBUG_REC(CIS,BYTES), */
4059: DEBUG_REC(STAID,WORDS),
4060: DEBUG_REC(CURRENTSSID,STRING),
4061: DEBUG_REC(CURRENTBSSID,BYTES),
4062: DEBUG_REC(COMMSQUALITY,WORDS),
4063: DEBUG_REC(CURRENTTXRATE,WORDS),
4064: DEBUG_REC(CURRENTBEACONINTERVAL,WORDS),
4065: DEBUG_REC(CURRENTSCALETHRESHOLDS,WORDS),
4066: DEBUG_REC(PROTOCOLRSPTIME,WORDS),
4067: DEBUG_REC(SHORTRETRYLIMIT,WORDS),
4068: DEBUG_REC(LONGRETRYLIMIT,WORDS),
4069: DEBUG_REC(MAXTRANSMITLIFETIME,WORDS),
4070: DEBUG_REC(MAXRECEIVELIFETIME,WORDS),
4071: DEBUG_REC(CFPOLLABLE,WORDS),
4072: DEBUG_REC(AUTHENTICATIONALGORITHMS,WORDS),
4073: DEBUG_REC(PRIVACYOPTIONIMPLEMENTED,WORDS),
4074: DEBUG_REC(OWNMACADDR,BYTES),
4075: DEBUG_REC(SCANRESULTSTABLE,WORDS),
4076: DEBUG_REC(PHYTYPE,WORDS),
4077: DEBUG_REC(CURRENTCHANNEL,WORDS),
4078: DEBUG_REC(CURRENTPOWERSTATE,WORDS),
4079: DEBUG_REC(CCAMODE,WORDS),
4080: DEBUG_REC(SUPPORTEDDATARATES,WORDS),
4081: DEBUG_REC(BUILDSEQ,BYTES),
4082: DEBUG_REC(FWID,XSTRING)
4083: #undef DEBUG_REC
4084: };
4085:
4086: #define DEBUG_LTV_SIZE 128
4087:
4088: static int orinoco_debug_dump_recs(struct net_device *dev)
4089: {
4090: struct orinoco_private *priv = dev->priv;
4091: hermes_t *hw = &priv->hw;
4092: u8 *val8;
4093: u16 *val16;
4094: int i,j;
4095: u16 length;
4096: int err;
4097:
4098: /* I'm not sure: we might have a lock here, so we'd better go
4099: atomic, just in case. */
4100: val8 = kmalloc(DEBUG_LTV_SIZE + 2, GFP_ATOMIC);
4101: if (! val8)
4102: return -ENOMEM;
4103: val16 = (u16 *)val8;
4104:
4105: for (i = 0; i < ARRAY_SIZE(record_table); i++) {
4106: u16 rid = record_table[i].rid;
4107: int len;
4108:
4109: memset(val8, 0, DEBUG_LTV_SIZE + 2);
4110:
4111: err = hermes_read_ltv(hw, USER_BAP, rid, DEBUG_LTV_SIZE,
4112: &length, val8);
4113: if (err) {
4114: DEBUG(0, "Error %d reading RID 0x%04x\n", err, rid);
4115: continue;
4116: }
4117: val16 = (u16 *)val8;
4118: if (length == 0)
4119: continue;
4120:
4121: printk(KERN_DEBUG "%-15s (0x%04x): length=%d (%d bytes)\tvalue=",
4122: record_table[i].name,
4123: rid, length, (length-1)*2);
4124: len = min(((int)length-1)*2, DEBUG_LTV_SIZE);
4125:
4126: switch (record_table[i].displaytype) {
4127: case DISPLAY_WORDS:
4128: for (j = 0; j < len / 2; j++)
4129: printk("%04X-", le16_to_cpu(val16[j]));
4130: break;
4131:
4132: case DISPLAY_BYTES:
4133: default:
4134: for (j = 0; j < len; j++)
4135: printk("%02X:", val8[j]);
4136: break;
4137:
4138: case DISPLAY_STRING:
4139: len = min(len, le16_to_cpu(val16[0])+2);
4140: val8[len] = '\0';
4141: printk("\"%s\"", (char *)&val16[1]);
4142: break;
4143:
4144: case DISPLAY_XSTRING:
4145: printk("'%s'", (char *)val8);
4146: }
4147:
4148: printk("\n");
4149: }
4150:
4151: kfree(val8);
4152:
4153: return 0;
4154: }
4155:
4156: struct net_device *alloc_orinocodev(int sizeof_card, int (*hard_reset)(struct orinoco_private *))
4157: {
4158: struct net_device *dev;
4159: struct orinoco_private *priv;
4160:
4161: dev = alloc_etherdev(sizeof(struct orinoco_private) + sizeof_card);
4162: priv = (struct orinoco_private *)dev->priv;
4163: priv->ndev = dev;
4164: if (sizeof_card)
4165: priv->card = (void *)((unsigned long)dev->priv + sizeof(struct orinoco_private));
4166: else
4167: priv->card = NULL;
4168:
4169: /* Setup / override net_device fields */
4170: dev->init = orinoco_init;
4171: dev->hard_start_xmit = orinoco_xmit;
4172: #ifdef HAVE_TX_TIMEOUT
4173: dev->tx_timeout = orinoco_tx_timeout;
4174: dev->watchdog_timeo = HZ; /* 1 second timeout */
4175: #endif
4176: dev->get_stats = orinoco_get_stats;
4177: dev->get_wireless_stats = orinoco_get_wireless_stats;
4178: dev->do_ioctl = orinoco_ioctl;
4179: dev->change_mtu = orinoco_change_mtu;
4180: dev->set_multicast_list = orinoco_set_multicast_list;
4181: /* we use the default eth_mac_addr for setting the MAC addr */
4182:
4183: /* Set up default callbacks */
4184: dev->open = orinoco_open;
4185: dev->stop = orinoco_stop;
4186: priv->hard_reset = hard_reset;
4187:
4188: spin_lock_init(&priv->lock);
4189: priv->open = 0;
4190: priv->hw_unavailable = 1; /* orinoco_init() must clear this
4191: * before anything else touches the
4192: * hardware */
4193: INIT_WORK(&priv->reset_work, (void (*)(void *))orinoco_reset, dev);
4194:
4195: priv->last_linkstatus = 0xffff;
4196: priv->connected = 0;
4197:
4198: return dev;
4199:
4200: }
4201:
4202: /********************************************************************/
4203: /* Module initialization */
4204: /********************************************************************/
4205:
4206: EXPORT_SYMBOL(alloc_orinocodev);
4207:
4208: EXPORT_SYMBOL(__orinoco_up);
4209: EXPORT_SYMBOL(__orinoco_down);
4210: EXPORT_SYMBOL(orinoco_stop);
4211: EXPORT_SYMBOL(orinoco_reinit_firmware);
4212:
4213: EXPORT_SYMBOL(orinoco_interrupt);
4214:
4215: /* Can't be declared "const" or the whole __initdata section will
4216: * become const */
4217: static char version[] __initdata = "orinoco.c 0.13e (David Gibson <[email protected]> and others)";
4218:
4219: static int __init init_orinoco(void)
4220: {
4221: printk(KERN_DEBUG "%s\n", version);
4222: return 0;
4223: }
4224:
4225: static void __exit exit_orinoco(void)
4226: {
4227: }
4228:
4229: module_init(init_orinoco);
4230: module_exit(exit_orinoco);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.