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 } 298