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