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