1 #ifndef __SOUND_CONTROL_H 2 #define __SOUND_CONTROL_H 3 4 /* 5 * Header file for control interface 6 * Copyright (c) by Jaroslav Kysela <perex@perex.cz> 7 * 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, write to the Free Software 21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 * 23 */ 24 25 #include <linux/wait.h> 26 #include <linux/nospec.h> 27 #include <sound/asound.h> 28 29 #define snd_kcontrol_chip(kcontrol) ((kcontrol)->private_data) 30 31 struct snd_kcontrol; 32 typedef int (snd_kcontrol_info_t) (struct snd_kcontrol * kcontrol, struct snd_ctl_elem_info * uinfo); 33 typedef int (snd_kcontrol_get_t) (struct snd_kcontrol * kcontrol, struct snd_ctl_elem_value * ucontrol); 34 typedef int (snd_kcontrol_put_t) (struct snd_kcontrol * kcontrol, struct snd_ctl_elem_value * ucontrol); 35 typedef int (snd_kcontrol_tlv_rw_t)(struct snd_kcontrol *kcontrol, 36 int op_flag, /* SNDRV_CTL_TLV_OP_XXX */ 37 unsigned int size, 38 unsigned int __user *tlv); 39 40 enum { 41 SNDRV_CTL_TLV_OP_READ = 0, 42 SNDRV_CTL_TLV_OP_WRITE = 1, 43 SNDRV_CTL_TLV_OP_CMD = -1, 44 }; 45 46 struct snd_kcontrol_new { 47 snd_ctl_elem_iface_t iface; /* interface identifier */ 48 unsigned int device; /* device/client number */ 49 unsigned int subdevice; /* subdevice (substream) number */ 50 const unsigned char *name; /* ASCII name of item */ 51 unsigned int index; /* index of item */ 52 unsigned int access; /* access rights */ 53 unsigned int count; /* count of same elements */ 54 snd_kcontrol_info_t *info; 55 snd_kcontrol_get_t *get; 56 snd_kcontrol_put_t *put; 57 union { 58 snd_kcontrol_tlv_rw_t *c; 59 const unsigned int *p; 60 } tlv; 61 unsigned long private_value; 62 }; 63 64 struct snd_kcontrol_volatile { 65 struct snd_ctl_file *owner; /* locked */ 66 unsigned int access; /* access rights */ 67 }; 68 69 struct snd_kcontrol { 70 struct list_head list; /* list of controls */ 71 struct snd_ctl_elem_id id; 72 unsigned int count; /* count of same elements */ 73 snd_kcontrol_info_t *info; 74 snd_kcontrol_get_t *get; 75 snd_kcontrol_put_t *put; 76 union { 77 snd_kcontrol_tlv_rw_t *c; 78 const unsigned int *p; 79 } tlv; 80 unsigned long private_value; 81 void *private_data; 82 void (*private_free)(struct snd_kcontrol *kcontrol); 83 struct snd_kcontrol_volatile vd[0]; /* volatile data */ 84 }; 85 86 #define snd_kcontrol(n) list_entry(n, struct snd_kcontrol, list) 87 88 struct snd_kctl_event { 89 struct list_head list; /* list of events */ 90 struct snd_ctl_elem_id id; 91 unsigned int mask; 92 }; 93 94 #define snd_kctl_event(n) list_entry(n, struct snd_kctl_event, list) 95 96 struct pid; 97 98 enum { 99 SND_CTL_SUBDEV_PCM, 100 SND_CTL_SUBDEV_RAWMIDI, 101 SND_CTL_SUBDEV_ITEMS, 102 }; 103 104 struct snd_ctl_file { 105 struct list_head list; /* list of all control files */ 106 struct snd_card *card; 107 struct pid *pid; 108 int preferred_subdevice[SND_CTL_SUBDEV_ITEMS]; 109 wait_queue_head_t change_sleep; 110 spinlock_t read_lock; 111 struct fasync_struct *fasync; 112 int subscribed; /* read interface is activated */ 113 struct list_head events; /* waiting events for read */ 114 }; 115 116 #define snd_ctl_file(n) list_entry(n, struct snd_ctl_file, list) 117 118 typedef int (*snd_kctl_ioctl_func_t) (struct snd_card * card, 119 struct snd_ctl_file * control, 120 unsigned int cmd, unsigned long arg); 121 122 void snd_ctl_notify(struct snd_card * card, unsigned int mask, struct snd_ctl_elem_id * id); 123 124 struct snd_kcontrol *snd_ctl_new1(const struct snd_kcontrol_new * kcontrolnew, void * private_data); 125 void snd_ctl_free_one(struct snd_kcontrol * kcontrol); 126 int snd_ctl_add(struct snd_card * card, struct snd_kcontrol * kcontrol); 127 int snd_ctl_remove(struct snd_card * card, struct snd_kcontrol * kcontrol); 128 int snd_ctl_replace(struct snd_card *card, struct snd_kcontrol *kcontrol, bool add_on_replace); 129 int snd_ctl_remove_id(struct snd_card * card, struct snd_ctl_elem_id *id); 130 int snd_ctl_rename_id(struct snd_card * card, struct snd_ctl_elem_id *src_id, struct snd_ctl_elem_id *dst_id); 131 int snd_ctl_activate_id(struct snd_card *card, struct snd_ctl_elem_id *id, 132 int active); 133 struct snd_kcontrol *snd_ctl_find_numid(struct snd_card * card, unsigned int numid); 134 struct snd_kcontrol *snd_ctl_find_id(struct snd_card * card, struct snd_ctl_elem_id *id); 135 136 int snd_ctl_create(struct snd_card *card); 137 138 int snd_ctl_register_ioctl(snd_kctl_ioctl_func_t fcn); 139 int snd_ctl_unregister_ioctl(snd_kctl_ioctl_func_t fcn); 140 #ifdef CONFIG_COMPAT 141 int snd_ctl_register_ioctl_compat(snd_kctl_ioctl_func_t fcn); 142 int snd_ctl_unregister_ioctl_compat(snd_kctl_ioctl_func_t fcn); 143 #else 144 #define snd_ctl_register_ioctl_compat(fcn) 145 #define snd_ctl_unregister_ioctl_compat(fcn) 146 #endif 147 148 int snd_ctl_get_preferred_subdevice(struct snd_card *card, int type); 149 150 static inline unsigned int snd_ctl_get_ioffnum(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id) 151 { 152 unsigned int ioff = id->numid - kctl->id.numid; 153 return array_index_nospec(ioff, kctl->count); 154 } 155 156 static inline unsigned int snd_ctl_get_ioffidx(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id) 157 { 158 unsigned int ioff = id->index - kctl->id.index; 159 return array_index_nospec(ioff, kctl->count); 160 } 161 162 static inline unsigned int snd_ctl_get_ioff(struct snd_kcontrol *kctl, struct snd_ctl_elem_id *id) 163 { 164 if (id->numid) { 165 return snd_ctl_get_ioffnum(kctl, id); 166 } else { 167 return snd_ctl_get_ioffidx(kctl, id); 168 } 169 } 170 171 static inline struct snd_ctl_elem_id *snd_ctl_build_ioff(struct snd_ctl_elem_id *dst_id, 172 struct snd_kcontrol *src_kctl, 173 unsigned int offset) 174 { 175 *dst_id = src_kctl->id; 176 dst_id->index += offset; 177 dst_id->numid += offset; 178 return dst_id; 179 } 180 181 /* 182 * Frequently used control callbacks/helpers 183 */ 184 int snd_ctl_boolean_mono_info(struct snd_kcontrol *kcontrol, 185 struct snd_ctl_elem_info *uinfo); 186 int snd_ctl_boolean_stereo_info(struct snd_kcontrol *kcontrol, 187 struct snd_ctl_elem_info *uinfo); 188 int snd_ctl_enum_info(struct snd_ctl_elem_info *info, unsigned int channels, 189 unsigned int items, const char *const names[]); 190 191 /* 192 * virtual master control 193 */ 194 struct snd_kcontrol *snd_ctl_make_virtual_master(char *name, 195 const unsigned int *tlv); 196 int _snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave, 197 unsigned int flags); 198 /* optional flags for slave */ 199 #define SND_CTL_SLAVE_NEED_UPDATE (1 << 0) 200 201 /** 202 * snd_ctl_add_slave - Add a virtual slave control 203 * @master: vmaster element 204 * @slave: slave element to add 205 * 206 * Add a virtual slave control to the given master element created via 207 * snd_ctl_create_virtual_master() beforehand. 208 * 209 * All slaves must be the same type (returning the same information 210 * via info callback). The function doesn't check it, so it's your 211 * responsibility. 212 * 213 * Also, some additional limitations: 214 * at most two channels, 215 * logarithmic volume control (dB level) thus no linear volume, 216 * master can only attenuate the volume without gain 217 * 218 * Return: Zero if successful or a negative error code. 219 */ 220 static inline int 221 snd_ctl_add_slave(struct snd_kcontrol *master, struct snd_kcontrol *slave) 222 { 223 return _snd_ctl_add_slave(master, slave, 0); 224 } 225 226 /** 227 * snd_ctl_add_slave_uncached - Add a virtual slave control 228 * @master: vmaster element 229 * @slave: slave element to add 230 * 231 * Add a virtual slave control to the given master. 232 * Unlike snd_ctl_add_slave(), the element added via this function 233 * is supposed to have volatile values, and get callback is called 234 * at each time queried from the master. 235 * 236 * When the control peeks the hardware values directly and the value 237 * can be changed by other means than the put callback of the element, 238 * this function should be used to keep the value always up-to-date. 239 * 240 * Return: Zero if successful or a negative error code. 241 */ 242 static inline int 243 snd_ctl_add_slave_uncached(struct snd_kcontrol *master, 244 struct snd_kcontrol *slave) 245 { 246 return _snd_ctl_add_slave(master, slave, SND_CTL_SLAVE_NEED_UPDATE); 247 } 248 249 int snd_ctl_add_vmaster_hook(struct snd_kcontrol *kctl, 250 void (*hook)(void *private_data, int), 251 void *private_data); 252 void snd_ctl_sync_vmaster(struct snd_kcontrol *kctl, bool hook_only); 253 #define snd_ctl_sync_vmaster_hook(kctl) snd_ctl_sync_vmaster(kctl, true) 254 int snd_ctl_apply_vmaster_slaves(struct snd_kcontrol *kctl, 255 int (*func)(struct snd_kcontrol *vslave, 256 struct snd_kcontrol *slave, 257 void *arg), 258 void *arg); 259 260 /* 261 * Helper functions for jack-detection controls 262 */ 263 struct snd_kcontrol * 264 snd_kctl_jack_new(const char *name, struct snd_card *card); 265 void snd_kctl_jack_report(struct snd_card *card, 266 struct snd_kcontrol *kctl, bool status); 267 268 #endif /* __SOUND_CONTROL_H */ 269