void
uberry_attach(device_t parent, device_t self, void *aux)
{
struct uberry_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
usbd_device_handle dev = uaa->device;
char *devinfop;
DPRINTFN(10,("uberry_attach: sc=%p\n", sc));
sc->sc_dev = self;
sc->sc_udev = dev;
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(dev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
uberry_charge(sc);
if (uaa->product == USB_PRODUCT_RIM_BLACKBERRY_PEARL)
uberry_dual_mode(sc);
DPRINTFN(10, ("uberry_attach: %p\n", sc->sc_udev));
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
return;
}
static void
md_attach(device_t parent, device_t self,
void *aux)
{
struct md_softc *sc = device_private(self);
bufq_alloc(&sc->sc_buflist, "fcfs", 0);
/* XXX - Could accept aux info here to set the config. */
#ifdef MEMORY_DISK_HOOKS
/*
* This external function might setup a pre-loaded disk.
* All it would need to do is setup the md_conf struct.
* See sys/dev/md_root.c for an example.
*/
md_attach_hook(device_unit(self), &sc->sc_md);
#endif
/*
* Initialize and attach the disk structure.
*/
disk_init(&sc->sc_dkdev, device_xname(self), &mddkdriver);
disk_attach(&sc->sc_dkdev);
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
}
void
uipad_attach(device_t parent, device_t self, void *aux)
{
struct uipad_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
struct usbd_device * dev = uaa->uaa_device;
char *devinfop;
DPRINTFN(10,("uipad_attach: sc=%p\n", sc));
sc->sc_dev = self;
sc->sc_udev = dev;
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(dev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
uipad_charge(sc);
DPRINTFN(10, ("uipad_attach: %p\n", sc->sc_udev));
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
return;
}
static void
fujitsu_hk_attach(device_t parent, device_t self, void *aux)
{
struct fujitsu_hk_softc *sc = device_private(self);
struct acpi_attach_args *aa = aux;
struct acpi_devnode *ad = aa->aa_node;
int i;
aprint_naive(": Fujitsu Hotkeys\n");
aprint_normal(": Fujitsu Hotkeys\n");
sc->sc_dev = self;
sc->sc_node = ad;
sc->sc_log = NULL;
sc->sc_caps = fujitsu_hk_capabilities(ad);
mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_NONE);
for (i = 0; i < FUJITSU_HK_PSW_COUNT; i++) {
(void)snprintf(sc->sc_smpsw_name[i],
sizeof(sc->sc_smpsw_name[i]), "%s-%d",
device_xname(self), i);
sc->sc_smpsw[i].smpsw_name = sc->sc_smpsw_name[i];
sc->sc_smpsw[i].smpsw_type = PSWITCH_TYPE_HOTKEY;
(void)sysmon_pswitch_register(&sc->sc_smpsw[i]);
}
fujitsu_hk_sysctl_setup(sc);
(void)pmf_device_register(self, fujitsu_hk_suspend, fujitsu_hk_resume);
(void)acpi_register_notify(sc->sc_node, fujitsu_hk_notify_handler);
}
static void
wzero3ssp_attach(device_t parent, device_t self, void *aux)
{
struct wzero3ssp_softc *sc = device_private(self);
sc->sc_dev = self;
wzero3ssp_sc = sc;
aprint_normal("\n");
aprint_naive("\n");
sc->sc_model = wzero3ssp_lookup();
if (sc->sc_model == NULL) {
aprint_error_dev(self, "unknown model\n");
return;
}
mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_TTY);
sc->sc_iot = &pxa2x0_bs_tag;
if (bus_space_map(sc->sc_iot, sc->sc_model->sspaddr, PXA2X0_SSP_SIZE, 0,
&sc->sc_ioh)) {
aprint_error_dev(sc->sc_dev, "can't map bus space\n");
return;
}
if (!pmf_device_register(sc->sc_dev, NULL, wzero3ssp_resume))
aprint_error_dev(sc->sc_dev,
"couldn't establish power handler\n");
wzero3ssp_init(sc);
}
static void
nsphyattach(device_t parent, device_t self, void *aux)
{
struct mii_softc *sc = device_private(self);
struct mii_attach_args *ma = aux;
struct mii_data *mii = ma->mii_data;
const struct mii_phydesc *mpd;
mpd = mii_phy_match(ma, nsphys);
aprint_naive(": Media interface\n");
aprint_normal(": %s, rev. %d\n", mpd->mpd_name, MII_REV(ma->mii_id2));
sc->mii_dev = self;
sc->mii_inst = mii->mii_instance;
sc->mii_phy = ma->mii_phyno;
sc->mii_funcs = &nsphy_funcs;
sc->mii_pdata = mii;
sc->mii_flags = ma->mii_flags;
sc->mii_anegticks = MII_ANEGTICKS;
PHY_RESET(sc);
sc->mii_capabilities =
PHY_READ(sc, MII_BMSR) & ma->mii_capmask;
aprint_normal_dev(self, "");
if ((sc->mii_capabilities & BMSR_MEDIAMASK) == 0)
aprint_error("no media present");
else
mii_phy_add_media(sc);
aprint_normal("\n");
if (!pmf_device_register(self, NULL, mii_phy_resume))
aprint_error_dev(self, "couldn't establish power handler\n");
}
void
fdcattach(struct fdc_softc *fdc)
{
mutex_init(&fdc->sc_mtx, MUTEX_DEFAULT, IPL_BIO);
cv_init(&fdc->sc_cv, "fdcwakeup");
callout_init(&fdc->sc_timo_ch, 0);
callout_init(&fdc->sc_intr_ch, 0);
fdc->sc_state = DEVIDLE;
TAILQ_INIT(&fdc->sc_drives);
fdc->sc_maxiosize = isa_dmamaxsize(fdc->sc_ic, fdc->sc_drq);
if (isa_drq_alloc(fdc->sc_ic, fdc->sc_drq) != 0) {
aprint_normal_dev(fdc->sc_dev, "can't reserve drq %d\n",
fdc->sc_drq);
return;
}
if (isa_dmamap_create(fdc->sc_ic, fdc->sc_drq, fdc->sc_maxiosize,
BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW)) {
aprint_normal_dev(fdc->sc_dev, "can't set up ISA DMA map\n");
return;
}
config_interrupts(fdc->sc_dev, fdcfinishattach);
if (!pmf_device_register(fdc->sc_dev, fdcsuspend, fdcresume)) {
aprint_error_dev(fdc->sc_dev,
"cannot set power mgmt handler\n");
}
}
void
pwdog_attach(device_t parent, device_t self, void *aux)
{
struct pwdog_softc *sc = device_private(self);
struct pci_attach_args *const pa = (struct pci_attach_args *)aux;
pcireg_t memtype;
memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_MAPREG_START);
if (pci_mapreg_map(pa, PCI_MAPREG_START, memtype, 0, &sc->sc_iot,
&sc->sc_ioh, NULL, &sc->sc_iosize)) {
aprint_error("\n");
aprint_error_dev(self, "PCI %s region not found\n",
memtype == PCI_MAPREG_TYPE_IO ? "I/O" : "memory");
return;
}
printf("\n");
sc->sc_dev = self;
pmf_device_register(self, pwdog_suspend, pwdog_resume);
bus_space_write_1(sc->sc_iot, sc->sc_ioh, PWDOG_DISABLE, 0);
sc->sc_smw.smw_name = device_xname(self);
sc->sc_smw.smw_cookie = sc;
sc->sc_smw.smw_setmode = pwdog_setmode;
sc->sc_smw.smw_tickle = pwdog_tickle;
sc->sc_smw.smw_period = PWDOG_MAX_PERIOD;
if (sysmon_wdog_register(&sc->sc_smw))
aprint_error_dev(self, "couldn't register with sysmon\n");
else
sc->sc_smw_valid = true;
}
/*
* atabus_attach:
*
* Autoconfiguration attach routine.
*/
static void
atabus_attach(device_t parent, device_t self, void *aux)
{
struct atabus_softc *sc = device_private(self);
struct ata_channel *chp = aux;
struct atabus_initq *initq;
int error;
sc->sc_chan = chp;
aprint_normal("\n");
aprint_naive("\n");
sc->sc_dev = self;
if (ata_addref(chp))
return;
RUN_ONCE(&ata_init_ctrl, atabus_init);
initq = malloc(sizeof(*initq), M_DEVBUF, M_WAITOK);
initq->atabus_sc = sc;
TAILQ_INSERT_TAIL(&atabus_initq_head, initq, atabus_initq);
config_pending_incr(sc->sc_dev);
if ((error = kthread_create(PRI_NONE, 0, NULL, atabus_thread, sc,
&chp->ch_thread, "%s", device_xname(self))) != 0)
aprint_error_dev(self,
"unable to create kernel thread: error %d\n", error);
if (!pmf_device_register(self, atabus_suspend, atabus_resume))
aprint_error_dev(self, "couldn't establish power handler\n");
}
static void
asus_attach(device_t parent, device_t self, void *opaque)
{
asus_softc_t *sc = device_private(self);
struct acpi_attach_args *aa = opaque;
ACPI_STATUS rv;
sc->sc_node = aa->aa_node;
sc->sc_dev = self;
aprint_naive("\n");
aprint_normal("\n");
asus_init(self);
sc->sc_smpsw_valid = true;
sc->sc_smpsw[ASUS_PSW_DISPLAY_CYCLE].smpsw_name =
PSWITCH_HK_DISPLAY_CYCLE;
sc->sc_smpsw[ASUS_PSW_DISPLAY_CYCLE].smpsw_type =
PSWITCH_TYPE_HOTKEY;
if (sysmon_pswitch_register(&sc->sc_smpsw[ASUS_PSW_DISPLAY_CYCLE])) {
aprint_error_dev(self, "couldn't register with sysmon\n");
sc->sc_smpsw_valid = false;
}
rv = AcpiInstallNotifyHandler(sc->sc_node->ad_handle, ACPI_ALL_NOTIFY,
asus_notify_handler, sc);
if (ACPI_FAILURE(rv))
aprint_error_dev(self, "couldn't install notify handler: %s\n",
AcpiFormatException(rv));
if (!pmf_device_register(self, asus_suspend, asus_resume))
aprint_error_dev(self, "couldn't establish power handler\n");
}
void
pcppi_attach(struct pcppi_softc *sc)
{
struct pcppi_attach_args pa;
device_t self = sc->sc_dv;
callout_init(&sc->sc_bell_ch, CALLOUT_MPSAFE);
callout_setfunc(&sc->sc_bell_ch, pcppi_bell_callout, sc);
cv_init(&sc->sc_slp, "bell");
sc->sc_bellactive = sc->sc_bellpitch = 0;
#if NPCKBD > 0
/* Provide a beeper for the PC Keyboard, if there isn't one already. */
pckbd_hookup_bell(pcppi_pckbd_bell, sc);
#endif
#if NATTIMER > 0
config_defer(sc->sc_dv, pcppi_attach_speaker);
#endif
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
pa.pa_cookie = sc;
config_search_loc(pcppisearch, sc->sc_dv, "pcppi", NULL, &pa);
}
static void
btkbd_attach(device_t parent, device_t self, void *aux)
{
struct btkbd_softc *sc = device_private(self);
struct bthidev_attach_args *ba = aux;
struct wskbddev_attach_args wska;
const char *parserr;
sc->sc_output = ba->ba_output;
ba->ba_input = btkbd_input;
parserr = btkbd_parse_desc(sc, ba->ba_id, ba->ba_desc, ba->ba_dlen);
if (parserr != NULL) {
aprint_error("%s\n", parserr);
return;
}
aprint_normal("\n");
#ifdef WSDISPLAY_COMPAT_RAWKBD
#ifdef BTKBD_REPEAT
callout_init(&sc->sc_repeat, 0);
callout_setfunc(&sc->sc_repeat, btkbd_repeat, sc);
#endif
#endif
wska.console = 0;
wska.keymap = &btkbd_keymapdata;
wska.accessops = &btkbd_accessops;
wska.accesscookie = sc;
sc->sc_wskbd = config_found(self, &wska, wskbddevprint);
pmf_device_register(self, NULL, NULL);
}
void
btnmgrattach(device_t parent,
device_t self, void *aux)
{
int id;
struct btnmgr_softc *sc = device_private(self);
struct wskbddev_attach_args wa;
printf("\n");
/*
* install button event listener
*/
for (id = 0; id <= n_button_config; id++)
if (button_config[id].name != NULL)
sc->sc_hook_tag = config_hook(CONFIG_HOOK_BUTTONEVENT,
id, CONFIG_HOOK_SHARE,
btnmgr_hook, sc);
/*
* attach wskbd
*/
wa.console = 0;
wa.keymap = &btnmgr_keymapdata;
wa.accessops = &btnmgr_wskbd_accessops;
wa.accesscookie = sc;
sc->sc_wskbddev = config_found(self, &wa, wskbddevprint);
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "unable to establish power handler\n");
}
static void
jmahci_attach(device_t parent, device_t self, void *aux)
{
struct jmahci_attach_args *jma = aux;
const struct pci_attach_args *pa = jma->jma_pa;
struct ahci_softc *sc = device_private(self);
uint32_t ahci_cap;
aprint_naive(": AHCI disk controller\n");
aprint_normal("\n");
sc->sc_atac.atac_dev = self;
sc->sc_ahcit = jma->jma_ahcit;
sc->sc_ahcih = jma->jma_ahcih;
ahci_cap = AHCI_READ(sc, AHCI_CAP);
if (pci_dma64_available(jma->jma_pa) && (ahci_cap & AHCI_CAP_64BIT))
sc->sc_dmat = jma->jma_pa->pa_dmat64;
else
sc->sc_dmat = jma->jma_pa->pa_dmat;
if (PCI_SUBCLASS(pa->pa_class) == PCI_SUBCLASS_MASS_STORAGE_RAID)
sc->sc_atac_capflags = ATAC_CAP_RAID;
ahci_attach(sc);
if (!pmf_device_register(self, NULL, jmahci_resume))
aprint_error_dev(self, "couldn't establish power handler\n");
}
static void
ppbattach(device_t parent, device_t self, void *aux)
{
struct ppb_softc *sc = device_private(self);
struct pci_attach_args *pa = aux;
pci_chipset_tag_t pc = pa->pa_pc;
struct pcibus_attach_args pba;
pcireg_t busdata;
pci_aprint_devinfo(pa, NULL);
sc->sc_pc = pc;
sc->sc_tag = pa->pa_tag;
sc->sc_dev = self;
busdata = pci_conf_read(pc, pa->pa_tag, PPB_REG_BUSINFO);
if (PPB_BUSINFO_SECONDARY(busdata) == 0) {
aprint_normal_dev(self, "not configured by system firmware\n");
return;
}
ppb_fix_pcie(self);
#if 0
/*
* XXX can't do this, because we're not given our bus number
* (we shouldn't need it), and because we've no way to
* decompose our tag.
*/
/* sanity check. */
if (pa->pa_bus != PPB_BUSINFO_PRIMARY(busdata))
panic("ppbattach: bus in tag (%d) != bus in reg (%d)",
pa->pa_bus, PPB_BUSINFO_PRIMARY(busdata));
#endif
if (!pmf_device_register(self, ppb_suspend, ppb_resume))
aprint_error_dev(self, "couldn't establish power handler\n");
/*
* Attach the PCI bus than hangs off of it.
*
* XXX Don't pass-through Memory Read Multiple. Should we?
* XXX Consult the spec...
*/
pba.pba_iot = pa->pa_iot;
pba.pba_memt = pa->pa_memt;
pba.pba_dmat = pa->pa_dmat;
pba.pba_dmat64 = pa->pa_dmat64;
pba.pba_pc = pc;
pba.pba_flags = pa->pa_flags & ~PCI_FLAGS_MRM_OKAY;
pba.pba_bus = PPB_BUSINFO_SECONDARY(busdata);
pba.pba_sub = PPB_BUSINFO_SUBORDINATE(busdata);
pba.pba_bridgetag = &sc->sc_tag;
pba.pba_intrswiz = pa->pa_intrswiz;
pba.pba_intrtag = pa->pa_intrtag;
config_found_ia(self, "pcibus", &pba, pcibusprint);
}
void
pckbdattach(device_t parent, device_t self, void *aux)
{
struct pckbd_softc *sc = device_private(self);
struct pckbport_attach_args *pa = aux;
struct wskbddev_attach_args a;
int isconsole;
u_char cmd[1];
aprint_naive("\n");
aprint_normal("\n");
sc->sc_dev = self;
isconsole = pckbd_is_console(pa->pa_tag, pa->pa_slot);
if (isconsole) {
sc->id = &pckbd_consdata;
/*
* Some keyboards are not enabled after a reset,
* so make sure it is enabled now.
*/
cmd[0] = KBC_ENABLE;
(void) pckbport_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
cmd, 1, 0, 0, 0);
sc->sc_enabled = 1;
} else {
sc->id = malloc(sizeof(struct pckbd_internal),
M_DEVBUF, M_WAITOK);
(void) pckbd_init(sc->id, pa->pa_tag, pa->pa_slot, 0);
/* no interrupts until enabled */
cmd[0] = KBC_DISABLE;
(void) pckbport_poll_cmd(sc->id->t_kbctag, sc->id->t_kbcslot,
cmd, 1, 0, 0, 0);
sc->sc_enabled = 0;
}
sc->id->t_sc = sc;
pckbport_set_inputhandler(sc->id->t_kbctag, sc->id->t_kbcslot,
pckbd_input, sc, device_xname(sc->sc_dev));
a.console = isconsole;
a.keymap = &pckbd_keymapdata;
a.accessops = &pckbd_accessops;
a.accesscookie = sc;
if (!pmf_device_register(self, pckbd_suspend, pckbd_resume))
aprint_error_dev(self, "couldn't establish power handler\n");
/*
* Attach the wskbd, saving a handle to it.
* XXX XXX XXX
*/
sc->sc_wskbddev = config_found_ia(self, "wskbddev", &a, wskbddevprint);
}
static void
tpm_isa_attach(device_t parent, device_t self, void *aux)
{
struct tpm_softc *sc = device_private(self);
struct isa_attach_args *ia = aux;
bus_addr_t iobase;
bus_size_t size;
int rv;
sc->sc_dev = self;
if (tpm_legacy_probe(ia->ia_iot, ia->ia_io[0].ir_addr)) {
sc->sc_bt = ia->ia_iot;
iobase = (unsigned int)ia->ia_io[0].ir_addr;
size = ia->ia_io[0].ir_size;
sc->sc_batm = ia->ia_iot;
sc->sc_init = tpm_legacy_init;
sc->sc_start = tpm_legacy_start;
sc->sc_read = tpm_legacy_read;
sc->sc_write = tpm_legacy_write;
sc->sc_end = tpm_legacy_end;
} else {
sc->sc_bt = ia->ia_memt;
iobase = (unsigned int)ia->ia_iomem[0].ir_addr;
size = TPM_SIZE;
sc->sc_init = tpm_tis12_init;
sc->sc_start = tpm_tis12_start;
sc->sc_read = tpm_tis12_read;
sc->sc_write = tpm_tis12_write;
sc->sc_end = tpm_tis12_end;
}
if (bus_space_map(sc->sc_bt, iobase, size, 0, &sc->sc_bh)) {
aprint_error_dev(sc->sc_dev, "cannot map registers\n");
return;
}
if ((rv = (*sc->sc_init)(sc, ia->ia_irq[0].ir_irq,
device_xname(sc->sc_dev))) != 0) {
bus_space_unmap(sc->sc_bt, sc->sc_bh, size);
return;
}
/*
* Only setup interrupt handler when we have a vector and the
* chip is TIS 1.2 compliant.
*/
if (sc->sc_init == tpm_tis12_init &&
ia->ia_irq[0].ir_irq != ISA_UNKNOWN_IRQ &&
(sc->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq[0].ir_irq,
IST_EDGE, IPL_TTY, tpm_intr, sc)) == NULL) {
bus_space_unmap(sc->sc_bt, sc->sc_bh, TPM_SIZE);
aprint_error_dev(sc->sc_dev, "cannot establish interrupt\n");
return;
}
if (!pmf_device_register(sc->sc_dev, tpm_suspend, tpm_resume))
aprint_error_dev(sc->sc_dev, "Cannot set power mgmt handler\n");
}
void
attimer_attach(struct attimer_softc *sc)
{
sc->sc_flags |= ATT_CONFIGURED;
if (!pmf_device_register(sc->sc_dev, NULL, NULL))
aprint_error_dev(sc->sc_dev, "couldn't establish power handler\n");
}
void
ath_cardbus_attach(device_t parent, device_t self, void *aux)
{
struct ath_cardbus_softc *csc = device_private(self);
struct ath_softc *sc = &csc->sc_ath;
struct cardbus_attach_args *ca = aux;
cardbus_devfunc_t ct = ca->ca_ct;
bus_addr_t adr;
sc->sc_dev = self;
sc->sc_dmat = ca->ca_dmat;
csc->sc_ct = ct;
csc->sc_tag = ca->ca_tag;
aprint_normal("\n");
/*
* Map the device.
*/
if (Cardbus_mapreg_map(ct, ATH_PCI_MMBA, PCI_MAPREG_TYPE_MEM, 0,
&csc->sc_iot, &csc->sc_ioh, &adr, &csc->sc_mapsize) == 0) {
#if rbus
#else
(*ct->ct_cf->cardbus_mem_open)(cc, 0, adr, adr+csc->sc_mapsize);
#endif
csc->sc_bar_val = adr | PCI_MAPREG_TYPE_MEM;
} else {
aprint_error_dev(self, "unable to map device registers\n");
return;
}
sc->sc_st = HALTAG(csc->sc_iot);
sc->sc_sh = HALHANDLE(csc->sc_ioh);
/*
* Set up the PCI configuration registers.
*/
ath_cardbus_setup(csc);
/* Remember which interrupt line. */
csc->sc_intrline = ca->ca_intrline;
ATH_LOCK_INIT(sc);
/*
* Finish off the attach.
*/
if (ath_attach(PCI_PRODUCT(ca->ca_id), sc) != 0)
return;
if (!pmf_device_register(self, ath_cardbus_suspend, ath_cardbus_resume))
aprint_error_dev(self, "couldn't establish power handler\n");
else {
pmf_class_network_register(self, &sc->sc_if);
pmf_device_suspend_self(self);
}
}
void
spkrattach(device_t parent, device_t self, void *aux)
{
printf("\n");
ppicookie = ((struct pcppi_attach_args *)aux)->pa_cookie;
spkr_attached = 1;
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
}
/*
* acpitz_attach: autoconf(9) attach routine
*/
static void
acpitz_attach(device_t parent, device_t self, void *aux)
{
struct acpitz_softc *sc = device_private(self);
struct acpi_attach_args *aa = aux;
ACPI_INTEGER val;
ACPI_STATUS rv;
sc->sc_first = true;
sc->sc_have_fan = false;
sc->sc_node = aa->aa_node;
sc->sc_zone.tzp = ATZ_TZP_RATE;
aprint_naive("\n");
acpitz_print_processor_list(self);
aprint_normal("\n");
/*
* The _TZP (ACPI 4.0, p. 430) defines the recommended
* polling interval (in tenths of seconds). A value zero
* means that polling "should not be necessary".
*/
rv = acpi_eval_integer(sc->sc_node->ad_handle, "_TZP", &val);
if (ACPI_SUCCESS(rv) && val != 0)
sc->sc_zone.tzp = val;
aprint_debug_dev(self, "polling interval %d.%d seconds\n",
sc->sc_zone.tzp / 10, sc->sc_zone.tzp % 10);
sc->sc_zone_expire = ATZ_ZONE_EXPIRE / sc->sc_zone.tzp;
/*
* XXX: The fan controls seen here are available on
* some HP laptops. Arguably these should not
* appear in a generic device driver like this.
*/
if (acpitz_get_fanspeed(self, &sc->sc_zone.fanmin,
&sc->sc_zone.fanmax, &sc->sc_zone.fancurrent) == 0)
sc->sc_have_fan = true;
acpitz_get_zone(self, 1);
acpitz_get_status(self);
(void)pmf_device_register(self, NULL, NULL);
(void)acpi_power_register(sc->sc_node->ad_handle);
(void)acpi_register_notify(sc->sc_node, acpitz_notify_handler);
callout_init(&sc->sc_callout, CALLOUT_MPSAFE);
callout_setfunc(&sc->sc_callout, acpitz_tick, self);
acpitz_init_envsys(self);
callout_schedule(&sc->sc_callout, sc->sc_zone.tzp * hz / 10);
}
static void
fxp_cardbus_attach(struct device *parent, struct device *self,
void *aux)
{
struct fxp_cardbus_softc *csc = device_private(self);
struct fxp_softc *sc = &csc->sc;
struct cardbus_attach_args *ca = aux;
bus_space_tag_t iot, memt;
bus_space_handle_t ioh, memh;
bus_addr_t adr;
bus_size_t size;
sc->sc_dev = self;
csc->ct = ca->ca_ct;
/*
* Map control/status registers.
*/
if (Cardbus_mapreg_map(csc->ct, CARDBUS_BASE1_REG,
PCI_MAPREG_TYPE_IO, 0, &iot, &ioh, &adr, &size) == 0) {
csc->base1_reg = adr | 1;
sc->sc_st = iot;
sc->sc_sh = ioh;
csc->size = size;
} else if (Cardbus_mapreg_map(csc->ct, CARDBUS_BASE0_REG,
PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT,
0, &memt, &memh, &adr, &size) == 0) {
csc->base0_reg = adr;
sc->sc_st = memt;
sc->sc_sh = memh;
csc->size = size;
} else
panic("%s: failed to allocate mem and io space", __func__);
if (ca->ca_cis.cis1_info[0] && ca->ca_cis.cis1_info[1])
printf(": %s %s\n", ca->ca_cis.cis1_info[0],
ca->ca_cis.cis1_info[1]);
else
printf("\n");
sc->sc_dmat = ca->ca_dmat;
sc->sc_enable = fxp_cardbus_enable;
sc->sc_disable = fxp_cardbus_disable;
sc->sc_enabled = 0;
fxp_enable(sc);
fxp_attach(sc);
fxp_disable(sc);
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
else
pmf_class_network_register(self, &sc->sc_ethercom.ec_if);
}
static void
nfsmbc_attach(device_t parent, device_t self, void *aux)
{
struct nfsmbc_softc *sc = device_private(self);
struct pci_attach_args *pa = aux;
struct nfsmbc_attach_args nfsmbca;
pcireg_t reg;
int baseregs[2];
char devinfo[256];
aprint_naive("\n");
pci_devinfo(pa->pa_id, pa->pa_class, 0, devinfo, sizeof(devinfo));
aprint_normal(": %s (rev. 0x%02x)\n", devinfo,
PCI_REVISION(pa->pa_class));
sc->sc_dev = self;
sc->sc_pc = pa->pa_pc;
sc->sc_tag = pa->pa_tag;
sc->sc_pa = pa;
sc->sc_iot = pa->pa_iot;
nfsmbca.nfsmb_iot = sc->sc_iot;
switch (PCI_PRODUCT(pa->pa_id)) {
case PCI_PRODUCT_NVIDIA_NFORCE2_SMBUS:
case PCI_PRODUCT_NVIDIA_NFORCE2_400_SMBUS:
case PCI_PRODUCT_NVIDIA_NFORCE3_SMBUS:
case PCI_PRODUCT_NVIDIA_NFORCE3_250_SMBUS:
case PCI_PRODUCT_NVIDIA_NFORCE4_SMBUS:
baseregs[0] = NFORCE_OLD_SMB1;
baseregs[1] = NFORCE_OLD_SMB2;
break;
default:
baseregs[0] = NFORCE_SMB1;
baseregs[1] = NFORCE_SMB2;
break;
}
reg = pci_conf_read(pa->pa_pc, pa->pa_tag, baseregs[0]);
nfsmbca.nfsmb_num = 1;
nfsmbca.nfsmb_addr = NFORCE_SMBBASE(reg);
sc->sc_nfsmb[0] = config_found(sc->sc_dev, &nfsmbca, nfsmbc_print);
reg = pci_conf_read(pa->pa_pc, pa->pa_tag, baseregs[1]);
nfsmbca.nfsmb_num = 2;
nfsmbca.nfsmb_addr = NFORCE_SMBBASE(reg);
sc->sc_nfsmb[1] = config_found(sc->sc_dev, &nfsmbca, nfsmbc_print);
/* This driver is similar to an ISA bridge that doesn't
* need any special handling. So registering NULL handlers
* are sufficent. */
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
}
static void
spic_acpi_attach(device_t parent, device_t self, void *aux)
{
struct spic_acpi_softc *sc = device_private(self);
struct acpi_attach_args *aa = aux;
struct acpi_io *io;
struct acpi_irq *irq;
struct acpi_resources res;
ACPI_STATUS rv;
aprint_naive(": Sony Programmable I/O Controller\n");
aprint_normal(": Sony Programmable I/O Controller\n");
sc->sc_spic.sc_dev = self;
sc->sc_node = aa->aa_node;
/* Parse our resources. */
rv = acpi_resource_parse(self, sc->sc_node->ad_handle,
"_CRS", &res, &acpi_resource_parse_ops_default);
if (ACPI_FAILURE(rv))
return;
sc->sc_spic.sc_iot = aa->aa_iot;
io = acpi_res_io(&res, 0);
if (io == NULL) {
aprint_error_dev(self, "unable to find io resource\n");
goto out;
}
if (bus_space_map(sc->sc_spic.sc_iot, io->ar_base, io->ar_length,
0, &sc->sc_spic.sc_ioh) != 0) {
aprint_error_dev(self, "unable to map data register\n");
goto out;
}
irq = acpi_res_irq(&res, 0);
if (irq == NULL) {
aprint_error_dev(self, "unable to find irq resource\n");
/* XXX unmap */
goto out;
}
#if 0
sc->sc_ih = isa_intr_establish(NULL, irq->ar_irq,
IST_EDGE, IPL_TTY, spic_intr, sc);
#endif
if (!pmf_device_register(self, spic_suspend, spic_resume))
aprint_error_dev(self, "couldn't establish power handler\n");
else
pmf_class_input_register(self);
spic_attach(&sc->sc_spic);
out:
acpi_resource_cleanup(&res);
}
static void
i915drm_attach(struct device *parent, struct device *self, void *aux)
{
struct pci_attach_args *pa = aux;
drm_device_t *dev = (drm_device_t *)self;
i915_configure(dev);
pmf_device_register(self, NULL, NULL);
drm_attach(self, pa, i915_pciidlist);
}
static void
cgd_attach(device_t parent, device_t self, void *aux)
{
struct cgd_softc *sc = device_private(self);
mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_BIO);
dk_init(&sc->sc_dksc, self, DKTYPE_CGD);
disk_init(&sc->sc_dksc.sc_dkdev, sc->sc_dksc.sc_xname, &cgddkdriver);
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "unable to register power management hooks\n");
}
static void
ahci_pci_attach(device_t parent, device_t self, void *aux)
{
struct pci_attach_args *pa = aux;
struct ahci_pci_softc *psc = device_private(self);
struct ahci_softc *sc = &psc->ah_sc;
bus_size_t size;
char devinfo[256];
const char *intrstr;
pci_intr_handle_t intrhandle;
void *ih;
sc->sc_atac.atac_dev = self;
if (pci_mapreg_map(pa, AHCI_PCI_ABAR,
PCI_MAPREG_TYPE_MEM | PCI_MAPREG_MEM_TYPE_32BIT, 0,
&sc->sc_ahcit, &sc->sc_ahcih, NULL, &size) != 0) {
aprint_error_dev(self, "can't map ahci registers\n");
return;
}
psc->sc_pc = pa->pa_pc;
psc->sc_pcitag = pa->pa_tag;
pci_devinfo(pa->pa_id, pa->pa_class, 0, devinfo, sizeof(devinfo));
aprint_naive(": AHCI disk controller\n");
aprint_normal(": %s\n", devinfo);
if (pci_intr_map(pa, &intrhandle) != 0) {
aprint_error("%s: couldn't map interrupt\n", AHCINAME(sc));
return;
}
intrstr = pci_intr_string(pa->pa_pc, intrhandle);
ih = pci_intr_establish(pa->pa_pc, intrhandle, IPL_BIO, ahci_intr, sc);
if (ih == NULL) {
aprint_error("%s: couldn't establish interrupt", AHCINAME(sc));
return;
}
aprint_normal("%s: interrupting at %s\n", AHCINAME(sc),
intrstr ? intrstr : "unknown interrupt");
sc->sc_dmat = pa->pa_dmat;
if (PCI_SUBCLASS(pa->pa_class) == PCI_SUBCLASS_MASS_STORAGE_RAID) {
AHCIDEBUG_PRINT(("%s: RAID mode\n", AHCINAME(sc)), DEBUG_PROBE);
sc->sc_atac_capflags = ATAC_CAP_RAID;
} else {
AHCIDEBUG_PRINT(("%s: SATA mode\n", AHCINAME(sc)), DEBUG_PROBE);
}
ahci_attach(sc);
if (!pmf_device_register(self, NULL, ahci_pci_resume))
aprint_error_dev(self, "couldn't establish power handler\n");
}
static void
n900audjck_attach(device_t parent, device_t self, void *aux)
{
struct n900audjck_softc *sc = device_private(self);
struct gpio_attach_args *ga = aux;
int caps;
sc->sc_dev = self;
sc->sc_gpio = ga->ga_gpio;
/* map pins */
sc->sc_map.pm_map = sc->sc_map_pins;
if (gpio_pin_map(sc->sc_gpio, ga->ga_offset, ga->ga_mask,
&sc->sc_map)) {
aprint_error(": couldn't map the pins\n");
return;
}
/* configure the input pin */
caps = gpio_pin_caps(sc->sc_gpio, &sc->sc_map, N900AUDJCK_PIN_INPUT);
if (!(caps & GPIO_PIN_INPUT)) {
aprint_error(": pin is unable to read input\n");
gpio_pin_unmap(sc->sc_gpio, &sc->sc_map);
return;
}
gpio_pin_ctl(sc->sc_gpio, &sc->sc_map, N900AUDJCK_PIN_INPUT,
GPIO_PIN_INPUT);
sc->sc_intr = intr_establish(N900AUDJCK_GPIO_BASE + ga->ga_offset,
IPL_VM, IST_EDGE_BOTH, n900audjck_intr, sc);
if (sc->sc_intr == NULL) {
aprint_error(": couldn't establish interrupt\n");
gpio_pin_unmap(sc->sc_gpio, &sc->sc_map);
return;
}
aprint_normal(": N900 audio jack\n");
aprint_naive(": N900 audio jack\n");
if (!pmf_device_register(sc->sc_dev, NULL, NULL)) {
aprint_error_dev(sc->sc_dev,
"couldn't establish power handler\n");
}
sysmon_task_queue_init();
sc->sc_smpsw.smpsw_name = device_xname(self);
sc->sc_smpsw.smpsw_type = PSWITCH_TYPE_HOTKEY;
sc->sc_state = PSWITCH_EVENT_RELEASED;
sysmon_pswitch_register(&sc->sc_smpsw);
/* report an event immediately if an audio jack is inserted */
n900audjck_refresh(sc);
}
static void
pxamci_attach(device_t parent, device_t self, void *aux)
{
struct wzero3mci_softc *sc = device_private(self);
struct pxaip_attach_args *pxa = aux;
const struct wzero3mci_model *model;
sc->sc.sc_dev = self;
model = wzero3mci_lookup();
if (model == NULL) {
aprint_error(": Unknown model.");
return;
}
sc->sc_detect_pin = model->detect_pin;
sc->sc_power_pin = model->power_pin;
/* Establish SD detect interrupt */
if (sc->sc_detect_pin >= 0) {
pxa2x0_gpio_set_function(sc->sc_detect_pin, GPIO_IN);
sc->sc_detect_ih = pxa2x0_gpio_intr_establish(sc->sc_detect_pin,
IST_EDGE_BOTH, IPL_BIO, wzero3mci_intr, sc);
if (sc->sc_detect_ih == NULL) {
aprint_error_dev(self,
"unable to establish card detect interrupt\n");
return;
}
}
sc->sc.sc_tag.cookie = sc;
sc->sc.sc_tag.get_ocr = wzero3mci_get_ocr;
sc->sc.sc_tag.set_power = wzero3mci_set_power;
sc->sc.sc_tag.card_detect = wzero3mci_card_detect;
sc->sc.sc_tag.write_protect = wzero3mci_write_protect;
sc->sc.sc_caps = PMC_CAPS_4BIT;
if (pxamci_attach_sub(self, pxa)) {
aprint_error_dev(self, "unable to attach MMC controller\n");
goto free_intr;
}
if (!pmf_device_register(self, NULL, NULL)) {
aprint_error_dev(self, "couldn't establish power handler\n");
}
return;
free_intr:
pxa2x0_gpio_intr_disestablish(sc->sc_detect_ih);
sc->sc_detect_ih = NULL;
}
void
ucom_attach(device_t parent, device_t self, void *aux)
{
struct ucom_softc *sc = device_private(self);
struct ucom_attach_args *uca = aux;
struct tty *tp;
if (uca->info != NULL)
aprint_normal(": %s", uca->info);
aprint_normal("\n");
sc->sc_dev = self;
sc->sc_udev = uca->device;
sc->sc_iface = uca->iface;
sc->sc_bulkout_no = uca->bulkout;
sc->sc_bulkin_no = uca->bulkin;
sc->sc_ibufsize = uca->ibufsize;
sc->sc_ibufsizepad = uca->ibufsizepad;
sc->sc_obufsize = uca->obufsize;
sc->sc_opkthdrlen = uca->opkthdrlen;
sc->sc_methods = uca->methods;
sc->sc_parent = uca->arg;
sc->sc_portno = uca->portno;
sc->sc_lsr = 0;
sc->sc_msr = 0;
sc->sc_mcr = 0;
sc->sc_tx_stopped = 0;
sc->sc_swflags = 0;
sc->sc_opening = 0;
sc->sc_refcnt = 0;
sc->sc_dying = 0;
sc->sc_si = softint_establish(SOFTINT_NET, ucom_softintr, sc);
tp = tty_alloc();
tp->t_oproc = ucomstart;
tp->t_param = ucomparam;
tp->t_hwiflow = ucomhwiflow;
sc->sc_tty = tp;
DPRINTF(("ucom_attach: tty_attach %p\n", tp));
tty_attach(tp);
rnd_attach_source(&sc->sc_rndsource, device_xname(sc->sc_dev),
RND_TYPE_TTY, RND_FLAG_DEFAULT);
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
return;
}
