Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0+ */
0002 /* Copyright (C) 2018 Microchip Technology Inc. */
0003 
0004 #include <linux/netdevice.h>
0005 #include <linux/net_tstamp.h>
0006 #include <linux/pci.h>
0007 #include <linux/phy.h>
0008 #include "lan743x_main.h"
0009 #include "lan743x_ethtool.h"
0010 #include <linux/sched.h>
0011 #include <linux/iopoll.h>
0012 
0013 /* eeprom */
0014 #define LAN743X_EEPROM_MAGIC            (0x74A5)
0015 #define LAN743X_OTP_MAGIC           (0x74F3)
0016 #define EEPROM_INDICATOR_1          (0xA5)
0017 #define EEPROM_INDICATOR_2          (0xAA)
0018 #define EEPROM_MAC_OFFSET           (0x01)
0019 #define MAX_EEPROM_SIZE             (512)
0020 #define MAX_OTP_SIZE                (1024)
0021 #define OTP_INDICATOR_1             (0xF3)
0022 #define OTP_INDICATOR_2             (0xF7)
0023 
0024 #define LOCK_TIMEOUT_MAX_CNT            (100) // 1 sec (10 msce * 100)
0025 
0026 #define LAN743X_CSR_READ_OP(offset)      lan743x_csr_read(adapter, offset)
0027 
0028 static int lan743x_otp_power_up(struct lan743x_adapter *adapter)
0029 {
0030     u32 reg_value;
0031 
0032     reg_value = lan743x_csr_read(adapter, OTP_PWR_DN);
0033 
0034     if (reg_value & OTP_PWR_DN_PWRDN_N_) {
0035         /* clear it and wait to be cleared */
0036         reg_value &= ~OTP_PWR_DN_PWRDN_N_;
0037         lan743x_csr_write(adapter, OTP_PWR_DN, reg_value);
0038 
0039         usleep_range(100, 20000);
0040     }
0041 
0042     return 0;
0043 }
0044 
0045 static void lan743x_otp_power_down(struct lan743x_adapter *adapter)
0046 {
0047     u32 reg_value;
0048 
0049     reg_value = lan743x_csr_read(adapter, OTP_PWR_DN);
0050     if (!(reg_value & OTP_PWR_DN_PWRDN_N_)) {
0051         /* set power down bit */
0052         reg_value |= OTP_PWR_DN_PWRDN_N_;
0053         lan743x_csr_write(adapter, OTP_PWR_DN, reg_value);
0054     }
0055 }
0056 
0057 static void lan743x_otp_set_address(struct lan743x_adapter *adapter,
0058                     u32 address)
0059 {
0060     lan743x_csr_write(adapter, OTP_ADDR_HIGH, (address >> 8) & 0x03);
0061     lan743x_csr_write(adapter, OTP_ADDR_LOW, address & 0xFF);
0062 }
0063 
0064 static void lan743x_otp_read_go(struct lan743x_adapter *adapter)
0065 {
0066     lan743x_csr_write(adapter, OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
0067     lan743x_csr_write(adapter, OTP_CMD_GO, OTP_CMD_GO_GO_);
0068 }
0069 
0070 static int lan743x_otp_wait_till_not_busy(struct lan743x_adapter *adapter)
0071 {
0072     unsigned long timeout;
0073     u32 reg_val;
0074 
0075     timeout = jiffies + HZ;
0076     do {
0077         if (time_after(jiffies, timeout)) {
0078             netif_warn(adapter, drv, adapter->netdev,
0079                    "Timeout on OTP_STATUS completion\n");
0080             return -EIO;
0081         }
0082         udelay(1);
0083         reg_val = lan743x_csr_read(adapter, OTP_STATUS);
0084     } while (reg_val & OTP_STATUS_BUSY_);
0085 
0086     return 0;
0087 }
0088 
0089 static int lan743x_otp_read(struct lan743x_adapter *adapter, u32 offset,
0090                 u32 length, u8 *data)
0091 {
0092     int ret;
0093     int i;
0094 
0095     if (offset + length > MAX_OTP_SIZE)
0096         return -EINVAL;
0097 
0098     ret = lan743x_otp_power_up(adapter);
0099     if (ret < 0)
0100         return ret;
0101 
0102     ret = lan743x_otp_wait_till_not_busy(adapter);
0103     if (ret < 0)
0104         return ret;
0105 
0106     for (i = 0; i < length; i++) {
0107         lan743x_otp_set_address(adapter, offset + i);
0108 
0109         lan743x_otp_read_go(adapter);
0110         ret = lan743x_otp_wait_till_not_busy(adapter);
0111         if (ret < 0)
0112             return ret;
0113         data[i] = lan743x_csr_read(adapter, OTP_READ_DATA);
0114     }
0115 
0116     lan743x_otp_power_down(adapter);
0117 
0118     return 0;
0119 }
0120 
0121 static int lan743x_otp_write(struct lan743x_adapter *adapter, u32 offset,
0122                  u32 length, u8 *data)
0123 {
0124     int ret;
0125     int i;
0126 
0127     if (offset + length > MAX_OTP_SIZE)
0128         return -EINVAL;
0129 
0130     ret = lan743x_otp_power_up(adapter);
0131     if (ret < 0)
0132         return ret;
0133 
0134     ret = lan743x_otp_wait_till_not_busy(adapter);
0135     if (ret < 0)
0136         return ret;
0137 
0138     /* set to BYTE program mode */
0139     lan743x_csr_write(adapter, OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
0140 
0141     for (i = 0; i < length; i++) {
0142         lan743x_otp_set_address(adapter, offset + i);
0143 
0144         lan743x_csr_write(adapter, OTP_PRGM_DATA, data[i]);
0145         lan743x_csr_write(adapter, OTP_TST_CMD, OTP_TST_CMD_PRGVRFY_);
0146         lan743x_csr_write(adapter, OTP_CMD_GO, OTP_CMD_GO_GO_);
0147 
0148         ret = lan743x_otp_wait_till_not_busy(adapter);
0149         if (ret < 0)
0150             return ret;
0151     }
0152 
0153     lan743x_otp_power_down(adapter);
0154 
0155     return 0;
0156 }
0157 
0158 int lan743x_hs_syslock_acquire(struct lan743x_adapter *adapter,
0159                    u16 timeout)
0160 {
0161     u16 timeout_cnt = 0;
0162     u32 val;
0163 
0164     do {
0165         spin_lock(&adapter->eth_syslock_spinlock);
0166         if (adapter->eth_syslock_acquire_cnt == 0) {
0167             lan743x_csr_write(adapter, ETH_SYSTEM_SYS_LOCK_REG,
0168                       SYS_LOCK_REG_ENET_SS_LOCK_);
0169             val = lan743x_csr_read(adapter,
0170                            ETH_SYSTEM_SYS_LOCK_REG);
0171             if (val & SYS_LOCK_REG_ENET_SS_LOCK_) {
0172                 adapter->eth_syslock_acquire_cnt++;
0173                 WARN_ON(adapter->eth_syslock_acquire_cnt == 0);
0174                 spin_unlock(&adapter->eth_syslock_spinlock);
0175                 break;
0176             }
0177         } else {
0178             adapter->eth_syslock_acquire_cnt++;
0179             WARN_ON(adapter->eth_syslock_acquire_cnt == 0);
0180             spin_unlock(&adapter->eth_syslock_spinlock);
0181             break;
0182         }
0183 
0184         spin_unlock(&adapter->eth_syslock_spinlock);
0185 
0186         if (timeout_cnt++ < timeout)
0187             usleep_range(10000, 11000);
0188         else
0189             return -ETIMEDOUT;
0190     } while (true);
0191 
0192     return 0;
0193 }
0194 
0195 void lan743x_hs_syslock_release(struct lan743x_adapter *adapter)
0196 {
0197     u32 val;
0198 
0199     spin_lock(&adapter->eth_syslock_spinlock);
0200     WARN_ON(adapter->eth_syslock_acquire_cnt == 0);
0201 
0202     if (adapter->eth_syslock_acquire_cnt) {
0203         adapter->eth_syslock_acquire_cnt--;
0204         if (adapter->eth_syslock_acquire_cnt == 0) {
0205             lan743x_csr_write(adapter, ETH_SYSTEM_SYS_LOCK_REG, 0);
0206             val = lan743x_csr_read(adapter,
0207                            ETH_SYSTEM_SYS_LOCK_REG);
0208             WARN_ON((val & SYS_LOCK_REG_ENET_SS_LOCK_) != 0);
0209         }
0210     }
0211 
0212     spin_unlock(&adapter->eth_syslock_spinlock);
0213 }
0214 
0215 static void lan743x_hs_otp_power_up(struct lan743x_adapter *adapter)
0216 {
0217     u32 reg_value;
0218 
0219     reg_value = lan743x_csr_read(adapter, HS_OTP_PWR_DN);
0220     if (reg_value & OTP_PWR_DN_PWRDN_N_) {
0221         reg_value &= ~OTP_PWR_DN_PWRDN_N_;
0222         lan743x_csr_write(adapter, HS_OTP_PWR_DN, reg_value);
0223         /* To flush the posted write so the subsequent delay is
0224          * guaranteed to happen after the write at the hardware
0225          */
0226         lan743x_csr_read(adapter, HS_OTP_PWR_DN);
0227         udelay(1);
0228     }
0229 }
0230 
0231 static void lan743x_hs_otp_power_down(struct lan743x_adapter *adapter)
0232 {
0233     u32 reg_value;
0234 
0235     reg_value = lan743x_csr_read(adapter, HS_OTP_PWR_DN);
0236     if (!(reg_value & OTP_PWR_DN_PWRDN_N_)) {
0237         reg_value |= OTP_PWR_DN_PWRDN_N_;
0238         lan743x_csr_write(adapter, HS_OTP_PWR_DN, reg_value);
0239         /* To flush the posted write so the subsequent delay is
0240          * guaranteed to happen after the write at the hardware
0241          */
0242         lan743x_csr_read(adapter, HS_OTP_PWR_DN);
0243         udelay(1);
0244     }
0245 }
0246 
0247 static void lan743x_hs_otp_set_address(struct lan743x_adapter *adapter,
0248                        u32 address)
0249 {
0250     lan743x_csr_write(adapter, HS_OTP_ADDR_HIGH, (address >> 8) & 0x03);
0251     lan743x_csr_write(adapter, HS_OTP_ADDR_LOW, address & 0xFF);
0252 }
0253 
0254 static void lan743x_hs_otp_read_go(struct lan743x_adapter *adapter)
0255 {
0256     lan743x_csr_write(adapter, HS_OTP_FUNC_CMD, OTP_FUNC_CMD_READ_);
0257     lan743x_csr_write(adapter, HS_OTP_CMD_GO, OTP_CMD_GO_GO_);
0258 }
0259 
0260 static int lan743x_hs_otp_cmd_cmplt_chk(struct lan743x_adapter *adapter)
0261 {
0262     u32 val;
0263 
0264     return readx_poll_timeout(LAN743X_CSR_READ_OP, HS_OTP_STATUS, val,
0265                   !(val & OTP_STATUS_BUSY_),
0266                   80, 10000);
0267 }
0268 
0269 static int lan743x_hs_otp_read(struct lan743x_adapter *adapter, u32 offset,
0270                    u32 length, u8 *data)
0271 {
0272     int ret;
0273     int i;
0274 
0275     ret = lan743x_hs_syslock_acquire(adapter, LOCK_TIMEOUT_MAX_CNT);
0276     if (ret < 0)
0277         return ret;
0278 
0279     lan743x_hs_otp_power_up(adapter);
0280 
0281     ret = lan743x_hs_otp_cmd_cmplt_chk(adapter);
0282     if (ret < 0)
0283         goto power_down;
0284 
0285     lan743x_hs_syslock_release(adapter);
0286 
0287     for (i = 0; i < length; i++) {
0288         ret = lan743x_hs_syslock_acquire(adapter,
0289                          LOCK_TIMEOUT_MAX_CNT);
0290         if (ret < 0)
0291             return ret;
0292 
0293         lan743x_hs_otp_set_address(adapter, offset + i);
0294 
0295         lan743x_hs_otp_read_go(adapter);
0296         ret = lan743x_hs_otp_cmd_cmplt_chk(adapter);
0297         if (ret < 0)
0298             goto power_down;
0299 
0300         data[i] = lan743x_csr_read(adapter, HS_OTP_READ_DATA);
0301 
0302         lan743x_hs_syslock_release(adapter);
0303     }
0304 
0305     ret = lan743x_hs_syslock_acquire(adapter,
0306                      LOCK_TIMEOUT_MAX_CNT);
0307     if (ret < 0)
0308         return ret;
0309 
0310 power_down:
0311     lan743x_hs_otp_power_down(adapter);
0312     lan743x_hs_syslock_release(adapter);
0313 
0314     return ret;
0315 }
0316 
0317 static int lan743x_hs_otp_write(struct lan743x_adapter *adapter, u32 offset,
0318                 u32 length, u8 *data)
0319 {
0320     int ret;
0321     int i;
0322 
0323     ret = lan743x_hs_syslock_acquire(adapter, LOCK_TIMEOUT_MAX_CNT);
0324     if (ret < 0)
0325         return ret;
0326 
0327     lan743x_hs_otp_power_up(adapter);
0328 
0329     ret = lan743x_hs_otp_cmd_cmplt_chk(adapter);
0330     if (ret < 0)
0331         goto power_down;
0332 
0333     /* set to BYTE program mode */
0334     lan743x_csr_write(adapter, HS_OTP_PRGM_MODE, OTP_PRGM_MODE_BYTE_);
0335 
0336     lan743x_hs_syslock_release(adapter);
0337 
0338     for (i = 0; i < length; i++) {
0339         ret = lan743x_hs_syslock_acquire(adapter,
0340                          LOCK_TIMEOUT_MAX_CNT);
0341         if (ret < 0)
0342             return ret;
0343 
0344         lan743x_hs_otp_set_address(adapter, offset + i);
0345 
0346         lan743x_csr_write(adapter, HS_OTP_PRGM_DATA, data[i]);
0347         lan743x_csr_write(adapter, HS_OTP_TST_CMD,
0348                   OTP_TST_CMD_PRGVRFY_);
0349         lan743x_csr_write(adapter, HS_OTP_CMD_GO, OTP_CMD_GO_GO_);
0350 
0351         ret = lan743x_hs_otp_cmd_cmplt_chk(adapter);
0352         if (ret < 0)
0353             goto power_down;
0354 
0355         lan743x_hs_syslock_release(adapter);
0356     }
0357 
0358     ret = lan743x_hs_syslock_acquire(adapter, LOCK_TIMEOUT_MAX_CNT);
0359     if (ret < 0)
0360         return ret;
0361 
0362 power_down:
0363     lan743x_hs_otp_power_down(adapter);
0364     lan743x_hs_syslock_release(adapter);
0365 
0366     return ret;
0367 }
0368 
0369 static int lan743x_eeprom_wait(struct lan743x_adapter *adapter)
0370 {
0371     unsigned long start_time = jiffies;
0372     u32 val;
0373 
0374     do {
0375         val = lan743x_csr_read(adapter, E2P_CMD);
0376 
0377         if (!(val & E2P_CMD_EPC_BUSY_) ||
0378             (val & E2P_CMD_EPC_TIMEOUT_))
0379             break;
0380         usleep_range(40, 100);
0381     } while (!time_after(jiffies, start_time + HZ));
0382 
0383     if (val & (E2P_CMD_EPC_TIMEOUT_ | E2P_CMD_EPC_BUSY_)) {
0384         netif_warn(adapter, drv, adapter->netdev,
0385                "EEPROM read operation timeout\n");
0386         return -EIO;
0387     }
0388 
0389     return 0;
0390 }
0391 
0392 static int lan743x_eeprom_confirm_not_busy(struct lan743x_adapter *adapter)
0393 {
0394     unsigned long start_time = jiffies;
0395     u32 val;
0396 
0397     do {
0398         val = lan743x_csr_read(adapter, E2P_CMD);
0399 
0400         if (!(val & E2P_CMD_EPC_BUSY_))
0401             return 0;
0402 
0403         usleep_range(40, 100);
0404     } while (!time_after(jiffies, start_time + HZ));
0405 
0406     netif_warn(adapter, drv, adapter->netdev, "EEPROM is busy\n");
0407     return -EIO;
0408 }
0409 
0410 static int lan743x_eeprom_read(struct lan743x_adapter *adapter,
0411                    u32 offset, u32 length, u8 *data)
0412 {
0413     int retval;
0414     u32 val;
0415     int i;
0416 
0417     if (offset + length > MAX_EEPROM_SIZE)
0418         return -EINVAL;
0419 
0420     retval = lan743x_eeprom_confirm_not_busy(adapter);
0421     if (retval)
0422         return retval;
0423 
0424     for (i = 0; i < length; i++) {
0425         val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_READ_;
0426         val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
0427         lan743x_csr_write(adapter, E2P_CMD, val);
0428 
0429         retval = lan743x_eeprom_wait(adapter);
0430         if (retval < 0)
0431             return retval;
0432 
0433         val = lan743x_csr_read(adapter, E2P_DATA);
0434         data[i] = val & 0xFF;
0435         offset++;
0436     }
0437 
0438     return 0;
0439 }
0440 
0441 static int lan743x_eeprom_write(struct lan743x_adapter *adapter,
0442                 u32 offset, u32 length, u8 *data)
0443 {
0444     int retval;
0445     u32 val;
0446     int i;
0447 
0448     if (offset + length > MAX_EEPROM_SIZE)
0449         return -EINVAL;
0450 
0451     retval = lan743x_eeprom_confirm_not_busy(adapter);
0452     if (retval)
0453         return retval;
0454 
0455     /* Issue write/erase enable command */
0456     val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_EWEN_;
0457     lan743x_csr_write(adapter, E2P_CMD, val);
0458 
0459     retval = lan743x_eeprom_wait(adapter);
0460     if (retval < 0)
0461         return retval;
0462 
0463     for (i = 0; i < length; i++) {
0464         /* Fill data register */
0465         val = data[i];
0466         lan743x_csr_write(adapter, E2P_DATA, val);
0467 
0468         /* Send "write" command */
0469         val = E2P_CMD_EPC_BUSY_ | E2P_CMD_EPC_CMD_WRITE_;
0470         val |= (offset & E2P_CMD_EPC_ADDR_MASK_);
0471         lan743x_csr_write(adapter, E2P_CMD, val);
0472 
0473         retval = lan743x_eeprom_wait(adapter);
0474         if (retval < 0)
0475             return retval;
0476 
0477         offset++;
0478     }
0479 
0480     return 0;
0481 }
0482 
0483 static int lan743x_hs_eeprom_cmd_cmplt_chk(struct lan743x_adapter *adapter)
0484 {
0485     u32 val;
0486 
0487     return readx_poll_timeout(LAN743X_CSR_READ_OP, HS_E2P_CMD, val,
0488                   (!(val & HS_E2P_CMD_EPC_BUSY_) ||
0489                     (val & HS_E2P_CMD_EPC_TIMEOUT_)),
0490                   50, 10000);
0491 }
0492 
0493 static int lan743x_hs_eeprom_read(struct lan743x_adapter *adapter,
0494                   u32 offset, u32 length, u8 *data)
0495 {
0496     int retval;
0497     u32 val;
0498     int i;
0499 
0500     retval = lan743x_hs_syslock_acquire(adapter, LOCK_TIMEOUT_MAX_CNT);
0501     if (retval < 0)
0502         return retval;
0503 
0504     retval = lan743x_hs_eeprom_cmd_cmplt_chk(adapter);
0505     lan743x_hs_syslock_release(adapter);
0506     if (retval < 0)
0507         return retval;
0508 
0509     for (i = 0; i < length; i++) {
0510         retval = lan743x_hs_syslock_acquire(adapter,
0511                             LOCK_TIMEOUT_MAX_CNT);
0512         if (retval < 0)
0513             return retval;
0514 
0515         val = HS_E2P_CMD_EPC_BUSY_ | HS_E2P_CMD_EPC_CMD_READ_;
0516         val |= (offset & HS_E2P_CMD_EPC_ADDR_MASK_);
0517         lan743x_csr_write(adapter, HS_E2P_CMD, val);
0518         retval = lan743x_hs_eeprom_cmd_cmplt_chk(adapter);
0519         if (retval < 0) {
0520             lan743x_hs_syslock_release(adapter);
0521             return retval;
0522         }
0523 
0524         val = lan743x_csr_read(adapter, HS_E2P_DATA);
0525 
0526         lan743x_hs_syslock_release(adapter);
0527 
0528         data[i] = val & 0xFF;
0529         offset++;
0530     }
0531 
0532     return 0;
0533 }
0534 
0535 static int lan743x_hs_eeprom_write(struct lan743x_adapter *adapter,
0536                    u32 offset, u32 length, u8 *data)
0537 {
0538     int retval;
0539     u32 val;
0540     int i;
0541 
0542     retval = lan743x_hs_syslock_acquire(adapter, LOCK_TIMEOUT_MAX_CNT);
0543     if (retval < 0)
0544         return retval;
0545 
0546     retval = lan743x_hs_eeprom_cmd_cmplt_chk(adapter);
0547     lan743x_hs_syslock_release(adapter);
0548     if (retval < 0)
0549         return retval;
0550 
0551     for (i = 0; i < length; i++) {
0552         retval = lan743x_hs_syslock_acquire(adapter,
0553                             LOCK_TIMEOUT_MAX_CNT);
0554         if (retval < 0)
0555             return retval;
0556 
0557         /* Fill data register */
0558         val = data[i];
0559         lan743x_csr_write(adapter, HS_E2P_DATA, val);
0560 
0561         /* Send "write" command */
0562         val = HS_E2P_CMD_EPC_BUSY_ | HS_E2P_CMD_EPC_CMD_WRITE_;
0563         val |= (offset & HS_E2P_CMD_EPC_ADDR_MASK_);
0564         lan743x_csr_write(adapter, HS_E2P_CMD, val);
0565 
0566         retval = lan743x_hs_eeprom_cmd_cmplt_chk(adapter);
0567         lan743x_hs_syslock_release(adapter);
0568         if (retval < 0)
0569             return retval;
0570 
0571         offset++;
0572     }
0573 
0574     return 0;
0575 }
0576 
0577 static void lan743x_ethtool_get_drvinfo(struct net_device *netdev,
0578                     struct ethtool_drvinfo *info)
0579 {
0580     struct lan743x_adapter *adapter = netdev_priv(netdev);
0581 
0582     strlcpy(info->driver, DRIVER_NAME, sizeof(info->driver));
0583     strlcpy(info->bus_info,
0584         pci_name(adapter->pdev), sizeof(info->bus_info));
0585 }
0586 
0587 static u32 lan743x_ethtool_get_msglevel(struct net_device *netdev)
0588 {
0589     struct lan743x_adapter *adapter = netdev_priv(netdev);
0590 
0591     return adapter->msg_enable;
0592 }
0593 
0594 static void lan743x_ethtool_set_msglevel(struct net_device *netdev,
0595                      u32 msglevel)
0596 {
0597     struct lan743x_adapter *adapter = netdev_priv(netdev);
0598 
0599     adapter->msg_enable = msglevel;
0600 }
0601 
0602 static int lan743x_ethtool_get_eeprom_len(struct net_device *netdev)
0603 {
0604     struct lan743x_adapter *adapter = netdev_priv(netdev);
0605 
0606     if (adapter->flags & LAN743X_ADAPTER_FLAG_OTP)
0607         return MAX_OTP_SIZE;
0608 
0609     return MAX_EEPROM_SIZE;
0610 }
0611 
0612 static int lan743x_ethtool_get_eeprom(struct net_device *netdev,
0613                       struct ethtool_eeprom *ee, u8 *data)
0614 {
0615     struct lan743x_adapter *adapter = netdev_priv(netdev);
0616     int ret = 0;
0617 
0618     if (adapter->flags & LAN743X_ADAPTER_FLAG_OTP) {
0619         if (adapter->is_pci11x1x)
0620             ret = lan743x_hs_otp_read(adapter, ee->offset,
0621                           ee->len, data);
0622         else
0623             ret = lan743x_otp_read(adapter, ee->offset,
0624                            ee->len, data);
0625     } else {
0626         if (adapter->is_pci11x1x)
0627             ret = lan743x_hs_eeprom_read(adapter, ee->offset,
0628                              ee->len, data);
0629         else
0630             ret = lan743x_eeprom_read(adapter, ee->offset,
0631                           ee->len, data);
0632     }
0633 
0634     return ret;
0635 }
0636 
0637 static int lan743x_ethtool_set_eeprom(struct net_device *netdev,
0638                       struct ethtool_eeprom *ee, u8 *data)
0639 {
0640     struct lan743x_adapter *adapter = netdev_priv(netdev);
0641     int ret = -EINVAL;
0642 
0643     if (adapter->flags & LAN743X_ADAPTER_FLAG_OTP) {
0644         /* Beware!  OTP is One Time Programming ONLY! */
0645         if (ee->magic == LAN743X_OTP_MAGIC) {
0646             if (adapter->is_pci11x1x)
0647                 ret = lan743x_hs_otp_write(adapter, ee->offset,
0648                                ee->len, data);
0649             else
0650                 ret = lan743x_otp_write(adapter, ee->offset,
0651                             ee->len, data);
0652         }
0653     } else {
0654         if (ee->magic == LAN743X_EEPROM_MAGIC) {
0655             if (adapter->is_pci11x1x)
0656                 ret = lan743x_hs_eeprom_write(adapter,
0657                                   ee->offset,
0658                                   ee->len, data);
0659             else
0660                 ret = lan743x_eeprom_write(adapter, ee->offset,
0661                                ee->len, data);
0662         }
0663     }
0664 
0665     return ret;
0666 }
0667 
0668 static const char lan743x_set0_hw_cnt_strings[][ETH_GSTRING_LEN] = {
0669     "RX FCS Errors",
0670     "RX Alignment Errors",
0671     "Rx Fragment Errors",
0672     "RX Jabber Errors",
0673     "RX Undersize Frame Errors",
0674     "RX Oversize Frame Errors",
0675     "RX Dropped Frames",
0676     "RX Unicast Byte Count",
0677     "RX Broadcast Byte Count",
0678     "RX Multicast Byte Count",
0679     "RX Unicast Frames",
0680     "RX Broadcast Frames",
0681     "RX Multicast Frames",
0682     "RX Pause Frames",
0683     "RX 64 Byte Frames",
0684     "RX 65 - 127 Byte Frames",
0685     "RX 128 - 255 Byte Frames",
0686     "RX 256 - 511 Bytes Frames",
0687     "RX 512 - 1023 Byte Frames",
0688     "RX 1024 - 1518 Byte Frames",
0689     "RX Greater 1518 Byte Frames",
0690 };
0691 
0692 static const char lan743x_set1_sw_cnt_strings[][ETH_GSTRING_LEN] = {
0693     "RX Queue 0 Frames",
0694     "RX Queue 1 Frames",
0695     "RX Queue 2 Frames",
0696     "RX Queue 3 Frames",
0697 };
0698 
0699 static const char lan743x_tx_queue_cnt_strings[][ETH_GSTRING_LEN] = {
0700     "TX Queue 0 Frames",
0701     "TX Queue 1 Frames",
0702     "TX Queue 2 Frames",
0703     "TX Queue 3 Frames",
0704     "TX Total Queue Frames",
0705 };
0706 
0707 static const char lan743x_set2_hw_cnt_strings[][ETH_GSTRING_LEN] = {
0708     "RX Total Frames",
0709     "EEE RX LPI Transitions",
0710     "EEE RX LPI Time",
0711     "RX Counter Rollover Status",
0712     "TX FCS Errors",
0713     "TX Excess Deferral Errors",
0714     "TX Carrier Errors",
0715     "TX Bad Byte Count",
0716     "TX Single Collisions",
0717     "TX Multiple Collisions",
0718     "TX Excessive Collision",
0719     "TX Late Collisions",
0720     "TX Unicast Byte Count",
0721     "TX Broadcast Byte Count",
0722     "TX Multicast Byte Count",
0723     "TX Unicast Frames",
0724     "TX Broadcast Frames",
0725     "TX Multicast Frames",
0726     "TX Pause Frames",
0727     "TX 64 Byte Frames",
0728     "TX 65 - 127 Byte Frames",
0729     "TX 128 - 255 Byte Frames",
0730     "TX 256 - 511 Bytes Frames",
0731     "TX 512 - 1023 Byte Frames",
0732     "TX 1024 - 1518 Byte Frames",
0733     "TX Greater 1518 Byte Frames",
0734     "TX Total Frames",
0735     "EEE TX LPI Transitions",
0736     "EEE TX LPI Time",
0737     "TX Counter Rollover Status",
0738 };
0739 
0740 static const u32 lan743x_set0_hw_cnt_addr[] = {
0741     STAT_RX_FCS_ERRORS,
0742     STAT_RX_ALIGNMENT_ERRORS,
0743     STAT_RX_FRAGMENT_ERRORS,
0744     STAT_RX_JABBER_ERRORS,
0745     STAT_RX_UNDERSIZE_FRAME_ERRORS,
0746     STAT_RX_OVERSIZE_FRAME_ERRORS,
0747     STAT_RX_DROPPED_FRAMES,
0748     STAT_RX_UNICAST_BYTE_COUNT,
0749     STAT_RX_BROADCAST_BYTE_COUNT,
0750     STAT_RX_MULTICAST_BYTE_COUNT,
0751     STAT_RX_UNICAST_FRAMES,
0752     STAT_RX_BROADCAST_FRAMES,
0753     STAT_RX_MULTICAST_FRAMES,
0754     STAT_RX_PAUSE_FRAMES,
0755     STAT_RX_64_BYTE_FRAMES,
0756     STAT_RX_65_127_BYTE_FRAMES,
0757     STAT_RX_128_255_BYTE_FRAMES,
0758     STAT_RX_256_511_BYTES_FRAMES,
0759     STAT_RX_512_1023_BYTE_FRAMES,
0760     STAT_RX_1024_1518_BYTE_FRAMES,
0761     STAT_RX_GREATER_1518_BYTE_FRAMES,
0762 };
0763 
0764 static const u32 lan743x_set2_hw_cnt_addr[] = {
0765     STAT_RX_TOTAL_FRAMES,
0766     STAT_EEE_RX_LPI_TRANSITIONS,
0767     STAT_EEE_RX_LPI_TIME,
0768     STAT_RX_COUNTER_ROLLOVER_STATUS,
0769     STAT_TX_FCS_ERRORS,
0770     STAT_TX_EXCESS_DEFERRAL_ERRORS,
0771     STAT_TX_CARRIER_ERRORS,
0772     STAT_TX_BAD_BYTE_COUNT,
0773     STAT_TX_SINGLE_COLLISIONS,
0774     STAT_TX_MULTIPLE_COLLISIONS,
0775     STAT_TX_EXCESSIVE_COLLISION,
0776     STAT_TX_LATE_COLLISIONS,
0777     STAT_TX_UNICAST_BYTE_COUNT,
0778     STAT_TX_BROADCAST_BYTE_COUNT,
0779     STAT_TX_MULTICAST_BYTE_COUNT,
0780     STAT_TX_UNICAST_FRAMES,
0781     STAT_TX_BROADCAST_FRAMES,
0782     STAT_TX_MULTICAST_FRAMES,
0783     STAT_TX_PAUSE_FRAMES,
0784     STAT_TX_64_BYTE_FRAMES,
0785     STAT_TX_65_127_BYTE_FRAMES,
0786     STAT_TX_128_255_BYTE_FRAMES,
0787     STAT_TX_256_511_BYTES_FRAMES,
0788     STAT_TX_512_1023_BYTE_FRAMES,
0789     STAT_TX_1024_1518_BYTE_FRAMES,
0790     STAT_TX_GREATER_1518_BYTE_FRAMES,
0791     STAT_TX_TOTAL_FRAMES,
0792     STAT_EEE_TX_LPI_TRANSITIONS,
0793     STAT_EEE_TX_LPI_TIME,
0794     STAT_TX_COUNTER_ROLLOVER_STATUS
0795 };
0796 
0797 static const char lan743x_priv_flags_strings[][ETH_GSTRING_LEN] = {
0798     "OTP_ACCESS",
0799 };
0800 
0801 static void lan743x_ethtool_get_strings(struct net_device *netdev,
0802                     u32 stringset, u8 *data)
0803 {
0804     struct lan743x_adapter *adapter = netdev_priv(netdev);
0805 
0806     switch (stringset) {
0807     case ETH_SS_STATS:
0808         memcpy(data, lan743x_set0_hw_cnt_strings,
0809                sizeof(lan743x_set0_hw_cnt_strings));
0810         memcpy(&data[sizeof(lan743x_set0_hw_cnt_strings)],
0811                lan743x_set1_sw_cnt_strings,
0812                sizeof(lan743x_set1_sw_cnt_strings));
0813         memcpy(&data[sizeof(lan743x_set0_hw_cnt_strings) +
0814                sizeof(lan743x_set1_sw_cnt_strings)],
0815                lan743x_set2_hw_cnt_strings,
0816                sizeof(lan743x_set2_hw_cnt_strings));
0817         if (adapter->is_pci11x1x) {
0818             memcpy(&data[sizeof(lan743x_set0_hw_cnt_strings) +
0819                    sizeof(lan743x_set1_sw_cnt_strings) +
0820                    sizeof(lan743x_set2_hw_cnt_strings)],
0821                    lan743x_tx_queue_cnt_strings,
0822                    sizeof(lan743x_tx_queue_cnt_strings));
0823         }
0824         break;
0825     case ETH_SS_PRIV_FLAGS:
0826         memcpy(data, lan743x_priv_flags_strings,
0827                sizeof(lan743x_priv_flags_strings));
0828         break;
0829     }
0830 }
0831 
0832 static void lan743x_ethtool_get_ethtool_stats(struct net_device *netdev,
0833                           struct ethtool_stats *stats,
0834                           u64 *data)
0835 {
0836     struct lan743x_adapter *adapter = netdev_priv(netdev);
0837     u64 total_queue_count = 0;
0838     int data_index = 0;
0839     u64 pkt_cnt;
0840     u32 buf;
0841     int i;
0842 
0843     for (i = 0; i < ARRAY_SIZE(lan743x_set0_hw_cnt_addr); i++) {
0844         buf = lan743x_csr_read(adapter, lan743x_set0_hw_cnt_addr[i]);
0845         data[data_index++] = (u64)buf;
0846     }
0847     for (i = 0; i < ARRAY_SIZE(adapter->rx); i++)
0848         data[data_index++] = (u64)(adapter->rx[i].frame_count);
0849     for (i = 0; i < ARRAY_SIZE(lan743x_set2_hw_cnt_addr); i++) {
0850         buf = lan743x_csr_read(adapter, lan743x_set2_hw_cnt_addr[i]);
0851         data[data_index++] = (u64)buf;
0852     }
0853     if (adapter->is_pci11x1x) {
0854         for (i = 0; i < ARRAY_SIZE(adapter->tx); i++) {
0855             pkt_cnt = (u64)(adapter->tx[i].frame_count);
0856             data[data_index++] = pkt_cnt;
0857             total_queue_count += pkt_cnt;
0858         }
0859         data[data_index++] = total_queue_count;
0860     }
0861 }
0862 
0863 static u32 lan743x_ethtool_get_priv_flags(struct net_device *netdev)
0864 {
0865     struct lan743x_adapter *adapter = netdev_priv(netdev);
0866 
0867     return adapter->flags;
0868 }
0869 
0870 static int lan743x_ethtool_set_priv_flags(struct net_device *netdev, u32 flags)
0871 {
0872     struct lan743x_adapter *adapter = netdev_priv(netdev);
0873 
0874     adapter->flags = flags;
0875 
0876     return 0;
0877 }
0878 
0879 static int lan743x_ethtool_get_sset_count(struct net_device *netdev, int sset)
0880 {
0881     struct lan743x_adapter *adapter = netdev_priv(netdev);
0882 
0883     switch (sset) {
0884     case ETH_SS_STATS:
0885     {
0886         int ret;
0887 
0888         ret = ARRAY_SIZE(lan743x_set0_hw_cnt_strings);
0889         ret += ARRAY_SIZE(lan743x_set1_sw_cnt_strings);
0890         ret += ARRAY_SIZE(lan743x_set2_hw_cnt_strings);
0891         if (adapter->is_pci11x1x)
0892             ret += ARRAY_SIZE(lan743x_tx_queue_cnt_strings);
0893         return ret;
0894     }
0895     case ETH_SS_PRIV_FLAGS:
0896         return ARRAY_SIZE(lan743x_priv_flags_strings);
0897     default:
0898         return -EOPNOTSUPP;
0899     }
0900 }
0901 
0902 static int lan743x_ethtool_get_rxnfc(struct net_device *netdev,
0903                      struct ethtool_rxnfc *rxnfc,
0904                      u32 *rule_locs)
0905 {
0906     switch (rxnfc->cmd) {
0907     case ETHTOOL_GRXFH:
0908         rxnfc->data = 0;
0909         switch (rxnfc->flow_type) {
0910         case TCP_V4_FLOW:case UDP_V4_FLOW:
0911         case TCP_V6_FLOW:case UDP_V6_FLOW:
0912             rxnfc->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;
0913             fallthrough;
0914         case IPV4_FLOW: case IPV6_FLOW:
0915             rxnfc->data |= RXH_IP_SRC | RXH_IP_DST;
0916             return 0;
0917         }
0918         break;
0919     case ETHTOOL_GRXRINGS:
0920         rxnfc->data = LAN743X_USED_RX_CHANNELS;
0921         return 0;
0922     }
0923     return -EOPNOTSUPP;
0924 }
0925 
0926 static u32 lan743x_ethtool_get_rxfh_key_size(struct net_device *netdev)
0927 {
0928     return 40;
0929 }
0930 
0931 static u32 lan743x_ethtool_get_rxfh_indir_size(struct net_device *netdev)
0932 {
0933     return 128;
0934 }
0935 
0936 static int lan743x_ethtool_get_rxfh(struct net_device *netdev,
0937                     u32 *indir, u8 *key, u8 *hfunc)
0938 {
0939     struct lan743x_adapter *adapter = netdev_priv(netdev);
0940 
0941     if (indir) {
0942         int dw_index;
0943         int byte_index = 0;
0944 
0945         for (dw_index = 0; dw_index < 32; dw_index++) {
0946             u32 four_entries =
0947                 lan743x_csr_read(adapter, RFE_INDX(dw_index));
0948 
0949             byte_index = dw_index << 2;
0950             indir[byte_index + 0] =
0951                 ((four_entries >> 0) & 0x000000FF);
0952             indir[byte_index + 1] =
0953                 ((four_entries >> 8) & 0x000000FF);
0954             indir[byte_index + 2] =
0955                 ((four_entries >> 16) & 0x000000FF);
0956             indir[byte_index + 3] =
0957                 ((four_entries >> 24) & 0x000000FF);
0958         }
0959     }
0960     if (key) {
0961         int dword_index;
0962         int byte_index = 0;
0963 
0964         for (dword_index = 0; dword_index < 10; dword_index++) {
0965             u32 four_entries =
0966                 lan743x_csr_read(adapter,
0967                          RFE_HASH_KEY(dword_index));
0968 
0969             byte_index = dword_index << 2;
0970             key[byte_index + 0] =
0971                 ((four_entries >> 0) & 0x000000FF);
0972             key[byte_index + 1] =
0973                 ((four_entries >> 8) & 0x000000FF);
0974             key[byte_index + 2] =
0975                 ((four_entries >> 16) & 0x000000FF);
0976             key[byte_index + 3] =
0977                 ((four_entries >> 24) & 0x000000FF);
0978         }
0979     }
0980     if (hfunc)
0981         (*hfunc) = ETH_RSS_HASH_TOP;
0982     return 0;
0983 }
0984 
0985 static int lan743x_ethtool_set_rxfh(struct net_device *netdev,
0986                     const u32 *indir, const u8 *key,
0987                     const u8 hfunc)
0988 {
0989     struct lan743x_adapter *adapter = netdev_priv(netdev);
0990 
0991     if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)
0992         return -EOPNOTSUPP;
0993 
0994     if (indir) {
0995         u32 indir_value = 0;
0996         int dword_index = 0;
0997         int byte_index = 0;
0998 
0999         for (dword_index = 0; dword_index < 32; dword_index++) {
1000             byte_index = dword_index << 2;
1001             indir_value =
1002                 (((indir[byte_index + 0] & 0x000000FF) << 0) |
1003                 ((indir[byte_index + 1] & 0x000000FF) << 8) |
1004                 ((indir[byte_index + 2] & 0x000000FF) << 16) |
1005                 ((indir[byte_index + 3] & 0x000000FF) << 24));
1006             lan743x_csr_write(adapter, RFE_INDX(dword_index),
1007                       indir_value);
1008         }
1009     }
1010     if (key) {
1011         int dword_index = 0;
1012         int byte_index = 0;
1013         u32 key_value = 0;
1014 
1015         for (dword_index = 0; dword_index < 10; dword_index++) {
1016             byte_index = dword_index << 2;
1017             key_value =
1018                 ((((u32)(key[byte_index + 0])) << 0) |
1019                 (((u32)(key[byte_index + 1])) << 8) |
1020                 (((u32)(key[byte_index + 2])) << 16) |
1021                 (((u32)(key[byte_index + 3])) << 24));
1022             lan743x_csr_write(adapter, RFE_HASH_KEY(dword_index),
1023                       key_value);
1024         }
1025     }
1026     return 0;
1027 }
1028 
1029 static int lan743x_ethtool_get_ts_info(struct net_device *netdev,
1030                        struct ethtool_ts_info *ts_info)
1031 {
1032     struct lan743x_adapter *adapter = netdev_priv(netdev);
1033 
1034     ts_info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
1035                    SOF_TIMESTAMPING_RX_SOFTWARE |
1036                    SOF_TIMESTAMPING_SOFTWARE |
1037                    SOF_TIMESTAMPING_TX_HARDWARE |
1038                    SOF_TIMESTAMPING_RX_HARDWARE |
1039                    SOF_TIMESTAMPING_RAW_HARDWARE;
1040 
1041     if (adapter->ptp.ptp_clock)
1042         ts_info->phc_index = ptp_clock_index(adapter->ptp.ptp_clock);
1043     else
1044         ts_info->phc_index = -1;
1045 
1046     ts_info->tx_types = BIT(HWTSTAMP_TX_OFF) |
1047                 BIT(HWTSTAMP_TX_ON) |
1048                 BIT(HWTSTAMP_TX_ONESTEP_SYNC);
1049     ts_info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) |
1050                   BIT(HWTSTAMP_FILTER_ALL);
1051     return 0;
1052 }
1053 
1054 static int lan743x_ethtool_get_eee(struct net_device *netdev,
1055                    struct ethtool_eee *eee)
1056 {
1057     struct lan743x_adapter *adapter = netdev_priv(netdev);
1058     struct phy_device *phydev = netdev->phydev;
1059     u32 buf;
1060     int ret;
1061 
1062     if (!phydev)
1063         return -EIO;
1064     if (!phydev->drv) {
1065         netif_err(adapter, drv, adapter->netdev,
1066               "Missing PHY Driver\n");
1067         return -EIO;
1068     }
1069 
1070     ret = phy_ethtool_get_eee(phydev, eee);
1071     if (ret < 0)
1072         return ret;
1073 
1074     buf = lan743x_csr_read(adapter, MAC_CR);
1075     if (buf & MAC_CR_EEE_EN_) {
1076         eee->eee_enabled = true;
1077         eee->eee_active = !!(eee->advertised & eee->lp_advertised);
1078         eee->tx_lpi_enabled = true;
1079         /* EEE_TX_LPI_REQ_DLY & tx_lpi_timer are same uSec unit */
1080         buf = lan743x_csr_read(adapter, MAC_EEE_TX_LPI_REQ_DLY_CNT);
1081         eee->tx_lpi_timer = buf;
1082     } else {
1083         eee->eee_enabled = false;
1084         eee->eee_active = false;
1085         eee->tx_lpi_enabled = false;
1086         eee->tx_lpi_timer = 0;
1087     }
1088 
1089     return 0;
1090 }
1091 
1092 static int lan743x_ethtool_set_eee(struct net_device *netdev,
1093                    struct ethtool_eee *eee)
1094 {
1095     struct lan743x_adapter *adapter;
1096     struct phy_device *phydev;
1097     u32 buf = 0;
1098     int ret = 0;
1099 
1100     if (!netdev)
1101         return -EINVAL;
1102     adapter = netdev_priv(netdev);
1103     if (!adapter)
1104         return -EINVAL;
1105     phydev = netdev->phydev;
1106     if (!phydev)
1107         return -EIO;
1108     if (!phydev->drv) {
1109         netif_err(adapter, drv, adapter->netdev,
1110               "Missing PHY Driver\n");
1111         return -EIO;
1112     }
1113 
1114     if (eee->eee_enabled) {
1115         ret = phy_init_eee(phydev, false);
1116         if (ret) {
1117             netif_err(adapter, drv, adapter->netdev,
1118                   "EEE initialization failed\n");
1119             return ret;
1120         }
1121 
1122         buf = (u32)eee->tx_lpi_timer;
1123         lan743x_csr_write(adapter, MAC_EEE_TX_LPI_REQ_DLY_CNT, buf);
1124 
1125         buf = lan743x_csr_read(adapter, MAC_CR);
1126         buf |= MAC_CR_EEE_EN_;
1127         lan743x_csr_write(adapter, MAC_CR, buf);
1128     } else {
1129         buf = lan743x_csr_read(adapter, MAC_CR);
1130         buf &= ~MAC_CR_EEE_EN_;
1131         lan743x_csr_write(adapter, MAC_CR, buf);
1132     }
1133 
1134     return phy_ethtool_set_eee(phydev, eee);
1135 }
1136 
1137 #ifdef CONFIG_PM
1138 static void lan743x_ethtool_get_wol(struct net_device *netdev,
1139                     struct ethtool_wolinfo *wol)
1140 {
1141     struct lan743x_adapter *adapter = netdev_priv(netdev);
1142 
1143     wol->supported = 0;
1144     wol->wolopts = 0;
1145 
1146     if (netdev->phydev)
1147         phy_ethtool_get_wol(netdev->phydev, wol);
1148 
1149     wol->supported |= WAKE_BCAST | WAKE_UCAST | WAKE_MCAST |
1150         WAKE_MAGIC | WAKE_PHY | WAKE_ARP;
1151 
1152     if (adapter->is_pci11x1x)
1153         wol->supported |= WAKE_MAGICSECURE;
1154 
1155     wol->wolopts |= adapter->wolopts;
1156     if (adapter->wolopts & WAKE_MAGICSECURE)
1157         memcpy(wol->sopass, adapter->sopass, sizeof(wol->sopass));
1158 }
1159 
1160 static int lan743x_ethtool_set_wol(struct net_device *netdev,
1161                    struct ethtool_wolinfo *wol)
1162 {
1163     struct lan743x_adapter *adapter = netdev_priv(netdev);
1164 
1165     adapter->wolopts = 0;
1166     if (wol->wolopts & WAKE_UCAST)
1167         adapter->wolopts |= WAKE_UCAST;
1168     if (wol->wolopts & WAKE_MCAST)
1169         adapter->wolopts |= WAKE_MCAST;
1170     if (wol->wolopts & WAKE_BCAST)
1171         adapter->wolopts |= WAKE_BCAST;
1172     if (wol->wolopts & WAKE_MAGIC)
1173         adapter->wolopts |= WAKE_MAGIC;
1174     if (wol->wolopts & WAKE_PHY)
1175         adapter->wolopts |= WAKE_PHY;
1176     if (wol->wolopts & WAKE_ARP)
1177         adapter->wolopts |= WAKE_ARP;
1178     if (wol->wolopts & WAKE_MAGICSECURE &&
1179         wol->wolopts & WAKE_MAGIC) {
1180         memcpy(adapter->sopass, wol->sopass, sizeof(wol->sopass));
1181         adapter->wolopts |= WAKE_MAGICSECURE;
1182     } else {
1183         memset(adapter->sopass, 0, sizeof(u8) * SOPASS_MAX);
1184     }
1185 
1186     device_set_wakeup_enable(&adapter->pdev->dev, (bool)wol->wolopts);
1187 
1188     return netdev->phydev ? phy_ethtool_set_wol(netdev->phydev, wol)
1189             : -ENETDOWN;
1190 }
1191 #endif /* CONFIG_PM */
1192 
1193 static void lan743x_common_regs(struct net_device *dev,
1194                 struct ethtool_regs *regs, void *p)
1195 
1196 {
1197     struct lan743x_adapter *adapter = netdev_priv(dev);
1198     u32 *rb = p;
1199 
1200     memset(p, 0, (MAX_LAN743X_ETH_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 
1223 static int lan743x_get_regs_len(struct net_device *dev)
1224 {
1225     return MAX_LAN743X_ETH_REGS * sizeof(u32);
1226 }
1227 
1228 static void lan743x_get_regs(struct net_device *dev,
1229                  struct ethtool_regs *regs, void *p)
1230 {
1231     regs->version = LAN743X_ETH_REG_VERSION;
1232 
1233     lan743x_common_regs(dev, regs, p);
1234 }
1235 
1236 const struct ethtool_ops lan743x_ethtool_ops = {
1237     .get_drvinfo = lan743x_ethtool_get_drvinfo,
1238     .get_msglevel = lan743x_ethtool_get_msglevel,
1239     .set_msglevel = lan743x_ethtool_set_msglevel,
1240     .get_link = ethtool_op_get_link,
1241 
1242     .get_eeprom_len = lan743x_ethtool_get_eeprom_len,
1243     .get_eeprom = lan743x_ethtool_get_eeprom,
1244     .set_eeprom = lan743x_ethtool_set_eeprom,
1245     .get_strings = lan743x_ethtool_get_strings,
1246     .get_ethtool_stats = lan743x_ethtool_get_ethtool_stats,
1247     .get_priv_flags = lan743x_ethtool_get_priv_flags,
1248     .set_priv_flags = lan743x_ethtool_set_priv_flags,
1249     .get_sset_count = lan743x_ethtool_get_sset_count,
1250     .get_rxnfc = lan743x_ethtool_get_rxnfc,
1251     .get_rxfh_key_size = lan743x_ethtool_get_rxfh_key_size,
1252     .get_rxfh_indir_size = lan743x_ethtool_get_rxfh_indir_size,
1253     .get_rxfh = lan743x_ethtool_get_rxfh,
1254     .set_rxfh = lan743x_ethtool_set_rxfh,
1255     .get_ts_info = lan743x_ethtool_get_ts_info,
1256     .get_eee = lan743x_ethtool_get_eee,
1257     .set_eee = lan743x_ethtool_set_eee,
1258     .get_link_ksettings = phy_ethtool_get_link_ksettings,
1259     .set_link_ksettings = phy_ethtool_set_link_ksettings,
1260     .get_regs_len = lan743x_get_regs_len,
1261     .get_regs = lan743x_get_regs,
1262 #ifdef CONFIG_PM
1263     .get_wol = lan743x_ethtool_get_wol,
1264     .set_wol = lan743x_ethtool_set_wol,
1265 #endif
1266 };
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!