static int
vpd_attach (device_t dev)
{
struct vpd_softc *sc;
char unit[4];
int error;
sc = device_get_softc(dev);
error = 0;
sc->dev = dev;
sc->rid = 0;
sc->res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->rid,
RF_ACTIVE);
if (sc->res == NULL) {
device_printf(dev, "Unable to allocate memory resource.\n");
error = ENOMEM;
goto bad;
}
sc->vpd = RES2VPD(sc->res);
snprintf(unit, sizeof(unit), "%d", device_get_unit(sc->dev));
snprintf(sc->MachineType, 5, "%.4s", sc->vpd->MachType);
snprintf(sc->MachineModel, 4, "%.3s", sc->vpd->MachType+4);
snprintf(sc->BuildID, 10, "%.9s", sc->vpd->BuildID);
snprintf(sc->BoxSerial, 8, "%.7s", sc->vpd->BoxSerial);
snprintf(sc->PlanarSerial, 12, "%.11s", sc->vpd->PlanarSerial);
sysctl_ctx_init(&sc->ctx);
SYSCTL_ADD_STRING(&sc->ctx,
SYSCTL_STATIC_CHILDREN(_hw_vpd_machine_type), OID_AUTO,
unit, CTLFLAG_RD|CTLFLAG_DYN, sc->MachineType, 0, NULL);
SYSCTL_ADD_STRING(&sc->ctx,
SYSCTL_STATIC_CHILDREN(_hw_vpd_machine_model), OID_AUTO,
unit, CTLFLAG_RD|CTLFLAG_DYN, sc->MachineModel, 0, NULL);
SYSCTL_ADD_STRING(&sc->ctx,
SYSCTL_STATIC_CHILDREN(_hw_vpd_build_id), OID_AUTO,
unit, CTLFLAG_RD|CTLFLAG_DYN, sc->BuildID, 0, NULL);
SYSCTL_ADD_STRING(&sc->ctx,
SYSCTL_STATIC_CHILDREN(_hw_vpd_serial_box), OID_AUTO,
unit, CTLFLAG_RD|CTLFLAG_DYN, sc->BoxSerial, 0, NULL);
SYSCTL_ADD_STRING(&sc->ctx,
SYSCTL_STATIC_CHILDREN(_hw_vpd_serial_planar), OID_AUTO,
unit, CTLFLAG_RD|CTLFLAG_DYN, sc->PlanarSerial, 0, NULL);
device_printf(dev, "Machine Type: %.4s, Model: %.3s, Build ID: %.9s\n",
sc->MachineType, sc->MachineModel, sc->BuildID);
device_printf(dev, "Box Serial: %.7s, Planar Serial: %.11s\n",
sc->BoxSerial, sc->PlanarSerial);
return (0);
bad:
if (sc->res)
bus_release_resource(dev, SYS_RES_MEMORY, sc->rid, sc->res);
return (error);
}
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 void
acpi_cpu_startup_cx(struct acpi_cpu_softc *sc)
{
acpi_cpu_cx_list(sc);
SYSCTL_ADD_STRING(&sc->cpu_sysctl_ctx,
SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)),
OID_AUTO, "cx_supported", CTLFLAG_RD,
sc->cpu_cx_supported, 0,
"Cx/microsecond values for supported Cx states");
SYSCTL_ADD_PROC(&sc->cpu_sysctl_ctx,
SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)),
OID_AUTO, "cx_lowest", CTLTYPE_STRING | CTLFLAG_RW,
(void *)sc, 0, acpi_cpu_cx_lowest_sysctl, "A",
"lowest Cx sleep state to use");
SYSCTL_ADD_PROC(&sc->cpu_sysctl_ctx,
SYSCTL_CHILDREN(device_get_sysctl_tree(sc->cpu_dev)),
OID_AUTO, "cx_usage", CTLTYPE_STRING | CTLFLAG_RD,
(void *)sc, 0, acpi_cpu_usage_sysctl, "A",
"percent usage for each Cx state");
#ifdef notyet
/* Signal platform that we can handle _CST notification. */
if (!cpu_cx_generic && cpu_cst_cnt != 0) {
ACPI_LOCK(acpi);
AcpiOsWritePort(cpu_smi_cmd, cpu_cst_cnt, 8);
ACPI_UNLOCK(acpi);
}
#endif
}
static int
uhso_attach_ifnet(struct uhso_softc *sc, struct usb_interface *iface, int type)
{
struct ifnet *ifp;
usb_error_t uerr;
struct sysctl_ctx_list *sctx;
struct sysctl_oid *soid;
unsigned int devunit;
uerr = usbd_transfer_setup(sc->sc_udev,
&iface->idesc->bInterfaceNumber, sc->sc_if_xfer,
uhso_ifnet_config, UHSO_IFNET_MAX, sc, &sc->sc_mtx);
if (uerr) {
UHSO_DPRINTF(0, "usbd_transfer_setup failed: %s\n",
usbd_errstr(uerr));
return (-1);
}
sc->sc_ifp = ifp = if_alloc(IFT_OTHER);
if (sc->sc_ifp == NULL) {
device_printf(sc->sc_dev, "if_alloc() failed\n");
return (-1);
}
callout_init_mtx(&sc->sc_c, &sc->sc_mtx, 0);
mtx_lock(&sc->sc_mtx);
callout_reset(&sc->sc_c, 1, uhso_if_rxflush, sc);
mtx_unlock(&sc->sc_mtx);
/*
* We create our own unit numbers for ifnet devices because the
* USB interface unit numbers can be at arbitrary positions yielding
* odd looking device names.
*/
devunit = alloc_unr(uhso_ifnet_unit);
if_initname(ifp, device_get_name(sc->sc_dev), devunit);
ifp->if_mtu = UHSO_MAX_MTU;
ifp->if_ioctl = uhso_if_ioctl;
ifp->if_init = uhso_if_init;
ifp->if_start = uhso_if_start;
ifp->if_output = uhso_if_output;
ifp->if_flags = IFF_BROADCAST | IFF_MULTICAST | IFF_NOARP;
ifp->if_softc = sc;
IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
IFQ_SET_READY(&ifp->if_snd);
if_attach(ifp);
bpfattach(ifp, DLT_RAW, 0);
sctx = device_get_sysctl_ctx(sc->sc_dev);
soid = device_get_sysctl_tree(sc->sc_dev);
/* Unlocked read... */
SYSCTL_ADD_STRING(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "netif",
CTLFLAG_RD, ifp->if_xname, 0, "Attached network interface");
return (0);
}
static void
acpi_cst_startup(struct acpi_cst_softc *sc)
{
struct acpi_cpu_softc *cpu = sc->cst_parent;
int i, bm_rld_done = 0;
for (i = 0; i < sc->cst_cx_count; ++i) {
struct acpi_cst_cx *cx = &sc->cst_cx_states[i];
int error;
/* If there are C3(+) states, always enable bus master wakeup */
if (cx->type >= ACPI_STATE_C3 && !bm_rld_done &&
(acpi_cst_quirks & ACPI_CST_QUIRK_NO_BM) == 0) {
acpi_cst_c3_bm_rld(sc);
bm_rld_done = 1;
}
/* Redo the Cx setup, since quirks have been changed */
error = acpi_cst_cx_setup(cx);
if (error)
panic("C%d startup setup failed: %d", i + 1, error);
}
acpi_cst_support_list(sc);
SYSCTL_ADD_STRING(&cpu->pcpu_sysctl_ctx,
SYSCTL_CHILDREN(cpu->pcpu_sysctl_tree),
OID_AUTO, "cx_supported", CTLFLAG_RD,
sc->cst_cx_supported, 0,
"Cx/microsecond values for supported Cx states");
SYSCTL_ADD_PROC(&cpu->pcpu_sysctl_ctx,
SYSCTL_CHILDREN(cpu->pcpu_sysctl_tree),
OID_AUTO, "cx_lowest", CTLTYPE_STRING | CTLFLAG_RW,
(void *)sc, 0, acpi_cst_lowest_sysctl, "A",
"requested lowest Cx sleep state");
SYSCTL_ADD_PROC(&cpu->pcpu_sysctl_ctx,
SYSCTL_CHILDREN(cpu->pcpu_sysctl_tree),
OID_AUTO, "cx_lowest_use", CTLTYPE_STRING | CTLFLAG_RD,
(void *)sc, 0, acpi_cst_lowest_use_sysctl, "A",
"lowest Cx sleep state to use");
SYSCTL_ADD_PROC(&cpu->pcpu_sysctl_ctx,
SYSCTL_CHILDREN(cpu->pcpu_sysctl_tree),
OID_AUTO, "cx_usage", CTLTYPE_STRING | CTLFLAG_RD,
(void *)sc, 0, acpi_cst_usage_sysctl, "A",
"percent usage for each Cx state");
#ifdef notyet
/* Signal platform that we can handle _CST notification. */
if (!acpi_cst_use_fadt && acpi_cst_ctrl != 0) {
ACPI_LOCK(acpi);
AcpiOsWritePort(acpi_cst_smi_cmd, acpi_cst_ctrl, 8);
ACPI_UNLOCK(acpi);
}
#endif
}
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);
}
}
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 int
est_init(void)
{
char hwmodel[128];
int mib[] = { CTL_HW, HW_MODEL };
size_t modellen = sizeof(hwmodel);
struct sysctl_oid *oid, *leaf;
uint64_t msr;
int mv;
size_t len, freq_len;
int err;
size_t i;
if ((cpu_feature2 & CPUID2_EST) == 0) {
kprintf("Enhanced SpeedStep unsupported on this hardware.\n");
return(EOPNOTSUPP);
}
modellen = sizeof(hwmodel);
err = kernel_sysctl(mib, 2, hwmodel, &modellen, NULL, 0, NULL);
if (err) {
kprintf("kernel_sysctl hw.model failed\n");
return(err);
}
msr = rdmsr(MSR_PERF_STATUS);
mv = MSR2MV(msr);
kprintf("%s (%d mV) ", est_desc, mv);
est_fqlist = findcpu(hwmodel, mv);
if (est_fqlist == NULL) {
kprintf(" - unknown CPU or operating point"
"(cpu_id:%#x, msr:%#jx).\n", cpu_id, (intmax_t)msr);
return(EOPNOTSUPP);
}
/*
* OK, tell the user the available frequencies.
*/
fsbmult = est_fqlist->fsbmult;
kprintf("%d MHz\n", MSR2MHZ(msr));
freq_len = est_fqlist->tablec * (sizeof("9999 ")-1) + 1;
if (freq_len >= sizeof(freqs_available)) {
kprintf("increase the size of freqs_available[]\n");
return(ENOMEM);
}
freqs_available[0] = '\0';
len = 0;
for (i = 0; i < est_fqlist->tablec; i++) {
len += ksnprintf(freqs_available + len, freq_len - len, "%d%s",
est_fqlist->table[i].mhz,
i < est_fqlist->tablec - 1 ? " " : "");
}
kprintf("%s frequencies available (MHz): %s\n", est_desc,
freqs_available);
/*
* Setup the sysctl sub-tree machdep.est.*
*/
oid = SYSCTL_ADD_NODE(&machdep_est_ctx,
SYSCTL_STATIC_CHILDREN(_machdep), OID_AUTO, "est",
CTLFLAG_RD, NULL, "");
if (oid == NULL)
return(EOPNOTSUPP);
oid = SYSCTL_ADD_NODE(&machdep_est_ctx, SYSCTL_CHILDREN(oid),
OID_AUTO, "frequency", CTLFLAG_RD, NULL, "");
if (oid == NULL)
return(EOPNOTSUPP);
leaf = SYSCTL_ADD_PROC(&machdep_est_ctx, SYSCTL_CHILDREN(oid),
OID_AUTO, "target", CTLTYPE_INT | CTLFLAG_RW, NULL, 0,
est_sysctl_helper, "I",
"Target CPU frequency for Enhanced SpeedStep");
if (leaf == NULL)
return(EOPNOTSUPP);
leaf = SYSCTL_ADD_PROC(&machdep_est_ctx, SYSCTL_CHILDREN(oid),
OID_AUTO, "current", CTLTYPE_INT | CTLFLAG_RD, NULL, 0,
est_sysctl_helper, "I",
"Current CPU frequency for Enhanced SpeedStep");
if (leaf == NULL)
return(EOPNOTSUPP);
leaf = SYSCTL_ADD_STRING(&machdep_est_ctx, SYSCTL_CHILDREN(oid),
OID_AUTO, "available", CTLFLAG_RD, freqs_available,
sizeof(freqs_available),
"CPU frequencies supported by Enhanced SpeedStep");
if (leaf == NULL)
return(EOPNOTSUPP);
return(0);
}
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 int
powernow_init(void)
{
uint64_t status;
size_t len , freq_len;
uint32_t maxfid, maxvid, i;
struct k8pnow_cpu_state *cstate;
struct k8pnow_state *state;
const char *techname;
u_int32_t regs [4];
cpuspeed = 0;
struct sysctl_oid *oid, *leaf;
do_cpuid(0x80000000, regs);
if (regs[0] < 0x80000007)
return 1;
do_cpuid(0x80000007, regs);
if (!(regs[3] & AMD_PN_FID_VID))
return 2;
/* Extended CPUID signature value */
do_cpuid(0x80000001, regs);
cstate = kmalloc(sizeof(struct k8pnow_cpu_state), M_DEVBUF, M_WAITOK);
cstate->n_states = 0;
status = rdmsr(MSR_AMDK7_FIDVID_STATUS);
maxfid = PN8_STA_MFID(status);
maxvid = PN8_STA_MVID(status);
if (PN8_STA_SFID(status) != PN8_STA_MFID(status))
techname = "PowerNow!";
else
techname = "Cool`n'Quiet";
k8pnow_states(cstate, regs[0], maxfid, maxvid);
len = 0;
if (cstate->n_states) {
freq_len = cstate->n_states * (sizeof("9999 ") - 1) + 1;
kprintf("%s speeds:",
techname);
for (i = cstate->n_states; i > 0; i--) {
state = &cstate->state_table[i - 1];
kprintf(" %d", state->freq);
len += ksnprintf(freqs_available + len, freq_len - len, "%d%s",
state->freq,
i > 1 ? " " : "");
}
kprintf(" MHz\n");
k8pnow_current_state = cstate;
k8_powernow_setperf(k8_get_curfreq());
} else {
kfree(cstate, M_DEVBUF);
kprintf("powernow: no power states found\n");
return 3;
}
/*
* Setup the sysctl sub-tree machdep.powernow.*
*/
oid = SYSCTL_ADD_NODE(&machdep_powernow_ctx,
SYSCTL_STATIC_CHILDREN(_machdep), OID_AUTO, "powernow",
CTLFLAG_RD, NULL, "");
if (oid == NULL)
return (EOPNOTSUPP);
oid = SYSCTL_ADD_NODE(&machdep_powernow_ctx, SYSCTL_CHILDREN(oid),
OID_AUTO, "frequency", CTLFLAG_RD, NULL, "");
if (oid == NULL)
return (EOPNOTSUPP);
leaf = SYSCTL_ADD_PROC(&machdep_powernow_ctx, SYSCTL_CHILDREN(oid),
OID_AUTO, "target", CTLTYPE_INT | CTLFLAG_RW, NULL, 0,
powernow_sysctl_helper, "I",
"Target CPU frequency for AMD PowerNow!");
if (leaf == NULL)
return (EOPNOTSUPP);
leaf = SYSCTL_ADD_PROC(&machdep_powernow_ctx, SYSCTL_CHILDREN(oid),
OID_AUTO, "current", CTLTYPE_INT | CTLFLAG_RD, NULL, 0,
powernow_sysctl_helper, "I",
"Current CPU frequency for AMD PowerNow!");
if (leaf == NULL)
return (EOPNOTSUPP);
leaf = SYSCTL_ADD_STRING(&machdep_powernow_ctx, SYSCTL_CHILDREN(oid),
OID_AUTO, "available", CTLFLAG_RD, freqs_available,
sizeof(freqs_available),
"CPU frequencies supported by AMD PowerNow!");
if (leaf == NULL)
return (EOPNOTSUPP);
return (0);
}
/********************************************************************************
* Allocate resources, initialise the controller.
*/
static int
twe_attach(device_t dev)
{
struct twe_softc *sc;
int rid, error;
u_int32_t command;
debug_called(4);
/*
* Initialise the softc structure.
*/
sc = device_get_softc(dev);
sc->twe_dev = dev;
sysctl_ctx_init(&sc->sysctl_ctx);
sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
device_get_nameunit(dev), CTLFLAG_RD, 0, "");
if (sc->sysctl_tree == NULL) {
twe_printf(sc, "cannot add sysctl tree node\n");
return (ENXIO);
}
SYSCTL_ADD_STRING(&sc->sysctl_ctx, SYSCTL_CHILDREN(sc->sysctl_tree),
OID_AUTO, "driver_version", CTLFLAG_RD, TWE_DRIVER_VERSION_STRING, 0,
"TWE driver version");
/*
* Make sure we are going to be able to talk to this board.
*/
command = pci_read_config(dev, PCIR_COMMAND, 2);
if ((command & PCIM_CMD_PORTEN) == 0) {
twe_printf(sc, "register window not available\n");
return(ENXIO);
}
/*
* Force the busmaster enable bit on, in case the BIOS forgot.
*/
command |= PCIM_CMD_BUSMASTEREN;
pci_write_config(dev, PCIR_COMMAND, command, 2);
/*
* Allocate the PCI register window.
*/
rid = TWE_IO_CONFIG_REG;
if ((sc->twe_io = bus_alloc_resource_any(dev, SYS_RES_IOPORT, &rid,
RF_ACTIVE)) == NULL) {
twe_printf(sc, "can't allocate register window\n");
twe_free(sc);
return(ENXIO);
}
sc->twe_btag = rman_get_bustag(sc->twe_io);
sc->twe_bhandle = rman_get_bushandle(sc->twe_io);
/*
* Allocate the parent bus DMA tag appropriate for PCI.
*/
if (bus_dma_tag_create(NULL, /* parent */
1, 0, /* alignment, boundary */
BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
BUS_SPACE_MAXADDR, /* highaddr */
NULL, NULL, /* filter, filterarg */
MAXBSIZE, TWE_MAX_SGL_LENGTH, /* maxsize, nsegments */
BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
0, /* flags */
NULL, /* lockfunc */
NULL, /* lockarg */
&sc->twe_parent_dmat)) {
twe_printf(sc, "can't allocate parent DMA tag\n");
twe_free(sc);
return(ENOMEM);
}
/*
* Allocate and connect our interrupt.
*/
rid = 0;
if ((sc->twe_irq = bus_alloc_resource_any(sc->twe_dev, SYS_RES_IRQ,
&rid, RF_SHAREABLE | RF_ACTIVE)) == NULL) {
twe_printf(sc, "can't allocate interrupt\n");
twe_free(sc);
return(ENXIO);
}
if (bus_setup_intr(sc->twe_dev, sc->twe_irq, INTR_TYPE_BIO | INTR_ENTROPY,
NULL, twe_pci_intr, sc, &sc->twe_intr)) {
twe_printf(sc, "can't set up interrupt\n");
twe_free(sc);
return(ENXIO);
}
/*
* Create DMA tag for mapping command's into controller-addressable space.
*/
if (bus_dma_tag_create(sc->twe_parent_dmat, /* parent */
1, 0, /* alignment, boundary */
BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
BUS_SPACE_MAXADDR, /* highaddr */
NULL, NULL, /* filter, filterarg */
sizeof(TWE_Command) *
TWE_Q_LENGTH, 1, /* maxsize, nsegments */
BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
0, /* flags */
NULL, /* lockfunc */
NULL, /* lockarg */
&sc->twe_cmd_dmat)) {
twe_printf(sc, "can't allocate data buffer DMA tag\n");
twe_free(sc);
return(ENOMEM);
}
/*
* Allocate memory and make it available for DMA.
*/
if (bus_dmamem_alloc(sc->twe_cmd_dmat, (void **)&sc->twe_cmd,
BUS_DMA_NOWAIT, &sc->twe_cmdmap)) {
twe_printf(sc, "can't allocate command memory\n");
return(ENOMEM);
}
bus_dmamap_load(sc->twe_cmd_dmat, sc->twe_cmdmap, sc->twe_cmd,
sizeof(TWE_Command) * TWE_Q_LENGTH,
twe_setup_request_dmamap, sc, 0);
bzero(sc->twe_cmd, sizeof(TWE_Command) * TWE_Q_LENGTH);
/*
* Create DMA tag for mapping objects into controller-addressable space.
*/
if (bus_dma_tag_create(sc->twe_parent_dmat, /* parent */
1, 0, /* alignment, boundary */
BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
BUS_SPACE_MAXADDR, /* highaddr */
NULL, NULL, /* filter, filterarg */
MAXBSIZE, TWE_MAX_SGL_LENGTH,/* maxsize, nsegments */
BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
BUS_DMA_ALLOCNOW, /* flags */
busdma_lock_mutex, /* lockfunc */
&Giant, /* lockarg */
&sc->twe_buffer_dmat)) {
twe_printf(sc, "can't allocate data buffer DMA tag\n");
twe_free(sc);
return(ENOMEM);
}
/*
* Create DMA tag for mapping objects into controller-addressable space.
*/
if (bus_dma_tag_create(sc->twe_parent_dmat, /* parent */
1, 0, /* alignment, boundary */
BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
BUS_SPACE_MAXADDR, /* highaddr */
NULL, NULL, /* filter, filterarg */
MAXBSIZE, 1, /* maxsize, nsegments */
BUS_SPACE_MAXSIZE_32BIT, /* maxsegsize */
0, /* flags */
NULL, /* lockfunc */
NULL, /* lockarg */
&sc->twe_immediate_dmat)) {
twe_printf(sc, "can't allocate data buffer DMA tag\n");
twe_free(sc);
return(ENOMEM);
}
/*
* Allocate memory for requests which cannot sleep or support continuation.
*/
if (bus_dmamem_alloc(sc->twe_immediate_dmat, (void **)&sc->twe_immediate,
BUS_DMA_NOWAIT, &sc->twe_immediate_map)) {
twe_printf(sc, "can't allocate memory for immediate requests\n");
return(ENOMEM);
}
/*
* Initialise the controller and driver core.
*/
if ((error = twe_setup(sc))) {
twe_free(sc);
return(error);
}
/*
* Print some information about the controller and configuration.
*/
twe_describe_controller(sc);
/*
* Create the control device.
*/
sc->twe_dev_t = make_dev(&twe_cdevsw, device_get_unit(sc->twe_dev), UID_ROOT, GID_OPERATOR,
S_IRUSR | S_IWUSR, "twe%d", device_get_unit(sc->twe_dev));
sc->twe_dev_t->si_drv1 = sc;
/*
* Schedule ourselves to bring the controller up once interrupts are available.
* This isn't strictly necessary, since we disable interrupts while probing the
* controller, but it is more in keeping with common practice for other disk
* devices.
*/
sc->twe_ich.ich_func = twe_intrhook;
sc->twe_ich.ich_arg = sc;
if (config_intrhook_establish(&sc->twe_ich) != 0) {
twe_printf(sc, "can't establish configuration hook\n");
twe_free(sc);
return(ENXIO);
}
return(0);
}
/*
* 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);
}
/*
* Function name: twa_attach
* Description: Allocates pci resources; updates sc; adds a node to the
* sysctl tree to expose the driver version; makes calls
* (to the Common Layer) to initialize ctlr, and to
* attach to CAM.
*
* Input: dev -- bus device corresponding to the ctlr
* Output: None
* Return value: 0 -- success
* non-zero-- failure
*/
static TW_INT32
twa_attach(device_t dev)
{
struct twa_softc *sc = device_get_softc(dev);
TW_UINT32 command;
TW_INT32 bar_num;
TW_INT32 bar0_offset;
TW_INT32 bar_size;
TW_INT32 error;
tw_osli_dbg_dprintf(3, sc, "entered");
sc->ctlr_handle.osl_ctlr_ctxt = sc;
/* Initialize the softc structure. */
sc->bus_dev = dev;
sc->device_id = pci_get_device(dev);
/* Initialize the mutexes right here. */
sc->io_lock = &(sc->io_lock_handle);
mtx_init(sc->io_lock, "tw_osl_io_lock", NULL, MTX_SPIN);
sc->q_lock = &(sc->q_lock_handle);
mtx_init(sc->q_lock, "tw_osl_q_lock", NULL, MTX_SPIN);
sc->sim_lock = &(sc->sim_lock_handle);
mtx_init(sc->sim_lock, "tw_osl_sim_lock", NULL, MTX_DEF | MTX_RECURSE);
sysctl_ctx_init(&sc->sysctl_ctxt);
sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctxt,
SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
device_get_nameunit(dev), CTLFLAG_RD, 0, "");
if (sc->sysctl_tree == NULL) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2000,
"Cannot add sysctl tree node",
ENXIO);
return(ENXIO);
}
SYSCTL_ADD_STRING(&sc->sysctl_ctxt, SYSCTL_CHILDREN(sc->sysctl_tree),
OID_AUTO, "driver_version", CTLFLAG_RD,
TW_OSL_DRIVER_VERSION_STRING, 0, "TWA driver version");
/* Make sure we are going to be able to talk to this board. */
command = pci_read_config(dev, PCIR_COMMAND, 2);
if ((command & PCIM_CMD_PORTEN) == 0) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2001,
"Register window not available",
ENXIO);
tw_osli_free_resources(sc);
return(ENXIO);
}
/* Force the busmaster enable bit on, in case the BIOS forgot. */
command |= PCIM_CMD_BUSMASTEREN;
pci_write_config(dev, PCIR_COMMAND, command, 2);
/* Allocate the PCI register window. */
if ((error = tw_cl_get_pci_bar_info(sc->device_id, TW_CL_BAR_TYPE_MEM,
&bar_num, &bar0_offset, &bar_size))) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x201F,
"Can't get PCI BAR info",
error);
tw_osli_free_resources(sc);
return(error);
}
sc->reg_res_id = PCIR_BARS + bar0_offset;
if ((sc->reg_res = bus_alloc_resource(dev, SYS_RES_MEMORY,
&(sc->reg_res_id), 0, ~0, 1, RF_ACTIVE))
== NULL) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2002,
"Can't allocate register window",
ENXIO);
tw_osli_free_resources(sc);
return(ENXIO);
}
sc->bus_tag = rman_get_bustag(sc->reg_res);
sc->bus_handle = rman_get_bushandle(sc->reg_res);
/* Allocate and register our interrupt. */
sc->irq_res_id = 0;
if ((sc->irq_res = bus_alloc_resource(sc->bus_dev, SYS_RES_IRQ,
&(sc->irq_res_id), 0, ~0, 1,
RF_SHAREABLE | RF_ACTIVE)) == NULL) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2003,
"Can't allocate interrupt",
ENXIO);
tw_osli_free_resources(sc);
return(ENXIO);
}
if ((error = twa_setup_intr(sc))) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2004,
"Can't set up interrupt",
error);
tw_osli_free_resources(sc);
return(error);
}
if ((error = tw_osli_alloc_mem(sc))) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2005,
"Memory allocation failure",
error);
tw_osli_free_resources(sc);
return(error);
}
/* Initialize the Common Layer for this controller. */
if ((error = tw_cl_init_ctlr(&sc->ctlr_handle, sc->flags, sc->device_id,
TW_OSLI_MAX_NUM_REQUESTS, TW_OSLI_MAX_NUM_AENS,
sc->non_dma_mem, sc->dma_mem,
sc->dma_mem_phys
))) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2006,
"Failed to initialize Common Layer/controller",
error);
tw_osli_free_resources(sc);
return(error);
}
/* Create the control device. */
sc->ctrl_dev = make_dev(&twa_cdevsw, device_get_unit(sc->bus_dev),
UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR,
"twa%d", device_get_unit(sc->bus_dev));
sc->ctrl_dev->si_drv1 = sc;
if ((error = tw_osli_cam_attach(sc))) {
tw_osli_free_resources(sc);
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2007,
"Failed to initialize CAM",
error);
return(error);
}
sc->watchdog_index = 0;
callout_init(&(sc->watchdog_callout[0]), CALLOUT_MPSAFE);
callout_init(&(sc->watchdog_callout[1]), CALLOUT_MPSAFE);
callout_reset(&(sc->watchdog_callout[0]), 5*hz, twa_watchdog, &sc->ctlr_handle);
return(0);
}
static int
tws_attach(device_t dev)
{
struct tws_softc *sc = device_get_softc(dev);
u_int32_t bar;
int error=0,i;
/* no tracing yet */
/* Look up our softc and initialize its fields. */
sc->tws_dev = dev;
sc->device_id = pci_get_device(dev);
sc->subvendor_id = pci_get_subvendor(dev);
sc->subdevice_id = pci_get_subdevice(dev);
/* Intialize mutexes */
mtx_init( &sc->q_lock, "tws_q_lock", NULL, MTX_DEF);
mtx_init( &sc->sim_lock, "tws_sim_lock", NULL, MTX_DEF);
mtx_init( &sc->gen_lock, "tws_gen_lock", NULL, MTX_DEF);
mtx_init( &sc->io_lock, "tws_io_lock", NULL, MTX_DEF | MTX_RECURSE);
if ( tws_init_trace_q(sc) == FAILURE )
printf("trace init failure\n");
/* send init event */
mtx_lock(&sc->gen_lock);
tws_send_event(sc, TWS_INIT_START);
mtx_unlock(&sc->gen_lock);
#if _BYTE_ORDER == _BIG_ENDIAN
TWS_TRACE(sc, "BIG endian", 0, 0);
#endif
/* sysctl context setup */
sysctl_ctx_init(&sc->tws_clist);
sc->tws_oidp = SYSCTL_ADD_NODE(&sc->tws_clist,
SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
device_get_nameunit(dev),
CTLFLAG_RD, 0, "");
if ( sc->tws_oidp == NULL ) {
tws_log(sc, SYSCTL_TREE_NODE_ADD);
goto attach_fail_1;
}
SYSCTL_ADD_STRING(&sc->tws_clist, SYSCTL_CHILDREN(sc->tws_oidp),
OID_AUTO, "driver_version", CTLFLAG_RD,
TWS_DRIVER_VERSION_STRING, 0, "TWS driver version");
pci_enable_busmaster(dev);
bar = pci_read_config(dev, TWS_PCI_BAR0, 4);
TWS_TRACE_DEBUG(sc, "bar0 ", bar, 0);
bar = pci_read_config(dev, TWS_PCI_BAR1, 4);
bar = bar & ~TWS_BIT2;
TWS_TRACE_DEBUG(sc, "bar1 ", bar, 0);
/* MFA base address is BAR2 register used for
* push mode. Firmware will evatualy move to
* pull mode during witch this needs to change
*/
#ifndef TWS_PULL_MODE_ENABLE
sc->mfa_base = (u_int64_t)pci_read_config(dev, TWS_PCI_BAR2, 4);
sc->mfa_base = sc->mfa_base & ~TWS_BIT2;
TWS_TRACE_DEBUG(sc, "bar2 ", sc->mfa_base, 0);
#endif
/* allocate MMIO register space */
sc->reg_res_id = TWS_PCI_BAR1; /* BAR1 offset */
if ((sc->reg_res = bus_alloc_resource(dev, SYS_RES_MEMORY,
&(sc->reg_res_id), 0, ~0, 1, RF_ACTIVE))
== NULL) {
tws_log(sc, ALLOC_MEMORY_RES);
goto attach_fail_1;
}
sc->bus_tag = rman_get_bustag(sc->reg_res);
sc->bus_handle = rman_get_bushandle(sc->reg_res);
#ifndef TWS_PULL_MODE_ENABLE
/* Allocate bus space for inbound mfa */
sc->mfa_res_id = TWS_PCI_BAR2; /* BAR2 offset */
if ((sc->mfa_res = bus_alloc_resource(dev, SYS_RES_MEMORY,
&(sc->mfa_res_id), 0, ~0, 0x100000, RF_ACTIVE))
== NULL) {
tws_log(sc, ALLOC_MEMORY_RES);
goto attach_fail_2;
}
sc->bus_mfa_tag = rman_get_bustag(sc->mfa_res);
sc->bus_mfa_handle = rman_get_bushandle(sc->mfa_res);
#endif
/* Allocate and register our interrupt. */
sc->intr_type = TWS_INTx; /* default */
if ( tws_enable_msi )
sc->intr_type = TWS_MSI;
if ( tws_setup_irq(sc) == FAILURE ) {
tws_log(sc, ALLOC_MEMORY_RES);
goto attach_fail_3;
}
/*
* Create a /dev entry for this device. The kernel will assign us
* a major number automatically. We use the unit number of this
* device as the minor number and name the character device
* "tws<unit>".
*/
sc->tws_cdev = make_dev(&tws_cdevsw, device_get_unit(dev),
UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR, "tws%u",
device_get_unit(dev));
sc->tws_cdev->si_drv1 = sc;
if ( tws_init(sc) == FAILURE ) {
tws_log(sc, TWS_INIT_FAILURE);
goto attach_fail_4;
}
if ( tws_init_ctlr(sc) == FAILURE ) {
tws_log(sc, TWS_CTLR_INIT_FAILURE);
goto attach_fail_4;
}
if ((error = tws_cam_attach(sc))) {
tws_log(sc, TWS_CAM_ATTACH);
goto attach_fail_4;
}
/* send init complete event */
mtx_lock(&sc->gen_lock);
tws_send_event(sc, TWS_INIT_COMPLETE);
mtx_unlock(&sc->gen_lock);
TWS_TRACE_DEBUG(sc, "attached successfully", 0, sc->device_id);
return(0);
attach_fail_4:
tws_teardown_intr(sc);
destroy_dev(sc->tws_cdev);
attach_fail_3:
for(i=0;i<sc->irqs;i++) {
if ( sc->irq_res[i] ){
if (bus_release_resource(sc->tws_dev,
SYS_RES_IRQ, sc->irq_res_id[i], sc->irq_res[i]))
TWS_TRACE(sc, "bus irq res", 0, 0);
}
}
#ifndef TWS_PULL_MODE_ENABLE
attach_fail_2:
#endif
if ( sc->mfa_res ){
if (bus_release_resource(sc->tws_dev,
SYS_RES_MEMORY, sc->mfa_res_id, sc->mfa_res))
TWS_TRACE(sc, "bus release ", 0, sc->mfa_res_id);
}
if ( sc->reg_res ){
if (bus_release_resource(sc->tws_dev,
SYS_RES_MEMORY, sc->reg_res_id, sc->reg_res))
TWS_TRACE(sc, "bus release2 ", 0, sc->reg_res_id);
}
attach_fail_1:
mtx_destroy(&sc->q_lock);
mtx_destroy(&sc->sim_lock);
mtx_destroy(&sc->gen_lock);
mtx_destroy(&sc->io_lock);
sysctl_ctx_free(&sc->tws_clist);
return (ENXIO);
}
/*
* Function name: twa_attach
* Description: Allocates pci resources; updates sc; adds a node to the
* sysctl tree to expose the driver version; makes calls
* (to the Common Layer) to initialize ctlr, and to
* attach to CAM.
*
* Input: dev -- bus device corresponding to the ctlr
* Output: None
* Return value: 0 -- success
* non-zero-- failure
*/
static TW_INT32
twa_attach(device_t dev)
{
struct twa_softc *sc = device_get_softc(dev);
TW_INT32 bar_num;
TW_INT32 bar0_offset;
TW_INT32 bar_size;
TW_INT32 irq_flags;
TW_INT32 error;
sc->ctlr_handle.osl_ctlr_ctxt = sc;
/* Initialize the softc structure. */
sc->bus_dev = dev;
tw_osli_dbg_dprintf(3, sc, "entered");
sc->device_id = pci_get_device(dev);
/* Initialize the mutexes right here. */
sc->io_lock = &(sc->io_lock_handle);
spin_init(sc->io_lock, "twa_iolock");
sc->q_lock = &(sc->q_lock_handle);
spin_init(sc->q_lock, "twa_qlock");
sc->sim_lock = &(sc->sim_lock_handle);
lockinit(sc->sim_lock, "tw_osl_sim_lock", 0, LK_CANRECURSE);
SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "driver_version", CTLFLAG_RD,
TW_OSL_DRIVER_VERSION_STRING, 0, "TWA driver version");
/* Force the busmaster enable bit on, in case the BIOS forgot. */
pci_enable_busmaster(dev);
/* Allocate the PCI register window. */
if ((error = tw_cl_get_pci_bar_info(sc->device_id, TW_CL_BAR_TYPE_MEM,
&bar_num, &bar0_offset, &bar_size))) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x201F,
"Can't get PCI BAR info",
error);
tw_osli_free_resources(sc);
return(error);
}
sc->reg_res_id = PCIR_BARS + bar0_offset;
if ((sc->reg_res = bus_alloc_resource(dev, SYS_RES_MEMORY,
&(sc->reg_res_id), 0, ~0, 1, RF_ACTIVE))
== NULL) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2002,
"Can't allocate register window",
ENXIO);
tw_osli_free_resources(sc);
return(ENXIO);
}
sc->bus_tag = rman_get_bustag(sc->reg_res);
sc->bus_handle = rman_get_bushandle(sc->reg_res);
/* Allocate and register our interrupt. */
sc->irq_res_id = 0;
sc->irq_type = pci_alloc_1intr(sc->bus_dev, twa_msi_enable,
&sc->irq_res_id, &irq_flags);
if ((sc->irq_res = bus_alloc_resource(sc->bus_dev, SYS_RES_IRQ,
&(sc->irq_res_id), 0, ~0, 1,
irq_flags)) == NULL) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2003,
"Can't allocate interrupt",
ENXIO);
tw_osli_free_resources(sc);
return(ENXIO);
}
if ((error = twa_setup_intr(sc))) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2004,
"Can't set up interrupt",
error);
tw_osli_free_resources(sc);
return(error);
}
if ((error = tw_osli_alloc_mem(sc))) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2005,
"Memory allocation failure",
error);
tw_osli_free_resources(sc);
return(error);
}
/* Initialize the Common Layer for this controller. */
if ((error = tw_cl_init_ctlr(&sc->ctlr_handle, sc->flags, sc->device_id,
TW_OSLI_MAX_NUM_REQUESTS, TW_OSLI_MAX_NUM_AENS,
sc->non_dma_mem, sc->dma_mem,
sc->dma_mem_phys
))) {
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2006,
"Failed to initialize Common Layer/controller",
error);
tw_osli_free_resources(sc);
return(error);
}
/* Create the control device. */
sc->ctrl_dev = make_dev(&twa_ops, device_get_unit(sc->bus_dev),
UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR,
"twa%d", device_get_unit(sc->bus_dev));
sc->ctrl_dev->si_drv1 = sc;
if ((error = tw_osli_cam_attach(sc))) {
tw_osli_free_resources(sc);
tw_osli_printf(sc, "error = %d",
TW_CL_SEVERITY_ERROR_STRING,
TW_CL_MESSAGE_SOURCE_FREEBSD_DRIVER,
0x2007,
"Failed to initialize CAM",
error);
return(error);
}
sc->watchdog_index = 0;
callout_init_mp(&(sc->watchdog_callout[0]));
callout_init_mp(&(sc->watchdog_callout[1]));
callout_reset(&(sc->watchdog_callout[0]), 5*hz, twa_watchdog, &sc->ctlr_handle);
return(0);
}
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);
}
/*
* Function name: twa_attach
* Description: Allocates pci resources; updates sc; adds a node to the
* sysctl tree to expose the driver version; makes calls
* to initialize ctlr, and to attach to CAM.
*
* Input: dev -- bus device corresponding to the ctlr
* Output: None
* Return value: 0 -- success
* non-zero-- failure
*/
static int
twa_attach(device_t dev)
{
struct twa_softc *sc = device_get_softc(dev);
u_int32_t command;
int res_id;
int error;
twa_dbg_dprint_enter(3, sc);
/* Initialize the softc structure. */
sc->twa_bus_dev = dev;
sysctl_ctx_init(&sc->twa_sysctl_ctx);
sc->twa_sysctl_tree = SYSCTL_ADD_NODE(&sc->twa_sysctl_ctx,
SYSCTL_STATIC_CHILDREN(_hw), OID_AUTO,
device_get_nameunit(dev), CTLFLAG_RD, 0, "");
if (sc->twa_sysctl_tree == NULL) {
twa_printf(sc, "Cannot add sysctl tree node.\n");
return(ENXIO);
}
SYSCTL_ADD_STRING(&sc->twa_sysctl_ctx, SYSCTL_CHILDREN(sc->twa_sysctl_tree),
OID_AUTO, "driver_version", CTLFLAG_RD,
TWA_DRIVER_VERSION_STRING, 0, "TWA driver version");
/* Make sure we are going to be able to talk to this board. */
command = pci_read_config(dev, PCIR_COMMAND, 2);
if ((command & PCIM_CMD_PORTEN) == 0) {
twa_printf(sc, "Register window not available.\n");
return(ENXIO);
}
/* Force the busmaster enable bit on, in case the BIOS forgot. */
command |= PCIM_CMD_BUSMASTEREN;
pci_write_config(dev, PCIR_COMMAND, command, 2);
/* Allocate the PCI register window. */
res_id = TWA_IO_CONFIG_REG;
if ((sc->twa_io_res = bus_alloc_resource(dev, SYS_RES_IOPORT, &res_id,
0, ~0, 1, RF_ACTIVE)) == NULL) {
twa_printf(sc, "can't allocate register window.\n");
twa_free(sc);
return(ENXIO);
}
sc->twa_bus_tag = rman_get_bustag(sc->twa_io_res);
sc->twa_bus_handle = rman_get_bushandle(sc->twa_io_res);
/* Allocate and connect our interrupt. */
res_id = 0;
if ((sc->twa_irq_res = bus_alloc_resource(sc->twa_bus_dev, SYS_RES_IRQ,
&res_id, 0, ~0, 1,
RF_SHAREABLE | RF_ACTIVE)) == NULL) {
twa_printf(sc, "Can't allocate interrupt.\n");
twa_free(sc);
return(ENXIO);
}
if (bus_setup_intr(sc->twa_bus_dev, sc->twa_irq_res, INTR_TYPE_CAM,
twa_pci_intr, sc, &sc->twa_intr_handle)) {
twa_printf(sc, "Can't set up interrupt.\n");
twa_free(sc);
return(ENXIO);
}
/* Initialize the driver for this controller. */
if ((error = twa_setup(sc))) {
twa_free(sc);
return(error);
}
/* Print some information about the controller and configuration. */
twa_describe_controller(sc);
/* Create the control device. */
sc->twa_ctrl_dev = make_dev(&twa_cdevsw, device_get_unit(sc->twa_bus_dev),
UID_ROOT, GID_OPERATOR, S_IRUSR | S_IWUSR,
"twa%d", device_get_unit(sc->twa_bus_dev));
sc->twa_ctrl_dev->si_drv1 = sc;
/*
* Schedule ourselves to bring the controller up once interrupts are
* available. This isn't strictly necessary, since we disable
* interrupts while probing the controller, but it is more in keeping
* with common practice for other disk devices.
*/
sc->twa_ich.ich_func = twa_intrhook;
sc->twa_ich.ich_arg = sc;
if (config_intrhook_establish(&sc->twa_ich) != 0) {
twa_printf(sc, "Can't establish configuration hook.\n");
twa_free(sc);
return(ENXIO);
}
if ((error = twa_cam_setup(sc))) {
twa_free(sc);
return(error);
}
return(0);
}
/*
* Install interface into kernel networking data structures
*/
int
ed_attach(device_t dev)
{
struct ed_softc *sc = device_get_softc(dev);
struct ifnet *ifp;
sc->dev = dev;
ED_LOCK_INIT(sc);
ifp = sc->ifp = if_alloc(IFT_ETHER);
if (ifp == NULL) {
device_printf(dev, "can not if_alloc()\n");
ED_LOCK_DESTROY(sc);
return (ENOSPC);
}
if (sc->readmem == NULL) {
if (sc->mem_shared) {
if (sc->isa16bit)
sc->readmem = ed_shmem_readmem16;
else
sc->readmem = ed_shmem_readmem8;
} else {
sc->readmem = ed_pio_readmem;
}
}
if (sc->sc_write_mbufs == NULL) {
device_printf(dev, "No write mbufs routine set\n");
return (ENXIO);
}
callout_init_mtx(&sc->tick_ch, ED_MUTEX(sc), 0);
/*
* Set interface to stopped condition (reset)
*/
ed_stop_hw(sc);
/*
* Initialize ifnet structure
*/
ifp->if_softc = sc;
if_initname(ifp, device_get_name(dev), device_get_unit(dev));
ifp->if_start = ed_start;
ifp->if_ioctl = ed_ioctl;
ifp->if_init = ed_init;
IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
IFQ_SET_READY(&ifp->if_snd);
ifp->if_linkmib = &sc->mibdata;
ifp->if_linkmiblen = sizeof sc->mibdata;
/*
* XXX - should do a better job.
*/
if (sc->chip_type == ED_CHIP_TYPE_WD790)
sc->mibdata.dot3StatsEtherChipSet =
DOT3CHIPSET(dot3VendorWesternDigital,
dot3ChipSetWesternDigital83C790);
else
sc->mibdata.dot3StatsEtherChipSet =
DOT3CHIPSET(dot3VendorNational,
dot3ChipSetNational8390);
sc->mibdata.dot3Compliance = DOT3COMPLIANCE_COLLS;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
/*
* Set default state for LINK2 flag (used to disable the
* tranceiver for AUI operation), based on config option.
* We only set this flag before we attach the device, so there's
* no race. It is convenient to allow users to turn this off
* by default in the kernel config, but given our more advanced
* boot time configuration options, this might no longer be needed.
*/
if (device_get_flags(dev) & ED_FLAGS_DISABLE_TRANCEIVER)
ifp->if_flags |= IFF_LINK2;
/*
* Attach the interface
*/
ether_ifattach(ifp, sc->enaddr);
/* device attach does transition from UNCONFIGURED to IDLE state */
sc->tx_mem = sc->txb_cnt * ED_PAGE_SIZE * ED_TXBUF_SIZE;
sc->rx_mem = (sc->rec_page_stop - sc->rec_page_start) * ED_PAGE_SIZE;
SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
0, "type", CTLFLAG_RD, sc->type_str, 0,
"Type of chip in card");
SYSCTL_ADD_UINT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
1, "TxMem", CTLFLAG_RD, &sc->tx_mem, 0,
"Memory set aside for transmitting packets");
SYSCTL_ADD_UINT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
2, "RxMem", CTLFLAG_RD, &sc->rx_mem, 0,
"Memory set aside for receiving packets");
SYSCTL_ADD_UINT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
3, "Mem", CTLFLAG_RD, &sc->mem_size, 0,
"Total Card Memory");
if (bootverbose) {
if (sc->type_str && (*sc->type_str != 0))
device_printf(dev, "type %s ", sc->type_str);
else
device_printf(dev, "type unknown (0x%x) ", sc->type);
#ifdef ED_HPP
if (sc->vendor == ED_VENDOR_HP)
printf("(%s %s IO)",
(sc->hpp_id & ED_HPP_ID_16_BIT_ACCESS) ?
"16-bit" : "32-bit",
sc->hpp_mem_start ? "memory mapped" : "regular");
else
#endif
printf("%s", sc->isa16bit ? "(16 bit)" : "(8 bit)");
#if defined(ED_HPP) || defined(ED_3C503)
printf("%s", (((sc->vendor == ED_VENDOR_3COM) ||
(sc->vendor == ED_VENDOR_HP)) &&
(ifp->if_flags & IFF_LINK2)) ?
" tranceiver disabled" : "");
#endif
printf("\n");
}
return (0);
}
static int
opal_sensor_attach(device_t dev)
{
struct opal_sensor_softc *sc;
struct sysctl_ctx_list *ctx;
struct sysctl_oid *tree;
char type[8];
phandle_t node;
cell_t sensor_id;
int i;
sc = device_get_softc(dev);
sc->sc_dev = dev;
node = ofw_bus_get_node(dev);
if (OF_getencprop(node, "sensor-data", &sensor_id, sizeof(sensor_id)) < 0) {
device_printf(dev, "Missing sensor ID\n");
return (ENXIO);
}
if (OF_getprop(node, "sensor-type", type, sizeof(type)) < 0) {
device_printf(dev, "Missing sensor type\n");
return (ENXIO);
}
sc->sc_type = -1;
for (i = 0; i < OPAL_SENSOR_MAX; i++) {
if (strcmp(type, opal_sensor_types[i]) == 0) {
sc->sc_type = i;
break;
}
}
if (sc->sc_type == -1) {
device_printf(dev, "Unknown sensor type '%s'\n", type);
return (ENXIO);
}
ctx = device_get_sysctl_ctx(dev);
tree = device_get_sysctl_tree(dev);
sc->sc_handle = sensor_id;
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"sensor", CTLTYPE_INT | CTLFLAG_RD, sc, sensor_id,
opal_sensor_sysctl, (sc->sc_type == OPAL_SENSOR_TEMP) ? "IK" : "I",
"current value");
SYSCTL_ADD_STRING(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "type",
CTLFLAG_RD, __DECONST(char *, opal_sensor_types[sc->sc_type]),
0, "");
OF_getprop_alloc(node, "label", (void **)&sc->sc_label);
SYSCTL_ADD_STRING(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, "label",
CTLFLAG_RD, sc->sc_label, 0, "");
if (OF_getprop(node, "sensor-data-min",
&sensor_id, sizeof(sensor_id)) > 0) {
sc->sc_min_handle = sensor_id;
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"sensor_min", CTLTYPE_INT | CTLFLAG_RD, sc, sensor_id,
opal_sensor_sysctl,
(sc->sc_type == OPAL_SENSOR_TEMP) ? "IK" : "I",
"minimum value");
}
if (OF_getprop(node, "sensor-data-max",
&sensor_id, sizeof(sensor_id)) > 0) {
sc->sc_max_handle = sensor_id;
SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
"sensor_max", CTLTYPE_INT | CTLFLAG_RD, sc, sensor_id,
opal_sensor_sysctl,
(sc->sc_type == OPAL_SENSOR_TEMP) ? "IK" : "I",
"maximum value");
}
SENSOR_LOCK_INIT(sc);
return (0);
}
