Context Navigation

source: GPL/trunk/lib32/soundmixer.c@ 479

Last change on this file since 479 was 479, checked in by David Azarewicz, 15 years ago
Cleanup compiler warnings
File size: 34.3 KB

Line
1	/* $Id: soundmixer.c,v 1.1.1.1 2003/07/02 13:57:02 eleph Exp $ */
2	/*
3	* MMPM/2 to OSS interface translation layer
4	*
5	* (C) 2000-2002 InnoTek Systemberatung GmbH
6	* (C) 2000-2001 Sander van Leeuwen (sandervl@xs4all.nl)
7	*
8	* This program is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU General Public License as
10	* published by the Free Software Foundation; either version 2 of
11	* the License, or (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public
19	* License along with this program; if not, write to the Free
20	* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
21	* USA.
22	*
23	*/
24
25	#include <sound/core.h>
26	#include <sound/control.h>
27	#include <sound/info.h>
28	#include <sound/pcm.h>
29	#include <sound/pcm_params.h>
30	#include <sound/minors.h>
31	#include <linux/file.h>
32	#include <linux/soundcard.h>
33
34	#define LINUX
35	#include <ossidc32.h>
36	#include <stacktoflat.h>
37	#include <stdlib.h>
38	#include "soundoss.h"
39
40	extern OpenedHandles opened_handles[8 * 256]; // from sound.c
41
42	static struct {
43	char *name;
44	unsigned int index;
45	unsigned int recsrc;
46	} ossid[OSS_MIXER_NRDEVICES] = {
47	/* OSS_MIXER_VOLUME */ { "Master", 0 , -1},
48	/* OSS_MIXER_BASS */ { "Tone Control - Bass", 0, -1},
49	/* OSS_MIXER_TREBLE */ { "Tone Control - Treble", 0, -1},
50	/* OSS_MIXER_SYNTH */ { "Synth", 0 , OSS32_MIX_RECSRC_SYNTH},
51	/* OSS_MIXER_PCM */ { "PCM", 0 , -1},
52	/* OSS_MIXER_PCSPEAKER */ { "PC Speaker", 0 , -1},
53	/* OSS_MIXER_LINE */ { "Line", 0 , OSS32_MIX_RECSRC_LINE},
54	/* OSS_MIXER_MIC */ { "Mic", 0, OSS32_MIX_RECSRC_MIC},
55	/* OSS_MIXER_CD */ { "CD", 0 , OSS32_MIX_RECSRC_CD},
56	/* OSS_MIXER_IMIX */ { "Monitor Mix", 0 , OSS32_MIX_RECSRC_MIXER},
57	/* OSS_MIXER_ALTPCM */ { "PCM", 1 , -1},
58	/* OSS_MIXER_RECLEV */ { "-- nothing --", 0 , -1},
59	/* OSS_MIXER_IGAIN */ { "Capture", 0 , -1},
60	/* OSS_MIXER_OGAIN */ { "Playback", 0 , -1},
61	/* OSS_MIXER_LINE1 */ { "Aux", 0 , OSS32_MIX_RECSRC_AUX},
62	/* OSS_MIXER_LINE2 */ { "Aux", 1 , -1},
63	/* OSS_MIXER_LINE3 */ { "Aux", 2 , -1},
64	/* OSS_MIXER_DIGITAL1 */ { "Digital", 0 , -1},
65	/* OSS_MIXER_DIGITAL2 */ { "Digital", 1 , -1},
66	/* OSS_MIXER_DIGITAL3 */ { "Digital", 2 , -1},
67	/* OSS_MIXER_PHONEIN */ { "Phone", 0 , OSS32_MIX_RECSRC_PHONE},
68	/* OSS_MIXER_PHONEOUT */ { "Phone", 1 , -1},
69	/* OSS_MIXER_VIDEO */ { "Video", 0 , OSS32_MIX_RECSRC_VIDEO},
70	/* OSS_MIXER_RADIO */ { "Radio", 0 , -1},
71	/* OSS_MIXER_MONITOR */ { "Monitor", 0 , -1},
72	/* OSS_MIXER_3DDEPTH */ { "3D Control - Depth", 0 , -1},
73	/* OSS_MIXER_3DCENTER */ { "3D Control - Center", 0 , -1},
74	/* OSS_MIXER_FRONT */ { "Front", 0 , -1},
75	/* OSS_MIXER_SPEAKER */ { "Speaker", 0 , -1},
76	/* OSS_MIXER_HEADPHONE */ { "Headphone", 0 , -1},
77	};
78	char *szRecSources[OSS32_MIX_RECSRC_MAX] = {
79	"Mic", "CD", "Line", "Video", "Aux", "Mix", "Mix Mono", "Phone", "Synth"
80	};
81
82	static unsigned char LinToLog[OSS32_MAX_VOLUME+1] = {
83	0, 0, 0, 0, 1, 2, 2, 5, 5, 10,
84	10, 10, 16, 19, 20, 22, 24, 25, 27, 27,
85	28, 28, 29, 30, 30, 35, 35, 35, 39, 39,
86	43, 44, 45, 47, 48, 49, 50, 51, 52, 53,
87	55, 56, 57, 59, 60, 62, 63, 64, 65, 66,
88	67, 68, 69, 70, 71, 72, 73, 74, 74, 75,
89	76, 77, 78, 79, 79, 80, 81, 82, 83, 84,
90	85, 86, 87, 88, 89, 90, 91, 92, 92, 93,
91	93, 94, 94, 95, 95, 96, 96, 97, 97, 98,
92	98, 99, 99, 99, 99, 100, 100, 100, 100, 100,
93	100
94	};
95
96	//******************************************************************************
97	//Convert linear volume to logarithmic
98	//******************************************************************************
99	ULONG ConvertVolume(ULONG ulLinVolume, ULONG ulLogVolMax)
100	{
101	if(ulLinVolume > OSS32_MAX_VOLUME) {
102	ulLinVolume = OSS32_MAX_VOLUME;
103	}
104	ulLinVolume = LinToLog[ulLinVolume];
105
106	return (ulLinVolume * ulLogVolMax) / OSS32_MAX_VOLUME;
107	}
108
109	//******************************************************************************
110	//******************************************************************************
111	OSSRET OSS32_MixOpen(ULONG deviceid, OSSSTREAMID *pStreamId)
112	{
113	mixerhandle *pHandle = NULL;
114	int ret, i, j, sz;
115
116	if(pStreamId == NULL) {
117	DebugInt3();
118	return OSSERR_INVALID_PARAMETER;
119	}
120	*pStreamId = 0;
121
122	if(alsa_fops == NULL) {
123	ret = OSSERR_NO_DEVICE_AVAILABLE;
124	goto failure;
125	}
126
127	sz = sizeof(mixerhandle);
128	pHandle = kmalloc(sz, GFP_KERNEL);
129	if(pHandle == NULL) {
130	ret = OSSERR_OUT_OF_MEMORY;
131	goto failure;
132	}
133	memset(pHandle, 0, sizeof(mixerhandle));
134
135	//set operation to non-blocking
136	pHandle->file.f_flags = O_NONBLOCK;
137
138	//setup pointers in file structure (used internally by ALSA)
139	pHandle->file.f_dentry = &pHandle->d_entry;
140	pHandle->file.f_dentry->d_inode = &pHandle->inode;
141
142	pHandle->file.f_mode = FMODE_WRITE;
143	pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
144
145	ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
146	if(ret) {
147	goto failure;
148	}
149	//retrieve mixer information
150	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
151	SNDRV_CTL_IOCTL_CARD_INFO,
152	(ULONG)&pHandle->info);
153	if(ret) {
154	goto failure;
155	}
156	//get the number of mixer elements
157	pHandle->list.offset = 0;
158	pHandle->list.space = 0;
159	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
160	SNDRV_CTL_IOCTL_ELEM_LIST,
161	(ULONG)&pHandle->list);
162	if(ret) {
163	goto failure;
164	}
165	//allocate memory for all mixer elements
166	pHandle->pids = (struct snd_ctl_elem_id )kmalloc(sizeof(struct snd_ctl_elem_id)pHandle->list.count, GFP_KERNEL);
167	if(pHandle->pids == NULL) {
168	goto failure;
169	}
170	//and retrieve all mixer elements
171	pHandle->list.offset = 0;
172	pHandle->list.space = pHandle->list.count;
173	pHandle->list.pids = pHandle->pids;
174	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
175	SNDRV_CTL_IOCTL_ELEM_LIST,
176	(ULONG)&pHandle->list);
177	if(ret) {
178	goto failure;
179	}
180
181	#if 0
182	dprintf(("Mixer name: %s", pHandle->info.mixername));
183	dprintf(("List of mixer elements:"));
184	for(i=0;i<pHandle->list.count;i++) {
185	dprintf(("index %d name %s id %d device %d subdevice %d", pHandle->pids[i].index, pHandle->pids[i].name, pHandle->pids[i].numid, pHandle->pids[i].device, pHandle->pids[i].subdevice));
186	}
187	#endif
188
189	//Extract standard mixer controls from array with control names
190	for(j=0;j<OSS_MIXER_NRDEVICES;j++)
191	{
192	int namelen = strlen(ossid[j].name);
193
194	pHandle->controls[j].idxVolume = -1;
195	pHandle->controls[j].idxMute = -1;
196	pHandle->controls[j].idxCustom = -1;
197	pHandle->controls[j].idxCaptureSwitch = -1;
198
199	for(i=0;i<pHandle->list.count;i++)
200	{
201	if (pHandle->pids[i].index == ossid[j].index &&
202	strncmp(pHandle->pids[i].name, ossid[j].name, namelen) == 0)
203	{
204	int controlnamelen = strlen(pHandle->pids[i].name);
205
206	if(namelen == controlnamelen)
207	{//control names are identical; found exact match
208	pHandle->controls[j].idxVolume = i;
209	break;
210	}
211	else
212	{//first part of the control name is correct; now find out what
213	//is it exactly
214	char *nextword = &pHandle->pids[i].name[namelen];
215	while(nextword && nextword == ' ') nextword++;
216
217	if(strncmp(nextword, MIXER_PLAYBACKVOLUME, sizeof(MIXER_PLAYBACKVOLUME)-1) == 0 \|\|
218	strncmp(nextword, MIXER_VOLUME, sizeof(MIXER_VOLUME)-1) == 0)
219	{//volume control
220	pHandle->controls[j].idxVolume = i;
221	}
222	else
223	if(strncmp(nextword, MIXER_PLAYBACKSWITCH, sizeof(MIXER_PLAYBACKSWITCH)-1) == 0 \|\|
224	strncmp(nextword, MIXER_SWITCH, sizeof(MIXER_SWITCH)-1) == 0)
225	{//mute control
226	pHandle->controls[j].idxMute = i;
227	if (pHandle->controls[j].idxVolume == -1)
228	pHandle->controls[j].idxVolume = i;
229	}
230	else
231	if(strncmp(nextword, MIXER_SOURCE, sizeof(MIXER_SOURCE)-1) == 0)
232	{//source control (e.g. recording source)
233	pHandle->controls[j].idxCustom = i;
234	}
235	else
236	if(strncmp(nextword, MIXER_CAPTUREROUTE, sizeof(MIXER_CAPTUREROUTE)-1) == 0 \|\|
237	strncmp(nextword, MIXER_CAPTURESWITCH, sizeof(MIXER_CAPTURESWITCH)-1) == 0)
238	{//source control for recording (per input)
239	pHandle->controls[j].idxCaptureSwitch = i;
240	}
241	else
242	if(i == OSS_MIXER_MIC) {
243	if(strncmp(nextword, MIXER_BOOST, sizeof(MIXER_BOOST)-1) == 0)
244	{//mic boost switch
245	pHandle->controls[j].idxCustom = i;
246	}
247	}
248	}
249	}
250	}
251	}
252
253	pHandle->reccaps = 0;
254	for(j=0;j<OSS32_MIX_RECSRC_MAX;j++) {
255	pHandle->idxRecCaps[j] = -1;
256	}
257
258	//request information about available capture sources
259	if(pHandle->controls[OSS_MIXER_IGAIN].idxCustom != -1)
260	{
261	struct snd_ctl_elem_info *pElemInfo = NULL;
262	int idx, j;
263
264	idx = pHandle->controls[OSS_MIXER_IGAIN].idxCustom;
265
266	//set operation to non-blocking
267	pHandle->file.f_flags = O_NONBLOCK;
268
269	pHandle->rectype = RECTYPE_SELECTOR;
270
271	//too big to put on the stack
272	pElemInfo = (struct snd_ctl_elem_info *)kmalloc(sizeof(struct snd_ctl_elem_info), GFP_KERNEL);
273	if(pElemInfo == NULL) {
274	DebugInt3();
275	goto failure;
276	}
277
278	pElemInfo->value.enumerated.items = 1;
279	for(i=0;i<pElemInfo->value.enumerated.items;i++)
280	{
281	pElemInfo->value.enumerated.item = i;
282	pElemInfo->id.numid = pHandle->pids[idx].numid;
283	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
284	if(ret) {
285	DebugInt3();
286	break;
287	}
288	if(pElemInfo->type != SNDRV_CTL_ELEM_TYPE_ENUMERATED) {
289	DebugInt3();
290	break;
291	}
292	for(j=0;j<OSS32_MIX_RECSRC_MAX;j++) {
293	if(!strcmp(pElemInfo->value.enumerated.name, szRecSources[j])) {
294	pHandle->reccaps \|= OSS32_MIX_FLAG(j);
295	pHandle->idxRecCaps[j] = i; //save alsa index
296	break;
297	}
298	}
299	}
300	kfree(pElemInfo);
301	}
302	else
303	{//This card has no record source selection, but probably route switches for
304	//each input source (SB mixers (also ALS4000), CMedia)
305	pHandle->rectype = RECTYPE_SWITCH;
306	for(j=0;j<OSS32_MIX_RECSRC_MAX;j++) {
307	pHandle->idxRecCaps[j] = -1;
308	}
309	for(j=0;j<OSS_MIXER_NRDEVICES;j++)
310	{
311	if(pHandle->controls[j].idxCaptureSwitch != -1) {
312	pHandle->reccaps \|= OSS32_MIX_FLAG(ossid[j].recsrc);
313	pHandle->idxRecCaps[ossid[j].recsrc] = pHandle->controls[j].idxCaptureSwitch; //save alsa index
314	}
315	}
316	}
317
318	pHandle->magic = MAGIC_MIXER_ALSA32;
319	*pStreamId = (ULONG)pHandle;
320	return OSSERR_SUCCESS;
321
322	failure:
323	if(pHandle) {
324	if(pHandle->pids) kfree(pHandle->pids);
325	kfree(pHandle);
326	}
327	DebugInt3();
328	return OSSERR_OUT_OF_MEMORY;
329	}
330	//******************************************************************************
331	//******************************************************************************
332	OSSRET OSS32_MixClose(OSSSTREAMID streamid)
333	{
334	mixerhandle pHandle = (mixerhandle )streamid;
335	int ret;
336
337	if(pHandle == NULL \|\| pHandle->magic != MAGIC_MIXER_ALSA32) {
338	DebugInt3();
339	return OSSERR_INVALID_STREAMID;
340	}
341	//set operation to non-blocking
342	pHandle->file.f_flags = O_NONBLOCK;
343	ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
344	kfree(pHandle->pids); //free mixer element array
345	kfree(pHandle); //free handle data
346
347	if(ret) {
348	DebugInt3();
349	return UNIXToOSSError(ret);
350	}
351	return OSSERR_SUCCESS;
352	}
353	//******************************************************************************
354	//******************************************************************************
355	OSSRET OSS32_MixGetVolume(OSSSTREAMID streamid, ULONG line, ULONG *pVolume)
356	{
357	mixerhandle pHandle = (mixerhandle )streamid;
358	int ret;
359
360	if(pHandle == NULL \|\| pHandle->magic != MAGIC_MIXER_ALSA32) {
361	DebugInt3();
362	return OSSERR_INVALID_STREAMID;
363	}
364	//set operation to non-blocking
365	pHandle->file.f_flags = O_NONBLOCK;
366
367	return OSSERR_NOT_SUPPORTED;
368	}
369	//******************************************************************************
370	//******************************************************************************
371	OSSRET OSS32_MixSetVolume(OSSSTREAMID streamid, ULONG line, ULONG volume)
372	{
373	mixerhandle pHandle = (mixerhandle )streamid;
374	struct snd_ctl_elem_value *pElem = NULL;
375	struct snd_ctl_elem_info *pElemInfo;
376	int ret, idx, lVol, rVol = 0, idxMute, cnt;
377
378	dprintf(("OSS32_MixSetVolume line=%d\n", line));
379	if(pHandle == NULL \|\| pHandle->magic != MAGIC_MIXER_ALSA32) {
380	printk("Invalid handle in OSS32_MixSetVolume\n");
381	DebugInt3();
382	return OSSERR_INVALID_STREAMID;
383	}
384	//set operation to non-blocking
385	pHandle->file.f_flags = O_NONBLOCK;
386
387	//too big to put on the stack
388	pElem = (struct snd_ctl_elem_value *)kmalloc(sizeof(struct snd_ctl_elem_value) + sizeof(struct snd_ctl_elem_info), GFP_KERNEL);
389	if(pElem == NULL) {
390	printk("Out of memory in OSS32_MixSetVolume\n");
391	DebugInt3();
392	return OSSERR_OUT_OF_MEMORY;
393	}
394	pElemInfo = (struct snd_ctl_elem_info *)(pElem+1);
395
396	switch(line) {
397	case OSS32_MIX_VOLUME_MASTER_FRONT:
398	idx = pHandle->controls[OSS_MIXER_VOLUME].idxVolume;
399	idxMute = pHandle->controls[OSS_MIXER_VOLUME].idxMute;
400	if (idx == -1)
401	{
402	/* HDA codecs workaround */
403	idx = pHandle->controls[OSS_MIXER_FRONT].idxVolume;
404	idxMute = pHandle->controls[OSS_MIXER_FRONT].idxMute;
405	}
406	break;
407	case OSS32_MIX_VOLUME_MASTER_REAR: //TODO:
408	idx = pHandle->controls[OSS_MIXER_VOLUME].idxVolume;
409	idxMute = pHandle->controls[OSS_MIXER_VOLUME].idxMute;
410	break;
411	case OSS32_MIX_VOLUME_PCM:
412	idx = pHandle->controls[OSS_MIXER_PCM].idxVolume;
413	idxMute = pHandle->controls[OSS_MIXER_PCM].idxMute;
414	if (idx == -1)
415	{
416	/* HDA codecs workaround */
417	idx = pHandle->controls[OSS_MIXER_FRONT].idxVolume;
418	idxMute = pHandle->controls[OSS_MIXER_FRONT].idxMute;
419	}
420	break;
421	case OSS32_MIX_VOLUME_MIDI:
422	idx = pHandle->controls[OSS_MIXER_SYNTH].idxVolume;
423	idxMute = pHandle->controls[OSS_MIXER_SYNTH].idxMute;
424	break;
425	case OSS32_MIX_VOLUME_LINEIN:
426	idx = pHandle->controls[OSS_MIXER_LINE].idxVolume;
427	idxMute = pHandle->controls[OSS_MIXER_LINE].idxMute;
428	break;
429	case OSS32_MIX_VOLUME_MIC:
430	idx = pHandle->controls[OSS_MIXER_MIC].idxVolume;
431	idxMute = pHandle->controls[OSS_MIXER_MIC].idxMute;
432	break;
433	case OSS32_MIX_VOLUME_CD:
434	idx = pHandle->controls[OSS_MIXER_CD].idxVolume;
435	idxMute = pHandle->controls[OSS_MIXER_CD].idxMute;
436	break;
437	case OSS32_MIX_VOLUME_SPDIF:
438	idx = pHandle->controls[OSS_MIXER_DIGITAL1].idxVolume;
439	idxMute = pHandle->controls[OSS_MIXER_DIGITAL1].idxMute;
440	break;
441	case OSS32_MIX_VOLUME_VIDEO:
442	idx = pHandle->controls[OSS_MIXER_VIDEO].idxVolume;
443	idxMute = pHandle->controls[OSS_MIXER_VIDEO].idxMute;
444	break;
445	case OSS32_MIX_VOLUME_PCSPEAKER:
446	idx = pHandle->controls[OSS_MIXER_PCSPEAKER].idxVolume;
447	idxMute = pHandle->controls[OSS_MIXER_PCSPEAKER].idxMute;
448	break;
449	case OSS32_MIX_VOLUME_PHONE:
450	idx = pHandle->controls[OSS_MIXER_PHONEOUT].idxVolume;
451	idxMute = pHandle->controls[OSS_MIXER_PHONEOUT].idxMute;
452	break;
453	case OSS32_MIX_VOLUME_HEADPHONE:
454	idx = pHandle->controls[OSS_MIXER_HEADPHONE].idxVolume;
455	idxMute = pHandle->controls[OSS_MIXER_HEADPHONE].idxMute;
456	break;
457	case OSS32_MIX_VOLUME_SPEAKER:
458	idx = pHandle->controls[OSS_MIXER_SPEAKER].idxVolume;
459	idxMute = pHandle->controls[OSS_MIXER_SPEAKER].idxMute;
460	break;
461	case OSS32_MIX_VOLUME_AUX:
462	idx = pHandle->controls[OSS_MIXER_LINE1].idxVolume;
463	idxMute = pHandle->controls[OSS_MIXER_LINE1].idxMute;
464	break;
465	case OSS32_MIX_VOLUME_CAPTURE:
466	idx = pHandle->controls[OSS_MIXER_IGAIN].idxVolume;
467	idxMute = pHandle->controls[OSS_MIXER_IGAIN].idxMute;
468	break;
469
470	default:
471	DebugInt3();
472	ret = OSSERR_INVALID_PARAMETER;
473	goto fail;
474	}
475	if(idx == -1) {
476	dprintf(("Unknown control %d", line));
477	ret = OSSERR_INVALID_PARAMETER;
478	goto fail;
479	}
480
481	if(idxMute != -1 && volume != 0) {
482	//disable mute
483	pElem->id.numid = pHandle->pids[idxMute].numid;
484	pElem->indirect = 0;
485
486	pElem->value.integer.value[0] = TRUE; //switch, not mute control (inversed)
487	pElem->value.integer.value[1] = TRUE;
488	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
489	}
490	//request information about mixer control
491	pElemInfo->id.numid = pHandle->pids[idx].numid;
492	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
493	if(ret) {
494	ret = UNIXToOSSError(ret);
495	DebugInt3();
496	goto fail;
497	}
498	if(pElemInfo->type != SNDRV_CTL_ELEM_TYPE_INTEGER) {
499	ret = OSSERR_INVALID_PARAMETER;
500	DebugInt3();
501	goto fail;
502	}
503	pElem->id.numid = pHandle->pids[idx].numid;
504	pElem->indirect = 0;
505
506	lVol = ConvertVolume(GET_VOLUME_L(volume), pElemInfo->value.integer.max);
507	pElem->value.integer.value[0] = lVol;
508
509	if(pElemInfo->count > 1) { //stereo
510	rVol = ConvertVolume(GET_VOLUME_R(volume), pElemInfo->value.integer.max);
511	pElem->value.integer.value[1] = rVol;
512	}
513
514	printk("OSS32_MixSetVolume of %s streamid %X to (%d,%d)(%d,%d) caps %d\n",
515	pHandle->pids[idx].name,
516	(ULONG)pHandle, GET_VOLUME_L(volume),
517	GET_VOLUME_R(volume), lVol, rVol, pElemInfo->value.integer.max);
518
519	// looking for more, then one opened streams to prevent of muting active stream
520	cnt = 0;
521	for (idx=0; idx < 8*256; idx++)
522	if (opened_handles[idx].handle != 0)
523	cnt++;
524
525	// if (((cnt == 1 && (lVol==0 && rVol==0)) \|\| (lVol>0 && rVol>0)) \|\|
526	if (cnt == 1 \|\| line != OSS32_MIX_VOLUME_PCM)
527	{
528	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
529
530	if(idxMute != -1 && volume == 0) {
531	//enable mute
532	pElem->id.numid = pHandle->pids[idxMute].numid;
533	pElem->indirect = 0;
534
535	pElem->value.integer.value[0] = FALSE; //switch, not mute control (inversed)
536	pElem->value.integer.value[1] = FALSE;
537	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
538	}
539	}
540
541	kfree(pElem);
542	pElem = NULL;
543	if(ret) {
544	printk("ret = %i\n", ret);
545	DebugInt3();
546	return UNIXToOSSError(ret);
547	}
548	return OSSERR_SUCCESS;
549
550	fail:
551	if(pElem) kfree(pElem);
552	return ret;
553	}
554	//******************************************************************************
555	//******************************************************************************
556	OSSRET OSS32_MixSetProperty(OSSSTREAMID streamid, ULONG ulLine, ULONG ulValue)
557	{
558	mixerhandle pHandle = (mixerhandle )streamid;
559	struct snd_ctl_elem_value *pElem = NULL;
560	struct snd_ctl_elem_info *pElemInfo;
561	int ret, idx = -1, lVol, rVol = 0, j, i;
562
563	if(pHandle == NULL \|\| pHandle->magic != MAGIC_MIXER_ALSA32) {
564	DebugInt3();
565	return OSSERR_INVALID_STREAMID;
566	}
567	//set operation to non-blocking
568	pHandle->file.f_flags = O_NONBLOCK;
569
570	//too big to put on the stack
571	pElem = (struct snd_ctl_elem_value *)kmalloc(sizeof(struct snd_ctl_elem_value) + sizeof(struct snd_ctl_elem_info), GFP_KERNEL);
572	if(pElem == NULL) {
573	DebugInt3();
574	return OSSERR_OUT_OF_MEMORY;
575	}
576	pElemInfo = (struct snd_ctl_elem_info *)(pElem+1);
577
578	switch(ulLine) {
579	case OSS32_MIX_INPUTSRC:
580	idx = pHandle->controls[OSS_MIXER_IGAIN].idxCustom;
581	//is this capture source supported by the hardware??
582	if(!(pHandle->reccaps & OSS32_MIX_FLAG(ulValue))) {
583	DebugInt3();
584	ret = OSSERR_INVALID_PARAMETER;
585	goto fail;
586	}
587	if(pHandle->rectype == RECTYPE_SELECTOR) {//input source selector
588	//set left and right capture source
589	pElem->value.enumerated.item[0] = pHandle->idxRecCaps[ulValue];
590	pElem->value.enumerated.item[1] = pHandle->idxRecCaps[ulValue];
591	}
592	else {//capture switch for each input source
593	//first turn off all capture switches...
594	for(j=0;j<OSS32_MIX_RECSRC_MAX;j++)
595	{
596	if(pHandle->idxRecCaps[j] != -1) {
597	idx = pHandle->idxRecCaps[j];
598
599	//request information about mixer control
600	pElemInfo->id.numid = pHandle->pids[idx].numid;
601	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
602	if(ret) {
603	ret = UNIXToOSSError(ret);
604	DebugInt3();
605	goto fail;
606	}
607	if(pElemInfo->type != SNDRV_CTL_ELEM_TYPE_BOOLEAN) {
608	ret = OSSERR_INVALID_PARAMETER;
609	DebugInt3();
610	goto fail;
611	}
612
613	pElem->id.numid = pHandle->pids[idx].numid;
614	pElem->indirect = 0;
615	for(i=0;i<pElemInfo->count;i++) {
616	pElem->value.integer.value[i] = 0;
617	}
618
619	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
620	if(ret) {
621	ret = UNIXToOSSError(ret);
622	DebugInt3();
623	goto fail;
624	}
625	}
626	}
627	//request information about mixer control
628	pElemInfo->id.numid = pHandle->pids[idx].numid;
629	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
630	if(ret) {
631	ret = UNIXToOSSError(ret);
632	DebugInt3();
633	goto fail;
634	}
635
636	//and enable the capture switch for the selected input source
637	idx = pHandle->idxRecCaps[ulValue];
638	for(i=0;i<pElemInfo->count;i++) {
639	pElem->value.integer.value[i] = 1;
640	}
641	}
642
643	break;
644
645	case OSS32_MIX_SWITCH_MICBOOST:
646	idx = pHandle->controls[OSS_MIXER_MIC].idxCustom;
647	if(idx == -1) {
648	DebugInt3();
649	ret = OSSERR_INVALID_PARAMETER;
650	goto fail;
651	}
652	//set mic switch value (on/off)
653	pElem->value.integer.value[0] = ulValue;
654	break;
655
656	case OSS32_MIX_LEVEL_BASS:
657	idx = pHandle->controls[OSS_MIXER_BASS].idxVolume;
658	goto levelcontinue;
659	case OSS32_MIX_LEVEL_TREBLE:
660	idx = pHandle->controls[OSS_MIXER_TREBLE].idxVolume;
661	goto levelcontinue;
662	case OSS32_MIX_LEVEL_3DCENTER:
663	idx = pHandle->controls[OSS_MIXER_3DCENTER].idxVolume;
664	goto levelcontinue;
665	case OSS32_MIX_LEVEL_3DDEPTH:
666	idx = pHandle->controls[OSS_MIXER_3DDEPTH].idxVolume;
667	levelcontinue:
668
669	if(idx == -1) {//supported?
670	DebugInt3();
671	ret = OSSERR_INVALID_PARAMETER;
672	goto fail;
673	}
674	//request information about mixer control
675	pElemInfo->id.numid = pHandle->pids[idx].numid;
676	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_INFO, (ULONG)pElemInfo);
677	if(ret) {
678	ret = UNIXToOSSError(ret);
679	DebugInt3();
680	goto fail;
681	}
682	if(pElemInfo->type != SNDRV_CTL_ELEM_TYPE_INTEGER) {
683	ret = OSSERR_INVALID_PARAMETER;
684	DebugInt3();
685	goto fail;
686	}
687	lVol = ConvertVolume(GET_VOLUME_L(ulValue), pElemInfo->value.integer.max);
688	pElem->value.integer.value[0] = lVol;
689
690	if(pElemInfo->count > 1) { //stereo
691	rVol = ConvertVolume(GET_VOLUME_R(ulValue), pElemInfo->value.integer.max);
692	pElem->value.integer.value[1] = rVol;
693	}
694	break;
695
696	default:
697	DebugInt3();
698	ret = OSSERR_INVALID_PARAMETER;
699	goto fail;
700	}
701	pElem->id.numid = pHandle->pids[idx].numid;
702	pElem->indirect = 0;
703
704	dprintf(("OSS32_MixSetProperty of %s to %x", pHandle->pids[idx].name, ulValue));
705	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file, SNDRV_CTL_IOCTL_ELEM_WRITE, (ULONG)pElem);
706
707	kfree(pElem);
708	pElem = NULL;
709	if(ret) {
710	DebugInt3();
711	return UNIXToOSSError(ret);
712	}
713	return OSSERR_SUCCESS;
714
715	fail:
716	if(pElem) kfree(pElem);
717	return ret;
718	}
719	//******************************************************************************
720	//******************************************************************************
721	OSSRET OSS32_MixGetProperty(OSSSTREAMID streamid, ULONG line, ULONG *pValue)
722	{
723	mixerhandle pHandle = (mixerhandle )streamid;
724	int ret;
725
726	if(pHandle == NULL \|\| pHandle->magic != MAGIC_MIXER_ALSA32) {
727	DebugInt3();
728	return OSSERR_INVALID_STREAMID;
729	}
730	//set operation to non-blocking
731	pHandle->file.f_flags = O_NONBLOCK;
732
733	return OSSERR_NOT_SUPPORTED;
734	}
735	//******************************************************************************
736	//******************************************************************************
737	ULONG OSSToALSAVolume(ULONG OSSVolIdx)
738	{
739	switch(OSSVolIdx) {
740	case OSS_MIXER_VOLUME:
741	return OSS32_MIX_VOLUME_MASTER_FRONT;
742	#if 0
743	case OSS_MIXER_VOLUME: //TODO:
744	return OSS32_MIX_VOLUME_MASTER_REAR;
745	#endif
746	case OSS_MIXER_PCM:
747	return OSS32_MIX_VOLUME_PCM;
748	case OSS_MIXER_SYNTH:
749	return OSS32_MIX_VOLUME_MIDI;
750	case OSS_MIXER_LINE:
751	return OSS32_MIX_VOLUME_LINEIN;
752	case OSS_MIXER_MIC:
753	return OSS32_MIX_VOLUME_MIC;
754	case OSS_MIXER_CD:
755	return OSS32_MIX_VOLUME_CD;
756	case OSS_MIXER_DIGITAL1:
757	return OSS32_MIX_VOLUME_SPDIF;
758	case OSS_MIXER_VIDEO:
759	return OSS32_MIX_VOLUME_VIDEO;
760	case OSS_MIXER_PCSPEAKER:
761	return OSS32_MIX_VOLUME_PCSPEAKER;
762	case OSS_MIXER_PHONEOUT:
763	return OSS32_MIX_VOLUME_PHONE;
764	case OSS_MIXER_IGAIN:
765	return OSS32_MIX_VOLUME_CAPTURE;
766	case OSS_MIXER_TREBLE:
767	return OSS32_MIX_LEVEL_TREBLE;
768	case OSS_MIXER_BASS:
769	return OSS32_MIX_LEVEL_BASS;
770	case OSS_MIXER_HEADPHONE:
771	return OSS32_MIX_VOLUME_HEADPHONE;
772	case OSS_MIXER_SPEAKER:
773	return OSS32_MIX_VOLUME_SPEAKER;
774	case OSS_MIXER_LINE1:
775	return OSS32_MIX_VOLUME_AUX;
776	}
777	return -1;
778	}
779	//******************************************************************************
780	//******************************************************************************
781	OSSRET OSS32_MixQueryCaps(OSSSTREAMID streamid, POSS32_MIXCAPS pCaps)
782	{
783	mixerhandle pHandle = (mixerhandle )streamid;
784	int i;
785
786	if(pHandle == NULL \|\| pHandle->magic != MAGIC_MIXER_ALSA32) {
787	DebugInt3();
788	return OSSERR_INVALID_STREAMID;
789	}
790
791	strncpy(pCaps->name, pHandle->info.mixername, sizeof(pCaps->name));
792	pCaps->fuCtrlCaps = 0;
793	pCaps->fuRecCaps = 0;
794
795	for(i=0;i<OSS_MIXER_NRDEVICES;i++)
796	{
797	if(pHandle->controls[i].idxVolume != -1) {
798	ULONG volidx = OSSToALSAVolume(i);
799	if(volidx != -1)
800	pCaps->fuCtrlCaps \|= OSS32_MIX_FLAG(volidx);
801	}
802	}
803
804	//if it has a capture source control or the card has capture route switches,
805	//then we support intput source selection
806	if(pHandle->controls[OSS_MIXER_IGAIN].idxCustom != -1 \|\|
807	pHandle->rectype == RECTYPE_SWITCH)
808	{
809	pCaps->fuCtrlCaps \|= OSS32_MIX_FLAG(OSS32_MIX_INPUTSRC);
810	pCaps->fuRecCaps = pHandle->reccaps;
811	}
812	return OSSERR_SUCCESS;
813	}
814	//******************************************************************************
815	//******************************************************************************
816	OSSRET OSS32_MixQueryName(ULONG deviceid, char *pszMixerName, ULONG cbMixerName)
817	{
818	mixerhandle *pHandle = NULL;
819	int ret, i, j;
820
821	if(alsa_fops == NULL)
822	return OSSERR_NO_DEVICE_AVAILABLE;
823
824	pHandle = kmalloc(sizeof(mixerhandle), GFP_KERNEL);
825	if(pHandle == NULL) {
826	ret = OSSERR_OUT_OF_MEMORY;
827	goto failure;
828	}
829	memset(pHandle, 0, sizeof(mixerhandle));
830
831	//set operation to non-blocking
832	pHandle->file.f_flags = O_NONBLOCK;
833
834	//setup pointers in file structure (used internally by ALSA)
835	pHandle->file.f_dentry = &pHandle->d_entry;
836	pHandle->file.f_dentry->d_inode = &pHandle->inode;
837
838	pHandle->file.f_mode = FMODE_WRITE;
839	pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
840
841	ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
842	if(ret) {
843	goto failure;
844	}
845	//retrieve mixer information
846	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
847	SNDRV_CTL_IOCTL_CARD_INFO,
848	(ULONG)&pHandle->info);
849	if(ret) {
850	goto failure;
851	}
852
853	strncpy(pszMixerName, pHandle->info.mixername, cbMixerName);
854
855	pHandle->file.f_flags = O_NONBLOCK;
856	ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
857	if(ret) {
858	goto failure;
859	}
860	kfree(pHandle);
861	return OSSERR_SUCCESS;
862
863	failure:
864	if(pHandle) {
865	kfree(pHandle);
866	}
867	DebugInt3();
868	return OSSERR_OUT_OF_MEMORY;
869	}
870	//******************************************************************************
871	//******************************************************************************
872	OSSRET OSS32_QueryNames(ULONG deviceid, char *pszDeviceName, ULONG cbDeviceName,
873	char *pszMixerName, ULONG cbMixerName, BOOL fLongName)
874	{
875	mixerhandle *pHandle = NULL;
876	int ret, i, j;
877
878	if(alsa_fops == NULL) {
879	ret = OSSERR_NO_DEVICE_AVAILABLE;
880	printk("ret = OSSERR_NO_DEVICE_AVAILABLE\n");
881	goto failure;
882	}
883
884	pHandle = kmalloc(sizeof(mixerhandle), GFP_KERNEL);
885	if(pHandle == NULL) {
886	ret = OSSERR_OUT_OF_MEMORY;
887	goto failure;
888	}
889	memset(pHandle, 0, sizeof(mixerhandle));
890
891	//set operation to non-blocking
892	pHandle->file.f_flags = O_NONBLOCK;
893
894	//setup pointers in file structure (used internally by ALSA)
895	pHandle->file.f_dentry = &pHandle->d_entry;
896	pHandle->file.f_dentry->d_inode = &pHandle->inode;
897
898	pHandle->file.f_mode = FMODE_WRITE;
899	pHandle->inode.i_rdev = SNDRV_MINOR(deviceid, SNDRV_MINOR_CONTROL);
900
901	ret = alsa_fops->open(&pHandle->inode, &pHandle->file);
902	if(ret) {
903	printk("open ret = %i\n", ret);
904	goto failure;
905	}
906	//retrieve mixer information
907	ret = pHandle->file.f_op->ioctl(&pHandle->inode, &pHandle->file,
908	SNDRV_CTL_IOCTL_CARD_INFO,
909	(ULONG)&pHandle->info);
910	if(ret) {
911	printk("ioctl ret = %i\n", ret);
912	goto failure;
913	}
914
915	if(pszDeviceName) {
916	if(fLongName == TRUE) {
917	strncpy(pszDeviceName, pHandle->info.longname, cbDeviceName);
918	}
919	else strncpy(pszDeviceName, pHandle->info.name, cbDeviceName);
920	}
921	if(pszMixerName) {
922	strncpy(pszMixerName, pHandle->info.mixername, cbMixerName);
923	}
924
925	// printk("Card: %s with mixer %s\n",pszDeviceName, pszMixerName);
926
927	pHandle->file.f_flags = O_NONBLOCK;
928	ret = pHandle->file.f_op->release(&pHandle->inode, &pHandle->file);
929	if(ret) {
930	printk("release ret = %i\n", ret);
931	goto failure;
932	}
933	kfree(pHandle);
934	return OSSERR_SUCCESS;
935
936	failure:
937	if(pHandle) {
938	kfree(pHandle);
939	}
940	DebugInt3();
941	printk("OSS32_QueryNames() ret = %i\n", ret);
942	return OSSERR_OUT_OF_MEMORY;
943	}
944	//******************************************************************************
945	//******************************************************************************
946

Note: See TracBrowser for help on using the repository browser.

Download in other formats: