?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / net / wireless / intersil / hostap / hostap_main.c
blobde97b3304115973203664deb298d6cbdf146df74
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Host AP (software wireless LAN access point) driver for
4 * Intersil Prism2/2.5/3 - hostap.o module, common routines
5 *
6 * Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
7 * <j@w1.fi>
8 * Copyright (c) 2002-2005, Jouni Malinen <j@w1.fi>
9 */
10
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/slab.h>
14 #include <linux/proc_fs.h>
15 #include <linux/if_arp.h>
16 #include <linux/delay.h>
17 #include <linux/random.h>
18 #include <linux/workqueue.h>
19 #include <linux/kmod.h>
20 #include <linux/rtnetlink.h>
21 #include <linux/wireless.h>
22 #include <linux/etherdevice.h>
23 #include <net/net_namespace.h>
24 #include <net/iw_handler.h>
25 #include <net/lib80211.h>
26 #include <linux/uaccess.h>
27
28 #include "hostap_wlan.h"
29 #include "hostap_80211.h"
30 #include "hostap_ap.h"
31 #include "hostap.h"
32
33 MODULE_AUTHOR("Jouni Malinen");
34 MODULE_DESCRIPTION("Host AP common routines");
35 MODULE_LICENSE("GPL");
36
37 #define TX_TIMEOUT (2 * HZ)
38
39 #define PRISM2_MAX_FRAME_SIZE 2304
40 #define PRISM2_MIN_MTU 256
41 /* FIX: */
42 #define PRISM2_MAX_MTU (PRISM2_MAX_FRAME_SIZE - (6 /* LLC */ + 8 /* WEP */))
43
44
45 struct net_device * hostap_add_interface(struct local_info *local,
46 int type, int rtnl_locked,
47 const char *prefix,
48 const char *name)
49 {
50 struct net_device *dev, *mdev;
51 struct hostap_interface *iface;
52 int ret;
53
54 dev = alloc_etherdev(sizeof(struct hostap_interface));
55 if (dev == NULL)
56 return NULL;
57
58 iface = netdev_priv(dev);
59 iface->dev = dev;
60 iface->local = local;
61 iface->type = type;
62 list_add(&iface->list, &local->hostap_interfaces);
63
64 mdev = local->dev;
65 eth_hw_addr_inherit(dev, mdev);
66 dev->base_addr = mdev->base_addr;
67 dev->irq = mdev->irq;
68 dev->mem_start = mdev->mem_start;
69 dev->mem_end = mdev->mem_end;
70
71 hostap_setup_dev(dev, local, type);
72 dev->needs_free_netdev = true;
73
74 sprintf(dev->name, "%s%s", prefix, name);
75 if (!rtnl_locked)
76 rtnl_lock();
77
78 SET_NETDEV_DEV(dev, mdev->dev.parent);
79 ret = register_netdevice(dev);
80
81 if (!rtnl_locked)
82 rtnl_unlock();
83
84 if (ret < 0) {
85 printk(KERN_WARNING "%s: failed to add new netdevice!\n",
86 dev->name);
87 free_netdev(dev);
88 return NULL;
89 }
90
91 printk(KERN_DEBUG "%s: registered netdevice %s\n",
92 mdev->name, dev->name);
93
94 return dev;
95 }
96
97
98 void hostap_remove_interface(struct net_device *dev, int rtnl_locked,
99 int remove_from_list)
100 {
101 struct hostap_interface *iface;
102
103 if (!dev)
104 return;
105
106 iface = netdev_priv(dev);
107
108 if (remove_from_list) {
109 list_del(&iface->list);
110 }
111
112 if (dev == iface->local->ddev)
113 iface->local->ddev = NULL;
114 else if (dev == iface->local->apdev)
115 iface->local->apdev = NULL;
116 else if (dev == iface->local->stadev)
117 iface->local->stadev = NULL;
118
119 if (rtnl_locked)
120 unregister_netdevice(dev);
121 else
122 unregister_netdev(dev);
123
124 /* 'dev->needs_free_netdev = true' implies device data, including
125 * private data, will be freed when the device is removed */
126 }
127
128
129 static inline int prism2_wds_special_addr(u8 *addr)
130 {
131 if (addr[0] || addr[1] || addr[2] || addr[3] || addr[4] || addr[5])
132 return 0;
133
134 return 1;
135 }
136
137
138 int prism2_wds_add(local_info_t *local, u8 *remote_addr,
139 int rtnl_locked)
140 {
141 struct net_device *dev;
142 struct list_head *ptr;
143 struct hostap_interface *iface, *empty, *match;
144
145 empty = match = NULL;
146 read_lock_bh(&local->iface_lock);
147 list_for_each(ptr, &local->hostap_interfaces) {
148 iface = list_entry(ptr, struct hostap_interface, list);
149 if (iface->type != HOSTAP_INTERFACE_WDS)
150 continue;
151
152 if (prism2_wds_special_addr(iface->u.wds.remote_addr))
153 empty = iface;
154 else if (ether_addr_equal(iface->u.wds.remote_addr, remote_addr)) {
155 match = iface;
156 break;
157 }
158 }
159 if (!match && empty && !prism2_wds_special_addr(remote_addr)) {
160 /* take pre-allocated entry into use */
161 memcpy(empty->u.wds.remote_addr, remote_addr, ETH_ALEN);
162 read_unlock_bh(&local->iface_lock);
163 printk(KERN_DEBUG "%s: using pre-allocated WDS netdevice %s\n",
164 local->dev->name, empty->dev->name);
165 return 0;
166 }
167 read_unlock_bh(&local->iface_lock);
168
169 if (!prism2_wds_special_addr(remote_addr)) {
170 if (match)
171 return -EEXIST;
172 hostap_add_sta(local->ap, remote_addr);
173 }
174
175 if (local->wds_connections >= local->wds_max_connections)
176 return -ENOBUFS;
177
178 /* verify that there is room for wds# postfix in the interface name */
179 if (strlen(local->dev->name) >= IFNAMSIZ - 5) {
180 printk(KERN_DEBUG "'%s' too long base device name\n",
181 local->dev->name);
182 return -EINVAL;
183 }
184
185 dev = hostap_add_interface(local, HOSTAP_INTERFACE_WDS, rtnl_locked,
186 local->ddev->name, "wds%d");
187 if (dev == NULL)
188 return -ENOMEM;
189
190 iface = netdev_priv(dev);
191 memcpy(iface->u.wds.remote_addr, remote_addr, ETH_ALEN);
192
193 local->wds_connections++;
194
195 return 0;
196 }
197
198
199 int prism2_wds_del(local_info_t *local, u8 *remote_addr,
200 int rtnl_locked, int do_not_remove)
201 {
202 unsigned long flags;
203 struct list_head *ptr;
204 struct hostap_interface *iface, *selected = NULL;
205
206 write_lock_irqsave(&local->iface_lock, flags);
207 list_for_each(ptr, &local->hostap_interfaces) {
208 iface = list_entry(ptr, struct hostap_interface, list);
209 if (iface->type != HOSTAP_INTERFACE_WDS)
210 continue;
211
212 if (ether_addr_equal(iface->u.wds.remote_addr, remote_addr)) {
213 selected = iface;
214 break;
215 }
216 }
217 if (selected && !do_not_remove)
218 list_del(&selected->list);
219 write_unlock_irqrestore(&local->iface_lock, flags);
220
221 if (selected) {
222 if (do_not_remove)
223 eth_zero_addr(selected->u.wds.remote_addr);
224 else {
225 hostap_remove_interface(selected->dev, rtnl_locked, 0);
226 local->wds_connections--;
227 }
228 }
229
230 return selected ? 0 : -ENODEV;
231 }
232
233
234 u16 hostap_tx_callback_register(local_info_t *local,
235 void (*func)(struct sk_buff *, int ok, void *),
236 void *data)
237 {
238 unsigned long flags;
239 struct hostap_tx_callback_info *entry;
240
241 entry = kmalloc(sizeof(*entry), GFP_KERNEL);
242 if (entry == NULL)
243 return 0;
244
245 entry->func = func;
246 entry->data = data;
247
248 spin_lock_irqsave(&local->lock, flags);
249 entry->idx = local->tx_callback ? local->tx_callback->idx + 1 : 1;
250 entry->next = local->tx_callback;
251 local->tx_callback = entry;
252 spin_unlock_irqrestore(&local->lock, flags);
253
254 return entry->idx;
255 }
256
257
258 int hostap_tx_callback_unregister(local_info_t *local, u16 idx)
259 {
260 unsigned long flags;
261 struct hostap_tx_callback_info *cb, *prev = NULL;
262
263 spin_lock_irqsave(&local->lock, flags);
264 cb = local->tx_callback;
265 while (cb != NULL && cb->idx != idx) {
266 prev = cb;
267 cb = cb->next;
268 }
269 if (cb) {
270 if (prev == NULL)
271 local->tx_callback = cb->next;
272 else
273 prev->next = cb->next;
274 kfree(cb);
275 }
276 spin_unlock_irqrestore(&local->lock, flags);
277
278 return cb ? 0 : -1;
279 }
280
281
282 /* val is in host byte order */
283 int hostap_set_word(struct net_device *dev, int rid, u16 val)
284 {
285 struct hostap_interface *iface;
286 __le16 tmp = cpu_to_le16(val);
287 iface = netdev_priv(dev);
288 return iface->local->func->set_rid(dev, rid, &tmp, 2);
289 }
290
291
292 int hostap_set_string(struct net_device *dev, int rid, const char *val)
293 {
294 struct hostap_interface *iface;
295 char buf[MAX_SSID_LEN + 2];
296 int len;
297
298 iface = netdev_priv(dev);
299 len = strlen(val);
300 if (len > MAX_SSID_LEN)
301 return -1;
302 memset(buf, 0, sizeof(buf));
303 buf[0] = len; /* little endian 16 bit word */
304 memcpy(buf + 2, val, len);
305
306 return iface->local->func->set_rid(dev, rid, &buf, MAX_SSID_LEN + 2);
307 }
308
309
310 u16 hostap_get_porttype(local_info_t *local)
311 {
312 if (local->iw_mode == IW_MODE_ADHOC && local->pseudo_adhoc)
313 return HFA384X_PORTTYPE_PSEUDO_IBSS;
314 if (local->iw_mode == IW_MODE_ADHOC)
315 return HFA384X_PORTTYPE_IBSS;
316 if (local->iw_mode == IW_MODE_INFRA)
317 return HFA384X_PORTTYPE_BSS;
318 if (local->iw_mode == IW_MODE_REPEAT)
319 return HFA384X_PORTTYPE_WDS;
320 if (local->iw_mode == IW_MODE_MONITOR)
321 return HFA384X_PORTTYPE_PSEUDO_IBSS;
322 return HFA384X_PORTTYPE_HOSTAP;
323 }
324
325
326 int hostap_set_encryption(local_info_t *local)
327 {
328 u16 val, old_val;
329 int i, keylen, len, idx;
330 char keybuf[WEP_KEY_LEN + 1];
331 enum { NONE, WEP, OTHER } encrypt_type;
332
333 idx = local->crypt_info.tx_keyidx;
334 if (local->crypt_info.crypt[idx] == NULL ||
335 local->crypt_info.crypt[idx]->ops == NULL)
336 encrypt_type = NONE;
337 else if (strcmp(local->crypt_info.crypt[idx]->ops->name, "WEP") == 0)
338 encrypt_type = WEP;
339 else
340 encrypt_type = OTHER;
341
342 if (local->func->get_rid(local->dev, HFA384X_RID_CNFWEPFLAGS, &val, 2,
343 1) < 0) {
344 printk(KERN_DEBUG "Could not read current WEP flags.\n");
345 goto fail;
346 }
347 le16_to_cpus(&val);
348 old_val = val;
349
350 if (encrypt_type != NONE || local->privacy_invoked)
351 val |= HFA384X_WEPFLAGS_PRIVACYINVOKED;
352 else
353 val &= ~HFA384X_WEPFLAGS_PRIVACYINVOKED;
354
355 if (local->open_wep || encrypt_type == NONE ||
356 ((local->ieee_802_1x || local->wpa) && local->host_decrypt))
357 val &= ~HFA384X_WEPFLAGS_EXCLUDEUNENCRYPTED;
358 else
359 val |= HFA384X_WEPFLAGS_EXCLUDEUNENCRYPTED;
360
361 if ((encrypt_type != NONE || local->privacy_invoked) &&
362 (encrypt_type == OTHER || local->host_encrypt))
363 val |= HFA384X_WEPFLAGS_HOSTENCRYPT;
364 else
365 val &= ~HFA384X_WEPFLAGS_HOSTENCRYPT;
366 if ((encrypt_type != NONE || local->privacy_invoked) &&
367 (encrypt_type == OTHER || local->host_decrypt))
368 val |= HFA384X_WEPFLAGS_HOSTDECRYPT;
369 else
370 val &= ~HFA384X_WEPFLAGS_HOSTDECRYPT;
371
372 if (val != old_val &&
373 hostap_set_word(local->dev, HFA384X_RID_CNFWEPFLAGS, val)) {
374 printk(KERN_DEBUG "Could not write new WEP flags (0x%x)\n",
375 val);
376 goto fail;
377 }
378
379 if (encrypt_type != WEP)
380 return 0;
381
382 /* 104-bit support seems to require that all the keys are set to the
383 * same keylen */
384 keylen = 6; /* first 5 octets */
385 len = local->crypt_info.crypt[idx]->ops->get_key(keybuf, sizeof(keybuf), NULL,
386 local->crypt_info.crypt[idx]->priv);
387 if (idx >= 0 && idx < WEP_KEYS && len > 5)
388 keylen = WEP_KEY_LEN + 1; /* first 13 octets */
389
390 for (i = 0; i < WEP_KEYS; i++) {
391 memset(keybuf, 0, sizeof(keybuf));
392 if (local->crypt_info.crypt[i]) {
393 (void) local->crypt_info.crypt[i]->ops->get_key(
394 keybuf, sizeof(keybuf),
395 NULL, local->crypt_info.crypt[i]->priv);
396 }
397 if (local->func->set_rid(local->dev,
398 HFA384X_RID_CNFDEFAULTKEY0 + i,
399 keybuf, keylen)) {
400 printk(KERN_DEBUG "Could not set key %d (len=%d)\n",
401 i, keylen);
402 goto fail;
403 }
404 }
405 if (hostap_set_word(local->dev, HFA384X_RID_CNFWEPDEFAULTKEYID, idx)) {
406 printk(KERN_DEBUG "Could not set default keyid %d\n", idx);
407 goto fail;
408 }
409
410 return 0;
411
412 fail:
413 printk(KERN_DEBUG "%s: encryption setup failed\n", local->dev->name);
414 return -1;
415 }
416
417
418 int hostap_set_antsel(local_info_t *local)
419 {
420 u16 val;
421 int ret = 0;
422
423 if (local->antsel_tx != HOSTAP_ANTSEL_DO_NOT_TOUCH &&
424 local->func->cmd(local->dev, HFA384X_CMDCODE_READMIF,
425 HFA386X_CR_TX_CONFIGURE,
426 NULL, &val) == 0) {
427 val &= ~(BIT(2) | BIT(1));
428 switch (local->antsel_tx) {
429 case HOSTAP_ANTSEL_DIVERSITY:
430 val |= BIT(1);
431 break;
432 case HOSTAP_ANTSEL_LOW:
433 break;
434 case HOSTAP_ANTSEL_HIGH:
435 val |= BIT(2);
436 break;
437 }
438
439 if (local->func->cmd(local->dev, HFA384X_CMDCODE_WRITEMIF,
440 HFA386X_CR_TX_CONFIGURE, &val, NULL)) {
441 printk(KERN_INFO "%s: setting TX AntSel failed\n",
442 local->dev->name);
443 ret = -1;
444 }
445 }
446
447 if (local->antsel_rx != HOSTAP_ANTSEL_DO_NOT_TOUCH &&
448 local->func->cmd(local->dev, HFA384X_CMDCODE_READMIF,
449 HFA386X_CR_RX_CONFIGURE,
450 NULL, &val) == 0) {
451 val &= ~(BIT(1) | BIT(0));
452 switch (local->antsel_rx) {
453 case HOSTAP_ANTSEL_DIVERSITY:
454 break;
455 case HOSTAP_ANTSEL_LOW:
456 val |= BIT(0);
457 break;
458 case HOSTAP_ANTSEL_HIGH:
459 val |= BIT(0) | BIT(1);
460 break;
461 }
462
463 if (local->func->cmd(local->dev, HFA384X_CMDCODE_WRITEMIF,
464 HFA386X_CR_RX_CONFIGURE, &val, NULL)) {
465 printk(KERN_INFO "%s: setting RX AntSel failed\n",
466 local->dev->name);
467 ret = -1;
468 }
469 }
470
471 return ret;
472 }
473
474
475 int hostap_set_roaming(local_info_t *local)
476 {
477 u16 val;
478
479 switch (local->host_roaming) {
480 case 1:
481 val = HFA384X_ROAMING_HOST;
482 break;
483 case 2:
484 val = HFA384X_ROAMING_DISABLED;
485 break;
486 case 0:
487 default:
488 val = HFA384X_ROAMING_FIRMWARE;
489 break;
490 }
491
492 return hostap_set_word(local->dev, HFA384X_RID_CNFROAMINGMODE, val);
493 }
494
495
496 int hostap_set_auth_algs(local_info_t *local)
497 {
498 int val = local->auth_algs;
499 /* At least STA f/w v0.6.2 seems to have issues with cnfAuthentication
500 * set to include both Open and Shared Key flags. It tries to use
501 * Shared Key authentication in that case even if WEP keys are not
502 * configured.. STA f/w v0.7.6 is able to handle such configuration,
503 * but it is unknown when this was fixed between 0.6.2 .. 0.7.6. */
504 if (local->sta_fw_ver < PRISM2_FW_VER(0,7,0) &&
505 val != PRISM2_AUTH_OPEN && val != PRISM2_AUTH_SHARED_KEY)
506 val = PRISM2_AUTH_OPEN;
507
508 if (hostap_set_word(local->dev, HFA384X_RID_CNFAUTHENTICATION, val)) {
509 printk(KERN_INFO "%s: cnfAuthentication setting to 0x%x "
510 "failed\n", local->dev->name, local->auth_algs);
511 return -EINVAL;
512 }
513
514 return 0;
515 }
516
517
518 void hostap_dump_rx_header(const char *name, const struct hfa384x_rx_frame *rx)
519 {
520 u16 status, fc;
521
522 status = __le16_to_cpu(rx->status);
523
524 printk(KERN_DEBUG "%s: RX status=0x%04x (port=%d, type=%d, "
525 "fcserr=%d) silence=%d signal=%d rate=%d rxflow=%d; "
526 "jiffies=%ld\n",
527 name, status, (status >> 8) & 0x07, status >> 13, status & 1,
528 rx->silence, rx->signal, rx->rate, rx->rxflow, jiffies);
529
530 fc = __le16_to_cpu(rx->frame_control);
531 printk(KERN_DEBUG " FC=0x%04x (type=%d:%d) dur=0x%04x seq=0x%04x "
532 "data_len=%d%s%s\n",
533 fc, (fc & IEEE80211_FCTL_FTYPE) >> 2,
534 (fc & IEEE80211_FCTL_STYPE) >> 4,
535 __le16_to_cpu(rx->duration_id), __le16_to_cpu(rx->seq_ctrl),
536 __le16_to_cpu(rx->data_len),
537 fc & IEEE80211_FCTL_TODS ? " [ToDS]" : "",
538 fc & IEEE80211_FCTL_FROMDS ? " [FromDS]" : "");
539
540 printk(KERN_DEBUG " A1=%pM A2=%pM A3=%pM A4=%pM\n",
541 rx->addr1, rx->addr2, rx->addr3, rx->addr4);
542
543 printk(KERN_DEBUG " dst=%pM src=%pM len=%d\n",
544 rx->dst_addr, rx->src_addr,
545 __be16_to_cpu(rx->len));
546 }
547
548
549 void hostap_dump_tx_header(const char *name, const struct hfa384x_tx_frame *tx)
550 {
551 u16 fc;
552
553 printk(KERN_DEBUG "%s: TX status=0x%04x retry_count=%d tx_rate=%d "
554 "tx_control=0x%04x; jiffies=%ld\n",
555 name, __le16_to_cpu(tx->status), tx->retry_count, tx->tx_rate,
556 __le16_to_cpu(tx->tx_control), jiffies);
557
558 fc = __le16_to_cpu(tx->frame_control);
559 printk(KERN_DEBUG " FC=0x%04x (type=%d:%d) dur=0x%04x seq=0x%04x "
560 "data_len=%d%s%s\n",
561 fc, (fc & IEEE80211_FCTL_FTYPE) >> 2,
562 (fc & IEEE80211_FCTL_STYPE) >> 4,
563 __le16_to_cpu(tx->duration_id), __le16_to_cpu(tx->seq_ctrl),
564 __le16_to_cpu(tx->data_len),
565 fc & IEEE80211_FCTL_TODS ? " [ToDS]" : "",
566 fc & IEEE80211_FCTL_FROMDS ? " [FromDS]" : "");
567
568 printk(KERN_DEBUG " A1=%pM A2=%pM A3=%pM A4=%pM\n",
569 tx->addr1, tx->addr2, tx->addr3, tx->addr4);
570
571 printk(KERN_DEBUG " dst=%pM src=%pM len=%d\n",
572 tx->dst_addr, tx->src_addr,
573 __be16_to_cpu(tx->len));
574 }
575
576
577 static int hostap_80211_header_parse(const struct sk_buff *skb,
578 unsigned char *haddr)
579 {
580 memcpy(haddr, skb_mac_header(skb) + 10, ETH_ALEN); /* addr2 */
581 return ETH_ALEN;
582 }
583
584
585 int hostap_80211_get_hdrlen(__le16 fc)
586 {
587 if (ieee80211_is_data(fc) && ieee80211_has_a4 (fc))
588 return 30; /* Addr4 */
589 else if (ieee80211_is_cts(fc) || ieee80211_is_ack(fc))
590 return 10;
591 else if (ieee80211_is_ctl(fc))
592 return 16;
593
594 return 24;
595 }
596
597
598 static int prism2_close(struct net_device *dev)
599 {
600 struct hostap_interface *iface;
601 local_info_t *local;
602
603 PDEBUG(DEBUG_FLOW, "%s: prism2_close\n", dev->name);
604
605 iface = netdev_priv(dev);
606 local = iface->local;
607
608 if (dev == local->ddev) {
609 prism2_sta_deauth(local, WLAN_REASON_DEAUTH_LEAVING);
610 }
611 #ifndef PRISM2_NO_KERNEL_IEEE80211_MGMT
612 if (!local->hostapd && dev == local->dev &&
613 (!local->func->card_present || local->func->card_present(local)) &&
614 local->hw_ready && local->ap && local->iw_mode == IW_MODE_MASTER)
615 hostap_deauth_all_stas(dev, local->ap, 1);
616 #endif /* PRISM2_NO_KERNEL_IEEE80211_MGMT */
617
618 if (dev == local->dev) {
619 local->func->hw_shutdown(dev, HOSTAP_HW_ENABLE_CMDCOMPL);
620 }
621
622 if (netif_running(dev)) {
623 netif_stop_queue(dev);
624 netif_device_detach(dev);
625 }
626
627 cancel_work_sync(&local->reset_queue);
628 cancel_work_sync(&local->set_multicast_list_queue);
629 cancel_work_sync(&local->set_tim_queue);
630 #ifndef PRISM2_NO_STATION_MODES
631 cancel_work_sync(&local->info_queue);
632 #endif
633 cancel_work_sync(&local->comms_qual_update);
634
635 module_put(local->hw_module);
636
637 local->num_dev_open--;
638
639 if (dev != local->dev && local->dev->flags & IFF_UP &&
640 local->master_dev_auto_open && local->num_dev_open == 1) {
641 /* Close master radio interface automatically if it was also
642 * opened automatically and we are now closing the last
643 * remaining non-master device. */
644 dev_close(local->dev);
645 }
646
647 return 0;
648 }
649
650
651 static int prism2_open(struct net_device *dev)
652 {
653 struct hostap_interface *iface;
654 local_info_t *local;
655
656 PDEBUG(DEBUG_FLOW, "%s: prism2_open\n", dev->name);
657
658 iface = netdev_priv(dev);
659 local = iface->local;
660
661 if (local->no_pri) {
662 printk(KERN_DEBUG "%s: could not set interface UP - no PRI "
663 "f/w\n", dev->name);
664 return -ENODEV;
665 }
666
667 if ((local->func->card_present && !local->func->card_present(local)) ||
668 local->hw_downloading)
669 return -ENODEV;
670
671 if (!try_module_get(local->hw_module))
672 return -ENODEV;
673 local->num_dev_open++;
674
675 if (!local->dev_enabled && local->func->hw_enable(dev, 1)) {
676 printk(KERN_WARNING "%s: could not enable MAC port\n",
677 dev->name);
678 prism2_close(dev);
679 return -ENODEV;
680 }
681 if (!local->dev_enabled)
682 prism2_callback(local, PRISM2_CALLBACK_ENABLE);
683 local->dev_enabled = 1;
684
685 if (dev != local->dev && !(local->dev->flags & IFF_UP)) {
686 /* Master radio interface is needed for all operation, so open
687 * it automatically when any virtual net_device is opened. */
688 local->master_dev_auto_open = 1;
689 dev_open(local->dev, NULL);
690 }
691
692 netif_device_attach(dev);
693 netif_start_queue(dev);
694
695 return 0;
696 }
697
698
699 static int prism2_set_mac_address(struct net_device *dev, void *p)
700 {
701 struct hostap_interface *iface;
702 local_info_t *local;
703 struct list_head *ptr;
704 struct sockaddr *addr = p;
705
706 iface = netdev_priv(dev);
707 local = iface->local;
708
709 if (local->func->set_rid(dev, HFA384X_RID_CNFOWNMACADDR, addr->sa_data,
710 ETH_ALEN) < 0 || local->func->reset_port(dev))
711 return -EINVAL;
712
713 read_lock_bh(&local->iface_lock);
714 list_for_each(ptr, &local->hostap_interfaces) {
715 iface = list_entry(ptr, struct hostap_interface, list);
716 memcpy(iface->dev->dev_addr, addr->sa_data, ETH_ALEN);
717 }
718 memcpy(local->dev->dev_addr, addr->sa_data, ETH_ALEN);
719 read_unlock_bh(&local->iface_lock);
720
721 return 0;
722 }
723
724
725 /* TODO: to be further implemented as soon as Prism2 fully supports
726 * GroupAddresses and correct documentation is available */
727 void hostap_set_multicast_list_queue(struct work_struct *work)
728 {
729 local_info_t *local =
730 container_of(work, local_info_t, set_multicast_list_queue);
731 struct net_device *dev = local->dev;
732
733 if (hostap_set_word(dev, HFA384X_RID_PROMISCUOUSMODE,
734 local->is_promisc)) {
735 printk(KERN_INFO "%s: %sabling promiscuous mode failed\n",
736 dev->name, local->is_promisc ? "en" : "dis");
737 }
738 }
739
740
741 static void hostap_set_multicast_list(struct net_device *dev)
742 {
743 #if 0
744 /* FIX: promiscuous mode seems to be causing a lot of problems with
745 * some station firmware versions (FCSErr frames, invalid MACPort, etc.
746 * corrupted incoming frames). This code is now commented out while the
747 * problems are investigated. */
748 struct hostap_interface *iface;
749 local_info_t *local;
750
751 iface = netdev_priv(dev);
752 local = iface->local;
753 if ((dev->flags & IFF_ALLMULTI) || (dev->flags & IFF_PROMISC)) {
754 local->is_promisc = 1;
755 } else {
756 local->is_promisc = 0;
757 }
758
759 schedule_work(&local->set_multicast_list_queue);
760 #endif
761 }
762
763
764 static void prism2_tx_timeout(struct net_device *dev, unsigned int txqueue)
765 {
766 struct hostap_interface *iface;
767 local_info_t *local;
768 struct hfa384x_regs regs;
769
770 iface = netdev_priv(dev);
771 local = iface->local;
772
773 printk(KERN_WARNING "%s Tx timed out! Resetting card\n", dev->name);
774 netif_stop_queue(local->dev);
775
776 local->func->read_regs(dev, &regs);
777 printk(KERN_DEBUG "%s: CMD=%04x EVSTAT=%04x "
778 "OFFSET0=%04x OFFSET1=%04x SWSUPPORT0=%04x\n",
779 dev->name, regs.cmd, regs.evstat, regs.offset0, regs.offset1,
780 regs.swsupport0);
781
782 local->func->schedule_reset(local);
783 }
784
785 const struct header_ops hostap_80211_ops = {
786 .create = eth_header,
787 .cache = eth_header_cache,
788 .cache_update = eth_header_cache_update,
789 .parse = hostap_80211_header_parse,
790 };
791 EXPORT_SYMBOL(hostap_80211_ops);
792
793
794 static const struct net_device_ops hostap_netdev_ops = {
795 .ndo_start_xmit = hostap_data_start_xmit,
796
797 .ndo_open = prism2_open,
798 .ndo_stop = prism2_close,
799 .ndo_do_ioctl = hostap_ioctl,
800 .ndo_set_mac_address = prism2_set_mac_address,
801 .ndo_set_rx_mode = hostap_set_multicast_list,
802 .ndo_tx_timeout = prism2_tx_timeout,
803 .ndo_validate_addr = eth_validate_addr,
804 };
805
806 static const struct net_device_ops hostap_mgmt_netdev_ops = {
807 .ndo_start_xmit = hostap_mgmt_start_xmit,
808
809 .ndo_open = prism2_open,
810 .ndo_stop = prism2_close,
811 .ndo_do_ioctl = hostap_ioctl,
812 .ndo_set_mac_address = prism2_set_mac_address,
813 .ndo_set_rx_mode = hostap_set_multicast_list,
814 .ndo_tx_timeout = prism2_tx_timeout,
815 .ndo_validate_addr = eth_validate_addr,
816 };
817
818 static const struct net_device_ops hostap_master_ops = {
819 .ndo_start_xmit = hostap_master_start_xmit,
820
821 .ndo_open = prism2_open,
822 .ndo_stop = prism2_close,
823 .ndo_do_ioctl = hostap_ioctl,
824 .ndo_set_mac_address = prism2_set_mac_address,
825 .ndo_set_rx_mode = hostap_set_multicast_list,
826 .ndo_tx_timeout = prism2_tx_timeout,
827 .ndo_validate_addr = eth_validate_addr,
828 };
829
830 void hostap_setup_dev(struct net_device *dev, local_info_t *local,
831 int type)
832 {
833 struct hostap_interface *iface;
834
835 iface = netdev_priv(dev);
836 ether_setup(dev);
837 dev->min_mtu = PRISM2_MIN_MTU;
838 dev->max_mtu = PRISM2_MAX_MTU;
839 dev->priv_flags &= ~IFF_TX_SKB_SHARING;
840
841 /* kernel callbacks */
842 if (iface) {
843 /* Currently, we point to the proper spy_data only on
844 * the main_dev. This could be fixed. Jean II */
845 iface->wireless_data.spy_data = &iface->spy_data;
846 dev->wireless_data = &iface->wireless_data;
847 }
848 dev->wireless_handlers = &hostap_iw_handler_def;
849 dev->watchdog_timeo = TX_TIMEOUT;
850
851 switch(type) {
852 case HOSTAP_INTERFACE_AP:
853 dev->priv_flags |= IFF_NO_QUEUE; /* use main radio device queue */
854 dev->netdev_ops = &hostap_mgmt_netdev_ops;
855 dev->type = ARPHRD_IEEE80211;
856 dev->header_ops = &hostap_80211_ops;
857 break;
858 case HOSTAP_INTERFACE_MASTER:
859 dev->netdev_ops = &hostap_master_ops;
860 break;
861 default:
862 dev->priv_flags |= IFF_NO_QUEUE; /* use main radio device queue */
863 dev->netdev_ops = &hostap_netdev_ops;
864 }
865
866 dev->mtu = local->mtu;
867
868
869 dev->ethtool_ops = &prism2_ethtool_ops;
870
871 }
872
873 static int hostap_enable_hostapd(local_info_t *local, int rtnl_locked)
874 {
875 struct net_device *dev = local->dev;
876
877 if (local->apdev)
878 return -EEXIST;
879
880 printk(KERN_DEBUG "%s: enabling hostapd mode\n", dev->name);
881
882 local->apdev = hostap_add_interface(local, HOSTAP_INTERFACE_AP,
883 rtnl_locked, local->ddev->name,
884 "ap");
885 if (local->apdev == NULL)
886 return -ENOMEM;
887
888 return 0;
889 }
890
891
892 static int hostap_disable_hostapd(local_info_t *local, int rtnl_locked)
893 {
894 struct net_device *dev = local->dev;
895
896 printk(KERN_DEBUG "%s: disabling hostapd mode\n", dev->name);
897
898 hostap_remove_interface(local->apdev, rtnl_locked, 1);
899 local->apdev = NULL;
900
901 return 0;
902 }
903
904
905 static int hostap_enable_hostapd_sta(local_info_t *local, int rtnl_locked)
906 {
907 struct net_device *dev = local->dev;
908
909 if (local->stadev)
910 return -EEXIST;
911
912 printk(KERN_DEBUG "%s: enabling hostapd STA mode\n", dev->name);
913
914 local->stadev = hostap_add_interface(local, HOSTAP_INTERFACE_STA,
915 rtnl_locked, local->ddev->name,
916 "sta");
917 if (local->stadev == NULL)
918 return -ENOMEM;
919
920 return 0;
921 }
922
923
924 static int hostap_disable_hostapd_sta(local_info_t *local, int rtnl_locked)
925 {
926 struct net_device *dev = local->dev;
927
928 printk(KERN_DEBUG "%s: disabling hostapd mode\n", dev->name);
929
930 hostap_remove_interface(local->stadev, rtnl_locked, 1);
931 local->stadev = NULL;
932
933 return 0;
934 }
935
936
937 int hostap_set_hostapd(local_info_t *local, int val, int rtnl_locked)
938 {
939 int ret;
940
941 if (val < 0 || val > 1)
942 return -EINVAL;
943
944 if (local->hostapd == val)
945 return 0;
946
947 if (val) {
948 ret = hostap_enable_hostapd(local, rtnl_locked);
949 if (ret == 0)
950 local->hostapd = 1;
951 } else {
952 local->hostapd = 0;
953 ret = hostap_disable_hostapd(local, rtnl_locked);
954 if (ret != 0)
955 local->hostapd = 1;
956 }
957
958 return ret;
959 }
960
961
962 int hostap_set_hostapd_sta(local_info_t *local, int val, int rtnl_locked)
963 {
964 int ret;
965
966 if (val < 0 || val > 1)
967 return -EINVAL;
968
969 if (local->hostapd_sta == val)
970 return 0;
971
972 if (val) {
973 ret = hostap_enable_hostapd_sta(local, rtnl_locked);
974 if (ret == 0)
975 local->hostapd_sta = 1;
976 } else {
977 local->hostapd_sta = 0;
978 ret = hostap_disable_hostapd_sta(local, rtnl_locked);
979 if (ret != 0)
980 local->hostapd_sta = 1;
981 }
982
983
984 return ret;
985 }
986
987
988 int prism2_update_comms_qual(struct net_device *dev)
989 {
990 struct hostap_interface *iface;
991 local_info_t *local;
992 int ret = 0;
993 struct hfa384x_comms_quality sq;
994
995 iface = netdev_priv(dev);
996 local = iface->local;
997 if (!local->sta_fw_ver)
998 ret = -1;
999 else if (local->sta_fw_ver >= PRISM2_FW_VER(1,3,1)) {
1000 if (local->func->get_rid(local->dev,
1001 HFA384X_RID_DBMCOMMSQUALITY,
1002 &sq, sizeof(sq), 1) >= 0) {
1003 local->comms_qual = (s16) le16_to_cpu(sq.comm_qual);
1004 local->avg_signal = (s16) le16_to_cpu(sq.signal_level);
1005 local->avg_noise = (s16) le16_to_cpu(sq.noise_level);
1006 local->last_comms_qual_update = jiffies;
1007 } else
1008 ret = -1;
1009 } else {
1010 if (local->func->get_rid(local->dev, HFA384X_RID_COMMSQUALITY,
1011 &sq, sizeof(sq), 1) >= 0) {
1012 local->comms_qual = le16_to_cpu(sq.comm_qual);
1013 local->avg_signal = HFA384X_LEVEL_TO_dBm(
1014 le16_to_cpu(sq.signal_level));
1015 local->avg_noise = HFA384X_LEVEL_TO_dBm(
1016 le16_to_cpu(sq.noise_level));
1017 local->last_comms_qual_update = jiffies;
1018 } else
1019 ret = -1;
1020 }
1021
1022 return ret;
1023 }
1024
1025
1026 int prism2_sta_send_mgmt(local_info_t *local, u8 *dst, u16 stype,
1027 u8 *body, size_t bodylen)
1028 {
1029 struct sk_buff *skb;
1030 struct hostap_ieee80211_mgmt *mgmt;
1031 struct hostap_skb_tx_data *meta;
1032 struct net_device *dev = local->dev;
1033
1034 skb = dev_alloc_skb(IEEE80211_MGMT_HDR_LEN + bodylen);
1035 if (skb == NULL)
1036 return -ENOMEM;
1037
1038 mgmt = skb_put_zero(skb, IEEE80211_MGMT_HDR_LEN);
1039 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
1040 memcpy(mgmt->da, dst, ETH_ALEN);
1041 memcpy(mgmt->sa, dev->dev_addr, ETH_ALEN);
1042 memcpy(mgmt->bssid, dst, ETH_ALEN);
1043 if (body)
1044 skb_put_data(skb, body, bodylen);
1045
1046 meta = (struct hostap_skb_tx_data *) skb->cb;
1047 memset(meta, 0, sizeof(*meta));
1048 meta->magic = HOSTAP_SKB_TX_DATA_MAGIC;
1049 meta->iface = netdev_priv(dev);
1050
1051 skb->dev = dev;
1052 skb_reset_mac_header(skb);
1053 skb_reset_network_header(skb);
1054 dev_queue_xmit(skb);
1055
1056 return 0;
1057 }
1058
1059
1060 int prism2_sta_deauth(local_info_t *local, u16 reason)
1061 {
1062 union iwreq_data wrqu;
1063 int ret;
1064 __le16 val = cpu_to_le16(reason);
1065
1066 if (local->iw_mode != IW_MODE_INFRA ||
1067 is_zero_ether_addr(local->bssid) ||
1068 ether_addr_equal(local->bssid, "\x44\x44\x44\x44\x44\x44"))
1069 return 0;
1070
1071 ret = prism2_sta_send_mgmt(local, local->bssid, IEEE80211_STYPE_DEAUTH,
1072 (u8 *) &val, 2);
1073 eth_zero_addr(wrqu.ap_addr.sa_data);
1074 wireless_send_event(local->dev, SIOCGIWAP, &wrqu, NULL);
1075 return ret;
1076 }
1077
1078
1079 struct proc_dir_entry *hostap_proc;
1080
1081 static int __init hostap_init(void)
1082 {
1083 if (init_net.proc_net != NULL) {
1084 hostap_proc = proc_mkdir("hostap", init_net.proc_net);
1085 if (!hostap_proc)
1086 printk(KERN_WARNING "Failed to mkdir "
1087 "/proc/net/hostap\n");
1088 } else
1089 hostap_proc = NULL;
1090
1091 return 0;
1092 }
1093
1094
1095 static void __exit hostap_exit(void)
1096 {
1097 if (hostap_proc != NULL) {
1098 hostap_proc = NULL;
1099 remove_proc_entry("hostap", init_net.proc_net);
1100 }
1101 }
1102
1103
1104 EXPORT_SYMBOL(hostap_set_word);
1105 EXPORT_SYMBOL(hostap_set_string);
1106 EXPORT_SYMBOL(hostap_get_porttype);
1107 EXPORT_SYMBOL(hostap_set_encryption);
1108 EXPORT_SYMBOL(hostap_set_antsel);
1109 EXPORT_SYMBOL(hostap_set_roaming);
1110 EXPORT_SYMBOL(hostap_set_auth_algs);
1111 EXPORT_SYMBOL(hostap_dump_rx_header);
1112 EXPORT_SYMBOL(hostap_dump_tx_header);
1113 EXPORT_SYMBOL(hostap_80211_get_hdrlen);
1114 EXPORT_SYMBOL(hostap_setup_dev);
1115 EXPORT_SYMBOL(hostap_set_multicast_list_queue);
1116 EXPORT_SYMBOL(hostap_set_hostapd);
1117 EXPORT_SYMBOL(hostap_set_hostapd_sta);
1118 EXPORT_SYMBOL(hostap_add_interface);
1119 EXPORT_SYMBOL(hostap_remove_interface);
1120 EXPORT_SYMBOL(prism2_update_comms_qual);
1121
1122 module_init(hostap_init);
1123 module_exit(hostap_exit);
Linux with added FPC-III support