2 * OSS emulation layer for the mixer interface
3 * Copyright (c) by Jaroslav Kysela <perex@perex.cz>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/time.h>
25 #include <linux/string.h>
26 #include <sound/core.h>
27 #include <sound/minors.h>
28 #include <sound/control.h>
29 #include <sound/info.h>
30 #include <sound/mixer_oss.h>
31 #include <linux/soundcard.h>
33 #define OSS_ALSAEMULVER _SIOR ('M', 249, int)
35 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
36 MODULE_DESCRIPTION("Mixer OSS emulation for ALSA.");
37 MODULE_LICENSE("GPL");
38 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_MIXER
);
40 static int snd_mixer_oss_open(struct inode
*inode
, struct file
*file
)
42 struct snd_card
*card
;
43 struct snd_mixer_oss_file
*fmixer
;
46 err
= nonseekable_open(inode
, file
);
50 card
= snd_lookup_oss_minor_data(iminor(inode
),
51 SNDRV_OSS_DEVICE_TYPE_MIXER
);
54 if (card
->mixer_oss
== NULL
)
56 err
= snd_card_file_add(card
, file
);
59 fmixer
= kzalloc(sizeof(*fmixer
), GFP_KERNEL
);
61 snd_card_file_remove(card
, file
);
65 fmixer
->mixer
= card
->mixer_oss
;
66 file
->private_data
= fmixer
;
67 if (!try_module_get(card
->module
)) {
69 snd_card_file_remove(card
, file
);
75 static int snd_mixer_oss_release(struct inode
*inode
, struct file
*file
)
77 struct snd_mixer_oss_file
*fmixer
;
79 if (file
->private_data
) {
80 fmixer
= (struct snd_mixer_oss_file
*) file
->private_data
;
81 module_put(fmixer
->card
->module
);
82 snd_card_file_remove(fmixer
->card
, file
);
88 static int snd_mixer_oss_info(struct snd_mixer_oss_file
*fmixer
,
89 mixer_info __user
*_info
)
91 struct snd_card
*card
= fmixer
->card
;
92 struct snd_mixer_oss
*mixer
= fmixer
->mixer
;
93 struct mixer_info info
;
95 memset(&info
, 0, sizeof(info
));
96 strlcpy(info
.id
, mixer
&& mixer
->id
[0] ? mixer
->id
: card
->driver
, sizeof(info
.id
));
97 strlcpy(info
.name
, mixer
&& mixer
->name
[0] ? mixer
->name
: card
->mixername
, sizeof(info
.name
));
98 info
.modify_counter
= card
->mixer_oss_change_count
;
99 if (copy_to_user(_info
, &info
, sizeof(info
)))
104 static int snd_mixer_oss_info_obsolete(struct snd_mixer_oss_file
*fmixer
,
105 _old_mixer_info __user
*_info
)
107 struct snd_card
*card
= fmixer
->card
;
108 struct snd_mixer_oss
*mixer
= fmixer
->mixer
;
109 _old_mixer_info info
;
111 memset(&info
, 0, sizeof(info
));
112 strlcpy(info
.id
, mixer
&& mixer
->id
[0] ? mixer
->id
: card
->driver
, sizeof(info
.id
));
113 strlcpy(info
.name
, mixer
&& mixer
->name
[0] ? mixer
->name
: card
->mixername
, sizeof(info
.name
));
114 if (copy_to_user(_info
, &info
, sizeof(info
)))
119 static int snd_mixer_oss_caps(struct snd_mixer_oss_file
*fmixer
)
121 struct snd_mixer_oss
*mixer
= fmixer
->mixer
;
126 if (mixer
->get_recsrc
&& mixer
->put_recsrc
)
127 result
|= SOUND_CAP_EXCL_INPUT
;
131 static int snd_mixer_oss_devmask(struct snd_mixer_oss_file
*fmixer
)
133 struct snd_mixer_oss
*mixer
= fmixer
->mixer
;
134 struct snd_mixer_oss_slot
*pslot
;
139 for (chn
= 0; chn
< 31; chn
++) {
140 pslot
= &mixer
->slots
[chn
];
141 if (pslot
->put_volume
|| pslot
->put_recsrc
)
147 static int snd_mixer_oss_stereodevs(struct snd_mixer_oss_file
*fmixer
)
149 struct snd_mixer_oss
*mixer
= fmixer
->mixer
;
150 struct snd_mixer_oss_slot
*pslot
;
155 for (chn
= 0; chn
< 31; chn
++) {
156 pslot
= &mixer
->slots
[chn
];
157 if (pslot
->put_volume
&& pslot
->stereo
)
163 static int snd_mixer_oss_recmask(struct snd_mixer_oss_file
*fmixer
)
165 struct snd_mixer_oss
*mixer
= fmixer
->mixer
;
170 if (mixer
->put_recsrc
&& mixer
->get_recsrc
) { /* exclusive */
171 result
= mixer
->mask_recsrc
;
173 struct snd_mixer_oss_slot
*pslot
;
175 for (chn
= 0; chn
< 31; chn
++) {
176 pslot
= &mixer
->slots
[chn
];
177 if (pslot
->put_recsrc
)
184 static int snd_mixer_oss_get_recsrc(struct snd_mixer_oss_file
*fmixer
)
186 struct snd_mixer_oss
*mixer
= fmixer
->mixer
;
191 if (mixer
->put_recsrc
&& mixer
->get_recsrc
) { /* exclusive */
193 if ((err
= mixer
->get_recsrc(fmixer
, &result
)) < 0)
195 result
= 1 << result
;
197 struct snd_mixer_oss_slot
*pslot
;
199 for (chn
= 0; chn
< 31; chn
++) {
200 pslot
= &mixer
->slots
[chn
];
201 if (pslot
->get_recsrc
) {
203 pslot
->get_recsrc(fmixer
, pslot
, &active
);
209 return mixer
->oss_recsrc
= result
;
212 static int snd_mixer_oss_set_recsrc(struct snd_mixer_oss_file
*fmixer
, int recsrc
)
214 struct snd_mixer_oss
*mixer
= fmixer
->mixer
;
215 struct snd_mixer_oss_slot
*pslot
;
221 if (mixer
->get_recsrc
&& mixer
->put_recsrc
) { /* exclusive input */
222 if (recsrc
& ~mixer
->oss_recsrc
)
223 recsrc
&= ~mixer
->oss_recsrc
;
224 mixer
->put_recsrc(fmixer
, ffz(~recsrc
));
225 mixer
->get_recsrc(fmixer
, &result
);
226 result
= 1 << result
;
228 for (chn
= 0; chn
< 31; chn
++) {
229 pslot
= &mixer
->slots
[chn
];
230 if (pslot
->put_recsrc
) {
231 active
= (recsrc
& (1 << chn
)) ? 1 : 0;
232 pslot
->put_recsrc(fmixer
, pslot
, active
);
236 for (chn
= 0; chn
< 31; chn
++) {
237 pslot
= &mixer
->slots
[chn
];
238 if (pslot
->get_recsrc
) {
240 pslot
->get_recsrc(fmixer
, pslot
, &active
);
249 static int snd_mixer_oss_get_volume(struct snd_mixer_oss_file
*fmixer
, int slot
)
251 struct snd_mixer_oss
*mixer
= fmixer
->mixer
;
252 struct snd_mixer_oss_slot
*pslot
;
253 int result
= 0, left
, right
;
255 if (mixer
== NULL
|| slot
> 30)
257 pslot
= &mixer
->slots
[slot
];
258 left
= pslot
->volume
[0];
259 right
= pslot
->volume
[1];
260 if (pslot
->get_volume
)
261 result
= pslot
->get_volume(fmixer
, pslot
, &left
, &right
);
264 if (snd_BUG_ON(left
< 0 || left
> 100))
266 if (snd_BUG_ON(right
< 0 || right
> 100))
269 pslot
->volume
[0] = left
;
270 pslot
->volume
[1] = right
;
271 result
= (left
& 0xff) | ((right
& 0xff) << 8);
276 static int snd_mixer_oss_set_volume(struct snd_mixer_oss_file
*fmixer
,
277 int slot
, int volume
)
279 struct snd_mixer_oss
*mixer
= fmixer
->mixer
;
280 struct snd_mixer_oss_slot
*pslot
;
281 int result
= 0, left
= volume
& 0xff, right
= (volume
>> 8) & 0xff;
283 if (mixer
== NULL
|| slot
> 30)
285 pslot
= &mixer
->slots
[slot
];
292 if (pslot
->put_volume
)
293 result
= pslot
->put_volume(fmixer
, pslot
, left
, right
);
296 pslot
->volume
[0] = left
;
297 pslot
->volume
[1] = right
;
298 return (left
& 0xff) | ((right
& 0xff) << 8);
301 static int snd_mixer_oss_ioctl1(struct snd_mixer_oss_file
*fmixer
, unsigned int cmd
, unsigned long arg
)
303 void __user
*argp
= (void __user
*)arg
;
304 int __user
*p
= argp
;
307 if (snd_BUG_ON(!fmixer
))
309 if (((cmd
>> 8) & 0xff) == 'M') {
311 case SOUND_MIXER_INFO
:
312 return snd_mixer_oss_info(fmixer
, argp
);
313 case SOUND_OLD_MIXER_INFO
:
314 return snd_mixer_oss_info_obsolete(fmixer
, argp
);
315 case SOUND_MIXER_WRITE_RECSRC
:
316 if (get_user(tmp
, p
))
318 tmp
= snd_mixer_oss_set_recsrc(fmixer
, tmp
);
321 return put_user(tmp
, p
);
323 return put_user(SNDRV_OSS_VERSION
, p
);
324 case OSS_ALSAEMULVER
:
325 return put_user(1, p
);
326 case SOUND_MIXER_READ_DEVMASK
:
327 tmp
= snd_mixer_oss_devmask(fmixer
);
330 return put_user(tmp
, p
);
331 case SOUND_MIXER_READ_STEREODEVS
:
332 tmp
= snd_mixer_oss_stereodevs(fmixer
);
335 return put_user(tmp
, p
);
336 case SOUND_MIXER_READ_RECMASK
:
337 tmp
= snd_mixer_oss_recmask(fmixer
);
340 return put_user(tmp
, p
);
341 case SOUND_MIXER_READ_CAPS
:
342 tmp
= snd_mixer_oss_caps(fmixer
);
345 return put_user(tmp
, p
);
346 case SOUND_MIXER_READ_RECSRC
:
347 tmp
= snd_mixer_oss_get_recsrc(fmixer
);
350 return put_user(tmp
, p
);
354 if (get_user(tmp
, p
))
356 tmp
= snd_mixer_oss_set_volume(fmixer
, cmd
& 0xff, tmp
);
359 return put_user(tmp
, p
);
360 } else if (cmd
& SIOC_OUT
) {
361 tmp
= snd_mixer_oss_get_volume(fmixer
, cmd
& 0xff);
364 return put_user(tmp
, p
);
369 static long snd_mixer_oss_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
371 return snd_mixer_oss_ioctl1((struct snd_mixer_oss_file
*) file
->private_data
, cmd
, arg
);
374 int snd_mixer_oss_ioctl_card(struct snd_card
*card
, unsigned int cmd
, unsigned long arg
)
376 struct snd_mixer_oss_file fmixer
;
378 if (snd_BUG_ON(!card
))
380 if (card
->mixer_oss
== NULL
)
382 memset(&fmixer
, 0, sizeof(fmixer
));
384 fmixer
.mixer
= card
->mixer_oss
;
385 return snd_mixer_oss_ioctl1(&fmixer
, cmd
, arg
);
390 #define snd_mixer_oss_ioctl_compat snd_mixer_oss_ioctl
392 #define snd_mixer_oss_ioctl_compat NULL
399 static const struct file_operations snd_mixer_oss_f_ops
=
401 .owner
= THIS_MODULE
,
402 .open
= snd_mixer_oss_open
,
403 .release
= snd_mixer_oss_release
,
405 .unlocked_ioctl
= snd_mixer_oss_ioctl
,
406 .compat_ioctl
= snd_mixer_oss_ioctl_compat
,
413 static long snd_mixer_oss_conv(long val
, long omin
, long omax
, long nmin
, long nmax
)
415 long orange
= omax
- omin
, nrange
= nmax
- nmin
;
419 return ((nrange
* (val
- omin
)) + (orange
/ 2)) / orange
+ nmin
;
422 /* convert from alsa native to oss values (0-100) */
423 static long snd_mixer_oss_conv1(long val
, long min
, long max
, int *old
)
425 if (val
== snd_mixer_oss_conv(*old
, 0, 100, min
, max
))
427 return snd_mixer_oss_conv(val
, min
, max
, 0, 100);
430 /* convert from oss to alsa native values */
431 static long snd_mixer_oss_conv2(long val
, long min
, long max
)
433 return snd_mixer_oss_conv(val
, 0, 100, min
, max
);
437 #define SNDRV_MIXER_OSS_SIGNATURE 0x65999250
439 #define SNDRV_MIXER_OSS_ITEM_GLOBAL 0
440 #define SNDRV_MIXER_OSS_ITEM_GSWITCH 1
441 #define SNDRV_MIXER_OSS_ITEM_GROUTE 2
442 #define SNDRV_MIXER_OSS_ITEM_GVOLUME 3
443 #define SNDRV_MIXER_OSS_ITEM_PSWITCH 4
444 #define SNDRV_MIXER_OSS_ITEM_PROUTE 5
445 #define SNDRV_MIXER_OSS_ITEM_PVOLUME 6
446 #define SNDRV_MIXER_OSS_ITEM_CSWITCH 7
447 #define SNDRV_MIXER_OSS_ITEM_CROUTE 8
448 #define SNDRV_MIXER_OSS_ITEM_CVOLUME 9
449 #define SNDRV_MIXER_OSS_ITEM_CAPTURE 10
451 #define SNDRV_MIXER_OSS_ITEM_COUNT 11
453 #define SNDRV_MIXER_OSS_PRESENT_GLOBAL (1<<0)
454 #define SNDRV_MIXER_OSS_PRESENT_GSWITCH (1<<1)
455 #define SNDRV_MIXER_OSS_PRESENT_GROUTE (1<<2)
456 #define SNDRV_MIXER_OSS_PRESENT_GVOLUME (1<<3)
457 #define SNDRV_MIXER_OSS_PRESENT_PSWITCH (1<<4)
458 #define SNDRV_MIXER_OSS_PRESENT_PROUTE (1<<5)
459 #define SNDRV_MIXER_OSS_PRESENT_PVOLUME (1<<6)
460 #define SNDRV_MIXER_OSS_PRESENT_CSWITCH (1<<7)
461 #define SNDRV_MIXER_OSS_PRESENT_CROUTE (1<<8)
462 #define SNDRV_MIXER_OSS_PRESENT_CVOLUME (1<<9)
463 #define SNDRV_MIXER_OSS_PRESENT_CAPTURE (1<<10)
466 unsigned int signature
;
467 unsigned int present
;
468 unsigned int channels
;
469 unsigned int numid
[SNDRV_MIXER_OSS_ITEM_COUNT
];
470 unsigned int capture_item
;
471 struct snd_mixer_oss_assign_table
*assigned
;
472 unsigned int allocated
: 1;
475 #define ID_UNKNOWN ((unsigned int)-1)
477 static struct snd_kcontrol
*snd_mixer_oss_test_id(struct snd_mixer_oss
*mixer
, const char *name
, int index
)
479 struct snd_card
*card
= mixer
->card
;
480 struct snd_ctl_elem_id id
;
482 memset(&id
, 0, sizeof(id
));
483 id
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
484 strcpy(id
.name
, name
);
486 return snd_ctl_find_id(card
, &id
);
489 static void snd_mixer_oss_get_volume1_vol(struct snd_mixer_oss_file
*fmixer
,
490 struct snd_mixer_oss_slot
*pslot
,
492 int *left
, int *right
)
494 struct snd_ctl_elem_info
*uinfo
;
495 struct snd_ctl_elem_value
*uctl
;
496 struct snd_kcontrol
*kctl
;
497 struct snd_card
*card
= fmixer
->card
;
499 if (numid
== ID_UNKNOWN
)
501 down_read(&card
->controls_rwsem
);
502 if ((kctl
= snd_ctl_find_numid(card
, numid
)) == NULL
) {
503 up_read(&card
->controls_rwsem
);
506 uinfo
= kzalloc(sizeof(*uinfo
), GFP_KERNEL
);
507 uctl
= kzalloc(sizeof(*uctl
), GFP_KERNEL
);
508 if (uinfo
== NULL
|| uctl
== NULL
)
510 if (kctl
->info(kctl
, uinfo
))
512 if (kctl
->get(kctl
, uctl
))
514 if (uinfo
->type
== SNDRV_CTL_ELEM_TYPE_BOOLEAN
&&
515 uinfo
->value
.integer
.min
== 0 && uinfo
->value
.integer
.max
== 1)
517 *left
= snd_mixer_oss_conv1(uctl
->value
.integer
.value
[0], uinfo
->value
.integer
.min
, uinfo
->value
.integer
.max
, &pslot
->volume
[0]);
518 if (uinfo
->count
> 1)
519 *right
= snd_mixer_oss_conv1(uctl
->value
.integer
.value
[1], uinfo
->value
.integer
.min
, uinfo
->value
.integer
.max
, &pslot
->volume
[1]);
521 up_read(&card
->controls_rwsem
);
526 static void snd_mixer_oss_get_volume1_sw(struct snd_mixer_oss_file
*fmixer
,
527 struct snd_mixer_oss_slot
*pslot
,
529 int *left
, int *right
,
532 struct snd_ctl_elem_info
*uinfo
;
533 struct snd_ctl_elem_value
*uctl
;
534 struct snd_kcontrol
*kctl
;
535 struct snd_card
*card
= fmixer
->card
;
537 if (numid
== ID_UNKNOWN
)
539 down_read(&card
->controls_rwsem
);
540 if ((kctl
= snd_ctl_find_numid(card
, numid
)) == NULL
) {
541 up_read(&card
->controls_rwsem
);
544 uinfo
= kzalloc(sizeof(*uinfo
), GFP_KERNEL
);
545 uctl
= kzalloc(sizeof(*uctl
), GFP_KERNEL
);
546 if (uinfo
== NULL
|| uctl
== NULL
)
548 if (kctl
->info(kctl
, uinfo
))
550 if (kctl
->get(kctl
, uctl
))
552 if (!uctl
->value
.integer
.value
[0]) {
554 if (uinfo
->count
== 1)
557 if (uinfo
->count
> 1 && !uctl
->value
.integer
.value
[route
? 3 : 1])
560 up_read(&card
->controls_rwsem
);
565 static int snd_mixer_oss_get_volume1(struct snd_mixer_oss_file
*fmixer
,
566 struct snd_mixer_oss_slot
*pslot
,
567 int *left
, int *right
)
569 struct slot
*slot
= (struct slot
*)pslot
->private_data
;
571 *left
= *right
= 100;
572 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PVOLUME
) {
573 snd_mixer_oss_get_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PVOLUME
], left
, right
);
574 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GVOLUME
) {
575 snd_mixer_oss_get_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GVOLUME
], left
, right
);
576 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GLOBAL
) {
577 snd_mixer_oss_get_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GLOBAL
], left
, right
);
579 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PSWITCH
) {
580 snd_mixer_oss_get_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PSWITCH
], left
, right
, 0);
581 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GSWITCH
) {
582 snd_mixer_oss_get_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GSWITCH
], left
, right
, 0);
583 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PROUTE
) {
584 snd_mixer_oss_get_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PROUTE
], left
, right
, 1);
585 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GROUTE
) {
586 snd_mixer_oss_get_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GROUTE
], left
, right
, 1);
591 static void snd_mixer_oss_put_volume1_vol(struct snd_mixer_oss_file
*fmixer
,
592 struct snd_mixer_oss_slot
*pslot
,
596 struct snd_ctl_elem_info
*uinfo
;
597 struct snd_ctl_elem_value
*uctl
;
598 struct snd_kcontrol
*kctl
;
599 struct snd_card
*card
= fmixer
->card
;
602 if (numid
== ID_UNKNOWN
)
604 down_read(&card
->controls_rwsem
);
605 if ((kctl
= snd_ctl_find_numid(card
, numid
)) == NULL
) {
606 up_read(&card
->controls_rwsem
);
609 uinfo
= kzalloc(sizeof(*uinfo
), GFP_KERNEL
);
610 uctl
= kzalloc(sizeof(*uctl
), GFP_KERNEL
);
611 if (uinfo
== NULL
|| uctl
== NULL
)
613 if (kctl
->info(kctl
, uinfo
))
615 if (uinfo
->type
== SNDRV_CTL_ELEM_TYPE_BOOLEAN
&&
616 uinfo
->value
.integer
.min
== 0 && uinfo
->value
.integer
.max
== 1)
618 uctl
->value
.integer
.value
[0] = snd_mixer_oss_conv2(left
, uinfo
->value
.integer
.min
, uinfo
->value
.integer
.max
);
619 if (uinfo
->count
> 1)
620 uctl
->value
.integer
.value
[1] = snd_mixer_oss_conv2(right
, uinfo
->value
.integer
.min
, uinfo
->value
.integer
.max
);
621 if ((res
= kctl
->put(kctl
, uctl
)) < 0)
624 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
, &kctl
->id
);
626 up_read(&card
->controls_rwsem
);
631 static void snd_mixer_oss_put_volume1_sw(struct snd_mixer_oss_file
*fmixer
,
632 struct snd_mixer_oss_slot
*pslot
,
637 struct snd_ctl_elem_info
*uinfo
;
638 struct snd_ctl_elem_value
*uctl
;
639 struct snd_kcontrol
*kctl
;
640 struct snd_card
*card
= fmixer
->card
;
643 if (numid
== ID_UNKNOWN
)
645 down_read(&card
->controls_rwsem
);
646 if ((kctl
= snd_ctl_find_numid(card
, numid
)) == NULL
) {
647 up_read(&card
->controls_rwsem
);
650 uinfo
= kzalloc(sizeof(*uinfo
), GFP_KERNEL
);
651 uctl
= kzalloc(sizeof(*uctl
), GFP_KERNEL
);
652 if (uinfo
== NULL
|| uctl
== NULL
)
654 if (kctl
->info(kctl
, uinfo
))
656 if (uinfo
->count
> 1) {
657 uctl
->value
.integer
.value
[0] = left
> 0 ? 1 : 0;
658 uctl
->value
.integer
.value
[route
? 3 : 1] = right
> 0 ? 1 : 0;
660 uctl
->value
.integer
.value
[1] =
661 uctl
->value
.integer
.value
[2] = 0;
664 uctl
->value
.integer
.value
[0] = (left
> 0 || right
> 0) ? 1 : 0;
666 if ((res
= kctl
->put(kctl
, uctl
)) < 0)
669 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
, &kctl
->id
);
671 up_read(&card
->controls_rwsem
);
676 static int snd_mixer_oss_put_volume1(struct snd_mixer_oss_file
*fmixer
,
677 struct snd_mixer_oss_slot
*pslot
,
680 struct slot
*slot
= (struct slot
*)pslot
->private_data
;
682 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PVOLUME
) {
683 snd_mixer_oss_put_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PVOLUME
], left
, right
);
684 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_CVOLUME
)
685 snd_mixer_oss_put_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CVOLUME
], left
, right
);
686 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_CVOLUME
) {
687 snd_mixer_oss_put_volume1_vol(fmixer
, pslot
,
688 slot
->numid
[SNDRV_MIXER_OSS_ITEM_CVOLUME
], left
, right
);
689 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GVOLUME
) {
690 snd_mixer_oss_put_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GVOLUME
], left
, right
);
691 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GLOBAL
) {
692 snd_mixer_oss_put_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GLOBAL
], left
, right
);
695 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PSWITCH
)
696 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PSWITCH
], left
, right
, 0);
697 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_CSWITCH
)
698 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CSWITCH
], left
, right
, 0);
699 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GSWITCH
)
700 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GSWITCH
], left
, right
, 0);
701 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PROUTE
)
702 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PROUTE
], left
, right
, 1);
703 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_CROUTE
)
704 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CROUTE
], left
, right
, 1);
705 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GROUTE
)
706 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GROUTE
], left
, right
, 1);
708 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PSWITCH
) {
709 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PSWITCH
], left
, right
, 0);
710 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_CSWITCH
) {
711 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CSWITCH
], left
, right
, 0);
712 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GSWITCH
) {
713 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GSWITCH
], left
, right
, 0);
714 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PROUTE
) {
715 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PROUTE
], left
, right
, 1);
716 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_CROUTE
) {
717 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CROUTE
], left
, right
, 1);
718 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GROUTE
) {
719 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GROUTE
], left
, right
, 1);
725 static int snd_mixer_oss_get_recsrc1_sw(struct snd_mixer_oss_file
*fmixer
,
726 struct snd_mixer_oss_slot
*pslot
,
729 struct slot
*slot
= (struct slot
*)pslot
->private_data
;
733 snd_mixer_oss_get_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CSWITCH
], &left
, &right
, 0);
734 *active
= (left
|| right
) ? 1 : 0;
738 static int snd_mixer_oss_get_recsrc1_route(struct snd_mixer_oss_file
*fmixer
,
739 struct snd_mixer_oss_slot
*pslot
,
742 struct slot
*slot
= (struct slot
*)pslot
->private_data
;
746 snd_mixer_oss_get_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CROUTE
], &left
, &right
, 1);
747 *active
= (left
|| right
) ? 1 : 0;
751 static int snd_mixer_oss_put_recsrc1_sw(struct snd_mixer_oss_file
*fmixer
,
752 struct snd_mixer_oss_slot
*pslot
,
755 struct slot
*slot
= (struct slot
*)pslot
->private_data
;
757 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CSWITCH
], active
, active
, 0);
761 static int snd_mixer_oss_put_recsrc1_route(struct snd_mixer_oss_file
*fmixer
,
762 struct snd_mixer_oss_slot
*pslot
,
765 struct slot
*slot
= (struct slot
*)pslot
->private_data
;
767 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CROUTE
], active
, active
, 1);
771 static int snd_mixer_oss_get_recsrc2(struct snd_mixer_oss_file
*fmixer
, unsigned int *active_index
)
773 struct snd_card
*card
= fmixer
->card
;
774 struct snd_mixer_oss
*mixer
= fmixer
->mixer
;
775 struct snd_kcontrol
*kctl
;
776 struct snd_mixer_oss_slot
*pslot
;
778 struct snd_ctl_elem_info
*uinfo
;
779 struct snd_ctl_elem_value
*uctl
;
782 uinfo
= kzalloc(sizeof(*uinfo
), GFP_KERNEL
);
783 uctl
= kzalloc(sizeof(*uctl
), GFP_KERNEL
);
784 if (uinfo
== NULL
|| uctl
== NULL
) {
788 down_read(&card
->controls_rwsem
);
789 kctl
= snd_mixer_oss_test_id(mixer
, "Capture Source", 0);
794 if ((err
= kctl
->info(kctl
, uinfo
)) < 0)
796 if ((err
= kctl
->get(kctl
, uctl
)) < 0)
798 for (idx
= 0; idx
< 32; idx
++) {
799 if (!(mixer
->mask_recsrc
& (1 << idx
)))
801 pslot
= &mixer
->slots
[idx
];
802 slot
= (struct slot
*)pslot
->private_data
;
803 if (slot
->signature
!= SNDRV_MIXER_OSS_SIGNATURE
)
805 if (!(slot
->present
& SNDRV_MIXER_OSS_PRESENT_CAPTURE
))
807 if (slot
->capture_item
== uctl
->value
.enumerated
.item
[0]) {
814 up_read(&card
->controls_rwsem
);
821 static int snd_mixer_oss_put_recsrc2(struct snd_mixer_oss_file
*fmixer
, unsigned int active_index
)
823 struct snd_card
*card
= fmixer
->card
;
824 struct snd_mixer_oss
*mixer
= fmixer
->mixer
;
825 struct snd_kcontrol
*kctl
;
826 struct snd_mixer_oss_slot
*pslot
;
827 struct slot
*slot
= NULL
;
828 struct snd_ctl_elem_info
*uinfo
;
829 struct snd_ctl_elem_value
*uctl
;
833 uinfo
= kzalloc(sizeof(*uinfo
), GFP_KERNEL
);
834 uctl
= kzalloc(sizeof(*uctl
), GFP_KERNEL
);
835 if (uinfo
== NULL
|| uctl
== NULL
) {
839 down_read(&card
->controls_rwsem
);
840 kctl
= snd_mixer_oss_test_id(mixer
, "Capture Source", 0);
845 if ((err
= kctl
->info(kctl
, uinfo
)) < 0)
847 for (idx
= 0; idx
< 32; idx
++) {
848 if (!(mixer
->mask_recsrc
& (1 << idx
)))
850 pslot
= &mixer
->slots
[idx
];
851 slot
= (struct slot
*)pslot
->private_data
;
852 if (slot
->signature
!= SNDRV_MIXER_OSS_SIGNATURE
)
854 if (!(slot
->present
& SNDRV_MIXER_OSS_PRESENT_CAPTURE
))
856 if (idx
== active_index
)
862 for (idx
= 0; idx
< uinfo
->count
; idx
++)
863 uctl
->value
.enumerated
.item
[idx
] = slot
->capture_item
;
864 err
= kctl
->put(kctl
, uctl
);
866 snd_ctl_notify(fmixer
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &kctl
->id
);
869 up_read(&card
->controls_rwsem
);
876 struct snd_mixer_oss_assign_table
{
882 static int snd_mixer_oss_build_test(struct snd_mixer_oss
*mixer
, struct slot
*slot
, const char *name
, int index
, int item
)
884 struct snd_ctl_elem_info
*info
;
885 struct snd_kcontrol
*kcontrol
;
886 struct snd_card
*card
= mixer
->card
;
889 down_read(&card
->controls_rwsem
);
890 kcontrol
= snd_mixer_oss_test_id(mixer
, name
, index
);
891 if (kcontrol
== NULL
) {
892 up_read(&card
->controls_rwsem
);
895 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
897 up_read(&card
->controls_rwsem
);
900 if ((err
= kcontrol
->info(kcontrol
, info
)) < 0) {
901 up_read(&card
->controls_rwsem
);
905 slot
->numid
[item
] = kcontrol
->id
.numid
;
906 up_read(&card
->controls_rwsem
);
907 if (info
->count
> slot
->channels
)
908 slot
->channels
= info
->count
;
909 slot
->present
|= 1 << item
;
914 static void snd_mixer_oss_slot_free(struct snd_mixer_oss_slot
*chn
)
916 struct slot
*p
= (struct slot
*)chn
->private_data
;
918 if (p
->allocated
&& p
->assigned
) {
919 kfree(p
->assigned
->name
);
926 static void mixer_slot_clear(struct snd_mixer_oss_slot
*rslot
)
928 int idx
= rslot
->number
; /* remember this */
929 if (rslot
->private_free
)
930 rslot
->private_free(rslot
);
931 memset(rslot
, 0, sizeof(*rslot
));
935 /* In a separate function to keep gcc 3.2 happy - do NOT merge this in
936 snd_mixer_oss_build_input! */
937 static int snd_mixer_oss_build_test_all(struct snd_mixer_oss
*mixer
,
938 struct snd_mixer_oss_assign_table
*ptr
,
944 err
= snd_mixer_oss_build_test(mixer
, slot
, ptr
->name
, ptr
->index
,
945 SNDRV_MIXER_OSS_ITEM_GLOBAL
);
948 sprintf(str
, "%s Switch", ptr
->name
);
949 err
= snd_mixer_oss_build_test(mixer
, slot
, str
, ptr
->index
,
950 SNDRV_MIXER_OSS_ITEM_GSWITCH
);
953 sprintf(str
, "%s Route", ptr
->name
);
954 err
= snd_mixer_oss_build_test(mixer
, slot
, str
, ptr
->index
,
955 SNDRV_MIXER_OSS_ITEM_GROUTE
);
958 sprintf(str
, "%s Volume", ptr
->name
);
959 err
= snd_mixer_oss_build_test(mixer
, slot
, str
, ptr
->index
,
960 SNDRV_MIXER_OSS_ITEM_GVOLUME
);
963 sprintf(str
, "%s Playback Switch", ptr
->name
);
964 err
= snd_mixer_oss_build_test(mixer
, slot
, str
, ptr
->index
,
965 SNDRV_MIXER_OSS_ITEM_PSWITCH
);
968 sprintf(str
, "%s Playback Route", ptr
->name
);
969 err
= snd_mixer_oss_build_test(mixer
, slot
, str
, ptr
->index
,
970 SNDRV_MIXER_OSS_ITEM_PROUTE
);
973 sprintf(str
, "%s Playback Volume", ptr
->name
);
974 err
= snd_mixer_oss_build_test(mixer
, slot
, str
, ptr
->index
,
975 SNDRV_MIXER_OSS_ITEM_PVOLUME
);
978 sprintf(str
, "%s Capture Switch", ptr
->name
);
979 err
= snd_mixer_oss_build_test(mixer
, slot
, str
, ptr
->index
,
980 SNDRV_MIXER_OSS_ITEM_CSWITCH
);
983 sprintf(str
, "%s Capture Route", ptr
->name
);
984 err
= snd_mixer_oss_build_test(mixer
, slot
, str
, ptr
->index
,
985 SNDRV_MIXER_OSS_ITEM_CROUTE
);
988 sprintf(str
, "%s Capture Volume", ptr
->name
);
989 err
= snd_mixer_oss_build_test(mixer
, slot
, str
, ptr
->index
,
990 SNDRV_MIXER_OSS_ITEM_CVOLUME
);
998 * build an OSS mixer element.
999 * ptr_allocated means the entry is dynamically allocated (change via proc file).
1000 * when replace_old = 1, the old entry is replaced with the new one.
1002 static int snd_mixer_oss_build_input(struct snd_mixer_oss
*mixer
, struct snd_mixer_oss_assign_table
*ptr
, int ptr_allocated
, int replace_old
)
1006 struct snd_kcontrol
*kctl
;
1007 struct snd_mixer_oss_slot
*rslot
;
1010 /* check if already assigned */
1011 if (mixer
->slots
[ptr
->oss_id
].get_volume
&& ! replace_old
)
1014 memset(&slot
, 0, sizeof(slot
));
1015 memset(slot
.numid
, 0xff, sizeof(slot
.numid
)); /* ID_UNKNOWN */
1016 if (snd_mixer_oss_build_test_all(mixer
, ptr
, &slot
))
1018 down_read(&mixer
->card
->controls_rwsem
);
1019 if (ptr
->index
== 0 && (kctl
= snd_mixer_oss_test_id(mixer
, "Capture Source", 0)) != NULL
) {
1020 struct snd_ctl_elem_info
*uinfo
;
1022 uinfo
= kzalloc(sizeof(*uinfo
), GFP_KERNEL
);
1024 up_read(&mixer
->card
->controls_rwsem
);
1028 if (kctl
->info(kctl
, uinfo
)) {
1029 up_read(&mixer
->card
->controls_rwsem
);
1032 strcpy(str
, ptr
->name
);
1033 if (!strcmp(str
, "Master"))
1035 if (!strcmp(str
, "Master Mono"))
1036 strcpy(str
, "Mix Mono");
1037 slot
.capture_item
= 0;
1038 if (!strcmp(uinfo
->value
.enumerated
.name
, str
)) {
1039 slot
.present
|= SNDRV_MIXER_OSS_PRESENT_CAPTURE
;
1041 for (slot
.capture_item
= 1; slot
.capture_item
< uinfo
->value
.enumerated
.items
; slot
.capture_item
++) {
1042 uinfo
->value
.enumerated
.item
= slot
.capture_item
;
1043 if (kctl
->info(kctl
, uinfo
)) {
1044 up_read(&mixer
->card
->controls_rwsem
);
1047 if (!strcmp(uinfo
->value
.enumerated
.name
, str
)) {
1048 slot
.present
|= SNDRV_MIXER_OSS_PRESENT_CAPTURE
;
1055 up_read(&mixer
->card
->controls_rwsem
);
1056 if (slot
.present
!= 0) {
1057 pslot
= kmalloc(sizeof(slot
), GFP_KERNEL
);
1061 pslot
->signature
= SNDRV_MIXER_OSS_SIGNATURE
;
1062 pslot
->assigned
= ptr
;
1063 pslot
->allocated
= ptr_allocated
;
1064 rslot
= &mixer
->slots
[ptr
->oss_id
];
1065 mixer_slot_clear(rslot
);
1066 rslot
->stereo
= slot
.channels
> 1 ? 1 : 0;
1067 rslot
->get_volume
= snd_mixer_oss_get_volume1
;
1068 rslot
->put_volume
= snd_mixer_oss_put_volume1
;
1069 /* note: ES18xx have both Capture Source and XX Capture Volume !!! */
1070 if (slot
.present
& SNDRV_MIXER_OSS_PRESENT_CSWITCH
) {
1071 rslot
->get_recsrc
= snd_mixer_oss_get_recsrc1_sw
;
1072 rslot
->put_recsrc
= snd_mixer_oss_put_recsrc1_sw
;
1073 } else if (slot
.present
& SNDRV_MIXER_OSS_PRESENT_CROUTE
) {
1074 rslot
->get_recsrc
= snd_mixer_oss_get_recsrc1_route
;
1075 rslot
->put_recsrc
= snd_mixer_oss_put_recsrc1_route
;
1076 } else if (slot
.present
& SNDRV_MIXER_OSS_PRESENT_CAPTURE
) {
1077 mixer
->mask_recsrc
|= 1 << ptr
->oss_id
;
1079 rslot
->private_data
= pslot
;
1080 rslot
->private_free
= snd_mixer_oss_slot_free
;
1086 #ifdef CONFIG_PROC_FS
1089 #define MIXER_VOL(name) [SOUND_MIXER_##name] = #name
1090 static char *oss_mixer_names
[SNDRV_OSS_MAX_MIXERS
] = {
1108 MIXER_VOL(DIGITAL1
),
1109 MIXER_VOL(DIGITAL2
),
1110 MIXER_VOL(DIGITAL3
),
1112 MIXER_VOL(PHONEOUT
),
1122 static void snd_mixer_oss_proc_read(struct snd_info_entry
*entry
,
1123 struct snd_info_buffer
*buffer
)
1125 struct snd_mixer_oss
*mixer
= entry
->private_data
;
1128 mutex_lock(&mixer
->reg_mutex
);
1129 for (i
= 0; i
< SNDRV_OSS_MAX_MIXERS
; i
++) {
1132 if (! oss_mixer_names
[i
])
1134 p
= (struct slot
*)mixer
->slots
[i
].private_data
;
1135 snd_iprintf(buffer
, "%s ", oss_mixer_names
[i
]);
1136 if (p
&& p
->assigned
)
1137 snd_iprintf(buffer
, "\"%s\" %d\n",
1139 p
->assigned
->index
);
1141 snd_iprintf(buffer
, "\"\" 0\n");
1143 mutex_unlock(&mixer
->reg_mutex
);
1146 static void snd_mixer_oss_proc_write(struct snd_info_entry
*entry
,
1147 struct snd_info_buffer
*buffer
)
1149 struct snd_mixer_oss
*mixer
= entry
->private_data
;
1150 char line
[128], str
[32], idxstr
[16];
1153 struct snd_mixer_oss_assign_table
*tbl
;
1156 while (!snd_info_get_line(buffer
, line
, sizeof(line
))) {
1157 cptr
= snd_info_get_str(str
, line
, sizeof(str
));
1158 for (ch
= 0; ch
< SNDRV_OSS_MAX_MIXERS
; ch
++)
1159 if (oss_mixer_names
[ch
] && strcmp(oss_mixer_names
[ch
], str
) == 0)
1161 if (ch
>= SNDRV_OSS_MAX_MIXERS
) {
1162 snd_printk(KERN_ERR
"mixer_oss: invalid OSS volume '%s'\n", str
);
1165 cptr
= snd_info_get_str(str
, cptr
, sizeof(str
));
1167 /* remove the entry */
1168 mutex_lock(&mixer
->reg_mutex
);
1169 mixer_slot_clear(&mixer
->slots
[ch
]);
1170 mutex_unlock(&mixer
->reg_mutex
);
1173 snd_info_get_str(idxstr
, cptr
, sizeof(idxstr
));
1174 idx
= simple_strtoul(idxstr
, NULL
, 10);
1175 if (idx
>= 0x4000) { /* too big */
1176 snd_printk(KERN_ERR
"mixer_oss: invalid index %d\n", idx
);
1179 mutex_lock(&mixer
->reg_mutex
);
1180 slot
= (struct slot
*)mixer
->slots
[ch
].private_data
;
1181 if (slot
&& slot
->assigned
&&
1182 slot
->assigned
->index
== idx
&& ! strcmp(slot
->assigned
->name
, str
))
1185 tbl
= kmalloc(sizeof(*tbl
), GFP_KERNEL
);
1187 snd_printk(KERN_ERR
"mixer_oss: no memory\n");
1191 tbl
->name
= kstrdup(str
, GFP_KERNEL
);
1197 if (snd_mixer_oss_build_input(mixer
, tbl
, 1, 1) <= 0) {
1202 mutex_unlock(&mixer
->reg_mutex
);
1206 static void snd_mixer_oss_proc_init(struct snd_mixer_oss
*mixer
)
1208 struct snd_info_entry
*entry
;
1210 entry
= snd_info_create_card_entry(mixer
->card
, "oss_mixer",
1211 mixer
->card
->proc_root
);
1214 entry
->content
= SNDRV_INFO_CONTENT_TEXT
;
1215 entry
->mode
= S_IFREG
| S_IRUGO
| S_IWUSR
;
1216 entry
->c
.text
.read
= snd_mixer_oss_proc_read
;
1217 entry
->c
.text
.write
= snd_mixer_oss_proc_write
;
1218 entry
->private_data
= mixer
;
1219 if (snd_info_register(entry
) < 0) {
1220 snd_info_free_entry(entry
);
1223 mixer
->proc_entry
= entry
;
1226 static void snd_mixer_oss_proc_done(struct snd_mixer_oss
*mixer
)
1228 snd_info_free_entry(mixer
->proc_entry
);
1229 mixer
->proc_entry
= NULL
;
1231 #else /* !CONFIG_PROC_FS */
1232 #define snd_mixer_oss_proc_init(mix)
1233 #define snd_mixer_oss_proc_done(mix)
1234 #endif /* CONFIG_PROC_FS */
1236 static void snd_mixer_oss_build(struct snd_mixer_oss
*mixer
)
1238 static struct snd_mixer_oss_assign_table table
[] = {
1239 { SOUND_MIXER_VOLUME
, "Master", 0 },
1240 { SOUND_MIXER_VOLUME
, "Front", 0 }, /* fallback */
1241 { SOUND_MIXER_BASS
, "Tone Control - Bass", 0 },
1242 { SOUND_MIXER_TREBLE
, "Tone Control - Treble", 0 },
1243 { SOUND_MIXER_SYNTH
, "Synth", 0 },
1244 { SOUND_MIXER_SYNTH
, "FM", 0 }, /* fallback */
1245 { SOUND_MIXER_SYNTH
, "Music", 0 }, /* fallback */
1246 { SOUND_MIXER_PCM
, "PCM", 0 },
1247 { SOUND_MIXER_SPEAKER
, "Beep", 0 },
1248 { SOUND_MIXER_SPEAKER
, "PC Speaker", 0 }, /* fallback */
1249 { SOUND_MIXER_SPEAKER
, "Speaker", 0 }, /* fallback */
1250 { SOUND_MIXER_LINE
, "Line", 0 },
1251 { SOUND_MIXER_MIC
, "Mic", 0 },
1252 { SOUND_MIXER_CD
, "CD", 0 },
1253 { SOUND_MIXER_IMIX
, "Monitor Mix", 0 },
1254 { SOUND_MIXER_ALTPCM
, "PCM", 1 },
1255 { SOUND_MIXER_ALTPCM
, "Headphone", 0 }, /* fallback */
1256 { SOUND_MIXER_ALTPCM
, "Wave", 0 }, /* fallback */
1257 { SOUND_MIXER_RECLEV
, "-- nothing --", 0 },
1258 { SOUND_MIXER_IGAIN
, "Capture", 0 },
1259 { SOUND_MIXER_OGAIN
, "Playback", 0 },
1260 { SOUND_MIXER_LINE1
, "Aux", 0 },
1261 { SOUND_MIXER_LINE2
, "Aux", 1 },
1262 { SOUND_MIXER_LINE3
, "Aux", 2 },
1263 { SOUND_MIXER_DIGITAL1
, "Digital", 0 },
1264 { SOUND_MIXER_DIGITAL1
, "IEC958", 0 }, /* fallback */
1265 { SOUND_MIXER_DIGITAL1
, "IEC958 Optical", 0 }, /* fallback */
1266 { SOUND_MIXER_DIGITAL1
, "IEC958 Coaxial", 0 }, /* fallback */
1267 { SOUND_MIXER_DIGITAL2
, "Digital", 1 },
1268 { SOUND_MIXER_DIGITAL3
, "Digital", 2 },
1269 { SOUND_MIXER_PHONEIN
, "Phone", 0 },
1270 { SOUND_MIXER_PHONEOUT
, "Master Mono", 0 },
1271 { SOUND_MIXER_PHONEOUT
, "Speaker", 0 }, /*fallback*/
1272 { SOUND_MIXER_PHONEOUT
, "Mono", 0 }, /*fallback*/
1273 { SOUND_MIXER_PHONEOUT
, "Phone", 0 }, /* fallback */
1274 { SOUND_MIXER_VIDEO
, "Video", 0 },
1275 { SOUND_MIXER_RADIO
, "Radio", 0 },
1276 { SOUND_MIXER_MONITOR
, "Monitor", 0 }
1280 for (idx
= 0; idx
< ARRAY_SIZE(table
); idx
++)
1281 snd_mixer_oss_build_input(mixer
, &table
[idx
], 0, 0);
1282 if (mixer
->mask_recsrc
) {
1283 mixer
->get_recsrc
= snd_mixer_oss_get_recsrc2
;
1284 mixer
->put_recsrc
= snd_mixer_oss_put_recsrc2
;
1292 static int snd_mixer_oss_free1(void *private)
1294 struct snd_mixer_oss
*mixer
= private;
1295 struct snd_card
*card
;
1301 if (snd_BUG_ON(mixer
!= card
->mixer_oss
))
1303 card
->mixer_oss
= NULL
;
1304 for (idx
= 0; idx
< SNDRV_OSS_MAX_MIXERS
; idx
++) {
1305 struct snd_mixer_oss_slot
*chn
= &mixer
->slots
[idx
];
1306 if (chn
->private_free
)
1307 chn
->private_free(chn
);
1313 static int snd_mixer_oss_notify_handler(struct snd_card
*card
, int cmd
)
1315 struct snd_mixer_oss
*mixer
;
1317 if (cmd
== SND_MIXER_OSS_NOTIFY_REGISTER
) {
1321 mixer
= kcalloc(2, sizeof(*mixer
), GFP_KERNEL
);
1324 mutex_init(&mixer
->reg_mutex
);
1325 sprintf(name
, "mixer%i%i", card
->number
, 0);
1326 if ((err
= snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER
,
1328 &snd_mixer_oss_f_ops
, card
,
1330 snd_printk(KERN_ERR
"unable to register OSS mixer device %i:%i\n",
1335 mixer
->oss_dev_alloc
= 1;
1337 if (*card
->mixername
)
1338 strlcpy(mixer
->name
, card
->mixername
, sizeof(mixer
->name
));
1340 strlcpy(mixer
->name
, name
, sizeof(mixer
->name
));
1341 #ifdef SNDRV_OSS_INFO_DEV_MIXERS
1342 snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIXERS
,
1346 for (idx
= 0; idx
< SNDRV_OSS_MAX_MIXERS
; idx
++)
1347 mixer
->slots
[idx
].number
= idx
;
1348 card
->mixer_oss
= mixer
;
1349 snd_mixer_oss_build(mixer
);
1350 snd_mixer_oss_proc_init(mixer
);
1352 mixer
= card
->mixer_oss
;
1355 if (mixer
->oss_dev_alloc
) {
1356 #ifdef SNDRV_OSS_INFO_DEV_MIXERS
1357 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIXERS
, mixer
->card
->number
);
1359 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER
, mixer
->card
, 0);
1360 mixer
->oss_dev_alloc
= 0;
1362 if (cmd
== SND_MIXER_OSS_NOTIFY_DISCONNECT
)
1364 snd_mixer_oss_proc_done(mixer
);
1365 return snd_mixer_oss_free1(mixer
);
1370 static int __init
alsa_mixer_oss_init(void)
1374 snd_mixer_oss_notify_callback
= snd_mixer_oss_notify_handler
;
1375 for (idx
= 0; idx
< SNDRV_CARDS
; idx
++) {
1377 snd_mixer_oss_notify_handler(snd_cards
[idx
], SND_MIXER_OSS_NOTIFY_REGISTER
);
1382 static void __exit
alsa_mixer_oss_exit(void)
1386 snd_mixer_oss_notify_callback
= NULL
;
1387 for (idx
= 0; idx
< SNDRV_CARDS
; idx
++) {
1389 snd_mixer_oss_notify_handler(snd_cards
[idx
], SND_MIXER_OSS_NOTIFY_FREE
);
1393 module_init(alsa_mixer_oss_init
)
1394 module_exit(alsa_mixer_oss_exit
)
1396 EXPORT_SYMBOL(snd_mixer_oss_ioctl_card
);