开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
airo.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：126k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

airo.c：源码内容
  1. /*======================================================================
  3.     Aironet driver for 4500 and 4800 series cards
  5.     This code is released under both the GPL version 2 and BSD licenses.
  6.     Either license may be used.  The respective licenses are found at
  7.     the end of this file.
  9.     This code was developed by Benjamin Reed <breed@users.sourceforge.net>
  10.     including portions of which come from the Aironet PC4500
  11.     Developer's Reference Manual and used with permission.  Copyright
  12.     (C) 1999 Benjamin Reed.  All Rights Reserved.  Permission to use
  13.     code in the Developer's manual was granted for this driver by
  14.     Aironet.  Major code contributions were received from Javier Achirica
  15.     and Jean Tourrilhes <jt@hpl.hp.com>.  Code was also integrated from
  16.     the Cisco Aironet driver for Linux.
  18. ======================================================================*/
  20. #include <linux/config.h>
  21. #include <linux/version.h>
  22. #include <asm/segment.h>
  23. #include <linux/init.h>
  25. #include <linux/kernel.h>
  26. #include <linux/module.h>
  27. #include <linux/proc_fs.h>
  29. #include <linux/sched.h>
  30. #include <linux/ptrace.h>
  31. #include <linux/slab.h>
  32. #include <linux/string.h>
  33. #include <linux/timer.h>
  34. #include <linux/interrupt.h>
  35. #include <linux/in.h>
  36. #include <asm/io.h>
  37. #include <asm/system.h>
  38. #include <asm/bitops.h>
  40. #include <linux/netdevice.h>
  41. #include <linux/etherdevice.h>
  42. #include <linux/skbuff.h>
  43. #include <linux/if_arp.h>
  44. #include <linux/ioport.h>
  45. #include <linux/config.h>
  46. #include <linux/pci.h>
  47. #include <asm/uaccess.h>
  49. #ifdef CONFIG_PCI
  50. static struct pci_device_id card_ids[] __devinitdata = {
  51. { 0x14b9, 1, PCI_ANY_ID, PCI_ANY_ID, },
  52. { 0x14b9, 0x4500, PCI_ANY_ID, PCI_ANY_ID },
  53. { 0x14b9, 0x4800, PCI_ANY_ID, PCI_ANY_ID, },
  54. { 0x14b9, 0x0340, PCI_ANY_ID, PCI_ANY_ID, },
  55. { 0x14b9, 0x0350, PCI_ANY_ID, PCI_ANY_ID, },
  56. { 0, }
  57. };
  58. MODULE_DEVICE_TABLE(pci, card_ids);
  60. static int airo_pci_probe(struct pci_dev *, const struct pci_device_id *);
  61. static void airo_pci_remove(struct pci_dev *);
  63. static struct pci_driver airo_driver = {
  64. name:     "airo",
  65. id_table: card_ids,
  66. probe:    airo_pci_probe,
  67. remove:   __devexit_p(airo_pci_remove),
  68. };
  69. #endif /* CONFIG_PCI */
  71. /* Include Wireless Extension definition and check version - Jean II */
  72. #include <linux/wireless.h>
  73. #define WIRELESS_SPY // enable iwspy support
  74. #if WIRELESS_EXT < 9
  75. #warning "Wireless extension v9 or newer required - please upgrade your kernel"
  76. #undef WIRELESS_EXT
  77. #undef WIRELESS_SPY
  78. #endif
  79. #define CISCO_EXT // enable Cisco extensions
  81. #ifdef CISCO_EXT
  82. #include <linux/delay.h>
  83. #endif
  85. /* As you can see this list is HUGH!
  86.    I really don't know what a lot of these counts are about, but they
  87.    are all here for completeness.  If the IGNLABEL macro is put in
  88.    infront of the label, that statistic will not be included in the list
  89.    of statistics in the /proc filesystem */
  91. #define IGNLABEL 0&(int)
  92. static char *statsLabels[] = {
  93. "RxOverrun",
  94. IGNLABEL "RxPlcpCrcErr",
  95. IGNLABEL "RxPlcpFormatErr",
  96. IGNLABEL "RxPlcpLengthErr",
  97. "RxMacCrcErr",
  98. "RxMacCrcOk",
  99. "RxWepErr",
  100. "RxWepOk",
  101. "RetryLong",
  102. "RetryShort",
  103. "MaxRetries",
  104. "NoAck",
  105. "NoCts",
  106. "RxAck",
  107. "RxCts",
  108. "TxAck",
  109. "TxRts",
  110. "TxCts",
  111. "TxMc",
  112. "TxBc",
  113. "TxUcFrags",
  114. "TxUcPackets",
  115. "TxBeacon",
  116. "RxBeacon",
  117. "TxSinColl",
  118. "TxMulColl",
  119. "DefersNo",
  120. "DefersProt",
  121. "DefersEngy",
  122. "DupFram",
  123. "RxFragDisc",
  124. "TxAged",
  125. "RxAged",
  126. "LostSync-MaxRetry",
  127. "LostSync-MissedBeacons",
  128. "LostSync-ArlExceeded",
  129. "LostSync-Deauth",
  130. "LostSync-Disassoced",
  131. "LostSync-TsfTiming",
  132. "HostTxMc",
  133. "HostTxBc",
  134. "HostTxUc",
  135. "HostTxFail",
  136. "HostRxMc",
  137. "HostRxBc",
  138. "HostRxUc",
  139. "HostRxDiscard",
  140. IGNLABEL "HmacTxMc",
  141. IGNLABEL "HmacTxBc",
  142. IGNLABEL "HmacTxUc",
  143. IGNLABEL "HmacTxFail",
  144. IGNLABEL "HmacRxMc",
  145. IGNLABEL "HmacRxBc",
  146. IGNLABEL "HmacRxUc",
  147. IGNLABEL "HmacRxDiscard",
  148. IGNLABEL "HmacRxAccepted",
  149. "SsidMismatch",
  150. "ApMismatch",
  151. "RatesMismatch",
  152. "AuthReject",
  153. "AuthTimeout",
  154. "AssocReject",
  155. "AssocTimeout",
  156. IGNLABEL "ReasonOutsideTable",
  157. IGNLABEL "ReasonStatus1",
  158. IGNLABEL "ReasonStatus2",
  159. IGNLABEL "ReasonStatus3",
  160. IGNLABEL "ReasonStatus4",
  161. IGNLABEL "ReasonStatus5",
  162. IGNLABEL "ReasonStatus6",
  163. IGNLABEL "ReasonStatus7",
  164. IGNLABEL "ReasonStatus8",
  165. IGNLABEL "ReasonStatus9",
  166. IGNLABEL "ReasonStatus10",
  167. IGNLABEL "ReasonStatus11",
  168. IGNLABEL "ReasonStatus12",
  169. IGNLABEL "ReasonStatus13",
  170. IGNLABEL "ReasonStatus14",
  171. IGNLABEL "ReasonStatus15",
  172. IGNLABEL "ReasonStatus16",
  173. IGNLABEL "ReasonStatus17",
  174. IGNLABEL "ReasonStatus18",
  175. IGNLABEL "ReasonStatus19",
  176. "RxMan",
  177. "TxMan",
  178. "RxRefresh",
  179. "TxRefresh",
  180. "RxPoll",
  181. "TxPoll",
  182. "HostRetries",
  183. "LostSync-HostReq",
  184. "HostTxBytes",
  185. "HostRxBytes",
  186. "ElapsedUsec",
  187. "ElapsedSec",
  188. "LostSyncBetterAP",
  189. "PrivacyMismatch",
  190. "Jammed",
  191. "DiscRxNotWepped",
  192. "PhyEleMismatch",
  193. (char*)-1 };
  194. #ifndef RUN_AT
  195. #define RUN_AT(x) (jiffies+(x))
  196. #endif
  199. /* These variables are for insmod, since it seems that the rates
  200.    can only be set in setup_card.  Rates should be a comma separated
  201.    (no spaces) list of rates (up to 8). */
  203. static int rates[8];
  204. static int basic_rate;
  205. static char *ssids[3];
  207. static int io[4];
  208. static int irq[4];
  210. static
  211. int maxencrypt /* = 0 */; /* The highest rate that the card can encrypt at.
  212.        0 means no limit.  For old cards this was 4 */
  214. static int auto_wep /* = 0 */; /* If set, it tries to figure out the wep mode */
  215. static int aux_bap /* = 0 */; /* Checks to see if the aux ports are needed to read
  216.     the bap, needed on some older cards and buses. */
  217. static int adhoc;
  219. static int proc_uid /* = 0 */;
  221. static int proc_gid /* = 0 */;
  223. static int airo_perm = 0555;
  225. static int proc_perm = 0644;
  227. MODULE_AUTHOR("Benjamin Reed");
  228. MODULE_DESCRIPTION("Support for Cisco/Aironet 802.11 wireless ethernet 
  229.                    cards.  Direct support for ISA/PCI cards and support 
  230.    for PCMCIA when used with airo_cs.");
  231. MODULE_LICENSE("Dual BSD/GPL");
  232. MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340");
  233. MODULE_PARM(io,"1-4i");
  234. MODULE_PARM(irq,"1-4i");
  235. MODULE_PARM(basic_rate,"i");
  236. MODULE_PARM(rates,"1-8i");
  237. MODULE_PARM(ssids,"1-3s");
  238. MODULE_PARM(auto_wep,"i");
  239. MODULE_PARM_DESC(auto_wep, "If non-zero, the driver will keep looping through 
  240. the authentication options until an association is made.  The value of 
  241. auto_wep is number of the wep keys to check.  A value of 2 will try using 
  242. the key at index 0 and index 1.");
  243. MODULE_PARM(aux_bap,"i");
  244. MODULE_PARM_DESC(aux_bap, "If non-zero, the driver will switch into a mode 
  245. than seems to work better for older cards with some older buses.  Before 
  246. switching it checks that the switch is needed.");
  247. MODULE_PARM(maxencrypt, "i");
  248. MODULE_PARM_DESC(maxencrypt, "The maximum speed that the card can do 
  249. encryption.  Units are in 512kbs.  Zero (default) means there is no limit. 
  250. Older cards used to be limited to 2mbs (4).");
  251. MODULE_PARM(adhoc, "i");
  252. MODULE_PARM_DESC(adhoc, "If non-zero, the card will start in adhoc mode.");
  254. MODULE_PARM(proc_uid, "i");
  255. MODULE_PARM_DESC(proc_uid, "The uid that the /proc files will belong to.");
  256. MODULE_PARM(proc_gid, "i");
  257. MODULE_PARM_DESC(proc_gid, "The gid that the /proc files will belong to.");
  258. MODULE_PARM(airo_perm, "i");
  259. MODULE_PARM_DESC(airo_perm, "The permission bits of /proc/[driver/]aironet.");
  260. MODULE_PARM(proc_perm, "i");
  261. MODULE_PARM_DESC(proc_perm, "The permission bits of the files in /proc");
  263. #include <asm/uaccess.h>
  265. /* This is a kind of sloppy hack to get this information to OUT4500 and
  266.    IN4500.  I would be extremely interested in the situation where this
  267.    doesnt work though!!! */
  268. static int do8bitIO = 0;
  270. /* Return codes */
  271. #define SUCCESS 0
  272. #define ERROR -1
  273. #define NO_PACKET -2
  275. /* Commands */
  276. #define NOP 0x0010
  277. #define MAC_ENABLE 0x0001
  278. #define MAC_DISABLE 0x0002
  279. #define CMD_LOSE_SYNC 0x0003 /* Not sure what this does... */
  280. #define CMD_ACCESS 0x0021
  281. #define CMD_ALLOCATETX 0x000a
  282. #define CMD_TRANSMIT 0x000b
  283. #define HOSTSLEEP 0x85
  284. #define CMD_SETMODE 0x0009
  285. #define CMD_ENABLEAUX 0x0111
  286. #define CMD_SOFTRESET 0x0004
  287. #define CMD_LISTBSS 0x0103
  289. /* Registers */
  290. #define COMMAND 0x00
  291. #define PARAM0 0x02
  292. #define PARAM1 0x04
  293. #define PARAM2 0x06
  294. #define STATUS 0x08
  295. #define RESP0 0x0a
  296. #define RESP1 0x0c
  297. #define RESP2 0x0e
  298. #define LINKSTAT 0x10
  299. #define SELECT0 0x18
  300. #define OFFSET0 0x1c
  301. #define RXFID 0x20
  302. #define TXALLOCFID 0x22
  303. #define TXCOMPLFID 0x24
  304. #define DATA0 0x36
  305. #define EVSTAT 0x30
  306. #define EVINTEN 0x32
  307. #define EVACK 0x34
  308. #define SWS0 0x28
  309. #define SWS1 0x2a
  310. #define SWS2 0x2c
  311. #define SWS3 0x2e
  312. #define AUXPAGE 0x3A
  313. #define AUXOFF 0x3C
  314. #define AUXDATA 0x3E
  316. /* BAP selectors */
  317. #define BAP0 0 // Used for receiving packets
  318. #define BAP1 2 // Used for xmiting packets and working with RIDS
  320. /* Flags */
  321. #define COMMAND_BUSY 0x8000
  323. #define BAP_BUSY 0x8000
  324. #define BAP_ERR 0x4000
  325. #define BAP_DONE 0x2000
  327. #define PROMISC 0xffff
  328. #define NOPROMISC 0x0000
  330. #define EV_CMD 0x10
  331. #define EV_CLEARCOMMANDBUSY 0x4000
  332. #define EV_RX 0x01
  333. #define EV_TX 0x02
  334. #define EV_TXEXC 0x04
  335. #define EV_ALLOC 0x08
  336. #define EV_LINK 0x80
  337. #define EV_AWAKE 0x100
  338. #define EV_UNKNOWN 0x800
  339. #define STATUS_INTS ( EV_AWAKE | EV_LINK | EV_TXEXC | EV_TX | EV_RX)
  340. #define IGNORE_INTS ( EV_CMD | EV_UNKNOWN)
  342. /* The RIDs */
  343. #define RID_CAPABILITIES 0xFF00
  344. #define RID_APINFO     0xFF01
  345. #define RID_RADIOINFO  0xFF02
  346. #define RID_UNKNOWN3   0xFF03
  347. #define RID_RSSI       0xFF04
  348. #define RID_CONFIG     0xFF10
  349. #define RID_SSID       0xFF11
  350. #define RID_APLIST     0xFF12
  351. #define RID_DRVNAME    0xFF13
  352. #define RID_ETHERENCAP 0xFF14
  353. #define RID_WEP_TEMP   0xFF15
  354. #define RID_WEP_PERM   0xFF16
  355. #define RID_MODULATION 0xFF17
  356. #define RID_OPTIONS    0xFF18
  357. #define RID_ACTUALCONFIG 0xFF20 /*readonly*/
  358. #define RID_FACTORYCONFIG 0xFF21
  359. #define RID_UNKNOWN22  0xFF22
  360. #define RID_LEAPUSERNAME 0xFF23
  361. #define RID_LEAPPASSWORD 0xFF24
  362. #define RID_STATUS     0xFF50
  363. #define RID_UNKNOWN52  0xFF52
  364. #define RID_UNKNOWN54  0xFF54
  365. #define RID_UNKNOWN55  0xFF55
  366. #define RID_UNKNOWN56  0xFF56
  367. #define RID_STATS16    0xFF60
  368. #define RID_STATS16DELTA 0xFF61
  369. #define RID_STATS16DELTACLEAR 0xFF62
  370. #define RID_STATS      0xFF68
  371. #define RID_STATSDELTA 0xFF69
  372. #define RID_STATSDELTACLEAR 0xFF6A
  373. #define RID_UNKNOWN70  0xFF70
  374. #define RID_UNKNOWN71  0xFF71
  375. #define RID_BSSLISTFIRST 0xFF72
  376. #define RID_BSSLISTNEXT  0xFF73
  378. typedef struct {
  379. u16 cmd;
  380. u16 parm0;
  381. u16 parm1;
  382. u16 parm2;
  383. } Cmd;
  385. typedef struct {
  386. u16 status;
  387. u16 rsp0;
  388. u16 rsp1;
  389. u16 rsp2;
  390. } Resp;
  392. /*
  393.  * Rids and endian-ness:  The Rids will always be in cpu endian, since
  394.  * this all the patches from the big-endian guys end up doing that.
  395.  * so all rid access should use the read/writeXXXRid routines.
  396.  */
  398. /* This is redundant for x86 archs, but it seems necessary for ARM */
  399. #pragma pack(1)
  401. /* This structure came from an email sent to me from an engineer at
  402.    aironet for inclusion into this driver */
  403. typedef struct {
  404. u16 len;
  405. u16 kindex;
  406. u8 mac[6];
  407. u16 klen;
  408. u8 key[16];
  409. } WepKeyRid;
  411. /* These structures are from the Aironet's PC4500 Developers Manual */
  412. typedef struct {
  413. u16 len;
  414. u8 ssid[32];
  415. } Ssid;
  417. typedef struct {
  418. u16 len;
  419. Ssid ssids[3];
  420. } SsidRid;
  422. typedef struct {
  423.         u16 len;
  424.         u16 modulation;
  425. #define MOD_DEFAULT 0
  426. #define MOD_CCK 1
  427. #define MOD_MOK 2
  428. } ModulationRid;
  430. typedef struct {
  431. u16 len; /* sizeof(ConfigRid) */
  432. u16 opmode; /* operating mode */
  433. #define MODE_STA_IBSS 0
  434. #define MODE_STA_ESS 1
  435. #define MODE_AP 2
  436. #define MODE_AP_RPTR 3
  437. #define MODE_ETHERNET_HOST (0<<8) /* rx payloads converted */
  438. #define MODE_LLC_HOST (1<<8) /* rx payloads left as is */
  439. #define MODE_AIRONET_EXTEND (1<<9) /* enable Aironet extenstions */
  440. #define MODE_AP_INTERFACE (1<<10) /* enable ap interface extensions */
  441. #define MODE_ANTENNA_ALIGN (1<<11) /* enable antenna alignment */
  442. #define MODE_ETHER_LLC (1<<12) /* enable ethernet LLC */
  443. #define MODE_LEAF_NODE (1<<13) /* enable leaf node bridge */
  444. #define MODE_CF_POLLABLE (1<<14) /* enable CF pollable */
  445. u16 rmode; /* receive mode */
  446. #define RXMODE_BC_MC_ADDR 0
  447. #define RXMODE_BC_ADDR 1 /* ignore multicasts */
  448. #define RXMODE_ADDR 2 /* ignore multicast and broadcast */
  449. #define RXMODE_RFMON 3 /* wireless monitor mode */
  450. #define RXMODE_RFMON_ANYBSS 4
  451. #define RXMODE_LANMON 5 /* lan style monitor -- data packets only */
  452. #define RXMODE_DISABLE_802_3_HEADER (1<<8) /* disables 802.3 header on rx */
  453. #define RXMODE_NORMALIZED_RSSI (1<<9) /* return normalized RSSI */
  454. u16 fragThresh;
  455. u16 rtsThres;
  456. u8 macAddr[6];
  457. u8 rates[8];
  458. u16 shortRetryLimit;
  459. u16 longRetryLimit;
  460. u16 txLifetime; /* in kusec */
  461. u16 rxLifetime; /* in kusec */
  462. u16 stationary;
  463. u16 ordering;
  464. u16 u16deviceType; /* for overriding device type */
  465. u16 cfpRate;
  466. u16 cfpDuration;
  467. u16 _reserved1[3];
  468. /*---------- Scanning/Associating ----------*/
  469. u16 scanMode;
  470. #define SCANMODE_ACTIVE 0
  471. #define SCANMODE_PASSIVE 1
  472. #define SCANMODE_AIROSCAN 2
  473. u16 probeDelay; /* in kusec */
  474. u16 probeEnergyTimeout; /* in kusec */
  475.         u16 probeResponseTimeout;
  476. u16 beaconListenTimeout;
  477. u16 joinNetTimeout;
  478. u16 authTimeout;
  479. u16 authType;
  480. #define AUTH_OPEN 0x1
  481. #define AUTH_ENCRYPT 0x101
  482. #define AUTH_SHAREDKEY 0x102
  483. #define AUTH_ALLOW_UNENCRYPTED 0x200
  484. u16 associationTimeout;
  485. u16 specifiedApTimeout;
  486. u16 offlineScanInterval;
  487. u16 offlineScanDuration;
  488. u16 linkLossDelay;
  489. u16 maxBeaconLostTime;
  490. u16 refreshInterval;
  491. #define DISABLE_REFRESH 0xFFFF
  492. u16 _reserved1a[1];
  493. /*---------- Power save operation ----------*/
  494. u16 powerSaveMode;
  495. #define POWERSAVE_CAM 0
  496. #define POWERSAVE_PSP 1
  497. #define POWERSAVE_PSPCAM 2
  498. u16 sleepForDtims;
  499. u16 listenInterval;
  500. u16 fastListenInterval;
  501. u16 listenDecay;
  502. u16 fastListenDelay;
  503. u16 _reserved2[2];
  504. /*---------- Ap/Ibss config items ----------*/
  505. u16 beaconPeriod;
  506. u16 atimDuration;
  507. u16 hopPeriod;
  508. u16 channelSet;
  509. u16 channel;
  510. u16 dtimPeriod;
  511. u16 bridgeDistance;
  512. u16 radioID;
  513. /*---------- Radio configuration ----------*/
  514. u16 radioType;
  515. #define RADIOTYPE_DEFAULT 0
  516. #define RADIOTYPE_802_11 1
  517. #define RADIOTYPE_LEGACY 2
  518. u8 rxDiversity;
  519. u8 txDiversity;
  520. u16 txPower;
  521. #define TXPOWER_DEFAULT 0
  522. u16 rssiThreshold;
  523. #define RSSI_DEFAULT 0
  524.         u16 modulation;
  525. #define PREAMBLE_AUTO 0
  526. #define PREAMBLE_LONG 1
  527. #define PREAMBLE_SHORT 2
  528. u16 preamble;
  529. u16 homeProduct;
  530. u16 radioSpecific;
  531. /*---------- Aironet Extensions ----------*/
  532. u8 nodeName[16];
  533. u16 arlThreshold;
  534. u16 arlDecay;
  535. u16 arlDelay;
  536. u16 _reserved4[1];
  537. /*---------- Aironet Extensions ----------*/
  538. u16 magicAction;
  539. #define MAGIC_ACTION_STSCHG 1
  540. #define MACIC_ACTION_RESUME 2
  541. #define MAGIC_IGNORE_MCAST (1<<8)
  542. #define MAGIC_IGNORE_BCAST (1<<9)
  543. #define MAGIC_SWITCH_TO_PSP (0<<10)
  544. #define MAGIC_STAY_IN_CAM (1<<10)
  545. u16 magicControl;
  546. u16 autoWake;
  547. } ConfigRid;
  549. typedef struct {
  550. u16 len;
  551. u8 mac[6];
  552. u16 mode;
  553. u16 errorCode;
  554. u16 sigQuality;
  555. u16 SSIDlen;
  556. char SSID[32];
  557. char apName[16];
  558. char bssid[4][6];
  559. u16 beaconPeriod;
  560. u16 dimPeriod;
  561. u16 atimDuration;
  562. u16 hopPeriod;
  563. u16 channelSet;
  564. u16 channel;
  565. u16 hopsToBackbone;
  566. u16 apTotalLoad;
  567. u16 generatedLoad;
  568. u16 accumulatedArl;
  569. u16 signalQuality;
  570. u16 currentXmitRate;
  571. u16 apDevExtensions;
  572. u16 normalizedSignalStrength;
  573. u16 _reserved[10];
  574. } StatusRid;
  576. typedef struct {
  577. u16 len;
  578. u16 spacer;
  579. u32 vals[100];
  580. } StatsRid;
  583. typedef struct {
  584. u16 len;
  585. u8 ap[4][6];
  586. } APListRid;
  588. typedef struct {
  589. u16 len;
  590. char oui[3];
  591. char zero;
  592. u16 prodNum;
  593. char manName[32];
  594. char prodName[16];
  595. char prodVer[8];
  596. char factoryAddr[6];
  597. char aironetAddr[6];
  598. u16 radioType;
  599. u16 country;
  600. char callid[6];
  601. char supportedRates[8];
  602. char rxDiversity;
  603. char txDiversity;
  604. u16 txPowerLevels[8];
  605. u16 hardVer;
  606. u16 hardCap;
  607. u16 tempRange;
  608. u16 softVer;
  609. u16 softSubVer;
  610. u16 interfaceVer;
  611. u16 softCap;
  612. u16 bootBlockVer;
  613. u16 requiredHard;
  614. } CapabilityRid;
  616. typedef struct {
  617.   u16 len;
  618.   u16 index; /* First is 0 and 0xffff means end of list */
  619. #define RADIO_FH 1 /* Frequency hopping radio type */
  620. #define RADIO_DS 2 /* Direct sequence radio type */
  621. #define RADIO_TMA 4 /* Proprietary radio used in old cards (2500) */
  622.   u16 radioType;
  623.   u8 bssid[6]; /* Mac address of the BSS */
  624.   u8 zero;
  625.   u8 ssidLen;
  626.   u8 ssid[32];
  627.   u16 rssi;
  628. #define CAP_ESS (1<<0)
  629. #define CAP_IBSS (1<<1)
  630. #define CAP_PRIVACY (1<<4)
  631. #define CAP_SHORTHDR (1<<5)
  632.   u16 cap;
  633.   u16 beaconInterval;
  634.   u8 rates[8]; /* Same as rates for config rid */
  635.   struct { /* For frequency hopping only */
  636.     u16 dwell;
  637.     u8 hopSet;
  638.     u8 hopPattern;
  639.     u8 hopIndex;
  640.     u8 fill;
  641.   } fh;
  642.   u16 dsChannel;
  643.   u16 atimWindow;
  644. } BSSListRid;
  646. typedef struct {
  647.   u8 rssipct;
  648.   u8 rssidBm;
  649. } tdsRssiEntry;
  651. typedef struct {
  652.   u16 len;
  653.   tdsRssiEntry x[256];
  654. } tdsRssiRid;
  656. #pragma pack()
  658. #define TXCTL_TXOK (1<<1) /* report if tx is ok */
  659. #define TXCTL_TXEX (1<<2) /* report if tx fails */
  660. #define TXCTL_802_3 (0<<3) /* 802.3 packet */
  661. #define TXCTL_802_11 (1<<3) /* 802.11 mac packet */
  662. #define TXCTL_ETHERNET (0<<4) /* payload has ethertype */
  663. #define TXCTL_LLC (1<<4) /* payload is llc */
  664. #define TXCTL_RELEASE (0<<5) /* release after completion */
  665. #define TXCTL_NORELEASE (1<<5) /* on completion returns to host */
  667. #define BUSY_FID 0x10000
  669. #ifdef CISCO_EXT
  670. #define AIROMAGIC 0xa55a
  671. /* Warning : SIOCDEVPRIVATE may disapear during 2.5.X - Jean II */
  672. #ifdef SIOCIWFIRSTPRIV
  673. #ifdef SIOCDEVPRIVATE
  674. #define AIROOLDIOCTL SIOCDEVPRIVATE
  675. #define AIROOLDIDIFC  AIROOLDIOCTL + 1
  676. #endif /* SIOCDEVPRIVATE */
  677. #else /* SIOCIWFIRSTPRIV */
  678. #define SIOCIWFIRSTPRIV SIOCDEVPRIVATE
  679. #endif /* SIOCIWFIRSTPRIV */
  680. #define AIROIOCTL SIOCIWFIRSTPRIV
  681. #define AIROIDIFC  AIROIOCTL + 1
  683. /* Ioctl constants to be used in airo_ioctl.command */
  685. #define AIROGCAP   0 // Capability rid
  686. #define AIROGCFG 1       // USED A LOT
  687. #define AIROGSLIST 2 // System ID list
  688. #define AIROGVLIST 3       // List of specified AP's
  689. #define AIROGDRVNAM 4 //  NOTUSED
  690. #define AIROGEHTENC 5 // NOTUSED
  691. #define AIROGWEPKTMP 6
  692. #define AIROGWEPKNV 7
  693. #define AIROGSTAT 8
  694. #define AIROGSTATSC32 9
  695. #define AIROGSTATSD32 10
  697. /* Leave gap of 40 commands after AIROGSTATSD32 for future */
  699. #define AIROPCAP                AIROGSTATSD32 + 40
  700. #define AIROPVLIST              AIROPCAP      + 1
  701. #define AIROPSLIST AIROPVLIST    + 1
  702. #define AIROPCFG AIROPSLIST    + 1
  703. #define AIROPSIDS AIROPCFG      + 1
  704. #define AIROPAPLIST AIROPSIDS     + 1
  705. #define AIROPMACON AIROPAPLIST   + 1 /* Enable mac  */
  706. #define AIROPMACOFF AIROPMACON    + 1  /* Disable mac */
  707. #define AIROPSTCLR AIROPMACOFF   + 1
  708. #define AIROPWEPKEY AIROPSTCLR    + 1
  709. #define AIROPWEPKEYNV AIROPWEPKEY   + 1
  710. #define AIROPLEAPPWD            AIROPWEPKEYNV + 1
  711. #define AIROPLEAPUSR            AIROPLEAPPWD  + 1
  713. /* Flash codes */
  715. #define AIROFLSHRST        AIROPWEPKEYNV  + 40
  716. #define AIROFLSHGCHR           AIROFLSHRST    + 1
  717. #define AIROFLSHSTFL           AIROFLSHGCHR   + 1
  718. #define AIROFLSHPCHR           AIROFLSHSTFL   + 1
  719. #define AIROFLPUTBUF           AIROFLSHPCHR   + 1
  720. #define AIRORESTART            AIROFLPUTBUF   + 1
  722. #define FLASHSIZE 32768
  724. typedef struct aironet_ioctl {
  725. unsigned short command; // What to do
  726. unsigned short len; // Len of data
  727. unsigned char *data; // d-data
  728. } aironet_ioctl;
  729. #endif /* CISCO_EXT */
  731. #ifdef WIRELESS_EXT
  732. // Frequency list (map channels to frequencies)
  733. const long frequency_list[] = { 2412, 2417, 2422, 2427, 2432, 2437, 2442,
  734. 2447, 2452, 2457, 2462, 2467, 2472, 2484 };
  736. // A few details needed for WEP (Wireless Equivalent Privacy)
  737. #define MAX_KEY_SIZE 13 // 128 (?) bits
  738. #define MIN_KEY_SIZE  5 // 40 bits RC4 - WEP
  739. typedef struct wep_key_t {
  740. u16 len;
  741. u8 key[16]; /* 40-bit and 104-bit keys */
  742. } wep_key_t;
  743. #endif /* WIRELESS_EXT */
  745. static const char version[] = "airo.c 0.3 (Ben Reed & Javier Achirica)";
  747. struct airo_info;
  749. static int get_dec_u16( char *buffer, int *start, int limit );
  750. static void OUT4500( struct airo_info *, u16 register, u16 value );
  751. static unsigned short IN4500( struct airo_info *, u16 register );
  752. static u16 setup_card(struct airo_info*, u8 *mac, ConfigRid *);
  753. static void enable_interrupts(struct airo_info*);
  754. static void disable_interrupts(struct airo_info*);
  755. static u16 lock_issuecommand(struct airo_info*, Cmd *pCmd, Resp *pRsp);
  756. static u16 issuecommand(struct airo_info*, Cmd *pCmd, Resp *pRsp);
  757. static int bap_setup(struct airo_info*, u16 rid, u16 offset, int whichbap);
  758. static int aux_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
  759. int whichbap);
  760. static int fast_bap_read(struct airo_info*, u16 *pu16Dst, int bytelen,
  761.  int whichbap);
  762. static int bap_write(struct airo_info*, const u16 *pu16Src, int bytelen,
  763.      int whichbap);
  764. static int PC4500_accessrid(struct airo_info*, u16 rid, u16 accmd);
  765. static int PC4500_readrid(struct airo_info*, u16 rid, void *pBuf, int len);
  766. static int PC4500_writerid(struct airo_info*, u16 rid, const void
  767.    *pBuf, int len);
  768. static int do_writerid( struct airo_info*, u16 rid, const void *rid_data,
  769. int len );
  770. static u16 transmit_allocate(struct airo_info*, int lenPayload);
  771. static int transmit_802_3_packet(struct airo_info*, u16 TxFid, char
  772.  *pPacket, int len);
  774. static void airo_interrupt( int irq, void* dev_id, struct pt_regs
  775.     *regs);
  776. static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
  777. #ifdef WIRELESS_EXT
  778. struct iw_statistics *airo_get_wireless_stats (struct net_device *dev);
  779. #endif /* WIRELESS_EXT */
  780. #ifdef CISCO_EXT
  781. static int readrids(struct net_device *dev, aironet_ioctl *comp);
  782. static int writerids(struct net_device *dev, aironet_ioctl *comp);
  783. int flashcard(struct net_device *dev, aironet_ioctl *comp);
  784. #endif /* CISCO_EXT */
  786. struct airo_info {
  787. struct net_device_stats stats;
  788. int open;
  789. struct net_device             *dev;
  790. /* Note, we can have MAX_FIDS outstanding.  FIDs are 16-bits, so we
  791.    use the high bit to mark wether it is in use. */
  792. #define MAX_FIDS 6
  793. int                           fids[MAX_FIDS];
  794. int registered;
  795. ConfigRid config;
  796. u16 authtype; // Used with auto_wep
  797. char keyindex; // Used with auto wep
  798. char defindex; // Used with auto wep
  799. struct timer_list timer;
  800. struct proc_dir_entry *proc_entry;
  801. struct airo_info *next;
  802.         spinlock_t aux_lock;
  803.         spinlock_t main_lock;
  804.         int flags;
  805. #define FLAG_PROMISC   IFF_PROMISC
  806. #define FLAG_RADIO_OFF 0x02
  807. int (*bap_read)(struct airo_info*, u16 *pu16Dst, int bytelen,
  808. int whichbap);
  809. int (*header_parse)(struct sk_buff*, unsigned char *);
  810. unsigned short *flash;
  811. tdsRssiEntry *rssi;
  812. #ifdef WIRELESS_EXT
  813. int need_commit; // Need to set config
  814. struct iw_statistics wstats; // wireless stats
  815. #ifdef WIRELESS_SPY
  816. int spy_number;
  817. u_char spy_address[IW_MAX_SPY][6];
  818. struct iw_quality spy_stat[IW_MAX_SPY];
  819. #endif /* WIRELESS_SPY */
  820. #endif /* WIRELESS_EXT */
  821. };
  823. static inline int bap_read(struct airo_info *ai, u16 *pu16Dst, int bytelen,
  824.    int whichbap) {
  825. return ai->bap_read(ai, pu16Dst, bytelen, whichbap);
  826. }
  828. static int setup_proc_entry( struct net_device *dev,
  829.      struct airo_info *apriv );
  830. static int takedown_proc_entry( struct net_device *dev,
  831. struct airo_info *apriv );
  833. static int readBSSListRid(struct airo_info *ai, int first,
  834.       BSSListRid *list) {
  835. int rc;
  836. Cmd cmd;
  837. Resp rsp;
  839. if (first == 1) {
  840. memset(&cmd, 0, sizeof(cmd));
  841. cmd.cmd=CMD_LISTBSS;
  842. lock_issuecommand(ai, &cmd, &rsp);
  843. /* Let the command take effect */
  844. set_current_state (TASK_INTERRUPTIBLE);
  845. schedule_timeout (3*HZ);
  846. }
  847. rc = PC4500_readrid(ai,
  848.             first ? RID_BSSLISTFIRST : RID_BSSLISTNEXT,
  849.     list, sizeof(*list));
  851. list->len = le16_to_cpu(list->len);
  852. list->index = le16_to_cpu(list->index);
  853. list->radioType = le16_to_cpu(list->radioType);
  854. list->cap = le16_to_cpu(list->cap);
  855. list->beaconInterval = le16_to_cpu(list->beaconInterval);
  856. list->fh.dwell = le16_to_cpu(list->fh.dwell);
  857. list->dsChannel = le16_to_cpu(list->dsChannel);
  858. list->atimWindow = le16_to_cpu(list->atimWindow);
  859. return rc;
  860. }
  862. static int readWepKeyRid(struct airo_info*ai, WepKeyRid *wkr, int temp) {
  863. int rc = PC4500_readrid(ai, temp ? RID_WEP_TEMP : RID_WEP_PERM,
  864. wkr, sizeof(*wkr));
  866. wkr->len = le16_to_cpu(wkr->len);
  867. wkr->kindex = le16_to_cpu(wkr->kindex);
  868. wkr->klen = le16_to_cpu(wkr->klen);
  869. return rc;
  870. }
  871. /* In the writeXXXRid routines we copy the rids so that we don't screwup
  872.  * the originals when we endian them... */
  873. static int writeWepKeyRid(struct airo_info*ai, WepKeyRid *pwkr, int perm) {
  874. int rc;
  875. WepKeyRid wkr = *pwkr;
  877. wkr.len = cpu_to_le16(wkr.len);
  878. wkr.kindex = cpu_to_le16(wkr.kindex);
  879. wkr.klen = cpu_to_le16(wkr.klen);
  880. rc = do_writerid(ai, RID_WEP_TEMP, &wkr, sizeof(wkr));
  881. if (rc!=SUCCESS) printk(KERN_ERR "airo:  WEP_TEMP set %xn", rc);
  882. if (perm) {
  883. rc = do_writerid(ai, RID_WEP_PERM, &wkr, sizeof(wkr));
  884. if (rc!=SUCCESS) {
  885. printk(KERN_ERR "airo:  WEP_PERM set %xn", rc);
  886. }
  887. }
  888. return rc;
  889. }
  891. static int readSsidRid(struct airo_info*ai, SsidRid *ssidr) {
  892. int i;
  893. int rc = PC4500_readrid(ai, RID_SSID, ssidr, sizeof(*ssidr));
  895. ssidr->len = le16_to_cpu(ssidr->len);
  896. for(i = 0; i < 3; i++) {
  897. ssidr->ssids[i].len = le16_to_cpu(ssidr->ssids[i].len);
  898. }
  899. return rc;
  900. }
  901. static int writeSsidRid(struct airo_info*ai, SsidRid *pssidr) {
  902. int rc;
  903. int i;
  904. SsidRid ssidr = *pssidr;
  906. ssidr.len = cpu_to_le16(ssidr.len);
  907. for(i = 0; i < 3; i++) {
  908. ssidr.ssids[i].len = cpu_to_le16(ssidr.ssids[i].len);
  909. }
  910. rc = do_writerid(ai, RID_SSID, &ssidr, sizeof(ssidr));
  911. return rc;
  912. }
  913. static int readConfigRid(struct airo_info*ai, ConfigRid *cfgr) {
  914. int rc = PC4500_readrid(ai, RID_ACTUALCONFIG, cfgr, sizeof(*cfgr));
  915. u16 *s;
  917. for(s = &cfgr->len; s <= &cfgr->rtsThres; s++) *s = le16_to_cpu(*s);
  919. for(s = &cfgr->shortRetryLimit; s <= &cfgr->radioType; s++)
  920. *s = le16_to_cpu(*s);
  922. for(s = &cfgr->txPower; s <= &cfgr->radioSpecific; s++)
  923. *s = le16_to_cpu(*s);
  925. for(s = &cfgr->arlThreshold; s <= &cfgr->autoWake; s++)
  926. *s = le16_to_cpu(*s);
  928. return rc;
  929. }
  930. static int writeConfigRid(struct airo_info*ai, ConfigRid *pcfgr) {
  931. u16 *s;
  932. ConfigRid cfgr = *pcfgr;
  934. for(s = &cfgr.len; s <= &cfgr.rtsThres; s++) *s = cpu_to_le16(*s);
  936. for(s = &cfgr.shortRetryLimit; s <= &cfgr.radioType; s++)
  937. *s = cpu_to_le16(*s);
  939. for(s = &cfgr.txPower; s <= &cfgr.radioSpecific; s++)
  940. *s = cpu_to_le16(*s);
  942. for(s = &cfgr.arlThreshold; s <= &cfgr.autoWake; s++)
  943. *s = cpu_to_le16(*s);
  945. return do_writerid( ai, RID_CONFIG, &cfgr, sizeof(cfgr));
  946. }
  947. static int readStatusRid(struct airo_info*ai, StatusRid *statr) {
  948. int rc = PC4500_readrid(ai, RID_STATUS, statr, sizeof(*statr));
  949. u16 *s;
  951. statr->len = le16_to_cpu(statr->len);
  952. for(s = &statr->mode; s <= &statr->SSIDlen; s++) *s = le16_to_cpu(*s);
  954. for(s = &statr->beaconPeriod; s <= &statr->_reserved[9]; s++)
  955. *s = le16_to_cpu(*s);
  957. return rc;
  958. }
  959. static int readAPListRid(struct airo_info*ai, APListRid *aplr) {
  960. int rc =  PC4500_readrid(ai, RID_APLIST, aplr, sizeof(*aplr));
  961. aplr->len = le16_to_cpu(aplr->len);
  962. return rc;
  963. }
  964. static int writeAPListRid(struct airo_info*ai, APListRid *aplr) {
  965. int rc;
  966. aplr->len = cpu_to_le16(aplr->len);
  967. rc = do_writerid(ai, RID_APLIST, aplr, sizeof(*aplr));
  968. return rc;
  969. }
  970. static int readCapabilityRid(struct airo_info*ai, CapabilityRid *capr) {
  971. int rc = PC4500_readrid(ai, RID_CAPABILITIES, capr, sizeof(*capr));
  972. u16 *s;
  974. capr->len = le16_to_cpu(capr->len);
  975. capr->prodNum = le16_to_cpu(capr->prodNum);
  976. capr->radioType = le16_to_cpu(capr->radioType);
  977. capr->country = le16_to_cpu(capr->country);
  978. for(s = &capr->txPowerLevels[0]; s <= &capr->requiredHard; s++)
  979. *s = le16_to_cpu(*s);
  980. return rc;
  981. }
  982. static int readStatsRid(struct airo_info*ai, StatsRid *sr, int rid) {
  983. int rc = PC4500_readrid(ai, rid, sr, sizeof(*sr));
  984. u32 *i;
  986. sr->len = le16_to_cpu(sr->len);
  987. for(i = &sr->vals[0]; i <= &sr->vals[99]; i++) *i = le32_to_cpu(*i);
  988. return rc;
  989. }
  991. static int airo_open(struct net_device *dev) {
  992. struct airo_info *info = dev->priv;
  994. enable_interrupts(info);
  996. netif_start_queue(dev);
  997. return 0;
  998. }
  1000. static int airo_start_xmit(struct sk_buff *skb, struct net_device *dev) {
  1001. s16 len;
  1002. u16 status;
  1003. u32 flags;
  1004. int i,j;
  1005. struct airo_info *priv = (struct airo_info*)dev->priv;
  1006. u32 *fids = priv->fids;
  1008. if ( skb == NULL ) {
  1009. printk( KERN_ERR "airo:  skb == NULL!!!n" );
  1010. return 0;
  1011. }
  1013. /* Find a vacant FID */
  1014. spin_lock_irqsave(&priv->main_lock, flags);
  1015. for( j = 0, i = -1; j < MAX_FIDS; j++ ) {
  1016. if ( !( fids[j] & 0xffff0000 ) ) {
  1017. if ( i == -1 ) i = j;
  1018. else break;
  1019. }
  1020. }
  1021. if ( j == MAX_FIDS ) netif_stop_queue(dev);
  1022. if ( i == -1 ) {
  1023. priv->stats.tx_fifo_errors++;
  1024. goto tx_done;
  1025. }
  1027. len = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; /* check min length*/
  1028. status = transmit_802_3_packet( priv, fids[i], skb->data, len );
  1030. if ( status == SUCCESS ) {
  1031.                 /* Mark fid as used & save length for later */
  1032. fids[i] |= (len << 16);
  1033. dev->trans_start = jiffies;
  1034. } else {
  1035. priv->stats.tx_window_errors++;
  1036. }
  1037.  tx_done:
  1038. spin_unlock_irqrestore(&priv->main_lock, flags);
  1039. dev_kfree_skb(skb);
  1040. return 0;
  1041. }
  1043. struct net_device_stats *airo_get_stats(struct net_device *dev)
  1044. {
  1045. struct airo_info *local = (struct airo_info*) dev->priv;
  1046. StatsRid stats_rid;
  1047. u32 *vals = stats_rid.vals;
  1049. /* Get stats out of the card */
  1050. readStatsRid(local, &stats_rid, RID_STATS);
  1052. local->stats.rx_packets = vals[43] + vals[44] + vals[45];
  1053. local->stats.tx_packets = vals[39] + vals[40] + vals[41];
  1054. local->stats.rx_bytes = vals[92];
  1055. local->stats.tx_bytes = vals[91];
  1056. local->stats.rx_errors = vals[0] + vals[2] + vals[3] + vals[4];
  1057. local->stats.tx_errors = vals[42] + local->stats.tx_fifo_errors;
  1058. local->stats.multicast = vals[43];
  1059. local->stats.collisions = vals[89];
  1061. /* detailed rx_errors: */
  1062. local->stats.rx_length_errors = vals[3];
  1063. local->stats.rx_crc_errors = vals[4];
  1064. local->stats.rx_frame_errors = vals[2];
  1065. local->stats.rx_fifo_errors = vals[0];
  1067. return (&local->stats);
  1068. }
  1070. static int enable_MAC( struct airo_info *ai, Resp *rsp );
  1071. static void disable_MAC(struct airo_info *ai);
  1073. static void airo_set_multicast_list(struct net_device *dev) {
  1074. struct airo_info *ai = (struct airo_info*)dev->priv;
  1075. Cmd cmd;
  1076. Resp rsp;
  1078. /* For some reason this command takes a lot of time (~20 ms) and it's
  1079.  * run in an interrupt handler, so we'd better be sure we needed it
  1080.  * before executing it.
  1081.  */
  1082. if ((dev->flags ^ ai->flags) & IFF_PROMISC) {
  1083. memset(&cmd, 0, sizeof(cmd));
  1084. cmd.cmd=CMD_SETMODE;
  1085. cmd.parm0=(dev->flags&IFF_PROMISC) ? PROMISC : NOPROMISC;
  1086. lock_issuecommand(ai, &cmd, &rsp);
  1087. ai->flags^=IFF_PROMISC;
  1088. }
  1090. if ((dev->flags&IFF_ALLMULTI)||dev->mc_count>0) {
  1091. /* Turn on multicast.  (Should be already setup...) */
  1092. }
  1093. }
  1095. static int airo_set_mac_address(struct net_device *dev, void *p)
  1096. {
  1097. struct airo_info *ai = (struct airo_info*)dev->priv;
  1098. struct sockaddr *addr = p;
  1099. ConfigRid cfg;
  1101. readConfigRid (ai, &cfg);
  1102. memcpy (cfg.macAddr, addr->sa_data, dev->addr_len);
  1103. writeConfigRid (ai, &cfg);
  1104. memcpy (dev->dev_addr, addr->sa_data, dev->addr_len);
  1105. return 0;
  1106. }
  1108. static int airo_change_mtu(struct net_device *dev, int new_mtu)
  1109. {
  1110. if ((new_mtu < 68) || (new_mtu > 2400))
  1111. return -EINVAL;
  1112. dev->mtu = new_mtu;
  1113. return 0;
  1114. }
  1117. static int airo_close(struct net_device *dev) {
  1118. struct airo_info *ai = (struct airo_info*)dev->priv;
  1120. netif_stop_queue(dev);
  1121. disable_interrupts( ai );
  1122. return 0;
  1123. }
  1125. static void del_airo_dev( struct net_device *dev );
  1127. void stop_airo_card( struct net_device *dev, int freeres )
  1128. {
  1129. struct airo_info *ai = (struct airo_info*)dev->priv;
  1130. if (ai->flash)
  1131. kfree(ai->flash);
  1132. if (ai->rssi)
  1133. kfree(ai->rssi);
  1134. takedown_proc_entry( dev, ai );
  1135. if (ai->registered) {
  1136. unregister_netdev( dev );
  1137. ai->registered = 0;
  1138. }
  1139. disable_interrupts(ai);
  1140. free_irq( dev->irq, dev );
  1141. if (auto_wep) del_timer_sync(&ai->timer);
  1142. if (freeres) {
  1143. /* PCMCIA frees this stuff, so only for PCI and ISA */
  1144.         release_region( dev->base_addr, 64 );
  1145.         }
  1146. del_airo_dev( dev );
  1147. kfree( dev );
  1148. }
  1150. static int add_airo_dev( struct net_device *dev );
  1152. struct net_device *init_airo_card( unsigned short irq, int port, int is_pcmcia )
  1153. {
  1154. struct net_device *dev;
  1155. struct airo_info *ai;
  1156. int i, rc;
  1158. /* Create the network device object. */
  1159.         dev = alloc_etherdev(sizeof(*ai));
  1160.         if (!dev) {
  1161. printk(KERN_ERR "airo:  Couldn't alloc_etherdevn");
  1162. return NULL;
  1163.         }
  1164. if (dev_alloc_name(dev, dev->name) < 0) {
  1165. printk(KERN_ERR "airo:  Couldn't get name!n");
  1166. goto err_out_free;
  1167. }
  1169. ai = dev->priv;
  1170. ai->registered = 0;
  1171.         ai->dev = dev;
  1172. ai->aux_lock = SPIN_LOCK_UNLOCKED;
  1173. ai->main_lock = SPIN_LOCK_UNLOCKED;
  1174. ai->header_parse = dev->hard_header_parse;
  1175. rc = add_airo_dev( dev );
  1176. if (rc)
  1177. goto err_out_free;
  1179. /* The Airo-specific entries in the device structure. */
  1180. dev->hard_start_xmit = &airo_start_xmit;
  1181. dev->get_stats = &airo_get_stats;
  1182. dev->set_multicast_list = &airo_set_multicast_list;
  1183. dev->set_mac_address = &airo_set_mac_address;
  1184. dev->do_ioctl = &airo_ioctl;
  1185. #ifdef WIRELESS_EXT
  1186. dev->get_wireless_stats = airo_get_wireless_stats;
  1187. #endif /* WIRELESS_EXT */
  1188. dev->change_mtu = &airo_change_mtu;
  1189. dev->open = &airo_open;
  1190. dev->stop = &airo_close;
  1191. dev->irq = irq;
  1192. dev->base_addr = port;
  1194. rc = request_irq( dev->irq, airo_interrupt, SA_SHIRQ, dev->name, dev );
  1195. if (rc) {
  1196. printk(KERN_ERR "airo: register interrupt %d failed, rc %dn", irq, rc );
  1197. goto err_out_unlink;
  1198. }
  1199. if (!is_pcmcia) {
  1200. if (!request_region( dev->base_addr, 64, dev->name )) {
  1201. rc = -EBUSY;
  1202. goto err_out_irq;
  1203. }
  1204. }
  1206. if ( setup_card( ai, dev->dev_addr, &ai->config) != SUCCESS ) {
  1207. printk( KERN_ERR "airo: MAC could not be enabledn" );
  1208. rc = -EIO;
  1209. goto err_out_res;
  1210. }
  1212. rc = register_netdev(dev);
  1213. if (rc)
  1214. goto err_out_res;
  1216. ai->registered = 1;
  1217. printk( KERN_INFO "airo: MAC enabled %s %x:%x:%x:%x:%x:%xn",
  1218. dev->name,
  1219. dev->dev_addr[0], dev->dev_addr[1], dev->dev_addr[2],
  1220. dev->dev_addr[3], dev->dev_addr[4], dev->dev_addr[5] );
  1222. /* Allocate the transmit buffers */
  1223. for( i = 0; i < MAX_FIDS; i++ )
  1224. ai->fids[i] = transmit_allocate( ai, 2312 );
  1226. setup_proc_entry( dev, dev->priv ); /* XXX check for failure */
  1227. netif_start_queue(dev);
  1228. SET_MODULE_OWNER(dev);
  1229. return dev;
  1231. err_out_res:
  1232. if (!is_pcmcia)
  1233.         release_region( dev->base_addr, 64 );
  1234. err_out_irq:
  1235. free_irq(dev->irq, dev);
  1236. err_out_unlink:
  1237. del_airo_dev(dev);
  1238. err_out_free:
  1239. kfree(dev);
  1240. return NULL;
  1241. }
  1243. int waitbusy (struct airo_info *ai) {
  1244. int delay = 0;
  1245. while ((IN4500 (ai, COMMAND) & COMMAND_BUSY) & (delay < 10000)) {
  1246. udelay (10);
  1247. if (++delay % 20)
  1248. OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
  1249. }
  1250. return delay < 10000;
  1251. }
  1253. int reset_airo_card( struct net_device *dev ) {
  1254. int i;
  1255. struct airo_info *ai = (struct airo_info*)dev->priv;
  1257. disable_MAC(ai);
  1258. waitbusy (ai);
  1259. OUT4500(ai,COMMAND,CMD_SOFTRESET);
  1260. set_current_state (TASK_UNINTERRUPTIBLE);
  1261. schedule_timeout (HZ/5);
  1262. waitbusy (ai);
  1263. set_current_state (TASK_UNINTERRUPTIBLE);
  1264. schedule_timeout (HZ/5);
  1265. if ( setup_card(ai, dev->dev_addr, &(ai)->config) != SUCCESS ) {
  1266. printk( KERN_ERR "airo: MAC could not be enabledn" );
  1267. return -1;
  1268. } else {
  1269. printk( KERN_INFO "airo: MAC enabled %s %x:%x:%x:%x:%x:%xn",
  1270. dev->name,
  1271. dev->dev_addr[0],
  1272. dev->dev_addr[1],
  1273. dev->dev_addr[2],
  1274. dev->dev_addr[3],
  1275. dev->dev_addr[4],
  1276. dev->dev_addr[5]
  1277. );
  1278. /* Allocate the transmit buffers */
  1279. for( i = 0; i < MAX_FIDS; i++ )
  1280. ai->fids[i] = transmit_allocate( ai, 2312 );
  1281. }
  1282. enable_interrupts( ai );
  1283. netif_wake_queue(dev);
  1284. return 0;
  1285. }
  1287. int wll_header_parse(struct sk_buff *skb, unsigned char *haddr)
  1288. {
  1289. memcpy(haddr, skb->mac.raw + 10, ETH_ALEN);
  1290. return ETH_ALEN;
  1291. }
  1293. static void airo_interrupt ( int irq, void* dev_id, struct pt_regs *regs) {
  1294. struct net_device *dev = (struct net_device *)dev_id;
  1295. u16 status;
  1296. u16 fid;
  1297. struct airo_info *apriv = (struct airo_info *)dev->priv;
  1298. u16 savedInterrupts = 0;
  1300. if (!netif_device_present(dev))
  1301. return;
  1303. for (;;) {
  1304. status = IN4500( apriv, EVSTAT );
  1305. if ( !status || status == 0xffff ) break;
  1307. if ( status & EV_AWAKE ) {
  1308. OUT4500( apriv, EVACK, EV_AWAKE );
  1309. OUT4500( apriv, EVACK, EV_AWAKE );
  1310. }
  1312. if (!savedInterrupts) {
  1313. savedInterrupts = IN4500( apriv, EVINTEN );
  1314. OUT4500( apriv, EVINTEN, 0 );
  1315. }
  1317. if ( status & EV_LINK ) {
  1318. /* The link status has changed, if you want to put a
  1319.    monitor hook in, do it here.  (Remember that
  1320.    interrupts are still disabled!)
  1321. */
  1322. u16 newStatus = IN4500(apriv, LINKSTAT);
  1323. OUT4500( apriv, EVACK, EV_LINK);
  1324. /* Here is what newStatus means: */
  1325. #define NOBEACON 0x8000 /* Loss of sync - missed beacons */
  1326. #define MAXRETRIES 0x8001 /* Loss of sync - max retries */
  1327. #define MAXARL 0x8002 /* Loss of sync - average retry level exceeded*/
  1328. #define FORCELOSS 0x8003 /* Loss of sync - host request */
  1329. #define TSFSYNC 0x8004 /* Loss of sync - TSF synchronization */
  1330. #define DEAUTH 0x8100 /* Deauthentication (low byte is reason code) */
  1331. #define DISASS 0x8200 /* Disassociation (low byte is reason code) */
  1332. #define ASSFAIL 0x8400 /* Association failure (low byte is reason
  1333.   code) */
  1334. #define AUTHFAIL 0x0300 /* Authentication failure (low byte is reason
  1335.    code) */
  1336. #define ASSOCIATED 0x0400 /* Assocatied */
  1337. #define RC_RESERVED 0 /* Reserved return code */
  1338. #define RC_NOREASON 1 /* Unspecified reason */
  1339. #define RC_AUTHINV 2 /* Previous authentication invalid */
  1340. #define RC_DEAUTH 3 /* Deauthenticated because sending station is
  1341.        leaving */
  1342. #define RC_NOACT 4 /* Disassociated due to inactivity */
  1343. #define RC_MAXLOAD 5 /* Disassociated because AP is unable to handle
  1344. all currently associated stations */
  1345. #define RC_BADCLASS2 6 /* Class 2 frame received from
  1346.   non-Authenticated station */
  1347. #define RC_BADCLASS3 7 /* Class 3 frame received from
  1348.   non-Associated station */
  1349. #define RC_STATLEAVE 8 /* Disassociated because sending station is
  1350.   leaving BSS */
  1351. #define RC_NOAUTH 9 /* Station requesting (Re)Association is not
  1352.        Authenticated with the responding station */
  1353. if (newStatus != ASSOCIATED) {
  1354. if (auto_wep && !timer_pending(&apriv->timer)) {
  1355. apriv->timer.expires = RUN_AT(HZ*3);
  1356.        add_timer(&apriv->timer);
  1357. }
  1358. }
  1359. }
  1361. /* Check to see if there is something to receive */
  1362. if ( status & EV_RX  ) {
  1363. struct sk_buff *skb = NULL;
  1364. u16 fc, len, hdrlen = 0;
  1365. struct {
  1366. u16 status, len;
  1367. u8 rssi[2];
  1368. } hdr;
  1370. fid = IN4500( apriv, RXFID );
  1372. /* Get the packet length */
  1373. if (dev->type == ARPHRD_IEEE80211) {
  1374. bap_setup (apriv, fid, 4, BAP0);
  1375. bap_read (apriv, (u16*)&hdr, sizeof(hdr), BAP0);
  1376. /* Bad CRC. Ignore packet */
  1377. if (le16_to_cpu(hdr.status) & 2)
  1378. hdr.len = 0;
  1379. } else {
  1380. bap_setup (apriv, fid, 6, BAP0);
  1381. bap_read (apriv, (u16*)&hdr.len, 4, BAP0);
  1382. }
  1383. len = le16_to_cpu(hdr.len);
  1385. if (len > 2312) {
  1386. printk( KERN_ERR "airo: Bad size %dn", len );
  1387. len = 0;
  1388. }
  1389. if (len) {
  1390. if (dev->type == ARPHRD_IEEE80211) {
  1391. bap_setup (apriv, fid, 0x14, BAP0);
  1392. bap_read (apriv, (u16*)&fc, sizeof(fc), BAP0);
  1393. if ((le16_to_cpu(fc) & 0x300) == 0x300)
  1394. hdrlen = 30;
  1395. else
  1396. hdrlen = 24;
  1397. } else
  1398. hdrlen = 12;
  1400. skb = dev_alloc_skb( len + hdrlen + 2 );
  1401. if ( !skb ) {
  1402. apriv->stats.rx_dropped++;
  1403. len = 0;
  1404. }
  1405. }
  1406. if (len) {
  1407. u16 *buffer;
  1408. buffer = (u16*)skb_put (skb, len + hdrlen);
  1409. if (dev->type == ARPHRD_IEEE80211) {
  1410. u16 gap, tmpbuf[4];
  1411. buffer[0] = fc;
  1412. bap_read (apriv, buffer + 1, hdrlen - 2, BAP0);
  1413. if (hdrlen == 24)
  1414. bap_read (apriv, tmpbuf, 6, BAP0);
  1416. bap_read (apriv, &gap, sizeof(gap), BAP0);
  1417. gap = le16_to_cpu(gap);
  1418. if (gap && gap <= 8)
  1419. bap_read (apriv, tmpbuf, gap, BAP0);
  1421. bap_read (apriv, buffer + hdrlen/2, len, BAP0);
  1422. } else {
  1423.                 bap_setup (apriv, fid, 0x38, BAP0);
  1424. bap_read (apriv, buffer,len + hdrlen,BAP0);
  1425. }
  1426. OUT4500( apriv, EVACK, EV_RX);
  1427. #ifdef WIRELESS_SPY
  1428. if (apriv->spy_number > 0) {
  1429. int i;
  1430. char *sa;
  1432. sa = (char*)buffer + ((dev->type == ARPHRD_IEEE80211) ? 10 : 6);
  1434. for (i=0; i<apriv->spy_number; i++)
  1435. if (!memcmp(sa,apriv->spy_address[i],6))
  1436. {
  1437. apriv->spy_stat[i].qual = hdr.rssi[0];
  1438. if (apriv->rssi)
  1439. apriv->spy_stat[i].level = 0x100 - apriv->rssi[hdr.rssi[1]].rssidBm;
  1440. else
  1441. apriv->spy_stat[i].level = (hdr.rssi[1] + 321) / 2;
  1442. apriv->spy_stat[i].noise = 0;
  1443. apriv->spy_stat[i].updated = 3;
  1444. break;
  1445. }
  1446. }
  1447. #endif /* WIRELESS_SPY  */
  1448. dev->last_rx = jiffies;
  1449. skb->dev = dev;
  1450. skb->ip_summed = CHECKSUM_NONE;
  1451. if (dev->type == ARPHRD_IEEE80211) {
  1452. skb->mac.raw = skb->data;
  1453. skb_pull (skb, hdrlen);
  1454. skb->pkt_type = PACKET_OTHERHOST;
  1455. skb->protocol = htons(ETH_P_802_2);
  1456. } else
  1457. skb->protocol = eth_type_trans(skb,dev);
  1459. netif_rx( skb );
  1460. } else
  1461. OUT4500( apriv, EVACK, EV_RX);
  1462. }
  1464. /* Check to see if a packet has been transmitted */
  1465. if (  status & ( EV_TX|EV_TXEXC ) ) {
  1466. int i;
  1467. int len = 0;
  1468. int index = -1;
  1470. fid = IN4500(apriv, TXCOMPLFID);
  1472. for( i = 0; i < MAX_FIDS; i++ ) {
  1473. if ( ( apriv->fids[i] & 0xffff ) == fid ) {
  1474. len = apriv->fids[i] >> 16;
  1475. index = i;
  1476. /* Set up to be used again */
  1477. apriv->fids[i] &= 0xffff;
  1478. }
  1479. }
  1480. if (index != -1) netif_wake_queue(dev);
  1481. if ((status & EV_TXEXC) &&
  1482. (bap_setup(apriv, fid, 4, BAP1) == SUCCESS)) {
  1484. u16 status;
  1485. bap_read(apriv, &status, 2, BAP1);
  1486. if (le16_to_cpu(status) & 2)
  1487. apriv->stats.tx_aborted_errors++;
  1488. if (le16_to_cpu(status) & 4)
  1489. apriv->stats.tx_heartbeat_errors++;
  1490. if (le16_to_cpu(status) & 0x10)
  1491. apriv->stats.tx_carrier_errors++;
  1492. }
  1493. OUT4500( apriv, EVACK, status & (EV_TX | EV_TXEXC));
  1494. if (index==-1) {
  1495. printk( KERN_ERR "airo: Unallocated FID was used to xmitn" );
  1496. }
  1497. }
  1498. if ( status & ~STATUS_INTS )
  1499. OUT4500( apriv, EVACK, status & ~STATUS_INTS);
  1501. if ( status & ~STATUS_INTS & ~IGNORE_INTS )
  1502. printk( KERN_WARNING "airo: Got weird status %xn",
  1503. status & ~STATUS_INTS & ~IGNORE_INTS );
  1504. }
  1506. if (savedInterrupts)
  1507. OUT4500( apriv, EVINTEN, savedInterrupts );
  1509. /* done.. */
  1510. return;
  1511. }
  1513. /*
  1514.  *  Routines to talk to the card
  1515.  */
  1517. /*
  1518.  *  This was originally written for the 4500, hence the name
  1519.  *  NOTE:  If use with 8bit mode and SMP bad things will happen!
  1520.  *         Why would some one do 8 bit IO in an SMP machine?!?
  1521.  */
  1522. static void OUT4500( struct airo_info *ai, u16 reg, u16 val ) {
  1523. if ( !do8bitIO )
  1524. outw( val, ai->dev->base_addr + reg );
  1525. else {
  1526. outb( val & 0xff, ai->dev->base_addr + reg );
  1527. outb( val >> 8, ai->dev->base_addr + reg + 1 );
  1528. }
  1529. }
  1531. static u16 IN4500( struct airo_info *ai, u16 reg ) {
  1532. unsigned short rc;
  1534. if ( !do8bitIO )
  1535. rc = inw( ai->dev->base_addr + reg );
  1536. else {
  1537. rc = inb( ai->dev->base_addr + reg );
  1538. rc += ((int)inb( ai->dev->base_addr + reg + 1 )) << 8;
  1539. }
  1540. return rc;
  1541. }
  1543. static int enable_MAC( struct airo_info *ai, Resp *rsp ) {
  1544.         Cmd cmd;
  1546.         if (ai->flags&FLAG_RADIO_OFF) return SUCCESS;
  1547. memset(&cmd, 0, sizeof(cmd));
  1548. cmd.cmd = MAC_ENABLE;
  1549. return lock_issuecommand(ai, &cmd, rsp);
  1550. }
  1552. static void disable_MAC( struct airo_info *ai ) {
  1553.         Cmd cmd;
  1554. Resp rsp;
  1556. memset(&cmd, 0, sizeof(cmd));
  1557. cmd.cmd = MAC_DISABLE; // disable in case already enabled
  1558. lock_issuecommand(ai, &cmd, &rsp);
  1559. }
  1561. static void enable_interrupts( struct airo_info *ai ) {
  1562. /* Reset the status register */
  1563. u16 status = IN4500( ai, EVSTAT );
  1564. OUT4500( ai, EVACK, status );
  1565. /* Enable the interrupts */
  1566. OUT4500( ai, EVINTEN, STATUS_INTS );
  1567. /* Note there is a race condition between the last two lines that
  1568.    I dont know how to get rid of right now... */
  1569. }
  1571. static void disable_interrupts( struct airo_info *ai ) {
  1572. OUT4500( ai, EVINTEN, 0 );
  1573. }
  1575. static u16 setup_card(struct airo_info *ai, u8 *mac,
  1576.       ConfigRid *config)
  1577. {
  1578. Cmd cmd;
  1579. Resp rsp;
  1580. ConfigRid cfg;
  1581. int status;
  1582. int i;
  1583. SsidRid mySsid;
  1584. u16 lastindex;
  1585. WepKeyRid wkr;
  1586. int rc;
  1588. memset( &mySsid, 0, sizeof( mySsid ) );
  1589. if (ai->flash) {
  1590. kfree (ai->flash);
  1591. ai->flash = NULL;
  1592. }
  1594. /* The NOP is the first step in getting the card going */
  1595. cmd.cmd = NOP;
  1596. cmd.parm0 = cmd.parm1 = cmd.parm2 = 0;
  1597. if ( lock_issuecommand( ai, &cmd, &rsp ) != SUCCESS ) {
  1598. return ERROR;
  1599. }
  1600. memset(&cmd, 0, sizeof(cmd));
  1601. cmd.cmd = MAC_DISABLE; // disable in case already enabled
  1602. if ( lock_issuecommand( ai, &cmd, &rsp ) != SUCCESS ) {
  1603. return ERROR;
  1604. }
  1606. // Let's figure out if we need to use the AUX port
  1607. cmd.cmd = CMD_ENABLEAUX;
  1608. if (lock_issuecommand(ai, &cmd, &rsp) != SUCCESS) {
  1609. printk(KERN_ERR "airo: Error checking for AUX portn");
  1610. return ERROR;
  1611. }
  1612. if (!aux_bap || rsp.status & 0xff00) {
  1613. ai->bap_read = fast_bap_read;
  1614. printk(KERN_DEBUG "airo: Doing fast bap_readsn");
  1615. } else {
  1616. ai->bap_read = aux_bap_read;
  1617. printk(KERN_DEBUG "airo: Doing AUX bap_readsn");
  1618. }
  1619. if ( config->len ) {
  1620. cfg = *config;
  1621. } else {
  1622. tdsRssiRid rssi_rid;
  1624. // general configuration (read/modify/write)
  1625. status = readConfigRid(ai, &cfg);
  1626. if ( status != SUCCESS ) return ERROR;
  1628. status = PC4500_readrid(ai,RID_RSSI,&rssi_rid,sizeof(rssi_rid));
  1629. if ( status == SUCCESS ) {
  1630. if (ai->rssi || (ai->rssi = kmalloc(512, GFP_KERNEL)) != NULL)
  1631. memcpy(ai->rssi, (u8*)&rssi_rid + 2, 512);
  1632. }
  1633. else {
  1634. CapabilityRid cap_rid;
  1635. if (ai->rssi) {
  1636. kfree(ai->rssi);
  1637. ai->rssi = NULL;
  1638. }
  1639. status = readCapabilityRid(ai, &cap_rid);
  1640. if ((status == SUCCESS) && (cap_rid.softCap & 8))
  1641. cfg.rmode |= RXMODE_NORMALIZED_RSSI;
  1642. else
  1643. printk(KERN_WARNING "airo: unknown received signal level scalen");
  1644. }
  1645. cfg.opmode = adhoc ? MODE_STA_IBSS : MODE_STA_ESS;
  1647. /* Save off the MAC */
  1648. for( i = 0; i < 6; i++ ) {
  1649. mac[i] = cfg.macAddr[i];
  1650. }
  1652. /* Check to see if there are any insmod configured
  1653.    rates to add */
  1654. if ( rates ) {
  1655. int i = 0;
  1656. if ( rates[0] ) memset(cfg.rates,0,sizeof(cfg.rates));
  1657. for( i = 0; i < 8 && rates[i]; i++ ) {
  1658. cfg.rates[i] = rates[i];
  1659. }
  1660. }
  1661. if ( basic_rate > 0 ) {
  1662. int i;
  1663. for( i = 0; i < 8; i++ ) {
  1664. if ( cfg.rates[i] == basic_rate ||
  1665.      !cfg.rates ) {
  1666. cfg.rates[i] = basic_rate | 0x80;
  1667. break;
  1668. }
  1669. }
  1670. }
  1671. cfg.authType = ai->authtype;
  1672. *config = cfg;
  1673. }
  1675. /* Setup the SSIDs if present */
  1676. if ( ssids[0] ) {
  1677. int i = 0;
  1678. for( i = 0; i < 3 && ssids[i]; i++ ) {
  1679. mySsid.ssids[i].len = strlen(ssids[i]);
  1680. if ( mySsid.ssids[i].len > 32 )
  1681. mySsid.ssids[i].len = 32;
  1682. memcpy(mySsid.ssids[i].ssid, ssids[i],
  1683.        mySsid.ssids[i].len);
  1684. mySsid.ssids[i].len = mySsid.ssids[i].len;
  1685. }
  1686. }
  1688. status = writeConfigRid(ai, &cfg);
  1689. if ( status != SUCCESS ) return ERROR;
  1691. /* Set up the SSID list */
  1692. status = writeSsidRid(ai, &mySsid);
  1693. if ( status != SUCCESS ) return ERROR;
  1695. /* Grab the initial wep key, we gotta save it for auto_wep */
  1696. rc = readWepKeyRid(ai, &wkr, 1);
  1697. if (rc == SUCCESS) do {
  1698. lastindex = wkr.kindex;
  1699. if (wkr.kindex == 0xffff) {
  1700. ai->defindex = wkr.mac[0];
  1701. }
  1702. rc = readWepKeyRid(ai, &wkr, 0);
  1703. } while(lastindex != wkr.kindex);
  1705. if (auto_wep && !timer_pending(&ai->timer)) {
  1706. ai->timer.expires = RUN_AT(HZ*3);
  1707. add_timer(&ai->timer);
  1708. }
  1709. return SUCCESS;
  1710. }
  1712. static u16 lock_issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
  1713. int rc;
  1714. long flags;
  1716. spin_lock_irqsave(&ai->main_lock, flags);
  1717. rc = issuecommand(ai, pCmd, pRsp);
  1718. spin_unlock_irqrestore(&ai->main_lock, flags);
  1719. return rc;
  1720. }
  1722. static u16 issuecommand(struct airo_info *ai, Cmd *pCmd, Resp *pRsp) {
  1723.         // Im really paranoid about letting it run forever!
  1724. int max_tries = 600000;
  1726. OUT4500(ai, PARAM0, pCmd->parm0);
  1727. OUT4500(ai, PARAM1, pCmd->parm1);
  1728. OUT4500(ai, PARAM2, pCmd->parm2);
  1729. OUT4500(ai, COMMAND, pCmd->cmd);
  1730. while ( max_tries-- &&
  1731. (IN4500(ai, EVSTAT) & EV_CMD) == 0) {
  1732. if ( IN4500(ai, COMMAND) == pCmd->cmd) {
  1733. // PC4500 didn't notice command, try again
  1734. OUT4500(ai, COMMAND, pCmd->cmd);
  1735. }
  1736. }
  1737. if ( max_tries == -1 ) {
  1738. printk( KERN_ERR
  1739. "airo: Max tries exceeded when issueing commandn" );
  1740.                 return ERROR;
  1741. }
  1742. // command completed
  1743. pRsp->status = IN4500(ai, STATUS);
  1744. pRsp->rsp0 = IN4500(ai, RESP0);
  1745. pRsp->rsp1 = IN4500(ai, RESP1);
  1746. pRsp->rsp2 = IN4500(ai, RESP2);
  1748. // clear stuck command busy if necessary
  1749. if (IN4500(ai, COMMAND) & COMMAND_BUSY) {
  1750. OUT4500(ai, EVACK, EV_CLEARCOMMANDBUSY);
  1751. }
  1752. // acknowledge processing the status/response
  1753. OUT4500(ai, EVACK, EV_CMD);
  1754. return SUCCESS;
  1755. }
  1757. /* Sets up the bap to start exchange data.  whichbap should
  1758.  * be one of the BAP0 or BAP1 defines.  Locks should be held before
  1759.  * calling! */
  1760. static int bap_setup(struct airo_info *ai, u16 rid, u16 offset, int whichbap )
  1761. {
  1762. int timeout = 50;
  1763. int max_tries = 3;
  1765. OUT4500(ai, SELECT0+whichbap, rid);
  1766. OUT4500(ai, OFFSET0+whichbap, offset);
  1767. while (1) {
  1768. int status = IN4500(ai, OFFSET0+whichbap);
  1769. if (status & BAP_BUSY) {
  1770.                         /* This isn't really a timeout, but its kinda
  1771.    close */
  1772. if (timeout--) {
  1773. continue;
  1774. }
  1775. } else if ( status & BAP_ERR ) {
  1776. /* invalid rid or offset */
  1777. printk( KERN_ERR "airo: BAP error %x %dn",
  1778. status, whichbap );
  1779. return ERROR;
  1780. } else if (status & BAP_DONE) { // success
  1781. return SUCCESS;
  1782. }
  1783. if ( !(max_tries--) ) {
  1784. printk( KERN_ERR
  1785. "airo: BAP setup error too many retriesn" );
  1786. return ERROR;
  1787. }
  1788. // -- PC4500 missed it, try again
  1789. OUT4500(ai, SELECT0+whichbap, rid);
  1790. OUT4500(ai, OFFSET0+whichbap, offset);
  1791. timeout = 50;
  1792. }
  1793. }
  1795. /* should only be called by aux_bap_read.  This aux function and the
  1796.    following use concepts not documented in the developers guide.  I
  1797.    got them from a patch given to my by Aironet */
  1798. static u16 aux_setup(struct airo_info *ai, u16 page,
  1799.      u16 offset, u16 *len)
  1800. {
  1801. u16 next;
  1803. OUT4500(ai, AUXPAGE, page);
  1804. OUT4500(ai, AUXOFF, 0);
  1805. next = IN4500(ai, AUXDATA);
  1806. *len = IN4500(ai, AUXDATA)&0xff;
  1807. if (offset != 4) OUT4500(ai, AUXOFF, offset);
  1808. return next;
  1809. }
  1811. /* requires call to bap_setup() first */
  1812. static int aux_bap_read(struct airo_info *ai, u16 *pu16Dst,
  1813. int bytelen, int whichbap)
  1814. {
  1815. u16 len;
  1816. u16 page;
  1817. u16 offset;
  1818. u16 next;
  1819. int words;
  1820. int i;
  1821. long flags;
  1823. spin_lock_irqsave(&ai->aux_lock, flags);
  1824. page = IN4500(ai, SWS0+whichbap);
  1825. offset = IN4500(ai, SWS2+whichbap);
  1826. next = aux_setup(ai, page, offset, &len);
  1827. words = (bytelen+1)>>1;
  1829. for (i=0; i<words;) {
  1830. int count;
  1831. count = (len>>1) < (words-i) ? (len>>1) : (words-i);
  1832. if ( !do8bitIO )
  1833. insw( ai->dev->base_addr+DATA0+whichbap,
  1834.       pu16Dst+i,count );
  1835. else
  1836. insb( ai->dev->base_addr+DATA0+whichbap,
  1837.       pu16Dst+i, count << 1 );
  1838. i += count;
  1839. if (i<words) {
  1840. next = aux_setup(ai, next, 4, &len);
  1841. }
  1842. }
  1843. spin_unlock_irqrestore(&ai->aux_lock, flags);
  1844. return SUCCESS;
  1845. }
  1848. /* requires call to bap_setup() first */
  1849. static int fast_bap_read(struct airo_info *ai, u16 *pu16Dst,
  1850.  int bytelen, int whichbap)
  1851. {
  1852. bytelen = (bytelen + 1) & (~1); // round up to even value
  1853. if ( !do8bitIO )
  1854. insw( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen>>1 );
  1855. else
  1856. insb( ai->dev->base_addr+DATA0+whichbap, pu16Dst, bytelen );
  1857. return SUCCESS;
  1858. }
  1860. /* requires call to bap_setup() first */
  1861. static int bap_write(struct airo_info *ai, const u16 *pu16Src,
  1862.      int bytelen, int whichbap)
  1863. {
  1864. bytelen = (bytelen + 1) & (~1); // round up to even value
  1865. if ( !do8bitIO )
  1866. outsw( ai->dev->base_addr+DATA0+whichbap,
  1867.        pu16Src, bytelen>>1 );
  1868. else
  1869. outsb( ai->dev->base_addr+DATA0+whichbap, pu16Src, bytelen );
  1870. return SUCCESS;
  1871. }
  1873. static int PC4500_accessrid(struct airo_info *ai, u16 rid, u16 accmd)
  1874. {
  1875. Cmd cmd; /* for issuing commands */
  1876. Resp rsp; /* response from commands */
  1877. u16 status;
  1879. memset(&cmd, 0, sizeof(cmd));
  1880. cmd.cmd = accmd;
  1881. cmd.parm0 = rid;
  1882. status = issuecommand(ai, &cmd, &rsp);
  1883. if (status != 0) return status;
  1884. if ( (rsp.status & 0x7F00) != 0) {
  1885. return (accmd << 8) + (rsp.rsp0 & 0xFF);
  1886. }
  1887. return 0;
  1888. }
  1890. /*  Note, that we are using BAP1 which is also used by transmit, so
  1891.  *  we must get a lock. */
  1892. static int PC4500_readrid(struct airo_info *ai, u16 rid, void *pBuf, int len)
  1893. {
  1894. u16 status;
  1895.         long flags;
  1896.         int rc = SUCCESS;
  1898. spin_lock_irqsave(&ai->main_lock, flags);
  1899. if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != SUCCESS) {
  1900.                 rc = status;
  1901.                 goto done;
  1902.         }
  1903. if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
  1904. rc = ERROR;
  1905.                 goto done;
  1906.         }
  1907. // read the rid length field
  1908. bap_read(ai, pBuf, 2, BAP1);
  1909. // length for remaining part of rid
  1910. len = min(len, (int)le16_to_cpu(*(u16*)pBuf)) - 2;
  1912. if ( len <= 2 ) {
  1913. printk( KERN_ERR
  1914. "airo: Rid %x has a length of %d which is too shortn",
  1915. (int)rid,
  1916. (int)len );
  1917. rc = ERROR;
  1918.                 goto done;
  1919. }
  1920. // read remainder of the rid
  1921. rc = bap_read(ai, ((u16*)pBuf)+1, len, BAP1);
  1922.  done:
  1923. spin_unlock_irqrestore(&ai->main_lock, flags);
  1924. return rc;
  1925. }
  1927. /*  Note, that we are using BAP1 which is also used by transmit, so
  1928.  *  make sure this isnt called when a transmit is happening */
  1929. static int PC4500_writerid(struct airo_info *ai, u16 rid,
  1930.    const void *pBuf, int len)
  1931. {
  1932. u16 status;
  1933.         long flags;
  1934. int rc = SUCCESS;
  1936. spin_lock_irqsave(&ai->main_lock, flags);
  1937. // --- first access so that we can write the rid data
  1938. if ( (status = PC4500_accessrid(ai, rid, CMD_ACCESS)) != 0) {
  1939.                 rc = status;
  1940.                 goto done;
  1941.         }
  1942. // --- now write the rid data
  1943. if (bap_setup(ai, rid, 0, BAP1) != SUCCESS) {
  1944.                 rc = ERROR;
  1945.                 goto done;
  1946.         }
  1947. bap_write(ai, pBuf, len, BAP1);
  1948. // ---now commit the rid data
  1949. rc = PC4500_accessrid(ai, rid, 0x100|CMD_ACCESS);
  1950.  done:
  1951. spin_unlock_irqrestore(&ai->main_lock, flags);
  1952.         return rc;
  1953. }
  1955. /* Allocates a FID to be used for transmitting packets.  We only use
  1956.    one for now. */
  1957. static u16 transmit_allocate(struct airo_info *ai, int lenPayload)
  1958. {
  1959. Cmd cmd;
  1960. Resp rsp;
  1961. u16 txFid;
  1962. u16 txControl;
  1963.         long flags;
  1965. cmd.cmd = CMD_ALLOCATETX;
  1966. cmd.parm0 = lenPayload;
  1967. if (lock_issuecommand(ai, &cmd, &rsp) != SUCCESS) return 0;
  1968. if ( (rsp.status & 0xFF00) != 0) return 0;
  1969. /* wait for the allocate event/indication
  1970.  * It makes me kind of nervous that this can just sit here and spin,
  1971.  * but in practice it only loops like four times. */
  1972. while ( (IN4500(ai, EVSTAT) & EV_ALLOC) == 0) ;
  1973. // get the allocated fid and acknowledge
  1974. txFid = IN4500(ai, TXALLOCFID);
  1975. OUT4500(ai, EVACK, EV_ALLOC);
  1977. /*  The CARD is pretty cool since it converts the ethernet packet
  1978.  *  into 802.11.  Also note that we don't release the FID since we
  1979.  *  will be using the same one over and over again. */
  1980. /*  We only have to setup the control once since we are not
  1981.  *  releasing the fid. */
  1982. txControl = cpu_to_le16(TXCTL_TXOK | TXCTL_TXEX | TXCTL_802_3
  1983. | TXCTL_ETHERNET | TXCTL_NORELEASE);
  1984. spin_lock_irqsave(&ai->main_lock, flags);
  1985. if (bap_setup(ai, txFid, 0x0008, BAP1) != SUCCESS) {
  1986. spin_unlock_irqrestore(&ai->main_lock, flags);
  1987. return ERROR;
  1988. }
  1989. bap_write(ai, &txControl, sizeof(txControl), BAP1);
  1990. spin_unlock_irqrestore(&ai->main_lock, flags);
  1992. return txFid;
  1993. }
  1995. /* In general BAP1 is dedicated to transmiting packets.  However,
  1996.    since we need a BAP when accessing RIDs, we also use BAP1 for that.
  1997.    Make sure the BAP1 spinlock is held when this is called. */
  1998. static int transmit_802_3_packet(struct airo_info *ai, u16 txFid,
  1999.  char *pPacket, int len)
  2000. {
  2001. u16 payloadLen;
  2002. Cmd cmd;
  2003. Resp rsp;
  2005. if (len < 12) {
  2006. printk( KERN_WARNING "Short packet %dn", len );
  2007. return ERROR;
  2008. }
  2010. // packet is destination[6], source[6], payload[len-12]
  2011. // write the payload length and dst/src/payload
  2012. if (bap_setup(ai, txFid, 0x0036, BAP1) != SUCCESS) return ERROR;
  2013. /* The hardware addresses aren't counted as part of the payload, so
  2014.  * we have to subtract the 12 bytes for the addresses off */
  2015. payloadLen = cpu_to_le16(len-12);
  2016. bap_write(ai, &payloadLen, sizeof(payloadLen),BAP1);
  2017. bap_write(ai, (const u16*)pPacket, len, BAP1);
  2018. // issue the transmit command
  2019. memset( &cmd, 0, sizeof( cmd ) );
  2020. cmd.cmd = CMD_TRANSMIT;
  2021. cmd.parm0 = txFid;
  2022. if (issuecommand(ai, &cmd, &rsp) != SUCCESS) return ERROR;
  2023. if ( (rsp.status & 0xFF00) != 0) return ERROR;
  2024. return SUCCESS;
  2025. }
  2027. /*
  2028.  *  This is the proc_fs routines.  It is a bit messier than I would
  2029.  *  like!  Feel free to clean it up!
  2030.  */
  2032. static ssize_t proc_read( struct file *file,
  2033.   char *buffer,
  2034.   size_t len,
  2035.   loff_t *offset);
  2037. static ssize_t proc_write( struct file *file,
  2038.    const char *buffer,
  2039.    size_t len,
  2040.    loff_t *offset );
  2041. static int proc_close( struct inode *inode, struct file *file );
  2043. static int proc_stats_open( struct inode *inode, struct file *file );
  2044. static int proc_statsdelta_open( struct inode *inode, struct file *file );
  2045. static int proc_status_open( struct inode *inode, struct file *file );
  2046. static int proc_SSID_open( struct inode *inode, struct file *file );
  2047. static int proc_APList_open( struct inode *inode, struct file *file );
  2048. static int proc_BSSList_open( struct inode *inode, struct file *file );
  2049. static int proc_config_open( struct inode *inode, struct file *file );
  2050. static int proc_wepkey_open( struct inode *inode, struct file *file );
  2052. static struct file_operations proc_statsdelta_ops = {
  2053. read:           proc_read,
  2054. open:           proc_statsdelta_open,
  2055. release:        proc_close
  2056. };
  2058. static struct file_operations proc_stats_ops = {
  2059. read:           proc_read,
  2060. open:           proc_stats_open,
  2061. release:        proc_close
  2062. };
  2064. static struct file_operations proc_status_ops = {
  2065. read:            proc_read,
  2066. open:            proc_status_open,
  2067. release:         proc_close
  2068. };
  2070. static struct file_operations proc_SSID_ops = {
  2071. read:          proc_read,
  2072. write:         proc_write,
  2073. open:          proc_SSID_open,
  2074. release:       proc_close
  2075. };
  2077. static struct file_operations proc_BSSList_ops = {
  2078. read:          proc_read,
  2079. write:         proc_write,
  2080. open:          proc_BSSList_open,
  2081. release:       proc_close
  2082. };
  2084. static struct file_operations proc_APList_ops = {
  2085. read:          proc_read,
  2086. write:         proc_write,
  2087. open:          proc_APList_open,
  2088. release:       proc_close
  2089. };
  2091. static struct file_operations proc_config_ops = {
  2092. read:          proc_read,
  2093. write:         proc_write,
  2094. open:          proc_config_open,
  2095. release:       proc_close
  2096. };
  2098. static struct file_operations proc_wepkey_ops = {
  2099. read:          proc_read,
  2100. write:         proc_write,
  2101. open:          proc_wepkey_open,
  2102. release:       proc_close
  2103. };
  2105. static struct proc_dir_entry *airo_entry = 0;
  2107. struct proc_data {
  2108. int release_buffer;
  2109. int readlen;
  2110. char *rbuffer;
  2111. int writelen;
  2112. int maxwritelen;
  2113. char *wbuffer;
  2114. void (*on_close) (struct inode *, struct file *);
  2115. };
  2117. #ifndef SETPROC_OPS
  2118. #define SETPROC_OPS(entry, ops) (entry)->proc_fops = &(ops)
  2119. #endif
  2121. static int setup_proc_entry( struct net_device *dev,
  2122.      struct airo_info *apriv ) {
  2123. struct proc_dir_entry *entry;
  2124. /* First setup the device directory */
  2125. apriv->proc_entry = create_proc_entry(dev->name,
  2126.       S_IFDIR|airo_perm,
  2127.       airo_entry);
  2128.         apriv->proc_entry->uid = proc_uid;
  2129.         apriv->proc_entry->gid = proc_gid;
  2131. /* Setup the StatsDelta */
  2132. entry = create_proc_entry("StatsDelta",
  2133.   S_IFREG | (S_IRUGO&proc_perm),
  2134.   apriv->proc_entry);
  2135.         entry->uid = proc_uid;
  2136.         entry->gid = proc_gid;
  2137. entry->data = dev;
  2138. SETPROC_OPS(entry, proc_statsdelta_ops);
  2140. /* Setup the Stats */
  2141. entry = create_proc_entry("Stats",
  2142.   S_IFREG | (S_IRUGO&proc_perm),
  2143.   apriv->proc_entry);
  2144.         entry->uid = proc_uid;
  2145.         entry->gid = proc_gid;
  2146. entry->data = dev;
  2147. SETPROC_OPS(entry, proc_stats_ops);
  2149. /* Setup the Status */
  2150. entry = create_proc_entry("Status",
  2151.   S_IFREG | (S_IRUGO&proc_perm),
  2152.   apriv->proc_entry);
  2153.         entry->uid = proc_uid;
  2154.         entry->gid = proc_gid;
  2155. entry->data = dev;
  2156. SETPROC_OPS(entry, proc_status_ops);
  2158. /* Setup the Config */
  2159. entry = create_proc_entry("Config",
  2160.   S_IFREG | proc_perm,
  2161.   apriv->proc_entry);
  2162.         entry->uid = proc_uid;
  2163.         entry->gid = proc_gid;
  2164. entry->data = dev;
  2165. SETPROC_OPS(entry, proc_config_ops);
  2167. /* Setup the SSID */
  2168. entry = create_proc_entry("SSID",
  2169.   S_IFREG | proc_perm,
  2170.   apriv->proc_entry);
  2171.         entry->uid = proc_uid;
  2172.         entry->gid = proc_gid;
  2173. entry->data = dev;
  2174. SETPROC_OPS(entry, proc_SSID_ops);
  2176. /* Setup the APList */
  2177. entry = create_proc_entry("APList",
  2178.   S_IFREG | proc_perm,
  2179.   apriv->proc_entry);
  2180.         entry->uid = proc_uid;
  2181.         entry->gid = proc_gid;
  2182. entry->data = dev;
  2183. SETPROC_OPS(entry, proc_APList_ops);
  2185. /* Setup the BSSList */
  2186. entry = create_proc_entry("BSSList",
  2187.   S_IFREG | proc_perm,
  2188.   apriv->proc_entry);
  2189. entry->uid = proc_uid;
  2190. entry->gid = proc_gid;
  2191. entry->data = dev;
  2192. SETPROC_OPS(entry, proc_BSSList_ops);
  2194. /* Setup the WepKey */
  2195. entry = create_proc_entry("WepKey",
  2196.   S_IFREG | proc_perm,
  2197.   apriv->proc_entry);
  2198.         entry->uid = proc_uid;
  2199.         entry->gid = proc_gid;
  2200. entry->data = dev;
  2201. SETPROC_OPS(entry, proc_wepkey_ops);
  2203. return 0;
  2204. }
  2206. static int takedown_proc_entry( struct net_device *dev,
  2207. struct airo_info *apriv ) {
  2208. if ( !apriv->proc_entry->namelen ) return 0;
  2209. remove_proc_entry("Stats",apriv->proc_entry);
  2210. remove_proc_entry("StatsDelta",apriv->proc_entry);
  2211. remove_proc_entry("Status",apriv->proc_entry);
  2212. remove_proc_entry("Config",apriv->proc_entry);
  2213. remove_proc_entry("SSID",apriv->proc_entry);
  2214. remove_proc_entry("APList",apriv->proc_entry);
  2215. remove_proc_entry("BSSList",apriv->proc_entry);
  2216. remove_proc_entry("WepKey",apriv->proc_entry);
  2217. remove_proc_entry(dev->name,airo_entry);
  2218. return 0;
  2219. }
  2221. /*
  2222.  *  What we want from the proc_fs is to be able to efficiently read
  2223.  *  and write the configuration.  To do this, we want to read the
  2224.  *  configuration when the file is opened and write it when the file is
  2225.  *  closed.  So basically we allocate a read buffer at open and fill it
  2226.  *  with data, and allocate a write buffer and read it at close.
  2227.  */
  2229. /*
  2230.  *  The read routine is generic, it relies on the preallocated rbuffer
  2231.  *  to supply the data.
  2232.  */
  2233. static ssize_t proc_read( struct file *file,
  2234.   char *buffer,
  2235.   size_t len,
  2236.   loff_t *offset )
  2237. {
  2238. int i;
  2239. int pos;
  2240. struct proc_data *priv = (struct proc_data*)file->private_data;
  2242. if( !priv->rbuffer ) return -EINVAL;
  2244. pos = *offset;
  2245. for( i = 0; i+pos < priv->readlen && i < len; i++ ) {
  2246. if (put_user( priv->rbuffer[i+pos], buffer+i ))
  2247. return -EFAULT;
  2248. }
  2249. *offset += i;
  2250. return i;
  2251. }
  2253. /*
  2254.  *  The write routine is generic, it fills in a preallocated rbuffer
  2255.  *  to supply the data.
  2256.  */
  2257. static ssize_t proc_write( struct file *file,
  2258.    const char *buffer,
  2259.    size_t len,
  2260.    loff_t *offset )
  2261. {
  2262. int i;
  2263. int pos;
  2264. struct proc_data *priv = (struct proc_data*)file->private_data;
  2266. if ( !priv->wbuffer ) {
  2267. return -EINVAL;
  2268. }
  2270. pos = *offset;
  2272. for( i = 0; i + pos <  priv->maxwritelen &&
  2273.      i < len; i++ ) {
  2274. if (get_user( priv->wbuffer[i+pos], buffer + i ))
  2275. return -EFAULT;
  2276. }
  2277. if ( i+pos > priv->writelen ) priv->writelen = i+file->f_pos;
  2278. *offset += i;
  2279. return i;
  2280. }
  2282. static int proc_status_open( struct inode *inode, struct file *file ) {
  2283. struct proc_data *data;
  2284. struct proc_dir_entry *dp = inode->u.generic_ip;
  2285. struct net_device *dev = dp->data;
  2286. struct airo_info *apriv = (struct airo_info *)dev->priv;
  2287. CapabilityRid cap_rid;
  2288. StatusRid status_rid;
  2289. int i;
  2291. MOD_INC_USE_COUNT;
  2293. dp = inode->u.generic_ip;
  2295. if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
  2296. return -ENOMEM;
  2297. memset(file->private_data, 0, sizeof(struct proc_data));
  2298. data = (struct proc_data *)file->private_data;
  2299. if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
  2300. kfree (file->private_data);
  2301. return -ENOMEM;
  2302. }
  2304. readStatusRid(apriv, &status_rid);
  2305. readCapabilityRid(apriv, &cap_rid);
  2307.         i = sprintf(data->rbuffer, "Status: %s%s%s%s%s%s%s%s%sn",
  2308.                     status_rid.mode & 1 ? "CFG ": "",
  2309.                     status_rid.mode & 2 ? "ACT ": "",
  2310.                     status_rid.mode & 0x10 ? "SYN ": "",
  2311.                     status_rid.mode & 0x20 ? "LNK ": "",
  2312.                     status_rid.mode & 0x40 ? "LEAP ": "",
  2313.                     status_rid.mode & 0x80 ? "PRIV ": "",
  2314.                     status_rid.mode & 0x100 ? "KEY ": "",
  2315.                     status_rid.mode & 0x200 ? "WEP ": "",
  2316.                     status_rid.mode & 0x8000 ? "ERR ": "");
  2317. sprintf( data->rbuffer+i, "Mode: %xn"
  2318.  "Signal Strength: %dn"
  2319.  "Signal Quality: %dn"
  2320.  "SSID: %-.*sn"
  2321.  "AP: %-.16sn"
  2322.  "Freq: %dn"
  2323.  "BitRate: %dmbsn"
  2324.  "Driver Version: %sn"
  2325.  "Device: %snManufacturer: %snFirmware Version: %sn"
  2326.  "Radio type: %xnCountry: %xnHardware Version: %xn"
  2327.  "Software Version: %xnSoftware Subversion: %xn"
  2328.  "Boot block version: %xn",
  2329.  (int)status_rid.mode,
  2330.  (int)status_rid.normalizedSignalStrength,
  2331.  (int)status_rid.signalQuality,
  2332.  (int)status_rid.SSIDlen,
  2333.  status_rid.SSID,
  2334.  status_rid.apName,
  2335.  (int)status_rid.channel,
  2336.  (int)status_rid.currentXmitRate/2,
  2337.  version,
  2338.  cap_rid.prodName,
  2339.  cap_rid.manName,
  2340.  cap_rid.prodVer,
  2341.  cap_rid.radioType,
  2342.  cap_rid.country,
  2343.  cap_rid.hardVer,
  2344.  (int)cap_rid.softVer,
  2345.  (int)cap_rid.softSubVer,
  2346.  (int)cap_rid.bootBlockVer );
  2347. data->readlen = strlen( data->rbuffer );
  2348. return 0;
  2349. }
  2351. static int proc_stats_rid_open(struct inode*, struct file*, u16);
  2352. static int proc_statsdelta_open( struct inode *inode,
  2353.  struct file *file ) {
  2354. if (file->f_mode&FMODE_WRITE) {
  2355. return proc_stats_rid_open(inode, file, RID_STATSDELTACLEAR);
  2356. }
  2357. return proc_stats_rid_open(inode, file, RID_STATSDELTA);
  2358. }
  2360. static int proc_stats_open( struct inode *inode, struct file *file ) {
  2361. return proc_stats_rid_open(inode, file, RID_STATS);
  2362. }
  2364. static int proc_stats_rid_open( struct inode *inode,
  2365. struct file *file,
  2366. u16 rid ) {
  2367. struct proc_data *data;
  2368. struct proc_dir_entry *dp = inode->u.generic_ip;
  2369. struct net_device *dev = dp->data;
  2370. struct airo_info *apriv = (struct airo_info *)dev->priv;
  2371. StatsRid stats;
  2372. int i, j;
  2373. int *vals = stats.vals;
  2374. MOD_INC_USE_COUNT;
  2377. dp = inode->u.generic_ip;
  2379. if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
  2380. return -ENOMEM;
  2381. memset(file->private_data, 0, sizeof(struct proc_data));
  2382. data = (struct proc_data *)file->private_data;
  2383. if ((data->rbuffer = kmalloc( 4096, GFP_KERNEL )) == NULL) {
  2384. kfree (file->private_data);
  2385. return -ENOMEM;
  2386. }
  2388. readStatsRid(apriv, &stats, rid);
  2390.         j = 0;
  2391. for(i=0; (int)statsLabels[i]!=-1 &&
  2392.     i*4<stats.len; i++){
  2393. if (!statsLabels[i]) continue;
  2394. if (j+strlen(statsLabels[i])+16>4096) {
  2395. printk(KERN_WARNING
  2396.        "airo: Potentially disasterous buffer overflow averted!n");
  2397. break;
  2398. }
  2399. j+=sprintf(data->rbuffer+j, "%s: %dn", statsLabels[i], vals[i]);
  2400. }
  2401. if (i*4>=stats.len){
  2402. printk(KERN_WARNING
  2403.        "airo: Got a short ridn");
  2404. }
  2405. data->readlen = j;
  2406. return 0;
  2407. }
  2409. static int get_dec_u16( char *buffer, int *start, int limit ) {
  2410. u16 value;
  2411. int valid = 0;
  2412. for( value = 0; buffer[*start] >= '0' &&
  2413.      buffer[*start] <= '9' &&
  2414.      *start < limit; (*start)++ ) {
  2415. valid = 1;
  2416. value *= 10;
  2417. value += buffer[*start] - '0';
  2418. }
  2419. if ( !valid ) return -1;
  2420. return value;
  2421. }
  2423. static void checkThrottle(ConfigRid *config) {
  2424. int i;
  2425. /* Old hardware had a limit on encryption speed */
  2426. if (config->authType != AUTH_OPEN && maxencrypt) {
  2427. for(i=0; i<8; i++) {
  2428. if (config->rates[i] > maxencrypt) {
  2429. config->rates[i] = 0;
  2430. }
  2431. }
  2432. }
  2433. }
  2435. static void proc_config_on_close( struct inode *inode, struct file *file ) {
  2436. struct proc_data *data = file->private_data;
  2437. struct proc_dir_entry *dp = inode->u.generic_ip;
  2438. struct net_device *dev = dp->data;
  2439. struct airo_info *ai = (struct airo_info*)dev->priv;
  2440. ConfigRid config;
  2441. Resp rsp;
  2442. char *line;
  2443. int need_reset = 0;
  2445. if ( !data->writelen ) return;
  2446. dp = (struct proc_dir_entry *) inode->u.generic_ip;
  2448. disable_MAC(ai);
  2449. readConfigRid(ai, &config);
  2451. line = data->wbuffer;
  2452. while( line[0] ) {
  2453. /*** Mode processing */
  2454. if ( !strncmp( line, "Mode: ", 6 ) ) {
  2455. line += 6;
  2456. config.rmode &= 0xfe00;
  2457. if ( line[0] == 'a' ) {
  2458. config.opmode = 0;
  2459. } else {
  2460. config.opmode = 1;
  2461. if ( line[0] == 'r' )
  2462. config.rmode |= RXMODE_RFMON | RXMODE_DISABLE_802_3_HEADER;
  2463. else if ( line[0] == 'y' )
  2464. config.rmode |= RXMODE_RFMON_ANYBSS | RXMODE_DISABLE_802_3_HEADER;
  2465. }
  2466. if (config.rmode & RXMODE_DISABLE_802_3_HEADER) {
  2467. dev->type = ARPHRD_IEEE80211;
  2468. dev->hard_header_parse = wll_header_parse;
  2469. } else if (dev->type == ARPHRD_IEEE80211) {
  2470. dev->type = ARPHRD_ETHER;
  2471. dev->hard_header_parse = ai->header_parse;
  2472. need_reset = 1;
  2473. }
  2474. }
  2476. /*** Radio status */
  2477. else if (!strncmp(line,"Radio: ", 7)) {
  2478. line += 7;
  2479. if (!strncmp(line,"off",3)) {
  2480. ai->flags |= FLAG_RADIO_OFF;
  2481. } else {
  2482. ai->flags &= ~FLAG_RADIO_OFF;
  2483. }
  2484. }
  2485. /*** NodeName processing */
  2486. else if ( !strncmp( line, "NodeName: ", 10 ) ) {
  2487. int j;
  2489. line += 10;
  2490. memset( config.nodeName, 0, 16 );
  2491. /* Do the name, assume a space between the mode and node name */
  2492. for( j = 0; j < 16 && line[j] != 'n'; j++ ) {
  2493. config.nodeName[j] = line[j];
  2494. }
  2495. }
  2497. /*** PowerMode processing */
  2498. else if ( !strncmp( line, "PowerMode: ", 11 ) ) {
  2499. line += 11;
  2500. if ( !strncmp( line, "PSPCAM", 6 ) ) {
  2501. config.powerSaveMode = POWERSAVE_PSPCAM;
  2502. } else if ( !strncmp( line, "PSP", 3 ) ) {
  2503. config.powerSaveMode = POWERSAVE_PSP;
  2504. } else {
  2505. config.powerSaveMode = POWERSAVE_CAM;
  2506. }
  2507. } else if ( !strncmp( line, "DataRates: ", 11 ) ) {
  2508. int v, i = 0, k = 0; /* i is index into line,
  2509. k is index to rates */
  2511. line += 11;
  2512. while((v = get_dec_u16(line, &i, 3))!=-1) {
  2513. config.rates[k++] = (u8)v;
  2514. line += i + 1;
  2515. i = 0;
  2516. }
  2517. } else if ( !strncmp( line, "Channel: ", 9 ) ) {
  2518. int v, i = 0;
  2519. line += 9;
  2520. v = get_dec_u16(line, &i, i+3);
  2521. if ( v != -1 )
  2522. config.channelSet = (u16)v;
  2523. } else if ( !strncmp( line, "XmitPower: ", 11 ) ) {
  2524. int v, i = 0;
  2525. line += 11;
  2526. v = get_dec_u16(line, &i, i+3);
  2527. if ( v != -1 ) config.txPower = (u16)v;
  2528. } else if ( !strncmp( line, "WEP: ", 5 ) ) {
  2529. line += 5;
  2530. switch( line[0] ) {
  2531. case 's':
  2532. config.authType = (u16)AUTH_SHAREDKEY;
  2533. break;
  2534. case 'e':
  2535. config.authType = (u16)AUTH_ENCRYPT;
  2536. break;
  2537. default:
  2538. config.authType = (u16)AUTH_OPEN;
  2539. break;
  2540. }
  2541. } else if ( !strncmp( line, "LongRetryLimit: ", 16 ) ) {
  2542. int v, i = 0;
  2544. line += 16;
  2545. v = get_dec_u16(line, &i, 3);
  2546. v = (v<0) ? 0 : ((v>255) ? 255 : v);
  2547. config.longRetryLimit = (u16)v;
  2548. } else if ( !strncmp( line, "ShortRetryLimit: ", 17 ) ) {
  2549. int v, i = 0;
  2551. line += 17;
  2552. v = get_dec_u16(line, &i, 3);
  2553. v = (v<0) ? 0 : ((v>255) ? 255 : v);
  2554. config.shortRetryLimit = (u16)v;
  2555. } else if ( !strncmp( line, "RTSThreshold: ", 14 ) ) {
  2556. int v, i = 0;
  2558. line += 14;
  2559. v = get_dec_u16(line, &i, 4);
  2560. v = (v<0) ? 0 : ((v>2312) ? 2312 : v);
  2561. config.rtsThres = (u16)v;
  2562. } else if ( !strncmp( line, "TXMSDULifetime: ", 16 ) ) {
  2563. int v, i = 0;
  2565. line += 16;
  2566. v = get_dec_u16(line, &i, 5);
  2567. v = (v<0) ? 0 : v;
  2568. config.txLifetime = (u16)v;
  2569. } else if ( !strncmp( line, "RXMSDULifetime: ", 16 ) ) {
  2570. int v, i = 0;
  2572. line += 16;
  2573. v = get_dec_u16(line, &i, 5);
  2574. v = (v<0) ? 0 : v;
  2575. config.rxLifetime = (u16)v;
  2576. } else if ( !strncmp( line, "TXDiversity: ", 13 ) ) {
  2577. config.txDiversity =
  2578. (line[13]=='l') ? 1 :
  2579. ((line[13]=='r')? 2: 3);
  2580. } else if ( !strncmp( line, "RXDiversity: ", 13 ) ) {
  2581. config.rxDiversity =
  2582. (line[13]=='l') ? 1 :
  2583. ((line[13]=='r')? 2: 3);
  2584. } else if ( !strncmp( line, "FragThreshold: ", 15 ) ) {
  2585. int v, i = 0;
  2587. line += 15;
  2588. v = get_dec_u16(line, &i, 4);
  2589. v = (v<256) ? 256 : ((v>2312) ? 2312 : v);
  2590. v = v & 0xfffe; /* Make sure its even */
  2591. config.fragThresh = (u16)v;
  2592. } else if (!strncmp(line, "Modulation: ", 12)) {
  2593. line += 12;
  2594. switch(*line) {
  2595. case 'd':  config.modulation=MOD_DEFAULT; break;
  2596. case 'c':  config.modulation=MOD_CCK; break;
  2597. case 'm':  config.modulation=MOD_MOK; break;
  2598. default:
  2599. printk( KERN_WARNING "airo: Unknown modulationn" );
  2600. }
  2601. } else if (!strncmp(line, "Preamble: ", 10)) {
  2602. line += 10;
  2603. switch(*line) {
  2604. case 'a': config.preamble=PREAMBLE_AUTO; break;
  2605. case 'l': config.preamble=PREAMBLE_LONG; break;
  2606. case 's': config.preamble=PREAMBLE_SHORT; break;
  2607.         default: printk(KERN_WARNING "airo: Unknown preamblen");
  2608. }
  2609. } else {
  2610. printk( KERN_WARNING "Couldn't figure out %sn", line );
  2611. }
  2612. while( line[0] && line[0] != 'n' ) line++;
  2613. if ( line[0] ) line++;
  2614. }
  2615. checkThrottle(&config);
  2616. ai->config = config;
  2617. if (need_reset) {
  2618. APListRid APList_rid;
  2619. SsidRid SSID_rid;
  2621. readAPListRid(ai, &APList_rid);
  2622. readSsidRid(ai, &SSID_rid);
  2623. reset_airo_card(dev);
  2624. writeSsidRid(ai, &SSID_rid);
  2625. writeAPListRid(ai, &APList_rid);
  2626. }
  2627. writeConfigRid(ai, &config);
  2628. enable_MAC(ai, &rsp);
  2629. }
  2631. static int proc_config_open( struct inode *inode, struct file *file ) {
  2632. struct proc_data *data;
  2633. struct proc_dir_entry *dp = inode->u.generic_ip;
  2634. struct net_device *dev = dp->data;
  2635. struct airo_info *ai = (struct airo_info*)dev->priv;
  2636. ConfigRid config;
  2637. int i;
  2639. MOD_INC_USE_COUNT;
  2641. dp = (struct proc_dir_entry *) inode->u.generic_ip;
  2643. if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
  2644. return -ENOMEM;
  2645. memset(file->private_data, 0, sizeof(struct proc_data));
  2646. data = (struct proc_data *)file->private_data;
  2647. if ((data->rbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
  2648. kfree (file->private_data);
  2649. return -ENOMEM;
  2650. }
  2651. if ((data->wbuffer = kmalloc( 2048, GFP_KERNEL )) == NULL) {
  2652. kfree (data->rbuffer);
  2653. kfree (file->private_data);
  2654. return -ENOMEM;
  2655. }
  2656. memset( data->wbuffer, 0, 2048 );
  2657. data->maxwritelen = 2048;
  2658. data->on_close = proc_config_on_close;
  2660. readConfigRid(ai, &config);
  2662. i = sprintf( data->rbuffer,
  2663.      "Mode: %sn"
  2664.      "Radio: %sn"
  2665.      "NodeName: %-16sn"
  2666.      "PowerMode: %sn"
  2667.      "DataRates: %d %d %d %d %d %d %d %dn"
  2668.      "Channel: %dn"
  2669.      "XmitPower: %dn",
  2670.      config.opmode == 0 ? "adhoc" :
  2671.      config.opmode == 1 ? "ESS" :
  2672.      config.opmode == 2 ? "AP" :
  2673.      config.opmode == 3 ? "AP RPTR" : "Error",
  2674.      ai->flags&FLAG_RADIO_OFF ? "off" : "on",
  2675.      config.nodeName,
  2676.      config.powerSaveMode == 0 ? "CAM" :
  2677.      config.powerSaveMode == 1 ? "PSP" :
  2678.      config.powerSaveMode == 2 ? "PSPCAM" : "Error",
  2679.      (int)config.rates[0],
  2680.      (int)config.rates[1],
  2681.      (int)config.rates[2],
  2682.      (int)config.rates[3],
  2683.      (int)config.rates[4],
  2684.      (int)config.rates[5],
  2685.      (int)config.rates[6],
  2686.      (int)config.rates[7],
  2687.      (int)config.channelSet,
  2688.      (int)config.txPower
  2689. );
  2690. sprintf( data->rbuffer + i,
  2691.  "LongRetryLimit: %dn"
  2692.  "ShortRetryLimit: %dn"
  2693.  "RTSThreshold: %dn"
  2694.  "TXMSDULifetime: %dn"
  2695.  "RXMSDULifetime: %dn"
  2696.  "TXDiversity: %sn"
  2697.  "RXDiversity: %sn"
  2698.  "FragThreshold: %dn"
  2699.  "WEP: %sn"
  2700.  "Modulation: %sn"
  2701.  "Preamble: %sn",
  2702.  (int)config.longRetryLimit,
  2703.  (int)config.shortRetryLimit,
  2704.  (int)config.rtsThres,
  2705.  (int)config.txLifetime,
  2706.  (int)config.rxLifetime,
  2707.  config.txDiversity == 1 ? "left" :
  2708.  config.txDiversity == 2 ? "right" : "both",
  2709.  config.rxDiversity == 1 ? "left" :
  2710.  config.rxDiversity == 2 ? "right" : "both",
  2711.  (int)config.fragThresh,
  2712.  config.authType == AUTH_ENCRYPT ? "encrypt" :
  2713.  config.authType == AUTH_SHAREDKEY ? "shared" : "open",
  2714.  config.modulation == 0 ? "default" :
  2715.  config.modulation == MOD_CCK ? "cck" :
  2716.  config.modulation == MOD_MOK ? "mok" : "error",
  2717.  config.preamble == PREAMBLE_AUTO ? "auto" :
  2718.  config.preamble == PREAMBLE_LONG ? "long" :
  2719.  config.preamble == PREAMBLE_SHORT ? "short" : "error"
  2720. );
  2721. data->readlen = strlen( data->rbuffer );
  2722. return 0;
  2723. }
  2725. static void proc_SSID_on_close( struct inode *inode, struct file *file ) {
  2726. struct proc_data *data = (struct proc_data *)file->private_data;
  2727. struct proc_dir_entry *dp = inode->u.generic_ip;
  2728. struct net_device *dev = dp->data;
  2729. struct airo_info *ai = (struct airo_info*)dev->priv;
  2730. SsidRid SSID_rid;
  2731. int i;
  2732. int offset = 0;
  2734. if ( !data->writelen ) return;
  2736. memset( &SSID_rid, 0, sizeof( SSID_rid ) );
  2738. for( i = 0; i < 3; i++ ) {
  2739. int j;
  2740. for( j = 0; j+offset < data->writelen && j < 32 &&
  2741.      data->wbuffer[offset+j] != 'n'; j++ ) {
  2742. SSID_rid.ssids[i].ssid[j] = data->wbuffer[offset+j];
  2743. }
  2744. if ( j == 0 ) break;
  2745. SSID_rid.ssids[i].len = j;
  2746. offset += j;
  2747. while( data->wbuffer[offset] != 'n' &&
  2748.        offset < data->writelen ) offset++;
  2749. offset++;
  2750. }
  2751. writeSsidRid(ai, &SSID_rid);
  2752. }
  2754. inline static u8 hexVal(char c) {
  2755. if (c>='0' && c<='9') return c -= '0';
  2756. if (c>='a' && c<='f') return c -= 'a'-10;
  2757. if (c>='A' && c<='F') return c -= 'A'-10;
  2758. return 0;
  2759. }
  2761. static void proc_APList_on_close( struct inode *inode, struct file *file ) {
  2762. struct proc_data *data = (struct proc_data *)file->private_data;
  2763. struct proc_dir_entry *dp = inode->u.generic_ip;
  2764. struct net_device *dev = dp->data;
  2765. struct airo_info *ai = (struct airo_info*)dev->priv;
  2766. APListRid APList_rid;
  2767. int i;
  2769. if ( !data->writelen ) return;
  2771. memset( &APList_rid, 0, sizeof(APList_rid) );
  2772. APList_rid.len = sizeof(APList_rid);
  2774. for( i = 0; i < 4 && data->writelen >= (i+1)*6*3; i++ ) {
  2775. int j;
  2776. for( j = 0; j < 6*3 && data->wbuffer[j+i*6*3]; j++ ) {
  2777. switch(j%3) {
  2778. case 0:
  2779. APList_rid.ap[i][j/3]=
  2780. hexVal(data->wbuffer[j+i*6*3])<<4;
  2781. break;
  2782. case 1:
  2783. APList_rid.ap[i][j/3]|=
  2784. hexVal(data->wbuffer[j+i*6*3]);
  2785. break;
  2786. }
  2787. }
  2788. }
  2789. writeAPListRid(ai, &APList_rid);
  2790. }
  2792. /* This function wraps PC4500_writerid with a MAC disable */
  2793. static int do_writerid( struct airo_info *ai, u16 rid, const void *rid_data,
  2794. int len ) {
  2795. int rc;
  2796. Resp rsp;
  2798. disable_MAC(ai);
  2799. rc = PC4500_writerid(ai, rid, rid_data, len);
  2800. enable_MAC(ai, &rsp);
  2801. return rc;
  2802. }
  2804. /* Returns the length of the key at the index.  If index == 0xffff
  2805.  * the index of the transmit key is returned.  If the key doesn't exist,
  2806.  * -1 will be returned.
  2807.  */
  2808. static int get_wep_key(struct airo_info *ai, u16 index) {
  2809. WepKeyRid wkr;
  2810. int rc;
  2811. u16 lastindex;
  2813. rc = readWepKeyRid(ai, &wkr, 1);
  2814. if (rc == SUCCESS) do {
  2815. lastindex = wkr.kindex;
  2816. if (wkr.kindex == index) {
  2817. if (index == 0xffff) {
  2818. return wkr.mac[0];
  2819. }
  2820. return wkr.klen;
  2821. }
  2822. readWepKeyRid(ai, &wkr, 0);
  2823. } while(lastindex != wkr.kindex);
  2824. return -1;
  2825. }
  2827. static int set_wep_key(struct airo_info *ai, u16 index,
  2828.        const char *key, u16 keylen, int perm ) {
  2829. static const unsigned char macaddr[6] = { 0x01, 0, 0, 0, 0, 0 };
  2830. WepKeyRid wkr;
  2832. memset(&wkr, 0, sizeof(wkr));
  2833. if (keylen == 0) {
  2834. // We are selecting which key to use
  2835. wkr.len = sizeof(wkr);
  2836. wkr.kindex = 0xffff;
  2837. wkr.mac[0] = (char)index;
  2838. if (perm) printk(KERN_INFO "Setting transmit key to %dn", index);
  2839. if (perm) ai->defindex = (char)index;
  2840. } else {
  2841. // We are actually setting the key
  2842. wkr.len = sizeof(wkr);
  2843. wkr.kindex = index;
  2844. wkr.klen = keylen;
  2845. memcpy( wkr.key, key, keylen );
  2846. memcpy( wkr.mac, macaddr, 6 );
  2847. printk(KERN_INFO "Setting key %dn", index);
  2848. }
  2850. writeWepKeyRid(ai, &wkr, perm);
  2851. return 0;
  2852. }
  2854. static void proc_wepkey_on_close( struct inode *inode, struct file *file ) {
  2855. struct proc_data *data;
  2856. struct proc_dir_entry *dp = inode->u.generic_ip;
  2857. struct net_device *dev = dp->data;
  2858. struct airo_info *ai = (struct airo_info*)dev->priv;
  2859. int i;
  2860. char key[16];
  2861. u16 index = 0;
  2862. int j = 0;
  2864. memset(key, 0, sizeof(key));
  2866. dp = (struct proc_dir_entry *) inode->u.generic_ip;
  2867. data = (struct proc_data *)file->private_data;
  2868. if ( !data->writelen ) return;
  2870. if (data->wbuffer[0] >= '0' && data->wbuffer[0] <= '3' &&
  2871.     (data->wbuffer[1] == ' ' || data->wbuffer[1] == 'n')) {
  2872. index = data->wbuffer[0] - '0';
  2873. if (data->wbuffer[1] == 'n') {
  2874. set_wep_key(ai, index, 0, 0, 1);
  2875. return;
  2876. }
  2877. j = 2;
  2878. } else {
  2879. printk(KERN_ERR "airo:  WepKey passed invalid key indexn");
  2880. return;
  2881. }
  2883. for( i = 0; i < 16*3 && data->wbuffer[i+j]; i++ ) {
  2884. switch(i%3) {
  2885. case 0:
  2886. key[i/3] = hexVal(data->wbuffer[i+j])<<4;
  2887. break;
  2888. case 1:
  2889. key[i/3] |= hexVal(data->wbuffer[i+j]);
  2890. break;
  2891. }
  2892. }
  2893. set_wep_key(ai, index, key, i/3, 1);
  2894. }
  2896. static int proc_wepkey_open( struct inode *inode, struct file *file ) {
  2897. struct proc_data *data;
  2898. struct proc_dir_entry *dp = inode->u.generic_ip;
  2899. struct net_device *dev = dp->data;
  2900. struct airo_info *ai = (struct airo_info*)dev->priv;
  2901. char *ptr;
  2902. WepKeyRid wkr;
  2903. u16 lastindex;
  2904. int j=0;
  2905. int rc;
  2907. MOD_INC_USE_COUNT;
  2909. dp = (struct proc_dir_entry *) inode->u.generic_ip;
  2911. if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
  2912. return -ENOMEM;
  2913. memset(file->private_data, 0, sizeof(struct proc_data));
  2914. memset(&wkr, 0, sizeof(wkr));
  2915. data = (struct proc_data *)file->private_data;
  2916. if ((data->rbuffer = kmalloc( 180, GFP_KERNEL )) == NULL) {
  2917. kfree (file->private_data);
  2918. return -ENOMEM;
  2919. }
  2920. memset(data->rbuffer, 0, 180);
  2921. data->writelen = 0;
  2922. data->maxwritelen = 80;
  2923. if ((data->wbuffer = kmalloc( 80, GFP_KERNEL )) == NULL) {
  2924. kfree (data->rbuffer);
  2925. kfree (file->private_data);
  2926. return -ENOMEM;
  2927. }
  2928. memset( data->wbuffer, 0, 80 );
  2929. data->on_close = proc_wepkey_on_close;
  2931. ptr = data->rbuffer;
  2932. strcpy(ptr, "No wep keysn");
  2933. rc = readWepKeyRid(ai, &wkr, 1);
  2934. if (rc == SUCCESS) do {
  2935. lastindex = wkr.kindex;
  2936. if (wkr.kindex == 0xffff) {
  2937. j += sprintf(ptr+j, "Tx key = %dn",
  2938.      (int)wkr.mac[0]);
  2939. } else {
  2940. j += sprintf(ptr+j, "Key %d set with length = %dn",
  2941.      (int)wkr.kindex, (int)wkr.klen);
  2942. }
  2943. readWepKeyRid(ai, &wkr, 0);
  2944. } while((lastindex != wkr.kindex) && (j < 180-30));
  2946. data->readlen = strlen( data->rbuffer );
  2947. return 0;
  2948. }
  2950. static int proc_SSID_open( struct inode *inode, struct file *file ) {
  2951. struct proc_data *data;
  2952. struct proc_dir_entry *dp = inode->u.generic_ip;
  2953. struct net_device *dev = dp->data;
  2954. struct airo_info *ai = (struct airo_info*)dev->priv;
  2955. int i;
  2956. char *ptr;
  2957. SsidRid SSID_rid;
  2959. MOD_INC_USE_COUNT;
  2961. dp = (struct proc_dir_entry *) inode->u.generic_ip;
  2963. if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
  2964. return -ENOMEM;
  2965. memset(file->private_data, 0, sizeof(struct proc_data));
  2966. data = (struct proc_data *)file->private_data;
  2967. if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
  2968. kfree (file->private_data);
  2969. return -ENOMEM;
  2970. }
  2971. data->writelen = 0;
  2972. data->maxwritelen = 33*3;
  2973. if ((data->wbuffer = kmalloc( 33*3, GFP_KERNEL )) == NULL) {
  2974. kfree (data->rbuffer);
  2975. kfree (file->private_data);
  2976. return -ENOMEM;
  2977. }
  2978. memset( data->wbuffer, 0, 33*3 );
  2979. data->on_close = proc_SSID_on_close;
  2981. readSsidRid(ai, &SSID_rid);
  2982. ptr = data->rbuffer;
  2983. for( i = 0; i < 3; i++ ) {
  2984. int j;
  2985. if ( !SSID_rid.ssids[i].len ) break;
  2986. for( j = 0; j < 32 &&
  2987.      j < SSID_rid.ssids[i].len &&
  2988.      SSID_rid.ssids[i].ssid[j]; j++ ) {
  2989. *ptr++ = SSID_rid.ssids[i].ssid[j];
  2990. }
  2991. *ptr++ = 'n';
  2992. }
  2993. *ptr = '';
  2994. data->readlen = strlen( data->rbuffer );
  2995. return 0;
  2996. }
  2998. static int proc_APList_open( struct inode *inode, struct file *file ) {
  2999. struct proc_data *data;
  3000. struct proc_dir_entry *dp = inode->u.generic_ip;
  3001. struct net_device *dev = dp->data;
  3002. struct airo_info *ai = (struct airo_info*)dev->priv;
  3003. int i;
  3004. char *ptr;
  3005. APListRid APList_rid;
  3007. MOD_INC_USE_COUNT;
  3009. dp = (struct proc_dir_entry *) inode->u.generic_ip;
  3011. if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
  3012. return -ENOMEM;
  3013. memset(file->private_data, 0, sizeof(struct proc_data));
  3014. data = (struct proc_data *)file->private_data;
  3015. if ((data->rbuffer = kmalloc( 104, GFP_KERNEL )) == NULL) {
  3016. kfree (file->private_data);
  3017. return -ENOMEM;
  3018. }
  3019. data->writelen = 0;
  3020. data->maxwritelen = 4*6*3;
  3021. if ((data->wbuffer = kmalloc( data->maxwritelen, GFP_KERNEL )) == NULL) {
  3022. kfree (data->rbuffer);
  3023. kfree (file->private_data);
  3024. return -ENOMEM;
  3025. }
  3026. memset( data->wbuffer, 0, data->maxwritelen );
  3027. data->on_close = proc_APList_on_close;
  3029. readAPListRid(ai, &APList_rid);
  3030. ptr = data->rbuffer;
  3031. for( i = 0; i < 4; i++ ) {
  3032. // We end when we find a zero MAC
  3033. if ( !*(int*)APList_rid.ap[i] &&
  3034.      !*(int*)&APList_rid.ap[i][2]) break;
  3035. ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02xn",
  3036.        (int)APList_rid.ap[i][0],
  3037.        (int)APList_rid.ap[i][1],
  3038.        (int)APList_rid.ap[i][2],
  3039.        (int)APList_rid.ap[i][3],
  3040.        (int)APList_rid.ap[i][4],
  3041.        (int)APList_rid.ap[i][5]);
  3042. }
  3043. if (i==0) ptr += sprintf(ptr, "Not using specific APsn");
  3045. *ptr = '';
  3046. data->readlen = strlen( data->rbuffer );
  3047. return 0;
  3048. }
  3050. static int proc_BSSList_open( struct inode *inode, struct file *file ) {
  3051. struct proc_data *data;
  3052. struct proc_dir_entry *dp = inode->u.generic_ip;
  3053. struct net_device *dev = dp->data;
  3054. struct airo_info *ai = (struct airo_info*)dev->priv;
  3055. char *ptr;
  3056. BSSListRid BSSList_rid;
  3057. int rc;
  3058. /* If doLoseSync is not 1, we won't do a Lose Sync */
  3059. int doLoseSync = -1;
  3061. MOD_INC_USE_COUNT;
  3063. dp = (struct proc_dir_entry *) inode->u.generic_ip;
  3065. if ((file->private_data = kmalloc(sizeof(struct proc_data ), GFP_KERNEL)) == NULL)
  3066. return -ENOMEM;
  3067. memset(file->private_data, 0, sizeof(struct proc_data));
  3068. data = (struct proc_data *)file->private_data;
  3069. if ((data->rbuffer = kmalloc( 1024, GFP_KERNEL )) == NULL) {
  3070. kfree (file->private_data);
  3071. return -ENOMEM;
  3072. }
  3073. data->writelen = 0;
  3074. data->maxwritelen = 0;
  3075. data->wbuffer = 0;
  3076. data->on_close = 0;
  3078. if (file->f_mode & FMODE_WRITE) {
  3079. if (!(file->f_mode & FMODE_READ)) {
  3080. Cmd cmd;
  3081. Resp rsp;
  3083. memset(&cmd, 0, sizeof(cmd));
  3084. cmd.cmd=CMD_LISTBSS;
  3085. lock_issuecommand(ai, &cmd, &rsp);
  3086. data->readlen = 0;
  3087. return 0;
  3088. }
  3089. doLoseSync = 1;
  3090. }
  3091. ptr = data->rbuffer;
  3092. /* There is a race condition here if there are concurrent opens.
  3093.            Since it is a rare condition, we'll just live with it, otherwise
  3094.            we have to add a spin lock... */
  3095. rc = readBSSListRid(ai, doLoseSync, &BSSList_rid);
  3096. while(rc == 0 && BSSList_rid.index != 0xffff) {
  3097. ptr += sprintf(ptr, "%02x:%02x:%02x:%02x:%02x:%02x %*s rssi = %d",
  3098. (int)BSSList_rid.bssid[0],
  3099. (int)BSSList_rid.bssid[1],
  3100. (int)BSSList_rid.bssid[2],
  3101. (int)BSSList_rid.bssid[3],
  3102. (int)BSSList_rid.bssid[4],
  3103. (int)BSSList_rid.bssid[5],
  3104. (int)BSSList_rid.ssidLen,
  3105. BSSList_rid.ssid,
  3106. (int)BSSList_rid.rssi);
  3107. ptr += sprintf(ptr, " channel = %d %s %s %s %sn",
  3108. (int)BSSList_rid.dsChannel,
  3109. BSSList_rid.cap & CAP_ESS ? "ESS" : "",
  3110. BSSList_rid.cap & CAP_IBSS ? "adhoc" : "",
  3111. BSSList_rid.cap & CAP_PRIVACY ? "wep" : "",
  3112. BSSList_rid.cap & CAP_SHORTHDR ? "shorthdr" : "");
  3113. rc = readBSSListRid(ai, 0, &BSSList_rid);
  3114. }
  3115. *ptr = '';
  3116. data->readlen = strlen( data->rbuffer );
  3117. return 0;
  3118. }
  3120. static int proc_close( struct inode *inode, struct file *file )
  3121. {
  3122. struct proc_data *data = (struct proc_data *)file->private_data;
  3123. if ( data->on_close != NULL ) data->on_close( inode, file );
  3124. MOD_DEC_USE_COUNT;
  3125. if ( data->rbuffer ) kfree( data->rbuffer );
  3126. if ( data->wbuffer ) kfree( data->wbuffer );
  3127. kfree( data );
  3128. return 0;
  3129. }
  3131. static struct net_device_list {
  3132. struct net_device *dev;
  3133. struct net_device_list *next;
  3134. } *airo_devices = 0;
  3136. /* Since the card doesnt automatically switch to the right WEP mode,
  3137.    we will make it do it.  If the card isn't associated, every secs we
  3138.    will switch WEP modes to see if that will help.  If the card is
  3139.    associated we will check every minute to see if anything has
  3140.    changed. */
  3141. static void timer_func( u_long data ) {
  3142. struct net_device *dev = (struct net_device*)data;
  3143. struct airo_info *apriv = (struct airo_info *)dev->priv;
  3144. u16 linkstat = IN4500(apriv, LINKSTAT);
  3146. if (linkstat != 0x400 ) {
  3147. /* We don't have a link so try changing the authtype */
  3148. ConfigRid config = apriv->config;
  3150. switch(apriv->authtype) {
  3151. case AUTH_ENCRYPT:
  3152. /* So drop to OPEN */
  3153. config.authType = AUTH_OPEN;
  3154. apriv->authtype = AUTH_OPEN;
  3155. break;
  3156. case AUTH_SHAREDKEY:
  3157. if (apriv->keyindex < auto_wep) {
  3158. set_wep_key(apriv, apriv->keyindex, 0, 0, 0);
  3159. config.authType = AUTH_SHAREDKEY;
  3160. apriv->authtype = AUTH_SHAREDKEY;
  3161. apriv->keyindex++;
  3162. } else {
  3163.         /* Drop to ENCRYPT */
  3164. apriv->keyindex = 0;
  3165. set_wep_key(apriv, apriv->defindex, 0, 0, 0);
  3166. config.authType = AUTH_ENCRYPT;
  3167. apriv->authtype = AUTH_ENCRYPT;
  3168. }
  3169. break;
  3170. default:  /* We'll escalate to SHAREDKEY */
  3171. config.authType = AUTH_SHAREDKEY;
  3172. apriv->authtype = AUTH_SHAREDKEY;
  3173. }
  3174. checkThrottle(&config);
  3175. writeConfigRid(apriv, &config);
  3177. /* Schedule check to see if the change worked */
  3178. apriv->timer.expires = RUN_AT(HZ*3);
  3179. add_timer(&apriv->timer);
  3180. }
  3181. }
  3183. static int add_airo_dev( struct net_device *dev ) {
  3184. struct net_device_list *node = kmalloc( sizeof( *node ), GFP_KERNEL );
  3185. if ( !node )
  3186. return -ENOMEM;
  3188. if ( auto_wep ) {
  3189. struct airo_info *apriv=dev->priv;
  3190. struct timer_list *timer = &apriv->timer;
  3192. timer->function = timer_func;
  3193. timer->data = (u_long)dev;
  3194. init_timer(timer);
  3195. apriv->authtype = AUTH_SHAREDKEY;
  3196. }
  3198. node->dev = dev;
  3199. node->next = airo_devices;
  3200. airo_devices = node;
  3202. return 0;
  3203. }
  3205. static void del_airo_dev( struct net_device *dev ) {
  3206. struct net_device_list **p = &airo_devices;
  3207. while( *p && ( (*p)->dev != dev ) )
  3208. p = &(*p)->next;
  3209. if ( *p && (*p)->dev == dev )
  3210. *p = (*p)->next;
  3211. }
  3213. #ifdef CONFIG_PCI
  3214. static int __devinit airo_pci_probe(struct pci_dev *pdev,
  3215.     const struct pci_device_id *pent)
  3216. {
  3217. struct net_device *dev;
  3219. dev = init_airo_card(pdev->irq, pdev->resource[2].start, 0);
  3220. if (!dev)
  3221. return -ENODEV;
  3223. pci_set_drvdata(pdev, dev);
  3224. return 0;
  3225. }
  3227. static void __devexit airo_pci_remove(struct pci_dev *pdev)
  3228. {
  3229. stop_airo_card(pci_get_drvdata(pdev), 1);
  3230. }
  3231. #endif
  3233. static int __init airo_init_module( void )
  3234. {
  3235. int i, rc = 0, have_isa_dev = 0;
  3237. airo_entry = create_proc_entry("aironet",
  3238.        S_IFDIR | airo_perm,
  3239.        proc_root_driver);
  3240.         airo_entry->uid = proc_uid;
  3241.         airo_entry->gid = proc_gid;
  3243. for( i = 0; i < 4 && io[i] && irq[i]; i++ ) {
  3244. printk( KERN_INFO
  3245. "airo:  Trying to configure ISA adapter at irq=%d io=0x%xn",
  3246. irq[i], io[i] );
  3247. if (init_airo_card( irq[i], io[i], 0 ))
  3248. have_isa_dev = 1;
  3249. }
  3251. #ifdef CONFIG_PCI
  3252. printk( KERN_INFO "airo:  Probing for PCI adaptersn" );
  3253. rc = pci_module_init(&airo_driver);
  3254. printk( KERN_INFO "airo:  Finished probing for PCI adaptersn" );
  3255. #endif
  3257. /* Always exit with success, as we are a library module
  3258.  * as well as a driver module
  3259.  */
  3260. return 0;
  3261. }
  3263. static void __exit airo_cleanup_module( void )
  3264. {
  3265. while( airo_devices ) {
  3266. printk( KERN_INFO "airo: Unregistering %sn", airo_devices->dev->name );
  3267. stop_airo_card( airo_devices->dev, 1 );
  3268. }
  3269. remove_proc_entry("aironet", proc_root_driver);
  3270. }
  3272. #ifdef WIRELESS_EXT
  3273. /*
  3274.  * Initial Wireless Extension code for Aironet driver by :
  3275.  * Jean Tourrilhes <jt@hpl.hp.com> - HPL - 17 November 00
  3276.  */
  3277. #ifndef IW_ENCODE_NOKEY
  3278. #define IW_ENCODE_NOKEY         0x0800  /* Key is write only, so not present */
  3279. #define IW_ENCODE_MODE  (IW_ENCODE_DISABLED | IW_ENCODE_RESTRICTED | IW_ENCODE_OPEN)
  3280. #endif /* IW_ENCODE_NOKEY */
  3281. #endif /* WIRELESS_EXT */
  3283. /*
  3284.  * This defines the configuration part of the Wireless Extensions
  3285.  * Note : irq and spinlock protection will occur in the subroutines
  3286.  *
  3287.  * TODO :
  3288.  * o Check input value more carefully and fill correct values in range
  3289.  * o Implement : POWER, SPY, APLIST
  3290.  * o Optimise when adapter is closed (aggregate changes, commit later)
  3291.  * o Test and shakeout the bugs (if any)
  3292.  *
  3293.  * Jean II
  3294.  *
  3295.  * Javier Achirica did a great job of merging code from the unnamed CISCO
  3296.  * developer that added support for flashing the card.
  3297.  */
  3298. static int airo_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
  3299. {
  3300. int i, rc = 0;
  3301. #ifdef WIRELESS_EXT
  3302. struct airo_info *local = (struct airo_info*) dev->priv;
  3303. struct iwreq *wrq = (struct iwreq *) rq;
  3304. ConfigRid config; /* Configuration info */
  3305. CapabilityRid cap_rid; /* Card capability info */
  3306. StatusRid status_rid; /* Card status info */
  3308. #ifdef CISCO_EXT
  3309. if (cmd != SIOCGIWPRIV && cmd != AIROIOCTL && cmd != AIROIDIFC
  3310. #ifdef AIROOLDIOCTL
  3311. && cmd != AIROOLDIOCTL && cmd != AIROOLDIDIFC
  3312. #endif
  3313. )
  3314. #endif /* CISCO_EXT */
  3315. {
  3316. /* If the command read some stuff, we better get it out of
  3317.  * the card first... */
  3318. if(IW_IS_GET(cmd))
  3319. readStatusRid(local, &status_rid);
  3320. if(IW_IS_GET(cmd) || (cmd == SIOCSIWRATE) || (cmd == SIOCSIWENCODE))
  3321. readCapabilityRid(local, &cap_rid);
  3322. /* Get config in all cases, because SET will just modify it */
  3323. readConfigRid(local, &config);
  3324. }
  3325. #endif /* WIRELESS_EXT */
  3327. switch (cmd) {
  3328. #ifdef WIRELESS_EXT
  3329. // Get name
  3330. case SIOCGIWNAME:
  3331. strcpy(wrq->u.name, "IEEE 802.11-DS");
  3332. break;
  3334. // Set frequency/channel
  3335. case SIOCSIWFREQ:
  3336. /* If setting by frequency, convert to a channel */
  3337. if((wrq->u.freq.e == 1) &&
  3338.    (wrq->u.freq.m >= (int) 2.412e8) &&
  3339.    (wrq->u.freq.m <= (int) 2.487e8)) {
  3340. int f = wrq->u.freq.m / 100000;
  3341. int c = 0;
  3342. while((c < 14) && (f != frequency_list[c]))
  3343. c++;
  3344. /* Hack to fall through... */
  3345. wrq->u.freq.e = 0;
  3346. wrq->u.freq.m = c + 1;
  3347. }
  3348. /* Setting by channel number */
  3349. if((wrq->u.freq.m > 1000) || (wrq->u.freq.e > 0))
  3350. rc = -EOPNOTSUPP;
  3351. else {
  3352. int channel = wrq->u.freq.m;
  3353. /* We should do a better check than that,
  3354.  * based on the card capability !!! */
  3355. if((channel < 1) || (channel > 16)) {
  3356. printk(KERN_DEBUG "%s: New channel value of %d is invalid!n", dev->name, wrq->u.freq.m);
  3357. rc = -EINVAL;
  3358. } else {
  3359. /* Yes ! We can set it !!! */
  3360. config.channelSet = (u16)(channel - 1);
  3361. local->need_commit = 1;
  3362. }
  3363. }
  3364. break;
  3366. // Get frequency/channel
  3367. case SIOCGIWFREQ:
  3368. #ifdef WEXT_USECHANNELS
  3369. wrq->u.freq.m = ((int)status_rid.channel) + 1;
  3370. wrq->u.freq.e = 0;
  3371. #else
  3372. {
  3373. int f = (int)status_rid.channel;
  3374. wrq->u.freq.m = frequency_list[f] * 100000;
  3375. wrq->u.freq.e = 1;
  3376. }
  3377. #endif
  3378. break;
  3380. // Set desired network name (ESSID)
  3381. case SIOCSIWESSID:
  3382. if (wrq->u.data.pointer) {
  3383. char essid[IW_ESSID_MAX_SIZE + 1];
  3384. SsidRid SSID_rid; /* SSIDs */
  3386. /* Reload the list of current SSID */
  3387. readSsidRid(local, &SSID_rid);
  3389. /* Check if we asked for `any' */
  3390. if(wrq->u.data.flags == 0) {
  3391. /* Just send an empty SSID list */
  3392. memset(&SSID_rid, 0, sizeof(SSID_rid));
  3393. } else {
  3394. int index = (wrq->u.data.flags &
  3395.  IW_ENCODE_INDEX) - 1;
  3397. /* Check the size of the string */
  3398. if(wrq->u.data.length > IW_ESSID_MAX_SIZE+1) {
  3399. rc = -E2BIG;
  3400. break;
  3401. }
  3402. /* Check if index is valid */
  3403. if((index < 0) || (index >= 4)) {
  3404. rc = -EINVAL;
  3405. break;
  3406. }
  3408. /* Set the SSID */
  3409. memset(essid, 0, sizeof(essid));
  3410. if (copy_from_user(essid,
  3411.        wrq->u.data.pointer,
  3412.        wrq->u.data.length)) {
  3413. rc = -EFAULT;
  3414. break;
  3415. }
  3416. memcpy(SSID_rid.ssids[index].ssid, essid,
  3417.        sizeof(essid) - 1);
  3418. SSID_rid.ssids[index].len = wrq->u.data.length - 1;
  3419. }
  3420. /* Write it to the card */
  3421. writeSsidRid(local, &SSID_rid);
  3422. }
  3423. break;
  3425. // Get current network name (ESSID)
  3426. case SIOCGIWESSID:
  3427. if (wrq->u.data.pointer) {
  3428. char essid[IW_ESSID_MAX_SIZE + 1];
  3430. /* Note : if wrq->u.data.flags != 0, we should
  3431.  * get the relevant SSID from the SSID list... */
  3433. /* Get the current SSID */
  3434. memcpy(essid, status_rid.SSID, status_rid.SSIDlen);
  3435. essid[status_rid.SSIDlen] = '';
  3436. /* If none, we may want to get the one that was set */
  3438. /* Push it out ! */
  3439. wrq->u.data.length = strlen(essid) + 1;
  3440. wrq->u.data.flags = 1; /* active */
  3441. if (copy_to_user(wrq->u.data.pointer, essid, sizeof(essid)))
  3442. rc = -EFAULT;
  3443. }
  3444. break;
  3446. case SIOCSIWAP:
  3447. if (wrq->u.ap_addr.sa_family != ARPHRD_ETHER)
  3448. rc = -EINVAL;
  3449. else {
  3450. APListRid APList_rid;
  3452. memset(&APList_rid, 0, sizeof(APList_rid));
  3453. APList_rid.len = sizeof(APList_rid);
  3454. memcpy(APList_rid.ap[0], wrq->u.ap_addr.sa_data, 6);
  3455. writeAPListRid(local, &APList_rid);
  3456. local->need_commit = 1;
  3457. }
  3458. break;
  3460. // Get current Access Point (BSSID)
  3461. case SIOCGIWAP:
  3462. /* Tentative. This seems to work, wow, I'm lucky !!! */
  3463. memcpy(wrq->u.ap_addr.sa_data, status_rid.bssid[0], 6);
  3464. wrq->u.ap_addr.sa_family = ARPHRD_ETHER;
  3465. break;
  3467. // Set desired station name
  3468. case SIOCSIWNICKN:
  3469. if (wrq->u.data.pointer) {
  3470. char name[16 + 1];
  3472. /* Check the size of the string */
  3473. if(wrq->u.data.length > 16 + 1) {
  3474. rc = -E2BIG;
  3475. break;
  3476. }
  3477. memset(name, 0, sizeof(name));
  3478. if (copy_from_user(name, wrq->u.data.pointer,
  3479.    wrq->u.data.length)) {
  3480. rc = -EFAULT;
  3481. break;
  3482. }
  3483. memcpy(config.nodeName, name, 16);
  3484. local->need_commit = 1;
  3485. }
  3486. break;
  3488. // Get current station name
  3489. case SIOCGIWNICKN:
  3490. if (wrq->u.data.pointer) {
  3491. char name[IW_ESSID_MAX_SIZE + 1];
  3493. strncpy(name, config.nodeName, 16);
  3494. name[16] = '';
  3495. wrq->u.data.length = strlen(name) + 1;
  3496. if (copy_to_user(wrq->u.data.pointer, name, sizeof(name)))
  3497. rc = -EFAULT;
  3498. }
  3499. break;
  3501. // Set the desired bit-rate
  3502. case SIOCSIWRATE:
  3503. {
  3504. /* First : get a valid bit rate value */
  3505. u8 brate = 0;
  3506. int i;
  3508. /* Which type of value ? */
  3509. if((wrq->u.bitrate.value < 8) &&
  3510.    (wrq->u.bitrate.value >= 0)) {
  3511. /* Setting by rate index */
  3512. /* Find value in the magic rate table */
  3513. brate = cap_rid.supportedRates[wrq->u.bitrate.value];
  3514. } else {
  3515. /* Setting by frequency value */
  3516. u8 normvalue = (u8) (wrq->u.bitrate.value/500000);
  3518. /* Check if rate is valid */
  3519. for(i = 0 ; i < 8 ; i++) {
  3520. if(normvalue == cap_rid.supportedRates[i]) {
  3521. brate = normvalue;
  3522. break;
  3523. }
  3524. }
  3525. }
  3526. /* -1 designed the max rate (mostly auto mode) */
  3527. if(wrq->u.bitrate.value == -1) {
  3528. /* Get the highest available rate */
  3529. for(i = 0 ; i < 8 ; i++) {
  3530. if(cap_rid.supportedRates[i] == 0)
  3531. break;
  3532. }
  3533. if(i != 0)
  3534. brate = cap_rid.supportedRates[i - 1];
  3535. }
  3536. /* Check that it is valid */
  3537. if(brate == 0) {
  3538. rc = -EINVAL;
  3539. break;
  3540. }
  3542. /* Now, check if we want a fixed or auto value */
  3543. if(wrq->u.bitrate.fixed == 0) {
  3544. /* Fill all the rates up to this max rate */
  3545. memset(config.rates, 0, 8);
  3546. for(i = 0 ; i < 8 ; i++) {
  3547. config.rates[i] = cap_rid.supportedRates[i];
  3548. if(config.rates[i] == brate)
  3549. break;
  3550. }
  3551. local->need_commit = 1;
  3552. } else {
  3553. /* Fixed mode */
  3554. /* One rate, fixed */
  3555. memset(config.rates, 0, 8);
  3556. config.rates[0] = brate;
  3557. local->need_commit = 1;
  3558. }
  3559. break;
  3560. }
  3562. // Get the current bit-rate
  3563. case SIOCGIWRATE:
  3564. {
  3565. int brate = status_rid.currentXmitRate;
  3566. wrq->u.bitrate.value = brate * 500000;
  3567. /* If more than one rate, set auto */
  3568. wrq->u.rts.fixed = (config.rates[1] == 0);
  3569. }
  3570. break;
  3572. // Set the desired RTS threshold
  3573. case SIOCSIWRTS:
  3574. {
  3575. int rthr = wrq->u.rts.value;
  3576. if(wrq->u.rts.disabled)
  3577. rthr = 2312;
  3578. if((rthr < 0) || (rthr > 2312)) {
  3579. rc = -EINVAL;
  3580. } else {
  3581. config.rtsThres = rthr;
  3582. local->need_commit = 1;
  3583. }
  3584. }
  3585. break;
  3587. // Get the current RTS threshold
  3588. case SIOCGIWRTS:
  3589. wrq->u.rts.value = config.rtsThres;
  3590. wrq->u.rts.disabled = (wrq->u.rts.value >= 2312);
  3591. wrq->u.rts.fixed = 1;
  3592. break;
  3594. // Set the desired fragmentation threshold
  3595. case SIOCSIWFRAG:
  3596. {
  3597. int fthr = wrq->u.frag.value;
  3598. if(wrq->u.frag.disabled)
  3599. fthr = 2312;
  3600. if((fthr < 256) || (fthr > 2312)) {
  3601. rc = -EINVAL;
  3602. } else {
  3603. fthr &= ~0x1; /* Get an even value */
  3604. config.fragThresh = (u16)fthr;
  3605. local->need_commit = 1;
  3606. }
  3607. }
  3608. break;
  3610. // Get the current fragmentation threshold
  3611. case SIOCGIWFRAG:
  3612. wrq->u.frag.value = config.fragThresh;
  3613. wrq->u.frag.disabled = (wrq->u.frag.value >= 2312);
  3614. wrq->u.frag.fixed = 1;
  3615. break;
  3617. // Set mode of operation
  3618. case SIOCSIWMODE:
  3619. switch(wrq->u.mode) {
  3620. case IW_MODE_ADHOC:
  3621. config.opmode = MODE_STA_IBSS;
  3622. local->need_commit = 1;
  3623. break;
  3624. case IW_MODE_INFRA:
  3625. config.opmode = MODE_STA_ESS;
  3626. local->need_commit = 1;
  3627. break;
  3628. case IW_MODE_MASTER:
  3629. config.opmode = MODE_AP;
  3630. local->need_commit = 1;
  3631. break;
  3632. case IW_MODE_REPEAT:
  3633. config.opmode = MODE_AP_RPTR;
  3634. local->need_commit = 1;
  3635. break;
  3636. default:
  3637. rc = -EINVAL;
  3638. }
  3639. break;
  3641. // Get mode of operation
  3642. case SIOCGIWMODE:
  3643. /* If not managed, assume it's ad-hoc */
  3644. switch (config.opmode & 0xFF) {
  3645. case MODE_STA_ESS:
  3646. wrq->u.mode = IW_MODE_INFRA;
  3647. break;
  3648. case MODE_AP:
  3649. wrq->u.mode = IW_MODE_MASTER;
  3650. break;
  3651. case MODE_AP_RPTR:
  3652. wrq->u.mode = IW_MODE_REPEAT;
  3653. break;
  3654. default:
  3655. wrq->u.mode = IW_MODE_ADHOC;
  3656. }
  3657. break;
  3659. // Set WEP keys and mode
  3660. case SIOCSIWENCODE:
  3661. /* Is WEP supported ? */
  3662. /* Older firmware doesn't support this...
  3663. if(!(cap_rid.softCap & 2)) {
  3664. rc = -EOPNOTSUPP;
  3665. break;
  3666. } */
  3667. /* Basic checking: do we have a key to set ? */
  3668. if (wrq->u.encoding.pointer != (caddr_t) 0) {
  3669. wep_key_t key;
  3670. int index = (wrq->u.encoding.flags & IW_ENCODE_INDEX) - 1;
  3671. int current_index = get_wep_key(local, 0xffff);
  3672. /* Check the size of the key */
  3673. if (wrq->u.encoding.length > MAX_KEY_SIZE) {
  3674. rc = -EINVAL;
  3675. break;
  3676. }
  3677. /* Check the index (none -> use current) */
  3678. if ((index < 0) || (index>=(cap_rid.softCap&0x80)?4:1))
  3679. index = current_index;
  3680. /* Set the length */
  3681. if (wrq->u.encoding.length > MIN_KEY_SIZE)
  3682. key.len = MAX_KEY_SIZE;
  3683. else
  3684. if (wrq->u.encoding.length > 0)
  3685. key.len = MIN_KEY_SIZE;
  3686. else
  3687. /* Disable the key */
  3688. key.len = 0;
  3689. /* Check if the key is not marked as invalid */
  3690. if(!(wrq->u.encoding.flags & IW_ENCODE_NOKEY)) {
  3691. /* Cleanup */
  3692. memset(key.key, 0, MAX_KEY_SIZE);
  3693. /* Copy the key in the driver */
  3694. if(copy_from_user(key.key,
  3695.   wrq->u.encoding.pointer,
  3696.   wrq->u.encoding.length)) {
  3697. key.len = 0;
  3698. rc = -EFAULT;
  3699. break;
  3700. }
  3701. /* Send the key to the card */
  3702. set_wep_key(local, index, key.key,
  3703.     key.len, 1);
  3704. }
  3705. /* WE specify that if a valid key is set, encryption
  3706.  * should be enabled (user may turn it off later)
  3707.  * This is also how "iwconfig ethX key on" works */
  3708. if((index == current_index) && (key.len > 0) &&
  3709.    (config.authType == AUTH_OPEN)) {
  3710. config.authType = AUTH_ENCRYPT;
  3711. local->need_commit = 1;
  3712. }
  3713. } else {
  3714. /* Do we want to just set the transmit key index ? */
  3715. int index = (wrq->u.encoding.flags & IW_ENCODE_INDEX) - 1;
  3716. if ((index>=0) && (index<(cap_rid.softCap&0x80)?4:1)) {
  3717. set_wep_key(local, index, 0, 0, 1);
  3718. } else
  3719. /* Don't complain if only change the mode */
  3720. if(!wrq->u.encoding.flags & IW_ENCODE_MODE) {
  3721. rc = -EINVAL;
  3722. break;
  3723. }
  3724. }
  3725. /* Read the flags */
  3726. if(wrq->u.encoding.flags & IW_ENCODE_DISABLED)
  3727. config.authType = AUTH_OPEN; // disable encryption
  3728. if(wrq->u.encoding.flags & IW_ENCODE_RESTRICTED)
  3729. config.authType = AUTH_SHAREDKEY; // Only Both
  3730. if(wrq->u.encoding.flags & IW_ENCODE_OPEN)
  3731. config.authType = AUTH_ENCRYPT; // Only Wep
  3732. /* Commit the changes if needed */
  3733. if(wrq->u.encoding.flags & IW_ENCODE_MODE)
  3734. local->need_commit = 1;
  3735. break;
  3737. // Get the WEP keys and mode
  3738. case SIOCGIWENCODE:
  3739. /* Is it supported ? */
  3740. if(!(cap_rid.softCap & 2)) {
  3741. rc = -EOPNOTSUPP;
  3742. break;
  3743. }
  3744. // Only super-user can see WEP key
  3745. if (!capable(CAP_NET_ADMIN)) {
  3746. rc = -EPERM;
  3747. break;
  3748. }
  3750. // Basic checking...
  3751. if (wrq->u.encoding.pointer != (caddr_t) 0) {
  3752. char zeros[16];
  3753. int index = (wrq->u.encoding.flags & IW_ENCODE_INDEX) - 1;
  3755. memset(zeros,0, sizeof(zeros));
  3756. /* Check encryption mode */
  3757. wrq->u.encoding.flags = IW_ENCODE_NOKEY;
  3758. /* Is WEP enabled ??? */
  3759. switch(config.authType) {
  3760. case AUTH_ENCRYPT:
  3761. wrq->u.encoding.flags |= IW_ENCODE_OPEN;
  3762. break;
  3763. case AUTH_SHAREDKEY:
  3764. wrq->u.encoding.flags |= IW_ENCODE_RESTRICTED;
  3765. break;
  3766. default:
  3767. case AUTH_OPEN:
  3768. wrq->u.encoding.flags |= IW_ENCODE_DISABLED;
  3769. break;
  3770. }
  3772. /* Which key do we want ? -1 -> tx index */
  3773. if((index < 0) || (index >= (cap_rid.softCap&0x80)?4:1))
  3774. index = get_wep_key(local, 0xffff);
  3775. wrq->u.encoding.flags |= index + 1;
  3776. /* Copy the key to the user buffer */
  3777. wrq->u.encoding.length = get_wep_key(local, index);
  3778. if (wrq->u.encoding.length > 16) {
  3779. wrq->u.encoding.length=0;
  3780. }
  3782. if(copy_to_user(wrq->u.encoding.pointer, zeros,
  3783. wrq->u.encoding.length))
  3784. rc = -EFAULT;
  3785. }
  3786. break;
  3788. #if WIRELESS_EXT > 9
  3789. // Get the current Tx-Power
  3790. case SIOCGIWTXPOW:
  3791. wrq->u.txpower.value = config.txPower;
  3792. wrq->u.txpower.fixed = 1; /* No power control */
  3793. wrq->u.txpower.disabled = (local->flags & FLAG_RADIO_OFF);
  3794. wrq->u.txpower.flags = IW_TXPOW_MWATT;
  3795. break;
  3796. case SIOCSIWTXPOW:
  3797. if (wrq->u.txpower.disabled) {
  3798. local->flags |= FLAG_RADIO_OFF;
  3799. local->need_commit = 1;
  3800. break;
  3801. }
  3802. if (wrq->u.txpower.flags != IW_TXPOW_MWATT) {
  3803. rc = -EINVAL;
  3804. break;
  3805. }
  3806. local->flags &= ~FLAG_RADIO_OFF;
  3807. rc = -EINVAL;
  3808. for (i = 0; cap_rid.txPowerLevels[i] && (i < 8); i++)
  3809. if ((wrq->u.txpower.value==cap_rid.txPowerLevels[i])) {
  3810. config.txPower = wrq->u.txpower.value;
  3811. local->need_commit = 1;
  3812. rc = 0;
  3813. break;
  3814. }
  3815. break;
  3816. #endif /* WIRELESS_EXT > 9 */
  3818. #if WIRELESS_EXT > 10
  3819. case SIOCSIWRETRY:
  3820. if(wrq->u.retry.disabled) {
  3821. rc = -EINVAL;
  3822. break;
  3823. }
  3824. local->need_commit = 0;
  3825. if(wrq->u.retry.flags & IW_RETRY_LIMIT) {
  3826. if(wrq->u.retry.flags & IW_RETRY_MAX)
  3827. config.longRetryLimit = wrq->u.retry.value;
  3828. else if (wrq->u.retry.flags & IW_RETRY_MIN)
  3829. config.shortRetryLimit = wrq->u.retry.value;
  3830. else {
  3831. /* No modifier : set both */
  3832. config.longRetryLimit = wrq->u.retry.value;
  3833. config.shortRetryLimit = wrq->u.retry.value;
  3834. }
  3835. local->need_commit = 1;
  3836. }
  3837. if(wrq->u.retry.flags & IW_RETRY_LIFETIME) {
  3838. config.txLifetime = wrq->u.retry.value / 1024;
  3839. local->need_commit = 1;
  3840. }
  3841. if(local->need_commit == 0) {
  3842. rc = -EINVAL;
  3843. }
  3844. break;
  3846. case SIOCGIWRETRY:
  3847. wrq->u.retry.disabled = 0;      /* Can't be disabled */
  3849. /* Note : by default, display the min retry number */
  3850. if((wrq->u.retry.flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
  3851. wrq->u.retry.flags = IW_RETRY_LIFETIME;
  3852. wrq->u.retry.value = (int)config.txLifetime * 1024;
  3853. } else if((wrq->u.retry.flags & IW_RETRY_MAX)) {
  3854. wrq->u.retry.flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
  3855. wrq->u.retry.value = (int)config.longRetryLimit;
  3856. } else {
  3857. wrq->u.retry.flags = IW_RETRY_LIMIT;
  3858. wrq->u.retry.value = (int)config.shortRetryLimit;
  3859. if((int)config.shortRetryLimit != (int)config.longRetryLimit)
  3860. wrq->u.retry.flags |= IW_RETRY_MIN;
  3861. }
  3863. break;
  3864. #endif /* WIRELESS_EXT > 10 */
  3866. // Get range of parameters
  3867. case SIOCGIWRANGE:
  3868. if (wrq->u.data.pointer) {
  3869. struct iw_range range;
  3870. int i;
  3871. int k;
  3873. wrq->u.data.length = sizeof(range);
  3874. memset(&range, 0, sizeof(range));
  3875. range.min_nwid = 0x0000;
  3876. range.max_nwid = 0x0000;
  3877. range.num_channels = 14;
  3878. /* Should be based on cap_rid.country to give only
  3879.  * what the current card support */
  3880. k = 0;
  3881. for(i = 0; i < 14; i++) {
  3882. range.freq[k].i = i + 1; /* List index */
  3883. range.freq[k].m = frequency_list[i] * 100000;
  3884. range.freq[k++].e = 1; /* Values in table in MHz -> * 10^5 * 10 */
  3885. }
  3886. range.num_frequency = k;
  3888. /* Hum... Should put the right values there */
  3889. range.max_qual.qual = 10;
  3890. range.max_qual.level = 0x100 - 120; /* -120 dBm */
  3891. range.max_qual.noise = 0;
  3892. range.sensitivity = 65535;
  3894. for(i = 0 ; i < 8 ; i++) {
  3895. range.bitrate[i] = cap_rid.supportedRates[i] * 500000;
  3896. if(range.bitrate[i] == 0)
  3897. break;
  3898. }
  3899. range.num_bitrates = i;
  3901. /* Set an indication of the max TCP throughput
  3902.  * in bit/s that we can expect using this interface.
  3903.  * May be use for QoS stuff... Jean II */
  3904. if(i > 2)
  3905. range.throughput = 5 * 1000 * 1000;
  3906. else
  3907. range.throughput = 1.5 * 1000 * 1000;
  3909. range.min_rts = 0;
  3910. range.max_rts = 2312;
  3911. range.min_frag = 256;
  3912. range.max_frag = 2312;
  3914. if(cap_rid.softCap & 2) {
  3915. // WEP: RC4 40 bits
  3916. range.encoding_size[0] = 5;
  3917. // RC4 ~128 bits
  3918. if (cap_rid.softCap & 0x100) {
  3919. range.encoding_size[1] = 13;
  3920. range.num_encoding_sizes = 2;
  3921. } else
  3922. range.num_encoding_sizes = 1;
  3923. range.max_encoding_tokens = (cap_rid.softCap & 0x80) ? 4 : 1;
  3924. } else {
  3925. range.num_encoding_sizes = 0;
  3926. range.max_encoding_tokens = 0;
  3927. }
  3928. #if WIRELESS_EXT > 9
  3929. range.min_pmp = 0;
  3930. range.max_pmp = 5000000; /* 5 secs */
  3931. range.min_pmt = 0;
  3932. range.max_pmt = 65535 * 1024; /* ??? */
  3933. range.pmp_flags = IW_POWER_PERIOD;
  3934. range.pmt_flags = IW_POWER_TIMEOUT;
  3935. range.pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT | IW_POWER_ALL_R;
  3937. /* Transmit Power - values are in mW */
  3938. for(i = 0 ; i < 8 ; i++) {
  3939. range.txpower[i] = cap_rid.txPowerLevels[i];
  3940. if(range.txpower[i] == 0)
  3941. break;
  3942. }
  3943. range.num_txpower = i;
  3944. range.txpower_capa = IW_TXPOW_MWATT;
  3945. #endif /* WIRELESS_EXT > 9 */
  3946. #if WIRELESS_EXT > 10
  3947. range.we_version_source = 12;
  3948. range.we_version_compiled = WIRELESS_EXT;
  3949. range.retry_capa = IW_RETRY_LIMIT | IW_RETRY_LIFETIME;
  3950. range.retry_flags = IW_RETRY_LIMIT;
  3951. range.r_time_flags = IW_RETRY_LIFETIME;
  3952. range.min_retry = 1;
  3953. range.max_retry = 65535;
  3954. range.min_r_time = 1024;
  3955. range.max_r_time = 65535 * 1024;
  3956. #endif /* WIRELESS_EXT > 10 */
  3957. #if WIRELESS_EXT > 11
  3958. /* Experimental measurements - boundary 11/5.5 Mb/s */
  3959. /* Note : with or without the (local->rssi), results
  3960.  * are somewhat different. - Jean II */
  3961. range.avg_qual.qual = 6;
  3962. if (local->rssi)
  3963. range.avg_qual.level = 186; /* -70 dBm */
  3964. else
  3965. range.avg_qual.level = 176; /* -80 dBm */
  3966. range.avg_qual.noise = 0;
  3967. #endif /* WIRELESS_EXT > 11 */
  3969. if (copy_to_user(wrq->u.data.pointer, &range, sizeof(struct iw_range)))
  3970. rc = -EFAULT;
  3971. }
  3972. break;
  3974. case SIOCGIWPOWER:
  3975. {
  3976. int mode = config.powerSaveMode;
  3977. if ((wrq->u.power.disabled = (mode == POWERSAVE_CAM)))
  3978. break;
  3979. if ((wrq->u.power.flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
  3980. wrq->u.power.value = (int)config.fastListenDelay * 1024;
  3981. wrq->u.power.flags = IW_POWER_TIMEOUT;
  3982. } else {
  3983. wrq->u.power.value = (int)config.fastListenInterval * 1024;
  3984. wrq->u.power.flags = IW_POWER_PERIOD;
  3985. }
  3986. if ((config.rmode & 0xFF) == RXMODE_ADDR)
  3987. wrq->u.power.flags |= IW_POWER_UNICAST_R;
  3988. else
  3989. wrq->u.power.flags |= IW_POWER_ALL_R;
  3990. }
  3991. break;
  3993. case SIOCSIWPOWER:
  3994. if (wrq->u.power.disabled) {
  3995. if ((config.rmode & 0xFF) >= RXMODE_RFMON) {
  3996. rc = -EINVAL;
  3997. break;
  3998. }
  3999. config.powerSaveMode = POWERSAVE_CAM;
  4000. config.rmode &= 0xFF00;
  4001. config.rmode |= RXMODE_BC_MC_ADDR;
  4002. local->need_commit = 1;
  4003. break;
  4004. }
  4005. if ((wrq->u.power.flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
  4006. config.fastListenDelay = (wrq->u.power.value + 500) / 1024;
  4007. config.powerSaveMode = POWERSAVE_PSPCAM;
  4008. local->need_commit = 1;
  4009. } else if ((wrq->u.power.flags & IW_POWER_TYPE) == IW_POWER_PERIOD) {
  4010. config.fastListenInterval = config.listenInterval = (wrq->u.power.value + 500) / 1024;
  4011. config.powerSaveMode = POWERSAVE_PSPCAM;
  4012. local->need_commit = 1;
  4013. }
  4014. switch (wrq->u.power.flags & IW_POWER_MODE) {
  4015. case IW_POWER_UNICAST_R:
  4016. if ((config.rmode & 0xFF) >= RXMODE_RFMON) {
  4017. rc = -EINVAL;
  4018. break;
  4019. }
  4020. config.rmode &= 0xFF00;
  4021. config.rmode |= RXMODE_ADDR;
  4022. local->need_commit = 1;
  4023. break;
  4024. case IW_POWER_ALL_R:
  4025. if ((config.rmode & 0xFF) >= RXMODE_RFMON) {
  4026. rc = -EINVAL;
  4027. break;
  4028. }
  4029. config.rmode &= 0xFF00;
  4030. config.rmode |= RXMODE_BC_MC_ADDR;
  4031. local->need_commit = 1;
  4032. case IW_POWER_ON:
  4033. break;
  4034. default:
  4035. rc = -EINVAL;
  4036. }
  4037. break;
  4039. case SIOCGIWSENS:
  4040. wrq->u.sens.value = config.rssiThreshold;
  4041. wrq->u.sens.disabled = (wrq->u.sens.value == 0);
  4042. wrq->u.sens.fixed = 1;
  4043. break;
  4045. case SIOCSIWSENS:
  4046. config.rssiThreshold = wrq->u.sens.disabled ? RSSI_DEFAULT : wrq->u.sens.value;
  4047. local->need_commit = 1;
  4048. break;
  4050. case SIOCGIWAPLIST:
  4051. if (wrq->u.data.pointer) {
  4052. int i, rc;
  4053. struct sockaddr s[IW_MAX_AP];
  4054. struct iw_quality qual[IW_MAX_AP];
  4055. BSSListRid BSSList;
  4056. int loseSync = capable(CAP_NET_ADMIN) ? 1: -1;
  4057. for (i = 0; i < IW_MAX_AP; i++) {
  4058. if (readBSSListRid(local, loseSync, &BSSList))
  4059. break;
  4060. loseSync = 0;
  4061. memcpy(s[i].sa_data, BSSList.bssid, 6);
  4062. s[i].sa_family = ARPHRD_ETHER;
  4063. if (local->rssi)
  4064. qual[i].level = 0x100 - local->rssi[BSSList.rssi].rssidBm;
  4065. else
  4066. qual[i].level = (BSSList.rssi + 321) / 2;
  4067. qual[i].qual = qual[i].noise = 0;
  4068. qual[i].updated = 2;
  4069. if (BSSList.index == 0xffff) break;
  4070. }
  4071. if (!i) {
  4072. for (i = 0;
  4073.      i < min(IW_MAX_AP, 4) &&
  4074.      (status_rid.bssid[i][0]
  4075.       & status_rid.bssid[i][1]
  4076.       & status_rid.bssid[i][2]
  4077.       & status_rid.bssid[i][3]
  4078.       & status_rid.bssid[i][4]
  4079.       & status_rid.bssid[i][5])!=-1 &&
  4080.      (status_rid.bssid[i][0]
  4081.       | status_rid.bssid[i][1]
  4082.       | status_rid.bssid[i][2]
  4083.       | status_rid.bssid[i][3]
  4084.       | status_rid.bssid[i][4]
  4085.       | status_rid.bssid[i][5]);
  4086.      i++) {
  4087. memcpy(s[i].sa_data,
  4088.        status_rid.bssid[i], 6);
  4089. s[i].sa_family = ARPHRD_ETHER;
  4090. }
  4091. } else {
  4092. wrq->u.data.flags = 1; /* Should be define'd */
  4093. if (copy_to_user(wrq->u.data.pointer
  4094.  + sizeof(struct sockaddr)*i,
  4095.  &qual,
  4096.  sizeof(struct iw_quality)*i))
  4097. rc = -EFAULT;
  4098. }
  4099. wrq->u.data.length = i;
  4100. if (copy_to_user(wrq->u.data.pointer, &s,
  4101.  sizeof(struct sockaddr)*i))
  4102. rc = -EFAULT;
  4103. }
  4104. break;
  4106. #ifdef WIRELESS_SPY
  4107. // Set the spy list
  4108. case SIOCSIWSPY:
  4109. if (wrq->u.data.length > IW_MAX_SPY)
  4110. {
  4111. rc = -E2BIG;
  4112. break;
  4113. }
  4114. local->spy_number = wrq->u.data.length;
  4115. if (local->spy_number > 0)
  4116. {
  4117. struct sockaddr address[IW_MAX_SPY];
  4118. int i;
  4120. if (copy_from_user(address, wrq->u.data.pointer,
  4121.    sizeof(struct sockaddr) * local->spy_number)) {
  4122. rc = -EFAULT;
  4123. break;
  4124. }
  4125. for (i=0; i<local->spy_number; i++)
  4126. memcpy(local->spy_address[i], address[i].sa_data, 6);
  4127. memset(local->spy_stat, 0, sizeof(struct iw_quality) * IW_MAX_SPY);
  4128. }
  4129. break;
  4131. // Get the spy list
  4132. case SIOCGIWSPY:
  4133. wrq->u.data.length = local->spy_number;
  4134. if ((local->spy_number > 0) && (wrq->u.data.pointer))
  4135. {
  4136. struct sockaddr address[IW_MAX_SPY];
  4137. int i;
  4138. rc = verify_area(VERIFY_WRITE, wrq->u.data.pointer, (sizeof(struct iw_quality)+sizeof(struct sockaddr)) * IW_MAX_SPY);
  4139. if (rc)
  4140. break;
  4141. for (i=0; i<local->spy_number; i++)
  4142. {
  4143. memcpy(address[i].sa_data, local->spy_address[i], 6);
  4144. address[i].sa_family = AF_UNIX;
  4145. }
  4146. if (copy_to_user(wrq->u.data.pointer, address, sizeof(struct sockaddr) * local->spy_number)) {
  4147. rc = -EFAULT;
  4148. break;
  4149. }
  4150. if (copy_to_user(wrq->u.data.pointer + (sizeof(struct sockaddr)*local->spy_number), local->spy_stat, sizeof(struct iw_quality) * local->spy_number)) {
  4151. rc = -EFAULT;
  4152. break;
  4153. }
  4154. for (i=0; i<local->spy_number; i++)
  4155. local->spy_stat[i].updated = 0;
  4156. }
  4157. break;
  4158. #endif /* WIRELESS_SPY */
  4160. #ifdef CISCO_EXT
  4161. case SIOCGIWPRIV:
  4162. if(wrq->u.data.pointer)
  4163. {
  4164. struct iw_priv_args   priv[] =
  4165. { /* cmd, set_args, get_args, name */
  4166. { AIROIOCTL, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl), IW_PRIV_TYPE_BYTE | 2047, "airoioctl" },
  4167. { AIROIDIFC, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | sizeof (aironet_ioctl), IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "airoidifc" },
  4168. };
  4170. /* Set the number of ioctl available */
  4171. wrq->u.data.length = 2;
  4173. /* Copy structure to the user buffer */
  4174. if(copy_to_user(wrq->u.data.pointer, (u_char *) priv,
  4175. sizeof(priv)))
  4176. rc = -EFAULT;
  4177. }
  4178. break;
  4179. #endif /* CISCO_EXT */
  4180. #endif /* WIRELESS_EXT */
  4182. #ifdef CISCO_EXT
  4183. case AIROIDIFC:
  4184. #ifdef AIROOLDIDIFC
  4185. case AIROOLDIDIFC:
  4186. #endif
  4187. {
  4188. int val = AIROMAGIC;
  4189. aironet_ioctl com;
  4190. if (copy_from_user(&com,rq->ifr_data,sizeof(com)))
  4191. rc = -EFAULT;
  4192. else if (copy_to_user(com.data,(char *)&val,sizeof(val)))
  4193. rc = -EFAULT;
  4194. }
  4195. break;
  4197. case AIROIOCTL:
  4198. #ifdef AIROOLDIOCTL
  4199. case AIROOLDIOCTL:
  4200. #endif
  4201. /* Get the command struct and hand it off for evaluation by
  4202.  * the proper subfunction
  4203.  */
  4204. {
  4205. aironet_ioctl com;
  4206. if (copy_from_user(&com,rq->ifr_data,sizeof(com))) {
  4207. rc = -EFAULT;
  4208. break;
  4209. }
  4211. /* Seperate R/W functions bracket legality here
  4212.  */
  4213. if ( com.command <= AIROGSTATSD32 )
  4214. rc = readrids(dev,&com);
  4215. else if ( com.command >= AIROPCAP && com.command <= AIROPLEAPUSR )
  4216. rc = writerids(dev,&com);
  4217. else if ( com.command >= AIROFLSHRST && com.command <= AIRORESTART )
  4218. rc = flashcard(dev,&com);
  4219. else
  4220. rc = -EINVAL;      /* Bad command in ioctl */
  4221. }
  4222. break;
  4223. #endif /* CISCO_EXT */
  4225. // All other calls are currently unsupported
  4226. default:
  4227. rc = -EOPNOTSUPP;
  4228. }
  4230. #ifdef WIRELESS_EXT
  4231. /* Some of the "SET" function may have modified some of the
  4232.  * parameters. It's now time to commit them in the card */
  4233. if(local->need_commit) {
  4234. /* A classical optimisation here is to not commit any change
  4235.  * if the card is not "opened". This is what we do in
  4236.  * wvlan_cs (see for details).
  4237.  * For that, we would need to have the config RID saved in
  4238.  * the airo_info struct and make sure to not re-read it if
  4239.  * local->need_commit != 0. Then, you need to patch "open"
  4240.  * to do the final commit of all parameters...
  4241.  * Jean II */
  4242. Resp rsp;
  4244. disable_MAC(local);
  4245. local->config = config; /* ???? config is local !!! */
  4246. checkThrottle(&config);
  4247. writeConfigRid(local, &config);
  4248. enable_MAC(local, &rsp);
  4250. local->need_commit = 0;
  4251. }
  4252. #endif /* WIRELESS_EXT */
  4254. return(rc);
  4255. }
  4257. #ifdef WIRELESS_EXT
  4258. /*
  4259.  * Get the Wireless stats out of the driver
  4260.  * Note : irq and spinlock protection will occur in the subroutines
  4261.  *
  4262.  * TODO :
  4263.  * o Check if work in Ad-Hoc mode (otherwise, use SPY, as in wvlan_cs)
  4264.  * o Find the noise level
  4265.  *
  4266.  * Jean
  4267.  */
  4268. struct iw_statistics *airo_get_wireless_stats(struct net_device *dev)
  4269. {
  4270. struct airo_info *local = (struct airo_info*) dev->priv;
  4271. StatusRid status_rid;
  4272. StatsRid stats_rid;
  4273. u32 *vals = stats_rid.vals;
  4275. /* Get stats out of the card */
  4276. readStatusRid(local, &status_rid);
  4277. readStatsRid(local, &stats_rid, RID_STATS);
  4279. /* The status */
  4280. local->wstats.status = status_rid.mode;
  4282. /* Signal quality and co. But where is the noise level ??? */
  4283. local->wstats.qual.qual = status_rid.signalQuality;
  4284. if (local->rssi)
  4285. local->wstats.qual.level = 0x100 - local->rssi[status_rid.sigQuality].rssidBm;
  4286. else
  4287. local->wstats.qual.level = (status_rid.normalizedSignalStrength + 321) / 2;
  4288. local->wstats.qual.noise = 0;
  4289. local->wstats.qual.updated = 3;
  4291. /* Packets discarded in the wireless adapter due to wireless
  4292.  * specific problems */
  4293. local->wstats.discard.nwid = vals[56] + vals[57] + vals[58];/* SSID Mismatch */
  4294. local->wstats.discard.code = vals[6];/* RxWepErr */
  4295. #if WIRELESS_EXT > 11
  4296. local->wstats.discard.fragment = vals[30];
  4297. local->wstats.discard.retries = vals[10];
  4298. local->wstats.discard.misc = vals[1] + vals[32];
  4299. local->wstats.miss.beacon = vals[34];
  4300. #else /* WIRELESS_EXT > 11 */
  4301. local->wstats.discard.misc = vals[1] + vals[30] + vals[32];
  4302. #endif /* WIRELESS_EXT > 11 */
  4303. return (&local->wstats);
  4304. }
  4305. #endif /* WIRELESS_EXT */
  4307. #ifdef CISCO_EXT
  4308. /*
  4309.  * This just translates from driver IOCTL codes to the command codes to
  4310.  * feed to the radio's host interface. Things can be added/deleted
  4311.  * as needed.  This represents the READ side of control I/O to
  4312.  * the card
  4313.  */
  4314. static int readrids(struct net_device *dev, aironet_ioctl *comp) {
  4315. unsigned short ridcode;
  4316. unsigned char iobuf[2048];
  4318. switch(comp->command)
  4319. {
  4320. case AIROGCAP:      ridcode = RID_CAPABILITIES; break;
  4321. case AIROGCFG:      ridcode = RID_CONFIG;       break;
  4322. case AIROGSLIST:    ridcode = RID_SSID;         break;
  4323. case AIROGVLIST:    ridcode = RID_APLIST;       break;
  4324. case AIROGDRVNAM:   ridcode = RID_DRVNAME;      break;
  4325. case AIROGEHTENC:   ridcode = RID_ETHERENCAP;   break;
  4326. case AIROGWEPKTMP:  ridcode = RID_WEP_TEMP;
  4327. /* Only super-user can read WEP keys */
  4328. if (!capable(CAP_NET_ADMIN))
  4329. return -EPERM;
  4330. break;
  4331. case AIROGWEPKNV:   ridcode = RID_WEP_PERM;
  4332. /* Only super-user can read WEP keys */
  4333. if (!capable(CAP_NET_ADMIN))
  4334. return -EPERM;
  4335. break;
  4336. case AIROGSTAT:     ridcode = RID_STATUS;       break;
  4337. case AIROGSTATSD32: ridcode = RID_STATSDELTA;   break;
  4338. case AIROGSTATSC32: ridcode = RID_STATS;        break;
  4339. default:
  4340. return -EINVAL;
  4341. break;
  4342. }
  4344. PC4500_readrid((struct airo_info *)dev->priv,ridcode,iobuf,sizeof(iobuf));
  4345. /* get the count of bytes in the rid  docs say 1st 2 bytes is it.
  4346.  * then return it to the user
  4347.  * 9/22/2000 Honor user given length
  4348.  */
  4350. if (copy_to_user(comp->data, iobuf,
  4351.  min((int)comp->len, (int)sizeof(iobuf))))
  4352. return -EFAULT;
  4353. return 0;
  4354. }
  4356. /*
  4357.  * Danger Will Robinson write the rids here
  4358.  */
  4360. static int writerids(struct net_device *dev, aironet_ioctl *comp) {
  4361. int  ridcode;
  4362. Resp      rsp;
  4363. static int (* writer)(struct airo_info *, u16 rid, const void *, int);
  4364. unsigned char iobuf[2048];
  4366. /* Only super-user can write RIDs */
  4367. if (!capable(CAP_NET_ADMIN))
  4368. return -EPERM;
  4370. ridcode = 0;
  4371. writer = do_writerid;
  4373. switch(comp->command)
  4374. {
  4375. case AIROPSIDS:     ridcode = RID_SSID;         break;
  4376. case AIROPCAP:      ridcode = RID_CAPABILITIES; break;
  4377. case AIROPAPLIST:   ridcode = RID_APLIST;       break;
  4378. case AIROPCFG:      ridcode = RID_CONFIG;       break;
  4379. case AIROPWEPKEYNV: ridcode = RID_WEP_PERM;     break;
  4380. case AIROPLEAPUSR:  ridcode = RID_LEAPUSERNAME; break;
  4381. case AIROPLEAPPWD:  ridcode = RID_LEAPPASSWORD; break;
  4382. case AIROPWEPKEY:   ridcode = RID_WEP_TEMP; writer = PC4500_writerid;
  4383. break;
  4385. /* this is not really a rid but a command given to the card
  4386.  * same with MAC off
  4387.  */
  4388. case AIROPMACON:
  4389. if (enable_MAC(dev->priv, &rsp) != 0)
  4390. return -EIO;
  4391. return 0;
  4393. /*
  4394.  * Evidently this code in the airo driver does not get a symbol
  4395.  * as disable_MAC. it's probably so short the compiler does not gen one.
  4396.  */
  4397. case AIROPMACOFF:
  4398. disable_MAC(dev->priv);
  4399. return 0;
  4401. /* This command merely clears the counts does not actually store any data
  4402.  * only reads rid. But as it changes the cards state, I put it in the
  4403.  * writerid routines.
  4404.  */
  4405. case AIROPSTCLR:
  4406. ridcode = RID_STATSDELTACLEAR;
  4408. PC4500_readrid(dev->priv,ridcode,iobuf,sizeof(iobuf));
  4410. if (copy_to_user(comp->data, iobuf,
  4411.  min((int)comp->len, (int)sizeof(iobuf))))
  4412. return -EFAULT;
  4413. return 0;
  4415. default:
  4416. return -EOPNOTSUPP; /* Blarg! */
  4417. }
  4418. if(comp->len > sizeof(iobuf))
  4419. return -EINVAL;
  4421. if (copy_from_user(iobuf,comp->data,comp->len))
  4422. return -EFAULT;
  4423. if((*writer)((struct airo_info *)dev->priv, ridcode, iobuf,comp->len))
  4424. return -EIO;
  4425. return 0;
  4426. }
  4428. /*****************************************************************************
  4429.  * Ancillary flash / mod functions much black magic lurkes here              *
  4430.  *****************************************************************************
  4431.  */
  4433. /*
  4434.  * Flash command switch table
  4435.  */
  4437. int flashcard(struct net_device *dev, aironet_ioctl *comp) {
  4438. int z;
  4439. int cmdreset(struct airo_info *);
  4440. int setflashmode(struct airo_info *);
  4441. int flashgchar(struct airo_info *,int,int);
  4442. int flashpchar(struct airo_info *,int,int);
  4443. int flashputbuf(struct airo_info *);
  4444. int flashrestart(struct airo_info *,struct net_device *);
  4446. /* Only super-user can modify flash */
  4447. if (!capable(CAP_NET_ADMIN))
  4448. return -EPERM;
  4450. switch(comp->command)
  4451. {
  4452. case AIROFLSHRST:
  4453. return cmdreset((struct airo_info *)dev->priv);
  4455. case AIROFLSHSTFL:
  4456. if (!((struct airo_info *)dev->priv)->flash &&
  4457. (((struct airo_info *)dev->priv)->flash = kmalloc (FLASHSIZE, GFP_KERNEL)) == NULL)
  4458. return -ENOMEM;
  4459. return setflashmode((struct airo_info *)dev->priv);
  4461. case AIROFLSHGCHR: /* Get char from aux */
  4462. if(comp->len != sizeof(int))
  4463. return -EINVAL;
  4464. if (copy_from_user(&z,comp->data,comp->len))
  4465. return -EFAULT;
  4466. return flashgchar((struct airo_info *)dev->priv,z,8000);
  4468. case AIROFLSHPCHR: /* Send char to card. */
  4469. if(comp->len != sizeof(int))
  4470. return -EINVAL;
  4471. if (copy_from_user(&z,comp->data,comp->len))
  4472. return -EFAULT;
  4473. return flashpchar((struct airo_info *)dev->priv,z,8000);
  4475. case AIROFLPUTBUF: /* Send 32k to card */
  4476. if (!((struct airo_info *)dev->priv)->flash)
  4477. return -ENOMEM;
  4478. if(comp->len > FLASHSIZE)
  4479. return -EINVAL;
  4480. if(copy_from_user(((struct airo_info *)dev->priv)->flash,comp->data,comp->len))
  4481. return -EFAULT;
  4483. flashputbuf((struct airo_info *)dev->priv);
  4484. return 0;
  4486. case AIRORESTART:
  4487. if(flashrestart((struct airo_info *)dev->priv,dev))
  4488. return -EIO;
  4489. return 0;
  4490. }
  4491. return -EINVAL;
  4492. }
  4494. #define FLASH_COMMAND  0x7e7e
  4496. /*
  4497.  * STEP 1)
  4498.  * Disable MAC and do soft reset on
  4499.  * card.
  4500.  */
  4502. int cmdreset(struct airo_info *ai) {
  4503. disable_MAC(ai);
  4505. if(!waitbusy (ai)){
  4506. printk(KERN_INFO "Waitbusy hang before RESETn");
  4507. return -EBUSY;
  4508. }
  4510. OUT4500(ai,COMMAND,CMD_SOFTRESET);
  4512. set_current_state (TASK_UNINTERRUPTIBLE);
  4513. schedule_timeout (HZ);          /* WAS 600 12/7/00 */
  4515. if(!waitbusy (ai)){
  4516. printk(KERN_INFO "Waitbusy hang AFTER RESETn");
  4517. return -EBUSY;
  4518. }
  4519. return 0;
  4520. }
  4522. /* STEP 2)
  4523.  * Put the card in legendary flash
  4524.  * mode
  4525.  */
  4527. int setflashmode (struct airo_info *ai) {
  4528. OUT4500(ai, SWS0, FLASH_COMMAND);
  4529. OUT4500(ai, SWS1, FLASH_COMMAND);
  4530. OUT4500(ai, SWS0, FLASH_COMMAND);
  4531. OUT4500(ai, COMMAND,0x10);
  4532. set_current_state (TASK_UNINTERRUPTIBLE);
  4533. schedule_timeout (HZ/2); /* 500ms delay */
  4535. if(!waitbusy(ai)) {
  4536. printk(KERN_INFO "Waitbusy hang after setflash moden");
  4537. return -EIO;
  4538. }
  4539. return 0;
  4540. }
  4542. /* Put character to SWS0 wait for dwelltime
  4543.  * x 50us for  echo .
  4544.  */
  4546. int flashpchar(struct airo_info *ai,int byte,int dwelltime) {
  4547. int echo;
  4548. int waittime;
  4550. byte |= 0x8000;
  4552. if(dwelltime == 0 )
  4553. dwelltime = 200;
  4555. waittime=dwelltime;
  4557. /* Wait for busy bit d15 to go false indicating buffer empty */
  4558. while ((IN4500 (ai, SWS0) & 0x8000) && waittime > 0) {
  4559. udelay (50);
  4560. waittime -= 50;
  4561. }
  4563. /* timeout for busy clear wait */
  4564. if(waittime <= 0 ){
  4565. printk(KERN_INFO "flash putchar busywait timeout! n");
  4566. return -EBUSY;
  4567. }
  4569. /* Port is clear now write byte and wait for it to echo back */
  4570. do {
  4571. OUT4500(ai,SWS0,byte);
  4572. udelay(50);
  4573. dwelltime -= 50;
  4574. echo = IN4500(ai,SWS1);
  4575. } while (dwelltime >= 0 && echo != byte);
  4577. OUT4500(ai,SWS1,0);
  4579. return (echo == byte) ? 0 : -EIO;
  4580. }
  4582. /*
  4583.  * Get a character from the card matching matchbyte
  4584.  * Step 3)
  4585.  */
  4586. int flashgchar(struct airo_info *ai,int matchbyte,int dwelltime){
  4587. int           rchar;
  4588. unsigned char rbyte=0;
  4590. do {
  4591. rchar = IN4500(ai,SWS1);
  4593. if(dwelltime && !(0x8000 & rchar)){
  4594. dwelltime -= 10;
  4595. mdelay(10);
  4596. continue;
  4597. }
  4598. rbyte = 0xff & rchar;
  4600. if( (rbyte == matchbyte) && (0x8000 & rchar) ){
  4601. OUT4500(ai,SWS1,0);
  4602. return 0;
  4603. }
  4604. if( rbyte == 0x81 || rbyte == 0x82 || rbyte == 0x83 || rbyte == 0x1a || 0xffff == rchar)
  4605. break;
  4606. OUT4500(ai,SWS1,0);
  4608. }while(dwelltime > 0);
  4609. return -EIO;
  4610. }
  4612. /*
  4613.  * Transfer 32k of firmware data from user buffer to our buffer and
  4614.  * send to the card
  4615.  */
  4617. int flashputbuf(struct airo_info *ai){
  4618. int            nwords;
  4620. /* Write stuff */
  4621. OUT4500(ai,AUXPAGE,0x100);
  4622. OUT4500(ai,AUXOFF,0);
  4624. for(nwords=0;nwords != FLASHSIZE / 2;nwords++){
  4625. OUT4500(ai,AUXDATA,ai->flash[nwords] & 0xffff);
  4626. }
  4628. OUT4500(ai,SWS0,0x8000);
  4630. return 0;
  4631. }
  4633. /*
  4634.  *
  4635.  */
  4636. int flashrestart(struct airo_info *ai,struct net_device *dev){
  4637. int    i,status;
  4639. set_current_state (TASK_UNINTERRUPTIBLE);
  4640. schedule_timeout (HZ);          /* Added 12/7/00 */
  4641. status = setup_card(ai, dev->dev_addr,&((struct airo_info*)dev->priv)->config);
  4643. for( i = 0; i < MAX_FIDS; i++ ) {
  4644. ai->fids[i] = transmit_allocate( ai, 2312 );
  4645. }
  4647. set_current_state (TASK_UNINTERRUPTIBLE);
  4648. schedule_timeout (HZ);          /* Added 12/7/00 */
  4649. return status;
  4650. }
  4651. #endif /* CISCO_EXT */
  4653. /*
  4654.     This program is free software; you can redistribute it and/or
  4655.     modify it under the terms of the GNU General Public License
  4656.     as published by the Free Software Foundation; either version 2
  4657.     of the License, or (at your option) any later version.
  4659.     This program is distributed in the hope that it will be useful,
  4660.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  4661.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  4662.     GNU General Public License for more details.
  4664.     In addition:
  4666.     Redistribution and use in source and binary forms, with or without
  4667.     modification, are permitted provided that the following conditions
  4668.     are met:
  4670.     1. Redistributions of source code must retain the above copyright
  4671.        notice, this list of conditions and the following disclaimer.
  4672.     2. Redistributions in binary form must reproduce the above copyright
  4673.        notice, this list of conditions and the following disclaimer in the
  4674.        documentation and/or other materials provided with the distribution.
  4675.     3. The name of the author may not be used to endorse or promote
  4676.        products derived from this software without specific prior written
  4677.        permission.
  4679.     THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  4680.     IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  4681.     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  4682.     ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  4683.     INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  4684.     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  4685.     SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  4686.     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  4687.     STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  4688.     IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  4689.     POSSIBILITY OF SUCH DAMAGE.
  4690. */
  4692. module_init(airo_init_module);
  4693. module_exit(airo_cleanup_module);