/*
* 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");
}
static int
ow_temp_attach(device_t dev)
{
struct ow_temp_softc *sc;
sc = device_get_softc(dev);
sc->dev = dev;
sc->type = ow_get_family(dev);
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "temperature", CTLFLAG_RD | CTLTYPE_INT,
&sc->temp, 0, sysctl_handle_int,
"IK3", "Current Temperature");
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "badcrc", CTLFLAG_RD,
&sc->bad_crc, 0,
"Number of Bad CRC on reading scratchpad");
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "badread", CTLFLAG_RD,
&sc->bad_reads, 0,
"Number of errors on reading scratchpad");
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "reading_interval", CTLFLAG_RW,
&sc->reading_interval, 0,
"ticks between reads");
SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "parasite", CTLFLAG_RW,
&sc->parasite, 0,
"In Parasite mode");
/*
* Just do this for unit 0 to avoid locking
* the ow bus until that code can be put
* into place.
*/
sc->temp = -1;
sc->reading_interval = 10 * hz;
mtx_init(&sc->temp_lock, "lock for doing temperature", NULL, MTX_DEF);
/* Start the thread */
if (kproc_create(ow_temp_event_thread, sc, &sc->event_thread, 0, 0,
"%s event thread", device_get_nameunit(dev))) {
device_printf(dev, "unable to create event thread.\n");
panic("cbb_create_event_thread");
}
return 0;
}
static int
acpi_dock_attach(device_t dev)
{
struct acpi_dock_softc *sc;
ACPI_HANDLE h;
sc = device_get_softc(dev);
h = acpi_get_handle(dev);
if (sc == NULL || h == NULL)
return (ENXIO);
sc->status = ACPI_DOCK_STATUS_UNKNOWN;
AcpiEvaluateObject(h, "_INI", NULL, NULL);
ACPI_SERIAL_BEGIN(dock);
acpi_dock_device_check(dev);
/* Get the sysctl tree */
sc->sysctl_ctx = device_get_sysctl_ctx(dev);
sc->sysctl_tree = device_get_sysctl_tree(dev);
SYSCTL_ADD_INT(sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree),
OID_AUTO, "_sta", CTLFLAG_RD,
&sc->_sta, 0, "Dock _STA");
SYSCTL_ADD_INT(sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree),
OID_AUTO, "_bdn", CTLFLAG_RD,
&sc->_bdn, 0, "Dock _BDN");
SYSCTL_ADD_INT(sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree),
OID_AUTO, "_uid", CTLFLAG_RD,
&sc->_uid, 0, "Dock _UID");
SYSCTL_ADD_PROC(sc->sysctl_ctx,
SYSCTL_CHILDREN(sc->sysctl_tree),
OID_AUTO, "status",
CTLTYPE_INT|CTLFLAG_RW, dev, 0,
acpi_dock_status_sysctl, "I",
"Dock/Undock operation");
ACPI_SERIAL_END(dock);
AcpiInstallNotifyHandler(h, ACPI_ALL_NOTIFY,
acpi_dock_notify_handler, dev);
return (0);
}
static void
ath_rate_sysctlattach(struct ath_softc *sc, struct sample_softc *osc)
{
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
/* XXX bounds check [0..100] */
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"smoothing_rate", CTLFLAG_RW, &osc->ath_smoothing_rate, 0,
"rate control: retry threshold to credit rate raise (%%)");
/* XXX bounds check [2..100] */
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"sample_rate", CTLFLAG_RW, &osc->ath_sample_rate,0,
"rate control: # good periods before raising rate");
}
void
ucom_set_pnpinfo_usb(struct ucom_super_softc *ssc, device_t dev)
{
char buf[64];
uint8_t iface_index;
struct usb_attach_arg *uaa;
snprintf(buf, sizeof(buf), "ttyname=" UCOM_TTY_PREFIX
"%d ttyports=%d", ssc->sc_unit, ssc->sc_subunits);
/* Store the PNP info in the first interface for the device */
uaa = device_get_ivars(dev);
iface_index = uaa->info.bIfaceIndex;
if (usbd_set_pnpinfo(uaa->device, iface_index, buf) != 0)
device_printf(dev, "Could not set PNP info\n");
/*
* The following information is also replicated in the PNP-info
* string which is registered above:
*/
if (ssc->sc_sysctl_ttyname == NULL) {
ssc->sc_sysctl_ttyname = SYSCTL_ADD_STRING(NULL,
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "ttyname", CTLFLAG_RD, ssc->sc_ttyname, 0,
"TTY device basename");
}
if (ssc->sc_sysctl_ttyports == NULL) {
ssc->sc_sysctl_ttyports = SYSCTL_ADD_INT(NULL,
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "ttyports", CTLFLAG_RD,
NULL, ssc->sc_subunits, "Number of ports");
}
}
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);
}
static void
r21a_attach_private(struct rtwn_softc *sc)
{
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
struct r12a_softc *rs;
rs = malloc(sizeof(struct r12a_softc), M_RTWN_PRIV, M_WAITOK | M_ZERO);
rs->rs_flags = R12A_RXCKSUM_EN | R12A_RXCKSUM6_EN;
rs->rs_radar = 0;
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"radar_detection", CTLFLAG_RDTUN, &rs->rs_radar,
rs->rs_radar, "Enable radar detection (untested)");
rs->rs_fix_spur = rtwn_nop_softc_chan;
rs->rs_set_band_2ghz = r21a_set_band_2ghz;
rs->rs_set_band_5ghz = r21a_set_band_5ghz;
rs->rs_init_burstlen = r21au_init_burstlen;
rs->rs_init_ampdu_fwhw = r21a_init_ampdu_fwhw;
rs->rs_crystalcap_write = r21a_crystalcap_write;
#ifndef RTWN_WITHOUT_UCODE
rs->rs_iq_calib_fw_supported = r21a_iq_calib_fw_supported;
#endif
rs->rs_iq_calib_sw = r21a_iq_calib_sw;
rs->ampdu_max_time = 0x5e;
rs->ac_usb_dma_size = 0x01;
rs->ac_usb_dma_time = 0x10;
sc->sc_priv = rs;
}
static void
amrr_sysctlattach(struct ieee80211_amrr *amrr,
struct sysctl_ctx_list *ctx, struct sysctl_oid *tree)
{
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"amrr_rate_interval", CTLTYPE_INT | CTLFLAG_RW, amrr,
0, amrr_sysctl_interval, "I", "amrr operation interval (ms)");
/* XXX bounds check values */
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"amrr_max_sucess_threshold", CTLFLAG_RW,
&amrr->amrr_max_success_threshold, 0, "");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"amrr_min_sucess_threshold", CTLFLAG_RW,
&amrr->amrr_min_success_threshold, 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);
}
}
/*
* 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
ath_rate_sysctlattach(struct ath_softc *sc)
{
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"rate_interval", CTLFLAG_RW, &ath_rateinterval, 0,
"rate control: operation interval (ms)");
/* XXX bounds check values */
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"rate_raise", CTLFLAG_RW, &ath_rate_raise, 0,
"rate control: retry threshold to credit rate raise (%%)");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"rate_raise_threshold", CTLFLAG_RW, &ath_rate_raise_threshold,0,
"rate control: # good periods before raising rate");
}
static void
ath_rate_sysctlattach(struct ath_softc *sc)
{
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"rate_interval", CTLFLAG_RW, &ath_rateinterval, 0,
"rate control: operation interval (ms)");
/* XXX bounds check values */
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"max_sucess_threshold", CTLFLAG_RW,
&ath_rate_max_success_threshold, 0, "");
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"min_sucess_threshold", CTLFLAG_RW,
&ath_rate_min_success_threshold, 0, "");
}
static void
iopoll_add_sysctl(struct sysctl_ctx_list *ctx, struct sysctl_oid_list *parent,
struct iopoll_ctx *io_ctx, int poll_type)
{
if (poll_type == IFPOLL_RX) {
SYSCTL_ADD_PROC(ctx, parent, OID_AUTO, "burst_max",
CTLTYPE_UINT | CTLFLAG_RW, io_ctx, 0, sysctl_burstmax,
"IU", "Max Polling burst size");
SYSCTL_ADD_PROC(ctx, parent, OID_AUTO, "each_burst",
CTLTYPE_UINT | CTLFLAG_RW, io_ctx, 0, sysctl_eachburst,
"IU", "Max size of each burst");
SYSCTL_ADD_UINT(ctx, parent, OID_AUTO, "burst", CTLFLAG_RD,
&io_ctx->poll_burst, 0, "Current polling burst size");
SYSCTL_ADD_UINT(ctx, parent, OID_AUTO, "user_frac", CTLFLAG_RW,
&io_ctx->user_frac, 0, "Desired user fraction of cpu time");
SYSCTL_ADD_UINT(ctx, parent, OID_AUTO, "kern_frac", CTLFLAG_RD,
&io_ctx->kern_frac, 0, "Kernel fraction of cpu time");
SYSCTL_ADD_INT(ctx, parent, OID_AUTO, "residual_burst", CTLFLAG_RD,
&io_ctx->residual_burst, 0,
"# of residual cycles in burst");
}
SYSCTL_ADD_UINT(ctx, parent, OID_AUTO, "phase", CTLFLAG_RD,
&io_ctx->phase, 0, "Polling phase");
SYSCTL_ADD_ULONG(ctx, parent, OID_AUTO, "suspect", CTLFLAG_RW,
&io_ctx->suspect, "Suspected events");
SYSCTL_ADD_ULONG(ctx, parent, OID_AUTO, "stalled", CTLFLAG_RW,
&io_ctx->stalled, "Potential stalls");
SYSCTL_ADD_ULONG(ctx, parent, OID_AUTO, "short_ticks", CTLFLAG_RW,
&io_ctx->short_ticks,
"Hardclock ticks shorter than they should be");
SYSCTL_ADD_ULONG(ctx, parent, OID_AUTO, "lost_polls", CTLFLAG_RW,
&io_ctx->lost_polls,
"How many times we would have lost a poll tick");
SYSCTL_ADD_UINT(ctx, parent, OID_AUTO, "pending_polls", CTLFLAG_RD,
&io_ctx->pending_polls, 0, "Do we need to poll again");
SYSCTL_ADD_UINT(ctx, parent, OID_AUTO, "handlers", CTLFLAG_RD,
&io_ctx->poll_handlers, 0, "Number of registered poll handlers");
}
int
sfxge_mcdi_init(struct sfxge_softc *sc)
{
efx_nic_t *enp;
struct sfxge_mcdi *mcdi;
efx_mcdi_transport_t *emtp;
efsys_mem_t *esmp;
int max_msg_size;
int rc;
enp = sc->enp;
mcdi = &sc->mcdi;
emtp = &mcdi->transport;
esmp = &mcdi->mem;
max_msg_size = sizeof (uint32_t) + MCDI_CTL_SDU_LEN_MAX_V2;
KASSERT(mcdi->state == SFXGE_MCDI_UNINITIALIZED,
("MCDI already initialized"));
SFXGE_MCDI_LOCK_INIT(mcdi, device_get_nameunit(sc->dev));
mcdi->state = SFXGE_MCDI_INITIALIZED;
if ((rc = sfxge_dma_alloc(sc, max_msg_size, esmp)) != 0)
goto fail;
emtp->emt_context = sc;
emtp->emt_dma_mem = esmp;
emtp->emt_execute = sfxge_mcdi_execute;
emtp->emt_ev_cpl = sfxge_mcdi_ev_cpl;
emtp->emt_exception = sfxge_mcdi_exception;
#if EFSYS_OPT_MCDI_LOGGING
emtp->emt_logger = sfxge_mcdi_logger;
SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)),
OID_AUTO, "mcdi_logging", CTLFLAG_RW,
&sc->mcdi_logging, 0,
"MCDI logging");
#endif
if ((rc = efx_mcdi_init(enp, emtp)) != 0)
goto fail;
return (0);
fail:
SFXGE_MCDI_LOCK_DESTROY(mcdi);
mcdi->state = SFXGE_MCDI_UNINITIALIZED;
return (rc);
}
static void
vchi_audio_sysctl_init(struct bcm2835_audio_info *sc)
{
struct sysctl_ctx_list *ctx;
struct sysctl_oid *tree_node;
struct sysctl_oid_list *tree;
/*
* Add system sysctl tree/handlers.
*/
ctx = device_get_sysctl_ctx(sc->dev);
tree_node = device_get_sysctl_tree(sc->dev);
tree = SYSCTL_CHILDREN(tree_node);
SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "dest",
CTLFLAG_RW | CTLTYPE_UINT, sc, sizeof(*sc),
sysctl_bcm2835_audio_dest, "IU", "audio destination, "
"0 - auto, 1 - headphones, 2 - HDMI");
SYSCTL_ADD_UQUAD(ctx, tree, OID_AUTO, "callbacks",
CTLFLAG_RD, &sc->pch.callbacks,
"callbacks total");
SYSCTL_ADD_UQUAD(ctx, tree, OID_AUTO, "submitted",
CTLFLAG_RD, &sc->pch.submitted_samples,
"last play submitted samples");
SYSCTL_ADD_UQUAD(ctx, tree, OID_AUTO, "retrieved",
CTLFLAG_RD, &sc->pch.retrieved_samples,
"last play retrieved samples");
SYSCTL_ADD_UQUAD(ctx, tree, OID_AUTO, "underruns",
CTLFLAG_RD, &sc->pch.underruns,
"callback underruns");
SYSCTL_ADD_INT(ctx, tree, OID_AUTO, "freebuffer",
CTLFLAG_RD, &sc->pch.available_space,
sc->pch.available_space, "callbacks total");
SYSCTL_ADD_INT(ctx, tree, OID_AUTO, "starved",
CTLFLAG_RD, &sc->pch.starved,
sc->pch.starved, "number of starved conditions");
}
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);
}
int
acpi_machdep_init(device_t dev)
{
struct acpi_softc *sc;
sc = device_get_softc(dev);
acpi_apm_init(sc);
if (intr_model != ACPI_INTR_PIC)
acpi_SetIntrModel(intr_model);
SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx,
SYSCTL_CHILDREN(sc->acpi_sysctl_tree), OID_AUTO,
"reset_video", CTLFLAG_RW, &acpi_reset_video, 0,
"Call the VESA reset BIOS vector on the resume path");
return (0);
}
int
drm_add_busid_modesetting(struct drm_device *dev, struct sysctl_ctx_list *ctx,
struct sysctl_oid *top)
{
struct sysctl_oid *oid;
snprintf(dev->busid_str, sizeof(dev->busid_str),
"pci:%04x:%02x:%02x.%d", dev->pci_domain, dev->pci_bus,
dev->pci_slot, dev->pci_func);
oid = SYSCTL_ADD_STRING(ctx, SYSCTL_CHILDREN(top), OID_AUTO, "busid",
CTLFLAG_RD, dev->busid_str, 0, NULL);
if (oid == NULL)
return (-ENOMEM);
dev->modesetting = (dev->driver->driver_features & DRIVER_MODESET) != 0;
oid = SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(top), OID_AUTO,
"modesetting", CTLFLAG_RD, &dev->modesetting, 0, NULL);
if (oid == NULL)
return (-ENOMEM);
return (0);
}
static void
spigen_sysctl_init(struct spigen_softc *sc)
{
struct sysctl_ctx_list *ctx;
struct sysctl_oid *tree_node;
struct sysctl_oid_list *tree;
/*
* Add system 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, "command_length_max",
CTLFLAG_MPSAFE | CTLFLAG_RW | CTLTYPE_UINT, sc, sizeof(*sc),
spigen_command_length_max_proc, "IU", "SPI command header portion (octets)");
SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "data_length_max",
CTLFLAG_MPSAFE | CTLFLAG_RW | CTLTYPE_UINT, sc, sizeof(*sc),
spigen_data_length_max_proc, "IU", "SPI data trailer portion (octets)");
SYSCTL_ADD_INT(ctx, tree, OID_AUTO, "data", CTLFLAG_RW,
&sc->sc_debug, 0, "debug flags");
}
static void
rtwn_usb_sysctlattach(struct rtwn_softc *sc)
{
struct rtwn_usb_softc *uc = RTWN_USB_SOFTC(sc);
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
char str[64];
int ret;
ret = snprintf(str, sizeof(str),
"Rx buffer size, 512-byte units [%d...%d]",
RTWN_USB_RXBUFSZ_MIN, RTWN_USB_RXBUFSZ_MAX);
KASSERT(ret > 0, ("ret (%d) <= 0!\n", ret));
(void) ret;
uc->uc_rx_buf_size = RTWN_USB_RXBUFSZ_DEF;
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"rx_buf_size", CTLFLAG_RDTUN, &uc->uc_rx_buf_size,
uc->uc_rx_buf_size, str);
if (uc->uc_rx_buf_size < RTWN_USB_RXBUFSZ_MIN)
uc->uc_rx_buf_size = RTWN_USB_RXBUFSZ_MIN;
if (uc->uc_rx_buf_size > RTWN_USB_RXBUFSZ_MAX)
uc->uc_rx_buf_size = RTWN_USB_RXBUFSZ_MAX;
}
static int
uhso_attach(device_t self)
{
struct uhso_softc *sc = device_get_softc(self);
struct usb_attach_arg *uaa = device_get_ivars(self);
struct usb_interface_descriptor *id;
struct sysctl_ctx_list *sctx;
struct sysctl_oid *soid;
struct sysctl_oid *tree = NULL, *tty_node;
struct ucom_softc *ucom;
struct uhso_tty *ht;
int i, error, port;
void *probe_f;
usb_error_t uerr;
char *desc;
sc->sc_dev = self;
sc->sc_udev = uaa->device;
mtx_init(&sc->sc_mtx, "uhso", NULL, MTX_DEF);
ucom_ref(&sc->sc_super_ucom);
sc->sc_ucom = NULL;
sc->sc_ttys = 0;
sc->sc_radio = 1;
id = usbd_get_interface_descriptor(uaa->iface);
sc->sc_ctrl_iface_no = id->bInterfaceNumber;
sc->sc_iface_no = uaa->info.bIfaceNum;
sc->sc_iface_index = uaa->info.bIfaceIndex;
/* Setup control pipe */
uerr = usbd_transfer_setup(uaa->device,
&sc->sc_iface_index, sc->sc_ctrl_xfer,
uhso_ctrl_config, UHSO_CTRL_MAX, sc, &sc->sc_mtx);
if (uerr) {
device_printf(self, "Failed to setup control pipe: %s\n",
usbd_errstr(uerr));
goto out;
}
if (USB_GET_DRIVER_INFO(uaa) == UHSO_STATIC_IFACE)
probe_f = uhso_probe_iface_static;
else if (USB_GET_DRIVER_INFO(uaa) == UHSO_AUTO_IFACE)
probe_f = uhso_probe_iface_auto;
else
goto out;
error = uhso_probe_iface(sc, uaa->info.bIfaceNum, probe_f);
if (error != 0)
goto out;
sctx = device_get_sysctl_ctx(sc->sc_dev);
soid = device_get_sysctl_tree(sc->sc_dev);
SYSCTL_ADD_STRING(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "type",
CTLFLAG_RD, uhso_port[UHSO_IFACE_PORT(sc->sc_type)], 0,
"Port available at this interface");
SYSCTL_ADD_PROC(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "radio",
CTLTYPE_INT | CTLFLAG_RW, sc, 0, uhso_radio_sysctl, "I", "Enable radio");
/*
* The default interface description on most Option devices isn't
* very helpful. So we skip device_set_usb_desc and set the
* device description manually.
*/
device_set_desc_copy(self, uhso_port_type[UHSO_IFACE_PORT_TYPE(sc->sc_type)]);
/* Announce device */
device_printf(self, "<%s port> at <%s %s> on %s\n",
uhso_port_type[UHSO_IFACE_PORT_TYPE(sc->sc_type)],
usb_get_manufacturer(uaa->device),
usb_get_product(uaa->device),
device_get_nameunit(device_get_parent(self)));
if (sc->sc_ttys > 0) {
SYSCTL_ADD_INT(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "ports",
CTLFLAG_RD, &sc->sc_ttys, 0, "Number of attached serial ports");
tree = SYSCTL_ADD_NODE(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
"port", CTLFLAG_RD, NULL, "Serial ports");
}
/*
* Loop through the number of found TTYs and create sysctl
* nodes for them.
*/
for (i = 0; i < sc->sc_ttys; i++) {
ht = &sc->sc_tty[i];
ucom = &sc->sc_ucom[i];
if (UHSO_IFACE_USB_TYPE(sc->sc_type) & UHSO_IF_MUX)
port = uhso_mux_port_map[ht->ht_muxport];
else
port = UHSO_IFACE_PORT_TYPE(sc->sc_type);
desc = uhso_port_type_sysctl[port];
tty_node = SYSCTL_ADD_NODE(sctx, SYSCTL_CHILDREN(tree), OID_AUTO,
desc, CTLFLAG_RD, NULL, "");
ht->ht_name[0] = 0;
if (sc->sc_ttys == 1)
snprintf(ht->ht_name, 32, "cuaU%d", ucom->sc_super->sc_unit);
else {
snprintf(ht->ht_name, 32, "cuaU%d.%d",
ucom->sc_super->sc_unit, ucom->sc_subunit);
}
desc = uhso_port_type[port];
SYSCTL_ADD_STRING(sctx, SYSCTL_CHILDREN(tty_node), OID_AUTO,
"tty", CTLFLAG_RD, ht->ht_name, 0, "");
SYSCTL_ADD_STRING(sctx, SYSCTL_CHILDREN(tty_node), OID_AUTO,
"desc", CTLFLAG_RD, desc, 0, "");
if (bootverbose)
device_printf(sc->sc_dev,
"\"%s\" port at %s\n", desc, ht->ht_name);
}
return (0);
out:
uhso_detach(sc->sc_dev);
return (ENXIO);
}
static void
cpufreq_initialize(struct imx6_anatop_softc *sc)
{
uint32_t cfg3speed;
struct oppt * op;
SYSCTL_ADD_INT(NULL, SYSCTL_STATIC_CHILDREN(_hw_imx6),
OID_AUTO, "cpu_mhz", CTLFLAG_RD, &sc->cpu_curmhz, 0,
"CPU frequency");
SYSCTL_ADD_PROC(NULL, SYSCTL_STATIC_CHILDREN(_hw_imx6),
OID_AUTO, "cpu_minmhz", CTLTYPE_INT | CTLFLAG_RWTUN, sc, 0,
cpufreq_sysctl_minmhz, "IU", "Minimum CPU frequency");
SYSCTL_ADD_PROC(NULL, SYSCTL_STATIC_CHILDREN(_hw_imx6),
OID_AUTO, "cpu_maxmhz", CTLTYPE_INT | CTLFLAG_RWTUN, sc, 0,
cpufreq_sysctl_maxmhz, "IU", "Maximum CPU frequency");
SYSCTL_ADD_INT(NULL, SYSCTL_STATIC_CHILDREN(_hw_imx6),
OID_AUTO, "cpu_maxmhz_hw", CTLFLAG_RD, &sc->cpu_maxmhz_hw, 0,
"Maximum CPU frequency allowed by hardware");
SYSCTL_ADD_INT(NULL, SYSCTL_STATIC_CHILDREN(_hw_imx6),
OID_AUTO, "cpu_overclock_enable", CTLFLAG_RWTUN,
&sc->cpu_overclock_enable, 0,
"Allow setting CPU frequency higher than cpu_maxmhz_hw");
/*
* XXX 24mhz shouldn't be hard-coded, should get this from imx6_ccm
* (even though in the real world it will always be 24mhz). Oh wait a
* sec, I never wrote imx6_ccm.
*/
sc->refosc_mhz = 24;
/*
* Get the maximum speed this cpu can be set to. The values in the
* OCOTP CFG3 register are not documented in the reference manual.
* The following info was in an archived email found via web search:
* - 2b'11: 1200000000Hz;
* - 2b'10: 996000000Hz;
* - 2b'01: 852000000Hz; -- i.MX6Q Only, exclusive with 996MHz.
* - 2b'00: 792000000Hz;
* The default hardware max speed can be overridden by a tunable.
*/
cfg3speed = (fsl_ocotp_read_4(FSL_OCOTP_CFG3) &
FSL_OCOTP_CFG3_SPEED_MASK) >> FSL_OCOTP_CFG3_SPEED_SHIFT;
sc->cpu_maxmhz_hw = imx6_ocotp_mhz_tab[cfg3speed];
sc->cpu_maxmhz = sc->cpu_maxmhz_hw;
TUNABLE_INT_FETCH("hw.imx6.cpu_overclock_enable",
&sc->cpu_overclock_enable);
TUNABLE_INT_FETCH("hw.imx6.cpu_minmhz", &sc->cpu_minmhz);
op = cpufreq_nearest_oppt(sc, sc->cpu_minmhz);
sc->cpu_minmhz = op->mhz;
sc->cpu_minmv = op->mv;
TUNABLE_INT_FETCH("hw.imx6.cpu_maxmhz", &sc->cpu_maxmhz);
op = cpufreq_nearest_oppt(sc, sc->cpu_maxmhz);
sc->cpu_maxmhz = op->mhz;
sc->cpu_maxmv = op->mv;
/*
* Set the CPU to maximum speed.
*
* We won't have thermal throttling until interrupts are enabled, but we
* want to run at full speed through all the device init stuff. This
* basically assumes that a single core can't overheat before interrupts
* are enabled; empirical testing shows that to be a safe assumption.
*/
cpufreq_set_clock(sc, op);
}
void
ieee80211_sysctl_vattach(struct ieee80211vap *vap)
{
struct ifnet *ifp = vap->iv_ifp;
struct sysctl_ctx_list *ctx;
struct sysctl_oid *oid;
char num[14]; /* sufficient for 32 bits */
ctx = (struct sysctl_ctx_list *) malloc(sizeof(struct sysctl_ctx_list),
M_DEVBUF, M_NOWAIT | M_ZERO);
if (ctx == NULL) {
if_printf(ifp, "%s: cannot allocate sysctl context!\n",
__func__);
return;
}
sysctl_ctx_init(ctx);
snprintf(num, sizeof(num), "%u", ifp->if_dunit);
oid = SYSCTL_ADD_NODE(ctx, &SYSCTL_NODE_CHILDREN(_net, wlan),
OID_AUTO, num, CTLFLAG_RD, NULL, "");
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"%parent", CTLTYPE_STRING | CTLFLAG_RD, vap->iv_ic, 0,
ieee80211_sysctl_parent, "A", "parent device");
SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"driver_caps", CTLFLAG_RW, &vap->iv_caps, 0,
"driver capabilities");
#ifdef IEEE80211_DEBUG
vap->iv_debug = ieee80211_debug;
SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"debug", CTLFLAG_RW, &vap->iv_debug, 0,
"control debugging printfs");
#endif
SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"bmiss_max", CTLFLAG_RW, &vap->iv_bmiss_max, 0,
"consecutive beacon misses before scanning");
/* XXX inherit from tunables */
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"inact_run", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_run, 0,
ieee80211_sysctl_inact, "I",
"station inactivity timeout (sec)");
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"inact_probe", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_probe, 0,
ieee80211_sysctl_inact, "I",
"station inactivity probe timeout (sec)");
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"inact_auth", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_auth, 0,
ieee80211_sysctl_inact, "I",
"station authentication timeout (sec)");
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"inact_init", CTLTYPE_INT | CTLFLAG_RW, &vap->iv_inact_init, 0,
ieee80211_sysctl_inact, "I",
"station initial state timeout (sec)");
if (vap->iv_htcaps & IEEE80211_HTC_HT) {
SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"ampdu_mintraffic_bk", CTLFLAG_RW,
&vap->iv_ampdu_mintraffic[WME_AC_BK], 0,
"BK traffic tx aggr threshold (pps)");
SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"ampdu_mintraffic_be", CTLFLAG_RW,
&vap->iv_ampdu_mintraffic[WME_AC_BE], 0,
"BE traffic tx aggr threshold (pps)");
SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"ampdu_mintraffic_vo", CTLFLAG_RW,
&vap->iv_ampdu_mintraffic[WME_AC_VO], 0,
"VO traffic tx aggr threshold (pps)");
SYSCTL_ADD_UINT(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"ampdu_mintraffic_vi", CTLFLAG_RW,
&vap->iv_ampdu_mintraffic[WME_AC_VI], 0,
"VI traffic tx aggr threshold (pps)");
}
if (vap->iv_caps & IEEE80211_C_DFS) {
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(oid), OID_AUTO,
"radar", CTLTYPE_INT | CTLFLAG_RW, vap->iv_ic, 0,
ieee80211_sysctl_radar, "I", "simulate radar event");
}
vap->iv_sysctl = ctx;
vap->iv_oid = oid;
}
static int
acpi_tz_attach(device_t dev)
{
struct acpi_tz_softc *sc;
struct acpi_softc *acpi_sc;
int error;
char oidname[8];
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = device_get_softc(dev);
sc->tz_dev = dev;
sc->tz_handle = acpi_get_handle(dev);
sc->tz_requested = TZ_ACTIVE_NONE;
sc->tz_active = TZ_ACTIVE_UNKNOWN;
sc->tz_thflags = TZ_THFLAG_NONE;
sc->tz_cooling_proc = NULL;
sc->tz_cooling_proc_running = FALSE;
sc->tz_cooling_active = FALSE;
sc->tz_cooling_updated = FALSE;
sc->tz_cooling_enabled = FALSE;
/*
* Parse the current state of the thermal zone and build control
* structures. We don't need to worry about interference with the
* control thread since we haven't fully attached this device yet.
*/
if ((error = acpi_tz_establish(sc)) != 0)
return (error);
/*
* Register for any Notify events sent to this zone.
*/
AcpiInstallNotifyHandler(sc->tz_handle, ACPI_DEVICE_NOTIFY,
acpi_tz_notify_handler, sc);
/*
* Create our sysctl nodes.
*
* XXX we need a mechanism for adding nodes under ACPI.
*/
if (device_get_unit(dev) == 0) {
acpi_sc = acpi_device_get_parent_softc(dev);
sysctl_ctx_init(&acpi_tz_sysctl_ctx);
acpi_tz_sysctl_tree = SYSCTL_ADD_NODE(&acpi_tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
OID_AUTO, "thermal", CTLFLAG_RD, 0, "");
SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_tz_sysctl_tree),
OID_AUTO, "min_runtime", CTLFLAG_RW,
&acpi_tz_min_runtime, 0,
"minimum cooling run time in sec");
SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_tz_sysctl_tree),
OID_AUTO, "polling_rate", CTLFLAG_RW,
&acpi_tz_polling_rate, 0, "monitor polling interval in seconds");
SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_tz_sysctl_tree), OID_AUTO,
"user_override", CTLFLAG_RW, &acpi_tz_override, 0,
"allow override of thermal settings");
}
sysctl_ctx_init(&sc->tz_sysctl_ctx);
sprintf(oidname, "tz%d", device_get_unit(dev));
sc->tz_sysctl_tree = SYSCTL_ADD_NODE(&sc->tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_tz_sysctl_tree),
OID_AUTO, oidname, CTLFLAG_RD, 0, "");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "temperature", CTLTYPE_INT | CTLFLAG_RD,
&sc->tz_temperature, 0, sysctl_handle_int,
"IK", "current thermal zone temperature");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "active", CTLTYPE_INT | CTLFLAG_RW,
sc, 0, acpi_tz_active_sysctl, "I", "cooling is active");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "passive_cooling", CTLTYPE_INT | CTLFLAG_RW,
sc, 0, acpi_tz_cooling_sysctl, "I",
"enable passive (speed reduction) cooling");
SYSCTL_ADD_INT(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "thermal_flags", CTLFLAG_RD,
&sc->tz_thflags, 0, "thermal zone flags");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_PSV", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.psv),
acpi_tz_temp_sysctl, "IK", "passive cooling temp setpoint");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_HOT", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.hot),
acpi_tz_temp_sysctl, "IK",
"too hot temp setpoint (suspend now)");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_CRT", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.crt),
acpi_tz_temp_sysctl, "IK",
"critical temp setpoint (shutdown now)");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_ACx", CTLTYPE_INT | CTLFLAG_RD,
&sc->tz_zone.ac, sizeof(sc->tz_zone.ac),
sysctl_handle_opaque, "IK", "");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_TC1", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.tc1),
acpi_tz_passive_sysctl, "I",
"thermal constant 1 for passive cooling");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_TC2", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.tc2),
acpi_tz_passive_sysctl, "I",
"thermal constant 2 for passive cooling");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_TSP", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.tsp),
acpi_tz_passive_sysctl, "I",
"thermal sampling period for passive cooling");
/*
* Create thread to service all of the thermal zones. Register
* our power profile event handler.
*/
sc->tz_event = EVENTHANDLER_REGISTER(power_profile_change,
acpi_tz_power_profile, sc, 0);
if (acpi_tz_proc == NULL) {
error = kproc_create(acpi_tz_thread, NULL, &acpi_tz_proc,
RFHIGHPID, 0, "acpi_thermal");
if (error != 0) {
device_printf(sc->tz_dev, "could not create thread - %d", error);
goto out;
}
}
/*
* Create a thread to handle passive cooling for 1st zone which
* has _PSV, _TSP, _TC1 and _TC2. Users can enable it for other
* zones manually for now.
*
* XXX We enable only one zone to avoid multiple zones conflict
* with each other since cpufreq currently sets all CPUs to the
* given frequency whereas it's possible for different thermal
* zones to specify independent settings for multiple CPUs.
*/
if (acpi_tz_cooling_unit < 0 && acpi_tz_cooling_is_available(sc))
sc->tz_cooling_enabled = TRUE;
if (sc->tz_cooling_enabled) {
error = acpi_tz_cooling_thread_start(sc);
if (error != 0) {
sc->tz_cooling_enabled = FALSE;
goto out;
}
acpi_tz_cooling_unit = device_get_unit(dev);
}
/*
* Flag the event handler for a manual invocation by our timeout.
* We defer it like this so that the rest of the subsystem has time
* to come up. Don't bother evaluating/printing the temperature at
* this point; on many systems it'll be bogus until the EC is running.
*/
sc->tz_flags |= TZ_FLAG_GETPROFILE;
out:
if (error != 0) {
EVENTHANDLER_DEREGISTER(power_profile_change, sc->tz_event);
AcpiRemoveNotifyHandler(sc->tz_handle, ACPI_DEVICE_NOTIFY,
acpi_tz_notify_handler);
sysctl_ctx_free(&sc->tz_sysctl_ctx);
}
return_VALUE (error);
}
/*
* The function called at load/unload.
*/
static int
load(module_t mod, int cmd, void *arg)
{
int error;
error = 0;
switch (cmd) {
case MOD_LOAD:
/* Initialize the contexts */
printf("Initializing contexts and creating subtrees.\n\n");
sysctl_ctx_init(&clist);
sysctl_ctx_init(&clist1);
sysctl_ctx_init(&clist2);
/*
* Create two partially overlapping subtrees, belonging
* to different contexts.
*/
printf("TREE ROOT NAME\n");
a_root = SYSCTL_ADD_NODE(&clist,
SYSCTL_STATIC_CHILDREN(/* top of sysctl tree */),
OID_AUTO, "dyn_sysctl", CTLFLAG_RW, 0,
"dyn_sysctl root node");
a_root = SYSCTL_ADD_NODE(&clist1,
SYSCTL_STATIC_CHILDREN(/* top of sysctl tree */),
OID_AUTO, "dyn_sysctl", CTLFLAG_RW, 0,
"dyn_sysctl root node");
if (a_root == NULL) {
printf("SYSCTL_ADD_NODE failed!\n");
return (EINVAL);
}
SYSCTL_ADD_LONG(&clist, SYSCTL_CHILDREN(a_root),
OID_AUTO, "long_a", CTLFLAG_RW, &a, "just to try");
SYSCTL_ADD_INT(&clist, SYSCTL_CHILDREN(a_root),
OID_AUTO, "int_b", CTLFLAG_RW, &b, 0, "just to try 1");
a_root1 = SYSCTL_ADD_NODE(&clist, SYSCTL_CHILDREN(a_root),
OID_AUTO, "nextlevel", CTLFLAG_RD, 0, "one level down");
SYSCTL_ADD_STRING(&clist, SYSCTL_CHILDREN(a_root1),
OID_AUTO, "string_c", CTLFLAG_RD, c, 0, "just to try 2");
printf("1. (%p) / dyn_sysctl\n", &clist);
/* Add a subtree under already existing category */
a_root1 = SYSCTL_ADD_NODE(&clist, SYSCTL_STATIC_CHILDREN(_kern),
OID_AUTO, "dyn_sysctl", CTLFLAG_RW, 0, "dyn_sysctl root node");
if (a_root1 == NULL) {
printf("SYSCTL_ADD_NODE failed!\n");
return (EINVAL);
}
SYSCTL_ADD_PROC(&clist, SYSCTL_CHILDREN(a_root1),
OID_AUTO, "procedure", CTLTYPE_STRING | CTLFLAG_RD,
NULL, 0, sysctl_dyn_sysctl_test, "A",
"I can be here, too");
printf(" (%p) /kern dyn_sysctl\n", &clist);
/* Overlap second tree with the first. */
b_root = SYSCTL_ADD_NODE(&clist1, SYSCTL_CHILDREN(a_root),
OID_AUTO, "nextlevel", CTLFLAG_RD, 0, "one level down");
SYSCTL_ADD_STRING(&clist1, SYSCTL_CHILDREN(b_root),
OID_AUTO, "string_c1", CTLFLAG_RD, c, 0, "just to try 2");
printf("2. (%p) / dyn_sysctl (overlapping #1)\n", &clist1);
/*
* And now do something stupid. Connect another subtree to
* dynamic oid.
* WARNING: this is an example of WRONG use of dynamic sysctls.
*/
b_root=SYSCTL_ADD_NODE(&clist2, SYSCTL_CHILDREN(a_root1),
OID_AUTO, "bad", CTLFLAG_RW, 0, "dependent node");
SYSCTL_ADD_STRING(&clist2, SYSCTL_CHILDREN(b_root),
OID_AUTO, "string_c", CTLFLAG_RD, c, 0, "shouldn't panic");
printf("3. (%p) /kern/dyn_sysctl bad (WRONG!)\n", &clist2);
break;
case MOD_UNLOAD:
printf("1. Try to free ctx1 (%p): ", &clist);
if (sysctl_ctx_free(&clist) != 0)
printf("failed: expected. Need to remove ctx3 first.\n");
else
printf("HELP! sysctl_ctx_free(%p) succeeded. EXPECT PANIC!!!\n", &clist);
printf("2. Try to free ctx3 (%p): ", &clist2);
if (sysctl_ctx_free(&clist2) != 0) {
printf("sysctl_ctx_free(%p) failed!\n", &clist2);
/* Remove subtree forcefully... */
sysctl_remove_oid(b_root, 1, 1);
printf("sysctl_remove_oid(%p) succeeded\n", b_root);
} else
printf("Ok\n");
printf("3. Try to free ctx1 (%p) again: ", &clist);
if (sysctl_ctx_free(&clist) != 0) {
printf("sysctl_ctx_free(%p) failed!\n", &clist);
/* Remove subtree forcefully... */
sysctl_remove_oid(a_root1, 1, 1);
printf("sysctl_remove_oid(%p) succeeded\n", a_root1);
} else
printf("Ok\n");
printf("4. Try to free ctx2 (%p): ", &clist1);
if (sysctl_ctx_free(&clist1) != 0) {
printf("sysctl_ctx_free(%p) failed!\n", &clist1);
/* Remove subtree forcefully... */
sysctl_remove_oid(a_root, 1, 1);
} else
printf("Ok\n");
break;
default:
error = EOPNOTSUPP;
break;
}
return (error);
}
static int
acpi_tz_attach(device_t dev)
{
struct acpi_tz_softc *sc;
struct acpi_softc *acpi_sc;
int error;
char oidname[8];
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = device_get_softc(dev);
sc->tz_dev = dev;
sc->tz_handle = acpi_get_handle(dev);
sc->tz_requested = TZ_ACTIVE_NONE;
sc->tz_active = TZ_ACTIVE_UNKNOWN;
sc->tz_thflags = TZ_THFLAG_NONE;
sc->tz_cooling_proc = NULL;
sc->tz_cooling_proc_running = FALSE;
sc->tz_cooling_active = FALSE;
sc->tz_cooling_updated = FALSE;
sc->tz_cooling_enabled = FALSE;
/*
* Parse the current state of the thermal zone and build control
* structures. We don't need to worry about interference with the
* control thread since we haven't fully attached this device yet.
*/
if ((error = acpi_tz_establish(sc)) != 0)
return (error);
/*
* Register for any Notify events sent to this zone.
*/
AcpiInstallNotifyHandler(sc->tz_handle, ACPI_DEVICE_NOTIFY,
acpi_tz_notify_handler, sc);
/*
* Create our sysctl nodes.
*
* XXX we need a mechanism for adding nodes under ACPI.
*/
if (device_get_unit(dev) == 0) {
acpi_sc = acpi_device_get_parent_softc(dev);
sysctl_ctx_init(&acpi_tz_sysctl_ctx);
acpi_tz_sysctl_tree = SYSCTL_ADD_NODE(&acpi_tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
OID_AUTO, "thermal", CTLFLAG_RD, 0, "");
SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_tz_sysctl_tree),
OID_AUTO, "min_runtime", CTLFLAG_RW,
&acpi_tz_min_runtime, 0,
"minimum cooling run time in sec");
SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_tz_sysctl_tree),
OID_AUTO, "polling_rate", CTLFLAG_RW,
&acpi_tz_polling_rate, 0, "monitor polling interval in seconds");
SYSCTL_ADD_INT(&acpi_tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_tz_sysctl_tree), OID_AUTO,
"user_override", CTLFLAG_RW, &acpi_tz_override, 0,
"allow override of thermal settings");
}
sysctl_ctx_init(&sc->tz_sysctl_ctx);
sprintf(oidname, "tz%d", device_get_unit(dev));
sc->tz_sysctl_tree = SYSCTL_ADD_NODE_WITH_LABEL(&sc->tz_sysctl_ctx,
SYSCTL_CHILDREN(acpi_tz_sysctl_tree),
OID_AUTO, oidname, CTLFLAG_RD, 0, "", "thermal_zone");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "temperature", CTLTYPE_INT | CTLFLAG_RD,
&sc->tz_temperature, 0, sysctl_handle_int,
"IK", "current thermal zone temperature");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "active", CTLTYPE_INT | CTLFLAG_RW,
sc, 0, acpi_tz_active_sysctl, "I", "cooling is active");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "passive_cooling", CTLTYPE_INT | CTLFLAG_RW,
sc, 0, acpi_tz_cooling_sysctl, "I",
"enable passive (speed reduction) cooling");
SYSCTL_ADD_INT(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "thermal_flags", CTLFLAG_RD,
&sc->tz_thflags, 0, "thermal zone flags");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_PSV", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.psv),
acpi_tz_temp_sysctl, "IK", "passive cooling temp setpoint");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_HOT", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.hot),
acpi_tz_temp_sysctl, "IK",
"too hot temp setpoint (suspend now)");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_CRT", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.crt),
acpi_tz_temp_sysctl, "IK",
"critical temp setpoint (shutdown now)");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_ACx", CTLTYPE_INT | CTLFLAG_RD,
&sc->tz_zone.ac, sizeof(sc->tz_zone.ac),
sysctl_handle_opaque, "IK", "");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_TC1", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.tc1),
acpi_tz_passive_sysctl, "I",
"thermal constant 1 for passive cooling");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_TC2", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.tc2),
acpi_tz_passive_sysctl, "I",
"thermal constant 2 for passive cooling");
SYSCTL_ADD_PROC(&sc->tz_sysctl_ctx, SYSCTL_CHILDREN(sc->tz_sysctl_tree),
OID_AUTO, "_TSP", CTLTYPE_INT | CTLFLAG_RW,
sc, offsetof(struct acpi_tz_softc, tz_zone.tsp),
acpi_tz_passive_sysctl, "I",
"thermal sampling period for passive cooling");
/*
* Register our power profile event handler.
*/
sc->tz_event = EVENTHANDLER_REGISTER(power_profile_change,
acpi_tz_power_profile, sc, 0);
/*
* Flag the event handler for a manual invocation by our timeout.
* We defer it like this so that the rest of the subsystem has time
* to come up. Don't bother evaluating/printing the temperature at
* this point; on many systems it'll be bogus until the EC is running.
*/
sc->tz_flags |= TZ_FLAG_GETPROFILE;
return_VALUE (0);
}
static int
acpi_battery_init(void)
{
struct acpi_softc *sc;
device_t dev;
int error;
ACPI_SERIAL_ASSERT(battery);
error = ENXIO;
dev = devclass_get_device(devclass_find("acpi"), 0);
if (dev == NULL)
goto out;
sc = device_get_softc(dev);
error = acpi_register_ioctl(ACPIIO_BATT_GET_UNITS, acpi_battery_ioctl,
NULL);
if (error != 0)
goto out;
error = acpi_register_ioctl(ACPIIO_BATT_GET_BATTINFO, acpi_battery_ioctl,
NULL);
if (error != 0)
goto out;
error = acpi_register_ioctl(ACPIIO_BATT_GET_BIF, acpi_battery_ioctl, NULL);
if (error != 0)
goto out;
error = acpi_register_ioctl(ACPIIO_BATT_GET_BST, acpi_battery_ioctl, NULL);
if (error != 0)
goto out;
sysctl_ctx_init(&acpi_battery_sysctl_ctx);
acpi_battery_sysctl_tree = SYSCTL_ADD_NODE(&acpi_battery_sysctl_ctx,
SYSCTL_CHILDREN(sc->acpi_sysctl_tree), OID_AUTO, "battery", CTLFLAG_RD,
0, "battery status and info");
SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx,
SYSCTL_CHILDREN(acpi_battery_sysctl_tree),
OID_AUTO, "life", CTLTYPE_INT | CTLFLAG_RD,
&acpi_battery_battinfo.cap, 0, acpi_battery_sysctl, "I",
"percent capacity remaining");
SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx,
SYSCTL_CHILDREN(acpi_battery_sysctl_tree),
OID_AUTO, "time", CTLTYPE_INT | CTLFLAG_RD,
&acpi_battery_battinfo.min, 0, acpi_battery_sysctl, "I",
"remaining time in minutes");
SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx,
SYSCTL_CHILDREN(acpi_battery_sysctl_tree),
OID_AUTO, "state", CTLTYPE_INT | CTLFLAG_RD,
&acpi_battery_battinfo.state, 0, acpi_battery_sysctl, "I",
"current status flags");
SYSCTL_ADD_PROC(&acpi_battery_sysctl_ctx,
SYSCTL_CHILDREN(acpi_battery_sysctl_tree),
OID_AUTO, "units", CTLTYPE_INT | CTLFLAG_RD,
NULL, 0, acpi_battery_units_sysctl, "I", "number of batteries");
SYSCTL_ADD_INT(&acpi_battery_sysctl_ctx,
SYSCTL_CHILDREN(acpi_battery_sysctl_tree),
OID_AUTO, "info_expire", CTLFLAG_RW,
&acpi_battery_info_expire, 0,
"time in seconds until info is refreshed");
acpi_batteries_initted = TRUE;
out:
if (error != 0) {
acpi_deregister_ioctl(ACPIIO_BATT_GET_UNITS, acpi_battery_ioctl);
acpi_deregister_ioctl(ACPIIO_BATT_GET_BATTINFO, acpi_battery_ioctl);
acpi_deregister_ioctl(ACPIIO_BATT_GET_BIF, acpi_battery_ioctl);
acpi_deregister_ioctl(ACPIIO_BATT_GET_BST, acpi_battery_ioctl);
}
return (error);
}
void
oce_add_sysctls(POCE_SOFTC sc)
{
struct sysctl_ctx_list *ctx = &sc->sysctl_ctx;
struct sysctl_oid *tree = sc->sysctl_tree;
struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree);
struct sysctl_oid *stats_node;
SYSCTL_ADD_STRING(ctx, child,
OID_AUTO, "component_revision",
CTLTYPE_INT | CTLFLAG_RD,
&component_revision,
sizeof(component_revision),
"EMULEX One-Connect device driver revision");
SYSCTL_ADD_STRING(ctx, child,
OID_AUTO, "firmware_version",
CTLTYPE_INT | CTLFLAG_RD,
&sc->fw_version,
sizeof(sc->fw_version),
"EMULEX One-Connect Firmware Version");
SYSCTL_ADD_INT(ctx, child,
OID_AUTO, "max_rsp_handled",
CTLTYPE_INT | CTLFLAG_RW,
&oce_max_rsp_handled,
sizeof(oce_max_rsp_handled),
"Maximum receive frames handled per interrupt");
if ((sc->function_mode & FNM_FLEX10_MODE) ||
(sc->function_mode & FNM_UMC_MODE))
SYSCTL_ADD_UINT(ctx, child,
OID_AUTO, "speed",
CTLFLAG_RD,
&sc->qos_link_speed,
0,"QOS Speed");
else
SYSCTL_ADD_UINT(ctx, child,
OID_AUTO, "speed",
CTLFLAG_RD,
&sc->speed,
0,"Link Speed");
if (sc->function_mode & FNM_UMC_MODE)
SYSCTL_ADD_UINT(ctx, child,
OID_AUTO, "pvid",
CTLFLAG_RD,
&sc->pvid,
0,"PVID");
SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "loop_back",
CTLTYPE_INT | CTLFLAG_RW, (void *)sc, 0,
oce_sysctl_loopback, "I", "Loop Back Tests");
SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "fw_upgrade",
CTLTYPE_STRING | CTLFLAG_RW, (void *)sc, 0,
oce_sys_fwupgrade, "A", "Firmware ufi file");
/*
* Dumps Transceiver data
* "sysctl hw.oce0.sfp_vpd_dump=0"
* "sysctl -x hw.oce0.sfp_vpd_dump_buffer" for hex dump
* "sysctl -b hw.oce0.sfp_vpd_dump_buffer > sfp.bin" for binary dump
*/
SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "sfp_vpd_dump",
CTLTYPE_INT | CTLFLAG_RW, (void *)sc, 0, oce_sysctl_sfp_vpd_dump,
"I", "Initiate a sfp_vpd_dump operation");
SYSCTL_ADD_OPAQUE(ctx, child, OID_AUTO, "sfp_vpd_dump_buffer",
CTLFLAG_RD, sfp_vpd_dump_buffer,
TRANSCEIVER_DATA_SIZE, "IU", "Access sfp_vpd_dump buffer");
stats_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats",
CTLFLAG_RD, NULL, "Ethernet Statistics");
if (IS_BE(sc) || IS_SH(sc))
oce_add_stats_sysctls_be3(sc, ctx, stats_node);
else
oce_add_stats_sysctls_xe201(sc, ctx, stats_node);
}
static void
ioat_setup_sysctl(device_t device)
{
struct sysctl_oid_list *par, *statpar, *state, *hammer;
struct sysctl_ctx_list *ctx;
struct sysctl_oid *tree, *tmp;
struct ioat_softc *ioat;
ioat = DEVICE2SOFTC(device);
ctx = device_get_sysctl_ctx(device);
tree = device_get_sysctl_tree(device);
par = SYSCTL_CHILDREN(tree);
SYSCTL_ADD_INT(ctx, par, OID_AUTO, "version", CTLFLAG_RD,
&ioat->version, 0, "HW version (0xMM form)");
SYSCTL_ADD_UINT(ctx, par, OID_AUTO, "max_xfer_size", CTLFLAG_RD,
&ioat->max_xfer_size, 0, "HW maximum transfer size");
SYSCTL_ADD_INT(ctx, par, OID_AUTO, "intrdelay_supported", CTLFLAG_RD,
&ioat->intrdelay_supported, 0, "Is INTRDELAY supported");
SYSCTL_ADD_U16(ctx, par, OID_AUTO, "intrdelay_max", CTLFLAG_RD,
&ioat->intrdelay_max, 0,
"Maximum configurable INTRDELAY on this channel (microseconds)");
tmp = SYSCTL_ADD_NODE(ctx, par, OID_AUTO, "state", CTLFLAG_RD, NULL,
"IOAT channel internal state");
state = SYSCTL_CHILDREN(tmp);
SYSCTL_ADD_UINT(ctx, state, OID_AUTO, "ring_size_order", CTLFLAG_RD,
&ioat->ring_size_order, 0, "SW descriptor ring size order");
SYSCTL_ADD_UINT(ctx, state, OID_AUTO, "head", CTLFLAG_RD, &ioat->head,
0, "SW descriptor head pointer index");
SYSCTL_ADD_UINT(ctx, state, OID_AUTO, "tail", CTLFLAG_RD, &ioat->tail,
0, "SW descriptor tail pointer index");
SYSCTL_ADD_UINT(ctx, state, OID_AUTO, "hw_head", CTLFLAG_RD,
&ioat->hw_head, 0, "HW DMACOUNT");
SYSCTL_ADD_UQUAD(ctx, state, OID_AUTO, "last_completion", CTLFLAG_RD,
ioat->comp_update, "HW addr of last completion");
SYSCTL_ADD_INT(ctx, state, OID_AUTO, "is_resize_pending", CTLFLAG_RD,
&ioat->is_resize_pending, 0, "resize pending");
SYSCTL_ADD_INT(ctx, state, OID_AUTO, "is_completion_pending",
CTLFLAG_RD, &ioat->is_completion_pending, 0, "completion pending");
SYSCTL_ADD_INT(ctx, state, OID_AUTO, "is_reset_pending", CTLFLAG_RD,
&ioat->is_reset_pending, 0, "reset pending");
SYSCTL_ADD_INT(ctx, state, OID_AUTO, "is_channel_running", CTLFLAG_RD,
&ioat->is_channel_running, 0, "channel running");
SYSCTL_ADD_PROC(ctx, state, OID_AUTO, "chansts",
CTLTYPE_STRING | CTLFLAG_RD, ioat, 0, sysctl_handle_chansts, "A",
"String of the channel status");
SYSCTL_ADD_U16(ctx, state, OID_AUTO, "intrdelay", CTLFLAG_RD,
&ioat->cached_intrdelay, 0,
"Current INTRDELAY on this channel (cached, microseconds)");
tmp = SYSCTL_ADD_NODE(ctx, par, OID_AUTO, "hammer", CTLFLAG_RD, NULL,
"Big hammers (mostly for testing)");
hammer = SYSCTL_CHILDREN(tmp);
SYSCTL_ADD_PROC(ctx, hammer, OID_AUTO, "force_hw_reset",
CTLTYPE_INT | CTLFLAG_RW, ioat, 0, sysctl_handle_reset, "I",
"Set to non-zero to reset the hardware");
SYSCTL_ADD_PROC(ctx, hammer, OID_AUTO, "force_hw_error",
CTLTYPE_INT | CTLFLAG_RW, ioat, 0, sysctl_handle_error, "I",
"Set to non-zero to inject a recoverable hardware error");
tmp = SYSCTL_ADD_NODE(ctx, par, OID_AUTO, "stats", CTLFLAG_RD, NULL,
"IOAT channel statistics");
statpar = SYSCTL_CHILDREN(tmp);
SYSCTL_ADD_UQUAD(ctx, statpar, OID_AUTO, "interrupts", CTLFLAG_RW,
&ioat->stats.interrupts,
"Number of interrupts processed on this channel");
SYSCTL_ADD_UQUAD(ctx, statpar, OID_AUTO, "descriptors", CTLFLAG_RW,
&ioat->stats.descriptors_processed,
"Number of descriptors processed on this channel");
SYSCTL_ADD_UQUAD(ctx, statpar, OID_AUTO, "submitted", CTLFLAG_RW,
&ioat->stats.descriptors_submitted,
"Number of descriptors submitted to this channel");
SYSCTL_ADD_UQUAD(ctx, statpar, OID_AUTO, "errored", CTLFLAG_RW,
&ioat->stats.descriptors_error,
"Number of descriptors failed by channel errors");
SYSCTL_ADD_U32(ctx, statpar, OID_AUTO, "halts", CTLFLAG_RW,
&ioat->stats.channel_halts, 0,
"Number of times the channel has halted");
SYSCTL_ADD_U32(ctx, statpar, OID_AUTO, "last_halt_chanerr", CTLFLAG_RW,
&ioat->stats.last_halt_chanerr, 0,
"The raw CHANERR when the channel was last halted");
SYSCTL_ADD_PROC(ctx, statpar, OID_AUTO, "desc_per_interrupt",
CTLTYPE_STRING | CTLFLAG_RD, ioat, 0, sysctl_handle_dpi, "A",
"Descriptors per interrupt");
}
