LCOV - code coverage report
Current view: top level - drivers/net/wireless/ath/ath9k - common-debug.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 31 124 25.0 %
Date: 2022-03-28 13:20:08 Functions: 5 9 55.6 %
Branches: 14 24 58.3 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Copyright (c) 2008-2011 Atheros Communications Inc.
       3                 :            :  *
       4                 :            :  * Permission to use, copy, modify, and/or distribute this software for any
       5                 :            :  * purpose with or without fee is hereby granted, provided that the above
       6                 :            :  * copyright notice and this permission notice appear in all copies.
       7                 :            :  *
       8                 :            :  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
       9                 :            :  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
      10                 :            :  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
      11                 :            :  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
      12                 :            :  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
      13                 :            :  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
      14                 :            :  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
      15                 :            :  */
      16                 :            : 
      17                 :            : #include "common.h"
      18                 :            : 
      19                 :          0 : static ssize_t read_file_modal_eeprom(struct file *file, char __user *user_buf,
      20                 :            :                                       size_t count, loff_t *ppos)
      21                 :            : {
      22                 :          0 :         struct ath_hw *ah = file->private_data;
      23                 :          0 :         u32 len = 0, size = 6000;
      24                 :          0 :         char *buf;
      25                 :          0 :         size_t retval;
      26                 :            : 
      27                 :          0 :         buf = kzalloc(size, GFP_KERNEL);
      28         [ #  # ]:          0 :         if (buf == NULL)
      29                 :            :                 return -ENOMEM;
      30                 :            : 
      31                 :          0 :         len = ah->eep_ops->dump_eeprom(ah, false, buf, len, size);
      32                 :            : 
      33                 :          0 :         retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
      34                 :          0 :         kfree(buf);
      35                 :            : 
      36                 :          0 :         return retval;
      37                 :            : }
      38                 :            : 
      39                 :            : static const struct file_operations fops_modal_eeprom = {
      40                 :            :         .read = read_file_modal_eeprom,
      41                 :            :         .open = simple_open,
      42                 :            :         .owner = THIS_MODULE,
      43                 :            :         .llseek = default_llseek,
      44                 :            : };
      45                 :            : 
      46                 :            : 
      47                 :          6 : void ath9k_cmn_debug_modal_eeprom(struct dentry *debugfs_phy,
      48                 :            :                                   struct ath_hw *ah)
      49                 :            : {
      50                 :          6 :         debugfs_create_file("modal_eeprom", 0400, debugfs_phy, ah,
      51                 :            :                             &fops_modal_eeprom);
      52                 :          6 : }
      53                 :            : EXPORT_SYMBOL(ath9k_cmn_debug_modal_eeprom);
      54                 :            : 
      55                 :          0 : static ssize_t read_file_base_eeprom(struct file *file, char __user *user_buf,
      56                 :            :                                      size_t count, loff_t *ppos)
      57                 :            : {
      58                 :          0 :         struct ath_hw *ah = file->private_data;
      59                 :          0 :         u32 len = 0, size = 1500;
      60                 :          0 :         ssize_t retval = 0;
      61                 :          0 :         char *buf;
      62                 :            : 
      63                 :          0 :         buf = kzalloc(size, GFP_KERNEL);
      64         [ #  # ]:          0 :         if (!buf)
      65                 :            :                 return -ENOMEM;
      66                 :            : 
      67                 :          0 :         len = ah->eep_ops->dump_eeprom(ah, true, buf, len, size);
      68                 :            : 
      69                 :          0 :         retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
      70                 :          0 :         kfree(buf);
      71                 :            : 
      72                 :          0 :         return retval;
      73                 :            : }
      74                 :            : 
      75                 :            : static const struct file_operations fops_base_eeprom = {
      76                 :            :         .read = read_file_base_eeprom,
      77                 :            :         .open = simple_open,
      78                 :            :         .owner = THIS_MODULE,
      79                 :            :         .llseek = default_llseek,
      80                 :            : };
      81                 :            : 
      82                 :          6 : void ath9k_cmn_debug_base_eeprom(struct dentry *debugfs_phy,
      83                 :            :                                  struct ath_hw *ah)
      84                 :            : {
      85                 :          6 :         debugfs_create_file("base_eeprom", 0400, debugfs_phy, ah,
      86                 :            :                             &fops_base_eeprom);
      87                 :          6 : }
      88                 :            : EXPORT_SYMBOL(ath9k_cmn_debug_base_eeprom);
      89                 :            : 
      90                 :         60 : void ath9k_cmn_debug_stat_rx(struct ath_rx_stats *rxstats,
      91                 :            :                              struct ath_rx_status *rs)
      92                 :            : {
      93                 :            : #define RX_PHY_ERR_INC(c) rxstats->phy_err_stats[c]++
      94                 :            : #define RX_CMN_STAT_INC(c) (rxstats->c++)
      95                 :            : 
      96                 :         60 :         RX_CMN_STAT_INC(rx_pkts_all);
      97                 :         60 :         rxstats->rx_bytes_all += rs->rs_datalen;
      98                 :            : 
      99         [ +  + ]:         60 :         if (rs->rs_status & ATH9K_RXERR_CRC)
     100                 :         12 :                 RX_CMN_STAT_INC(crc_err);
     101         [ +  + ]:         60 :         if (rs->rs_status & ATH9K_RXERR_DECRYPT)
     102                 :          6 :                 RX_CMN_STAT_INC(decrypt_crc_err);
     103         [ +  + ]:         60 :         if (rs->rs_status & ATH9K_RXERR_MIC)
     104                 :          2 :                 RX_CMN_STAT_INC(mic_err);
     105         [ +  + ]:         60 :         if (rs->rs_status & ATH9K_RX_DELIM_CRC_PRE)
     106                 :          2 :                 RX_CMN_STAT_INC(pre_delim_crc_err);
     107         [ +  + ]:         60 :         if (rs->rs_status & ATH9K_RX_DELIM_CRC_POST)
     108                 :          4 :                 RX_CMN_STAT_INC(post_delim_crc_err);
     109         [ -  + ]:         60 :         if (rs->rs_status & ATH9K_RX_DECRYPT_BUSY)
     110                 :          0 :                 RX_CMN_STAT_INC(decrypt_busy_err);
     111                 :            : 
     112         [ +  + ]:         60 :         if (rs->rs_status & ATH9K_RXERR_PHY) {
     113                 :         30 :                 RX_CMN_STAT_INC(phy_err);
     114         [ +  - ]:         30 :                 if (rs->rs_phyerr < ATH9K_PHYERR_MAX)
     115                 :         30 :                         RX_PHY_ERR_INC(rs->rs_phyerr);
     116                 :            :         }
     117                 :            : 
     118                 :            : #undef RX_CMN_STAT_INC
     119                 :            : #undef RX_PHY_ERR_INC
     120                 :         60 : }
     121                 :            : EXPORT_SYMBOL(ath9k_cmn_debug_stat_rx);
     122                 :            : 
     123                 :          0 : static ssize_t read_file_recv(struct file *file, char __user *user_buf,
     124                 :            :                               size_t count, loff_t *ppos)
     125                 :            : {
     126                 :            : #define RXS_ERR(s, e)                                   \
     127                 :            :         do {                                            \
     128                 :            :                 len += scnprintf(buf + len, size - len, \
     129                 :            :                                  "%18s : %10u\n", s,  \
     130                 :            :                                  rxstats->e);                \
     131                 :            :         } while (0)
     132                 :            : 
     133                 :          0 :         struct ath_rx_stats *rxstats = file->private_data;
     134                 :          0 :         char *buf;
     135                 :          0 :         unsigned int len = 0, size = 1600;
     136                 :          0 :         ssize_t retval = 0;
     137                 :            : 
     138                 :          0 :         buf = kzalloc(size, GFP_KERNEL);
     139         [ #  # ]:          0 :         if (buf == NULL)
     140                 :            :                 return -ENOMEM;
     141                 :            : 
     142                 :          0 :         RXS_ERR("PKTS-ALL", rx_pkts_all);
     143                 :          0 :         RXS_ERR("BYTES-ALL", rx_bytes_all);
     144                 :          0 :         RXS_ERR("BEACONS", rx_beacons);
     145                 :          0 :         RXS_ERR("FRAGS", rx_frags);
     146                 :          0 :         RXS_ERR("SPECTRAL", rx_spectral);
     147                 :          0 :         RXS_ERR("SPECTRAL SMPL GOOD", rx_spectral_sample_good);
     148                 :          0 :         RXS_ERR("SPECTRAL SMPL ERR", rx_spectral_sample_err);
     149                 :            : 
     150                 :          0 :         RXS_ERR("CRC ERR", crc_err);
     151                 :          0 :         RXS_ERR("DECRYPT CRC ERR", decrypt_crc_err);
     152                 :          0 :         RXS_ERR("PHY ERR", phy_err);
     153                 :          0 :         RXS_ERR("MIC ERR", mic_err);
     154                 :          0 :         RXS_ERR("PRE-DELIM CRC ERR", pre_delim_crc_err);
     155                 :          0 :         RXS_ERR("POST-DELIM CRC ERR", post_delim_crc_err);
     156                 :          0 :         RXS_ERR("DECRYPT BUSY ERR", decrypt_busy_err);
     157                 :          0 :         RXS_ERR("LENGTH-ERR", rx_len_err);
     158                 :          0 :         RXS_ERR("OOM-ERR", rx_oom_err);
     159                 :          0 :         RXS_ERR("RATE-ERR", rx_rate_err);
     160                 :          0 :         RXS_ERR("TOO-MANY-FRAGS", rx_too_many_frags_err);
     161                 :            : 
     162                 :          0 :         if (len > size)
     163                 :            :                 len = size;
     164                 :            : 
     165                 :          0 :         retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
     166                 :          0 :         kfree(buf);
     167                 :            : 
     168                 :          0 :         return retval;
     169                 :            : 
     170                 :            : #undef RXS_ERR
     171                 :            : }
     172                 :            : 
     173                 :            : static const struct file_operations fops_recv = {
     174                 :            :         .read = read_file_recv,
     175                 :            :         .open = simple_open,
     176                 :            :         .owner = THIS_MODULE,
     177                 :            :         .llseek = default_llseek,
     178                 :            : };
     179                 :            : 
     180                 :          6 : void ath9k_cmn_debug_recv(struct dentry *debugfs_phy,
     181                 :            :                           struct ath_rx_stats *rxstats)
     182                 :            : {
     183                 :          6 :         debugfs_create_file("recv", 0400, debugfs_phy, rxstats, &fops_recv);
     184                 :          6 : }
     185                 :            : EXPORT_SYMBOL(ath9k_cmn_debug_recv);
     186                 :            : 
     187                 :          0 : static ssize_t read_file_phy_err(struct file *file, char __user *user_buf,
     188                 :            :                                  size_t count, loff_t *ppos)
     189                 :            : {
     190                 :            : #define PHY_ERR(s, p) \
     191                 :            :         len += scnprintf(buf + len, size - len, "%22s : %10u\n", s, \
     192                 :            :                          rxstats->phy_err_stats[p]);
     193                 :            : 
     194                 :          0 :         struct ath_rx_stats *rxstats = file->private_data;
     195                 :          0 :         char *buf;
     196                 :          0 :         unsigned int len = 0, size = 1600;
     197                 :          0 :         ssize_t retval = 0;
     198                 :            : 
     199                 :          0 :         buf = kzalloc(size, GFP_KERNEL);
     200         [ #  # ]:          0 :         if (buf == NULL)
     201                 :            :                 return -ENOMEM;
     202                 :            : 
     203                 :          0 :         PHY_ERR("UNDERRUN ERR", ATH9K_PHYERR_UNDERRUN);
     204                 :          0 :         PHY_ERR("TIMING ERR", ATH9K_PHYERR_TIMING);
     205                 :          0 :         PHY_ERR("PARITY ERR", ATH9K_PHYERR_PARITY);
     206                 :          0 :         PHY_ERR("RATE ERR", ATH9K_PHYERR_RATE);
     207                 :          0 :         PHY_ERR("LENGTH ERR", ATH9K_PHYERR_LENGTH);
     208                 :          0 :         PHY_ERR("RADAR ERR", ATH9K_PHYERR_RADAR);
     209                 :          0 :         PHY_ERR("SERVICE ERR", ATH9K_PHYERR_SERVICE);
     210                 :          0 :         PHY_ERR("TOR ERR", ATH9K_PHYERR_TOR);
     211                 :            : 
     212                 :          0 :         PHY_ERR("OFDM-TIMING ERR", ATH9K_PHYERR_OFDM_TIMING);
     213                 :          0 :         PHY_ERR("OFDM-SIGNAL-PARITY ERR", ATH9K_PHYERR_OFDM_SIGNAL_PARITY);
     214                 :          0 :         PHY_ERR("OFDM-RATE ERR", ATH9K_PHYERR_OFDM_RATE_ILLEGAL);
     215                 :          0 :         PHY_ERR("OFDM-LENGTH ERR", ATH9K_PHYERR_OFDM_LENGTH_ILLEGAL);
     216                 :          0 :         PHY_ERR("OFDM-POWER-DROP ERR", ATH9K_PHYERR_OFDM_POWER_DROP);
     217                 :          0 :         PHY_ERR("OFDM-SERVICE ERR", ATH9K_PHYERR_OFDM_SERVICE);
     218                 :          0 :         PHY_ERR("OFDM-RESTART ERR", ATH9K_PHYERR_OFDM_RESTART);
     219                 :            : 
     220                 :          0 :         PHY_ERR("CCK-BLOCKER ERR", ATH9K_PHYERR_CCK_BLOCKER);
     221                 :          0 :         PHY_ERR("CCK-TIMING ERR", ATH9K_PHYERR_CCK_TIMING);
     222                 :          0 :         PHY_ERR("CCK-HEADER-CRC ERR", ATH9K_PHYERR_CCK_HEADER_CRC);
     223                 :          0 :         PHY_ERR("CCK-RATE ERR", ATH9K_PHYERR_CCK_RATE_ILLEGAL);
     224                 :          0 :         PHY_ERR("CCK-LENGTH ERR", ATH9K_PHYERR_CCK_LENGTH_ILLEGAL);
     225                 :          0 :         PHY_ERR("CCK-POWER-DROP ERR", ATH9K_PHYERR_CCK_POWER_DROP);
     226                 :          0 :         PHY_ERR("CCK-SERVICE ERR", ATH9K_PHYERR_CCK_SERVICE);
     227                 :          0 :         PHY_ERR("CCK-RESTART ERR", ATH9K_PHYERR_CCK_RESTART);
     228                 :            : 
     229                 :          0 :         PHY_ERR("HT-CRC ERR", ATH9K_PHYERR_HT_CRC_ERROR);
     230                 :          0 :         PHY_ERR("HT-LENGTH ERR", ATH9K_PHYERR_HT_LENGTH_ILLEGAL);
     231                 :          0 :         PHY_ERR("HT-RATE ERR", ATH9K_PHYERR_HT_RATE_ILLEGAL);
     232                 :          0 :         PHY_ERR("HT-ZLF ERR", ATH9K_PHYERR_HT_ZLF);
     233                 :            : 
     234                 :          0 :         PHY_ERR("FALSE-RADAR-EXT ERR", ATH9K_PHYERR_FALSE_RADAR_EXT);
     235                 :          0 :         PHY_ERR("GREEN-FIELD ERR", ATH9K_PHYERR_GREEN_FIELD);
     236                 :          0 :         PHY_ERR("SPECTRAL ERR", ATH9K_PHYERR_SPECTRAL);
     237                 :            : 
     238                 :          0 :         if (len > size)
     239                 :            :                 len = size;
     240                 :            : 
     241                 :          0 :         retval = simple_read_from_buffer(user_buf, count, ppos, buf, len);
     242                 :          0 :         kfree(buf);
     243                 :            : 
     244                 :          0 :         return retval;
     245                 :            : 
     246                 :            : #undef PHY_ERR
     247                 :            : }
     248                 :            : 
     249                 :            : static const struct file_operations fops_phy_err = {
     250                 :            :         .read = read_file_phy_err,
     251                 :            :         .open = simple_open,
     252                 :            :         .owner = THIS_MODULE,
     253                 :            :         .llseek = default_llseek,
     254                 :            : };
     255                 :            : 
     256                 :          6 : void ath9k_cmn_debug_phy_err(struct dentry *debugfs_phy,
     257                 :            :                              struct ath_rx_stats *rxstats)
     258                 :            : {
     259                 :          6 :         debugfs_create_file("phy_err", 0400, debugfs_phy, rxstats,
     260                 :            :                             &fops_phy_err);
     261                 :          6 : }
     262                 :            : EXPORT_SYMBOL(ath9k_cmn_debug_phy_err);

Generated by: LCOV version 1.14