usr/src/uts/common/io/audio/impl/audio_impl.h

   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 */