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");
}
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 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 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);
}
int
sfxge_ev_init(struct sfxge_softc *sc)
{
struct sysctl_ctx_list *sysctl_ctx = device_get_sysctl_ctx(sc->dev);
struct sysctl_oid *sysctl_tree = device_get_sysctl_tree(sc->dev);
struct sfxge_intr *intr;
int index;
int rc;
intr = &sc->intr;
sc->evq_count = intr->n_alloc;
KASSERT(intr->state == SFXGE_INTR_INITIALIZED,
("intr->state != SFXGE_INTR_INITIALIZED"));
/* Set default interrupt moderation; add a sysctl to
* read and change it.
*/
sc->ev_moderation = SFXGE_MODERATION;
SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree),
OID_AUTO, "int_mod", CTLTYPE_UINT|CTLFLAG_RW,
sc, 0, sfxge_int_mod_handler, "IU",
"sfxge interrupt moderation (us)");
/*
* Initialize the event queue(s) - one per interrupt.
*/
for (index = 0; index < sc->evq_count; index++) {
if ((rc = sfxge_ev_qinit(sc, index)) != 0)
goto fail;
}
#if EFSYS_OPT_QSTATS
sfxge_ev_stat_init(sc);
#endif
return (0);
fail:
while (--index >= 0)
sfxge_ev_qfini(sc, index);
sc->evq_count = 0;
return (rc);
}
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
bcm_fb_sysctl_init(struct bcmsc_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->dev);
tree_node = device_get_sysctl_tree(sc->dev);
tree = SYSCTL_CHILDREN(tree_node);
SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "resync",
CTLFLAG_RW | CTLTYPE_UINT, sc, sizeof(*sc),
bcm_fb_resync_sysctl, "IU", "Set to resync framebuffer with VC");
}
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
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");
}
static void
sfxge_vpd_try_add(struct sfxge_softc *sc, struct sysctl_oid_list *list,
efx_vpd_tag_t tag, const char *keyword)
{
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->dev);
efx_vpd_value_t value;
/* Check whether VPD tag/keyword is present */
value.evv_tag = tag;
value.evv_keyword = EFX_VPD_KEYWORD(keyword[0], keyword[1]);
if (efx_vpd_get(sc->enp, sc->vpd_data, sc->vpd_size, &value) != 0)
return;
SYSCTL_ADD_PROC(
ctx, list, OID_AUTO, keyword, CTLTYPE_STRING|CTLFLAG_RD,
sc, tag << 16 | EFX_VPD_KEYWORD(keyword[0], keyword[1]),
sfxge_vpd_handler, "A", "");
}
static int
acpi_sony_attach(device_t dev)
{
struct acpi_sony_softc *sc;
int i;
sc = device_get_softc(dev);
acpi_GetInteger(acpi_get_handle(dev), ACPI_SONY_GET_PID, &sc->pid);
device_printf(dev, "PID %x\n", sc->pid);
for (i = 0 ; acpi_sony_oids[i].nodename != NULL; i++){
SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
i, acpi_sony_oids[i].nodename , CTLTYPE_INT |
((acpi_sony_oids[i].setmethod)? CTLFLAG_RW: CTLFLAG_RD),
dev, i, sysctl_acpi_sony_gen_handler, "I",
acpi_sony_oids[i].comment);
}
return (0);
}
void isci_sysctl_initialize(struct isci_softc *isci)
{
struct sysctl_ctx_list *sysctl_ctx = device_get_sysctl_ctx(isci->device);
struct sysctl_oid *sysctl_tree = device_get_sysctl_tree(isci->device);
SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
"coalesce_timeout", CTLTYPE_UINT | CTLFLAG_RW, isci, 0,
isci_sysctl_coalesce_timeout, "IU",
"Interrupt coalescing timeout (in microseconds)");
SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
"coalesce_number", CTLTYPE_UINT | CTLFLAG_RW, isci, 0,
isci_sysctl_coalesce_number, "IU",
"Interrupt coalescing number");
SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
"reset_remote_device_on_controller0", CTLTYPE_UINT| CTLFLAG_RW,
isci, 0, isci_sysctl_reset_remote_device_on_controller0, "IU",
"Reset remote device on controller 0");
SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
"reset_remote_device_on_controller1", CTLTYPE_UINT| CTLFLAG_RW,
isci, 0, isci_sysctl_reset_remote_device_on_controller1, "IU",
"Reset remote device on controller 1");
SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
"stop_phy", CTLTYPE_UINT| CTLFLAG_RW, isci, 0, isci_sysctl_stop_phy,
"IU", "Stop PHY on a controller");
SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
"start_phy", CTLTYPE_UINT| CTLFLAG_RW, isci, 0,
isci_sysctl_start_phy, "IU", "Start PHY on a controller");
SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
"log_frozen_lun_masks", CTLTYPE_UINT| CTLFLAG_RW, isci, 0,
isci_sysctl_log_frozen_lun_masks, "IU",
"Log frozen lun masks to kernel log");
SYSCTL_ADD_PROC(sysctl_ctx, SYSCTL_CHILDREN(sysctl_tree), OID_AUTO,
"fail_on_task_timeout", CTLTYPE_UINT | CTLFLAG_RW, isci, 0,
isci_sysctl_fail_on_task_timeout, "IU",
"Fail a command that has encountered a task management timeout");
}
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 void
sfxge_ev_stat_init(struct sfxge_softc *sc)
{
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->dev);
struct sysctl_oid_list *stat_list;
unsigned int id;
char name[40];
stat_list = SYSCTL_CHILDREN(sc->stats_node);
for (id = 0; id < EV_NQSTATS; id++) {
snprintf(name, sizeof(name), "ev_%s",
efx_ev_qstat_name(sc->enp, id));
SYSCTL_ADD_PROC(
ctx, stat_list,
OID_AUTO, name, CTLTYPE_U64|CTLFLAG_RD,
sc, id, sfxge_ev_stat_handler, "Q",
"");
}
}
static int
at24co2n_attach(device_t dev)
{
struct at24co2n_softc *sc = device_get_softc(dev);
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
struct sysctl_oid *tree = device_get_sysctl_tree(dev);
if(sc == NULL) {
printf("at24co2n_attach device_get_softc failed\n");
return (0);
}
sc->sc_dev = dev;
sc->sc_addr = iicbus_get_addr(dev);
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"eeprom-mac", CTLTYPE_STRING | CTLFLAG_RD, sc, 0,
at24co2n_mac_sysctl, "A", "mac address");
return (0);
}
static void
uart_pps_init(struct uart_softc *sc)
{
struct sysctl_ctx_list *ctx;
struct sysctl_oid *tree;
ctx = device_get_sysctl_ctx(sc->sc_dev);
tree = device_get_sysctl_tree(sc->sc_dev);
/*
* The historical default for pps capture mode is either DCD or CTS,
* depending on the UART_PPS_ON_CTS kernel option. Start with that,
* then try to fetch the tunable that overrides the mode for all uart
* devices, then try to fetch the sysctl-tunable that overrides the mode
* for one specific device.
*/
#ifdef UART_PPS_ON_CTS
sc->sc_pps_mode = UART_PPS_CTS;
#else
sc->sc_pps_mode = UART_PPS_DCD;
#endif
TUNABLE_INT_FETCH("hw.uart.pps_mode", &sc->sc_pps_mode);
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "pps_mode",
CTLTYPE_INT | CTLFLAG_RWTUN, sc, 0, uart_pps_mode_sysctl, "I",
"pulse mode: 0/1/2=disabled/CTS/DCD; "
"add 0x10 to invert, 0x20 for narrow pulse");
if (!uart_pps_mode_valid(sc->sc_pps_mode)) {
device_printf(sc->sc_dev,
"Invalid pps_mode 0x%02x configured; disabling PPS capture\n",
sc->sc_pps_mode);
sc->sc_pps_mode = UART_PPS_DISABLED;
} else if (bootverbose) {
uart_pps_print_mode(sc);
}
sc->sc_pps.ppscap = PPS_CAPTUREBOTH;
sc->sc_pps.driver_mtx = uart_tty_getlock(sc);
sc->sc_pps.driver_abi = PPS_ABI_VERSION;
pps_init_abi(&sc->sc_pps);
}
static int
rstmgr_add_sysctl(struct rstmgr_softc *sc)
{
struct sysctl_oid_list *children;
struct sysctl_ctx_list *ctx;
ctx = device_get_sysctl_ctx(sc->dev);
children = SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev));
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "fpga2hps",
CTLTYPE_UINT | CTLFLAG_RW, sc, RSTMGR_SYSCTL_FPGA2HPS,
rstmgr_sysctl, "I", "Enable fpga2hps bridge");
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "lwhps2fpga",
CTLTYPE_UINT | CTLFLAG_RW, sc, RSTMGR_SYSCTL_LWHPS2FPGA,
rstmgr_sysctl, "I", "Enable lwhps2fpga bridge");
SYSCTL_ADD_PROC(ctx, children, OID_AUTO, "hps2fpga",
CTLTYPE_UINT | CTLFLAG_RW, sc, RSTMGR_SYSCTL_HPS2FPGA,
rstmgr_sysctl, "I", "Enable hps2fpga bridge");
return (0);
}
static void
ds1307_start(void *xdev)
{
device_t dev;
struct ds1307_softc *sc;
struct sysctl_ctx_list *ctx;
struct sysctl_oid *tree_node;
struct sysctl_oid_list *tree;
dev = (device_t)xdev;
sc = device_get_softc(dev);
ctx = device_get_sysctl_ctx(dev);
tree_node = device_get_sysctl_tree(dev);
tree = SYSCTL_CHILDREN(tree_node);
config_intrhook_disestablish(&sc->enum_hook);
/* Set the 24 hours mode. */
if (ds1307_set_24hrs_mode(sc) != 0)
return;
/* Enable the oscillator if halted. */
if (ds1307_osc_enable(sc) != 0)
return;
/* Configuration parameters. */
SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "sqwe",
CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_MPSAFE, sc, 0,
ds1307_sqwe_sysctl, "IU", "DS1307 square-wave enable");
SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "sqw_freq",
CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_MPSAFE, sc, 0,
ds1307_sqw_freq_sysctl, "IU",
"DS1307 square-wave output frequency");
SYSCTL_ADD_PROC(ctx, tree, OID_AUTO, "sqw_out",
CTLFLAG_RW | CTLTYPE_UINT | CTLFLAG_MPSAFE, sc, 0,
ds1307_sqw_out_sysctl, "IU", "DS1307 square-wave output state");
/* 1 second resolution. */
clock_register(dev, 1000000);
}
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 int
max6657_attach(device_t dev)
{
struct max6657_softc *sc = device_get_softc(dev);
struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
struct sysctl_oid *tree = device_get_sysctl_tree(dev);
if(sc==NULL) {
printf("max6657_attach device_get_softc failed\n");
return (0);
}
sc->sc_dev = dev;
sc->sc_addr = iicbus_get_addr(dev);
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"temp", CTLTYPE_INT | CTLFLAG_RD, sc, 0,
max6657_sysctl_temp, "I", "operating temperature");
device_printf(dev, "Chip temperature {%d} Degree Celsius\n",
max6657_read(sc->sc_dev, sc->sc_addr, MAX6657_EXT_TEMP));
return (0);
}
static int
gpiobacklight_attach(device_t dev)
{
struct gpiobacklight_softc *sc;
struct sysctl_ctx_list *ctx;
struct sysctl_oid *tree;
phandle_t node;
sc = device_get_softc(dev);
if ((node = ofw_bus_get_node(dev)) == -1)
return (ENXIO);
if (OF_hasprop(node, "default-on"))
sc->sc_brightness = true;
else
sc->sc_brightness = false;
gpio_pin_get_by_ofw_idx(dev, node, 0, &sc->sc_pin);
if (sc->sc_pin == NULL) {
device_printf(dev, "failed to map GPIO pin\n");
return (ENXIO);
}
gpio_pin_setflags(sc->sc_pin, GPIO_PIN_OUTPUT);
gpiobacklight_update_brightness(sc);
/* Init backlight interface */
ctx = device_get_sysctl_ctx(dev);
tree = device_get_sysctl_tree(dev);
sc->sc_oid = SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"brightness", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
gpiobacklight_sysctl, "I", "backlight brightness");
return (0);
}
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
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 void
adb_init_trackpad(device_t dev)
{
struct adb_mouse_softc *sc;
struct sysctl_ctx_list *ctx;
struct sysctl_oid *tree;
size_t r1_len;
u_char r1[8];
u_char r2[8];
sc = device_get_softc(dev);
r1_len = adb_read_register(dev, 1, r1);
/* An Extended Mouse register1 must return 8 bytes. */
if (r1_len != 8)
return;
if((r1[6] != 0x0d))
{
r1[6] = 0x0d;
adb_write_register(dev, 1, 8, r1);
r1_len = adb_read_register(dev, 1, r1);
if (r1[6] != 0x0d)
{
device_printf(dev, "ADB Mouse = 0x%x "
"(non-Extended Mode)\n", r1[6]);
return;
} else {
device_printf(dev, "ADB Mouse = 0x%x "
"(Extended Mode)\n", r1[6]);
/* Set ADB Extended Features to default values,
enabled. */
r2[0] = 0x19; /* Clicking: 0x19 disabled 0x99 enabled */
r2[1] = 0x94; /* Dragging: 0x14 disabled 0x94 enabled */
r2[2] = 0x19;
r2[3] = 0xff; /* DragLock: 0xff disabled 0xb2 enabled */
r2[4] = 0xb2;
r2[5] = 0x8a;
r2[6] = 0x1b;
r2[7] = 0x57; /* 0x57 bits 3:0 for W mode */
adb_write_register(dev, 2, 8, r2);
}
}
/*
* Set up sysctl
*/
ctx = device_get_sysctl_ctx(dev);
tree = device_get_sysctl_tree(dev);
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "tapping",
CTLTYPE_INT | CTLFLAG_RW, sc, 0, adb_tapping_sysctl,
"I", "Tapping the pad causes button events");
return;
}
if (OF_getprop(child, "prim-info", prim_info,
sizeof(prim_info)) >= 7)
sc->sc_batteries = (prim_info[6] >> 16) & 0xff;
if (bootverbose && sc->sc_batteries > 0)
device_printf(dev, "%d batteries detected\n",
sc->sc_batteries);
}
}
/*
* Set up sysctls
*/
ctx = device_get_sysctl_ctx(dev);
tree = device_get_sysctl_tree(dev);
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"server_mode", CTLTYPE_INT | CTLFLAG_RW, sc, 0,
pmu_server_mode, "I", "Enable reboot after power failure");
if (sc->sc_batteries > 0) {
struct sysctl_oid *oid, *battroot;
char battnum[2];
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"acline", CTLTYPE_INT | CTLFLAG_RD, sc, 0,
pmu_acline_state, "I", "AC Line Status");
battroot = SYSCTL_ADD_NODE(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
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);
}
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
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");
}
static int
apb_attach(device_t dev)
{
struct apb_softc *sc;
struct sysctl_ctx_list *sctx;
struct sysctl_oid *soid;
sc = device_get_softc(dev);
/*
* Get current bridge configuration.
*/
sc->sc_bsc.ops_pcib_sc.domain = pci_get_domain(dev);
sc->sc_bsc.ops_pcib_sc.secstat =
pci_read_config(dev, PCIR_SECSTAT_1, 2);
sc->sc_bsc.ops_pcib_sc.command =
pci_read_config(dev, PCIR_COMMAND, 2);
sc->sc_bsc.ops_pcib_sc.pribus =
pci_read_config(dev, PCIR_PRIBUS_1, 1);
sc->sc_bsc.ops_pcib_sc.bus.sec =
pci_read_config(dev, PCIR_SECBUS_1, 1);
sc->sc_bsc.ops_pcib_sc.bus.sub =
pci_read_config(dev, PCIR_SUBBUS_1, 1);
sc->sc_bsc.ops_pcib_sc.bridgectl =
pci_read_config(dev, PCIR_BRIDGECTL_1, 2);
sc->sc_bsc.ops_pcib_sc.seclat =
pci_read_config(dev, PCIR_SECLAT_1, 1);
sc->sc_iomap = pci_read_config(dev, APBR_IOMAP, 1);
sc->sc_memmap = pci_read_config(dev, APBR_MEMMAP, 1);
/*
* Setup SYSCTL reporting nodes.
*/
sctx = device_get_sysctl_ctx(dev);
soid = device_get_sysctl_tree(dev);
SYSCTL_ADD_UINT(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "domain",
CTLFLAG_RD, &sc->sc_bsc.ops_pcib_sc.domain, 0,
"Domain number");
SYSCTL_ADD_UINT(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "pribus",
CTLFLAG_RD, &sc->sc_bsc.ops_pcib_sc.pribus, 0,
"Primary bus number");
SYSCTL_ADD_UINT(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "secbus",
CTLFLAG_RD, &sc->sc_bsc.ops_pcib_sc.bus.sec, 0,
"Secondary bus number");
SYSCTL_ADD_UINT(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "subbus",
CTLFLAG_RD, &sc->sc_bsc.ops_pcib_sc.bus.sub, 0,
"Subordinate bus number");
ofw_pcib_gen_setup(dev);
if (bootverbose) {
device_printf(dev, " domain %d\n",
sc->sc_bsc.ops_pcib_sc.domain);
device_printf(dev, " secondary bus %d\n",
sc->sc_bsc.ops_pcib_sc.bus.sec);
device_printf(dev, " subordinate bus %d\n",
sc->sc_bsc.ops_pcib_sc.bus.sub);
device_printf(dev, " I/O decode ");
apb_map_print(sc->sc_iomap, APB_IO_SCALE);
printf("\n");
device_printf(dev, " memory decode ");
apb_map_print(sc->sc_memmap, APB_MEM_SCALE);
printf("\n");
}
device_add_child(dev, "pci", -1);
return (bus_generic_attach(dev));
}
