xref: /openbmc/linux/drivers/net/wireless/st/cw1200/scan.c (revision 51b67a6e)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Scan implementation for ST-Ericsson CW1200 mac80211 drivers
4  *
5  * Copyright (c) 2010, ST-Ericsson
6  * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
7  */
8 
9 #include <linux/sched.h>
10 #include "cw1200.h"
11 #include "scan.h"
12 #include "sta.h"
13 #include "pm.h"
14 
15 static void cw1200_scan_restart_delayed(struct cw1200_common *priv);
16 
17 static int cw1200_scan_start(struct cw1200_common *priv, struct wsm_scan *scan)
18 {
19 	int ret, i;
20 	int tmo = 2000;
21 
22 	switch (priv->join_status) {
23 	case CW1200_JOIN_STATUS_PRE_STA:
24 	case CW1200_JOIN_STATUS_JOINING:
25 		return -EBUSY;
26 	default:
27 		break;
28 	}
29 
30 	wiphy_dbg(priv->hw->wiphy, "[SCAN] hw req, type %d, %d channels, flags: 0x%x.\n",
31 		  scan->type, scan->num_channels, scan->flags);
32 
33 	for (i = 0; i < scan->num_channels; ++i)
34 		tmo += scan->ch[i].max_chan_time + 10;
35 
36 	cancel_delayed_work_sync(&priv->clear_recent_scan_work);
37 	atomic_set(&priv->scan.in_progress, 1);
38 	atomic_set(&priv->recent_scan, 1);
39 	cw1200_pm_stay_awake(&priv->pm_state, msecs_to_jiffies(tmo));
40 	queue_delayed_work(priv->workqueue, &priv->scan.timeout,
41 			   msecs_to_jiffies(tmo));
42 	ret = wsm_scan(priv, scan);
43 	if (ret) {
44 		atomic_set(&priv->scan.in_progress, 0);
45 		cancel_delayed_work_sync(&priv->scan.timeout);
46 		cw1200_scan_restart_delayed(priv);
47 	}
48 	return ret;
49 }
50 
51 int cw1200_hw_scan(struct ieee80211_hw *hw,
52 		   struct ieee80211_vif *vif,
53 		   struct ieee80211_scan_request *hw_req)
54 {
55 	struct cw1200_common *priv = hw->priv;
56 	struct cfg80211_scan_request *req = &hw_req->req;
57 	struct wsm_template_frame frame = {
58 		.frame_type = WSM_FRAME_TYPE_PROBE_REQUEST,
59 	};
60 	int i, ret;
61 
62 	if (!priv->vif)
63 		return -EINVAL;
64 
65 	/* Scan when P2P_GO corrupt firmware MiniAP mode */
66 	if (priv->join_status == CW1200_JOIN_STATUS_AP)
67 		return -EOPNOTSUPP;
68 
69 	if (req->n_ssids == 1 && !req->ssids[0].ssid_len)
70 		req->n_ssids = 0;
71 
72 	wiphy_dbg(hw->wiphy, "[SCAN] Scan request for %d SSIDs.\n",
73 		  req->n_ssids);
74 
75 	if (req->n_ssids > WSM_SCAN_MAX_NUM_OF_SSIDS)
76 		return -EINVAL;
77 
78 	/* will be unlocked in cw1200_scan_work() */
79 	down(&priv->scan.lock);
80 	mutex_lock(&priv->conf_mutex);
81 
82 	frame.skb = ieee80211_probereq_get(hw, priv->vif->addr, NULL, 0,
83 		req->ie_len);
84 	if (!frame.skb) {
85 		mutex_unlock(&priv->conf_mutex);
86 		up(&priv->scan.lock);
87 		return -ENOMEM;
88 	}
89 
90 	if (req->ie_len)
91 		skb_put_data(frame.skb, req->ie, req->ie_len);
92 
93 	ret = wsm_set_template_frame(priv, &frame);
94 	if (!ret) {
95 		/* Host want to be the probe responder. */
96 		ret = wsm_set_probe_responder(priv, true);
97 	}
98 	if (ret) {
99 		dev_kfree_skb(frame.skb);
100 		mutex_unlock(&priv->conf_mutex);
101 		up(&priv->scan.lock);
102 		return ret;
103 	}
104 
105 	wsm_lock_tx(priv);
106 
107 	BUG_ON(priv->scan.req);
108 	priv->scan.req = req;
109 	priv->scan.n_ssids = 0;
110 	priv->scan.status = 0;
111 	priv->scan.begin = &req->channels[0];
112 	priv->scan.curr = priv->scan.begin;
113 	priv->scan.end = &req->channels[req->n_channels];
114 	priv->scan.output_power = priv->output_power;
115 
116 	for (i = 0; i < req->n_ssids; ++i) {
117 		struct wsm_ssid *dst = &priv->scan.ssids[priv->scan.n_ssids];
118 		memcpy(&dst->ssid[0], req->ssids[i].ssid, sizeof(dst->ssid));
119 		dst->length = req->ssids[i].ssid_len;
120 		++priv->scan.n_ssids;
121 	}
122 
123 	if (frame.skb)
124 		dev_kfree_skb(frame.skb);
125 	mutex_unlock(&priv->conf_mutex);
126 	queue_work(priv->workqueue, &priv->scan.work);
127 	return 0;
128 }
129 
130 void cw1200_scan_work(struct work_struct *work)
131 {
132 	struct cw1200_common *priv = container_of(work, struct cw1200_common,
133 							scan.work);
134 	struct ieee80211_channel **it;
135 	struct wsm_scan scan = {
136 		.type = WSM_SCAN_TYPE_FOREGROUND,
137 		.flags = WSM_SCAN_FLAG_SPLIT_METHOD,
138 	};
139 	bool first_run = (priv->scan.begin == priv->scan.curr &&
140 			  priv->scan.begin != priv->scan.end);
141 	int i;
142 
143 	if (first_run) {
144 		/* Firmware gets crazy if scan request is sent
145 		 * when STA is joined but not yet associated.
146 		 * Force unjoin in this case.
147 		 */
148 		if (cancel_delayed_work_sync(&priv->join_timeout) > 0)
149 			cw1200_join_timeout(&priv->join_timeout.work);
150 	}
151 
152 	mutex_lock(&priv->conf_mutex);
153 
154 	if (first_run) {
155 		if (priv->join_status == CW1200_JOIN_STATUS_STA &&
156 		    !(priv->powersave_mode.mode & WSM_PSM_PS)) {
157 			struct wsm_set_pm pm = priv->powersave_mode;
158 			pm.mode = WSM_PSM_PS;
159 			cw1200_set_pm(priv, &pm);
160 		} else if (priv->join_status == CW1200_JOIN_STATUS_MONITOR) {
161 			/* FW bug: driver has to restart p2p-dev mode
162 			 * after scan
163 			 */
164 			cw1200_disable_listening(priv);
165 		}
166 	}
167 
168 	if (!priv->scan.req || (priv->scan.curr == priv->scan.end)) {
169 		struct cfg80211_scan_info info = {
170 			.aborted = priv->scan.status ? 1 : 0,
171 		};
172 
173 		if (priv->scan.output_power != priv->output_power)
174 			wsm_set_output_power(priv, priv->output_power * 10);
175 		if (priv->join_status == CW1200_JOIN_STATUS_STA &&
176 		    !(priv->powersave_mode.mode & WSM_PSM_PS))
177 			cw1200_set_pm(priv, &priv->powersave_mode);
178 
179 		if (priv->scan.status < 0)
180 			wiphy_warn(priv->hw->wiphy,
181 				   "[SCAN] Scan failed (%d).\n",
182 				   priv->scan.status);
183 		else if (priv->scan.req)
184 			wiphy_dbg(priv->hw->wiphy,
185 				  "[SCAN] Scan completed.\n");
186 		else
187 			wiphy_dbg(priv->hw->wiphy,
188 				  "[SCAN] Scan canceled.\n");
189 
190 		priv->scan.req = NULL;
191 		cw1200_scan_restart_delayed(priv);
192 		wsm_unlock_tx(priv);
193 		mutex_unlock(&priv->conf_mutex);
194 		ieee80211_scan_completed(priv->hw, &info);
195 		up(&priv->scan.lock);
196 		return;
197 	} else {
198 		struct ieee80211_channel *first = *priv->scan.curr;
199 		for (it = priv->scan.curr + 1, i = 1;
200 		     it != priv->scan.end && i < WSM_SCAN_MAX_NUM_OF_CHANNELS;
201 		     ++it, ++i) {
202 			if ((*it)->band != first->band)
203 				break;
204 			if (((*it)->flags ^ first->flags) &
205 					IEEE80211_CHAN_NO_IR)
206 				break;
207 			if (!(first->flags & IEEE80211_CHAN_NO_IR) &&
208 			    (*it)->max_power != first->max_power)
209 				break;
210 		}
211 		scan.band = first->band;
212 
213 		if (priv->scan.req->no_cck)
214 			scan.max_tx_rate = WSM_TRANSMIT_RATE_6;
215 		else
216 			scan.max_tx_rate = WSM_TRANSMIT_RATE_1;
217 		scan.num_probes =
218 			(first->flags & IEEE80211_CHAN_NO_IR) ? 0 : 2;
219 		scan.num_ssids = priv->scan.n_ssids;
220 		scan.ssids = &priv->scan.ssids[0];
221 		scan.num_channels = it - priv->scan.curr;
222 		/* TODO: Is it optimal? */
223 		scan.probe_delay = 100;
224 		/* It is not stated in WSM specification, however
225 		 * FW team says that driver may not use FG scan
226 		 * when joined.
227 		 */
228 		if (priv->join_status == CW1200_JOIN_STATUS_STA) {
229 			scan.type = WSM_SCAN_TYPE_BACKGROUND;
230 			scan.flags = WSM_SCAN_FLAG_FORCE_BACKGROUND;
231 		}
232 		scan.ch = kcalloc(it - priv->scan.curr,
233 				  sizeof(struct wsm_scan_ch),
234 				  GFP_KERNEL);
235 		if (!scan.ch) {
236 			priv->scan.status = -ENOMEM;
237 			goto fail;
238 		}
239 		for (i = 0; i < scan.num_channels; ++i) {
240 			scan.ch[i].number = priv->scan.curr[i]->hw_value;
241 			if (priv->scan.curr[i]->flags & IEEE80211_CHAN_NO_IR) {
242 				scan.ch[i].min_chan_time = 50;
243 				scan.ch[i].max_chan_time = 100;
244 			} else {
245 				scan.ch[i].min_chan_time = 10;
246 				scan.ch[i].max_chan_time = 25;
247 			}
248 		}
249 		if (!(first->flags & IEEE80211_CHAN_NO_IR) &&
250 		    priv->scan.output_power != first->max_power) {
251 			priv->scan.output_power = first->max_power;
252 			wsm_set_output_power(priv,
253 					     priv->scan.output_power * 10);
254 		}
255 		priv->scan.status = cw1200_scan_start(priv, &scan);
256 		kfree(scan.ch);
257 		if (priv->scan.status)
258 			goto fail;
259 		priv->scan.curr = it;
260 	}
261 	mutex_unlock(&priv->conf_mutex);
262 	return;
263 
264 fail:
265 	priv->scan.curr = priv->scan.end;
266 	mutex_unlock(&priv->conf_mutex);
267 	queue_work(priv->workqueue, &priv->scan.work);
268 	return;
269 }
270 
271 static void cw1200_scan_restart_delayed(struct cw1200_common *priv)
272 {
273 	/* FW bug: driver has to restart p2p-dev mode after scan. */
274 	if (priv->join_status == CW1200_JOIN_STATUS_MONITOR) {
275 		cw1200_enable_listening(priv);
276 		cw1200_update_filtering(priv);
277 	}
278 
279 	if (priv->delayed_unjoin) {
280 		priv->delayed_unjoin = false;
281 		if (queue_work(priv->workqueue, &priv->unjoin_work) <= 0)
282 			wsm_unlock_tx(priv);
283 	} else if (priv->delayed_link_loss) {
284 			wiphy_dbg(priv->hw->wiphy, "[CQM] Requeue BSS loss.\n");
285 			priv->delayed_link_loss = 0;
286 			cw1200_cqm_bssloss_sm(priv, 1, 0, 0);
287 	}
288 }
289 
290 static void cw1200_scan_complete(struct cw1200_common *priv)
291 {
292 	queue_delayed_work(priv->workqueue, &priv->clear_recent_scan_work, HZ);
293 	if (priv->scan.direct_probe) {
294 		wiphy_dbg(priv->hw->wiphy, "[SCAN] Direct probe complete.\n");
295 		cw1200_scan_restart_delayed(priv);
296 		priv->scan.direct_probe = 0;
297 		up(&priv->scan.lock);
298 		wsm_unlock_tx(priv);
299 	} else {
300 		cw1200_scan_work(&priv->scan.work);
301 	}
302 }
303 
304 void cw1200_scan_failed_cb(struct cw1200_common *priv)
305 {
306 	if (priv->mode == NL80211_IFTYPE_UNSPECIFIED)
307 		/* STA is stopped. */
308 		return;
309 
310 	if (cancel_delayed_work_sync(&priv->scan.timeout) > 0) {
311 		priv->scan.status = -EIO;
312 		queue_delayed_work(priv->workqueue, &priv->scan.timeout, 0);
313 	}
314 }
315 
316 
317 void cw1200_scan_complete_cb(struct cw1200_common *priv,
318 				struct wsm_scan_complete *arg)
319 {
320 	if (priv->mode == NL80211_IFTYPE_UNSPECIFIED)
321 		/* STA is stopped. */
322 		return;
323 
324 	if (cancel_delayed_work_sync(&priv->scan.timeout) > 0) {
325 		priv->scan.status = 1;
326 		queue_delayed_work(priv->workqueue, &priv->scan.timeout, 0);
327 	}
328 }
329 
330 void cw1200_clear_recent_scan_work(struct work_struct *work)
331 {
332 	struct cw1200_common *priv =
333 		container_of(work, struct cw1200_common,
334 			     clear_recent_scan_work.work);
335 	atomic_xchg(&priv->recent_scan, 0);
336 }
337 
338 void cw1200_scan_timeout(struct work_struct *work)
339 {
340 	struct cw1200_common *priv =
341 		container_of(work, struct cw1200_common, scan.timeout.work);
342 	if (atomic_xchg(&priv->scan.in_progress, 0)) {
343 		if (priv->scan.status > 0) {
344 			priv->scan.status = 0;
345 		} else if (!priv->scan.status) {
346 			wiphy_warn(priv->hw->wiphy,
347 				   "Timeout waiting for scan complete notification.\n");
348 			priv->scan.status = -ETIMEDOUT;
349 			priv->scan.curr = priv->scan.end;
350 			wsm_stop_scan(priv);
351 		}
352 		cw1200_scan_complete(priv);
353 	}
354 }
355 
356 void cw1200_probe_work(struct work_struct *work)
357 {
358 	struct cw1200_common *priv =
359 		container_of(work, struct cw1200_common, scan.probe_work.work);
360 	u8 queue_id = cw1200_queue_get_queue_id(priv->pending_frame_id);
361 	struct cw1200_queue *queue = &priv->tx_queue[queue_id];
362 	const struct cw1200_txpriv *txpriv;
363 	struct wsm_tx *wsm;
364 	struct wsm_template_frame frame = {
365 		.frame_type = WSM_FRAME_TYPE_PROBE_REQUEST,
366 	};
367 	struct wsm_ssid ssids[1] = {{
368 		.length = 0,
369 	} };
370 	struct wsm_scan_ch ch[1] = {{
371 		.min_chan_time = 0,
372 		.max_chan_time = 10,
373 	} };
374 	struct wsm_scan scan = {
375 		.type = WSM_SCAN_TYPE_FOREGROUND,
376 		.num_probes = 1,
377 		.probe_delay = 0,
378 		.num_channels = 1,
379 		.ssids = ssids,
380 		.ch = ch,
381 	};
382 	u8 *ies;
383 	size_t ies_len;
384 	int ret;
385 
386 	wiphy_dbg(priv->hw->wiphy, "[SCAN] Direct probe work.\n");
387 
388 	mutex_lock(&priv->conf_mutex);
389 	if (down_trylock(&priv->scan.lock)) {
390 		/* Scan is already in progress. Requeue self. */
391 		schedule();
392 		queue_delayed_work(priv->workqueue, &priv->scan.probe_work,
393 				   msecs_to_jiffies(100));
394 		mutex_unlock(&priv->conf_mutex);
395 		return;
396 	}
397 
398 	/* Make sure we still have a pending probe req */
399 	if (cw1200_queue_get_skb(queue,	priv->pending_frame_id,
400 				 &frame.skb, &txpriv)) {
401 		up(&priv->scan.lock);
402 		mutex_unlock(&priv->conf_mutex);
403 		wsm_unlock_tx(priv);
404 		return;
405 	}
406 	wsm = (struct wsm_tx *)frame.skb->data;
407 	scan.max_tx_rate = wsm->max_tx_rate;
408 	scan.band = (priv->channel->band == NL80211_BAND_5GHZ) ?
409 		WSM_PHY_BAND_5G : WSM_PHY_BAND_2_4G;
410 	if (priv->join_status == CW1200_JOIN_STATUS_STA ||
411 	    priv->join_status == CW1200_JOIN_STATUS_IBSS) {
412 		scan.type = WSM_SCAN_TYPE_BACKGROUND;
413 		scan.flags = WSM_SCAN_FLAG_FORCE_BACKGROUND;
414 	}
415 	ch[0].number = priv->channel->hw_value;
416 
417 	skb_pull(frame.skb, txpriv->offset);
418 
419 	ies = &frame.skb->data[sizeof(struct ieee80211_hdr_3addr)];
420 	ies_len = frame.skb->len - sizeof(struct ieee80211_hdr_3addr);
421 
422 	if (ies_len) {
423 		u8 *ssidie =
424 			(u8 *)cfg80211_find_ie(WLAN_EID_SSID, ies, ies_len);
425 		if (ssidie && ssidie[1] && ssidie[1] <= sizeof(ssids[0].ssid)) {
426 			u8 *nextie = &ssidie[2 + ssidie[1]];
427 			/* Remove SSID from the IE list. It has to be provided
428 			 * as a separate argument in cw1200_scan_start call
429 			 */
430 
431 			/* Store SSID localy */
432 			ssids[0].length = ssidie[1];
433 			memcpy(ssids[0].ssid, &ssidie[2], ssids[0].length);
434 			scan.num_ssids = 1;
435 
436 			/* Remove SSID from IE list */
437 			ssidie[1] = 0;
438 			memmove(&ssidie[2], nextie, &ies[ies_len] - nextie);
439 			skb_trim(frame.skb, frame.skb->len - ssids[0].length);
440 		}
441 	}
442 
443 	/* FW bug: driver has to restart p2p-dev mode after scan */
444 	if (priv->join_status == CW1200_JOIN_STATUS_MONITOR)
445 		cw1200_disable_listening(priv);
446 	ret = wsm_set_template_frame(priv, &frame);
447 	priv->scan.direct_probe = 1;
448 	if (!ret) {
449 		wsm_flush_tx(priv);
450 		ret = cw1200_scan_start(priv, &scan);
451 	}
452 	mutex_unlock(&priv->conf_mutex);
453 
454 	skb_push(frame.skb, txpriv->offset);
455 	if (!ret)
456 		IEEE80211_SKB_CB(frame.skb)->flags |= IEEE80211_TX_STAT_ACK;
457 	BUG_ON(cw1200_queue_remove(queue, priv->pending_frame_id));
458 
459 	if (ret) {
460 		priv->scan.direct_probe = 0;
461 		up(&priv->scan.lock);
462 		wsm_unlock_tx(priv);
463 	}
464 
465 	return;
466 }
467