Root/drivers/staging/rtl8192e/rtllib_softmac_wx.c

1/* IEEE 802.11 SoftMAC layer
2 * Copyright (c) 2005 Andrea Merello <andreamrl@tiscali.it>
3 *
4 * Mostly extracted from the rtl8180-sa2400 driver for the
5 * in-kernel generic ieee802.11 stack.
6 *
7 * Some pieces of code might be stolen from ipw2100 driver
8 * copyright of who own it's copyright ;-)
9 *
10 * PS wx handler mostly stolen from hostap, copyright who
11 * own it's copyright ;-)
12 *
13 * released under the GPL
14 */
15
16
17#include "rtllib.h"
18#include "dot11d.h"
19/* FIXME: add A freqs */
20
21const long rtllib_wlan_frequencies[] = {
22    2412, 2417, 2422, 2427,
23    2432, 2437, 2442, 2447,
24    2452, 2457, 2462, 2467,
25    2472, 2484
26};
27EXPORT_SYMBOL(rtllib_wlan_frequencies);
28
29
30int rtllib_wx_set_freq(struct rtllib_device *ieee, struct iw_request_info *a,
31                 union iwreq_data *wrqu, char *b)
32{
33    int ret;
34    struct iw_freq *fwrq = &wrqu->freq;
35
36    down(&ieee->wx_sem);
37
38    if (ieee->iw_mode == IW_MODE_INFRA) {
39        ret = 0;
40        goto out;
41    }
42
43    /* if setting by freq convert to channel */
44    if (fwrq->e == 1) {
45        if ((fwrq->m >= (int) 2.412e8 &&
46             fwrq->m <= (int) 2.487e8)) {
47            int f = fwrq->m / 100000;
48            int c = 0;
49
50            while ((c < 14) && (f != rtllib_wlan_frequencies[c]))
51                c++;
52
53            /* hack to fall through */
54            fwrq->e = 0;
55            fwrq->m = c + 1;
56        }
57    }
58
59    if (fwrq->e > 0 || fwrq->m > 14 || fwrq->m < 1) {
60        ret = -EOPNOTSUPP;
61        goto out;
62
63    } else { /* Set the channel */
64
65        if (ieee->active_channel_map[fwrq->m] != 1) {
66            ret = -EINVAL;
67            goto out;
68        }
69        ieee->current_network.channel = fwrq->m;
70        ieee->set_chan(ieee->dev, ieee->current_network.channel);
71
72        if (ieee->iw_mode == IW_MODE_ADHOC ||
73            ieee->iw_mode == IW_MODE_MASTER)
74            if (ieee->state == RTLLIB_LINKED) {
75                rtllib_stop_send_beacons(ieee);
76                rtllib_start_send_beacons(ieee);
77            }
78    }
79
80    ret = 0;
81out:
82    up(&ieee->wx_sem);
83    return ret;
84}
85EXPORT_SYMBOL(rtllib_wx_set_freq);
86
87
88int rtllib_wx_get_freq(struct rtllib_device *ieee,
89                 struct iw_request_info *a,
90                 union iwreq_data *wrqu, char *b)
91{
92    struct iw_freq *fwrq = &wrqu->freq;
93
94    if (ieee->current_network.channel == 0)
95        return -1;
96    fwrq->m = rtllib_wlan_frequencies[ieee->current_network.channel-1] *
97          100000;
98    fwrq->e = 1;
99    return 0;
100}
101EXPORT_SYMBOL(rtllib_wx_get_freq);
102
103int rtllib_wx_get_wap(struct rtllib_device *ieee,
104                struct iw_request_info *info,
105                union iwreq_data *wrqu, char *extra)
106{
107    unsigned long flags;
108
109    wrqu->ap_addr.sa_family = ARPHRD_ETHER;
110
111    if (ieee->iw_mode == IW_MODE_MONITOR)
112        return -1;
113
114    /* We want avoid to give to the user inconsistent infos*/
115    spin_lock_irqsave(&ieee->lock, flags);
116
117    if (ieee->state != RTLLIB_LINKED &&
118        ieee->state != RTLLIB_LINKED_SCANNING &&
119        ieee->wap_set == 0)
120
121        memset(wrqu->ap_addr.sa_data, 0, ETH_ALEN);
122    else
123        memcpy(wrqu->ap_addr.sa_data,
124               ieee->current_network.bssid, ETH_ALEN);
125
126    spin_unlock_irqrestore(&ieee->lock, flags);
127
128    return 0;
129}
130EXPORT_SYMBOL(rtllib_wx_get_wap);
131
132
133int rtllib_wx_set_wap(struct rtllib_device *ieee,
134             struct iw_request_info *info,
135             union iwreq_data *awrq,
136             char *extra)
137{
138
139    int ret = 0;
140    u8 zero[] = {0, 0, 0, 0, 0, 0};
141    unsigned long flags;
142
143    short ifup = ieee->proto_started;
144    struct sockaddr *temp = (struct sockaddr *)awrq;
145
146    rtllib_stop_scan_syncro(ieee);
147
148    down(&ieee->wx_sem);
149    /* use ifconfig hw ether */
150    if (ieee->iw_mode == IW_MODE_MASTER) {
151        ret = -1;
152        goto out;
153    }
154
155    if (temp->sa_family != ARPHRD_ETHER) {
156        ret = -EINVAL;
157        goto out;
158    }
159
160    if (memcmp(temp->sa_data, zero, ETH_ALEN) == 0) {
161        spin_lock_irqsave(&ieee->lock, flags);
162        memcpy(ieee->current_network.bssid, temp->sa_data, ETH_ALEN);
163        ieee->wap_set = 0;
164        spin_unlock_irqrestore(&ieee->lock, flags);
165        ret = -1;
166        goto out;
167    }
168
169
170    if (ifup)
171        rtllib_stop_protocol(ieee, true);
172
173    /* just to avoid to give inconsistent infos in the
174     * get wx method. not really needed otherwise
175     */
176    spin_lock_irqsave(&ieee->lock, flags);
177
178    ieee->cannot_notify = false;
179    memcpy(ieee->current_network.bssid, temp->sa_data, ETH_ALEN);
180    ieee->wap_set = (memcmp(temp->sa_data, zero, ETH_ALEN) != 0);
181
182    spin_unlock_irqrestore(&ieee->lock, flags);
183
184    if (ifup)
185        rtllib_start_protocol(ieee);
186out:
187    up(&ieee->wx_sem);
188    return ret;
189}
190EXPORT_SYMBOL(rtllib_wx_set_wap);
191
192int rtllib_wx_get_essid(struct rtllib_device *ieee, struct iw_request_info *a,
193             union iwreq_data *wrqu, char *b)
194{
195    int len, ret = 0;
196    unsigned long flags;
197
198    if (ieee->iw_mode == IW_MODE_MONITOR)
199        return -1;
200
201    /* We want avoid to give to the user inconsistent infos*/
202    spin_lock_irqsave(&ieee->lock, flags);
203
204    if (ieee->current_network.ssid[0] == '\0' ||
205        ieee->current_network.ssid_len == 0) {
206        ret = -1;
207        goto out;
208    }
209
210    if (ieee->state != RTLLIB_LINKED &&
211        ieee->state != RTLLIB_LINKED_SCANNING &&
212        ieee->ssid_set == 0) {
213        ret = -1;
214        goto out;
215    }
216    len = ieee->current_network.ssid_len;
217    wrqu->essid.length = len;
218    strncpy(b, ieee->current_network.ssid, len);
219    wrqu->essid.flags = 1;
220
221out:
222    spin_unlock_irqrestore(&ieee->lock, flags);
223
224    return ret;
225
226}
227EXPORT_SYMBOL(rtllib_wx_get_essid);
228
229int rtllib_wx_set_rate(struct rtllib_device *ieee,
230                 struct iw_request_info *info,
231                 union iwreq_data *wrqu, char *extra)
232{
233
234    u32 target_rate = wrqu->bitrate.value;
235
236    ieee->rate = target_rate/100000;
237    return 0;
238}
239EXPORT_SYMBOL(rtllib_wx_set_rate);
240
241int rtllib_wx_get_rate(struct rtllib_device *ieee,
242                 struct iw_request_info *info,
243                 union iwreq_data *wrqu, char *extra)
244{
245    u32 tmp_rate = 0;
246    tmp_rate = TxCountToDataRate(ieee,
247                     ieee->softmac_stats.CurrentShowTxate);
248    wrqu->bitrate.value = tmp_rate * 500000;
249
250    return 0;
251}
252EXPORT_SYMBOL(rtllib_wx_get_rate);
253
254
255int rtllib_wx_set_rts(struct rtllib_device *ieee,
256                 struct iw_request_info *info,
257                 union iwreq_data *wrqu, char *extra)
258{
259    if (wrqu->rts.disabled || !wrqu->rts.fixed)
260        ieee->rts = DEFAULT_RTS_THRESHOLD;
261    else {
262        if (wrqu->rts.value < MIN_RTS_THRESHOLD ||
263                wrqu->rts.value > MAX_RTS_THRESHOLD)
264            return -EINVAL;
265        ieee->rts = wrqu->rts.value;
266    }
267    return 0;
268}
269EXPORT_SYMBOL(rtllib_wx_set_rts);
270
271int rtllib_wx_get_rts(struct rtllib_device *ieee,
272                 struct iw_request_info *info,
273                 union iwreq_data *wrqu, char *extra)
274{
275    wrqu->rts.value = ieee->rts;
276    wrqu->rts.fixed = 0; /* no auto select */
277    wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD);
278    return 0;
279}
280EXPORT_SYMBOL(rtllib_wx_get_rts);
281
282int rtllib_wx_set_mode(struct rtllib_device *ieee, struct iw_request_info *a,
283                 union iwreq_data *wrqu, char *b)
284{
285    int set_mode_status = 0;
286
287    rtllib_stop_scan_syncro(ieee);
288    down(&ieee->wx_sem);
289    switch (wrqu->mode) {
290    case IW_MODE_MONITOR:
291    case IW_MODE_ADHOC:
292    case IW_MODE_INFRA:
293        break;
294    case IW_MODE_AUTO:
295        wrqu->mode = IW_MODE_INFRA;
296        break;
297    default:
298        set_mode_status = -EINVAL;
299        goto out;
300    }
301
302    if (wrqu->mode == ieee->iw_mode)
303        goto out;
304
305    if (wrqu->mode == IW_MODE_MONITOR) {
306        ieee->dev->type = ARPHRD_IEEE80211;
307        rtllib_EnableNetMonitorMode(ieee->dev, false);
308    } else {
309        ieee->dev->type = ARPHRD_ETHER;
310        if (ieee->iw_mode == IW_MODE_MONITOR)
311            rtllib_DisableNetMonitorMode(ieee->dev, false);
312    }
313
314    if (!ieee->proto_started) {
315        ieee->iw_mode = wrqu->mode;
316    } else {
317        rtllib_stop_protocol(ieee, true);
318        ieee->iw_mode = wrqu->mode;
319        rtllib_start_protocol(ieee);
320    }
321
322out:
323    up(&ieee->wx_sem);
324    return set_mode_status;
325}
326EXPORT_SYMBOL(rtllib_wx_set_mode);
327
328void rtllib_wx_sync_scan_wq(void *data)
329{
330    struct rtllib_device *ieee = container_of_work_rsl(data,
331                     struct rtllib_device, wx_sync_scan_wq);
332    short chan;
333    enum ht_extchnl_offset chan_offset = 0;
334    enum ht_channel_width bandwidth = 0;
335    int b40M = 0;
336    static int count;
337
338    if (!(ieee->softmac_features & IEEE_SOFTMAC_SCAN)) {
339        rtllib_start_scan_syncro(ieee, 0);
340        goto out;
341    }
342
343    chan = ieee->current_network.channel;
344
345    if (ieee->LeisurePSLeave)
346        ieee->LeisurePSLeave(ieee->dev);
347    /* notify AP to be in PS mode */
348    rtllib_sta_ps_send_null_frame(ieee, 1);
349    rtllib_sta_ps_send_null_frame(ieee, 1);
350
351    rtllib_stop_all_queues(ieee);
352
353    if (ieee->data_hard_stop)
354        ieee->data_hard_stop(ieee->dev);
355    rtllib_stop_send_beacons(ieee);
356    ieee->state = RTLLIB_LINKED_SCANNING;
357    ieee->link_change(ieee->dev);
358    /* wait for ps packet to be kicked out successfully */
359    msleep(50);
360
361    if (ieee->ScanOperationBackupHandler)
362        ieee->ScanOperationBackupHandler(ieee->dev, SCAN_OPT_BACKUP);
363
364    if (ieee->pHTInfo->bCurrentHTSupport && ieee->pHTInfo->bEnableHT &&
365        ieee->pHTInfo->bCurBW40MHz) {
366        b40M = 1;
367        chan_offset = ieee->pHTInfo->CurSTAExtChnlOffset;
368        bandwidth = (enum ht_channel_width)ieee->pHTInfo->bCurBW40MHz;
369        RT_TRACE(COMP_DBG, "Scan in 40M, force to 20M first:%d, %d\n",
370             chan_offset, bandwidth);
371        ieee->SetBWModeHandler(ieee->dev, HT_CHANNEL_WIDTH_20,
372                       HT_EXTCHNL_OFFSET_NO_EXT);
373    }
374
375    rtllib_start_scan_syncro(ieee, 0);
376
377    if (b40M) {
378        RT_TRACE(COMP_DBG, "Scan in 20M, back to 40M\n");
379        if (chan_offset == HT_EXTCHNL_OFFSET_UPPER)
380            ieee->set_chan(ieee->dev, chan + 2);
381        else if (chan_offset == HT_EXTCHNL_OFFSET_LOWER)
382            ieee->set_chan(ieee->dev, chan - 2);
383        else
384            ieee->set_chan(ieee->dev, chan);
385        ieee->SetBWModeHandler(ieee->dev, bandwidth, chan_offset);
386    } else {
387        ieee->set_chan(ieee->dev, chan);
388    }
389
390    if (ieee->ScanOperationBackupHandler)
391        ieee->ScanOperationBackupHandler(ieee->dev, SCAN_OPT_RESTORE);
392
393    ieee->state = RTLLIB_LINKED;
394    ieee->link_change(ieee->dev);
395
396    /* Notify AP that I wake up again */
397    rtllib_sta_ps_send_null_frame(ieee, 0);
398
399    if (ieee->LinkDetectInfo.NumRecvBcnInPeriod == 0 ||
400        ieee->LinkDetectInfo.NumRecvDataInPeriod == 0) {
401        ieee->LinkDetectInfo.NumRecvBcnInPeriod = 1;
402        ieee->LinkDetectInfo.NumRecvDataInPeriod = 1;
403    }
404
405    if (ieee->data_hard_resume)
406        ieee->data_hard_resume(ieee->dev);
407
408    if (ieee->iw_mode == IW_MODE_ADHOC || ieee->iw_mode == IW_MODE_MASTER)
409        rtllib_start_send_beacons(ieee);
410
411    rtllib_wake_all_queues(ieee);
412
413    count = 0;
414out:
415    up(&ieee->wx_sem);
416
417}
418
419int rtllib_wx_set_scan(struct rtllib_device *ieee, struct iw_request_info *a,
420                 union iwreq_data *wrqu, char *b)
421{
422    int ret = 0;
423
424    down(&ieee->wx_sem);
425
426    if (ieee->iw_mode == IW_MODE_MONITOR || !(ieee->proto_started)) {
427        ret = -1;
428        goto out;
429    }
430
431    if (ieee->state == RTLLIB_LINKED) {
432        queue_work_rsl(ieee->wq, &ieee->wx_sync_scan_wq);
433        /* intentionally forget to up sem */
434        return 0;
435    }
436
437out:
438    up(&ieee->wx_sem);
439    return ret;
440}
441EXPORT_SYMBOL(rtllib_wx_set_scan);
442
443int rtllib_wx_set_essid(struct rtllib_device *ieee,
444            struct iw_request_info *a,
445            union iwreq_data *wrqu, char *extra)
446{
447
448    int ret = 0, len, i;
449    short proto_started;
450    unsigned long flags;
451
452    rtllib_stop_scan_syncro(ieee);
453    down(&ieee->wx_sem);
454
455    proto_started = ieee->proto_started;
456
457    len = (wrqu->essid.length < IW_ESSID_MAX_SIZE) ? wrqu->essid.length :
458           IW_ESSID_MAX_SIZE;
459
460    if (len > IW_ESSID_MAX_SIZE) {
461        ret = -E2BIG;
462        goto out;
463    }
464
465    if (ieee->iw_mode == IW_MODE_MONITOR) {
466        ret = -1;
467        goto out;
468    }
469
470    for (i = 0; i < len; i++) {
471        if (extra[i] < 0) {
472            ret = -1;
473            goto out;
474        }
475    }
476
477    if (proto_started)
478        rtllib_stop_protocol(ieee, true);
479
480
481    /* this is just to be sure that the GET wx callback
482     * has consistent infos. not needed otherwise
483     */
484    spin_lock_irqsave(&ieee->lock, flags);
485
486    if (wrqu->essid.flags && wrqu->essid.length) {
487        strncpy(ieee->current_network.ssid, extra, len);
488        ieee->current_network.ssid_len = len;
489        ieee->cannot_notify = false;
490        ieee->ssid_set = 1;
491    } else {
492        ieee->ssid_set = 0;
493        ieee->current_network.ssid[0] = '\0';
494        ieee->current_network.ssid_len = 0;
495    }
496    spin_unlock_irqrestore(&ieee->lock, flags);
497
498    if (proto_started)
499        rtllib_start_protocol(ieee);
500out:
501    up(&ieee->wx_sem);
502    return ret;
503}
504EXPORT_SYMBOL(rtllib_wx_set_essid);
505
506int rtllib_wx_get_mode(struct rtllib_device *ieee, struct iw_request_info *a,
507               union iwreq_data *wrqu, char *b)
508{
509    wrqu->mode = ieee->iw_mode;
510    return 0;
511}
512EXPORT_SYMBOL(rtllib_wx_get_mode);
513
514int rtllib_wx_set_rawtx(struct rtllib_device *ieee,
515            struct iw_request_info *info,
516            union iwreq_data *wrqu, char *extra)
517{
518
519    int *parms = (int *)extra;
520    int enable = (parms[0] > 0);
521    short prev = ieee->raw_tx;
522
523    down(&ieee->wx_sem);
524
525    if (enable)
526        ieee->raw_tx = 1;
527    else
528        ieee->raw_tx = 0;
529
530    printk(KERN_INFO"raw TX is %s\n",
531          ieee->raw_tx ? "enabled" : "disabled");
532
533    if (ieee->iw_mode == IW_MODE_MONITOR) {
534        if (prev == 0 && ieee->raw_tx) {
535            if (ieee->data_hard_resume)
536                ieee->data_hard_resume(ieee->dev);
537
538            netif_carrier_on(ieee->dev);
539        }
540
541        if (prev && ieee->raw_tx == 1)
542            netif_carrier_off(ieee->dev);
543    }
544
545    up(&ieee->wx_sem);
546
547    return 0;
548}
549EXPORT_SYMBOL(rtllib_wx_set_rawtx);
550
551int rtllib_wx_get_name(struct rtllib_device *ieee,
552                 struct iw_request_info *info,
553                 union iwreq_data *wrqu, char *extra)
554{
555    strcpy(wrqu->name, "802.11");
556
557    if (ieee->modulation & RTLLIB_CCK_MODULATION)
558        strcat(wrqu->name, "b");
559    if (ieee->modulation & RTLLIB_OFDM_MODULATION)
560        strcat(wrqu->name, "g");
561    if (ieee->mode & (IEEE_N_24G | IEEE_N_5G))
562        strcat(wrqu->name, "n");
563    return 0;
564}
565EXPORT_SYMBOL(rtllib_wx_get_name);
566
567
568/* this is mostly stolen from hostap */
569int rtllib_wx_set_power(struct rtllib_device *ieee,
570                 struct iw_request_info *info,
571                 union iwreq_data *wrqu, char *extra)
572{
573    int ret = 0;
574
575    if ((!ieee->sta_wake_up) ||
576        (!ieee->enter_sleep_state) ||
577        (!ieee->ps_is_queue_empty)) {
578        RTLLIB_DEBUG(RTLLIB_DL_ERR, "%s(): PS mode is tried to be use "
579                 "but driver missed a callback\n\n", __func__);
580        return -1;
581    }
582
583    down(&ieee->wx_sem);
584
585    if (wrqu->power.disabled) {
586        RT_TRACE(COMP_DBG, "===>%s(): power disable\n", __func__);
587        ieee->ps = RTLLIB_PS_DISABLED;
588        goto exit;
589    }
590    if (wrqu->power.flags & IW_POWER_TIMEOUT) {
591        ieee->ps_timeout = wrqu->power.value / 1000;
592        RT_TRACE(COMP_DBG, "===>%s():ps_timeout is %d\n", __func__,
593             ieee->ps_timeout);
594    }
595
596    if (wrqu->power.flags & IW_POWER_PERIOD)
597        ieee->ps_period = wrqu->power.value / 1000;
598
599    switch (wrqu->power.flags & IW_POWER_MODE) {
600    case IW_POWER_UNICAST_R:
601        ieee->ps = RTLLIB_PS_UNICAST;
602        break;
603    case IW_POWER_MULTICAST_R:
604        ieee->ps = RTLLIB_PS_MBCAST;
605        break;
606    case IW_POWER_ALL_R:
607        ieee->ps = RTLLIB_PS_UNICAST | RTLLIB_PS_MBCAST;
608        break;
609
610    case IW_POWER_ON:
611        break;
612
613    default:
614        ret = -EINVAL;
615        goto exit;
616
617    }
618exit:
619    up(&ieee->wx_sem);
620    return ret;
621
622}
623EXPORT_SYMBOL(rtllib_wx_set_power);
624
625/* this is stolen from hostap */
626int rtllib_wx_get_power(struct rtllib_device *ieee,
627                 struct iw_request_info *info,
628                 union iwreq_data *wrqu, char *extra)
629{
630    int ret = 0;
631
632    down(&ieee->wx_sem);
633
634    if (ieee->ps == RTLLIB_PS_DISABLED) {
635        wrqu->power.disabled = 1;
636        goto exit;
637    }
638
639    wrqu->power.disabled = 0;
640
641    if ((wrqu->power.flags & IW_POWER_TYPE) == IW_POWER_TIMEOUT) {
642        wrqu->power.flags = IW_POWER_TIMEOUT;
643        wrqu->power.value = ieee->ps_timeout * 1000;
644    } else {
645        wrqu->power.flags = IW_POWER_PERIOD;
646        wrqu->power.value = ieee->ps_period * 1000;
647    }
648
649    if ((ieee->ps & (RTLLIB_PS_MBCAST | RTLLIB_PS_UNICAST)) ==
650        (RTLLIB_PS_MBCAST | RTLLIB_PS_UNICAST))
651        wrqu->power.flags |= IW_POWER_ALL_R;
652    else if (ieee->ps & RTLLIB_PS_MBCAST)
653        wrqu->power.flags |= IW_POWER_MULTICAST_R;
654    else
655        wrqu->power.flags |= IW_POWER_UNICAST_R;
656
657exit:
658    up(&ieee->wx_sem);
659    return ret;
660
661}
662EXPORT_SYMBOL(rtllib_wx_get_power);
663

Archive Download this file



interactive