1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 1998, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 #include <regex.h>
26 #include <devfsadm.h>
27 #include <strings.h>
28 #include <ctype.h>
29 #include <stdlib.h>
30 #include <limits.h>
31 #include <stdio.h>
32 #include <syslog.h>
33 #include <bsm/devalloc.h>
34 #include <sys/audio.h>
35 #include <sys/soundcard.h>
36 #include <unistd.h>
37
38 #define MAX_AUDIO_LINK 100
39 #define RE_SIZE 64
40
41 extern int system_labeled;
42
43 static void check_audio_link(di_node_t anynode, char *secondary_link,
44 const char *primary_link_format);
45
46 static int audio_process(di_minor_t minor, di_node_t node);
47 static int sndstat_process(di_minor_t minor, di_node_t node);
48
49 static devfsadm_create_t audio_cbt[] = {
50 { "audio", "ddi_audio", NULL,
51 TYPE_EXACT, ILEVEL_0, audio_process
52 },
53 { "pseudo", "ddi_pseudo", "audio",
54 TYPE_EXACT|DRV_EXACT, ILEVEL_0, sndstat_process
55 },
56 };
57
58 DEVFSADM_CREATE_INIT_V0(audio_cbt);
59
60 /*
61 * the following can't be one big RE with a bunch of alterations "|"
62 * because recurse_dev_re() would not work.
63 */
64 static devfsadm_remove_t audio_remove_cbt[] = {
65 /*
66 * Secondary links.
67 */
68
69 /* /dev/audio, /dev/audioctl, /dev/dsp */
70 { "audio", "^audio$",
71 RM_POST|RM_HOT|RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
72 },
73 { "audio", "^audioctl$",
74 RM_POST|RM_HOT|RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
75 },
76 { "audio", "^dsp$",
77 RM_POST|RM_HOT|RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
78 },
79 { "audio", "^mixer",
80 RM_POST|RM_HOT|RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
81 },
82 { "audio", "^sndstat$",
83 RM_PRE|RM_HOT|RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
84 },
85 { "audio", "^mixer[0-9]+$",
86 RM_POST|RM_HOT|RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
87 },
88 { "audio", "^dsp[0-9]+$",
89 RM_POST|RM_HOT|RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
90 },
91 { "audio", "^sound/[0-9]+$",
92 RM_POST|RM_HOT|RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
93 },
94 { "audio", "^sound/[0-9]+ctl$",
95 RM_POST|RM_HOT|RM_ALWAYS, ILEVEL_0, devfsadm_rm_all
96 },
97 };
98
99 DEVFSADM_REMOVE_INIT_V0(audio_remove_cbt);
100
101 static di_node_t anynode;
102
103 int
minor_init(void)104 minor_init(void)
105 {
106 anynode = DI_NODE_NIL;
107 return (DEVFSADM_SUCCESS);
108 }
109
110 int
minor_fini(void)111 minor_fini(void)
112 {
113 check_audio_link(anynode, "audio", "sound/%d");
114 check_audio_link(anynode, "audioctl", "sound/%dctl");
115 check_audio_link(anynode, "dsp", "dsp%d");
116 anynode = DI_NODE_NIL;
117 return (DEVFSADM_SUCCESS);
118 }
119
120
121 #define COPYSUB(to, from, pm, pos) (void) strncpy(to, &from[pm[pos].rm_so], \
122 pm[pos].rm_eo - pm[pos].rm_so); \
123 to[pm[pos].rm_eo - pm[pos].rm_so] = 0;
124
125 static void
send_number(long num)126 send_number(long num)
127 {
128 char buf[PATH_MAX+1];
129
130 /*
131 * This is not safe with -r.
132 */
133 if (strcmp(devfsadm_root_path(), "/") != 0)
134 return;
135
136 (void) snprintf(buf, sizeof (buf), "/dev/mixer%ld", num);
137 if (device_exists(buf)) {
138 int fd;
139
140 if ((fd = open(buf, O_RDWR)) < 0)
141 return;
142
143 (void) ioctl(fd, SNDCTL_SUN_SEND_NUMBER, &num);
144 (void) close(fd);
145 devfsadm_print(CHATTY_MID,
146 "sent devnum audio %ld to %s\n", num, buf);
147 }
148 }
149
150 static int
sndstat_process(di_minor_t minor,di_node_t node)151 sndstat_process(di_minor_t minor, di_node_t node)
152 {
153 char *mn;
154
155 mn = di_minor_name(minor);
156 anynode = node;
157
158 /*
159 * "Special" handling for /dev/sndstat and /dev/mixer.
160 */
161 if (strcmp(mn, "sound,sndstat0") == 0) {
162 (void) devfsadm_mklink("sndstat", node, minor, 0);
163 (void) devfsadm_secondary_link("mixer", "sndstat", 0);
164 }
165
166 return (DEVFSADM_CONTINUE);
167 }
168
169 /*
170 * This function is called for every audio node.
171 * Calls enumerate to assign a logical unit id, and then
172 * devfsadm_mklink to make the link.
173 */
174 static int
audio_process(di_minor_t minor,di_node_t node)175 audio_process(di_minor_t minor, di_node_t node)
176 {
177 int flags = 0;
178 char devpath[PATH_MAX + 1];
179 char newpath[PATH_MAX + 1];
180 char *buf;
181 char *mn;
182 char *tmp;
183 char *ep;
184 char re_string[RE_SIZE+1];
185 devfsadm_enumerate_t rules[1] = {NULL};
186 char base[PATH_MAX + 1];
187 char linksrc[PATH_MAX + 1];
188 char linkdst[PATH_MAX + 1];
189 long num;
190 long inst;
191 int i;
192 char *driver;
193
194 if (system_labeled)
195 flags = DA_ADD|DA_AUDIO;
196
197 anynode = node;
198 mn = di_minor_name(minor);
199
200 if ((tmp = di_devfs_path(node)) == NULL) {
201 return (DEVFSADM_CONTINUE);
202 }
203 (void) snprintf(devpath, sizeof (devpath), "%s:%s", tmp, mn);
204 di_devfs_path_free(tmp);
205
206 if (strncmp(mn, "sound,", sizeof ("sound,") - 1) != 0) {
207 devfsadm_errprint("SUNW_audio_link: "
208 "can't find match for'%s'\n", mn);
209 return (DEVFSADM_CONTINUE);
210 }
211
212 /* strlen("sound,") */
213 (void) strlcpy(base, mn + 6, sizeof (base));
214 mn = base;
215
216 driver = di_driver_name(node);
217
218 /* if driver name override in minor name */
219 if ((tmp = strchr(mn, ',')) != NULL) {
220 driver = mn;
221 *tmp = '\0';
222 mn = tmp + 1;
223 }
224
225 /* skip past "audio" portion of the minor name */
226 if (strncmp(mn, "audio", sizeof ("audio") - 1) == 0) {
227 mn += sizeof ("audio") - 1;
228 }
229
230 /* parse the instance number */
231 for (i = strlen(mn); i; i--) {
232 if (!isdigit(mn[i - 1]))
233 break;
234 }
235 inst = strtol(mn + i, &ep, 10);
236 mn[i] = 0; /* lop off the instance number */
237
238 /*
239 * First we create a node with the driver under /dev/sound.
240 * Note that "instance numbers" used by the audio framework
241 * are guaranteed to be unique for each driver.
242 */
243 (void) snprintf(newpath, sizeof (newpath), "sound/%s:%d%s",
244 driver, inst, mn);
245 (void) devfsadm_mklink(newpath, node, minor, flags);
246
247 /*
248 * The rest of this logic is a gross simplification that is
249 * made possible by the fact that each audio node will have
250 * several different minors associated with it. Rather than
251 * processing each node separately, we just create the links
252 * all at once.
253 *
254 * This reduces the chances of the various links being out of
255 * sync with each other.
256 */
257 if (strcmp(mn, "mixer") != 0) {
258 return (DEVFSADM_CONTINUE);
259 }
260
261 /*
262 * Its the control node, so create the various
263 * secondary links.
264 */
265
266 /*
267 * We want a match against the physical path
268 * without the minor name component.
269 */
270 (void) snprintf(re_string, RE_SIZE, "%s", "^mixer([0-9]+)");
271 rules[0].re = re_string;
272 rules[0].subexp = 1;
273 rules[0].flags = MATCH_ALL;
274
275 /*
276 * enumerate finds the logical audio id, and stuffs
277 * it in buf
278 */
279 (void) strlcpy(devpath, newpath, sizeof (devpath));
280 if (devfsadm_enumerate_int(devpath, 0, &buf, rules, 1)) {
281 return (DEVFSADM_CONTINUE);
282 }
283 num = strtol(buf, &ep, 10);
284 free(buf);
285
286 /* /dev/sound/0 */
287 (void) snprintf(linksrc, sizeof (linksrc), "sound/%s:%ld",
288 driver, inst);
289 (void) snprintf(linkdst, sizeof (linkdst), "sound/%ld", num);
290 (void) devfsadm_secondary_link(linkdst, linksrc, flags);
291
292 (void) snprintf(linksrc, sizeof (linksrc), "sound/%s:%ldctl",
293 driver, inst);
294 (void) snprintf(linkdst, sizeof (linkdst), "sound/%ldctl", num);
295 (void) devfsadm_secondary_link(linkdst, linksrc, flags);
296
297 (void) snprintf(linksrc, sizeof (linksrc), "sound/%s:%lddsp",
298 driver, inst);
299 (void) snprintf(linkdst, sizeof (linkdst), "dsp%ld", num);
300 (void) devfsadm_secondary_link(linkdst, linksrc, flags);
301
302 (void) snprintf(linksrc, sizeof (linksrc), "sound/%s:%ldmixer",
303 driver, inst);
304 (void) snprintf(linkdst, sizeof (linkdst), "mixer%ld", num);
305 (void) devfsadm_secondary_link(linkdst, linksrc, flags);
306
307 /* Send control number */
308 send_number(num);
309
310 return (DEVFSADM_CONTINUE);
311 }
312
313 static void
check_audio_link(di_node_t anynode,char * secondary,const char * primary_format)314 check_audio_link(di_node_t anynode, char *secondary, const char *primary_format)
315 {
316 char primary[PATH_MAX + 1];
317 int i;
318 int flags = 0;
319
320 /* if link is present, return */
321 if (devfsadm_link_valid(anynode, secondary) == DEVFSADM_TRUE) {
322 return;
323 }
324
325 if (system_labeled)
326 flags = DA_ADD|DA_AUDIO;
327
328 for (i = 0; i < MAX_AUDIO_LINK; i++) {
329 (void) sprintf(primary, primary_format, i);
330 if (devfsadm_link_valid(anynode, primary) == DEVFSADM_TRUE) {
331 /* we read link to get it to the master "real" link */
332 (void) devfsadm_secondary_link(secondary,
333 primary, flags);
334 break;
335 }
336 }
337 }
338