Page MenuHomeFreeBSD
Differential D25793 Diff 78110 head/sys/dev/axgbe/xgbe-sysctl.c

Changeset View

Standalone View

View Options

head/sys/dev/axgbe/xgbe-sysctl.c

PropertyOld ValueNew Value
svn:eol-stylenullnative
\ No newline at end of property
svn:keywordsnullFreeBSD=%H
\ No newline at end of property
svn:mime-typenulltext/plain
\ No newline at end of property
/*-
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
* Copyright (c) 2020 Advanced Micro Devices, Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* Contact Information :
* Rajesh Kumar <rajesh1.kumar@amd.com>
* Arpan Palit <Arpan.Palit@amd.com>
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/sysctl.h>
#include <sys/sbuf.h>
#include "xgbe.h"
#include "xgbe-common.h"
#define SYSCTL_BUF_LEN 64
typedef enum{
/* Coalesce flag */
rx_coalesce_usecs = 1,
rx_max_coalesced_frames,
rx_coalesce_usecs_irq,
rx_max_coalesced_frames_irq,
tx_coalesce_usecs,
tx_max_coalesced_frames,
tx_coalesce_usecs_irq,
tx_max_coalesced_frames_irq,
stats_block_coalesce_usecs,
use_adaptive_rx_coalesce,
use_adaptive_tx_coalesce,
pkt_rate_low,
rx_coalesce_usecs_low,
rx_max_coalesced_frames_low,
tx_coalesce_usecs_low,
tx_max_coalesced_frames_low,
pkt_rate_high,
rx_coalesce_usecs_high,
rx_max_coalesced_frames_high,
tx_coalesce_usecs_high,
tx_max_coalesced_frames_high,
rate_sample_interval,
/* Pasue flag */
autoneg,
tx_pause,
rx_pause,
/* link settings */
speed,
duplex,
/* Ring settings */
rx_pending,
rx_mini_pending,
rx_jumbo_pending,
tx_pending,
/* Channels settings */
rx_count,
tx_count,
other_count,
combined_count,
} sysctl_variable_t;
typedef enum {
SYSL_NONE,
SYSL_BOOL,
SYSL_S32,
SYSL_U8,
SYSL_U16,
SYSL_U32,
SYSL_U64,
SYSL_BE16,
SYSL_IP4,
SYSL_STR,
SYSL_FLAG,
SYSL_MAC,
} sysctl_type_t;
struct sysctl_info {
uint8_t name[32];
sysctl_type_t type;
sysctl_variable_t flag;
uint8_t support[16];
};
struct sysctl_op {
/* Coalesce options */
unsigned int rx_coalesce_usecs;
unsigned int rx_max_coalesced_frames;
unsigned int rx_coalesce_usecs_irq;
unsigned int rx_max_coalesced_frames_irq;
unsigned int tx_coalesce_usecs;
unsigned int tx_max_coalesced_frames;
unsigned int tx_coalesce_usecs_irq;
unsigned int tx_max_coalesced_frames_irq;
unsigned int stats_block_coalesce_usecs;
unsigned int use_adaptive_rx_coalesce;
unsigned int use_adaptive_tx_coalesce;
unsigned int pkt_rate_low;
unsigned int rx_coalesce_usecs_low;
unsigned int rx_max_coalesced_frames_low;
unsigned int tx_coalesce_usecs_low;
unsigned int tx_max_coalesced_frames_low;
unsigned int pkt_rate_high;
unsigned int rx_coalesce_usecs_high;
unsigned int rx_max_coalesced_frames_high;
unsigned int tx_coalesce_usecs_high;
unsigned int tx_max_coalesced_frames_high;
unsigned int rate_sample_interval;
/* Pasue options */
unsigned int autoneg;
unsigned int tx_pause;
unsigned int rx_pause;
/* Link settings options */
unsigned int speed;
unsigned int duplex;
/* Ring param options */
unsigned int rx_max_pending;
unsigned int rx_mini_max_pending;
unsigned int rx_jumbo_max_pending;
unsigned int tx_max_pending;
unsigned int rx_pending;
unsigned int rx_mini_pending;
unsigned int rx_jumbo_pending;
unsigned int tx_pending;
/* Channels options */
unsigned int max_rx;
unsigned int max_tx;
unsigned int max_other;
unsigned int max_combined;
unsigned int rx_count;
unsigned int tx_count;
unsigned int other_count;
unsigned int combined_count;
} sys_op;
#define GSTRING_LEN 32
struct xgbe_stats {
char stat_string[GSTRING_LEN];
int stat_size;
int stat_offset;
};
#define FIELD_SIZEOF(t, f) (sizeof(((t*)0)->f))
#define XGMAC_MMC_STAT(_string, _var) \
{ _string, \
FIELD_SIZEOF(struct xgbe_mmc_stats, _var), \
offsetof(struct xgbe_prv_data, mmc_stats._var), \
}
#define XGMAC_EXT_STAT(_string, _var) \
{ _string, \
FIELD_SIZEOF(struct xgbe_ext_stats, _var), \
offsetof(struct xgbe_prv_data, ext_stats._var), \
}
static const struct xgbe_stats xgbe_gstring_stats[] = {
XGMAC_MMC_STAT("tx_bytes", txoctetcount_gb),
XGMAC_MMC_STAT("tx_packets", txframecount_gb),
XGMAC_MMC_STAT("tx_unicast_packets", txunicastframes_gb),
XGMAC_MMC_STAT("tx_broadcast_packets", txbroadcastframes_gb),
XGMAC_MMC_STAT("tx_multicast_packets", txmulticastframes_gb),
XGMAC_MMC_STAT("tx_vlan_packets", txvlanframes_g),
XGMAC_EXT_STAT("tx_vxlan_packets", tx_vxlan_packets),
XGMAC_EXT_STAT("tx_tso_packets", tx_tso_packets),
XGMAC_MMC_STAT("tx_64_byte_packets", tx64octets_gb),
XGMAC_MMC_STAT("tx_65_to_127_byte_packets", tx65to127octets_gb),
XGMAC_MMC_STAT("tx_128_to_255_byte_packets", tx128to255octets_gb),
XGMAC_MMC_STAT("tx_256_to_511_byte_packets", tx256to511octets_gb),
XGMAC_MMC_STAT("tx_512_to_1023_byte_packets", tx512to1023octets_gb),
XGMAC_MMC_STAT("tx_1024_to_max_byte_packets", tx1024tomaxoctets_gb),
XGMAC_MMC_STAT("tx_underflow_errors", txunderflowerror),
XGMAC_MMC_STAT("tx_pause_frames", txpauseframes),
XGMAC_MMC_STAT("rx_bytes", rxoctetcount_gb),
XGMAC_MMC_STAT("rx_packets", rxframecount_gb),
XGMAC_MMC_STAT("rx_unicast_packets", rxunicastframes_g),
XGMAC_MMC_STAT("rx_broadcast_packets", rxbroadcastframes_g),
XGMAC_MMC_STAT("rx_multicast_packets", rxmulticastframes_g),
XGMAC_MMC_STAT("rx_vlan_packets", rxvlanframes_gb),
XGMAC_EXT_STAT("rx_vxlan_packets", rx_vxlan_packets),
XGMAC_MMC_STAT("rx_64_byte_packets", rx64octets_gb),
XGMAC_MMC_STAT("rx_65_to_127_byte_packets", rx65to127octets_gb),
XGMAC_MMC_STAT("rx_128_to_255_byte_packets", rx128to255octets_gb),
XGMAC_MMC_STAT("rx_256_to_511_byte_packets", rx256to511octets_gb),
XGMAC_MMC_STAT("rx_512_to_1023_byte_packets", rx512to1023octets_gb),
XGMAC_MMC_STAT("rx_1024_to_max_byte_packets", rx1024tomaxoctets_gb),
XGMAC_MMC_STAT("rx_undersize_packets", rxundersize_g),
XGMAC_MMC_STAT("rx_oversize_packets", rxoversize_g),
XGMAC_MMC_STAT("rx_crc_errors", rxcrcerror),
XGMAC_MMC_STAT("rx_crc_errors_small_packets", rxrunterror),
XGMAC_MMC_STAT("rx_crc_errors_giant_packets", rxjabbererror),
XGMAC_MMC_STAT("rx_length_errors", rxlengtherror),
XGMAC_MMC_STAT("rx_out_of_range_errors", rxoutofrangetype),
XGMAC_MMC_STAT("rx_fifo_overflow_errors", rxfifooverflow),
XGMAC_MMC_STAT("rx_watchdog_errors", rxwatchdogerror),
XGMAC_EXT_STAT("rx_csum_errors", rx_csum_errors),
XGMAC_EXT_STAT("rx_vxlan_csum_errors", rx_vxlan_csum_errors),
XGMAC_MMC_STAT("rx_pause_frames", rxpauseframes),
XGMAC_EXT_STAT("rx_split_header_packets", rx_split_header_packets),
XGMAC_EXT_STAT("rx_buffer_unavailable", rx_buffer_unavailable),
};
#define XGBE_STATS_COUNT ARRAY_SIZE(xgbe_gstring_stats)
char** alloc_sysctl_buffer(void);
void get_val(char *buf, char **op, char **val, int *n_op);
void fill_data(struct sysctl_op *sys_op, int flag, unsigned int value);
static int
exit_bad_op(void)
{
printf("SYSCTL: bad command line option (s)\n");
return(-EINVAL);
}
static inline unsigned
fls_long(unsigned long l)
{
if (sizeof(l) == 4)
return (fls(l));
return (fls64(l));
}
static inline __attribute__((const))
unsigned long __rounddown_pow_of_two(unsigned long n)
{
return (1UL << (fls_long(n) - 1));
}
static inline int
get_ubuf(struct sysctl_req *req, char *ubuf)
{
int rc;
printf("%s: len:0x%li idx:0x%li\n", __func__, req->newlen,
req->newidx);
if (req->newlen >= SYSCTL_BUF_LEN)
return (-EINVAL);
rc = SYSCTL_IN(req, ubuf, req->newlen);
if (rc)
return (rc);
ubuf[req->newlen] = '\0';
return (0);
}
char**
alloc_sysctl_buffer(void)
{
char **buffer;
int i;
buffer = malloc(sizeof(char *)*32, M_AXGBE, M_WAITOK | M_ZERO);
for(i = 0; i < 32; i++)
buffer[i] = malloc(sizeof(char)*32, M_AXGBE, M_WAITOK | M_ZERO);
return (buffer);
}
void
get_val(char *buf, char **op, char **val, int *n_op)
{
int blen = strlen(buf);
int count = 0;
int i, j;
*n_op = 0;
for (i = 0; i < blen; i++) {
count++;
/* Get sysctl command option */
for (j = 0; buf[i] != ' '; j++) {
if (i >= blen)
break;
op[*n_op][j] = buf[i++];
}
op[*n_op][j+1] = '\0';
if (i >= strlen(buf))
goto out;
/* Get sysctl value*/
i++;
for (j = 0; buf[i] != ' '; j++) {
if (i >= blen)
break;
val[*n_op][j] = buf[i++];
}
val[*n_op][j+1] = '\0';
if (i >= strlen(buf))
goto out;
*n_op = count;
}
out:
*n_op = count;
}
void
fill_data(struct sysctl_op *sys_op, int flag, unsigned int value)
{
switch(flag) {
case 1:
sys_op->rx_coalesce_usecs = value;
break;
case 2:
sys_op->rx_max_coalesced_frames = value;
break;
case 3:
sys_op->rx_coalesce_usecs_irq = value;
break;
case 4:
sys_op->rx_max_coalesced_frames_irq = value;
break;
case 5:
sys_op->tx_coalesce_usecs = value;
break;
case 6:
sys_op->tx_max_coalesced_frames = value;
break;
case 7:
sys_op->tx_coalesce_usecs_irq = value;
break;
case 8:
sys_op->tx_max_coalesced_frames_irq = value;
break;
case 9:
sys_op->stats_block_coalesce_usecs = value;
break;
case 10:
sys_op->use_adaptive_rx_coalesce = value;
break;
case 11:
sys_op->use_adaptive_tx_coalesce = value;
break;
case 12:
sys_op->pkt_rate_low = value;
break;
case 13:
sys_op->rx_coalesce_usecs_low = value;
break;
case 14:
sys_op->rx_max_coalesced_frames_low = value;
break;
case 15:
sys_op->tx_coalesce_usecs_low = value;
break;
case 16:
sys_op->tx_max_coalesced_frames_low = value;
break;
case 17:
sys_op->pkt_rate_high = value;
break;
case 18:
sys_op->rx_coalesce_usecs_high = value;
break;
case 19:
sys_op->rx_max_coalesced_frames_high = value;
break;
case 20:
sys_op->tx_coalesce_usecs_high = value;
break;
case 21:
sys_op->tx_max_coalesced_frames_high = value;
break;
case 22:
sys_op->rate_sample_interval = value;
break;
case 23:
sys_op->autoneg = value;
break;
case 24:
sys_op->rx_pause = value;
break;
case 25:
sys_op->tx_pause = value;
break;
case 26:
sys_op->speed = value;
break;
case 27:
sys_op->duplex = value;
break;
case 28:
sys_op->rx_pending = value;
break;
case 29:
sys_op->rx_mini_pending = value;
break;
case 30:
sys_op->rx_jumbo_pending = value;
break;
case 31:
sys_op->tx_pending = value;
break;
default:
printf("Option error\n");
}
}
static int
parse_generic_sysctl(struct xgbe_prv_data *pdata, char *buf,
struct sysctl_info *info, unsigned int n_info)
{
struct sysctl_op *sys_op = pdata->sys_op;
unsigned int value;
char **op, **val;
int n_op = 0;
int rc = 0;
int i, idx;
op = alloc_sysctl_buffer();
val = alloc_sysctl_buffer();
get_val(buf, op, val, &n_op);
for (i = 0; i < n_op; i++) {
for (idx = 0; idx < n_info; idx++) {
if (strcmp(info[idx].name, op[i]) == 0) {
if (strcmp(info[idx].support,
"not-supported") == 0){
axgbe_printf(1, "ignoring not-supported "
"option \"%s\"\n", info[idx].name);
break;
}
switch(info[idx].type) {
case SYSL_BOOL: {
if (!strcmp(val[i], "on"))
fill_data(sys_op,
info[idx].flag, 1);
else if (!strcmp(val[i], "off"))
fill_data(sys_op,
info[idx].flag, 0);
else
rc = exit_bad_op();
break;
}
case SYSL_S32:
sscanf(val[i], "%u", &value);
fill_data(sys_op, info[idx].flag, value);
break;
case SYSL_U8:
if (!strcmp(val[i], "half"))
fill_data(sys_op,
info[idx].flag, DUPLEX_HALF);
else if (!strcmp(val[i], "full"))
fill_data(sys_op,
info[idx].flag, DUPLEX_FULL);
else
exit_bad_op();
default:
rc = exit_bad_op();
}
}
}
}
for(i = 0; i < 32; i++)
free(op[i], M_AXGBE);
free(op, M_AXGBE);
for(i = 0; i < 32; i++)
free(val[i], M_AXGBE);
free(val, M_AXGBE);
return (rc);
}
static int
sysctl_xgmac_reg_addr_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
ssize_t buf_size = 64;
char buf[buf_size];
struct sbuf *sb;
unsigned int reg;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
axgbe_printf(2, "READ: %s: sysctl_xgmac_reg: 0x%x\n", __func__,
pdata->sysctl_xgmac_reg);
sbuf_printf(sb, "\nXGMAC reg_addr: 0x%x\n",
pdata->sysctl_xgmac_reg);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
sscanf(buf, "%x", &reg);
axgbe_printf(2, "WRITE: %s: reg: 0x%x\n", __func__, reg);
pdata->sysctl_xgmac_reg = reg;
}
axgbe_printf(2, "%s: rc= %d\n", __func__, rc);
return (rc);
}
static int
sysctl_get_drv_info_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
struct xgbe_hw_features *hw_feat = &pdata->hw_feat;
ssize_t buf_size = 64;
struct sbuf *sb;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
sbuf_printf(sb, "\ndriver: %s", XGBE_DRV_NAME);
sbuf_printf(sb, "\nversion: %s", XGBE_DRV_VERSION);
sbuf_printf(sb, "\nfirmware-version: %d.%d.%d",
XGMAC_GET_BITS(hw_feat->version, MAC_VR, USERVER),
XGMAC_GET_BITS(hw_feat->version, MAC_VR, DEVID),
XGMAC_GET_BITS(hw_feat->version, MAC_VR, SNPSVER));
sbuf_printf(sb, "\nbus-info: %04d:%02d:%02d",
pdata->pcie_bus, pdata->pcie_device, pdata->pcie_func);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
return (-EINVAL);
}
static int
sysctl_get_link_info_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
ssize_t buf_size = 64;
struct sbuf *sb;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
sbuf_printf(sb, "\nLink is %s", pdata->phy.link ? "Up" : "Down");
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (0);
}
return (-EINVAL);
}
#define COALESCE_SYSCTL_INFO(__coalop) \
{ \
{ "adaptive-rx", SYSL_BOOL, use_adaptive_rx_coalesce, "not-supported" }, \
{ "adaptive-tx", SYSL_BOOL, use_adaptive_tx_coalesce, "not-supported" }, \
{ "sample-interval", SYSL_S32, rate_sample_interval, "not-supported" }, \
{ "stats-block-usecs", SYSL_S32, stats_block_coalesce_usecs, "not-supported" }, \
{ "pkt-rate-low", SYSL_S32, pkt_rate_low, "not-supported" }, \
{ "pkt-rate-high", SYSL_S32, pkt_rate_high, "not-supported" }, \
{ "rx-usecs", SYSL_S32, rx_coalesce_usecs, "supported" }, \
{ "rx-frames", SYSL_S32, rx_max_coalesced_frames, "supported" }, \
{ "rx-usecs-irq", SYSL_S32, rx_coalesce_usecs_irq, "not-supported" }, \
{ "rx-frames-irq", SYSL_S32, rx_max_coalesced_frames_irq, "not-supported" }, \
{ "tx-usecs", SYSL_S32, tx_coalesce_usecs, "not-supported" }, \
{ "tx-frames", SYSL_S32, tx_max_coalesced_frames, "supported" }, \
{ "tx-usecs-irq", SYSL_S32, tx_coalesce_usecs_irq, "not-supported" }, \
{ "tx-frames-irq", SYSL_S32, tx_max_coalesced_frames_irq, "not-supported" }, \
{ "rx-usecs-low", SYSL_S32, rx_coalesce_usecs_low, "not-supported" }, \
{ "rx-frames-low", SYSL_S32, rx_max_coalesced_frames_low, "not-supported"}, \
{ "tx-usecs-low", SYSL_S32, tx_coalesce_usecs_low, "not-supported" }, \
{ "tx-frames-low", SYSL_S32, tx_max_coalesced_frames_low, "not-supported" }, \
{ "rx-usecs-high", SYSL_S32, rx_coalesce_usecs_high, "not-supported" }, \
{ "rx-frames-high", SYSL_S32, rx_max_coalesced_frames_high, "not-supported" }, \
{ "tx-usecs-high", SYSL_S32, tx_coalesce_usecs_high, "not-supported" }, \
{ "tx-frames-high", SYSL_S32, tx_max_coalesced_frames_high, "not-supported" }, \
}
static int
sysctl_coalesce_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
struct xgbe_hw_if *hw_if = &pdata->hw_if;
struct sysctl_op *sys_op = pdata->sys_op;
struct sysctl_info sysctl_coalesce[] = COALESCE_SYSCTL_INFO(coalop);
unsigned int rx_frames, rx_riwt, rx_usecs;
unsigned int tx_frames;
ssize_t buf_size = 64;
char buf[buf_size];
struct sbuf *sb;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
sys_op->rx_coalesce_usecs = pdata->rx_usecs;
sys_op->rx_max_coalesced_frames = pdata->rx_frames;
sys_op->tx_max_coalesced_frames = pdata->tx_frames;
sbuf_printf(sb, "\nAdaptive RX: %s TX: %s\n",
sys_op->use_adaptive_rx_coalesce ? "on" : "off",
sys_op->use_adaptive_tx_coalesce ? "on" : "off");
sbuf_printf(sb, "stats-block-usecs: %u\n"
"sample-interval: %u\n"
"pkt-rate-low: %u\n"
"pkt-rate-high: %u\n"
"\n"
"rx-usecs: %u\n"
"rx-frames: %u\n"
"rx-usecs-irq: %u\n"
"rx-frames-irq: %u\n"
"\n"
"tx-usecs: %u\n"
"tx-frames: %u\n"
"tx-usecs-irq: %u\n"
"tx-frames-irq: %u\n"
"\n"
"rx-usecs-low: %u\n"
"rx-frames-low: %u\n"
"tx-usecs-low: %u\n"
"tx-frames-low: %u\n"
"\n"
"rx-usecs-high: %u\n"
"rx-frames-high: %u\n"
"tx-usecs-high: %u\n"
"tx-frames-high: %u\n",
sys_op->stats_block_coalesce_usecs,
sys_op->rate_sample_interval,
sys_op->pkt_rate_low,
sys_op->pkt_rate_high,
sys_op->rx_coalesce_usecs,
sys_op->rx_max_coalesced_frames,
sys_op->rx_coalesce_usecs_irq,
sys_op->rx_max_coalesced_frames_irq,
sys_op->tx_coalesce_usecs,
sys_op->tx_max_coalesced_frames,
sys_op->tx_coalesce_usecs_irq,
sys_op->tx_max_coalesced_frames_irq,
sys_op->rx_coalesce_usecs_low,
sys_op->rx_max_coalesced_frames_low,
sys_op->tx_coalesce_usecs_low,
sys_op->tx_max_coalesced_frames_low,
sys_op->rx_coalesce_usecs_high,
sys_op->rx_max_coalesced_frames_high,
sys_op->tx_coalesce_usecs_high,
sys_op->tx_max_coalesced_frames_high);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (0);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
parse_generic_sysctl(pdata, buf, sysctl_coalesce,
ARRAY_SIZE(sysctl_coalesce));
rx_riwt = hw_if->usec_to_riwt(pdata, sys_op->rx_coalesce_usecs);
rx_usecs = sys_op->rx_coalesce_usecs;
rx_frames = sys_op->rx_max_coalesced_frames;
/* Use smallest possible value if conversion resulted in zero */
if (rx_usecs && !rx_riwt)
rx_riwt = 1;
/* Check the bounds of values for Rx */
if (rx_riwt > XGMAC_MAX_DMA_RIWT) {
axgbe_printf(2, "rx-usec is limited to %d usecs\n",
hw_if->riwt_to_usec(pdata, XGMAC_MAX_DMA_RIWT));
return (-EINVAL);
}
if (rx_frames > pdata->rx_desc_count) {
axgbe_printf(2, "rx-frames is limited to %d frames\n",
pdata->rx_desc_count);
return (-EINVAL);
}
tx_frames = sys_op->tx_max_coalesced_frames;
/* Check the bounds of values for Tx */
if (tx_frames > pdata->tx_desc_count) {
axgbe_printf(2, "tx-frames is limited to %d frames\n",
pdata->tx_desc_count);
return (-EINVAL);
}
pdata->rx_riwt = rx_riwt;
pdata->rx_usecs = rx_usecs;
pdata->rx_frames = rx_frames;
hw_if->config_rx_coalesce(pdata);
pdata->tx_frames = tx_frames;
hw_if->config_tx_coalesce(pdata);
}
axgbe_printf(2, "%s: rc= %d\n", __func__, rc);
return (rc);
}
static int
sysctl_pauseparam_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
struct sysctl_op *sys_op = pdata->sys_op;
struct sysctl_info sysctl_pauseparam[] = {
{ "autoneg", SYSL_BOOL, autoneg, "supported" },
{ "rx", SYSL_BOOL, rx_pause, "supported" },
{ "tx", SYSL_BOOL, tx_pause, "supported" },
};
ssize_t buf_size = 512;
char buf[buf_size];
struct sbuf *sb;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
sys_op->autoneg = pdata->phy.pause_autoneg;
sys_op->tx_pause = pdata->phy.tx_pause;
sys_op->rx_pause = pdata->phy.rx_pause;
sbuf_printf(sb,
"\nAutonegotiate: %s\n"
"RX: %s\n"
"TX: %s\n",
sys_op->autoneg ? "on" : "off",
sys_op->rx_pause ? "on" : "off",
sys_op->tx_pause ? "on" : "off");
if (pdata->phy.lp_advertising) {
int an_rx = 0, an_tx = 0;
if (pdata->phy.advertising & pdata->phy.lp_advertising &
ADVERTISED_Pause) {
an_tx = 1;
an_rx = 1;
} else if (pdata->phy.advertising &
pdata->phy.lp_advertising & ADVERTISED_Asym_Pause) {
if (pdata->phy.advertising & ADVERTISED_Pause)
an_rx = 1;
else if (pdata->phy.lp_advertising &
ADVERTISED_Pause)
an_tx = 1;
}
sbuf_printf(sb,
"\n->\nRX negotiated: %s\n"
"TX negotiated: %s\n",
an_rx ? "on" : "off",
an_tx ? "on" : "off");
}
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (0);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
parse_generic_sysctl(pdata, buf, sysctl_pauseparam,
ARRAY_SIZE(sysctl_pauseparam));
if (sys_op->autoneg && (pdata->phy.autoneg != AUTONEG_ENABLE)) {
axgbe_error("autoneg disabled, pause autoneg not available\n");
return (-EINVAL);
}
pdata->phy.pause_autoneg = sys_op->autoneg;
pdata->phy.tx_pause = sys_op->tx_pause;
pdata->phy.rx_pause = sys_op->rx_pause;
XGBE_CLR_ADV(&pdata->phy, Pause);
XGBE_CLR_ADV(&pdata->phy, Asym_Pause);
if (sys_op->rx_pause) {
XGBE_SET_ADV(&pdata->phy, Pause);
XGBE_SET_ADV(&pdata->phy, Asym_Pause);
}
if (sys_op->tx_pause) {
/* Equivalent to XOR of Asym_Pause */
if (XGBE_ADV(&pdata->phy, Asym_Pause))
XGBE_CLR_ADV(&pdata->phy, Asym_Pause);
else
XGBE_SET_ADV(&pdata->phy, Asym_Pause);
}
if (test_bit(XGBE_LINK_INIT, &pdata->dev_state))
rc = pdata->phy_if.phy_config_aneg(pdata);
}
return (rc);
}
static int
sysctl_link_ksettings_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
struct sysctl_op *sys_op = pdata->sys_op;
struct sysctl_info sysctl_linksettings[] = {
{ "autoneg", SYSL_BOOL, autoneg, "supported" },
{ "speed", SYSL_U32, speed, "supported" },
{ "duplex", SYSL_U8, duplex, "supported" },
};
ssize_t buf_size = 512;
char buf[buf_size], link_modes[16], speed_modes[16];
struct sbuf *sb;
uint32_t speed;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
sys_op->autoneg = pdata->phy.autoneg;
sys_op->speed = pdata->phy.speed;
sys_op->duplex = pdata->phy.duplex;
XGBE_LM_COPY(&pdata->phy, supported, &pdata->phy, supported);
XGBE_LM_COPY(&pdata->phy, advertising, &pdata->phy, advertising);
XGBE_LM_COPY(&pdata->phy, lp_advertising, &pdata->phy, lp_advertising);
switch (sys_op->speed) {
case 1:
strcpy(link_modes, "Unknown");
strcpy(speed_modes, "Unknown");
break;
case 2:
strcpy(link_modes, "10Gbps/Full");
strcpy(speed_modes, "10000");
break;
case 3:
strcpy(link_modes, "2.5Gbps/Full");
strcpy(speed_modes, "2500");
break;
case 4:
strcpy(link_modes, "1Gbps/Full");
strcpy(speed_modes, "1000");
break;
case 5:
strcpy(link_modes, "100Mbps/Full");
strcpy(speed_modes, "100");
break;
case 6:
strcpy(link_modes, "10Mbps/Full");
strcpy(speed_modes, "10");
break;
}
sbuf_printf(sb,
"\nlink_modes: %s\n"
"autonegotiation: %s\n"
"speed: %sMbps\n",
link_modes,
(sys_op->autoneg == AUTONEG_DISABLE) ? "off" : "on",
speed_modes);
switch (sys_op->duplex) {
case DUPLEX_HALF:
sbuf_printf(sb, "Duplex: Half\n");
break;
case DUPLEX_FULL:
sbuf_printf(sb, "Duplex: Full\n");
break;
default:
sbuf_printf(sb, "Duplex: Unknown\n");
break;
}
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (0);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
parse_generic_sysctl(pdata, buf, sysctl_linksettings,
ARRAY_SIZE(sysctl_linksettings));
speed = sys_op->speed;
if ((sys_op->autoneg != AUTONEG_ENABLE) &&
(sys_op->autoneg != AUTONEG_DISABLE)) {
axgbe_error("unsupported autoneg %hhu\n",
(unsigned char)sys_op->autoneg);
return (-EINVAL);
}
if (sys_op->autoneg == AUTONEG_DISABLE) {
if (!pdata->phy_if.phy_valid_speed(pdata, speed)) {
axgbe_error("unsupported speed %u\n", speed);
return (-EINVAL);
}
if (sys_op->duplex != DUPLEX_FULL) {
axgbe_error("unsupported duplex %hhu\n",
(unsigned char)sys_op->duplex);
return (-EINVAL);
}
}
pdata->phy.autoneg = sys_op->autoneg;
pdata->phy.speed = speed;
pdata->phy.duplex = sys_op->duplex;
if (sys_op->autoneg == AUTONEG_ENABLE)
XGBE_SET_ADV(&pdata->phy, Autoneg);
else
XGBE_CLR_ADV(&pdata->phy, Autoneg);
if (test_bit(XGBE_LINK_INIT, &pdata->dev_state))
rc = pdata->phy_if.phy_config_aneg(pdata);
}
return (rc);
}
static int
sysctl_ringparam_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
struct sysctl_op *sys_op = pdata->sys_op;
struct sysctl_info sysctl_ringparam[] = {
{ "rx", SYSL_S32, rx_pending, "supported" },
{ "rx-mini", SYSL_S32, rx_mini_pending, "supported" },
{ "rx-jumbo", SYSL_S32, rx_jumbo_pending, "supported" },
{ "tx", SYSL_S32, tx_pending, "supported" },
};
ssize_t buf_size = 512;
unsigned int rx, tx;
char buf[buf_size];
struct sbuf *sb;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
sys_op->rx_max_pending = XGBE_RX_DESC_CNT_MAX;
sys_op->tx_max_pending = XGBE_TX_DESC_CNT_MAX;
sys_op->rx_pending = pdata->rx_desc_count;
sys_op->tx_pending = pdata->tx_desc_count;
sbuf_printf(sb,
"\nPre-set maximums:\n"
"RX: %u\n"
"RX Mini: %u\n"
"RX Jumbo: %u\n"
"TX: %u\n",
sys_op->rx_max_pending,
sys_op->rx_mini_max_pending,
sys_op->rx_jumbo_max_pending,
sys_op->tx_max_pending);
sbuf_printf(sb,
"\nCurrent hardware settings:\n"
"RX: %u\n"
"RX Mini: %u\n"
"RX Jumbo: %u\n"
"TX: %u\n",
sys_op->rx_pending,
sys_op->rx_mini_pending,
sys_op->rx_jumbo_pending,
sys_op->tx_pending);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (0);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
parse_generic_sysctl(pdata, buf, sysctl_ringparam,
ARRAY_SIZE(sysctl_ringparam));
if (sys_op->rx_mini_pending || sys_op->rx_jumbo_pending) {
axgbe_error("unsupported ring parameter\n");
return (-EINVAL);
}
if ((sys_op->rx_pending < XGBE_RX_DESC_CNT_MIN) ||
(sys_op->rx_pending > XGBE_RX_DESC_CNT_MAX)) {
axgbe_error("rx ring param must be between %u and %u\n",
XGBE_RX_DESC_CNT_MIN, XGBE_RX_DESC_CNT_MAX);
return (-EINVAL);
}
if ((sys_op->tx_pending < XGBE_TX_DESC_CNT_MIN) ||
(sys_op->tx_pending > XGBE_TX_DESC_CNT_MAX)) {
axgbe_error("tx ring param must be between %u and %u\n",
XGBE_TX_DESC_CNT_MIN, XGBE_TX_DESC_CNT_MAX);
return (-EINVAL);
}
rx = __rounddown_pow_of_two(sys_op->rx_pending);
if (rx != sys_op->rx_pending)
axgbe_printf(1, "rx ring param rounded to power of 2: %u\n",
rx);
tx = __rounddown_pow_of_two(sys_op->tx_pending);
if (tx != sys_op->tx_pending)
axgbe_printf(1, "tx ring param rounded to power of 2: %u\n",
tx);
if ((rx == pdata->rx_desc_count) &&
(tx == pdata->tx_desc_count))
goto out;
pdata->rx_desc_count = rx;
pdata->tx_desc_count = tx;
/* TODO - restart dev */
}
out:
return (0);
}
static int
sysctl_channels_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
struct sysctl_op *sys_op = pdata->sys_op;
struct sysctl_info sysctl_channels[] = {
{ "rx", SYSL_S32, rx_count, "supported" },
{ "tx", SYSL_S32, tx_count, "supported" },
{ "other", SYSL_S32, other_count, "supported" },
{ "combined", SYSL_S32, combined_count, "supported" },
};
unsigned int rx, tx, combined;
ssize_t buf_size = 512;
char buf[buf_size];
struct sbuf *sb;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
rx = min(pdata->hw_feat.rx_ch_cnt, pdata->rx_max_channel_count);
rx = min(rx, pdata->channel_irq_count);
tx = min(pdata->hw_feat.tx_ch_cnt, pdata->tx_max_channel_count);
tx = min(tx, pdata->channel_irq_count);
tx = min(tx, pdata->tx_max_q_count);
combined = min(rx, tx);
sys_op->max_combined = combined;
sys_op->max_rx = rx ? rx - 1 : 0;
sys_op->max_tx = tx ? tx - 1 : 0;
/* Get current settings based on device state */
rx = pdata->rx_ring_count;
tx = pdata->tx_ring_count;
combined = min(rx, tx);
rx -= combined;
tx -= combined;
sys_op->combined_count = combined;
sys_op->rx_count = rx;
sys_op->tx_count = tx;
sbuf_printf(sb,
"\nPre-set maximums:\n"
"RX: %u\n"
"TX: %u\n"
"Other: %u\n"
"Combined: %u\n",
sys_op->max_rx, sys_op->max_tx,
sys_op->max_other,
sys_op->max_combined);
sbuf_printf(sb,
"\nCurrent hardware settings:\n"
"RX: %u\n"
"TX: %u\n"
"Other: %u\n"
"Combined: %u\n",
sys_op->rx_count, sys_op->tx_count,
sys_op->other_count,
sys_op->combined_count);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (0);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
parse_generic_sysctl(pdata, buf, sysctl_channels,
ARRAY_SIZE(sysctl_channels));
axgbe_error( "channel inputs: combined=%u, rx-only=%u,"
" tx-only=%u\n", sys_op->combined_count,
sys_op->rx_count, sys_op->tx_count);
}
return (rc);
}
static int
sysctl_mac_stats_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
ssize_t buf_size = 64;
struct sbuf *sb;
int rc = 0;
int i;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
pdata->hw_if.read_mmc_stats(pdata);
for (i = 0; i < XGBE_STATS_COUNT; i++) {
sbuf_printf(sb, "\n %s: %lu",
xgbe_gstring_stats[i].stat_string,
*(uint64_t *)((uint8_t *)pdata + xgbe_gstring_stats[i].stat_offset));
}
for (i = 0; i < pdata->tx_ring_count; i++) {
sbuf_printf(sb,
"\n txq_packets[%d]: %lu"
"\n txq_bytes[%d]: %lu",
i, pdata->ext_stats.txq_packets[i],
i, pdata->ext_stats.txq_bytes[i]);
}
for (i = 0; i < pdata->rx_ring_count; i++) {
sbuf_printf(sb,
"\n rxq_packets[%d]: %lu"
"\n rxq_bytes[%d]: %lu",
i, pdata->ext_stats.rxq_packets[i],
i, pdata->ext_stats.rxq_bytes[i]);
}
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
return (-EINVAL);
}
static int
sysctl_xgmac_reg_value_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
ssize_t buf_size = 64;
char buf[buf_size];
unsigned int value;
struct sbuf *sb;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
value = XGMAC_IOREAD(pdata, pdata->sysctl_xgmac_reg);
axgbe_printf(2, "READ: %s: value: 0x%x\n", __func__, value);
sbuf_printf(sb, "\nXGMAC reg_value: 0x%x\n", value);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
sscanf(buf, "%x", &value);
axgbe_printf(2, "WRITE: %s: value: 0x%x\n", __func__, value);
XGMAC_IOWRITE(pdata, pdata->sysctl_xgmac_reg, value);
}
axgbe_printf(2, "%s: rc= %d\n", __func__, rc);
return (rc);
}
static int
sysctl_xpcs_mmd_reg_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
ssize_t buf_size = 64;
char buf[buf_size];
struct sbuf *sb;
unsigned int reg;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
axgbe_printf(2, "READ: %s: xpcs_mmd: 0x%x\n", __func__,
pdata->sysctl_xpcs_mmd);
sbuf_printf(sb, "\nXPCS mmd_reg: 0x%x\n",
pdata->sysctl_xpcs_mmd);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
sscanf(buf, "%x", &reg);
axgbe_printf(2, "WRITE: %s: mmd_reg: 0x%x\n", __func__, reg);
pdata->sysctl_xpcs_mmd = reg;
}
axgbe_printf(2, "%s: rc= %d\n", __func__, rc);
return (rc);
}
static int
sysctl_xpcs_reg_addr_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
ssize_t buf_size = 64;
char buf[buf_size];
struct sbuf *sb;
unsigned int reg;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
axgbe_printf(2, "READ: %s: sysctl_xpcs_reg: 0x%x\n", __func__,
pdata->sysctl_xpcs_reg);
sbuf_printf(sb, "\nXPCS reg_addr: 0x%x\n",
pdata->sysctl_xpcs_reg);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
sscanf(buf, "%x", &reg);
axgbe_printf(2, "WRITE: %s: reg: 0x%x\n", __func__, reg);
pdata->sysctl_xpcs_reg = reg;
}
axgbe_printf(2, "%s: rc= %d\n", __func__, rc);
return (rc);
}
static int
sysctl_xpcs_reg_value_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
ssize_t buf_size = 64;
char buf[buf_size];
unsigned int value;
struct sbuf *sb;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
value = XMDIO_READ(pdata, pdata->sysctl_xpcs_mmd,
pdata->sysctl_xpcs_reg);
axgbe_printf(2, "READ: %s: value: 0x%x\n", __func__, value);
sbuf_printf(sb, "\nXPCS reg_value: 0x%x\n", value);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
sscanf(buf, "%x", &value);
axgbe_printf(2, "WRITE: %s: value: 0x%x\n", __func__, value);
XMDIO_WRITE(pdata, pdata->sysctl_xpcs_mmd,
pdata->sysctl_xpcs_reg, value);
}
axgbe_printf(2, "%s: rc= %d\n", __func__, rc);
return (rc);
}
static int
sysctl_xprop_reg_addr_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
ssize_t buf_size = 64;
char buf[buf_size];
struct sbuf *sb;
unsigned int reg;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
axgbe_printf(2, "READ: %s: sysctl_xprop_reg: 0x%x\n", __func__,
pdata->sysctl_xprop_reg);
sbuf_printf(sb, "\nXPROP reg_addr: 0x%x\n",
pdata->sysctl_xprop_reg);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
sscanf(buf, "%x", &reg);
axgbe_printf(2, "WRITE: %s: reg: 0x%x\n", __func__, reg);
pdata->sysctl_xprop_reg = reg;
}
axgbe_printf(2, "%s: rc= %d\n", __func__, rc);
return (rc);
}
static int
sysctl_xprop_reg_value_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
ssize_t buf_size = 64;
char buf[buf_size];
unsigned int value;
struct sbuf *sb;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
value = XP_IOREAD(pdata, pdata->sysctl_xprop_reg);
axgbe_printf(2, "READ: %s: value: 0x%x\n", __func__, value);
sbuf_printf(sb, "\nXPROP reg_value: 0x%x\n", value);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
sscanf(buf, "%x", &value);
axgbe_printf(2, "WRITE: %s: value: 0x%x\n", __func__, value);
XP_IOWRITE(pdata, pdata->sysctl_xprop_reg, value);
}
axgbe_printf(2, "%s: rc= %d\n", __func__, rc);
return (rc);
}
static int
sysctl_xi2c_reg_addr_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
ssize_t buf_size = 64;
char buf[buf_size];
struct sbuf *sb;
unsigned int reg;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
axgbe_printf(2, "READ: %s: sysctl_xi2c_reg: 0x%x\n", __func__,
pdata->sysctl_xi2c_reg);
sbuf_printf(sb, "\nXI2C reg_addr: 0x%x\n",
pdata->sysctl_xi2c_reg);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
sscanf(buf, "%x", &reg);
axgbe_printf(2, "WRITE: %s: reg: 0x%x\n", __func__, reg);
pdata->sysctl_xi2c_reg = reg;
}
axgbe_printf(2, "%s: rc= %d\n", __func__, rc);
return (rc);
}
static int
sysctl_xi2c_reg_value_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
ssize_t buf_size = 64;
char buf[buf_size];
unsigned int value;
struct sbuf *sb;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
value = XI2C_IOREAD(pdata, pdata->sysctl_xi2c_reg);
axgbe_printf(2, "READ: %s: value: 0x%x\n", __func__, value);
sbuf_printf(sb, "\nXI2C reg_value: 0x%x\n", value);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
sscanf(buf, "%x", &value);
axgbe_printf(2, "WRITE: %s: value: 0x%x\n", __func__, value);
XI2C_IOWRITE(pdata, pdata->sysctl_xi2c_reg, value);
}
axgbe_printf(2, "%s: rc= %d\n", __func__, rc);
return (rc);
}
static int
sysctl_an_cdr_wr_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
unsigned int an_cdr_wr = 0;
ssize_t buf_size = 64;
char buf[buf_size];
struct sbuf *sb;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
axgbe_printf(2, "READ: %s: an_cdr_wr: %d\n", __func__,
pdata->sysctl_an_cdr_workaround);
sbuf_printf(sb, "%d\n", pdata->sysctl_an_cdr_workaround);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
sscanf(buf, "%u", &an_cdr_wr);
axgbe_printf(2, "WRITE: %s: an_cdr_wr: 0x%d\n", __func__,
an_cdr_wr);
if (an_cdr_wr)
pdata->sysctl_an_cdr_workaround = 1;
else
pdata->sysctl_an_cdr_workaround = 0;
}
axgbe_printf(2, "%s: rc= %d\n", __func__, rc);
return (rc);
}
static int
sysctl_an_cdr_track_early_handler(SYSCTL_HANDLER_ARGS)
{
struct xgbe_prv_data *pdata = (struct xgbe_prv_data *)arg1;
unsigned int an_cdr_track_early = 0;
ssize_t buf_size = 64;
char buf[buf_size];
struct sbuf *sb;
int rc = 0;
if (req->newptr == NULL) {
sb = sbuf_new_for_sysctl(NULL, NULL, buf_size, req);
if (sb == NULL) {
rc = sb->s_error;
return (rc);
}
axgbe_printf(2, "READ: %s: an_cdr_track_early %d\n", __func__,
pdata->sysctl_an_cdr_track_early);
sbuf_printf(sb, "%d\n", pdata->sysctl_an_cdr_track_early);
rc = sbuf_finish(sb);
sbuf_delete(sb);
return (rc);
}
rc = get_ubuf(req, buf);
if (rc == 0) {
sscanf(buf, "%u", &an_cdr_track_early);
axgbe_printf(2, "WRITE: %s: an_cdr_track_early: %d\n", __func__,
an_cdr_track_early);
if (an_cdr_track_early)
pdata->sysctl_an_cdr_track_early = 1;
else
pdata->sysctl_an_cdr_track_early = 0;
}
axgbe_printf(2, "%s: rc= %d\n", __func__, rc);
return (rc);
}
void
axgbe_sysctl_exit(struct xgbe_prv_data *pdata)
{
if (pdata->sys_op)
free(pdata->sys_op, M_AXGBE);
}
void
axgbe_sysctl_init(struct xgbe_prv_data *pdata)
{
struct sysctl_ctx_list *clist;
struct sysctl_oid_list *top;
struct sysctl_oid *parent;
struct sysctl_op *sys_op;
sys_op = malloc(sizeof(*sys_op), M_AXGBE, M_WAITOK | M_ZERO);
pdata->sys_op = sys_op;
clist = device_get_sysctl_ctx(pdata->dev);
parent = device_get_sysctl_tree(pdata->dev);
top = SYSCTL_CHILDREN(parent);
/* Set defaults */
pdata->sysctl_xgmac_reg = 0;
pdata->sysctl_xpcs_mmd = 1;
pdata->sysctl_xpcs_reg = 0;
SYSCTL_ADD_UINT(clist, top, OID_AUTO, "axgbe_debug_level", CTLFLAG_RWTUN,
&pdata->debug_level, 0, "axgbe log level -- higher is verbose");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "xgmac_register",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_xgmac_reg_addr_handler, "IU",
"xgmac register addr");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "xgmac_register_value",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_xgmac_reg_value_handler, "IU",
"xgmac register value");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "xpcs_mmd",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_xpcs_mmd_reg_handler, "IU", "xpcs mmd register");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "xpcs_register",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_xpcs_reg_addr_handler, "IU", "xpcs register");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "xpcs_register_value",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_xpcs_reg_value_handler, "IU",
"xpcs register value");
if (pdata->xpcs_res) {
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "xprop_register",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_xprop_reg_addr_handler,
"IU", "xprop register");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "xprop_register_value",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_xprop_reg_value_handler,
"IU", "xprop register value");
}
if (pdata->xpcs_res) {
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "xi2c_register",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_xi2c_reg_addr_handler,
"IU", "xi2c register");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "xi2c_register_value",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_xi2c_reg_value_handler,
"IU", "xi2c register value");
}
if (pdata->vdata->an_cdr_workaround) {
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "an_cdr_workaround",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_an_cdr_wr_handler, "IU",
"an cdr workaround");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "an_cdr_track_early",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_an_cdr_track_early_handler, "IU",
"an cdr track early");
}
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "drv_info",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_get_drv_info_handler, "IU",
"xgbe drv info");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "link_info",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_get_link_info_handler, "IU",
"xgbe link info");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "coalesce_info",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_coalesce_handler, "IU",
"xgbe coalesce info");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "pauseparam_info",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_pauseparam_handler, "IU",
"xgbe pauseparam info");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "link_ksettings_info",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_link_ksettings_handler, "IU",
"xgbe link_ksettings info");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "ringparam_info",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_ringparam_handler, "IU",
"xgbe ringparam info");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "channels_info",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_channels_handler, "IU",
"xgbe channels info");
SYSCTL_ADD_PROC(clist, top, OID_AUTO, "mac_stats",
CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
pdata, 0, sysctl_mac_stats_handler, "IU",
"xgbe mac stats");
}