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

TOMOYO Linux Cross Reference
Linux/sound/soc/codecs/tpa6130a2.c

Version: ~ [ linux-5.6-rc1 ] ~ [ linux-5.5.2 ] ~ [ linux-5.4.17 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.102 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.170 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.213 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.213 ] ~ [ 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.81 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ 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 SoC Texas Instruments TPA6130A2 headset stereo amplifier driver
  3  *
  4  * Copyright (C) Nokia Corporation
  5  *
  6  * Author: Peter Ujfalusi <peter.ujfalusi@ti.com>
  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
 10  * version 2 as published by the Free Software Foundation.
 11  *
 12  * This program is distributed in the hope that it will be useful, but
 13  * WITHOUT ANY WARRANTY; without even the implied warranty of
 14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 15  * General Public License for more details.
 16  *
 17  * You should have received a copy of the GNU General Public License
 18  * along with this program; if not, write to the Free Software
 19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 20  * 02110-1301 USA
 21  */
 22 
 23 #include <linux/module.h>
 24 #include <linux/errno.h>
 25 #include <linux/device.h>
 26 #include <linux/i2c.h>
 27 #include <linux/gpio.h>
 28 #include <linux/regulator/consumer.h>
 29 #include <linux/slab.h>
 30 #include <sound/tpa6130a2-plat.h>
 31 #include <sound/soc.h>
 32 #include <sound/tlv.h>
 33 
 34 #include "tpa6130a2.h"
 35 
 36 enum tpa_model {
 37         TPA6130A2,
 38         TPA6140A2,
 39 };
 40 
 41 static struct i2c_client *tpa6130a2_client;
 42 
 43 /* This struct is used to save the context */
 44 struct tpa6130a2_data {
 45         struct mutex mutex;
 46         unsigned char regs[TPA6130A2_CACHEREGNUM];
 47         struct regulator *supply;
 48         int power_gpio;
 49         u8 power_state:1;
 50         enum tpa_model id;
 51 };
 52 
 53 static int tpa6130a2_i2c_read(int reg)
 54 {
 55         struct tpa6130a2_data *data;
 56         int val;
 57 
 58         BUG_ON(tpa6130a2_client == NULL);
 59         data = i2c_get_clientdata(tpa6130a2_client);
 60 
 61         /* If powered off, return the cached value */
 62         if (data->power_state) {
 63                 val = i2c_smbus_read_byte_data(tpa6130a2_client, reg);
 64                 if (val < 0)
 65                         dev_err(&tpa6130a2_client->dev, "Read failed\n");
 66                 else
 67                         data->regs[reg] = val;
 68         } else {
 69                 val = data->regs[reg];
 70         }
 71 
 72         return val;
 73 }
 74 
 75 static int tpa6130a2_i2c_write(int reg, u8 value)
 76 {
 77         struct tpa6130a2_data *data;
 78         int val = 0;
 79 
 80         BUG_ON(tpa6130a2_client == NULL);
 81         data = i2c_get_clientdata(tpa6130a2_client);
 82 
 83         if (data->power_state) {
 84                 val = i2c_smbus_write_byte_data(tpa6130a2_client, reg, value);
 85                 if (val < 0) {
 86                         dev_err(&tpa6130a2_client->dev, "Write failed\n");
 87                         return val;
 88                 }
 89         }
 90 
 91         /* Either powered on or off, we save the context */
 92         data->regs[reg] = value;
 93 
 94         return val;
 95 }
 96 
 97 static u8 tpa6130a2_read(int reg)
 98 {
 99         struct tpa6130a2_data *data;
100 
101         BUG_ON(tpa6130a2_client == NULL);
102         data = i2c_get_clientdata(tpa6130a2_client);
103 
104         return data->regs[reg];
105 }
106 
107 static int tpa6130a2_initialize(void)
108 {
109         struct tpa6130a2_data *data;
110         int i, ret = 0;
111 
112         BUG_ON(tpa6130a2_client == NULL);
113         data = i2c_get_clientdata(tpa6130a2_client);
114 
115         for (i = 1; i < TPA6130A2_REG_VERSION; i++) {
116                 ret = tpa6130a2_i2c_write(i, data->regs[i]);
117                 if (ret < 0)
118                         break;
119         }
120 
121         return ret;
122 }
123 
124 static int tpa6130a2_power(u8 power)
125 {
126         struct  tpa6130a2_data *data;
127         u8      val;
128         int     ret = 0;
129 
130         BUG_ON(tpa6130a2_client == NULL);
131         data = i2c_get_clientdata(tpa6130a2_client);
132 
133         mutex_lock(&data->mutex);
134         if (power == data->power_state)
135                 goto exit;
136 
137         if (power) {
138                 ret = regulator_enable(data->supply);
139                 if (ret != 0) {
140                         dev_err(&tpa6130a2_client->dev,
141                                 "Failed to enable supply: %d\n", ret);
142                         goto exit;
143                 }
144                 /* Power on */
145                 if (data->power_gpio >= 0)
146                         gpio_set_value(data->power_gpio, 1);
147 
148                 data->power_state = 1;
149                 ret = tpa6130a2_initialize();
150                 if (ret < 0) {
151                         dev_err(&tpa6130a2_client->dev,
152                                 "Failed to initialize chip\n");
153                         if (data->power_gpio >= 0)
154                                 gpio_set_value(data->power_gpio, 0);
155                         regulator_disable(data->supply);
156                         data->power_state = 0;
157                         goto exit;
158                 }
159         } else {
160                 /* set SWS */
161                 val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
162                 val |= TPA6130A2_SWS;
163                 tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
164 
165                 /* Power off */
166                 if (data->power_gpio >= 0)
167                         gpio_set_value(data->power_gpio, 0);
168 
169                 ret = regulator_disable(data->supply);
170                 if (ret != 0) {
171                         dev_err(&tpa6130a2_client->dev,
172                                 "Failed to disable supply: %d\n", ret);
173                         goto exit;
174                 }
175 
176                 data->power_state = 0;
177         }
178 
179 exit:
180         mutex_unlock(&data->mutex);
181         return ret;
182 }
183 
184 static int tpa6130a2_get_volsw(struct snd_kcontrol *kcontrol,
185                 struct snd_ctl_elem_value *ucontrol)
186 {
187         struct soc_mixer_control *mc =
188                 (struct soc_mixer_control *)kcontrol->private_value;
189         struct tpa6130a2_data *data;
190         unsigned int reg = mc->reg;
191         unsigned int shift = mc->shift;
192         int max = mc->max;
193         unsigned int mask = (1 << fls(max)) - 1;
194         unsigned int invert = mc->invert;
195 
196         BUG_ON(tpa6130a2_client == NULL);
197         data = i2c_get_clientdata(tpa6130a2_client);
198 
199         mutex_lock(&data->mutex);
200 
201         ucontrol->value.integer.value[0] =
202                 (tpa6130a2_read(reg) >> shift) & mask;
203 
204         if (invert)
205                 ucontrol->value.integer.value[0] =
206                         max - ucontrol->value.integer.value[0];
207 
208         mutex_unlock(&data->mutex);
209         return 0;
210 }
211 
212 static int tpa6130a2_put_volsw(struct snd_kcontrol *kcontrol,
213                 struct snd_ctl_elem_value *ucontrol)
214 {
215         struct soc_mixer_control *mc =
216                 (struct soc_mixer_control *)kcontrol->private_value;
217         struct tpa6130a2_data *data;
218         unsigned int reg = mc->reg;
219         unsigned int shift = mc->shift;
220         int max = mc->max;
221         unsigned int mask = (1 << fls(max)) - 1;
222         unsigned int invert = mc->invert;
223         unsigned int val = (ucontrol->value.integer.value[0] & mask);
224         unsigned int val_reg;
225 
226         BUG_ON(tpa6130a2_client == NULL);
227         data = i2c_get_clientdata(tpa6130a2_client);
228 
229         if (invert)
230                 val = max - val;
231 
232         mutex_lock(&data->mutex);
233 
234         val_reg = tpa6130a2_read(reg);
235         if (((val_reg >> shift) & mask) == val) {
236                 mutex_unlock(&data->mutex);
237                 return 0;
238         }
239 
240         val_reg &= ~(mask << shift);
241         val_reg |= val << shift;
242         tpa6130a2_i2c_write(reg, val_reg);
243 
244         mutex_unlock(&data->mutex);
245 
246         return 1;
247 }
248 
249 /*
250  * TPA6130 volume. From -59.5 to 4 dB with increasing step size when going
251  * down in gain.
252  */
253 static const unsigned int tpa6130_tlv[] = {
254         TLV_DB_RANGE_HEAD(10),
255         0, 1, TLV_DB_SCALE_ITEM(-5950, 600, 0),
256         2, 3, TLV_DB_SCALE_ITEM(-5000, 250, 0),
257         4, 5, TLV_DB_SCALE_ITEM(-4550, 160, 0),
258         6, 7, TLV_DB_SCALE_ITEM(-4140, 190, 0),
259         8, 9, TLV_DB_SCALE_ITEM(-3650, 120, 0),
260         10, 11, TLV_DB_SCALE_ITEM(-3330, 160, 0),
261         12, 13, TLV_DB_SCALE_ITEM(-3040, 180, 0),
262         14, 20, TLV_DB_SCALE_ITEM(-2710, 110, 0),
263         21, 37, TLV_DB_SCALE_ITEM(-1960, 74, 0),
264         38, 63, TLV_DB_SCALE_ITEM(-720, 45, 0),
265 };
266 
267 static const struct snd_kcontrol_new tpa6130a2_controls[] = {
268         SOC_SINGLE_EXT_TLV("TPA6130A2 Headphone Playback Volume",
269                        TPA6130A2_REG_VOL_MUTE, 0, 0x3f, 0,
270                        tpa6130a2_get_volsw, tpa6130a2_put_volsw,
271                        tpa6130_tlv),
272 };
273 
274 static const unsigned int tpa6140_tlv[] = {
275         TLV_DB_RANGE_HEAD(3),
276         0, 8, TLV_DB_SCALE_ITEM(-5900, 400, 0),
277         9, 16, TLV_DB_SCALE_ITEM(-2500, 200, 0),
278         17, 31, TLV_DB_SCALE_ITEM(-1000, 100, 0),
279 };
280 
281 static const struct snd_kcontrol_new tpa6140a2_controls[] = {
282         SOC_SINGLE_EXT_TLV("TPA6140A2 Headphone Playback Volume",
283                        TPA6130A2_REG_VOL_MUTE, 1, 0x1f, 0,
284                        tpa6130a2_get_volsw, tpa6130a2_put_volsw,
285                        tpa6140_tlv),
286 };
287 
288 /*
289  * Enable or disable channel (left or right)
290  * The bit number for mute and amplifier are the same per channel:
291  * bit 6: Right channel
292  * bit 7: Left channel
293  * in both registers.
294  */
295 static void tpa6130a2_channel_enable(u8 channel, int enable)
296 {
297         u8      val;
298 
299         if (enable) {
300                 /* Enable channel */
301                 /* Enable amplifier */
302                 val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
303                 val |= channel;
304                 val &= ~TPA6130A2_SWS;
305                 tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
306 
307                 /* Unmute channel */
308                 val = tpa6130a2_read(TPA6130A2_REG_VOL_MUTE);
309                 val &= ~channel;
310                 tpa6130a2_i2c_write(TPA6130A2_REG_VOL_MUTE, val);
311         } else {
312                 /* Disable channel */
313                 /* Mute channel */
314                 val = tpa6130a2_read(TPA6130A2_REG_VOL_MUTE);
315                 val |= channel;
316                 tpa6130a2_i2c_write(TPA6130A2_REG_VOL_MUTE, val);
317 
318                 /* Disable amplifier */
319                 val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
320                 val &= ~channel;
321                 tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
322         }
323 }
324 
325 int tpa6130a2_stereo_enable(struct snd_soc_codec *codec, int enable)
326 {
327         int ret = 0;
328         if (enable) {
329                 ret = tpa6130a2_power(1);
330                 if (ret < 0)
331                         return ret;
332                 tpa6130a2_channel_enable(TPA6130A2_HP_EN_R | TPA6130A2_HP_EN_L,
333                                          1);
334         } else {
335                 tpa6130a2_channel_enable(TPA6130A2_HP_EN_R | TPA6130A2_HP_EN_L,
336                                          0);
337                 ret = tpa6130a2_power(0);
338         }
339 
340         return ret;
341 }
342 EXPORT_SYMBOL_GPL(tpa6130a2_stereo_enable);
343 
344 int tpa6130a2_add_controls(struct snd_soc_codec *codec)
345 {
346         struct  tpa6130a2_data *data;
347 
348         if (tpa6130a2_client == NULL)
349                 return -ENODEV;
350 
351         data = i2c_get_clientdata(tpa6130a2_client);
352 
353         if (data->id == TPA6140A2)
354                 return snd_soc_add_codec_controls(codec, tpa6140a2_controls,
355                                                 ARRAY_SIZE(tpa6140a2_controls));
356         else
357                 return snd_soc_add_codec_controls(codec, tpa6130a2_controls,
358                                                 ARRAY_SIZE(tpa6130a2_controls));
359 }
360 EXPORT_SYMBOL_GPL(tpa6130a2_add_controls);
361 
362 static int tpa6130a2_probe(struct i2c_client *client,
363                            const struct i2c_device_id *id)
364 {
365         struct device *dev;
366         struct tpa6130a2_data *data;
367         struct tpa6130a2_platform_data *pdata;
368         const char *regulator;
369         int ret;
370 
371         dev = &client->dev;
372 
373         if (client->dev.platform_data == NULL) {
374                 dev_err(dev, "Platform data not set\n");
375                 dump_stack();
376                 return -ENODEV;
377         }
378 
379         data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
380         if (data == NULL) {
381                 dev_err(dev, "Can not allocate memory\n");
382                 return -ENOMEM;
383         }
384 
385         tpa6130a2_client = client;
386 
387         i2c_set_clientdata(tpa6130a2_client, data);
388 
389         pdata = client->dev.platform_data;
390         data->power_gpio = pdata->power_gpio;
391         data->id = id->driver_data;
392 
393         mutex_init(&data->mutex);
394 
395         /* Set default register values */
396         data->regs[TPA6130A2_REG_CONTROL] =     TPA6130A2_SWS;
397         data->regs[TPA6130A2_REG_VOL_MUTE] =    TPA6130A2_MUTE_R |
398                                                 TPA6130A2_MUTE_L;
399 
400         if (data->power_gpio >= 0) {
401                 ret = devm_gpio_request(dev, data->power_gpio,
402                                         "tpa6130a2 enable");
403                 if (ret < 0) {
404                         dev_err(dev, "Failed to request power GPIO (%d)\n",
405                                 data->power_gpio);
406                         goto err_gpio;
407                 }
408                 gpio_direction_output(data->power_gpio, 0);
409         }
410 
411         switch (data->id) {
412         default:
413                 dev_warn(dev, "Unknown TPA model (%d). Assuming 6130A2\n",
414                          data->id);
415         case TPA6130A2:
416                 regulator = "Vdd";
417                 break;
418         case TPA6140A2:
419                 regulator = "AVdd";
420                 break;
421         }
422 
423         data->supply = devm_regulator_get(dev, regulator);
424         if (IS_ERR(data->supply)) {
425                 ret = PTR_ERR(data->supply);
426                 dev_err(dev, "Failed to request supply: %d\n", ret);
427                 goto err_gpio;
428         }
429 
430         ret = tpa6130a2_power(1);
431         if (ret != 0)
432                 goto err_gpio;
433 
434 
435         /* Read version */
436         ret = tpa6130a2_i2c_read(TPA6130A2_REG_VERSION) &
437                                  TPA6130A2_VERSION_MASK;
438         if ((ret != 1) && (ret != 2))
439                 dev_warn(dev, "UNTESTED version detected (%d)\n", ret);
440 
441         /* Disable the chip */
442         ret = tpa6130a2_power(0);
443         if (ret != 0)
444                 goto err_gpio;
445 
446         return 0;
447 
448 err_gpio:
449         tpa6130a2_client = NULL;
450 
451         return ret;
452 }
453 
454 static int tpa6130a2_remove(struct i2c_client *client)
455 {
456         tpa6130a2_power(0);
457         tpa6130a2_client = NULL;
458 
459         return 0;
460 }
461 
462 static const struct i2c_device_id tpa6130a2_id[] = {
463         { "tpa6130a2", TPA6130A2 },
464         { "tpa6140a2", TPA6140A2 },
465         { }
466 };
467 MODULE_DEVICE_TABLE(i2c, tpa6130a2_id);
468 
469 static struct i2c_driver tpa6130a2_i2c_driver = {
470         .driver = {
471                 .name = "tpa6130a2",
472                 .owner = THIS_MODULE,
473         },
474         .probe = tpa6130a2_probe,
475         .remove = tpa6130a2_remove,
476         .id_table = tpa6130a2_id,
477 };
478 
479 module_i2c_driver(tpa6130a2_i2c_driver);
480 
481 MODULE_AUTHOR("Peter Ujfalusi <peter.ujfalusi@ti.com>");
482 MODULE_DESCRIPTION("TPA6130A2 Headphone amplifier driver");
483 MODULE_LICENSE("GPL");
484 

~ [ 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