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; } } }