sound/i2c/other/pt2258.c

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