2 * OSS emulation layer for the mixer interface
3 * Copyright (c) by Jaroslav Kysela <perex@suse.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 <sound/driver.h>
23 #include <linux/init.h>
24 #include <linux/smp_lock.h>
25 #include <linux/slab.h>
26 #include <linux/time.h>
27 #include <sound/core.h>
28 #include <sound/minors.h>
29 #include <sound/control.h>
30 #include <sound/info.h>
31 #include <sound/mixer_oss.h>
32 #include <linux/soundcard.h>
34 #define OSS_ALSAEMULVER _SIOR ('M', 249, int)
36 MODULE_AUTHOR("Jaroslav Kysela <perex@suse.cz>");
37 MODULE_DESCRIPTION("Mixer OSS emulation for ALSA.");
38 MODULE_LICENSE("GPL");
39 MODULE_ALIAS_SNDRV_MINOR(SNDRV_MINOR_OSS_MIXER
);
41 static int snd_mixer_oss_open(struct inode
*inode
, struct file
*file
)
43 int cardnum
= SNDRV_MINOR_OSS_CARD(iminor(inode
));
45 snd_mixer_oss_file_t
*fmixer
;
48 if ((card
= snd_cards
[cardnum
]) == NULL
)
50 if (card
->mixer_oss
== NULL
)
52 err
= snd_card_file_add(card
, file
);
55 fmixer
= kcalloc(1, sizeof(*fmixer
), GFP_KERNEL
);
57 snd_card_file_remove(card
, file
);
61 fmixer
->mixer
= card
->mixer_oss
;
62 file
->private_data
= fmixer
;
63 if (!try_module_get(card
->module
)) {
65 snd_card_file_remove(card
, file
);
71 static int snd_mixer_oss_release(struct inode
*inode
, struct file
*file
)
73 snd_mixer_oss_file_t
*fmixer
;
75 if (file
->private_data
) {
76 fmixer
= (snd_mixer_oss_file_t
*) file
->private_data
;
77 module_put(fmixer
->card
->module
);
78 snd_card_file_remove(fmixer
->card
, file
);
84 static int snd_mixer_oss_info(snd_mixer_oss_file_t
*fmixer
,
85 mixer_info __user
*_info
)
87 snd_card_t
*card
= fmixer
->card
;
88 snd_mixer_oss_t
*mixer
= fmixer
->mixer
;
89 struct mixer_info info
;
91 memset(&info
, 0, sizeof(info
));
92 strlcpy(info
.id
, mixer
&& mixer
->id
[0] ? mixer
->id
: card
->driver
, sizeof(info
.id
));
93 strlcpy(info
.name
, mixer
&& mixer
->name
[0] ? mixer
->name
: card
->mixername
, sizeof(info
.name
));
94 info
.modify_counter
= card
->mixer_oss_change_count
;
95 if (copy_to_user(_info
, &info
, sizeof(info
)))
100 static int snd_mixer_oss_info_obsolete(snd_mixer_oss_file_t
*fmixer
,
101 _old_mixer_info __user
*_info
)
103 snd_card_t
*card
= fmixer
->card
;
104 snd_mixer_oss_t
*mixer
= fmixer
->mixer
;
105 _old_mixer_info info
;
107 memset(&info
, 0, sizeof(info
));
108 strlcpy(info
.id
, mixer
&& mixer
->id
[0] ? mixer
->id
: card
->driver
, sizeof(info
.id
));
109 strlcpy(info
.name
, mixer
&& mixer
->name
[0] ? mixer
->name
: card
->mixername
, sizeof(info
.name
));
110 if (copy_to_user(_info
, &info
, sizeof(info
)))
115 static int snd_mixer_oss_caps(snd_mixer_oss_file_t
*fmixer
)
117 snd_mixer_oss_t
*mixer
= fmixer
->mixer
;
122 if (mixer
->get_recsrc
&& mixer
->put_recsrc
)
123 result
|= SOUND_CAP_EXCL_INPUT
;
127 static int snd_mixer_oss_devmask(snd_mixer_oss_file_t
*fmixer
)
129 snd_mixer_oss_t
*mixer
= fmixer
->mixer
;
130 snd_mixer_oss_slot_t
*pslot
;
135 for (chn
= 0; chn
< 31; chn
++) {
136 pslot
= &mixer
->slots
[chn
];
137 if (pslot
->put_volume
|| pslot
->put_recsrc
)
143 static int snd_mixer_oss_stereodevs(snd_mixer_oss_file_t
*fmixer
)
145 snd_mixer_oss_t
*mixer
= fmixer
->mixer
;
146 snd_mixer_oss_slot_t
*pslot
;
151 for (chn
= 0; chn
< 31; chn
++) {
152 pslot
= &mixer
->slots
[chn
];
153 if (pslot
->put_volume
&& pslot
->stereo
)
159 static int snd_mixer_oss_recmask(snd_mixer_oss_file_t
*fmixer
)
161 snd_mixer_oss_t
*mixer
= fmixer
->mixer
;
166 if (mixer
->put_recsrc
&& mixer
->get_recsrc
) { /* exclusive */
167 result
= mixer
->mask_recsrc
;
169 snd_mixer_oss_slot_t
*pslot
;
171 for (chn
= 0; chn
< 31; chn
++) {
172 pslot
= &mixer
->slots
[chn
];
173 if (pslot
->put_recsrc
)
180 static int snd_mixer_oss_get_recsrc(snd_mixer_oss_file_t
*fmixer
)
182 snd_mixer_oss_t
*mixer
= fmixer
->mixer
;
187 if (mixer
->put_recsrc
&& mixer
->get_recsrc
) { /* exclusive */
189 if ((err
= mixer
->get_recsrc(fmixer
, &result
)) < 0)
191 result
= 1 << result
;
193 snd_mixer_oss_slot_t
*pslot
;
195 for (chn
= 0; chn
< 31; chn
++) {
196 pslot
= &mixer
->slots
[chn
];
197 if (pslot
->get_recsrc
) {
199 pslot
->get_recsrc(fmixer
, pslot
, &active
);
205 return mixer
->oss_recsrc
= result
;
208 static int snd_mixer_oss_set_recsrc(snd_mixer_oss_file_t
*fmixer
, int recsrc
)
210 snd_mixer_oss_t
*mixer
= fmixer
->mixer
;
211 snd_mixer_oss_slot_t
*pslot
;
217 if (mixer
->get_recsrc
&& mixer
->put_recsrc
) { /* exclusive input */
218 if (recsrc
& ~mixer
->oss_recsrc
)
219 recsrc
&= ~mixer
->oss_recsrc
;
220 mixer
->put_recsrc(fmixer
, ffz(~recsrc
));
221 mixer
->get_recsrc(fmixer
, &result
);
222 result
= 1 << result
;
224 for (chn
= 0; chn
< 31; chn
++) {
225 pslot
= &mixer
->slots
[chn
];
226 if (pslot
->put_recsrc
) {
227 active
= (recsrc
& (1 << chn
)) ? 1 : 0;
228 pslot
->put_recsrc(fmixer
, pslot
, active
);
232 for (chn
= 0; chn
< 31; chn
++) {
233 pslot
= &mixer
->slots
[chn
];
234 if (pslot
->get_recsrc
) {
236 pslot
->get_recsrc(fmixer
, pslot
, &active
);
245 static int snd_mixer_oss_get_volume(snd_mixer_oss_file_t
*fmixer
, int slot
)
247 snd_mixer_oss_t
*mixer
= fmixer
->mixer
;
248 snd_mixer_oss_slot_t
*pslot
;
249 int result
= 0, left
, right
;
251 if (mixer
== NULL
|| slot
> 30)
253 pslot
= &mixer
->slots
[slot
];
254 left
= pslot
->volume
[0];
255 right
= pslot
->volume
[1];
256 if (pslot
->get_volume
)
257 result
= pslot
->get_volume(fmixer
, pslot
, &left
, &right
);
260 snd_assert(left
>= 0 && left
<= 100, return -EIO
);
261 snd_assert(right
>= 0 && right
<= 100, return -EIO
);
263 pslot
->volume
[0] = left
;
264 pslot
->volume
[1] = right
;
265 result
= (left
& 0xff) | ((right
& 0xff) << 8);
270 static int snd_mixer_oss_set_volume(snd_mixer_oss_file_t
*fmixer
,
271 int slot
, int volume
)
273 snd_mixer_oss_t
*mixer
= fmixer
->mixer
;
274 snd_mixer_oss_slot_t
*pslot
;
275 int result
= 0, left
= volume
& 0xff, right
= (volume
>> 8) & 0xff;
277 if (mixer
== NULL
|| slot
> 30)
279 pslot
= &mixer
->slots
[slot
];
286 if (pslot
->put_volume
)
287 result
= pslot
->put_volume(fmixer
, pslot
, left
, right
);
290 pslot
->volume
[0] = left
;
291 pslot
->volume
[1] = right
;
292 return (left
& 0xff) | ((right
& 0xff) << 8);
295 static int snd_mixer_oss_ioctl1(snd_mixer_oss_file_t
*fmixer
, unsigned int cmd
, unsigned long arg
)
297 void __user
*argp
= (void __user
*)arg
;
298 int __user
*p
= argp
;
301 snd_assert(fmixer
!= NULL
, return -ENXIO
);
302 if (((cmd
>> 8) & 0xff) == 'M') {
304 case SOUND_MIXER_INFO
:
305 return snd_mixer_oss_info(fmixer
, argp
);
306 case SOUND_OLD_MIXER_INFO
:
307 return snd_mixer_oss_info_obsolete(fmixer
, argp
);
308 case SOUND_MIXER_WRITE_RECSRC
:
309 if (get_user(tmp
, p
))
311 tmp
= snd_mixer_oss_set_recsrc(fmixer
, tmp
);
314 return put_user(tmp
, p
);
316 return put_user(SNDRV_OSS_VERSION
, p
);
317 case OSS_ALSAEMULVER
:
318 return put_user(1, p
);
319 case SOUND_MIXER_READ_DEVMASK
:
320 tmp
= snd_mixer_oss_devmask(fmixer
);
323 return put_user(tmp
, p
);
324 case SOUND_MIXER_READ_STEREODEVS
:
325 tmp
= snd_mixer_oss_stereodevs(fmixer
);
328 return put_user(tmp
, p
);
329 case SOUND_MIXER_READ_RECMASK
:
330 tmp
= snd_mixer_oss_recmask(fmixer
);
333 return put_user(tmp
, p
);
334 case SOUND_MIXER_READ_CAPS
:
335 tmp
= snd_mixer_oss_caps(fmixer
);
338 return put_user(tmp
, p
);
339 case SOUND_MIXER_READ_RECSRC
:
340 tmp
= snd_mixer_oss_get_recsrc(fmixer
);
343 return put_user(tmp
, p
);
347 if (get_user(tmp
, p
))
349 tmp
= snd_mixer_oss_set_volume(fmixer
, cmd
& 0xff, tmp
);
352 return put_user(tmp
, p
);
353 } else if (cmd
& SIOC_OUT
) {
354 tmp
= snd_mixer_oss_get_volume(fmixer
, cmd
& 0xff);
357 return put_user(tmp
, p
);
362 static long snd_mixer_oss_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
364 return snd_mixer_oss_ioctl1((snd_mixer_oss_file_t
*) file
->private_data
, cmd
, arg
);
367 int snd_mixer_oss_ioctl_card(snd_card_t
*card
, unsigned int cmd
, unsigned long arg
)
369 snd_mixer_oss_file_t fmixer
;
371 snd_assert(card
!= NULL
, return -ENXIO
);
372 if (card
->mixer_oss
== NULL
)
374 memset(&fmixer
, 0, sizeof(fmixer
));
376 fmixer
.mixer
= card
->mixer_oss
;
377 return snd_mixer_oss_ioctl1(&fmixer
, cmd
, arg
);
382 #define snd_mixer_oss_ioctl_compat snd_mixer_oss_ioctl
384 #define snd_mixer_oss_ioctl_compat NULL
391 static struct file_operations snd_mixer_oss_f_ops
=
393 .owner
= THIS_MODULE
,
394 .open
= snd_mixer_oss_open
,
395 .release
= snd_mixer_oss_release
,
396 .unlocked_ioctl
= snd_mixer_oss_ioctl
,
397 .compat_ioctl
= snd_mixer_oss_ioctl_compat
,
400 static snd_minor_t snd_mixer_oss_reg
=
403 .f_ops
= &snd_mixer_oss_f_ops
,
410 static long snd_mixer_oss_conv(long val
, long omin
, long omax
, long nmin
, long nmax
)
412 long orange
= omax
- omin
, nrange
= nmax
- nmin
;
416 return ((nrange
* (val
- omin
)) + (orange
/ 2)) / orange
+ nmin
;
419 /* convert from alsa native to oss values (0-100) */
420 static long snd_mixer_oss_conv1(long val
, long min
, long max
, int *old
)
422 if (val
== snd_mixer_oss_conv(*old
, 0, 100, min
, max
))
424 return snd_mixer_oss_conv(val
, min
, max
, 0, 100);
427 /* convert from oss to alsa native values */
428 static long snd_mixer_oss_conv2(long val
, long min
, long max
)
430 return snd_mixer_oss_conv(val
, 0, 100, min
, max
);
434 static void snd_mixer_oss_recsrce_set(snd_card_t
*card
, int slot
)
436 snd_mixer_oss_t
*mixer
= card
->mixer_oss
;
438 mixer
->mask_recsrc
|= 1 << slot
;
441 static int snd_mixer_oss_recsrce_get(snd_card_t
*card
, int slot
)
443 snd_mixer_oss_t
*mixer
= card
->mixer_oss
;
444 if (mixer
&& (mixer
->mask_recsrc
& (1 << slot
)))
450 #define SNDRV_MIXER_OSS_SIGNATURE 0x65999250
452 #define SNDRV_MIXER_OSS_ITEM_GLOBAL 0
453 #define SNDRV_MIXER_OSS_ITEM_GSWITCH 1
454 #define SNDRV_MIXER_OSS_ITEM_GROUTE 2
455 #define SNDRV_MIXER_OSS_ITEM_GVOLUME 3
456 #define SNDRV_MIXER_OSS_ITEM_PSWITCH 4
457 #define SNDRV_MIXER_OSS_ITEM_PROUTE 5
458 #define SNDRV_MIXER_OSS_ITEM_PVOLUME 6
459 #define SNDRV_MIXER_OSS_ITEM_CSWITCH 7
460 #define SNDRV_MIXER_OSS_ITEM_CROUTE 8
461 #define SNDRV_MIXER_OSS_ITEM_CVOLUME 9
462 #define SNDRV_MIXER_OSS_ITEM_CAPTURE 10
464 #define SNDRV_MIXER_OSS_ITEM_COUNT 11
466 #define SNDRV_MIXER_OSS_PRESENT_GLOBAL (1<<0)
467 #define SNDRV_MIXER_OSS_PRESENT_GSWITCH (1<<1)
468 #define SNDRV_MIXER_OSS_PRESENT_GROUTE (1<<2)
469 #define SNDRV_MIXER_OSS_PRESENT_GVOLUME (1<<3)
470 #define SNDRV_MIXER_OSS_PRESENT_PSWITCH (1<<4)
471 #define SNDRV_MIXER_OSS_PRESENT_PROUTE (1<<5)
472 #define SNDRV_MIXER_OSS_PRESENT_PVOLUME (1<<6)
473 #define SNDRV_MIXER_OSS_PRESENT_CSWITCH (1<<7)
474 #define SNDRV_MIXER_OSS_PRESENT_CROUTE (1<<8)
475 #define SNDRV_MIXER_OSS_PRESENT_CVOLUME (1<<9)
476 #define SNDRV_MIXER_OSS_PRESENT_CAPTURE (1<<10)
479 unsigned int signature
;
480 unsigned int present
;
481 unsigned int channels
;
482 unsigned int numid
[SNDRV_MIXER_OSS_ITEM_COUNT
];
483 unsigned int capture_item
;
484 struct snd_mixer_oss_assign_table
*assigned
;
485 unsigned int allocated
: 1;
488 #define ID_UNKNOWN ((unsigned int)-1)
490 static snd_kcontrol_t
*snd_mixer_oss_test_id(snd_mixer_oss_t
*mixer
, const char *name
, int index
)
492 snd_card_t
* card
= mixer
->card
;
493 snd_ctl_elem_id_t id
;
495 memset(&id
, 0, sizeof(id
));
496 id
.iface
= SNDRV_CTL_ELEM_IFACE_MIXER
;
497 strcpy(id
.name
, name
);
499 return snd_ctl_find_id(card
, &id
);
502 static void snd_mixer_oss_get_volume1_vol(snd_mixer_oss_file_t
*fmixer
,
503 snd_mixer_oss_slot_t
*pslot
,
505 int *left
, int *right
)
507 snd_ctl_elem_info_t
*uinfo
;
508 snd_ctl_elem_value_t
*uctl
;
509 snd_kcontrol_t
*kctl
;
510 snd_card_t
*card
= fmixer
->card
;
512 if (numid
== ID_UNKNOWN
)
514 down_read(&card
->controls_rwsem
);
515 if ((kctl
= snd_ctl_find_numid(card
, numid
)) == NULL
) {
516 up_read(&card
->controls_rwsem
);
519 uinfo
= kcalloc(1, sizeof(*uinfo
), GFP_KERNEL
);
520 uctl
= kcalloc(1, sizeof(*uctl
), GFP_KERNEL
);
521 if (uinfo
== NULL
|| uctl
== NULL
)
523 snd_runtime_check(!kctl
->info(kctl
, uinfo
), goto __unalloc
);
524 snd_runtime_check(!kctl
->get(kctl
, uctl
), goto __unalloc
);
525 snd_runtime_check(uinfo
->type
!= SNDRV_CTL_ELEM_TYPE_BOOLEAN
|| uinfo
->value
.integer
.min
!= 0 || uinfo
->value
.integer
.max
!= 1, goto __unalloc
);
526 *left
= snd_mixer_oss_conv1(uctl
->value
.integer
.value
[0], uinfo
->value
.integer
.min
, uinfo
->value
.integer
.max
, &pslot
->volume
[0]);
527 if (uinfo
->count
> 1)
528 *right
= snd_mixer_oss_conv1(uctl
->value
.integer
.value
[1], uinfo
->value
.integer
.min
, uinfo
->value
.integer
.max
, &pslot
->volume
[1]);
530 up_read(&card
->controls_rwsem
);
535 static void snd_mixer_oss_get_volume1_sw(snd_mixer_oss_file_t
*fmixer
,
536 snd_mixer_oss_slot_t
*pslot
,
538 int *left
, int *right
,
541 snd_ctl_elem_info_t
*uinfo
;
542 snd_ctl_elem_value_t
*uctl
;
543 snd_kcontrol_t
*kctl
;
544 snd_card_t
*card
= fmixer
->card
;
546 if (numid
== ID_UNKNOWN
)
548 down_read(&card
->controls_rwsem
);
549 if ((kctl
= snd_ctl_find_numid(card
, numid
)) == NULL
) {
550 up_read(&card
->controls_rwsem
);
553 uinfo
= kcalloc(1, sizeof(*uinfo
), GFP_KERNEL
);
554 uctl
= kcalloc(1, sizeof(*uctl
), GFP_KERNEL
);
555 if (uinfo
== NULL
|| uctl
== NULL
)
557 snd_runtime_check(!kctl
->info(kctl
, uinfo
), goto __unalloc
);
558 snd_runtime_check(!kctl
->get(kctl
, uctl
), goto __unalloc
);
559 if (!uctl
->value
.integer
.value
[0]) {
561 if (uinfo
->count
== 1)
564 if (uinfo
->count
> 1 && !uctl
->value
.integer
.value
[route
? 3 : 1])
567 up_read(&card
->controls_rwsem
);
572 static int snd_mixer_oss_get_volume1(snd_mixer_oss_file_t
*fmixer
,
573 snd_mixer_oss_slot_t
*pslot
,
574 int *left
, int *right
)
576 struct slot
*slot
= (struct slot
*)pslot
->private_data
;
578 *left
= *right
= 100;
579 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PVOLUME
) {
580 snd_mixer_oss_get_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PVOLUME
], left
, right
);
581 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GVOLUME
) {
582 snd_mixer_oss_get_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GVOLUME
], left
, right
);
583 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GLOBAL
) {
584 snd_mixer_oss_get_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GLOBAL
], left
, right
);
586 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PSWITCH
) {
587 snd_mixer_oss_get_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PSWITCH
], left
, right
, 0);
588 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GSWITCH
) {
589 snd_mixer_oss_get_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GSWITCH
], left
, right
, 0);
590 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PROUTE
) {
591 snd_mixer_oss_get_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PROUTE
], left
, right
, 1);
592 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GROUTE
) {
593 snd_mixer_oss_get_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GROUTE
], left
, right
, 1);
598 static void snd_mixer_oss_put_volume1_vol(snd_mixer_oss_file_t
*fmixer
,
599 snd_mixer_oss_slot_t
*pslot
,
603 snd_ctl_elem_info_t
*uinfo
;
604 snd_ctl_elem_value_t
*uctl
;
605 snd_kcontrol_t
*kctl
;
606 snd_card_t
*card
= fmixer
->card
;
609 if (numid
== ID_UNKNOWN
)
611 down_read(&card
->controls_rwsem
);
612 if ((kctl
= snd_ctl_find_numid(card
, numid
)) == NULL
)
614 uinfo
= kcalloc(1, sizeof(*uinfo
), GFP_KERNEL
);
615 uctl
= kcalloc(1, sizeof(*uctl
), GFP_KERNEL
);
616 if (uinfo
== NULL
|| uctl
== NULL
)
618 snd_runtime_check(!kctl
->info(kctl
, uinfo
), goto __unalloc
);
619 snd_runtime_check(uinfo
->type
!= SNDRV_CTL_ELEM_TYPE_BOOLEAN
|| uinfo
->value
.integer
.min
!= 0 || uinfo
->value
.integer
.max
!= 1, goto __unalloc
);
620 uctl
->value
.integer
.value
[0] = snd_mixer_oss_conv2(left
, uinfo
->value
.integer
.min
, uinfo
->value
.integer
.max
);
621 if (uinfo
->count
> 1)
622 uctl
->value
.integer
.value
[1] = snd_mixer_oss_conv2(right
, uinfo
->value
.integer
.min
, uinfo
->value
.integer
.max
);
623 snd_runtime_check((res
= kctl
->put(kctl
, uctl
)) >= 0, goto __unalloc
);
625 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
, &kctl
->id
);
627 up_read(&card
->controls_rwsem
);
632 static void snd_mixer_oss_put_volume1_sw(snd_mixer_oss_file_t
*fmixer
,
633 snd_mixer_oss_slot_t
*pslot
,
638 snd_ctl_elem_info_t
*uinfo
;
639 snd_ctl_elem_value_t
*uctl
;
640 snd_kcontrol_t
*kctl
;
641 snd_card_t
*card
= fmixer
->card
;
644 if (numid
== ID_UNKNOWN
)
646 down_read(&card
->controls_rwsem
);
647 if ((kctl
= snd_ctl_find_numid(card
, numid
)) == NULL
) {
648 up_read(&fmixer
->card
->controls_rwsem
);
651 uinfo
= kcalloc(1, sizeof(*uinfo
), GFP_KERNEL
);
652 uctl
= kcalloc(1, sizeof(*uctl
), GFP_KERNEL
);
653 if (uinfo
== NULL
|| uctl
== NULL
)
655 snd_runtime_check(!kctl
->info(kctl
, uinfo
), goto __unalloc
);
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 snd_runtime_check((res
= kctl
->put(kctl
, uctl
)) >= 0, goto __unalloc
);
668 snd_ctl_notify(card
, SNDRV_CTL_EVENT_MASK_VALUE
, &kctl
->id
);
670 up_read(&card
->controls_rwsem
);
675 static int snd_mixer_oss_put_volume1(snd_mixer_oss_file_t
*fmixer
,
676 snd_mixer_oss_slot_t
*pslot
,
679 struct slot
*slot
= (struct slot
*)pslot
->private_data
;
681 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PVOLUME
) {
682 snd_mixer_oss_put_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PVOLUME
], left
, right
);
683 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_CVOLUME
)
684 snd_mixer_oss_put_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CVOLUME
], left
, right
);
685 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GVOLUME
) {
686 snd_mixer_oss_put_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GVOLUME
], left
, right
);
687 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GLOBAL
) {
688 snd_mixer_oss_put_volume1_vol(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GLOBAL
], left
, right
);
691 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PSWITCH
)
692 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PSWITCH
], left
, right
, 0);
693 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GSWITCH
)
694 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GSWITCH
], left
, right
, 0);
695 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PROUTE
)
696 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PROUTE
], left
, right
, 1);
697 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GROUTE
)
698 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GROUTE
], left
, right
, 1);
700 if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PSWITCH
) {
701 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PSWITCH
], left
, right
, 0);
702 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GSWITCH
) {
703 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GSWITCH
], left
, right
, 0);
704 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_PROUTE
) {
705 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_PROUTE
], left
, right
, 1);
706 } else if (slot
->present
& SNDRV_MIXER_OSS_PRESENT_GROUTE
) {
707 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_GROUTE
], left
, right
, 1);
713 static int snd_mixer_oss_get_recsrc1_sw(snd_mixer_oss_file_t
*fmixer
,
714 snd_mixer_oss_slot_t
*pslot
,
717 struct slot
*slot
= (struct slot
*)pslot
->private_data
;
721 snd_mixer_oss_get_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CSWITCH
], &left
, &right
, 0);
722 *active
= (left
|| right
) ? 1 : 0;
726 static int snd_mixer_oss_get_recsrc1_route(snd_mixer_oss_file_t
*fmixer
,
727 snd_mixer_oss_slot_t
*pslot
,
730 struct slot
*slot
= (struct slot
*)pslot
->private_data
;
734 snd_mixer_oss_get_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CROUTE
], &left
, &right
, 1);
735 *active
= (left
|| right
) ? 1 : 0;
739 static int snd_mixer_oss_put_recsrc1_sw(snd_mixer_oss_file_t
*fmixer
,
740 snd_mixer_oss_slot_t
*pslot
,
743 struct slot
*slot
= (struct slot
*)pslot
->private_data
;
745 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CSWITCH
], active
, active
, 0);
749 static int snd_mixer_oss_put_recsrc1_route(snd_mixer_oss_file_t
*fmixer
,
750 snd_mixer_oss_slot_t
*pslot
,
753 struct slot
*slot
= (struct slot
*)pslot
->private_data
;
755 snd_mixer_oss_put_volume1_sw(fmixer
, pslot
, slot
->numid
[SNDRV_MIXER_OSS_ITEM_CROUTE
], active
, active
, 1);
759 static int snd_mixer_oss_get_recsrc2(snd_mixer_oss_file_t
*fmixer
, unsigned int *active_index
)
761 snd_card_t
*card
= fmixer
->card
;
762 snd_mixer_oss_t
*mixer
= fmixer
->mixer
;
763 snd_kcontrol_t
*kctl
;
764 snd_mixer_oss_slot_t
*pslot
;
766 snd_ctl_elem_info_t
*uinfo
;
767 snd_ctl_elem_value_t
*uctl
;
770 uinfo
= kcalloc(1, sizeof(*uinfo
), GFP_KERNEL
);
771 uctl
= kcalloc(1, sizeof(*uctl
), GFP_KERNEL
);
772 if (uinfo
== NULL
|| uctl
== NULL
) {
776 down_read(&card
->controls_rwsem
);
777 kctl
= snd_mixer_oss_test_id(mixer
, "Capture Source", 0);
778 snd_runtime_check(kctl
!= NULL
, err
= -ENOENT
; goto __unlock
);
779 snd_runtime_check(!(err
= kctl
->info(kctl
, uinfo
)), goto __unlock
);
780 snd_runtime_check(!(err
= kctl
->get(kctl
, uctl
)), goto __unlock
);
781 for (idx
= 0; idx
< 32; idx
++) {
782 if (!(mixer
->mask_recsrc
& (1 << idx
)))
784 pslot
= &mixer
->slots
[idx
];
785 slot
= (struct slot
*)pslot
->private_data
;
786 if (slot
->signature
!= SNDRV_MIXER_OSS_SIGNATURE
)
788 if (!(slot
->present
& SNDRV_MIXER_OSS_PRESENT_CAPTURE
))
790 if (slot
->capture_item
== uctl
->value
.enumerated
.item
[0]) {
797 up_read(&card
->controls_rwsem
);
803 static int snd_mixer_oss_put_recsrc2(snd_mixer_oss_file_t
*fmixer
, unsigned int active_index
)
805 snd_card_t
*card
= fmixer
->card
;
806 snd_mixer_oss_t
*mixer
= fmixer
->mixer
;
807 snd_kcontrol_t
*kctl
;
808 snd_mixer_oss_slot_t
*pslot
;
809 struct slot
*slot
= NULL
;
810 snd_ctl_elem_info_t
*uinfo
;
811 snd_ctl_elem_value_t
*uctl
;
815 uinfo
= kcalloc(1, sizeof(*uinfo
), GFP_KERNEL
);
816 uctl
= kcalloc(1, sizeof(*uctl
), GFP_KERNEL
);
817 if (uinfo
== NULL
|| uctl
== NULL
) {
821 down_read(&card
->controls_rwsem
);
822 kctl
= snd_mixer_oss_test_id(mixer
, "Capture Source", 0);
823 snd_runtime_check(kctl
!= NULL
, err
= -ENOENT
; goto __unlock
);
824 snd_runtime_check(!(err
= kctl
->info(kctl
, uinfo
)), goto __unlock
);
825 for (idx
= 0; idx
< 32; idx
++) {
826 if (!(mixer
->mask_recsrc
& (1 << idx
)))
828 pslot
= &mixer
->slots
[idx
];
829 slot
= (struct slot
*)pslot
->private_data
;
830 if (slot
->signature
!= SNDRV_MIXER_OSS_SIGNATURE
)
832 if (!(slot
->present
& SNDRV_MIXER_OSS_PRESENT_CAPTURE
))
834 if (idx
== active_index
)
838 snd_runtime_check(slot
!= NULL
, goto __unlock
);
839 for (idx
= 0; idx
< uinfo
->count
; idx
++)
840 uctl
->value
.enumerated
.item
[idx
] = slot
->capture_item
;
841 snd_runtime_check((err
= kctl
->put(kctl
, uctl
)) >= 0, );
843 snd_ctl_notify(fmixer
->card
, SNDRV_CTL_EVENT_MASK_VALUE
, &kctl
->id
);
846 up_read(&card
->controls_rwsem
);
852 struct snd_mixer_oss_assign_table
{
858 static int snd_mixer_oss_build_test(snd_mixer_oss_t
*mixer
, struct slot
*slot
, const char *name
, int index
, int item
)
860 snd_ctl_elem_info_t
*info
;
861 snd_kcontrol_t
*kcontrol
;
862 snd_card_t
*card
= mixer
->card
;
865 down_read(&card
->controls_rwsem
);
866 kcontrol
= snd_mixer_oss_test_id(mixer
, name
, index
);
867 if (kcontrol
== NULL
) {
868 up_read(&card
->controls_rwsem
);
871 info
= kmalloc(sizeof(*info
), GFP_KERNEL
);
873 up_read(&card
->controls_rwsem
);
876 if ((err
= kcontrol
->info(kcontrol
, info
)) < 0) {
877 up_read(&card
->controls_rwsem
);
881 slot
->numid
[item
] = kcontrol
->id
.numid
;
882 up_read(&card
->controls_rwsem
);
883 if (info
->count
> slot
->channels
)
884 slot
->channels
= info
->count
;
885 slot
->present
|= 1 << item
;
890 static void snd_mixer_oss_slot_free(snd_mixer_oss_slot_t
*chn
)
892 struct slot
*p
= (struct slot
*)chn
->private_data
;
894 if (p
->allocated
&& p
->assigned
) {
895 kfree(p
->assigned
->name
);
902 static void mixer_slot_clear(snd_mixer_oss_slot_t
*rslot
)
904 int idx
= rslot
->number
; /* remember this */
905 if (rslot
->private_free
)
906 rslot
->private_free(rslot
);
907 memset(rslot
, 0, sizeof(*rslot
));
912 * build an OSS mixer element.
913 * ptr_allocated means the entry is dynamically allocated (change via proc file).
914 * when replace_old = 1, the old entry is replaced with the new one.
916 static int snd_mixer_oss_build_input(snd_mixer_oss_t
*mixer
, struct snd_mixer_oss_assign_table
*ptr
, int ptr_allocated
, int replace_old
)
920 snd_kcontrol_t
*kctl
;
921 snd_mixer_oss_slot_t
*rslot
;
924 /* check if already assigned */
925 if (mixer
->slots
[ptr
->oss_id
].get_volume
&& ! replace_old
)
928 memset(&slot
, 0, sizeof(slot
));
929 memset(slot
.numid
, 0xff, sizeof(slot
.numid
)); /* ID_UNKNOWN */
930 if (snd_mixer_oss_build_test(mixer
, &slot
, ptr
->name
, ptr
->index
,
931 SNDRV_MIXER_OSS_ITEM_GLOBAL
))
933 sprintf(str
, "%s Switch", ptr
->name
);
934 if (snd_mixer_oss_build_test(mixer
, &slot
, str
, ptr
->index
,
935 SNDRV_MIXER_OSS_ITEM_GSWITCH
))
937 sprintf(str
, "%s Route", ptr
->name
);
938 if (snd_mixer_oss_build_test(mixer
, &slot
, str
, ptr
->index
,
939 SNDRV_MIXER_OSS_ITEM_GROUTE
))
941 sprintf(str
, "%s Volume", ptr
->name
);
942 if (snd_mixer_oss_build_test(mixer
, &slot
, str
, ptr
->index
,
943 SNDRV_MIXER_OSS_ITEM_GVOLUME
))
945 sprintf(str
, "%s Playback Switch", ptr
->name
);
946 if (snd_mixer_oss_build_test(mixer
, &slot
, str
, ptr
->index
,
947 SNDRV_MIXER_OSS_ITEM_PSWITCH
))
949 sprintf(str
, "%s Playback Route", ptr
->name
);
950 if (snd_mixer_oss_build_test(mixer
, &slot
, str
, ptr
->index
,
951 SNDRV_MIXER_OSS_ITEM_PROUTE
))
953 sprintf(str
, "%s Playback Volume", ptr
->name
);
954 if (snd_mixer_oss_build_test(mixer
, &slot
, str
, ptr
->index
,
955 SNDRV_MIXER_OSS_ITEM_PVOLUME
))
957 sprintf(str
, "%s Capture Switch", ptr
->name
);
958 if (snd_mixer_oss_build_test(mixer
, &slot
, str
, ptr
->index
,
959 SNDRV_MIXER_OSS_ITEM_CSWITCH
))
961 sprintf(str
, "%s Capture Route", ptr
->name
);
962 if (snd_mixer_oss_build_test(mixer
, &slot
, str
, ptr
->index
,
963 SNDRV_MIXER_OSS_ITEM_CROUTE
))
965 sprintf(str
, "%s Capture Volume", ptr
->name
);
966 if (snd_mixer_oss_build_test(mixer
, &slot
, str
, ptr
->index
,
967 SNDRV_MIXER_OSS_ITEM_CVOLUME
))
969 down_read(&mixer
->card
->controls_rwsem
);
970 if (ptr
->index
== 0 && (kctl
= snd_mixer_oss_test_id(mixer
, "Capture Source", 0)) != NULL
) {
971 snd_ctl_elem_info_t
*uinfo
;
973 uinfo
= kmalloc(sizeof(*uinfo
), GFP_KERNEL
);
975 up_read(&mixer
->card
->controls_rwsem
);
979 memset(uinfo
, 0, sizeof(*uinfo
));
980 if (kctl
->info(kctl
, uinfo
)) {
981 up_read(&mixer
->card
->controls_rwsem
);
984 strcpy(str
, ptr
->name
);
985 if (!strcmp(str
, "Master"))
987 if (!strcmp(str
, "Master Mono"))
988 strcpy(str
, "Mix Mono");
989 slot
.capture_item
= 0;
990 if (!strcmp(uinfo
->value
.enumerated
.name
, str
)) {
991 slot
.present
|= SNDRV_MIXER_OSS_PRESENT_CAPTURE
;
993 for (slot
.capture_item
= 1; slot
.capture_item
< uinfo
->value
.enumerated
.items
; slot
.capture_item
++) {
994 uinfo
->value
.enumerated
.item
= slot
.capture_item
;
995 if (kctl
->info(kctl
, uinfo
)) {
996 up_read(&mixer
->card
->controls_rwsem
);
999 if (!strcmp(uinfo
->value
.enumerated
.name
, str
)) {
1000 slot
.present
|= SNDRV_MIXER_OSS_PRESENT_CAPTURE
;
1007 up_read(&mixer
->card
->controls_rwsem
);
1008 if (slot
.present
!= 0) {
1009 pslot
= (struct slot
*)kmalloc(sizeof(slot
), GFP_KERNEL
);
1010 snd_runtime_check(pslot
!= NULL
, return -ENOMEM
);
1012 pslot
->signature
= SNDRV_MIXER_OSS_SIGNATURE
;
1013 pslot
->assigned
= ptr
;
1014 pslot
->allocated
= ptr_allocated
;
1015 rslot
= &mixer
->slots
[ptr
->oss_id
];
1016 mixer_slot_clear(rslot
);
1017 rslot
->stereo
= slot
.channels
> 1 ? 1 : 0;
1018 rslot
->get_volume
= snd_mixer_oss_get_volume1
;
1019 rslot
->put_volume
= snd_mixer_oss_put_volume1
;
1020 /* note: ES18xx have both Capture Source and XX Capture Volume !!! */
1021 if (slot
.present
& SNDRV_MIXER_OSS_PRESENT_CSWITCH
) {
1022 rslot
->get_recsrc
= snd_mixer_oss_get_recsrc1_sw
;
1023 rslot
->put_recsrc
= snd_mixer_oss_put_recsrc1_sw
;
1024 } else if (slot
.present
& SNDRV_MIXER_OSS_PRESENT_CROUTE
) {
1025 rslot
->get_recsrc
= snd_mixer_oss_get_recsrc1_route
;
1026 rslot
->put_recsrc
= snd_mixer_oss_put_recsrc1_route
;
1027 } else if (slot
.present
& SNDRV_MIXER_OSS_PRESENT_CAPTURE
) {
1028 mixer
->mask_recsrc
|= 1 << ptr
->oss_id
;
1030 rslot
->private_data
= pslot
;
1031 rslot
->private_free
= snd_mixer_oss_slot_free
;
1039 #define MIXER_VOL(name) [SOUND_MIXER_##name] = #name
1040 static char *oss_mixer_names
[SNDRV_OSS_MAX_MIXERS
] = {
1058 MIXER_VOL(DIGITAL1
),
1059 MIXER_VOL(DIGITAL2
),
1060 MIXER_VOL(DIGITAL3
),
1062 MIXER_VOL(PHONEOUT
),
1072 static void snd_mixer_oss_proc_read(snd_info_entry_t
*entry
,
1073 snd_info_buffer_t
* buffer
)
1075 snd_mixer_oss_t
*mixer
= entry
->private_data
;
1078 down(&mixer
->reg_mutex
);
1079 for (i
= 0; i
< SNDRV_OSS_MAX_MIXERS
; i
++) {
1082 if (! oss_mixer_names
[i
])
1084 p
= (struct slot
*)mixer
->slots
[i
].private_data
;
1085 snd_iprintf(buffer
, "%s ", oss_mixer_names
[i
]);
1086 if (p
&& p
->assigned
)
1087 snd_iprintf(buffer
, "\"%s\" %d\n",
1089 p
->assigned
->index
);
1091 snd_iprintf(buffer
, "\"\" 0\n");
1093 up(&mixer
->reg_mutex
);
1096 static void snd_mixer_oss_proc_write(snd_info_entry_t
*entry
,
1097 snd_info_buffer_t
* buffer
)
1099 snd_mixer_oss_t
*mixer
= entry
->private_data
;
1100 char line
[128], str
[32], idxstr
[16], *cptr
;
1102 struct snd_mixer_oss_assign_table
*tbl
;
1105 while (!snd_info_get_line(buffer
, line
, sizeof(line
))) {
1106 cptr
= snd_info_get_str(str
, line
, sizeof(str
));
1107 for (ch
= 0; ch
< SNDRV_OSS_MAX_MIXERS
; ch
++)
1108 if (oss_mixer_names
[ch
] && strcmp(oss_mixer_names
[ch
], str
) == 0)
1110 if (ch
>= SNDRV_OSS_MAX_MIXERS
) {
1111 snd_printk(KERN_ERR
"mixer_oss: invalid OSS volume '%s'\n", str
);
1114 cptr
= snd_info_get_str(str
, cptr
, sizeof(str
));
1116 /* remove the entry */
1117 down(&mixer
->reg_mutex
);
1118 mixer_slot_clear(&mixer
->slots
[ch
]);
1119 up(&mixer
->reg_mutex
);
1122 snd_info_get_str(idxstr
, cptr
, sizeof(idxstr
));
1123 idx
= simple_strtoul(idxstr
, NULL
, 10);
1124 if (idx
>= 0x4000) { /* too big */
1125 snd_printk(KERN_ERR
"mixer_oss: invalid index %d\n", idx
);
1128 down(&mixer
->reg_mutex
);
1129 slot
= (struct slot
*)mixer
->slots
[ch
].private_data
;
1130 if (slot
&& slot
->assigned
&&
1131 slot
->assigned
->index
== idx
&& ! strcmp(slot
->assigned
->name
, str
))
1134 tbl
= kmalloc(sizeof(*tbl
), GFP_KERNEL
);
1136 snd_printk(KERN_ERR
"mixer_oss: no memory\n");
1140 tbl
->name
= snd_kmalloc_strdup(str
, GFP_KERNEL
);
1146 if (snd_mixer_oss_build_input(mixer
, tbl
, 1, 1) <= 0) {
1151 up(&mixer
->reg_mutex
);
1155 static void snd_mixer_oss_proc_init(snd_mixer_oss_t
*mixer
)
1157 snd_info_entry_t
*entry
;
1159 entry
= snd_info_create_card_entry(mixer
->card
, "oss_mixer",
1160 mixer
->card
->proc_root
);
1163 entry
->content
= SNDRV_INFO_CONTENT_TEXT
;
1164 entry
->mode
= S_IFREG
| S_IRUGO
| S_IWUSR
;
1165 entry
->c
.text
.read_size
= 8192;
1166 entry
->c
.text
.read
= snd_mixer_oss_proc_read
;
1167 entry
->c
.text
.write_size
= 8192;
1168 entry
->c
.text
.write
= snd_mixer_oss_proc_write
;
1169 entry
->private_data
= mixer
;
1170 if (snd_info_register(entry
) < 0) {
1171 snd_info_free_entry(entry
);
1174 mixer
->proc_entry
= entry
;
1177 static void snd_mixer_oss_proc_done(snd_mixer_oss_t
*mixer
)
1179 if (mixer
->proc_entry
) {
1180 snd_info_unregister(mixer
->proc_entry
);
1181 mixer
->proc_entry
= NULL
;
1185 static void snd_mixer_oss_build(snd_mixer_oss_t
*mixer
)
1187 static struct snd_mixer_oss_assign_table table
[] = {
1188 { SOUND_MIXER_VOLUME
, "Master", 0 },
1189 { SOUND_MIXER_VOLUME
, "Front", 0 }, /* fallback */
1190 { SOUND_MIXER_BASS
, "Tone Control - Bass", 0 },
1191 { SOUND_MIXER_TREBLE
, "Tone Control - Treble", 0 },
1192 { SOUND_MIXER_SYNTH
, "Synth", 0 },
1193 { SOUND_MIXER_SYNTH
, "FM", 0 }, /* fallback */
1194 { SOUND_MIXER_SYNTH
, "Music", 0 }, /* fallback */
1195 { SOUND_MIXER_PCM
, "PCM", 0 },
1196 { SOUND_MIXER_SPEAKER
, "PC Speaker", 0 },
1197 { SOUND_MIXER_LINE
, "Line", 0 },
1198 { SOUND_MIXER_MIC
, "Mic", 0 },
1199 { SOUND_MIXER_CD
, "CD", 0 },
1200 { SOUND_MIXER_IMIX
, "Monitor Mix", 0 },
1201 { SOUND_MIXER_ALTPCM
, "PCM", 1 },
1202 { SOUND_MIXER_ALTPCM
, "Headphone", 0 }, /* fallback */
1203 { SOUND_MIXER_ALTPCM
, "Wave", 0 }, /* fallback */
1204 { SOUND_MIXER_RECLEV
, "-- nothing --", 0 },
1205 { SOUND_MIXER_IGAIN
, "Capture", 0 },
1206 { SOUND_MIXER_OGAIN
, "Playback", 0 },
1207 { SOUND_MIXER_LINE1
, "Aux", 0 },
1208 { SOUND_MIXER_LINE2
, "Aux", 1 },
1209 { SOUND_MIXER_LINE3
, "Aux", 2 },
1210 { SOUND_MIXER_DIGITAL1
, "Digital", 0 },
1211 { SOUND_MIXER_DIGITAL1
, "IEC958", 0 }, /* fallback */
1212 { SOUND_MIXER_DIGITAL1
, "IEC958 Optical", 0 }, /* fallback */
1213 { SOUND_MIXER_DIGITAL1
, "IEC958 Coaxial", 0 }, /* fallback */
1214 { SOUND_MIXER_DIGITAL2
, "Digital", 1 },
1215 { SOUND_MIXER_DIGITAL3
, "Digital", 2 },
1216 { SOUND_MIXER_PHONEIN
, "Phone", 0 },
1217 { SOUND_MIXER_PHONEOUT
, "Master Mono", 0 },
1218 { SOUND_MIXER_PHONEOUT
, "Phone", 0 }, /* fallback */
1219 { SOUND_MIXER_VIDEO
, "Video", 0 },
1220 { SOUND_MIXER_RADIO
, "Radio", 0 },
1221 { SOUND_MIXER_MONITOR
, "Monitor", 0 }
1225 for (idx
= 0; idx
< ARRAY_SIZE(table
); idx
++)
1226 snd_mixer_oss_build_input(mixer
, &table
[idx
], 0, 0);
1227 if (mixer
->mask_recsrc
) {
1228 mixer
->get_recsrc
= snd_mixer_oss_get_recsrc2
;
1229 mixer
->put_recsrc
= snd_mixer_oss_put_recsrc2
;
1237 static int snd_mixer_oss_free1(void *private)
1239 snd_mixer_oss_t
*mixer
= private;
1243 snd_assert(mixer
!= NULL
, return -ENXIO
);
1245 snd_assert(mixer
== card
->mixer_oss
, return -ENXIO
);
1246 card
->mixer_oss
= NULL
;
1247 for (idx
= 0; idx
< SNDRV_OSS_MAX_MIXERS
; idx
++) {
1248 snd_mixer_oss_slot_t
*chn
= &mixer
->slots
[idx
];
1249 if (chn
->private_free
)
1250 chn
->private_free(chn
);
1256 static int snd_mixer_oss_notify_handler(snd_card_t
* card
, int cmd
)
1258 snd_mixer_oss_t
*mixer
;
1260 if (cmd
== SND_MIXER_OSS_NOTIFY_REGISTER
) {
1264 mixer
= kcalloc(2, sizeof(*mixer
), GFP_KERNEL
);
1267 init_MUTEX(&mixer
->reg_mutex
);
1268 sprintf(name
, "mixer%i%i", card
->number
, 0);
1269 if ((err
= snd_register_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER
,
1273 snd_printk("unable to register OSS mixer device %i:%i\n", card
->number
, 0);
1277 mixer
->oss_dev_alloc
= 1;
1279 if (*card
->mixername
)
1280 strlcpy(mixer
->name
, card
->mixername
, sizeof(mixer
->name
));
1282 strlcpy(mixer
->name
, name
, sizeof(mixer
->name
));
1283 #ifdef SNDRV_OSS_INFO_DEV_MIXERS
1284 snd_oss_info_register(SNDRV_OSS_INFO_DEV_MIXERS
,
1288 for (idx
= 0; idx
< SNDRV_OSS_MAX_MIXERS
; idx
++)
1289 mixer
->slots
[idx
].number
= idx
;
1290 card
->mixer_oss
= mixer
;
1291 snd_mixer_oss_build(mixer
);
1292 snd_mixer_oss_proc_init(mixer
);
1293 } else if (cmd
== SND_MIXER_OSS_NOTIFY_DISCONNECT
) {
1294 mixer
= card
->mixer_oss
;
1295 if (mixer
== NULL
|| !mixer
->oss_dev_alloc
)
1297 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER
, mixer
->card
, 0);
1298 mixer
->oss_dev_alloc
= 0;
1300 mixer
= card
->mixer_oss
;
1303 #ifdef SNDRV_OSS_INFO_DEV_MIXERS
1304 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_MIXERS
, mixer
->card
->number
);
1306 if (mixer
->oss_dev_alloc
)
1307 snd_unregister_oss_device(SNDRV_OSS_DEVICE_TYPE_MIXER
, mixer
->card
, 0);
1308 snd_mixer_oss_proc_done(mixer
);
1309 return snd_mixer_oss_free1(mixer
);
1314 static int __init
alsa_mixer_oss_init(void)
1318 snd_mixer_oss_notify_callback
= snd_mixer_oss_notify_handler
;
1319 for (idx
= 0; idx
< SNDRV_CARDS
; idx
++) {
1321 snd_mixer_oss_notify_handler(snd_cards
[idx
], SND_MIXER_OSS_NOTIFY_REGISTER
);
1326 static void __exit
alsa_mixer_oss_exit(void)
1330 snd_mixer_oss_notify_callback
= NULL
;
1331 for (idx
= 0; idx
< SNDRV_CARDS
; idx
++) {
1333 snd_mixer_oss_notify_handler(snd_cards
[idx
], SND_MIXER_OSS_NOTIFY_FREE
);
1337 module_init(alsa_mixer_oss_init
)
1338 module_exit(alsa_mixer_oss_exit
)
1340 EXPORT_SYMBOL(snd_mixer_oss_ioctl_card
);