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