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 * Copyright (C) 4Front Technologies 1996-2008. 23 * 24 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. 25 */ 26 27 #ifndef _AUDIO_IMPL_H 28 #define _AUDIO_IMPL_H 29 30 #include <sys/types.h> 31 #include <sys/list.h> 32 #include <sys/poll.h> 33 34 #include <sys/audio/audio_driver.h> 35 #include "audio_client.h" 36 37 #define AUDIO_MAX_OPENS 256 38 #define AUDIO_MAX_CHANNELS 16 39 #define AUDIO_UNIT_EXPAND 1024 40 #define AUDIO_CHBUFS 2048 /* samples for mixing */ 41 #define AUDIO_VOL_SCALE 256 42 #define AUDIO_DB_SIZE 50 43 44 #define AUDIO_INTRHZ 100 45 #define AUDIO_INTRHZ_MIN 50 /* 20 msec max */ 46 #define AUDIO_INTRHZ_MAX 500 47 48 struct audio_parms { 49 int p_format; 50 int p_rate; 51 int p_nchan; 52 }; 53 54 typedef int (*audio_cnv_func_t)(audio_stream_t *, int); 55 56 struct audio_buffer { 57 caddr_t b_data; 58 uint64_t b_head; 59 uint64_t b_tail; 60 uint_t b_hidx; /* head % nframes */ 61 uint_t b_tidx; /* tail % nframes */ 62 uint_t b_nframes; /* total frames */ 63 uint_t b_framesz; /* bytes per frame */ 64 }; 65 66 /* 67 * struct audio_stream: This structure represents a virtual stream exposed 68 * to a single client. Each client will have at most two of these (one for 69 * record, one for playback.) 70 */ 71 struct audio_stream { 72 audio_buffer_t s_buf; 73 #define s_data s_buf.b_data 74 #define s_bufsz s_buf.b_size 75 #define s_head s_buf.b_head 76 #define s_tail s_buf.b_tail 77 #define s_framesz s_buf.b_framesz 78 #define s_nframes s_buf.b_nframes 79 #define s_tidx s_buf.b_tidx 80 #define s_hidx s_buf.b_hidx 81 uint_t s_nfrags; 82 uint_t s_fragfr; 83 uint_t s_nbytes; 84 uint_t s_fragbytes; 85 ddi_umem_cookie_t s_cookie; 86 uint32_t s_allocsz; 87 uint32_t s_hintsz; /* latency hints */ 88 uint16_t s_hintfrags; 89 90 /* 91 * Various counters. 92 */ 93 uint64_t s_samples; 94 uint64_t s_errors; /* underrun or overrun count */ 95 96 boolean_t s_running; 97 boolean_t s_paused; /* stream paused */ 98 boolean_t s_draining; /* stream draining */ 99 100 /* 101 * Sample rate conversion (SRC) and format conversion details. 102 */ 103 struct grc3state *s_src_state[AUDIO_MAX_CHANNELS]; 104 uint_t s_src_quality; 105 int s_cnv_max; 106 audio_cnv_func_t s_converter; 107 uint32_t *s_cnv_buf0; 108 uint32_t *s_cnv_buf1; 109 void *s_cnv_src; 110 void *s_cnv_dst; 111 audio_parms_t s_cnv_src_parms; 112 #define s_cnv_src_nchan s_cnv_src_parms.p_nchan 113 #define s_cnv_src_rate s_cnv_src_parms.p_rate 114 #define s_cnv_src_format s_cnv_src_parms.p_format 115 116 audio_parms_t s_cnv_dst_parms; 117 #define s_cnv_dst_nchan s_cnv_dst_parms.p_nchan 118 #define s_cnv_dst_rate s_cnv_dst_parms.p_rate 119 #define s_cnv_dst_format s_cnv_dst_parms.p_format 120 121 size_t s_cnv_cnt; 122 int32_t *s_cnv_ptr; 123 124 audio_parms_t *s_user_parms; 125 audio_parms_t *s_phys_parms; 126 127 /* 128 * Volume. 129 */ 130 uint8_t s_gain_master; 131 uint8_t s_gain_pct; 132 uint16_t s_gain_scaled; 133 uint16_t s_gain_eff; 134 boolean_t s_muted; 135 136 /* 137 * Callbacks. 138 */ 139 uint64_t s_drain_idx; /* engine index */ 140 141 /* 142 * Other per stream details, e.g. channel offset, etc. 143 */ 144 kmutex_t s_lock; 145 kcondvar_t s_cv; 146 list_node_t s_eng_linkage; /* place on engine list */ 147 audio_client_t *s_client; 148 audio_engine_t *s_engine; 149 int s_choffs; 150 151 /* 152 * Other bits. 153 */ 154 uint_t s_engcap; /* ENGINE_xxx_CAP */ 155 }; 156 157 /* 158 * struct audio_client: This structure represents a logical port, 159 * associated with an open file, etc. These are the entities that are 160 * mixed. 161 */ 162 struct audio_client { 163 audio_stream_t c_istream; 164 audio_stream_t c_ostream; 165 void *c_private; 166 167 /* 168 * We can keep a linked list of clients to "notify" so that 169 * we can do this outside of locked context. 170 */ 171 audio_client_t *c_next_input; 172 audio_client_t *c_next_output; 173 audio_client_t *c_next_drain; 174 175 /* 176 * DDI support. 177 */ 178 major_t c_major; 179 minor_t c_minor; 180 minor_t c_origminor; 181 queue_t *c_rq; 182 queue_t *c_wq; 183 184 /* 185 * Linkage for per-device list of clients. 186 */ 187 list_node_t c_global_linkage; 188 list_node_t c_dev_linkage; 189 int c_refcnt; 190 boolean_t c_serialize; 191 192 kmutex_t c_lock; 193 kcondvar_t c_cv; 194 boolean_t c_is_active; 195 196 /* 197 * Client wide settings... e.g. ops vector, etc. 198 */ 199 uint_t c_omode; /* open mode */ 200 pid_t c_pid; /* opening process id */ 201 audio_dev_t *c_dev; 202 cred_t *c_cred; 203 audio_client_ops_t c_ops; 204 #define c_open c_ops.aco_open 205 #define c_close c_ops.aco_close 206 #define c_read c_ops.aco_read 207 #define c_write c_ops.aco_write 208 #define c_ioctl c_ops.aco_ioctl 209 #define c_chpoll c_ops.aco_chpoll 210 #define c_output c_ops.aco_output 211 #define c_input c_ops.aco_input 212 #define c_notify c_ops.aco_notify 213 #define c_drain c_ops.aco_drain 214 #define c_wput c_ops.aco_wput 215 #define c_wsrv c_ops.aco_wsrv 216 #define c_rsrv c_ops.aco_rsrv 217 218 struct pollhead c_pollhead; 219 220 }; 221 222 struct audio_infostr { 223 char i_line[100]; 224 list_node_t i_linkage; 225 }; 226 227 struct audio_stats { 228 kstat_named_t st_head; 229 kstat_named_t st_tail; 230 kstat_named_t st_flags; 231 kstat_named_t st_nfrags; 232 kstat_named_t st_framesz; 233 kstat_named_t st_nbytes; 234 kstat_named_t st_hidx; 235 kstat_named_t st_tidx; 236 kstat_named_t st_format; 237 kstat_named_t st_nchan; 238 kstat_named_t st_rate; 239 kstat_named_t st_errors; 240 kstat_named_t st_engine_underruns; 241 kstat_named_t st_engine_overruns; 242 kstat_named_t st_stream_underruns; 243 kstat_named_t st_stream_overruns; 244 kstat_named_t st_playahead; 245 kstat_named_t st_suspended; 246 kstat_named_t st_failed; 247 }; 248 249 typedef void (*audio_import_fn_t)(audio_engine_t *, uint_t, audio_stream_t *); 250 typedef void (*audio_export_fn_t)(audio_engine_t *, uint_t, uint_t); 251 252 /* 253 * An audio engine corresponds to a single DMA transfer channel. It can 254 * represent either record or playback, but not both at the same time. 255 * A device that supports simultaneous record and playback will register 256 * separate channels. 257 */ 258 struct audio_engine { 259 audio_engine_ops_t e_ops; 260 void *e_private; 261 uint_t e_flags; 262 263 /* 264 * Mixing related fields. 265 */ 266 uint_t e_limiter_state; 267 int32_t *e_chbufs[AUDIO_MAX_CHANNELS]; 268 uint_t e_choffs[AUDIO_MAX_CHANNELS]; 269 uint_t e_chincr[AUDIO_MAX_CHANNELS]; 270 audio_export_fn_t e_export; 271 audio_import_fn_t e_import; 272 273 /* 274 * Underlying physical buffer shared with device driver. 275 */ 276 audio_buffer_t e_buf; 277 #define e_head e_buf.b_head 278 #define e_tail e_buf.b_tail 279 #define e_data e_buf.b_data 280 #define e_framesz e_buf.b_framesz 281 #define e_nframes e_buf.b_nframes 282 #define e_hidx e_buf.b_hidx 283 #define e_tidx e_buf.b_tidx 284 uint_t e_fragfr; 285 uint_t e_playahead; 286 287 int e_errors; 288 int e_overruns; 289 int e_underruns; 290 int e_stream_overruns; 291 int e_stream_underruns; 292 293 audio_parms_t e_parms; 294 #define e_format e_parms.p_format 295 #define e_nchan e_parms.p_nchan 296 #define e_rate e_parms.p_rate 297 298 /* 299 * Statistics. 300 */ 301 kstat_t *e_ksp; 302 struct audio_stats e_stats; 303 304 305 /* 306 * Synchronization. 307 */ 308 kmutex_t e_lock; 309 kcondvar_t e_cv; 310 ddi_periodic_t e_periodic; 311 312 /* 313 * Linkage for per-device list. 314 */ 315 list_node_t e_dev_linkage; 316 audio_dev_t *e_dev; 317 int e_num; /* arbitrary engine number */ 318 319 /* 320 * List of of streams attached to this engine. 321 */ 322 list_t e_streams; 323 boolean_t e_suspended; 324 boolean_t e_failed; 325 326 boolean_t e_need_start; 327 }; 328 329 struct audio_dev { 330 dev_info_t *d_dip; 331 major_t d_major; 332 int d_instance; 333 334 uint32_t d_flags; 335 #define DEV_OUTPUT_CAP (1U << 0) 336 #define DEV_INPUT_CAP (1U << 1) 337 #define DEV_DUPLEX_CAP (1U << 2) 338 #define DEV_SNDSTAT_CAP (1U << 3) 339 #define DEV_OPAQUE_CAP (1U << 4) /* AC3 are not mixable */ 340 341 char d_name[128]; /* generic description */ 342 char d_desc[128]; /* detailed config descr */ 343 char d_vers[128]; /* detailed version descr */ 344 int d_number; /* global /dev/audioXX # */ 345 int d_index; /* master device index */ 346 int d_engno; /* engine counter */ 347 348 list_t d_hwinfo; /* strings of hw info */ 349 350 /* 351 * Synchronization. 352 */ 353 kmutex_t d_lock; 354 kcondvar_t d_cv; 355 kmutex_t d_ctrl_lock; /* leaf lock */ 356 kcondvar_t d_ctrl_cv; 357 krwlock_t d_clnt_lock; 358 uint_t d_refcnt; 359 int d_suspended; 360 boolean_t d_failed; 361 362 /* 363 * Lists of virtual clients, controls and engines. Protected by 364 * the d_lock field above. 365 */ 366 list_t d_clients; 367 list_t d_engines; 368 list_t d_controls; 369 audio_ctrl_t *d_pcmvol_ctrl; 370 uint64_t d_pcmvol; 371 372 volatile uint_t d_serial; 373 374 /* 375 * Linkage onto global list of devices. 376 */ 377 list_node_t d_by_index; 378 list_node_t d_by_number; 379 380 /* 381 * Personality specific data. 382 */ 383 void *d_minor_data[1 << AUDIO_MN_TYPE_NBITS]; 384 }; 385 386 /* 387 * Each audio_dev optionally can have controls attached to it. 388 * Controls are separate from audio engines. They are methods of 389 * adjusting pharameters or reading metrics that usually relate to 390 * hardware on devices engine by the driver. They can be things like 391 * master volume for example. 392 * 393 * If the driver does not support controls then it must insure 394 * that any hardware controls are initialized to a usable state. 395 * 396 * For the framework/user-apps to be able to change controls 397 * the driver must create, enable and configure controls with 398 * control API's. 399 * 400 * There are a number of common controls (well-known) that most 401 * hardware supports. These have known names and known ctrl numbers. 402 * In addition a driver can have any number of extention 403 * controls (device-private). These can have any name and any ctrl 404 * number other then the ones, defined as well-knonw ones. 405 * 406 * Only controls created through control API's will be available, 407 * well-known or device-private. 408 */ 409 struct audio_ctrl { 410 audio_ctrl_desc_t ctrl_des; 411 #define ctrl_name ctrl_des.acd_name 412 #define ctrl_type ctrl_des.acd_type 413 #define ctrl_enum ctrl_des.acd_enum 414 #define ctrl_flags ctrl_des.acd_flags 415 audio_dev_t *ctrl_dev; 416 audio_ctrl_rd_t ctrl_read_fn; 417 audio_ctrl_wr_t ctrl_write_fn; 418 list_node_t ctrl_linkage; 419 void *ctrl_arg; 420 uint64_t ctrl_saved; /* the saved value */ 421 boolean_t ctrl_saved_ok; 422 }; 423 424 425 /* 426 * Prototypes. 427 */ 428 429 /* audio_format.c */ 430 int auimpl_format_alloc(audio_stream_t *); 431 void auimpl_format_free(audio_stream_t *); 432 int auimpl_format_setup(audio_stream_t *, audio_parms_t *, uint_t); 433 #define FORMAT_MSK_NONE (0x0) 434 #define FORMAT_MSK_FMT (0x1) 435 #define FORMAT_MSK_RATE (0x2) 436 #define FORMAT_MSK_CHAN (0x4) 437 #define FOMMAT_MSK_ALL (0x7) 438 439 /* audio_output.c */ 440 void auimpl_export_16ne(audio_engine_t *, uint_t, uint_t); 441 void auimpl_export_16oe(audio_engine_t *, uint_t, uint_t); 442 void auimpl_export_24ne(audio_engine_t *, uint_t, uint_t); 443 void auimpl_export_24oe(audio_engine_t *, uint_t, uint_t); 444 void auimpl_export_32ne(audio_engine_t *, uint_t, uint_t); 445 void auimpl_export_32oe(audio_engine_t *, uint_t, uint_t); 446 void auimpl_output_callback(void *); 447 void auimpl_output_preload(audio_engine_t *); 448 449 /* audio_input.c */ 450 void auimpl_import_16ne(audio_engine_t *, uint_t, audio_stream_t *); 451 void auimpl_import_16oe(audio_engine_t *, uint_t, audio_stream_t *); 452 void auimpl_import_24ne(audio_engine_t *, uint_t, audio_stream_t *); 453 void auimpl_import_24oe(audio_engine_t *, uint_t, audio_stream_t *); 454 void auimpl_import_32ne(audio_engine_t *, uint_t, audio_stream_t *); 455 void auimpl_import_32oe(audio_engine_t *, uint_t, audio_stream_t *); 456 void auimpl_input_callback(void *); 457 int auimpl_input_drain(audio_stream_t *); 458 459 /* audio_client.c */ 460 void auimpl_client_init(void); 461 void auimpl_client_fini(void); 462 audio_client_t *auimpl_client_create(dev_t); 463 void auimpl_client_destroy(audio_client_t *); 464 void auimpl_client_activate(audio_client_t *); 465 void auimpl_client_deactivate(audio_client_t *); 466 int auimpl_create_minors(audio_dev_t *); 467 void auimpl_remove_minors(audio_dev_t *); 468 int auimpl_set_pcmvol(void *, uint64_t); 469 int auimpl_get_pcmvol(void *, uint64_t *); 470 471 /* audio_ctrl.c */ 472 int auimpl_save_controls(audio_dev_t *); 473 int auimpl_restore_controls(audio_dev_t *); 474 475 /* audio_engine.c */ 476 extern int audio_priority; 477 void auimpl_dev_init(void); 478 void auimpl_dev_fini(void); 479 void auimpl_dev_hold(audio_dev_t *); 480 audio_dev_t *auimpl_dev_hold_by_devt(dev_t); 481 audio_dev_t *auimpl_dev_hold_by_index(int); 482 void auimpl_dev_release(audio_dev_t *); 483 int auimpl_choose_format(int); 484 485 int auimpl_engine_open(audio_stream_t *, int); 486 int auimpl_engine_setup(audio_stream_t *, int, audio_parms_t *, uint_t); 487 void auimpl_engine_close(audio_stream_t *); 488 489 void auimpl_dev_walk_engines(audio_dev_t *, 490 int (*)(audio_engine_t *, void *), void *); 491 492 void auimpl_dev_vwarn(audio_dev_t *, const char *, va_list); 493 494 /* engine operations */ 495 #define E_OP(e, entry) ((e)->e_ops.audio_engine_##entry) 496 #define E_PRV(e) ((e)->e_private) 497 #define ENG_FORMAT(e) E_OP(e, format)(E_PRV(e)) 498 #define ENG_RATE(e) E_OP(e, rate)(E_PRV(e)) 499 #define ENG_CHANNELS(e) E_OP(e, channels)(E_PRV(e)) 500 #define ENG_SYNC(e, num) E_OP(e, sync)(E_PRV(e), num) 501 #define ENG_START(e) E_OP(e, start)(E_PRV(e)) 502 #define ENG_STOP(e) E_OP(e, stop)(E_PRV(e)) 503 #define ENG_COUNT(e) E_OP(e, count)(E_PRV(e)) 504 #define ENG_QLEN(e) E_OP(e, qlen)(E_PRV(e)) 505 #define ENG_PLAYAHEAD(e) E_OP(e, playahead)(E_PRV(e)) 506 #define ENG_CLOSE(e) E_OP(e, close)(E_PRV(e)) 507 #define ENG_OPEN(e, flg, nf, d) E_OP(e, open)(E_PRV(e), flg, nf, d) 508 #define ENG_CHINFO(e, c, o, i) E_OP(e, chinfo(E_PRV(e), c, o, i)) 509 510 /* audio_sun.c */ 511 void auimpl_sun_init(void); 512 513 /* audio_oss.c */ 514 void auimpl_oss_init(void); 515 516 #endif /* _AUDIO_IMPL_H */ 517