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