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);
}
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);
}
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);
}
/*
* Iterate through the list of boot time hints that populate
* a device MAC address hint based on the "board" MAC address.
*
* ar71xx_mac_map.X.devid=<device id, eg ath>
* ar71xx_mac_map.X.unitid=<unit id, eg 0>
* ar71xx_mac_map.X.offset=<mac address value offset>
* ar71xx_mac_map.X.is_local=<1 or 0>
*/
static int
ar71xx_platform_check_mac_hints(void)
{
int i;
const char *devid;
int offset, is_local, unitid;
for (i = 0; i < 8; i++) {
if (resource_string_value("ar71xx_mac_map", i, "devid",
&devid) != 0)
break;
if (resource_int_value("ar71xx_mac_map", i, "unitid",
&unitid) != 0)
break;
if (resource_int_value("ar71xx_mac_map", i, "offset",
&offset) != 0)
break;
if (resource_int_value("ar71xx_mac_map", i, "is_local",
&is_local) != 0)
break;
printf("ar71xx: devid '%s.%d', MAC offset '%d'\n",
devid, unitid, offset);
(void) ar71xx_platform_set_mac_hint(devid, unitid,
ar71xx_board_mac_addr, offset, is_local);
}
return (0);
}
void
terasic_de4led_attach(struct terasic_de4led_softc *sc)
{
const char *cmd;
TERASIC_DE4LED_LOCK_INIT(sc);
/*
* Clear the LED array before we start.
*/
TERASIC_DE4LED_LOCK(sc);
TERASIC_DE4LED_CLEARBAR(sc);
terasic_de4led_update(sc);
TERASIC_DE4LED_UNLOCK(sc);
/*
* Register the LED array with led(4).
*/
sc->tdl_leds[0] = led_create(led_0, sc, "de4led_0");
sc->tdl_leds[1] = led_create(led_1, sc, "de4led_1");
sc->tdl_leds[2] = led_create(led_2, sc, "de4led_2");
sc->tdl_leds[3] = led_create(led_3, sc, "de4led_3");
sc->tdl_leds[4] = led_create(led_4, sc, "de4led_4");
sc->tdl_leds[5] = led_create(led_5, sc, "de4led_5");
sc->tdl_leds[6] = led_create(led_6, sc, "de4led_6");
sc->tdl_leds[7] = led_create(led_7, sc, "de4led_7");
if (resource_string_value(device_get_name(sc->tdl_dev),
sc->tdl_unit, "de4led_0_cmd", &cmd) == 0)
led_set("de4led_0", cmd);
if (resource_string_value(device_get_name(sc->tdl_dev),
sc->tdl_unit, "de4led_1_cmd", &cmd) == 0)
led_set("de4led_1", cmd);
if (resource_string_value(device_get_name(sc->tdl_dev),
sc->tdl_unit, "de4led_2_cmd", &cmd) == 0)
led_set("de4led_2", cmd);
if (resource_string_value(device_get_name(sc->tdl_dev),
sc->tdl_unit, "de4led_3_cmd", &cmd) == 0)
led_set("de4led_3", cmd);
if (resource_string_value(device_get_name(sc->tdl_dev),
sc->tdl_unit, "de4led_4_cmd", &cmd) == 0)
led_set("de4led_4", cmd);
if (resource_string_value(device_get_name(sc->tdl_dev),
sc->tdl_unit, "de4led_5_cmd", &cmd) == 0)
led_set("de4led_5", cmd);
if (resource_string_value(device_get_name(sc->tdl_dev),
sc->tdl_unit, "de4led_6_cmd", &cmd) == 0)
led_set("de4led_6", cmd);
if (resource_string_value(device_get_name(sc->tdl_dev),
sc->tdl_unit, "de4led_7_cmd", &cmd) == 0)
led_set("de4led_7", cmd);
}
int
sc_get_cons_priority(int *unit, int *flags)
{
const char *at;
int f, u;
#ifdef XBOX
/*
* The XBox Loader does not support hints, which makes our initial
* console probe fail. Therefore, if an XBox is found, we hardcode the
* existence of the console, as it is always there anyway.
*/
if (arch_i386_is_xbox) {
*unit = 0;
*flags = SC_KERNEL_CONSOLE;
return (CN_INTERNAL);
}
#endif
*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;
}
#if 0
return ((*flags & SC_KERNEL_CONSOLE) != 0 ? CN_INTERNAL : CN_NORMAL);
#endif
return (CN_INTERNAL);
}
/*
* Attach btcoex to the given interface
*/
int
ath_btcoex_attach(struct ath_softc *sc)
{
int ret;
struct ath_hal *ah = sc->sc_ah;
const char *profname;
/*
* No chipset bluetooth coexistence? Then do nothing.
*/
if (! ath_hal_btcoex_supported(ah))
return (0);
/*
* Look at the hints to determine which bluetooth
* profile to configure.
*/
ret = resource_string_value(device_get_name(sc->sc_dev),
device_get_unit(sc->sc_dev),
"btcoex_profile",
&profname);
if (ret != 0) {
/* nothing to do */
return (0);
}
if (strncmp(profname, "wb195", 5) == 0) {
ret = ath_btcoex_cfg_wb195(sc);
} else if (strncmp(profname, "wb222", 5) == 0) {
ret = ath_btcoex_cfg_wb222(sc);
} else if (strncmp(profname, "wb225", 5) == 0) {
ret = ath_btcoex_cfg_wb225(sc);
} else {
return (0);
}
/*
* Propagate up failure from the actual attach phase.
*/
if (ret != 0)
return (ret);
return (0);
}
static int
gpioled_attach(device_t dev)
{
struct gpioled_softc *sc;
#ifdef FDT
phandle_t node;
char *name;
#else
const char *name;
#endif
sc = device_get_softc(dev);
sc->sc_dev = dev;
sc->sc_busdev = device_get_parent(dev);
GPIOLED_LOCK_INIT(sc);
#ifdef FDT
name = NULL;
if ((node = ofw_bus_get_node(dev)) == -1)
return (ENXIO);
if (OF_getprop_alloc(node, "label", 1, (void **)&name) == -1)
OF_getprop_alloc(node, "name", 1, (void **)&name);
#else
if (resource_string_value(device_get_name(dev),
device_get_unit(dev), "name", &name))
name = NULL;
#endif
sc->sc_leddev = led_create(gpioled_control, sc, name ? name :
device_get_nameunit(dev));
#ifdef FDT
if (name != NULL)
free(name, M_OFWPROP);
#endif
return (0);
}
int
ata_attach(device_t dev)
{
struct ata_channel *ch = device_get_softc(dev);
int error, rid;
struct cam_devq *devq;
const char *res;
char buf[64];
int i, mode;
/* check that we have a virgin channel to attach */
if (ch->r_irq)
return EEXIST;
/* initialize the softc basics */
ch->dev = dev;
ch->state = ATA_IDLE;
bzero(&ch->state_mtx, sizeof(struct mtx));
mtx_init(&ch->state_mtx, "ATA state lock", NULL, MTX_DEF);
TASK_INIT(&ch->conntask, 0, ata_conn_event, dev);
for (i = 0; i < 16; i++) {
ch->user[i].revision = 0;
snprintf(buf, sizeof(buf), "dev%d.sata_rev", i);
if (resource_int_value(device_get_name(dev),
device_get_unit(dev), buf, &mode) != 0 &&
resource_int_value(device_get_name(dev),
device_get_unit(dev), "sata_rev", &mode) != 0)
mode = -1;
if (mode >= 0)
ch->user[i].revision = mode;
ch->user[i].mode = 0;
snprintf(buf, sizeof(buf), "dev%d.mode", i);
if (resource_string_value(device_get_name(dev),
device_get_unit(dev), buf, &res) == 0)
mode = ata_str2mode(res);
else if (resource_string_value(device_get_name(dev),
device_get_unit(dev), "mode", &res) == 0)
mode = ata_str2mode(res);
else
mode = -1;
if (mode >= 0)
ch->user[i].mode = mode;
if (ch->flags & ATA_SATA)
ch->user[i].bytecount = 8192;
else
ch->user[i].bytecount = MAXPHYS;
ch->user[i].caps = 0;
ch->curr[i] = ch->user[i];
if (ch->flags & ATA_SATA) {
if (ch->pm_level > 0)
ch->user[i].caps |= CTS_SATA_CAPS_H_PMREQ;
if (ch->pm_level > 1)
ch->user[i].caps |= CTS_SATA_CAPS_D_PMREQ;
} else {
if (!(ch->flags & ATA_NO_48BIT_DMA))
ch->user[i].caps |= CTS_ATA_CAPS_H_DMA48;
}
}
callout_init(&ch->poll_callout, 1);
/* allocate DMA resources if DMA HW present*/
if (ch->dma.alloc)
ch->dma.alloc(dev);
/* setup interrupt delivery */
rid = ATA_IRQ_RID;
ch->r_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
RF_SHAREABLE | RF_ACTIVE);
if (!ch->r_irq) {
device_printf(dev, "unable to allocate interrupt\n");
return ENXIO;
}
if ((error = bus_setup_intr(dev, ch->r_irq, ATA_INTR_FLAGS, NULL,
ata_interrupt, ch, &ch->ih))) {
bus_release_resource(dev, SYS_RES_IRQ, rid, ch->r_irq);
device_printf(dev, "unable to setup interrupt\n");
return error;
}
if (ch->flags & ATA_PERIODIC_POLL)
callout_reset(&ch->poll_callout, hz, ata_periodic_poll, ch);
mtx_lock(&ch->state_mtx);
/* Create the device queue for our SIM. */
devq = cam_simq_alloc(1);
if (devq == NULL) {
device_printf(dev, "Unable to allocate simq\n");
error = ENOMEM;
goto err1;
}
/* Construct SIM entry */
ch->sim = cam_sim_alloc(ataaction, atapoll, "ata", ch,
device_get_unit(dev), &ch->state_mtx, 1, 0, devq);
if (ch->sim == NULL) {
device_printf(dev, "unable to allocate sim\n");
cam_simq_free(devq);
error = ENOMEM;
goto err1;
}
if (xpt_bus_register(ch->sim, dev, 0) != CAM_SUCCESS) {
device_printf(dev, "unable to register xpt bus\n");
error = ENXIO;
goto err2;
}
if (xpt_create_path(&ch->path, /*periph*/NULL, cam_sim_path(ch->sim),
CAM_TARGET_WILDCARD, CAM_LUN_WILDCARD) != CAM_REQ_CMP) {
device_printf(dev, "unable to create path\n");
error = ENXIO;
goto err3;
}
mtx_unlock(&ch->state_mtx);
return (0);
err3:
xpt_bus_deregister(cam_sim_path(ch->sim));
err2:
cam_sim_free(ch->sim, /*free_devq*/TRUE);
ch->sim = NULL;
err1:
bus_release_resource(dev, SYS_RES_IRQ, rid, ch->r_irq);
mtx_unlock(&ch->state_mtx);
if (ch->flags & ATA_PERIODIC_POLL)
callout_drain(&ch->poll_callout);
return (error);
}
static int
ath_pci_attach(device_t dev)
{
struct ath_pci_softc *psc = device_get_softc(dev);
struct ath_softc *sc = &psc->sc_sc;
int error = ENXIO;
int rid;
#ifdef ATH_EEPROM_FIRMWARE
const struct firmware *fw = NULL;
const char *buf;
#endif
const struct pci_device_id *pd;
sc->sc_dev = dev;
/* Do this lookup anyway; figure out what to do with it later */
pd = ath_pci_probe_device(dev, ath_pci_id_table, nitems(ath_pci_id_table));
if (pd)
sc->sc_pci_devinfo = pd->driver_data;
/*
* Enable bus mastering.
*/
pci_enable_busmaster(dev);
/*
* Setup other PCI bus configuration parameters.
*/
ath_pci_setup(dev);
/*
* Setup memory-mapping of PCI registers.
*/
rid = BS_BAR;
psc->sc_sr = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid,
RF_ACTIVE);
if (psc->sc_sr == NULL) {
device_printf(dev, "cannot map register space\n");
goto bad;
}
sc->sc_st = (HAL_BUS_TAG) rman_get_bustag(psc->sc_sr);
sc->sc_sh = (HAL_BUS_HANDLE) rman_get_bushandle(psc->sc_sr);
/*
* Mark device invalid so any interrupts (shared or otherwise)
* that arrive before the HAL is setup are discarded.
*/
sc->sc_invalid = 1;
ATH_LOCK_INIT(sc);
ATH_PCU_LOCK_INIT(sc);
ATH_RX_LOCK_INIT(sc);
ATH_TX_LOCK_INIT(sc);
ATH_TXSTATUS_LOCK_INIT(sc);
/*
* Arrange interrupt line.
*/
rid = 0;
psc->sc_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
RF_SHAREABLE|RF_ACTIVE);
if (psc->sc_irq == NULL) {
device_printf(dev, "could not map interrupt\n");
goto bad1;
}
if (bus_setup_intr(dev, psc->sc_irq,
INTR_TYPE_NET | INTR_MPSAFE,
NULL, ath_intr, sc, &psc->sc_ih)) {
device_printf(dev, "could not establish interrupt\n");
goto bad2;
}
/*
* Setup DMA descriptor area.
*/
if (bus_dma_tag_create(bus_get_dma_tag(dev), /* parent */
1, 0, /* alignment, bounds */
BUS_SPACE_MAXADDR_32BIT, /* lowaddr */
BUS_SPACE_MAXADDR, /* highaddr */
NULL, NULL, /* filter, filterarg */
0x3ffff, /* maxsize XXX */
ATH_MAX_SCATTER, /* nsegments */
0x3ffff, /* maxsegsize XXX */
BUS_DMA_ALLOCNOW, /* flags */
NULL, /* lockfunc */
NULL, /* lockarg */
&sc->sc_dmat)) {
device_printf(dev, "cannot allocate DMA tag\n");
goto bad3;
}
#ifdef ATH_EEPROM_FIRMWARE
/*
* If there's an EEPROM firmware image, load that in.
*/
if (resource_string_value(device_get_name(dev), device_get_unit(dev),
"eeprom_firmware", &buf) == 0) {
if (bootverbose)
device_printf(dev, "%s: looking up firmware @ '%s'\n",
__func__, buf);
fw = firmware_get(buf);
if (fw == NULL) {
device_printf(dev, "%s: couldn't find firmware\n",
__func__);
goto bad4;
}
device_printf(dev, "%s: EEPROM firmware @ %p\n",
__func__, fw->data);
sc->sc_eepromdata =
malloc(fw->datasize, M_TEMP, M_WAITOK | M_ZERO);
if (! sc->sc_eepromdata) {
device_printf(dev, "%s: can't malloc eepromdata\n",
__func__);
goto bad4;
}
memcpy(sc->sc_eepromdata, fw->data, fw->datasize);
firmware_put(fw, 0);
}
#endif /* ATH_EEPROM_FIRMWARE */
error = ath_attach(pci_get_device(dev), sc);
if (error == 0) /* success */
return 0;
#ifdef ATH_EEPROM_FIRMWARE
bad4:
#endif
bus_dma_tag_destroy(sc->sc_dmat);
bad3:
bus_teardown_intr(dev, psc->sc_irq, psc->sc_ih);
bad2:
bus_release_resource(dev, SYS_RES_IRQ, 0, psc->sc_irq);
bad1:
bus_release_resource(dev, SYS_RES_MEMORY, BS_BAR, psc->sc_sr);
ATH_TXSTATUS_LOCK_DESTROY(sc);
ATH_PCU_LOCK_DESTROY(sc);
ATH_RX_LOCK_DESTROY(sc);
ATH_TX_LOCK_DESTROY(sc);
ATH_LOCK_DESTROY(sc);
bad:
return (error);
}
void
isa_hint_device_unit(device_t bus, device_t child, const char *name, int *unitp)
{
const char *s;
long value;
int line, matches, unit;
line = 0;
for (;;) {
if (resource_find_dev(&line, name, &unit, "at", NULL) != 0)
break;
/* Must have an "at" for isa. */
resource_string_value(name, unit, "at", &s);
if (!(strcmp(s, device_get_nameunit(bus)) == 0 ||
strcmp(s, device_get_name(bus)) == 0))
continue;
/*
* Check for matching resources. We must have at
* least one match. Since I/O and memory resources
* cannot be shared, if we get a match on either of
* those, ignore any mismatches in IRQs or DRQs.
*
* XXX: We may want to revisit this to be more lenient
* and wire as long as it gets one match.
*/
matches = 0;
if (resource_long_value(name, unit, "port", &value) == 0) {
/*
* Floppy drive controllers are notorious for
* having a wide variety of resources not all
* of which include the first port that is
* specified by the hint (typically 0x3f0)
* (see the comment above
* fdc_isa_alloc_resources() in fdc_isa.c).
* However, they do all seem to include port +
* 2 (e.g. 0x3f2) so for a floppy device, look
* for 'value + 2' in the port resources
* instead of the hint value.
*/
if (strcmp(name, "fdc") == 0)
value += 2;
if (isa_match_resource_hint(child, SYS_RES_IOPORT,
value))
matches++;
else
continue;
}
if (resource_long_value(name, unit, "maddr", &value) == 0) {
if (isa_match_resource_hint(child, SYS_RES_MEMORY,
value))
matches++;
else
continue;
}
if (matches > 0)
goto matched;
if (resource_long_value(name, unit, "irq", &value) == 0) {
if (isa_match_resource_hint(child, SYS_RES_IRQ, value))
matches++;
else
continue;
}
if (resource_long_value(name, unit, "drq", &value) == 0) {
if (isa_match_resource_hint(child, SYS_RES_DRQ, value))
matches++;
else
continue;
}
matched:
if (matches > 0) {
/* We have a winner! */
*unitp = unit;
break;
}
}
}
