projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
iwlwifi: virtualize iwl_{grab,release}_nic_access
[deliverable/linux.git] / drivers / net / wireless / iwlwifi / iwl-devtrace.h
1 /******************************************************************************
2 *
3 * Copyright(c) 2009 - 2012 Intel Corporation. All rights reserved.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program; if not, write to the Free Software Foundation, Inc.,
16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
17 *
18 * The full GNU General Public License is included in this distribution in the
19 * file called LICENSE.
20 *
21 * Contact Information:
22 * Intel Linux Wireless <ilw@linux.intel.com>
23 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
24 *
25 *****************************************************************************/
26
27 #if !defined(__IWLWIFI_DEVICE_TRACE) || defined(TRACE_HEADER_MULTI_READ)
28 #include <linux/skbuff.h>
29 #include <linux/ieee80211.h>
30 #include <net/cfg80211.h>
31 #include "iwl-trans.h"
32 #if !defined(__IWLWIFI_DEVICE_TRACE)
33 static inline bool iwl_trace_data(struct sk_buff *skb)
34 {
35 struct ieee80211_hdr *hdr = (void *)skb->data;
36
37 if (ieee80211_is_data(hdr->frame_control))
38 return skb->protocol != cpu_to_be16(ETH_P_PAE);
39 return false;
40 }
41
42 static inline size_t iwl_rx_trace_len(const struct iwl_trans *trans,
43 void *rxbuf, size_t len)
44 {
45 struct iwl_cmd_header *cmd = (void *)((u8 *)rxbuf + sizeof(__le32));
46 struct ieee80211_hdr *hdr;
47
48 if (cmd->cmd != trans->rx_mpdu_cmd)
49 return len;
50
51 hdr = (void *)((u8 *)cmd + sizeof(struct iwl_cmd_header) +
52 trans->rx_mpdu_cmd_hdr_size);
53 if (!ieee80211_is_data(hdr->frame_control))
54 return len;
55 /* maybe try to identify EAPOL frames? */
56 return sizeof(__le32) + sizeof(*cmd) + trans->rx_mpdu_cmd_hdr_size +
57 ieee80211_hdrlen(hdr->frame_control);
58 }
59 #endif
60
61 #define __IWLWIFI_DEVICE_TRACE
62
63 #include <linux/tracepoint.h>
64 #include <linux/device.h>
65 #include "iwl-trans.h"
66
67
68 #if !defined(CONFIG_IWLWIFI_DEVICE_TRACING) || defined(__CHECKER__)
69 #undef TRACE_EVENT
70 #define TRACE_EVENT(name, proto, ...) \
71 static inline void trace_ ## name(proto) {}
72 #undef DECLARE_EVENT_CLASS
73 #define DECLARE_EVENT_CLASS(...)
74 #undef DEFINE_EVENT
75 #define DEFINE_EVENT(evt_class, name, proto, ...) \
76 static inline void trace_ ## name(proto) {}
77 #endif
78
79 #define DEV_ENTRY __string(dev, dev_name(dev))
80 #define DEV_ASSIGN __assign_str(dev, dev_name(dev))
81
82 #undef TRACE_SYSTEM
83 #define TRACE_SYSTEM iwlwifi_io
84
85 TRACE_EVENT(iwlwifi_dev_ioread32,
86 TP_PROTO(const struct device *dev, u32 offs, u32 val),
87 TP_ARGS(dev, offs, val),
88 TP_STRUCT__entry(
89 DEV_ENTRY
90 __field(u32, offs)
91 __field(u32, val)
92 ),
93 TP_fast_assign(
94 DEV_ASSIGN;
95 __entry->offs = offs;
96 __entry->val = val;
97 ),
98 TP_printk("[%s] read io[%#x] = %#x",
99 __get_str(dev), __entry->offs, __entry->val)
100 );
101
102 TRACE_EVENT(iwlwifi_dev_iowrite8,
103 TP_PROTO(const struct device *dev, u32 offs, u8 val),
104 TP_ARGS(dev, offs, val),
105 TP_STRUCT__entry(
106 DEV_ENTRY
107 __field(u32, offs)
108 __field(u8, val)
109 ),
110 TP_fast_assign(
111 DEV_ASSIGN;
112 __entry->offs = offs;
113 __entry->val = val;
114 ),
115 TP_printk("[%s] write io[%#x] = %#x)",
116 __get_str(dev), __entry->offs, __entry->val)
117 );
118
119 TRACE_EVENT(iwlwifi_dev_iowrite32,
120 TP_PROTO(const struct device *dev, u32 offs, u32 val),
121 TP_ARGS(dev, offs, val),
122 TP_STRUCT__entry(
123 DEV_ENTRY
124 __field(u32, offs)
125 __field(u32, val)
126 ),
127 TP_fast_assign(
128 DEV_ASSIGN;
129 __entry->offs = offs;
130 __entry->val = val;
131 ),
132 TP_printk("[%s] write io[%#x] = %#x)",
133 __get_str(dev), __entry->offs, __entry->val)
134 );
135
136 TRACE_EVENT(iwlwifi_dev_iowrite_prph32,
137 TP_PROTO(const struct device *dev, u32 offs, u32 val),
138 TP_ARGS(dev, offs, val),
139 TP_STRUCT__entry(
140 DEV_ENTRY
141 __field(u32, offs)
142 __field(u32, val)
143 ),
144 TP_fast_assign(
145 DEV_ASSIGN;
146 __entry->offs = offs;
147 __entry->val = val;
148 ),
149 TP_printk("[%s] write PRPH[%#x] = %#x)",
150 __get_str(dev), __entry->offs, __entry->val)
151 );
152
153 TRACE_EVENT(iwlwifi_dev_ioread_prph32,
154 TP_PROTO(const struct device *dev, u32 offs, u32 val),
155 TP_ARGS(dev, offs, val),
156 TP_STRUCT__entry(
157 DEV_ENTRY
158 __field(u32, offs)
159 __field(u32, val)
160 ),
161 TP_fast_assign(
162 DEV_ASSIGN;
163 __entry->offs = offs;
164 __entry->val = val;
165 ),
166 TP_printk("[%s] read PRPH[%#x] = %#x",
167 __get_str(dev), __entry->offs, __entry->val)
168 );
169
170 TRACE_EVENT(iwlwifi_dev_irq,
171 TP_PROTO(const struct device *dev),
172 TP_ARGS(dev),
173 TP_STRUCT__entry(
174 DEV_ENTRY
175 ),
176 TP_fast_assign(
177 DEV_ASSIGN;
178 ),
179 /* TP_printk("") doesn't compile */
180 TP_printk("%d", 0)
181 );
182
183 TRACE_EVENT(iwlwifi_dev_ict_read,
184 TP_PROTO(const struct device *dev, u32 index, u32 value),
185 TP_ARGS(dev, index, value),
186 TP_STRUCT__entry(
187 DEV_ENTRY
188 __field(u32, index)
189 __field(u32, value)
190 ),
191 TP_fast_assign(
192 DEV_ASSIGN;
193 __entry->index = index;
194 __entry->value = value;
195 ),
196 TP_printk("[%s] read ict[%d] = %#.8x",
197 __get_str(dev), __entry->index, __entry->value)
198 );
199
200 #undef TRACE_SYSTEM
201 #define TRACE_SYSTEM iwlwifi_ucode
202
203 TRACE_EVENT(iwlwifi_dev_ucode_cont_event,
204 TP_PROTO(const struct device *dev, u32 time, u32 data, u32 ev),
205 TP_ARGS(dev, time, data, ev),
206 TP_STRUCT__entry(
207 DEV_ENTRY
208
209 __field(u32, time)
210 __field(u32, data)
211 __field(u32, ev)
212 ),
213 TP_fast_assign(
214 DEV_ASSIGN;
215 __entry->time = time;
216 __entry->data = data;
217 __entry->ev = ev;
218 ),
219 TP_printk("[%s] EVT_LOGT:%010u:0x%08x:%04u",
220 __get_str(dev), __entry->time, __entry->data, __entry->ev)
221 );
222
223 TRACE_EVENT(iwlwifi_dev_ucode_wrap_event,
224 TP_PROTO(const struct device *dev, u32 wraps, u32 n_entry, u32 p_entry),
225 TP_ARGS(dev, wraps, n_entry, p_entry),
226 TP_STRUCT__entry(
227 DEV_ENTRY
228
229 __field(u32, wraps)
230 __field(u32, n_entry)
231 __field(u32, p_entry)
232 ),
233 TP_fast_assign(
234 DEV_ASSIGN;
235 __entry->wraps = wraps;
236 __entry->n_entry = n_entry;
237 __entry->p_entry = p_entry;
238 ),
239 TP_printk("[%s] wraps=#%02d n=0x%X p=0x%X",
240 __get_str(dev), __entry->wraps, __entry->n_entry,
241 __entry->p_entry)
242 );
243
244 #undef TRACE_SYSTEM
245 #define TRACE_SYSTEM iwlwifi_msg
246
247 #define MAX_MSG_LEN 110
248
249 DECLARE_EVENT_CLASS(iwlwifi_msg_event,
250 TP_PROTO(struct va_format *vaf),
251 TP_ARGS(vaf),
252 TP_STRUCT__entry(
253 __dynamic_array(char, msg, MAX_MSG_LEN)
254 ),
255 TP_fast_assign(
256 WARN_ON_ONCE(vsnprintf(__get_dynamic_array(msg),
257 MAX_MSG_LEN, vaf->fmt,
258 *vaf->va) >= MAX_MSG_LEN);
259 ),
260 TP_printk("%s", __get_str(msg))
261 );
262
263 DEFINE_EVENT(iwlwifi_msg_event, iwlwifi_err,
264 TP_PROTO(struct va_format *vaf),
265 TP_ARGS(vaf)
266 );
267
268 DEFINE_EVENT(iwlwifi_msg_event, iwlwifi_warn,
269 TP_PROTO(struct va_format *vaf),
270 TP_ARGS(vaf)
271 );
272
273 DEFINE_EVENT(iwlwifi_msg_event, iwlwifi_info,
274 TP_PROTO(struct va_format *vaf),
275 TP_ARGS(vaf)
276 );
277
278 DEFINE_EVENT(iwlwifi_msg_event, iwlwifi_crit,
279 TP_PROTO(struct va_format *vaf),
280 TP_ARGS(vaf)
281 );
282
283 TRACE_EVENT(iwlwifi_dbg,
284 TP_PROTO(u32 level, bool in_interrupt, const char *function,
285 struct va_format *vaf),
286 TP_ARGS(level, in_interrupt, function, vaf),
287 TP_STRUCT__entry(
288 __field(u32, level)
289 __field(u8, in_interrupt)
290 __string(function, function)
291 __dynamic_array(char, msg, MAX_MSG_LEN)
292 ),
293 TP_fast_assign(
294 __entry->level = level;
295 __entry->in_interrupt = in_interrupt;
296 __assign_str(function, function);
297 WARN_ON_ONCE(vsnprintf(__get_dynamic_array(msg),
298 MAX_MSG_LEN, vaf->fmt,
299 *vaf->va) >= MAX_MSG_LEN);
300 ),
301 TP_printk("%s", (char *)__get_dynamic_array(msg))
302 );
303
304 #undef TRACE_SYSTEM
305 #define TRACE_SYSTEM iwlwifi_data
306
307 TRACE_EVENT(iwlwifi_dev_tx_data,
308 TP_PROTO(const struct device *dev,
309 struct sk_buff *skb,
310 void *data, size_t data_len),
311 TP_ARGS(dev, skb, data, data_len),
312 TP_STRUCT__entry(
313 DEV_ENTRY
314
315 __dynamic_array(u8, data, iwl_trace_data(skb) ? data_len : 0)
316 ),
317 TP_fast_assign(
318 DEV_ASSIGN;
319 if (iwl_trace_data(skb))
320 memcpy(__get_dynamic_array(data), data, data_len);
321 ),
322 TP_printk("[%s] TX frame data", __get_str(dev))
323 );
324
325 TRACE_EVENT(iwlwifi_dev_rx_data,
326 TP_PROTO(const struct device *dev,
327 const struct iwl_trans *trans,
328 void *rxbuf, size_t len),
329 TP_ARGS(dev, trans, rxbuf, len),
330 TP_STRUCT__entry(
331 DEV_ENTRY
332
333 __dynamic_array(u8, data,
334 len - iwl_rx_trace_len(trans, rxbuf, len))
335 ),
336 TP_fast_assign(
337 size_t offs = iwl_rx_trace_len(trans, rxbuf, len);
338 DEV_ASSIGN;
339 if (offs < len)
340 memcpy(__get_dynamic_array(data),
341 ((u8 *)rxbuf) + offs, len - offs);
342 ),
343 TP_printk("[%s] RX frame data", __get_str(dev))
344 );
345
346 #undef TRACE_SYSTEM
347 #define TRACE_SYSTEM iwlwifi
348
349 TRACE_EVENT(iwlwifi_dev_hcmd,
350 TP_PROTO(const struct device *dev,
351 struct iwl_host_cmd *cmd, u16 total_size,
352 const void *hdr, size_t hdr_len),
353 TP_ARGS(dev, cmd, total_size, hdr, hdr_len),
354 TP_STRUCT__entry(
355 DEV_ENTRY
356 __dynamic_array(u8, hcmd, total_size)
357 __field(u32, flags)
358 ),
359 TP_fast_assign(
360 int i, offset = hdr_len;
361
362 DEV_ASSIGN;
363 __entry->flags = cmd->flags;
364 memcpy(__get_dynamic_array(hcmd), hdr, hdr_len);
365
366 for (i = 0; i < IWL_MAX_CMD_TFDS; i++) {
367 if (!cmd->len[i])
368 continue;
369 if (!(cmd->dataflags[i] & IWL_HCMD_DFL_NOCOPY))
370 continue;
371 memcpy((u8 *)__get_dynamic_array(hcmd) + offset,
372 cmd->data[i], cmd->len[i]);
373 offset += cmd->len[i];
374 }
375 ),
376 TP_printk("[%s] hcmd %#.2x (%ssync)",
377 __get_str(dev), ((u8 *)__get_dynamic_array(hcmd))[0],
378 __entry->flags & CMD_ASYNC ? "a" : "")
379 );
380
381 TRACE_EVENT(iwlwifi_dev_rx,
382 TP_PROTO(const struct device *dev, const struct iwl_trans *trans,
383 void *rxbuf, size_t len),
384 TP_ARGS(dev, trans, rxbuf, len),
385 TP_STRUCT__entry(
386 DEV_ENTRY
387 __dynamic_array(u8, rxbuf, iwl_rx_trace_len(trans, rxbuf, len))
388 ),
389 TP_fast_assign(
390 DEV_ASSIGN;
391 memcpy(__get_dynamic_array(rxbuf), rxbuf,
392 iwl_rx_trace_len(trans, rxbuf, len));
393 ),
394 TP_printk("[%s] RX cmd %#.2x",
395 __get_str(dev), ((u8 *)__get_dynamic_array(rxbuf))[4])
396 );
397
398 TRACE_EVENT(iwlwifi_dev_tx,
399 TP_PROTO(const struct device *dev, struct sk_buff *skb,
400 void *tfd, size_t tfdlen,
401 void *buf0, size_t buf0_len,
402 void *buf1, size_t buf1_len),
403 TP_ARGS(dev, skb, tfd, tfdlen, buf0, buf0_len, buf1, buf1_len),
404 TP_STRUCT__entry(
405 DEV_ENTRY
406
407 __field(size_t, framelen)
408 __dynamic_array(u8, tfd, tfdlen)
409
410 /*
411 * Do not insert between or below these items,
412 * we want to keep the frame together (except
413 * for the possible padding).
414 */
415 __dynamic_array(u8, buf0, buf0_len)
416 __dynamic_array(u8, buf1, iwl_trace_data(skb) ? 0 : buf1_len)
417 ),
418 TP_fast_assign(
419 DEV_ASSIGN;
420 __entry->framelen = buf0_len + buf1_len;
421 memcpy(__get_dynamic_array(tfd), tfd, tfdlen);
422 memcpy(__get_dynamic_array(buf0), buf0, buf0_len);
423 if (!iwl_trace_data(skb))
424 memcpy(__get_dynamic_array(buf1), buf1, buf1_len);
425 ),
426 TP_printk("[%s] TX %.2x (%zu bytes)",
427 __get_str(dev), ((u8 *)__get_dynamic_array(buf0))[0],
428 __entry->framelen)
429 );
430
431 TRACE_EVENT(iwlwifi_dev_ucode_error,
432 TP_PROTO(const struct device *dev, u32 desc, u32 tsf_low,
433 u32 data1, u32 data2, u32 line, u32 blink1,
434 u32 blink2, u32 ilink1, u32 ilink2, u32 bcon_time,
435 u32 gp1, u32 gp2, u32 gp3, u32 ucode_ver, u32 hw_ver,
436 u32 brd_ver),
437 TP_ARGS(dev, desc, tsf_low, data1, data2, line,
438 blink1, blink2, ilink1, ilink2, bcon_time, gp1, gp2,
439 gp3, ucode_ver, hw_ver, brd_ver),
440 TP_STRUCT__entry(
441 DEV_ENTRY
442 __field(u32, desc)
443 __field(u32, tsf_low)
444 __field(u32, data1)
445 __field(u32, data2)
446 __field(u32, line)
447 __field(u32, blink1)
448 __field(u32, blink2)
449 __field(u32, ilink1)
450 __field(u32, ilink2)
451 __field(u32, bcon_time)
452 __field(u32, gp1)
453 __field(u32, gp2)
454 __field(u32, gp3)
455 __field(u32, ucode_ver)
456 __field(u32, hw_ver)
457 __field(u32, brd_ver)
458 ),
459 TP_fast_assign(
460 DEV_ASSIGN;
461 __entry->desc = desc;
462 __entry->tsf_low = tsf_low;
463 __entry->data1 = data1;
464 __entry->data2 = data2;
465 __entry->line = line;
466 __entry->blink1 = blink1;
467 __entry->blink2 = blink2;
468 __entry->ilink1 = ilink1;
469 __entry->ilink2 = ilink2;
470 __entry->bcon_time = bcon_time;
471 __entry->gp1 = gp1;
472 __entry->gp2 = gp2;
473 __entry->gp3 = gp3;
474 __entry->ucode_ver = ucode_ver;
475 __entry->hw_ver = hw_ver;
476 __entry->brd_ver = brd_ver;
477 ),
478 TP_printk("[%s] #%02d %010u data 0x%08X 0x%08X line %u, "
479 "blink 0x%05X 0x%05X ilink 0x%05X 0x%05X "
480 "bcon_tm %010u gp 0x%08X 0x%08X 0x%08X uCode 0x%08X "
481 "hw 0x%08X brd 0x%08X",
482 __get_str(dev), __entry->desc, __entry->tsf_low,
483 __entry->data1,
484 __entry->data2, __entry->line, __entry->blink1,
485 __entry->blink2, __entry->ilink1, __entry->ilink2,
486 __entry->bcon_time, __entry->gp1, __entry->gp2,
487 __entry->gp3, __entry->ucode_ver, __entry->hw_ver,
488 __entry->brd_ver)
489 );
490
491 TRACE_EVENT(iwlwifi_dev_ucode_event,
492 TP_PROTO(const struct device *dev, u32 time, u32 data, u32 ev),
493 TP_ARGS(dev, time, data, ev),
494 TP_STRUCT__entry(
495 DEV_ENTRY
496
497 __field(u32, time)
498 __field(u32, data)
499 __field(u32, ev)
500 ),
501 TP_fast_assign(
502 DEV_ASSIGN;
503 __entry->time = time;
504 __entry->data = data;
505 __entry->ev = ev;
506 ),
507 TP_printk("[%s] EVT_LOGT:%010u:0x%08x:%04u",
508 __get_str(dev), __entry->time, __entry->data, __entry->ev)
509 );
510 #endif /* __IWLWIFI_DEVICE_TRACE */
511
512 #undef TRACE_INCLUDE_PATH
513 #define TRACE_INCLUDE_PATH .
514 #undef TRACE_INCLUDE_FILE
515 #define TRACE_INCLUDE_FILE iwl-devtrace
516 #include <trace/define_trace.h>
Linux kernel - Deliverables
This page took 0.053173 seconds and 5 git commands to generate.