Loading...
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, "FLAGS : %lx\n",
102 qca->flags);
103
104 seq_printf(s, "SPI max speed : %lu\n",
105 (unsigned long)qca->spi_dev->max_speed_hz);
106 seq_printf(s, "SPI mode : %x\n",
107 qca->spi_dev->mode);
108 seq_printf(s, "SPI chip select : %u\n",
109 (unsigned int)spi_get_chipselect(qca->spi_dev, 0));
110 seq_printf(s, "SPI legacy mode : %u\n",
111 (unsigned int)qca->legacy_mode);
112 seq_printf(s, "SPI burst length : %u\n",
113 (unsigned int)qca->burst_len);
114
115 return 0;
116}
117DEFINE_SHOW_ATTRIBUTE(qcaspi_info);
118
119void
120qcaspi_init_device_debugfs(struct qcaspi *qca)
121{
122 qca->device_root = debugfs_create_dir(dev_name(&qca->net_dev->dev),
123 NULL);
124
125 debugfs_create_file("info", S_IFREG | 0444, qca->device_root, qca,
126 &qcaspi_info_fops);
127}
128
129void
130qcaspi_remove_device_debugfs(struct qcaspi *qca)
131{
132 debugfs_remove_recursive(qca->device_root);
133}
134
135#else /* CONFIG_DEBUG_FS */
136
137void
138qcaspi_init_device_debugfs(struct qcaspi *qca)
139{
140}
141
142void
143qcaspi_remove_device_debugfs(struct qcaspi *qca)
144{
145}
146
147#endif
148
149static void
150qcaspi_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *p)
151{
152 struct qcaspi *qca = netdev_priv(dev);
153
154 strscpy(p->driver, QCASPI_DRV_NAME, sizeof(p->driver));
155 strscpy(p->version, QCASPI_DRV_VERSION, sizeof(p->version));
156 strscpy(p->fw_version, "QCA7000", sizeof(p->fw_version));
157 strscpy(p->bus_info, dev_name(&qca->spi_dev->dev),
158 sizeof(p->bus_info));
159}
160
161static int
162qcaspi_get_link_ksettings(struct net_device *dev,
163 struct ethtool_link_ksettings *cmd)
164{
165 ethtool_link_ksettings_zero_link_mode(cmd, supported);
166 ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half);
167
168 cmd->base.speed = SPEED_10;
169 cmd->base.duplex = DUPLEX_HALF;
170 cmd->base.port = PORT_OTHER;
171 cmd->base.autoneg = AUTONEG_DISABLE;
172
173 return 0;
174}
175
176static void
177qcaspi_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *estats, u64 *data)
178{
179 struct qcaspi *qca = netdev_priv(dev);
180 struct qcaspi_stats *st = &qca->stats;
181
182 memcpy(data, st, ARRAY_SIZE(qcaspi_gstrings_stats) * sizeof(u64));
183}
184
185static void
186qcaspi_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
187{
188 switch (stringset) {
189 case ETH_SS_STATS:
190 memcpy(buf, &qcaspi_gstrings_stats,
191 sizeof(qcaspi_gstrings_stats));
192 break;
193 default:
194 WARN_ON(1);
195 break;
196 }
197}
198
199static int
200qcaspi_get_sset_count(struct net_device *dev, int sset)
201{
202 switch (sset) {
203 case ETH_SS_STATS:
204 return ARRAY_SIZE(qcaspi_gstrings_stats);
205 default:
206 return -EINVAL;
207 }
208}
209
210static int
211qcaspi_get_regs_len(struct net_device *dev)
212{
213 return sizeof(u32) * QCASPI_MAX_REGS;
214}
215
216static void
217qcaspi_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *p)
218{
219 struct qcaspi *qca = netdev_priv(dev);
220 u32 *regs_buff = p;
221 unsigned int i;
222
223 regs->version = 1;
224 memset(regs_buff, 0, sizeof(u32) * QCASPI_MAX_REGS);
225
226 for (i = 0; i < ARRAY_SIZE(qcaspi_spi_regs); i++) {
227 u16 offset, value;
228
229 qcaspi_read_register(qca, qcaspi_spi_regs[i], &value);
230 offset = qcaspi_spi_regs[i] >> 8;
231 regs_buff[offset] = value;
232 }
233}
234
235static void
236qcaspi_get_ringparam(struct net_device *dev, struct ethtool_ringparam *ring,
237 struct kernel_ethtool_ringparam *kernel_ring,
238 struct netlink_ext_ack *extack)
239{
240 struct qcaspi *qca = netdev_priv(dev);
241
242 ring->rx_max_pending = QCASPI_RX_MAX_FRAMES;
243 ring->tx_max_pending = QCASPI_TX_RING_MAX_LEN;
244 ring->rx_pending = QCASPI_RX_MAX_FRAMES;
245 ring->tx_pending = qca->txr.count;
246}
247
248static int
249qcaspi_set_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 if (ring->rx_pending != QCASPI_RX_MAX_FRAMES ||
256 (ring->rx_mini_pending) ||
257 (ring->rx_jumbo_pending))
258 return -EINVAL;
259
260 if (qca->spi_thread)
261 kthread_park(qca->spi_thread);
262
263 qca->txr.count = max_t(u32, ring->tx_pending, QCASPI_TX_RING_MIN_LEN);
264 qca->txr.count = min_t(u16, qca->txr.count, QCASPI_TX_RING_MAX_LEN);
265
266 if (qca->spi_thread)
267 kthread_unpark(qca->spi_thread);
268
269 return 0;
270}
271
272static const struct ethtool_ops qcaspi_ethtool_ops = {
273 .get_drvinfo = qcaspi_get_drvinfo,
274 .get_link = ethtool_op_get_link,
275 .get_ethtool_stats = qcaspi_get_ethtool_stats,
276 .get_strings = qcaspi_get_strings,
277 .get_sset_count = qcaspi_get_sset_count,
278 .get_regs_len = qcaspi_get_regs_len,
279 .get_regs = qcaspi_get_regs,
280 .get_ringparam = qcaspi_get_ringparam,
281 .set_ringparam = qcaspi_set_ringparam,
282 .get_link_ksettings = qcaspi_get_link_ksettings,
283};
284
285void qcaspi_set_ethtool_ops(struct net_device *dev)
286{
287 dev->ethtool_ops = &qcaspi_ethtool_ops;
288}
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};
66
67#ifdef CONFIG_DEBUG_FS
68
69static int
70qcaspi_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}
129DEFINE_SHOW_ATTRIBUTE(qcaspi_info);
130
131void
132qcaspi_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
141void
142qcaspi_remove_device_debugfs(struct qcaspi *qca)
143{
144 debugfs_remove_recursive(qca->device_root);
145}
146
147#else /* CONFIG_DEBUG_FS */
148
149void
150qcaspi_init_device_debugfs(struct qcaspi *qca)
151{
152}
153
154void
155qcaspi_remove_device_debugfs(struct qcaspi *qca)
156{
157}
158
159#endif
160
161static void
162qcaspi_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
173static int
174qcaspi_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
188static void
189qcaspi_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
197static void
198qcaspi_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
211static int
212qcaspi_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
222static int
223qcaspi_get_regs_len(struct net_device *dev)
224{
225 return sizeof(u32) * QCASPI_MAX_REGS;
226}
227
228static void
229qcaspi_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
247static void
248qcaspi_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
258static int
259qcaspi_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
281static 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
294void qcaspi_set_ethtool_ops(struct net_device *dev)
295{
296 dev->ethtool_ops = &qcaspi_ethtool_ops;
297}