/*
* Check if the minor is correct and ensure necessary structures
* are properly allocated.
*/
int
check_pty(int minor)
{
struct pt_softc *pti;
rw_enter_write(&pt_softc_lock);
if (minor >= npty) {
struct pt_softc **newpt;
int newnpty;
/* check if the requested pty can be granted */
if (minor >= maxptys)
goto limit_reached;
/* grow pty array by powers of two, up to maxptys */
for (newnpty = npty; newnpty <= minor; newnpty *= 2)
;
if (newnpty > maxptys)
newnpty = maxptys;
newpt = ptyarralloc(newnpty);
if (maxptys == npty) {
goto limit_reached;
}
memcpy(newpt, pt_softc, npty * sizeof(struct pt_softc *));
free(pt_softc, M_DEVBUF);
pt_softc = newpt;
npty = newnpty;
}
/*
* If the entry is not yet allocated, allocate one.
*/
if (!pt_softc[minor]) {
pti = malloc(sizeof(struct pt_softc), M_DEVBUF,
M_WAITOK|M_ZERO);
pti->pt_tty = ttymalloc();
ptydevname(minor, pti);
pt_softc[minor] = pti;
}
rw_exit_write(&pt_softc_lock);
return (0);
limit_reached:
rw_exit_write(&pt_softc_lock);
tablefull("pty");
return (ENXIO);
}
int
tmpfs_mem_incr(struct tmpfs_mount *mp, size_t sz)
{
uint64_t lim;
rw_enter_write(&mp->tm_acc_lock);
lim = tmpfs_bytes_max(mp);
if (mp->tm_bytes_used + sz >= lim) {
rw_exit_write(&mp->tm_acc_lock);
return 0;
}
mp->tm_bytes_used += sz;
rw_exit_write(&mp->tm_acc_lock);
return 1;
}
int
acpivout_set_param(struct wsdisplay_param *dp)
{
struct acpivout_softc *sc = NULL;
int i, exact;
switch (dp->param) {
case WSDISPLAYIO_PARAM_BRIGHTNESS:
for (i = 0; i < acpivout_cd.cd_ndevs; i++) {
if (acpivout_cd.cd_devs[i] == NULL)
continue;
sc = (struct acpivout_softc *)acpivout_cd.cd_devs[i];
/* Ignore device if not connected. */
if (sc->sc_bcl_len != 0)
break;
}
if (sc != NULL && sc->sc_bcl_len != 0) {
rw_enter_write(&sc->sc_acpi->sc_lck);
exact = acpivout_find_brightness(sc, dp->curval);
acpivout_set_brightness(sc, exact);
rw_exit_write(&sc->sc_acpi->sc_lck);
return 0;
}
return -1;
default:
return -1;
}
}
int
get_param_brightness(struct wsdisplay_param *dp)
{
struct acpitoshiba_softc *sc = NULL;
int i, ret;
for (i = 0; i < acpitoshiba_cd.cd_ndevs; i++) {
if (acpitoshiba_cd.cd_devs[i] == NULL)
continue;
sc = (struct acpitoshiba_softc *)acpitoshiba_cd.cd_devs[i];
}
if (sc != NULL) {
rw_enter_write(&sc->sc_acpi->sc_lck);
/* default settings */
dp->min = HCI_LCD_BRIGHTNESS_MIN;
dp->max = HCI_LCD_BRIGHTNESS_MAX;
ret = toshiba_get_brightness(sc, &dp->curval);
rw_exit_write(&sc->sc_acpi->sc_lck);
if ((dp->curval != -1) && (ret != HCI_FAILURE) )
return (0);
}
return (1);
}
int
set_param_brightness(struct wsdisplay_param *dp)
{
struct acpitoshiba_softc *sc = NULL;
int i, ret;
for (i = 0; i < acpitoshiba_cd.cd_ndevs; i++) {
if (acpitoshiba_cd.cd_devs[i] == NULL)
continue;
sc = (struct acpitoshiba_softc *)acpitoshiba_cd.cd_devs[i];
}
if (sc != NULL) {
rw_enter_write(&sc->sc_acpi->sc_lck);
ret = toshiba_find_brightness(sc, &dp->curval);
rw_exit_write(&sc->sc_acpi->sc_lck);
if ((dp->curval != -1) && ( ret != HCI_FAILURE))
return (0);
}
return (1);
}
int
safte_detach(struct device *self, int flags)
{
struct safte_softc *sc = (struct safte_softc *)self;
int i;
rw_enter_write(&sc->sc_lock);
#if NBIO > 0
if (sc->sc_nslots > 0)
bio_unregister(self);
#endif
if (sc->sc_nsensors > 0) {
sensordev_deinstall(&sc->sc_sensordev);
sensor_task_unregister(sc->sc_sensortask);
for (i = 0; i < sc->sc_nsensors; i++)
sensor_detach(&sc->sc_sensordev,
&sc->sc_sensors[i].se_sensor);
free(sc->sc_sensors, M_DEVBUF);
}
if (sc->sc_encbuf != NULL)
free(sc->sc_encbuf, M_DEVBUF);
rw_exit_write(&sc->sc_lock);
return (0);
}
void
ucom_unlock(struct ucom_softc *sc)
{
rw_exit_write(&sc->sc_lock);
if (--sc->sc_refcnt < 0)
usb_detach_wakeup(&sc->sc_dev);
}
int
apmkqfilter(dev_t dev, struct knote *kn)
{
struct apm_softc *sc;
/* apm0 only */
if (!apm_cd.cd_ndevs || APMUNIT(dev) != 0 ||
!(sc = apm_cd.cd_devs[APMUNIT(dev)]))
return ENXIO;
switch (kn->kn_filter) {
case EVFILT_READ:
kn->kn_fop = &apmread_filtops;
break;
default:
return (EINVAL);
}
kn->kn_hook = (caddr_t)sc;
rw_enter_write(&sc->sc_lock);
SLIST_INSERT_HEAD(&sc->sc_note, kn, kn_selnext);
rw_exit_write(&sc->sc_lock);
return (0);
}
void
tmpfs_mem_decr(struct tmpfs_mount *mp, size_t sz)
{
rw_enter_write(&mp->tm_acc_lock);
KASSERT(mp->tm_bytes_used >= sz);
mp->tm_bytes_used -= sz;
rw_exit_write(&mp->tm_acc_lock);
}
void
filt_apmrdetach(struct knote *kn)
{
struct apm_softc *sc = (struct apm_softc *)kn->kn_hook;
rw_enter_write(&sc->sc_lock);
SLIST_REMOVE(&sc->sc_note, kn, knote, kn_selnext);
rw_exit_write(&sc->sc_lock);
}
static void radeon_gem_prime_vunmap(struct dma_buf *dma_buf, void *vaddr)
{
struct radeon_bo *bo = dma_buf->priv;
struct drm_device *dev = bo->rdev->ddev;
rw_enter_write(&dev->struct_rwlock);
bo->vmapping_count--;
if (bo->vmapping_count == 0) {
ttm_bo_kunmap(&bo->dma_buf_vmap);
}
rw_exit_write(&dev->struct_rwlock);
}
void
apm_thread(void *v)
{
struct apm_softc *sc = v;
for (;;) {
rw_enter_write(&sc->sc_lock);
(void) apm_periodic_check(sc);
rw_exit_write(&sc->sc_lock);
tsleep(&lbolt, PWAIT, "apmev", 0);
}
}
int
owctr_detach(struct device *self, int flags)
{
struct owctr_softc *sc = (struct owctr_softc *)self;
rw_enter_write(&sc->sc_lock);
sensordev_deinstall(&sc->sc_sensordev);
if (sc->sc_sensortask != NULL)
sensor_task_unregister(sc->sc_sensortask);
rw_exit_write(&sc->sc_lock);
return (0);
}
static void *radeon_gem_prime_vmap(struct dma_buf *dma_buf)
{
struct radeon_bo *bo = dma_buf->priv;
struct drm_device *dev = bo->rdev->ddev;
int ret;
rw_enter_write(&dev->struct_rwlock);
if (bo->vmapping_count) {
bo->vmapping_count++;
goto out_unlock;
}
ret = ttm_bo_kmap(&bo->tbo, 0, bo->tbo.num_pages,
&bo->dma_buf_vmap);
if (ret) {
rw_exit_write(&dev->struct_rwlock);
return ERR_PTR(ret);
}
bo->vmapping_count = 1;
out_unlock:
rw_exit_write(&dev->struct_rwlock);
return bo->dma_buf_vmap.virtual;
}
static struct sg_table *radeon_gem_map_dma_buf(struct dma_buf_attachment *attachment,
enum dma_data_direction dir)
{
struct radeon_bo *bo = attachment->dmabuf->priv;
struct drm_device *dev = bo->rdev->ddev;
int npages = bo->tbo.num_pages;
struct sg_table *sg;
int nents;
rw_enter_write(&dev->struct_rwlock);
sg = drm_prime_pages_to_sg(bo->tbo.ttm->pages, npages);
nents = dma_map_sg(attachment->dev, sg->sgl, sg->nents, dir);
rw_exit_write(&dev->struct_rwlock);
return sg;
}
int
apmopen(dev_t dev, int flag, int mode, struct proc *p)
{
struct apm_softc *sc;
int error = 0;
/* apm0 only */
if (!apm_cd.cd_ndevs || APMUNIT(dev) != 0 ||
!(sc = apm_cd.cd_devs[APMUNIT(dev)]))
return ENXIO;
if (apm_flags & APM_BIOS_PM_DISABLED)
return ENXIO;
DPRINTF(("apmopen: dev %d pid %d flag %x mode %x\n",
APMDEV(dev), p->p_pid, flag, mode));
rw_enter_write(&sc->sc_lock);
switch (APMDEV(dev)) {
case APMDEV_CTL:
if (!(flag & FWRITE)) {
error = EINVAL;
break;
}
if (sc->sc_flags & SCFLAG_OWRITE) {
error = EBUSY;
break;
}
sc->sc_flags |= SCFLAG_OWRITE;
break;
case APMDEV_NORMAL:
if (!(flag & FREAD) || (flag & FWRITE)) {
error = EINVAL;
break;
}
sc->sc_flags |= SCFLAG_OREAD;
break;
default:
error = ENXIO;
break;
}
rw_exit_write(&sc->sc_lock);
return error;
}
void intel_fb_restore_mode(struct drm_device *dev)
{
int ret;
drm_i915_private_t *dev_priv = dev->dev_private;
struct drm_mode_config *config = &dev->mode_config;
struct drm_plane *plane;
rw_enter_write(&dev->mode_config.rwl);
ret = drm_fb_helper_restore_fbdev_mode(&dev_priv->fbdev->helper);
if (ret)
DRM_DEBUG("failed to restore crtc mode\n");
/* Be sure to shut off any planes that may be active */
list_for_each_entry(plane, &config->plane_list, head)
plane->funcs->disable_plane(plane);
rw_exit_write(&dev->mode_config.rwl);
}
/*
* Reclaim an nfsnode so that it can be used for other purposes.
*/
int
nfs_reclaim(void *v)
{
struct vop_reclaim_args *ap = v;
struct vnode *vp = ap->a_vp;
struct nfsmount *nmp;
struct nfsnode *np = VTONFS(vp);
#ifdef DIAGNOSTIC
if (prtactive && vp->v_usecount != 0)
vprint("nfs_reclaim: pushing active", vp);
#endif
if (ap->a_vp->v_flag & VLARVAL)
/*
* vnode was incompletely set up, just return
* as we are throwing it away.
*/
return(0);
#ifdef DIAGNOSTIC
if (ap->a_vp->v_data == NULL)
panic("NULL v_data (no nfsnode set up?) in vnode %p",
ap->a_vp);
#endif
nmp = VFSTONFS(vp->v_mount);
rw_enter_write(&nfs_hashlock);
RB_REMOVE(nfs_nodetree, &nmp->nm_ntree, np);
rw_exit_write(&nfs_hashlock);
if (np->n_rcred)
crfree(np->n_rcred);
if (np->n_wcred)
crfree(np->n_wcred);
cache_purge(vp);
pool_put(&nfs_node_pool, vp->v_data);
vp->v_data = NULL;
return (0);
}
static int radeon_prime_create(struct drm_device *dev,
size_t size,
struct sg_table *sg,
struct radeon_bo **pbo)
{
struct radeon_device *rdev = dev->dev_private;
struct radeon_bo *bo;
int ret;
ret = radeon_bo_create(rdev, size, PAGE_SIZE, false,
RADEON_GEM_DOMAIN_GTT, sg, pbo);
if (ret)
return ret;
bo = *pbo;
bo->gem_base.driver_private = bo;
rw_enter_write(&rdev->gem.rwlock);
list_add_tail(&bo->list, &rdev->gem.objects);
rw_exit_write(&rdev->gem.rwlock);
return 0;
}
/*
* Return pty-related information.
*/
int
sysctl_pty(int *name, u_int namelen, void *oldp, size_t *oldlenp, void *newp,
size_t newlen)
{
int error, oldmax;
if (namelen != 1)
return (ENOTDIR);
switch (name[0]) {
case KERN_TTY_MAXPTYS:
if (!newp)
return (sysctl_rdint(oldp, oldlenp, newp, maxptys));
rw_enter_write(&pt_softc_lock);
oldmax = maxptys;
error = sysctl_int(oldp, oldlenp, newp, newlen, &maxptys);
/*
* We can't set the max lower than the current active
* value or to a value bigger than NPTY_MAX.
*/
if (error == 0 && (maxptys > NPTY_MAX || maxptys < npty)) {
maxptys = oldmax;
error = ERANGE;
}
rw_exit_write(&pt_softc_lock);
return (error);
case KERN_TTY_NPTYS:
return (sysctl_rdint(oldp, oldlenp, newp, npty));
#ifdef notyet
case KERN_TTY_GID:
return (sysctl_int(oldp, oldlenp, newp, newlen, &tty_gid));
#endif
default:
return (EOPNOTSUPP);
}
/* NOTREACHED */
}
int
apmclose(dev_t dev, int flag, int mode, struct proc *p)
{
struct apm_softc *sc;
/* apm0 only */
if (!apm_cd.cd_ndevs || APMUNIT(dev) != 0 ||
!(sc = apm_cd.cd_devs[APMUNIT(dev)]))
return ENXIO;
DPRINTF(("apmclose: pid %d flag %x mode %x\n", p->p_pid, flag, mode));
rw_enter_write(&sc->sc_lock);
switch (APMDEV(dev)) {
case APMDEV_CTL:
sc->sc_flags &= ~SCFLAG_OWRITE;
break;
case APMDEV_NORMAL:
sc->sc_flags &= ~SCFLAG_OREAD;
break;
}
rw_exit_write(&sc->sc_lock);
return 0;
}
void
safte_read_encstat(void *arg)
{
struct safte_softc *sc = (struct safte_softc *)arg;
struct safte_readbuf_cmd cmd;
int flags, i;
struct safte_sensor *s;
u_int16_t oot;
rw_enter_write(&sc->sc_lock);
memset(&cmd, 0, sizeof(cmd));
cmd.opcode = READ_BUFFER;
cmd.flags |= SAFTE_RD_MODE;
cmd.bufferid = SAFTE_RD_ENCSTAT;
cmd.length = htobe16(sc->sc_encbuflen);
flags = SCSI_DATA_IN;
#ifndef SCSIDEBUG
flags |= SCSI_SILENT;
#endif
if (cold)
flags |= SCSI_AUTOCONF;
if (scsi_scsi_cmd(sc->sc_link, (struct scsi_generic *)&cmd,
sizeof(cmd), sc->sc_encbuf, sc->sc_encbuflen, 2, 30000, NULL,
flags) != 0) {
rw_exit_write(&sc->sc_lock);
return;
}
for (i = 0; i < sc->sc_nsensors; i++) {
s = &sc->sc_sensors[i];
s->se_sensor.flags &= ~SENSOR_FUNKNOWN;
DPRINTF(("%s: %d type: %d field: 0x%02x\n", DEVNAME(sc), i,
s->se_type, *s->se_field));
switch (s->se_type) {
case SAFTE_T_FAN:
switch (*s->se_field) {
case SAFTE_FAN_OP:
s->se_sensor.value = 1;
s->se_sensor.status = SENSOR_S_OK;
break;
case SAFTE_FAN_MF:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_CRIT;
break;
case SAFTE_FAN_NOTINST:
case SAFTE_FAN_UNKNOWN:
default:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_UNKNOWN;
s->se_sensor.flags |= SENSOR_FUNKNOWN;
break;
}
break;
case SAFTE_T_PWRSUP:
switch (*s->se_field) {
case SAFTE_PWR_OP_ON:
s->se_sensor.value = 1;
s->se_sensor.status = SENSOR_S_OK;
break;
case SAFTE_PWR_OP_OFF:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_OK;
break;
case SAFTE_PWR_MF_ON:
s->se_sensor.value = 1;
s->se_sensor.status = SENSOR_S_CRIT;
break;
case SAFTE_PWR_MF_OFF:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_CRIT;
break;
case SAFTE_PWR_NOTINST:
case SAFTE_PWR_PRESENT:
case SAFTE_PWR_UNKNOWN:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_UNKNOWN;
s->se_sensor.flags |= SENSOR_FUNKNOWN;
break;
}
break;
case SAFTE_T_DOORLOCK:
switch (*s->se_field) {
case SAFTE_DOOR_LOCKED:
s->se_sensor.value = 1;
s->se_sensor.status = SENSOR_S_OK;
break;
case SAFTE_DOOR_UNLOCKED:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_CRIT;
break;
case SAFTE_DOOR_UNKNOWN:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_CRIT;
s->se_sensor.flags |= SENSOR_FUNKNOWN;
break;
}
break;
case SAFTE_T_ALARM:
switch (*s->se_field) {
case SAFTE_SPKR_OFF:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_OK;
break;
case SAFTE_SPKR_ON:
s->se_sensor.value = 1;
s->se_sensor.status = SENSOR_S_CRIT;
break;
}
break;
case SAFTE_T_TEMP:
s->se_sensor.value = safte_temp2uK(*s->se_field,
sc->sc_celsius);
break;
}
}
oot = betoh16(*sc->sc_temperrs);
for (i = 0; i < sc->sc_ntemps; i++)
sc->sc_temps[i].se_sensor.status =
(oot & (1 << i)) ? SENSOR_S_CRIT : SENSOR_S_OK;
rw_exit_write(&sc->sc_lock);
}
void
safte_read_encstat(void *arg)
{
struct safte_readbuf_cmd *cmd;
struct safte_sensor *s;
struct safte_softc *sc = (struct safte_softc *)arg;
struct scsi_xfer *xs;
int error, i, flags = 0;
u_int16_t oot;
rw_enter_write(&sc->sc_lock);
if (cold)
flags |= SCSI_AUTOCONF;
xs = scsi_xs_get(sc->sc_link, flags | SCSI_DATA_IN | SCSI_SILENT);
if (xs == NULL) {
rw_exit_write(&sc->sc_lock);
return;
}
xs->cmdlen = sizeof(*cmd);
xs->data = sc->sc_encbuf;
xs->datalen = sc->sc_encbuflen;
xs->retries = 2;
xs->timeout = 30000;
cmd = (struct safte_readbuf_cmd *)xs->cmd;
cmd->opcode = READ_BUFFER;
cmd->flags |= SAFTE_RD_MODE;
cmd->bufferid = SAFTE_RD_ENCSTAT;
cmd->length = htobe16(sc->sc_encbuflen);
error = scsi_xs_sync(xs);
scsi_xs_put(xs);
if (error != 0) {
rw_exit_write(&sc->sc_lock);
return;
}
for (i = 0; i < sc->sc_nsensors; i++) {
s = &sc->sc_sensors[i];
s->se_sensor.flags &= ~SENSOR_FUNKNOWN;
DPRINTF(("%s: %d type: %d field: 0x%02x\n", DEVNAME(sc), i,
s->se_type, *s->se_field));
switch (s->se_type) {
case SAFTE_T_FAN:
switch (*s->se_field) {
case SAFTE_FAN_OP:
s->se_sensor.value = 1;
s->se_sensor.status = SENSOR_S_OK;
break;
case SAFTE_FAN_MF:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_CRIT;
break;
case SAFTE_FAN_NOTINST:
case SAFTE_FAN_UNKNOWN:
default:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_UNKNOWN;
s->se_sensor.flags |= SENSOR_FUNKNOWN;
break;
}
break;
case SAFTE_T_PWRSUP:
switch (*s->se_field) {
case SAFTE_PWR_OP_ON:
s->se_sensor.value = 1;
s->se_sensor.status = SENSOR_S_OK;
break;
case SAFTE_PWR_OP_OFF:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_OK;
break;
case SAFTE_PWR_MF_ON:
s->se_sensor.value = 1;
s->se_sensor.status = SENSOR_S_CRIT;
break;
case SAFTE_PWR_MF_OFF:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_CRIT;
break;
case SAFTE_PWR_NOTINST:
case SAFTE_PWR_PRESENT:
case SAFTE_PWR_UNKNOWN:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_UNKNOWN;
s->se_sensor.flags |= SENSOR_FUNKNOWN;
break;
}
break;
case SAFTE_T_DOORLOCK:
switch (*s->se_field) {
case SAFTE_DOOR_LOCKED:
s->se_sensor.value = 1;
s->se_sensor.status = SENSOR_S_OK;
break;
case SAFTE_DOOR_UNLOCKED:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_CRIT;
break;
case SAFTE_DOOR_UNKNOWN:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_CRIT;
s->se_sensor.flags |= SENSOR_FUNKNOWN;
break;
}
break;
case SAFTE_T_ALARM:
switch (*s->se_field) {
case SAFTE_SPKR_OFF:
s->se_sensor.value = 0;
s->se_sensor.status = SENSOR_S_OK;
break;
case SAFTE_SPKR_ON:
s->se_sensor.value = 1;
s->se_sensor.status = SENSOR_S_CRIT;
break;
}
break;
case SAFTE_T_TEMP:
s->se_sensor.value = safte_temp2uK(*s->se_field,
sc->sc_celsius);
break;
}
}
oot = _2btol(sc->sc_temperrs);
for (i = 0; i < sc->sc_ntemps; i++)
sc->sc_temps[i].se_sensor.status =
(oot & (1 << i)) ? SENSOR_S_CRIT : SENSOR_S_OK;
rw_exit_write(&sc->sc_lock);
}
void
owctr_update_counter(void *arg, int bank)
{
struct owctr_softc *sc = arg;
u_int32_t counter;
u_int16_t crc;
u_int8_t *buf;
rw_enter_write(&sc->sc_lock);
onewire_lock(sc->sc_onewire, 0);
if (onewire_reset(sc->sc_onewire) != 0)
goto done;
buf = malloc(DS2423_COUNTER_BUFSZ, M_DEVBUF, M_NOWAIT);
if (buf == NULL) {
printf("%s: malloc() failed\n", sc->sc_dev.dv_xname);
goto done;
}
onewire_matchrom(sc->sc_onewire, sc->sc_rom);
buf[0] = DSCTR_CMD_READ_MEMCOUNTER;
buf[1] = bank;
buf[2] = bank >> 8;
onewire_write_byte(sc->sc_onewire, buf[0]);
onewire_write_byte(sc->sc_onewire, buf[1]);
onewire_write_byte(sc->sc_onewire, buf[2]);
onewire_read_block(sc->sc_onewire, &buf[3], DS2423_COUNTER_BUFSZ-3);
crc = onewire_crc16(buf, DS2423_COUNTER_BUFSZ-2);
crc ^= buf[DS2423_COUNTER_BUF_CRC]
| (buf[DS2423_COUNTER_BUF_CRC+1] << 8);
if ( crc != 0xffff) {
printf("%s: invalid CRC\n", sc->sc_dev.dv_xname);
if (bank == DS2423_COUNTER_BANK_A) {
sc->sc_counterA.value = 0;
sc->sc_counterA.status = SENSOR_S_UNKNOWN;
sc->sc_counterA.flags |= SENSOR_FUNKNOWN;
} else {
sc->sc_counterB.value = 0;
sc->sc_counterB.status = SENSOR_S_UNKNOWN;
sc->sc_counterB.flags |= SENSOR_FUNKNOWN;
}
} else {
counter = buf[DS2423_COUNTER_BUF_COUNTER]
| (buf[DS2423_COUNTER_BUF_COUNTER+1] << 8)
| (buf[DS2423_COUNTER_BUF_COUNTER+2] << 16)
| (buf[DS2423_COUNTER_BUF_COUNTER+3] << 24);
if (bank == DS2423_COUNTER_BANK_A) {
sc->sc_counterA.value = counter;
sc->sc_counterA.status = SENSOR_S_UNSPEC;
sc->sc_counterA.flags &= ~SENSOR_FUNKNOWN;
} else {
sc->sc_counterB.value = counter;
sc->sc_counterB.status = SENSOR_S_UNSPEC;
sc->sc_counterB.flags &= ~SENSOR_FUNKNOWN;
}
}
onewire_reset(sc->sc_onewire);
free(buf, M_DEVBUF);
done:
onewire_unlock(sc->sc_onewire);
rw_exit_write(&sc->sc_lock);
}
int
apmioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
{
struct apm_softc *sc;
struct apmregs regs;
int error = 0;
/* apm0 only */
if (!apm_cd.cd_ndevs || APMUNIT(dev) != 0 ||
!(sc = apm_cd.cd_devs[APMUNIT(dev)]))
return ENXIO;
rw_enter_write(&sc->sc_lock);
switch (cmd) {
/* some ioctl names from linux */
case APM_IOC_STANDBY:
if ((flag & FWRITE) == 0)
error = EBADF;
else
apm_userstandbys++;
break;
case APM_IOC_SUSPEND:
if ((flag & FWRITE) == 0)
error = EBADF;
else
apm_suspends++;
break;
case APM_IOC_PRN_CTL:
if ((flag & FWRITE) == 0)
error = EBADF;
else {
int flag = *(int *)data;
DPRINTF(( "APM_IOC_PRN_CTL: %d\n", flag ));
switch (flag) {
case APM_PRINT_ON: /* enable printing */
sc->sc_flags &= ~SCFLAG_PRINT;
break;
case APM_PRINT_OFF: /* disable printing */
sc->sc_flags &= ~SCFLAG_PRINT;
sc->sc_flags |= SCFLAG_NOPRINT;
break;
case APM_PRINT_PCT: /* disable some printing */
sc->sc_flags &= ~SCFLAG_PRINT;
sc->sc_flags |= SCFLAG_PCTPRINT;
break;
default:
error = EINVAL;
break;
}
}
break;
case APM_IOC_DEV_CTL:
if ((flag & FWRITE) == 0)
error = EBADF;
else {
struct apm_ctl *actl = (struct apm_ctl *)data;
bzero(®s, sizeof(regs));
if (!apmcall(APM_GET_POWER_STATE, actl->dev, ®s))
printf("%s: dev %04x state %04x\n",
sc->sc_dev.dv_xname, dev, regs.cx);
error = apm_set_powstate(actl->dev, actl->mode);
}
break;
case APM_IOC_GETPOWER:
if (apm_get_powstat(®s) == 0) {
struct apm_power_info *powerp =
(struct apm_power_info *)data;
bzero(powerp, sizeof(*powerp));
if (BATT_LIFE(®s) != APM_BATT_LIFE_UNKNOWN)
powerp->battery_life = BATT_LIFE(®s);
powerp->ac_state = AC_STATE(®s);
switch (apm_minver) {
case 0:
if (!(BATT_FLAGS(®s) & APM_BATT_FLAG_NOBATTERY))
powerp->battery_state = BATT_STATE(®s);
break;
case 1:
default:
if (BATT_FLAGS(®s) & APM_BATT_FLAG_HIGH)
powerp->battery_state = APM_BATT_HIGH;
else if (BATT_FLAGS(®s) & APM_BATT_FLAG_LOW)
powerp->battery_state = APM_BATT_LOW;
else if (BATT_FLAGS(®s) & APM_BATT_FLAG_CRITICAL)
powerp->battery_state = APM_BATT_CRITICAL;
else if (BATT_FLAGS(®s) & APM_BATT_FLAG_CHARGING)
powerp->battery_state = APM_BATT_CHARGING;
else if (BATT_FLAGS(®s) & APM_BATT_FLAG_NOBATTERY)
powerp->battery_state = APM_BATTERY_ABSENT;
else
powerp->battery_state = APM_BATT_UNKNOWN;
if (BATT_REM_VALID(®s)) {
powerp->minutes_left = BATT_REMAINING(®s);
if (sc->be_batt)
powerp->minutes_left =
swap16(powerp->minutes_left);
}
}
} else {
apm_perror("ioctl get power status", ®s);
error = EIO;
}
break;
case APM_IOC_STANDBY_REQ:
if ((flag & FWRITE) == 0)
error = EBADF;
/* only fails if no one cares. apmd at least should */
else if (apm_record_event(sc, APM_USER_STANDBY_REQ))
error = EINVAL; /* ? */
break;
case APM_IOC_SUSPEND_REQ:
if ((flag & FWRITE) == 0)
error = EBADF;
/* only fails if no one cares. apmd at least should */
else if (apm_record_event(sc, APM_USER_SUSPEND_REQ))
error = EINVAL; /* ? */
break;
default:
error = ENOTTY;
}
rw_exit_write(&sc->sc_lock);
return error;
}
/*
* Look up a vnode/nfsnode by file handle and store the pointer in *npp.
* Callers must check for mount points!!
* An error number is returned.
*/
int
nfs_nget(struct mount *mnt, nfsfh_t *fh, int fhsize, struct nfsnode **npp)
{
struct nfsmount *nmp;
struct nfsnode *np, find, *np2;
struct vnode *vp, *nvp;
struct proc *p = curproc; /* XXX */
int error;
nmp = VFSTONFS(mnt);
loop:
rw_enter_write(&nfs_hashlock);
find.n_fhp = fh;
find.n_fhsize = fhsize;
np = RB_FIND(nfs_nodetree, &nmp->nm_ntree, &find);
if (np != NULL) {
rw_exit_write(&nfs_hashlock);
vp = NFSTOV(np);
error = vget(vp, LK_EXCLUSIVE, p);
if (error)
goto loop;
*npp = np;
return (0);
}
/*
* getnewvnode() could recycle a vnode, potentially formerly
* owned by NFS. This will cause a VOP_RECLAIM() to happen,
* which will cause recursive locking, so we unlock before
* calling getnewvnode() lock again afterwards, but must check
* to see if this nfsnode has been added while we did not hold
* the lock.
*/
rw_exit_write(&nfs_hashlock);
error = getnewvnode(VT_NFS, mnt, &nfs_vops, &nvp);
/* note that we don't have this vnode set up completely yet */
rw_enter_write(&nfs_hashlock);
if (error) {
*npp = NULL;
rw_exit_write(&nfs_hashlock);
return (error);
}
nvp->v_flag |= VLARVAL;
np = RB_FIND(nfs_nodetree, &nmp->nm_ntree, &find);
if (np != NULL) {
vgone(nvp);
rw_exit_write(&nfs_hashlock);
goto loop;
}
vp = nvp;
np = pool_get(&nfs_node_pool, PR_WAITOK | PR_ZERO);
vp->v_data = np;
/* we now have an nfsnode on this vnode */
vp->v_flag &= ~VLARVAL;
np->n_vnode = vp;
rw_init(&np->n_commitlock, "nfs_commitlk");
/*
* Are we getting the root? If so, make sure the vnode flags
* are correct
*/
if ((fhsize == nmp->nm_fhsize) && !bcmp(fh, nmp->nm_fh, fhsize)) {
if (vp->v_type == VNON)
vp->v_type = VDIR;
vp->v_flag |= VROOT;
}
np->n_fhp = &np->n_fh;
bcopy(fh, np->n_fhp, fhsize);
np->n_fhsize = fhsize;
np2 = RB_INSERT(nfs_nodetree, &nmp->nm_ntree, np);
KASSERT(np2 == NULL);
np->n_accstamp = -1;
rw_exit(&nfs_hashlock);
*npp = np;
return (0);
}
void
ucom_unlock(struct ucom_softc *sc)
{
rw_exit_write(&sc->sc_lock);
}
