projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
pcmcia: simplify IntType
[linux-2.6-block.git] / drivers / net / wireless / ray_cs.c
CommitLineData
1da177e4
LT		 1/*=============================================================================
2 *
3 * A PCMCIA client driver for the Raylink wireless LAN card.
4 * The starting point for this module was the skeleton.c in the
5 * PCMCIA 2.9.12 package written by David Hinds, dahinds@users.sourceforge.net
6 *
7 *
8 * Copyright (c) 1998 Corey Thomas (corey@world.std.com)
9 *
10 * This driver is free software; you can redistribute it and/or modify
141fa61f 11 * it under the terms of version 2 only of the GNU General Public License as
1da177e4
LT		 12 * published by the Free Software Foundation.
13 *
14 * It is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
22 *
23 * Changes:
24 * Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 08/08/2000
25 * - reorganize kmallocs in ray_attach, checking all for failure
26 * and releasing the previous allocations if one fails
27 *
28 * Daniele Bellucci <bellucda@tiscali.it> - 07/10/2003
29 * - Audit copy_to_user in ioctl(SIOCGIWESSID)
141fa61f 30 *
1da177e4
LT		 31=============================================================================*/
32
1da177e4
LT		 33#include <linux/module.h>
34#include <linux/kernel.h>
35#include <linux/proc_fs.h>
36#include <linux/ptrace.h>
6b914c52 37#include <linux/seq_file.h>
1da177e4
LT		 38#include <linux/string.h>
39#include <linux/timer.h>
40#include <linux/init.h>
41#include <linux/netdevice.h>
42#include <linux/etherdevice.h>
43#include <linux/if_arp.h>
44#include <linux/ioport.h>
45#include <linux/skbuff.h>
46#include <linux/ethtool.h>
7698d697 47#include <linux/ieee80211.h>
1da177e4 48
1da177e4
LT		 49#include <pcmcia/cs.h>
50#include <pcmcia/cistpl.h>
51#include <pcmcia/cisreg.h>
52#include <pcmcia/ds.h>
1da177e4
LT		 53
54#include <linux/wireless.h>
113b898e 55#include <net/iw_handler.h>
1da177e4
LT		 56
57#include <asm/io.h>
58#include <asm/system.h>
59#include <asm/byteorder.h>
60#include <asm/uaccess.h>
61
62/* Warning : these stuff will slow down the driver... */
63#define WIRELESS_SPY /* Enable spying addresses */
64/* Definitions we need for spy */
141fa61f
JD		 65typedef struct iw_statistics iw_stats;
66typedef u_char mac_addr[ETH_ALEN]; /* Hardware address */
1da177e4
LT		 67
68#include "rayctl.h"
69#include "ray_cs.h"
70
1da177e4 71
1da177e4 72/** Prototypes based on PCMCIA skeleton driver *******************************/
15b99ac1 73static int ray_config(struct pcmcia_device *link);
fba395ee 74static void ray_release(struct pcmcia_device *link);
cc3b4866 75static void ray_detach(struct pcmcia_device *p_dev);
1da177e4
LT		 76
77/***** Prototypes indicated by device structure ******************************/
78static int ray_dev_close(struct net_device *dev);
79static int ray_dev_config(struct net_device *dev, struct ifmap *map);
80static struct net_device_stats *ray_get_stats(struct net_device *dev);
81static int ray_dev_init(struct net_device *dev);
1da177e4 82
7282d491 83static const struct ethtool_ops netdev_ethtool_ops;
1da177e4
LT		 84
85static int ray_open(struct net_device *dev);
d0cf9c0d
SH		 86static netdev_tx_t ray_dev_start_xmit(struct sk_buff *skb,
87 struct net_device *dev);
1da177e4
LT		 88static void set_multicast_list(struct net_device *dev);
89static void ray_update_multi_list(struct net_device *dev, int all);
90static int translate_frame(ray_dev_t *local, struct tx_msg __iomem *ptx,
141fa61f
JD		 91 unsigned char *data, int len);
92static void ray_build_header(ray_dev_t *local, struct tx_msg __iomem *ptx,
93 UCHAR msg_type, unsigned char *data);
1da177e4 94static void untranslate(ray_dev_t *local, struct sk_buff *skb, int len);
141fa61f
JD		 95static iw_stats *ray_get_wireless_stats(struct net_device *dev);
96static const struct iw_handler_def ray_handler_def;
1da177e4
LT		 97
98/***** Prototypes for raylink functions **************************************/
1da177e4
LT		 99static void authenticate(ray_dev_t *local);
100static int build_auth_frame(ray_dev_t *local, UCHAR *dest, int auth_type);
101static void authenticate_timeout(u_long);
102static int get_free_ccs(ray_dev_t *local);
103static int get_free_tx_ccs(ray_dev_t *local);
104static void init_startup_params(ray_dev_t *local);
105static int parse_addr(char *in_str, UCHAR *out);
141fa61f 106static int ray_hw_xmit(unsigned char *data, int len, struct net_device *dev, UCHAR type);
1da177e4
LT		 107static int ray_init(struct net_device *dev);
108static int interrupt_ecf(ray_dev_t *local, int ccs);
109static void ray_reset(struct net_device *dev);
110static void ray_update_parm(struct net_device *dev, UCHAR objid, UCHAR *value, int len);
111static void verify_dl_startup(u_long);
112
113/* Prototypes for interrpt time functions **********************************/
141fa61f 114static irqreturn_t ray_interrupt(int reg, void *dev_id);
1da177e4 115static void clear_interrupt(ray_dev_t *local);
141fa61f
JD		 116static void rx_deauthenticate(ray_dev_t *local, struct rcs __iomem *prcs,
117 unsigned int pkt_addr, int rx_len);
1da177e4
LT		 118static int copy_from_rx_buff(ray_dev_t *local, UCHAR *dest, int pkt_addr, int len);
119static void ray_rx(struct net_device *dev, ray_dev_t *local, struct rcs __iomem *prcs);
120static void release_frag_chain(ray_dev_t *local, struct rcs __iomem *prcs);
121static void rx_authenticate(ray_dev_t *local, struct rcs __iomem *prcs,
141fa61f
JD		 122 unsigned int pkt_addr, int rx_len);
123static void rx_data(struct net_device *dev, struct rcs __iomem *prcs,
124 unsigned int pkt_addr, int rx_len);
1da177e4
LT		 125static void associate(ray_dev_t *local);
126
127/* Card command functions */
128static int dl_startup_params(struct net_device *dev);
129static void join_net(u_long local);
130static void start_net(u_long local);
131/* void start_net(ray_dev_t *local); */
132
133/*===========================================================================*/
134/* Parameters that can be set with 'insmod' */
135
136/* ADHOC=0, Infrastructure=1 */
137static int net_type = ADHOC;
138
139/* Hop dwell time in Kus (1024 us units defined by 802.11) */
140static int hop_dwell = 128;
141
142/* Beacon period in Kus */
143static int beacon_period = 256;
144
145/* power save mode (0 = off, 1 = save power) */
146static int psm;
147
148/* String for network's Extended Service Set ID. 32 Characters max */
149static char *essid;
150
151/* Default to encapsulation unless translation requested */
152static int translate = 1;
153
154static int country = USA;
155
156static int sniffer;
157
158static int bc;
159
160/* 48 bit physical card address if overriding card's real physical
161 * address is required. Since IEEE 802.11 addresses are 48 bits
162 * like ethernet, an int can't be used, so a string is used. To
163 * allow use of addresses starting with a decimal digit, the first
164 * character must be a letter and will be ignored. This letter is
165 * followed by up to 12 hex digits which are the address. If less
166 * than 12 digits are used, the address will be left filled with 0's.
167 * Note that bit 0 of the first byte is the broadcast bit, and evil
168 * things will happen if it is not 0 in a card address.
169 */
170static char *phy_addr = NULL;
171
172
fba395ee 173/* A struct pcmcia_device structure has fields for most things that are needed
1da177e4
LT		 174 to keep track of a socket, but there will usually be some device
175 specific information that also needs to be kept track of. The
fba395ee 176 'priv' pointer in a struct pcmcia_device structure can be used to point to
1da177e4
LT		 177 a device-specific private data structure, like this.
178*/
179static unsigned int ray_mem_speed = 500;
180
fd238232
DB		 181/* WARNING: THIS DRIVER IS NOT CAPABLE OF HANDLING MULTIPLE DEVICES! */
182static struct pcmcia_device *this_device = NULL;
183
1da177e4
LT		 184MODULE_AUTHOR("Corey Thomas <corey@world.std.com>");
185MODULE_DESCRIPTION("Raylink/WebGear wireless LAN driver");
186MODULE_LICENSE("GPL");
187
188module_param(net_type, int, 0);
189module_param(hop_dwell, int, 0);
190module_param(beacon_period, int, 0);
191module_param(psm, int, 0);
192module_param(essid, charp, 0);
193module_param(translate, int, 0);
194module_param(country, int, 0);
195module_param(sniffer, int, 0);
196module_param(bc, int, 0);
197module_param(phy_addr, charp, 0);
198module_param(ray_mem_speed, int, 0);
199
200static UCHAR b5_default_startup_parms[] = {
141fa61f
JD		 201 0, 0, /* Adhoc station */
202 'L', 'I', 'N', 'U', 'X', 0, 0, 0, /* 32 char ESSID */
203 0, 0, 0, 0, 0, 0, 0, 0,
204 0, 0, 0, 0, 0, 0, 0, 0,
205 0, 0, 0, 0, 0, 0, 0, 0,
206 1, 0, /* Active scan, CA Mode */
207 0, 0, 0, 0, 0, 0, /* No default MAC addr */
208 0x7f, 0xff, /* Frag threshold */
209 0x00, 0x80, /* Hop time 128 Kus */
210 0x01, 0x00, /* Beacon period 256 Kus */
211 0x01, 0x07, 0xa3, /* DTIM, retries, ack timeout */
212 0x1d, 0x82, 0x4e, /* SIFS, DIFS, PIFS */
213 0x7f, 0xff, /* RTS threshold */
214 0x04, 0xe2, 0x38, 0xA4, /* scan_dwell, max_scan_dwell */
215 0x05, /* assoc resp timeout thresh */
216 0x08, 0x02, 0x08, /* adhoc, infra, super cycle max */
217 0, /* Promiscuous mode */
218 0x0c, 0x0bd, /* Unique word */
219 0x32, /* Slot time */
220 0xff, 0xff, /* roam-low snr, low snr count */
221 0x05, 0xff, /* Infra, adhoc missed bcn thresh */
222 0x01, 0x0b, 0x4f, /* USA, hop pattern, hop pat length */
1da177e4 223/* b4 - b5 differences start here */
141fa61f
JD		 224 0x00, 0x3f, /* CW max */
225 0x00, 0x0f, /* CW min */
226 0x04, 0x08, /* Noise gain, limit offset */
227 0x28, 0x28, /* det rssi, med busy offsets */
228 7, /* det sync thresh */
229 0, 2, 2, /* test mode, min, max */
230 0, /* allow broadcast SSID probe resp */
231 0, 0, /* privacy must start, can join */
232 2, 0, 0, 0, 0, 0, 0, 0 /* basic rate set */
1da177e4
LT		 233};
234
235static UCHAR b4_default_startup_parms[] = {
141fa61f
JD		 236 0, 0, /* Adhoc station */
237 'L', 'I', 'N', 'U', 'X', 0, 0, 0, /* 32 char ESSID */
238 0, 0, 0, 0, 0, 0, 0, 0,
239 0, 0, 0, 0, 0, 0, 0, 0,
240 0, 0, 0, 0, 0, 0, 0, 0,
241 1, 0, /* Active scan, CA Mode */
242 0, 0, 0, 0, 0, 0, /* No default MAC addr */
243 0x7f, 0xff, /* Frag threshold */
244 0x02, 0x00, /* Hop time */
245 0x00, 0x01, /* Beacon period */
246 0x01, 0x07, 0xa3, /* DTIM, retries, ack timeout */
247 0x1d, 0x82, 0xce, /* SIFS, DIFS, PIFS */
248 0x7f, 0xff, /* RTS threshold */
249 0xfb, 0x1e, 0xc7, 0x5c, /* scan_dwell, max_scan_dwell */
250 0x05, /* assoc resp timeout thresh */
251 0x04, 0x02, 0x4, /* adhoc, infra, super cycle max */
252 0, /* Promiscuous mode */
253 0x0c, 0x0bd, /* Unique word */
254 0x4e, /* Slot time (TBD seems wrong) */
255 0xff, 0xff, /* roam-low snr, low snr count */
256 0x05, 0xff, /* Infra, adhoc missed bcn thresh */
257 0x01, 0x0b, 0x4e, /* USA, hop pattern, hop pat length */
1da177e4 258/* b4 - b5 differences start here */
141fa61f
JD		 259 0x3f, 0x0f, /* CW max, min */
260 0x04, 0x08, /* Noise gain, limit offset */
261 0x28, 0x28, /* det rssi, med busy offsets */
262 7, /* det sync thresh */
263 0, 2, 2 /* test mode, min, max */
1da177e4 264};
141fa61f 265
1da177e4 266/*===========================================================================*/
141fa61f 267static unsigned char eth2_llc[] = { 0xaa, 0xaa, 3, 0, 0, 0 };
1da177e4
LT		 268
269static char hop_pattern_length[] = { 1,
141fa61f
JD		 270 USA_HOP_MOD, EUROPE_HOP_MOD,
271 JAPAN_HOP_MOD, KOREA_HOP_MOD,
272 SPAIN_HOP_MOD, FRANCE_HOP_MOD,
273 ISRAEL_HOP_MOD, AUSTRALIA_HOP_MOD,
274 JAPAN_TEST_HOP_MOD
1da177e4
LT		 275};
276
141fa61f
JD		 277static char rcsid[] =
278 "Raylink/WebGear wireless LAN - Corey <Thomas corey@world.std.com>";
1da177e4 279
32f5a330
SH		 280static const struct net_device_ops ray_netdev_ops = {
281 .ndo_init = ray_dev_init,
282 .ndo_open = ray_open,
283 .ndo_stop = ray_dev_close,
284 .ndo_start_xmit = ray_dev_start_xmit,
285 .ndo_set_config = ray_dev_config,
286 .ndo_get_stats = ray_get_stats,
287 .ndo_set_multicast_list = set_multicast_list,
288 .ndo_change_mtu = eth_change_mtu,
289 .ndo_set_mac_address = eth_mac_addr,
290 .ndo_validate_addr = eth_validate_addr,
291};
292
1da177e4
LT		 293/*=============================================================================
294 ray_attach() creates an "instance" of the driver, allocating
295 local data structures for one device. The device is registered
296 with Card Services.
297 The dev_link structure is initialized, but we don't actually
298 configure the card at this point -- we wait until we receive a
299 card insertion event.
300=============================================================================*/
15b99ac1 301static int ray_probe(struct pcmcia_device *p_dev)
1da177e4 302{
141fa61f
JD		 303 ray_dev_t *local;
304 struct net_device *dev;
305
624dd669 306 dev_dbg(&p_dev->dev, "ray_attach()\n");
141fa61f
JD		 307
308 /* Allocate space for private device-specific data */
309 dev = alloc_etherdev(sizeof(ray_dev_t));
310 if (!dev)
311 goto fail_alloc_dev;
312
313 local = netdev_priv(dev);
314 local->finder = p_dev;
315
316 /* The io structure describes IO port mapping. None used here */
90abdc3b
DB		 317 p_dev->resource[0]->end = 0;
318 p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
141fa61f 319
141fa61f
JD		 320 /* General socket configuration */
321 p_dev->conf.Attributes = CONF_ENABLE_IRQ;
141fa61f
JD		 322 p_dev->conf.ConfigIndex = 1;
323
324 p_dev->priv = dev;
141fa61f
JD		 325
326 local->finder = p_dev;
327 local->card_status = CARD_INSERTED;
328 local->authentication_state = UNAUTHENTICATED;
329 local->num_multi = 0;
624dd669 330 dev_dbg(&p_dev->dev, "ray_attach p_dev = %p, dev = %p, local = %p, intr = %p\n",
141fa61f
JD		 331 p_dev, dev, local, &ray_interrupt);
332
333 /* Raylink entries in the device structure */
32f5a330 334 dev->netdev_ops = &ray_netdev_ops;
141fa61f
JD		 335 SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
336 dev->wireless_handlers = &ray_handler_def;
3d5d5ac0 337#ifdef WIRELESS_SPY
141fa61f
JD		 338 local->wireless_data.spy_data = &local->spy_data;
339 dev->wireless_data = &local->wireless_data;
340#endif /* WIRELESS_SPY */
1da177e4 341
1da177e4 342
624dd669 343 dev_dbg(&p_dev->dev, "ray_cs ray_attach calling ether_setup.)\n");
141fa61f 344 netif_stop_queue(dev);
1da177e4 345
141fa61f 346 init_timer(&local->timer);
1da177e4 347
141fa61f
JD		 348 this_device = p_dev;
349 return ray_config(p_dev);
1da177e4
LT		 350
351fail_alloc_dev:
141fa61f 352 return -ENOMEM;
1da177e4 353} /* ray_attach */
141fa61f 354
1da177e4
LT		 355/*=============================================================================
356 This deletes a driver "instance". The device is de-registered
357 with Card Services. If it has been released, all local data
358 structures are freed. Otherwise, the structures will be freed
359 when the device is released.
360=============================================================================*/
fba395ee 361static void ray_detach(struct pcmcia_device *link)
1da177e4 362{
141fa61f
JD		 363 struct net_device *dev;
364 ray_dev_t *local;
1da177e4 365
624dd669 366 dev_dbg(&link->dev, "ray_detach\n");
1da177e4 367
141fa61f
JD		 368 this_device = NULL;
369 dev = link->priv;
cc3b4866 370
141fa61f 371 ray_release(link);
cc3b4866 372
141fa61f
JD		 373 local = netdev_priv(dev);
374 del_timer(&local->timer);
1da177e4 375
141fa61f 376 if (link->priv) {
c7c2fa07 377 unregister_netdev(dev);
141fa61f
JD		 378 free_netdev(dev);
379 }
624dd669 380 dev_dbg(&link->dev, "ray_cs ray_detach ending\n");
1da177e4 381} /* ray_detach */
141fa61f 382
1da177e4
LT		 383/*=============================================================================
384 ray_config() is run after a CARD_INSERTION event
385 is received, to configure the PCMCIA socket, and to make the
386 ethernet device available to the system.
387=============================================================================*/
1da177e4 388#define MAX_TUPLE_SIZE 128
15b99ac1 389static int ray_config(struct pcmcia_device *link)
1da177e4 390{
624dd669 391 int ret = 0;
141fa61f 392 int i;
141fa61f
JD		 393 struct net_device *dev = (struct net_device *)link->priv;
394 ray_dev_t *local = netdev_priv(dev);
395
624dd669 396 dev_dbg(&link->dev, "ray_config\n");
141fa61f
JD		 397
398 /* Determine card type and firmware version */
399 printk(KERN_INFO "ray_cs Detected: %s%s%s%s\n",
400 link->prod_id[0] ? link->prod_id[0] : " ",
401 link->prod_id[1] ? link->prod_id[1] : " ",
402 link->prod_id[2] ? link->prod_id[2] : " ",
403 link->prod_id[3] ? link->prod_id[3] : " ");
404
405 /* Now allocate an interrupt line. Note that this does not
406 actually assign a handler to the interrupt.
407 */
eb14120f 408 ret = pcmcia_request_irq(link, ray_interrupt);
624dd669
DB		 409 if (ret)
410 goto failed;
eb14120f 411 dev->irq = link->irq;
141fa61f
JD		 412
413 /* This actually configures the PCMCIA socket -- setting up
414 the I/O windows and the interrupt mapping.
415 */
624dd669
DB		 416 ret = pcmcia_request_configuration(link, &link->conf);
417 if (ret)
418 goto failed;
1da177e4
LT		 419
420/*** Set up 32k window for shared memory (transmit and control) ************/
cdb13808
DB		 421 link->resource[2]->flags |= WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_CM | WIN_ENABLE | WIN_USE_WAIT;
422 link->resource[2]->start = 0;
423 link->resource[2]->end = 0x8000;
424 ret = pcmcia_request_window(link, link->resource[2], ray_mem_speed);
624dd669
DB		 425 if (ret)
426 goto failed;
cdb13808 427 ret = pcmcia_map_mem_page(link, link->resource[2], 0);
624dd669
DB		 428 if (ret)
429 goto failed;
cdb13808
DB		 430 local->sram = ioremap(link->resource[2]->start,
431 resource_size(link->resource[2]));
1da177e4
LT		 432
433/*** Set up 16k window for shared memory (receive buffer) ***************/
cdb13808 434 link->resource[3]->flags |=
141fa61f 435 WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_CM | WIN_ENABLE | WIN_USE_WAIT;
cdb13808
DB		 436 link->resource[3]->start = 0;
437 link->resource[3]->end = 0x4000;
438 ret = pcmcia_request_window(link, link->resource[3], ray_mem_speed);
624dd669
DB		 439 if (ret)
440 goto failed;
cdb13808 441 ret = pcmcia_map_mem_page(link, link->resource[3], 0x8000);
624dd669
DB		 442 if (ret)
443 goto failed;
cdb13808
DB		 444 local->rmem = ioremap(link->resource[3]->start,
445 resource_size(link->resource[3]));
1da177e4
LT		 446
447/*** Set up window for attribute memory ***********************************/
cdb13808 448 link->resource[4]->flags |=
141fa61f 449 WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_AM | WIN_ENABLE | WIN_USE_WAIT;
cdb13808
DB		 450 link->resource[4]->start = 0;
451 link->resource[4]->end = 0x1000;
452 ret = pcmcia_request_window(link, link->resource[4], ray_mem_speed);
624dd669
DB		 453 if (ret)
454 goto failed;
cdb13808 455 ret = pcmcia_map_mem_page(link, link->resource[4], 0);
624dd669
DB		 456 if (ret)
457 goto failed;
cdb13808
DB		 458 local->amem = ioremap(link->resource[4]->start,
459 resource_size(link->resource[4]));
141fa61f 460
624dd669
DB		 461 dev_dbg(&link->dev, "ray_config sram=%p\n", local->sram);
462 dev_dbg(&link->dev, "ray_config rmem=%p\n", local->rmem);
463 dev_dbg(&link->dev, "ray_config amem=%p\n", local->amem);
141fa61f
JD		 464 if (ray_init(dev) < 0) {
465 ray_release(link);
466 return -ENODEV;
467 }
468
dd2e5a15 469 SET_NETDEV_DEV(dev, &link->dev);
141fa61f
JD		 470 i = register_netdev(dev);
471 if (i != 0) {
472 printk("ray_config register_netdev() failed\n");
473 ray_release(link);
474 return i;
475 }
476
141fa61f
JD		 477 printk(KERN_INFO "%s: RayLink, irq %d, hw_addr %pM\n",
478 dev->name, dev->irq, dev->dev_addr);
479
480 return 0;
1da177e4 481
624dd669 482failed:
141fa61f
JD		 483 ray_release(link);
484 return -ENODEV;
1da177e4
LT		 485} /* ray_config */
486
487static inline struct ccs __iomem *ccs_base(ray_dev_t *dev)
488{
489 return dev->sram + CCS_BASE;
490}
491
492static inline struct rcs __iomem *rcs_base(ray_dev_t *dev)
493{
494 /*
495 * This looks nonsensical, since there is a separate
496 * RCS_BASE. But the difference between a "struct rcs"
497 * and a "struct ccs" ends up being in the _index_ off
498 * the base, so the base pointer is the same for both
499 * ccs/rcs.
500 */
501 return dev->sram + CCS_BASE;
502}
503
504/*===========================================================================*/
505static int ray_init(struct net_device *dev)
506{
141fa61f
JD		 507 int i;
508 UCHAR *p;
509 struct ccs __iomem *pccs;
510 ray_dev_t *local = netdev_priv(dev);
511 struct pcmcia_device *link = local->finder;
624dd669 512 dev_dbg(&link->dev, "ray_init(0x%p)\n", dev);
141fa61f 513 if (!(pcmcia_dev_present(link))) {
624dd669 514 dev_dbg(&link->dev, "ray_init - device not present\n");
141fa61f
JD		 515 return -1;
516 }
517
518 local->net_type = net_type;
519 local->sta_type = TYPE_STA;
520
521 /* Copy the startup results to local memory */
522 memcpy_fromio(&local->startup_res, local->sram + ECF_TO_HOST_BASE,
523 sizeof(struct startup_res_6));
524
525 /* Check Power up test status and get mac address from card */
526 if (local->startup_res.startup_word != 0x80) {
527 printk(KERN_INFO "ray_init ERROR card status = %2x\n",
528 local->startup_res.startup_word);
529 local->card_status = CARD_INIT_ERROR;
530 return -1;
531 }
532
533 local->fw_ver = local->startup_res.firmware_version[0];
534 local->fw_bld = local->startup_res.firmware_version[1];
535 local->fw_var = local->startup_res.firmware_version[2];
cb01b09c 536 dev_dbg(&link->dev, "ray_init firmware version %d.%d\n", local->fw_ver,
141fa61f
JD		 537 local->fw_bld);
538
539 local->tib_length = 0x20;
540 if ((local->fw_ver == 5) && (local->fw_bld >= 30))
541 local->tib_length = local->startup_res.tib_length;
624dd669 542 dev_dbg(&link->dev, "ray_init tib_length = 0x%02x\n", local->tib_length);
141fa61f
JD		 543 /* Initialize CCS's to buffer free state */
544 pccs = ccs_base(local);
545 for (i = 0; i < NUMBER_OF_CCS; i++) {
546 writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
547 }
548 init_startup_params(local);
549
550 /* copy mac address to startup parameters */
551 if (parse_addr(phy_addr, local->sparm.b4.a_mac_addr)) {
552 p = local->sparm.b4.a_mac_addr;
553 } else {
554 memcpy(&local->sparm.b4.a_mac_addr,
555 &local->startup_res.station_addr, ADDRLEN);
556 p = local->sparm.b4.a_mac_addr;
557 }
558
559 clear_interrupt(local); /* Clear any interrupt from the card */
560 local->card_status = CARD_AWAITING_PARAM;
624dd669 561 dev_dbg(&link->dev, "ray_init ending\n");
141fa61f 562 return 0;
1da177e4 563} /* ray_init */
141fa61f 564
1da177e4
LT		 565/*===========================================================================*/
566/* Download startup parameters to the card and command it to read them */
567static int dl_startup_params(struct net_device *dev)
568{
141fa61f
JD		 569 int ccsindex;
570 ray_dev_t *local = netdev_priv(dev);
571 struct ccs __iomem *pccs;
572 struct pcmcia_device *link = local->finder;
573
624dd669 574 dev_dbg(&link->dev, "dl_startup_params entered\n");
141fa61f 575 if (!(pcmcia_dev_present(link))) {
624dd669 576 dev_dbg(&link->dev, "ray_cs dl_startup_params - device not present\n");
141fa61f
JD		 577 return -1;
578 }
579
580 /* Copy parameters to host to ECF area */
581 if (local->fw_ver == 0x55)
582 memcpy_toio(local->sram + HOST_TO_ECF_BASE, &local->sparm.b4,
583 sizeof(struct b4_startup_params));
584 else
585 memcpy_toio(local->sram + HOST_TO_ECF_BASE, &local->sparm.b5,
586 sizeof(struct b5_startup_params));
587
588 /* Fill in the CCS fields for the ECF */
589 if ((ccsindex = get_free_ccs(local)) < 0)
590 return -1;
591 local->dl_param_ccs = ccsindex;
592 pccs = ccs_base(local) + ccsindex;
593 writeb(CCS_DOWNLOAD_STARTUP_PARAMS, &pccs->cmd);
624dd669 594 dev_dbg(&link->dev, "dl_startup_params start ccsindex = %d\n",
141fa61f
JD		 595 local->dl_param_ccs);
596 /* Interrupt the firmware to process the command */
597 if (interrupt_ecf(local, ccsindex)) {
598 printk(KERN_INFO "ray dl_startup_params failed - "
599 "ECF not ready for intr\n");
600 local->card_status = CARD_DL_PARAM_ERROR;
601 writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
602 return -2;
603 }
604 local->card_status = CARD_DL_PARAM;
605 /* Start kernel timer to wait for dl startup to complete. */
606 local->timer.expires = jiffies + HZ / 2;
607 local->timer.data = (long)local;
608 local->timer.function = &verify_dl_startup;
609 add_timer(&local->timer);
624dd669 610 dev_dbg(&link->dev,
141fa61f
JD		 611 "ray_cs dl_startup_params started timer for verify_dl_startup\n");
612 return 0;
1da177e4 613} /* dl_startup_params */
141fa61f 614
1da177e4
LT		 615/*===========================================================================*/
616static void init_startup_params(ray_dev_t *local)
617{
141fa61f
JD		 618 int i;
619
620 if (country > JAPAN_TEST)
621 country = USA;
622 else if (country < USA)
623 country = USA;
624 /* structure for hop time and beacon period is defined here using
625 * New 802.11D6.1 format. Card firmware is still using old format
626 * until version 6.
627 * Before After
628 * a_hop_time ms byte a_hop_time ms byte
629 * a_hop_time 2s byte a_hop_time ls byte
630 * a_hop_time ls byte a_beacon_period ms byte
631 * a_beacon_period a_beacon_period ls byte
632 *
633 * a_hop_time = uS a_hop_time = KuS
634 * a_beacon_period = hops a_beacon_period = KuS
635 *//* 64ms = 010000 */
636 if (local->fw_ver == 0x55) {
637 memcpy((UCHAR *) &local->sparm.b4, b4_default_startup_parms,
638 sizeof(struct b4_startup_params));
639 /* Translate sane kus input values to old build 4/5 format */
640 /* i = hop time in uS truncated to 3 bytes */
641 i = (hop_dwell * 1024) & 0xffffff;
642 local->sparm.b4.a_hop_time[0] = (i >> 16) & 0xff;
643 local->sparm.b4.a_hop_time[1] = (i >> 8) & 0xff;
644 local->sparm.b4.a_beacon_period[0] = 0;
645 local->sparm.b4.a_beacon_period[1] =
646 ((beacon_period / hop_dwell) - 1) & 0xff;
647 local->sparm.b4.a_curr_country_code = country;
648 local->sparm.b4.a_hop_pattern_length =
649 hop_pattern_length[(int)country] - 1;
650 if (bc) {
651 local->sparm.b4.a_ack_timeout = 0x50;
652 local->sparm.b4.a_sifs = 0x3f;
653 }
654 } else { /* Version 5 uses real kus values */
655 memcpy((UCHAR *) &local->sparm.b5, b5_default_startup_parms,
656 sizeof(struct b5_startup_params));
657
658 local->sparm.b5.a_hop_time[0] = (hop_dwell >> 8) & 0xff;
659 local->sparm.b5.a_hop_time[1] = hop_dwell & 0xff;
660 local->sparm.b5.a_beacon_period[0] =
661 (beacon_period >> 8) & 0xff;
662 local->sparm.b5.a_beacon_period[1] = beacon_period & 0xff;
663 if (psm)
664 local->sparm.b5.a_power_mgt_state = 1;
665 local->sparm.b5.a_curr_country_code = country;
666 local->sparm.b5.a_hop_pattern_length =
667 hop_pattern_length[(int)country];
668 }
669
670 local->sparm.b4.a_network_type = net_type & 0x01;
671 local->sparm.b4.a_acting_as_ap_status = TYPE_STA;
672
673 if (essid != NULL)
674 strncpy(local->sparm.b4.a_current_ess_id, essid, ESSID_SIZE);
675} /* init_startup_params */
676
1da177e4
LT		 677/*===========================================================================*/
678static void verify_dl_startup(u_long data)
679{
141fa61f
JD		 680 ray_dev_t *local = (ray_dev_t *) data;
681 struct ccs __iomem *pccs = ccs_base(local) + local->dl_param_ccs;
682 UCHAR status;
683 struct pcmcia_device *link = local->finder;
1da177e4 684
141fa61f 685 if (!(pcmcia_dev_present(link))) {
624dd669 686 dev_dbg(&link->dev, "ray_cs verify_dl_startup - device not present\n");
141fa61f
JD		 687 return;
688 }
624dd669
DB		 689#if 0
690 {
141fa61f
JD		 691 int i;
692 printk(KERN_DEBUG
693 "verify_dl_startup parameters sent via ccs %d:\n",
694 local->dl_param_ccs);
695 for (i = 0; i < sizeof(struct b5_startup_params); i++) {
696 printk(" %2x",
697 (unsigned int)readb(local->sram +
698 HOST_TO_ECF_BASE + i));
699 }
700 printk("\n");
701 }
1da177e4
LT		 702#endif
703
141fa61f
JD		 704 status = readb(&pccs->buffer_status);
705 if (status != CCS_BUFFER_FREE) {
706 printk(KERN_INFO
707 "Download startup params failed. Status = %d\n",
708 status);
709 local->card_status = CARD_DL_PARAM_ERROR;
710 return;
711 }
712 if (local->sparm.b4.a_network_type == ADHOC)
713 start_net((u_long) local);
714 else
715 join_net((u_long) local);
1da177e4 716} /* end verify_dl_startup */
141fa61f 717
1da177e4
LT		 718/*===========================================================================*/
719/* Command card to start a network */
720static void start_net(u_long data)
721{
141fa61f
JD		 722 ray_dev_t *local = (ray_dev_t *) data;
723 struct ccs __iomem *pccs;
724 int ccsindex;
725 struct pcmcia_device *link = local->finder;
726 if (!(pcmcia_dev_present(link))) {
624dd669 727 dev_dbg(&link->dev, "ray_cs start_net - device not present\n");
141fa61f
JD		 728 return;
729 }
730 /* Fill in the CCS fields for the ECF */
731 if ((ccsindex = get_free_ccs(local)) < 0)
732 return;
733 pccs = ccs_base(local) + ccsindex;
734 writeb(CCS_START_NETWORK, &pccs->cmd);
735 writeb(0, &pccs->var.start_network.update_param);
736 /* Interrupt the firmware to process the command */
737 if (interrupt_ecf(local, ccsindex)) {
624dd669 738 dev_dbg(&link->dev, "ray start net failed - card not ready for intr\n");
141fa61f
JD		 739 writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
740 return;
741 }
742 local->card_status = CARD_DOING_ACQ;
1da177e4 743} /* end start_net */
141fa61f 744
1da177e4
LT		 745/*===========================================================================*/
746/* Command card to join a network */
747static void join_net(u_long data)
748{
141fa61f
JD		 749 ray_dev_t *local = (ray_dev_t *) data;
750
751 struct ccs __iomem *pccs;
752 int ccsindex;
753 struct pcmcia_device *link = local->finder;
754
755 if (!(pcmcia_dev_present(link))) {
624dd669 756 dev_dbg(&link->dev, "ray_cs join_net - device not present\n");
141fa61f
JD		 757 return;
758 }
759 /* Fill in the CCS fields for the ECF */
760 if ((ccsindex = get_free_ccs(local)) < 0)
761 return;
762 pccs = ccs_base(local) + ccsindex;
763 writeb(CCS_JOIN_NETWORK, &pccs->cmd);
764 writeb(0, &pccs->var.join_network.update_param);
765 writeb(0, &pccs->var.join_network.net_initiated);
766 /* Interrupt the firmware to process the command */
767 if (interrupt_ecf(local, ccsindex)) {
624dd669 768 dev_dbg(&link->dev, "ray join net failed - card not ready for intr\n");
141fa61f
JD		 769 writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
770 return;
771 }
772 local->card_status = CARD_DOING_ACQ;
1da177e4 773}
141fa61f 774
1da177e4
LT		 775/*============================================================================
776 After a card is removed, ray_release() will unregister the net
777 device, and release the PCMCIA configuration. If the device is
778 still open, this will be postponed until it is closed.
779=============================================================================*/
fba395ee 780static void ray_release(struct pcmcia_device *link)
1da177e4 781{
141fa61f
JD		 782 struct net_device *dev = link->priv;
783 ray_dev_t *local = netdev_priv(dev);
141fa61f 784
624dd669 785 dev_dbg(&link->dev, "ray_release\n");
141fa61f
JD		 786
787 del_timer(&local->timer);
788
789 iounmap(local->sram);
790 iounmap(local->rmem);
791 iounmap(local->amem);
141fa61f
JD		 792 pcmcia_disable_device(link);
793
624dd669 794 dev_dbg(&link->dev, "ray_release ending\n");
1da177e4
LT		 795}
796
fba395ee 797static int ray_suspend(struct pcmcia_device *link)
98e4c28b 798{
98e4c28b
DB		 799 struct net_device *dev = link->priv;
800
e2d40963 801 if (link->open)
8661bb5b 802 netif_device_detach(dev);
98e4c28b
DB		 803
804 return 0;
805}
806
fba395ee 807static int ray_resume(struct pcmcia_device *link)
98e4c28b 808{
98e4c28b
DB		 809 struct net_device *dev = link->priv;
810
e2d40963 811 if (link->open) {
8661bb5b
DB		 812 ray_reset(dev);
813 netif_device_attach(dev);
814 }
98e4c28b
DB		 815
816 return 0;
817}
818
1da177e4 819/*===========================================================================*/
2ed5ba89 820static int ray_dev_init(struct net_device *dev)
1da177e4
LT		 821{
822#ifdef RAY_IMMEDIATE_INIT
141fa61f
JD		 823 int i;
824#endif /* RAY_IMMEDIATE_INIT */
825 ray_dev_t *local = netdev_priv(dev);
826 struct pcmcia_device *link = local->finder;
827
624dd669 828 dev_dbg(&link->dev, "ray_dev_init(dev=%p)\n", dev);
141fa61f 829 if (!(pcmcia_dev_present(link))) {
624dd669 830 dev_dbg(&link->dev, "ray_dev_init - device not present\n");
141fa61f
JD		 831 return -1;
832 }
1da177e4 833#ifdef RAY_IMMEDIATE_INIT
141fa61f
JD		 834 /* Download startup parameters */
835 if ((i = dl_startup_params(dev)) < 0) {
836 printk(KERN_INFO "ray_dev_init dl_startup_params failed - "
837 "returns 0x%x\n", i);
838 return -1;
839 }
840#else /* RAY_IMMEDIATE_INIT */
841 /* Postpone the card init so that we can still configure the card,
842 * for example using the Wireless Extensions. The init will happen
843 * in ray_open() - Jean II */
624dd669 844 dev_dbg(&link->dev,
141fa61f
JD		 845 "ray_dev_init: postponing card init to ray_open() ; Status = %d\n",
846 local->card_status);
847#endif /* RAY_IMMEDIATE_INIT */
848
849 /* copy mac and broadcast addresses to linux device */
3a6d54c5 850 memcpy(dev->dev_addr, &local->sparm.b4.a_mac_addr, ADDRLEN);
141fa61f
JD		 851 memset(dev->broadcast, 0xff, ETH_ALEN);
852
624dd669 853 dev_dbg(&link->dev, "ray_dev_init ending\n");
141fa61f 854 return 0;
1da177e4 855}
141fa61f 856
1da177e4
LT		 857/*===========================================================================*/
858static int ray_dev_config(struct net_device *dev, struct ifmap *map)
859{
141fa61f
JD		 860 ray_dev_t *local = netdev_priv(dev);
861 struct pcmcia_device *link = local->finder;
862 /* Dummy routine to satisfy device structure */
624dd669 863 dev_dbg(&link->dev, "ray_dev_config(dev=%p,ifmap=%p)\n", dev, map);
141fa61f 864 if (!(pcmcia_dev_present(link))) {
624dd669 865 dev_dbg(&link->dev, "ray_dev_config - device not present\n");
141fa61f
JD		 866 return -1;
867 }
1da177e4 868
141fa61f 869 return 0;
1da177e4 870}
141fa61f 871
1da177e4 872/*===========================================================================*/
d0cf9c0d
SH		 873static netdev_tx_t ray_dev_start_xmit(struct sk_buff *skb,
874 struct net_device *dev)
1da177e4 875{
141fa61f
JD		 876 ray_dev_t *local = netdev_priv(dev);
877 struct pcmcia_device *link = local->finder;
878 short length = skb->len;
879
d0cf9c0d 880 if (!pcmcia_dev_present(link)) {
624dd669 881 dev_dbg(&link->dev, "ray_dev_start_xmit - device not present\n");
d0cf9c0d
SH		 882 dev_kfree_skb(skb);
883 return NETDEV_TX_OK;
141fa61f 884 }
d0cf9c0d 885
624dd669 886 dev_dbg(&link->dev, "ray_dev_start_xmit(skb=%p, dev=%p)\n", skb, dev);
141fa61f 887 if (local->authentication_state == NEED_TO_AUTH) {
624dd669 888 dev_dbg(&link->dev, "ray_cs Sending authentication request.\n");
141fa61f
JD		 889 if (!build_auth_frame(local, local->auth_id, OPEN_AUTH_REQUEST)) {
890 local->authentication_state = AUTHENTICATED;
891 netif_stop_queue(dev);
5b548140 892 return NETDEV_TX_BUSY;
141fa61f
JD		 893 }
894 }
895
896 if (length < ETH_ZLEN) {
897 if (skb_padto(skb, ETH_ZLEN))
6ed10654 898 return NETDEV_TX_OK;
141fa61f
JD		 899 length = ETH_ZLEN;
900 }
901 switch (ray_hw_xmit(skb->data, length, dev, DATA_TYPE)) {
902 case XMIT_NO_CCS:
903 case XMIT_NEED_AUTH:
904 netif_stop_queue(dev);
5b548140 905 return NETDEV_TX_BUSY;
141fa61f
JD		 906 case XMIT_NO_INTR:
907 case XMIT_MSG_BAD:
908 case XMIT_OK:
909 default:
141fa61f 910 dev_kfree_skb(skb);
141fa61f 911 }
d0cf9c0d 912
6ed10654 913 return NETDEV_TX_OK;
1da177e4 914} /* ray_dev_start_xmit */
141fa61f 915
1da177e4 916/*===========================================================================*/
141fa61f
JD		 917static int ray_hw_xmit(unsigned char *data, int len, struct net_device *dev,
918 UCHAR msg_type)
919{
920 ray_dev_t *local = netdev_priv(dev);
921 struct ccs __iomem *pccs;
922 int ccsindex;
923 int offset;
924 struct tx_msg __iomem *ptx; /* Address of xmit buffer in PC space */
925 short int addr; /* Address of xmit buffer in card space */
926
624dd669 927 pr_debug("ray_hw_xmit(data=%p, len=%d, dev=%p)\n", data, len, dev);
141fa61f
JD		 928 if (len + TX_HEADER_LENGTH > TX_BUF_SIZE) {
929 printk(KERN_INFO "ray_hw_xmit packet too large: %d bytes\n",
930 len);
931 return XMIT_MSG_BAD;
932 }
1da177e4
LT		 933 switch (ccsindex = get_free_tx_ccs(local)) {
934 case ECCSBUSY:
624dd669 935 pr_debug("ray_hw_xmit tx_ccs table busy\n");
1da177e4 936 case ECCSFULL:
624dd669 937 pr_debug("ray_hw_xmit No free tx ccs\n");
1da177e4 938 case ECARDGONE:
141fa61f
JD		 939 netif_stop_queue(dev);
940 return XMIT_NO_CCS;
1da177e4
LT		 941 default:
942 break;
943 }
141fa61f
JD		 944 addr = TX_BUF_BASE + (ccsindex << 11);
945
946 if (msg_type == DATA_TYPE) {
947 local->stats.tx_bytes += len;
948 local->stats.tx_packets++;
949 }
950
951 ptx = local->sram + addr;
952
953 ray_build_header(local, ptx, msg_type, data);
954 if (translate) {
955 offset = translate_frame(local, ptx, data, len);
956 } else { /* Encapsulate frame */
957 /* TBD TIB length will move address of ptx->var */
958 memcpy_toio(&ptx->var, data, len);
959 offset = 0;
960 }
961
962 /* fill in the CCS */
963 pccs = ccs_base(local) + ccsindex;
964 len += TX_HEADER_LENGTH + offset;
965 writeb(CCS_TX_REQUEST, &pccs->cmd);
966 writeb(addr >> 8, &pccs->var.tx_request.tx_data_ptr[0]);
967 writeb(local->tib_length, &pccs->var.tx_request.tx_data_ptr[1]);
968 writeb(len >> 8, &pccs->var.tx_request.tx_data_length[0]);
969 writeb(len & 0xff, &pccs->var.tx_request.tx_data_length[1]);
1da177e4 970/* TBD still need psm_cam? */
141fa61f
JD		 971 writeb(PSM_CAM, &pccs->var.tx_request.pow_sav_mode);
972 writeb(local->net_default_tx_rate, &pccs->var.tx_request.tx_rate);
973 writeb(0, &pccs->var.tx_request.antenna);
624dd669 974 pr_debug("ray_hw_xmit default_tx_rate = 0x%x\n",
141fa61f
JD		 975 local->net_default_tx_rate);
976
977 /* Interrupt the firmware to process the command */
978 if (interrupt_ecf(local, ccsindex)) {
624dd669 979 pr_debug("ray_hw_xmit failed - ECF not ready for intr\n");
1da177e4
LT		 980/* TBD very inefficient to copy packet to buffer, and then not
981 send it, but the alternative is to queue the messages and that
982 won't be done for a while. Maybe set tbusy until a CCS is free?
983*/
141fa61f
JD		 984 writeb(CCS_BUFFER_FREE, &pccs->buffer_status);
985 return XMIT_NO_INTR;
986 }
987 return XMIT_OK;
1da177e4 988} /* end ray_hw_xmit */
141fa61f 989
1da177e4 990/*===========================================================================*/
141fa61f
JD		 991static int translate_frame(ray_dev_t *local, struct tx_msg __iomem *ptx,
992 unsigned char *data, int len)
993{
994 __be16 proto = ((struct ethhdr *)data)->h_proto;
995 if (ntohs(proto) >= 1536) { /* DIX II ethernet frame */
624dd669 996 pr_debug("ray_cs translate_frame DIX II\n");
141fa61f
JD		 997 /* Copy LLC header to card buffer */
998 memcpy_toio(&ptx->var, eth2_llc, sizeof(eth2_llc));
999 memcpy_toio(((void __iomem *)&ptx->var) + sizeof(eth2_llc),
1000 (UCHAR *) &proto, 2);
1001 if (proto == htons(ETH_P_AARP) || proto == htons(ETH_P_IPX)) {
1002 /* This is the selective translation table, only 2 entries */
1003 writeb(0xf8,
1004 &((struct snaphdr_t __iomem *)ptx->var)->org[3]);
1005 }
1006 /* Copy body of ethernet packet without ethernet header */
1007 memcpy_toio((void __iomem *)&ptx->var +
1008 sizeof(struct snaphdr_t), data + ETH_HLEN,
1009 len - ETH_HLEN);
1010 return (int)sizeof(struct snaphdr_t) - ETH_HLEN;
1011 } else { /* already 802 type, and proto is length */
624dd669 1012 pr_debug("ray_cs translate_frame 802\n");
141fa61f 1013 if (proto == htons(0xffff)) { /* evil netware IPX 802.3 without LLC */
624dd669 1014 pr_debug("ray_cs translate_frame evil IPX\n");
141fa61f
JD		 1015 memcpy_toio(&ptx->var, data + ETH_HLEN, len - ETH_HLEN);
1016 return 0 - ETH_HLEN;
1017 }
1018 memcpy_toio(&ptx->var, data + ETH_HLEN, len - ETH_HLEN);
1019 return 0 - ETH_HLEN;
1020 }
1021 /* TBD do other frame types */
1da177e4 1022} /* end translate_frame */
141fa61f 1023
1da177e4 1024/*===========================================================================*/
141fa61f
JD		 1025static void ray_build_header(ray_dev_t *local, struct tx_msg __iomem *ptx,
1026 UCHAR msg_type, unsigned char *data)
1da177e4 1027{
141fa61f 1028 writeb(PROTOCOL_VER | msg_type, &ptx->mac.frame_ctl_1);
1da177e4 1029/*** IEEE 802.11 Address field assignments *************
141fa61f
JD		 1030 TODS FROMDS addr_1 addr_2 addr_3 addr_4
1031Adhoc 0 0 dest src (terminal) BSSID N/A
1032AP to Terminal 0 1 dest AP(BSSID) source N/A
1033Terminal to AP 1 0 AP(BSSID) src (terminal) dest N/A
1034AP to AP 1 1 dest AP src AP dest source
1da177e4 1035*******************************************************/
141fa61f
JD		 1036 if (local->net_type == ADHOC) {
1037 writeb(0, &ptx->mac.frame_ctl_2);
1038 memcpy_toio(ptx->mac.addr_1, ((struct ethhdr *)data)->h_dest,
1039 2 * ADDRLEN);
1040 memcpy_toio(ptx->mac.addr_3, local->bss_id, ADDRLEN);
1041 } else { /* infrastructure */
1042
1043 if (local->sparm.b4.a_acting_as_ap_status) {
1044 writeb(FC2_FROM_DS, &ptx->mac.frame_ctl_2);
1045 memcpy_toio(ptx->mac.addr_1,
1046 ((struct ethhdr *)data)->h_dest, ADDRLEN);
1047 memcpy_toio(ptx->mac.addr_2, local->bss_id, 6);
1048 memcpy_toio(ptx->mac.addr_3,
1049 ((struct ethhdr *)data)->h_source, ADDRLEN);
1050 } else { /* Terminal */
1051
1052 writeb(FC2_TO_DS, &ptx->mac.frame_ctl_2);
1053 memcpy_toio(ptx->mac.addr_1, local->bss_id, ADDRLEN);
1054 memcpy_toio(ptx->mac.addr_2,
1055 ((struct ethhdr *)data)->h_source, ADDRLEN);
1056 memcpy_toio(ptx->mac.addr_3,
1057 ((struct ethhdr *)data)->h_dest, ADDRLEN);
1058 }
1059 }
1da177e4
LT		 1060} /* end encapsulate_frame */
1061
1da177e4
LT		 1062/*===========================================================================*/
1063
1064static void netdev_get_drvinfo(struct net_device *dev,
1065 struct ethtool_drvinfo *info)
1066{
1067 strcpy(info->driver, "ray_cs");
1068}
1069
7282d491 1070static const struct ethtool_ops netdev_ethtool_ops = {
141fa61f 1071 .get_drvinfo = netdev_get_drvinfo,
1da177e4
LT		 1072};
1073
1074/*====================================================================*/
1075
3d5d5ac0
JT		 1076/*------------------------------------------------------------------*/
1077/*
1078 * Wireless Handler : get protocol name
1079 */
43ead78a
JP		 1080static int ray_get_name(struct net_device *dev, struct iw_request_info *info,
1081 union iwreq_data *wrqu, char *extra)
1da177e4 1082{
43ead78a 1083 strcpy(wrqu->name, "IEEE 802.11-FH");
3d5d5ac0
JT		 1084 return 0;
1085}
1da177e4 1086
3d5d5ac0
JT		 1087/*------------------------------------------------------------------*/
1088/*
1089 * Wireless Handler : set frequency
1090 */
43ead78a
JP		 1091static int ray_set_freq(struct net_device *dev, struct iw_request_info *info,
1092 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1093{
6dbc9c89 1094 ray_dev_t *local = netdev_priv(dev);
141fa61f 1095 int err = -EINPROGRESS; /* Call commit handler */
1da177e4 1096
3d5d5ac0 1097 /* Reject if card is already initialised */
141fa61f 1098 if (local->card_status != CARD_AWAITING_PARAM)
3d5d5ac0 1099 return -EBUSY;
1da177e4 1100
3d5d5ac0 1101 /* Setting by channel number */
43ead78a 1102 if ((wrqu->freq.m > USA_HOP_MOD) || (wrqu->freq.e > 0))
3d5d5ac0
JT		 1103 err = -EOPNOTSUPP;
1104 else
43ead78a 1105 local->sparm.b5.a_hop_pattern = wrqu->freq.m;
1da177e4 1106
3d5d5ac0
JT		 1107 return err;
1108}
141fa61f 1109
3d5d5ac0
JT		 1110/*------------------------------------------------------------------*/
1111/*
1112 * Wireless Handler : get frequency
1113 */
43ead78a
JP		 1114static int ray_get_freq(struct net_device *dev, struct iw_request_info *info,
1115 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1116{
6dbc9c89 1117 ray_dev_t *local = netdev_priv(dev);
1da177e4 1118
43ead78a
JP		 1119 wrqu->freq.m = local->sparm.b5.a_hop_pattern;
1120 wrqu->freq.e = 0;
3d5d5ac0
JT		 1121 return 0;
1122}
1123
1124/*------------------------------------------------------------------*/
1125/*
1126 * Wireless Handler : set ESSID
1127 */
43ead78a
JP		 1128static int ray_set_essid(struct net_device *dev, struct iw_request_info *info,
1129 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1130{
6dbc9c89 1131 ray_dev_t *local = netdev_priv(dev);
3d5d5ac0
JT		 1132
1133 /* Reject if card is already initialised */
141fa61f 1134 if (local->card_status != CARD_AWAITING_PARAM)
3d5d5ac0
JT		 1135 return -EBUSY;
1136
1137 /* Check if we asked for `any' */
43ead78a 1138 if (wrqu->essid.flags == 0)
1da177e4 1139 /* Corey : can you do that ? */
3d5d5ac0 1140 return -EOPNOTSUPP;
1da177e4 1141
43ead78a
JP		 1142 /* Check the size of the string */
1143 if (wrqu->essid.length > IW_ESSID_MAX_SIZE)
1144 return -E2BIG;
1145
1146 /* Set the ESSID in the card */
1147 memset(local->sparm.b5.a_current_ess_id, 0, IW_ESSID_MAX_SIZE);
1148 memcpy(local->sparm.b5.a_current_ess_id, extra, wrqu->essid.length);
1da177e4 1149
141fa61f 1150 return -EINPROGRESS; /* Call commit handler */
3d5d5ac0 1151}
1da177e4 1152
3d5d5ac0
JT		 1153/*------------------------------------------------------------------*/
1154/*
1155 * Wireless Handler : get ESSID
1156 */
43ead78a
JP		 1157static int ray_get_essid(struct net_device *dev, struct iw_request_info *info,
1158 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1159{
6dbc9c89 1160 ray_dev_t *local = netdev_priv(dev);
3d5d5ac0
JT		 1161
1162 /* Get the essid that was set */
1163 memcpy(extra, local->sparm.b5.a_current_ess_id, IW_ESSID_MAX_SIZE);
3d5d5ac0
JT		 1164
1165 /* Push it out ! */
43ead78a
JP		 1166 wrqu->essid.length = strlen(extra);
1167 wrqu->essid.flags = 1; /* active */
3d5d5ac0
JT		 1168
1169 return 0;
1170}
1171
1172/*------------------------------------------------------------------*/
1173/*
1174 * Wireless Handler : get AP address
1175 */
43ead78a
JP		 1176static int ray_get_wap(struct net_device *dev, struct iw_request_info *info,
1177 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1178{
6dbc9c89 1179 ray_dev_t *local = netdev_priv(dev);
3d5d5ac0 1180
43ead78a
JP		 1181 memcpy(wrqu->ap_addr.sa_data, local->bss_id, ETH_ALEN);
1182 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
3d5d5ac0
JT		 1183
1184 return 0;
1185}
1186
1187/*------------------------------------------------------------------*/
1188/*
1189 * Wireless Handler : set Bit-Rate
1190 */
43ead78a
JP		 1191static int ray_set_rate(struct net_device *dev, struct iw_request_info *info,
1192 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1193{
6dbc9c89 1194 ray_dev_t *local = netdev_priv(dev);
3d5d5ac0
JT		 1195
1196 /* Reject if card is already initialised */
141fa61f 1197 if (local->card_status != CARD_AWAITING_PARAM)
3d5d5ac0
JT		 1198 return -EBUSY;
1199
1200 /* Check if rate is in range */
43ead78a 1201 if ((wrqu->bitrate.value != 1000000) && (wrqu->bitrate.value != 2000000))
3d5d5ac0
JT		 1202 return -EINVAL;
1203
1204 /* Hack for 1.5 Mb/s instead of 2 Mb/s */
141fa61f 1205 if ((local->fw_ver == 0x55) && /* Please check */
43ead78a 1206 (wrqu->bitrate.value == 2000000))
3d5d5ac0 1207 local->net_default_tx_rate = 3;
1da177e4 1208 else
43ead78a 1209 local->net_default_tx_rate = wrqu->bitrate.value / 500000;
3d5d5ac0
JT		 1210
1211 return 0;
1212}
1213
1214/*------------------------------------------------------------------*/
1215/*
1216 * Wireless Handler : get Bit-Rate
1217 */
43ead78a
JP		 1218static int ray_get_rate(struct net_device *dev, struct iw_request_info *info,
1219 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1220{
6dbc9c89 1221 ray_dev_t *local = netdev_priv(dev);
3d5d5ac0 1222
141fa61f 1223 if (local->net_default_tx_rate == 3)
43ead78a 1224 wrqu->bitrate.value = 2000000; /* Hum... */
3d5d5ac0 1225 else
43ead78a
JP		 1226 wrqu->bitrate.value = local->net_default_tx_rate * 500000;
1227 wrqu->bitrate.fixed = 0; /* We are in auto mode */
3d5d5ac0
JT		 1228
1229 return 0;
1230}
1231
1232/*------------------------------------------------------------------*/
1233/*
1234 * Wireless Handler : set RTS threshold
1235 */
43ead78a
JP		 1236static int ray_set_rts(struct net_device *dev, struct iw_request_info *info,
1237 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1238{
6dbc9c89 1239 ray_dev_t *local = netdev_priv(dev);
43ead78a 1240 int rthr = wrqu->rts.value;
3d5d5ac0
JT		 1241
1242 /* Reject if card is already initialised */
141fa61f 1243 if (local->card_status != CARD_AWAITING_PARAM)
3d5d5ac0
JT		 1244 return -EBUSY;
1245
1246 /* if(wrq->u.rts.fixed == 0) we should complain */
43ead78a 1247 if (wrqu->rts.disabled)
3d5d5ac0
JT		 1248 rthr = 32767;
1249 else {
141fa61f 1250 if ((rthr < 0) || (rthr > 2347)) /* What's the max packet size ??? */
3d5d5ac0
JT		 1251 return -EINVAL;
1252 }
1da177e4
LT		 1253 local->sparm.b5.a_rts_threshold[0] = (rthr >> 8) & 0xFF;
1254 local->sparm.b5.a_rts_threshold[1] = rthr & 0xFF;
1da177e4 1255
141fa61f 1256 return -EINPROGRESS; /* Call commit handler */
3d5d5ac0 1257}
1da177e4 1258
3d5d5ac0
JT		 1259/*------------------------------------------------------------------*/
1260/*
1261 * Wireless Handler : get RTS threshold
1262 */
43ead78a
JP		 1263static int ray_get_rts(struct net_device *dev, struct iw_request_info *info,
1264 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1265{
6dbc9c89 1266 ray_dev_t *local = netdev_priv(dev);
3d5d5ac0 1267
43ead78a 1268 wrqu->rts.value = (local->sparm.b5.a_rts_threshold[0] << 8)
141fa61f 1269 + local->sparm.b5.a_rts_threshold[1];
43ead78a
JP		 1270 wrqu->rts.disabled = (wrqu->rts.value == 32767);
1271 wrqu->rts.fixed = 1;
3d5d5ac0
JT		 1272
1273 return 0;
1274}
1275
1276/*------------------------------------------------------------------*/
1277/*
1278 * Wireless Handler : set Fragmentation threshold
1279 */
43ead78a
JP		 1280static int ray_set_frag(struct net_device *dev, struct iw_request_info *info,
1281 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1282{
6dbc9c89 1283 ray_dev_t *local = netdev_priv(dev);
43ead78a 1284 int fthr = wrqu->frag.value;
3d5d5ac0
JT		 1285
1286 /* Reject if card is already initialised */
141fa61f 1287 if (local->card_status != CARD_AWAITING_PARAM)
3d5d5ac0 1288 return -EBUSY;
1da177e4
LT		 1289
1290 /* if(wrq->u.frag.fixed == 0) should complain */
43ead78a 1291 if (wrqu->frag.disabled)
3d5d5ac0
JT		 1292 fthr = 32767;
1293 else {
141fa61f 1294 if ((fthr < 256) || (fthr > 2347)) /* To check out ! */
3d5d5ac0
JT		 1295 return -EINVAL;
1296 }
1da177e4
LT		 1297 local->sparm.b5.a_frag_threshold[0] = (fthr >> 8) & 0xFF;
1298 local->sparm.b5.a_frag_threshold[1] = fthr & 0xFF;
1da177e4 1299
141fa61f 1300 return -EINPROGRESS; /* Call commit handler */
3d5d5ac0
JT		 1301}
1302
1303/*------------------------------------------------------------------*/
1304/*
1305 * Wireless Handler : get Fragmentation threshold
1306 */
43ead78a
JP		 1307static int ray_get_frag(struct net_device *dev, struct iw_request_info *info,
1308 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1309{
6dbc9c89 1310 ray_dev_t *local = netdev_priv(dev);
3d5d5ac0 1311
43ead78a 1312 wrqu->frag.value = (local->sparm.b5.a_frag_threshold[0] << 8)
141fa61f 1313 + local->sparm.b5.a_frag_threshold[1];
43ead78a
JP		 1314 wrqu->frag.disabled = (wrqu->frag.value == 32767);
1315 wrqu->frag.fixed = 1;
1da177e4 1316
3d5d5ac0
JT		 1317 return 0;
1318}
1da177e4 1319
3d5d5ac0
JT		 1320/*------------------------------------------------------------------*/
1321/*
1322 * Wireless Handler : set Mode of Operation
1323 */
43ead78a
JP		 1324static int ray_set_mode(struct net_device *dev, struct iw_request_info *info,
1325 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1326{
6dbc9c89 1327 ray_dev_t *local = netdev_priv(dev);
141fa61f 1328 int err = -EINPROGRESS; /* Call commit handler */
1da177e4 1329 char card_mode = 1;
1da177e4 1330
3d5d5ac0 1331 /* Reject if card is already initialised */
141fa61f 1332 if (local->card_status != CARD_AWAITING_PARAM)
3d5d5ac0
JT		 1333 return -EBUSY;
1334
43ead78a 1335 switch (wrqu->mode) {
1da177e4 1336 case IW_MODE_ADHOC:
3d5d5ac0 1337 card_mode = 0;
141fa61f 1338 /* Fall through */
1da177e4 1339 case IW_MODE_INFRA:
3d5d5ac0
JT		 1340 local->sparm.b5.a_network_type = card_mode;
1341 break;
1da177e4 1342 default:
3d5d5ac0 1343 err = -EINVAL;
1da177e4 1344 }
1da177e4 1345
3d5d5ac0
JT		 1346 return err;
1347}
1da177e4 1348
3d5d5ac0
JT		 1349/*------------------------------------------------------------------*/
1350/*
1351 * Wireless Handler : get Mode of Operation
1352 */
43ead78a
JP		 1353static int ray_get_mode(struct net_device *dev, struct iw_request_info *info,
1354 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1355{
6dbc9c89 1356 ray_dev_t *local = netdev_priv(dev);
1da177e4 1357
141fa61f 1358 if (local->sparm.b5.a_network_type)
43ead78a 1359 wrqu->mode = IW_MODE_INFRA;
3d5d5ac0 1360 else
43ead78a 1361 wrqu->mode = IW_MODE_ADHOC;
1da177e4 1362
3d5d5ac0
JT		 1363 return 0;
1364}
1da177e4 1365
3d5d5ac0
JT		 1366/*------------------------------------------------------------------*/
1367/*
1368 * Wireless Handler : get range info
1369 */
43ead78a
JP		 1370static int ray_get_range(struct net_device *dev, struct iw_request_info *info,
1371 union iwreq_data *wrqu, char *extra)
3d5d5ac0 1372{
141fa61f 1373 struct iw_range *range = (struct iw_range *)extra;
3d5d5ac0 1374
43ead78a 1375 memset(range, 0, sizeof(struct iw_range));
3d5d5ac0
JT		 1376
1377 /* Set the length (very important for backward compatibility) */
43ead78a 1378 wrqu->data.length = sizeof(struct iw_range);
3d5d5ac0
JT		 1379
1380 /* Set the Wireless Extension versions */
1381 range->we_version_compiled = WIRELESS_EXT;
1382 range->we_version_source = 9;
1383
1384 /* Set information in the range struct */
1385 range->throughput = 1.1 * 1000 * 1000; /* Put the right number here */
141fa61f 1386 range->num_channels = hop_pattern_length[(int)country];
3d5d5ac0
JT		 1387 range->num_frequency = 0;
1388 range->max_qual.qual = 0;
1389 range->max_qual.level = 255; /* What's the correct value ? */
1390 range->max_qual.noise = 255; /* Idem */
1391 range->num_bitrates = 2;
1392 range->bitrate[0] = 1000000; /* 1 Mb/s */
1393 range->bitrate[1] = 2000000; /* 2 Mb/s */
1394 return 0;
1395}
1da177e4 1396
3d5d5ac0
JT		 1397/*------------------------------------------------------------------*/
1398/*
1399 * Wireless Private Handler : set framing mode
1400 */
43ead78a 1401static int ray_set_framing(struct net_device *dev, struct iw_request_info *info,
141fa61f 1402 union iwreq_data *wrqu, char *extra)
3d5d5ac0
JT		 1403{
1404 translate = *(extra); /* Set framing mode */
1da177e4 1405
3d5d5ac0
JT		 1406 return 0;
1407}
1da177e4 1408
3d5d5ac0
JT		 1409/*------------------------------------------------------------------*/
1410/*
1411 * Wireless Private Handler : get framing mode
1412 */
43ead78a 1413static int ray_get_framing(struct net_device *dev, struct iw_request_info *info,
141fa61f 1414 union iwreq_data *wrqu, char *extra)
3d5d5ac0
JT		 1415{
1416 *(extra) = translate;
1417
1418 return 0;
1419}
1420
1421/*------------------------------------------------------------------*/
1422/*
1423 * Wireless Private Handler : get country
1424 */
43ead78a 1425static int ray_get_country(struct net_device *dev, struct iw_request_info *info,
141fa61f 1426 union iwreq_data *wrqu, char *extra)
3d5d5ac0
JT		 1427{
1428 *(extra) = country;
1429
1430 return 0;
1431}
1432
1433/*------------------------------------------------------------------*/
1434/*
1435 * Commit handler : called after a bunch of SET operations
1436 */
43ead78a
JP		 1437static int ray_commit(struct net_device *dev, struct iw_request_info *info,
1438 union iwreq_data *wrqu, char *extra)
1439{
3d5d5ac0
JT		 1440 return 0;
1441}
1442
1443/*------------------------------------------------------------------*/
1444/*
1445 * Stats handler : return Wireless Stats
1446 */
141fa61f 1447static iw_stats *ray_get_wireless_stats(struct net_device *dev)
1da177e4 1448{
141fa61f
JD		 1449 ray_dev_t *local = netdev_priv(dev);
1450 struct pcmcia_device *link = local->finder;
1451 struct status __iomem *p = local->sram + STATUS_BASE;
1da177e4 1452
141fa61f 1453 local->wstats.status = local->card_status;
1da177e4 1454#ifdef WIRELESS_SPY
141fa61f
JD		 1455 if ((local->spy_data.spy_number > 0)
1456 && (local->sparm.b5.a_network_type == 0)) {
1457 /* Get it from the first node in spy list */
1458 local->wstats.qual.qual = local->spy_data.spy_stat[0].qual;
1459 local->wstats.qual.level = local->spy_data.spy_stat[0].level;
1460 local->wstats.qual.noise = local->spy_data.spy_stat[0].noise;
1461 local->wstats.qual.updated =
1462 local->spy_data.spy_stat[0].updated;
1463 }
1da177e4
LT		 1464#endif /* WIRELESS_SPY */
1465
141fa61f
JD		 1466 if (pcmcia_dev_present(link)) {
1467 local->wstats.qual.noise = readb(&p->rxnoise);
1468 local->wstats.qual.updated |= 4;
1469 }
1da177e4 1470
141fa61f 1471 return &local->wstats;
1da177e4 1472} /* end ray_get_wireless_stats */
3d5d5ac0
JT		 1473
1474/*------------------------------------------------------------------*/
1475/*
1476 * Structures to export the Wireless Handlers
1477 */
1478
141fa61f 1479static const iw_handler ray_handler[] = {
43ead78a
JP		 1480 IW_HANDLER(SIOCSIWCOMMIT, ray_commit),
1481 IW_HANDLER(SIOCGIWNAME, ray_get_name),
1482 IW_HANDLER(SIOCSIWFREQ, ray_set_freq),
1483 IW_HANDLER(SIOCGIWFREQ, ray_get_freq),
1484 IW_HANDLER(SIOCSIWMODE, ray_set_mode),
1485 IW_HANDLER(SIOCGIWMODE, ray_get_mode),
1486 IW_HANDLER(SIOCGIWRANGE, ray_get_range),
3d5d5ac0 1487#ifdef WIRELESS_SPY
270020e8
JP		 1488 IW_HANDLER(SIOCSIWSPY, iw_handler_set_spy),
1489 IW_HANDLER(SIOCGIWSPY, iw_handler_get_spy),
1490 IW_HANDLER(SIOCSIWTHRSPY, iw_handler_set_thrspy),
1491 IW_HANDLER(SIOCGIWTHRSPY, iw_handler_get_thrspy),
141fa61f 1492#endif /* WIRELESS_SPY */
43ead78a
JP		 1493 IW_HANDLER(SIOCGIWAP, ray_get_wap),
1494 IW_HANDLER(SIOCSIWESSID, ray_set_essid),
1495 IW_HANDLER(SIOCGIWESSID, ray_get_essid),
1496 IW_HANDLER(SIOCSIWRATE, ray_set_rate),
1497 IW_HANDLER(SIOCGIWRATE, ray_get_rate),
1498 IW_HANDLER(SIOCSIWRTS, ray_set_rts),
1499 IW_HANDLER(SIOCGIWRTS, ray_get_rts),
1500 IW_HANDLER(SIOCSIWFRAG, ray_set_frag),
1501 IW_HANDLER(SIOCGIWFRAG, ray_get_frag),
3d5d5ac0
JT		 1502};
1503
141fa61f 1504#define SIOCSIPFRAMING SIOCIWFIRSTPRIV /* Set framing mode */
3d5d5ac0
JT		 1505#define SIOCGIPFRAMING SIOCIWFIRSTPRIV + 1 /* Get framing mode */
1506#define SIOCGIPCOUNTRY SIOCIWFIRSTPRIV + 3 /* Get country code */
1507
141fa61f 1508static const iw_handler ray_private_handler[] = {
43ead78a
JP		 1509 [0] = ray_set_framing,
1510 [1] = ray_get_framing,
1511 [3] = ray_get_country,
3d5d5ac0
JT		 1512};
1513
141fa61f 1514static const struct iw_priv_args ray_private_args[] = {
3d5d5ac0 1515/* cmd, set_args, get_args, name */
141fa61f
JD		 1516 {SIOCSIPFRAMING, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1, 0,
1517 "set_framing"},
1518 {SIOCGIPFRAMING, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
1519 "get_framing"},
1520 {SIOCGIPCOUNTRY, 0, IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
1521 "get_country"},
3d5d5ac0
JT		 1522};
1523
141fa61f
JD		 1524static const struct iw_handler_def ray_handler_def = {
1525 .num_standard = ARRAY_SIZE(ray_handler),
1526 .num_private = ARRAY_SIZE(ray_private_handler),
ff8ac609 1527 .num_private_args = ARRAY_SIZE(ray_private_args),
141fa61f
JD		 1528 .standard = ray_handler,
1529 .private = ray_private_handler,
1530 .private_args = ray_private_args,
3d5d5ac0
JT		 1531 .get_wireless_stats = ray_get_wireless_stats,
1532};
1533
1da177e4
LT		 1534/*===========================================================================*/
1535static int ray_open(struct net_device *dev)
1536{
141fa61f
JD		 1537 ray_dev_t *local = netdev_priv(dev);
1538 struct pcmcia_device *link;
1539 link = local->finder;
1da177e4 1540
624dd669 1541 dev_dbg(&link->dev, "ray_open('%s')\n", dev->name);
1da177e4 1542
141fa61f
JD		 1543 if (link->open == 0)
1544 local->num_multi = 0;
1545 link->open++;
1da177e4 1546
141fa61f
JD		 1547 /* If the card is not started, time to start it ! - Jean II */
1548 if (local->card_status == CARD_AWAITING_PARAM) {
1549 int i;
1da177e4 1550
624dd669 1551 dev_dbg(&link->dev, "ray_open: doing init now !\n");
141fa61f
JD		 1552
1553 /* Download startup parameters */
1554 if ((i = dl_startup_params(dev)) < 0) {
1555 printk(KERN_INFO
1556 "ray_dev_init dl_startup_params failed - "
1557 "returns 0x%x\n", i);
1558 return -1;
1559 }
1560 }
1561
1562 if (sniffer)
1563 netif_stop_queue(dev);
1564 else
1565 netif_start_queue(dev);
1566
624dd669 1567 dev_dbg(&link->dev, "ray_open ending\n");
141fa61f 1568 return 0;
1da177e4 1569} /* end ray_open */
141fa61f 1570
1da177e4
LT		 1571/*===========================================================================*/
1572static int ray_dev_close(struct net_device *dev)
1573{
141fa61f
JD		 1574 ray_dev_t *local = netdev_priv(dev);
1575 struct pcmcia_device *link;
1576 link = local->finder;
1da177e4 1577
624dd669 1578 dev_dbg(&link->dev, "ray_dev_close('%s')\n", dev->name);
1da177e4 1579
141fa61f
JD		 1580 link->open--;
1581 netif_stop_queue(dev);
1da177e4 1582
141fa61f
JD		 1583 /* In here, we should stop the hardware (stop card from beeing active)
1584 * and set local->card_status to CARD_AWAITING_PARAM, so that while the
1585 * card is closed we can chage its configuration.
1586 * Probably also need a COR reset to get sane state - Jean II */
1da177e4 1587
141fa61f 1588 return 0;
1da177e4 1589} /* end ray_dev_close */
141fa61f 1590
1da177e4 1591/*===========================================================================*/
141fa61f
JD		 1592static void ray_reset(struct net_device *dev)
1593{
624dd669 1594 pr_debug("ray_reset entered\n");
1da177e4 1595}
141fa61f 1596
1da177e4
LT		 1597/*===========================================================================*/
1598/* Cause a firmware interrupt if it is ready for one */
1599/* Return nonzero if not ready */
1600static int interrupt_ecf(ray_dev_t *local, int ccs)
1601{
141fa61f
JD		 1602 int i = 50;
1603 struct pcmcia_device *link = local->finder;
1604
1605 if (!(pcmcia_dev_present(link))) {
624dd669 1606 dev_dbg(&link->dev, "ray_cs interrupt_ecf - device not present\n");
141fa61f
JD		 1607 return -1;
1608 }
624dd669 1609 dev_dbg(&link->dev, "interrupt_ecf(local=%p, ccs = 0x%x\n", local, ccs);
141fa61f
JD		 1610
1611 while (i &&
1612 (readb(local->amem + CIS_OFFSET + ECF_INTR_OFFSET) &
1613 ECF_INTR_SET))
1614 i--;
1615 if (i == 0) {
624dd669 1616 dev_dbg(&link->dev, "ray_cs interrupt_ecf card not ready for interrupt\n");
141fa61f
JD		 1617 return -1;
1618 }
1da177e4 1619 /* Fill the mailbox, then kick the card */
141fa61f
JD		 1620 writeb(ccs, local->sram + SCB_BASE);
1621 writeb(ECF_INTR_SET, local->amem + CIS_OFFSET + ECF_INTR_OFFSET);
1622 return 0;
1da177e4 1623} /* interrupt_ecf */
141fa61f 1624
1da177e4
LT		 1625/*===========================================================================*/
1626/* Get next free transmit CCS */
1627/* Return - index of current tx ccs */
1628static int get_free_tx_ccs(ray_dev_t *local)
1629{
141fa61f
JD		 1630 int i;
1631 struct ccs __iomem *pccs = ccs_base(local);
1632 struct pcmcia_device *link = local->finder;
1da177e4 1633
141fa61f 1634 if (!(pcmcia_dev_present(link))) {
624dd669 1635 dev_dbg(&link->dev, "ray_cs get_free_tx_ccs - device not present\n");
141fa61f
JD		 1636 return ECARDGONE;
1637 }
1da177e4 1638
141fa61f 1639 if (test_and_set_bit(0, &local->tx_ccs_lock)) {
624dd669 1640 dev_dbg(&link->dev, "ray_cs tx_ccs_lock busy\n");
141fa61f
JD		 1641 return ECCSBUSY;
1642 }
1da177e4 1643
141fa61f
JD		 1644 for (i = 0; i < NUMBER_OF_TX_CCS; i++) {
1645 if (readb(&(pccs + i)->buffer_status) == CCS_BUFFER_FREE) {
1646 writeb(CCS_BUFFER_BUSY, &(pccs + i)->buffer_status);
1647 writeb(CCS_END_LIST, &(pccs + i)->link);
1da177e4 1648 local->tx_ccs_lock = 0;
141fa61f
JD		 1649 return i;
1650 }
1651 }
1da177e4 1652 local->tx_ccs_lock = 0;
624dd669 1653 dev_dbg(&link->dev, "ray_cs ERROR no free tx CCS for raylink card\n");
141fa61f 1654 return ECCSFULL;
1da177e4 1655} /* get_free_tx_ccs */
141fa61f 1656
1da177e4
LT		 1657/*===========================================================================*/
1658/* Get next free CCS */
1659/* Return - index of current ccs */
1660static int get_free_ccs(ray_dev_t *local)
1661{
141fa61f
JD		 1662 int i;
1663 struct ccs __iomem *pccs = ccs_base(local);
1664 struct pcmcia_device *link = local->finder;
1665
1666 if (!(pcmcia_dev_present(link))) {
624dd669 1667 dev_dbg(&link->dev, "ray_cs get_free_ccs - device not present\n");
141fa61f
JD		 1668 return ECARDGONE;
1669 }
1670 if (test_and_set_bit(0, &local->ccs_lock)) {
624dd669 1671 dev_dbg(&link->dev, "ray_cs ccs_lock busy\n");
141fa61f
JD		 1672 return ECCSBUSY;
1673 }
1674
1675 for (i = NUMBER_OF_TX_CCS; i < NUMBER_OF_CCS; i++) {
1676 if (readb(&(pccs + i)->buffer_status) == CCS_BUFFER_FREE) {
1677 writeb(CCS_BUFFER_BUSY, &(pccs + i)->buffer_status);
1678 writeb(CCS_END_LIST, &(pccs + i)->link);
1da177e4 1679 local->ccs_lock = 0;
141fa61f
JD		 1680 return i;
1681 }
1682 }
1da177e4 1683 local->ccs_lock = 0;
624dd669 1684 dev_dbg(&link->dev, "ray_cs ERROR no free CCS for raylink card\n");
141fa61f 1685 return ECCSFULL;
1da177e4 1686} /* get_free_ccs */
141fa61f 1687
1da177e4
LT		 1688/*===========================================================================*/
1689static void authenticate_timeout(u_long data)
1690{
141fa61f
JD		 1691 ray_dev_t *local = (ray_dev_t *) data;
1692 del_timer(&local->timer);
1693 printk(KERN_INFO "ray_cs Authentication with access point failed"
1694 " - timeout\n");
1695 join_net((u_long) local);
1da177e4 1696}
141fa61f 1697
1da177e4
LT		 1698/*===========================================================================*/
1699static int parse_addr(char *in_str, UCHAR *out)
1700{
141fa61f
JD		 1701 int len;
1702 int i, j, k;
1703 int status;
1704
1705 if (in_str == NULL)
1706 return 0;
1707 if ((len = strlen(in_str)) < 2)
1708 return 0;
1709 memset(out, 0, ADDRLEN);
1710
1711 status = 1;
1712 j = len - 1;
1713 if (j > 12)
1714 j = 12;
1715 i = 5;
1716
1717 while (j > 0) {
882d829a 1718 if ((k = hex_to_bin(in_str[j--])) != -1)
141fa61f
JD		 1719 out[i] = k;
1720 else
1721 return 0;
1722
1723 if (j == 0)
1724 break;
882d829a 1725 if ((k = hex_to_bin(in_str[j--])) != -1)
141fa61f
JD		 1726 out[i] += k << 4;
1727 else
1728 return 0;
1729 if (!i--)
1730 break;
1731 }
1732 return status;
1da177e4 1733}
141fa61f 1734
1da177e4
LT		 1735/*===========================================================================*/
1736static struct net_device_stats *ray_get_stats(struct net_device *dev)
1737{
141fa61f
JD		 1738 ray_dev_t *local = netdev_priv(dev);
1739 struct pcmcia_device *link = local->finder;
1740 struct status __iomem *p = local->sram + STATUS_BASE;
1741 if (!(pcmcia_dev_present(link))) {
624dd669 1742 dev_dbg(&link->dev, "ray_cs net_device_stats - device not present\n");
141fa61f
JD		 1743 return &local->stats;
1744 }
1745 if (readb(&p->mrx_overflow_for_host)) {
1746 local->stats.rx_over_errors += swab16(readw(&p->mrx_overflow));
1747 writeb(0, &p->mrx_overflow);
1748 writeb(0, &p->mrx_overflow_for_host);
1749 }
1750 if (readb(&p->mrx_checksum_error_for_host)) {
1751 local->stats.rx_crc_errors +=
1752 swab16(readw(&p->mrx_checksum_error));
1753 writeb(0, &p->mrx_checksum_error);
1754 writeb(0, &p->mrx_checksum_error_for_host);
1755 }
1756 if (readb(&p->rx_hec_error_for_host)) {
1757 local->stats.rx_frame_errors += swab16(readw(&p->rx_hec_error));
1758 writeb(0, &p->rx_hec_error);
1759 writeb(0, &p->rx_hec_error_for_host);
1760 }
1761 return &local->stats;
1da177e4 1762}
141fa61f 1763
1da177e4 1764/*===========================================================================*/
141fa61f
JD		 1765static void ray_update_parm(struct net_device *dev, UCHAR objid, UCHAR *value,
1766 int len)
1767{
1768 ray_dev_t *local = netdev_priv(dev);
1769 struct pcmcia_device *link = local->finder;
1770 int ccsindex;
1771 int i;
1772 struct ccs __iomem *pccs;
1773
1774 if (!(pcmcia_dev_present(link))) {
624dd669 1775 dev_dbg(&link->dev, "ray_update_parm - device not present\n");
141fa61f
JD		 1776 return;
1777 }
1778
1779 if ((ccsindex = get_free_ccs(local)) < 0) {
624dd669 1780 dev_dbg(&link->dev, "ray_update_parm - No free ccs\n");
141fa61f
JD		 1781 return;
1782 }
1783 pccs = ccs_base(local) + ccsindex;
1784 writeb(CCS_UPDATE_PARAMS, &pccs->cmd);
1785 writeb(objid, &pccs->var.update_param.object_id);
1786 writeb(1, &pccs->var.update_param.number_objects);
1787 writeb(0, &pccs->var.update_param.failure_cause);
1788 for (i = 0; i < len; i++) {
1789 writeb(value[i], local->sram + HOST_TO_ECF_BASE);
1790 }
1791 /* Interrupt the firmware to process the command */
1792 if (interrupt_ecf(local, ccsindex)) {
624dd669 1793 dev_dbg(&link->dev, "ray_cs associate failed - ECF not ready for intr\n");
141fa61f
JD		 1794 writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
1795 }
1da177e4 1796}
141fa61f 1797
1da177e4
LT		 1798/*===========================================================================*/
1799static void ray_update_multi_list(struct net_device *dev, int all)
1800{
141fa61f
JD		 1801 int ccsindex;
1802 struct ccs __iomem *pccs;
141fa61f
JD		 1803 ray_dev_t *local = netdev_priv(dev);
1804 struct pcmcia_device *link = local->finder;
1805 void __iomem *p = local->sram + HOST_TO_ECF_BASE;
1806
1807 if (!(pcmcia_dev_present(link))) {
624dd669 1808 dev_dbg(&link->dev, "ray_update_multi_list - device not present\n");
141fa61f
JD		 1809 return;
1810 } else
624dd669 1811 dev_dbg(&link->dev, "ray_update_multi_list(%p)\n", dev);
141fa61f 1812 if ((ccsindex = get_free_ccs(local)) < 0) {
624dd669 1813 dev_dbg(&link->dev, "ray_update_multi - No free ccs\n");
141fa61f
JD		 1814 return;
1815 }
1816 pccs = ccs_base(local) + ccsindex;
1817 writeb(CCS_UPDATE_MULTICAST_LIST, &pccs->cmd);
1818
1819 if (all) {
1820 writeb(0xff, &pccs->var);
1821 local->num_multi = 0xff;
1822 } else {
22bedad3 1823 struct netdev_hw_addr *ha;
655ffee2
JP		 1824 int i = 0;
1825
141fa61f 1826 /* Copy the kernel's list of MC addresses to card */
22bedad3
JP		 1827 netdev_for_each_mc_addr(ha, dev) {
1828 memcpy_toio(p, ha->addr, ETH_ALEN);
624dd669 1829 dev_dbg(&link->dev,
141fa61f 1830 "ray_update_multi add addr %02x%02x%02x%02x%02x%02x\n",
22bedad3
JP		 1831 ha->addr[0], ha->addr[1],
1832 ha->addr[2], ha->addr[3],
1833 ha->addr[4], ha->addr[5]);
141fa61f
JD		 1834 p += ETH_ALEN;
1835 i++;
1836 }
1837 if (i > 256 / ADDRLEN)
1838 i = 256 / ADDRLEN;
1839 writeb((UCHAR) i, &pccs->var);
624dd669 1840 dev_dbg(&link->dev, "ray_cs update_multi %d addresses in list\n", i);
141fa61f
JD		 1841 /* Interrupt the firmware to process the command */
1842 local->num_multi = i;
1843 }
1844 if (interrupt_ecf(local, ccsindex)) {
624dd669 1845 dev_dbg(&link->dev,
141fa61f
JD		 1846 "ray_cs update_multi failed - ECF not ready for intr\n");
1847 writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
1848 }
1da177e4 1849} /* end ray_update_multi_list */
141fa61f 1850
1da177e4
LT		 1851/*===========================================================================*/
1852static void set_multicast_list(struct net_device *dev)
1853{
141fa61f
JD		 1854 ray_dev_t *local = netdev_priv(dev);
1855 UCHAR promisc;
1856
624dd669 1857 pr_debug("ray_cs set_multicast_list(%p)\n", dev);
141fa61f
JD		 1858
1859 if (dev->flags & IFF_PROMISC) {
1860 if (local->sparm.b5.a_promiscuous_mode == 0) {
624dd669 1861 pr_debug("ray_cs set_multicast_list promisc on\n");
141fa61f
JD		 1862 local->sparm.b5.a_promiscuous_mode = 1;
1863 promisc = 1;
1864 ray_update_parm(dev, OBJID_promiscuous_mode,
1865 &promisc, sizeof(promisc));
1866 }
1867 } else {
1868 if (local->sparm.b5.a_promiscuous_mode == 1) {
624dd669 1869 pr_debug("ray_cs set_multicast_list promisc off\n");
141fa61f
JD		 1870 local->sparm.b5.a_promiscuous_mode = 0;
1871 promisc = 0;
1872 ray_update_parm(dev, OBJID_promiscuous_mode,
1873 &promisc, sizeof(promisc));
1874 }
1875 }
1876
1877 if (dev->flags & IFF_ALLMULTI)
1878 ray_update_multi_list(dev, 1);
1879 else {
4cd24eaf 1880 if (local->num_multi != netdev_mc_count(dev))
141fa61f
JD		 1881 ray_update_multi_list(dev, 0);
1882 }
1da177e4 1883} /* end set_multicast_list */
141fa61f 1884
1da177e4
LT		 1885/*=============================================================================
1886 * All routines below here are run at interrupt time.
1887=============================================================================*/
7d12e780 1888static irqreturn_t ray_interrupt(int irq, void *dev_id)
1da177e4 1889{
141fa61f
JD		 1890 struct net_device *dev = (struct net_device *)dev_id;
1891 struct pcmcia_device *link;
1892 ray_dev_t *local;
1893 struct ccs __iomem *pccs;
1894 struct rcs __iomem *prcs;
1895 UCHAR rcsindex;
1896 UCHAR tmp;
1897 UCHAR cmd;
1898 UCHAR status;
1899
1900 if (dev == NULL) /* Note that we want interrupts with dev->start == 0 */
1901 return IRQ_NONE;
1902
624dd669 1903 pr_debug("ray_cs: interrupt for *dev=%p\n", dev);
141fa61f
JD		 1904
1905 local = netdev_priv(dev);
1906 link = (struct pcmcia_device *)local->finder;
1907 if (!pcmcia_dev_present(link)) {
624dd669
DB		 1908 pr_debug(
1909 "ray_cs interrupt from device not present or suspended.\n");
141fa61f
JD		 1910 return IRQ_NONE;
1911 }
1912 rcsindex = readb(&((struct scb __iomem *)(local->sram))->rcs_index);
1913
1914 if (rcsindex >= (NUMBER_OF_CCS + NUMBER_OF_RCS)) {
624dd669 1915 dev_dbg(&link->dev, "ray_cs interrupt bad rcsindex = 0x%x\n", rcsindex);
141fa61f
JD		 1916 clear_interrupt(local);
1917 return IRQ_HANDLED;
1918 }
1919 if (rcsindex < NUMBER_OF_CCS) { /* If it's a returned CCS */
1920 pccs = ccs_base(local) + rcsindex;
1921 cmd = readb(&pccs->cmd);
1922 status = readb(&pccs->buffer_status);
1923 switch (cmd) {
1924 case CCS_DOWNLOAD_STARTUP_PARAMS: /* Happens in firmware someday */
1925 del_timer(&local->timer);
1926 if (status == CCS_COMMAND_COMPLETE) {
624dd669 1927 dev_dbg(&link->dev,
141fa61f
JD		 1928 "ray_cs interrupt download_startup_parameters OK\n");
1929 } else {
624dd669 1930 dev_dbg(&link->dev,
141fa61f
JD		 1931 "ray_cs interrupt download_startup_parameters fail\n");
1932 }
1933 break;
1934 case CCS_UPDATE_PARAMS:
624dd669 1935 dev_dbg(&link->dev, "ray_cs interrupt update params done\n");
141fa61f
JD		 1936 if (status != CCS_COMMAND_COMPLETE) {
1937 tmp =
1938 readb(&pccs->var.update_param.
1939 failure_cause);
624dd669 1940 dev_dbg(&link->dev,
141fa61f
JD		 1941 "ray_cs interrupt update params failed - reason %d\n",
1942 tmp);
1943 }
1944 break;
1945 case CCS_REPORT_PARAMS:
624dd669 1946 dev_dbg(&link->dev, "ray_cs interrupt report params done\n");
141fa61f
JD		 1947 break;
1948 case CCS_UPDATE_MULTICAST_LIST: /* Note that this CCS isn't returned */
624dd669 1949 dev_dbg(&link->dev,
141fa61f
JD		 1950 "ray_cs interrupt CCS Update Multicast List done\n");
1951 break;
1952 case CCS_UPDATE_POWER_SAVINGS_MODE:
624dd669 1953 dev_dbg(&link->dev,
141fa61f
JD		 1954 "ray_cs interrupt update power save mode done\n");
1955 break;
1956 case CCS_START_NETWORK:
1957 case CCS_JOIN_NETWORK:
1958 if (status == CCS_COMMAND_COMPLETE) {
1959 if (readb
1960 (&pccs->var.start_network.net_initiated) ==
1961 1) {
624dd669 1962 dev_dbg(&link->dev,
141fa61f
JD		 1963 "ray_cs interrupt network \"%s\" started\n",
1964 local->sparm.b4.a_current_ess_id);
1965 } else {
624dd669 1966 dev_dbg(&link->dev,
141fa61f
JD		 1967 "ray_cs interrupt network \"%s\" joined\n",
1968 local->sparm.b4.a_current_ess_id);
1969 }
1970 memcpy_fromio(&local->bss_id,
1971 pccs->var.start_network.bssid,
1972 ADDRLEN);
1973
1974 if (local->fw_ver == 0x55)
1975 local->net_default_tx_rate = 3;
1976 else
1977 local->net_default_tx_rate =
1978 readb(&pccs->var.start_network.
1979 net_default_tx_rate);
1980 local->encryption =
1981 readb(&pccs->var.start_network.encryption);
1982 if (!sniffer && (local->net_type == INFRA)
1983 && !(local->sparm.b4.a_acting_as_ap_status)) {
1984 authenticate(local);
1985 }
1986 local->card_status = CARD_ACQ_COMPLETE;
1987 } else {
1988 local->card_status = CARD_ACQ_FAILED;
1989
1990 del_timer(&local->timer);
1991 local->timer.expires = jiffies + HZ * 5;
1992 local->timer.data = (long)local;
1993 if (status == CCS_START_NETWORK) {
624dd669 1994 dev_dbg(&link->dev,
141fa61f
JD		 1995 "ray_cs interrupt network \"%s\" start failed\n",
1996 local->sparm.b4.a_current_ess_id);
1997 local->timer.function = &start_net;
1998 } else {
624dd669 1999 dev_dbg(&link->dev,
141fa61f
JD		 2000 "ray_cs interrupt network \"%s\" join failed\n",
2001 local->sparm.b4.a_current_ess_id);
2002 local->timer.function = &join_net;
2003 }
2004 add_timer(&local->timer);
2005 }
2006 break;
2007 case CCS_START_ASSOCIATION:
2008 if (status == CCS_COMMAND_COMPLETE) {
2009 local->card_status = CARD_ASSOC_COMPLETE;
624dd669 2010 dev_dbg(&link->dev, "ray_cs association successful\n");
141fa61f 2011 } else {
624dd669 2012 dev_dbg(&link->dev, "ray_cs association failed,\n");
141fa61f
JD		 2013 local->card_status = CARD_ASSOC_FAILED;
2014 join_net((u_long) local);
2015 }
2016 break;
2017 case CCS_TX_REQUEST:
2018 if (status == CCS_COMMAND_COMPLETE) {
624dd669 2019 dev_dbg(&link->dev,
141fa61f
JD		 2020 "ray_cs interrupt tx request complete\n");
2021 } else {
624dd669 2022 dev_dbg(&link->dev,
141fa61f
JD		 2023 "ray_cs interrupt tx request failed\n");
2024 }
2025 if (!sniffer)
2026 netif_start_queue(dev);
2027 netif_wake_queue(dev);
2028 break;
2029 case CCS_TEST_MEMORY:
624dd669 2030 dev_dbg(&link->dev, "ray_cs interrupt mem test done\n");
141fa61f
JD		 2031 break;
2032 case CCS_SHUTDOWN:
624dd669 2033 dev_dbg(&link->dev,
141fa61f
JD		 2034 "ray_cs interrupt Unexpected CCS returned - Shutdown\n");
2035 break;
2036 case CCS_DUMP_MEMORY:
624dd669 2037 dev_dbg(&link->dev, "ray_cs interrupt dump memory done\n");
141fa61f
JD		 2038 break;
2039 case CCS_START_TIMER:
624dd669 2040 dev_dbg(&link->dev,
141fa61f
JD		 2041 "ray_cs interrupt DING - raylink timer expired\n");
2042 break;
2043 default:
624dd669 2044 dev_dbg(&link->dev,
141fa61f
JD		 2045 "ray_cs interrupt Unexpected CCS 0x%x returned 0x%x\n",
2046 rcsindex, cmd);
2047 }
2048 writeb(CCS_BUFFER_FREE, &pccs->buffer_status);
2049 } else { /* It's an RCS */
2050
2051 prcs = rcs_base(local) + rcsindex;
2052
2053 switch (readb(&prcs->interrupt_id)) {
2054 case PROCESS_RX_PACKET:
2055 ray_rx(dev, local, prcs);
2056 break;
2057 case REJOIN_NET_COMPLETE:
624dd669 2058 dev_dbg(&link->dev, "ray_cs interrupt rejoin net complete\n");
141fa61f
JD		 2059 local->card_status = CARD_ACQ_COMPLETE;
2060 /* do we need to clear tx buffers CCS's? */
2061 if (local->sparm.b4.a_network_type == ADHOC) {
2062 if (!sniffer)
2063 netif_start_queue(dev);
2064 } else {
2065 memcpy_fromio(&local->bss_id,
2066 prcs->var.rejoin_net_complete.
2067 bssid, ADDRLEN);
624dd669 2068 dev_dbg(&link->dev,
141fa61f
JD		 2069 "ray_cs new BSSID = %02x%02x%02x%02x%02x%02x\n",
2070 local->bss_id[0], local->bss_id[1],
2071 local->bss_id[2], local->bss_id[3],
2072 local->bss_id[4], local->bss_id[5]);
2073 if (!sniffer)
2074 authenticate(local);
2075 }
2076 break;
2077 case ROAMING_INITIATED:
624dd669 2078 dev_dbg(&link->dev, "ray_cs interrupt roaming initiated\n");
141fa61f
JD		 2079 netif_stop_queue(dev);
2080 local->card_status = CARD_DOING_ACQ;
2081 break;
2082 case JAPAN_CALL_SIGN_RXD:
624dd669 2083 dev_dbg(&link->dev, "ray_cs interrupt japan call sign rx\n");
141fa61f
JD		 2084 break;
2085 default:
624dd669 2086 dev_dbg(&link->dev,
141fa61f
JD		 2087 "ray_cs Unexpected interrupt for RCS 0x%x cmd = 0x%x\n",
2088 rcsindex,
2089 (unsigned int)readb(&prcs->interrupt_id));
2090 break;
2091 }
2092 writeb(CCS_BUFFER_FREE, &prcs->buffer_status);
2093 }
2094 clear_interrupt(local);
2095 return IRQ_HANDLED;
1da177e4 2096} /* ray_interrupt */
141fa61f 2097
1da177e4 2098/*===========================================================================*/
141fa61f
JD		 2099static void ray_rx(struct net_device *dev, ray_dev_t *local,
2100 struct rcs __iomem *prcs)
2101{
2102 int rx_len;
2103 unsigned int pkt_addr;
2104 void __iomem *pmsg;
624dd669 2105 pr_debug("ray_rx process rx packet\n");
141fa61f
JD		 2106
2107 /* Calculate address of packet within Rx buffer */
2108 pkt_addr = ((readb(&prcs->var.rx_packet.rx_data_ptr[0]) << 8)
2109 + readb(&prcs->var.rx_packet.rx_data_ptr[1])) & RX_BUFF_END;
2110 /* Length of first packet fragment */
2111 rx_len = (readb(&prcs->var.rx_packet.rx_data_length[0]) << 8)
2112 + readb(&prcs->var.rx_packet.rx_data_length[1]);
2113
2114 local->last_rsl = readb(&prcs->var.rx_packet.rx_sig_lev);
2115 pmsg = local->rmem + pkt_addr;
2116 switch (readb(pmsg)) {
2117 case DATA_TYPE:
624dd669 2118 pr_debug("ray_rx data type\n");
141fa61f
JD		 2119 rx_data(dev, prcs, pkt_addr, rx_len);
2120 break;
2121 case AUTHENTIC_TYPE:
624dd669 2122 pr_debug("ray_rx authentic type\n");
141fa61f
JD		 2123 if (sniffer)
2124 rx_data(dev, prcs, pkt_addr, rx_len);
2125 else
2126 rx_authenticate(local, prcs, pkt_addr, rx_len);
2127 break;
2128 case DEAUTHENTIC_TYPE:
624dd669 2129 pr_debug("ray_rx deauth type\n");
141fa61f
JD		 2130 if (sniffer)
2131 rx_data(dev, prcs, pkt_addr, rx_len);
2132 else
2133 rx_deauthenticate(local, prcs, pkt_addr, rx_len);
2134 break;
2135 case NULL_MSG_TYPE:
624dd669 2136 pr_debug("ray_cs rx NULL msg\n");
141fa61f
JD		 2137 break;
2138 case BEACON_TYPE:
624dd669 2139 pr_debug("ray_rx beacon type\n");
141fa61f
JD		 2140 if (sniffer)
2141 rx_data(dev, prcs, pkt_addr, rx_len);
2142
2143 copy_from_rx_buff(local, (UCHAR *) &local->last_bcn, pkt_addr,
2144 rx_len < sizeof(struct beacon_rx) ?
2145 rx_len : sizeof(struct beacon_rx));
2146
2147 local->beacon_rxed = 1;
2148 /* Get the statistics so the card counters never overflow */
2149 ray_get_stats(dev);
2150 break;
2151 default:
624dd669 2152 pr_debug("ray_cs unknown pkt type %2x\n",
141fa61f
JD		 2153 (unsigned int)readb(pmsg));
2154 break;
2155 }
1da177e4
LT		 2156
2157} /* end ray_rx */
141fa61f 2158
1da177e4 2159/*===========================================================================*/
141fa61f
JD		 2160static void rx_data(struct net_device *dev, struct rcs __iomem *prcs,
2161 unsigned int pkt_addr, int rx_len)
2162{
2163 struct sk_buff *skb = NULL;
2164 struct rcs __iomem *prcslink = prcs;
2165 ray_dev_t *local = netdev_priv(dev);
2166 UCHAR *rx_ptr;
2167 int total_len;
2168 int tmp;
1da177e4 2169#ifdef WIRELESS_SPY
141fa61f
JD		 2170 int siglev = local->last_rsl;
2171 u_char linksrcaddr[ETH_ALEN]; /* Other end of the wireless link */
1da177e4
LT		 2172#endif
2173
141fa61f
JD		 2174 if (!sniffer) {
2175 if (translate) {
1da177e4 2176/* TBD length needs fixing for translated header */
141fa61f
JD		 2177 if (rx_len < (ETH_HLEN + RX_MAC_HEADER_LENGTH) ||
2178 rx_len >
2179 (dev->mtu + RX_MAC_HEADER_LENGTH + ETH_HLEN +
2180 FCS_LEN)) {
624dd669 2181 pr_debug(
cb01b09c 2182 "ray_cs invalid packet length %d received\n",
141fa61f
JD		 2183 rx_len);
2184 return;
2185 }
2186 } else { /* encapsulated ethernet */
2187
2188 if (rx_len < (ETH_HLEN + RX_MAC_HEADER_LENGTH) ||
2189 rx_len >
2190 (dev->mtu + RX_MAC_HEADER_LENGTH + ETH_HLEN +
2191 FCS_LEN)) {
624dd669 2192 pr_debug(
cb01b09c 2193 "ray_cs invalid packet length %d received\n",
141fa61f
JD		 2194 rx_len);
2195 return;
2196 }
2197 }
2198 }
624dd669 2199 pr_debug("ray_cs rx_data packet\n");
141fa61f
JD		 2200 /* If fragmented packet, verify sizes of fragments add up */
2201 if (readb(&prcs->var.rx_packet.next_frag_rcs_index) != 0xFF) {
624dd669 2202 pr_debug("ray_cs rx'ed fragment\n");
141fa61f
JD		 2203 tmp = (readb(&prcs->var.rx_packet.totalpacketlength[0]) << 8)
2204 + readb(&prcs->var.rx_packet.totalpacketlength[1]);
2205 total_len = tmp;
2206 prcslink = prcs;
2207 do {
2208 tmp -=
2209 (readb(&prcslink->var.rx_packet.rx_data_length[0])
2210 << 8)
2211 + readb(&prcslink->var.rx_packet.rx_data_length[1]);
2212 if (readb(&prcslink->var.rx_packet.next_frag_rcs_index)
2213 == 0xFF || tmp < 0)
2214 break;
2215 prcslink = rcs_base(local)
2216 + readb(&prcslink->link_field);
2217 } while (1);
2218
2219 if (tmp < 0) {
624dd669 2220 pr_debug(
141fa61f
JD		 2221 "ray_cs rx_data fragment lengths don't add up\n");
2222 local->stats.rx_dropped++;
2223 release_frag_chain(local, prcs);
2224 return;
2225 }
2226 } else { /* Single unfragmented packet */
2227 total_len = rx_len;
2228 }
2229
2230 skb = dev_alloc_skb(total_len + 5);
2231 if (skb == NULL) {
624dd669 2232 pr_debug("ray_cs rx_data could not allocate skb\n");
141fa61f
JD		 2233 local->stats.rx_dropped++;
2234 if (readb(&prcs->var.rx_packet.next_frag_rcs_index) != 0xFF)
2235 release_frag_chain(local, prcs);
2236 return;
2237 }
2238 skb_reserve(skb, 2); /* Align IP on 16 byte (TBD check this) */
2239
624dd669 2240 pr_debug("ray_cs rx_data total_len = %x, rx_len = %x\n", total_len,
141fa61f 2241 rx_len);
1da177e4
LT		 2242
2243/************************/
141fa61f
JD		 2244 /* Reserve enough room for the whole damn packet. */
2245 rx_ptr = skb_put(skb, total_len);
2246 /* Copy the whole packet to sk_buff */
2247 rx_ptr +=
2248 copy_from_rx_buff(local, rx_ptr, pkt_addr & RX_BUFF_END, rx_len);
2249 /* Get source address */
1da177e4 2250#ifdef WIRELESS_SPY
141fa61f
JD		 2251 skb_copy_from_linear_data_offset(skb,
2252 offsetof(struct mac_header, addr_2),
2253 linksrcaddr, ETH_ALEN);
1da177e4 2254#endif
141fa61f
JD		 2255 /* Now, deal with encapsulation/translation/sniffer */
2256 if (!sniffer) {
2257 if (!translate) {
2258 /* Encapsulated ethernet, so just lop off 802.11 MAC header */
1da177e4 2259/* TBD reserve skb_reserve( skb, RX_MAC_HEADER_LENGTH); */
141fa61f
JD		 2260 skb_pull(skb, RX_MAC_HEADER_LENGTH);
2261 } else {
2262 /* Do translation */
2263 untranslate(local, skb, total_len);
2264 }
2265 } else { /* sniffer mode, so just pass whole packet */
2266 };
1da177e4
LT		 2267
2268/************************/
141fa61f
JD		 2269 /* Now pick up the rest of the fragments if any */
2270 tmp = 17;
2271 if (readb(&prcs->var.rx_packet.next_frag_rcs_index) != 0xFF) {
2272 prcslink = prcs;
624dd669 2273 pr_debug("ray_cs rx_data in fragment loop\n");
141fa61f
JD		 2274 do {
2275 prcslink = rcs_base(local)
2276 +
2277 readb(&prcslink->var.rx_packet.next_frag_rcs_index);
2278 rx_len =
2279 ((readb(&prcslink->var.rx_packet.rx_data_length[0])
2280 << 8)
2281 +
2282 readb(&prcslink->var.rx_packet.rx_data_length[1]))
2283 & RX_BUFF_END;
2284 pkt_addr =
2285 ((readb(&prcslink->var.rx_packet.rx_data_ptr[0]) <<
2286 8)
2287 + readb(&prcslink->var.rx_packet.rx_data_ptr[1]))
2288 & RX_BUFF_END;
2289
2290 rx_ptr +=
2291 copy_from_rx_buff(local, rx_ptr, pkt_addr, rx_len);
2292
2293 } while (tmp-- &&
2294 readb(&prcslink->var.rx_packet.next_frag_rcs_index) !=
2295 0xFF);
2296 release_frag_chain(local, prcs);
2297 }
2298
2299 skb->protocol = eth_type_trans(skb, dev);
2300 netif_rx(skb);
2301 local->stats.rx_packets++;
2302 local->stats.rx_bytes += total_len;
2303
2304 /* Gather signal strength per address */
1da177e4 2305#ifdef WIRELESS_SPY
141fa61f
JD		 2306 /* For the Access Point or the node having started the ad-hoc net
2307 * note : ad-hoc work only in some specific configurations, but we
2308 * kludge in ray_get_wireless_stats... */
2309 if (!memcmp(linksrcaddr, local->bss_id, ETH_ALEN)) {
2310 /* Update statistics */
2311 /*local->wstats.qual.qual = none ? */
2312 local->wstats.qual.level = siglev;
2313 /*local->wstats.qual.noise = none ? */
2314 local->wstats.qual.updated = 0x2;
2315 }
2316 /* Now, update the spy stuff */
2317 {
2318 struct iw_quality wstats;
2319 wstats.level = siglev;
2320 /* wstats.noise = none ? */
2321 /* wstats.qual = none ? */
2322 wstats.updated = 0x2;
2323 /* Update spy records */
2324 wireless_spy_update(dev, linksrcaddr, &wstats);
2325 }
2326#endif /* WIRELESS_SPY */
1da177e4 2327} /* end rx_data */
141fa61f 2328
1da177e4
LT		 2329/*===========================================================================*/
2330static void untranslate(ray_dev_t *local, struct sk_buff *skb, int len)
2331{
141fa61f
JD		 2332 snaphdr_t *psnap = (snaphdr_t *) (skb->data + RX_MAC_HEADER_LENGTH);
2333 struct ieee80211_hdr *pmac = (struct ieee80211_hdr *)skb->data;
2334 __be16 type = *(__be16 *) psnap->ethertype;
2335 int delta;
2336 struct ethhdr *peth;
2337 UCHAR srcaddr[ADDRLEN];
2338 UCHAR destaddr[ADDRLEN];
2339 static UCHAR org_bridge[3] = { 0, 0, 0xf8 };
2340 static UCHAR org_1042[3] = { 0, 0, 0 };
1da177e4 2341
141fa61f
JD		 2342 memcpy(destaddr, ieee80211_get_DA(pmac), ADDRLEN);
2343 memcpy(srcaddr, ieee80211_get_SA(pmac), ADDRLEN);
1da177e4 2344
624dd669
DB		 2345#if 0
2346 if {
ad361c98
JP		 2347 print_hex_dump(KERN_DEBUG, "skb->data before untranslate: ",
2348 DUMP_PREFIX_NONE, 16, 1,
2349 skb->data, 64, true);
2350 printk(KERN_DEBUG
141fa61f
JD		 2351 "type = %08x, xsap = %02x%02x%02x, org = %02x02x02x\n",
2352 ntohs(type), psnap->dsap, psnap->ssap, psnap->ctrl,
2353 psnap->org[0], psnap->org[1], psnap->org[2]);
2354 printk(KERN_DEBUG "untranslate skb->data = %p\n", skb->data);
2355 }
1da177e4
LT		 2356#endif
2357
141fa61f
JD		 2358 if (psnap->dsap != 0xaa || psnap->ssap != 0xaa || psnap->ctrl != 3) {
2359 /* not a snap type so leave it alone */
624dd669 2360 pr_debug("ray_cs untranslate NOT SNAP %02x %02x %02x\n",
141fa61f
JD		 2361 psnap->dsap, psnap->ssap, psnap->ctrl);
2362
2363 delta = RX_MAC_HEADER_LENGTH - ETH_HLEN;
2364 peth = (struct ethhdr *)(skb->data + delta);
2365 peth->h_proto = htons(len - RX_MAC_HEADER_LENGTH);
2366 } else { /* Its a SNAP */
2367 if (memcmp(psnap->org, org_bridge, 3) == 0) {
2368 /* EtherII and nuke the LLC */
624dd669 2369 pr_debug("ray_cs untranslate Bridge encap\n");
141fa61f
JD		 2370 delta = RX_MAC_HEADER_LENGTH
2371 + sizeof(struct snaphdr_t) - ETH_HLEN;
2372 peth = (struct ethhdr *)(skb->data + delta);
2373 peth->h_proto = type;
2374 } else if (memcmp(psnap->org, org_1042, 3) == 0) {
2375 switch (ntohs(type)) {
2376 case ETH_P_IPX:
2377 case ETH_P_AARP:
624dd669 2378 pr_debug("ray_cs untranslate RFC IPX/AARP\n");
141fa61f
JD		 2379 delta = RX_MAC_HEADER_LENGTH - ETH_HLEN;
2380 peth = (struct ethhdr *)(skb->data + delta);
2381 peth->h_proto =
2382 htons(len - RX_MAC_HEADER_LENGTH);
2383 break;
2384 default:
624dd669 2385 pr_debug("ray_cs untranslate RFC default\n");
141fa61f
JD		 2386 delta = RX_MAC_HEADER_LENGTH +
2387 sizeof(struct snaphdr_t) - ETH_HLEN;
2388 peth = (struct ethhdr *)(skb->data + delta);
2389 peth->h_proto = type;
2390 break;
2391 }
2392 } else {
2393 printk("ray_cs untranslate very confused by packet\n");
2394 delta = RX_MAC_HEADER_LENGTH - ETH_HLEN;
2395 peth = (struct ethhdr *)(skb->data + delta);
2396 peth->h_proto = type;
2397 }
7698d697 2398 }
1da177e4 2399/* TBD reserve skb_reserve(skb, delta); */
141fa61f 2400 skb_pull(skb, delta);
624dd669 2401 pr_debug("untranslate after skb_pull(%d), skb->data = %p\n", delta,
141fa61f
JD		 2402 skb->data);
2403 memcpy(peth->h_dest, destaddr, ADDRLEN);
2404 memcpy(peth->h_source, srcaddr, ADDRLEN);
624dd669
DB		 2405#if 0
2406 {
141fa61f
JD		 2407 int i;
2408 printk(KERN_DEBUG "skb->data after untranslate:");
2409 for (i = 0; i < 64; i++)
2410 printk("%02x ", skb->data[i]);
2411 printk("\n");
2412 }
1da177e4
LT		 2413#endif
2414} /* end untranslate */
141fa61f 2415
1da177e4
LT		 2416/*===========================================================================*/
2417/* Copy data from circular receive buffer to PC memory.
2418 * dest = destination address in PC memory
2419 * pkt_addr = source address in receive buffer
2420 * len = length of packet to copy
2421 */
141fa61f
JD		 2422static int copy_from_rx_buff(ray_dev_t *local, UCHAR *dest, int pkt_addr,
2423 int length)
2424{
2425 int wrap_bytes = (pkt_addr + length) - (RX_BUFF_END + 1);
2426 if (wrap_bytes <= 0) {
2427 memcpy_fromio(dest, local->rmem + pkt_addr, length);
2428 } else { /* Packet wrapped in circular buffer */
2429
2430 memcpy_fromio(dest, local->rmem + pkt_addr,
2431 length - wrap_bytes);
2432 memcpy_fromio(dest + length - wrap_bytes, local->rmem,
2433 wrap_bytes);
2434 }
2435 return length;
1da177e4 2436}
141fa61f 2437
1da177e4 2438/*===========================================================================*/
141fa61f
JD		 2439static void release_frag_chain(ray_dev_t *local, struct rcs __iomem *prcs)
2440{
2441 struct rcs __iomem *prcslink = prcs;
2442 int tmp = 17;
2443 unsigned rcsindex = readb(&prcs->var.rx_packet.next_frag_rcs_index);
2444
2445 while (tmp--) {
2446 writeb(CCS_BUFFER_FREE, &prcslink->buffer_status);
2447 if (rcsindex >= (NUMBER_OF_CCS + NUMBER_OF_RCS)) {
624dd669 2448 pr_debug("ray_cs interrupt bad rcsindex = 0x%x\n",
141fa61f
JD		 2449 rcsindex);
2450 break;
2451 }
2452 prcslink = rcs_base(local) + rcsindex;
2453 rcsindex = readb(&prcslink->var.rx_packet.next_frag_rcs_index);
2454 }
2455 writeb(CCS_BUFFER_FREE, &prcslink->buffer_status);
1da177e4 2456}
141fa61f 2457
1da177e4
LT		 2458/*===========================================================================*/
2459static void authenticate(ray_dev_t *local)
2460{
141fa61f 2461 struct pcmcia_device *link = local->finder;
624dd669 2462 dev_dbg(&link->dev, "ray_cs Starting authentication.\n");
141fa61f 2463 if (!(pcmcia_dev_present(link))) {
624dd669 2464 dev_dbg(&link->dev, "ray_cs authenticate - device not present\n");
141fa61f
JD		 2465 return;
2466 }
2467
2468 del_timer(&local->timer);
2469 if (build_auth_frame(local, local->bss_id, OPEN_AUTH_REQUEST)) {
2470 local->timer.function = &join_net;
2471 } else {
2472 local->timer.function = &authenticate_timeout;
2473 }
2474 local->timer.expires = jiffies + HZ * 2;
2475 local->timer.data = (long)local;
2476 add_timer(&local->timer);
2477 local->authentication_state = AWAITING_RESPONSE;
1da177e4 2478} /* end authenticate */
141fa61f 2479
1da177e4
LT		 2480/*===========================================================================*/
2481static void rx_authenticate(ray_dev_t *local, struct rcs __iomem *prcs,
141fa61f
JD		 2482 unsigned int pkt_addr, int rx_len)
2483{
2484 UCHAR buff[256];
2485 struct rx_msg *msg = (struct rx_msg *)buff;
2486
2487 del_timer(&local->timer);
2488
2489 copy_from_rx_buff(local, buff, pkt_addr, rx_len & 0xff);
2490 /* if we are trying to get authenticated */
2491 if (local->sparm.b4.a_network_type == ADHOC) {
624dd669 2492 pr_debug("ray_cs rx_auth var= %02x %02x %02x %02x %02x %02x\n",
141fa61f
JD		 2493 msg->var[0], msg->var[1], msg->var[2], msg->var[3],
2494 msg->var[4], msg->var[5]);
2495 if (msg->var[2] == 1) {
624dd669 2496 pr_debug("ray_cs Sending authentication response.\n");
141fa61f
JD		 2497 if (!build_auth_frame
2498 (local, msg->mac.addr_2, OPEN_AUTH_RESPONSE)) {
2499 local->authentication_state = NEED_TO_AUTH;
2500 memcpy(local->auth_id, msg->mac.addr_2,
2501 ADDRLEN);
2502 }
2503 }
2504 } else { /* Infrastructure network */
2505
2506 if (local->authentication_state == AWAITING_RESPONSE) {
2507 /* Verify authentication sequence #2 and success */
2508 if (msg->var[2] == 2) {
2509 if ((msg->var[3] | msg->var[4]) == 0) {
624dd669 2510 pr_debug("Authentication successful\n");
141fa61f
JD		 2511 local->card_status = CARD_AUTH_COMPLETE;
2512 associate(local);
2513 local->authentication_state =
2514 AUTHENTICATED;
2515 } else {
624dd669 2516 pr_debug("Authentication refused\n");
141fa61f
JD		 2517 local->card_status = CARD_AUTH_REFUSED;
2518 join_net((u_long) local);
2519 local->authentication_state =
2520 UNAUTHENTICATED;
2521 }
2522 }
2523 }
2524 }
1da177e4
LT		 2525
2526} /* end rx_authenticate */
141fa61f 2527
1da177e4
LT		 2528/*===========================================================================*/
2529static void associate(ray_dev_t *local)
2530{
141fa61f
JD		 2531 struct ccs __iomem *pccs;
2532 struct pcmcia_device *link = local->finder;
2533 struct net_device *dev = link->priv;
2534 int ccsindex;
2535 if (!(pcmcia_dev_present(link))) {
624dd669 2536 dev_dbg(&link->dev, "ray_cs associate - device not present\n");
141fa61f
JD		 2537 return;
2538 }
2539 /* If no tx buffers available, return */
2540 if ((ccsindex = get_free_ccs(local)) < 0) {
1da177e4 2541/* TBD should never be here but... what if we are? */
624dd669 2542 dev_dbg(&link->dev, "ray_cs associate - No free ccs\n");
141fa61f
JD		 2543 return;
2544 }
624dd669 2545 dev_dbg(&link->dev, "ray_cs Starting association with access point\n");
141fa61f
JD		 2546 pccs = ccs_base(local) + ccsindex;
2547 /* fill in the CCS */
2548 writeb(CCS_START_ASSOCIATION, &pccs->cmd);
2549 /* Interrupt the firmware to process the command */
2550 if (interrupt_ecf(local, ccsindex)) {
624dd669 2551 dev_dbg(&link->dev, "ray_cs associate failed - ECF not ready for intr\n");
141fa61f
JD		 2552 writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
2553
2554 del_timer(&local->timer);
2555 local->timer.expires = jiffies + HZ * 2;
2556 local->timer.data = (long)local;
2557 local->timer.function = &join_net;
2558 add_timer(&local->timer);
2559 local->card_status = CARD_ASSOC_FAILED;
2560 return;
2561 }
2562 if (!sniffer)
2563 netif_start_queue(dev);
1da177e4
LT		 2564
2565} /* end associate */
141fa61f 2566
1da177e4 2567/*===========================================================================*/
141fa61f
JD		 2568static void rx_deauthenticate(ray_dev_t *local, struct rcs __iomem *prcs,
2569 unsigned int pkt_addr, int rx_len)
1da177e4
LT		 2570{
2571/* UCHAR buff[256];
2572 struct rx_msg *msg = (struct rx_msg *)buff;
2573*/
624dd669 2574 pr_debug("Deauthentication frame received\n");
141fa61f
JD		 2575 local->authentication_state = UNAUTHENTICATED;
2576 /* Need to reauthenticate or rejoin depending on reason code */
1da177e4
LT		 2577/* copy_from_rx_buff(local, buff, pkt_addr, rx_len & 0xff);
2578 */
2579}
141fa61f 2580
1da177e4
LT		 2581/*===========================================================================*/
2582static void clear_interrupt(ray_dev_t *local)
2583{
141fa61f 2584 writeb(0, local->amem + CIS_OFFSET + HCS_INTR_OFFSET);
1da177e4 2585}
141fa61f 2586
1da177e4
LT		 2587/*===========================================================================*/
2588#ifdef CONFIG_PROC_FS
2589#define MAXDATA (PAGE_SIZE - 80)
2590
2591static char *card_status[] = {
141fa61f
JD		 2592 "Card inserted - uninitialized", /* 0 */
2593 "Card not downloaded", /* 1 */
2594 "Waiting for download parameters", /* 2 */
2595 "Card doing acquisition", /* 3 */
2596 "Acquisition complete", /* 4 */
2597 "Authentication complete", /* 5 */
2598 "Association complete", /* 6 */
2599 "???", "???", "???", "???", /* 7 8 9 10 undefined */
2600 "Card init error", /* 11 */
2601 "Download parameters error", /* 12 */
2602 "???", /* 13 */
2603 "Acquisition failed", /* 14 */
2604 "Authentication refused", /* 15 */
2605 "Association failed" /* 16 */
1da177e4
LT		 2606};
2607
141fa61f
JD		 2608static char *nettype[] = { "Adhoc", "Infra " };
2609static char *framing[] = { "Encapsulation", "Translation" }
2610
1da177e4
LT		 2611;
2612/*===========================================================================*/
6b914c52 2613static int ray_cs_proc_show(struct seq_file *m, void *v)
1da177e4
LT		 2614{
2615/* Print current values which are not available via other means
141fa61f 2616 * eg ifconfig
1da177e4 2617 */
141fa61f
JD		 2618 int i;
2619 struct pcmcia_device *link;
2620 struct net_device *dev;
2621 ray_dev_t *local;
2622 UCHAR *p;
2623 struct freq_hop_element *pfh;
2624 UCHAR c[33];
2625
2626 link = this_device;
2627 if (!link)
2628 return 0;
2629 dev = (struct net_device *)link->priv;
2630 if (!dev)
2631 return 0;
2632 local = netdev_priv(dev);
2633 if (!local)
2634 return 0;
2635
2636 seq_puts(m, "Raylink Wireless LAN driver status\n");
2637 seq_printf(m, "%s\n", rcsid);
2638 /* build 4 does not report version, and field is 0x55 after memtest */
2639 seq_puts(m, "Firmware version = ");
2640 if (local->fw_ver == 0x55)
2641 seq_puts(m, "4 - Use dump_cis for more details\n");
2642 else
2643 seq_printf(m, "%2d.%02d.%02d\n",
2644 local->fw_ver, local->fw_bld, local->fw_var);
2645
2646 for (i = 0; i < 32; i++)
2647 c[i] = local->sparm.b5.a_current_ess_id[i];
2648 c[32] = 0;
2649 seq_printf(m, "%s network ESSID = \"%s\"\n",
2650 nettype[local->sparm.b5.a_network_type], c);
2651
2652 p = local->bss_id;
2653 seq_printf(m, "BSSID = %pM\n", p);
2654
2655 seq_printf(m, "Country code = %d\n",
2656 local->sparm.b5.a_curr_country_code);
2657
2658 i = local->card_status;
2659 if (i < 0)
2660 i = 10;
2661 if (i > 16)
2662 i = 10;
2663 seq_printf(m, "Card status = %s\n", card_status[i]);
2664
2665 seq_printf(m, "Framing mode = %s\n", framing[translate]);
2666
2667 seq_printf(m, "Last pkt signal lvl = %d\n", local->last_rsl);
2668
2669 if (local->beacon_rxed) {
2670 /* Pull some fields out of last beacon received */
2671 seq_printf(m, "Beacon Interval = %d Kus\n",
2672 local->last_bcn.beacon_intvl[0]
2673 + 256 * local->last_bcn.beacon_intvl[1]);
2674
2675 p = local->last_bcn.elements;
2676 if (p[0] == C_ESSID_ELEMENT_ID)
2677 p += p[1] + 2;
2678 else {
2679 seq_printf(m,
2680 "Parse beacon failed at essid element id = %d\n",
2681 p[0]);
2682 return 0;
2683 }
2684
2685 if (p[0] == C_SUPPORTED_RATES_ELEMENT_ID) {
2686 seq_puts(m, "Supported rate codes = ");
2687 for (i = 2; i < p[1] + 2; i++)
2688 seq_printf(m, "0x%02x ", p[i]);
2689 seq_putc(m, '\n');
2690 p += p[1] + 2;
2691 } else {
2692 seq_puts(m, "Parse beacon failed at rates element\n");
2693 return 0;
2694 }
2695
2696 if (p[0] == C_FH_PARAM_SET_ELEMENT_ID) {
2697 pfh = (struct freq_hop_element *)p;
2698 seq_printf(m, "Hop dwell = %d Kus\n",
2699 pfh->dwell_time[0] +
2700 256 * pfh->dwell_time[1]);
cb01b09c 2701 seq_printf(m, "Hop set = %d\n",
141fa61f 2702 pfh->hop_set);
cb01b09c 2703 seq_printf(m, "Hop pattern = %d\n",
141fa61f 2704 pfh->hop_pattern);
cb01b09c 2705 seq_printf(m, "Hop index = %d\n",
141fa61f
JD		 2706 pfh->hop_index);
2707 p += p[1] + 2;
2708 } else {
2709 seq_puts(m,
2710 "Parse beacon failed at FH param element\n");
2711 return 0;
2712 }
2713 } else {
2714 seq_puts(m, "No beacons received\n");
1da177e4 2715 }
141fa61f 2716 return 0;
1da177e4
LT		 2717}
2718
6b914c52
AD		 2719static int ray_cs_proc_open(struct inode *inode, struct file *file)
2720{
2721 return single_open(file, ray_cs_proc_show, NULL);
2722}
2723
2724static const struct file_operations ray_cs_proc_fops = {
141fa61f
JD		 2725 .owner = THIS_MODULE,
2726 .open = ray_cs_proc_open,
2727 .read = seq_read,
2728 .llseek = seq_lseek,
2729 .release = single_release,
6b914c52 2730};
1da177e4
LT		 2731#endif
2732/*===========================================================================*/
2733static int build_auth_frame(ray_dev_t *local, UCHAR *dest, int auth_type)
2734{
141fa61f
JD		 2735 int addr;
2736 struct ccs __iomem *pccs;
2737 struct tx_msg __iomem *ptx;
2738 int ccsindex;
2739
2740 /* If no tx buffers available, return */
2741 if ((ccsindex = get_free_tx_ccs(local)) < 0) {
624dd669 2742 pr_debug("ray_cs send authenticate - No free tx ccs\n");
141fa61f
JD		 2743 return -1;
2744 }
2745
2746 pccs = ccs_base(local) + ccsindex;
2747
2748 /* Address in card space */
2749 addr = TX_BUF_BASE + (ccsindex << 11);
2750 /* fill in the CCS */
2751 writeb(CCS_TX_REQUEST, &pccs->cmd);
2752 writeb(addr >> 8, pccs->var.tx_request.tx_data_ptr);
2753 writeb(0x20, pccs->var.tx_request.tx_data_ptr + 1);
2754 writeb(TX_AUTHENTICATE_LENGTH_MSB, pccs->var.tx_request.tx_data_length);
2755 writeb(TX_AUTHENTICATE_LENGTH_LSB,
2756 pccs->var.tx_request.tx_data_length + 1);
2757 writeb(0, &pccs->var.tx_request.pow_sav_mode);
2758
2759 ptx = local->sram + addr;
2760 /* fill in the mac header */
2761 writeb(PROTOCOL_VER | AUTHENTIC_TYPE, &ptx->mac.frame_ctl_1);
2762 writeb(0, &ptx->mac.frame_ctl_2);
2763
2764 memcpy_toio(ptx->mac.addr_1, dest, ADDRLEN);
2765 memcpy_toio(ptx->mac.addr_2, local->sparm.b4.a_mac_addr, ADDRLEN);
2766 memcpy_toio(ptx->mac.addr_3, local->bss_id, ADDRLEN);
2767
2768 /* Fill in msg body with protocol 00 00, sequence 01 00 ,status 00 00 */
2769 memset_io(ptx->var, 0, 6);
2770 writeb(auth_type & 0xff, ptx->var + 2);
2771
2772 /* Interrupt the firmware to process the command */
2773 if (interrupt_ecf(local, ccsindex)) {
624dd669 2774 pr_debug(
141fa61f
JD		 2775 "ray_cs send authentication request failed - ECF not ready for intr\n");
2776 writeb(CCS_BUFFER_FREE, &(pccs++)->buffer_status);
2777 return -1;
2778 }
2779 return 0;
1da177e4
LT		 2780} /* End build_auth_frame */
2781
2782/*===========================================================================*/
2783#ifdef CONFIG_PROC_FS
83daee06
AD		 2784static ssize_t ray_cs_essid_proc_write(struct file *file,
2785 const char __user *buffer, size_t count, loff_t *pos)
1da177e4
LT		 2786{
2787 static char proc_essid[33];
575c9ed7 2788 unsigned int len = count;
1da177e4
LT		 2789
2790 if (len > 32)
2791 len = 32;
2792 memset(proc_essid, 0, 33);
2793 if (copy_from_user(proc_essid, buffer, len))
2794 return -EFAULT;
2795 essid = proc_essid;
2796 return count;
2797}
2798
83daee06
AD		 2799static const struct file_operations ray_cs_essid_proc_fops = {
2800 .owner = THIS_MODULE,
2801 .write = ray_cs_essid_proc_write,
2802};
2803
2804static ssize_t int_proc_write(struct file *file, const char __user *buffer,
2805 size_t count, loff_t *pos)
1da177e4
LT		 2806{
2807 static char proc_number[10];
2808 char *p;
2809 int nr, len;
2810
2811 if (!count)
2812 return 0;
2813
2814 if (count > 9)
2815 return -EINVAL;
2816 if (copy_from_user(proc_number, buffer, count))
2817 return -EFAULT;
2818 p = proc_number;
2819 nr = 0;
2820 len = count;
2821 do {
2822 unsigned int c = *p - '0';
2823 if (c > 9)
2824 return -EINVAL;
141fa61f 2825 nr = nr * 10 + c;
1da177e4
LT		 2826 p++;
2827 } while (--len);
83daee06 2828 *(int *)PDE(file->f_path.dentry->d_inode)->data = nr;
1da177e4
LT		 2829 return count;
2830}
83daee06
AD		 2831
2832static const struct file_operations int_proc_fops = {
2833 .owner = THIS_MODULE,
2834 .write = int_proc_write,
2835};
1da177e4
LT		 2836#endif
2837
f57ea2a2
DB		 2838static struct pcmcia_device_id ray_ids[] = {
2839 PCMCIA_DEVICE_MANF_CARD(0x01a6, 0x0000),
2840 PCMCIA_DEVICE_NULL,
2841};
141fa61f 2842
f57ea2a2
DB		 2843MODULE_DEVICE_TABLE(pcmcia, ray_ids);
2844
1da177e4 2845static struct pcmcia_driver ray_driver = {
141fa61f
JD		 2846 .owner = THIS_MODULE,
2847 .drv = {
2848 .name = "ray_cs",
2849 },
2850 .probe = ray_probe,
2851 .remove = ray_detach,
2852 .id_table = ray_ids,
2853 .suspend = ray_suspend,
2854 .resume = ray_resume,
1da177e4
LT		 2855};
2856
2857static int __init init_ray_cs(void)
2858{
141fa61f
JD		 2859 int rc;
2860
624dd669 2861 pr_debug("%s\n", rcsid);
141fa61f 2862 rc = pcmcia_register_driver(&ray_driver);
624dd669 2863 pr_debug("raylink init_module register_pcmcia_driver returns 0x%x\n",
141fa61f 2864 rc);
1da177e4
LT		 2865
2866#ifdef CONFIG_PROC_FS
141fa61f 2867 proc_mkdir("driver/ray_cs", NULL);
1da177e4 2868
141fa61f 2869 proc_create("driver/ray_cs/ray_cs", 0, NULL, &ray_cs_proc_fops);
83daee06
AD		 2870 proc_create("driver/ray_cs/essid", S_IWUSR, NULL, &ray_cs_essid_proc_fops);
2871 proc_create_data("driver/ray_cs/net_type", S_IWUSR, NULL, &int_proc_fops, &net_type);
2872 proc_create_data("driver/ray_cs/translate", S_IWUSR, NULL, &int_proc_fops, &translate);
1da177e4 2873#endif
141fa61f
JD		 2874 if (translate != 0)
2875 translate = 1;
2876 return 0;
1da177e4
LT		 2877} /* init_ray_cs */
2878
2879/*===========================================================================*/
2880
2881static void __exit exit_ray_cs(void)
2882{
624dd669 2883 pr_debug("ray_cs: cleanup_module\n");
1da177e4
LT		 2884
2885#ifdef CONFIG_PROC_FS
141fa61f
JD		 2886 remove_proc_entry("driver/ray_cs/ray_cs", NULL);
2887 remove_proc_entry("driver/ray_cs/essid", NULL);
2888 remove_proc_entry("driver/ray_cs/net_type", NULL);
2889 remove_proc_entry("driver/ray_cs/translate", NULL);
2890 remove_proc_entry("driver/ray_cs", NULL);
1da177e4
LT		 2891#endif
2892
141fa61f 2893 pcmcia_unregister_driver(&ray_driver);
1da177e4
LT		 2894} /* exit_ray_cs */
2895
2896module_init(init_ray_cs);
2897module_exit(exit_ray_cs);
2898
2899/*===========================================================================*/
Linux 6.x block layer and io_uring tree(s)