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         "Write verify errors",
  64         "Buffer available errors",
  65 };
  66
  67 #ifdef CONFIG_DEBUG_FS
  68
  69 static int
  70 qcaspi_info_show(struct seq_file *s, void *what)
  71 {
  72         struct qcaspi *qca = s->private;
  73
  74         seq_printf(s, "RX buffer size   : %lu\n",
  75                    (unsigned long)qca->buffer_size);
  76
  77         seq_puts(s, "TX ring state    : ");
  78
  79         if (qca->txr.skb[qca->txr.head] == NULL)
  80                 seq_puts(s, "empty");
  81         else if (qca->txr.skb[qca->txr.tail])
  82                 seq_puts(s, "full");
  83         else
  84                 seq_puts(s, "in use");
  85
  86         seq_puts(s, "\n");
  87
  88         seq_printf(s, "TX ring size     : %u\n",
  89                    qca->txr.size);
  90
  91         seq_printf(s, "Sync state       : %u (",
  92                    (unsigned int)qca->sync);
  93         switch (qca->sync) {
  94         case QCASPI_SYNC_UNKNOWN:
  95                 seq_puts(s, "QCASPI_SYNC_UNKNOWN");
  96                 break;
  97         case QCASPI_SYNC_RESET:
  98                 seq_puts(s, "QCASPI_SYNC_RESET");
  99                 break;
 100         case QCASPI_SYNC_READY:
 101                 seq_puts(s, "QCASPI_SYNC_READY");
 102                 break;
 103         default:
 104                 seq_puts(s, "INVALID");
 105                 break;
 106         }
 107         seq_puts(s, ")\n");
 108
 109         seq_printf(s, "IRQ              : %d\n",
 110                    qca->spi_dev->irq);
 111         seq_printf(s, "INTR REQ         : %u\n",
 112                    qca->intr_req);
 113         seq_printf(s, "INTR SVC         : %u\n",
 114                    qca->intr_svc);
 115
 116         seq_printf(s, "SPI max speed    : %lu\n",
 117                    (unsigned long)qca->spi_dev->max_speed_hz);
 118         seq_printf(s, "SPI mode         : %x\n",
 119                    qca->spi_dev->mode);
 120         seq_printf(s, "SPI chip select  : %u\n",
 121                    (unsigned int)qca->spi_dev->chip_select);
 122         seq_printf(s, "SPI legacy mode  : %u\n",
 123                    (unsigned int)qca->legacy_mode);
 124         seq_printf(s, "SPI burst length : %u\n",
 125                    (unsigned int)qca->burst_len);
 126
 127         return 0;
 128 }
 129 DEFINE_SHOW_ATTRIBUTE(qcaspi_info);
 130
 131 void
 132 qcaspi_init_device_debugfs(struct qcaspi *qca)
 133 {
 134         qca->device_root = debugfs_create_dir(dev_name(&qca->net_dev->dev),
 135                                               NULL);
 136
 137         debugfs_create_file("info", S_IFREG | 0444, qca->device_root, qca,
 138                             &qcaspi_info_fops);
 139 }
 140
 141 void
 142 qcaspi_remove_device_debugfs(struct qcaspi *qca)
 143 {
 144         debugfs_remove_recursive(qca->device_root);
 145 }
 146
 147 #else /* CONFIG_DEBUG_FS */
 148
 149 void
 150 qcaspi_init_device_debugfs(struct qcaspi *qca)
 151 {
 152 }
 153
 154 void
 155 qcaspi_remove_device_debugfs(struct qcaspi *qca)
 156 {
 157 }
 158
 159 #endif
 160
 161 static void
 162 qcaspi_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *p)
 163 {
 164         struct qcaspi *qca = netdev_priv(dev);
 165
 166         strlcpy(p->driver, QCASPI_DRV_NAME, sizeof(p->driver));
 167         strlcpy(p->version, QCASPI_DRV_VERSION, sizeof(p->version));
 168         strlcpy(p->fw_version, "QCA7000", sizeof(p->fw_version));
 169         strlcpy(p->bus_info, dev_name(&qca->spi_dev->dev),
 170                 sizeof(p->bus_info));
 171 }
 172
 173 static int
 174 qcaspi_get_link_ksettings(struct net_device *dev,
 175                           struct ethtool_link_ksettings *cmd)
 176 {
 177         ethtool_link_ksettings_zero_link_mode(cmd, supported);
 178         ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half);
 179
 180         cmd->base.speed = SPEED_10;
 181         cmd->base.duplex = DUPLEX_HALF;
 182         cmd->base.port = PORT_OTHER;
 183         cmd->base.autoneg = AUTONEG_DISABLE;
 184
 185         return 0;
 186 }
 187
 188 static void
 189 qcaspi_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *estats, u64 *data)
 190 {
 191         struct qcaspi *qca = netdev_priv(dev);
 192         struct qcaspi_stats *st = &qca->stats;
 193
 194         memcpy(data, st, ARRAY_SIZE(qcaspi_gstrings_stats) * sizeof(u64));
 195 }
 196
 197 static void
 198 qcaspi_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
 199 {
 200         switch (stringset) {
 201         case ETH_SS_STATS:
 202                 memcpy(buf, &qcaspi_gstrings_stats,
 203                        sizeof(qcaspi_gstrings_stats));
 204                 break;
 205         default:
 206                 WARN_ON(1);
 207                 break;
 208         }
 209 }
 210
 211 static int
 212 qcaspi_get_sset_count(struct net_device *dev, int sset)
 213 {
 214         switch (sset) {
 215         case ETH_SS_STATS:
 216                 return ARRAY_SIZE(qcaspi_gstrings_stats);
 217         default:
 218                 return -EINVAL;
 219         }
 220 }
 221
 222 static int
 223 qcaspi_get_regs_len(struct net_device *dev)
 224 {
 225         return sizeof(u32) * QCASPI_MAX_REGS;
 226 }
 227
 228 static void
 229 qcaspi_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
 230 {
 231         struct qcaspi *qca = netdev_priv(dev);
 232         u32 *regs_buff = p;
 233         unsigned int i;
 234
 235         regs->version = 1;
 236         memset(regs_buff, 0, sizeof(u32) * QCASPI_MAX_REGS);
 237
 238         for (i = 0; i < ARRAY_SIZE(qcaspi_spi_regs); i++) {
 239                 u16 offset, value;
 240
 241                 qcaspi_read_register(qca, qcaspi_spi_regs[i], &value);
 242                 offset = qcaspi_spi_regs[i] >> 8;
 243                 regs_buff[offset] = value;
 244         }
 245 }
 246
 247 static void
 248 qcaspi_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
 249 {
 250         struct qcaspi *qca = netdev_priv(dev);
 251
 252         ring->rx_max_pending = 4;
 253         ring->tx_max_pending = TX_RING_MAX_LEN;
 254         ring->rx_pending = 4;
 255         ring->tx_pending = qca->txr.count;
 256 }
 257
 258 static int
 259 qcaspi_set_ringparam(struct net_device *dev, struct ethtool_ringparam *ring)
 260 {
 261         const struct net_device_ops *ops = dev->netdev_ops;
 262         struct qcaspi *qca = netdev_priv(dev);
 263
 264         if ((ring->rx_pending) ||
 265             (ring->rx_mini_pending) ||
 266             (ring->rx_jumbo_pending))
 267                 return -EINVAL;
 268
 269         if (netif_running(dev))
 270                 ops->ndo_stop(dev);
 271
 272         qca->txr.count = max_t(u32, ring->tx_pending, TX_RING_MIN_LEN);
 273         qca->txr.count = min_t(u16, qca->txr.count, TX_RING_MAX_LEN);
 274
 275         if (netif_running(dev))
 276                 ops->ndo_open(dev);
 277
 278         return 0;
 279 }
 280
 281 static const struct ethtool_ops qcaspi_ethtool_ops = {
 282         .get_drvinfo = qcaspi_get_drvinfo,
 283         .get_link = ethtool_op_get_link,
 284         .get_ethtool_stats = qcaspi_get_ethtool_stats,
 285         .get_strings = qcaspi_get_strings,
 286         .get_sset_count = qcaspi_get_sset_count,
 287         .get_regs_len = qcaspi_get_regs_len,
 288         .get_regs = qcaspi_get_regs,
 289         .get_ringparam = qcaspi_get_ringparam,
 290         .set_ringparam = qcaspi_set_ringparam,
 291         .get_link_ksettings = qcaspi_get_link_ksettings,
 292 };
 293
 294 void qcaspi_set_ethtool_ops(struct net_device *dev)
 295 {
 296         dev->ethtool_ops = &qcaspi_ethtool_ops;
 297 }