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