1
2
3
4
5
6
7
8
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
33MODULE_AUTHOR("Jouni Malinen");
34MODULE_DESCRIPTION("Host AP common routines");
35MODULE_LICENSE("GPL");
36
37#define TX_TIMEOUT (2 * HZ)
38
39#define PRISM2_MAX_FRAME_SIZE 2304
40#define PRISM2_MIN_MTU 256
41
42#define PRISM2_MAX_MTU (PRISM2_MAX_FRAME_SIZE - (6 + 8 ))
43
44
45struct 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
98void 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
125
126}
127
128
129static 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
138int 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
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
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
199int 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
234u16 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
258int 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
283int 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
292int 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;
304 memcpy(buf + 2, val, len);
305
306 return iface->local->func->set_rid(dev, rid, &buf, MAX_SSID_LEN + 2);
307}
308
309
310u16 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
326int 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
383
384 keylen = 6;
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;
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
418int 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
475int 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
496int hostap_set_auth_algs(local_info_t *local)
497{
498 int val = local->auth_algs;
499
500
501
502
503
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
518void 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
549void 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
577static 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);
581 return ETH_ALEN;
582}
583
584
585int hostap_80211_get_hdrlen(__le16 fc)
586{
587 if (ieee80211_is_data(fc) && ieee80211_has_a4 (fc))
588 return 30;
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
598static 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
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
642
643
644 dev_close(local->dev);
645 }
646
647 return 0;
648}
649
650
651static 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
687
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
699static 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
726
727void 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
741static void hostap_set_multicast_list(struct net_device *dev)
742{
743#if 0
744
745
746
747
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
764static void prism2_tx_timeout(struct net_device *dev)
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, ®s);
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
785const 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};
791EXPORT_SYMBOL(hostap_80211_ops);
792
793
794static 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
806static 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
818static 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
830void 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
842 if (iface) {
843
844
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;
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;
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
873static 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
892static 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
905static 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
924static 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
937int 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
962int 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
988int 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
1026int 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
1060int 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
1079struct proc_dir_entry *hostap_proc;
1080
1081static 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
1095static 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
1104EXPORT_SYMBOL(hostap_set_word);
1105EXPORT_SYMBOL(hostap_set_string);
1106EXPORT_SYMBOL(hostap_get_porttype);
1107EXPORT_SYMBOL(hostap_set_encryption);
1108EXPORT_SYMBOL(hostap_set_antsel);
1109EXPORT_SYMBOL(hostap_set_roaming);
1110EXPORT_SYMBOL(hostap_set_auth_algs);
1111EXPORT_SYMBOL(hostap_dump_rx_header);
1112EXPORT_SYMBOL(hostap_dump_tx_header);
1113EXPORT_SYMBOL(hostap_80211_get_hdrlen);
1114EXPORT_SYMBOL(hostap_setup_dev);
1115EXPORT_SYMBOL(hostap_set_multicast_list_queue);
1116EXPORT_SYMBOL(hostap_set_hostapd);
1117EXPORT_SYMBOL(hostap_set_hostapd_sta);
1118EXPORT_SYMBOL(hostap_add_interface);
1119EXPORT_SYMBOL(hostap_remove_interface);
1120EXPORT_SYMBOL(prism2_update_comms_qual);
1121
1122module_init(hostap_init);
1123module_exit(hostap_exit);
1124
