2 * Scan implementation for ST-Ericsson CW1200 mac80211 drivers
4 * Copyright (c) 2010, ST-Ericsson
5 * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <linux/sched.h>
18 static void cw1200_scan_restart_delayed(struct cw1200_common *priv);
20 static int cw1200_scan_start(struct cw1200_common *priv, struct wsm_scan *scan)
25 switch (priv->join_status) {
26 case CW1200_JOIN_STATUS_PRE_STA:
27 case CW1200_JOIN_STATUS_JOINING:
33 wiphy_dbg(priv->hw->wiphy, "[SCAN] hw req, type %d, %d channels, flags: 0x%x.\n",
34 scan->type, scan->num_channels, scan->flags);
36 for (i = 0; i < scan->num_channels; ++i)
37 tmo += scan->ch[i].max_chan_time + 10;
39 cancel_delayed_work_sync(&priv->clear_recent_scan_work);
40 atomic_set(&priv->scan.in_progress, 1);
41 atomic_set(&priv->recent_scan, 1);
42 cw1200_pm_stay_awake(&priv->pm_state, msecs_to_jiffies(tmo));
43 queue_delayed_work(priv->workqueue, &priv->scan.timeout,
44 msecs_to_jiffies(tmo));
45 ret = wsm_scan(priv, scan);
47 atomic_set(&priv->scan.in_progress, 0);
48 cancel_delayed_work_sync(&priv->scan.timeout);
49 cw1200_scan_restart_delayed(priv);
54 int cw1200_hw_scan(struct ieee80211_hw *hw,
55 struct ieee80211_vif *vif,
56 struct ieee80211_scan_request *hw_req)
58 struct cw1200_common *priv = hw->priv;
59 struct cfg80211_scan_request *req = &hw_req->req;
60 struct wsm_template_frame frame = {
61 .frame_type = WSM_FRAME_TYPE_PROBE_REQUEST,
68 /* Scan when P2P_GO corrupt firmware MiniAP mode */
69 if (priv->join_status == CW1200_JOIN_STATUS_AP)
72 if (req->n_ssids == 1 && !req->ssids[0].ssid_len)
75 wiphy_dbg(hw->wiphy, "[SCAN] Scan request for %d SSIDs.\n",
78 if (req->n_ssids > WSM_SCAN_MAX_NUM_OF_SSIDS)
81 /* will be unlocked in cw1200_scan_work() */
82 down(&priv->scan.lock);
83 mutex_lock(&priv->conf_mutex);
85 frame.skb = ieee80211_probereq_get(hw, priv->vif->addr, NULL, 0,
88 mutex_unlock(&priv->conf_mutex);
94 memcpy(skb_put(frame.skb, req->ie_len), req->ie, req->ie_len);
96 ret = wsm_set_template_frame(priv, &frame);
98 /* Host want to be the probe responder. */
99 ret = wsm_set_probe_responder(priv, true);
102 dev_kfree_skb(frame.skb);
103 mutex_unlock(&priv->conf_mutex);
104 up(&priv->scan.lock);
110 BUG_ON(priv->scan.req);
111 priv->scan.req = req;
112 priv->scan.n_ssids = 0;
113 priv->scan.status = 0;
114 priv->scan.begin = &req->channels[0];
115 priv->scan.curr = priv->scan.begin;
116 priv->scan.end = &req->channels[req->n_channels];
117 priv->scan.output_power = priv->output_power;
119 for (i = 0; i < req->n_ssids; ++i) {
120 struct wsm_ssid *dst = &priv->scan.ssids[priv->scan.n_ssids];
121 memcpy(&dst->ssid[0], req->ssids[i].ssid, sizeof(dst->ssid));
122 dst->length = req->ssids[i].ssid_len;
123 ++priv->scan.n_ssids;
127 dev_kfree_skb(frame.skb);
128 mutex_unlock(&priv->conf_mutex);
129 queue_work(priv->workqueue, &priv->scan.work);
133 void cw1200_scan_work(struct work_struct *work)
135 struct cw1200_common *priv = container_of(work, struct cw1200_common,
137 struct ieee80211_channel **it;
138 struct wsm_scan scan = {
139 .type = WSM_SCAN_TYPE_FOREGROUND,
140 .flags = WSM_SCAN_FLAG_SPLIT_METHOD,
142 bool first_run = (priv->scan.begin == priv->scan.curr &&
143 priv->scan.begin != priv->scan.end);
147 /* Firmware gets crazy if scan request is sent
148 * when STA is joined but not yet associated.
149 * Force unjoin in this case.
151 if (cancel_delayed_work_sync(&priv->join_timeout) > 0)
152 cw1200_join_timeout(&priv->join_timeout.work);
155 mutex_lock(&priv->conf_mutex);
158 if (priv->join_status == CW1200_JOIN_STATUS_STA &&
159 !(priv->powersave_mode.mode & WSM_PSM_PS)) {
160 struct wsm_set_pm pm = priv->powersave_mode;
161 pm.mode = WSM_PSM_PS;
162 cw1200_set_pm(priv, &pm);
163 } else if (priv->join_status == CW1200_JOIN_STATUS_MONITOR) {
164 /* FW bug: driver has to restart p2p-dev mode
167 cw1200_disable_listening(priv);
171 if (!priv->scan.req || (priv->scan.curr == priv->scan.end)) {
172 struct cfg80211_scan_info info = {
173 .aborted = priv->scan.status ? 1 : 0,
176 if (priv->scan.output_power != priv->output_power)
177 wsm_set_output_power(priv, priv->output_power * 10);
178 if (priv->join_status == CW1200_JOIN_STATUS_STA &&
179 !(priv->powersave_mode.mode & WSM_PSM_PS))
180 cw1200_set_pm(priv, &priv->powersave_mode);
182 if (priv->scan.status < 0)
183 wiphy_warn(priv->hw->wiphy,
184 "[SCAN] Scan failed (%d).\n",
186 else if (priv->scan.req)
187 wiphy_dbg(priv->hw->wiphy,
188 "[SCAN] Scan completed.\n");
190 wiphy_dbg(priv->hw->wiphy,
191 "[SCAN] Scan canceled.\n");
193 priv->scan.req = NULL;
194 cw1200_scan_restart_delayed(priv);
196 mutex_unlock(&priv->conf_mutex);
197 ieee80211_scan_completed(priv->hw, &info);
198 up(&priv->scan.lock);
201 struct ieee80211_channel *first = *priv->scan.curr;
202 for (it = priv->scan.curr + 1, i = 1;
203 it != priv->scan.end && i < WSM_SCAN_MAX_NUM_OF_CHANNELS;
205 if ((*it)->band != first->band)
207 if (((*it)->flags ^ first->flags) &
208 IEEE80211_CHAN_NO_IR)
210 if (!(first->flags & IEEE80211_CHAN_NO_IR) &&
211 (*it)->max_power != first->max_power)
214 scan.band = first->band;
216 if (priv->scan.req->no_cck)
217 scan.max_tx_rate = WSM_TRANSMIT_RATE_6;
219 scan.max_tx_rate = WSM_TRANSMIT_RATE_1;
221 (first->flags & IEEE80211_CHAN_NO_IR) ? 0 : 2;
222 scan.num_ssids = priv->scan.n_ssids;
223 scan.ssids = &priv->scan.ssids[0];
224 scan.num_channels = it - priv->scan.curr;
225 /* TODO: Is it optimal? */
226 scan.probe_delay = 100;
227 /* It is not stated in WSM specification, however
228 * FW team says that driver may not use FG scan
231 if (priv->join_status == CW1200_JOIN_STATUS_STA) {
232 scan.type = WSM_SCAN_TYPE_BACKGROUND;
233 scan.flags = WSM_SCAN_FLAG_FORCE_BACKGROUND;
236 sizeof(struct wsm_scan_ch) * (it - priv->scan.curr),
239 priv->scan.status = -ENOMEM;
242 for (i = 0; i < scan.num_channels; ++i) {
243 scan.ch[i].number = priv->scan.curr[i]->hw_value;
244 if (priv->scan.curr[i]->flags & IEEE80211_CHAN_NO_IR) {
245 scan.ch[i].min_chan_time = 50;
246 scan.ch[i].max_chan_time = 100;
248 scan.ch[i].min_chan_time = 10;
249 scan.ch[i].max_chan_time = 25;
252 if (!(first->flags & IEEE80211_CHAN_NO_IR) &&
253 priv->scan.output_power != first->max_power) {
254 priv->scan.output_power = first->max_power;
255 wsm_set_output_power(priv,
256 priv->scan.output_power * 10);
258 priv->scan.status = cw1200_scan_start(priv, &scan);
260 if (priv->scan.status)
262 priv->scan.curr = it;
264 mutex_unlock(&priv->conf_mutex);
268 priv->scan.curr = priv->scan.end;
269 mutex_unlock(&priv->conf_mutex);
270 queue_work(priv->workqueue, &priv->scan.work);
274 static void cw1200_scan_restart_delayed(struct cw1200_common *priv)
276 /* FW bug: driver has to restart p2p-dev mode after scan. */
277 if (priv->join_status == CW1200_JOIN_STATUS_MONITOR) {
278 cw1200_enable_listening(priv);
279 cw1200_update_filtering(priv);
282 if (priv->delayed_unjoin) {
283 priv->delayed_unjoin = false;
284 if (queue_work(priv->workqueue, &priv->unjoin_work) <= 0)
286 } else if (priv->delayed_link_loss) {
287 wiphy_dbg(priv->hw->wiphy, "[CQM] Requeue BSS loss.\n");
288 priv->delayed_link_loss = 0;
289 cw1200_cqm_bssloss_sm(priv, 1, 0, 0);
293 static void cw1200_scan_complete(struct cw1200_common *priv)
295 queue_delayed_work(priv->workqueue, &priv->clear_recent_scan_work, HZ);
296 if (priv->scan.direct_probe) {
297 wiphy_dbg(priv->hw->wiphy, "[SCAN] Direct probe complete.\n");
298 cw1200_scan_restart_delayed(priv);
299 priv->scan.direct_probe = 0;
300 up(&priv->scan.lock);
303 cw1200_scan_work(&priv->scan.work);
307 void cw1200_scan_failed_cb(struct cw1200_common *priv)
309 if (priv->mode == NL80211_IFTYPE_UNSPECIFIED)
310 /* STA is stopped. */
313 if (cancel_delayed_work_sync(&priv->scan.timeout) > 0) {
314 priv->scan.status = -EIO;
315 queue_delayed_work(priv->workqueue, &priv->scan.timeout, 0);
320 void cw1200_scan_complete_cb(struct cw1200_common *priv,
321 struct wsm_scan_complete *arg)
323 if (priv->mode == NL80211_IFTYPE_UNSPECIFIED)
324 /* STA is stopped. */
327 if (cancel_delayed_work_sync(&priv->scan.timeout) > 0) {
328 priv->scan.status = 1;
329 queue_delayed_work(priv->workqueue, &priv->scan.timeout, 0);
333 void cw1200_clear_recent_scan_work(struct work_struct *work)
335 struct cw1200_common *priv =
336 container_of(work, struct cw1200_common,
337 clear_recent_scan_work.work);
338 atomic_xchg(&priv->recent_scan, 0);
341 void cw1200_scan_timeout(struct work_struct *work)
343 struct cw1200_common *priv =
344 container_of(work, struct cw1200_common, scan.timeout.work);
345 if (atomic_xchg(&priv->scan.in_progress, 0)) {
346 if (priv->scan.status > 0) {
347 priv->scan.status = 0;
348 } else if (!priv->scan.status) {
349 wiphy_warn(priv->hw->wiphy,
350 "Timeout waiting for scan complete notification.\n");
351 priv->scan.status = -ETIMEDOUT;
352 priv->scan.curr = priv->scan.end;
355 cw1200_scan_complete(priv);
359 void cw1200_probe_work(struct work_struct *work)
361 struct cw1200_common *priv =
362 container_of(work, struct cw1200_common, scan.probe_work.work);
363 u8 queue_id = cw1200_queue_get_queue_id(priv->pending_frame_id);
364 struct cw1200_queue *queue = &priv->tx_queue[queue_id];
365 const struct cw1200_txpriv *txpriv;
367 struct wsm_template_frame frame = {
368 .frame_type = WSM_FRAME_TYPE_PROBE_REQUEST,
370 struct wsm_ssid ssids[1] = {{
373 struct wsm_scan_ch ch[1] = {{
377 struct wsm_scan scan = {
378 .type = WSM_SCAN_TYPE_FOREGROUND,
389 wiphy_dbg(priv->hw->wiphy, "[SCAN] Direct probe work.\n");
391 mutex_lock(&priv->conf_mutex);
392 if (down_trylock(&priv->scan.lock)) {
393 /* Scan is already in progress. Requeue self. */
395 queue_delayed_work(priv->workqueue, &priv->scan.probe_work,
396 msecs_to_jiffies(100));
397 mutex_unlock(&priv->conf_mutex);
401 /* Make sure we still have a pending probe req */
402 if (cw1200_queue_get_skb(queue, priv->pending_frame_id,
403 &frame.skb, &txpriv)) {
404 up(&priv->scan.lock);
405 mutex_unlock(&priv->conf_mutex);
409 wsm = (struct wsm_tx *)frame.skb->data;
410 scan.max_tx_rate = wsm->max_tx_rate;
411 scan.band = (priv->channel->band == NL80211_BAND_5GHZ) ?
412 WSM_PHY_BAND_5G : WSM_PHY_BAND_2_4G;
413 if (priv->join_status == CW1200_JOIN_STATUS_STA ||
414 priv->join_status == CW1200_JOIN_STATUS_IBSS) {
415 scan.type = WSM_SCAN_TYPE_BACKGROUND;
416 scan.flags = WSM_SCAN_FLAG_FORCE_BACKGROUND;
418 ch[0].number = priv->channel->hw_value;
420 skb_pull(frame.skb, txpriv->offset);
422 ies = &frame.skb->data[sizeof(struct ieee80211_hdr_3addr)];
423 ies_len = frame.skb->len - sizeof(struct ieee80211_hdr_3addr);
427 (u8 *)cfg80211_find_ie(WLAN_EID_SSID, ies, ies_len);
428 if (ssidie && ssidie[1] && ssidie[1] <= sizeof(ssids[0].ssid)) {
429 u8 *nextie = &ssidie[2 + ssidie[1]];
430 /* Remove SSID from the IE list. It has to be provided
431 * as a separate argument in cw1200_scan_start call
434 /* Store SSID localy */
435 ssids[0].length = ssidie[1];
436 memcpy(ssids[0].ssid, &ssidie[2], ssids[0].length);
439 /* Remove SSID from IE list */
441 memmove(&ssidie[2], nextie, &ies[ies_len] - nextie);
442 skb_trim(frame.skb, frame.skb->len - ssids[0].length);
446 /* FW bug: driver has to restart p2p-dev mode after scan */
447 if (priv->join_status == CW1200_JOIN_STATUS_MONITOR)
448 cw1200_disable_listening(priv);
449 ret = wsm_set_template_frame(priv, &frame);
450 priv->scan.direct_probe = 1;
453 ret = cw1200_scan_start(priv, &scan);
455 mutex_unlock(&priv->conf_mutex);
457 skb_push(frame.skb, txpriv->offset);
459 IEEE80211_SKB_CB(frame.skb)->flags |= IEEE80211_TX_STAT_ACK;
460 BUG_ON(cw1200_queue_remove(queue, priv->pending_frame_id));
463 priv->scan.direct_probe = 0;
464 up(&priv->scan.lock);