Loading...
1/* SPDX-License-Identifier: GPL-2.0+ */
2/* Copyright (C) 2018 Microchip Technology Inc. */
3
4#include <linux/netdevice.h>
5#include <linux/net_tstamp.h>
6#include <linux/pci.h>
7#include <linux/phy.h>
8#include "lan743x_main.h"
9#include "lan743x_ethtool.h"
10#include <linux/sched.h>
11#include <linux/iopoll.h>
12
13/* eeprom */
14#define LAN743X_EEPROM_MAGIC (0x74A5)
15#define LAN743X_OTP_MAGIC (0x74F3)
16#define EEPROM_INDICATOR_1 (0xA5)
17#define EEPROM_INDICATOR_2 (0xAA)
18#define EEPROM_MAC_OFFSET (0x01)
19#define MAX_EEPROM_SIZE (512)
20#define MAX_OTP_SIZE (1024)
21#define OTP_INDICATOR_1 (0xF3)
22#define OTP_INDICATOR_2 (0xF7)
23
24#define LOCK_TIMEOUT_MAX_CNT (100) // 1 sec (10 msce * 100)
25
26#define LAN743X_CSR_READ_OP(offset) lan743x_csr_read(adapter, offset)
27
28static int lan743x_otp_power_up(struct lan743x_adapter *adapter)
29{
30 u32 reg_value;
31
32 reg_value = lan743x_csr_read(adapter, OTP_PWR_DN);
33
34 if (reg_value & OTP_PWR_DN_PWRDN_N_) {
35 /* clear it and wait to be cleared */
36 reg_value &= ~OTP_PWR_DN_PWRDN_N_;
37 lan743x_csr_write(adapter, OTP_PWR_DN, reg_value);
38
39 usleep_range(100, 20000);
40 }
41
42 return 0;
43}
44
45static void lan743x_otp_power_down(struct lan743x_adapter *adapter)
46{
47 u32 reg_value;
48
49 reg_value = lan743x_csr_read(adapter, OTP_PWR_DN);
50 if (!(reg_value & OTP_PWR_DN_PWRDN_N_)) {
51 /* set power down bit */
52 reg_value |= OTP_PWR_DN_PWRDN_N_;
53 lan743x_csr_write(adapter, OTP_PWR_DN, reg_value);
54 }
55}
56
57static void lan743x_otp_set_address(struct lan743x_adapter *adapter,
58 u32 address)
59{
60 lan743x_csr_write(adapter, OTP_ADDR_HIGH, (address >> 8) & 0x03);
61 lan743x_csr_write(adapter, OTP_ADDR_LOW, address & 0xFF);
62}
63
64static void lan743x_otp_read_go(struct lan743x_adapter *adapter)
65{
66 lan743x_csr_write(adapter, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
67 lan743x_csr_write(adapter, OTP_CMD_GO, OTP_CMD_GO_GO_);
68}
69
70static int lan743x_otp_wait_till_not_busy(struct lan743x_adapter *adapter)
71{
72 unsigned long timeout;
73 u32 reg_val;
74
75 timeout = jiffies + HZ;
76 do {
77 if (time_after(jiffies, timeout)) {
78 netif_warn(adapter, drv, adapter->netdev,
79 "Timeout on OTP_STATUS completion\n");
80 return -EIO;
81 }
82 udelay(1);
83 reg_val = lan743x_csr_read(adapter, OTP_STATUS);
84 } while (reg_val & OTP_STATUS_BUSY_);
85
86 return 0;
87}
88
89static int lan743x_otp_read(struct lan743x_adapter *adapter, u32 offset,
90 u32 length, u8 *data)
91{
92 int ret;
93 int i;
94
95 if (offset + length > MAX_OTP_SIZE)
96 return -EINVAL;
97
98 ret = lan743x_otp_power_up(adapter);
99 if (ret < 0)
100 return ret;
101
102 ret = lan743x_otp_wait_till_not_busy(adapter);
103 if (ret < 0)
104 return ret;
105
106 for (i = 0; i < length; i++) {
107 lan743x_otp_set_address(adapter, offset + i);
108
109 lan743x_otp_read_go(adapter);
110 ret = lan743x_otp_wait_till_not_busy(adapter);
111 if (ret < 0)
112 return ret;
113 data[i] = lan743x_csr_read(adapter, OTP_READ_DATA);
114 }
115
116 lan743x_otp_power_down(adapter);
117
118 return 0;
119}
120
121static int lan743x_otp_write(struct lan743x_adapter *adapter, u32 offset,
122 u32 length, u8 *data)
123{
124 int ret;
125 int i;
126
127 if (offset + length > MAX_OTP_SIZE)
128 return -EINVAL;
129
130 ret = lan743x_otp_power_up(adapter);
131 if (ret < 0)
132 return ret;
133
134 ret = lan743x_otp_wait_till_not_busy(adapter);
135 if (ret < 0)
136 return ret;
137
138 /* set to BYTE program mode */
139 lan743x_csr_write(adapter, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
140
141 for (i = 0; i < length; i++) {
142 lan743x_otp_set_address(adapter, offset + i);
143
144 lan743x_csr_write(adapter, OTP_PRGM_DATA, data[i]);
145 lan743x_csr_write(adapter, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
146 lan743x_csr_write(adapter, OTP_CMD_GO, OTP_CMD_GO_GO_);
147
148 ret = lan743x_otp_wait_till_not_busy(adapter);
149 if (ret < 0)
150 return ret;
151 }
152
153 lan743x_otp_power_down(adapter);
154
155 return 0;
156}
157
158int lan743x_hs_syslock_acquire(struct lan743x_adapter *adapter,
159 u16 timeout)
160{
161 u16 timeout_cnt = 0;
162 u32 val;
163
164 do {
165 spin_lock(&adapter->eth_syslock_spinlock);
166 if (adapter->eth_syslock_acquire_cnt == 0) {
167 lan743x_csr_write(adapter, ETH_SYSTEM_SYS_LOCK_REG,
168 SYS_LOCK_REG_ENET_SS_LOCK_);
169 val = lan743x_csr_read(adapter,
170 ETH_SYSTEM_SYS_LOCK_REG);
171 if (val & SYS_LOCK_REG_ENET_SS_LOCK_) {
172 adapter->eth_syslock_acquire_cnt++;
173 WARN_ON(adapter->eth_syslock_acquire_cnt == 0);
174 spin_unlock(&adapter->eth_syslock_spinlock);
175 break;
176 }
177 } else {
178 adapter->eth_syslock_acquire_cnt++;
179 WARN_ON(adapter->eth_syslock_acquire_cnt == 0);
180 spin_unlock(&adapter->eth_syslock_spinlock);
181 break;
182 }
183
184 spin_unlock(&adapter->eth_syslock_spinlock);
185
186 if (timeout_cnt++ < timeout)
187 usleep_range(10000, 11000);
188 else
189 return -ETIMEDOUT;
190 } while (true);
191
192 return 0;
193}
194
195void lan743x_hs_syslock_release(struct lan743x_adapter *adapter)
196{
197 u32 val;
198
199 spin_lock(&adapter->eth_syslock_spinlock);
200 WARN_ON(adapter->eth_syslock_acquire_cnt == 0);
201
202 if (adapter->eth_syslock_acquire_cnt) {
203 adapter->eth_syslock_acquire_cnt--;
204 if (adapter->eth_syslock_acquire_cnt == 0) {
205 lan743x_csr_write(adapter, ETH_SYSTEM_SYS_LOCK_REG, 0);
206 val = lan743x_csr_read(adapter,
207 ETH_SYSTEM_SYS_LOCK_REG);
208 WARN_ON((val & SYS_LOCK_REG_ENET_SS_LOCK_) != 0);
209 }
210 }
211
212 spin_unlock(&adapter->eth_syslock_spinlock);
213}
214
215static void lan743x_hs_otp_power_up(struct lan743x_adapter *adapter)
216{
217 u32 reg_value;
218
219 reg_value = lan743x_csr_read(adapter, HS_OTP_PWR_DN);
220 if (reg_value & OTP_PWR_DN_PWRDN_N_) {
221 reg_value &= ~OTP_PWR_DN_PWRDN_N_;
222 lan743x_csr_write(adapter, HS_OTP_PWR_DN, reg_value);
223 /* To flush the posted write so the subsequent delay is
224 * guaranteed to happen after the write at the hardware
225 */
226 lan743x_csr_read(adapter, HS_OTP_PWR_DN);
227 udelay(1);
228 }
229}
230
231static void lan743x_hs_otp_power_down(struct lan743x_adapter *adapter)
232{
233 u32 reg_value;
234
235 reg_value = lan743x_csr_read(adapter, HS_OTP_PWR_DN);
236 if (!(reg_value & OTP_PWR_DN_PWRDN_N_)) {
237 reg_value |= OTP_PWR_DN_PWRDN_N_;
238 lan743x_csr_write(adapter, HS_OTP_PWR_DN, reg_value);
239 /* To flush the posted write so the subsequent delay is
240 * guaranteed to happen after the write at the hardware
241 */
242 lan743x_csr_read(adapter, HS_OTP_PWR_DN);
243 udelay(1);
244 }
245}
246
247static void lan743x_hs_otp_set_address(struct lan743x_adapter *adapter,
248 u32 address)
249{
250 lan743x_csr_write(adapter, HS_OTP_ADDR_HIGH, (address >> 8) & 0x03);
251 lan743x_csr_write(adapter, HS_OTP_ADDR_LOW, address & 0xFF);
252}
253
254static void lan743x_hs_otp_read_go(struct lan743x_adapter *adapter)
255{
256 lan743x_csr_write(adapter, HS_OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
257 lan743x_csr_write(adapter, HS_OTP_CMD_GO, OTP_CMD_GO_GO_);
258}
259
260static int lan743x_hs_otp_cmd_cmplt_chk(struct lan743x_adapter *adapter)
261{
262 u32 val;
263
264 return readx_poll_timeout(LAN743X_CSR_READ_OP, HS_OTP_STATUS, val,
265 !(val & OTP_STATUS_BUSY_),
266 80, 10000);
267}
268
269static int lan743x_hs_otp_read(struct lan743x_adapter *adapter, u32 offset,
270 u32 length, u8 *data)
271{
272 int ret;
273 int i;
274
275 ret = lan743x_hs_syslock_acquire(adapter, LOCK_TIMEOUT_MAX_CNT);
276 if (ret < 0)
277 return ret;
278
279 lan743x_hs_otp_power_up(adapter);
280
281 ret = lan743x_hs_otp_cmd_cmplt_chk(adapter);
282 if (ret < 0)
283 goto power_down;
284
285 lan743x_hs_syslock_release(adapter);
286
287 for (i = 0; i < length; i++) {
288 ret = lan743x_hs_syslock_acquire(adapter,
289 LOCK_TIMEOUT_MAX_CNT);
290 if (ret < 0)
291 return ret;
292
293 lan743x_hs_otp_set_address(adapter, offset + i);
294
295 lan743x_hs_otp_read_go(adapter);
296 ret = lan743x_hs_otp_cmd_cmplt_chk(adapter);
297 if (ret < 0)
298 goto power_down;
299
300 data[i] = lan743x_csr_read(adapter, HS_OTP_READ_DATA);
301
302 lan743x_hs_syslock_release(adapter);
303 }
304
305 ret = lan743x_hs_syslock_acquire(adapter,
306 LOCK_TIMEOUT_MAX_CNT);
307 if (ret < 0)
308 return ret;
309
310power_down:
311 lan743x_hs_otp_power_down(adapter);
312 lan743x_hs_syslock_release(adapter);
313
314 return ret;
315}
316
317static int lan743x_hs_otp_write(struct lan743x_adapter *adapter, u32 offset,
318 u32 length, u8 *data)
319{
320 int ret;
321 int i;
322
323 ret = lan743x_hs_syslock_acquire(adapter, LOCK_TIMEOUT_MAX_CNT);
324 if (ret < 0)
325 return ret;
326
327 lan743x_hs_otp_power_up(adapter);
328
329 ret = lan743x_hs_otp_cmd_cmplt_chk(adapter);
330 if (ret < 0)
331 goto power_down;
332
333 /* set to BYTE program mode */
334 lan743x_csr_write(adapter, HS_OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
335
336 lan743x_hs_syslock_release(adapter);
337
338 for (i = 0; i < length; i++) {
339 ret = lan743x_hs_syslock_acquire(adapter,
340 LOCK_TIMEOUT_MAX_CNT);
341 if (ret < 0)
342 return ret;
343
344 lan743x_hs_otp_set_address(adapter, offset + i);
345
346 lan743x_csr_write(adapter, HS_OTP_PRGM_DATA, data[i]);
347 lan743x_csr_write(adapter, HS_OTP_TST_CMD,
348 OTP_TST_CMD_PRGVRFY_);
349 lan743x_csr_write(adapter, HS_OTP_CMD_GO, OTP_CMD_GO_GO_);
350
351 ret = lan743x_hs_otp_cmd_cmplt_chk(adapter);
352 if (ret < 0)
353 goto power_down;
354
355 lan743x_hs_syslock_release(adapter);
356 }
357
358 ret = lan743x_hs_syslock_acquire(adapter, LOCK_TIMEOUT_MAX_CNT);
359 if (ret < 0)
360 return ret;
361
362power_down:
363 lan743x_hs_otp_power_down(adapter);
364 lan743x_hs_syslock_release(adapter);
365
366 return ret;
367}
368
369static int lan743x_eeprom_wait(struct lan743x_adapter *adapter)
370{
371 unsigned long start_time = jiffies;
372 u32 val;
373
374 do {
375 val = lan743x_csr_read(adapter, E2P_CMD);
376
377 if (!(val & E2P_CMD_EPC_BUSY_) ||
378 (val & E2P_CMD_EPC_TIMEOUT_))
379 break;
380 usleep_range(40, 100);
381 } while (!time_after(jiffies, start_time + HZ));
382
383 if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
384 netif_warn(adapter, drv, adapter->netdev,
385 "EEPROM read operation timeout\n");
386 return -EIO;
387 }
388
389 return 0;
390}
391
392static int lan743x_eeprom_confirm_not_busy(struct lan743x_adapter *adapter)
393{
394 unsigned long start_time = jiffies;
395 u32 val;
396
397 do {
398 val = lan743x_csr_read(adapter, E2P_CMD);
399
400 if (!(val & E2P_CMD_EPC_BUSY_))
401 return 0;
402
403 usleep_range(40, 100);
404 } while (!time_after(jiffies, start_time + HZ));
405
406 netif_warn(adapter, drv, adapter->netdev, "EEPROM is busy\n");
407 return -EIO;
408}
409
410static int lan743x_eeprom_read(struct lan743x_adapter *adapter,
411 u32 offset, u32 length, u8 *data)
412{
413 int retval;
414 u32 val;
415 int i;
416
417 if (offset + length > MAX_EEPROM_SIZE)
418 return -EINVAL;
419
420 retval = lan743x_eeprom_confirm_not_busy(adapter);
421 if (retval)
422 return retval;
423
424 for (i = 0; i < length; i++) {
425 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
426 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
427 lan743x_csr_write(adapter, E2P_CMD, val);
428
429 retval = lan743x_eeprom_wait(adapter);
430 if (retval < 0)
431 return retval;
432
433 val = lan743x_csr_read(adapter, E2P_DATA);
434 data[i] = val & 0xFF;
435 offset++;
436 }
437
438 return 0;
439}
440
441static int lan743x_eeprom_write(struct lan743x_adapter *adapter,
442 u32 offset, u32 length, u8 *data)
443{
444 int retval;
445 u32 val;
446 int i;
447
448 if (offset + length > MAX_EEPROM_SIZE)
449 return -EINVAL;
450
451 retval = lan743x_eeprom_confirm_not_busy(adapter);
452 if (retval)
453 return retval;
454
455 /* Issue write/erase enable command */
456 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
457 lan743x_csr_write(adapter, E2P_CMD, val);
458
459 retval = lan743x_eeprom_wait(adapter);
460 if (retval < 0)
461 return retval;
462
463 for (i = 0; i < length; i++) {
464 /* Fill data register */
465 val = data[i];
466 lan743x_csr_write(adapter, E2P_DATA, val);
467
468 /* Send "write" command */
469 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
470 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
471 lan743x_csr_write(adapter, E2P_CMD, val);
472
473 retval = lan743x_eeprom_wait(adapter);
474 if (retval < 0)
475 return retval;
476
477 offset++;
478 }
479
480 return 0;
481}
482
483static int lan743x_hs_eeprom_cmd_cmplt_chk(struct lan743x_adapter *adapter)
484{
485 u32 val;
486
487 return readx_poll_timeout(LAN743X_CSR_READ_OP, HS_E2P_CMD, val,
488 (!(val & HS_E2P_CMD_EPC_BUSY_) ||
489 (val & HS_E2P_CMD_EPC_TIMEOUT_)),
490 50, 10000);
491}
492
493static int lan743x_hs_eeprom_read(struct lan743x_adapter *adapter,
494 u32 offset, u32 length, u8 *data)
495{
496 int retval;
497 u32 val;
498 int i;
499
500 retval = lan743x_hs_syslock_acquire(adapter, LOCK_TIMEOUT_MAX_CNT);
501 if (retval < 0)
502 return retval;
503
504 retval = lan743x_hs_eeprom_cmd_cmplt_chk(adapter);
505 lan743x_hs_syslock_release(adapter);
506 if (retval < 0)
507 return retval;
508
509 for (i = 0; i < length; i++) {
510 retval = lan743x_hs_syslock_acquire(adapter,
511 LOCK_TIMEOUT_MAX_CNT);
512 if (retval < 0)
513 return retval;
514
515 val = HS_E2P_CMD_EPC_BUSY_ | HS_E2P_CMD_EPC_CMD_READ_;
516 val |= (offset & HS_E2P_CMD_EPC_ADDR_MASK_);
517 lan743x_csr_write(adapter, HS_E2P_CMD, val);
518 retval = lan743x_hs_eeprom_cmd_cmplt_chk(adapter);
519 if (retval < 0) {
520 lan743x_hs_syslock_release(adapter);
521 return retval;
522 }
523
524 val = lan743x_csr_read(adapter, HS_E2P_DATA);
525
526 lan743x_hs_syslock_release(adapter);
527
528 data[i] = val & 0xFF;
529 offset++;
530 }
531
532 return 0;
533}
534
535static int lan743x_hs_eeprom_write(struct lan743x_adapter *adapter,
536 u32 offset, u32 length, u8 *data)
537{
538 int retval;
539 u32 val;
540 int i;
541
542 retval = lan743x_hs_syslock_acquire(adapter, LOCK_TIMEOUT_MAX_CNT);
543 if (retval < 0)
544 return retval;
545
546 retval = lan743x_hs_eeprom_cmd_cmplt_chk(adapter);
547 lan743x_hs_syslock_release(adapter);
548 if (retval < 0)
549 return retval;
550
551 for (i = 0; i < length; i++) {
552 retval = lan743x_hs_syslock_acquire(adapter,
553 LOCK_TIMEOUT_MAX_CNT);
554 if (retval < 0)
555 return retval;
556
557 /* Fill data register */
558 val = data[i];
559 lan743x_csr_write(adapter, HS_E2P_DATA, val);
560
561 /* Send "write" command */
562 val = HS_E2P_CMD_EPC_BUSY_ | HS_E2P_CMD_EPC_CMD_WRITE_;
563 val |= (offset & HS_E2P_CMD_EPC_ADDR_MASK_);
564 lan743x_csr_write(adapter, HS_E2P_CMD, val);
565
566 retval = lan743x_hs_eeprom_cmd_cmplt_chk(adapter);
567 lan743x_hs_syslock_release(adapter);
568 if (retval < 0)
569 return retval;
570
571 offset++;
572 }
573
574 return 0;
575}
576
577static void lan743x_ethtool_get_drvinfo(struct net_device *netdev,
578 struct ethtool_drvinfo *info)
579{
580 struct lan743x_adapter *adapter = netdev_priv(netdev);
581
582 strscpy(info->driver, DRIVER_NAME, sizeof(info->driver));
583 strscpy(info->bus_info,
584 pci_name(adapter->pdev), sizeof(info->bus_info));
585}
586
587static u32 lan743x_ethtool_get_msglevel(struct net_device *netdev)
588{
589 struct lan743x_adapter *adapter = netdev_priv(netdev);
590
591 return adapter->msg_enable;
592}
593
594static void lan743x_ethtool_set_msglevel(struct net_device *netdev,
595 u32 msglevel)
596{
597 struct lan743x_adapter *adapter = netdev_priv(netdev);
598
599 adapter->msg_enable = msglevel;
600}
601
602static int lan743x_ethtool_get_eeprom_len(struct net_device *netdev)
603{
604 struct lan743x_adapter *adapter = netdev_priv(netdev);
605
606 if (adapter->flags & LAN743X_ADAPTER_FLAG_OTP)
607 return MAX_OTP_SIZE;
608
609 return MAX_EEPROM_SIZE;
610}
611
612static int lan743x_ethtool_get_eeprom(struct net_device *netdev,
613 struct ethtool_eeprom *ee, u8 *data)
614{
615 struct lan743x_adapter *adapter = netdev_priv(netdev);
616 int ret = 0;
617
618 if (adapter->flags & LAN743X_ADAPTER_FLAG_OTP) {
619 if (adapter->is_pci11x1x)
620 ret = lan743x_hs_otp_read(adapter, ee->offset,
621 ee->len, data);
622 else
623 ret = lan743x_otp_read(adapter, ee->offset,
624 ee->len, data);
625 } else {
626 if (adapter->is_pci11x1x)
627 ret = lan743x_hs_eeprom_read(adapter, ee->offset,
628 ee->len, data);
629 else
630 ret = lan743x_eeprom_read(adapter, ee->offset,
631 ee->len, data);
632 }
633
634 return ret;
635}
636
637static int lan743x_ethtool_set_eeprom(struct net_device *netdev,
638 struct ethtool_eeprom *ee, u8 *data)
639{
640 struct lan743x_adapter *adapter = netdev_priv(netdev);
641 int ret = -EINVAL;
642
643 if (adapter->flags & LAN743X_ADAPTER_FLAG_OTP) {
644 /* Beware! OTP is One Time Programming ONLY! */
645 if (ee->magic == LAN743X_OTP_MAGIC) {
646 if (adapter->is_pci11x1x)
647 ret = lan743x_hs_otp_write(adapter, ee->offset,
648 ee->len, data);
649 else
650 ret = lan743x_otp_write(adapter, ee->offset,
651 ee->len, data);
652 }
653 } else {
654 if (ee->magic == LAN743X_EEPROM_MAGIC) {
655 if (adapter->is_pci11x1x)
656 ret = lan743x_hs_eeprom_write(adapter,
657 ee->offset,
658 ee->len, data);
659 else
660 ret = lan743x_eeprom_write(adapter, ee->offset,
661 ee->len, data);
662 }
663 }
664
665 return ret;
666}
667
668static const char lan743x_set0_hw_cnt_strings[][ETH_GSTRING_LEN] = {
669 "RX FCS Errors",
670 "RX Alignment Errors",
671 "Rx Fragment Errors",
672 "RX Jabber Errors",
673 "RX Undersize Frame Errors",
674 "RX Oversize Frame Errors",
675 "RX Dropped Frames",
676 "RX Unicast Byte Count",
677 "RX Broadcast Byte Count",
678 "RX Multicast Byte Count",
679 "RX Unicast Frames",
680 "RX Broadcast Frames",
681 "RX Multicast Frames",
682 "RX Pause Frames",
683 "RX 64 Byte Frames",
684 "RX 65 - 127 Byte Frames",
685 "RX 128 - 255 Byte Frames",
686 "RX 256 - 511 Bytes Frames",
687 "RX 512 - 1023 Byte Frames",
688 "RX 1024 - 1518 Byte Frames",
689 "RX Greater 1518 Byte Frames",
690};
691
692static const char lan743x_set1_sw_cnt_strings[][ETH_GSTRING_LEN] = {
693 "RX Queue 0 Frames",
694 "RX Queue 1 Frames",
695 "RX Queue 2 Frames",
696 "RX Queue 3 Frames",
697};
698
699static const char lan743x_tx_queue_cnt_strings[][ETH_GSTRING_LEN] = {
700 "TX Queue 0 Frames",
701 "TX Queue 1 Frames",
702 "TX Queue 2 Frames",
703 "TX Queue 3 Frames",
704 "TX Total Queue Frames",
705};
706
707static const char lan743x_set2_hw_cnt_strings[][ETH_GSTRING_LEN] = {
708 "RX Total Frames",
709 "EEE RX LPI Transitions",
710 "EEE RX LPI Time",
711 "RX Counter Rollover Status",
712 "TX FCS Errors",
713 "TX Excess Deferral Errors",
714 "TX Carrier Errors",
715 "TX Bad Byte Count",
716 "TX Single Collisions",
717 "TX Multiple Collisions",
718 "TX Excessive Collision",
719 "TX Late Collisions",
720 "TX Unicast Byte Count",
721 "TX Broadcast Byte Count",
722 "TX Multicast Byte Count",
723 "TX Unicast Frames",
724 "TX Broadcast Frames",
725 "TX Multicast Frames",
726 "TX Pause Frames",
727 "TX 64 Byte Frames",
728 "TX 65 - 127 Byte Frames",
729 "TX 128 - 255 Byte Frames",
730 "TX 256 - 511 Bytes Frames",
731 "TX 512 - 1023 Byte Frames",
732 "TX 1024 - 1518 Byte Frames",
733 "TX Greater 1518 Byte Frames",
734 "TX Total Frames",
735 "EEE TX LPI Transitions",
736 "EEE TX LPI Time",
737 "TX Counter Rollover Status",
738};
739
740static const u32 lan743x_set0_hw_cnt_addr[] = {
741 STAT_RX_FCS_ERRORS,
742 STAT_RX_ALIGNMENT_ERRORS,
743 STAT_RX_FRAGMENT_ERRORS,
744 STAT_RX_JABBER_ERRORS,
745 STAT_RX_UNDERSIZE_FRAME_ERRORS,
746 STAT_RX_OVERSIZE_FRAME_ERRORS,
747 STAT_RX_DROPPED_FRAMES,
748 STAT_RX_UNICAST_BYTE_COUNT,
749 STAT_RX_BROADCAST_BYTE_COUNT,
750 STAT_RX_MULTICAST_BYTE_COUNT,
751 STAT_RX_UNICAST_FRAMES,
752 STAT_RX_BROADCAST_FRAMES,
753 STAT_RX_MULTICAST_FRAMES,
754 STAT_RX_PAUSE_FRAMES,
755 STAT_RX_64_BYTE_FRAMES,
756 STAT_RX_65_127_BYTE_FRAMES,
757 STAT_RX_128_255_BYTE_FRAMES,
758 STAT_RX_256_511_BYTES_FRAMES,
759 STAT_RX_512_1023_BYTE_FRAMES,
760 STAT_RX_1024_1518_BYTE_FRAMES,
761 STAT_RX_GREATER_1518_BYTE_FRAMES,
762};
763
764static const u32 lan743x_set2_hw_cnt_addr[] = {
765 STAT_RX_TOTAL_FRAMES,
766 STAT_EEE_RX_LPI_TRANSITIONS,
767 STAT_EEE_RX_LPI_TIME,
768 STAT_RX_COUNTER_ROLLOVER_STATUS,
769 STAT_TX_FCS_ERRORS,
770 STAT_TX_EXCESS_DEFERRAL_ERRORS,
771 STAT_TX_CARRIER_ERRORS,
772 STAT_TX_BAD_BYTE_COUNT,
773 STAT_TX_SINGLE_COLLISIONS,
774 STAT_TX_MULTIPLE_COLLISIONS,
775 STAT_TX_EXCESSIVE_COLLISION,
776 STAT_TX_LATE_COLLISIONS,
777 STAT_TX_UNICAST_BYTE_COUNT,
778 STAT_TX_BROADCAST_BYTE_COUNT,
779 STAT_TX_MULTICAST_BYTE_COUNT,
780 STAT_TX_UNICAST_FRAMES,
781 STAT_TX_BROADCAST_FRAMES,
782 STAT_TX_MULTICAST_FRAMES,
783 STAT_TX_PAUSE_FRAMES,
784 STAT_TX_64_BYTE_FRAMES,
785 STAT_TX_65_127_BYTE_FRAMES,
786 STAT_TX_128_255_BYTE_FRAMES,
787 STAT_TX_256_511_BYTES_FRAMES,
788 STAT_TX_512_1023_BYTE_FRAMES,
789 STAT_TX_1024_1518_BYTE_FRAMES,
790 STAT_TX_GREATER_1518_BYTE_FRAMES,
791 STAT_TX_TOTAL_FRAMES,
792 STAT_EEE_TX_LPI_TRANSITIONS,
793 STAT_EEE_TX_LPI_TIME,
794 STAT_TX_COUNTER_ROLLOVER_STATUS
795};
796
797static const char lan743x_priv_flags_strings[][ETH_GSTRING_LEN] = {
798 "OTP_ACCESS",
799};
800
801static void lan743x_ethtool_get_strings(struct net_device *netdev,
802 u32 stringset, u8 *data)
803{
804 struct lan743x_adapter *adapter = netdev_priv(netdev);
805
806 switch (stringset) {
807 case ETH_SS_STATS:
808 memcpy(data, lan743x_set0_hw_cnt_strings,
809 sizeof(lan743x_set0_hw_cnt_strings));
810 memcpy(&data[sizeof(lan743x_set0_hw_cnt_strings)],
811 lan743x_set1_sw_cnt_strings,
812 sizeof(lan743x_set1_sw_cnt_strings));
813 memcpy(&data[sizeof(lan743x_set0_hw_cnt_strings) +
814 sizeof(lan743x_set1_sw_cnt_strings)],
815 lan743x_set2_hw_cnt_strings,
816 sizeof(lan743x_set2_hw_cnt_strings));
817 if (adapter->is_pci11x1x) {
818 memcpy(&data[sizeof(lan743x_set0_hw_cnt_strings) +
819 sizeof(lan743x_set1_sw_cnt_strings) +
820 sizeof(lan743x_set2_hw_cnt_strings)],
821 lan743x_tx_queue_cnt_strings,
822 sizeof(lan743x_tx_queue_cnt_strings));
823 }
824 break;
825 case ETH_SS_PRIV_FLAGS:
826 memcpy(data, lan743x_priv_flags_strings,
827 sizeof(lan743x_priv_flags_strings));
828 break;
829 }
830}
831
832static void lan743x_ethtool_get_ethtool_stats(struct net_device *netdev,
833 struct ethtool_stats *stats,
834 u64 *data)
835{
836 struct lan743x_adapter *adapter = netdev_priv(netdev);
837 u64 total_queue_count = 0;
838 int data_index = 0;
839 u64 pkt_cnt;
840 u32 buf;
841 int i;
842
843 for (i = 0; i < ARRAY_SIZE(lan743x_set0_hw_cnt_addr); i++) {
844 buf = lan743x_csr_read(adapter, lan743x_set0_hw_cnt_addr[i]);
845 data[data_index++] = (u64)buf;
846 }
847 for (i = 0; i < ARRAY_SIZE(adapter->rx); i++)
848 data[data_index++] = (u64)(adapter->rx[i].frame_count);
849 for (i = 0; i < ARRAY_SIZE(lan743x_set2_hw_cnt_addr); i++) {
850 buf = lan743x_csr_read(adapter, lan743x_set2_hw_cnt_addr[i]);
851 data[data_index++] = (u64)buf;
852 }
853 if (adapter->is_pci11x1x) {
854 for (i = 0; i < ARRAY_SIZE(adapter->tx); i++) {
855 pkt_cnt = (u64)(adapter->tx[i].frame_count);
856 data[data_index++] = pkt_cnt;
857 total_queue_count += pkt_cnt;
858 }
859 data[data_index++] = total_queue_count;
860 }
861}
862
863static u32 lan743x_ethtool_get_priv_flags(struct net_device *netdev)
864{
865 struct lan743x_adapter *adapter = netdev_priv(netdev);
866
867 return adapter->flags;
868}
869
870static int lan743x_ethtool_set_priv_flags(struct net_device *netdev, u32 flags)
871{
872 struct lan743x_adapter *adapter = netdev_priv(netdev);
873
874 adapter->flags = flags;
875
876 return 0;
877}
878
879static int lan743x_ethtool_get_sset_count(struct net_device *netdev, int sset)
880{
881 struct lan743x_adapter *adapter = netdev_priv(netdev);
882
883 switch (sset) {
884 case ETH_SS_STATS:
885 {
886 int ret;
887
888 ret = ARRAY_SIZE(lan743x_set0_hw_cnt_strings);
889 ret += ARRAY_SIZE(lan743x_set1_sw_cnt_strings);
890 ret += ARRAY_SIZE(lan743x_set2_hw_cnt_strings);
891 if (adapter->is_pci11x1x)
892 ret += ARRAY_SIZE(lan743x_tx_queue_cnt_strings);
893 return ret;
894 }
895 case ETH_SS_PRIV_FLAGS:
896 return ARRAY_SIZE(lan743x_priv_flags_strings);
897 default:
898 return -EOPNOTSUPP;
899 }
900}
901
902static int lan743x_ethtool_get_rxnfc(struct net_device *netdev,
903 struct ethtool_rxnfc *rxnfc,
904 u32 *rule_locs)
905{
906 switch (rxnfc->cmd) {
907 case ETHTOOL_GRXFH:
908 rxnfc->data = 0;
909 switch (rxnfc->flow_type) {
910 case TCP_V4_FLOW:case UDP_V4_FLOW:
911 case TCP_V6_FLOW:case UDP_V6_FLOW:
912 rxnfc->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
913 fallthrough;
914 case IPV4_FLOW: case IPV6_FLOW:
915 rxnfc->data |= RXH_IP_SRC | RXH_IP_DST;
916 return 0;
917 }
918 break;
919 case ETHTOOL_GRXRINGS:
920 rxnfc->data = LAN743X_USED_RX_CHANNELS;
921 return 0;
922 }
923 return -EOPNOTSUPP;
924}
925
926static u32 lan743x_ethtool_get_rxfh_key_size(struct net_device *netdev)
927{
928 return 40;
929}
930
931static u32 lan743x_ethtool_get_rxfh_indir_size(struct net_device *netdev)
932{
933 return 128;
934}
935
936static int lan743x_ethtool_get_rxfh(struct net_device *netdev,
937 struct ethtool_rxfh_param *rxfh)
938{
939 struct lan743x_adapter *adapter = netdev_priv(netdev);
940
941 if (rxfh->indir) {
942 int dw_index;
943 int byte_index = 0;
944
945 for (dw_index = 0; dw_index < 32; dw_index++) {
946 u32 four_entries =
947 lan743x_csr_read(adapter, RFE_INDX(dw_index));
948
949 byte_index = dw_index << 2;
950 rxfh->indir[byte_index + 0] =
951 ((four_entries >> 0) & 0x000000FF);
952 rxfh->indir[byte_index + 1] =
953 ((four_entries >> 8) & 0x000000FF);
954 rxfh->indir[byte_index + 2] =
955 ((four_entries >> 16) & 0x000000FF);
956 rxfh->indir[byte_index + 3] =
957 ((four_entries >> 24) & 0x000000FF);
958 }
959 }
960 if (rxfh->key) {
961 int dword_index;
962 int byte_index = 0;
963
964 for (dword_index = 0; dword_index < 10; dword_index++) {
965 u32 four_entries =
966 lan743x_csr_read(adapter,
967 RFE_HASH_KEY(dword_index));
968
969 byte_index = dword_index << 2;
970 rxfh->key[byte_index + 0] =
971 ((four_entries >> 0) & 0x000000FF);
972 rxfh->key[byte_index + 1] =
973 ((four_entries >> 8) & 0x000000FF);
974 rxfh->key[byte_index + 2] =
975 ((four_entries >> 16) & 0x000000FF);
976 rxfh->key[byte_index + 3] =
977 ((four_entries >> 24) & 0x000000FF);
978 }
979 }
980 rxfh->hfunc = ETH_RSS_HASH_TOP;
981 return 0;
982}
983
984static int lan743x_ethtool_set_rxfh(struct net_device *netdev,
985 struct ethtool_rxfh_param *rxfh,
986 struct netlink_ext_ack *extack)
987{
988 struct lan743x_adapter *adapter = netdev_priv(netdev);
989 u32 *indir = rxfh->indir;
990 u8 *key = rxfh->key;
991
992 if (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE &&
993 rxfh->hfunc != ETH_RSS_HASH_TOP)
994 return -EOPNOTSUPP;
995
996 if (indir) {
997 u32 indir_value = 0;
998 int dword_index = 0;
999 int byte_index = 0;
1000
1001 for (dword_index = 0; dword_index < 32; dword_index++) {
1002 byte_index = dword_index << 2;
1003 indir_value =
1004 (((indir[byte_index + 0] & 0x000000FF) << 0) |
1005 ((indir[byte_index + 1] & 0x000000FF) << 8) |
1006 ((indir[byte_index + 2] & 0x000000FF) << 16) |
1007 ((indir[byte_index + 3] & 0x000000FF) << 24));
1008 lan743x_csr_write(adapter, RFE_INDX(dword_index),
1009 indir_value);
1010 }
1011 }
1012 if (key) {
1013 int dword_index = 0;
1014 int byte_index = 0;
1015 u32 key_value = 0;
1016
1017 for (dword_index = 0; dword_index < 10; dword_index++) {
1018 byte_index = dword_index << 2;
1019 key_value =
1020 ((((u32)(key[byte_index + 0])) << 0) |
1021 (((u32)(key[byte_index + 1])) << 8) |
1022 (((u32)(key[byte_index + 2])) << 16) |
1023 (((u32)(key[byte_index + 3])) << 24));
1024 lan743x_csr_write(adapter, RFE_HASH_KEY(dword_index),
1025 key_value);
1026 }
1027 }
1028 return 0;
1029}
1030
1031static int lan743x_ethtool_get_ts_info(struct net_device *netdev,
1032 struct ethtool_ts_info *ts_info)
1033{
1034 struct lan743x_adapter *adapter = netdev_priv(netdev);
1035
1036 ts_info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
1037 SOF_TIMESTAMPING_RX_SOFTWARE |
1038 SOF_TIMESTAMPING_SOFTWARE |
1039 SOF_TIMESTAMPING_TX_HARDWARE |
1040 SOF_TIMESTAMPING_RX_HARDWARE |
1041 SOF_TIMESTAMPING_RAW_HARDWARE;
1042
1043 if (adapter->ptp.ptp_clock)
1044 ts_info->phc_index = ptp_clock_index(adapter->ptp.ptp_clock);
1045 else
1046 ts_info->phc_index = -1;
1047
1048 ts_info->tx_types = BIT(HWTSTAMP_TX_OFF) |
1049 BIT(HWTSTAMP_TX_ON) |
1050 BIT(HWTSTAMP_TX_ONESTEP_SYNC);
1051 ts_info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) |
1052 BIT(HWTSTAMP_FILTER_ALL) |
1053 BIT(HWTSTAMP_FILTER_PTP_V2_EVENT);
1054 return 0;
1055}
1056
1057static int lan743x_ethtool_get_eee(struct net_device *netdev,
1058 struct ethtool_eee *eee)
1059{
1060 struct lan743x_adapter *adapter = netdev_priv(netdev);
1061 struct phy_device *phydev = netdev->phydev;
1062 u32 buf;
1063 int ret;
1064
1065 if (!phydev)
1066 return -EIO;
1067 if (!phydev->drv) {
1068 netif_err(adapter, drv, adapter->netdev,
1069 "Missing PHY Driver\n");
1070 return -EIO;
1071 }
1072
1073 ret = phy_ethtool_get_eee(phydev, eee);
1074 if (ret < 0)
1075 return ret;
1076
1077 buf = lan743x_csr_read(adapter, MAC_CR);
1078 if (buf & MAC_CR_EEE_EN_) {
1079 eee->eee_enabled = true;
1080 eee->tx_lpi_enabled = true;
1081 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1082 buf = lan743x_csr_read(adapter, MAC_EEE_TX_LPI_REQ_DLY_CNT);
1083 eee->tx_lpi_timer = buf;
1084 } else {
1085 eee->eee_enabled = false;
1086 eee->eee_active = false;
1087 eee->tx_lpi_enabled = false;
1088 eee->tx_lpi_timer = 0;
1089 }
1090
1091 return 0;
1092}
1093
1094static int lan743x_ethtool_set_eee(struct net_device *netdev,
1095 struct ethtool_eee *eee)
1096{
1097 struct lan743x_adapter *adapter;
1098 struct phy_device *phydev;
1099 u32 buf = 0;
1100 int ret = 0;
1101
1102 if (!netdev)
1103 return -EINVAL;
1104 adapter = netdev_priv(netdev);
1105 if (!adapter)
1106 return -EINVAL;
1107 phydev = netdev->phydev;
1108 if (!phydev)
1109 return -EIO;
1110 if (!phydev->drv) {
1111 netif_err(adapter, drv, adapter->netdev,
1112 "Missing PHY Driver\n");
1113 return -EIO;
1114 }
1115
1116 if (eee->eee_enabled) {
1117 ret = phy_init_eee(phydev, false);
1118 if (ret) {
1119 netif_err(adapter, drv, adapter->netdev,
1120 "EEE initialization failed\n");
1121 return ret;
1122 }
1123
1124 buf = (u32)eee->tx_lpi_timer;
1125 lan743x_csr_write(adapter, MAC_EEE_TX_LPI_REQ_DLY_CNT, buf);
1126
1127 buf = lan743x_csr_read(adapter, MAC_CR);
1128 buf |= MAC_CR_EEE_EN_;
1129 lan743x_csr_write(adapter, MAC_CR, buf);
1130 } else {
1131 buf = lan743x_csr_read(adapter, MAC_CR);
1132 buf &= ~MAC_CR_EEE_EN_;
1133 lan743x_csr_write(adapter, MAC_CR, buf);
1134 }
1135
1136 return phy_ethtool_set_eee(phydev, eee);
1137}
1138
1139#ifdef CONFIG_PM
1140static void lan743x_ethtool_get_wol(struct net_device *netdev,
1141 struct ethtool_wolinfo *wol)
1142{
1143 struct lan743x_adapter *adapter = netdev_priv(netdev);
1144
1145 wol->supported = 0;
1146 wol->wolopts = 0;
1147
1148 if (netdev->phydev)
1149 phy_ethtool_get_wol(netdev->phydev, wol);
1150
1151 wol->supported |= WAKE_BCAST | WAKE_UCAST | WAKE_MCAST |
1152 WAKE_MAGIC | WAKE_PHY | WAKE_ARP;
1153
1154 if (adapter->is_pci11x1x)
1155 wol->supported |= WAKE_MAGICSECURE;
1156
1157 wol->wolopts |= adapter->wolopts;
1158 if (adapter->wolopts & WAKE_MAGICSECURE)
1159 memcpy(wol->sopass, adapter->sopass, sizeof(wol->sopass));
1160}
1161
1162static int lan743x_ethtool_set_wol(struct net_device *netdev,
1163 struct ethtool_wolinfo *wol)
1164{
1165 struct lan743x_adapter *adapter = netdev_priv(netdev);
1166
1167 adapter->wolopts = 0;
1168 if (wol->wolopts & WAKE_UCAST)
1169 adapter->wolopts |= WAKE_UCAST;
1170 if (wol->wolopts & WAKE_MCAST)
1171 adapter->wolopts |= WAKE_MCAST;
1172 if (wol->wolopts & WAKE_BCAST)
1173 adapter->wolopts |= WAKE_BCAST;
1174 if (wol->wolopts & WAKE_MAGIC)
1175 adapter->wolopts |= WAKE_MAGIC;
1176 if (wol->wolopts & WAKE_PHY)
1177 adapter->wolopts |= WAKE_PHY;
1178 if (wol->wolopts & WAKE_ARP)
1179 adapter->wolopts |= WAKE_ARP;
1180 if (wol->wolopts & WAKE_MAGICSECURE &&
1181 wol->wolopts & WAKE_MAGIC) {
1182 memcpy(adapter->sopass, wol->sopass, sizeof(wol->sopass));
1183 adapter->wolopts |= WAKE_MAGICSECURE;
1184 } else {
1185 memset(adapter->sopass, 0, sizeof(u8) * SOPASS_MAX);
1186 }
1187
1188 device_set_wakeup_enable(&adapter->pdev->dev, (bool)wol->wolopts);
1189
1190 return netdev->phydev ? phy_ethtool_set_wol(netdev->phydev, wol)
1191 : -ENETDOWN;
1192}
1193#endif /* CONFIG_PM */
1194
1195static void lan743x_common_regs(struct net_device *dev, void *p)
1196{
1197 struct lan743x_adapter *adapter = netdev_priv(dev);
1198 u32 *rb = p;
1199
1200 memset(p, 0, (MAX_LAN743X_ETH_COMMON_REGS * sizeof(u32)));
1201
1202 rb[ETH_PRIV_FLAGS] = adapter->flags;
1203 rb[ETH_ID_REV] = lan743x_csr_read(adapter, ID_REV);
1204 rb[ETH_FPGA_REV] = lan743x_csr_read(adapter, FPGA_REV);
1205 rb[ETH_STRAP_READ] = lan743x_csr_read(adapter, STRAP_READ);
1206 rb[ETH_INT_STS] = lan743x_csr_read(adapter, INT_STS);
1207 rb[ETH_HW_CFG] = lan743x_csr_read(adapter, HW_CFG);
1208 rb[ETH_PMT_CTL] = lan743x_csr_read(adapter, PMT_CTL);
1209 rb[ETH_E2P_CMD] = lan743x_csr_read(adapter, E2P_CMD);
1210 rb[ETH_E2P_DATA] = lan743x_csr_read(adapter, E2P_DATA);
1211 rb[ETH_MAC_CR] = lan743x_csr_read(adapter, MAC_CR);
1212 rb[ETH_MAC_RX] = lan743x_csr_read(adapter, MAC_RX);
1213 rb[ETH_MAC_TX] = lan743x_csr_read(adapter, MAC_TX);
1214 rb[ETH_FLOW] = lan743x_csr_read(adapter, MAC_FLOW);
1215 rb[ETH_MII_ACC] = lan743x_csr_read(adapter, MAC_MII_ACC);
1216 rb[ETH_MII_DATA] = lan743x_csr_read(adapter, MAC_MII_DATA);
1217 rb[ETH_EEE_TX_LPI_REQ_DLY] = lan743x_csr_read(adapter,
1218 MAC_EEE_TX_LPI_REQ_DLY_CNT);
1219 rb[ETH_WUCSR] = lan743x_csr_read(adapter, MAC_WUCSR);
1220 rb[ETH_WK_SRC] = lan743x_csr_read(adapter, MAC_WK_SRC);
1221}
1222
1223static void lan743x_sgmii_regs(struct net_device *dev, void *p)
1224{
1225 struct lan743x_adapter *adp = netdev_priv(dev);
1226 u32 *rb = p;
1227 u16 idx;
1228 int val;
1229 struct {
1230 u8 id;
1231 u8 dev;
1232 u16 addr;
1233 } regs[] = {
1234 { ETH_SR_VSMMD_DEV_ID1, MDIO_MMD_VEND1, 0x0002},
1235 { ETH_SR_VSMMD_DEV_ID2, MDIO_MMD_VEND1, 0x0003},
1236 { ETH_SR_VSMMD_PCS_ID1, MDIO_MMD_VEND1, 0x0004},
1237 { ETH_SR_VSMMD_PCS_ID2, MDIO_MMD_VEND1, 0x0005},
1238 { ETH_SR_VSMMD_STS, MDIO_MMD_VEND1, 0x0008},
1239 { ETH_SR_VSMMD_CTRL, MDIO_MMD_VEND1, 0x0009},
1240 { ETH_SR_MII_CTRL, MDIO_MMD_VEND2, 0x0000},
1241 { ETH_SR_MII_STS, MDIO_MMD_VEND2, 0x0001},
1242 { ETH_SR_MII_DEV_ID1, MDIO_MMD_VEND2, 0x0002},
1243 { ETH_SR_MII_DEV_ID2, MDIO_MMD_VEND2, 0x0003},
1244 { ETH_SR_MII_AN_ADV, MDIO_MMD_VEND2, 0x0004},
1245 { ETH_SR_MII_LP_BABL, MDIO_MMD_VEND2, 0x0005},
1246 { ETH_SR_MII_EXPN, MDIO_MMD_VEND2, 0x0006},
1247 { ETH_SR_MII_EXT_STS, MDIO_MMD_VEND2, 0x000F},
1248 { ETH_SR_MII_TIME_SYNC_ABL, MDIO_MMD_VEND2, 0x0708},
1249 { ETH_SR_MII_TIME_SYNC_TX_MAX_DLY_LWR, MDIO_MMD_VEND2, 0x0709},
1250 { ETH_SR_MII_TIME_SYNC_TX_MAX_DLY_UPR, MDIO_MMD_VEND2, 0x070A},
1251 { ETH_SR_MII_TIME_SYNC_TX_MIN_DLY_LWR, MDIO_MMD_VEND2, 0x070B},
1252 { ETH_SR_MII_TIME_SYNC_TX_MIN_DLY_UPR, MDIO_MMD_VEND2, 0x070C},
1253 { ETH_SR_MII_TIME_SYNC_RX_MAX_DLY_LWR, MDIO_MMD_VEND2, 0x070D},
1254 { ETH_SR_MII_TIME_SYNC_RX_MAX_DLY_UPR, MDIO_MMD_VEND2, 0x070E},
1255 { ETH_SR_MII_TIME_SYNC_RX_MIN_DLY_LWR, MDIO_MMD_VEND2, 0x070F},
1256 { ETH_SR_MII_TIME_SYNC_RX_MIN_DLY_UPR, MDIO_MMD_VEND2, 0x0710},
1257 { ETH_VR_MII_DIG_CTRL1, MDIO_MMD_VEND2, 0x8000},
1258 { ETH_VR_MII_AN_CTRL, MDIO_MMD_VEND2, 0x8001},
1259 { ETH_VR_MII_AN_INTR_STS, MDIO_MMD_VEND2, 0x8002},
1260 { ETH_VR_MII_TC, MDIO_MMD_VEND2, 0x8003},
1261 { ETH_VR_MII_DBG_CTRL, MDIO_MMD_VEND2, 0x8005},
1262 { ETH_VR_MII_EEE_MCTRL0, MDIO_MMD_VEND2, 0x8006},
1263 { ETH_VR_MII_EEE_TXTIMER, MDIO_MMD_VEND2, 0x8008},
1264 { ETH_VR_MII_EEE_RXTIMER, MDIO_MMD_VEND2, 0x8009},
1265 { ETH_VR_MII_LINK_TIMER_CTRL, MDIO_MMD_VEND2, 0x800A},
1266 { ETH_VR_MII_EEE_MCTRL1, MDIO_MMD_VEND2, 0x800B},
1267 { ETH_VR_MII_DIG_STS, MDIO_MMD_VEND2, 0x8010},
1268 { ETH_VR_MII_ICG_ERRCNT1, MDIO_MMD_VEND2, 0x8011},
1269 { ETH_VR_MII_GPIO, MDIO_MMD_VEND2, 0x8015},
1270 { ETH_VR_MII_EEE_LPI_STATUS, MDIO_MMD_VEND2, 0x8016},
1271 { ETH_VR_MII_EEE_WKERR, MDIO_MMD_VEND2, 0x8017},
1272 { ETH_VR_MII_MISC_STS, MDIO_MMD_VEND2, 0x8018},
1273 { ETH_VR_MII_RX_LSTS, MDIO_MMD_VEND2, 0x8020},
1274 { ETH_VR_MII_GEN2_GEN4_TX_BSTCTRL0, MDIO_MMD_VEND2, 0x8038},
1275 { ETH_VR_MII_GEN2_GEN4_TX_LVLCTRL0, MDIO_MMD_VEND2, 0x803A},
1276 { ETH_VR_MII_GEN2_GEN4_TXGENCTRL0, MDIO_MMD_VEND2, 0x803C},
1277 { ETH_VR_MII_GEN2_GEN4_TXGENCTRL1, MDIO_MMD_VEND2, 0x803D},
1278 { ETH_VR_MII_GEN4_TXGENCTRL2, MDIO_MMD_VEND2, 0x803E},
1279 { ETH_VR_MII_GEN2_GEN4_TX_STS, MDIO_MMD_VEND2, 0x8048},
1280 { ETH_VR_MII_GEN2_GEN4_RXGENCTRL0, MDIO_MMD_VEND2, 0x8058},
1281 { ETH_VR_MII_GEN2_GEN4_RXGENCTRL1, MDIO_MMD_VEND2, 0x8059},
1282 { ETH_VR_MII_GEN4_RXEQ_CTRL, MDIO_MMD_VEND2, 0x805B},
1283 { ETH_VR_MII_GEN4_RXLOS_CTRL0, MDIO_MMD_VEND2, 0x805D},
1284 { ETH_VR_MII_GEN2_GEN4_MPLL_CTRL0, MDIO_MMD_VEND2, 0x8078},
1285 { ETH_VR_MII_GEN2_GEN4_MPLL_CTRL1, MDIO_MMD_VEND2, 0x8079},
1286 { ETH_VR_MII_GEN2_GEN4_MPLL_STS, MDIO_MMD_VEND2, 0x8088},
1287 { ETH_VR_MII_GEN2_GEN4_LVL_CTRL, MDIO_MMD_VEND2, 0x8090},
1288 { ETH_VR_MII_GEN4_MISC_CTRL2, MDIO_MMD_VEND2, 0x8093},
1289 { ETH_VR_MII_GEN2_GEN4_MISC_CTRL0, MDIO_MMD_VEND2, 0x8099},
1290 { ETH_VR_MII_GEN2_GEN4_MISC_CTRL1, MDIO_MMD_VEND2, 0x809A},
1291 { ETH_VR_MII_SNPS_CR_CTRL, MDIO_MMD_VEND2, 0x80A0},
1292 { ETH_VR_MII_SNPS_CR_ADDR, MDIO_MMD_VEND2, 0x80A1},
1293 { ETH_VR_MII_SNPS_CR_DATA, MDIO_MMD_VEND2, 0x80A2},
1294 { ETH_VR_MII_DIG_CTRL2, MDIO_MMD_VEND2, 0x80E1},
1295 { ETH_VR_MII_DIG_ERRCNT, MDIO_MMD_VEND2, 0x80E2},
1296 };
1297
1298 for (idx = 0; idx < ARRAY_SIZE(regs); idx++) {
1299 val = lan743x_sgmii_read(adp, regs[idx].dev, regs[idx].addr);
1300 if (val < 0)
1301 rb[regs[idx].id] = 0xFFFF;
1302 else
1303 rb[regs[idx].id] = val;
1304 }
1305}
1306
1307static int lan743x_get_regs_len(struct net_device *dev)
1308{
1309 struct lan743x_adapter *adapter = netdev_priv(dev);
1310 u32 num_regs = MAX_LAN743X_ETH_COMMON_REGS;
1311
1312 if (adapter->is_sgmii_en)
1313 num_regs += MAX_LAN743X_ETH_SGMII_REGS;
1314
1315 return num_regs * sizeof(u32);
1316}
1317
1318static void lan743x_get_regs(struct net_device *dev,
1319 struct ethtool_regs *regs, void *p)
1320{
1321 struct lan743x_adapter *adapter = netdev_priv(dev);
1322 int regs_len;
1323
1324 regs_len = lan743x_get_regs_len(dev);
1325 memset(p, 0, regs_len);
1326
1327 regs->version = LAN743X_ETH_REG_VERSION;
1328 regs->len = regs_len;
1329
1330 lan743x_common_regs(dev, p);
1331 p = (u32 *)p + MAX_LAN743X_ETH_COMMON_REGS;
1332
1333 if (adapter->is_sgmii_en) {
1334 lan743x_sgmii_regs(dev, p);
1335 p = (u32 *)p + MAX_LAN743X_ETH_SGMII_REGS;
1336 }
1337}
1338
1339static void lan743x_get_pauseparam(struct net_device *dev,
1340 struct ethtool_pauseparam *pause)
1341{
1342 struct lan743x_adapter *adapter = netdev_priv(dev);
1343 struct lan743x_phy *phy = &adapter->phy;
1344
1345 if (phy->fc_request_control & FLOW_CTRL_TX)
1346 pause->tx_pause = 1;
1347 if (phy->fc_request_control & FLOW_CTRL_RX)
1348 pause->rx_pause = 1;
1349 pause->autoneg = phy->fc_autoneg;
1350}
1351
1352static int lan743x_set_pauseparam(struct net_device *dev,
1353 struct ethtool_pauseparam *pause)
1354{
1355 struct lan743x_adapter *adapter = netdev_priv(dev);
1356 struct phy_device *phydev = dev->phydev;
1357 struct lan743x_phy *phy = &adapter->phy;
1358
1359 if (!phydev)
1360 return -ENODEV;
1361
1362 if (!phy_validate_pause(phydev, pause))
1363 return -EINVAL;
1364
1365 phy->fc_request_control = 0;
1366 if (pause->rx_pause)
1367 phy->fc_request_control |= FLOW_CTRL_RX;
1368
1369 if (pause->tx_pause)
1370 phy->fc_request_control |= FLOW_CTRL_TX;
1371
1372 phy->fc_autoneg = pause->autoneg;
1373
1374 if (pause->autoneg == AUTONEG_DISABLE)
1375 lan743x_mac_flow_ctrl_set_enables(adapter, pause->tx_pause,
1376 pause->rx_pause);
1377 else
1378 phy_set_asym_pause(phydev, pause->rx_pause, pause->tx_pause);
1379
1380 return 0;
1381}
1382
1383const struct ethtool_ops lan743x_ethtool_ops = {
1384 .get_drvinfo = lan743x_ethtool_get_drvinfo,
1385 .get_msglevel = lan743x_ethtool_get_msglevel,
1386 .set_msglevel = lan743x_ethtool_set_msglevel,
1387 .get_link = ethtool_op_get_link,
1388
1389 .get_eeprom_len = lan743x_ethtool_get_eeprom_len,
1390 .get_eeprom = lan743x_ethtool_get_eeprom,
1391 .set_eeprom = lan743x_ethtool_set_eeprom,
1392 .get_strings = lan743x_ethtool_get_strings,
1393 .get_ethtool_stats = lan743x_ethtool_get_ethtool_stats,
1394 .get_priv_flags = lan743x_ethtool_get_priv_flags,
1395 .set_priv_flags = lan743x_ethtool_set_priv_flags,
1396 .get_sset_count = lan743x_ethtool_get_sset_count,
1397 .get_rxnfc = lan743x_ethtool_get_rxnfc,
1398 .get_rxfh_key_size = lan743x_ethtool_get_rxfh_key_size,
1399 .get_rxfh_indir_size = lan743x_ethtool_get_rxfh_indir_size,
1400 .get_rxfh = lan743x_ethtool_get_rxfh,
1401 .set_rxfh = lan743x_ethtool_set_rxfh,
1402 .get_ts_info = lan743x_ethtool_get_ts_info,
1403 .get_eee = lan743x_ethtool_get_eee,
1404 .set_eee = lan743x_ethtool_set_eee,
1405 .get_link_ksettings = phy_ethtool_get_link_ksettings,
1406 .set_link_ksettings = phy_ethtool_set_link_ksettings,
1407 .get_regs_len = lan743x_get_regs_len,
1408 .get_regs = lan743x_get_regs,
1409 .get_pauseparam = lan743x_get_pauseparam,
1410 .set_pauseparam = lan743x_set_pauseparam,
1411#ifdef CONFIG_PM
1412 .get_wol = lan743x_ethtool_get_wol,
1413 .set_wol = lan743x_ethtool_set_wol,
1414#endif
1415};
1/* SPDX-License-Identifier: GPL-2.0+ */
2/* Copyright (C) 2018 Microchip Technology Inc. */
3
4#include <linux/netdevice.h>
5#include <linux/net_tstamp.h>
6#include <linux/pci.h>
7#include <linux/phy.h>
8#include "lan743x_main.h"
9#include "lan743x_ethtool.h"
10
11/* eeprom */
12#define LAN743X_EEPROM_MAGIC (0x74A5)
13#define LAN743X_OTP_MAGIC (0x74F3)
14#define EEPROM_INDICATOR_1 (0xA5)
15#define EEPROM_INDICATOR_2 (0xAA)
16#define EEPROM_MAC_OFFSET (0x01)
17#define MAX_EEPROM_SIZE (512)
18#define MAX_OTP_SIZE (1024)
19#define OTP_INDICATOR_1 (0xF3)
20#define OTP_INDICATOR_2 (0xF7)
21
22static int lan743x_otp_power_up(struct lan743x_adapter *adapter)
23{
24 u32 reg_value;
25
26 reg_value = lan743x_csr_read(adapter, OTP_PWR_DN);
27
28 if (reg_value & OTP_PWR_DN_PWRDN_N_) {
29 /* clear it and wait to be cleared */
30 reg_value &= ~OTP_PWR_DN_PWRDN_N_;
31 lan743x_csr_write(adapter, OTP_PWR_DN, reg_value);
32
33 usleep_range(100, 20000);
34 }
35
36 return 0;
37}
38
39static void lan743x_otp_power_down(struct lan743x_adapter *adapter)
40{
41 u32 reg_value;
42
43 reg_value = lan743x_csr_read(adapter, OTP_PWR_DN);
44 if (!(reg_value & OTP_PWR_DN_PWRDN_N_)) {
45 /* set power down bit */
46 reg_value |= OTP_PWR_DN_PWRDN_N_;
47 lan743x_csr_write(adapter, OTP_PWR_DN, reg_value);
48 }
49}
50
51static void lan743x_otp_set_address(struct lan743x_adapter *adapter,
52 u32 address)
53{
54 lan743x_csr_write(adapter, OTP_ADDR_HIGH, (address >> 8) & 0x03);
55 lan743x_csr_write(adapter, OTP_ADDR_LOW, address & 0xFF);
56}
57
58static void lan743x_otp_read_go(struct lan743x_adapter *adapter)
59{
60 lan743x_csr_write(adapter, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
61 lan743x_csr_write(adapter, OTP_CMD_GO, OTP_CMD_GO_GO_);
62}
63
64static int lan743x_otp_wait_till_not_busy(struct lan743x_adapter *adapter)
65{
66 unsigned long timeout;
67 u32 reg_val;
68
69 timeout = jiffies + HZ;
70 do {
71 if (time_after(jiffies, timeout)) {
72 netif_warn(adapter, drv, adapter->netdev,
73 "Timeout on OTP_STATUS completion\n");
74 return -EIO;
75 }
76 udelay(1);
77 reg_val = lan743x_csr_read(adapter, OTP_STATUS);
78 } while (reg_val & OTP_STATUS_BUSY_);
79
80 return 0;
81}
82
83static int lan743x_otp_read(struct lan743x_adapter *adapter, u32 offset,
84 u32 length, u8 *data)
85{
86 int ret;
87 int i;
88
89 if (offset + length > MAX_OTP_SIZE)
90 return -EINVAL;
91
92 ret = lan743x_otp_power_up(adapter);
93 if (ret < 0)
94 return ret;
95
96 ret = lan743x_otp_wait_till_not_busy(adapter);
97 if (ret < 0)
98 return ret;
99
100 for (i = 0; i < length; i++) {
101 lan743x_otp_set_address(adapter, offset + i);
102
103 lan743x_otp_read_go(adapter);
104 ret = lan743x_otp_wait_till_not_busy(adapter);
105 if (ret < 0)
106 return ret;
107 data[i] = lan743x_csr_read(adapter, OTP_READ_DATA);
108 }
109
110 lan743x_otp_power_down(adapter);
111
112 return 0;
113}
114
115static int lan743x_otp_write(struct lan743x_adapter *adapter, u32 offset,
116 u32 length, u8 *data)
117{
118 int ret;
119 int i;
120
121 if (offset + length > MAX_OTP_SIZE)
122 return -EINVAL;
123
124 ret = lan743x_otp_power_up(adapter);
125 if (ret < 0)
126 return ret;
127
128 ret = lan743x_otp_wait_till_not_busy(adapter);
129 if (ret < 0)
130 return ret;
131
132 /* set to BYTE program mode */
133 lan743x_csr_write(adapter, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
134
135 for (i = 0; i < length; i++) {
136 lan743x_otp_set_address(adapter, offset + i);
137
138 lan743x_csr_write(adapter, OTP_PRGM_DATA, data[i]);
139 lan743x_csr_write(adapter, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
140 lan743x_csr_write(adapter, OTP_CMD_GO, OTP_CMD_GO_GO_);
141
142 ret = lan743x_otp_wait_till_not_busy(adapter);
143 if (ret < 0)
144 return ret;
145 }
146
147 lan743x_otp_power_down(adapter);
148
149 return 0;
150}
151
152static int lan743x_eeprom_wait(struct lan743x_adapter *adapter)
153{
154 unsigned long start_time = jiffies;
155 u32 val;
156
157 do {
158 val = lan743x_csr_read(adapter, E2P_CMD);
159
160 if (!(val & E2P_CMD_EPC_BUSY_) ||
161 (val & E2P_CMD_EPC_TIMEOUT_))
162 break;
163 usleep_range(40, 100);
164 } while (!time_after(jiffies, start_time + HZ));
165
166 if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
167 netif_warn(adapter, drv, adapter->netdev,
168 "EEPROM read operation timeout\n");
169 return -EIO;
170 }
171
172 return 0;
173}
174
175static int lan743x_eeprom_confirm_not_busy(struct lan743x_adapter *adapter)
176{
177 unsigned long start_time = jiffies;
178 u32 val;
179
180 do {
181 val = lan743x_csr_read(adapter, E2P_CMD);
182
183 if (!(val & E2P_CMD_EPC_BUSY_))
184 return 0;
185
186 usleep_range(40, 100);
187 } while (!time_after(jiffies, start_time + HZ));
188
189 netif_warn(adapter, drv, adapter->netdev, "EEPROM is busy\n");
190 return -EIO;
191}
192
193static int lan743x_eeprom_read(struct lan743x_adapter *adapter,
194 u32 offset, u32 length, u8 *data)
195{
196 int retval;
197 u32 val;
198 int i;
199
200 if (offset + length > MAX_EEPROM_SIZE)
201 return -EINVAL;
202
203 retval = lan743x_eeprom_confirm_not_busy(adapter);
204 if (retval)
205 return retval;
206
207 for (i = 0; i < length; i++) {
208 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
209 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
210 lan743x_csr_write(adapter, E2P_CMD, val);
211
212 retval = lan743x_eeprom_wait(adapter);
213 if (retval < 0)
214 return retval;
215
216 val = lan743x_csr_read(adapter, E2P_DATA);
217 data[i] = val & 0xFF;
218 offset++;
219 }
220
221 return 0;
222}
223
224static int lan743x_eeprom_write(struct lan743x_adapter *adapter,
225 u32 offset, u32 length, u8 *data)
226{
227 int retval;
228 u32 val;
229 int i;
230
231 if (offset + length > MAX_EEPROM_SIZE)
232 return -EINVAL;
233
234 retval = lan743x_eeprom_confirm_not_busy(adapter);
235 if (retval)
236 return retval;
237
238 /* Issue write/erase enable command */
239 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
240 lan743x_csr_write(adapter, E2P_CMD, val);
241
242 retval = lan743x_eeprom_wait(adapter);
243 if (retval < 0)
244 return retval;
245
246 for (i = 0; i < length; i++) {
247 /* Fill data register */
248 val = data[i];
249 lan743x_csr_write(adapter, E2P_DATA, val);
250
251 /* Send "write" command */
252 val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
253 val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
254 lan743x_csr_write(adapter, E2P_CMD, val);
255
256 retval = lan743x_eeprom_wait(adapter);
257 if (retval < 0)
258 return retval;
259
260 offset++;
261 }
262
263 return 0;
264}
265
266static void lan743x_ethtool_get_drvinfo(struct net_device *netdev,
267 struct ethtool_drvinfo *info)
268{
269 struct lan743x_adapter *adapter = netdev_priv(netdev);
270
271 strlcpy(info->driver, DRIVER_NAME, sizeof(info->driver));
272 strlcpy(info->bus_info,
273 pci_name(adapter->pdev), sizeof(info->bus_info));
274}
275
276static u32 lan743x_ethtool_get_msglevel(struct net_device *netdev)
277{
278 struct lan743x_adapter *adapter = netdev_priv(netdev);
279
280 return adapter->msg_enable;
281}
282
283static void lan743x_ethtool_set_msglevel(struct net_device *netdev,
284 u32 msglevel)
285{
286 struct lan743x_adapter *adapter = netdev_priv(netdev);
287
288 adapter->msg_enable = msglevel;
289}
290
291static int lan743x_ethtool_get_eeprom_len(struct net_device *netdev)
292{
293 struct lan743x_adapter *adapter = netdev_priv(netdev);
294
295 if (adapter->flags & LAN743X_ADAPTER_FLAG_OTP)
296 return MAX_OTP_SIZE;
297
298 return MAX_EEPROM_SIZE;
299}
300
301static int lan743x_ethtool_get_eeprom(struct net_device *netdev,
302 struct ethtool_eeprom *ee, u8 *data)
303{
304 struct lan743x_adapter *adapter = netdev_priv(netdev);
305 int ret = 0;
306
307 if (adapter->flags & LAN743X_ADAPTER_FLAG_OTP)
308 ret = lan743x_otp_read(adapter, ee->offset, ee->len, data);
309 else
310 ret = lan743x_eeprom_read(adapter, ee->offset, ee->len, data);
311
312 return ret;
313}
314
315static int lan743x_ethtool_set_eeprom(struct net_device *netdev,
316 struct ethtool_eeprom *ee, u8 *data)
317{
318 struct lan743x_adapter *adapter = netdev_priv(netdev);
319 int ret = -EINVAL;
320
321 if (adapter->flags & LAN743X_ADAPTER_FLAG_OTP) {
322 /* Beware! OTP is One Time Programming ONLY! */
323 if (ee->magic == LAN743X_OTP_MAGIC) {
324 ret = lan743x_otp_write(adapter, ee->offset,
325 ee->len, data);
326 }
327 } else {
328 if (ee->magic == LAN743X_EEPROM_MAGIC) {
329 ret = lan743x_eeprom_write(adapter, ee->offset,
330 ee->len, data);
331 }
332 }
333
334 return ret;
335}
336
337static const char lan743x_set0_hw_cnt_strings[][ETH_GSTRING_LEN] = {
338 "RX FCS Errors",
339 "RX Alignment Errors",
340 "Rx Fragment Errors",
341 "RX Jabber Errors",
342 "RX Undersize Frame Errors",
343 "RX Oversize Frame Errors",
344 "RX Dropped Frames",
345 "RX Unicast Byte Count",
346 "RX Broadcast Byte Count",
347 "RX Multicast Byte Count",
348 "RX Unicast Frames",
349 "RX Broadcast Frames",
350 "RX Multicast Frames",
351 "RX Pause Frames",
352 "RX 64 Byte Frames",
353 "RX 65 - 127 Byte Frames",
354 "RX 128 - 255 Byte Frames",
355 "RX 256 - 511 Bytes Frames",
356 "RX 512 - 1023 Byte Frames",
357 "RX 1024 - 1518 Byte Frames",
358 "RX Greater 1518 Byte Frames",
359};
360
361static const char lan743x_set1_sw_cnt_strings[][ETH_GSTRING_LEN] = {
362 "RX Queue 0 Frames",
363 "RX Queue 1 Frames",
364 "RX Queue 2 Frames",
365 "RX Queue 3 Frames",
366};
367
368static const char lan743x_set2_hw_cnt_strings[][ETH_GSTRING_LEN] = {
369 "RX Total Frames",
370 "EEE RX LPI Transitions",
371 "EEE RX LPI Time",
372 "RX Counter Rollover Status",
373 "TX FCS Errors",
374 "TX Excess Deferral Errors",
375 "TX Carrier Errors",
376 "TX Bad Byte Count",
377 "TX Single Collisions",
378 "TX Multiple Collisions",
379 "TX Excessive Collision",
380 "TX Late Collisions",
381 "TX Unicast Byte Count",
382 "TX Broadcast Byte Count",
383 "TX Multicast Byte Count",
384 "TX Unicast Frames",
385 "TX Broadcast Frames",
386 "TX Multicast Frames",
387 "TX Pause Frames",
388 "TX 64 Byte Frames",
389 "TX 65 - 127 Byte Frames",
390 "TX 128 - 255 Byte Frames",
391 "TX 256 - 511 Bytes Frames",
392 "TX 512 - 1023 Byte Frames",
393 "TX 1024 - 1518 Byte Frames",
394 "TX Greater 1518 Byte Frames",
395 "TX Total Frames",
396 "EEE TX LPI Transitions",
397 "EEE TX LPI Time",
398 "TX Counter Rollover Status",
399};
400
401static const u32 lan743x_set0_hw_cnt_addr[] = {
402 STAT_RX_FCS_ERRORS,
403 STAT_RX_ALIGNMENT_ERRORS,
404 STAT_RX_FRAGMENT_ERRORS,
405 STAT_RX_JABBER_ERRORS,
406 STAT_RX_UNDERSIZE_FRAME_ERRORS,
407 STAT_RX_OVERSIZE_FRAME_ERRORS,
408 STAT_RX_DROPPED_FRAMES,
409 STAT_RX_UNICAST_BYTE_COUNT,
410 STAT_RX_BROADCAST_BYTE_COUNT,
411 STAT_RX_MULTICAST_BYTE_COUNT,
412 STAT_RX_UNICAST_FRAMES,
413 STAT_RX_BROADCAST_FRAMES,
414 STAT_RX_MULTICAST_FRAMES,
415 STAT_RX_PAUSE_FRAMES,
416 STAT_RX_64_BYTE_FRAMES,
417 STAT_RX_65_127_BYTE_FRAMES,
418 STAT_RX_128_255_BYTE_FRAMES,
419 STAT_RX_256_511_BYTES_FRAMES,
420 STAT_RX_512_1023_BYTE_FRAMES,
421 STAT_RX_1024_1518_BYTE_FRAMES,
422 STAT_RX_GREATER_1518_BYTE_FRAMES,
423};
424
425static const u32 lan743x_set2_hw_cnt_addr[] = {
426 STAT_RX_TOTAL_FRAMES,
427 STAT_EEE_RX_LPI_TRANSITIONS,
428 STAT_EEE_RX_LPI_TIME,
429 STAT_RX_COUNTER_ROLLOVER_STATUS,
430 STAT_TX_FCS_ERRORS,
431 STAT_TX_EXCESS_DEFERRAL_ERRORS,
432 STAT_TX_CARRIER_ERRORS,
433 STAT_TX_BAD_BYTE_COUNT,
434 STAT_TX_SINGLE_COLLISIONS,
435 STAT_TX_MULTIPLE_COLLISIONS,
436 STAT_TX_EXCESSIVE_COLLISION,
437 STAT_TX_LATE_COLLISIONS,
438 STAT_TX_UNICAST_BYTE_COUNT,
439 STAT_TX_BROADCAST_BYTE_COUNT,
440 STAT_TX_MULTICAST_BYTE_COUNT,
441 STAT_TX_UNICAST_FRAMES,
442 STAT_TX_BROADCAST_FRAMES,
443 STAT_TX_MULTICAST_FRAMES,
444 STAT_TX_PAUSE_FRAMES,
445 STAT_TX_64_BYTE_FRAMES,
446 STAT_TX_65_127_BYTE_FRAMES,
447 STAT_TX_128_255_BYTE_FRAMES,
448 STAT_TX_256_511_BYTES_FRAMES,
449 STAT_TX_512_1023_BYTE_FRAMES,
450 STAT_TX_1024_1518_BYTE_FRAMES,
451 STAT_TX_GREATER_1518_BYTE_FRAMES,
452 STAT_TX_TOTAL_FRAMES,
453 STAT_EEE_TX_LPI_TRANSITIONS,
454 STAT_EEE_TX_LPI_TIME,
455 STAT_TX_COUNTER_ROLLOVER_STATUS
456};
457
458static const char lan743x_priv_flags_strings[][ETH_GSTRING_LEN] = {
459 "OTP_ACCESS",
460};
461
462static void lan743x_ethtool_get_strings(struct net_device *netdev,
463 u32 stringset, u8 *data)
464{
465 switch (stringset) {
466 case ETH_SS_STATS:
467 memcpy(data, lan743x_set0_hw_cnt_strings,
468 sizeof(lan743x_set0_hw_cnt_strings));
469 memcpy(&data[sizeof(lan743x_set0_hw_cnt_strings)],
470 lan743x_set1_sw_cnt_strings,
471 sizeof(lan743x_set1_sw_cnt_strings));
472 memcpy(&data[sizeof(lan743x_set0_hw_cnt_strings) +
473 sizeof(lan743x_set1_sw_cnt_strings)],
474 lan743x_set2_hw_cnt_strings,
475 sizeof(lan743x_set2_hw_cnt_strings));
476 break;
477 case ETH_SS_PRIV_FLAGS:
478 memcpy(data, lan743x_priv_flags_strings,
479 sizeof(lan743x_priv_flags_strings));
480 break;
481 }
482}
483
484static void lan743x_ethtool_get_ethtool_stats(struct net_device *netdev,
485 struct ethtool_stats *stats,
486 u64 *data)
487{
488 struct lan743x_adapter *adapter = netdev_priv(netdev);
489 int data_index = 0;
490 u32 buf;
491 int i;
492
493 for (i = 0; i < ARRAY_SIZE(lan743x_set0_hw_cnt_addr); i++) {
494 buf = lan743x_csr_read(adapter, lan743x_set0_hw_cnt_addr[i]);
495 data[data_index++] = (u64)buf;
496 }
497 for (i = 0; i < ARRAY_SIZE(adapter->rx); i++)
498 data[data_index++] = (u64)(adapter->rx[i].frame_count);
499 for (i = 0; i < ARRAY_SIZE(lan743x_set2_hw_cnt_addr); i++) {
500 buf = lan743x_csr_read(adapter, lan743x_set2_hw_cnt_addr[i]);
501 data[data_index++] = (u64)buf;
502 }
503}
504
505static u32 lan743x_ethtool_get_priv_flags(struct net_device *netdev)
506{
507 struct lan743x_adapter *adapter = netdev_priv(netdev);
508
509 return adapter->flags;
510}
511
512static int lan743x_ethtool_set_priv_flags(struct net_device *netdev, u32 flags)
513{
514 struct lan743x_adapter *adapter = netdev_priv(netdev);
515
516 adapter->flags = flags;
517
518 return 0;
519}
520
521static int lan743x_ethtool_get_sset_count(struct net_device *netdev, int sset)
522{
523 switch (sset) {
524 case ETH_SS_STATS:
525 {
526 int ret;
527
528 ret = ARRAY_SIZE(lan743x_set0_hw_cnt_strings);
529 ret += ARRAY_SIZE(lan743x_set1_sw_cnt_strings);
530 ret += ARRAY_SIZE(lan743x_set2_hw_cnt_strings);
531 return ret;
532 }
533 case ETH_SS_PRIV_FLAGS:
534 return ARRAY_SIZE(lan743x_priv_flags_strings);
535 default:
536 return -EOPNOTSUPP;
537 }
538}
539
540static int lan743x_ethtool_get_rxnfc(struct net_device *netdev,
541 struct ethtool_rxnfc *rxnfc,
542 u32 *rule_locs)
543{
544 switch (rxnfc->cmd) {
545 case ETHTOOL_GRXFH:
546 rxnfc->data = 0;
547 switch (rxnfc->flow_type) {
548 case TCP_V4_FLOW:case UDP_V4_FLOW:
549 case TCP_V6_FLOW:case UDP_V6_FLOW:
550 rxnfc->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
551 fallthrough;
552 case IPV4_FLOW: case IPV6_FLOW:
553 rxnfc->data |= RXH_IP_SRC | RXH_IP_DST;
554 return 0;
555 }
556 break;
557 case ETHTOOL_GRXRINGS:
558 rxnfc->data = LAN743X_USED_RX_CHANNELS;
559 return 0;
560 }
561 return -EOPNOTSUPP;
562}
563
564static u32 lan743x_ethtool_get_rxfh_key_size(struct net_device *netdev)
565{
566 return 40;
567}
568
569static u32 lan743x_ethtool_get_rxfh_indir_size(struct net_device *netdev)
570{
571 return 128;
572}
573
574static int lan743x_ethtool_get_rxfh(struct net_device *netdev,
575 u32 *indir, u8 *key, u8 *hfunc)
576{
577 struct lan743x_adapter *adapter = netdev_priv(netdev);
578
579 if (indir) {
580 int dw_index;
581 int byte_index = 0;
582
583 for (dw_index = 0; dw_index < 32; dw_index++) {
584 u32 four_entries =
585 lan743x_csr_read(adapter, RFE_INDX(dw_index));
586
587 byte_index = dw_index << 2;
588 indir[byte_index + 0] =
589 ((four_entries >> 0) & 0x000000FF);
590 indir[byte_index + 1] =
591 ((four_entries >> 8) & 0x000000FF);
592 indir[byte_index + 2] =
593 ((four_entries >> 16) & 0x000000FF);
594 indir[byte_index + 3] =
595 ((four_entries >> 24) & 0x000000FF);
596 }
597 }
598 if (key) {
599 int dword_index;
600 int byte_index = 0;
601
602 for (dword_index = 0; dword_index < 10; dword_index++) {
603 u32 four_entries =
604 lan743x_csr_read(adapter,
605 RFE_HASH_KEY(dword_index));
606
607 byte_index = dword_index << 2;
608 key[byte_index + 0] =
609 ((four_entries >> 0) & 0x000000FF);
610 key[byte_index + 1] =
611 ((four_entries >> 8) & 0x000000FF);
612 key[byte_index + 2] =
613 ((four_entries >> 16) & 0x000000FF);
614 key[byte_index + 3] =
615 ((four_entries >> 24) & 0x000000FF);
616 }
617 }
618 if (hfunc)
619 (*hfunc) = ETH_RSS_HASH_TOP;
620 return 0;
621}
622
623static int lan743x_ethtool_set_rxfh(struct net_device *netdev,
624 const u32 *indir, const u8 *key,
625 const u8 hfunc)
626{
627 struct lan743x_adapter *adapter = netdev_priv(netdev);
628
629 if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
630 return -EOPNOTSUPP;
631
632 if (indir) {
633 u32 indir_value = 0;
634 int dword_index = 0;
635 int byte_index = 0;
636
637 for (dword_index = 0; dword_index < 32; dword_index++) {
638 byte_index = dword_index << 2;
639 indir_value =
640 (((indir[byte_index + 0] & 0x000000FF) << 0) |
641 ((indir[byte_index + 1] & 0x000000FF) << 8) |
642 ((indir[byte_index + 2] & 0x000000FF) << 16) |
643 ((indir[byte_index + 3] & 0x000000FF) << 24));
644 lan743x_csr_write(adapter, RFE_INDX(dword_index),
645 indir_value);
646 }
647 }
648 if (key) {
649 int dword_index = 0;
650 int byte_index = 0;
651 u32 key_value = 0;
652
653 for (dword_index = 0; dword_index < 10; dword_index++) {
654 byte_index = dword_index << 2;
655 key_value =
656 ((((u32)(key[byte_index + 0])) << 0) |
657 (((u32)(key[byte_index + 1])) << 8) |
658 (((u32)(key[byte_index + 2])) << 16) |
659 (((u32)(key[byte_index + 3])) << 24));
660 lan743x_csr_write(adapter, RFE_HASH_KEY(dword_index),
661 key_value);
662 }
663 }
664 return 0;
665}
666
667static int lan743x_ethtool_get_ts_info(struct net_device *netdev,
668 struct ethtool_ts_info *ts_info)
669{
670 struct lan743x_adapter *adapter = netdev_priv(netdev);
671
672 ts_info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
673 SOF_TIMESTAMPING_RX_SOFTWARE |
674 SOF_TIMESTAMPING_SOFTWARE |
675 SOF_TIMESTAMPING_TX_HARDWARE |
676 SOF_TIMESTAMPING_RX_HARDWARE |
677 SOF_TIMESTAMPING_RAW_HARDWARE;
678
679 if (adapter->ptp.ptp_clock)
680 ts_info->phc_index = ptp_clock_index(adapter->ptp.ptp_clock);
681 else
682 ts_info->phc_index = -1;
683
684 ts_info->tx_types = BIT(HWTSTAMP_TX_OFF) |
685 BIT(HWTSTAMP_TX_ON) |
686 BIT(HWTSTAMP_TX_ONESTEP_SYNC);
687 ts_info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) |
688 BIT(HWTSTAMP_FILTER_ALL);
689 return 0;
690}
691
692static int lan743x_ethtool_get_eee(struct net_device *netdev,
693 struct ethtool_eee *eee)
694{
695 struct lan743x_adapter *adapter = netdev_priv(netdev);
696 struct phy_device *phydev = netdev->phydev;
697 u32 buf;
698 int ret;
699
700 if (!phydev)
701 return -EIO;
702 if (!phydev->drv) {
703 netif_err(adapter, drv, adapter->netdev,
704 "Missing PHY Driver\n");
705 return -EIO;
706 }
707
708 ret = phy_ethtool_get_eee(phydev, eee);
709 if (ret < 0)
710 return ret;
711
712 buf = lan743x_csr_read(adapter, MAC_CR);
713 if (buf & MAC_CR_EEE_EN_) {
714 eee->eee_enabled = true;
715 eee->eee_active = !!(eee->advertised & eee->lp_advertised);
716 eee->tx_lpi_enabled = true;
717 /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
718 buf = lan743x_csr_read(adapter, MAC_EEE_TX_LPI_REQ_DLY_CNT);
719 eee->tx_lpi_timer = buf;
720 } else {
721 eee->eee_enabled = false;
722 eee->eee_active = false;
723 eee->tx_lpi_enabled = false;
724 eee->tx_lpi_timer = 0;
725 }
726
727 return 0;
728}
729
730static int lan743x_ethtool_set_eee(struct net_device *netdev,
731 struct ethtool_eee *eee)
732{
733 struct lan743x_adapter *adapter = netdev_priv(netdev);
734 struct phy_device *phydev = NULL;
735 u32 buf = 0;
736 int ret = 0;
737
738 if (!netdev)
739 return -EINVAL;
740 adapter = netdev_priv(netdev);
741 if (!adapter)
742 return -EINVAL;
743 phydev = netdev->phydev;
744 if (!phydev)
745 return -EIO;
746 if (!phydev->drv) {
747 netif_err(adapter, drv, adapter->netdev,
748 "Missing PHY Driver\n");
749 return -EIO;
750 }
751
752 if (eee->eee_enabled) {
753 ret = phy_init_eee(phydev, 0);
754 if (ret) {
755 netif_err(adapter, drv, adapter->netdev,
756 "EEE initialization failed\n");
757 return ret;
758 }
759
760 buf = (u32)eee->tx_lpi_timer;
761 lan743x_csr_write(adapter, MAC_EEE_TX_LPI_REQ_DLY_CNT, buf);
762
763 buf = lan743x_csr_read(adapter, MAC_CR);
764 buf |= MAC_CR_EEE_EN_;
765 lan743x_csr_write(adapter, MAC_CR, buf);
766 } else {
767 buf = lan743x_csr_read(adapter, MAC_CR);
768 buf &= ~MAC_CR_EEE_EN_;
769 lan743x_csr_write(adapter, MAC_CR, buf);
770 }
771
772 return phy_ethtool_set_eee(phydev, eee);
773}
774
775#ifdef CONFIG_PM
776static void lan743x_ethtool_get_wol(struct net_device *netdev,
777 struct ethtool_wolinfo *wol)
778{
779 struct lan743x_adapter *adapter = netdev_priv(netdev);
780
781 wol->supported = 0;
782 wol->wolopts = 0;
783 phy_ethtool_get_wol(netdev->phydev, wol);
784
785 wol->supported |= WAKE_BCAST | WAKE_UCAST | WAKE_MCAST |
786 WAKE_MAGIC | WAKE_PHY | WAKE_ARP;
787
788 wol->wolopts |= adapter->wolopts;
789}
790
791static int lan743x_ethtool_set_wol(struct net_device *netdev,
792 struct ethtool_wolinfo *wol)
793{
794 struct lan743x_adapter *adapter = netdev_priv(netdev);
795
796 adapter->wolopts = 0;
797 if (wol->wolopts & WAKE_UCAST)
798 adapter->wolopts |= WAKE_UCAST;
799 if (wol->wolopts & WAKE_MCAST)
800 adapter->wolopts |= WAKE_MCAST;
801 if (wol->wolopts & WAKE_BCAST)
802 adapter->wolopts |= WAKE_BCAST;
803 if (wol->wolopts & WAKE_MAGIC)
804 adapter->wolopts |= WAKE_MAGIC;
805 if (wol->wolopts & WAKE_PHY)
806 adapter->wolopts |= WAKE_PHY;
807 if (wol->wolopts & WAKE_ARP)
808 adapter->wolopts |= WAKE_ARP;
809
810 device_set_wakeup_enable(&adapter->pdev->dev, (bool)wol->wolopts);
811
812 phy_ethtool_set_wol(netdev->phydev, wol);
813
814 return 0;
815}
816#endif /* CONFIG_PM */
817
818const struct ethtool_ops lan743x_ethtool_ops = {
819 .get_drvinfo = lan743x_ethtool_get_drvinfo,
820 .get_msglevel = lan743x_ethtool_get_msglevel,
821 .set_msglevel = lan743x_ethtool_set_msglevel,
822 .get_link = ethtool_op_get_link,
823
824 .get_eeprom_len = lan743x_ethtool_get_eeprom_len,
825 .get_eeprom = lan743x_ethtool_get_eeprom,
826 .set_eeprom = lan743x_ethtool_set_eeprom,
827 .get_strings = lan743x_ethtool_get_strings,
828 .get_ethtool_stats = lan743x_ethtool_get_ethtool_stats,
829 .get_priv_flags = lan743x_ethtool_get_priv_flags,
830 .set_priv_flags = lan743x_ethtool_set_priv_flags,
831 .get_sset_count = lan743x_ethtool_get_sset_count,
832 .get_rxnfc = lan743x_ethtool_get_rxnfc,
833 .get_rxfh_key_size = lan743x_ethtool_get_rxfh_key_size,
834 .get_rxfh_indir_size = lan743x_ethtool_get_rxfh_indir_size,
835 .get_rxfh = lan743x_ethtool_get_rxfh,
836 .set_rxfh = lan743x_ethtool_set_rxfh,
837 .get_ts_info = lan743x_ethtool_get_ts_info,
838 .get_eee = lan743x_ethtool_get_eee,
839 .set_eee = lan743x_ethtool_set_eee,
840 .get_link_ksettings = phy_ethtool_get_link_ksettings,
841 .set_link_ksettings = phy_ethtool_set_link_ksettings,
842#ifdef CONFIG_PM
843 .get_wol = lan743x_ethtool_get_wol,
844 .set_wol = lan743x_ethtool_set_wol,
845#endif
846};