1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #ifndef _AUDIO_CLIENT_H 28 #define _AUDIO_CLIENT_H 29 30 /* 31 * Structure implementation in audio_impl.h 32 */ 33 #include <sys/audio/audio_common.h> 34 35 typedef struct audio_client_ops { 36 const char *aco_minor_prefix; 37 void *(*aco_dev_init)(audio_dev_t *); 38 void (*aco_dev_fini)(void *); 39 int (*aco_open)(audio_client_t *, int); 40 void (*aco_close)(audio_client_t *); 41 int (*aco_read)(audio_client_t *, struct uio *, cred_t *); 42 int (*aco_write)(audio_client_t *, struct uio *, cred_t *); 43 int (*aco_ioctl)(audio_client_t *, int, intptr_t, int, 44 cred_t *, int *); 45 int (*aco_chpoll)(audio_client_t *, short, int, short *, 46 struct pollhead **); 47 int (*aco_mmap)(audio_client_t *, ...); 48 void (*aco_input)(audio_client_t *); 49 void (*aco_output)(audio_client_t *); 50 void (*aco_drain)(audio_client_t *); 51 52 void (*aco_wput)(audio_client_t *, mblk_t *); 53 void (*aco_wsrv)(audio_client_t *); 54 void (*aco_rsrv)(audio_client_t *); 55 } audio_client_ops_t; 56 57 void *auclnt_get_private(audio_client_t *); 58 void auclnt_set_private(audio_client_t *, void *); 59 60 int auclnt_drain(audio_client_t *); 61 int auclnt_start_drain(audio_client_t *); 62 63 int auclnt_set_rate(audio_stream_t *, int); 64 int auclnt_get_rate(audio_stream_t *); 65 66 int auclnt_set_format(audio_stream_t *, int); 67 int auclnt_get_format(audio_stream_t *); 68 69 int auclnt_set_channels(audio_stream_t *, int); 70 int auclnt_get_channels(audio_stream_t *); 71 72 void auclnt_set_gain(audio_stream_t *, uint8_t); 73 uint8_t auclnt_get_gain(audio_stream_t *); 74 75 void auclnt_set_muted(audio_stream_t *, boolean_t); 76 boolean_t auclnt_get_muted(audio_stream_t *); 77 78 uint64_t auclnt_get_samples(audio_stream_t *); 79 void auclnt_set_samples(audio_stream_t *, uint64_t); 80 81 uint64_t auclnt_get_errors(audio_stream_t *); 82 void auclnt_set_errors(audio_stream_t *, uint64_t); 83 84 uint64_t auclnt_get_eof(audio_stream_t *); 85 void auclnt_set_eof(audio_stream_t *, uint64_t); 86 87 boolean_t auclnt_is_running(audio_stream_t *); 88 void auclnt_start(audio_stream_t *); 89 void auclnt_stop(audio_stream_t *); 90 91 void auclnt_set_paused(audio_stream_t *); 92 void auclnt_clear_paused(audio_stream_t *); 93 boolean_t auclnt_is_paused(audio_stream_t *); 94 95 void auclnt_flush(audio_stream_t *); 96 97 void auclnt_get_output_qlen(audio_client_t *, uint_t *, uint_t *); 98 99 uint_t auclnt_get_fragsz(audio_stream_t *); 100 uint_t auclnt_get_framesz(audio_stream_t *); 101 uint_t auclnt_get_nfrags(audio_stream_t *); 102 uint_t auclnt_get_nframes(audio_stream_t *); 103 uint_t auclnt_get_count(audio_stream_t *); 104 uint64_t auclnt_get_head(audio_stream_t *); 105 uint64_t auclnt_get_tail(audio_stream_t *); 106 uint_t auclnt_get_hidx(audio_stream_t *); 107 uint_t auclnt_get_tidx(audio_stream_t *); 108 109 void auclnt_set_latency(audio_stream_t *, uint_t, uint_t); 110 111 audio_stream_t *auclnt_input_stream(audio_client_t *); 112 audio_stream_t *auclnt_output_stream(audio_client_t *); 113 114 int auclnt_get_oflag(audio_client_t *); 115 116 int auclnt_open(audio_client_t *, uint_t, int); 117 void auclnt_close(audio_client_t *); 118 119 void auclnt_register_ops(minor_t, audio_client_ops_t *); 120 121 minor_t auclnt_get_minor(audio_client_t *); 122 minor_t auclnt_get_original_minor(audio_client_t *); 123 minor_t auclnt_get_minor_type(audio_client_t *); 124 queue_t *auclnt_get_rq(audio_client_t *); 125 queue_t *auclnt_get_wq(audio_client_t *); 126 127 uint_t auclnt_produce(audio_stream_t *, uint_t); 128 uint_t auclnt_produce_data(audio_stream_t *, caddr_t, uint_t); 129 uint_t auclnt_consume(audio_stream_t *, uint_t); 130 uint_t auclnt_consume_data(audio_stream_t *, caddr_t, uint_t); 131 int auclnt_read(audio_client_t *, struct uio *); 132 int auclnt_write(audio_client_t *, struct uio *); 133 int auclnt_chpoll(audio_client_t *, short, int, short *, struct pollhead **); 134 void auclnt_pollwakeup(audio_client_t *, short); 135 136 /* 137 * Return the process id that performed the original open() of the client. 138 */ 139 pid_t auclnt_get_pid(audio_client_t *); 140 141 /* 142 * Return the credentials of the process that opened the client. 143 */ 144 cred_t *auclnt_get_cred(audio_client_t *); 145 146 /* 147 * Get an opaque handle the underlying device for an audio client. 148 */ 149 audio_dev_t *auclnt_get_dev(audio_client_t *); 150 audio_dev_t *auclnt_hold_dev_by_index(int); 151 void auclnt_release_dev(audio_dev_t *); 152 int auclnt_get_dev_index(audio_dev_t *); 153 int auclnt_get_dev_number(audio_dev_t *); 154 void auclnt_set_dev_number(audio_dev_t *, int); 155 const char *auclnt_get_dev_name(audio_dev_t *); 156 const char *auclnt_get_dev_driver(audio_dev_t *); 157 dev_info_t *auclnt_get_dev_devinfo(audio_dev_t *); 158 int auclnt_get_dev_instance(audio_dev_t *); 159 const char *auclnt_get_dev_description(audio_dev_t *); 160 const char *auclnt_get_dev_version(audio_dev_t *); 161 const char *auclnt_get_dev_hw_info(audio_dev_t *, void **); 162 uint_t auclnt_get_dev_capab(audio_dev_t *); 163 #define AUDIO_CLIENT_CAP_PLAY (1U << 0) 164 #define AUDIO_CLIENT_CAP_RECORD (1U << 1) 165 #define AUDIO_CLIENT_CAP_DUPLEX (1U << 2) 166 #define AUDIO_CLIENT_CAP_SNDSTAT (1U << 3) 167 #define AUDIO_CLIENT_CAP_OPAQUE (1U << 4) 168 169 /* 170 * Walk all the open client structures for a named audio device. 171 * Clients can use this to find "peer" clients accessing the same 172 * audio device. (This is useful for implementing special linkages, 173 * e.g. between /dev/audio and /dev/audioctl.) 174 */ 175 void auclnt_dev_walk_clients(audio_dev_t *, 176 int (*)(audio_client_t *, void *), void *); 177 178 /* 179 * This is used to check for updates to volume and control status. 180 * Its a polling-based interface because that's what our clients (OSS) 181 * need, and its far lighter weight than forcing an asynchronous 182 * callback on everything. 183 */ 184 uint_t auclnt_dev_get_serial(audio_dev_t *); 185 186 /* 187 * Audio control functions for use by clients. 188 */ 189 190 /* 191 * This will walk all controls registered to my device and callback 192 * to walker for each one with its audio_ctrl_desc_t.. 193 * 194 * Note that walk_func may return values to continue (AUDIO_WALK_CONTINUE) 195 * or stop walk (AUDIO_WALK_STOP). 196 * 197 */ 198 void auclnt_walk_controls(audio_dev_t *, 199 int (*)(audio_ctrl_t *, void *), void *); 200 201 /* 202 * This will search all controls attached to a clients 203 * audio device for a control with the desired name. 204 * 205 * On successful return a ctrl handle will be returned. On 206 * failure NULL is returned. 207 */ 208 audio_ctrl_t *auclnt_find_control(audio_dev_t *, const char *); 209 210 /* 211 * Given a known control, get its attributes. 212 * 213 * The caller must supply a audio_ctrl_desc_t structure. Also the 214 * values in the structure are ignored when making the call and filled 215 * in by this function. 216 * 217 * If an error occurs then a non-zero is returned. 218 */ 219 int auclnt_control_describe(audio_ctrl_t *, audio_ctrl_desc_t *); 220 221 222 /* 223 * This is used to read the current value of a control. 224 * Note, this will cause a callback into the driver to get the value. 225 * 226 * On return zero is returned on success else errno is returned. 227 */ 228 int auclnt_control_read(audio_ctrl_t *, uint64_t *); 229 230 /* 231 * This is used to write a value to a control. 232 * Note, this will cause a callback into the driver to write the value. 233 * 234 * On return zero is returned on success else errno is returned. 235 * 236 */ 237 int auclnt_control_write(audio_ctrl_t *, uint64_t); 238 239 /* 240 * Walk all the audio devices on the system. Useful for clients 241 * like sndstat, which may need to inquire about every audio device 242 * on the system. 243 */ 244 void auclnt_walk_devs(int (*walker)(audio_dev_t *, void *), void *); 245 void auclnt_walk_devs_by_number(int (*walker)(audio_dev_t *, void *), void *); 246 247 audio_client_t *auclnt_hold_by_devt(dev_t); 248 void auclnt_release(audio_client_t *); 249 void auclnt_hold(audio_client_t *); 250 int auclnt_serialize(audio_client_t *); 251 void auclnt_unserialize(audio_client_t *); 252 253 /* 254 * Engine rlated accesses. Note that normally clients don't need this level 255 * of information. 256 */ 257 void auclnt_dev_walk_engines(audio_dev_t *, 258 int (*)(audio_engine_t *, void *), void *); 259 int auclnt_engine_get_format(audio_engine_t *); 260 int auclnt_engine_get_rate(audio_engine_t *); 261 int auclnt_engine_get_channels(audio_engine_t *); 262 uint_t auclnt_engine_get_capab(audio_engine_t *); 263 264 /* 265 * Retrieve minor-specific data for the instance. This allows for 266 * personality modules to store persistent state data on a physical 267 * device (e.g. to store persistent settings.) Synchronization of 268 * stored settings between personality modules is up to the 269 * personality modules themselves. 270 */ 271 void *auclnt_get_minor_data(audio_client_t *, minor_t); 272 void *auclnt_get_dev_minor_data(audio_dev_t *, minor_t); 273 274 /* 275 * Simpler warning message, alternative to cmn_err. 276 */ 277 void auclnt_warn(audio_client_t *, const char *fmt, ...); 278 279 #endif /* _AUDIO_CLIENT_H */ 280