void
randomdev_init(void)
{
#ifndef __OSV__
struct sysctl_oid *random_sys_o, *random_sys_harvest_o;
#endif
#if defined(RANDOM_YARROW)
random_yarrow_init_alg(/*&random_clist*/);
#endif
#if defined(RANDOM_FORTUNA)
random_fortuna_init_alg(/*&random_clist*/);
#endif
#ifndef __OSV__
random_sys_o = SYSCTL_ADD_NODE(&random_clist,
SYSCTL_STATIC_CHILDREN(_kern_random),
OID_AUTO, "sys", CTLFLAG_RW, 0,
"Entropy Device Parameters");
SYSCTL_ADD_PROC(&random_clist,
SYSCTL_CHILDREN(random_sys_o),
OID_AUTO, "seeded", CTLTYPE_INT | CTLFLAG_RW,
&random_context.seeded, 0, random_check_boolean, "I",
"Seeded State");
random_sys_harvest_o = SYSCTL_ADD_NODE(&random_clist,
SYSCTL_CHILDREN(random_sys_o),
OID_AUTO, "harvest", CTLFLAG_RW, 0,
"Entropy Sources");
SYSCTL_ADD_PROC(&random_clist,
SYSCTL_CHILDREN(random_sys_harvest_o),
OID_AUTO, "ethernet", CTLTYPE_INT | CTLFLAG_RW,
&harvest.ethernet, 1, random_check_boolean, "I",
"Harvest NIC entropy");
SYSCTL_ADD_PROC(&random_clist,
SYSCTL_CHILDREN(random_sys_harvest_o),
OID_AUTO, "point_to_point", CTLTYPE_INT | CTLFLAG_RW,
&harvest.point_to_point, 1, random_check_boolean, "I",
"Harvest serial net entropy");
SYSCTL_ADD_PROC(&random_clist,
SYSCTL_CHILDREN(random_sys_harvest_o),
OID_AUTO, "interrupt", CTLTYPE_INT | CTLFLAG_RW,
&harvest.interrupt, 1, random_check_boolean, "I",
"Harvest IRQ entropy");
SYSCTL_ADD_PROC(&random_clist,
SYSCTL_CHILDREN(random_sys_harvest_o),
OID_AUTO, "swi", CTLTYPE_INT | CTLFLAG_RW,
&harvest.swi, 1, random_check_boolean, "I",
"Harvest SWI entropy");
#endif
random_harvestq_init(random_process_event);
/* Register the randomness harvesting routine */
randomdev_init_harvester(random_harvestq_internal,
random_context.read);
}
void
nvme_sysctl_initialize_ctrlr(struct nvme_controller *ctrlr)
{
struct sysctl_ctx_list *ctrlr_ctx;
struct sysctl_oid *ctrlr_tree, *que_tree;
struct sysctl_oid_list *ctrlr_list;
#define QUEUE_NAME_LENGTH 16
char queue_name[QUEUE_NAME_LENGTH];
int i;
ctrlr_ctx = device_get_sysctl_ctx(ctrlr->dev);
ctrlr_tree = device_get_sysctl_tree(ctrlr->dev);
ctrlr_list = SYSCTL_CHILDREN(ctrlr_tree);
SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
"int_coal_time", CTLTYPE_UINT | CTLFLAG_RW, ctrlr, 0,
nvme_sysctl_int_coal_time, "IU",
"Interrupt coalescing timeout (in microseconds)");
SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
"int_coal_threshold", CTLTYPE_UINT | CTLFLAG_RW, ctrlr, 0,
nvme_sysctl_int_coal_threshold, "IU",
"Interrupt coalescing threshold");
SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
"timeout_period", CTLTYPE_UINT | CTLFLAG_RW, ctrlr, 0,
nvme_sysctl_timeout_period, "IU",
"Timeout period (in seconds)");
SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
"num_cmds", CTLTYPE_S64 | CTLFLAG_RD,
ctrlr, 0, nvme_sysctl_num_cmds, "IU",
"Number of commands submitted");
SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
"num_intr_handler_calls", CTLTYPE_S64 | CTLFLAG_RD,
ctrlr, 0, nvme_sysctl_num_intr_handler_calls, "IU",
"Number of times interrupt handler was invoked (will "
"typically be less than number of actual interrupts "
"generated due to coalescing)");
SYSCTL_ADD_PROC(ctrlr_ctx, ctrlr_list, OID_AUTO,
"reset_stats", CTLTYPE_UINT | CTLFLAG_RW, ctrlr, 0,
nvme_sysctl_reset_stats, "IU", "Reset statistics to zero");
que_tree = SYSCTL_ADD_NODE(ctrlr_ctx, ctrlr_list, OID_AUTO, "adminq",
CTLFLAG_RD, NULL, "Admin Queue");
nvme_sysctl_initialize_queue(&ctrlr->adminq, ctrlr_ctx, que_tree);
for (i = 0; i < ctrlr->num_io_queues; i++) {
snprintf(queue_name, QUEUE_NAME_LENGTH, "ioq%d", i);
que_tree = SYSCTL_ADD_NODE(ctrlr_ctx, ctrlr_list, OID_AUTO,
queue_name, CTLFLAG_RD, NULL, "IO Queue");
nvme_sysctl_initialize_queue(&ctrlr->ioq[i], ctrlr_ctx,
que_tree);
}
}
void
ptx_sysctl_init(device_t device, struct ptx_softc *scp)
{
struct sysctl_ctx_list *scl;
struct sysctl_oid_list *sol;
struct sysctl_oid *soid;
scl = device_get_sysctl_ctx(device);
sol = SYSCTL_CHILDREN(device_get_sysctl_tree(device));
SYSCTL_ADD_PROC(scl, sol,
OID_AUTO, "lnb", CTLTYPE_INT|CTLFLAG_RW|CTLFLAG_ANYBODY,
scp, 0, sysctl_lnb, "I", "LNB");
soid = SYSCTL_ADD_NODE(scl, sol,
OID_AUTO, "s0", CTLFLAG_RD, 0, "ISDB-S tuner0");
SYSCTL_ADD_PROC(scl, SYSCTL_CHILDREN(soid),
OID_AUTO, "freq", CTLTYPE_INT|CTLFLAG_WR|CTLFLAG_ANYBODY,
scp->dev[0], 0, sysctl_freq, "I", "channel freq.");
SYSCTL_ADD_PROC(scl, SYSCTL_CHILDREN(soid),
OID_AUTO, "signal", CTLTYPE_INT|CTLFLAG_RD,
scp->dev[0], 0, sysctl_signal, "I", "signal strength");
soid = SYSCTL_ADD_NODE(scl, sol,
OID_AUTO, "t0", CTLFLAG_RD, 0, "ISDB-T tuner0");
SYSCTL_ADD_PROC(scl, SYSCTL_CHILDREN(soid),
OID_AUTO, "freq", CTLTYPE_INT|CTLFLAG_WR|CTLFLAG_ANYBODY,
scp->dev[1], 0, sysctl_freq, "I", "channel freq.");
SYSCTL_ADD_PROC(scl, SYSCTL_CHILDREN(soid),
OID_AUTO, "signal", CTLTYPE_INT|CTLFLAG_RD,
scp->dev[1], 0, sysctl_signal, "I", "signal strength");
soid = SYSCTL_ADD_NODE(scl, sol,
OID_AUTO, "s1", CTLFLAG_RD, 0, "ISDB-S tuner1");
SYSCTL_ADD_PROC(scl, SYSCTL_CHILDREN(soid),
OID_AUTO, "freq", CTLTYPE_INT|CTLFLAG_WR|CTLFLAG_ANYBODY,
scp->dev[2], 0, sysctl_freq, "I", "channel freq.");
SYSCTL_ADD_PROC(scl, SYSCTL_CHILDREN(soid),
OID_AUTO, "signal", CTLTYPE_INT|CTLFLAG_RD,
scp->dev[2], 0, sysctl_signal, "I", "signal strength");
soid = SYSCTL_ADD_NODE(scl, sol,
OID_AUTO, "t1", CTLFLAG_RD, 0, "ISDB-S tuner1");
SYSCTL_ADD_PROC(scl, SYSCTL_CHILDREN(soid),
OID_AUTO, "freq", CTLTYPE_INT|CTLFLAG_WR|CTLFLAG_ANYBODY,
scp->dev[3], 0, sysctl_freq, "I", "channel freq.");
SYSCTL_ADD_PROC(scl, SYSCTL_CHILDREN(soid),
OID_AUTO, "signal", CTLTYPE_INT|CTLFLAG_RD,
scp->dev[3], 0, sysctl_signal, "I", "signal strength");
}
static void
pmpsysctlinit(void *context, int pending)
{
struct cam_periph *periph;
struct pmp_softc *softc;
char tmpstr[80], tmpstr2[80];
periph = (struct cam_periph *)context;
if (cam_periph_acquire(periph) != CAM_REQ_CMP)
return;
softc = (struct pmp_softc *)periph->softc;
snprintf(tmpstr, sizeof(tmpstr), "CAM PMP unit %d", periph->unit_number);
snprintf(tmpstr2, sizeof(tmpstr2), "%d", periph->unit_number);
sysctl_ctx_init(&softc->sysctl_ctx);
softc->flags |= PMP_FLAG_SCTX_INIT;
softc->sysctl_tree = SYSCTL_ADD_NODE(&softc->sysctl_ctx,
SYSCTL_STATIC_CHILDREN(_kern_cam_pmp), OID_AUTO, tmpstr2,
CTLFLAG_RD, 0, tmpstr);
if (softc->sysctl_tree == NULL) {
printf("pmpsysctlinit: unable to allocate sysctl tree\n");
cam_periph_release(periph);
return;
}
cam_periph_release(periph);
}
/*
* Create the OS-specific port helper thread and per-port lock.
*/
void
ahci_os_start_port(struct ahci_port *ap)
{
char name[16];
atomic_set_int(&ap->ap_signal, AP_SIGF_INIT | AP_SIGF_THREAD_SYNC);
lockinit(&ap->ap_lock, "ahcipo", 0, 0);
lockinit(&ap->ap_sim_lock, "ahcicam", 0, LK_CANRECURSE);
lockinit(&ap->ap_sig_lock, "ahport", 0, 0);
sysctl_ctx_init(&ap->sysctl_ctx);
ksnprintf(name, sizeof(name), "%d", ap->ap_num);
ap->sysctl_tree = SYSCTL_ADD_NODE(&ap->sysctl_ctx,
SYSCTL_CHILDREN(ap->ap_sc->sysctl_tree),
OID_AUTO, name, CTLFLAG_RD, 0, "");
if ((ap->ap_sc->sc_cap & AHCI_REG_CAP_SALP) &&
(ap->ap_sc->sc_cap & (AHCI_REG_CAP_PSC | AHCI_REG_CAP_SSC))) {
SYSCTL_ADD_PROC(&ap->sysctl_ctx,
SYSCTL_CHILDREN(ap->sysctl_tree), OID_AUTO,
"link_pwr_mgmt", CTLTYPE_INT | CTLFLAG_RW, ap, 0,
ahci_sysctl_link_pwr_mgmt, "I",
"Link power management policy "
"(0 = disabled, 1 = medium, 2 = aggressive)");
SYSCTL_ADD_PROC(&ap->sysctl_ctx,
SYSCTL_CHILDREN(ap->sysctl_tree), OID_AUTO,
"link_pwr_state", CTLTYPE_STRING | CTLFLAG_RD, ap, 0,
ahci_sysctl_link_pwr_state, "A",
"Link power management state");
}
kthread_create(ahci_port_thread, ap, &ap->ap_thread,
"%s", PORTNAME(ap));
}
static int
canbus_attach(device_t dev)
{
struct canbus_softc *sc = device_get_softc(dev);
struct sysctl_oid *canbus_sysctl_tree;
sc->io_delay_time = CANBE_IO_DELAY_TIME;
/* I/O resource setup */
if(alloc_ioresource(dev))
return (ENXIO);
/* Dynamic sysctl tree setup */
sysctl_ctx_init(&sc->canbus_sysctl_ctx);
canbus_sysctl_tree = SYSCTL_ADD_NODE(&sc->canbus_sysctl_ctx,
SYSCTL_STATIC_CHILDREN(/* tree top */), OID_AUTO,
"canbus", CTLFLAG_RD, 0, "CanBe I/O Bus");
SYSCTL_ADD_INT(&sc->canbus_sysctl_ctx,
SYSCTL_CHILDREN(canbus_sysctl_tree), OID_AUTO, "io_delay_time",
CTLFLAG_RW, &sc->io_delay_time, 0, "CanBe Bus I/O delay time");
bus_generic_probe(dev);
bus_generic_attach(dev);
return (0);
}
/*
* This doesn't necessarily belong here (because it's HAL related, not
* driver related).
*/
void
ath_sysctl_hal_attach(struct ath_softc *sc)
{
struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree);
tree = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "hal", CTLFLAG_RD,
NULL, "Atheros HAL parameters");
child = SYSCTL_CHILDREN(tree);
sc->sc_ah->ah_config.ah_debug = 0;
SYSCTL_ADD_INT(ctx, child, OID_AUTO, "debug", CTLFLAG_RW,
&sc->sc_ah->ah_config.ah_debug, 0, "Atheros HAL debugging printfs");
sc->sc_ah->ah_config.ah_ar5416_biasadj = 0;
SYSCTL_ADD_INT(ctx, child, OID_AUTO, "ar5416_biasadj", CTLFLAG_RW,
&sc->sc_ah->ah_config.ah_ar5416_biasadj, 0,
"Enable 2GHz AR5416 direction sensitivity bias adjust");
sc->sc_ah->ah_config.ah_dma_beacon_response_time = 2;
SYSCTL_ADD_INT(ctx, child, OID_AUTO, "dma_brt", CTLFLAG_RW,
&sc->sc_ah->ah_config.ah_dma_beacon_response_time, 0,
"Atheros HAL DMA beacon response time");
sc->sc_ah->ah_config.ah_sw_beacon_response_time = 10;
SYSCTL_ADD_INT(ctx, child, OID_AUTO, "sw_brt", CTLFLAG_RW,
&sc->sc_ah->ah_config.ah_sw_beacon_response_time, 0,
"Atheros HAL software beacon response time");
sc->sc_ah->ah_config.ah_additional_swba_backoff = 0;
SYSCTL_ADD_INT(ctx, child, OID_AUTO, "swba_backoff", CTLFLAG_RW,
&sc->sc_ah->ah_config.ah_additional_swba_backoff, 0,
"Atheros HAL additional SWBA backoff time");
}
void
random_fortuna_init_alg(void)
{
int i;
#ifdef _KERNEL
struct sysctl_oid *random_fortuna_o;
#endif
memset(fortuna_start_cache.junk, 0, sizeof(fortuna_start_cache.junk));
fortuna_start_cache.length = 0U;
randomdev_hash_init(&fortuna_start_cache.hash);
/* Set up a lock for the reseed process */
#ifdef _KERNEL
mtx_init(&random_reseed_mtx, "reseed mutex", NULL, MTX_DEF);
#else /* !_KERNEL */
mtx_init(&random_reseed_mtx, mtx_plain);
#endif /* _KERNEL */
#ifdef _KERNEL
/* Fortuna parameters. Do not adjust these unless you have
* have a very good clue about what they do!
*/
random_fortuna_o = SYSCTL_ADD_NODE(&random_clist,
SYSCTL_STATIC_CHILDREN(_kern_random),
OID_AUTO, "fortuna", CTLFLAG_RW, 0,
"Fortuna Parameters");
SYSCTL_ADD_PROC(&random_clist,
SYSCTL_CHILDREN(random_fortuna_o), OID_AUTO,
"minpoolsize", CTLTYPE_UINT|CTLFLAG_RW,
&fortuna_state.minpoolsize, DEFPOOLSIZE,
random_check_uint_minpoolsize, "IU",
"Minimum pool size necessary to cause a reseed automatically");
fortuna_state.lasttime = 0U;
#endif
fortuna_state.minpoolsize = DEFPOOLSIZE;
/* F&S - InitializePRNG() */
/* F&S - P_i = \epsilon */
for (i = 0; i < NPOOLS; i++) {
randomdev_hash_init(&fortuna_state.pool[i].hash);
fortuna_state.pool[i].length = 0U;
}
/* F&S - ReseedCNT = 0 */
fortuna_state.reseedcount = 0U;
/* F&S - InitializeGenerator() */
/* F&S - C = 0 */
uint128_clear(&fortuna_state.counter.whole);
/* F&S - K = 0 */
memset(&fortuna_state.key, 0, sizeof(fortuna_state.key));
}
/*
* Initialize a new timecounter and possibly use it.
*/
void
tc_init(struct timecounter *tc)
{
u_int u;
struct sysctl_oid *tc_root;
u = tc->tc_frequency / tc->tc_counter_mask;
/* XXX: We need some margin here, 10% is a guess */
u *= 11;
u /= 10;
if (u > hz && tc->tc_quality >= 0) {
tc->tc_quality = -2000;
if (bootverbose) {
printf("Timecounter \"%s\" frequency %ju Hz",
tc->tc_name, (uintmax_t)tc->tc_frequency);
printf(" -- Insufficient hz, needs at least %u\n", u);
}
} else if (tc->tc_quality >= 0 || bootverbose) {
printf("Timecounter \"%s\" frequency %ju Hz quality %d\n",
tc->tc_name, (uintmax_t)tc->tc_frequency,
tc->tc_quality);
}
tc->tc_next = timecounters;
timecounters = tc;
/*
* Set up sysctl tree for this counter.
*/
tc_root = SYSCTL_ADD_NODE(NULL,
SYSCTL_STATIC_CHILDREN(_kern_timecounter_tc), OID_AUTO, tc->tc_name,
CTLFLAG_RW, 0, "timecounter description");
SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(tc_root), OID_AUTO,
"mask", CTLFLAG_RD, &(tc->tc_counter_mask), 0,
"mask for implemented bits");
SYSCTL_ADD_PROC(NULL, SYSCTL_CHILDREN(tc_root), OID_AUTO,
"counter", CTLTYPE_UINT | CTLFLAG_RD, tc, sizeof(*tc),
sysctl_kern_timecounter_get, "IU", "current timecounter value");
SYSCTL_ADD_PROC(NULL, SYSCTL_CHILDREN(tc_root), OID_AUTO,
"frequency", CTLTYPE_U64 | CTLFLAG_RD, tc, sizeof(*tc),
sysctl_kern_timecounter_freq, "QU", "timecounter frequency");
SYSCTL_ADD_INT(NULL, SYSCTL_CHILDREN(tc_root), OID_AUTO,
"quality", CTLFLAG_RD, &(tc->tc_quality), 0,
"goodness of time counter");
/*
* Never automatically use a timecounter with negative quality.
* Even though we run on the dummy counter, switching here may be
* worse since this timecounter may not be monotonous.
*/
if (tc->tc_quality < 0)
return;
if (tc->tc_quality < timecounter->tc_quality)
return;
if (tc->tc_quality == timecounter->tc_quality &&
tc->tc_frequency < timecounter->tc_frequency)
return;
(void)tc->tc_get_timecount(tc);
(void)tc->tc_get_timecount(tc);
timecounter = tc;
}
static void
ti_adc_sysctl_init(struct ti_adc_softc *sc)
{
char pinbuf[3];
struct sysctl_ctx_list *ctx;
struct sysctl_oid *tree_node, *inp_node, *inpN_node;
struct sysctl_oid_list *tree, *inp_tree, *inpN_tree;
int ain;
/*
* Add per-pin sysctl tree/handlers.
*/
ctx = device_get_sysctl_ctx(sc->sc_dev);
tree_node = device_get_sysctl_tree(sc->sc_dev);
tree = SYSCTL_CHILDREN(tree_node);
SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "clockdiv",
CTLFLAG_RW | CTLTYPE_UINT, sc, 0,
ti_adc_clockdiv_proc, "IU", "ADC clock prescaler");
inp_node = SYSCTL_ADD_NODE(ctx, tree, OID_AUTO, "ain",
CTLFLAG_RD, NULL, "ADC inputs");
inp_tree = SYSCTL_CHILDREN(inp_node);
for (ain = 0; ain < TI_ADC_NPINS; ain++) {
snprintf(pinbuf, sizeof(pinbuf), "%d", ain);
inpN_node = SYSCTL_ADD_NODE(ctx, inp_tree, OID_AUTO, pinbuf,
CTLFLAG_RD, NULL, "ADC input");
inpN_tree = SYSCTL_CHILDREN(inpN_node);
SYSCTL_ADD_PROC(ctx, inpN_tree, OID_AUTO, "enable",
CTLFLAG_RW | CTLTYPE_UINT, &ti_adc_inputs[ain], 0,
ti_adc_enable_proc, "IU", "Enable ADC input");
SYSCTL_ADD_PROC(ctx, inpN_tree, OID_AUTO, "open_delay",
CTLFLAG_RW | CTLTYPE_UINT, &ti_adc_inputs[ain], 0,
ti_adc_open_delay_proc, "IU", "ADC open delay");
SYSCTL_ADD_PROC(ctx, inpN_tree, OID_AUTO, "samples_avg",
CTLFLAG_RW | CTLTYPE_UINT, &ti_adc_inputs[ain], 0,
ti_adc_samples_avg_proc, "IU", "ADC samples average");
SYSCTL_ADD_INT(ctx, inpN_tree, OID_AUTO, "input",
CTLFLAG_RD, &ti_adc_inputs[ain].value, 0,
"Converted raw value for the ADC input");
}
}
static int
zy7_devcfg_init_fclk_sysctl(struct zy7_devcfg_softc *sc)
{
struct sysctl_oid *fclk_node;
char fclk_num[4];
int i;
sysctl_ctx_init(&sc->sysctl_tree);
sc->sysctl_tree_top = SYSCTL_ADD_NODE(&sc->sysctl_tree,
SYSCTL_STATIC_CHILDREN(_hw_fpga), OID_AUTO, "fclk",
CTLFLAG_RD, 0, "");
if (sc->sysctl_tree_top == NULL) {
sysctl_ctx_free(&sc->sysctl_tree);
return (-1);
}
for (i = 0; i < FCLK_NUM; i++) {
snprintf(fclk_num, sizeof(fclk_num), "%d", i);
fclk_node = SYSCTL_ADD_NODE(&sc->sysctl_tree,
SYSCTL_CHILDREN(sc->sysctl_tree_top), OID_AUTO, fclk_num,
CTLFLAG_RD, 0, "");
SYSCTL_ADD_INT(&sc->sysctl_tree,
SYSCTL_CHILDREN(fclk_node), OID_AUTO,
"actual_freq", CTLFLAG_RD,
&fclk_configs[i].actual_frequency, i,
"Actual frequency");
SYSCTL_ADD_PROC(&sc->sysctl_tree,
SYSCTL_CHILDREN(fclk_node), OID_AUTO,
"freq", CTLFLAG_RW | CTLTYPE_INT,
&fclk_configs[i], i,
zy7_devcfg_fclk_sysctl_freq,
"I", "Configured frequency");
SYSCTL_ADD_PROC(&sc->sysctl_tree,
SYSCTL_CHILDREN(fclk_node), OID_AUTO,
"source", CTLFLAG_RW | CTLTYPE_STRING,
&fclk_configs[i], i,
zy7_devcfg_fclk_sysctl_source,
"A", "Clock source");
}
return (0);
}
void
mlx5e_create_ethtool(struct mlx5e_priv *priv)
{
struct sysctl_oid *node;
const char *pnameunit;
unsigned x;
/* set some defaults */
priv->params_ethtool.tx_queue_size_max = 1 << MLX5E_PARAMS_MAXIMUM_LOG_SQ_SIZE;
priv->params_ethtool.rx_queue_size_max = 1 << MLX5E_PARAMS_MAXIMUM_LOG_RQ_SIZE;
priv->params_ethtool.tx_queue_size = 1 << priv->params.log_sq_size;
priv->params_ethtool.rx_queue_size = 1 << priv->params.log_rq_size;
priv->params_ethtool.channels = priv->params.num_channels;
priv->params_ethtool.coalesce_pkts_max = MLX5E_FLD_MAX(cqc, cq_max_count);
priv->params_ethtool.coalesce_usecs_max = MLX5E_FLD_MAX(cqc, cq_period);
priv->params_ethtool.rx_coalesce_mode = priv->params.rx_cq_moderation_mode;
priv->params_ethtool.rx_coalesce_usecs = priv->params.rx_cq_moderation_usec;
priv->params_ethtool.rx_coalesce_pkts = priv->params.rx_cq_moderation_pkts;
priv->params_ethtool.tx_coalesce_usecs = priv->params.tx_cq_moderation_usec;
priv->params_ethtool.tx_coalesce_pkts = priv->params.tx_cq_moderation_pkts;
priv->params_ethtool.hw_lro = priv->params.hw_lro_en;
/* create root node */
node = SYSCTL_ADD_NODE(&priv->sysctl_ctx,
SYSCTL_CHILDREN(priv->sysctl_dev), OID_AUTO,
"conf", CTLFLAG_RW, NULL, "Configuration");
if (node == NULL)
return;
for (x = 0; x != MLX5E_PARAMS_NUM; x++) {
/* check for read-only parameter */
if (strstr(mlx5e_params_desc[2 * x], "_max") != NULL) {
SYSCTL_ADD_PROC(&priv->sysctl_ctx, SYSCTL_CHILDREN(node), OID_AUTO,
mlx5e_params_desc[2 * x], CTLTYPE_U64 | CTLFLAG_RD |
CTLFLAG_MPSAFE, priv, x, &mlx5e_ethtool_handler, "QU",
mlx5e_params_desc[2 * x + 1]);
} else {
SYSCTL_ADD_PROC(&priv->sysctl_ctx, SYSCTL_CHILDREN(node), OID_AUTO,
mlx5e_params_desc[2 * x], CTLTYPE_U64 | CTLFLAG_RWTUN |
CTLFLAG_MPSAFE, priv, x, &mlx5e_ethtool_handler, "QU",
mlx5e_params_desc[2 * x + 1]);
}
}
SYSCTL_ADD_PROC(&priv->sysctl_ctx, SYSCTL_CHILDREN(node), OID_AUTO,
"debug_stats", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_MPSAFE, priv,
0, &mlx5e_ethtool_debug_stats, "I", "Extended debug statistics");
pnameunit = device_get_nameunit(priv->mdev->pdev->dev.bsddev);
SYSCTL_ADD_STRING(&priv->sysctl_ctx, SYSCTL_CHILDREN(node),
OID_AUTO, "device_name", CTLFLAG_RD,
__DECONST(void *, pnameunit), 0,
"PCI device name");
}
static int
acpi_panasonic_attach(device_t dev)
{
struct acpi_panasonic_softc *sc;
struct acpi_softc *acpi_sc;
ACPI_STATUS status;
int i;
sc = device_get_softc(dev);
sc->dev = dev;
sc->handle = acpi_get_handle(dev);
acpi_sc = acpi_device_get_parent_softc(dev);
/* Build sysctl tree */
sysctl_ctx_init(&sc->sysctl_ctx);
sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO,
"panasonic", CTLFLAG_RD, 0, "");
for (i = 0; sysctl_table[i].name != NULL; i++) {
SYSCTL_ADD_PROC(&sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
sysctl_table[i].name,
CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
sc, i, acpi_panasonic_sysctl, "I", "");
}
#if 0
/* Activate hotkeys */
status = AcpiEvaluateObject(sc->handle, "", NULL, NULL);
if (ACPI_FAILURE(status)) {
device_printf(dev, "enable FN keys failed\n");
sysctl_ctx_free(&sc->sysctl_ctx);
return (ENXIO);
}
#endif
/* Handle notifies */
status = AcpiInstallNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY,
acpi_panasonic_notify, sc);
if (ACPI_FAILURE(status)) {
device_printf(dev, "couldn't install notify handler - %s\n",
AcpiFormatException(status));
sysctl_ctx_free(&sc->sysctl_ctx);
return (ENXIO);
}
/* Install power profile event handler */
sc->power_evh = EVENTHANDLER_REGISTER(power_profile_change,
acpi_panasonic_power_profile, sc->handle, 0);
return (0);
}
static void
ath_sysctl_stats_attach_rxphyerr(struct ath_softc *sc, struct sysctl_oid_list *parent)
{
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree);
int i;
char sn[8];
tree = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO, "rx_phy_err", CTLFLAG_RD, NULL, "Per-code RX PHY Errors");
child = SYSCTL_CHILDREN(tree);
for (i = 0; i < 64; i++) {
snprintf(sn, sizeof(sn), "%d", i);
SYSCTL_ADD_UINT(ctx, child, OID_AUTO, sn, CTLFLAG_RD, &sc->sc_stats.ast_rx_phy[i], 0, "");
}
}
static void
vmm_init(void)
{
sysctl_ctx_init(&vmm_sysctl_ctx);
vmm_sysctl_tree = SYSCTL_ADD_NODE(&vmm_sysctl_ctx,
SYSCTL_STATIC_CHILDREN(_hw),
OID_AUTO, "vmm",
CTLFLAG_RD, 0, "VMM options");
if (cpu_vendor_id == CPU_VENDOR_INTEL) {
ctl = get_ctl_intel();
} else if (cpu_vendor_id == CPU_VENDOR_AMD) {
ctl = get_ctl_amd();
}
if (ctl->init()) {
SYSCTL_ADD_INT(&vmm_sysctl_ctx,
SYSCTL_CHILDREN(vmm_sysctl_tree),
OID_AUTO, "enable", CTLFLAG_RD,
&vmm_enabled, 0,
"enable not supported");
} else {
SYSCTL_ADD_STRING(&vmm_sysctl_ctx,
SYSCTL_CHILDREN(vmm_sysctl_tree),
OID_AUTO, "type", CTLFLAG_RD,
ctl->name, 0,
"Type of the VMM");
SYSCTL_ADD_PROC(&vmm_sysctl_ctx,
SYSCTL_CHILDREN(vmm_sysctl_tree),
OID_AUTO, "enable", CTLTYPE_INT | CTLFLAG_WR,
NULL, sizeof vmm_enabled, sysctl_vmm_enable, "I",
"Control the state of the VMM");
SYSCTL_ADD_INT(&vmm_sysctl_ctx,
SYSCTL_CHILDREN(vmm_sysctl_tree),
OID_AUTO, "debug", CTLTYPE_INT | CTLFLAG_RW,
&vmm_debug, 0,
"vmm debugging");
if (ctl->enable()) {
kprintf("VMM: vmm enable() failed\n");
} else {
vmm_enabled = 1;
}
EVENTHANDLER_REGISTER(shutdown_pre_sync, vmm_shutdown, NULL, SHUTDOWN_PRI_DEFAULT-1);
}
}
static int
tegra124_coretemp_attach(device_t dev)
{
struct tegra124_coretemp_softc *sc;
device_t pdev;
struct sysctl_oid *oid;
struct sysctl_ctx_list *ctx;
int rv;
sc = device_get_softc(dev);
sc->dev = dev;
sc->cpu_id = device_get_unit(dev);
sc->core_max_temp = 102000;
pdev = device_get_parent(dev);
rv = tegra124_coretemp_ofw_parse(sc);
if (rv != 0)
return (rv);
ctx = device_get_sysctl_ctx(dev);
oid = SYSCTL_ADD_NODE(ctx,
SYSCTL_CHILDREN(device_get_sysctl_tree(pdev)), OID_AUTO,
"coretemp", CTLFLAG_RD, NULL, "Per-CPU thermal information");
/*
* Add the MIBs to dev.cpu.N and dev.cpu.N.coretemp.
*/
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(device_get_sysctl_tree(pdev)),
OID_AUTO, "temperature", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
dev, CORETEMP_TEMP, coretemp_get_val_sysctl, "IK",
"Current temperature");
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, "delta",
CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, dev, CORETEMP_DELTA,
coretemp_get_val_sysctl, "I",
"Delta between TCC activation and current temperature");
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, "resolution",
CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, dev, CORETEMP_RESOLUTION,
coretemp_get_val_sysctl, "I",
"Resolution of CPU thermal sensor");
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO, "tjmax",
CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE, dev, CORETEMP_TJMAX,
coretemp_get_val_sysctl, "IK",
"TCC activation temperature");
return (0);
}
static int
sfxge_vpd_init(struct sfxge_softc *sc)
{
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->dev);
struct sysctl_oid *vpd_node;
struct sysctl_oid_list *vpd_list;
char keyword[3];
efx_vpd_value_t value;
int rc;
if ((rc = efx_vpd_size(sc->enp, &sc->vpd_size)) != 0)
goto fail;
sc->vpd_data = malloc(sc->vpd_size, M_SFXGE, M_WAITOK);
if ((rc = efx_vpd_read(sc->enp, sc->vpd_data, sc->vpd_size)) != 0)
goto fail2;
/* Copy ID (product name) into device description, and log it. */
value.evv_tag = EFX_VPD_ID;
if (efx_vpd_get(sc->enp, sc->vpd_data, sc->vpd_size, &value) == 0) {
value.evv_value[value.evv_length] = 0;
device_set_desc_copy(sc->dev, value.evv_value);
device_printf(sc->dev, "%s\n", value.evv_value);
}
vpd_node = SYSCTL_ADD_NODE(
ctx, SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)),
OID_AUTO, "vpd", CTLFLAG_RD, NULL, "Vital Product Data");
vpd_list = SYSCTL_CHILDREN(vpd_node);
/* Add sysctls for all expected and any vendor-defined keywords. */
sfxge_vpd_try_add(sc, vpd_list, EFX_VPD_RO, "PN");
sfxge_vpd_try_add(sc, vpd_list, EFX_VPD_RO, "EC");
sfxge_vpd_try_add(sc, vpd_list, EFX_VPD_RO, "SN");
keyword[0] = 'V';
keyword[2] = 0;
for (keyword[1] = '0'; keyword[1] <= '9'; keyword[1]++)
sfxge_vpd_try_add(sc, vpd_list, EFX_VPD_RO, keyword);
for (keyword[1] = 'A'; keyword[1] <= 'Z'; keyword[1]++)
sfxge_vpd_try_add(sc, vpd_list, EFX_VPD_RO, keyword);
return 0;
fail2:
free(sc->vpd_data, M_SFXGE);
fail:
return rc;
}
static void
poll_comm_init(int cpuid)
{
struct poll_comm *comm;
char cpuid_str[16];
comm = kmalloc(sizeof(*comm), M_DEVBUF, M_WAITOK | M_ZERO);
if (ifpoll_stfrac < 0)
ifpoll_stfrac = IFPOLL_STFRAC_DEFAULT;
if (ifpoll_txfrac < 0)
ifpoll_txfrac = IFPOLL_TXFRAC_DEFAULT;
comm->pollhz = ifpoll_pollhz;
comm->poll_cpuid = cpuid;
comm->poll_stfrac = ifpoll_stfrac;
comm->poll_txfrac = ifpoll_txfrac;
ksnprintf(cpuid_str, sizeof(cpuid_str), "%d", cpuid);
sysctl_ctx_init(&comm->sysctl_ctx);
comm->sysctl_tree = SYSCTL_ADD_NODE(&comm->sysctl_ctx,
SYSCTL_STATIC_CHILDREN(_net_ifpoll),
OID_AUTO, cpuid_str, CTLFLAG_RD, 0, "");
SYSCTL_ADD_PROC(&comm->sysctl_ctx, SYSCTL_CHILDREN(comm->sysctl_tree),
OID_AUTO, "pollhz", CTLTYPE_INT | CTLFLAG_RW,
comm, 0, sysctl_pollhz,
"I", "Device polling frequency");
if (cpuid == 0) {
SYSCTL_ADD_PROC(&comm->sysctl_ctx,
SYSCTL_CHILDREN(comm->sysctl_tree),
OID_AUTO, "status_frac",
CTLTYPE_INT | CTLFLAG_RW,
comm, 0, sysctl_stfrac,
"I", "# of cycles before status is polled");
}
SYSCTL_ADD_PROC(&comm->sysctl_ctx, SYSCTL_CHILDREN(comm->sysctl_tree),
OID_AUTO, "tx_frac", CTLTYPE_INT | CTLFLAG_RW,
comm, 0, sysctl_txfrac,
"I", "# of cycles before TX is polled");
poll_common[cpuid] = comm;
}
void
mlx5e_create_stats(struct sysctl_ctx_list *ctx,
struct sysctl_oid_list *parent, const char *buffer,
const char **desc, unsigned num, u64 * arg)
{
struct sysctl_oid *node;
unsigned x;
sysctl_ctx_init(ctx);
node = SYSCTL_ADD_NODE(ctx, parent, OID_AUTO,
buffer, CTLFLAG_RD, NULL, "Statistics");
if (node == NULL)
return;
for (x = 0; x != num; x++) {
SYSCTL_ADD_UQUAD(ctx, SYSCTL_CHILDREN(node), OID_AUTO,
desc[2 * x], CTLFLAG_RD, arg + x, desc[2 * x + 1]);
}
}
static int
ahci_attach (device_t dev)
{
struct ahci_softc *sc = device_get_softc(dev);
char name[16];
int error;
sc->sc_ad = ahci_lookup_device(dev);
if (sc->sc_ad == NULL)
return(ENXIO);
/*
* Some chipsets do not properly implement the AHCI spec and may
* require the link speed to be specifically requested.
*/
if (kgetenv("hint.ahci.force150"))
AhciForceGen = 1;
if (kgetenv("hint.ahci.force300"))
AhciForceGen = 2;
if (kgetenv("hint.ahci.force600"))
AhciForceGen = 3;
if (kgetenv("hint.ahci.nofeatures"))
AhciNoFeatures = -1;
if (kgetenv("hint.ahci.forcefbss"))
sc->sc_flags |= AHCI_F_FORCE_FBSS;
sysctl_ctx_init(&sc->sysctl_ctx);
ksnprintf(name, sizeof(name), "%s%d",
device_get_name(dev), device_get_unit(dev));
sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
SYSCTL_STATIC_CHILDREN(_hw),
OID_AUTO, name, CTLFLAG_RD, 0, "");
error = sc->sc_ad->ad_attach(dev);
if (error) {
sysctl_ctx_free(&sc->sysctl_ctx);
sc->sysctl_tree = NULL;
}
return (error);
}
static void
stpoll_init(void)
{
struct stpoll_ctx *st_ctx = &stpoll_context;
const struct poll_comm *comm = poll_common[0];
sysctl_ctx_init(&st_ctx->poll_sysctl_ctx);
st_ctx->poll_sysctl_tree = SYSCTL_ADD_NODE(&st_ctx->poll_sysctl_ctx,
SYSCTL_CHILDREN(comm->sysctl_tree),
OID_AUTO, "status", CTLFLAG_RD, 0, "");
SYSCTL_ADD_UINT(&st_ctx->poll_sysctl_ctx,
SYSCTL_CHILDREN(st_ctx->poll_sysctl_tree),
OID_AUTO, "handlers", CTLFLAG_RD,
&st_ctx->poll_handlers, 0,
"Number of registered status poll handlers");
netmsg_init(&st_ctx->poll_netmsg, NULL, &netisr_adone_rport,
0, stpoll_handler);
}
static void
fhaold_init(void *foo)
{
struct fha_params *softc;
softc = &fhaold_softc;
bzero(softc, sizeof(*softc));
/*
* Setup the callbacks for this FHA personality.
*/
softc->callbacks.get_procnum = fhaold_get_procnum;
softc->callbacks.realign = fhaold_realign;
softc->callbacks.get_fh = fhaold_get_fh;
softc->callbacks.is_read = fhaold_is_read;
softc->callbacks.is_write = fhaold_is_write;
softc->callbacks.get_offset = fhaold_get_offset;
softc->callbacks.no_offset = fhaold_no_offset;
softc->callbacks.set_locktype = fhaold_set_locktype;
softc->callbacks.fhe_stats_sysctl = fheold_stats_sysctl;
snprintf(softc->server_name, sizeof(softc->server_name),
FHAOLD_SERVER_NAME);
softc->pool = &nfsrv_pool;
/*
* Initialize the sysctl context list for the fha module.
*/
sysctl_ctx_init(&softc->sysctl_ctx);
softc->sysctl_tree = SYSCTL_ADD_NODE(&softc->sysctl_ctx,
SYSCTL_STATIC_CHILDREN(_vfs_nfsrv), OID_AUTO, "fha", CTLFLAG_RD,
0, "fha node");
if (softc->sysctl_tree == NULL) {
printf("%s: unable to allocate sysctl tree\n", __func__);
return;
}
fha_init(softc);
}
void
vmbus_br_sysctl_create(struct sysctl_ctx_list *ctx, struct sysctl_oid *br_tree,
struct vmbus_br *br, const char *name)
{
struct sysctl_oid *tree;
char desc[64];
tree = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(br_tree), OID_AUTO,
name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
if (tree == NULL)
return;
snprintf(desc, sizeof(desc), "%s state", name);
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "state",
CTLTYPE_STRING | CTLFLAG_RD | CTLFLAG_MPSAFE,
br, 0, vmbus_br_sysctl_state, "A", desc);
snprintf(desc, sizeof(desc), "%s binary state", name);
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "state_bin",
CTLTYPE_OPAQUE | CTLFLAG_RD | CTLFLAG_MPSAFE,
br, 0, vmbus_br_sysctl_state_bin, "IU", desc);
}
static void mlx4_en_rate_limit_sysctl_stat(struct mlx4_en_priv *priv, int ring_id)
{
struct mlx4_en_tx_ring *tx_ring;
struct sysctl_ctx_list *ctx;
struct sysctl_oid_list *head_node;
struct sysctl_oid *ring_node;
struct sysctl_oid_list *ring_list;
char namebuf[128];
tx_ring = priv->tx_ring[ring_id];
ctx = &tx_ring->rl_data.rl_stats_ctx;
snprintf(namebuf, sizeof(namebuf), "tx_ring%d", ring_id);
head_node = SYSCTL_CHILDREN(priv->sysctl_stat);
ring_node = SYSCTL_ADD_NODE(ctx, head_node, OID_AUTO, namebuf,
CTLFLAG_RD, NULL, "TX Ring");
ring_list = SYSCTL_CHILDREN(ring_node);
SYSCTL_ADD_UINT(ctx, ring_list, OID_AUTO, "rate_limit_val",
CTLFLAG_RD, &priv->rate_limits[tx_ring->rl_data.rate_index].rate, 0, "Rate Limit value");
SYSCTL_ADD_ULONG(ctx, ring_list, OID_AUTO, "packets",
CTLFLAG_RD, &tx_ring->packets, "TX packets");
SYSCTL_ADD_ULONG(ctx, ring_list, OID_AUTO, "bytes",
CTLFLAG_RD, &tx_ring->bytes, "TX bytes");
}
/*
* Initialize per-cpu polling(4) context. Called from kern_clock.c:
*/
void
init_device_poll_pcpu(int cpuid)
{
struct pollctx *pctx;
char cpuid_str[3];
if (cpuid >= POLLCTX_MAX)
return;
if ((CPUMASK(cpuid) & poll_cpumask0) == 0)
return;
if (poll_burst_max < MIN_POLL_BURST_MAX)
poll_burst_max = MIN_POLL_BURST_MAX;
else if (poll_burst_max > MAX_POLL_BURST_MAX)
poll_burst_max = MAX_POLL_BURST_MAX;
if (poll_each_burst > poll_burst_max)
poll_each_burst = poll_burst_max;
poll_cpumask |= CPUMASK(cpuid);
pctx = kmalloc(sizeof(*pctx), M_DEVBUF, M_WAITOK | M_ZERO);
pctx->poll_each_burst = poll_each_burst;
pctx->poll_burst_max = poll_burst_max;
pctx->user_frac = 50;
pctx->reg_frac = 20;
pctx->polling_enabled = polling_enabled;
pctx->pollhz = pollhz;
pctx->poll_cpuid = cpuid;
poll_reset_state(pctx);
netmsg_init(&pctx->poll_netmsg, NULL, &netisr_adone_rport,
0, netisr_poll);
#ifdef INVARIANTS
pctx->poll_netmsg.lmsg.u.ms_resultp = pctx;
#endif
netmsg_init(&pctx->poll_more_netmsg, NULL, &netisr_adone_rport,
0, netisr_pollmore);
#ifdef INVARIANTS
pctx->poll_more_netmsg.lmsg.u.ms_resultp = pctx;
#endif
KASSERT(cpuid < POLLCTX_MAX, ("cpu id must < %d", cpuid));
poll_context[cpuid] = pctx;
if (poll_defcpu < 0) {
poll_defcpu = cpuid;
/*
* Initialize global sysctl nodes, for compat
*/
poll_add_sysctl(NULL, SYSCTL_STATIC_CHILDREN(_kern_polling),
pctx);
}
/*
* Initialize per-cpu sysctl nodes
*/
ksnprintf(cpuid_str, sizeof(cpuid_str), "%d", pctx->poll_cpuid);
sysctl_ctx_init(&pctx->poll_sysctl_ctx);
pctx->poll_sysctl_tree = SYSCTL_ADD_NODE(&pctx->poll_sysctl_ctx,
SYSCTL_STATIC_CHILDREN(_kern_polling),
OID_AUTO, cpuid_str, CTLFLAG_RD, 0, "");
poll_add_sysctl(&pctx->poll_sysctl_ctx,
SYSCTL_CHILDREN(pctx->poll_sysctl_tree), pctx);
/*
* Initialize systimer
*/
systimer_init_periodic_nq(&pctx->pollclock, pollclock, pctx, 1);
}
static int
acpi_cpu_attach(device_t dev)
{
ACPI_BUFFER buf;
ACPI_OBJECT arg, *obj;
ACPI_OBJECT_LIST arglist;
struct pcpu *pcpu_data;
struct acpi_cpu_softc *sc;
struct acpi_softc *acpi_sc;
ACPI_STATUS status;
u_int features;
int cpu_id, drv_count, i;
driver_t **drivers;
uint32_t cap_set[3];
/* UUID needed by _OSC evaluation */
static uint8_t cpu_oscuuid[16] = { 0x16, 0xA6, 0x77, 0x40, 0x0C, 0x29,
0xBE, 0x47, 0x9E, 0xBD, 0xD8, 0x70,
0x58, 0x71, 0x39, 0x53 };
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = device_get_softc(dev);
sc->cpu_dev = dev;
sc->cpu_handle = acpi_get_handle(dev);
cpu_id = (int)(intptr_t)acpi_get_private(dev);
cpu_softc[cpu_id] = sc;
pcpu_data = pcpu_find(cpu_id);
pcpu_data->pc_device = dev;
sc->cpu_pcpu = pcpu_data;
cpu_smi_cmd = AcpiGbl_FADT.SmiCommand;
cpu_cst_cnt = AcpiGbl_FADT.CstControl;
buf.Pointer = NULL;
buf.Length = ACPI_ALLOCATE_BUFFER;
status = AcpiEvaluateObject(sc->cpu_handle, NULL, NULL, &buf);
if (ACPI_FAILURE(status)) {
device_printf(dev, "attach failed to get Processor obj - %s\n",
AcpiFormatException(status));
return (ENXIO);
}
obj = (ACPI_OBJECT *)buf.Pointer;
sc->cpu_p_blk = obj->Processor.PblkAddress;
sc->cpu_p_blk_len = obj->Processor.PblkLength;
sc->cpu_acpi_id = obj->Processor.ProcId;
AcpiOsFree(obj);
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "acpi_cpu%d: P_BLK at %#x/%d\n",
device_get_unit(dev), sc->cpu_p_blk, sc->cpu_p_blk_len));
/*
* If this is the first cpu we attach, create and initialize the generic
* resources that will be used by all acpi cpu devices.
*/
if (device_get_unit(dev) == 0) {
/* Assume we won't be using generic Cx mode by default */
cpu_cx_generic = FALSE;
/* Install hw.acpi.cpu sysctl tree */
acpi_sc = acpi_device_get_parent_softc(dev);
sysctl_ctx_init(&cpu_sysctl_ctx);
cpu_sysctl_tree = SYSCTL_ADD_NODE(&cpu_sysctl_ctx,
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO, "cpu",
CTLFLAG_RD, 0, "node for CPU children");
}
/*
* Before calling any CPU methods, collect child driver feature hints
* and notify ACPI of them. We support unified SMP power control
* so advertise this ourselves. Note this is not the same as independent
* SMP control where each CPU can have different settings.
*/
sc->cpu_features = ACPI_CAP_SMP_SAME | ACPI_CAP_SMP_SAME_C3 |
ACPI_CAP_C1_IO_HALT;
#if defined(__i386__) || defined(__amd64__)
/*
* Ask for MWAIT modes if not disabled and interrupts work
* reasonable with MWAIT.
*/
if (!acpi_disabled("mwait") && cpu_mwait_usable())
sc->cpu_features |= ACPI_CAP_SMP_C1_NATIVE | ACPI_CAP_SMP_C3_NATIVE;
#endif
if (devclass_get_drivers(acpi_cpu_devclass, &drivers, &drv_count) == 0) {
for (i = 0; i < drv_count; i++) {
if (ACPI_GET_FEATURES(drivers[i], &features) == 0)
sc->cpu_features |= features;
}
free(drivers, M_TEMP);
}
/*
* CPU capabilities are specified in
* Intel Processor Vendor-Specific ACPI Interface Specification.
*/
if (sc->cpu_features) {
cap_set[1] = sc->cpu_features;
status = acpi_EvaluateOSC(sc->cpu_handle, cpu_oscuuid, 1, 2, cap_set,
cap_set, false);
if (ACPI_SUCCESS(status)) {
if (cap_set[0] != 0)
device_printf(dev, "_OSC returned status %#x\n", cap_set[0]);
}
else {
arglist.Pointer = &arg;
arglist.Count = 1;
arg.Type = ACPI_TYPE_BUFFER;
arg.Buffer.Length = sizeof(cap_set);
arg.Buffer.Pointer = (uint8_t *)cap_set;
cap_set[0] = 1; /* revision */
cap_set[1] = 1; /* number of capabilities integers */
cap_set[2] = sc->cpu_features;
AcpiEvaluateObject(sc->cpu_handle, "_PDC", &arglist, NULL);
}
}
/* Probe for Cx state support. */
acpi_cpu_cx_probe(sc);
return (0);
}
static void
vmbus_chan_sysctl_create(struct vmbus_channel *chan)
{
struct sysctl_oid *ch_tree, *chid_tree, *br_tree;
struct sysctl_ctx_list *ctx;
uint32_t ch_id;
char name[16];
/*
* Add sysctl nodes related to this channel to this
* channel's sysctl ctx, so that they can be destroyed
* independently upon close of this channel, which can
* happen even if the device is not detached.
*/
ctx = &chan->ch_sysctl_ctx;
sysctl_ctx_init(ctx);
/*
* Create dev.NAME.UNIT.channel tree.
*/
ch_tree = SYSCTL_ADD_NODE(ctx,
SYSCTL_CHILDREN(device_get_sysctl_tree(chan->ch_dev)),
OID_AUTO, "channel", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
if (ch_tree == NULL)
return;
/*
* Create dev.NAME.UNIT.channel.CHANID tree.
*/
if (VMBUS_CHAN_ISPRIMARY(chan))
ch_id = chan->ch_id;
else
ch_id = chan->ch_prichan->ch_id;
snprintf(name, sizeof(name), "%d", ch_id);
chid_tree = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(ch_tree),
OID_AUTO, name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
if (chid_tree == NULL)
return;
if (!VMBUS_CHAN_ISPRIMARY(chan)) {
/*
* Create dev.NAME.UNIT.channel.CHANID.sub tree.
*/
ch_tree = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(chid_tree),
OID_AUTO, "sub", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
if (ch_tree == NULL)
return;
/*
* Create dev.NAME.UNIT.channel.CHANID.sub.SUBIDX tree.
*
* NOTE:
* chid_tree is changed to this new sysctl tree.
*/
snprintf(name, sizeof(name), "%d", chan->ch_subidx);
chid_tree = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(ch_tree),
OID_AUTO, name, CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
if (chid_tree == NULL)
return;
SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(chid_tree), OID_AUTO,
"chanid", CTLFLAG_RD, &chan->ch_id, 0, "channel id");
}
SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(chid_tree), OID_AUTO,
"cpu", CTLFLAG_RD, &chan->ch_cpuid, 0, "owner CPU id");
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(chid_tree), OID_AUTO,
"mnf", CTLTYPE_INT | CTLFLAG_RD | CTLFLAG_MPSAFE,
chan, 0, vmbus_chan_sysctl_mnf, "I",
"has monitor notification facilities");
br_tree = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(chid_tree), OID_AUTO,
"br", CTLFLAG_RD | CTLFLAG_MPSAFE, 0, "");
if (br_tree != NULL) {
/*
* Create sysctl tree for RX bufring.
*/
vmbus_br_sysctl_create(ctx, br_tree, &chan->ch_rxbr.rxbr, "rx");
/*
* Create sysctl tree for TX bufring.
*/
vmbus_br_sysctl_create(ctx, br_tree, &chan->ch_txbr.txbr, "tx");
}
}
/*
* Initialize the software state of the iSCSI ULP driver.
*
* ENXIO means firmware didn't set up something that it was supposed to.
*/
static int
cxgbei_init(struct adapter *sc, struct cxgbei_data *ci)
{
struct sysctl_oid *oid;
struct sysctl_oid_list *children;
struct ppod_region *pr;
uint32_t r;
int rc;
MPASS(sc->vres.iscsi.size > 0);
MPASS(ci != NULL);
rc = alloc_ci_counters(ci);
if (rc != 0)
return (rc);
read_pdu_limits(sc, &ci->max_tx_pdu_len, &ci->max_rx_pdu_len);
pr = &ci->pr;
r = t4_read_reg(sc, A_ULP_RX_ISCSI_PSZ);
rc = t4_init_ppod_region(pr, &sc->vres.iscsi, r, "iSCSI page pods");
if (rc != 0) {
device_printf(sc->dev,
"%s: failed to initialize the iSCSI page pod region: %u.\n",
__func__, rc);
free_ci_counters(ci);
return (rc);
}
r = t4_read_reg(sc, A_ULP_RX_ISCSI_TAGMASK);
r &= V_ISCSITAGMASK(M_ISCSITAGMASK);
if (r != pr->pr_tag_mask) {
/*
* Recent firmwares are supposed to set up the iSCSI tagmask
* but we'll do it ourselves it the computed value doesn't match
* what's in the register.
*/
device_printf(sc->dev,
"tagmask 0x%08x does not match computed mask 0x%08x.\n", r,
pr->pr_tag_mask);
t4_set_reg_field(sc, A_ULP_RX_ISCSI_TAGMASK,
V_ISCSITAGMASK(M_ISCSITAGMASK), pr->pr_tag_mask);
}
sysctl_ctx_init(&ci->ctx);
oid = device_get_sysctl_tree(sc->dev); /* dev.t5nex.X */
children = SYSCTL_CHILDREN(oid);
oid = SYSCTL_ADD_NODE(&ci->ctx, children, OID_AUTO, "iscsi", CTLFLAG_RD,
NULL, "iSCSI ULP statistics");
children = SYSCTL_CHILDREN(oid);
SYSCTL_ADD_COUNTER_U64(&ci->ctx, children, OID_AUTO, "ddp_setup_ok",
CTLFLAG_RD, &ci->ddp_setup_ok,
"# of times DDP buffer was setup successfully.");
SYSCTL_ADD_COUNTER_U64(&ci->ctx, children, OID_AUTO, "ddp_setup_error",
CTLFLAG_RD, &ci->ddp_setup_error,
"# of times DDP buffer setup failed.");
SYSCTL_ADD_COUNTER_U64(&ci->ctx, children, OID_AUTO, "ddp_bytes",
CTLFLAG_RD, &ci->ddp_bytes, "# of bytes placed directly");
SYSCTL_ADD_COUNTER_U64(&ci->ctx, children, OID_AUTO, "ddp_pdus",
CTLFLAG_RD, &ci->ddp_pdus, "# of PDUs with data placed directly.");
SYSCTL_ADD_COUNTER_U64(&ci->ctx, children, OID_AUTO, "fl_bytes",
CTLFLAG_RD, &ci->fl_bytes, "# of data bytes delivered in freelist");
SYSCTL_ADD_COUNTER_U64(&ci->ctx, children, OID_AUTO, "fl_pdus",
CTLFLAG_RD, &ci->fl_pdus,
"# of PDUs with data delivered in freelist");
ci->ddp_threshold = 2048;
SYSCTL_ADD_UINT(&ci->ctx, children, OID_AUTO, "ddp_threshold",
CTLFLAG_RW, &ci->ddp_threshold, 0, "Rx zero copy threshold");
return (0);
}
static int
acpi_cpu_attach(device_t dev)
{
struct acpi_cpux_softc *sc = device_get_softc(dev);
ACPI_HANDLE handle;
device_t child;
int cpu_id, cpu_features;
struct acpi_softc *acpi_sc;
handle = acpi_get_handle(dev);
cpu_id = acpi_get_magic(dev);
acpi_sc = acpi_device_get_parent_softc(dev);
if (cpu_id == 0) {
sysctl_ctx_init(&sc->glob_sysctl_ctx);
sc->glob_sysctl_tree = SYSCTL_ADD_NODE(&sc->glob_sysctl_ctx,
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
OID_AUTO, "cpu", CTLFLAG_RD, 0,
"node for CPU global settings");
if (sc->glob_sysctl_tree == NULL)
return ENOMEM;
}
sysctl_ctx_init(&sc->pcpu_sysctl_ctx);
sc->pcpu_sysctl_tree = SYSCTL_ADD_NODE(&sc->pcpu_sysctl_ctx,
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
OID_AUTO, device_get_nameunit(dev), CTLFLAG_RD, 0,
"node for per-CPU settings");
if (sc->pcpu_sysctl_tree == NULL) {
sysctl_ctx_free(&sc->glob_sysctl_ctx);
return ENOMEM;
}
/*
* Before calling any CPU methods, collect child driver feature hints
* and notify ACPI of them. We support unified SMP power control
* so advertise this ourselves. Note this is not the same as independent
* SMP control where each CPU can have different settings.
*/
cpu_features = ACPI_PDC_MP_C1PXTX | ACPI_PDC_MP_C2C3;
cpu_features |= acpi_cpu_md_features();
/*
* CPU capabilities are specified as a buffer of 32-bit integers:
* revision, count, and one or more capabilities.
*/
if (cpu_features) {
ACPI_OBJECT_LIST arglist;
uint32_t cap_set[3];
ACPI_OBJECT arg[4];
ACPI_STATUS status;
/* UUID needed by _OSC evaluation */
static uint8_t cpu_oscuuid[16] = {
0x16, 0xA6, 0x77, 0x40, 0x0C, 0x29, 0xBE, 0x47,
0x9E, 0xBD, 0xD8, 0x70, 0x58, 0x71, 0x39, 0x53
};
arglist.Pointer = arg;
arglist.Count = 4;
arg[0].Type = ACPI_TYPE_BUFFER;
arg[0].Buffer.Length = sizeof(cpu_oscuuid);
arg[0].Buffer.Pointer = cpu_oscuuid; /* UUID */
arg[1].Type = ACPI_TYPE_INTEGER;
arg[1].Integer.Value = 1; /* revision */
arg[2].Type = ACPI_TYPE_INTEGER;
arg[2].Integer.Value = 2; /* # of capabilities integers */
arg[3].Type = ACPI_TYPE_BUFFER;
arg[3].Buffer.Length = sizeof(cap_set[0]) * 2; /* capabilities buffer */
arg[3].Buffer.Pointer = (uint8_t *)cap_set;
cap_set[0] = 0;
cap_set[1] = cpu_features;
status = AcpiEvaluateObject(handle, "_OSC", &arglist, NULL);
if (!ACPI_SUCCESS(status)) {
if (bootverbose)
device_printf(dev, "_OSC failed, use _PDC\n");
arglist.Pointer = arg;
arglist.Count = 1;
arg[0].Type = ACPI_TYPE_BUFFER;
arg[0].Buffer.Length = sizeof(cap_set);
arg[0].Buffer.Pointer = (uint8_t *)cap_set;
cap_set[0] = 1; /* revision */
cap_set[1] = 1; /* # of capabilities integers */
cap_set[2] = cpu_features;
AcpiEvaluateObject(handle, "_PDC", &arglist, NULL);
}
}
child = BUS_ADD_CHILD(dev, dev, 0, "cpu_cst", -1);
if (child == NULL)
return ENXIO;
acpi_set_handle(child, handle);
acpi_set_magic(child, cpu_id);
sc->cpux_cst = child;
child = BUS_ADD_CHILD(dev, dev, 0, "cpu_pst", -1);
if (child == NULL)
return ENXIO;
acpi_set_handle(child, handle);
acpi_set_magic(child, cpu_id);
bus_generic_attach(dev);
AcpiInstallNotifyHandler(handle, ACPI_DEVICE_NOTIFY, acpi_cpu_notify, sc);
return 0;
}
static void
aibs_attach_sif(struct aibs_softc *sc, enum aibs_type st)
{
ACPI_STATUS s;
ACPI_BUFFER b;
ACPI_OBJECT *bp, *o;
int i, n;
const char *node;
char name[] = "?SIF";
struct aibs_sensor *as;
struct sysctl_oid *so;
switch (st) {
case AIBS_VOLT:
node = "volt";
name[0] = 'V';
break;
case AIBS_TEMP:
node = "temp";
name[0] = 'T';
break;
case AIBS_FAN:
node = "fan";
name[0] = 'F';
break;
default:
return;
}
b.Length = ACPI_ALLOCATE_BUFFER;
s = AcpiEvaluateObjectTyped(sc->sc_ah, name, NULL, &b,
ACPI_TYPE_PACKAGE);
if (ACPI_FAILURE(s)) {
device_printf(sc->sc_dev, "%s not found\n", name);
return;
}
bp = b.Pointer;
o = bp->Package.Elements;
if (o[0].Type != ACPI_TYPE_INTEGER) {
device_printf(sc->sc_dev, "%s[0]: invalid type\n", name);
AcpiOsFree(b.Pointer);
return;
}
n = o[0].Integer.Value;
if (bp->Package.Count - 1 < n) {
device_printf(sc->sc_dev, "%s: invalid package\n", name);
AcpiOsFree(b.Pointer);
return;
} else if (bp->Package.Count - 1 > n) {
int on = n;
#ifdef AIBS_MORE_SENSORS
n = bp->Package.Count - 1;
#endif
device_printf(sc->sc_dev, "%s: malformed package: %i/%i"
", assume %i\n", name, on, bp->Package.Count - 1, n);
}
if (n < 1) {
device_printf(sc->sc_dev, "%s: no members in the package\n",
name);
AcpiOsFree(b.Pointer);
return;
}
as = malloc(sizeof(*as) * n, M_DEVBUF, M_NOWAIT | M_ZERO);
if (as == NULL) {
device_printf(sc->sc_dev, "%s: malloc fail\n", name);
AcpiOsFree(b.Pointer);
return;
}
switch (st) {
case AIBS_VOLT:
sc->sc_asens_volt = as;
break;
case AIBS_TEMP:
sc->sc_asens_temp = as;
break;
case AIBS_FAN:
sc->sc_asens_fan = as;
break;
}
/* sysctl subtree for sensors of this type */
so = SYSCTL_ADD_NODE(device_get_sysctl_ctx(sc->sc_dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(sc->sc_dev)), st,
node, CTLFLAG_RD, NULL, NULL);
for (i = 0, o++; i < n; i++, o++) {
ACPI_OBJECT *oi;
char si[3];
const char *desc;
/* acpica5 automatically evaluates the referenced package */
if (o[0].Type != ACPI_TYPE_PACKAGE) {
device_printf(sc->sc_dev,
"%s: %i: not a package: %i type\n",
name, i, o[0].Type);
continue;
}
oi = o[0].Package.Elements;
if (o[0].Package.Count != 5 ||
oi[0].Type != ACPI_TYPE_INTEGER ||
oi[1].Type != ACPI_TYPE_STRING ||
oi[2].Type != ACPI_TYPE_INTEGER ||
oi[3].Type != ACPI_TYPE_INTEGER ||
oi[4].Type != ACPI_TYPE_INTEGER) {
device_printf(sc->sc_dev,
"%s: %i: invalid package\n",
name, i);
continue;
}
as[i].i = oi[0].Integer.Value;
desc = oi[1].String.Pointer;
as[i].l = oi[2].Integer.Value;
as[i].h = oi[3].Integer.Value;
as[i].t = st;
#ifdef AIBS_VERBOSE
device_printf(sc->sc_dev, "%c%i: "
"0x%08"PRIx64" %20s %5"PRIi64" / %5"PRIi64" "
"0x%"PRIx64"\n",
name[0], i,
(uint64_t)as[i].i, desc, (int64_t)as[i].l,
(int64_t)as[i].h, (uint64_t)oi[4].Integer.Value);
#endif
snprintf(si, sizeof(si), "%i", i);
SYSCTL_ADD_PROC(device_get_sysctl_ctx(sc->sc_dev),
SYSCTL_CHILDREN(so), i, si, CTLTYPE_INT | CTLFLAG_RD,
sc, st, aibs_sysctl, st == AIBS_TEMP ? "IK" : "I", desc);
}
AcpiOsFree(b.Pointer);
}
