static void
mpt_set_options(struct mpt_softc *mpt)
{
int tval;
tval = 0;
if (resource_int_value(device_get_name(mpt->dev),
device_get_unit(mpt->dev), "debug", &tval) == 0 && tval != 0) {
mpt->verbose = tval;
}
tval = -1;
if (resource_int_value(device_get_name(mpt->dev),
device_get_unit(mpt->dev), "role", &tval) == 0 && tval >= 0 &&
tval <= 3) {
mpt->cfg_role = tval;
mpt->do_cfg_role = 1;
}
tval = 0;
mpt->msi_enable = 0;
if (mpt->is_sas)
mpt->msi_enable = 1;
if (resource_int_value(device_get_name(mpt->dev),
device_get_unit(mpt->dev), "msi_enable", &tval) == 0) {
mpt->msi_enable = tval;
}
}
static void
obio_hinted_child(device_t bus, const char *dname, int dunit)
{
device_t child;
long maddr;
int msize;
int irq;
int result;
child = BUS_ADD_CHILD(bus, 0, dname, dunit);
/*
* Set hard-wired resources for hinted child using
* specific RIDs.
*/
resource_long_value(dname, dunit, "maddr", &maddr);
resource_int_value(dname, dunit, "msize", &msize);
result = bus_set_resource(child, SYS_RES_MEMORY, 0,
maddr, msize);
if (result != 0)
device_printf(bus, "warning: bus_set_resource() failed\n");
if (resource_int_value(dname, dunit, "irq", &irq) == 0) {
result = bus_set_resource(child, SYS_RES_IRQ, 0, irq, 1);
if (result != 0)
device_printf(bus,
"warning: bus_set_resource() failed\n");
}
}
static int
ath_ahb_probe(device_t dev)
{
int vendor_id, device_id;
const char* devname;
/*
* Check if a device/vendor ID is provided in hints.
*/
if (resource_int_value(device_get_name(dev), device_get_unit(dev),
"vendor_id", &vendor_id) != 0) {
vendor_id = VENDOR_ATHEROS;
}
if (resource_int_value(device_get_name(dev), device_get_unit(dev),
"device_id", &device_id) != 0) {
device_id = AR9130_DEVID;
}
device_printf(dev, "Vendor=0x%04x, Device=0x%04x\n",
vendor_id & 0xffff,
device_id & 0xffff);
/* Attempt to probe */
devname = ath_hal_probe(vendor_id, device_id);
if (devname != NULL) {
device_set_desc(dev, devname);
return BUS_PROBE_DEFAULT;
}
return ENXIO;
}
static int
ata_zbbus_attach(device_t dev)
{
int i, rid, regshift, regoffset;
struct ata_channel *ch;
struct resource *io;
ch = device_get_softc(dev);
if (ch->attached)
return (0);
ch->attached = 1;
rid = 0;
io = bus_alloc_resource(dev, SYS_RES_MEMORY, &rid, 0, ~0, 1, RF_ACTIVE);
if (io == NULL)
return (ENXIO);
/*
* SWARM needs an address shift of 5 when accessing ATA registers.
*
* For e.g. an access to register 4 actually needs an address
* of (4 << 5) to be output on the generic bus.
*/
regshift = 5;
resource_int_value(device_get_name(dev), device_get_unit(dev),
"regshift", ®shift);
if (regshift && bootverbose)
device_printf(dev, "using a register shift of %d\n", regshift);
regoffset = 0x1F0;
resource_int_value(device_get_name(dev), device_get_unit(dev),
"regoffset", ®offset);
if (regoffset && bootverbose) {
device_printf(dev, "using a register offset of 0x%0x\n",
regoffset);
}
/* setup the ata register addresses */
for (i = ATA_DATA; i <= ATA_COMMAND; ++i) {
ch->r_io[i].res = io;
ch->r_io[i].offset = (regoffset + i) << regshift;
}
ch->r_io[ATA_CONTROL].res = io;
ch->r_io[ATA_CONTROL].offset = (regoffset + ATA_CTLOFFSET) << regshift;
ch->r_io[ATA_IDX_ADDR].res = io; /* XXX what is this used for */
ata_default_registers(dev);
/* initialize softc for this channel */
ch->unit = 0;
ch->flags |= ATA_USE_16BIT;
ata_generic_hw(dev);
return (ata_attach(dev));
}
static int
altera_avgen_nexus_attach(device_t dev)
{
struct altera_avgen_softc *sc;
const char *str_fileio, *str_geomio, *str_mmapio;
const char *str_devname;
int devunit, error;
sc = device_get_softc(dev);
sc->avg_dev = dev;
sc->avg_unit = device_get_unit(dev);
/*
* Query non-standard hints to find out what operations are permitted
* on the device, and whether it is cached.
*/
str_fileio = NULL;
str_geomio = NULL;
str_mmapio = NULL;
str_devname = NULL;
devunit = -1;
sc->avg_width = 1;
error = resource_int_value(device_get_name(dev), device_get_unit(dev),
ALTERA_AVALON_STR_WIDTH, &sc->avg_width);
if (error != 0 && error != ENOENT) {
device_printf(dev, "invalid %s\n", ALTERA_AVALON_STR_WIDTH);
return (error);
}
(void)resource_string_value(device_get_name(dev),
device_get_unit(dev), ALTERA_AVALON_STR_FILEIO, &str_fileio);
(void)resource_string_value(device_get_name(dev),
device_get_unit(dev), ALTERA_AVALON_STR_GEOMIO, &str_geomio);
(void)resource_string_value(device_get_name(dev),
device_get_unit(dev), ALTERA_AVALON_STR_MMAPIO, &str_mmapio);
(void)resource_string_value(device_get_name(dev),
device_get_unit(dev), ALTERA_AVALON_STR_DEVNAME, &str_devname);
(void)resource_int_value(device_get_name(dev), device_get_unit(dev),
ALTERA_AVALON_STR_DEVUNIT, &devunit);
/* Memory allocation and checking. */
sc->avg_rid = 0;
sc->avg_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
&sc->avg_rid, RF_ACTIVE);
if (sc->avg_res == NULL) {
device_printf(dev, "couldn't map memory\n");
return (ENXIO);
}
error = altera_avgen_attach(sc, str_fileio, str_geomio, str_mmapio,
str_devname, devunit);
if (error != 0)
bus_release_resource(dev, SYS_RES_MEMORY, sc->avg_rid,
sc->avg_res);
return (error);
}
static void
ixp425_hinted_child(device_t bus, const char *dname, int dunit)
{
device_t child;
struct ixp425_ivar *ivar;
child = BUS_ADD_CHILD(bus, 0, dname, dunit);
ivar = IXP425_IVAR(child);
resource_int_value(dname, dunit, "addr", &ivar->addr);
resource_int_value(dname, dunit, "irq", &ivar->irq);
}
static void
spibus_hinted_child(device_t bus, const char *dname, int dunit)
{
device_t child;
struct spibus_ivar *devi;
child = BUS_ADD_CHILD(bus, 0, dname, dunit);
devi = SPIBUS_IVAR(child);
devi->mode = SPIBUS_MODE_NONE;
resource_int_value(dname, dunit, "cs", &devi->cs);
resource_int_value(dname, dunit, "mode", &devi->mode);
}
static void
nexus_hinted_child(device_t bus, const char *dname, int dunit)
{
device_t child;
long maddr;
int msize;
int order;
int result;
int irq;
int mem_hints_count;
if ((resource_int_value(dname, dunit, "order", &order)) != 0)
order = 1000;
child = BUS_ADD_CHILD(bus, order, dname, dunit);
if (child == NULL)
return;
/*
* Set hard-wired resources for hinted child using
* specific RIDs.
*/
mem_hints_count = 0;
if (resource_long_value(dname, dunit, "maddr", &maddr) == 0)
mem_hints_count++;
if (resource_int_value(dname, dunit, "msize", &msize) == 0)
mem_hints_count++;
/* check if all info for mem resource has been provided */
if ((mem_hints_count > 0) && (mem_hints_count < 2)) {
printf("Either maddr or msize hint is missing for %s%d\n",
dname, dunit);
}
else if (mem_hints_count) {
dprintf("%s: discovered hinted child %s at maddr %p(%d)\n",
__func__, device_get_nameunit(child),
(void *)(intptr_t)maddr, msize);
result = bus_set_resource(child, SYS_RES_MEMORY, 0, maddr,
msize);
if (result != 0) {
device_printf(bus,
"warning: bus_set_resource() failed\n");
}
}
if (resource_int_value(dname, dunit, "irq", &irq) == 0) {
result = bus_set_resource(child, SYS_RES_IRQ, 0, irq, 1);
if (result != 0)
device_printf(bus,
"warning: bus_set_resource() failed\n");
}
}
static void
isahint_add_device(device_t parent, const char *name, int unit)
{
device_t child;
int sensitive, start, count, t;
int order;
/* device-specific flag overrides any wildcard */
sensitive = 0;
if (resource_int_value(name, unit, "sensitive", &sensitive) != 0)
resource_int_value(name, -1, "sensitive", &sensitive);
if (sensitive)
order = ISA_ORDER_SENSITIVE;
else
order = ISA_ORDER_SPECULATIVE;
child = BUS_ADD_CHILD(parent, parent, order, name, unit);
if (child == 0)
return;
start = 0;
count = 0;
resource_int_value(name, unit, "port", &start);
resource_int_value(name, unit, "portsize", &count);
if (start > 0 || count > 0)
bus_set_resource(child, SYS_RES_IOPORT, 0, start, count, -1);
start = 0;
count = 0;
resource_int_value(name, unit, "maddr", &start);
resource_int_value(name, unit, "msize", &count);
if (start > 0 || count > 0)
bus_set_resource(child, SYS_RES_MEMORY, 0, start, count, -1);
if (resource_int_value(name, unit, "irq", &start) == 0 && start > 0) {
bus_set_resource(child, SYS_RES_IRQ, 0, start, 1,
machintr_legacy_intr_cpuid(start));
}
if (resource_int_value(name, unit, "drq", &start) == 0 && start >= 0)
bus_set_resource(child, SYS_RES_DRQ, 0, start, 1, -1);
if (resource_int_value(name, unit, "flags", &t) == 0)
device_set_flags(child, t);
if (resource_int_value(name, unit, "disabled", &t) == 0 && t != 0)
device_disable(child);
}
/*
* Map the local APIC and setup necessary interrupt vectors.
*/
void
lapic_init(vm_paddr_t addr)
{
u_int regs[4];
int i, arat;
/* Map the local APIC and setup the spurious interrupt handler. */
KASSERT(trunc_page(addr) == addr,
("local APIC not aligned on a page boundary"));
lapic_paddr = addr;
lapic = pmap_mapdev(addr, sizeof(lapic_t));
setidt(APIC_SPURIOUS_INT, IDTVEC(spuriousint), SDT_APIC, SEL_KPL,
GSEL_APIC);
/* Perform basic initialization of the BSP's local APIC. */
lapic_enable();
/* Set BSP's per-CPU local APIC ID. */
PCPU_SET(apic_id, lapic_id());
/* Local APIC timer interrupt. */
setidt(APIC_TIMER_INT, IDTVEC(timerint), SDT_APIC, SEL_KPL, GSEL_APIC);
/* Local APIC error interrupt. */
setidt(APIC_ERROR_INT, IDTVEC(errorint), SDT_APIC, SEL_KPL, GSEL_APIC);
/* XXX: Thermal interrupt */
/* Local APIC CMCI. */
setidt(APIC_CMC_INT, IDTVEC(cmcint), SDT_APICT, SEL_KPL, GSEL_APIC);
if ((resource_int_value("apic", 0, "clock", &i) != 0 || i != 0)) {
arat = 0;
/* Intel CPUID 0x06 EAX[2] set if APIC timer runs in C3. */
if (cpu_vendor_id == CPU_VENDOR_INTEL && cpu_high >= 6) {
do_cpuid(0x06, regs);
if ((regs[0] & CPUTPM1_ARAT) != 0)
arat = 1;
}
bzero(&lapic_et, sizeof(lapic_et));
lapic_et.et_name = "LAPIC";
lapic_et.et_flags = ET_FLAGS_PERIODIC | ET_FLAGS_ONESHOT |
ET_FLAGS_PERCPU;
lapic_et.et_quality = 600;
if (!arat) {
lapic_et.et_flags |= ET_FLAGS_C3STOP;
lapic_et.et_quality -= 200;
}
lapic_et.et_frequency = 0;
/* We don't know frequency yet, so trying to guess. */
lapic_et.et_min_period.sec = 0;
lapic_et.et_min_period.frac = 0x00001000LL << 32;
lapic_et.et_max_period.sec = 1;
lapic_et.et_max_period.frac = 0;
lapic_et.et_start = lapic_et_start;
lapic_et.et_stop = lapic_et_stop;
lapic_et.et_priv = NULL;
et_register(&lapic_et);
}
}
static void
iicbus_hinted_child(device_t bus, const char *dname, int dunit)
{
device_t child;
int irq;
struct iicbus_ivar *devi;
child = BUS_ADD_CHILD(bus, 0, dname, dunit);
devi = IICBUS_IVAR(child);
resource_int_value(dname, dunit, "addr", &devi->addr);
if (resource_int_value(dname, dunit, "irq", &irq) == 0) {
if (bus_set_resource(child, SYS_RES_IRQ, 0, irq, 1) != 0)
device_printf(bus,
"warning: bus_set_resource() failed\n");
}
}
int
sc_get_cons_priority(int *unit, int *flags)
{
const char *at;
int f, u;
*unit = -1;
for (u = 0; u < 16; u++) {
if (resource_disabled(SC_DRIVER_NAME, u))
continue;
if (resource_string_value(SC_DRIVER_NAME, u, "at", &at) != 0)
continue;
if (resource_int_value(SC_DRIVER_NAME, u, "flags", &f) != 0)
f = 0;
if (f & SC_KERNEL_CONSOLE) {
/* the user designates this unit to be the console */
*unit = u;
*flags = f;
break;
}
if (*unit < 0) {
/* ...otherwise remember the first found unit */
*unit = u;
*flags = f;
}
}
if (*unit < 0) {
*unit = 0;
*flags = 0;
}
return (CN_INTERNAL);
}
int
ata_setup_interrupt(device_t dev, void *intr_func)
{
struct ata_pci_controller *ctlr = device_get_softc(dev);
int i, msi = 0;
if (!ctlr->legacy) {
if (resource_int_value(device_get_name(dev),
device_get_unit(dev), "msi", &i) == 0 && i != 0)
msi = 1;
if (msi && pci_msi_count(dev) > 0 && pci_alloc_msi(dev, &msi) == 0) {
ctlr->r_irq_rid = 0x1;
} else {
msi = 0;
ctlr->r_irq_rid = ATA_IRQ_RID;
}
if (!(ctlr->r_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ,
&ctlr->r_irq_rid, RF_SHAREABLE | RF_ACTIVE))) {
device_printf(dev, "unable to map interrupt\n");
if (msi)
pci_release_msi(dev);
return ENXIO;
}
if ((bus_setup_intr(dev, ctlr->r_irq, ATA_INTR_FLAGS, NULL,
intr_func, ctlr, &ctlr->handle))) {
device_printf(dev, "unable to setup interrupt\n");
bus_release_resource(dev,
SYS_RES_IRQ, ctlr->r_irq_rid, ctlr->r_irq);
if (msi)
pci_release_msi(dev);
return ENXIO;
}
}
return 0;
}
void
iicbus_init_frequency(device_t dev, u_int bus_freq)
{
struct iicbus_softc *sc = IICBUS_SOFTC(dev);
/*
* If a bus frequency value was passed in, use it. Otherwise initialize
* it first to the standard i2c 100KHz frequency, then override that
* from a hint if one exists.
*/
if (bus_freq > 0)
sc->bus_freq = bus_freq;
else {
sc->bus_freq = 100000;
resource_int_value(device_get_name(dev), device_get_unit(dev),
"frequency", (int *)&sc->bus_freq);
}
/*
* Set up the sysctl that allows the bus frequency to be changed.
* It is flagged as a tunable so that the user can set the value in
* loader(8), and that will override any other setting from any source.
* The sysctl tunable/value is the one most directly controlled by the
* user and thus the one that always takes precedence.
*/
SYSCTL_ADD_UINT(device_get_sysctl_ctx(dev),
SYSCTL_CHILDREN(device_get_sysctl_tree(dev)),
OID_AUTO, "frequency", CTLFLAG_RW | CTLFLAG_TUN, &sc->bus_freq,
sc->bus_freq, "Bus frequency in Hz");
}
static int
at91_usart_requires_rts0_workaround(struct uart_softc *sc)
{
int value;
int unit;
unit = device_get_unit(sc->sc_dev);
/*
* On the rm9200 chips, the PA21/RTS0 pin is not correctly wired to the
* usart device interally (so-called 'erratum 39', but it's 41.14 in rev
* I of the manual). This prevents use of the hardware flow control
* feature in the usart itself. It also means that if we are to
* implement RTS/CTS flow via the tty layer logic, we must use pin PA21
* as a gpio and manually manipulate it in at91_usart_bus_setsig(). We
* can only safely do so if we've been given permission via a hint,
* otherwise we might manipulate a pin that's attached to who-knows-what
* and Bad Things could happen.
*/
if (at91_is_rm92() && unit == 1) {
value = 0;
resource_int_value(device_get_name(sc->sc_dev), unit,
"use_rts0_workaround", &value);
if (value != 0) {
at91_pio_use_gpio(AT91RM92_PIOA_BASE, AT91C_PIO_PA21);
at91_pio_gpio_output(AT91RM92_PIOA_BASE,
AT91C_PIO_PA21, 1);
at91_pio_use_periph_a(AT91RM92_PIOA_BASE,
AT91C_PIO_PA20, 0);
return (1);
}
}
return (0);
}
static int
gpioled_attach(device_t dev)
{
struct gpioled_softc *sc;
int state;
const char *name;
sc = device_get_softc(dev);
sc->sc_dev = dev;
sc->sc_busdev = device_get_parent(dev);
GPIOLED_LOCK_INIT(sc);
state = 0;
if (resource_string_value(device_get_name(dev),
device_get_unit(dev), "name", &name))
name = NULL;
resource_int_value(device_get_name(dev),
device_get_unit(dev), "invert", &sc->sc_invert);
sc->sc_leddev = led_create_state(gpioled_control, sc, name ? name :
device_get_nameunit(dev), state);
return (0);
}
/*
* The back door to the keyboard driver!
* This function is called by the console driver, via the kbdio module,
* to tickle keyboard drivers when the low-level console is being initialized.
* Almost nothing in the kernel has been initialied yet. Try to probe
* keyboards if possible.
* NOTE: because of the way the low-level conole is initialized, this routine
* may be called more than once!!
*/
static int
pckbd_configure(int flags)
{
keyboard_t *kbd;
int arg[2];
int i;
/* XXX: a kludge to obtain the device configuration flags */
if (resource_int_value(DRIVER_NAME, 0, "flags", &i) == 0) {
flags |= i;
/* if the driver is disabled, unregister the keyboard if any */
if (resource_disabled(DRIVER_NAME, 0)) {
i = kbd_find_keyboard(DRIVER_NAME, PC98KBD_DEFAULT);
if (i >= 0) {
kbd = kbd_get_keyboard(i);
kbd_unregister(kbd);
kbd->kb_flags &= ~KB_REGISTERED;
return 0;
}
}
}
/* probe the default keyboard */
arg[0] = -1;
arg[1] = -1;
kbd = NULL;
if (pckbd_probe(PC98KBD_DEFAULT, arg, flags))
return 0;
if (pckbd_init(PC98KBD_DEFAULT, &kbd, arg, flags))
return 0;
/* return the number of found keyboards */
return 1;
}
static void
bvm_cnprobe(struct consdev *cp)
{
int disabled, port;
disabled = 0;
cp->cn_pri = CN_DEAD;
resource_int_value("bvmconsole", 0, "disabled", &disabled);
if (!disabled) {
if (resource_int_value("bvmconsole", 0, "port", &port) == 0)
bvm_cons_port = port;
if (inw(bvm_cons_port) == BVM_CONS_SIG)
cp->cn_pri = CN_REMOTE;
}
}
int
uart_cpu_getdev(int devtype, struct uart_devinfo *di)
{
uint32_t i, ivar, vaddr;
/*
* Scan the hints. The IXP425 only have 2 serial ports, so only
* scan them.
*/
for (i = 0; i < 2; i++) {
if (resource_int_value("uart", i, "flags", &ivar))
continue;
if (devtype == UART_DEV_CONSOLE && !UART_FLAGS_CONSOLE(ivar))
continue;
if (devtype == UART_DEV_DBGPORT && !UART_FLAGS_DBGPORT(ivar))
continue;
/*
* We have a possible device. Make sure it's enabled and
* that we have an I/O port.
*/
if (resource_int_value("uart", i, "disabled", &ivar) == 0 &&
ivar != 0)
continue;
if (resource_int_value("uart", i, "addr", &ivar) != 0 ||
ivar == 0)
continue;
/* Got it. Fill in the instance and return it. */
di->ops = uart_getops(&uart_ns8250_class);
di->bas.chan = 0;
di->bas.bst = &ixp425_a4x_bs_tag;
di->bas.regshft = 0;
di->bas.rclk = IXP425_UART_FREQ;
di->baudrate = 115200;
di->databits = 8;
di->stopbits = 1;
di->parity = UART_PARITY_NONE;
uart_bus_space_io = NULL;
uart_bus_space_mem = &ixp425_a4x_bs_tag;
getvbase(ivar, IXP425_REG_SIZE, &vaddr);
di->bas.bsh = vaddr;
return (0);
}
return (ENXIO);
}
static void
nvram2env_identify(driver_t * drv, device_t parent)
{
int i, ivar;
for (i = 0; !resource_int_value("nvram", i, "base", &ivar); i++)
BUS_ADD_CHILD(parent, 0, "nvram2env", i);
}
static int
gpioiic_attach(device_t dev)
{
device_t bitbang;
#ifdef FDT
phandle_t node;
pcell_t pin;
#endif
struct gpiobus_ivar *devi;
struct gpioiic_softc *sc;
sc = device_get_softc(dev);
sc->sc_dev = dev;
sc->sc_busdev = device_get_parent(dev);
if (resource_int_value(device_get_name(dev),
device_get_unit(dev), "scl", &sc->scl_pin))
sc->scl_pin = SCL_PIN_DEFAULT;
if (resource_int_value(device_get_name(dev),
device_get_unit(dev), "sda", &sc->sda_pin))
sc->sda_pin = SDA_PIN_DEFAULT;
#ifdef FDT
if ((node = ofw_bus_get_node(dev)) == -1)
return (ENXIO);
if (OF_getencprop(node, "scl", &pin, sizeof(pin)) > 0)
sc->scl_pin = (int)pin;
if (OF_getencprop(node, "sda", &pin, sizeof(pin)) > 0)
sc->sda_pin = (int)pin;
#endif
if (sc->scl_pin < 0 || sc->scl_pin > 1)
sc->scl_pin = SCL_PIN_DEFAULT;
if (sc->sda_pin < 0 || sc->sda_pin > 1)
sc->sda_pin = SDA_PIN_DEFAULT;
devi = GPIOBUS_IVAR(dev);
device_printf(dev, "SCL pin: %d, SDA pin: %d\n",
devi->pins[sc->scl_pin], devi->pins[sc->sda_pin]);
/* add generic bit-banging code */
bitbang = device_add_child(dev, "iicbb", -1);
device_probe_and_attach(bitbang);
return (0);
}
static void
obio_hinted_child(device_t bus, const char *dname, int dunit)
{
long maddr;
int msize;
int irq;
/*
* Set hard-wired resources for hinted child using
* specific RIDs.
*/
resource_long_value(dname, dunit, "maddr", &maddr);
resource_int_value(dname, dunit, "msize", &msize);
if (resource_int_value(dname, dunit, "irq", &irq) == 0) irq = -1;
obio_add_res_child(bus, dname, dunit, maddr, msize, irq);
}
/*
* Fetch the LED configuration from the boot hints.
*/
static int
ar8327_fetch_pdata_led(struct arswitch_softc *sc,
struct ar8327_led_cfg *lcfg)
{
int val;
val = 0;
if (resource_int_value(device_get_name(sc->sc_dev),
device_get_unit(sc->sc_dev),
"led.ctrl0", &val) != 0)
return (0);
lcfg->led_ctrl0 = val;
val = 0;
if (resource_int_value(device_get_name(sc->sc_dev),
device_get_unit(sc->sc_dev),
"led.ctrl1", &val) != 0)
return (0);
lcfg->led_ctrl1 = val;
val = 0;
if (resource_int_value(device_get_name(sc->sc_dev),
device_get_unit(sc->sc_dev),
"led.ctrl2", &val) != 0)
return (0);
lcfg->led_ctrl2 = val;
val = 0;
if (resource_int_value(device_get_name(sc->sc_dev),
device_get_unit(sc->sc_dev),
"led.ctrl3", &val) != 0)
return (0);
lcfg->led_ctrl3 = val;
val = 0;
if (resource_int_value(device_get_name(sc->sc_dev),
device_get_unit(sc->sc_dev),
"led.open_drain", &val) != 0)
return (0);
lcfg->open_drain = val;
return (1);
}
static void
iicbus_hinted_child(device_t bus, const char *dname, int dunit)
{
device_t child;
struct iicbus_ivar *devi;
child = BUS_ADD_CHILD(bus, 0, dname, dunit);
devi = IICBUS_IVAR(child);
resource_int_value(dname, dunit, "addr", &devi->addr);
}
static void
gpiobus_hinted_child(device_t bus, const char *dname, int dunit)
{
struct gpiobus_softc *sc = GPIOBUS_SOFTC(bus);
struct gpiobus_ivar *devi;
device_t child;
int irq, pins;
child = BUS_ADD_CHILD(bus, 0, dname, dunit);
devi = GPIOBUS_IVAR(child);
resource_int_value(dname, dunit, "pins", &pins);
if (gpiobus_parse_pins(sc, child, pins))
device_delete_child(bus, child);
if (resource_int_value(dname, dunit, "irq", &irq) == 0) {
if (bus_set_resource(child, SYS_RES_IRQ, 0, irq, 1) != 0)
device_printf(bus,
"warning: bus_set_resource() failed\n");
}
}
/*
* Check to see if a device is disabled via a disabled hint.
*/
int
resource_disabled(const char *name, int unit)
{
int error, value;
error = resource_int_value(name, unit, "disabled", &value);
if (error)
return (0);
return (value);
}
static void
pxa_smi_add_device(device_t dev, const char *name, int unit)
{
device_t child;
int start, count;
struct smi_ivars *ivars;
ivars = (struct smi_ivars *)malloc(
sizeof(struct smi_ivars), M_PXASMI, M_WAITOK);
if (ivars == NULL)
return;
child = device_add_child(dev, name, unit);
if (child == NULL) {
free(ivars, M_PXASMI);
return;
}
device_set_ivars(child, ivars);
resource_list_init(&ivars->smid_resources);
start = 0;
count = 0;
resource_int_value(name, unit, "mem", &start);
resource_int_value(name, unit, "size", &count);
if (start > 0 || count > 0) {
resource_list_add(&ivars->smid_resources, SYS_RES_MEMORY, 0,
start, start + count, count);
ivars->smid_mem = (bus_addr_t)start;
}
start = -1;
count = 0;
resource_int_value(name, unit, "irq", &start);
if (start > -1)
resource_list_add(&ivars->smid_resources, SYS_RES_IRQ, 0, start,
start, 1);
if (resource_disabled(name, unit))
device_disable(child);
}
static void
apb_hinted_child(device_t bus, const char *dname, int dunit)
{
device_t child;
long maddr;
int msize;
int irq;
int result;
int mem_hints_count;
child = BUS_ADD_CHILD(bus, 0, dname, dunit);
/*
* Set hard-wired resources for hinted child using
* specific RIDs.
*/
mem_hints_count = 0;
if (resource_long_value(dname, dunit, "maddr", &maddr) == 0)
mem_hints_count++;
if (resource_int_value(dname, dunit, "msize", &msize) == 0)
mem_hints_count++;
/* check if all info for mem resource has been provided */
if ((mem_hints_count > 0) && (mem_hints_count < 2)) {
printf("Either maddr or msize hint is missing for %s%d\n",
dname, dunit);
} else if (mem_hints_count) {
result = bus_set_resource(child, SYS_RES_MEMORY, 0,
maddr, msize);
if (result != 0)
device_printf(bus,
"warning: bus_set_resource() failed\n");
}
if (resource_int_value(dname, dunit, "irq", &irq) == 0) {
result = bus_set_resource(child, SYS_RES_IRQ, 0, irq, 1);
if (result != 0)
device_printf(bus,
"warning: bus_set_resource() failed\n");
}
}
/*
* The back door to the keyboard driver!
* This function is called by the console driver, via the kbdio module,
* to tickle keyboard drivers when the low-level console is being initialized.
* Almost nothing in the kernel has been initialied yet. Try to probe
* keyboards if possible.
* NOTE: because of the way the low-level console is initialized, this routine
* may be called more than once!!
*/
static int
atkbd_configure(int flags)
{
keyboard_t *kbd;
int arg[2];
int i;
/* probe the keyboard controller */
atkbdc_configure();
/* if the driver is disabled, unregister the keyboard if any */
if ((resource_int_value("atkbd", ATKBD_DEFAULT, "disabled", &i) == 0)
&& i != 0) {
i = kbd_find_keyboard(ATKBD_DRIVER_NAME, ATKBD_DEFAULT);
if (i >= 0) {
kbd = kbd_get_keyboard(i);
kbd_unregister(kbd);
kbd->kb_flags &= ~KB_REGISTERED;
}
return 0;
}
/* XXX: a kludge to obtain the device configuration flags */
if (resource_int_value("atkbd", ATKBD_DEFAULT, "flags", &i) == 0)
flags |= i;
/* probe the default keyboard */
arg[0] = -1;
arg[1] = -1;
kbd = NULL;
if (atkbd_probe(ATKBD_DEFAULT, arg, flags))
return 0;
if (atkbd_init(ATKBD_DEFAULT, &kbd, arg, flags))
return 0;
/* return the number of found keyboards */
return 1;
}
int
at91_usart_bus_probe(struct uart_softc *sc)
{
int value;
value = USART_DEFAULT_FIFO_BYTES;
resource_int_value(device_get_name(sc->sc_dev),
device_get_unit(sc->sc_dev), "fifo_bytes", &value);
value = roundup2(value, arm_dcache_align);
sc->sc_txfifosz = value;
sc->sc_rxfifosz = value;
sc->sc_hwiflow = 0;
return (0);
}