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