blob: b8044bcd5044c7ee2a4933d701d0d8e21b4d98f1 [file] [log] [blame]
Cindy H. Kao4613e722011-05-06 10:40:15 -07001/******************************************************************************
2 *
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
5 *
6 * GPL LICENSE SUMMARY
7 *
Wey-Yi Guy4e318262011-12-27 11:21:32 -08008 * Copyright(c) 2010 - 2012 Intel Corporation. All rights reserved.
Cindy H. Kao4613e722011-05-06 10:40:15 -07009 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
22 * USA
23 *
24 * The full GNU General Public License is included in this distribution
25 * in the file called LICENSE.GPL.
26 *
27 * Contact Information:
28 * Intel Linux Wireless <ilw@linux.intel.com>
29 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30 *
31 * BSD LICENSE
32 *
Wey-Yi Guy4e318262011-12-27 11:21:32 -080033 * Copyright(c) 2010 - 2012 Intel Corporation. All rights reserved.
Cindy H. Kao4613e722011-05-06 10:40:15 -070034 * All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 *
40 * * Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * * Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in
44 * the documentation and/or other materials provided with the
45 * distribution.
46 * * Neither the name Intel Corporation nor the names of its
47 * contributors may be used to endorse or promote products derived
48 * from this software without specific prior written permission.
49 *
50 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
54 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
60 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61 *
62 *****************************************************************************/
63#include <linux/init.h>
64#include <linux/kernel.h>
65#include <linux/module.h>
Emmanuel Grumbach522376d2011-09-06 09:31:19 -070066#include <linux/dma-mapping.h>
Cindy H. Kao4613e722011-05-06 10:40:15 -070067#include <net/net_namespace.h>
68#include <linux/netdevice.h>
69#include <net/cfg80211.h>
70#include <net/mac80211.h>
71#include <net/netlink.h>
72
Cindy H. Kao4613e722011-05-06 10:40:15 -070073#include "iwl-dev.h"
74#include "iwl-core.h"
75#include "iwl-debug.h"
Cindy H. Kao4613e722011-05-06 10:40:15 -070076#include "iwl-io.h"
77#include "iwl-agn.h"
78#include "iwl-testmode.h"
Emmanuel Grumbachbdfbf092011-07-08 08:46:16 -070079#include "iwl-trans.h"
Amit Beka6fe7dd02012-01-25 09:19:24 +020080#include "iwl-fh.h"
Johannes Bergeae63b82012-03-06 13:31:06 -080081#include "iwl-prph.h"
Cindy H. Kao4613e722011-05-06 10:40:15 -070082
Amit Beka6c55f5e2012-01-25 13:30:27 +020083
84/* Periphery registers absolute lower bound. This is used in order to
85 * differentiate registery access through HBUS_TARG_PRPH_* and
86 * HBUS_TARG_MEM_* accesses.
87 */
88#define IWL_TM_ABS_PRPH_START (0xA00000)
89
Cindy H. Kao4613e722011-05-06 10:40:15 -070090/* The TLVs used in the gnl message policy between the kernel module and
91 * user space application. iwl_testmode_gnl_msg_policy is to be carried
92 * through the NL80211_CMD_TESTMODE channel regulated by nl80211.
93 * See iwl-testmode.h
94 */
95static
96struct nla_policy iwl_testmode_gnl_msg_policy[IWL_TM_ATTR_MAX] = {
97 [IWL_TM_ATTR_COMMAND] = { .type = NLA_U32, },
98
99 [IWL_TM_ATTR_UCODE_CMD_ID] = { .type = NLA_U8, },
100 [IWL_TM_ATTR_UCODE_CMD_DATA] = { .type = NLA_UNSPEC, },
101
102 [IWL_TM_ATTR_REG_OFFSET] = { .type = NLA_U32, },
103 [IWL_TM_ATTR_REG_VALUE8] = { .type = NLA_U8, },
104 [IWL_TM_ATTR_REG_VALUE32] = { .type = NLA_U32, },
105
106 [IWL_TM_ATTR_SYNC_RSP] = { .type = NLA_UNSPEC, },
107 [IWL_TM_ATTR_UCODE_RX_PKT] = { .type = NLA_UNSPEC, },
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700108
Wey-Yi Guy4babc352011-05-03 18:05:12 -0700109 [IWL_TM_ATTR_EEPROM] = { .type = NLA_UNSPEC, },
110
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700111 [IWL_TM_ATTR_TRACE_ADDR] = { .type = NLA_UNSPEC, },
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -0700112 [IWL_TM_ATTR_TRACE_DUMP] = { .type = NLA_UNSPEC, },
Wey-Yi Guy49b72102011-05-30 10:29:37 -0700113 [IWL_TM_ATTR_TRACE_SIZE] = { .type = NLA_U32, },
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700114
Wey-Yi Guy64898542011-05-03 18:05:13 -0700115 [IWL_TM_ATTR_FIXRATE] = { .type = NLA_U32, },
Wey-Yi Guy49b72102011-05-30 10:29:37 -0700116
Wey-Yi Guye98a1932011-07-08 08:46:26 -0700117 [IWL_TM_ATTR_UCODE_OWNER] = { .type = NLA_U8, },
Hsu, Kenny306713f2011-11-22 23:03:39 -0800118
Amit Beka6c55f5e2012-01-25 13:30:27 +0200119 [IWL_TM_ATTR_MEM_ADDR] = { .type = NLA_U32, },
120 [IWL_TM_ATTR_BUFFER_SIZE] = { .type = NLA_U32, },
121 [IWL_TM_ATTR_BUFFER_DUMP] = { .type = NLA_UNSPEC, },
Hsu, Kennye1a38fe2011-11-28 00:55:38 -0800122
123 [IWL_TM_ATTR_FW_VERSION] = { .type = NLA_U32, },
Hsu, Kenny0bec12b2011-12-01 01:12:50 -0800124 [IWL_TM_ATTR_DEVICE_ID] = { .type = NLA_U32, },
Kenny Hsuaca9b5f2011-12-24 12:12:12 +0800125 [IWL_TM_ATTR_FW_TYPE] = { .type = NLA_U32, },
126 [IWL_TM_ATTR_FW_INST_SIZE] = { .type = NLA_U32, },
127 [IWL_TM_ATTR_FW_DATA_SIZE] = { .type = NLA_U32, },
Amit Beka0aef8dd2012-03-07 09:52:29 -0800128
129 [IWL_TM_ATTR_ENABLE_NOTIFICATION] = {.type = NLA_FLAG, },
Cindy H. Kao4613e722011-05-06 10:40:15 -0700130};
131
132/*
133 * See the struct iwl_rx_packet in iwl-commands.h for the format of the
134 * received events from the device
135 */
Johannes Berg48a2d662012-03-05 11:24:39 -0800136static inline int get_event_length(struct iwl_rx_cmd_buffer *rxb)
Cindy H. Kao4613e722011-05-06 10:40:15 -0700137{
138 struct iwl_rx_packet *pkt = rxb_addr(rxb);
139 if (pkt)
140 return le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
141 else
142 return 0;
143}
144
145
146/*
147 * This function multicasts the spontaneous messages from the device to the
148 * user space. It is invoked whenever there is a received messages
149 * from the device. This function is called within the ISR of the rx handlers
150 * in iwlagn driver.
151 *
152 * The parsing of the message content is left to the user space application,
153 * The message content is treated as unattacked raw data and is encapsulated
154 * with IWL_TM_ATTR_UCODE_RX_PKT multicasting to the user space.
155 *
156 * @priv: the instance of iwlwifi device
157 * @rxb: pointer to rx data content received by the ISR
158 *
159 * See the message policies and TLVs in iwl_testmode_gnl_msg_policy[].
160 * For the messages multicasting to the user application, the mandatory
161 * TLV fields are :
162 * IWL_TM_ATTR_COMMAND must be IWL_TM_CMD_DEV2APP_UCODE_RX_PKT
163 * IWL_TM_ATTR_UCODE_RX_PKT for carrying the message content
164 */
165
166static void iwl_testmode_ucode_rx_pkt(struct iwl_priv *priv,
Johannes Berg48a2d662012-03-05 11:24:39 -0800167 struct iwl_rx_cmd_buffer *rxb)
Cindy H. Kao4613e722011-05-06 10:40:15 -0700168{
169 struct ieee80211_hw *hw = priv->hw;
170 struct sk_buff *skb;
171 void *data;
172 int length;
173
174 data = (void *)rxb_addr(rxb);
175 length = get_event_length(rxb);
176
177 if (!data || length == 0)
178 return;
179
180 skb = cfg80211_testmode_alloc_event_skb(hw->wiphy, 20 + length,
181 GFP_ATOMIC);
182 if (skb == NULL) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800183 IWL_ERR(priv,
Cindy H. Kao4613e722011-05-06 10:40:15 -0700184 "Run out of memory for messages to user space ?\n");
185 return;
186 }
187 NLA_PUT_U32(skb, IWL_TM_ATTR_COMMAND, IWL_TM_CMD_DEV2APP_UCODE_RX_PKT);
188 NLA_PUT(skb, IWL_TM_ATTR_UCODE_RX_PKT, length, data);
189 cfg80211_testmode_event(skb, GFP_ATOMIC);
190 return;
191
192nla_put_failure:
193 kfree_skb(skb);
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800194 IWL_ERR(priv, "Ouch, overran buffer, check allocation!\n");
Cindy H. Kao4613e722011-05-06 10:40:15 -0700195}
196
197void iwl_testmode_init(struct iwl_priv *priv)
198{
Amit Beka0aef8dd2012-03-07 09:52:29 -0800199 priv->pre_rx_handler = NULL;
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700200 priv->testmode_trace.trace_enabled = false;
Amit Beka6c55f5e2012-01-25 13:30:27 +0200201 priv->testmode_mem.read_in_progress = false;
Hsu, Kenny306713f2011-11-22 23:03:39 -0800202}
203
Amit Beka6c55f5e2012-01-25 13:30:27 +0200204static void iwl_mem_cleanup(struct iwl_priv *priv)
Hsu, Kenny306713f2011-11-22 23:03:39 -0800205{
Amit Beka6c55f5e2012-01-25 13:30:27 +0200206 if (priv->testmode_mem.read_in_progress) {
207 kfree(priv->testmode_mem.buff_addr);
208 priv->testmode_mem.buff_addr = NULL;
209 priv->testmode_mem.buff_size = 0;
210 priv->testmode_mem.num_chunks = 0;
211 priv->testmode_mem.read_in_progress = false;
Hsu, Kenny306713f2011-11-22 23:03:39 -0800212 }
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700213}
214
215static void iwl_trace_cleanup(struct iwl_priv *priv)
216{
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700217 if (priv->testmode_trace.trace_enabled) {
218 if (priv->testmode_trace.cpu_addr &&
219 priv->testmode_trace.dma_addr)
Emmanuel Grumbach1042db22012-01-03 16:56:15 +0200220 dma_free_coherent(trans(priv)->dev,
Wey-Yi Guy49b72102011-05-30 10:29:37 -0700221 priv->testmode_trace.total_size,
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700222 priv->testmode_trace.cpu_addr,
223 priv->testmode_trace.dma_addr);
224 priv->testmode_trace.trace_enabled = false;
225 priv->testmode_trace.cpu_addr = NULL;
226 priv->testmode_trace.trace_addr = NULL;
227 priv->testmode_trace.dma_addr = 0;
Wey-Yi Guy49b72102011-05-30 10:29:37 -0700228 priv->testmode_trace.buff_size = 0;
229 priv->testmode_trace.total_size = 0;
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700230 }
231}
232
233
234void iwl_testmode_cleanup(struct iwl_priv *priv)
235{
236 iwl_trace_cleanup(priv);
Amit Beka6c55f5e2012-01-25 13:30:27 +0200237 iwl_mem_cleanup(priv);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700238}
239
Amit Bekacdfef6c2012-01-31 15:30:39 +0200240
Cindy H. Kao4613e722011-05-06 10:40:15 -0700241/*
242 * This function handles the user application commands to the ucode.
243 *
244 * It retrieves the mandatory fields IWL_TM_ATTR_UCODE_CMD_ID and
245 * IWL_TM_ATTR_UCODE_CMD_DATA and calls to the handler to send the
246 * host command to the ucode.
247 *
248 * If any mandatory field is missing, -ENOMSG is replied to the user space
Amit Bekacdfef6c2012-01-31 15:30:39 +0200249 * application; otherwise, waits for the host command to be sent and checks
250 * the return code. In case or error, it is returned, otherwise a reply is
251 * allocated and the reply RX packet
252 * is returned.
Cindy H. Kao4613e722011-05-06 10:40:15 -0700253 *
254 * @hw: ieee80211_hw object that represents the device
255 * @tb: gnl message fields from the user space
256 */
257static int iwl_testmode_ucode(struct ieee80211_hw *hw, struct nlattr **tb)
258{
Emmanuel Grumbachd0f76d62012-02-09 16:08:15 +0200259 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700260 struct iwl_host_cmd cmd;
Amit Bekacdfef6c2012-01-31 15:30:39 +0200261 struct iwl_rx_packet *pkt;
262 struct sk_buff *skb;
263 void *reply_buf;
264 u32 reply_len;
265 int ret;
266 bool cmd_want_skb;
Cindy H. Kao4613e722011-05-06 10:40:15 -0700267
268 memset(&cmd, 0, sizeof(struct iwl_host_cmd));
269
270 if (!tb[IWL_TM_ATTR_UCODE_CMD_ID] ||
271 !tb[IWL_TM_ATTR_UCODE_CMD_DATA]) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800272 IWL_ERR(priv, "Missing ucode command mandatory fields\n");
Cindy H. Kao4613e722011-05-06 10:40:15 -0700273 return -ENOMSG;
274 }
275
Amit Bekacdfef6c2012-01-31 15:30:39 +0200276 cmd.flags = CMD_ON_DEMAND | CMD_SYNC;
277 cmd_want_skb = nla_get_flag(tb[IWL_TM_ATTR_UCODE_CMD_SKB]);
278 if (cmd_want_skb)
279 cmd.flags |= CMD_WANT_SKB;
280
Cindy H. Kao4613e722011-05-06 10:40:15 -0700281 cmd.id = nla_get_u8(tb[IWL_TM_ATTR_UCODE_CMD_ID]);
Johannes Berg3fa50732011-05-04 07:50:38 -0700282 cmd.data[0] = nla_data(tb[IWL_TM_ATTR_UCODE_CMD_DATA]);
283 cmd.len[0] = nla_len(tb[IWL_TM_ATTR_UCODE_CMD_DATA]);
Johannes Berg4ce7cc22011-05-13 11:57:40 -0700284 cmd.dataflags[0] = IWL_HCMD_DFL_NOCOPY;
Amit Bekacdfef6c2012-01-31 15:30:39 +0200285 IWL_DEBUG_INFO(priv, "testmode ucode command ID 0x%x, flags 0x%x,"
Johannes Berg3fa50732011-05-04 07:50:38 -0700286 " len %d\n", cmd.id, cmd.flags, cmd.len[0]);
Amit Bekacdfef6c2012-01-31 15:30:39 +0200287
Johannes Berge10a0532012-03-06 13:30:39 -0800288 ret = iwl_dvm_send_cmd(priv, &cmd);
Amit Bekacdfef6c2012-01-31 15:30:39 +0200289 if (ret) {
290 IWL_ERR(priv, "Failed to send hcmd\n");
291 return ret;
292 }
293 if (!cmd_want_skb)
294 return ret;
295
296 /* Handling return of SKB to the user */
Johannes Berg65b94a42012-03-05 11:24:38 -0800297 pkt = cmd.resp_pkt;
Amit Bekacdfef6c2012-01-31 15:30:39 +0200298 if (!pkt) {
299 IWL_ERR(priv, "HCMD received a null response packet\n");
300 return ret;
301 }
302
303 reply_len = le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
304 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, reply_len + 20);
305 reply_buf = kmalloc(reply_len, GFP_KERNEL);
306 if (!skb || !reply_buf) {
307 kfree_skb(skb);
308 kfree(reply_buf);
309 return -ENOMEM;
310 }
311
312 /* The reply is in a page, that we cannot send to user space. */
Amit Bekaedabfa92012-02-08 10:01:35 +0200313 memcpy(reply_buf, &(pkt->hdr), reply_len);
Johannes Berg65b94a42012-03-05 11:24:38 -0800314 iwl_free_resp(&cmd);
Amit Bekacdfef6c2012-01-31 15:30:39 +0200315
316 NLA_PUT_U32(skb, IWL_TM_ATTR_COMMAND, IWL_TM_CMD_DEV2APP_UCODE_RX_PKT);
317 NLA_PUT(skb, IWL_TM_ATTR_UCODE_RX_PKT, reply_len, reply_buf);
318 return cfg80211_testmode_reply(skb);
319
320nla_put_failure:
321 IWL_DEBUG_INFO(priv, "Failed creating NL attributes\n");
322 return -ENOMSG;
Cindy H. Kao4613e722011-05-06 10:40:15 -0700323}
324
325
326/*
327 * This function handles the user application commands for register access.
328 *
329 * It retrieves command ID carried with IWL_TM_ATTR_COMMAND and calls to the
330 * handlers respectively.
331 *
332 * If it's an unknown commdn ID, -ENOSYS is returned; or -ENOMSG if the
333 * mandatory fields(IWL_TM_ATTR_REG_OFFSET,IWL_TM_ATTR_REG_VALUE32,
334 * IWL_TM_ATTR_REG_VALUE8) are missing; Otherwise 0 is replied indicating
335 * the success of the command execution.
336 *
337 * If IWL_TM_ATTR_COMMAND is IWL_TM_CMD_APP2DEV_REG_READ32, the register read
338 * value is returned with IWL_TM_ATTR_REG_VALUE32.
339 *
340 * @hw: ieee80211_hw object that represents the device
341 * @tb: gnl message fields from the user space
342 */
343static int iwl_testmode_reg(struct ieee80211_hw *hw, struct nlattr **tb)
344{
Emmanuel Grumbachd0f76d62012-02-09 16:08:15 +0200345 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
Amit Beka6fe7dd02012-01-25 09:19:24 +0200346 u32 ofs, val32, cmd;
Cindy H. Kao4613e722011-05-06 10:40:15 -0700347 u8 val8;
348 struct sk_buff *skb;
349 int status = 0;
350
351 if (!tb[IWL_TM_ATTR_REG_OFFSET]) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800352 IWL_ERR(priv, "Missing register offset\n");
Cindy H. Kao4613e722011-05-06 10:40:15 -0700353 return -ENOMSG;
354 }
355 ofs = nla_get_u32(tb[IWL_TM_ATTR_REG_OFFSET]);
356 IWL_INFO(priv, "testmode register access command offset 0x%x\n", ofs);
357
Amit Beka6fe7dd02012-01-25 09:19:24 +0200358 /* Allow access only to FH/CSR/HBUS in direct mode.
359 Since we don't have the upper bounds for the CSR and HBUS segments,
360 we will use only the upper bound of FH for sanity check. */
361 cmd = nla_get_u32(tb[IWL_TM_ATTR_COMMAND]);
362 if ((cmd == IWL_TM_CMD_APP2DEV_DIRECT_REG_READ32 ||
363 cmd == IWL_TM_CMD_APP2DEV_DIRECT_REG_WRITE32 ||
364 cmd == IWL_TM_CMD_APP2DEV_DIRECT_REG_WRITE8) &&
365 (ofs >= FH_MEM_UPPER_BOUND)) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800366 IWL_ERR(priv, "offset out of segment (0x0 - 0x%x)\n",
Amit Beka6fe7dd02012-01-25 09:19:24 +0200367 FH_MEM_UPPER_BOUND);
368 return -EINVAL;
369 }
370
371 switch (cmd) {
Hsu, Kenny72bcacc2011-11-15 19:24:32 -0800372 case IWL_TM_CMD_APP2DEV_DIRECT_REG_READ32:
Emmanuel Grumbach1042db22012-01-03 16:56:15 +0200373 val32 = iwl_read_direct32(trans(priv), ofs);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700374 IWL_INFO(priv, "32bit value to read 0x%x\n", val32);
375
376 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, 20);
377 if (!skb) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800378 IWL_ERR(priv, "Memory allocation fail\n");
Cindy H. Kao4613e722011-05-06 10:40:15 -0700379 return -ENOMEM;
380 }
381 NLA_PUT_U32(skb, IWL_TM_ATTR_REG_VALUE32, val32);
382 status = cfg80211_testmode_reply(skb);
383 if (status < 0)
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800384 IWL_ERR(priv, "Error sending msg : %d\n", status);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700385 break;
Hsu, Kenny72bcacc2011-11-15 19:24:32 -0800386 case IWL_TM_CMD_APP2DEV_DIRECT_REG_WRITE32:
Cindy H. Kao4613e722011-05-06 10:40:15 -0700387 if (!tb[IWL_TM_ATTR_REG_VALUE32]) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800388 IWL_ERR(priv, "Missing value to write\n");
Cindy H. Kao4613e722011-05-06 10:40:15 -0700389 return -ENOMSG;
390 } else {
391 val32 = nla_get_u32(tb[IWL_TM_ATTR_REG_VALUE32]);
392 IWL_INFO(priv, "32bit value to write 0x%x\n", val32);
Emmanuel Grumbach1042db22012-01-03 16:56:15 +0200393 iwl_write_direct32(trans(priv), ofs, val32);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700394 }
395 break;
Hsu, Kenny72bcacc2011-11-15 19:24:32 -0800396 case IWL_TM_CMD_APP2DEV_DIRECT_REG_WRITE8:
Cindy H. Kao4613e722011-05-06 10:40:15 -0700397 if (!tb[IWL_TM_ATTR_REG_VALUE8]) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800398 IWL_ERR(priv, "Missing value to write\n");
Cindy H. Kao4613e722011-05-06 10:40:15 -0700399 return -ENOMSG;
400 } else {
401 val8 = nla_get_u8(tb[IWL_TM_ATTR_REG_VALUE8]);
402 IWL_INFO(priv, "8bit value to write 0x%x\n", val8);
Emmanuel Grumbach1042db22012-01-03 16:56:15 +0200403 iwl_write8(trans(priv), ofs, val8);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700404 }
405 break;
406 default:
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800407 IWL_ERR(priv, "Unknown testmode register command ID\n");
Cindy H. Kao4613e722011-05-06 10:40:15 -0700408 return -ENOSYS;
409 }
410
411 return status;
412
413nla_put_failure:
414 kfree_skb(skb);
415 return -EMSGSIZE;
416}
417
418
419static int iwl_testmode_cfg_init_calib(struct iwl_priv *priv)
420{
421 struct iwl_notification_wait calib_wait;
422 int ret;
423
Johannes Berg4bd14dd2012-03-06 13:30:58 -0800424 iwl_init_notification_wait(&priv->notif_wait, &calib_wait,
425 CALIBRATION_COMPLETE_NOTIFICATION,
426 NULL, NULL);
Johannes Berge1991882012-03-06 13:30:36 -0800427 ret = iwl_init_alive_start(priv);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700428 if (ret) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800429 IWL_ERR(priv, "Fail init calibration: %d\n", ret);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700430 goto cfg_init_calib_error;
431 }
432
Johannes Berg4bd14dd2012-03-06 13:30:58 -0800433 ret = iwl_wait_notification(&priv->notif_wait, &calib_wait, 2 * HZ);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700434 if (ret)
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800435 IWL_ERR(priv, "Error detecting"
Cindy H. Kao4613e722011-05-06 10:40:15 -0700436 " CALIBRATION_COMPLETE_NOTIFICATION: %d\n", ret);
437 return ret;
438
439cfg_init_calib_error:
Johannes Berg4bd14dd2012-03-06 13:30:58 -0800440 iwl_remove_notification(&priv->notif_wait, &calib_wait);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700441 return ret;
442}
443
444/*
445 * This function handles the user application commands for driver.
446 *
447 * It retrieves command ID carried with IWL_TM_ATTR_COMMAND and calls to the
448 * handlers respectively.
449 *
450 * If it's an unknown commdn ID, -ENOSYS is replied; otherwise, the returned
451 * value of the actual command execution is replied to the user application.
452 *
453 * If there's any message responding to the user space, IWL_TM_ATTR_SYNC_RSP
454 * is used for carry the message while IWL_TM_ATTR_COMMAND must set to
455 * IWL_TM_CMD_DEV2APP_SYNC_RSP.
456 *
457 * @hw: ieee80211_hw object that represents the device
458 * @tb: gnl message fields from the user space
459 */
460static int iwl_testmode_driver(struct ieee80211_hw *hw, struct nlattr **tb)
461{
Emmanuel Grumbachd0f76d62012-02-09 16:08:15 +0200462 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
Don Fry69a679b2011-12-07 08:50:46 -0800463 struct iwl_trans *trans = trans(priv);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700464 struct sk_buff *skb;
465 unsigned char *rsp_data_ptr = NULL;
466 int status = 0, rsp_data_len = 0;
Kenny Hsuaca9b5f2011-12-24 12:12:12 +0800467 u32 devid, inst_size = 0, data_size = 0;
Cindy H. Kao4613e722011-05-06 10:40:15 -0700468
469 switch (nla_get_u32(tb[IWL_TM_ATTR_COMMAND])) {
470 case IWL_TM_CMD_APP2DEV_GET_DEVICENAME:
Don Fry38622412011-12-16 07:07:36 -0800471 rsp_data_ptr = (unsigned char *)cfg(priv)->name;
472 rsp_data_len = strlen(cfg(priv)->name);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700473 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
474 rsp_data_len + 20);
475 if (!skb) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800476 IWL_ERR(priv, "Memory allocation fail\n");
Cindy H. Kao4613e722011-05-06 10:40:15 -0700477 return -ENOMEM;
478 }
479 NLA_PUT_U32(skb, IWL_TM_ATTR_COMMAND,
480 IWL_TM_CMD_DEV2APP_SYNC_RSP);
481 NLA_PUT(skb, IWL_TM_ATTR_SYNC_RSP,
482 rsp_data_len, rsp_data_ptr);
483 status = cfg80211_testmode_reply(skb);
484 if (status < 0)
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800485 IWL_ERR(priv, "Error sending msg : %d\n", status);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700486 break;
487
488 case IWL_TM_CMD_APP2DEV_LOAD_INIT_FW:
Johannes Berge1991882012-03-06 13:30:36 -0800489 status = iwl_load_ucode_wait_alive(priv, IWL_UCODE_INIT);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700490 if (status)
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800491 IWL_ERR(priv, "Error loading init ucode: %d\n", status);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700492 break;
493
494 case IWL_TM_CMD_APP2DEV_CFG_INIT_CALIB:
495 iwl_testmode_cfg_init_calib(priv);
Don Fry69a679b2011-12-07 08:50:46 -0800496 iwl_trans_stop_device(trans);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700497 break;
498
499 case IWL_TM_CMD_APP2DEV_LOAD_RUNTIME_FW:
Johannes Berge1991882012-03-06 13:30:36 -0800500 status = iwl_load_ucode_wait_alive(priv, IWL_UCODE_REGULAR);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700501 if (status) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800502 IWL_ERR(priv,
Cindy H. Kao4613e722011-05-06 10:40:15 -0700503 "Error loading runtime ucode: %d\n", status);
504 break;
505 }
506 status = iwl_alive_start(priv);
507 if (status)
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800508 IWL_ERR(priv,
Cindy H. Kao4613e722011-05-06 10:40:15 -0700509 "Error starting the device: %d\n", status);
510 break;
511
Hsu, Kennyd4af19f2011-11-24 22:26:53 -0800512 case IWL_TM_CMD_APP2DEV_LOAD_WOWLAN_FW:
513 iwl_scan_cancel_timeout(priv, 200);
Don Fry69a679b2011-12-07 08:50:46 -0800514 iwl_trans_stop_device(trans);
Johannes Berge1991882012-03-06 13:30:36 -0800515 status = iwl_load_ucode_wait_alive(priv, IWL_UCODE_WOWLAN);
Hsu, Kennyd4af19f2011-11-24 22:26:53 -0800516 if (status) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800517 IWL_ERR(priv,
Hsu, Kennyd4af19f2011-11-24 22:26:53 -0800518 "Error loading WOWLAN ucode: %d\n", status);
519 break;
520 }
521 status = iwl_alive_start(priv);
522 if (status)
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800523 IWL_ERR(priv,
Hsu, Kennyd4af19f2011-11-24 22:26:53 -0800524 "Error starting the device: %d\n", status);
525 break;
526
Wey-Yi Guy4babc352011-05-03 18:05:12 -0700527 case IWL_TM_CMD_APP2DEV_GET_EEPROM:
Don Fryab36eab2011-11-30 15:37:32 -0800528 if (priv->shrd->eeprom) {
Wey-Yi Guy4babc352011-05-03 18:05:12 -0700529 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
Don Fry38622412011-12-16 07:07:36 -0800530 cfg(priv)->base_params->eeprom_size + 20);
Wey-Yi Guy4babc352011-05-03 18:05:12 -0700531 if (!skb) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800532 IWL_ERR(priv, "Memory allocation fail\n");
Wey-Yi Guy4babc352011-05-03 18:05:12 -0700533 return -ENOMEM;
534 }
535 NLA_PUT_U32(skb, IWL_TM_ATTR_COMMAND,
536 IWL_TM_CMD_DEV2APP_EEPROM_RSP);
537 NLA_PUT(skb, IWL_TM_ATTR_EEPROM,
Don Fry38622412011-12-16 07:07:36 -0800538 cfg(priv)->base_params->eeprom_size,
Don Fryab36eab2011-11-30 15:37:32 -0800539 priv->shrd->eeprom);
Wey-Yi Guy4babc352011-05-03 18:05:12 -0700540 status = cfg80211_testmode_reply(skb);
541 if (status < 0)
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800542 IWL_ERR(priv, "Error sending msg : %d\n",
543 status);
Wey-Yi Guy4babc352011-05-03 18:05:12 -0700544 } else
545 return -EFAULT;
546 break;
547
Wey-Yi Guy64898542011-05-03 18:05:13 -0700548 case IWL_TM_CMD_APP2DEV_FIXRATE_REQ:
549 if (!tb[IWL_TM_ATTR_FIXRATE]) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800550 IWL_ERR(priv, "Missing fixrate setting\n");
Wey-Yi Guy64898542011-05-03 18:05:13 -0700551 return -ENOMSG;
552 }
Wey-Yi Guy4e308112011-07-08 08:46:28 -0700553 priv->tm_fixed_rate = nla_get_u32(tb[IWL_TM_ATTR_FIXRATE]);
Wey-Yi Guy64898542011-05-03 18:05:13 -0700554 break;
555
Hsu, Kennye1a38fe2011-11-28 00:55:38 -0800556 case IWL_TM_CMD_APP2DEV_GET_FW_VERSION:
Don Fryd3596672012-02-06 15:51:15 -0800557 IWL_INFO(priv, "uCode version raw: 0x%x\n",
Johannes Berg0692fe42012-03-06 13:30:37 -0800558 priv->fw->ucode_ver);
Hsu, Kennye1a38fe2011-11-28 00:55:38 -0800559
560 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, 20);
561 if (!skb) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800562 IWL_ERR(priv, "Memory allocation fail\n");
Hsu, Kennye1a38fe2011-11-28 00:55:38 -0800563 return -ENOMEM;
564 }
Don Fryd3596672012-02-06 15:51:15 -0800565 NLA_PUT_U32(skb, IWL_TM_ATTR_FW_VERSION,
Johannes Berg0692fe42012-03-06 13:30:37 -0800566 priv->fw->ucode_ver);
Hsu, Kennye1a38fe2011-11-28 00:55:38 -0800567 status = cfg80211_testmode_reply(skb);
568 if (status < 0)
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800569 IWL_ERR(priv, "Error sending msg : %d\n", status);
Hsu, Kennye1a38fe2011-11-28 00:55:38 -0800570 break;
571
Hsu, Kenny0bec12b2011-12-01 01:12:50 -0800572 case IWL_TM_CMD_APP2DEV_GET_DEVICE_ID:
Emmanuel Grumbach99673ee2012-01-08 21:19:45 +0200573 devid = trans(priv)->hw_id;
Wey-Yi Guyfb6c1c62011-12-10 11:33:53 -0800574 IWL_INFO(priv, "hw version: 0x%x\n", devid);
Hsu, Kenny0bec12b2011-12-01 01:12:50 -0800575
576 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, 20);
577 if (!skb) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800578 IWL_ERR(priv, "Memory allocation fail\n");
Hsu, Kenny0bec12b2011-12-01 01:12:50 -0800579 return -ENOMEM;
580 }
581 NLA_PUT_U32(skb, IWL_TM_ATTR_DEVICE_ID, devid);
582 status = cfg80211_testmode_reply(skb);
583 if (status < 0)
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800584 IWL_ERR(priv, "Error sending msg : %d\n", status);
Hsu, Kenny0bec12b2011-12-01 01:12:50 -0800585 break;
586
Kenny Hsuaca9b5f2011-12-24 12:12:12 +0800587 case IWL_TM_CMD_APP2DEV_GET_FW_INFO:
588 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy, 20 + 8);
589 if (!skb) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800590 IWL_ERR(priv, "Memory allocation fail\n");
Kenny Hsuaca9b5f2011-12-24 12:12:12 +0800591 return -ENOMEM;
592 }
593 switch (priv->shrd->ucode_type) {
594 case IWL_UCODE_REGULAR:
Johannes Berg0692fe42012-03-06 13:30:37 -0800595 inst_size = priv->fw->ucode_rt.code.len;
596 data_size = priv->fw->ucode_rt.data.len;
Kenny Hsuaca9b5f2011-12-24 12:12:12 +0800597 break;
598 case IWL_UCODE_INIT:
Johannes Berg0692fe42012-03-06 13:30:37 -0800599 inst_size = priv->fw->ucode_init.code.len;
600 data_size = priv->fw->ucode_init.data.len;
Kenny Hsuaca9b5f2011-12-24 12:12:12 +0800601 break;
602 case IWL_UCODE_WOWLAN:
Johannes Berg0692fe42012-03-06 13:30:37 -0800603 inst_size = priv->fw->ucode_wowlan.code.len;
604 data_size = priv->fw->ucode_wowlan.data.len;
Kenny Hsuaca9b5f2011-12-24 12:12:12 +0800605 break;
606 case IWL_UCODE_NONE:
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800607 IWL_ERR(priv, "No uCode has not been loaded\n");
Kenny Hsuaca9b5f2011-12-24 12:12:12 +0800608 break;
609 default:
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800610 IWL_ERR(priv, "Unsupported uCode type\n");
Kenny Hsuaca9b5f2011-12-24 12:12:12 +0800611 break;
612 }
613 NLA_PUT_U32(skb, IWL_TM_ATTR_FW_TYPE, priv->shrd->ucode_type);
614 NLA_PUT_U32(skb, IWL_TM_ATTR_FW_INST_SIZE, inst_size);
615 NLA_PUT_U32(skb, IWL_TM_ATTR_FW_DATA_SIZE, data_size);
616 status = cfg80211_testmode_reply(skb);
617 if (status < 0)
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800618 IWL_ERR(priv, "Error sending msg : %d\n", status);
Kenny Hsuaca9b5f2011-12-24 12:12:12 +0800619 break;
620
Cindy H. Kao4613e722011-05-06 10:40:15 -0700621 default:
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800622 IWL_ERR(priv, "Unknown testmode driver command ID\n");
Cindy H. Kao4613e722011-05-06 10:40:15 -0700623 return -ENOSYS;
624 }
625 return status;
626
627nla_put_failure:
628 kfree_skb(skb);
629 return -EMSGSIZE;
630}
631
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700632
633/*
634 * This function handles the user application commands for uCode trace
635 *
636 * It retrieves command ID carried with IWL_TM_ATTR_COMMAND and calls to the
637 * handlers respectively.
638 *
639 * If it's an unknown commdn ID, -ENOSYS is replied; otherwise, the returned
640 * value of the actual command execution is replied to the user application.
641 *
642 * @hw: ieee80211_hw object that represents the device
643 * @tb: gnl message fields from the user space
644 */
645static int iwl_testmode_trace(struct ieee80211_hw *hw, struct nlattr **tb)
646{
Emmanuel Grumbachd0f76d62012-02-09 16:08:15 +0200647 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700648 struct sk_buff *skb;
649 int status = 0;
Emmanuel Grumbach1042db22012-01-03 16:56:15 +0200650 struct device *dev = trans(priv)->dev;
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700651
652 switch (nla_get_u32(tb[IWL_TM_ATTR_COMMAND])) {
653 case IWL_TM_CMD_APP2DEV_BEGIN_TRACE:
654 if (priv->testmode_trace.trace_enabled)
655 return -EBUSY;
656
Wey-Yi Guy49b72102011-05-30 10:29:37 -0700657 if (!tb[IWL_TM_ATTR_TRACE_SIZE])
658 priv->testmode_trace.buff_size = TRACE_BUFF_SIZE_DEF;
659 else
660 priv->testmode_trace.buff_size =
661 nla_get_u32(tb[IWL_TM_ATTR_TRACE_SIZE]);
662 if (!priv->testmode_trace.buff_size)
663 return -EINVAL;
664 if (priv->testmode_trace.buff_size < TRACE_BUFF_SIZE_MIN ||
665 priv->testmode_trace.buff_size > TRACE_BUFF_SIZE_MAX)
666 return -EINVAL;
667
668 priv->testmode_trace.total_size =
669 priv->testmode_trace.buff_size + TRACE_BUFF_PADD;
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700670 priv->testmode_trace.cpu_addr =
671 dma_alloc_coherent(dev,
Wey-Yi Guy49b72102011-05-30 10:29:37 -0700672 priv->testmode_trace.total_size,
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700673 &priv->testmode_trace.dma_addr,
674 GFP_KERNEL);
675 if (!priv->testmode_trace.cpu_addr)
676 return -ENOMEM;
677 priv->testmode_trace.trace_enabled = true;
678 priv->testmode_trace.trace_addr = (u8 *)PTR_ALIGN(
679 priv->testmode_trace.cpu_addr, 0x100);
680 memset(priv->testmode_trace.trace_addr, 0x03B,
Wey-Yi Guy49b72102011-05-30 10:29:37 -0700681 priv->testmode_trace.buff_size);
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700682 skb = cfg80211_testmode_alloc_reply_skb(hw->wiphy,
683 sizeof(priv->testmode_trace.dma_addr) + 20);
684 if (!skb) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800685 IWL_ERR(priv, "Memory allocation fail\n");
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700686 iwl_trace_cleanup(priv);
687 return -ENOMEM;
688 }
689 NLA_PUT(skb, IWL_TM_ATTR_TRACE_ADDR,
690 sizeof(priv->testmode_trace.dma_addr),
691 (u64 *)&priv->testmode_trace.dma_addr);
692 status = cfg80211_testmode_reply(skb);
693 if (status < 0) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800694 IWL_ERR(priv, "Error sending msg : %d\n", status);
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700695 }
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -0700696 priv->testmode_trace.num_chunks =
697 DIV_ROUND_UP(priv->testmode_trace.buff_size,
Hsu, Kennye056a652011-11-22 23:05:02 -0800698 DUMP_CHUNK_SIZE);
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700699 break;
700
701 case IWL_TM_CMD_APP2DEV_END_TRACE:
702 iwl_trace_cleanup(priv);
703 break;
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700704 default:
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800705 IWL_ERR(priv, "Unknown testmode mem command ID\n");
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -0700706 return -ENOSYS;
707 }
708 return status;
709
710nla_put_failure:
711 kfree_skb(skb);
712 if (nla_get_u32(tb[IWL_TM_ATTR_COMMAND]) ==
713 IWL_TM_CMD_APP2DEV_BEGIN_TRACE)
714 iwl_trace_cleanup(priv);
715 return -EMSGSIZE;
716}
717
Johannes Bergc1803c92012-03-07 09:52:14 -0800718static int iwl_testmode_trace_dump(struct ieee80211_hw *hw,
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -0700719 struct sk_buff *skb,
720 struct netlink_callback *cb)
721{
Emmanuel Grumbachd0f76d62012-02-09 16:08:15 +0200722 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -0700723 int idx, length;
724
725 if (priv->testmode_trace.trace_enabled &&
726 priv->testmode_trace.trace_addr) {
727 idx = cb->args[4];
728 if (idx >= priv->testmode_trace.num_chunks)
729 return -ENOENT;
Hsu, Kennye056a652011-11-22 23:05:02 -0800730 length = DUMP_CHUNK_SIZE;
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -0700731 if (((idx + 1) == priv->testmode_trace.num_chunks) &&
Hsu, Kennye056a652011-11-22 23:05:02 -0800732 (priv->testmode_trace.buff_size % DUMP_CHUNK_SIZE))
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -0700733 length = priv->testmode_trace.buff_size %
Hsu, Kennye056a652011-11-22 23:05:02 -0800734 DUMP_CHUNK_SIZE;
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -0700735
736 NLA_PUT(skb, IWL_TM_ATTR_TRACE_DUMP, length,
737 priv->testmode_trace.trace_addr +
Hsu, Kennye056a652011-11-22 23:05:02 -0800738 (DUMP_CHUNK_SIZE * idx));
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -0700739 idx++;
740 cb->args[4] = idx;
741 return 0;
742 } else
743 return -EFAULT;
744
745 nla_put_failure:
746 return -ENOBUFS;
747}
748
Wey-Yi Guye98a1932011-07-08 08:46:26 -0700749/*
750 * This function handles the user application switch ucode ownership.
751 *
752 * It retrieves the mandatory fields IWL_TM_ATTR_UCODE_OWNER and
753 * decide who the current owner of the uCode
754 *
755 * If the current owner is OWNERSHIP_TM, then the only host command
756 * can deliver to uCode is from testmode, all the other host commands
757 * will dropped.
758 *
759 * default driver is the owner of uCode in normal operational mode
760 *
761 * @hw: ieee80211_hw object that represents the device
762 * @tb: gnl message fields from the user space
763 */
764static int iwl_testmode_ownership(struct ieee80211_hw *hw, struct nlattr **tb)
765{
Emmanuel Grumbachd0f76d62012-02-09 16:08:15 +0200766 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
Wey-Yi Guye98a1932011-07-08 08:46:26 -0700767 u8 owner;
768
769 if (!tb[IWL_TM_ATTR_UCODE_OWNER]) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800770 IWL_ERR(priv, "Missing ucode owner\n");
Wey-Yi Guye98a1932011-07-08 08:46:26 -0700771 return -ENOMSG;
772 }
773
774 owner = nla_get_u8(tb[IWL_TM_ATTR_UCODE_OWNER]);
Amit Beka0aef8dd2012-03-07 09:52:29 -0800775 if (owner == IWL_OWNERSHIP_DRIVER) {
Johannes Berg947a9402012-03-06 13:30:59 -0800776 priv->ucode_owner = owner;
Amit Beka0aef8dd2012-03-07 09:52:29 -0800777 priv->pre_rx_handler = NULL;
778 } else if (owner == IWL_OWNERSHIP_TM) {
779 priv->pre_rx_handler = iwl_testmode_ucode_rx_pkt;
780 priv->ucode_owner = owner;
781 } else {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800782 IWL_ERR(priv, "Invalid owner\n");
Wey-Yi Guye98a1932011-07-08 08:46:26 -0700783 return -EINVAL;
784 }
785 return 0;
786}
787
Amit Beka6c55f5e2012-01-25 13:30:27 +0200788static int iwl_testmode_indirect_read(struct iwl_priv *priv, u32 addr, u32 size)
789{
790 struct iwl_trans *trans = trans(priv);
791 unsigned long flags;
792 int i;
793
794 if (size & 0x3)
795 return -EINVAL;
796 priv->testmode_mem.buff_size = size;
797 priv->testmode_mem.buff_addr =
798 kmalloc(priv->testmode_mem.buff_size, GFP_KERNEL);
799 if (priv->testmode_mem.buff_addr == NULL)
800 return -ENOMEM;
801
802 /* Hard-coded periphery absolute address */
803 if (IWL_TM_ABS_PRPH_START <= addr &&
804 addr < IWL_TM_ABS_PRPH_START + PRPH_END) {
805 spin_lock_irqsave(&trans->reg_lock, flags);
806 iwl_grab_nic_access(trans);
Amit Beka858b7c72012-02-06 00:40:47 +0200807 iwl_write32(trans, HBUS_TARG_PRPH_RADDR,
808 addr | (3 << 24));
Amit Beka6c55f5e2012-01-25 13:30:27 +0200809 for (i = 0; i < size; i += 4)
Amit Beka858b7c72012-02-06 00:40:47 +0200810 *(u32 *)(priv->testmode_mem.buff_addr + i) =
Amit Beka6c55f5e2012-01-25 13:30:27 +0200811 iwl_read32(trans, HBUS_TARG_PRPH_RDAT);
812 iwl_release_nic_access(trans);
813 spin_unlock_irqrestore(&trans->reg_lock, flags);
814 } else { /* target memory (SRAM) */
815 _iwl_read_targ_mem_words(trans, addr,
816 priv->testmode_mem.buff_addr,
817 priv->testmode_mem.buff_size / 4);
818 }
819
820 priv->testmode_mem.num_chunks =
821 DIV_ROUND_UP(priv->testmode_mem.buff_size, DUMP_CHUNK_SIZE);
822 priv->testmode_mem.read_in_progress = true;
823 return 0;
824
825}
826
827static int iwl_testmode_indirect_write(struct iwl_priv *priv, u32 addr,
828 u32 size, unsigned char *buf)
829{
830 struct iwl_trans *trans = trans(priv);
831 u32 val, i;
832 unsigned long flags;
833
834 if (IWL_TM_ABS_PRPH_START <= addr &&
835 addr < IWL_TM_ABS_PRPH_START + PRPH_END) {
836 /* Periphery writes can be 1-3 bytes long, or DWORDs */
837 if (size < 4) {
838 memcpy(&val, buf, size);
839 spin_lock_irqsave(&trans->reg_lock, flags);
840 iwl_grab_nic_access(trans);
841 iwl_write32(trans, HBUS_TARG_PRPH_WADDR,
Amit Beka858b7c72012-02-06 00:40:47 +0200842 (addr & 0x0000FFFF) |
843 ((size - 1) << 24));
Amit Beka6c55f5e2012-01-25 13:30:27 +0200844 iwl_write32(trans, HBUS_TARG_PRPH_WDAT, val);
845 iwl_release_nic_access(trans);
846 /* needed after consecutive writes w/o read */
847 mmiowb();
848 spin_unlock_irqrestore(&trans->reg_lock, flags);
849 } else {
850 if (size % 4)
851 return -EINVAL;
852 for (i = 0; i < size; i += 4)
853 iwl_write_prph(trans, addr+i,
Amit Beka858b7c72012-02-06 00:40:47 +0200854 *(u32 *)(buf+i));
Amit Beka6c55f5e2012-01-25 13:30:27 +0200855 }
856 } else if (iwlagn_hw_valid_rtc_data_addr(addr) ||
857 (IWLAGN_RTC_INST_LOWER_BOUND <= addr &&
858 addr < IWLAGN_RTC_INST_UPPER_BOUND)) {
859 _iwl_write_targ_mem_words(trans, addr, buf, size/4);
860 } else
861 return -EINVAL;
862 return 0;
863}
864
Hsu, Kenny306713f2011-11-22 23:03:39 -0800865/*
866 * This function handles the user application commands for SRAM data dump
867 *
868 * It retrieves the mandatory fields IWL_TM_ATTR_SRAM_ADDR and
869 * IWL_TM_ATTR_SRAM_SIZE to decide the memory area for SRAM data reading
870 *
871 * Several error will be retured, -EBUSY if the SRAM data retrieved by
872 * previous command has not been delivered to userspace, or -ENOMSG if
873 * the mandatory fields (IWL_TM_ATTR_SRAM_ADDR,IWL_TM_ATTR_SRAM_SIZE)
874 * are missing, or -ENOMEM if the buffer allocation fails.
875 *
876 * Otherwise 0 is replied indicating the success of the SRAM reading.
877 *
878 * @hw: ieee80211_hw object that represents the device
879 * @tb: gnl message fields from the user space
880 */
Amit Beka6c55f5e2012-01-25 13:30:27 +0200881static int iwl_testmode_indirect_mem(struct ieee80211_hw *hw,
882 struct nlattr **tb)
Hsu, Kenny306713f2011-11-22 23:03:39 -0800883{
Emmanuel Grumbachd0f76d62012-02-09 16:08:15 +0200884 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
Amit Beka6c55f5e2012-01-25 13:30:27 +0200885 u32 addr, size, cmd;
886 unsigned char *buf;
Hsu, Kenny306713f2011-11-22 23:03:39 -0800887
Amit Beka6c55f5e2012-01-25 13:30:27 +0200888 /* Both read and write should be blocked, for atomicity */
889 if (priv->testmode_mem.read_in_progress)
Hsu, Kenny306713f2011-11-22 23:03:39 -0800890 return -EBUSY;
891
Amit Beka6c55f5e2012-01-25 13:30:27 +0200892 cmd = nla_get_u32(tb[IWL_TM_ATTR_COMMAND]);
893 if (!tb[IWL_TM_ATTR_MEM_ADDR]) {
894 IWL_ERR(priv, "Error finding memory offset address\n");
Hsu, Kenny306713f2011-11-22 23:03:39 -0800895 return -ENOMSG;
896 }
Amit Beka6c55f5e2012-01-25 13:30:27 +0200897 addr = nla_get_u32(tb[IWL_TM_ATTR_MEM_ADDR]);
898 if (!tb[IWL_TM_ATTR_BUFFER_SIZE]) {
899 IWL_ERR(priv, "Error finding size for memory reading\n");
Hsu, Kenny306713f2011-11-22 23:03:39 -0800900 return -ENOMSG;
901 }
Amit Beka6c55f5e2012-01-25 13:30:27 +0200902 size = nla_get_u32(tb[IWL_TM_ATTR_BUFFER_SIZE]);
903
904 if (cmd == IWL_TM_CMD_APP2DEV_INDIRECT_BUFFER_READ)
905 return iwl_testmode_indirect_read(priv, addr, size);
906 else {
907 if (!tb[IWL_TM_ATTR_BUFFER_DUMP])
908 return -EINVAL;
909 buf = (unsigned char *) nla_data(tb[IWL_TM_ATTR_BUFFER_DUMP]);
910 return iwl_testmode_indirect_write(priv, addr, size, buf);
Kenny Hsu76de2f22011-11-23 06:57:22 -0800911 }
Hsu, Kenny306713f2011-11-22 23:03:39 -0800912}
913
Johannes Bergc1803c92012-03-07 09:52:14 -0800914static int iwl_testmode_buffer_dump(struct ieee80211_hw *hw,
915 struct sk_buff *skb,
916 struct netlink_callback *cb)
Hsu, Kenny306713f2011-11-22 23:03:39 -0800917{
Emmanuel Grumbachd0f76d62012-02-09 16:08:15 +0200918 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
Hsu, Kenny306713f2011-11-22 23:03:39 -0800919 int idx, length;
920
Amit Beka6c55f5e2012-01-25 13:30:27 +0200921 if (priv->testmode_mem.read_in_progress) {
Hsu, Kenny306713f2011-11-22 23:03:39 -0800922 idx = cb->args[4];
Amit Beka6c55f5e2012-01-25 13:30:27 +0200923 if (idx >= priv->testmode_mem.num_chunks) {
924 iwl_mem_cleanup(priv);
Hsu, Kenny306713f2011-11-22 23:03:39 -0800925 return -ENOENT;
926 }
Hsu, Kennye056a652011-11-22 23:05:02 -0800927 length = DUMP_CHUNK_SIZE;
Amit Beka6c55f5e2012-01-25 13:30:27 +0200928 if (((idx + 1) == priv->testmode_mem.num_chunks) &&
929 (priv->testmode_mem.buff_size % DUMP_CHUNK_SIZE))
930 length = priv->testmode_mem.buff_size %
Hsu, Kennye056a652011-11-22 23:05:02 -0800931 DUMP_CHUNK_SIZE;
Hsu, Kenny306713f2011-11-22 23:03:39 -0800932
Amit Beka6c55f5e2012-01-25 13:30:27 +0200933 NLA_PUT(skb, IWL_TM_ATTR_BUFFER_DUMP, length,
934 priv->testmode_mem.buff_addr +
Hsu, Kennye056a652011-11-22 23:05:02 -0800935 (DUMP_CHUNK_SIZE * idx));
Hsu, Kenny306713f2011-11-22 23:03:39 -0800936 idx++;
937 cb->args[4] = idx;
938 return 0;
939 } else
940 return -EFAULT;
941
942 nla_put_failure:
943 return -ENOBUFS;
944}
945
Amit Beka0aef8dd2012-03-07 09:52:29 -0800946static int iwl_testmode_notifications(struct ieee80211_hw *hw,
947 struct nlattr **tb)
948{
949 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
950 bool enable;
951
952 enable = nla_get_flag(tb[IWL_TM_ATTR_ENABLE_NOTIFICATION]);
953 if (enable)
954 priv->pre_rx_handler = iwl_testmode_ucode_rx_pkt;
955 else
956 priv->pre_rx_handler = NULL;
957 return 0;
958}
959
Wey-Yi Guye98a1932011-07-08 08:46:26 -0700960
Cindy H. Kao4613e722011-05-06 10:40:15 -0700961/* The testmode gnl message handler that takes the gnl message from the
962 * user space and parses it per the policy iwl_testmode_gnl_msg_policy, then
963 * invoke the corresponding handlers.
964 *
965 * This function is invoked when there is user space application sending
966 * gnl message through the testmode tunnel NL80211_CMD_TESTMODE regulated
967 * by nl80211.
968 *
969 * It retrieves the mandatory field, IWL_TM_ATTR_COMMAND, before
970 * dispatching it to the corresponding handler.
971 *
972 * If IWL_TM_ATTR_COMMAND is missing, -ENOMSG is replied to user application;
973 * -ENOSYS is replied to the user application if the command is unknown;
974 * Otherwise, the command is dispatched to the respective handler.
975 *
976 * @hw: ieee80211_hw object that represents the device
977 * @data: pointer to user space message
978 * @len: length in byte of @data
979 */
Wey-Yi Guyade4c642011-10-10 07:27:11 -0700980int iwlagn_mac_testmode_cmd(struct ieee80211_hw *hw, void *data, int len)
Cindy H. Kao4613e722011-05-06 10:40:15 -0700981{
Wey-Yi Guya6779272011-07-11 10:47:39 -0700982 struct nlattr *tb[IWL_TM_ATTR_MAX];
Emmanuel Grumbachd0f76d62012-02-09 16:08:15 +0200983 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700984 int result;
985
986 result = nla_parse(tb, IWL_TM_ATTR_MAX - 1, data, len,
987 iwl_testmode_gnl_msg_policy);
988 if (result != 0) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800989 IWL_ERR(priv, "Error parsing the gnl message : %d\n", result);
Cindy H. Kao4613e722011-05-06 10:40:15 -0700990 return result;
991 }
992
993 /* IWL_TM_ATTR_COMMAND is absolutely mandatory */
994 if (!tb[IWL_TM_ATTR_COMMAND]) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -0800995 IWL_ERR(priv, "Missing testmode command type\n");
Cindy H. Kao4613e722011-05-06 10:40:15 -0700996 return -ENOMSG;
997 }
998 /* in case multiple accesses to the device happens */
Johannes Bergb1eea292012-03-06 13:30:42 -0800999 mutex_lock(&priv->mutex);
Cindy H. Kao4613e722011-05-06 10:40:15 -07001000
1001 switch (nla_get_u32(tb[IWL_TM_ATTR_COMMAND])) {
1002 case IWL_TM_CMD_APP2DEV_UCODE:
1003 IWL_DEBUG_INFO(priv, "testmode cmd to uCode\n");
1004 result = iwl_testmode_ucode(hw, tb);
1005 break;
Hsu, Kenny72bcacc2011-11-15 19:24:32 -08001006 case IWL_TM_CMD_APP2DEV_DIRECT_REG_READ32:
1007 case IWL_TM_CMD_APP2DEV_DIRECT_REG_WRITE32:
1008 case IWL_TM_CMD_APP2DEV_DIRECT_REG_WRITE8:
Cindy H. Kao4613e722011-05-06 10:40:15 -07001009 IWL_DEBUG_INFO(priv, "testmode cmd to register\n");
1010 result = iwl_testmode_reg(hw, tb);
1011 break;
1012 case IWL_TM_CMD_APP2DEV_GET_DEVICENAME:
1013 case IWL_TM_CMD_APP2DEV_LOAD_INIT_FW:
1014 case IWL_TM_CMD_APP2DEV_CFG_INIT_CALIB:
1015 case IWL_TM_CMD_APP2DEV_LOAD_RUNTIME_FW:
Wey-Yi Guy4babc352011-05-03 18:05:12 -07001016 case IWL_TM_CMD_APP2DEV_GET_EEPROM:
Wey-Yi Guy64898542011-05-03 18:05:13 -07001017 case IWL_TM_CMD_APP2DEV_FIXRATE_REQ:
Hsu, Kennyd4af19f2011-11-24 22:26:53 -08001018 case IWL_TM_CMD_APP2DEV_LOAD_WOWLAN_FW:
Hsu, Kennye1a38fe2011-11-28 00:55:38 -08001019 case IWL_TM_CMD_APP2DEV_GET_FW_VERSION:
Hsu, Kenny0bec12b2011-12-01 01:12:50 -08001020 case IWL_TM_CMD_APP2DEV_GET_DEVICE_ID:
Kenny Hsuaca9b5f2011-12-24 12:12:12 +08001021 case IWL_TM_CMD_APP2DEV_GET_FW_INFO:
Cindy H. Kao4613e722011-05-06 10:40:15 -07001022 IWL_DEBUG_INFO(priv, "testmode cmd to driver\n");
1023 result = iwl_testmode_driver(hw, tb);
1024 break;
Wey-Yi Guy7a4e5282011-05-06 10:21:28 -07001025
1026 case IWL_TM_CMD_APP2DEV_BEGIN_TRACE:
1027 case IWL_TM_CMD_APP2DEV_END_TRACE:
1028 case IWL_TM_CMD_APP2DEV_READ_TRACE:
1029 IWL_DEBUG_INFO(priv, "testmode uCode trace cmd to driver\n");
1030 result = iwl_testmode_trace(hw, tb);
1031 break;
1032
Wey-Yi Guye98a1932011-07-08 08:46:26 -07001033 case IWL_TM_CMD_APP2DEV_OWNERSHIP:
1034 IWL_DEBUG_INFO(priv, "testmode change uCode ownership\n");
1035 result = iwl_testmode_ownership(hw, tb);
1036 break;
1037
Amit Beka6c55f5e2012-01-25 13:30:27 +02001038 case IWL_TM_CMD_APP2DEV_INDIRECT_BUFFER_READ:
1039 case IWL_TM_CMD_APP2DEV_INDIRECT_BUFFER_WRITE:
1040 IWL_DEBUG_INFO(priv, "testmode indirect memory cmd "
1041 "to driver\n");
1042 result = iwl_testmode_indirect_mem(hw, tb);
Hsu, Kenny306713f2011-11-22 23:03:39 -08001043 break;
1044
Amit Beka0aef8dd2012-03-07 09:52:29 -08001045 case IWL_TM_CMD_APP2DEV_NOTIFICATIONS:
1046 IWL_DEBUG_INFO(priv, "testmode notifications cmd "
1047 "to driver\n");
1048 result = iwl_testmode_notifications(hw, tb);
1049 break;
1050
Cindy H. Kao4613e722011-05-06 10:40:15 -07001051 default:
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -08001052 IWL_ERR(priv, "Unknown testmode command\n");
Cindy H. Kao4613e722011-05-06 10:40:15 -07001053 result = -ENOSYS;
1054 break;
1055 }
1056
Johannes Bergb1eea292012-03-06 13:30:42 -08001057 mutex_unlock(&priv->mutex);
Cindy H. Kao4613e722011-05-06 10:40:15 -07001058 return result;
1059}
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -07001060
Wey-Yi Guyade4c642011-10-10 07:27:11 -07001061int iwlagn_mac_testmode_dump(struct ieee80211_hw *hw, struct sk_buff *skb,
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -07001062 struct netlink_callback *cb,
1063 void *data, int len)
1064{
1065 struct nlattr *tb[IWL_TM_ATTR_MAX];
Emmanuel Grumbachd0f76d62012-02-09 16:08:15 +02001066 struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -07001067 int result;
1068 u32 cmd;
1069
1070 if (cb->args[3]) {
1071 /* offset by 1 since commands start at 0 */
1072 cmd = cb->args[3] - 1;
1073 } else {
1074 result = nla_parse(tb, IWL_TM_ATTR_MAX - 1, data, len,
1075 iwl_testmode_gnl_msg_policy);
1076 if (result) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -08001077 IWL_ERR(priv,
1078 "Error parsing the gnl message : %d\n", result);
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -07001079 return result;
1080 }
1081
1082 /* IWL_TM_ATTR_COMMAND is absolutely mandatory */
1083 if (!tb[IWL_TM_ATTR_COMMAND]) {
Wey-Yi Guy2f73d7c2012-02-03 13:06:57 -08001084 IWL_ERR(priv, "Missing testmode command type\n");
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -07001085 return -ENOMSG;
1086 }
1087 cmd = nla_get_u32(tb[IWL_TM_ATTR_COMMAND]);
1088 cb->args[3] = cmd + 1;
1089 }
1090
1091 /* in case multiple accesses to the device happens */
Johannes Bergb1eea292012-03-06 13:30:42 -08001092 mutex_lock(&priv->mutex);
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -07001093 switch (cmd) {
1094 case IWL_TM_CMD_APP2DEV_READ_TRACE:
1095 IWL_DEBUG_INFO(priv, "uCode trace cmd to driver\n");
Johannes Bergc1803c92012-03-07 09:52:14 -08001096 result = iwl_testmode_trace_dump(hw, skb, cb);
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -07001097 break;
Amit Beka6c55f5e2012-01-25 13:30:27 +02001098 case IWL_TM_CMD_APP2DEV_INDIRECT_BUFFER_DUMP:
Hsu, Kenny306713f2011-11-22 23:03:39 -08001099 IWL_DEBUG_INFO(priv, "testmode sram dump cmd to driver\n");
Johannes Bergc1803c92012-03-07 09:52:14 -08001100 result = iwl_testmode_buffer_dump(hw, skb, cb);
Hsu, Kenny306713f2011-11-22 23:03:39 -08001101 break;
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -07001102 default:
1103 result = -EINVAL;
1104 break;
1105 }
1106
Johannes Bergb1eea292012-03-06 13:30:42 -08001107 mutex_unlock(&priv->mutex);
Wey-Yi Guyeb64dca2011-05-31 08:03:02 -07001108 return result;
1109}