drivers/net/wireless/ti/wlcore/testmode.c

   1 /*
   2  * This file is part of wl1271
   3  *
   4  * Copyright (C) 2010 Nokia Corporation
   5  *
   6  * Contact: Luciano Coelho <luciano.coelho@nokia.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * version 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  *
  22  */
  23 #include "testmode.h"
  24
  25 #include <linux/pm_runtime.h>
  26 #include <linux/slab.h>
  27 #include <net/genetlink.h>
  28
  29 #include "wlcore.h"
  30 #include "debug.h"
  31 #include "acx.h"
  32 #include "io.h"
  33
  34 #define WL1271_TM_MAX_DATA_LENGTH 1024
  35
  36 enum wl1271_tm_commands {
  37         WL1271_TM_CMD_UNSPEC,
  38         WL1271_TM_CMD_TEST,
  39         WL1271_TM_CMD_INTERROGATE,
  40         WL1271_TM_CMD_CONFIGURE,
  41         WL1271_TM_CMD_NVS_PUSH,         /* Not in use. Keep to not break ABI */
  42         WL1271_TM_CMD_SET_PLT_MODE,
  43         WL1271_TM_CMD_RECOVER,          /* Not in use. Keep to not break ABI */
  44         WL1271_TM_CMD_GET_MAC,
  45
  46         __WL1271_TM_CMD_AFTER_LAST
  47 };
  48 #define WL1271_TM_CMD_MAX (__WL1271_TM_CMD_AFTER_LAST - 1)
  49
  50 enum wl1271_tm_attrs {
  51         WL1271_TM_ATTR_UNSPEC,
  52         WL1271_TM_ATTR_CMD_ID,
  53         WL1271_TM_ATTR_ANSWER,
  54         WL1271_TM_ATTR_DATA,
  55         WL1271_TM_ATTR_IE_ID,
  56         WL1271_TM_ATTR_PLT_MODE,
  57
  58         __WL1271_TM_ATTR_AFTER_LAST
  59 };
  60 #define WL1271_TM_ATTR_MAX (__WL1271_TM_ATTR_AFTER_LAST - 1)
  61
  62 static struct nla_policy wl1271_tm_policy[WL1271_TM_ATTR_MAX + 1] = {
  63         [WL1271_TM_ATTR_CMD_ID] =       { .type = NLA_U32 },
  64         [WL1271_TM_ATTR_ANSWER] =       { .type = NLA_U8 },
  65         [WL1271_TM_ATTR_DATA] =         { .type = NLA_BINARY,
  66                                           .len = WL1271_TM_MAX_DATA_LENGTH },
  67         [WL1271_TM_ATTR_IE_ID] =        { .type = NLA_U32 },
  68         [WL1271_TM_ATTR_PLT_MODE] =     { .type = NLA_U32 },
  69 };
  70
  71
  72 static int wl1271_tm_cmd_test(struct wl1271 *wl, struct nlattr *tb[])
  73 {
  74         int buf_len, ret, len;
  75         struct sk_buff *skb;
  76         void *buf;
  77         u8 answer = 0;
  78
  79         wl1271_debug(DEBUG_TESTMODE, "testmode cmd test");
  80
  81         if (!tb[WL1271_TM_ATTR_DATA])
  82                 return -EINVAL;
  83
  84         buf = nla_data(tb[WL1271_TM_ATTR_DATA]);
  85         buf_len = nla_len(tb[WL1271_TM_ATTR_DATA]);
  86
  87         if (tb[WL1271_TM_ATTR_ANSWER])
  88                 answer = nla_get_u8(tb[WL1271_TM_ATTR_ANSWER]);
  89
  90         if (buf_len > sizeof(struct wl1271_command))
  91                 return -EMSGSIZE;
  92
  93         mutex_lock(&wl->mutex);
  94
  95         if (unlikely(wl->state != WLCORE_STATE_ON)) {
  96                 ret = -EINVAL;
  97                 goto out;
  98         }
  99
 100         ret = pm_runtime_get_sync(wl->dev);
 101         if (ret < 0) {
 102                 pm_runtime_put_noidle(wl->dev);
 103                 goto out;
 104         }
 105
 106         ret = wl1271_cmd_test(wl, buf, buf_len, answer);
 107         if (ret < 0) {
 108                 wl1271_warning("testmode cmd test failed: %d", ret);
 109                 goto out_sleep;
 110         }
 111
 112         if (answer) {
 113                 /* If we got bip calibration answer print radio status */
 114                 struct wl1271_cmd_cal_p2g *params =
 115                         (struct wl1271_cmd_cal_p2g *) buf;
 116
 117                 s16 radio_status = (s16) le16_to_cpu(params->radio_status);
 118
 119                 if (params->test.id == TEST_CMD_P2G_CAL &&
 120                     radio_status < 0)
 121                         wl1271_warning("testmode cmd: radio status=%d",
 122                                         radio_status);
 123                 else
 124                         wl1271_info("testmode cmd: radio status=%d",
 125                                         radio_status);
 126
 127                 len = nla_total_size(buf_len);
 128                 skb = cfg80211_testmode_alloc_reply_skb(wl->hw->wiphy, len);
 129                 if (!skb) {
 130                         ret = -ENOMEM;
 131                         goto out_sleep;
 132                 }
 133
 134                 if (nla_put(skb, WL1271_TM_ATTR_DATA, buf_len, buf)) {
 135                         kfree_skb(skb);
 136                         ret = -EMSGSIZE;
 137                         goto out_sleep;
 138                 }
 139
 140                 ret = cfg80211_testmode_reply(skb);
 141                 if (ret < 0)
 142                         goto out_sleep;
 143         }
 144
 145 out_sleep:
 146         pm_runtime_mark_last_busy(wl->dev);
 147         pm_runtime_put_autosuspend(wl->dev);
 148 out:
 149         mutex_unlock(&wl->mutex);
 150
 151         return ret;
 152 }
 153
 154 static int wl1271_tm_cmd_interrogate(struct wl1271 *wl, struct nlattr *tb[])
 155 {
 156         int ret;
 157         struct wl1271_command *cmd;
 158         struct sk_buff *skb;
 159         u8 ie_id;
 160
 161         wl1271_debug(DEBUG_TESTMODE, "testmode cmd interrogate");
 162
 163         if (!tb[WL1271_TM_ATTR_IE_ID])
 164                 return -EINVAL;
 165
 166         ie_id = nla_get_u8(tb[WL1271_TM_ATTR_IE_ID]);
 167
 168         mutex_lock(&wl->mutex);
 169
 170         if (unlikely(wl->state != WLCORE_STATE_ON)) {
 171                 ret = -EINVAL;
 172                 goto out;
 173         }
 174
 175         ret = pm_runtime_get_sync(wl->dev);
 176         if (ret < 0) {
 177                 pm_runtime_put_noidle(wl->dev);
 178                 goto out;
 179         }
 180
 181         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 182         if (!cmd) {
 183                 ret = -ENOMEM;
 184                 goto out_sleep;
 185         }
 186
 187         ret = wl1271_cmd_interrogate(wl, ie_id, cmd,
 188                                      sizeof(struct acx_header), sizeof(*cmd));
 189         if (ret < 0) {
 190                 wl1271_warning("testmode cmd interrogate failed: %d", ret);
 191                 goto out_free;
 192         }
 193
 194         skb = cfg80211_testmode_alloc_reply_skb(wl->hw->wiphy, sizeof(*cmd));
 195         if (!skb) {
 196                 ret = -ENOMEM;
 197                 goto out_free;
 198         }
 199
 200         if (nla_put(skb, WL1271_TM_ATTR_DATA, sizeof(*cmd), cmd)) {
 201                 kfree_skb(skb);
 202                 ret = -EMSGSIZE;
 203                 goto out_free;
 204         }
 205
 206         ret = cfg80211_testmode_reply(skb);
 207         if (ret < 0)
 208                 goto out_free;
 209
 210 out_free:
 211         kfree(cmd);
 212 out_sleep:
 213         pm_runtime_mark_last_busy(wl->dev);
 214         pm_runtime_put_autosuspend(wl->dev);
 215 out:
 216         mutex_unlock(&wl->mutex);
 217
 218         return ret;
 219 }
 220
 221 static int wl1271_tm_cmd_configure(struct wl1271 *wl, struct nlattr *tb[])
 222 {
 223         int buf_len, ret;
 224         void *buf;
 225         u8 ie_id;
 226
 227         wl1271_debug(DEBUG_TESTMODE, "testmode cmd configure");
 228
 229         if (!tb[WL1271_TM_ATTR_DATA])
 230                 return -EINVAL;
 231         if (!tb[WL1271_TM_ATTR_IE_ID])
 232                 return -EINVAL;
 233
 234         ie_id = nla_get_u8(tb[WL1271_TM_ATTR_IE_ID]);
 235         buf = nla_data(tb[WL1271_TM_ATTR_DATA]);
 236         buf_len = nla_len(tb[WL1271_TM_ATTR_DATA]);
 237
 238         if (buf_len > sizeof(struct wl1271_command))
 239                 return -EMSGSIZE;
 240
 241         mutex_lock(&wl->mutex);
 242         ret = wl1271_cmd_configure(wl, ie_id, buf, buf_len);
 243         mutex_unlock(&wl->mutex);
 244
 245         if (ret < 0) {
 246                 wl1271_warning("testmode cmd configure failed: %d", ret);
 247                 return ret;
 248         }
 249
 250         return 0;
 251 }
 252
 253 static int wl1271_tm_detect_fem(struct wl1271 *wl, struct nlattr *tb[])
 254 {
 255         /* return FEM type */
 256         int ret, len;
 257         struct sk_buff *skb;
 258
 259         ret = wl1271_plt_start(wl, PLT_FEM_DETECT);
 260         if (ret < 0)
 261                 goto out;
 262
 263         mutex_lock(&wl->mutex);
 264
 265         len = nla_total_size(sizeof(wl->fem_manuf));
 266         skb = cfg80211_testmode_alloc_reply_skb(wl->hw->wiphy, len);
 267         if (!skb) {
 268                 ret = -ENOMEM;
 269                 goto out_mutex;
 270         }
 271
 272         if (nla_put(skb, WL1271_TM_ATTR_DATA, sizeof(wl->fem_manuf),
 273                                               &wl->fem_manuf)) {
 274                 kfree_skb(skb);
 275                 ret = -EMSGSIZE;
 276                 goto out_mutex;
 277         }
 278
 279         ret = cfg80211_testmode_reply(skb);
 280
 281 out_mutex:
 282         mutex_unlock(&wl->mutex);
 283
 284         /* We always stop plt after DETECT mode */
 285         wl1271_plt_stop(wl);
 286 out:
 287         return ret;
 288 }
 289
 290 static int wl1271_tm_cmd_set_plt_mode(struct wl1271 *wl, struct nlattr *tb[])
 291 {
 292         u32 val;
 293         int ret;
 294
 295         wl1271_debug(DEBUG_TESTMODE, "testmode cmd set plt mode");
 296
 297         if (!tb[WL1271_TM_ATTR_PLT_MODE])
 298                 return -EINVAL;
 299
 300         val = nla_get_u32(tb[WL1271_TM_ATTR_PLT_MODE]);
 301
 302         switch (val) {
 303         case PLT_OFF:
 304                 ret = wl1271_plt_stop(wl);
 305                 break;
 306         case PLT_ON:
 307         case PLT_CHIP_AWAKE:
 308                 ret = wl1271_plt_start(wl, val);
 309                 break;
 310         case PLT_FEM_DETECT:
 311                 ret = wl1271_tm_detect_fem(wl, tb);
 312                 break;
 313         default:
 314                 ret = -EINVAL;
 315                 break;
 316         }
 317
 318         return ret;
 319 }
 320
 321 static int wl12xx_tm_cmd_get_mac(struct wl1271 *wl, struct nlattr *tb[])
 322 {
 323         struct sk_buff *skb;
 324         u8 mac_addr[ETH_ALEN];
 325         int ret = 0;
 326
 327         mutex_lock(&wl->mutex);
 328
 329         if (!wl->plt) {
 330                 ret = -EINVAL;
 331                 goto out;
 332         }
 333
 334         if (wl->fuse_oui_addr == 0 && wl->fuse_nic_addr == 0) {
 335                 ret = -EOPNOTSUPP;
 336                 goto out;
 337         }
 338
 339         mac_addr[0] = (u8)(wl->fuse_oui_addr >> 16);
 340         mac_addr[1] = (u8)(wl->fuse_oui_addr >> 8);
 341         mac_addr[2] = (u8) wl->fuse_oui_addr;
 342         mac_addr[3] = (u8)(wl->fuse_nic_addr >> 16);
 343         mac_addr[4] = (u8)(wl->fuse_nic_addr >> 8);
 344         mac_addr[5] = (u8) wl->fuse_nic_addr;
 345
 346         skb = cfg80211_testmode_alloc_reply_skb(wl->hw->wiphy, ETH_ALEN);
 347         if (!skb) {
 348                 ret = -ENOMEM;
 349                 goto out;
 350         }
 351
 352         if (nla_put(skb, WL1271_TM_ATTR_DATA, ETH_ALEN, mac_addr)) {
 353                 kfree_skb(skb);
 354                 ret = -EMSGSIZE;
 355                 goto out;
 356         }
 357
 358         ret = cfg80211_testmode_reply(skb);
 359         if (ret < 0)
 360                 goto out;
 361
 362 out:
 363         mutex_unlock(&wl->mutex);
 364         return ret;
 365 }
 366
 367 int wl1271_tm_cmd(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
 368                   void *data, int len)
 369 {
 370         struct wl1271 *wl = hw->priv;
 371         struct nlattr *tb[WL1271_TM_ATTR_MAX + 1];
 372         u32 nla_cmd;
 373         int err;
 374
 375         err = nla_parse_deprecated(tb, WL1271_TM_ATTR_MAX, data, len,
 376                                    wl1271_tm_policy, NULL);
 377         if (err)
 378                 return err;
 379
 380         if (!tb[WL1271_TM_ATTR_CMD_ID])
 381                 return -EINVAL;
 382
 383         nla_cmd = nla_get_u32(tb[WL1271_TM_ATTR_CMD_ID]);
 384
 385         /* Only SET_PLT_MODE is allowed in case of mode PLT_CHIP_AWAKE */
 386         if (wl->plt_mode == PLT_CHIP_AWAKE &&
 387             nla_cmd != WL1271_TM_CMD_SET_PLT_MODE)
 388                 return -EOPNOTSUPP;
 389
 390         switch (nla_cmd) {
 391         case WL1271_TM_CMD_TEST:
 392                 return wl1271_tm_cmd_test(wl, tb);
 393         case WL1271_TM_CMD_INTERROGATE:
 394                 return wl1271_tm_cmd_interrogate(wl, tb);
 395         case WL1271_TM_CMD_CONFIGURE:
 396                 return wl1271_tm_cmd_configure(wl, tb);
 397         case WL1271_TM_CMD_SET_PLT_MODE:
 398                 return wl1271_tm_cmd_set_plt_mode(wl, tb);
 399         case WL1271_TM_CMD_GET_MAC:
 400                 return wl12xx_tm_cmd_get_mac(wl, tb);
 401         default:
 402                 return -EOPNOTSUPP;
 403         }
 404 }