int thinkpad_adaptive_change(struct acpithinkpad_softc *sc) { struct aml_value arg; int64_t mode; if (aml_evalinteger(sc->sc_acpi, sc->sc_devnode, "GTRW", 0, NULL, &mode)) { printf("%s: couldn't get adaptive keyboard mode\n", DEVNAME(sc)); return (1); } bzero(&arg, sizeof(arg)); arg.type = AML_OBJTYPE_INTEGER; if (mode == THINKPAD_ADAPTIVE_MODE_FUNCTION) arg.v_integer = THINKPAD_ADAPTIVE_MODE_HOME; else arg.v_integer = THINKPAD_ADAPTIVE_MODE_FUNCTION; if (aml_evalname(sc->sc_acpi, sc->sc_devnode, "STRW", 1, &arg, NULL)) { printf("%s: couldn't set adaptive keyboard mode\n", DEVNAME(sc)); return (1); } return (0); }
static int get_config (char *fname) { FILE *fp; int i = 0; int rc; char dump[128]; if ((fp = fopen (fname, "r")) == NULL) { return 1; } while ((i < 2) && ((rc = fscanf (fp, "%s %lx %lx %lx", DEVNAME (i), &DEVOFFSET (i), &ENVSIZE (i), &DEVESIZE (i) )) != EOF)) { /* Skip incomplete conversions and comment strings */ if ((rc < 3) || (*DEVNAME (i) == '#')) { fgets (dump, sizeof (dump), fp); /* Consume till end */ continue; } i++; } fclose (fp); HaveRedundEnv = i - 1; if (!i) { /* No valid entries found */ errno = EINVAL; return 1; } else return 0; }
int acpidock_eject(struct acpidock_softc *sc, struct aml_node *node) { struct aml_value cmd; struct aml_value res; int rv; if (node != sc->sc_devnode) aml_notify(node, 3); memset(&cmd, 0, sizeof cmd); cmd.v_integer = 1; cmd.type = AML_OBJTYPE_INTEGER; if (aml_evalname(sc->sc_acpi, node, "_EJ0", 1, &cmd, &res) != 0) { dnprintf(15, "%s: _EJ0 failed\n", DEVNAME(sc)); rv = 0; } else { dnprintf(15, "%s: _EJ0 successful\n", DEVNAME(sc)); rv = 1; } aml_freevalue(&res); return (rv); }
int acpitz_setcpu(struct acpitz_softc *sc, int trend) { struct aml_value res0, *ref; int x; if (aml_evalname(sc->sc_acpi, sc->sc_devnode, "_PSL", 0, NULL, &res0)) { printf("%s: _PSL failed\n", DEVNAME(sc)); goto out; } if (res0.type != AML_OBJTYPE_PACKAGE) { printf("%s: not a package\n", DEVNAME(sc)); goto out; } for (x = 0; x < res0.length; x++) { if (res0.v_package[x]->type != AML_OBJTYPE_OBJREF) { printf("%s: _PSL[%d] not a object ref\n", DEVNAME(sc), x); continue; } ref = res0.v_package[x]->v_objref.ref; if (ref->type != AML_OBJTYPE_PROCESSOR) printf("%s: _PSL[%d] not a CPU\n", DEVNAME(sc), x); } out: aml_freevalue(&res0); return (0); }
static int cs_pcmcia_enable(struct cs_softc *sc) { struct cs_pcmcia_softc *psc = (void *)sc; struct pcmcia_function *pf = psc->sc_pf; if (pcmcia_io_map(pf, PCMCIA_WIDTH_AUTO, 0, psc->sc_pcioh.size, &psc->sc_pcioh, &psc->sc_io_window) != 0) { printf("%s: can't map i/o space\n", DEVNAME(sc)); goto fail; } psc->sc_flags |= CS_PCMCIA_FLAGS_IO_MAPPED; if (pcmcia_function_enable(pf)) { printf("%s: can't enable function\n", DEVNAME(sc)); goto fail; } sc->sc_ih = pcmcia_intr_establish(pf, IPL_NET, cs_intr, sc); if (sc->sc_ih == 0) { printf("%s: can't establish interrupt\n", DEVNAME(sc)); goto fail; } return 0; fail: return EIO; }
void armv7_attach(struct device *parent, struct device *self, void *aux) { struct armv7_softc *sc = (struct armv7_softc *)self; struct board_dev *bd; sc->sc_board_devs = platform_board_devs(); if (hw_prod) printf(": %s\n", hw_prod); else printf(": UNKNOWN BOARD %u\n", board_id); /* Directly configure on-board devices (dev* in config file). */ for (bd = sc->sc_board_devs; bd->name != NULL; bd++) { struct armv7_dev *ad = armv7_find_dev(bd->name, bd->unit); struct armv7_attach_args aa; if (ad == NULL) { printf("%s: device %s unit %d not found\n", DEVNAME(sc), bd->name, bd->unit); continue; } memset(&aa, 0, sizeof(aa)); aa.aa_dev = ad; aa.aa_iot = &armv7_bs_tag; aa.aa_dmat = &armv7_bus_dma_tag; if (config_found_sm(self, &aa, NULL, armv7_submatch) == NULL) printf("%s: device %s unit %d not configured\n", DEVNAME(sc), bd->name, bd->unit); } }
void emc_attach(struct device *parent, struct device *self, void *aux) { struct emc_softc *sc = (struct emc_softc *)self; struct scsi_attach_args *sa = aux; struct scsi_link *link = sa->sa_sc_link; int sp; printf("\n"); /* init link */ link->device_softc = sc; /* init path */ scsi_xsh_set(&sc->sc_path.p_xsh, link, emc_mpath_start); sc->sc_path.p_link = link; /* init status handler */ scsi_xsh_set(&sc->sc_xsh, link, emc_status); sc->sc_pg = dma_alloc(sizeof(*sc->sc_pg), PR_WAITOK); /* let's go */ if (emc_sp_info(sc, &sp)) { printf("%s: unable to get sp info\n", DEVNAME(sc)); return; } if (mpath_path_attach(&sc->sc_path, sp, &emc_mpath_ops) != 0) printf("%s: unable to attach path\n", DEVNAME(sc)); }
int che_read_eeprom(struct cheg_softc *sc, struct pci_attach_args *pa, pcireg_t addr, pcireg_t *dp) { pcireg_t rv, base; int i = 4; if (!pci_get_capability(pa->pa_pc, pa->pa_tag, CHE_PCI_CAP_ID_VPD, &base, NULL)) { printf("%s: VPD EEPROM not found\n", DEVNAME(sc), addr); return EIO; } addr <<= 16; pci_conf_write(pa->pa_pc, pa->pa_tag, base, addr); while(i--) { delay(10); rv = pci_conf_read(pa->pa_pc, pa->pa_tag, base); if (rv & CHE_PCI_F_VPD_ADDR) break; } if (!(rv & CHE_PCI_F_VPD_ADDR)) { printf("%s: reading EEPROM address 0x%x failed\n", DEVNAME(sc), addr); return EIO; } *dp = pci_conf_read(pa->pa_pc, pa->pa_tag, base + CHE_PCI_VPD_DATA); return (0); }
int com_cardbus_enable(struct com_softc *sc) { struct com_cardbus_softc *csc = (struct com_cardbus_softc*)sc; struct cardbus_softc *psc = (struct cardbus_softc *)sc->sc_dev.dv_parent; cardbus_chipset_tag_t cc = psc->sc_cc; cardbus_function_tag_t cf = psc->sc_cf; Cardbus_function_enable(csc->cc_ct); com_cardbus_setup(csc); /* establish the interrupt. */ csc->cc_ih = cardbus_intr_establish(cc, cf, psc->sc_intrline, IPL_TTY, comintr, sc, DEVNAME(csc)); if (csc->cc_ih == NULL) { printf("%s: couldn't establish interrupt\n", DEVNAME(csc)); return (1); } printf(": irq %d", psc->sc_intrline); return (0); }
void safte_attach(struct device *parent, struct device *self, void *aux) { struct safte_softc *sc = (struct safte_softc *)self; struct scsi_attach_args *sa = aux; int i = 0; sc->sc_link = sa->sa_sc_link; sa->sa_sc_link->device_softc = sc; rw_init(&sc->sc_lock, DEVNAME(sc)); printf("\n"); sc->sc_encbuf = NULL; sc->sc_nsensors = 0; #if NBIO > 0 sc->sc_nslots = 0; #endif if (safte_read_config(sc) != 0) { printf("%s: unable to read enclosure configuration\n", DEVNAME(sc)); return; } if (sc->sc_nsensors > 0) { sc->sc_sensortask = sensor_task_register(sc, safte_read_encstat, 10); if (sc->sc_sensortask == NULL) { printf("%s: unable to register update task\n", DEVNAME(sc)); sc->sc_nsensors = sc->sc_ntemps = 0; free(sc->sc_sensors, M_DEVBUF); } else { for (i = 0; i < sc->sc_nsensors; i++) sensor_attach(&sc->sc_sensordev, &sc->sc_sensors[i].se_sensor); sensordev_install(&sc->sc_sensordev); } } #if NBIO > 0 if (sc->sc_nslots > 0 && bio_register(self, safte_ioctl) != 0) { printf("%s: unable to register ioctl with bio\n", DEVNAME(sc)); sc->sc_nslots = 0; } else i++; #endif if (i) /* if we're doing something, then preinit encbuf and sensors */ safte_read_encstat(sc); else { free(sc->sc_encbuf, M_DEVBUF); sc->sc_encbuf = NULL; } }
void mfi_pci_attach(struct device *parent, struct device *self, void *aux) { struct mfi_softc *sc = (struct mfi_softc *)self; struct pci_attach_args *pa = aux; const struct mfi_pci_device *mpd; pci_intr_handle_t ih; bus_size_t size; pcireg_t reg; int regbar; mpd = mfi_pci_find_device(pa); if (mpd == NULL) { printf(": can't find matching pci device\n"); return; } if (mpd->mpd_iop == MFI_IOP_GEN2 || mpd->mpd_iop == MFI_IOP_SKINNY) regbar = MFI_BAR_GEN2; else regbar = MFI_BAR; reg = pci_mapreg_type(pa->pa_pc, pa->pa_tag, regbar); if (pci_mapreg_map(pa, regbar, reg, 0, &sc->sc_iot, &sc->sc_ioh, NULL, &size, MFI_PCI_MEMSIZE)) { printf(": can't map controller pci space\n"); return; } sc->sc_dmat = pa->pa_dmat; if (pci_intr_map(pa, &ih) != 0) { printf(": can't map interrupt\n"); goto unmap; } printf(": %s\n", pci_intr_string(pa->pa_pc, ih)); sc->sc_ih = pci_intr_establish(pa->pa_pc, ih, IPL_BIO, mfi_intr, sc, sc->sc_dev.dv_xname); if (!sc->sc_ih) { printf("%s: can't establish interrupt\n", DEVNAME(sc)); goto unmap; } if (mfi_attach(sc, mpd->mpd_iop)) { printf("%s: can't attach\n", DEVNAME(sc)); goto unintr; } return; unintr: pci_intr_disestablish(pa->pa_pc, sc->sc_ih); sc->sc_ih = NULL; unmap: bus_space_unmap(sc->sc_iot, sc->sc_ioh, size); }
void viomb_deflate(struct viomb_softc *sc) { struct virtio_softc *vsc = (struct virtio_softc *)sc->sc_virtio; struct balloon_req *b; struct vm_page *p; struct virtqueue *vq = &sc->sc_vq[VQ_DEFLATE]; u_int64_t nvpages; int i, slot; nvpages = sc->sc_actual - sc->sc_npages; if (nvpages > PGS_PER_REQ) nvpages = PGS_PER_REQ; b = &sc->sc_req; b->bl_nentries = nvpages; TAILQ_INIT(&b->bl_pglist); for (i = 0; i < nvpages; i++) { p = TAILQ_FIRST(&sc->sc_balloon_pages); if (p == NULL){ b->bl_nentries = i - 1; break; } TAILQ_REMOVE(&sc->sc_balloon_pages, p, pageq); TAILQ_INSERT_TAIL(&b->bl_pglist, p, pageq); b->bl_pages[i] = p->phys_addr / VIRTIO_PAGE_SIZE; } if (virtio_enqueue_prep(vq, &slot)) { printf("%s:virtio_get_slot(def) vq_num %d\n", DEVNAME(sc), vq->vq_num); goto err; } if (virtio_enqueue_reserve(vq, slot, 1)) { printf("%s:virtio_enqueue_reserve() vq_num %d\n", DEVNAME(sc), vq->vq_num); goto err; } bus_dmamap_sync(vsc->sc_dmat, b->bl_dmamap, 0, sizeof(u_int32_t) * nvpages, BUS_DMASYNC_PREWRITE); virtio_enqueue_p(vq, slot, b->bl_dmamap, 0, sizeof(u_int32_t) * nvpages, VRING_READ); if (!(vsc->sc_features & VIRTIO_BALLOON_F_MUST_TELL_HOST)) uvm_pglistfree(&b->bl_pglist); virtio_enqueue_commit(vsc, vq, slot, VRING_NOTIFY); return; err: while ((p = TAILQ_LAST(&b->bl_pglist, pglist))) { TAILQ_REMOVE(&b->bl_pglist, p, pageq); TAILQ_INSERT_HEAD(&sc->sc_balloon_pages, p, pageq); } return; }
/* * Called from the kernel proper when it can create threads. */ void usbf_create_thread(void *arg) { struct usbf_softc *sc = arg; if (kthread_create(usbf_task_thread, sc, &sc->sc_proc, "%s", DEVNAME(sc)) != 0) { printf("%s: can't create task thread\n", DEVNAME(sc)); return; } config_pending_decr(); }
void usbf_attach(struct device *parent, struct device *self, void *aux) { struct usbf_softc *sc = (struct usbf_softc *)self; int usbrev; int speed; usbf_status err; /* Continue to set up the bus struct. */ sc->sc_bus = aux; sc->sc_bus->usbfctl = sc; usbrev = sc->sc_bus->usbrev; printf(": USB revision %s", usbrev_str[usbrev]); switch (usbrev) { case USBREV_2_0: speed = USB_SPEED_HIGH; break; case USBREV_1_1: case USBREV_1_0: speed = USB_SPEED_FULL; break; default: printf(", not supported\n"); sc->sc_dying = 1; return; } printf("\n"); /* Initialize the usbf struct. */ TAILQ_INIT(&sc->sc_tskq); /* Establish the software interrupt. */ if (usbf_softintr_establish(sc->sc_bus)) { printf("%s: can't establish softintr\n", DEVNAME(sc)); sc->sc_dying = 1; return; } /* Attach the function driver. */ err = usbf_new_device(self, sc->sc_bus, 0, speed, 0, &sc->sc_port); if (err) { printf("%s: usbf_new_device failed, %s\n", DEVNAME(sc), usbf_errstr(err)); sc->sc_dying = 1; return; } /* Create a process context for asynchronous tasks. */ config_pending_incr(); kthread_create_deferred(usbf_create_thread, sc); }
void acpitz_refresh(void *arg) { struct acpitz_softc *sc = arg; int i, trend; extern int acpi_s5; dnprintf(30, "%s: %s: refresh\n", DEVNAME(sc), sc->sc_devnode->parent->name); if (-1 == (sc->sc_tmp = acpitz_getreading(sc, "_TMP"))) { dnprintf(30, "%s: %s: failed to read temp!\n", DEVNAME(sc), sc->sc_devnode->parent->name); sc->sc_tmp = 0; /* XXX */ } if (sc->sc_crt != -1 && sc->sc_crt <= sc->sc_tmp) { /* Do critical shutdown */ printf("%s: Critical temperature, shutting down!\n", DEVNAME(sc)); acpi_s5 = 1; psignal(initproc, SIGUSR1); } if (sc->sc_hot != -1 && sc->sc_hot <= sc->sc_tmp) printf("%s: _HOT temperature\n", DEVNAME(sc)); if (sc->sc_lasttmp != -1 && sc->sc_tc1 != -1 && sc->sc_tc2 != -1 && sc->sc_psv != -1) { if (sc->sc_psv <= sc->sc_tmp) { sc->sc_pse = 1; trend = sc->sc_tc1 * (sc->sc_tmp - sc->sc_lasttmp) + sc->sc_tc2 * (sc->sc_tmp - sc->sc_psv); /* printf("_TZ trend = %d\n", trend); */ } else if (sc->sc_pse) sc->sc_pse = 0; } sc->sc_lasttmp = sc->sc_tmp; for (i = 0; i < ACPITZ_MAX_AC; i++) { if (sc->sc_ac[i] != -1 && sc->sc_ac[i] <= sc->sc_tmp) { /* turn on fan i */ if (sc->sc_ac_stat[i] <= 0) acpitz_setfan(sc, i, "_ON_"); } else if (sc->sc_ac[i] != -1) { /* turn off fan i */ if (sc->sc_ac_stat[i] > 0) acpitz_setfan(sc, i, "_OFF"); } } sc->sc_sens.value = sc->sc_tmp * 100000; }
int ahci_map_intr(struct ahci_pci_softc *psc, struct pci_attach_args *pa, pci_intr_handle_t ih) { struct ahci_softc *sc = &psc->psc_ahci; sc->sc_ih = pci_intr_establish(psc->psc_pc, ih, IPL_BIO, ahci_intr, sc, DEVNAME(sc)); if (sc->sc_ih == NULL) { printf("%s: unable to map interrupt\n", DEVNAME(sc)); return (1); } return (0); }
void viomb_inflate(struct viomb_softc *sc) { struct virtio_softc *vsc = (struct virtio_softc *)sc->sc_virtio; struct balloon_req *b; struct vm_page *p; struct virtqueue *vq = &sc->sc_vq[VQ_INFLATE]; u_int32_t nvpages; int slot, error, i = 0; nvpages = sc->sc_npages - sc->sc_actual; if (nvpages > PGS_PER_REQ) nvpages = PGS_PER_REQ; b = &sc->sc_req; if ((error = uvm_pglistalloc(nvpages * PAGE_SIZE, 0, dma_constraint.ucr_high, 0, 0, &b->bl_pglist, nvpages, UVM_PLA_NOWAIT))) { printf("%s unable to allocate %u physmem pages," "error %d\n", DEVNAME(sc), nvpages, error); return; } b->bl_nentries = nvpages; TAILQ_FOREACH(p, &b->bl_pglist, pageq) b->bl_pages[i++] = p->phys_addr / VIRTIO_PAGE_SIZE; KASSERT(i == nvpages); if ((virtio_enqueue_prep(vq, &slot)) > 0) { printf("%s:virtio_enqueue_prep() vq_num %d\n", DEVNAME(sc), vq->vq_num); goto err; } if (virtio_enqueue_reserve(vq, slot, 1)) { printf("%s:virtio_enqueue_reserve vq_num %d\n", DEVNAME(sc), vq->vq_num); goto err; } bus_dmamap_sync(vsc->sc_dmat, b->bl_dmamap, 0, sizeof(u_int32_t) * nvpages, BUS_DMASYNC_PREWRITE); virtio_enqueue_p(vq, slot, b->bl_dmamap, 0, sizeof(u_int32_t) * nvpages, VRING_READ); virtio_enqueue_commit(vsc, vq, slot, VRING_NOTIFY); return; err: uvm_pglistfree(&b->bl_pglist); return; }
int toshiba_set_video_output(struct acpitoshiba_softc *sc, u_int32_t *video_output) { struct aml_value args[HCI_WORDS]; int i; bzero(args, sizeof(args)); if ((*video_output < HCI_VIDEO_OUTPUT_CYCLE_MIN) || (*video_output > HCI_VIDEO_OUTPUT_CYCLE_MAX)) return (HCI_FAILURE); *video_output |= HCI_VIDEO_OUTPUT_FLAG; for (i = 0; i < HCI_WORDS; ++i) args[i].type = AML_OBJTYPE_INTEGER; args[HCI_REG_AX].v_integer = HCI_SET; args[HCI_REG_BX].v_integer = HCI_REG_VIDEO_OUTPUT; args[HCI_REG_CX].v_integer = *video_output; if (aml_evalname(sc->sc_acpi, sc->sc_devnode, METHOD_HCI, i, args, NULL)) { printf("%s: set video output failed\n", DEVNAME(sc)); return (HCI_FAILURE); } return (HCI_SUCCESS); }
int toshiba_get_video_output(struct acpitoshiba_softc *sc, u_int32_t *video_output) { struct aml_value res, args[HCI_WORDS]; int i; bzero(args, sizeof(args)); bzero(&res, sizeof(res)); for (i = 0; i < HCI_WORDS; ++i) args[i].type = AML_OBJTYPE_INTEGER; args[HCI_REG_AX].v_integer = HCI_GET; args[HCI_REG_BX].v_integer = HCI_REG_VIDEO_OUTPUT; if (aml_evalname(sc->sc_acpi, sc->sc_devnode, METHOD_HCI, i, args, &res)) { printf("%s: get video output failed\n", DEVNAME(sc)); return (HCI_FAILURE); } /* * We receive a package type so we need to get the event * value from the HCI_REG_CX. */ *video_output = aml_val2int(res.v_package[HCI_REG_CX]); *video_output &= 0xff; aml_freevalue(&res); return (HCI_SUCCESS); }
int toshiba_get_brightness(struct acpitoshiba_softc *sc, u_int32_t *brightness) { struct aml_value args[HCI_WORDS]; struct aml_value res; int i; bzero(args, sizeof(args)); bzero(&res, sizeof(res)); for (i = 0; i < HCI_WORDS; ++i) args[i].type = AML_OBJTYPE_INTEGER; args[HCI_REG_AX].v_integer = HCI_GET; args[HCI_REG_BX].v_integer = HCI_REG_LCD_BRIGHTNESS; if (aml_evalname(sc->sc_acpi, sc->sc_devnode, METHOD_HCI, i, args, &res)) { printf("%s: get brightness failed\n", DEVNAME(sc)); return (HCI_FAILURE); } /* * We receive a package type so we need to get the event * value from the HCI_REG_CX. */ *brightness = aml_val2int(res.v_package[HCI_REG_CX]); *brightness >>= HCI_LCD_BRIGHTNESS_SHIFT; aml_freevalue(&res); return (HCI_SUCCESS); }
int toshiba_set_brightness(struct acpitoshiba_softc *sc, u_int32_t *brightness) { struct aml_value args[HCI_WORDS]; int i; bzero(args, sizeof(args)); for (i = 0; i < HCI_WORDS; ++i) args[i].type = AML_OBJTYPE_INTEGER; if ((*brightness < HCI_LCD_BRIGHTNESS_MIN) || (*brightness > HCI_LCD_BRIGHTNESS_MAX)) return (HCI_FAILURE); *brightness <<= HCI_LCD_BRIGHTNESS_SHIFT; args[HCI_REG_AX].v_integer = HCI_SET; args[HCI_REG_BX].v_integer = HCI_REG_LCD_BRIGHTNESS; args[HCI_REG_CX].v_integer = *brightness; if (aml_evalname(sc->sc_acpi, sc->sc_devnode, METHOD_HCI, i, args, NULL)) { printf("%s: set brightness failed\n", DEVNAME(sc)); return (HCI_FAILURE); } return (HCI_SUCCESS); }
int toshiba_read_events(struct acpitoshiba_softc *sc) { struct aml_value args[HCI_WORDS]; struct aml_value res; int i, val; bzero(args, sizeof(args)); bzero(&res, sizeof(res)); for (i = 0; i < HCI_WORDS; ++i) args[i].type = AML_OBJTYPE_INTEGER; args[HCI_REG_AX].v_integer = HCI_GET; args[HCI_REG_BX].v_integer = HCI_REG_SYSTEM_EVENT; if (aml_evalname(sc->sc_acpi, sc->sc_devnode, METHOD_HCI, i, args, &res)) { printf("%s: couldn't toggle METHOD_HCI\n", DEVNAME(sc)); return (HCI_FAILURE); } /* * We receive a package type so we need to get the event * value from the HCI_REG_CX. */ val = aml_val2int(res.v_package[HCI_REG_CX]); aml_freevalue(&res); return (val); }
int acpiasus_activate(struct device *self, int act) { struct acpiasus_softc *sc = (struct acpiasus_softc *)self; struct aml_value cmd; struct aml_value ret; switch (act) { case DVACT_SUSPEND: break; case DVACT_RESUME: acpiasus_init(self); bzero(&cmd, sizeof(cmd)); cmd.type = AML_OBJTYPE_INTEGER; cmd.v_integer = ASUS_SDSP_LCD; if (aml_evalname(sc->sc_acpi, sc->sc_devnode, "SDSP", 1, &cmd, &ret)) printf("%s: no SDSP\n", DEVNAME(sc)); else aml_freevalue(&ret); break; } return (0); }
void sym_attach(struct device *parent, struct device *self, void *aux) { struct sym_softc *sc = (struct sym_softc *)self; struct scsi_attach_args *sa = aux; struct scsi_link *link = sa->sa_sc_link; struct scsi_inquiry_data *inq = sa->sa_inqbuf; const struct mpath_ops *ops = &sym_mpath_sym_ops; struct sym_device *s; int i; printf("\n"); /* check if we're an assymetric access device */ for (i = 0; i < nitems(asym_devices); i++) { s = &asym_devices[i]; if (bcmp(s->vendor, inq->vendor, strlen(s->vendor)) == 0 && bcmp(s->product, inq->product, strlen(s->product)) == 0) { ops = &sym_mpath_asym_ops; break; } } /* init link */ link->device_softc = sc; /* init path */ scsi_xsh_set(&sc->sc_path.p_xsh, link, sym_mpath_start); sc->sc_path.p_link = link; if (mpath_path_attach(&sc->sc_path, ops) != 0) printf("%s: unable to attach path\n", DEVNAME(sc)); }
void acpibat_monitor(struct acpibat_softc *sc) { int type; /* assume _BIF and _BST have been called */ strlcpy(sc->sc_sensdev.xname, DEVNAME(sc), sizeof(sc->sc_sensdev.xname)); type = sc->sc_bif.bif_power_unit ? SENSOR_AMPHOUR : SENSOR_WATTHOUR; strlcpy(sc->sc_sens[0].desc, "last full capacity", sizeof(sc->sc_sens[0].desc)); sc->sc_sens[0].type = type; sensor_attach(&sc->sc_sensdev, &sc->sc_sens[0]); sc->sc_sens[0].value = sc->sc_bif.bif_last_capacity * 1000; strlcpy(sc->sc_sens[1].desc, "warning capacity", sizeof(sc->sc_sens[1].desc)); sc->sc_sens[1].type = type; sensor_attach(&sc->sc_sensdev, &sc->sc_sens[1]); sc->sc_sens[1].value = sc->sc_bif.bif_warning * 1000; strlcpy(sc->sc_sens[2].desc, "low capacity", sizeof(sc->sc_sens[2].desc)); sc->sc_sens[2].type = type; sensor_attach(&sc->sc_sensdev, &sc->sc_sens[2]); sc->sc_sens[2].value = sc->sc_bif.bif_low * 1000; strlcpy(sc->sc_sens[3].desc, "voltage", sizeof(sc->sc_sens[3].desc)); sc->sc_sens[3].type = SENSOR_VOLTS_DC; sensor_attach(&sc->sc_sensdev, &sc->sc_sens[3]); sc->sc_sens[3].value = sc->sc_bif.bif_voltage * 1000; strlcpy(sc->sc_sens[4].desc, "battery unknown", sizeof(sc->sc_sens[4].desc)); sc->sc_sens[4].type = SENSOR_INTEGER; sensor_attach(&sc->sc_sensdev, &sc->sc_sens[4]); sc->sc_sens[4].value = sc->sc_bst.bst_state; strlcpy(sc->sc_sens[5].desc, "rate", sizeof(sc->sc_sens[5].desc)); sc->sc_sens[5].type = sc->sc_bif.bif_power_unit ? SENSOR_AMPS : SENSOR_WATTS; sensor_attach(&sc->sc_sensdev, &sc->sc_sens[5]); sc->sc_sens[5].value = sc->sc_bst.bst_rate * 1000; strlcpy(sc->sc_sens[6].desc, "remaining capacity", sizeof(sc->sc_sens[6].desc)); sc->sc_sens[6].type = type; sensor_attach(&sc->sc_sensdev, &sc->sc_sens[6]); sc->sc_sens[6].value = sc->sc_bst.bst_capacity * 1000; strlcpy(sc->sc_sens[7].desc, "current voltage", sizeof(sc->sc_sens[7].desc)); sc->sc_sens[7].type = SENSOR_VOLTS_DC; sensor_attach(&sc->sc_sensdev, &sc->sc_sens[7]); sc->sc_sens[7].value = sc->sc_bst.bst_voltage * 1000; sensordev_install(&sc->sc_sensdev); }
int process_list(int fd, int house, int devs, int cmd) { /* * Process and execute on/off commands on a cluster of devices */ unsigned short unit; int i; /* apply cmd to devices in list */ for (i = 0; i < 16; i++) { if (devs & (1 << i)) { unit = (unsigned char)((house << 4) | i); if (Verbose) printf("%s: Turning %s appliance %c%d\n", MyName, (cmd == ON) ? "on":"off", HOUSENAME(house), DEVNAME(i)); if (x10_br_out(fd, unit, (unsigned char)cmd) < 0) return -1; } } return 0; }
int acpiec_gpehandler(struct acpi_softc *acpi_sc, int gpe, void *arg) { struct acpiec_softc *sc = arg; u_int8_t mask, stat, en; int s; KASSERT(sc->sc_ecbusy == 0); dnprintf(10, "ACPIEC: got gpe\n"); do { if (sc->sc_gotsci) acpiec_sci_event(sc); stat = acpiec_status(sc); dnprintf(40, "%s: EC interrupt, stat: %b\n", DEVNAME(sc), (int)stat, "\20\x8IGN\x7SMI\x6SCI\05BURST\04CMD\03IGN\02IBF\01OBF"); if (stat & EC_STAT_SCI_EVT) sc->sc_gotsci = 1; else sc->sc_gotsci = 0; } while (sc->sc_gotsci); /* Unmask the GPE which was blocked at interrupt time */ s = spltty(); mask = (1L << (gpe & 7)); en = acpi_read_pmreg(acpi_sc, ACPIREG_GPE_EN, gpe>>3); acpi_write_pmreg(acpi_sc, ACPIREG_GPE_EN, gpe>>3, en | mask); splx(s); return (0); }
void acpiec_attach(struct device *parent, struct device *self, void *aux) { struct acpiec_softc *sc = (struct acpiec_softc *)self; struct acpi_attach_args *aa = aux; sc->sc_acpi = (struct acpi_softc *)parent; sc->sc_devnode = aa->aaa_node; if (acpiec_getcrs(sc, aa)) { printf(": Failed to read resource settings\n"); return; } sc->sc_acpi->sc_ec = sc; if (acpiec_reg(sc)) { printf(": Failed to register address space\n"); return; } acpiec_get_events(sc); dnprintf(10, "%s: GPE: %d\n", DEVNAME(sc), sc->sc_gpe); #ifndef SMALL_KERNEL acpi_set_gpehandler(sc->sc_acpi, sc->sc_gpe, acpiec_gpehandler, sc, 1); #endif printf("\n"); }
int acpiec_gpehandler(struct acpi_softc *acpi_sc, int gpe, void *arg) { struct acpiec_softc *sc = arg; u_int8_t mask, stat; dnprintf(10, "ACPIEC: got gpe\n"); /* Reset GPE event */ mask = (1L << (gpe & 7)); acpi_write_pmreg(acpi_sc, ACPIREG_GPE_STS, gpe>>3, mask); acpi_write_pmreg(acpi_sc, ACPIREG_GPE_EN, gpe>>3, mask); do { if (sc->sc_gotsci) acpiec_sci_event(sc); stat = acpiec_status(sc); dnprintf(40, "%s: EC interrupt, stat: %b\n", DEVNAME(sc), (int)stat, "\20\x8IGN\x7SMI\x6SCI\05BURST\04CMD\03IGN\02IBF\01OBF"); if (stat & EC_STAT_SCI_EVT) sc->sc_gotsci = 1; } while (sc->sc_gotsci); return (0); }
void aibs_attach(struct device *parent, struct device *self, void *aux) { struct aibs_softc *sc = (struct aibs_softc *)self; struct acpi_attach_args *aa = aux; sc->sc_acpi = (struct acpi_softc *)parent; sc->sc_devnode = aa->aaa_node; strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname, sizeof(sc->sc_sensordev.xname)); SIMPLEQ_INIT(&sc->sc_sensorlist); aibs_probe(sc); printf("\n"); if (sc->sc_mode) aibs_attach_new(sc); else { aibs_attach_sif(sc, SENSOR_TEMP); aibs_attach_sif(sc, SENSOR_FANRPM); aibs_attach_sif(sc, SENSOR_VOLTS_DC); } if (sc->sc_sensordev.sensors_count == 0) { printf("%s: no sensors found\n", DEVNAME(sc)); return; } sensordev_install(&sc->sc_sensordev); aml_register_notify(sc->sc_devnode, aa->aaa_dev, aibs_notify, sc, ACPIDEV_POLL); }