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