IABSD.fr/src/usr.bin/sndiod/dev_sioctl.c

Branch : - branch - master - tag -

• Show log

  Commit

• Author : ratchov
  Date : 2024-12-20 07:35:56
  Hash : 7b639200
  Message : sndiod: Switch to printf(3)-style logging With this change, any line is logged using a single function call (instead of one function call per logged token). This makes the sources easier to read and reduces the binary size. Debug strings that would be too difficult to produce with snprintf(3) are simplified. ok tb, dlg

• usr.bin/sndiod/dev_sioctl.c

• /*	$OpenBSD: dev_sioctl.c,v 1.11 2024/12/20 07:35:56 ratchov Exp $	*/
  /*
   * Copyright (c) 2014-2020 Alexandre Ratchov <alex@caoua.org>
   *
   * Permission to use, copy, modify, and distribute this software for any
   * purpose with or without fee is hereby granted, provided that the above
   * copyright notice and this permission notice appear in all copies.
   *
   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   */
  #include <sys/time.h>
  #include <sys/types.h>
  
  #include <poll.h>
  #include <sndio.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include "abuf.h"
  #include "defs.h"
  #include "dev.h"
  #include "dsp.h"
  #include "file.h"
  #include "dev_sioctl.h"
  #include "utils.h"
  
  void dev_sioctl_ondesc(void *, struct sioctl_desc *, int);
  void dev_sioctl_onval(void *, unsigned int, unsigned int);
  int dev_sioctl_pollfd(void *, struct pollfd *);
  int dev_sioctl_revents(void *, struct pollfd *);
  void dev_sioctl_in(void *);
  void dev_sioctl_out(void *);
  void dev_sioctl_hup(void *);
  
  struct fileops dev_sioctl_ops = {
  	"sioctl",
  	dev_sioctl_pollfd,
  	dev_sioctl_revents,
  	dev_sioctl_in,
  	dev_sioctl_out,
  	dev_sioctl_hup
  };
  
  void
  dev_sioctl_ondesc(void *arg, struct sioctl_desc *desc, int val)
  {
  	struct dev *d = arg;
  	char *group, group_buf[CTL_NAMEMAX];
  
  	if (desc == NULL) {
  		dev_ctlsync(d);
  		return;
  	}
  
  	ctl_del(CTL_HW, d, &desc->addr);
  
  	if (desc->group[0] == 0)
  		group = d->name;
  	else {
  		if (snprintf(group_buf, CTL_NAMEMAX, "%s/%s",
  			d->name, desc->group) >= CTL_NAMEMAX)
  			return;
  		group = group_buf;
  	}
  
  	ctl_new(CTL_HW, d, &desc->addr,
  	    desc->type, desc->display, group,
  	    desc->node0.name, desc->node0.unit, desc->func,
  	    desc->node1.name, desc->node1.unit, desc->maxval, val);
  }
  
  void
  dev_sioctl_onval(void *arg, unsigned int addr, unsigned int val)
  {
  	char str[64];
  	struct dev *d = arg;
  	struct ctl *c;
  
  	logx(2, "%s: onctl: addr = %u, val = %u", d->path, addr, val);
  
  	for (c = ctl_list; c != NULL; c = c->next) {
  		if (c->scope != CTL_HW || c->u.hw.dev != d ||
  		    c->u.hw.addr != addr)
  			continue;
  
  		logx(2, "ctl%u: %s -> %u", c->addr,
  		    (ctl_fmt(str, sizeof(str), c), str), val);
  
  		c->val_mask = ~0U;
  		c->curval = val;
  	}
  }
  
  /*
   * open the control device.
   */
  void
  dev_sioctl_open(struct dev *d)
  {
  	if (d->sioctl.hdl == NULL) {
  		/*
  		 * At this point there are clients, for instance if we're
  		 * called by dev_reopen() but the control device couldn't
  		 * be opened. In this case controls have changed (thoseof
  		 * old device are just removed) so we need to notify clients.
  		 */
  		dev_ctlsync(d);
  		return;
  	}
  	sioctl_ondesc(d->sioctl.hdl, dev_sioctl_ondesc, d);
  	sioctl_onval(d->sioctl.hdl, dev_sioctl_onval, d);
  }
  
  /*
   * close the control device.
   */
  void
  dev_sioctl_close(struct dev *d)
  {
  	struct ctl *c, **pc;
  
  	/* remove controls */
  	pc = &ctl_list;
  	while ((c = *pc) != NULL) {
  		if (c->scope == CTL_HW && c->u.hw.dev == d) {
  			c->refs_mask &= ~CTL_DEVMASK;
  			if (c->refs_mask == 0) {
  				*pc = c->next;
  				xfree(c);
  				continue;
  			}
  			c->type = CTL_NONE;
  			c->desc_mask = ~0;
  		}
  		pc = &c->next;
  	}
  	dev_ctlsync(d);
  }
  
  int
  dev_sioctl_pollfd(void *arg, struct pollfd *pfd)
  {
  	struct dev *d = arg;
  	struct ctl *c;
  	int events = 0;
  
  	for (c = ctl_list; c != NULL; c = c->next) {
  		if (c->scope == CTL_HW && c->u.hw.dev == d && c->dirty)
  			events |= POLLOUT;
  	}
  	return sioctl_pollfd(d->sioctl.hdl, pfd, events);
  }
  
  int
  dev_sioctl_revents(void *arg, struct pollfd *pfd)
  {
  	struct dev *d = arg;
  
  	return sioctl_revents(d->sioctl.hdl, pfd);
  }
  
  void
  dev_sioctl_in(void *arg)
  {
  }
  
  void
  dev_sioctl_out(void *arg)
  {
  	struct dev *d = arg;
  	struct ctl *c;
  	int cnt;
  
  	/*
  	 * for each dirty ctl, call sioctl_setval() and dev_unref(). As
  	 * dev_unref() may destroy the ctl_list, we must call it after
  	 * we've finished iterating on it.
  	 */
  	cnt = 0;
  	for (c = ctl_list; c != NULL; c = c->next) {
  		if (c->scope != CTL_HW || c->u.hw.dev != d || !c->dirty)
  			continue;
  		if (!sioctl_setval(d->sioctl.hdl, c->u.hw.addr, c->curval)) {
  			logx(1, "ctl%u: set failed", c->addr);
  			break;
  		}
  		c->dirty = 0;
  		cnt++;
  	}
  	while (cnt-- > 0)
  		dev_unref(d);
  }
  
  void
  dev_sioctl_hup(void *arg)
  {
  	struct dev *d = arg;
  
  	dev_sioctl_close(d);
  	file_del(d->sioctl.file);
  	sioctl_close(d->sioctl.hdl);
  	d->sioctl.hdl = NULL;
  }