Annotation of src/usr.bin/sndiod/dev_sioctl.c, Revision 1.2
1.2 ! ratchov 1: /* $OpenBSD: dev_sioctl.c,v 1.1 2020/02/26 13:53:58 ratchov Exp $ */
1.1 ratchov 2: /*
3: * Copyright (c) 2014-2020 Alexandre Ratchov <alex@caoua.org>
4: *
5: * Permission to use, copy, modify, and distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16: */
17: #include <sys/time.h>
18: #include <sys/types.h>
19:
20: #include <poll.h>
21: #include <sndio.h>
22: #include <stdio.h>
23: #include <stdlib.h>
24: #include <string.h>
25: #include "abuf.h"
26: #include "defs.h"
27: #include "dev.h"
28: #include "dsp.h"
29: #include "file.h"
30: #include "dev_sioctl.h"
31: #include "utils.h"
32:
33: void dev_sioctl_ondesc(void *, struct sioctl_desc *, int);
34: void dev_sioctl_onval(void *, unsigned int, unsigned int);
35: int dev_sioctl_pollfd(void *, struct pollfd *);
36: int dev_sioctl_revents(void *, struct pollfd *);
37: void dev_sioctl_in(void *);
38: void dev_sioctl_out(void *);
39: void dev_sioctl_hup(void *);
40:
41: struct fileops dev_sioctl_ops = {
42: "sioctl",
43: dev_sioctl_pollfd,
44: dev_sioctl_revents,
45: dev_sioctl_in,
46: dev_sioctl_out,
47: dev_sioctl_hup
48: };
49:
50: void
51: dev_sioctl_ondesc(void *arg, struct sioctl_desc *desc, int val)
52: {
53: #define GROUP_PREFIX "hw"
54: char group_buf[CTL_NAMEMAX], *group;
55: struct dev *d = arg;
56: int addr;
57:
1.2 ! ratchov 58: if (desc == NULL) {
! 59: dev_ctlsync(d);
1.1 ratchov 60: return;
1.2 ! ratchov 61: }
! 62:
1.1 ratchov 63: addr = CTLADDR_END + desc->addr;
64: dev_rmctl(d, addr);
65:
66: /*
67: * prefix group names we use (top-level and "app") with "hw."
68: * to ensure that all controls have unique names when multiple
69: * sndiod's are chained
70: */
71: if (desc->group[0] == 0)
72: group = GROUP_PREFIX;
73: else {
74: group = group_buf;
75: if (snprintf(group_buf, CTL_NAMEMAX, GROUP_PREFIX "/%s",
76: desc->group) >= CTL_NAMEMAX)
77: return;
78: }
79:
80: dev_addctl(d, group, desc->type, addr,
81: desc->node0.name, desc->node0.unit, desc->func,
82: desc->node1.name, desc->node1.unit, desc->maxval, val);
83: }
84:
85: void
86: dev_sioctl_onval(void *arg, unsigned int addr, unsigned int val)
87: {
88: struct dev *d = arg;
89: struct ctl *c;
90:
91: addr += CTLADDR_END;
92:
93: dev_log(d);
94: log_puts(": onctl: addr = ");
95: log_putu(addr);
96: log_puts(", val = ");
97: log_putu(val);
98: log_puts("\n");
99:
100: for (c = d->ctl_list; c != NULL; c = c->next) {
101: if (c->addr != addr)
102: continue;
103: ctl_log(c);
104: log_puts(": new value -> ");
105: log_putu(val);
106: log_puts("\n");
107: c->val_mask = ~0U;
108: c->curval = val;
109: }
110: }
111:
112: /*
113: * open the control device.
114: */
115: void
116: dev_sioctl_open(struct dev *d)
117: {
118: if (d->sioctl.hdl == NULL)
119: return;
120: sioctl_ondesc(d->sioctl.hdl, dev_sioctl_ondesc, d);
121: sioctl_onval(d->sioctl.hdl, dev_sioctl_onval, d);
122: d->sioctl.file = file_new(&dev_sioctl_ops, d, "mix",
123: sioctl_nfds(d->sioctl.hdl));
124: }
125:
126: /*
127: * close the control device.
128: */
129: void
130: dev_sioctl_close(struct dev *d)
131: {
132: if (d->sioctl.hdl == NULL)
133: return;
134: file_del(d->sioctl.file);
135: }
136:
137: int
138: dev_sioctl_pollfd(void *arg, struct pollfd *pfd)
139: {
140: struct dev *d = arg;
141: struct ctl *c;
142: int events = 0;
143:
144: for (c = d->ctl_list; c != NULL; c = c->next) {
145: if (c->dirty)
146: events |= POLLOUT;
147: }
148: return sioctl_pollfd(d->sioctl.hdl, pfd, events);
149: }
150:
151: int
152: dev_sioctl_revents(void *arg, struct pollfd *pfd)
153: {
154: struct dev *d = arg;
155:
156: return sioctl_revents(d->sioctl.hdl, pfd);
157: }
158:
159: void
160: dev_sioctl_in(void *arg)
161: {
162: }
163:
164: void
165: dev_sioctl_out(void *arg)
166: {
167: struct dev *d = arg;
168: struct ctl *c;
169: int cnt;
170:
171: /*
172: * for each dirty ctl, call sioctl_setval() and dev_unref(). As
173: * dev_unref() may destroy the ctl_list, we must call it after
174: * we've finished iterating on it.
175: */
176: cnt = 0;
177: for (c = d->ctl_list; c != NULL; c = c->next) {
178: if (!c->dirty)
179: continue;
180: if (!sioctl_setval(d->sioctl.hdl,
181: c->addr - CTLADDR_END, c->curval)) {
182: ctl_log(c);
183: log_puts(": set failed\n");
184: break;
185: }
186: if (log_level >= 2) {
187: ctl_log(c);
188: log_puts(": changed\n");
189: }
190: c->dirty = 0;
191: cnt++;
192: }
193: while (cnt-- > 0)
194: dev_unref(d);
195: }
196:
197: void
198: dev_sioctl_hup(void *arg)
199: {
200: struct dev *d = arg;
201:
202: dev_sioctl_close(d);
203: }