drivers/net/wireless/wl12xx/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/slab.h>
  26 #include <net/genetlink.h>
  27
  28 #include "wl12xx.h"
  29 #include "acx.h"
  30 #include "reg.h"
  31
  32 #define WL1271_TM_MAX_DATA_LENGTH 1024
  33
  34 enum wl1271_tm_commands {
  35         WL1271_TM_CMD_UNSPEC,
  36         WL1271_TM_CMD_TEST,
  37         WL1271_TM_CMD_INTERROGATE,
  38         WL1271_TM_CMD_CONFIGURE,
  39         WL1271_TM_CMD_NVS_PUSH,
  40         WL1271_TM_CMD_SET_PLT_MODE,
  41         WL1271_TM_CMD_RECOVER,
  42
  43         __WL1271_TM_CMD_AFTER_LAST
  44 };
  45 #define WL1271_TM_CMD_MAX (__WL1271_TM_CMD_AFTER_LAST - 1)
  46
  47 enum wl1271_tm_attrs {
  48         WL1271_TM_ATTR_UNSPEC,
  49         WL1271_TM_ATTR_CMD_ID,
  50         WL1271_TM_ATTR_ANSWER,
  51         WL1271_TM_ATTR_DATA,
  52         WL1271_TM_ATTR_IE_ID,
  53         WL1271_TM_ATTR_PLT_MODE,
  54
  55         __WL1271_TM_ATTR_AFTER_LAST
  56 };
  57 #define WL1271_TM_ATTR_MAX (__WL1271_TM_ATTR_AFTER_LAST - 1)
  58
  59 static struct nla_policy wl1271_tm_policy[WL1271_TM_ATTR_MAX + 1] = {
  60         [WL1271_TM_ATTR_CMD_ID] =       { .type = NLA_U32 },
  61         [WL1271_TM_ATTR_ANSWER] =       { .type = NLA_U8 },
  62         [WL1271_TM_ATTR_DATA] =         { .type = NLA_BINARY,
  63                                           .len = WL1271_TM_MAX_DATA_LENGTH },
  64         [WL1271_TM_ATTR_IE_ID] =        { .type = NLA_U32 },
  65         [WL1271_TM_ATTR_PLT_MODE] =     { .type = NLA_U32 },
  66 };
  67
  68
  69 static int wl1271_tm_cmd_test(struct wl1271 *wl, struct nlattr *tb[])
  70 {
  71         int buf_len, ret, len;
  72         struct sk_buff *skb;
  73         void *buf;
  74         u8 answer = 0;
  75
  76         wl1271_debug(DEBUG_TESTMODE, "testmode cmd test");
  77
  78         if (!tb[WL1271_TM_ATTR_DATA])
  79                 return -EINVAL;
  80
  81         buf = nla_data(tb[WL1271_TM_ATTR_DATA]);
  82         buf_len = nla_len(tb[WL1271_TM_ATTR_DATA]);
  83
  84         if (tb[WL1271_TM_ATTR_ANSWER])
  85                 answer = nla_get_u8(tb[WL1271_TM_ATTR_ANSWER]);
  86
  87         if (buf_len > sizeof(struct wl1271_command))
  88                 return -EMSGSIZE;
  89
  90         mutex_lock(&wl->mutex);
  91         ret = wl1271_cmd_test(wl, buf, buf_len, answer);
  92         mutex_unlock(&wl->mutex);
  93
  94         if (ret < 0) {
  95                 wl1271_warning("testmode cmd test failed: %d", ret);
  96                 return ret;
  97         }
  98
  99         if (answer) {
 100                 len = nla_total_size(buf_len);
 101                 skb = cfg80211_testmode_alloc_reply_skb(wl->hw->wiphy, len);
 102                 if (!skb)
 103                         return -ENOMEM;
 104
 105                 NLA_PUT(skb, WL1271_TM_ATTR_DATA, buf_len, buf);
 106                 ret = cfg80211_testmode_reply(skb);
 107                 if (ret < 0)
 108                         return ret;
 109         }
 110
 111         return 0;
 112
 113 nla_put_failure:
 114         kfree_skb(skb);
 115         return -EMSGSIZE;
 116 }
 117
 118 static int wl1271_tm_cmd_interrogate(struct wl1271 *wl, struct nlattr *tb[])
 119 {
 120         int ret;
 121         struct wl1271_command *cmd;
 122         struct sk_buff *skb;
 123         u8 ie_id;
 124
 125         wl1271_debug(DEBUG_TESTMODE, "testmode cmd interrogate");
 126
 127         if (!tb[WL1271_TM_ATTR_IE_ID])
 128                 return -EINVAL;
 129
 130         ie_id = nla_get_u8(tb[WL1271_TM_ATTR_IE_ID]);
 131
 132         cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
 133         if (!cmd)
 134                 return -ENOMEM;
 135
 136         mutex_lock(&wl->mutex);
 137         ret = wl1271_cmd_interrogate(wl, ie_id, cmd, sizeof(*cmd));
 138         mutex_unlock(&wl->mutex);
 139
 140         if (ret < 0) {
 141                 wl1271_warning("testmode cmd interrogate failed: %d", ret);
 142                 return ret;
 143         }
 144
 145         skb = cfg80211_testmode_alloc_reply_skb(wl->hw->wiphy, sizeof(*cmd));
 146         if (!skb)
 147                 return -ENOMEM;
 148
 149         NLA_PUT(skb, WL1271_TM_ATTR_DATA, sizeof(*cmd), cmd);
 150
 151         return 0;
 152
 153 nla_put_failure:
 154         kfree_skb(skb);
 155         return -EMSGSIZE;
 156 }
 157
 158 static int wl1271_tm_cmd_configure(struct wl1271 *wl, struct nlattr *tb[])
 159 {
 160         int buf_len, ret;
 161         void *buf;
 162         u8 ie_id;
 163
 164         wl1271_debug(DEBUG_TESTMODE, "testmode cmd configure");
 165
 166         if (!tb[WL1271_TM_ATTR_DATA])
 167                 return -EINVAL;
 168         if (!tb[WL1271_TM_ATTR_IE_ID])
 169                 return -EINVAL;
 170
 171         ie_id = nla_get_u8(tb[WL1271_TM_ATTR_IE_ID]);
 172         buf = nla_data(tb[WL1271_TM_ATTR_DATA]);
 173         buf_len = nla_len(tb[WL1271_TM_ATTR_DATA]);
 174
 175         if (buf_len > sizeof(struct wl1271_command))
 176                 return -EMSGSIZE;
 177
 178         mutex_lock(&wl->mutex);
 179         ret = wl1271_cmd_configure(wl, ie_id, buf, buf_len);
 180         mutex_unlock(&wl->mutex);
 181
 182         if (ret < 0) {
 183                 wl1271_warning("testmode cmd configure failed: %d", ret);
 184                 return ret;
 185         }
 186
 187         return 0;
 188 }
 189
 190 static int wl1271_tm_cmd_nvs_push(struct wl1271 *wl, struct nlattr *tb[])
 191 {
 192         int ret = 0;
 193         size_t len;
 194         void *buf;
 195
 196         wl1271_debug(DEBUG_TESTMODE, "testmode cmd nvs push");
 197
 198         if (!tb[WL1271_TM_ATTR_DATA])
 199                 return -EINVAL;
 200
 201         buf = nla_data(tb[WL1271_TM_ATTR_DATA]);
 202         len = nla_len(tb[WL1271_TM_ATTR_DATA]);
 203
 204         mutex_lock(&wl->mutex);
 205
 206         kfree(wl->nvs);
 207
 208         if ((wl->chip.id == CHIP_ID_1283_PG20) &&
 209             (len != sizeof(struct wl128x_nvs_file)))
 210                 return -EINVAL;
 211         else if (len != sizeof(struct wl1271_nvs_file))
 212                 return -EINVAL;
 213
 214         wl->nvs = kzalloc(len, GFP_KERNEL);
 215         if (!wl->nvs) {
 216                 wl1271_error("could not allocate memory for the nvs file");
 217                 ret = -ENOMEM;
 218                 goto out;
 219         }
 220
 221         memcpy(wl->nvs, buf, len);
 222         wl->nvs_len = len;
 223
 224         wl1271_debug(DEBUG_TESTMODE, "testmode pushed nvs");
 225
 226 out:
 227         mutex_unlock(&wl->mutex);
 228
 229         return ret;
 230 }
 231
 232 static int wl1271_tm_cmd_set_plt_mode(struct wl1271 *wl, struct nlattr *tb[])
 233 {
 234         u32 val;
 235         int ret;
 236
 237         wl1271_debug(DEBUG_TESTMODE, "testmode cmd set plt mode");
 238
 239         if (!tb[WL1271_TM_ATTR_PLT_MODE])
 240                 return -EINVAL;
 241
 242         val = nla_get_u32(tb[WL1271_TM_ATTR_PLT_MODE]);
 243
 244         switch (val) {
 245         case 0:
 246                 ret = wl1271_plt_stop(wl);
 247                 break;
 248         case 1:
 249                 ret = wl1271_plt_start(wl);
 250                 break;
 251         default:
 252                 ret = -EINVAL;
 253                 break;
 254         }
 255
 256         return ret;
 257 }
 258
 259 static int wl1271_tm_cmd_recover(struct wl1271 *wl, struct nlattr *tb[])
 260 {
 261         wl1271_debug(DEBUG_TESTMODE, "testmode cmd recover");
 262
 263         wl12xx_queue_recovery_work(wl);
 264
 265         return 0;
 266 }
 267
 268 int wl1271_tm_cmd(struct ieee80211_hw *hw, void *data, int len)
 269 {
 270         struct wl1271 *wl = hw->priv;
 271         struct nlattr *tb[WL1271_TM_ATTR_MAX + 1];
 272         int err;
 273
 274         err = nla_parse(tb, WL1271_TM_ATTR_MAX, data, len, wl1271_tm_policy);
 275         if (err)
 276                 return err;
 277
 278         if (!tb[WL1271_TM_ATTR_CMD_ID])
 279                 return -EINVAL;
 280
 281         switch (nla_get_u32(tb[WL1271_TM_ATTR_CMD_ID])) {
 282         case WL1271_TM_CMD_TEST:
 283                 return wl1271_tm_cmd_test(wl, tb);
 284         case WL1271_TM_CMD_INTERROGATE:
 285                 return wl1271_tm_cmd_interrogate(wl, tb);
 286         case WL1271_TM_CMD_CONFIGURE:
 287                 return wl1271_tm_cmd_configure(wl, tb);
 288         case WL1271_TM_CMD_NVS_PUSH:
 289                 return wl1271_tm_cmd_nvs_push(wl, tb);
 290         case WL1271_TM_CMD_SET_PLT_MODE:
 291                 return wl1271_tm_cmd_set_plt_mode(wl, tb);
 292         case WL1271_TM_CMD_RECOVER:
 293                 return wl1271_tm_cmd_recover(wl, tb);
 294         default:
 295                 return -EOPNOTSUPP;
 296         }
 297 }