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