1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * mac80211 glue code for mac80211 ST-Ericsson CW1200 drivers
4  * DebugFS code
5  *
6  * Copyright (c) 2010, ST-Ericsson
7  * Author: Dmitry Tarnyagin <dmitry.tarnyagin@lockless.no>
8  */
9 
10 #include <linux/module.h>
11 #include <linux/debugfs.h>
12 #include <linux/seq_file.h>
13 #include "cw1200.h"
14 #include "debug.h"
15 #include "fwio.h"
16 
17 /* join_status */
18 static const char * const cw1200_debug_join_status[] = {
19 	"passive",
20 	"monitor",
21 	"station (joining)",
22 	"station (not authenticated yet)",
23 	"station",
24 	"adhoc",
25 	"access point",
26 };
27 
28 /* WSM_JOIN_PREAMBLE_... */
29 static const char * const cw1200_debug_preamble[] = {
30 	"long",
31 	"short",
32 	"long on 1 and 2 Mbps",
33 };
34 
35 
36 static const char * const cw1200_debug_link_id[] = {
37 	"OFF",
38 	"REQ",
39 	"SOFT",
40 	"HARD",
41 	"RESET",
42 	"RESET_REMAP",
43 };
44 
45 static const char *cw1200_debug_mode(int mode)
46 {
47 	switch (mode) {
48 	case NL80211_IFTYPE_UNSPECIFIED:
49 		return "unspecified";
50 	case NL80211_IFTYPE_MONITOR:
51 		return "monitor";
52 	case NL80211_IFTYPE_STATION:
53 		return "station";
54 	case NL80211_IFTYPE_ADHOC:
55 		return "adhoc";
56 	case NL80211_IFTYPE_MESH_POINT:
57 		return "mesh point";
58 	case NL80211_IFTYPE_AP:
59 		return "access point";
60 	case NL80211_IFTYPE_P2P_CLIENT:
61 		return "p2p client";
62 	case NL80211_IFTYPE_P2P_GO:
63 		return "p2p go";
64 	default:
65 		return "unsupported";
66 	}
67 }
68 
69 static void cw1200_queue_status_show(struct seq_file *seq,
70 				     struct cw1200_queue *q)
71 {
72 	int i;
73 	seq_printf(seq, "Queue       %d:\n", q->queue_id);
74 	seq_printf(seq, "  capacity: %zu\n", q->capacity);
75 	seq_printf(seq, "  queued:   %zu\n", q->num_queued);
76 	seq_printf(seq, "  pending:  %zu\n", q->num_pending);
77 	seq_printf(seq, "  sent:     %zu\n", q->num_sent);
78 	seq_printf(seq, "  locked:   %s\n", q->tx_locked_cnt ? "yes" : "no");
79 	seq_printf(seq, "  overfull: %s\n", q->overfull ? "yes" : "no");
80 	seq_puts(seq,   "  link map: 0-> ");
81 	for (i = 0; i < q->stats->map_capacity; ++i)
82 		seq_printf(seq, "%.2d ", q->link_map_cache[i]);
83 	seq_printf(seq, "<-%zu\n", q->stats->map_capacity);
84 }
85 
86 static void cw1200_debug_print_map(struct seq_file *seq,
87 				   struct cw1200_common *priv,
88 				   const char *label,
89 				   u32 map)
90 {
91 	int i;
92 	seq_printf(seq, "%s0-> ", label);
93 	for (i = 0; i < priv->tx_queue_stats.map_capacity; ++i)
94 		seq_printf(seq, "%s ", (map & BIT(i)) ? "**" : "..");
95 	seq_printf(seq, "<-%zu\n", priv->tx_queue_stats.map_capacity - 1);
96 }
97 
98 static int cw1200_status_show(struct seq_file *seq, void *v)
99 {
100 	int i;
101 	struct list_head *item;
102 	struct cw1200_common *priv = seq->private;
103 	struct cw1200_debug_priv *d = priv->debug;
104 
105 	seq_puts(seq,   "CW1200 Wireless LAN driver status\n");
106 	seq_printf(seq, "Hardware:   %d.%d\n",
107 		   priv->wsm_caps.hw_id,
108 		   priv->wsm_caps.hw_subid);
109 	seq_printf(seq, "Firmware:   %s %d.%d\n",
110 		   cw1200_fw_types[priv->wsm_caps.fw_type],
111 		   priv->wsm_caps.fw_ver,
112 		   priv->wsm_caps.fw_build);
113 	seq_printf(seq, "FW API:     %d\n",
114 		   priv->wsm_caps.fw_api);
115 	seq_printf(seq, "FW caps:    0x%.4X\n",
116 		   priv->wsm_caps.fw_cap);
117 	seq_printf(seq, "FW label:  '%s'\n",
118 		   priv->wsm_caps.fw_label);
119 	seq_printf(seq, "Mode:       %s%s\n",
120 		   cw1200_debug_mode(priv->mode),
121 		   priv->listening ? " (listening)" : "");
122 	seq_printf(seq, "Join state: %s\n",
123 		   cw1200_debug_join_status[priv->join_status]);
124 	if (priv->channel)
125 		seq_printf(seq, "Channel:    %d%s\n",
126 			   priv->channel->hw_value,
127 			   priv->channel_switch_in_progress ?
128 			   " (switching)" : "");
129 	if (priv->rx_filter.promiscuous)
130 		seq_puts(seq,   "Filter:     promisc\n");
131 	else if (priv->rx_filter.fcs)
132 		seq_puts(seq,   "Filter:     fcs\n");
133 	if (priv->rx_filter.bssid)
134 		seq_puts(seq,   "Filter:     bssid\n");
135 	if (!priv->disable_beacon_filter)
136 		seq_puts(seq,   "Filter:     beacons\n");
137 
138 	if (priv->enable_beacon ||
139 	    priv->mode == NL80211_IFTYPE_AP ||
140 	    priv->mode == NL80211_IFTYPE_ADHOC ||
141 	    priv->mode == NL80211_IFTYPE_MESH_POINT ||
142 	    priv->mode == NL80211_IFTYPE_P2P_GO)
143 		seq_printf(seq, "Beaconing:  %s\n",
144 			   priv->enable_beacon ?
145 			   "enabled" : "disabled");
146 
147 	for (i = 0; i < 4; ++i)
148 		seq_printf(seq, "EDCA(%d):    %d, %d, %d, %d, %d\n", i,
149 			   priv->edca.params[i].cwmin,
150 			   priv->edca.params[i].cwmax,
151 			   priv->edca.params[i].aifns,
152 			   priv->edca.params[i].txop_limit,
153 			   priv->edca.params[i].max_rx_lifetime);
154 
155 	if (priv->join_status == CW1200_JOIN_STATUS_STA) {
156 		static const char *pm_mode = "unknown";
157 		switch (priv->powersave_mode.mode) {
158 		case WSM_PSM_ACTIVE:
159 			pm_mode = "off";
160 			break;
161 		case WSM_PSM_PS:
162 			pm_mode = "on";
163 			break;
164 		case WSM_PSM_FAST_PS:
165 			pm_mode = "dynamic";
166 			break;
167 		}
168 		seq_printf(seq, "Preamble:   %s\n",
169 			   cw1200_debug_preamble[priv->association_mode.preamble]);
170 		seq_printf(seq, "AMPDU spcn: %d\n",
171 			   priv->association_mode.mpdu_start_spacing);
172 		seq_printf(seq, "Basic rate: 0x%.8X\n",
173 			   le32_to_cpu(priv->association_mode.basic_rate_set));
174 		seq_printf(seq, "Bss lost:   %d beacons\n",
175 			   priv->bss_params.beacon_lost_count);
176 		seq_printf(seq, "AID:        %d\n",
177 			   priv->bss_params.aid);
178 		seq_printf(seq, "Rates:      0x%.8X\n",
179 			   priv->bss_params.operational_rate_set);
180 		seq_printf(seq, "Powersave:  %s\n", pm_mode);
181 	}
182 	seq_printf(seq, "HT:         %s\n",
183 		   cw1200_is_ht(&priv->ht_info) ? "on" : "off");
184 	if (cw1200_is_ht(&priv->ht_info)) {
185 		seq_printf(seq, "Greenfield: %s\n",
186 			   cw1200_ht_greenfield(&priv->ht_info) ? "yes" : "no");
187 		seq_printf(seq, "AMPDU dens: %d\n",
188 			   cw1200_ht_ampdu_density(&priv->ht_info));
189 	}
190 	seq_printf(seq, "RSSI thold: %d\n",
191 		   priv->cqm_rssi_thold);
192 	seq_printf(seq, "RSSI hyst:  %d\n",
193 		   priv->cqm_rssi_hyst);
194 	seq_printf(seq, "Long retr:  %d\n",
195 		   priv->long_frame_max_tx_count);
196 	seq_printf(seq, "Short retr: %d\n",
197 		   priv->short_frame_max_tx_count);
198 	spin_lock_bh(&priv->tx_policy_cache.lock);
199 	i = 0;
200 	list_for_each(item, &priv->tx_policy_cache.used)
201 		++i;
202 	spin_unlock_bh(&priv->tx_policy_cache.lock);
203 	seq_printf(seq, "RC in use:  %d\n", i);
204 
205 	seq_puts(seq, "\n");
206 	for (i = 0; i < 4; ++i) {
207 		cw1200_queue_status_show(seq, &priv->tx_queue[i]);
208 		seq_puts(seq, "\n");
209 	}
210 
211 	cw1200_debug_print_map(seq, priv, "Link map:   ",
212 			       priv->link_id_map);
213 	cw1200_debug_print_map(seq, priv, "Asleep map: ",
214 			       priv->sta_asleep_mask);
215 	cw1200_debug_print_map(seq, priv, "PSPOLL map: ",
216 			       priv->pspoll_mask);
217 
218 	seq_puts(seq, "\n");
219 
220 	for (i = 0; i < CW1200_MAX_STA_IN_AP_MODE; ++i) {
221 		if (priv->link_id_db[i].status) {
222 			seq_printf(seq, "Link %d:     %s, %pM\n",
223 				   i + 1,
224 				   cw1200_debug_link_id[priv->link_id_db[i].status],
225 				   priv->link_id_db[i].mac);
226 		}
227 	}
228 
229 	seq_puts(seq, "\n");
230 
231 	seq_printf(seq, "BH status:  %s\n",
232 		   atomic_read(&priv->bh_term) ? "terminated" : "alive");
233 	seq_printf(seq, "Pending RX: %d\n",
234 		   atomic_read(&priv->bh_rx));
235 	seq_printf(seq, "Pending TX: %d\n",
236 		   atomic_read(&priv->bh_tx));
237 	if (priv->bh_error)
238 		seq_printf(seq, "BH errcode: %d\n",
239 			   priv->bh_error);
240 	seq_printf(seq, "TX bufs:    %d x %d bytes\n",
241 		   priv->wsm_caps.input_buffers,
242 		   priv->wsm_caps.input_buffer_size);
243 	seq_printf(seq, "Used bufs:  %d\n",
244 		   priv->hw_bufs_used);
245 	seq_printf(seq, "Powermgmt:  %s\n",
246 		   priv->powersave_enabled ? "on" : "off");
247 	seq_printf(seq, "Device:     %s\n",
248 		   priv->device_can_sleep ? "asleep" : "awake");
249 
250 	spin_lock(&priv->wsm_cmd.lock);
251 	seq_printf(seq, "WSM status: %s\n",
252 		   priv->wsm_cmd.done ? "idle" : "active");
253 	seq_printf(seq, "WSM cmd:    0x%.4X (%td bytes)\n",
254 		   priv->wsm_cmd.cmd, priv->wsm_cmd.len);
255 	seq_printf(seq, "WSM retval: %d\n",
256 		   priv->wsm_cmd.ret);
257 	spin_unlock(&priv->wsm_cmd.lock);
258 
259 	seq_printf(seq, "Datapath:   %s\n",
260 		   atomic_read(&priv->tx_lock) ? "locked" : "unlocked");
261 	if (atomic_read(&priv->tx_lock))
262 		seq_printf(seq, "TXlock cnt: %d\n",
263 			   atomic_read(&priv->tx_lock));
264 
265 	seq_printf(seq, "TXed:       %d\n",
266 		   d->tx);
267 	seq_printf(seq, "AGG TXed:   %d\n",
268 		   d->tx_agg);
269 	seq_printf(seq, "MULTI TXed: %d (%d)\n",
270 		   d->tx_multi, d->tx_multi_frames);
271 	seq_printf(seq, "RXed:       %d\n",
272 		   d->rx);
273 	seq_printf(seq, "AGG RXed:   %d\n",
274 		   d->rx_agg);
275 	seq_printf(seq, "TX miss:    %d\n",
276 		   d->tx_cache_miss);
277 	seq_printf(seq, "TX align:   %d\n",
278 		   d->tx_align);
279 	seq_printf(seq, "TX burst:   %d\n",
280 		   d->tx_burst);
281 	seq_printf(seq, "TX TTL:     %d\n",
282 		   d->tx_ttl);
283 	seq_printf(seq, "Scan:       %s\n",
284 		   atomic_read(&priv->scan.in_progress) ? "active" : "idle");
285 
286 	return 0;
287 }
288 
289 DEFINE_SHOW_ATTRIBUTE(cw1200_status);
290 
291 static int cw1200_counters_show(struct seq_file *seq, void *v)
292 {
293 	int ret;
294 	struct cw1200_common *priv = seq->private;
295 	struct wsm_mib_counters_table counters;
296 
297 	ret = wsm_get_counters_table(priv, &counters);
298 	if (ret)
299 		return ret;
300 
301 #define PUT_COUNTER(tab, name) \
302 	seq_printf(seq, "%s:" tab "%d\n", #name, \
303 		__le32_to_cpu(counters.name))
304 
305 	PUT_COUNTER("\t\t", plcp_errors);
306 	PUT_COUNTER("\t\t", fcs_errors);
307 	PUT_COUNTER("\t\t", tx_packets);
308 	PUT_COUNTER("\t\t", rx_packets);
309 	PUT_COUNTER("\t\t", rx_packet_errors);
310 	PUT_COUNTER("\t",   rx_decryption_failures);
311 	PUT_COUNTER("\t\t", rx_mic_failures);
312 	PUT_COUNTER("\t",   rx_no_key_failures);
313 	PUT_COUNTER("\t",   tx_multicast_frames);
314 	PUT_COUNTER("\t",   tx_frames_success);
315 	PUT_COUNTER("\t",   tx_frame_failures);
316 	PUT_COUNTER("\t",   tx_frames_retried);
317 	PUT_COUNTER("\t",   tx_frames_multi_retried);
318 	PUT_COUNTER("\t",   rx_frame_duplicates);
319 	PUT_COUNTER("\t\t", rts_success);
320 	PUT_COUNTER("\t\t", rts_failures);
321 	PUT_COUNTER("\t\t", ack_failures);
322 	PUT_COUNTER("\t",   rx_multicast_frames);
323 	PUT_COUNTER("\t",   rx_frames_success);
324 	PUT_COUNTER("\t",   rx_cmac_icv_errors);
325 	PUT_COUNTER("\t\t", rx_cmac_replays);
326 	PUT_COUNTER("\t",   rx_mgmt_ccmp_replays);
327 
328 #undef PUT_COUNTER
329 
330 	return 0;
331 }
332 
333 DEFINE_SHOW_ATTRIBUTE(cw1200_counters);
334 
335 static ssize_t cw1200_wsm_dumps(struct file *file,
336 	const char __user *user_buf, size_t count, loff_t *ppos)
337 {
338 	struct cw1200_common *priv = file->private_data;
339 	char buf[1];
340 
341 	if (!count)
342 		return -EINVAL;
343 	if (copy_from_user(buf, user_buf, 1))
344 		return -EFAULT;
345 
346 	if (buf[0] == '1')
347 		priv->wsm_enable_wsm_dumps = 1;
348 	else
349 		priv->wsm_enable_wsm_dumps = 0;
350 
351 	return count;
352 }
353 
354 static const struct file_operations fops_wsm_dumps = {
355 	.open = simple_open,
356 	.write = cw1200_wsm_dumps,
357 	.llseek = default_llseek,
358 };
359 
360 int cw1200_debug_init(struct cw1200_common *priv)
361 {
362 	int ret = -ENOMEM;
363 	struct cw1200_debug_priv *d = kzalloc(sizeof(struct cw1200_debug_priv),
364 			GFP_KERNEL);
365 	priv->debug = d;
366 	if (!d)
367 		return ret;
368 
369 	d->debugfs_phy = debugfs_create_dir("cw1200",
370 					    priv->hw->wiphy->debugfsdir);
371 	debugfs_create_file("status", 0400, d->debugfs_phy, priv,
372 			    &cw1200_status_fops);
373 	debugfs_create_file("counters", 0400, d->debugfs_phy, priv,
374 			    &cw1200_counters_fops);
375 	debugfs_create_file("wsm_dumps", 0200, d->debugfs_phy, priv,
376 			    &fops_wsm_dumps);
377 
378 	return 0;
379 }
380 
381 void cw1200_debug_release(struct cw1200_common *priv)
382 {
383 	struct cw1200_debug_priv *d = priv->debug;
384 	if (d) {
385 		debugfs_remove_recursive(d->debugfs_phy);
386 		priv->debug = NULL;
387 		kfree(d);
388 	}
389 }
390