openEuler/openEuler_kernel_rk3588
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
openEuler_kernel_rk3588/drivers/net/ethernet/mucse/rnp/rnp_sysfs.c
ardu 24cacf092e init
2026-01-29 22:25:33 +08:00

2162 lines
58 KiB
C
Raw Blame History

// SPDX-License-Identifier: GPL-2.0
/* Copyright(c) 2022 - 2023 Mucse Corporation. */
#include <linux/module.h>
#include <linux/types.h>
#include <linux/sysfs.h>
#include <linux/kobject.h>
#include <linux/device.h>
#include <linux/netdevice.h>
#include <linux/hwmon.h>
#include <linux/ctype.h>
#include "rnp.h"
#include "rnp_common.h"
#include "rnp_type.h"
#include "rnp_mbx.h"
#include "rnp_mbx_fw.h"
#define PHY_EXT_REG_FLAG 0x80000000
struct maintain_req {
int magic;
#define MAINTAIN_MAGIC 0xa6a7a8a9
int cmd;
int arg0;
int req_data_bytes;
int reply_bytes;
char data[0];
} __attribute__((packed));
struct ucfg_mac_sn {
unsigned char macaddr[64];
unsigned char sn[32];
int magic;
#define MAC_SN_MAGIC 0x87654321
char rev[52];
unsigned char pn[32];
} __attribute__((packed, aligned(4)));
static int print_desc(char *buf, void *data, int len)
{
u8 *ptr = (u8 *)data;
int ret = 0;
int i = 0;
for (i = 0; i < len; i++)
ret += sprintf(buf + ret, "%02x ", *(ptr + i));
return ret;
}
static ssize_t rnp_hwmon_show_location(struct device __always_unused *dev,
struct device_attribute *attr,
char *buf)
{
struct hwmon_attr *rnp_attr =
container_of(attr, struct hwmon_attr, dev_attr);
return snprintf(buf, PAGE_SIZE, "loc%u\n",
rnp_attr->sensor->location);
}
static ssize_t rnp_hwmon_show_name(struct device __always_unused *dev,
struct device_attribute *attr,
char *buf)
{
return snprintf(buf, PAGE_SIZE, "rnp\n");
}
static ssize_t rnp_hwmon_show_temp(struct device __always_unused *dev,
struct device_attribute *attr,
char *buf)
{
struct hwmon_attr *rnp_attr =
container_of(attr, struct hwmon_attr, dev_attr);
unsigned int value;
/* reset the temp field */
rnp_attr->hw->ops.get_thermal_sensor_data(rnp_attr->hw);
value = rnp_attr->sensor->temp;
/* display millidegree */
value *= 1000;
return snprintf(buf, PAGE_SIZE, "%u\n", value);
}
static ssize_t
rnp_hwmon_show_cautionthresh(struct device __always_unused *dev,
struct device_attribute *attr, char *buf)
{
struct hwmon_attr *rnp_attr =
container_of(attr, struct hwmon_attr, dev_attr);
unsigned int value = rnp_attr->sensor->caution_thresh;
/* display millidegree */
value *= 1000;
return snprintf(buf, PAGE_SIZE, "%u\n", value);
}
static ssize_t
rnp_hwmon_show_maxopthresh(struct device __always_unused *dev,
struct device_attribute *attr, char *buf)
{
struct hwmon_attr *rnp_attr =
container_of(attr, struct hwmon_attr, dev_attr);
unsigned int value = rnp_attr->sensor->max_op_thresh;
/* display millidegree */
value *= 1000;
return snprintf(buf, PAGE_SIZE, "%u\n", value);
}
/**
* rnp_add_hwmon_attr - Create hwmon attr table for a hwmon sysfs file.
* @adapter: pointer to the adapter structure
* @offset: offset in the eeprom sensor data table
* @type: type of sensor data to display
*
* For each file we want in hwmon's sysfs interface we need a
* device_attribute This is included in our hwmon_attr struct that contains
* the references to the data structures we need to get the data to display
*/
static int rnp_add_hwmon_attr(struct rnp_adapter *adapter,
unsigned int offset, int type)
{
unsigned int n_attr;
struct hwmon_attr *rnp_attr;
n_attr = adapter->rnp_hwmon_buff->n_hwmon;
rnp_attr = &adapter->rnp_hwmon_buff->hwmon_list[n_attr];
switch (type) {
case RNP_HWMON_TYPE_LOC:
rnp_attr->dev_attr.show = rnp_hwmon_show_location;
snprintf(rnp_attr->name, sizeof(rnp_attr->name),
"temp%u_label", offset + 1);
break;
case RNP_HWMON_TYPE_NAME:
rnp_attr->dev_attr.show = rnp_hwmon_show_name;
snprintf(rnp_attr->name, sizeof(rnp_attr->name), "name");
break;
case RNP_HWMON_TYPE_TEMP:
rnp_attr->dev_attr.show = rnp_hwmon_show_temp;
snprintf(rnp_attr->name, sizeof(rnp_attr->name),
"temp%u_input", offset + 1);
break;
case RNP_HWMON_TYPE_CAUTION:
rnp_attr->dev_attr.show = rnp_hwmon_show_cautionthresh;
snprintf(rnp_attr->name, sizeof(rnp_attr->name),
"temp%u_max", offset + 1);
break;
case RNP_HWMON_TYPE_MAX:
rnp_attr->dev_attr.show = rnp_hwmon_show_maxopthresh;
snprintf(rnp_attr->name, sizeof(rnp_attr->name),
"temp%u_crit", offset + 1);
break;
default:
return -EPERM;
}
/* These always the same regardless of type */
rnp_attr->sensor = &adapter->hw.thermal_sensor_data.sensor[offset];
rnp_attr->hw = &adapter->hw;
rnp_attr->dev_attr.store = NULL;
rnp_attr->dev_attr.attr.mode = 0444;
rnp_attr->dev_attr.attr.name = rnp_attr->name;
sysfs_attr_init(&rnp_attr->dev_attr.attr);
adapter->rnp_hwmon_buff->attrs[n_attr] = &rnp_attr->dev_attr.attr;
++adapter->rnp_hwmon_buff->n_hwmon;
return 0;
}
#define to_net_device(n) container_of(n, struct net_device, dev)
static ssize_t maintain_read(struct file *filp, struct kobject *kobj,
struct bin_attribute *attr, char *buf,
loff_t off, size_t count)
{
struct device *dev = kobj_to_dev(kobj);
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
int rbytes = count;
if (!adapter->maintain_buf)
return 0;
if (off + count > adapter->maintain_buf_len)
rbytes = adapter->maintain_buf_len - off;
memcpy(buf, adapter->maintain_buf + off, rbytes);
if ((off + rbytes) >= adapter->maintain_buf_len) {
kfree(adapter->maintain_buf);
adapter->maintain_buf = NULL;
adapter->maintain_buf_len = 0;
}
return rbytes;
}
static ssize_t maintain_write(struct file *filp, struct kobject *kobj,
struct bin_attribute *attr, char *buf,
loff_t off, size_t count)
{
struct device *dev = kobj_to_dev(kobj);
int err = -EINVAL;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
struct maintain_req *req;
void *dma_buf = NULL;
dma_addr_t dma_phy;
int bytes;
if (off == 0) {
if (count < sizeof(*req))
return -EINVAL;
req = (struct maintain_req *)buf;
if (req->magic != MAINTAIN_MAGIC)
return -EINVAL;
bytes = max_t(int, req->req_data_bytes, req->reply_bytes);
bytes += sizeof(*req);
/* free no readed buf */
kfree(adapter->maintain_buf);
adapter->maintain_buf = NULL;
adapter->maintain_buf_len = 0;
dma_buf = dma_alloc_coherent(&hw->pdev->dev, bytes,
&dma_phy, GFP_ATOMIC);
if (!dma_buf)
return -ENOMEM;
adapter->maintain_dma_buf = dma_buf;
adapter->maintain_dma_phy = dma_phy;
adapter->maintain_dma_size = bytes;
adapter->maintain_in_bytes =
req->req_data_bytes + sizeof(*req);
memcpy(dma_buf + off, buf, count);
if (count < adapter->maintain_in_bytes)
return count;
}
dma_buf = adapter->maintain_dma_buf;
dma_phy = adapter->maintain_dma_phy;
req = (struct maintain_req *)dma_buf;
memcpy(dma_buf + off, buf, count);
/* all data got, send req */
if ((off + count) >= adapter->maintain_in_bytes) {
int reply_bytes = req->reply_bytes;
/* send req */
err = rnp_maintain_req(hw, req->cmd, req->arg0,
req->req_data_bytes,
req->reply_bytes, dma_phy);
if (err != 0)
goto err_quit;
/* req can't be acces, a copy data for read */
if (reply_bytes > 0) {
adapter->maintain_buf_len = reply_bytes;
adapter->maintain_buf = kmalloc(adapter->maintain_buf_len,
GFP_KERNEL);
if (!adapter->maintain_buf) {
err = -ENOMEM;
goto err_quit;
}
memcpy(adapter->maintain_buf, dma_buf,
reply_bytes);
}
if (dma_buf) {
dma_free_coherent(&hw->pdev->dev,
adapter->maintain_dma_size,
dma_buf, dma_phy);
}
adapter->maintain_dma_buf = NULL;
}
return count;
err_quit:
if (dma_buf) {
dma_free_coherent(&hw->pdev->dev,
adapter->maintain_dma_size, dma_buf,
dma_phy);
adapter->maintain_dma_buf = NULL;
}
return err;
}
static BIN_ATTR(maintain, 0644, maintain_read,
maintain_write, 1 * 1024 * 1024);
static ssize_t rx_desc_info_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
u32 rx_ring_num = adapter->sysfs_rx_ring_num;
u32 rx_desc_num = adapter->sysfs_rx_desc_num;
struct rnp_ring *ring = adapter->rx_ring[rx_ring_num];
int ret = 0;
union rnp_rx_desc *desc;
desc = RNP_RX_DESC(ring, rx_desc_num);
ret += sprintf(buf + ret, "rx ring %d desc %d:\n", rx_ring_num,
rx_desc_num);
ret += print_desc(buf + ret, desc, sizeof(*desc));
ret += sprintf(buf + ret, "\n");
return ret;
}
static ssize_t rx_desc_info_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
int ret = count;
u32 rx_desc_num = adapter->sysfs_rx_desc_num;
u32 rx_ring_num = adapter->sysfs_rx_ring_num;
struct rnp_ring *ring = adapter->rx_ring[rx_ring_num];
if (kstrtou32(buf, 0, &rx_desc_num) != 0)
return -EINVAL;
/* should check tx_ring_num is valid */
if (rx_desc_num < ring->count)
adapter->sysfs_rx_desc_num = rx_desc_num;
else
ret = -EINVAL;
return ret;
}
static ssize_t tcp_sync_info_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
int ret = 0;
if (adapter->priv_flags & RNP_PRIV_FLAG_TCP_SYNC) {
ret += sprintf(buf + ret,
"tcp sync remap on queue %d prio %s\n",
adapter->tcp_sync_queue,
(adapter->priv_flags &
RNP_PRIV_FLAG_TCP_SYNC_PRIO) ?
"NO" :
"OFF");
} else {
ret += sprintf(buf + ret, "tcp sync remap off\n");
}
return ret;
}
static ssize_t tcp_sync_info_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
int ret = count;
u32 tcp_sync_queue;
if (kstrtou32(buf, 0, &tcp_sync_queue) != 0)
return -EINVAL;
if (tcp_sync_queue < adapter->num_rx_queues) {
adapter->tcp_sync_queue = tcp_sync_queue;
adapter->priv_flags |= RNP_PRIV_FLAG_TCP_SYNC;
if (adapter->priv_flags & RNP_PRIV_FLAG_TCP_SYNC_PRIO) {
hw->ops.set_tcp_sync_remapping(hw,
adapter->tcp_sync_queue,
true, true);
} else {
hw->ops.set_tcp_sync_remapping(hw,
adapter->tcp_sync_queue,
true, false);
}
} else {
adapter->priv_flags &= ~RNP_PRIV_FLAG_TCP_SYNC;
hw->ops.set_tcp_sync_remapping(hw, adapter->tcp_sync_queue,
false, false);
}
return ret;
}
static ssize_t rx_skip_info_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
int ret = 0;
if (adapter->priv_flags & RNP_PRIV_FLAG_RX_SKIP_EN)
ret += sprintf(buf + ret, "rx skip bytes: %d\n",
16 * (adapter->priv_skip_count + 1));
else
ret += sprintf(buf + ret, "rx skip off\n");
return ret;
}
static ssize_t rx_skip_info_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
int ret = count;
u32 rx_skip_count;
if (kstrtou32(buf, 0, &rx_skip_count) != 0)
return -EINVAL;
if (rx_skip_count > 0 && rx_skip_count < 17) {
adapter->priv_skip_count = rx_skip_count - 1;
adapter->priv_flags |= RNP_PRIV_FLAG_RX_SKIP_EN;
hw->ops.set_rx_skip(hw, adapter->priv_skip_count, true);
} else {
adapter->priv_flags &= ~RNP_PRIV_FLAG_RX_SKIP_EN;
hw->ops.set_rx_skip(hw, adapter->priv_skip_count, false);
return -EINVAL;
}
return ret;
}
static ssize_t rx_drop_info_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
int ret = 0;
ret += sprintf(buf + ret, "rx_drop_status %llx\n",
adapter->rx_drop_status);
return ret;
}
static ssize_t rx_drop_info_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
int ret = count;
u64 rx_drop_status;
if (kstrtou64(buf, 0, &rx_drop_status) != 0)
return -EINVAL;
adapter->rx_drop_status = rx_drop_status;
hw->ops.update_rx_drop(hw);
return ret;
}
static ssize_t outer_vlan_info_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
int ret = 0;
if (adapter->priv_flags & RNP_PRIV_FLAG_DOUBLE_VLAN)
ret += sprintf(buf + ret, "double vlan on\n");
else
ret += sprintf(buf + ret, "double vlan off\n");
switch (adapter->outer_vlan_type) {
case outer_vlan_type_88a8:
ret += sprintf(buf + ret, "outer vlan 0x88a8\n");
break;
case outer_vlan_type_9100:
ret += sprintf(buf + ret, "outer vlan 0x9100\n");
break;
case outer_vlan_type_9200:
ret += sprintf(buf + ret, "outer vlan 0x9200\n");
break;
default:
ret += sprintf(buf + ret, "outer vlan error\n");
break;
}
return ret;
}
static ssize_t outer_vlan_info_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
int ret = count;
u32 outer_vlan_type;
if (kstrtou32(buf, 0, &outer_vlan_type) != 0)
return -EINVAL;
if (outer_vlan_type < outer_vlan_type_max)
adapter->outer_vlan_type = outer_vlan_type;
else
ret = -EINVAL;
if (hw->ops.set_outer_vlan_type)
hw->ops.set_outer_vlan_type(hw, outer_vlan_type);
return ret;
}
static ssize_t tx_stags_info_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
int ret = 0;
if (adapter->flags2 & RNP_FLAG2_VLAN_STAGS_ENABLED)
ret += sprintf(buf + ret, "tx stags on\n");
else
ret += sprintf(buf + ret, "tx stags off\n");
ret += sprintf(buf + ret, "vid 0x%x\n", adapter->stags_vid);
return ret;
}
static ssize_t tx_stags_info_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
struct rnp_eth_info *eth = &hw->eth;
int ret = count;
u16 tx_stags;
if (kstrtou16(buf, 0, &tx_stags) != 0)
return -EINVAL;
if (tx_stags < VLAN_N_VID)
adapter->stags_vid = tx_stags;
else
ret = -EINVAL;
/* should update vlan filter */
eth->ops.set_vfta(eth, adapter->stags_vid, true);
return ret;
}
static ssize_t tx_desc_info_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
u32 tx_ring_num = adapter->sysfs_tx_ring_num;
u32 tx_desc_num = adapter->sysfs_tx_desc_num;
struct rnp_ring *ring = adapter->tx_ring[tx_ring_num];
int ret = 0;
struct rnp_tx_desc *desc;
desc = RNP_TX_DESC(ring, tx_desc_num);
ret += sprintf(buf + ret, "tx ring %d desc %d:\n", tx_ring_num,
tx_desc_num);
/* print next to watch desc */
ret += print_desc(buf + ret, desc, sizeof(*desc));
ret += sprintf(buf + ret, "\n");
return ret;
}
static ssize_t tx_desc_info_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
int ret = count;
u32 tx_desc_num = adapter->sysfs_tx_desc_num;
u32 tx_ring_num = adapter->sysfs_tx_ring_num;
struct rnp_ring *ring = adapter->tx_ring[tx_ring_num];
if (kstrtou32(buf, 0, &tx_desc_num) != 0)
return -EINVAL;
if (tx_desc_num < ring->count)
adapter->sysfs_tx_desc_num = tx_desc_num;
else
ret = -EINVAL;
return ret;
}
static ssize_t para_info_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
struct rnp_eth_info *eth = &hw->eth;
struct rnp_mac_info *mac = &hw->mac;
ret += sprintf(buf + ret, "nsi_en:%d\n", hw->ncsi_en);
ret += sprintf(buf + ret,
"eth:\n\tmc_filter_type:%u, mcft_size:%u, vft_size:%u,\n",
eth->mc_filter_type, eth->mcft_size, eth->vft_size);
ret += sprintf(buf + ret, "num_rar_entries:%u,\n",
eth->num_rar_entries);
ret += sprintf(buf + ret,
"\trar_highwater:%u, rx_pb_size:%u, max_tx_queues:%u,\n",
eth->rar_highwater, eth->rx_pb_size,
eth->max_tx_queues);
ret += sprintf(buf + ret,
"max_rx_queues:%u,\n",
eth->max_rx_queues);
ret += sprintf(buf + ret,
"\treg_off:%u, orig_autoc:%u, cached_autoc:%u, orig_autoc2:%u\n",
eth->reg_off,
eth->orig_autoc, eth->cached_autoc, eth->orig_autoc2);
ret += sprintf(buf + ret,
"mac:\n\t");
ret += sprintf(buf + ret,
"mc_filter_type:%u mcft_size:%u vft_size:%u num_rar_entries:%u\n",
mac->mc_filter_type, mac->mcft_size, mac->vft_size,
mac->num_rar_entries);
ret += sprintf(buf + ret,
"\trar_highwater:%u rx_pb_size:%u max_tx_queues:%u max_rx_queues:%u\n",
mac->rar_highwater, mac->rx_pb_size, mac->max_tx_queues,
mac->max_rx_queues);
ret += sprintf(buf + ret,
"\treg_off:%u orig_autoc:%u cached_autoc:%u orig_autoc2:%u\n",
mac->reg_off,
mac->orig_autoc, mac->cached_autoc, mac->orig_autoc2);
ret += sprintf(buf + ret,
"orig_link_settings_stored:%u\n",
mac->orig_link_settings_stored);
ret += sprintf(buf + ret,
"\tautotry_restart:%u mac_flags:%u\n",
mac->autotry_restart,
mac->mac_flags);
return ret;
}
static ssize_t rx_ring_info_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
u32 rx_ring_num = adapter->sysfs_rx_ring_num;
struct rnp_ring *ring = adapter->rx_ring[rx_ring_num];
int ret = 0;
union rnp_rx_desc *rx_desc;
ret += sprintf(buf + ret, "queue %d info:\n", rx_ring_num);
ret += sprintf(buf + ret, "next_to_use %d\n", ring->next_to_use);
ret += sprintf(buf + ret, "next_to_clean %d\n",
ring->next_to_clean);
rx_desc = RNP_RX_DESC(ring, ring->next_to_clean);
ret += sprintf(buf + ret, "next_to_clean desc: ");
ret += print_desc(buf + ret, rx_desc, sizeof(*rx_desc));
ret += sprintf(buf + ret, "\n");
return ret;
}
static ssize_t rx_ring_info_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
int ret = count;
u32 rx_ring_num = adapter->sysfs_rx_ring_num;
if (kstrtou32(buf, 0, &rx_ring_num) != 0)
return -EINVAL;
if (rx_ring_num < adapter->num_rx_queues)
adapter->sysfs_rx_ring_num = rx_ring_num;
else
ret = -EINVAL;
return ret;
}
static ssize_t tx_ring_info_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
u32 tx_ring_num = adapter->sysfs_tx_ring_num;
struct rnp_ring *ring = adapter->tx_ring[tx_ring_num];
int ret = 0;
struct rnp_tx_buffer *tx_buffer;
struct rnp_tx_desc *eop_desc;
/* print all tx_ring_num info */
ret += sprintf(buf + ret, "queue %d info:\n", tx_ring_num);
ret += sprintf(buf + ret, "next_to_use %d\n", ring->next_to_use);
ret += sprintf(buf + ret, "next_to_clean %d\n",
ring->next_to_clean);
tx_buffer = &ring->tx_buffer_info[ring->next_to_clean];
eop_desc = tx_buffer->next_to_watch;
/* if have watch desc */
if (eop_desc) {
ret += sprintf(buf + ret, "next_to_watch:\n");
ret += print_desc(buf + ret, eop_desc, sizeof(*eop_desc));
ret += sprintf(buf + ret, "\n");
} else {
ret += sprintf(buf + ret, "no next_to_watch data\n");
}
return ret;
}
static ssize_t tx_ring_info_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
int ret = count;
u32 tx_ring_num = adapter->sysfs_tx_ring_num;
if (kstrtou32(buf, 0, &tx_ring_num) != 0)
return -EINVAL;
if (tx_ring_num < adapter->num_tx_queues)
adapter->sysfs_tx_ring_num = tx_ring_num;
else
ret = -EINVAL;
return ret;
}
static ssize_t queue_mapping_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int ret = 0;
int i;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_ring *ring;
struct rnp_q_vector *q_vector;
ret += sprintf(buf + ret, "tx_queue count %d\n",
adapter->num_tx_queues);
ret += sprintf(buf + ret, "queue-mapping :\n");
for (i = 0; i < adapter->num_tx_queues; i++) {
ring = adapter->tx_ring[i];
ret += sprintf(buf + ret, "tx queue %d <---> ring %d\n", i,
ring->rnp_queue_idx);
}
ret += sprintf(buf + ret, "rx_queue count %d\n",
adapter->num_rx_queues);
ret += sprintf(buf + ret, "queue-mapping :\n");
for (i = 0; i < adapter->num_rx_queues; i++) {
ring = adapter->rx_ring[i];
ret += sprintf(buf + ret, "rx queue %d <---> ring %d\n", i,
ring->rnp_queue_idx);
}
ret += sprintf(buf + ret, "vector-queue mapping:\n");
for (i = 0; i < adapter->num_q_vectors; i++) {
q_vector = adapter->q_vector[i];
ret += sprintf(buf + ret, "---vector %d---\n", i);
rnp_for_each_ring(ring, q_vector->tx) {
ret += sprintf(buf + ret, "tx ring %d\n",
ring->rnp_queue_idx);
}
rnp_for_each_ring(ring, q_vector->rx) {
ret += sprintf(buf + ret, "rx ring %d\n",
ring->rnp_queue_idx);
}
}
return ret;
}
static ssize_t queue_mapping_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
return count;
}
static ssize_t tx_counter_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
u32 val = 0;
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
ret += sprintf(buf + ret, "tx counters\n");
ret += sprintf(buf + ret, "ring0-tx:\n");
val = rd32(hw, RNP_DMA_REG_TX_DESC_BUF_LEN);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"len:", RNP_DMA_REG_TX_DESC_BUF_LEN, val);
val = rd32(hw, RNP_DMA_REG_TX_DESC_BUF_HEAD);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"head:", RNP_DMA_REG_TX_DESC_BUF_HEAD, val);
val = rd32(hw, RNP_DMA_REG_TX_DESC_BUF_TAIL);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"tail:", RNP_DMA_REG_TX_DESC_BUF_TAIL, val);
ret += sprintf(buf + ret, "to_1to4_p1:\n");
val = rd32(hw, RNP_ETH_1TO4_INST0_IN_PKTS);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"emac_in:", RNP_ETH_1TO4_INST0_IN_PKTS, val);
val = rd32(hw, RNP_ETH_IN_0_TX_PKT_NUM(0));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"emac_send:", RNP_ETH_IN_0_TX_PKT_NUM(0), val);
ret += sprintf(buf + ret, "to_1to4_p2:\n");
val = rd32(hw, RNP_ETH_IN_1_TX_PKT_NUM(0));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"sop_pkt:", RNP_ETH_IN_1_TX_PKT_NUM(0), val);
val = rd32(hw, RNP_ETH_IN_2_TX_PKT_NUM(0));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"eop_pkt:", RNP_ETH_IN_2_TX_PKT_NUM(0), val);
val = rd32(hw, RNP_ETH_IN_3_TX_PKT_NUM(0));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"send_terr:", RNP_ETH_IN_3_TX_PKT_NUM(0), val);
ret += sprintf(buf + ret, "to_tx_trans(phy):\n");
val = rd32(hw, RNP_ETH_EMAC_TX_TO_PHY_PKTS(0));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"in:", RNP_ETH_EMAC_TX_TO_PHY_PKTS(0), val);
val = rd32(hw, RNP_ETH_TXTRANS_PTP_PKT_NUM(0));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"out:", RNP_ETH_TXTRANS_PTP_PKT_NUM(0), val);
ret += sprintf(buf + ret, "mac:\n");
val = rd32(hw, 0x1081c);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n", "tx:", 0x1081c,
val);
val = rd32(hw, 0x1087c);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"underflow_err:", 0x1087c, val);
val = rd32(hw, RNP_ETH_TX_DEBUG(0));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"port0_txtrans_sop:", RNP_ETH_TX_DEBUG(0), val);
val = rd32(hw, RNP_ETH_TX_DEBUG(4));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"port0_txtrans_eop:", RNP_ETH_TX_DEBUG(4), val);
val = rd32(hw, RNP_ETH_TX_DEBUG(13));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"tx_empty:", RNP_ETH_TX_DEBUG(13), val);
val = rd32(hw, RNP_ETH_TX_DEBUG(14));
ret += sprintf(buf + ret, "\t %16s 0x%08x: 0x%x\n",
"tx_prog_full:", RNP_ETH_TX_DEBUG(14), val);
val = rd32(hw, RNP_ETH_TX_DEBUG(15));
ret += sprintf(buf + ret, "\t %16s 0x%08x: 0x%x\n",
"tx_full:", RNP_ETH_TX_DEBUG(15), val);
return ret;
}
static DEVICE_ATTR_RO(tx_counter);
static ssize_t rx_counter_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
u32 val = 0, port = 0;
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
ret += sprintf(buf + ret, "rx counters\n");
for (port = 0; port < 4; port++) {
ret += sprintf(buf + ret, "emac_rx_trans (port:%d):\n",
port);
val = rd32(hw, RNP_RXTRANS_RX_PKTS(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"pkts:", RNP_RXTRANS_RX_PKTS(port), val);
val = rd32(hw, RNP_RXTRANS_DROP_PKTS(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"drop:", RNP_RXTRANS_DROP_PKTS(port), val);
val = rd32(hw, RNP_RXTRANS_WDT_ERR_PKTS(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"wdt_err:", RNP_RXTRANS_WDT_ERR_PKTS(port),
val);
val = rd32(hw, RNP_RXTRANS_CODE_ERR_PKTS(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"code_err:", RNP_RXTRANS_CODE_ERR_PKTS(port),
val);
val = rd32(hw, RNP_RXTRANS_CRC_ERR_PKTS(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"crc_err:", RNP_RXTRANS_CRC_ERR_PKTS(port),
val);
val = rd32(hw, RNP_RXTRANS_SLEN_ERR_PKTS(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"slen_err:", RNP_RXTRANS_SLEN_ERR_PKTS(port),
val);
val = rd32(hw, RNP_RXTRANS_GLEN_ERR_PKTS(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"glen_err:", RNP_RXTRANS_GLEN_ERR_PKTS(port),
val);
val = rd32(hw, RNP_RXTRANS_IPH_ERR_PKTS(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"iph_err:", RNP_RXTRANS_IPH_ERR_PKTS(port),
val);
val = rd32(hw, RNP_RXTRANS_CSUM_ERR_PKTS(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"csum_err:", RNP_RXTRANS_CSUM_ERR_PKTS(port),
val);
val = rd32(hw, RNP_RXTRANS_LEN_ERR_PKTS(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"len_err:", RNP_RXTRANS_LEN_ERR_PKTS(port),
val);
val = rd32(hw, RNP_RXTRANS_CUT_ERR_PKTS(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"trans_cut_err:",
RNP_RXTRANS_CUT_ERR_PKTS(port), val);
val = rd32(hw, RNP_RXTRANS_EXCEPT_BYTES(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"expt_byte_err:",
RNP_RXTRANS_EXCEPT_BYTES(port), val);
val = rd32(hw, RNP_RXTRANS_G1600_BYTES_PKTS(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
">1600Byte:",
RNP_RXTRANS_G1600_BYTES_PKTS(port), val);
}
ret += sprintf(buf + ret, "gather:\n");
val = rd32(hw, RNP_ETH_TOTAL_GAT_RX_PKT_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"total_in_pkts:", RNP_ETH_TOTAL_GAT_RX_PKT_NUM,
val);
port = 0;
val = rd32(hw, RNP_ETH_RX_PKT_NUM(port));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"to_nxt_mdodule:", RNP_ETH_RX_PKT_NUM(port), val);
for (port = 0; port < 4; port++) {
u8 pname[16] = { 0 };
val = rd32(hw, RNP_ETH_RX_PKT_NUM(port));
sprintf(pname, "p%d-rx:", port);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n", pname,
RNP_ETH_RX_PKT_NUM(port), val);
}
for (port = 0; port < 4; port++) {
u8 pname[16] = { 0 };
val = rd32(hw, RNP_ETH_RX_DROP_PKT_NUM(port));
sprintf(pname, "p%d-drop:", port);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n", pname,
RNP_ETH_RX_DROP_PKT_NUM(port), val);
}
ret += sprintf(buf + ret, "ip-parse:\n");
val = rd32(hw, RNP_ETH_PKT_EGRESS_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"pkg_egree:", RNP_ETH_PKT_EGRESS_NUM, val);
val = rd32(hw, RNP_ETH_PKT_IP_HDR_LEN_ERR_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"L3_len_err:", RNP_ETH_PKT_IP_HDR_LEN_ERR_NUM, val);
val = rd32(hw, RNP_ETH_PKT_IP_PKT_LEN_ERR_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"ip_hdr_err:", RNP_ETH_PKT_IP_PKT_LEN_ERR_NUM, val);
val = rd32(hw, RNP_ETH_PKT_L3_HDR_CHK_ERR_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"l3-csum-err:", RNP_ETH_PKT_L3_HDR_CHK_ERR_NUM,
val);
val = rd32(hw, RNP_ETH_PKT_L4_HDR_CHK_ERR_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"l4-csum-err:", RNP_ETH_PKT_L4_HDR_CHK_ERR_NUM,
val);
val = rd32(hw, RNP_ETH_PKT_SCTP_CHK_ERR_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"sctp-err:", RNP_ETH_PKT_SCTP_CHK_ERR_NUM, val);
val = rd32(hw, RNP_ETH_PKT_VLAN_ERR_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"vlan-err:", RNP_ETH_PKT_VLAN_ERR_NUM, val);
val = rd32(hw, RNP_ETH_PKT_EXCEPT_SHORT_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"except_short_num:", RNP_ETH_PKT_EXCEPT_SHORT_NUM,
val);
val = rd32(hw, RNP_ETH_PKT_PTP_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"ptp:", RNP_ETH_PKT_PTP_NUM, val);
ret += sprintf(buf + ret, "to-indecap:\n");
val = rd32(hw, RNP_ETH_DECAP_PKT_IN_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"*in engin*:", RNP_ETH_DECAP_PKT_IN_NUM, val);
val = rd32(hw, RNP_ETH_DECAP_PKT_OUT_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"*out engin*:", RNP_ETH_DECAP_PKT_OUT_NUM, val);
val = rd32(hw, RNP_ETH_DECAP_DMAC_OUT_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"to-dma/host:", RNP_ETH_DECAP_DMAC_OUT_NUM, val);
val = rd32(hw, RNP_ETH_DECAP_BMC_OUT_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"to-bmc:", RNP_ETH_DECAP_BMC_OUT_NUM, val);
val = rd32(hw, RNP_ETH_DECAP_SW_OUT_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"to-switch:", RNP_ETH_DECAP_SW_OUT_NUM, val);
val = rd32(hw, RNP_ETH_DECAP_MIRROR_OUT_NUM);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"bmc+host:", RNP_ETH_DECAP_MIRROR_OUT_NUM, val);
val = rd32(hw, RNP_ETH_DECAP_PKT_DROP_NUM(0x0));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"err_drop:", RNP_ETH_DECAP_PKT_DROP_NUM(0x0), val);
val = rd32(hw, RNP_ETH_DECAP_PKT_DROP_NUM(1));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"plicy_drop:", RNP_ETH_DECAP_PKT_DROP_NUM(1), val);
val = rd32(hw, RNP_ETH_DECAP_PKT_DROP_NUM(2));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"dmac_drop:", RNP_ETH_DECAP_PKT_DROP_NUM(2), val);
val = rd32(hw, RNP_ETH_DECAP_PKT_DROP_NUM(3));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"bmc_drop:", RNP_ETH_DECAP_PKT_DROP_NUM(3), val);
val = rd32(hw, RNP_ETH_DECAP_PKT_DROP_NUM(4));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"sw_drop:", RNP_ETH_DECAP_PKT_DROP_NUM(4), val);
val = rd32(hw, RNP_ETH_DECAP_PKT_DROP_NUM(5));
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"rm_vlane_num:", RNP_ETH_DECAP_PKT_DROP_NUM(5),
val);
ret += sprintf(buf + ret, "dma-2-host:\n");
val = rd32(hw, 0x264);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"fifo equ:", 0x264, val);
val = rd32(hw, 0x268);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"fifo deq:", 0x268, val);
val = rd32(hw, 0x114);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"unexpt_abtring:", 0x114, val);
val = rd32(hw, 0x288);
ret += sprintf(buf + ret, "\t %16s 0x%08x: %d\n",
"pci2host:", 0x288, val);
for (port = 0; port < 4; port++) {
ret += sprintf(buf + ret, "rx-ring%d:\n", port);
val = rd32(hw, RNP_DMA_REG_RX_DESC_BUF_HEAD);
ret += sprintf(buf + ret, "\t %16s 0x%08x: 0x%x\n",
"head:", RNP_DMA_REG_RX_DESC_BUF_HEAD, val);
val = rd32(hw, RNP_DMA_REG_RX_DESC_BUF_TAIL);
ret += sprintf(buf + ret, "\t %16s 0x%08x: 0x%x\n",
"tail:", RNP_DMA_REG_RX_DESC_BUF_TAIL, val);
val = rd32(hw, RNP_DMA_REG_RX_DESC_BUF_LEN);
ret += sprintf(buf + ret, "\t %16s 0x%08x: 0x%x\n",
"len:", RNP_DMA_REG_RX_DESC_BUF_LEN, val);
}
return ret;
}
static DEVICE_ATTR_RO(rx_counter);
static ssize_t active_vid_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
u16 vid;
u16 current_vid = 0;
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
u8 vfnum = hw->max_vfs - 1;
if ((adapter->flags & RNP_FLAG_SRIOV_ENABLED)) {
current_vid = rd32(hw,
RNP_DMA_PORT_VEB_VID_TBL(adapter->port,
vfnum));
}
for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID) {
ret += sprintf(buf + ret, "%u%s ", vid,
(current_vid == vid ? "*" : ""));
}
ret += sprintf(buf + ret, "\n");
return ret;
}
static ssize_t active_vid_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
u16 vid;
int err = -EINVAL;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
u8 vfnum = hw->max_vfs - 1;
int port = 0;
if (!(adapter->flags & RNP_FLAG_SRIOV_ENABLED))
return -EIO;
if (kstrtou16(buf, 0, &vid) != 0)
return -EINVAL;
if (vid < 4096 && test_bit(vid, adapter->active_vlans)) {
if (rd32(hw, RNP_DMA_VERSION) >= 0x20201231) {
for (port = 0; port < 4; port++)
wr32(hw,
RNP_DMA_PORT_VEB_VID_TBL(port, vfnum),
vid);
} else {
wr32(hw, RNP_DMA_PORT_VEB_VID_TBL(adapter->port,
vfnum), vid);
}
err = 0;
}
return err ? err : count;
}
static inline int pn_sn_dlen(char *v, int v_len)
{
int i, len = 0;
for (i = 0; i < v_len; i++) {
if (isascii(v[i]))
len++;
else
break;
}
return len;
}
static int rnp_mbx_get_pn_sn(struct rnp_hw *hw, char pn[33], char sn[33])
{
struct maintain_req *req;
void *dma_buf = NULL;
dma_addr_t dma_phy;
struct ucfg_mac_sn *cfg;
int err = 0,
bytes = sizeof(*req) + sizeof(struct ucfg_mac_sn);
memset(pn, 0, 33);
memset(sn, 0, 33);
dma_buf = dma_alloc_coherent(&hw->pdev->dev, bytes, &dma_phy,
GFP_KERNEL);
if (!dma_buf)
return -ENOMEM;
req = (struct maintain_req *)dma_buf;
memset(dma_buf, 0, bytes);
cfg = (struct ucfg_mac_sn *)(req + 1);
req->magic = MAINTAIN_MAGIC;
req->cmd = 0;
req->arg0 = 3;
req->req_data_bytes = 0;
req->reply_bytes = bytes - sizeof(*req);
err = rnp_maintain_req(hw, req->cmd, req->arg0,
req->req_data_bytes, req->reply_bytes,
dma_phy);
if (err != 0)
goto err_quit;
if (cfg->magic == MAC_SN_MAGIC) {
int sz = pn_sn_dlen(cfg->pn, 32);
if (sz) {
memcpy(pn, cfg->pn, sz);
pn[sz] = 0;
}
sz = pn_sn_dlen(cfg->sn, 32);
if (sz) {
memcpy(sn, cfg->sn, sz);
sn[sz] = 0;
}
}
err_quit:
if (dma_buf)
dma_free_coherent(&hw->pdev->dev, bytes, dma_buf, dma_phy);
return 0;
}
static ssize_t own_vpd_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
char pn[33] = { 0 }, sn[33] = { 0 };
rnp_mbx_get_pn_sn(hw, pn, sn);
ret += sprintf(buf + ret, "Product Name: %s\n",
"N10 Series for 10GbE or 40GbE (Dual-port)");
ret += sprintf(buf + ret, "[PN] Part number: %s\n", pn);
ret += sprintf(buf + ret, "[SN] Serial number: %s\n", sn);
return ret;
}
static DEVICE_ATTR_RO(own_vpd);
static ssize_t port_idx_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
ret += sprintf(buf, "%d\n", adapter->portid_of_card);
return ret;
}
static DEVICE_ATTR_RO(port_idx);
static ssize_t debug_linkstat_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
ret += sprintf(buf, "%d %d dumy:0x%x up-flag:%d carry:%d\n",
adapter->link_up, adapter->hw.link, rd32(hw, 0xc),
adapter->flags & RNP_FLAG_NEED_LINK_UPDATE,
netif_carrier_ok(netdev));
return ret;
}
static DEVICE_ATTR_RO(debug_linkstat);
static ssize_t sfp_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
if (rnp_mbx_get_lane_stat(hw) != 0) {
ret += sprintf(buf, " IO Error\n");
} else {
ret += sprintf(buf,
"mod-abs:%d\ntx-fault:%d\ntx-dis:%d\nrx-los:%d\n",
adapter->sfp.mod_abs, adapter->sfp.fault,
adapter->sfp.tx_dis, adapter->sfp.los);
}
return ret;
}
static DEVICE_ATTR_RO(sfp);
static ssize_t pci_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
int err = -EINVAL;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
int gen = 3, lanes = 8;
if (count > 30)
return -EINVAL;
if (sscanf(buf, "gen%dx%d", &gen, &lanes) != 2)
return -EINVAL;
if (gen > 3 || lanes > 8)
return -EINVAL;
err = rnp_set_lane_fun(hw, LANE_FUN_PCI_LANE, gen, lanes, 0, 0);
return err ? err : count;
}
static ssize_t pci_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
if (rnp_mbx_get_lane_stat(hw) != 0) {
ret += sprintf(buf, " IO Error\n");
} else {
ret += sprintf(buf, "gen%dx%d\n", hw->pci_gen,
hw->pci_lanes);
}
return ret;
}
static DEVICE_ATTR_RW(pci);
static ssize_t sfp_tx_disable_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int err = -EINVAL;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
long enable = 0;
if (kstrtol(buf, 10, &enable))
return -EINVAL;
err = rnp_set_lane_fun(hw, LANE_FUN_SFP_TX_DISABLE, !!enable, 0, 0,
0);
return err ? err : count;
}
static ssize_t sfp_tx_disable_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
if (rnp_mbx_get_lane_stat(hw) != 0)
ret += sprintf(buf, " IO Error\n");
else
ret += sprintf(buf, "%d\n", adapter->sfp.tx_dis);
return ret;
}
static DEVICE_ATTR_RW(sfp_tx_disable);
static ssize_t link_traing_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int err = -EINVAL;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
long enable = 0;
if (kstrtol(buf, 10, &enable))
return -EINVAL;
err = rnp_set_lane_fun(hw, LANE_FUN_LINK_TRAING, !!enable, 0, 0,
0);
return err ? err : count;
}
static ssize_t link_traing_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
if (rnp_mbx_get_lane_stat(hw) != 0)
ret += sprintf(buf, " IO Error\n");
else
ret += sprintf(buf, "%d\n", adapter->link_traing);
return ret;
}
static DEVICE_ATTR_RW(link_traing);
static ssize_t fec_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
int err = -EINVAL;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
long enable = 0;
if (kstrtol(buf, 10, &enable))
return -EINVAL;
err = rnp_set_lane_fun(hw, LANE_FUN_FEC, !!enable, 0, 0, 0);
return err ? err : count;
}
static ssize_t fec_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
if (rnp_mbx_get_lane_stat(hw) != 0)
ret += sprintf(buf, " IO Error\n");
else
ret += sprintf(buf, "%d\n", adapter->fec);
return ret;
}
static DEVICE_ATTR_RW(fec);
/* write pcs reg: echo "<lane> <pcs_reg> <val>" > pcs_reg */
/* read pcs reg: echo "<lane> <pcs_reg>" > pcs_reg */
static ssize_t pcs_reg_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
u32 reg_hi = 0, reg_lo = 0, pcs_base_regs = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
int input_arg_cnt;
u32 pcs_phy_regs[] = {
0x00040000, 0x00041000, 0x00042000, 0x00043000,
0x00040000, 0x00041000, 0x00042000, 0x00043000,
};
if (count > 64) {
e_err(drv, "Error: Input size >100: too large\n");
return -EINVAL;
}
input_arg_cnt = sscanf(buf, "%u %x %x",
&adapter->sysfs_pcs_lane_num,
&adapter->sysfs_bar4_reg_addr,
&adapter->sysfs_bar4_reg_val);
if (input_arg_cnt != 2 && input_arg_cnt != 3) {
e_err(drv, "Error: Invalid Input: read lane x reg 0xXXX or write phy x reg");
e_err(drv, "0xXXX val 0xXXX\n");
return -EINVAL;
}
if (adapter->sysfs_pcs_lane_num > 8) {
e_err(drv, "Error: Invalid value. should in 0~7\n");
return -EINVAL;
}
switch (input_arg_cnt) {
case 2:
reg_hi = adapter->sysfs_bar4_reg_addr >> 8;
reg_lo = (adapter->sysfs_bar4_reg_addr & 0xff) << 2;
pcs_base_regs = pcs_phy_regs[adapter->sysfs_pcs_lane_num];
wr32(hw, pcs_base_regs + (0xff << 2), reg_hi);
adapter->sysfs_bar4_reg_val =
rd32(hw, pcs_base_regs + reg_lo);
break;
case 3:
reg_hi = adapter->sysfs_bar4_reg_addr >> 8;
reg_lo = (adapter->sysfs_bar4_reg_addr & 0xff) << 2;
pcs_base_regs = pcs_phy_regs[adapter->sysfs_pcs_lane_num];
wr32(hw, pcs_base_regs + (0xff << 2), reg_hi);
wr32(hw, pcs_base_regs + reg_lo,
adapter->sysfs_bar4_reg_val);
break;
default:
e_err(drv, "Error: Invalid value. input_arg_cnt=%d\n",
input_arg_cnt);
break;
}
adapter->sysfs_input_arg_cnt = input_arg_cnt;
return count;
}
static ssize_t pcs_reg_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
switch (adapter->sysfs_input_arg_cnt) {
case 2:
ret += sprintf(buf, "lane%u pcs: 0x%x => 0x%x\n",
adapter->sysfs_pcs_lane_num,
adapter->sysfs_bar4_reg_addr,
adapter->sysfs_bar4_reg_val);
break;
case 3:
ret += sprintf(buf, "lane%u pcs: 0x%x <= 0x%x\n",
adapter->sysfs_pcs_lane_num,
adapter->sysfs_bar4_reg_addr,
adapter->sysfs_bar4_reg_val);
break;
default:
e_err(drv, "Error: Invalid input_arg_cnt value =%d\n",
adapter->sysfs_input_arg_cnt);
break;
}
return ret;
}
static DEVICE_ATTR_RW(pcs_reg);
static ssize_t phy_reg_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
int val = 0;
int err = -EINVAL;
int phy_reg = adapter->sysfs_phy_reg;
if (hw) {
if (adapter->sysfs_is_phy_ext_reg) {
err = rnp_mbx_phy_read(hw,
phy_reg |
PHY_EXT_REG_FLAG,
&val);
} else {
err = rnp_mbx_phy_read(hw, phy_reg, &val);
}
}
if (err) {
return 0;
} else {
return sprintf(buf, "phy %s 0x%04x : 0x%04x\n",
adapter->sysfs_is_phy_ext_reg ? "ext reg" :
"reg",
phy_reg, val & 0xffff);
}
}
static ssize_t phy_reg_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int i = 0, argc = 0, err = -EINVAL;
char argv[3][16];
unsigned long val[3] = { 0 };
int phy_reg = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
memset(argv, 0, sizeof(argv));
argc = sscanf(buf, "%15s %15s %15s", argv[0], argv[1], argv[2]);
if (argc < 1)
return -EINVAL;
adapter->sysfs_is_phy_ext_reg = 0;
if (strcmp(argv[0], "ext") == 0) {
adapter->sysfs_is_phy_ext_reg = 1;
} else {
if (kstrtoul(argv[0], 0, &val[0]))
return -EINVAL;
}
for (i = 1; i < argc; i++) {
if (kstrtoul(argv[i], 0, &val[i]))
return -EINVAL;
}
if (argc == 1) {
if (adapter->sysfs_is_phy_ext_reg)
return -EINVAL;
/* set phy reg index */
phy_reg = val[0];
err = 0;
}
if (argc == 2) {
if (adapter->sysfs_is_phy_ext_reg) {
/* set ext phy reg index */
phy_reg = val[1];
err = 0;
} else {
/* write phy reg */
phy_reg = val[0];
err = rnp_mbx_phy_write(hw, phy_reg, val[1]);
}
}
if (argc == 3) {
if (adapter->sysfs_is_phy_ext_reg) {
/* write ext phy reg */
phy_reg = val[1];
err = rnp_mbx_phy_write(hw,
phy_reg |
PHY_EXT_REG_FLAG,
val[2]);
} else {
return -EINVAL;
}
}
adapter->sysfs_phy_reg = phy_reg;
return err ? err : count;
}
static DEVICE_ATTR_RW(phy_reg);
static ssize_t prbs_store(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t count)
{
int err = -EINVAL;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
long prbs = 0;
if (kstrtol(buf, 10, &prbs))
return -EINVAL;
err = rnp_set_lane_fun(hw, LANE_FUN_PRBS, prbs, 0, 0, 0);
return err ? err : count;
}
static DEVICE_ATTR_WO(prbs);
static ssize_t autoneg_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int err = -EINVAL;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
long enable = 0;
if (kstrtol(buf, 10, &enable))
return -EINVAL;
err = rnp_set_lane_fun(hw, LANE_FUN_AN, !!enable, 0, 0, 0);
return err ? err : count;
}
static ssize_t autoneg_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int ret = 0;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
if (rnp_mbx_get_lane_stat(hw) != 0)
ret += sprintf(buf, " IO Error\n");
else
ret += sprintf(buf, "%d\n", adapter->an);
return ret;
}
static DEVICE_ATTR_RW(autoneg);
static ssize_t si_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int err = -EINVAL;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
int si_main = -1, si_pre = -1, si_post = -1, si_txboost = -1;
int cnt;
if (rnp_mbx_get_lane_stat(hw) != 0) {
e_err(drv, "Error: rnp_mbx_get_lane_stat failed\n");
return -EIO;
}
if (count > 100) {
e_err(drv, "Error: Input size >100: too large\n");
return -EINVAL;
}
if (hw->supported_link &
(RNP_LINK_SPEED_40GB_FULL | RNP_LINK_SPEED_25GB_FULL)) {
u32 lane0_main, lane0_pre, lane0_post, lane0_boost;
u32 lane1_main, lane1_pre, lane1_post, lane1_boost;
u32 lane2_main, lane2_pre, lane2_post, lane2_boost;
u32 lane3_main, lane3_pre, lane3_post, lane3_boost;
cnt = sscanf(buf,
"%u %u %u %u,%u %u %u %u,%u %u %u %u,%u %u %u %u",
&lane0_main, &lane0_pre, &lane0_post, &lane0_boost,
&lane1_main, &lane1_pre, &lane1_post, &lane1_boost,
&lane2_main, &lane2_pre, &lane2_post, &lane2_boost,
&lane3_main, &lane3_pre, &lane3_post,
&lane3_boost);
if (cnt != 16) {
e_err(drv, "Error: Invalid Input.\n");
e_err(drv, " <lane0_si>,<lane1_si>,<lane2_si>,<lane3_si>\n");
e_err(drv, " laneX_si: <main> <pre> <post> <boost>\n\n");
e_err(drv, " ie: 21 0 11 11,22 0 12 12,23 0 13 13,24 0 14 14\n");
return -EINVAL;
}
si_main = ((lane0_main & 0xff) << 0) |
((lane1_main & 0xff) << 8) |
((lane2_main & 0xff) << 16) |
((lane3_main & 0xff) << 24);
si_pre = ((lane0_pre & 0xff) << 0) |
((lane1_pre & 0xff) << 8) |
((lane2_pre & 0xff) << 16) |
((lane3_pre & 0xff) << 24);
si_post = ((lane0_post & 0xff) << 0) |
((lane1_post & 0xff) << 8) |
((lane2_post & 0xff) << 16) |
((lane3_post & 0xff) << 24);
si_txboost = ((lane0_boost & 0xf) << 0) |
((lane1_boost & 0xf) << 4) |
((lane2_boost & 0xf) << 8) |
((lane3_boost & 0xf) << 12);
pr_info("%s: main:0x%x pre:0x%x post:0x%x boost:0x%x\n",
adapter->name, si_main, si_pre, si_post,
si_txboost);
} else {
cnt = sscanf(buf, "%u %u %u %u", &si_main, &si_pre,
&si_post, &si_txboost);
if (cnt != 4) {
e_err(drv, "Error: Invalid Input: <main> <pre> <post> <tx_boost>\n");
return -EINVAL;
}
if (si_main > 63 || si_pre > 63 || si_post > 63) {
e_err(drv, "Error: Invalid value. should in 0~63\n");
return -EINVAL;
}
if (si_txboost > 16) {
e_err(drv, "Error: Invalid txboost. should in 0~15\n");
return -EINVAL;
}
}
err = rnp_set_lane_fun(hw, LANE_FUN_SI, si_main, si_pre, si_post,
si_txboost);
return err ? err : count;
}
static ssize_t si_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
int ret = 0, i;
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
if (rnp_mbx_get_lane_stat(hw) != 0) {
ret += sprintf(buf, " IO Error\n");
} else {
if (hw->supported_link & (RNP_LINK_SPEED_40GB_FULL |
RNP_LINK_SPEED_25GB_FULL)) {
ret += sprintf(buf + ret,
"main:0x%08x pre:0x%08x post:0x%08x tx_boost:0x%04x\n\n",
adapter->si.main, adapter->si.pre,
adapter->si.post, adapter->si.tx_boost);
for (i = 0; i < 4; i++) {
ret += sprintf(buf + ret,
"lane%d main:%u pre:%u post:%u tx_boost:%u\n",
i,
(adapter->si.main >> (i * 8)) &
0xff,
(adapter->si.pre >> (i * 8)) &
0xff,
(adapter->si.post >> (i * 8)) &
0xff,
(adapter->si.tx_boost >> (i * 4)) &
0xf);
}
} else {
ret += sprintf(buf + ret,
"lane:%d main:%u pre:%u post:%u tx_boost:%u\n",
hw->nr_lane, adapter->si.main,
adapter->si.pre, adapter->si.post,
adapter->si.tx_boost & 0xf);
}
}
return ret;
}
static DEVICE_ATTR_RW(si);
static ssize_t temperature_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
struct rnp_hw *hw = &adapter->hw;
int ret = 0, temp = 0, voltage = 0;
temp = rnp_mbx_get_temp(hw, &voltage);
ret += sprintf(buf, "temp:%d oC volatage:%d mV\n", temp, voltage);
return ret;
}
static struct pci_dev *pcie_find_root_port_old(struct pci_dev *dev)
{
while (1) {
if (!pci_is_pcie(dev))
break;
if (pci_pcie_type(dev) == PCI_EXP_TYPE_ROOT_PORT)
return dev;
if (!dev->bus->self)
break;
dev = dev->bus->self;
}
return NULL;
}
static ssize_t root_slot_info_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct net_device *netdev = to_net_device(dev);
struct rnp_adapter *adapter = netdev_priv(netdev);
int ret = 0;
struct pci_dev *root_pdev = pcie_find_root_port_old(adapter->pdev);
if (root_pdev) {
ret += sprintf(buf + ret, "%02x:%02x.%x\n",
root_pdev->bus->number,
PCI_SLOT(root_pdev->devfn),
PCI_FUNC(root_pdev->devfn));
}
return ret;
}
static int do_switch_loopback_set(struct rnp_adapter *adapter, int en,
int sport_lane, int dport_lane)
{
int v;
struct rnp_hw *hw = &adapter->hw;
pr_info("%s: %s %d -> %d en:%d\n", __func__,
netdev_name(adapter->netdev), sport_lane, dport_lane, en);
if (en)
adapter->flags |= RNP_FLAG_SWITCH_LOOPBACK_EN;
else
adapter->flags &= ~RNP_FLAG_SWITCH_LOOPBACK_EN;
/* redir pkgs to peer */
wr32(hw, RNP_ETH_INPORT_POLICY_REG(sport_lane),
BIT(29) | (dport_lane << 16));
/* enable/disable policy */
v = rd32(hw, RNP_ETH_INPORT_POLICY_VAL);
/* enable this-port-policy */
if (en)
v |= BIT(sport_lane);
else
v &= ~BIT(sport_lane);
wr32(hw, RNP_ETH_INPORT_POLICY_VAL, v);
/* mac promisc */
v = mac_rd32(&hw->mac, RNP10_MAC_PKT_FLT);
if (en)
v |= (RNP_RX_ALL | RNP_RX_ALL_MUL);
else
v &= ~(RNP_RX_ALL | RNP_RX_ALL_MUL);
mac_wr32(&hw->mac, RNP10_MAC_PKT_FLT, v);
/* disable unicase-table */
eth_wr32(&hw->eth, RNP10_ETH_DMAC_MCSTCTRL, 0x0);
return 0;
}
static ssize_t _switch_loopback(struct rnp_adapter *adapter,
const char *peer_eth, int en)
{
struct net_device *peer_netdev = NULL;
struct rnp_adapter *peer_adapter = NULL;
char name[100];
strscpy(name, peer_eth, sizeof(name));
strim(name);
pr_info("%s: nr_lane:%d peer_lane:%s en:%d\n", __func__, 0,
peer_eth, en);
peer_netdev = dev_get_by_name(&init_net, name);
if (!peer_netdev) {
e_err(drv, "canot' find %s\n", name);
return -EINVAL;
}
peer_adapter = netdev_priv(peer_netdev);
if (PCI_SLOT(peer_adapter->pdev->devfn) !=
PCI_SLOT(adapter->pdev->devfn)) {
e_err(drv, "%s %s not in same slot\n",
netdev_name(adapter->netdev),
netdev_name(peer_adapter->netdev));
dev_put(peer_netdev);
return -EINVAL;
}
do_switch_loopback_set(adapter, en, 0,
rnp_is_pf1(&peer_adapter->hw) ? 4 : 0);
do_switch_loopback_set(peer_adapter, en, 0,
rnp_is_pf1(&adapter->hw) ? 4 : 0);
if (peer_netdev)
dev_put(peer_netdev);
return 0;
}
static ssize_t switch_loopback_on_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct rnp_adapter *adapter = netdev_priv(to_net_device(dev));
return _switch_loopback(adapter, buf, 1) == 0 ? count : -EINVAL;
}
static DEVICE_ATTR_WO(switch_loopback_on);
static ssize_t switch_loopback_off_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct rnp_adapter *adapter = netdev_priv(to_net_device(dev));
return _switch_loopback(adapter, buf, 0) == 0 ? count : -EINVAL;
}
static DEVICE_ATTR_WO(switch_loopback_off);
static DEVICE_ATTR_RO(root_slot_info);
static DEVICE_ATTR_RO(temperature);
static DEVICE_ATTR_RW(active_vid);
static DEVICE_ATTR_RW(queue_mapping);
static DEVICE_ATTR_RW(tx_ring_info);
static DEVICE_ATTR_RW(rx_ring_info);
static DEVICE_ATTR_RO(para_info);
static DEVICE_ATTR_RW(tx_desc_info);
static DEVICE_ATTR_RW(rx_desc_info);
static DEVICE_ATTR_RW(rx_drop_info);
static DEVICE_ATTR_RW(outer_vlan_info);
static DEVICE_ATTR_RW(tcp_sync_info);
static DEVICE_ATTR_RW(rx_skip_info);
static DEVICE_ATTR_RW(tx_stags_info);
static struct attribute *dev_attrs[] = {
&dev_attr_tx_stags_info.attr,
&dev_attr_root_slot_info.attr,
&dev_attr_active_vid.attr,
&dev_attr_queue_mapping.attr,
&dev_attr_rx_drop_info.attr,
&dev_attr_outer_vlan_info.attr,
&dev_attr_tcp_sync_info.attr,
&dev_attr_rx_skip_info.attr,
&dev_attr_tx_ring_info.attr,
&dev_attr_rx_ring_info.attr,
&dev_attr_para_info.attr,
&dev_attr_tx_desc_info.attr,
&dev_attr_rx_desc_info.attr,
&dev_attr_tx_counter.attr,
&dev_attr_rx_counter.attr,
&dev_attr_own_vpd.attr,
&dev_attr_port_idx.attr,
&dev_attr_temperature.attr,
&dev_attr_si.attr,
&dev_attr_sfp.attr,
&dev_attr_autoneg.attr,
&dev_attr_sfp_tx_disable.attr,
&dev_attr_fec.attr,
&dev_attr_link_traing.attr,
&dev_attr_pci.attr,
&dev_attr_prbs.attr,
&dev_attr_pcs_reg.attr,
&dev_attr_phy_reg.attr,
&dev_attr_debug_linkstat.attr,
&dev_attr_switch_loopback_off.attr,
&dev_attr_switch_loopback_on.attr,
NULL,
};
static struct bin_attribute *dev_bin_attrs[] = {
&bin_attr_maintain,
NULL,
};
static struct attribute_group dev_attr_grp = {
.attrs = dev_attrs,
.bin_attrs = dev_bin_attrs,
};
static void
rnp_sysfs_del_adapter(struct rnp_adapter __maybe_unused *adapter)
{
}
/* called from rnp_main.c */
void rnp_sysfs_exit(struct rnp_adapter *adapter)
{
rnp_sysfs_del_adapter(adapter);
sysfs_remove_group(&adapter->netdev->dev.kobj, &dev_attr_grp);
}
/* called from rnp_main.c */
int rnp_sysfs_init(struct rnp_adapter *adapter)
{
int rc = 0;
int flag;
struct hwmon_buff *rnp_hwmon;
struct device *hwmon_dev;
unsigned int i;
flag = sysfs_create_group(&adapter->netdev->dev.kobj,
&dev_attr_grp);
if (flag != 0) {
dev_err(&adapter->netdev->dev,
"sysfs_create_group failed:flag:%d\n", flag);
return flag;
}
/* If this method isn't defined we don't support thermals */
if (!adapter->hw.ops.init_thermal_sensor_thresh)
goto no_thermal;
/* Don't create thermal hwmon interface if no sensors present */
if (adapter->hw.ops.init_thermal_sensor_thresh(&adapter->hw))
goto no_thermal;
rnp_hwmon = devm_kzalloc(&adapter->pdev->dev, sizeof(*rnp_hwmon),
GFP_KERNEL);
if (!rnp_hwmon) {
rc = -ENOMEM;
goto exit;
}
adapter->rnp_hwmon_buff = rnp_hwmon;
for (i = 0; i < RNP_MAX_SENSORS; i++) {
/* Only create hwmon sysfs entries for sensors that have
* meaningful data for.
*/
if (adapter->hw.thermal_sensor_data.sensor[i].location ==
0)
continue;
/* Bail if any hwmon attr struct fails to initialize */
rc = rnp_add_hwmon_attr(adapter, i,
RNP_HWMON_TYPE_CAUTION);
if (rc)
goto err;
rc = rnp_add_hwmon_attr(adapter, i, RNP_HWMON_TYPE_LOC);
if (rc)
goto err;
rc = rnp_add_hwmon_attr(adapter, i, RNP_HWMON_TYPE_TEMP);
if (rc)
goto err;
rc = rnp_add_hwmon_attr(adapter, i, RNP_HWMON_TYPE_MAX);
if (rc)
goto err;
}
rnp_hwmon->groups[0] = &rnp_hwmon->group;
rnp_hwmon->group.attrs = rnp_hwmon->attrs;
hwmon_dev = devm_hwmon_device_register_with_groups(&adapter->pdev->dev,
"rnp",
rnp_hwmon,
rnp_hwmon->groups);
if (IS_ERR(hwmon_dev)) {
rc = PTR_ERR(hwmon_dev);
goto exit;
}
no_thermal:
goto exit;
err:
rnp_sysfs_exit(adapter);
exit:
return rc;
}
Reference in New Issue View Git Blame Copy Permalink