1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2005-2009 Ariff Abdullah <ariff@FreeBSD.org> 5 * Portions Copyright (c) Ryan Beasley <ryan.beasley@gmail.com> - GSoC 2006 6 * Copyright (c) 1999 Cameron Grant <cg@FreeBSD.org> 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 * 30 * $FreeBSD$ 31 */ 32 33 struct pcmchan_caps { 34 u_int32_t minspeed, maxspeed; 35 u_int32_t *fmtlist; 36 u_int32_t caps; 37 }; 38 39 struct pcmchan_matrix { 40 int id; 41 uint8_t channels, ext; 42 struct { 43 int type; 44 uint32_t members; 45 } map[SND_CHN_T_MAX + 1]; 46 uint32_t mask; 47 int8_t offset[SND_CHN_T_MAX]; 48 }; 49 50 /* Forward declarations */ 51 struct pcm_channel; 52 struct pcmchan_syncgroup; 53 struct pcmchan_syncmember; 54 55 extern struct mtx snd_pcm_syncgroups_mtx; 56 extern SLIST_HEAD(pcm_synclist, pcmchan_syncgroup) snd_pcm_syncgroups; 57 58 #define PCM_SG_LOCK() mtx_lock(&snd_pcm_syncgroups_mtx) 59 #define PCM_SG_TRYLOCK() mtx_trylock(&snd_pcm_syncgroups_mtx) 60 #define PCM_SG_UNLOCK() mtx_unlock(&snd_pcm_syncgroups_mtx) 61 #define PCM_SG_LOCKASSERT(arg) mtx_assert(&snd_pcm_syncgroups_mtx, arg) 62 63 /** 64 * @brief Specifies an audio device sync group 65 */ 66 struct pcmchan_syncgroup { 67 SLIST_ENTRY(pcmchan_syncgroup) link; 68 SLIST_HEAD(, pcmchan_syncmember) members; 69 int id; /**< Group identifier; set to address of group. */ 70 }; 71 72 /** 73 * @brief Specifies a container for members of a sync group 74 */ 75 struct pcmchan_syncmember { 76 SLIST_ENTRY(pcmchan_syncmember) link; 77 struct pcmchan_syncgroup *parent; /**< group head */ 78 struct pcm_channel *ch; 79 }; 80 81 #define CHN_NAMELEN 32 82 #define CHN_COMM_UNUSED "<UNUSED>" 83 #define CHN_COMM_UNKNOWN "<UNKNOWN>" 84 85 struct pcm_channel { 86 kobj_t methods; 87 88 pid_t pid; 89 int refcount; 90 struct pcm_feeder *feeder; 91 u_int32_t align; 92 93 int latency; 94 u_int32_t speed; 95 u_int32_t format; 96 u_int32_t flags; 97 u_int32_t feederflags; 98 u_int64_t blocks; 99 100 int direction; 101 unsigned int interrupts, xruns, feedcount; 102 unsigned int timeout; 103 struct snd_dbuf *bufhard, *bufsoft; 104 struct snddev_info *parentsnddev; 105 struct pcm_channel *parentchannel; 106 void *devinfo; 107 device_t dev; 108 int unit; 109 char name[CHN_NAMELEN]; 110 char comm[MAXCOMLEN + 1]; 111 struct mtx *lock; 112 int trigger; 113 /** 114 * For interrupt manipulations. 115 */ 116 struct cv intr_cv; 117 /** 118 * Increment,decrement this around operations that temporarily yield 119 * lock. 120 */ 121 unsigned int inprog; 122 /** 123 * Special channel operations should examine @c inprog after acquiring 124 * lock. If zero, operations may continue. Else, thread should 125 * wait on this cv for previous operation to finish. 126 */ 127 struct cv cv; 128 /** 129 * Low water mark for select()/poll(). 130 * 131 * This is initialized to the channel's fragment size, and will be 132 * overwritten if a new fragment size is set. Users may alter this 133 * value directly with the @c SNDCTL_DSP_LOW_WATER ioctl. 134 */ 135 unsigned int lw; 136 /** 137 * If part of a sync group, this will point to the syncmember 138 * container. 139 */ 140 struct pcmchan_syncmember *sm; 141 #ifdef OSSV4_EXPERIMENT 142 u_int16_t lpeak, rpeak; /**< Peak value from 0-32767. */ 143 #endif 144 145 struct { 146 SLIST_HEAD(, pcm_channel) head; 147 SLIST_ENTRY(pcm_channel) link; 148 struct { 149 SLIST_HEAD(, pcm_channel) head; 150 SLIST_ENTRY(pcm_channel) link; 151 } busy; 152 } children; 153 154 struct { 155 struct { 156 SLIST_ENTRY(pcm_channel) link; 157 struct { 158 SLIST_ENTRY(pcm_channel) link; 159 } busy; 160 struct { 161 SLIST_ENTRY(pcm_channel) link; 162 } opened; 163 } pcm; 164 } channels; 165 166 struct pcmchan_matrix matrix; 167 struct pcmchan_matrix matrix_scratch; 168 169 int16_t volume[SND_VOL_C_MAX][SND_CHN_T_VOL_MAX]; 170 int8_t muted[SND_VOL_C_MAX][SND_CHN_T_VOL_MAX]; 171 172 void *data1, *data2; 173 }; 174 175 #define CHN_HEAD(x, y) &(x)->y.head 176 #define CHN_INIT(x, y) SLIST_INIT(CHN_HEAD(x, y)) 177 #define CHN_LINK(y) y.link 178 #define CHN_EMPTY(x, y) SLIST_EMPTY(CHN_HEAD(x, y)) 179 #define CHN_FIRST(x, y) SLIST_FIRST(CHN_HEAD(x, y)) 180 181 #define CHN_FOREACH(x, y, z) \ 182 SLIST_FOREACH(x, CHN_HEAD(y, z), CHN_LINK(z)) 183 184 #define CHN_FOREACH_SAFE(w, x, y, z) \ 185 SLIST_FOREACH_SAFE(w, CHN_HEAD(x, z), CHN_LINK(z), y) 186 187 #define CHN_INSERT_HEAD(x, y, z) \ 188 SLIST_INSERT_HEAD(CHN_HEAD(x, z), y, CHN_LINK(z)) 189 190 #define CHN_INSERT_AFTER(x, y, z) \ 191 SLIST_INSERT_AFTER(x, y, CHN_LINK(z)) 192 193 #define CHN_REMOVE(x, y, z) \ 194 SLIST_REMOVE(CHN_HEAD(x, z), y, pcm_channel, CHN_LINK(z)) 195 196 #define CHN_INSERT_HEAD_SAFE(x, y, z) do { \ 197 struct pcm_channel *t = NULL; \ 198 CHN_FOREACH(t, x, z) { \ 199 if (t == y) \ 200 break; \ 201 } \ 202 if (t != y) \ 203 CHN_INSERT_HEAD(x, y, z); \ 204 } while (0) 205 206 #define CHN_INSERT_AFTER_SAFE(w, x, y, z) do { \ 207 struct pcm_channel *t = NULL; \ 208 CHN_FOREACH(t, w, z) { \ 209 if (t == y) \ 210 break; \ 211 } \ 212 if (t != y) \ 213 CHN_INSERT_AFTER(x, y, z); \ 214 } while (0) 215 216 #define CHN_REMOVE_SAFE(x, y, z) do { \ 217 struct pcm_channel *t = NULL; \ 218 CHN_FOREACH(t, x, z) { \ 219 if (t == y) \ 220 break; \ 221 } \ 222 if (t == y) \ 223 CHN_REMOVE(x, y, z); \ 224 } while (0) 225 226 #define CHN_INSERT_SORT(w, x, y, z) do { \ 227 struct pcm_channel *t, *a = NULL; \ 228 CHN_FOREACH(t, x, z) { \ 229 if ((y)->unit w t->unit) \ 230 a = t; \ 231 else \ 232 break; \ 233 } \ 234 if (a != NULL) \ 235 CHN_INSERT_AFTER(a, y, z); \ 236 else \ 237 CHN_INSERT_HEAD(x, y, z); \ 238 } while (0) 239 240 #define CHN_INSERT_SORT_ASCEND(x, y, z) CHN_INSERT_SORT(>, x, y, z) 241 #define CHN_INSERT_SORT_DESCEND(x, y, z) CHN_INSERT_SORT(<, x, y, z) 242 243 #define CHN_UNIT(x) (snd_unit2u((x)->unit)) 244 #define CHN_DEV(x) (snd_unit2d((x)->unit)) 245 #define CHN_CHAN(x) (snd_unit2c((x)->unit)) 246 247 #define CHN_BUF_PARENT(x, y) \ 248 (((x) != NULL && (x)->parentchannel != NULL && \ 249 (x)->parentchannel->bufhard != NULL) ? \ 250 (x)->parentchannel->bufhard : (y)) 251 252 #define CHN_BROADCAST(x) do { \ 253 if ((x)->cv_waiters != 0) \ 254 cv_broadcastpri(x, PRIBIO); \ 255 } while (0) 256 257 #include "channel_if.h" 258 259 int chn_reinit(struct pcm_channel *c); 260 int chn_write(struct pcm_channel *c, struct uio *buf); 261 int chn_read(struct pcm_channel *c, struct uio *buf); 262 u_int32_t chn_start(struct pcm_channel *c, int force); 263 int chn_sync(struct pcm_channel *c, int threshold); 264 int chn_flush(struct pcm_channel *c); 265 int chn_poll(struct pcm_channel *c, int ev, struct thread *td); 266 267 int chn_init(struct pcm_channel *c, void *devinfo, int dir, int direction); 268 int chn_kill(struct pcm_channel *c); 269 int chn_reset(struct pcm_channel *c, u_int32_t fmt, u_int32_t spd); 270 int chn_setvolume(struct pcm_channel *c, int left, int right); 271 int chn_setvolume_multi(struct pcm_channel *c, int vc, int left, int right, 272 int center); 273 int chn_setvolume_matrix(struct pcm_channel *c, int vc, int vt, int val); 274 int chn_getvolume_matrix(struct pcm_channel *c, int vc, int vt); 275 int chn_setmute_multi(struct pcm_channel *c, int vc, int mute); 276 int chn_setmute_matrix(struct pcm_channel *c, int vc, int vt, int mute); 277 int chn_getmute_matrix(struct pcm_channel *c, int vc, int vt); 278 void chn_vpc_reset(struct pcm_channel *c, int vc, int force); 279 int chn_setparam(struct pcm_channel *c, uint32_t format, uint32_t speed); 280 int chn_setspeed(struct pcm_channel *c, uint32_t speed); 281 int chn_setformat(struct pcm_channel *c, uint32_t format); 282 int chn_setblocksize(struct pcm_channel *c, int blkcnt, int blksz); 283 int chn_setlatency(struct pcm_channel *c, int latency); 284 void chn_syncstate(struct pcm_channel *c); 285 int chn_trigger(struct pcm_channel *c, int go); 286 int chn_getptr(struct pcm_channel *c); 287 struct pcmchan_caps *chn_getcaps(struct pcm_channel *c); 288 u_int32_t chn_getformats(struct pcm_channel *c); 289 290 struct pcmchan_matrix *chn_getmatrix(struct pcm_channel *); 291 int chn_setmatrix(struct pcm_channel *, struct pcmchan_matrix *); 292 293 int chn_oss_getorder(struct pcm_channel *, unsigned long long *); 294 int chn_oss_setorder(struct pcm_channel *, unsigned long long *); 295 int chn_oss_getmask(struct pcm_channel *, uint32_t *); 296 297 void chn_resetbuf(struct pcm_channel *c); 298 void chn_intr_locked(struct pcm_channel *c); 299 void chn_intr(struct pcm_channel *c); 300 int chn_abort(struct pcm_channel *c); 301 302 int chn_notify(struct pcm_channel *c, u_int32_t flags); 303 304 int chn_getrates(struct pcm_channel *c, int **rates); 305 int chn_syncdestroy(struct pcm_channel *c); 306 307 #define CHN_SETVOLUME(...) chn_setvolume_matrix(__VA_ARGS__) 308 #if defined(SND_DIAGNOSTIC) || defined(INVARIANTS) 309 #define CHN_GETVOLUME(...) chn_getvolume_matrix(__VA_ARGS__) 310 #else 311 #define CHN_GETVOLUME(x, y, z) ((x)->volume[y][z]) 312 #endif 313 314 #define CHN_GETMUTE(x, y, z) ((x)->muted[y][z]) 315 316 #ifdef OSSV4_EXPERIMENT 317 int chn_getpeaks(struct pcm_channel *c, int *lpeak, int *rpeak); 318 #endif 319 320 #define CHN_LOCKOWNED(c) mtx_owned((c)->lock) 321 #define CHN_LOCK(c) mtx_lock((c)->lock) 322 #define CHN_UNLOCK(c) mtx_unlock((c)->lock) 323 #define CHN_TRYLOCK(c) mtx_trylock((c)->lock) 324 #define CHN_LOCKASSERT(c) mtx_assert((c)->lock, MA_OWNED) 325 #define CHN_UNLOCKASSERT(c) mtx_assert((c)->lock, MA_NOTOWNED) 326 327 int snd_fmtvalid(uint32_t fmt, uint32_t *fmtlist); 328 329 uint32_t snd_str2afmt(const char *); 330 uint32_t snd_afmt2str(uint32_t, char *, size_t); 331 332 #define AFMTSTR_LEN 16 333 334 extern int chn_latency; 335 extern int chn_latency_profile; 336 extern int report_soft_formats; 337 extern int report_soft_matrix; 338 339 #define PCMDIR_PLAY 1 340 #define PCMDIR_PLAY_VIRTUAL 2 341 #define PCMDIR_REC -1 342 #define PCMDIR_REC_VIRTUAL -2 343 344 #define PCMTRIG_START 1 345 #define PCMTRIG_EMLDMAWR 2 346 #define PCMTRIG_EMLDMARD 3 347 #define PCMTRIG_STOP 0 348 #define PCMTRIG_ABORT -1 349 350 #define PCMTRIG_COMMON(x) ((x) == PCMTRIG_START || \ 351 (x) == PCMTRIG_STOP || \ 352 (x) == PCMTRIG_ABORT) 353 354 #define CHN_F_CLOSING 0x00000001 /* a pending close */ 355 #define CHN_F_ABORTING 0x00000002 /* a pending abort */ 356 #define CHN_F_RUNNING 0x00000004 /* dma is running */ 357 #define CHN_F_TRIGGERED 0x00000008 358 #define CHN_F_NOTRIGGER 0x00000010 359 #define CHN_F_SLEEPING 0x00000020 360 361 #define CHN_F_NBIO 0x00000040 /* do non-blocking i/o */ 362 #define CHN_F_MMAP 0x00000080 /* has been mmap()ed */ 363 364 #define CHN_F_BUSY 0x00000100 /* has been opened */ 365 #define CHN_F_DIRTY 0x00000200 /* need re-config */ 366 #define CHN_F_DEAD 0x00000400 /* too many errors, dead, mdk */ 367 #define CHN_F_SILENCE 0x00000800 /* silence, nil, null, yada */ 368 369 #define CHN_F_HAS_SIZE 0x00001000 /* user set block size */ 370 #define CHN_F_HAS_VCHAN 0x00002000 /* vchan master */ 371 372 #define CHN_F_VCHAN_PASSTHROUGH 0x00004000 /* digital ac3/dts passthrough */ 373 #define CHN_F_VCHAN_ADAPTIVE 0x00008000 /* adaptive format/rate selection */ 374 #define CHN_F_VCHAN_DYNAMIC (CHN_F_VCHAN_PASSTHROUGH | CHN_F_VCHAN_ADAPTIVE) 375 376 #define CHN_F_VIRTUAL 0x10000000 /* not backed by hardware */ 377 #define CHN_F_BITPERFECT 0x20000000 /* un-cooked, Heh.. */ 378 #define CHN_F_PASSTHROUGH 0x40000000 /* passthrough re-config */ 379 #define CHN_F_EXCLUSIVE 0x80000000 /* exclusive access */ 380 381 #define CHN_F_BITS "\020" \ 382 "\001CLOSING" \ 383 "\002ABORTING" \ 384 "\003RUNNING" \ 385 "\004TRIGGERED" \ 386 "\005NOTRIGGER" \ 387 "\006SLEEPING" \ 388 "\007NBIO" \ 389 "\010MMAP" \ 390 "\011BUSY" \ 391 "\012DIRTY" \ 392 "\013DEAD" \ 393 "\014SILENCE" \ 394 "\015HAS_SIZE" \ 395 "\016HAS_VCHAN" \ 396 "\017VCHAN_PASSTHROUGH" \ 397 "\020VCHAN_ADAPTIVE" \ 398 "\035VIRTUAL" \ 399 "\036BITPERFECT" \ 400 "\037PASSTHROUGH" \ 401 "\040EXCLUSIVE" 402 403 #define CHN_F_RESET (CHN_F_BUSY | CHN_F_DEAD | \ 404 CHN_F_VIRTUAL | CHN_F_HAS_VCHAN | \ 405 CHN_F_VCHAN_DYNAMIC | \ 406 CHN_F_PASSTHROUGH | CHN_F_EXCLUSIVE) 407 408 #define CHN_F_MMAP_INVALID (CHN_F_DEAD | CHN_F_RUNNING) 409 410 411 412 #define CHN_N_RATE 0x00000001 413 #define CHN_N_FORMAT 0x00000002 414 #define CHN_N_VOLUME 0x00000004 415 #define CHN_N_BLOCKSIZE 0x00000008 416 #define CHN_N_TRIGGER 0x00000010 417 418 #define CHN_LATENCY_MIN 0 419 #define CHN_LATENCY_MAX 10 420 #define CHN_LATENCY_DEFAULT 2 /* 21.3ms total buffering */ 421 #define CHN_POLICY_MIN CHN_LATENCY_MIN 422 #define CHN_POLICY_MAX CHN_LATENCY_MAX 423 #define CHN_POLICY_DEFAULT CHN_LATENCY_DEFAULT 424 425 #define CHN_LATENCY_PROFILE_MIN 0 426 #define CHN_LATENCY_PROFILE_MAX 1 427 #define CHN_LATENCY_PROFILE_DEFAULT CHN_LATENCY_PROFILE_MAX 428 429 #define CHN_STARTED(c) ((c)->flags & CHN_F_TRIGGERED) 430 #define CHN_STOPPED(c) (!CHN_STARTED(c)) 431 #define CHN_DIRSTR(c) (((c)->direction == PCMDIR_PLAY) ? \ 432 "PCMDIR_PLAY" : "PCMDIR_REC") 433 #define CHN_BITPERFECT(c) ((c)->flags & CHN_F_BITPERFECT) 434 #define CHN_PASSTHROUGH(c) ((c)->flags & CHN_F_PASSTHROUGH) 435 436 #define CHN_TIMEOUT 5 437 #define CHN_TIMEOUT_MIN 1 438 #define CHN_TIMEOUT_MAX 10 439 440 /* 441 * This should be large enough to hold all pcm data between 442 * tsleeps in chn_{read,write} at the highest sample rate. 443 * (which is usually 48kHz * 16bit * stereo = 192000 bytes/sec) 444 */ 445 #define CHN_2NDBUFBLKSIZE (2 * 1024) 446 /* The total number of blocks per secondary bufhard. */ 447 #define CHN_2NDBUFBLKNUM (32) 448 /* The size of a whole secondary bufhard. */ 449 #define CHN_2NDBUFMAXSIZE (131072) 450 451 #define CHANNEL_DECLARE(name) static DEFINE_CLASS(name, name ## _methods, sizeof(struct kobj)) 452