drivers/net/ethernet/qualcomm/qca_debug.c

   1 /*
   2  *   Copyright (c) 2011, 2012, Qualcomm Atheros Communications Inc.
   3  *   Copyright (c) 2014, I2SE GmbH
   4  *
   5  *   Permission to use, copy, modify, and/or distribute this software
   6  *   for any purpose with or without fee is hereby granted, provided
   7  *   that the above copyright notice and this permission notice appear
   8  *   in all copies.
   9  *
  10  *   THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  11  *   WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  12  *   WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
  13  *   THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR
  14  *   CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  15  *   LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  16  *   NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  17  *   CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  18  */
  19
  20 /*   This file contains debugging routines for use in the QCA7K driver.
  21  */
  22
  23 #include <linux/debugfs.h>
  24 #include <linux/ethtool.h>
  25 #include <linux/seq_file.h>
  26 #include <linux/types.h>
  27
  28 #include "qca_7k.h"
  29 #include "qca_debug.h"
  30
  31 #define QCASPI_MAX_REGS 0x20
  32
  33 static const u16 qcaspi_spi_regs[] = {
  34         SPI_REG_BFR_SIZE,
  35         SPI_REG_WRBUF_SPC_AVA,
  36         SPI_REG_RDBUF_BYTE_AVA,
  37         SPI_REG_SPI_CONFIG,
  38         SPI_REG_SPI_STATUS,
  39         SPI_REG_INTR_CAUSE,
  40         SPI_REG_INTR_ENABLE,
  41         SPI_REG_RDBUF_WATERMARK,
  42         SPI_REG_WRBUF_WATERMARK,
  43         SPI_REG_SIGNATURE,
  44         SPI_REG_ACTION_CTRL
  45 };
  46
  47 /* The order of these strings must match the order of the fields in
  48  * struct qcaspi_stats
  49  * See qca_spi.h
  50  */
  51 static const char qcaspi_gstrings_stats[][ETH_GSTRING_LEN] = {
  52         "Triggered resets",
  53         "Device resets",
  54         "Reset timeouts",
  55         "Read errors",
  56         "Write errors",
  57         "Read buffer errors",
  58         "Write buffer errors",
  59         "Out of memory",
  60         "Write buffer misses",
  61         "Transmit ring full",
  62         "SPI errors",
  63 };
  64
  65 #ifdef CONFIG_DEBUG_FS
  66
  67 static int
  68 qcaspi_info_show(struct seq_file *s, void *what)
  69 {
  70         struct qcaspi *qca = s->private;
  71
  72         seq_printf(s, "RX buffer size   : %lu\n",
  73                    (unsigned long)qca->buffer_size);
  74
  75         seq_puts(s, "TX ring state    : ");
  76
  77         if (qca->txr.skb[qca->txr.head] == NULL)
  78                 seq_puts(s, "empty");
  79         else if (qca->txr.skb[qca->txr.tail])
  80                 seq_puts(s, "full");
  81         else
  82                 seq_puts(s, "in use");
  83
  84         seq_puts(s, "\n");
  85
  86         seq_printf(s, "TX ring size     : %u\n",
  87                    qca->txr.size);
  88
  89         seq_printf(s, "Sync state       : %u (",
  90                    (unsigned int)qca->sync);
  91         switch (qca->sync) {
  92         case QCASPI_SYNC_UNKNOWN:
  93                 seq_puts(s, "QCASPI_SYNC_UNKNOWN");
  94                 break;
  95         case QCASPI_SYNC_RESET:
  96                 seq_puts(s, "QCASPI_SYNC_RESET");
  97                 break;
  98         case QCASPI_SYNC_READY:
  99                 seq_puts(s, "QCASPI_SYNC_READY");
 100                 break;
 101         default:
 102                 seq_puts(s, "INVALID");
 103                 break;
 104         }
 105         seq_puts(s, ")\n");
 106
 107         seq_printf(s, "IRQ              : %d\n",
 108                    qca->spi_dev->irq);
 109         seq_printf(s, "INTR REQ         : %u\n",
 110                    qca->intr_req);
 111         seq_printf(s, "INTR SVC         : %u\n",
 112                    qca->intr_svc);
 113
 114         seq_printf(s, "SPI max speed    : %lu\n",
 115                    (unsigned long)qca->spi_dev->max_speed_hz);
 116         seq_printf(s, "SPI mode         : %x\n",
 117                    qca->spi_dev->mode);
 118         seq_printf(s, "SPI chip select  : %u\n",
 119                    (unsigned int)qca->spi_dev->chip_select);
 120         seq_printf(s, "SPI legacy mode  : %u\n",
 121                    (unsigned int)qca->legacy_mode);
 122         seq_printf(s, "SPI burst length : %u\n",
 123                    (unsigned int)qca->burst_len);
 124
 125         return 0;
 126 }
 127
 128 static int
 129 qcaspi_info_open(struct inode *inode, struct file *file)
 130 {
 131         return single_open(file, qcaspi_info_show, inode->i_private);
 132 }
 133
 134 static const struct file_operations qcaspi_info_ops = {
 135         .open = qcaspi_info_open,
 136         .read = seq_read,
 137         .llseek = seq_lseek,
 138         .release = single_release,
 139 };
 140
 141 void
 142 qcaspi_init_device_debugfs(struct qcaspi *qca)
 143 {
 144         struct dentry *device_root;
 145
 146         device_root = debugfs_create_dir(dev_name(&qca->net_dev->dev), NULL);
 147         qca->device_root = device_root;
 148
 149         if (IS_ERR(device_root) || !device_root) {
 150                 pr_warn("failed to create debugfs directory for %s\n",
 151                         dev_name(&qca->net_dev->dev));
 152                 return;
 153         }
 154         debugfs_create_file("info", S_IFREG | 0444, device_root, qca,
 155                             &qcaspi_info_ops);
 156 }
 157
 158 void
 159 qcaspi_remove_device_debugfs(struct qcaspi *qca)
 160 {
 161         debugfs_remove_recursive(qca->device_root);
 162 }
 163
 164 #else /* CONFIG_DEBUG_FS */
 165
 166 void
 167 qcaspi_init_device_debugfs(struct qcaspi *qca)
 168 {
 169 }
 170
 171 void
 172 qcaspi_remove_device_debugfs(struct qcaspi *qca)
 173 {
 174 }
 175
 176 #endif
 177
 178 static void
 179 qcaspi_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *p)
 180 {
 181         struct qcaspi *qca = netdev_priv(dev);
 182
 183         strlcpy(p->driver, QCASPI_DRV_NAME, sizeof(p->driver));
 184         strlcpy(p->version, QCASPI_DRV_VERSION, sizeof(p->version));
 185         strlcpy(p->fw_version, "QCA7000", sizeof(p->fw_version));
 186         strlcpy(p->bus_info, dev_name(&qca->spi_dev->dev),
 187                 sizeof(p->bus_info));
 188 }
 189
 190 static int
 191 qcaspi_get_link_ksettings(struct net_device *dev,
 192                           struct ethtool_link_ksettings *cmd)
 193 {
 194         ethtool_link_ksettings_zero_link_mode(cmd, supported);
 195         ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half);
 196
 197         cmd->base.speed = SPEED_10;
 198         cmd->base.duplex = DUPLEX_HALF;
 199         cmd->base.port = PORT_OTHER;
 200         cmd->base.autoneg = AUTONEG_DISABLE;
 201
 202         return 0;
 203 }
 204
 205 static void
 206 qcaspi_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *estats, u64 *data)
 207 {
 208         struct qcaspi *qca = netdev_priv(dev);
 209         struct qcaspi_stats *st = &qca->stats;
 210
 211         memcpy(data, st, ARRAY_SIZE(qcaspi_gstrings_stats) * sizeof(u64));
 212 }
 213
 214 static void
 215 qcaspi_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
 216 {
 217         switch (stringset) {
 218         case ETH_SS_STATS:
 219                 memcpy(buf, &qcaspi_gstrings_stats,
 220                        sizeof(qcaspi_gstrings_stats));
 221                 break;
 222         default:
 223                 WARN_ON(1);
 224                 break;
 225         }
 226 }
 227
 228 static int
 229 qcaspi_get_sset_count(struct net_device *dev, int sset)
 230 {
 231         switch (sset) {
 232         case ETH_SS_STATS:
 233                 return ARRAY_SIZE(qcaspi_gstrings_stats);
 234         default:
 235                 return -EINVAL;
 236         }
 237 }
 238
 239 static int
 240 qcaspi_get_regs_len(struct net_device *dev)
 241 {
 242         return sizeof(u32) * QCASPI_MAX_REGS;
 243 }
 244
 245 static void
 246 qcaspi_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
 247 {
 248         struct qcaspi *qca = netdev_priv(dev);
 249         u32 *regs_buff = p;
 250         unsigned int i;
 251
 252         regs->version = 1;
 253         memset(regs_buff, 0, sizeof(u32) * QCASPI_MAX_REGS);
 254
 255         for (i = 0; i < ARRAY_SIZE(qcaspi_spi_regs); i++) {
 256                 u16 offset, value;
 257
 258                 qcaspi_read_register(qca, qcaspi_spi_regs[i], &value);
 259                 offset = qcaspi_spi_regs[i] >> 8;
 260                 regs_buff[offset] = value;
 261         }
 262 }
 263
 264 static void
 265 qcaspi_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
 266 {
 267         struct qcaspi *qca = netdev_priv(dev);
 268
 269         ring->rx_max_pending = 4;
 270         ring->tx_max_pending = TX_RING_MAX_LEN;
 271         ring->rx_pending = 4;
 272         ring->tx_pending = qca->txr.count;
 273 }
 274
 275 static int
 276 qcaspi_set_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
 277 {
 278         const struct net_device_ops *ops = dev->netdev_ops;
 279         struct qcaspi *qca = netdev_priv(dev);
 280
 281         if ((ring->rx_pending) ||
 282             (ring->rx_mini_pending) ||
 283             (ring->rx_jumbo_pending))
 284                 return -EINVAL;
 285
 286         if (netif_running(dev))
 287                 ops->ndo_stop(dev);
 288
 289         qca->txr.count = max_t(u32, ring->tx_pending, TX_RING_MIN_LEN);
 290         qca->txr.count = min_t(u16, qca->txr.count, TX_RING_MAX_LEN);
 291
 292         if (netif_running(dev))
 293                 ops->ndo_open(dev);
 294
 295         return 0;
 296 }
 297
 298 static const struct ethtool_ops qcaspi_ethtool_ops = {
 299         .get_drvinfo = qcaspi_get_drvinfo,
 300         .get_link = ethtool_op_get_link,
 301         .get_ethtool_stats = qcaspi_get_ethtool_stats,
 302         .get_strings = qcaspi_get_strings,
 303         .get_sset_count = qcaspi_get_sset_count,
 304         .get_regs_len = qcaspi_get_regs_len,
 305         .get_regs = qcaspi_get_regs,
 306         .get_ringparam = qcaspi_get_ringparam,
 307         .set_ringparam = qcaspi_set_ringparam,
 308         .get_link_ksettings = qcaspi_get_link_ksettings,
 309 };
 310
 311 void qcaspi_set_ethtool_ops(struct net_device *dev)
 312 {
 313         dev->ethtool_ops = &qcaspi_ethtool_ops;
 314 }