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 33static 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 */ 51static 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 67static int 68qcaspi_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 128static int 129qcaspi_info_open(struct inode *inode, struct file *file) 130{ 131 return single_open(file, qcaspi_info_show, inode->i_private); 132} 133 134static 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 141void 142qcaspi_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 | S_IRUGO, device_root, qca, 155 &qcaspi_info_ops); 156} 157 158void 159qcaspi_remove_device_debugfs(struct qcaspi *qca) 160{ 161 debugfs_remove_recursive(qca->device_root); 162} 163 164#else /* CONFIG_DEBUG_FS */ 165 166void 167qcaspi_init_device_debugfs(struct qcaspi *qca) 168{ 169} 170 171void 172qcaspi_remove_device_debugfs(struct qcaspi *qca) 173{ 174} 175 176#endif 177 178static void 179qcaspi_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 190static int 191qcaspi_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 192{ 193 cmd->transceiver = XCVR_INTERNAL; 194 cmd->supported = SUPPORTED_10baseT_Half; 195 ethtool_cmd_speed_set(cmd, SPEED_10); 196 cmd->duplex = DUPLEX_HALF; 197 cmd->port = PORT_OTHER; 198 cmd->autoneg = AUTONEG_DISABLE; 199 200 return 0; 201} 202 203static void 204qcaspi_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *estats, u64 *data) 205{ 206 struct qcaspi *qca = netdev_priv(dev); 207 struct qcaspi_stats *st = &qca->stats; 208 209 memcpy(data, st, ARRAY_SIZE(qcaspi_gstrings_stats) * sizeof(u64)); 210} 211 212static void 213qcaspi_get_strings(struct net_device *dev, u32 stringset, u8 *buf) 214{ 215 switch (stringset) { 216 case ETH_SS_STATS: 217 memcpy(buf, &qcaspi_gstrings_stats, 218 sizeof(qcaspi_gstrings_stats)); 219 break; 220 default: 221 WARN_ON(1); 222 break; 223 } 224} 225 226static int 227qcaspi_get_sset_count(struct net_device *dev, int sset) 228{ 229 switch (sset) { 230 case ETH_SS_STATS: 231 return ARRAY_SIZE(qcaspi_gstrings_stats); 232 default: 233 return -EINVAL; 234 } 235} 236 237static int 238qcaspi_get_regs_len(struct net_device *dev) 239{ 240 return sizeof(u32) * QCASPI_MAX_REGS; 241} 242 243static void 244qcaspi_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p) 245{ 246 struct qcaspi *qca = netdev_priv(dev); 247 u32 *regs_buff = p; 248 unsigned int i; 249 250 regs->version = 1; 251 memset(regs_buff, 0, sizeof(u32) * QCASPI_MAX_REGS); 252 253 for (i = 0; i < ARRAY_SIZE(qcaspi_spi_regs); i++) { 254 u16 offset, value; 255 256 qcaspi_read_register(qca, qcaspi_spi_regs[i], &value); 257 offset = qcaspi_spi_regs[i] >> 8; 258 regs_buff[offset] = value; 259 } 260} 261 262static void 263qcaspi_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring) 264{ 265 struct qcaspi *qca = netdev_priv(dev); 266 267 ring->rx_max_pending = 4; 268 ring->tx_max_pending = TX_RING_MAX_LEN; 269 ring->rx_pending = 4; 270 ring->tx_pending = qca->txr.count; 271} 272 273static int 274qcaspi_set_ringparam(struct net_device *dev, struct ethtool_ringparam *ring) 275{ 276 struct qcaspi *qca = netdev_priv(dev); 277 278 if ((ring->rx_pending) || 279 (ring->rx_mini_pending) || 280 (ring->rx_jumbo_pending)) 281 return -EINVAL; 282 283 if (netif_running(dev)) 284 qcaspi_netdev_close(dev); 285 286 qca->txr.count = max_t(u32, ring->tx_pending, TX_RING_MIN_LEN); 287 qca->txr.count = min_t(u16, qca->txr.count, TX_RING_MAX_LEN); 288 289 if (netif_running(dev)) 290 qcaspi_netdev_open(dev); 291 292 return 0; 293} 294 295static const struct ethtool_ops qcaspi_ethtool_ops = { 296 .get_drvinfo = qcaspi_get_drvinfo, 297 .get_link = ethtool_op_get_link, 298 .get_settings = qcaspi_get_settings, 299 .get_ethtool_stats = qcaspi_get_ethtool_stats, 300 .get_strings = qcaspi_get_strings, 301 .get_sset_count = qcaspi_get_sset_count, 302 .get_regs_len = qcaspi_get_regs_len, 303 .get_regs = qcaspi_get_regs, 304 .get_ringparam = qcaspi_get_ringparam, 305 .set_ringparam = qcaspi_set_ringparam, 306}; 307 308void qcaspi_set_ethtool_ops(struct net_device *dev) 309{ 310 dev->ethtool_ops = &qcaspi_ethtool_ops; 311} 312