source: GPL/branches/alsa-resync1/alsa-kernel/isa/gus/gus_mixer.c@ 224

Last change on this file since 224 was 224, checked in by Brendan Oakley, 18 years ago

Merged to Alsa 0.9.1
File size: 6.5 KB
Line 
1/*
2 * Copyright (c) by Jaroslav Kysela <perex@suse.cz>
3 * Routines for control of ICS 2101 chip and "mixer" in GF1 chip
4 *
5 *
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.
10 *
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.
15 *
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
19 *
20 */
21
22#include <sound/driver.h>
23#include <linux/time.h>
24#include <linux/wait.h>
25#include <sound/core.h>
26#include <sound/control.h>
27#include <sound/gus.h>
28
29#define chip_t snd_gus_card_t
30
31/*
32 *
33 */
34
35#define GF1_SINGLE(xname, xindex, shift, invert) \
36{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
37 .info = snd_gf1_info_single, \
38 .get = snd_gf1_get_single, .put = snd_gf1_put_single, \
39 .private_value = shift | (invert << 8) }
40
41static int snd_gf1_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
42{
43 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
44 uinfo->count = 1;
45 uinfo->value.integer.min = 0;
46 uinfo->value.integer.max = 1;
47 return 0;
48}
49
50static int snd_gf1_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
51{
52 snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol);
53 int shift = kcontrol->private_value & 0xff;
54 int invert = (kcontrol->private_value >> 8) & 1;
55
56 ucontrol->value.integer.value[0] = (gus->mix_cntrl_reg >> shift) & 1;
57 if (invert)
58 ucontrol->value.integer.value[0] ^= 1;
59 return 0;
60}
61
62static int snd_gf1_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
63{
64 snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol);
65 unsigned long flags;
66 int shift = kcontrol->private_value & 0xff;
67 int invert = (kcontrol->private_value >> 8) & 1;
68 int change;
69 unsigned char oval, nval;
70
71 nval = ucontrol->value.integer.value[0] & 1;
72 if (invert)
73 nval ^= 1;
74 nval <<= shift;
75 spin_lock_irqsave(&gus->reg_lock, flags);
76 oval = gus->mix_cntrl_reg;
77 nval = (oval & ~(1 << shift)) | nval;
78 change = nval != oval;
79 outb(gus->mix_cntrl_reg = nval, GUSP(gus, MIXCNTRLREG));
80 outb(gus->gf1.active_voice = 0, GUSP(gus, GF1PAGE));
81 spin_unlock_irqrestore(&gus->reg_lock, flags);
82 return change;
83}
84
85#define ICS_DOUBLE(xname, xindex, addr) \
86{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \
87 .info = snd_ics_info_double, \
88 .get = snd_ics_get_double, .put = snd_ics_put_double, \
89 .private_value = addr }
90
91static int snd_ics_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
92{
93 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
94 uinfo->count = 2;
95 uinfo->value.integer.min = 0;
96 uinfo->value.integer.max = 127;
97 return 0;
98}
99
100static int snd_ics_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
101{
102 snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol);
103 unsigned long flags;
104 int addr = kcontrol->private_value & 0xff;
105 unsigned char left, right;
106
107 spin_lock_irqsave(&gus->reg_lock, flags);
108 left = gus->gf1.ics_regs[addr][0];
109 right = gus->gf1.ics_regs[addr][1];
110 spin_unlock_irqrestore(&gus->reg_lock, flags);
111 ucontrol->value.integer.value[0] = left & 127;
112 ucontrol->value.integer.value[1] = right & 127;
113 return 0;
114}
115
116static int snd_ics_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
117{
118 snd_gus_card_t *gus = snd_kcontrol_chip(kcontrol);
119 unsigned long flags;
120 int addr = kcontrol->private_value & 0xff;
121 int change;
122 unsigned char val1, val2, oval1, oval2, tmp;
123
124 val1 = ucontrol->value.integer.value[0] & 127;
125 val2 = ucontrol->value.integer.value[1] & 127;
126 spin_lock_irqsave(&gus->reg_lock, flags);
127 oval1 = gus->gf1.ics_regs[addr][0];
128 oval2 = gus->gf1.ics_regs[addr][1];
129 change = val1 != oval1 || val2 != oval2;
130 gus->gf1.ics_regs[addr][0] = val1;
131 gus->gf1.ics_regs[addr][1] = val2;
132 if (gus->ics_flag && gus->ics_flipped &&
133 (addr == SNDRV_ICS_GF1_DEV || addr == SNDRV_ICS_MASTER_DEV)) {
134 tmp = val1;
135 val1 = val2;
136 val2 = tmp;
137 }
138 addr <<= 3;
139 outb(addr | 0, GUSP(gus, MIXCNTRLPORT));
140 outb(1, GUSP(gus, MIXDATAPORT));
141 outb(addr | 2, GUSP(gus, MIXCNTRLPORT));
142 outb((unsigned char) val1, GUSP(gus, MIXDATAPORT));
143 outb(addr | 1, GUSP(gus, MIXCNTRLPORT));
144 outb(2, GUSP(gus, MIXDATAPORT));
145 outb(addr | 3, GUSP(gus, MIXCNTRLPORT));
146 outb((unsigned char) val2, GUSP(gus, MIXDATAPORT));
147 spin_unlock_irqrestore(&gus->reg_lock, flags);
148 return change;
149}
150
151#define GF1_CONTROLS (sizeof(snd_gf1_controls)/sizeof(snd_kcontrol_new_t))
152
153static snd_kcontrol_new_t snd_gf1_controls[] = {
154GF1_SINGLE("Master Playback Switch", 0, 1, 1),
155GF1_SINGLE("Line Switch", 0, 0, 1),
156GF1_SINGLE("Mic Switch", 0, 2, 0)
157};
158
159#define ICS_CONTROLS (sizeof(snd_ics_controls)/sizeof(snd_kcontrol_new_t))
160
161static snd_kcontrol_new_t snd_ics_controls[] = {
162GF1_SINGLE("Master Playback Switch", 0, 1, 1),
163ICS_DOUBLE("Master Playback Volume", 0, SNDRV_ICS_MASTER_DEV),
164ICS_DOUBLE("Synth Playback Volume", 0, SNDRV_ICS_GF1_DEV),
165GF1_SINGLE("Line Switch", 0, 0, 1),
166ICS_DOUBLE("Line Playback Volume", 0, SNDRV_ICS_LINE_DEV),
167GF1_SINGLE("Mic Switch", 0, 2, 0),
168ICS_DOUBLE("Mic Playback Volume", 0, SNDRV_ICS_MIC_DEV),
169ICS_DOUBLE("CD Playback Volume", 0, SNDRV_ICS_CD_DEV)
170};
171
172int snd_gf1_new_mixer(snd_gus_card_t * gus)
173{
174 snd_card_t *card;
175 unsigned int idx, max;
176 int err;
177
178 snd_assert(gus != NULL, return -EINVAL);
179 card = gus->card;
180 snd_assert(card != NULL, return -EINVAL);
181
182 if (gus->ics_flag)
183 snd_component_add(card, "ICS2101");
184 if (card->mixername[0] == '\0') {
185 strcpy(card->mixername, gus->ics_flag ? "GF1,ICS2101" : "GF1");
186 } else {
187 if (gus->ics_flag)
188 strcat(card->mixername, ",ICS2101");
189 strcat(card->mixername, ",GF1");
190 }
191
192 if (!gus->ics_flag) {
193 max = gus->ess_flag ? 1 : GF1_CONTROLS;
194 for (idx = 0; idx < max; idx++) {
195 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_gf1_controls[idx], gus))) < 0)
196 return err;
197 }
198 } else {
199 for (idx = 0; idx < ICS_CONTROLS; idx++) {
200 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_ics_controls[idx], gus))) < 0)
201 return err;
202 }
203 }
204 return 0;
205}
Note: See TracBrowser for help on using the repository browser.