~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/i2c/other/pt2258.c

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *   ALSA Driver for the PT2258 volume controller.
  3  *
  4  *      Copyright (c) 2006  Jochen Voss <voss@seehuhn.de>
  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/core.h>
 23 #include <sound/control.h>
 24 #include <sound/tlv.h>
 25 #include <sound/i2c.h>
 26 #include <sound/pt2258.h>
 27 #include <linux/module.h>
 28 
 29 MODULE_AUTHOR("Jochen Voss <voss@seehuhn.de>");
 30 MODULE_DESCRIPTION("PT2258 volume controller (Princeton Technology Corp.)");
 31 MODULE_LICENSE("GPL");
 32 
 33 #define PT2258_CMD_RESET 0xc0
 34 #define PT2258_CMD_UNMUTE 0xf8
 35 #define PT2258_CMD_MUTE 0xf9
 36 
 37 static const unsigned char pt2258_channel_code[12] = {
 38         0x80, 0x90,             /* channel 1: -10dB, -1dB */
 39         0x40, 0x50,             /* channel 2: -10dB, -1dB */
 40         0x00, 0x10,             /* channel 3: -10dB, -1dB */
 41         0x20, 0x30,             /* channel 4: -10dB, -1dB */
 42         0x60, 0x70,             /* channel 5: -10dB, -1dB */
 43         0xa0, 0xb0              /* channel 6: -10dB, -1dB */
 44 };
 45 
 46 int snd_pt2258_reset(struct snd_pt2258 *pt)
 47 {
 48         unsigned char bytes[2];
 49         int i;
 50 
 51         /* reset chip */
 52         bytes[0] = PT2258_CMD_RESET;
 53         snd_i2c_lock(pt->i2c_bus);
 54         if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 1) != 1)
 55                 goto __error;
 56         snd_i2c_unlock(pt->i2c_bus);
 57 
 58         /* mute all channels */
 59         pt->mute = 1;
 60         bytes[0] = PT2258_CMD_MUTE;
 61         snd_i2c_lock(pt->i2c_bus);
 62         if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 1) != 1)
 63                 goto __error;
 64         snd_i2c_unlock(pt->i2c_bus);
 65 
 66         /* set all channels to 0dB */
 67         for (i = 0; i < 6; ++i)
 68                 pt->volume[i] = 0;
 69         bytes[0] = 0xd0;
 70         bytes[1] = 0xe0;
 71         snd_i2c_lock(pt->i2c_bus);
 72         if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 2) != 2)
 73                 goto __error;
 74         snd_i2c_unlock(pt->i2c_bus);
 75 
 76         return 0;
 77 
 78       __error:
 79         snd_i2c_unlock(pt->i2c_bus);
 80         snd_printk(KERN_ERR "PT2258 reset failed\n");
 81         return -EIO;
 82 }
 83 
 84 static int pt2258_stereo_volume_info(struct snd_kcontrol *kcontrol,
 85                                      struct snd_ctl_elem_info *uinfo)
 86 {
 87         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 88         uinfo->count = 2;
 89         uinfo->value.integer.min = 0;
 90         uinfo->value.integer.max = 79;
 91         return 0;
 92 }
 93 
 94 static int pt2258_stereo_volume_get(struct snd_kcontrol *kcontrol,
 95                                     struct snd_ctl_elem_value *ucontrol)
 96 {
 97         struct snd_pt2258 *pt = kcontrol->private_data;
 98         int base = kcontrol->private_value;
 99 
100         /* chip does not support register reads */
101         ucontrol->value.integer.value[0] = 79 - pt->volume[base];
102         ucontrol->value.integer.value[1] = 79 - pt->volume[base + 1];
103         return 0;
104 }
105 
106 static int pt2258_stereo_volume_put(struct snd_kcontrol *kcontrol,
107                                     struct snd_ctl_elem_value *ucontrol)
108 {
109         struct snd_pt2258 *pt = kcontrol->private_data;
110         int base = kcontrol->private_value;
111         unsigned char bytes[2];
112         int val0, val1;
113 
114         val0 = 79 - ucontrol->value.integer.value[0];
115         val1 = 79 - ucontrol->value.integer.value[1];
116         if (val0 < 0 || val0 > 79 || val1 < 0 || val1 > 79)
117                 return -EINVAL;
118         if (val0 == pt->volume[base] && val1 == pt->volume[base + 1])
119                 return 0;
120 
121         pt->volume[base] = val0;
122         bytes[0] = pt2258_channel_code[2 * base] | (val0 / 10);
123         bytes[1] = pt2258_channel_code[2 * base + 1] | (val0 % 10);
124         snd_i2c_lock(pt->i2c_bus);
125         if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 2) != 2)
126                 goto __error;
127         snd_i2c_unlock(pt->i2c_bus);
128 
129         pt->volume[base + 1] = val1;
130         bytes[0] = pt2258_channel_code[2 * base + 2] | (val1 / 10);
131         bytes[1] = pt2258_channel_code[2 * base + 3] | (val1 % 10);
132         snd_i2c_lock(pt->i2c_bus);
133         if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 2) != 2)
134                 goto __error;
135         snd_i2c_unlock(pt->i2c_bus);
136 
137         return 1;
138 
139       __error:
140         snd_i2c_unlock(pt->i2c_bus);
141         snd_printk(KERN_ERR "PT2258 access failed\n");
142         return -EIO;
143 }
144 
145 #define pt2258_switch_info      snd_ctl_boolean_mono_info
146 
147 static int pt2258_switch_get(struct snd_kcontrol *kcontrol,
148                              struct snd_ctl_elem_value *ucontrol)
149 {
150         struct snd_pt2258 *pt = kcontrol->private_data;
151 
152         ucontrol->value.integer.value[0] = !pt->mute;
153         return 0;
154 }
155 
156 static int pt2258_switch_put(struct snd_kcontrol *kcontrol,
157                              struct snd_ctl_elem_value *ucontrol)
158 {
159         struct snd_pt2258 *pt = kcontrol->private_data;
160         unsigned char bytes[2];
161         int val;
162 
163         val = !ucontrol->value.integer.value[0];
164         if (pt->mute == val)
165                 return 0;
166 
167         pt->mute = val;
168         bytes[0] = val ? PT2258_CMD_MUTE : PT2258_CMD_UNMUTE;
169         snd_i2c_lock(pt->i2c_bus);
170         if (snd_i2c_sendbytes(pt->i2c_dev, bytes, 1) != 1)
171                 goto __error;
172         snd_i2c_unlock(pt->i2c_bus);
173 
174         return 1;
175 
176       __error:
177         snd_i2c_unlock(pt->i2c_bus);
178         snd_printk(KERN_ERR "PT2258 access failed 2\n");
179         return -EIO;
180 }
181 
182 static const DECLARE_TLV_DB_SCALE(pt2258_db_scale, -7900, 100, 0);
183 
184 int snd_pt2258_build_controls(struct snd_pt2258 *pt)
185 {
186         struct snd_kcontrol_new knew;
187         char *names[3] = {
188                 "Mic Loopback Playback Volume",
189                 "Line Loopback Playback Volume",
190                 "CD Loopback Playback Volume"
191         };
192         int i, err;
193 
194         for (i = 0; i < 3; ++i) {
195                 memset(&knew, 0, sizeof(knew));
196                 knew.name = names[i];
197                 knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
198                 knew.count = 1;
199                 knew.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
200                     SNDRV_CTL_ELEM_ACCESS_TLV_READ;
201                 knew.private_value = 2 * i;
202                 knew.info = pt2258_stereo_volume_info;
203                 knew.get = pt2258_stereo_volume_get;
204                 knew.put = pt2258_stereo_volume_put;
205                 knew.tlv.p = pt2258_db_scale;
206 
207                 err = snd_ctl_add(pt->card, snd_ctl_new1(&knew, pt));
208                 if (err < 0)
209                         return err;
210         }
211 
212         memset(&knew, 0, sizeof(knew));
213         knew.name = "Loopback Switch";
214         knew.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
215         knew.info = pt2258_switch_info;
216         knew.get = pt2258_switch_get;
217         knew.put = pt2258_switch_put;
218         knew.access = 0;
219         err = snd_ctl_add(pt->card, snd_ctl_new1(&knew, pt));
220         if (err < 0)
221                 return err;
222 
223         return 0;
224 }
225 
226 EXPORT_SYMBOL(snd_pt2258_reset);
227 EXPORT_SYMBOL(snd_pt2258_build_controls);
228 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp