1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2010 Felix Fietkau <nbd@openwrt.org> 4 */ 5 #include <linux/netdevice.h> 6 #include <linux/types.h> 7 #include <linux/skbuff.h> 8 #include <linux/debugfs.h> 9 #include <linux/ieee80211.h> 10 #include <linux/export.h> 11 #include <net/mac80211.h> 12 #include "rc80211_minstrel_ht.h" 13 14 struct minstrel_debugfs_info { 15 size_t len; 16 char buf[]; 17 }; 18 19 static ssize_t 20 minstrel_stats_read(struct file *file, char __user *buf, size_t len, loff_t *ppos) 21 { 22 struct minstrel_debugfs_info *ms; 23 24 ms = file->private_data; 25 return simple_read_from_buffer(buf, len, ppos, ms->buf, ms->len); 26 } 27 28 static int 29 minstrel_stats_release(struct inode *inode, struct file *file) 30 { 31 kfree(file->private_data); 32 return 0; 33 } 34 35 static char * 36 minstrel_ht_stats_dump(struct minstrel_ht_sta *mi, int i, char *p) 37 { 38 const struct mcs_group *mg; 39 unsigned int j, tp_max, tp_avg, eprob, tx_time; 40 char htmode = '2'; 41 char gimode = 'L'; 42 u32 gflags; 43 44 if (!mi->supported[i]) 45 return p; 46 47 mg = &minstrel_mcs_groups[i]; 48 gflags = mg->flags; 49 50 if (gflags & IEEE80211_TX_RC_40_MHZ_WIDTH) 51 htmode = '4'; 52 else if (gflags & IEEE80211_TX_RC_80_MHZ_WIDTH) 53 htmode = '8'; 54 if (gflags & IEEE80211_TX_RC_SHORT_GI) 55 gimode = 'S'; 56 57 for (j = 0; j < MCS_GROUP_RATES; j++) { 58 struct minstrel_rate_stats *mrs = &mi->groups[i].rates[j]; 59 int idx = i * MCS_GROUP_RATES + j; 60 unsigned int duration; 61 62 if (!(mi->supported[i] & BIT(j))) 63 continue; 64 65 if (gflags & IEEE80211_TX_RC_MCS) { 66 p += sprintf(p, "HT%c0 ", htmode); 67 p += sprintf(p, "%cGI ", gimode); 68 p += sprintf(p, "%d ", mg->streams); 69 } else if (gflags & IEEE80211_TX_RC_VHT_MCS) { 70 p += sprintf(p, "VHT%c0 ", htmode); 71 p += sprintf(p, "%cGI ", gimode); 72 p += sprintf(p, "%d ", mg->streams); 73 } else if (i == MINSTREL_OFDM_GROUP) { 74 p += sprintf(p, "OFDM "); 75 p += sprintf(p, "1 "); 76 } else { 77 p += sprintf(p, "CCK "); 78 p += sprintf(p, "%cP ", j < 4 ? 'L' : 'S'); 79 p += sprintf(p, "1 "); 80 } 81 82 *(p++) = (idx == mi->max_tp_rate[0]) ? 'A' : ' '; 83 *(p++) = (idx == mi->max_tp_rate[1]) ? 'B' : ' '; 84 *(p++) = (idx == mi->max_tp_rate[2]) ? 'C' : ' '; 85 *(p++) = (idx == mi->max_tp_rate[3]) ? 'D' : ' '; 86 *(p++) = (idx == mi->max_prob_rate) ? 'P' : ' '; 87 88 if (gflags & IEEE80211_TX_RC_MCS) { 89 p += sprintf(p, " MCS%-2u", (mg->streams - 1) * 8 + j); 90 } else if (gflags & IEEE80211_TX_RC_VHT_MCS) { 91 p += sprintf(p, " MCS%-1u/%1u", j, mg->streams); 92 } else { 93 int r; 94 95 if (i == MINSTREL_OFDM_GROUP) 96 r = minstrel_ofdm_bitrates[j % 8]; 97 else 98 r = minstrel_cck_bitrates[j % 4]; 99 100 p += sprintf(p, " %2u.%1uM", r / 10, r % 10); 101 } 102 103 p += sprintf(p, " %3u ", idx); 104 105 /* tx_time[rate(i)] in usec */ 106 duration = mg->duration[j]; 107 duration <<= mg->shift; 108 tx_time = DIV_ROUND_CLOSEST(duration, 1000); 109 p += sprintf(p, "%6u ", tx_time); 110 111 tp_max = minstrel_ht_get_tp_avg(mi, i, j, MINSTREL_FRAC(100, 100)); 112 tp_avg = minstrel_ht_get_tp_avg(mi, i, j, mrs->prob_avg); 113 eprob = MINSTREL_TRUNC(mrs->prob_avg * 1000); 114 115 p += sprintf(p, "%4u.%1u %4u.%1u %3u.%1u" 116 " %3u %3u %-3u " 117 "%9llu %-9llu\n", 118 tp_max / 10, tp_max % 10, 119 tp_avg / 10, tp_avg % 10, 120 eprob / 10, eprob % 10, 121 mrs->retry_count, 122 mrs->last_success, 123 mrs->last_attempts, 124 (unsigned long long)mrs->succ_hist, 125 (unsigned long long)mrs->att_hist); 126 } 127 128 return p; 129 } 130 131 static int 132 minstrel_ht_stats_open(struct inode *inode, struct file *file) 133 { 134 struct minstrel_ht_sta *mi = inode->i_private; 135 struct minstrel_debugfs_info *ms; 136 unsigned int i; 137 char *p; 138 139 ms = kmalloc(32768, GFP_KERNEL); 140 if (!ms) 141 return -ENOMEM; 142 143 file->private_data = ms; 144 p = ms->buf; 145 146 p += sprintf(p, "\n"); 147 p += sprintf(p, 148 " best ____________rate__________ ____statistics___ _____last____ ______sum-of________\n"); 149 p += sprintf(p, 150 "mode guard # rate [name idx airtime max_tp] [avg(tp) avg(prob)] [retry|suc|att] [#success | #attempts]\n"); 151 152 p = minstrel_ht_stats_dump(mi, MINSTREL_CCK_GROUP, p); 153 for (i = 0; i < MINSTREL_CCK_GROUP; i++) 154 p = minstrel_ht_stats_dump(mi, i, p); 155 for (i++; i < ARRAY_SIZE(mi->groups); i++) 156 p = minstrel_ht_stats_dump(mi, i, p); 157 158 p += sprintf(p, "\nTotal packet count:: ideal %d " 159 "lookaround %d\n", 160 max(0, (int) mi->total_packets - (int) mi->sample_packets), 161 mi->sample_packets); 162 if (mi->avg_ampdu_len) 163 p += sprintf(p, "Average # of aggregated frames per A-MPDU: %d.%d\n", 164 MINSTREL_TRUNC(mi->avg_ampdu_len), 165 MINSTREL_TRUNC(mi->avg_ampdu_len * 10) % 10); 166 ms->len = p - ms->buf; 167 WARN_ON(ms->len + sizeof(*ms) > 32768); 168 169 return nonseekable_open(inode, file); 170 } 171 172 static const struct file_operations minstrel_ht_stat_fops = { 173 .owner = THIS_MODULE, 174 .open = minstrel_ht_stats_open, 175 .read = minstrel_stats_read, 176 .release = minstrel_stats_release, 177 .llseek = no_llseek, 178 }; 179 180 static char * 181 minstrel_ht_stats_csv_dump(struct minstrel_ht_sta *mi, int i, char *p) 182 { 183 const struct mcs_group *mg; 184 unsigned int j, tp_max, tp_avg, eprob, tx_time; 185 char htmode = '2'; 186 char gimode = 'L'; 187 u32 gflags; 188 189 if (!mi->supported[i]) 190 return p; 191 192 mg = &minstrel_mcs_groups[i]; 193 gflags = mg->flags; 194 195 if (gflags & IEEE80211_TX_RC_40_MHZ_WIDTH) 196 htmode = '4'; 197 else if (gflags & IEEE80211_TX_RC_80_MHZ_WIDTH) 198 htmode = '8'; 199 if (gflags & IEEE80211_TX_RC_SHORT_GI) 200 gimode = 'S'; 201 202 for (j = 0; j < MCS_GROUP_RATES; j++) { 203 struct minstrel_rate_stats *mrs = &mi->groups[i].rates[j]; 204 int idx = i * MCS_GROUP_RATES + j; 205 unsigned int duration; 206 207 if (!(mi->supported[i] & BIT(j))) 208 continue; 209 210 if (gflags & IEEE80211_TX_RC_MCS) { 211 p += sprintf(p, "HT%c0,", htmode); 212 p += sprintf(p, "%cGI,", gimode); 213 p += sprintf(p, "%d,", mg->streams); 214 } else if (gflags & IEEE80211_TX_RC_VHT_MCS) { 215 p += sprintf(p, "VHT%c0,", htmode); 216 p += sprintf(p, "%cGI,", gimode); 217 p += sprintf(p, "%d,", mg->streams); 218 } else if (i == MINSTREL_OFDM_GROUP) { 219 p += sprintf(p, "OFDM,,1,"); 220 } else { 221 p += sprintf(p, "CCK,"); 222 p += sprintf(p, "%cP,", j < 4 ? 'L' : 'S'); 223 p += sprintf(p, "1,"); 224 } 225 226 p += sprintf(p, "%s" ,((idx == mi->max_tp_rate[0]) ? "A" : "")); 227 p += sprintf(p, "%s" ,((idx == mi->max_tp_rate[1]) ? "B" : "")); 228 p += sprintf(p, "%s" ,((idx == mi->max_tp_rate[2]) ? "C" : "")); 229 p += sprintf(p, "%s" ,((idx == mi->max_tp_rate[3]) ? "D" : "")); 230 p += sprintf(p, "%s" ,((idx == mi->max_prob_rate) ? "P" : "")); 231 232 if (gflags & IEEE80211_TX_RC_MCS) { 233 p += sprintf(p, ",MCS%-2u,", (mg->streams - 1) * 8 + j); 234 } else if (gflags & IEEE80211_TX_RC_VHT_MCS) { 235 p += sprintf(p, ",MCS%-1u/%1u,", j, mg->streams); 236 } else { 237 int r; 238 239 if (i == MINSTREL_OFDM_GROUP) 240 r = minstrel_ofdm_bitrates[j % 8]; 241 else 242 r = minstrel_cck_bitrates[j % 4]; 243 244 p += sprintf(p, ",%2u.%1uM,", r / 10, r % 10); 245 } 246 247 p += sprintf(p, "%u,", idx); 248 249 duration = mg->duration[j]; 250 duration <<= mg->shift; 251 tx_time = DIV_ROUND_CLOSEST(duration, 1000); 252 p += sprintf(p, "%u,", tx_time); 253 254 tp_max = minstrel_ht_get_tp_avg(mi, i, j, MINSTREL_FRAC(100, 100)); 255 tp_avg = minstrel_ht_get_tp_avg(mi, i, j, mrs->prob_avg); 256 eprob = MINSTREL_TRUNC(mrs->prob_avg * 1000); 257 258 p += sprintf(p, "%u.%u,%u.%u,%u.%u,%u,%u," 259 "%u,%llu,%llu,", 260 tp_max / 10, tp_max % 10, 261 tp_avg / 10, tp_avg % 10, 262 eprob / 10, eprob % 10, 263 mrs->retry_count, 264 mrs->last_success, 265 mrs->last_attempts, 266 (unsigned long long)mrs->succ_hist, 267 (unsigned long long)mrs->att_hist); 268 p += sprintf(p, "%d,%d,%d.%d\n", 269 max(0, (int) mi->total_packets - 270 (int) mi->sample_packets), 271 mi->sample_packets, 272 MINSTREL_TRUNC(mi->avg_ampdu_len), 273 MINSTREL_TRUNC(mi->avg_ampdu_len * 10) % 10); 274 } 275 276 return p; 277 } 278 279 static int 280 minstrel_ht_stats_csv_open(struct inode *inode, struct file *file) 281 { 282 struct minstrel_ht_sta *mi = inode->i_private; 283 struct minstrel_debugfs_info *ms; 284 unsigned int i; 285 char *p; 286 287 ms = kmalloc(32768, GFP_KERNEL); 288 if (!ms) 289 return -ENOMEM; 290 291 file->private_data = ms; 292 293 p = ms->buf; 294 295 p = minstrel_ht_stats_csv_dump(mi, MINSTREL_CCK_GROUP, p); 296 for (i = 0; i < MINSTREL_CCK_GROUP; i++) 297 p = minstrel_ht_stats_csv_dump(mi, i, p); 298 for (i++; i < ARRAY_SIZE(mi->groups); i++) 299 p = minstrel_ht_stats_csv_dump(mi, i, p); 300 301 ms->len = p - ms->buf; 302 WARN_ON(ms->len + sizeof(*ms) > 32768); 303 304 return nonseekable_open(inode, file); 305 } 306 307 static const struct file_operations minstrel_ht_stat_csv_fops = { 308 .owner = THIS_MODULE, 309 .open = minstrel_ht_stats_csv_open, 310 .read = minstrel_stats_read, 311 .release = minstrel_stats_release, 312 .llseek = no_llseek, 313 }; 314 315 void 316 minstrel_ht_add_sta_debugfs(void *priv, void *priv_sta, struct dentry *dir) 317 { 318 debugfs_create_file("rc_stats", 0444, dir, priv_sta, 319 &minstrel_ht_stat_fops); 320 debugfs_create_file("rc_stats_csv", 0444, dir, priv_sta, 321 &minstrel_ht_stat_csv_fops); 322 } 323