Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-31 19:08
📄 asequencer.h /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note / / * Main header file for the ALSA sequencer * Copyright (c) 1998-1999 by Frank van de Pol <fvdpol@coil.demon.nl> * (c) 1998-1999 by Jaroslav Kysela <perex@perex.cz> / #ifndef __SOUND_ASEQUENCER_H #define __SOUND_ASEQUENCER_H #include <sound/asound.h> /* version of the sequencer / #define SNDRV_SEQ_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 5) /* * definition of sequencer event types / /* system messages * event data type = #snd_seq_result / #define SNDRV_SEQ_EVENT_SYSTEM 0 #define SNDRV_SEQ_EVENT_RESULT 1 /* note messages (channel specific) * event data type = #snd_seq_ev_note / #define SNDRV_SEQ_EVENT_NOTE 5 #define SNDRV_SEQ_EVENT_NOTEON 6 #define SNDRV_SEQ_EVENT_NOTEOFF 7 #define SNDRV_SEQ_EVENT_KEYPRESS 8 /* control messages (channel specific) * event data type = #snd_seq_ev_ctrl / #define SNDRV_SEQ_EVENT_CONTROLLER 10 #define SNDRV_SEQ_EVENT_PGMCHANGE 11 #define SNDRV_SEQ_EVENT_CHANPRESS 12 #define SNDRV_SEQ_EVENT_PITCHBEND 13 /< from -8192 to 8191 / #define SNDRV_SEQ_EVENT_CONTROL14 14 /*< 14 bit controller value / #define SNDRV_SEQ_EVENT_NONREGPARAM 15 /*< 14 bit NRPN address + 14 bit unsigned value / #define SNDRV_SEQ_EVENT_REGPARAM 16 /*< 14 bit RPN address + 14 bit unsigned value / /** synchronisation messages * event data type = #snd_seq_ev_ctrl / #define SNDRV_SEQ_EVENT_SONGPOS 20 / Song Position Pointer with LSB and MSB values / #define SNDRV_SEQ_EVENT_SONGSEL 21 / Song Select with song ID number / #define SNDRV_SEQ_EVENT_QFRAME 22 / midi time code quarter frame / #define SNDRV_SEQ_EVENT_TIMESIGN 23 / SMF Time Signature event / #define SNDRV_SEQ_EVENT_KEYSIGN 24 / SMF Key Signature event / /* timer messages * event data type = snd_seq_ev_queue_control / #define SNDRV_SEQ_EVENT_START 30 / midi Real Time Start message / #define SNDRV_SEQ_EVENT_CONTINUE 31 / midi Real Time Continue message / #define SNDRV_SEQ_EVENT_STOP 32 / midi Real Time Stop message / #define SNDRV_SEQ_EVENT_SETPOS_TICK 33 / set tick queue position / #define SNDRV_SEQ_EVENT_SETPOS_TIME 34 / set realtime queue position / #define SNDRV_SEQ_EVENT_TEMPO 35 / (SMF) Tempo event / #define SNDRV_SEQ_EVENT_CLOCK 36 / midi Real Time Clock message / #define SNDRV_SEQ_EVENT_TICK 37 / midi Real Time Tick message / #define SNDRV_SEQ_EVENT_QUEUE_SKEW 38 / skew queue tempo / /* others * event data type = none / #define SNDRV_SEQ_EVENT_TUNE_REQUEST 40 / tune request / #define SNDRV_SEQ_EVENT_RESET 41 / reset to power-on state / #define SNDRV_SEQ_EVENT_SENSING 42 / "active sensing" event / /* echo back, kernel private messages * event data type = any type / #define SNDRV_SEQ_EVENT_ECHO 50 / echo event / #define SNDRV_SEQ_EVENT_OSS 51 / OSS raw event / /* system status messages (broadcast for subscribers) * event data type = snd_seq_addr / #define SNDRV_SEQ_EVENT_CLIENT_START 60 / new client has connected / #define SNDRV_SEQ_EVENT_CLIENT_EXIT 61 / client has left the system / #define SNDRV_SEQ_EVENT_CLIENT_CHANGE 62 / client status/info has changed / #define SNDRV_SEQ_EVENT_PORT_START 63 / new port was created / #define SNDRV_SEQ_EVENT_PORT_EXIT 64 / port was deleted from system / #define SNDRV_SEQ_EVENT_PORT_CHANGE 65 / port status/info has changed / /* port connection changes * event data type = snd_seq_connect / #define SNDRV_SEQ_EVENT_PORT_SUBSCRIBED 66 / ports connected / #define SNDRV_SEQ_EVENT_PORT_UNSUBSCRIBED 67 / ports disconnected / #define SNDRV_SEQ_EVENT_UMP_EP_CHANGE 68 / UMP EP info has changed / #define SNDRV_SEQ_EVENT_UMP_BLOCK_CHANGE 69 / UMP block info has changed / / 70-89: synthesizer events - obsoleted / /* user-defined events with fixed length * event data type = any / #define SNDRV_SEQ_EVENT_USR0 90 #define SNDRV_SEQ_EVENT_USR1 91 #define SNDRV_SEQ_EVENT_USR2 92 #define SNDRV_SEQ_EVENT_USR3 93 #define SNDRV_SEQ_EVENT_USR4 94 #define SNDRV_SEQ_EVENT_USR5 95 #define SNDRV_SEQ_EVENT_USR6 96 #define SNDRV_SEQ_EVENT_USR7 97 #define SNDRV_SEQ_EVENT_USR8 98 #define SNDRV_SEQ_EVENT_USR9 99 / 100-118: instrument layer - obsoleted / / 119-129: reserved / / 130-139: variable length events * event data type = snd_seq_ev_ext * (SNDRV_SEQ_EVENT_LENGTH_VARIABLE must be set) / #define SNDRV_SEQ_EVENT_SYSEX 130 / system exclusive data (variable length) / #define SNDRV_SEQ_EVENT_BOUNCE 131 / error event / / 132-134: reserved / #define SNDRV_SEQ_EVENT_USR_VAR0 135 #define SNDRV_SEQ_EVENT_USR_VAR1 136 #define SNDRV_SEQ_EVENT_USR_VAR2 137 #define SNDRV_SEQ_EVENT_USR_VAR3 138 #define SNDRV_SEQ_EVENT_USR_VAR4 139 / 150-151: kernel events with quote - DO NOT use in user clients / #define SNDRV_SEQ_EVENT_KERNEL_ERROR 150 #define SNDRV_SEQ_EVENT_KERNEL_QUOTE 151 / obsolete / / 152-191: reserved / / 192-254: hardware specific events / / 255: special event / #define SNDRV_SEQ_EVENT_NONE 255 typedef unsigned char snd_seq_event_type_t; /* event address / struct snd_seq_addr { unsigned char client; /< Client number: 0..255, 255 = broadcast to all clients / unsigned char port; /*< Port within client: 0..255, 255 = broadcast to all ports / }; /** port connection / struct snd_seq_connect { struct snd_seq_addr sender; struct snd_seq_addr dest; }; #define SNDRV_SEQ_ADDRESS_UNKNOWN 253 / unknown source / #define SNDRV_SEQ_ADDRESS_SUBSCRIBERS 254 / send event to all subscribed ports / #define SNDRV_SEQ_ADDRESS_BROADCAST 255 / send event to all queues/clients/ports/channels / #define SNDRV_SEQ_QUEUE_DIRECT 253 / direct dispatch / / event mode flag - NOTE: only 8 bits available! / #define SNDRV_SEQ_TIME_STAMP_TICK (0<<0) / timestamp in clock ticks / #define SNDRV_SEQ_TIME_STAMP_REAL (1<<0) / timestamp in real time / #define SNDRV_SEQ_TIME_STAMP_MASK (1<<0) #define SNDRV_SEQ_TIME_MODE_ABS (0<<1) / absolute timestamp / #define SNDRV_SEQ_TIME_MODE_REL (1<<1) / relative to current time / #define SNDRV_SEQ_TIME_MODE_MASK (1<<1) #define SNDRV_SEQ_EVENT_LENGTH_FIXED (0<<2) / fixed event size / #define SNDRV_SEQ_EVENT_LENGTH_VARIABLE (1<<2) / variable event size / #define SNDRV_SEQ_EVENT_LENGTH_VARUSR (2<<2) / variable event size - user memory space / #define SNDRV_SEQ_EVENT_LENGTH_MASK (3<<2) #define SNDRV_SEQ_PRIORITY_NORMAL (0<<4) / normal priority / #define SNDRV_SEQ_PRIORITY_HIGH (1<<4) / event should be processed before others / #define SNDRV_SEQ_PRIORITY_MASK (1<<4) #define SNDRV_SEQ_EVENT_UMP (1<<5) / event holds a UMP packet / / note event / struct snd_seq_ev_note { unsigned char channel; unsigned char note; unsigned char velocity; unsigned char off_velocity; / only for SNDRV_SEQ_EVENT_NOTE / unsigned int duration; / only for SNDRV_SEQ_EVENT_NOTE / }; / controller event / struct snd_seq_ev_ctrl { unsigned char channel; unsigned char unused1, unused2, unused3; / pad / unsigned int param; signed int value; }; / generic set of bytes (12x8 bit) / struct snd_seq_ev_raw8 { unsigned char d[12]; / 8 bit value / }; / generic set of integers (3x32 bit) / struct snd_seq_ev_raw32 { unsigned int d[3]; / 32 bit value / }; / external stored data / struct snd_seq_ev_ext { unsigned int len; / length of data / void ptr; /* pointer to data (note: maybe 64-bit) / } __attribute__((packed)); struct snd_seq_result { int event; / processed event type / int result; }; struct snd_seq_real_time { unsigned int tv_sec; / seconds / unsigned int tv_nsec; / nanoseconds / }; typedef unsigned int snd_seq_tick_time_t; / midi ticks / union snd_seq_timestamp { snd_seq_tick_time_t tick; struct snd_seq_real_time time; }; struct snd_seq_queue_skew { unsigned int value; unsigned int base; }; / queue timer control / struct snd_seq_ev_queue_control { unsigned char queue; / affected queue / unsigned char pad[3]; / reserved / union { signed int value; / affected value (e.g. tempo) / union snd_seq_timestamp time; / time / unsigned int position; / sync position / struct snd_seq_queue_skew skew; unsigned int d32[2]; unsigned char d8[8]; } param; }; / quoted event - inside the kernel only / struct snd_seq_ev_quote { struct snd_seq_addr origin; / original sender / unsigned short value; / optional data / struct snd_seq_event event; /* quoted event / } __attribute__((packed)); / UMP info change notify / struct snd_seq_ev_ump_notify { unsigned char client; /< Client number / unsigned char block; /*< Block number (optional) / }; union snd_seq_event_data { /* event data... / struct snd_seq_ev_note note; struct snd_seq_ev_ctrl control; struct snd_seq_ev_raw8 raw8; struct snd_seq_ev_raw32 raw32; struct snd_seq_ev_ext ext; struct snd_seq_ev_queue_control queue; union snd_seq_timestamp time; struct snd_seq_addr addr; struct snd_seq_connect connect; struct snd_seq_result result; struct snd_seq_ev_quote quote; struct snd_seq_ev_ump_notify ump_notify; }; / sequencer event / struct snd_seq_event { snd_seq_event_type_t type; / event type / unsigned char flags; / event flags / char tag; unsigned char queue; / schedule queue / union snd_seq_timestamp time; / schedule time / struct snd_seq_addr source; / source address / struct snd_seq_addr dest; / destination address / union snd_seq_event_data data; }; / (compatible) event for UMP-capable clients / struct snd_seq_ump_event { snd_seq_event_type_t type; / event type / unsigned char flags; / event flags / char tag; unsigned char queue; / schedule queue / union snd_seq_timestamp time; / schedule time / struct snd_seq_addr source; / source address / struct snd_seq_addr dest; / destination address / union { union snd_seq_event_data data; unsigned int ump[4]; }; }; / * bounce event - stored as variable size data / struct snd_seq_event_bounce { int err; struct snd_seq_event event; / external data follows here. / }; / system information / struct snd_seq_system_info { int queues; / maximum queues count / int clients; / maximum clients count / int ports; / maximum ports per client / int channels; / maximum channels per port / int cur_clients; / current clients / int cur_queues; / current queues / char reserved[24]; }; / system running information / struct snd_seq_running_info { unsigned char client; / client id / unsigned char big_endian; / 1 = big-endian / unsigned char cpu_mode; / 4 = 32bit, 8 = 64bit / unsigned char pad; / reserved / unsigned char reserved[12]; }; / known client numbers / #define SNDRV_SEQ_CLIENT_SYSTEM 0 / internal client numbers / #define SNDRV_SEQ_CLIENT_DUMMY 14 / midi through / #define SNDRV_SEQ_CLIENT_OSS 15 / oss sequencer emulator / / client types / typedef int __bitwise snd_seq_client_type_t; #define NO_CLIENT ((snd_seq_client_type_t) 0) #define USER_CLIENT ((snd_seq_client_type_t) 1) #define KERNEL_CLIENT ((snd_seq_client_type_t) 2) / event filter flags / #define SNDRV_SEQ_FILTER_BROADCAST (1U<<0) / accept broadcast messages / #define SNDRV_SEQ_FILTER_MULTICAST (1U<<1) / accept multicast messages / #define SNDRV_SEQ_FILTER_BOUNCE (1U<<2) / accept bounce event in error / #define SNDRV_SEQ_FILTER_NO_CONVERT (1U<<30) / don't convert UMP events / #define SNDRV_SEQ_FILTER_USE_EVENT (1U<<31) / use event filter / struct snd_seq_client_info { int client; / client number to inquire / snd_seq_client_type_t type; / client type / char name[64]; / client name / unsigned int filter; / filter flags / unsigned char multicast_filter[8]; / multicast filter bitmap / unsigned char event_filter[32]; / event filter bitmap / int num_ports; / RO: number of ports / int event_lost; / number of lost events / int card; / RO: card number[kernel] / int pid; / RO: pid[user] / unsigned int midi_version; / MIDI version / unsigned int group_filter; / UMP group filter bitmap * (bit 0 = groupless messages, * bit 1-16 = messages for groups 1-16) / char reserved[48]; / for future use / }; / MIDI version numbers in client info / #define SNDRV_SEQ_CLIENT_LEGACY_MIDI 0 / Legacy client / #define SNDRV_SEQ_CLIENT_UMP_MIDI_1_0 1 / UMP MIDI 1.0 / #define SNDRV_SEQ_CLIENT_UMP_MIDI_2_0 2 / UMP MIDI 2.0 / / client pool size / struct snd_seq_client_pool { int client; / client number to inquire / int output_pool; / outgoing (write) pool size / int input_pool; / incoming (read) pool size / int output_room; / minimum free pool size for select/blocking mode / int output_free; / unused size / int input_free; / unused size / char reserved[64]; }; / Remove events by specified criteria / #define SNDRV_SEQ_REMOVE_INPUT (1<<0) / Flush input queues / #define SNDRV_SEQ_REMOVE_OUTPUT (1<<1) / Flush output queues / #define SNDRV_SEQ_REMOVE_DEST (1<<2) / Restrict by destination q:client:port / #define SNDRV_SEQ_REMOVE_DEST_CHANNEL (1<<3) / Restrict by channel / #define SNDRV_SEQ_REMOVE_TIME_BEFORE (1<<4) / Restrict to before time / #define SNDRV_SEQ_REMOVE_TIME_AFTER (1<<5) / Restrict to time or after / #define SNDRV_SEQ_REMOVE_TIME_TICK (1<<6) / Time is in ticks / #define SNDRV_SEQ_REMOVE_EVENT_TYPE (1<<7) / Restrict to event type / #define SNDRV_SEQ_REMOVE_IGNORE_OFF (1<<8) / Do not flush off events / #define SNDRV_SEQ_REMOVE_TAG_MATCH (1<<9) / Restrict to events with given tag / struct snd_seq_remove_events { unsigned int remove_mode; / Flags that determine what gets removed / union snd_seq_timestamp time; unsigned char queue; / Queue for REMOVE_DEST / struct snd_seq_addr dest; / Address for REMOVE_DEST / unsigned char channel; / Channel for REMOVE_DEST / int type; / For REMOVE_EVENT_TYPE / char tag; / Tag for REMOVE_TAG / int reserved[10]; / To allow for future binary compatibility / }; / known port numbers / #define SNDRV_SEQ_PORT_SYSTEM_TIMER 0 #define SNDRV_SEQ_PORT_SYSTEM_ANNOUNCE 1 / port capabilities (32 bits) / #define SNDRV_SEQ_PORT_CAP_READ (1<<0) / readable from this port / #define SNDRV_SEQ_PORT_CAP_WRITE (1<<1) / writable to this port / #define SNDRV_SEQ_PORT_CAP_SYNC_READ (1<<2) #define SNDRV_SEQ_PORT_CAP_SYNC_WRITE (1<<3) #define SNDRV_SEQ_PORT_CAP_DUPLEX (1<<4) #define SNDRV_SEQ_PORT_CAP_SUBS_READ (1<<5) / allow read subscription / #define SNDRV_SEQ_PORT_CAP_SUBS_WRITE (1<<6) / allow write subscription / #define SNDRV_SEQ_PORT_CAP_NO_EXPORT (1<<7) / routing not allowed / #define SNDRV_SEQ_PORT_CAP_INACTIVE (1<<8) / inactive port / #define SNDRV_SEQ_PORT_CAP_UMP_ENDPOINT (1<<9) / MIDI 2.0 UMP Endpoint port / / port type / #define SNDRV_SEQ_PORT_TYPE_SPECIFIC (1<<0) / hardware specific / #define SNDRV_SEQ_PORT_TYPE_MIDI_GENERIC (1<<1) / generic MIDI device / #define SNDRV_SEQ_PORT_TYPE_MIDI_GM (1<<2) / General MIDI compatible device / #define SNDRV_SEQ_PORT_TYPE_MIDI_GS (1<<3) / GS compatible device / #define SNDRV_SEQ_PORT_TYPE_MIDI_XG (1<<4) / XG compatible device / #define SNDRV_SEQ_PORT_TYPE_MIDI_MT32 (1<<5) / MT-32 compatible device / #define SNDRV_SEQ_PORT_TYPE_MIDI_GM2 (1<<6) / General MIDI 2 compatible device / #define SNDRV_SEQ_PORT_TYPE_MIDI_UMP (1<<7) / UMP / / other standards.../ #define SNDRV_SEQ_PORT_TYPE_SYNTH (1<<10) / Synth device (no MIDI compatible - direct wavetable) / #define SNDRV_SEQ_PORT_TYPE_DIRECT_SAMPLE (1<<11) / Sampling device (support sample download) / #define SNDRV_SEQ_PORT_TYPE_SAMPLE (1<<12) / Sampling device (sample can be downloaded at any time) / /.../ #define SNDRV_SEQ_PORT_TYPE_HARDWARE (1<<16) / driver for a hardware device / #define SNDRV_SEQ_PORT_TYPE_SOFTWARE (1<<17) / implemented in software / #define SNDRV_SEQ_PORT_TYPE_SYNTHESIZER (1<<18) / generates sound / #define SNDRV_SEQ_PORT_TYPE_PORT (1<<19) / connects to other device(s) / #define SNDRV_SEQ_PORT_TYPE_APPLICATION (1<<20) / application (sequencer/editor) / / misc. conditioning flags / #define SNDRV_SEQ_PORT_FLG_GIVEN_PORT (1<<0) #define SNDRV_SEQ_PORT_FLG_TIMESTAMP (1<<1) #define SNDRV_SEQ_PORT_FLG_TIME_REAL (1<<2) #define SNDRV_SEQ_PORT_FLG_IS_MIDI1 (1<<3) / Keep MIDI 1.0 protocol / / port direction / #define SNDRV_SEQ_PORT_DIR_UNKNOWN 0 #define SNDRV_SEQ_PORT_DIR_INPUT 1 #define SNDRV_SEQ_PORT_DIR_OUTPUT 2 #define SNDRV_SEQ_PORT_DIR_BIDIRECTION 3 struct snd_seq_port_info { struct snd_seq_addr addr; / client/port numbers / char name[64]; / port name / unsigned int capability; / port capability bits / unsigned int type; / port type bits / int midi_channels; / channels per MIDI port / int midi_voices; / voices per MIDI port / int synth_voices; / voices per SYNTH port / int read_use; / R/O: subscribers for output (from this port) / int write_use; / R/O: subscribers for input (to this port) / void kernel; /* reserved for kernel use (must be NULL) / unsigned int flags; / misc. conditioning / unsigned char time_queue; / queue # for timestamping / unsigned char direction; / port usage direction (r/w/bidir) / unsigned char ump_group; / 0 = UMP EP (no conversion), 1-16 = UMP group number / char reserved[57]; / for future use / }; / queue flags / #define SNDRV_SEQ_QUEUE_FLG_SYNC (1<<0) / sync enabled / / queue information / struct snd_seq_queue_info { int queue; / queue id / / * security settings, only owner of this queue can start/stop timer * etc. if the queue is locked for other clients / int owner; / client id for owner of the queue / unsigned locked:1; / timing queue locked for other queues / char name[64]; / name of this queue / unsigned int flags; / flags / char reserved[60]; / for future use / }; / queue info/status / struct snd_seq_queue_status { int queue; / queue id / int events; / read-only - queue size / snd_seq_tick_time_t tick; / current tick / struct snd_seq_real_time time; / current time / int running; / running state of queue / int flags; / various flags / char reserved[64]; / for the future / }; / queue tempo / struct snd_seq_queue_tempo { int queue; / sequencer queue / unsigned int tempo; / current tempo, us/tick (or different time-base below) / int ppq; / time resolution, ticks/quarter / unsigned int skew_value; / queue skew / unsigned int skew_base; / queue skew base / unsigned short tempo_base; / tempo base in nsec unit; either 10 or 1000 / char reserved[22]; / for the future / }; / sequencer timer sources / #define SNDRV_SEQ_TIMER_ALSA 0 / ALSA timer / #define SNDRV_SEQ_TIMER_MIDI_CLOCK 1 / Midi Clock (CLOCK event) / #define SNDRV_SEQ_TIMER_MIDI_TICK 2 / Midi Timer Tick (TICK event) / / queue timer info / struct snd_seq_queue_timer { int queue; / sequencer queue / int type; / source timer type / union { struct { struct snd_timer_id id; / ALSA's timer ID / unsigned int resolution; / resolution in Hz / } alsa; } u; char reserved[64]; / for the future use / }; struct snd_seq_queue_client { int queue; / sequencer queue / int client; / sequencer client / int used; / queue is used with this client (must be set for accepting events) / / per client watermarks / char reserved[64]; / for future use / }; #define SNDRV_SEQ_PORT_SUBS_EXCLUSIVE (1<<0) / exclusive connection / #define SNDRV_SEQ_PORT_SUBS_TIMESTAMP (1<<1) #define SNDRV_SEQ_PORT_SUBS_TIME_REAL (1<<2) struct snd_seq_port_subscribe { struct snd_seq_addr sender; / sender address / struct snd_seq_addr dest; / destination address / unsigned int voices; / number of voices to be allocated (0 = don't care) / unsigned int flags; / modes / unsigned char queue; / input time-stamp queue (optional) / unsigned char pad[3]; / reserved / char reserved[64]; }; / type of query subscription / #define SNDRV_SEQ_QUERY_SUBS_READ 0 #define SNDRV_SEQ_QUERY_SUBS_WRITE 1 struct snd_seq_query_subs { struct snd_seq_addr root; / client/port id to be searched / int type; / READ or WRITE / int index; / 0..N-1 / int num_subs; / R/O: number of subscriptions on this port / struct snd_seq_addr addr; / R/O: result / unsigned char queue; / R/O: result / unsigned int flags; / R/O: result / char reserved[64]; / for future use / }; / * UMP-specific information / / type of UMP info query / #define SNDRV_SEQ_CLIENT_UMP_INFO_ENDPOINT 0 #define SNDRV_SEQ_CLIENT_UMP_INFO_BLOCK 1 struct snd_seq_client_ump_info { int client; / client number to inquire/set / int type; / type to inquire/set / unsigned char info[512]; / info (either UMP ep or block info) / } __attribute__((packed)); / * IOCTL commands / #define SNDRV_SEQ_IOCTL_PVERSION _IOR ('S', 0x00, int) #define SNDRV_SEQ_IOCTL_CLIENT_ID _IOR ('S', 0x01, int) #define SNDRV_SEQ_IOCTL_SYSTEM_INFO _IOWR('S', 0x02, struct snd_seq_system_info) #define SNDRV_SEQ_IOCTL_RUNNING_MODE _IOWR('S', 0x03, struct snd_seq_running_info) #define SNDRV_SEQ_IOCTL_USER_PVERSION _IOW('S', 0x04, int) #define SNDRV_SEQ_IOCTL_GET_CLIENT_INFO _IOWR('S', 0x10, struct snd_seq_client_info) #define SNDRV_SEQ_IOCTL_SET_CLIENT_INFO _IOW ('S', 0x11, struct snd_seq_client_info) #define SNDRV_SEQ_IOCTL_GET_CLIENT_UMP_INFO _IOWR('S', 0x12, struct snd_seq_client_ump_info) #define SNDRV_SEQ_IOCTL_SET_CLIENT_UMP_INFO _IOWR('S', 0x13, struct snd_seq_client_ump_info) #define SNDRV_SEQ_IOCTL_CREATE_PORT _IOWR('S', 0x20, struct snd_seq_port_info) #define SNDRV_SEQ_IOCTL_DELETE_PORT _IOW ('S', 0x21, struct snd_seq_port_info) #define SNDRV_SEQ_IOCTL_GET_PORT_INFO _IOWR('S', 0x22, struct snd_seq_port_info) #define SNDRV_SEQ_IOCTL_SET_PORT_INFO _IOW ('S', 0x23, struct snd_seq_port_info) #define SNDRV_SEQ_IOCTL_SUBSCRIBE_PORT _IOW ('S', 0x30, struct snd_seq_port_subscribe) #define SNDRV_SEQ_IOCTL_UNSUBSCRIBE_PORT _IOW ('S', 0x31, struct snd_seq_port_subscribe) #define SNDRV_SEQ_IOCTL_CREATE_QUEUE _IOWR('S', 0x32, struct snd_seq_queue_info) #define SNDRV_SEQ_IOCTL_DELETE_QUEUE _IOW ('S', 0x33, struct snd_seq_queue_info) #define SNDRV_SEQ_IOCTL_GET_QUEUE_INFO _IOWR('S', 0x34, struct snd_seq_queue_info) #define SNDRV_SEQ_IOCTL_SET_QUEUE_INFO _IOWR('S', 0x35, struct snd_seq_queue_info) #define SNDRV_SEQ_IOCTL_GET_NAMED_QUEUE _IOWR('S', 0x36, struct snd_seq_queue_info) #define SNDRV_SEQ_IOCTL_GET_QUEUE_STATUS _IOWR('S', 0x40, struct snd_seq_queue_status) #define SNDRV_SEQ_IOCTL_GET_QUEUE_TEMPO _IOWR('S', 0x41, struct snd_seq_queue_tempo) #define SNDRV_SEQ_IOCTL_SET_QUEUE_TEMPO _IOW ('S', 0x42, struct snd_seq_queue_tempo) #define SNDRV_SEQ_IOCTL_GET_QUEUE_TIMER _IOWR('S', 0x45, struct snd_seq_queue_timer) #define SNDRV_SEQ_IOCTL_SET_QUEUE_TIMER _IOW ('S', 0x46, struct snd_seq_queue_timer) #define SNDRV_SEQ_IOCTL_GET_QUEUE_CLIENT _IOWR('S', 0x49, struct snd_seq_queue_client) #define SNDRV_SEQ_IOCTL_SET_QUEUE_CLIENT _IOW ('S', 0x4a, struct snd_seq_queue_client) #define SNDRV_SEQ_IOCTL_GET_CLIENT_POOL _IOWR('S', 0x4b, struct snd_seq_client_pool) #define SNDRV_SEQ_IOCTL_SET_CLIENT_POOL _IOW ('S', 0x4c, struct snd_seq_client_pool) #define SNDRV_SEQ_IOCTL_REMOVE_EVENTS _IOW ('S', 0x4e, struct snd_seq_remove_events) #define SNDRV_SEQ_IOCTL_QUERY_SUBS _IOWR('S', 0x4f, struct snd_seq_query_subs) #define SNDRV_SEQ_IOCTL_GET_SUBSCRIPTION _IOWR('S', 0x50, struct snd_seq_port_subscribe) #define SNDRV_SEQ_IOCTL_QUERY_NEXT_CLIENT _IOWR('S', 0x51, struct snd_seq_client_info) #define SNDRV_SEQ_IOCTL_QUERY_NEXT_PORT _IOWR('S', 0x52, struct snd_seq_port_info) #endif / __SOUND_ASEQUENCER_H */	23.25 KB	2026-03-24 10:01
📄 asoc.h /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note / / * uapi/sound/asoc.h -- ALSA SoC Firmware Controls and DAPM * * Copyright (C) 2012 Texas Instruments Inc. * Copyright (C) 2015 Intel Corporation. * * Simple file API to load FW that includes mixers, coefficients, DAPM graphs, * algorithms, equalisers, DAIs, widgets etc. / #ifndef __LINUX_UAPI_SND_ASOC_H #define __LINUX_UAPI_SND_ASOC_H #include <linux/types.h> #include <sound/asound.h> / * Maximum number of channels topology kcontrol can represent. / #define SND_SOC_TPLG_MAX_CHAN 8 / * Maximum number of PCM formats capability / #define SND_SOC_TPLG_MAX_FORMATS 16 / * Maximum number of PCM stream configs / #define SND_SOC_TPLG_STREAM_CONFIG_MAX 8 / * Maximum number of physical link's hardware configs / #define SND_SOC_TPLG_HW_CONFIG_MAX 8 / individual kcontrol info types - can be mixed with other types / #define SND_SOC_TPLG_CTL_VOLSW 1 #define SND_SOC_TPLG_CTL_VOLSW_SX 2 #define SND_SOC_TPLG_CTL_VOLSW_XR_SX 3 #define SND_SOC_TPLG_CTL_ENUM 4 #define SND_SOC_TPLG_CTL_BYTES 5 #define SND_SOC_TPLG_CTL_ENUM_VALUE 6 #define SND_SOC_TPLG_CTL_RANGE 7 #define SND_SOC_TPLG_CTL_STROBE 8 / individual widget kcontrol info types - can be mixed with other types / #define SND_SOC_TPLG_DAPM_CTL_VOLSW 64 #define SND_SOC_TPLG_DAPM_CTL_ENUM_DOUBLE 65 #define SND_SOC_TPLG_DAPM_CTL_ENUM_VIRT 66 #define SND_SOC_TPLG_DAPM_CTL_ENUM_VALUE 67 #define SND_SOC_TPLG_DAPM_CTL_PIN 68 / DAPM widget types - add new items to the end / #define SND_SOC_TPLG_DAPM_INPUT 0 #define SND_SOC_TPLG_DAPM_OUTPUT 1 #define SND_SOC_TPLG_DAPM_MUX 2 #define SND_SOC_TPLG_DAPM_MIXER 3 #define SND_SOC_TPLG_DAPM_PGA 4 #define SND_SOC_TPLG_DAPM_OUT_DRV 5 #define SND_SOC_TPLG_DAPM_ADC 6 #define SND_SOC_TPLG_DAPM_DAC 7 #define SND_SOC_TPLG_DAPM_SWITCH 8 #define SND_SOC_TPLG_DAPM_PRE 9 #define SND_SOC_TPLG_DAPM_POST 10 #define SND_SOC_TPLG_DAPM_AIF_IN 11 #define SND_SOC_TPLG_DAPM_AIF_OUT 12 #define SND_SOC_TPLG_DAPM_DAI_IN 13 #define SND_SOC_TPLG_DAPM_DAI_OUT 14 #define SND_SOC_TPLG_DAPM_DAI_LINK 15 #define SND_SOC_TPLG_DAPM_BUFFER 16 #define SND_SOC_TPLG_DAPM_SCHEDULER 17 #define SND_SOC_TPLG_DAPM_EFFECT 18 #define SND_SOC_TPLG_DAPM_SIGGEN 19 #define SND_SOC_TPLG_DAPM_SRC 20 #define SND_SOC_TPLG_DAPM_ASRC 21 #define SND_SOC_TPLG_DAPM_ENCODER 22 #define SND_SOC_TPLG_DAPM_DECODER 23 #define SND_SOC_TPLG_DAPM_LAST SND_SOC_TPLG_DAPM_DECODER / Header magic number and string sizes / #define SND_SOC_TPLG_MAGIC 0x41536F43 / ASoC / / string sizes / #define SND_SOC_TPLG_NUM_TEXTS 16 / ABI version / #define SND_SOC_TPLG_ABI_VERSION 0x5 / current version / #define SND_SOC_TPLG_ABI_VERSION_MIN 0x5 / oldest version supported / / Max size of TLV data / #define SND_SOC_TPLG_TLV_SIZE 32 / * File and Block header data types. * Add new generic and vendor types to end of list. * Generic types are handled by the core whilst vendors types are passed * to the component drivers for handling. / #define SND_SOC_TPLG_TYPE_MIXER 1 #define SND_SOC_TPLG_TYPE_BYTES 2 #define SND_SOC_TPLG_TYPE_ENUM 3 #define SND_SOC_TPLG_TYPE_DAPM_GRAPH 4 #define SND_SOC_TPLG_TYPE_DAPM_WIDGET 5 #define SND_SOC_TPLG_TYPE_DAI_LINK 6 #define SND_SOC_TPLG_TYPE_PCM 7 #define SND_SOC_TPLG_TYPE_MANIFEST 8 #define SND_SOC_TPLG_TYPE_CODEC_LINK 9 #define SND_SOC_TPLG_TYPE_BACKEND_LINK 10 #define SND_SOC_TPLG_TYPE_PDATA 11 #define SND_SOC_TPLG_TYPE_DAI 12 #define SND_SOC_TPLG_TYPE_MAX SND_SOC_TPLG_TYPE_DAI / vendor block IDs - please add new vendor types to end / #define SND_SOC_TPLG_TYPE_VENDOR_FW 1000 #define SND_SOC_TPLG_TYPE_VENDOR_CONFIG 1001 #define SND_SOC_TPLG_TYPE_VENDOR_COEFF 1002 #define SND_SOC_TPLG_TYPEVENDOR_CODEC 1003 #define SND_SOC_TPLG_STREAM_PLAYBACK 0 #define SND_SOC_TPLG_STREAM_CAPTURE 1 / vendor tuple types / #define SND_SOC_TPLG_TUPLE_TYPE_UUID 0 #define SND_SOC_TPLG_TUPLE_TYPE_STRING 1 #define SND_SOC_TPLG_TUPLE_TYPE_BOOL 2 #define SND_SOC_TPLG_TUPLE_TYPE_BYTE 3 #define SND_SOC_TPLG_TUPLE_TYPE_WORD 4 #define SND_SOC_TPLG_TUPLE_TYPE_SHORT 5 / DAI flags / #define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_RATES (1 << 0) #define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_CHANNELS (1 << 1) #define SND_SOC_TPLG_DAI_FLGBIT_SYMMETRIC_SAMPLEBITS (1 << 2) / DAI clock gating / #define SND_SOC_TPLG_DAI_CLK_GATE_UNDEFINED 0 #define SND_SOC_TPLG_DAI_CLK_GATE_GATED 1 #define SND_SOC_TPLG_DAI_CLK_GATE_CONT 2 / DAI mclk_direction / #define SND_SOC_TPLG_MCLK_CO 0 / for codec, mclk is output / #define SND_SOC_TPLG_MCLK_CI 1 / for codec, mclk is input / / DAI physical PCM data formats. * Add new formats to the end of the list. / #define SND_SOC_DAI_FORMAT_I2S 1 / I2S mode / #define SND_SOC_DAI_FORMAT_RIGHT_J 2 / Right Justified mode / #define SND_SOC_DAI_FORMAT_LEFT_J 3 / Left Justified mode / #define SND_SOC_DAI_FORMAT_DSP_A 4 / L data MSB after FRM LRC / #define SND_SOC_DAI_FORMAT_DSP_B 5 / L data MSB during FRM LRC / #define SND_SOC_DAI_FORMAT_AC97 6 / AC97 / #define SND_SOC_DAI_FORMAT_PDM 7 / Pulse density modulation / / left and right justified also known as MSB and LSB respectively / #define SND_SOC_DAI_FORMAT_MSB SND_SOC_DAI_FORMAT_LEFT_J #define SND_SOC_DAI_FORMAT_LSB SND_SOC_DAI_FORMAT_RIGHT_J / DAI link flags / #define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_RATES (1 << 0) #define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_CHANNELS (1 << 1) #define SND_SOC_TPLG_LNK_FLGBIT_SYMMETRIC_SAMPLEBITS (1 << 2) #define SND_SOC_TPLG_LNK_FLGBIT_VOICE_WAKEUP (1 << 3) / DAI topology BCLK parameter * For the backwards capability, by default codec is bclk provider / #define SND_SOC_TPLG_BCLK_CP 0 / codec is bclk provider / #define SND_SOC_TPLG_BCLK_CC 1 / codec is bclk consumer / / keep previous definitions for compatibility / #define SND_SOC_TPLG_BCLK_CM SND_SOC_TPLG_BCLK_CP #define SND_SOC_TPLG_BCLK_CS SND_SOC_TPLG_BCLK_CC / DAI topology FSYNC parameter * For the backwards capability, by default codec is fsync provider / #define SND_SOC_TPLG_FSYNC_CP 0 / codec is fsync provider / #define SND_SOC_TPLG_FSYNC_CC 1 / codec is fsync consumer / / keep previous definitions for compatibility / #define SND_SOC_TPLG_FSYNC_CM SND_SOC_TPLG_FSYNC_CP #define SND_SOC_TPLG_FSYNC_CS SND_SOC_TPLG_FSYNC_CC / * Block Header. * This header precedes all object and object arrays below. / struct snd_soc_tplg_hdr { __le32 magic; / magic number / __le32 abi; / ABI version / __le32 version; / optional vendor specific version details / __le32 type; / SND_SOC_TPLG_TYPE_ / __le32 size; / size of this structure / __le32 vendor_type; / optional vendor specific type info / __le32 payload_size; / data bytes, excluding this header / __le32 index; / identifier for block / __le32 count; / number of elements in block / } __attribute__((packed)); / vendor tuple for uuid / struct snd_soc_tplg_vendor_uuid_elem { __le32 token; char uuid[16]; } __attribute__((packed)); / vendor tuple for a bool/byte/short/word value / struct snd_soc_tplg_vendor_value_elem { __le32 token; __le32 value; } __attribute__((packed)); / vendor tuple for string / struct snd_soc_tplg_vendor_string_elem { __le32 token; char string[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; } __attribute__((packed)); struct snd_soc_tplg_vendor_array { __le32 size; / size in bytes of the array, including all elements / __le32 type; / SND_SOC_TPLG_TUPLE_TYPE_ / __le32 num_elems; / number of elements in array / union { __DECLARE_FLEX_ARRAY(struct snd_soc_tplg_vendor_uuid_elem, uuid); __DECLARE_FLEX_ARRAY(struct snd_soc_tplg_vendor_value_elem, value); __DECLARE_FLEX_ARRAY(struct snd_soc_tplg_vendor_string_elem, string); }; } __attribute__((packed)); / * Private data. * All topology objects may have private data that can be used by the driver or * firmware. Core will ignore this data. / struct snd_soc_tplg_private { __le32 size; / in bytes of private data / union { __DECLARE_FLEX_ARRAY(char, data); __DECLARE_FLEX_ARRAY(struct snd_soc_tplg_vendor_array, array); }; } __attribute__((packed)); / * Kcontrol TLV data. / struct snd_soc_tplg_tlv_dbscale { __le32 min; __le32 step; __le32 mute; } __attribute__((packed)); struct snd_soc_tplg_ctl_tlv { __le32 size; / in bytes of this structure / __le32 type; / SNDRV_CTL_TLVT_, type of TLV / union { __le32 data[SND_SOC_TPLG_TLV_SIZE]; struct snd_soc_tplg_tlv_dbscale scale; }; } __attribute__((packed)); /* * Kcontrol channel data / struct snd_soc_tplg_channel { __le32 size; / in bytes of this structure / __le32 reg; __le32 shift; __le32 id; / ID maps to Left, Right, LFE etc / } __attribute__((packed)); / * Genericl Operations IDs, for binding Kcontrol or Bytes ext ops * Kcontrol ops need get/put/info. * Bytes ext ops need get/put. / struct snd_soc_tplg_io_ops { __le32 get; __le32 put; __le32 info; } __attribute__((packed)); / * kcontrol header / struct snd_soc_tplg_ctl_hdr { __le32 size; / in bytes of this structure / __le32 type; char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; __le32 access; struct snd_soc_tplg_io_ops ops; struct snd_soc_tplg_ctl_tlv tlv; } __attribute__((packed)); / * Stream Capabilities / struct snd_soc_tplg_stream_caps { __le32 size; / in bytes of this structure / char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; __le64 formats; / supported formats SNDRV_PCM_FMTBIT_* / __le32 rates; / supported rates SNDRV_PCM_RATE_* / __le32 rate_min; / min rate / __le32 rate_max; / max rate / __le32 channels_min; / min channels / __le32 channels_max; / max channels / __le32 periods_min; / min number of periods / __le32 periods_max; / max number of periods / __le32 period_size_min; / min period size bytes / __le32 period_size_max; / max period size bytes / __le32 buffer_size_min; / min buffer size bytes / __le32 buffer_size_max; / max buffer size bytes / __le32 sig_bits; / number of bits of content / } __attribute__((packed)); / * FE or BE Stream configuration supported by SW/FW / struct snd_soc_tplg_stream { __le32 size; / in bytes of this structure / char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; / Name of the stream / __le64 format; / SNDRV_PCM_FMTBIT_* / __le32 rate; / SNDRV_PCM_RATE_* / __le32 period_bytes; / size of period in bytes / __le32 buffer_bytes; / size of buffer in bytes / __le32 channels; / channels / } __attribute__((packed)); / * Describes a physical link's runtime supported hardware config, * i.e. hardware audio formats. / struct snd_soc_tplg_hw_config { __le32 size; / in bytes of this structure / __le32 id; / unique ID - - used to match / __le32 fmt; / SND_SOC_DAI_FORMAT_ format value / __u8 clock_gated; / SND_SOC_TPLG_DAI_CLK_GATE_ value / __u8 invert_bclk; / 1 for inverted BCLK, 0 for normal / __u8 invert_fsync; / 1 for inverted frame clock, 0 for normal / __u8 bclk_provider; / SND_SOC_TPLG_BCLK_ value / __u8 fsync_provider; / SND_SOC_TPLG_FSYNC_ value / __u8 mclk_direction; / SND_SOC_TPLG_MCLK_ value / __le16 reserved; / for 32bit alignment / __le32 mclk_rate; / MCLK or SYSCLK freqency in Hz / __le32 bclk_rate; / BCLK freqency in Hz / __le32 fsync_rate; / frame clock in Hz / __le32 tdm_slots; / number of TDM slots in use / __le32 tdm_slot_width; / width in bits for each slot / __le32 tx_slots; / bit mask for active Tx slots / __le32 rx_slots; / bit mask for active Rx slots / __le32 tx_channels; / number of Tx channels / __le32 tx_chanmap[SND_SOC_TPLG_MAX_CHAN]; / array of slot number / __le32 rx_channels; / number of Rx channels / __le32 rx_chanmap[SND_SOC_TPLG_MAX_CHAN]; / array of slot number / } __attribute__((packed)); / * Manifest. List totals for each payload type. Not used in parsing, but will * be passed to the component driver before any other objects in order for any * global component resource allocations. * * File block representation for manifest :- * +-----------------------------------+----+ * \| struct snd_soc_tplg_hdr \| 1 \| * +-----------------------------------+----+ * \| struct snd_soc_tplg_manifest \| 1 \| * +-----------------------------------+----+ / struct snd_soc_tplg_manifest { __le32 size; / in bytes of this structure / __le32 control_elems; / number of control elements / __le32 widget_elems; / number of widget elements / __le32 graph_elems; / number of graph elements / __le32 pcm_elems; / number of PCM elements / __le32 dai_link_elems; / number of DAI link elements / __le32 dai_elems; / number of physical DAI elements / __le32 reserved[20]; / reserved for new ABI element types / struct snd_soc_tplg_private priv; } __attribute__((packed)); / * Mixer kcontrol. * * File block representation for mixer kcontrol :- * +-----------------------------------+----+ * \| struct snd_soc_tplg_hdr \| 1 \| * +-----------------------------------+----+ * \| struct snd_soc_tplg_mixer_control \| N \| * +-----------------------------------+----+ / struct snd_soc_tplg_mixer_control { struct snd_soc_tplg_ctl_hdr hdr; __le32 size; / in bytes of this structure / __le32 min; __le32 max; __le32 platform_max; __le32 invert; __le32 num_channels; struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN]; struct snd_soc_tplg_private priv; } __attribute__((packed)); / * Enumerated kcontrol * * File block representation for enum kcontrol :- * +-----------------------------------+----+ * \| struct snd_soc_tplg_hdr \| 1 \| * +-----------------------------------+----+ * \| struct snd_soc_tplg_enum_control \| N \| * +-----------------------------------+----+ / struct snd_soc_tplg_enum_control { struct snd_soc_tplg_ctl_hdr hdr; __le32 size; / in bytes of this structure / __le32 num_channels; struct snd_soc_tplg_channel channel[SND_SOC_TPLG_MAX_CHAN]; __le32 items; __le32 mask; __le32 count; char texts[SND_SOC_TPLG_NUM_TEXTS][SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; __le32 values[SND_SOC_TPLG_NUM_TEXTS SNDRV_CTL_ELEM_ID_NAME_MAXLEN / 4]; struct snd_soc_tplg_private priv; } __attribute__((packed)); /* * Bytes kcontrol * * File block representation for bytes kcontrol :- * +-----------------------------------+----+ * \| struct snd_soc_tplg_hdr \| 1 \| * +-----------------------------------+----+ * \| struct snd_soc_tplg_bytes_control \| N \| * +-----------------------------------+----+ / struct snd_soc_tplg_bytes_control { struct snd_soc_tplg_ctl_hdr hdr; __le32 size; / in bytes of this structure / __le32 max; __le32 mask; __le32 base; __le32 num_regs; struct snd_soc_tplg_io_ops ext_ops; struct snd_soc_tplg_private priv; } __attribute__((packed)); / * DAPM Graph Element * * File block representation for DAPM graph elements :- * +-------------------------------------+----+ * \| struct snd_soc_tplg_hdr \| 1 \| * +-------------------------------------+----+ * \| struct snd_soc_tplg_dapm_graph_elem \| N \| * +-------------------------------------+----+ / struct snd_soc_tplg_dapm_graph_elem { char sink[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; char control[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; char source[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; } __attribute__((packed)); / * DAPM Widget. * * File block representation for DAPM widget :- * +-------------------------------------+-----+ * \| struct snd_soc_tplg_hdr \| 1 \| * +-------------------------------------+-----+ * \| struct snd_soc_tplg_dapm_widget \| N \| * +-------------------------------------+-----+ * \| struct snd_soc_tplg_enum_control \| 0\|1 \| * \| struct snd_soc_tplg_mixer_control \| 0\|N \| * +-------------------------------------+-----+ * * Optional enum or mixer control can be appended to the end of each widget * in the block. / struct snd_soc_tplg_dapm_widget { __le32 size; / in bytes of this structure / __le32 id; / SND_SOC_DAPM_CTL / char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; char sname[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; __le32 reg; / negative reg = no direct dapm / __le32 shift; / bits to shift / __le32 mask; / non-shifted mask / __le32 subseq; / sort within widget type / __le32 invert; / invert the power bit / __le32 ignore_suspend; / kept enabled over suspend / __le16 event_flags; __le16 event_type; __le32 num_kcontrols; struct snd_soc_tplg_private priv; / * kcontrols that relate to this widget * follow here after widget private data / } __attribute__((packed)); / * Describes SW/FW specific features of PCM (FE DAI & DAI link). * * File block representation for PCM :- * +-----------------------------------+-----+ * \| struct snd_soc_tplg_hdr \| 1 \| * +-----------------------------------+-----+ * \| struct snd_soc_tplg_pcm \| N \| * +-----------------------------------+-----+ / struct snd_soc_tplg_pcm { __le32 size; / in bytes of this structure / char pcm_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; __le32 pcm_id; / unique ID - used to match with DAI link / __le32 dai_id; / unique ID - used to match / __le32 playback; / supports playback mode / __le32 capture; / supports capture mode / __le32 compress; / 1 = compressed; 0 = PCM / struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; / for DAI link / __le32 num_streams; / number of streams / struct snd_soc_tplg_stream_caps caps[2]; / playback and capture for DAI / __le32 flag_mask; / bitmask of flags to configure / __le32 flags; / SND_SOC_TPLG_LNK_FLGBIT_* flag value / struct snd_soc_tplg_private priv; } __attribute__((packed)); / * Describes the physical link runtime supported configs or params * * File block representation for physical link config :- * +-----------------------------------+-----+ * \| struct snd_soc_tplg_hdr \| 1 \| * +-----------------------------------+-----+ * \| struct snd_soc_tplg_link_config \| N \| * +-----------------------------------+-----+ / struct snd_soc_tplg_link_config { __le32 size; / in bytes of this structure / __le32 id; / unique ID - used to match / char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; / name - used to match / char stream_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; / stream name - used to match / struct snd_soc_tplg_stream stream[SND_SOC_TPLG_STREAM_CONFIG_MAX]; / supported configs playback and captrure / __le32 num_streams; / number of streams / struct snd_soc_tplg_hw_config hw_config[SND_SOC_TPLG_HW_CONFIG_MAX]; / hw configs / __le32 num_hw_configs; / number of hw configs / __le32 default_hw_config_id; / default hw config ID for init / __le32 flag_mask; / bitmask of flags to configure / __le32 flags; / SND_SOC_TPLG_LNK_FLGBIT_* flag value / struct snd_soc_tplg_private priv; } __attribute__((packed)); / * Describes SW/FW specific features of physical DAI. * It can be used to configure backend DAIs for DPCM. * * File block representation for physical DAI :- * +-----------------------------------+-----+ * \| struct snd_soc_tplg_hdr \| 1 \| * +-----------------------------------+-----+ * \| struct snd_soc_tplg_dai \| N \| * +-----------------------------------+-----+ / struct snd_soc_tplg_dai { __le32 size; / in bytes of this structure / char dai_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; / name - used to match / __le32 dai_id; / unique ID - used to match / __le32 playback; / supports playback mode / __le32 capture; / supports capture mode / struct snd_soc_tplg_stream_caps caps[2]; / playback and capture for DAI / __le32 flag_mask; / bitmask of flags to configure / __le32 flags; / SND_SOC_TPLG_DAI_FLGBIT_* */ struct snd_soc_tplg_private priv; } __attribute__((packed)); #endif	19.7 KB	2026-03-24 10:01
📄 asound.h /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note / / * Advanced Linux Sound Architecture - ALSA - Driver * Copyright (c) 1994-2003 by Jaroslav Kysela <perex@perex.cz>, * Abramo Bagnara <abramo@alsa-project.org> / #ifndef __SOUND_ASOUND_H #define __SOUND_ASOUND_H #if defined(__KERNEL__) \|\| defined(__linux__) #include <linux/types.h> #include <asm/byteorder.h> #else #include <endian.h> #include <sys/ioctl.h> #endif #include <stdlib.h> #include <time.h> / * protocol version / #define SNDRV_PROTOCOL_VERSION(major, minor, subminor) (((major)<<16)\|((minor)<<8)\|(subminor)) #define SNDRV_PROTOCOL_MAJOR(version) (((version)>>16)&0xffff) #define SNDRV_PROTOCOL_MINOR(version) (((version)>>8)&0xff) #define SNDRV_PROTOCOL_MICRO(version) ((version)&0xff) #define SNDRV_PROTOCOL_INCOMPATIBLE(kversion, uversion) \ (SNDRV_PROTOCOL_MAJOR(kversion) != SNDRV_PROTOCOL_MAJOR(uversion) \|\| \ (SNDRV_PROTOCOL_MAJOR(kversion) == SNDRV_PROTOCOL_MAJOR(uversion) && \ SNDRV_PROTOCOL_MINOR(kversion) != SNDRV_PROTOCOL_MINOR(uversion))) /*************************************************************************** * * * Digital audio interface * * * ***************************************************************************/ #define AES_IEC958_STATUS_SIZE 24 struct snd_aes_iec958 { unsigned char status[AES_IEC958_STATUS_SIZE]; / AES/IEC958 channel status bits / unsigned char subcode[147]; / AES/IEC958 subcode bits / unsigned char pad; / nothing / unsigned char dig_subframe[4]; / AES/IEC958 subframe bits / }; /*************************************************************************** * * * CEA-861 Audio InfoFrame. Used in HDMI and DisplayPort * * * ***************************************************************************/ struct snd_cea_861_aud_if { unsigned char db1_ct_cc; / coding type and channel count / unsigned char db2_sf_ss; / sample frequency and size / unsigned char db3; / not used, all zeros / unsigned char db4_ca; / channel allocation code / unsigned char db5_dminh_lsv; / downmix inhibit & level-shit values / }; /*************************************************************************** * * * Section for driver hardware dependent interface - /dev/snd/hw? * * * ***************************************************************************/ #define SNDRV_HWDEP_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 1) enum { SNDRV_HWDEP_IFACE_OPL2 = 0, SNDRV_HWDEP_IFACE_OPL3, SNDRV_HWDEP_IFACE_OPL4, SNDRV_HWDEP_IFACE_SB16CSP, / Creative Signal Processor / SNDRV_HWDEP_IFACE_EMU10K1, / FX8010 processor in EMU10K1 chip / SNDRV_HWDEP_IFACE_YSS225, / Yamaha FX processor / SNDRV_HWDEP_IFACE_ICS2115, / Wavetable synth / SNDRV_HWDEP_IFACE_SSCAPE, / Ensoniq SoundScape ISA card (MC68EC000) / SNDRV_HWDEP_IFACE_VX, / Digigram VX cards / SNDRV_HWDEP_IFACE_MIXART, / Digigram miXart cards / SNDRV_HWDEP_IFACE_USX2Y, / Tascam US122, US224 & US428 usb / SNDRV_HWDEP_IFACE_EMUX_WAVETABLE, / EmuX wavetable / SNDRV_HWDEP_IFACE_BLUETOOTH, / Bluetooth audio / SNDRV_HWDEP_IFACE_USX2Y_PCM, / Tascam US122, US224 & US428 rawusb pcm / SNDRV_HWDEP_IFACE_PCXHR, / Digigram PCXHR / SNDRV_HWDEP_IFACE_SB_RC, / SB Extigy/Audigy2NX remote control / SNDRV_HWDEP_IFACE_HDA, / HD-audio / SNDRV_HWDEP_IFACE_USB_STREAM, / direct access to usb stream / SNDRV_HWDEP_IFACE_FW_DICE, / TC DICE FireWire device / SNDRV_HWDEP_IFACE_FW_FIREWORKS, / Echo Audio Fireworks based device / SNDRV_HWDEP_IFACE_FW_BEBOB, / BridgeCo BeBoB based device / SNDRV_HWDEP_IFACE_FW_OXFW, / Oxford OXFW970/971 based device / SNDRV_HWDEP_IFACE_FW_DIGI00X, / Digidesign Digi 002/003 family / SNDRV_HWDEP_IFACE_FW_TASCAM, / TASCAM FireWire series / SNDRV_HWDEP_IFACE_LINE6, / Line6 USB processors / SNDRV_HWDEP_IFACE_FW_MOTU, / MOTU FireWire series / SNDRV_HWDEP_IFACE_FW_FIREFACE, / RME Fireface series / / Don't forget to change the following: / SNDRV_HWDEP_IFACE_LAST = SNDRV_HWDEP_IFACE_FW_FIREFACE }; struct snd_hwdep_info { unsigned int device; / WR: device number / int card; / R: card number / unsigned char id[64]; / ID (user selectable) / unsigned char name[80]; / hwdep name / int iface; / hwdep interface / unsigned char reserved[64]; / reserved for future / }; / generic DSP loader / struct snd_hwdep_dsp_status { unsigned int version; / R: driver-specific version / unsigned char id[32]; / R: driver-specific ID string / unsigned int num_dsps; / R: number of DSP images to transfer / unsigned int dsp_loaded; / R: bit flags indicating the loaded DSPs / unsigned int chip_ready; / R: 1 = initialization finished / unsigned char reserved[16]; / reserved for future use / }; struct snd_hwdep_dsp_image { unsigned int index; / W: DSP index / unsigned char name[64]; / W: ID (e.g. file name) / unsigned char image; /* W: binary image / size_t length; / W: size of image in bytes / unsigned long driver_data; / W: driver-specific data / }; #define SNDRV_HWDEP_IOCTL_PVERSION _IOR ('H', 0x00, int) #define SNDRV_HWDEP_IOCTL_INFO _IOR ('H', 0x01, struct snd_hwdep_info) #define SNDRV_HWDEP_IOCTL_DSP_STATUS _IOR('H', 0x02, struct snd_hwdep_dsp_status) #define SNDRV_HWDEP_IOCTL_DSP_LOAD _IOW('H', 0x03, struct snd_hwdep_dsp_image) /**************************************************************************** * * * Digital Audio (PCM) interface - /dev/snd/pcm?? * * * ****************************************************************************/ #define SNDRV_PCM_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 18) typedef unsigned long snd_pcm_uframes_t; typedef signed long snd_pcm_sframes_t; enum { SNDRV_PCM_CLASS_GENERIC = 0, / standard mono or stereo device / SNDRV_PCM_CLASS_MULTI, / multichannel device / SNDRV_PCM_CLASS_MODEM, / software modem class / SNDRV_PCM_CLASS_DIGITIZER, / digitizer class / / Don't forget to change the following: / SNDRV_PCM_CLASS_LAST = SNDRV_PCM_CLASS_DIGITIZER, }; enum { SNDRV_PCM_SUBCLASS_GENERIC_MIX = 0, / mono or stereo subdevices are mixed together / SNDRV_PCM_SUBCLASS_MULTI_MIX, / multichannel subdevices are mixed together / / Don't forget to change the following: / SNDRV_PCM_SUBCLASS_LAST = SNDRV_PCM_SUBCLASS_MULTI_MIX, }; enum { SNDRV_PCM_STREAM_PLAYBACK = 0, SNDRV_PCM_STREAM_CAPTURE, SNDRV_PCM_STREAM_LAST = SNDRV_PCM_STREAM_CAPTURE, }; typedef int __bitwise snd_pcm_access_t; #define SNDRV_PCM_ACCESS_MMAP_INTERLEAVED ((snd_pcm_access_t) 0) / interleaved mmap / #define SNDRV_PCM_ACCESS_MMAP_NONINTERLEAVED ((snd_pcm_access_t) 1) / noninterleaved mmap / #define SNDRV_PCM_ACCESS_MMAP_COMPLEX ((snd_pcm_access_t) 2) / complex mmap / #define SNDRV_PCM_ACCESS_RW_INTERLEAVED ((snd_pcm_access_t) 3) / readi/writei / #define SNDRV_PCM_ACCESS_RW_NONINTERLEAVED ((snd_pcm_access_t) 4) / readn/writen / #define SNDRV_PCM_ACCESS_LAST SNDRV_PCM_ACCESS_RW_NONINTERLEAVED typedef int __bitwise snd_pcm_format_t; #define SNDRV_PCM_FORMAT_S8 ((snd_pcm_format_t) 0) #define SNDRV_PCM_FORMAT_U8 ((snd_pcm_format_t) 1) #define SNDRV_PCM_FORMAT_S16_LE ((snd_pcm_format_t) 2) #define SNDRV_PCM_FORMAT_S16_BE ((snd_pcm_format_t) 3) #define SNDRV_PCM_FORMAT_U16_LE ((snd_pcm_format_t) 4) #define SNDRV_PCM_FORMAT_U16_BE ((snd_pcm_format_t) 5) #define SNDRV_PCM_FORMAT_S24_LE ((snd_pcm_format_t) 6) / low three bytes / #define SNDRV_PCM_FORMAT_S24_BE ((snd_pcm_format_t) 7) / low three bytes / #define SNDRV_PCM_FORMAT_U24_LE ((snd_pcm_format_t) 8) / low three bytes / #define SNDRV_PCM_FORMAT_U24_BE ((snd_pcm_format_t) 9) / low three bytes / / * For S32/U32 formats, 'msbits' hardware parameter is often used to deliver information about the * available bit count in most significant bit. It's for the case of so-called 'left-justified' or * `right-padding` sample which has less width than 32 bit. / #define SNDRV_PCM_FORMAT_S32_LE ((snd_pcm_format_t) 10) #define SNDRV_PCM_FORMAT_S32_BE ((snd_pcm_format_t) 11) #define SNDRV_PCM_FORMAT_U32_LE ((snd_pcm_format_t) 12) #define SNDRV_PCM_FORMAT_U32_BE ((snd_pcm_format_t) 13) #define SNDRV_PCM_FORMAT_FLOAT_LE ((snd_pcm_format_t) 14) / 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 / #define SNDRV_PCM_FORMAT_FLOAT_BE ((snd_pcm_format_t) 15) / 4-byte float, IEEE-754 32-bit, range -1.0 to 1.0 / #define SNDRV_PCM_FORMAT_FLOAT64_LE ((snd_pcm_format_t) 16) / 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 / #define SNDRV_PCM_FORMAT_FLOAT64_BE ((snd_pcm_format_t) 17) / 8-byte float, IEEE-754 64-bit, range -1.0 to 1.0 / #define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE ((snd_pcm_format_t) 18) / IEC-958 subframe, Little Endian / #define SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE ((snd_pcm_format_t) 19) / IEC-958 subframe, Big Endian / #define SNDRV_PCM_FORMAT_MU_LAW ((snd_pcm_format_t) 20) #define SNDRV_PCM_FORMAT_A_LAW ((snd_pcm_format_t) 21) #define SNDRV_PCM_FORMAT_IMA_ADPCM ((snd_pcm_format_t) 22) #define SNDRV_PCM_FORMAT_MPEG ((snd_pcm_format_t) 23) #define SNDRV_PCM_FORMAT_GSM ((snd_pcm_format_t) 24) #define SNDRV_PCM_FORMAT_S20_LE ((snd_pcm_format_t) 25) / in four bytes, LSB justified / #define SNDRV_PCM_FORMAT_S20_BE ((snd_pcm_format_t) 26) / in four bytes, LSB justified / #define SNDRV_PCM_FORMAT_U20_LE ((snd_pcm_format_t) 27) / in four bytes, LSB justified / #define SNDRV_PCM_FORMAT_U20_BE ((snd_pcm_format_t) 28) / in four bytes, LSB justified / / gap in the numbering for a future standard linear format / #define SNDRV_PCM_FORMAT_SPECIAL ((snd_pcm_format_t) 31) #define SNDRV_PCM_FORMAT_S24_3LE ((snd_pcm_format_t) 32) / in three bytes / #define SNDRV_PCM_FORMAT_S24_3BE ((snd_pcm_format_t) 33) / in three bytes / #define SNDRV_PCM_FORMAT_U24_3LE ((snd_pcm_format_t) 34) / in three bytes / #define SNDRV_PCM_FORMAT_U24_3BE ((snd_pcm_format_t) 35) / in three bytes / #define SNDRV_PCM_FORMAT_S20_3LE ((snd_pcm_format_t) 36) / in three bytes / #define SNDRV_PCM_FORMAT_S20_3BE ((snd_pcm_format_t) 37) / in three bytes / #define SNDRV_PCM_FORMAT_U20_3LE ((snd_pcm_format_t) 38) / in three bytes / #define SNDRV_PCM_FORMAT_U20_3BE ((snd_pcm_format_t) 39) / in three bytes / #define SNDRV_PCM_FORMAT_S18_3LE ((snd_pcm_format_t) 40) / in three bytes / #define SNDRV_PCM_FORMAT_S18_3BE ((snd_pcm_format_t) 41) / in three bytes / #define SNDRV_PCM_FORMAT_U18_3LE ((snd_pcm_format_t) 42) / in three bytes / #define SNDRV_PCM_FORMAT_U18_3BE ((snd_pcm_format_t) 43) / in three bytes / #define SNDRV_PCM_FORMAT_G723_24 ((snd_pcm_format_t) 44) / 8 samples in 3 bytes / #define SNDRV_PCM_FORMAT_G723_24_1B ((snd_pcm_format_t) 45) / 1 sample in 1 byte / #define SNDRV_PCM_FORMAT_G723_40 ((snd_pcm_format_t) 46) / 8 Samples in 5 bytes / #define SNDRV_PCM_FORMAT_G723_40_1B ((snd_pcm_format_t) 47) / 1 sample in 1 byte / #define SNDRV_PCM_FORMAT_DSD_U8 ((snd_pcm_format_t) 48) / DSD, 1-byte samples DSD (x8) / #define SNDRV_PCM_FORMAT_DSD_U16_LE ((snd_pcm_format_t) 49) / DSD, 2-byte samples DSD (x16), little endian / #define SNDRV_PCM_FORMAT_DSD_U32_LE ((snd_pcm_format_t) 50) / DSD, 4-byte samples DSD (x32), little endian / #define SNDRV_PCM_FORMAT_DSD_U16_BE ((snd_pcm_format_t) 51) / DSD, 2-byte samples DSD (x16), big endian / #define SNDRV_PCM_FORMAT_DSD_U32_BE ((snd_pcm_format_t) 52) / DSD, 4-byte samples DSD (x32), big endian / #define SNDRV_PCM_FORMAT_LAST SNDRV_PCM_FORMAT_DSD_U32_BE #define SNDRV_PCM_FORMAT_FIRST SNDRV_PCM_FORMAT_S8 #ifdef SNDRV_LITTLE_ENDIAN #define SNDRV_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16_LE #define SNDRV_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16_LE #define SNDRV_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24_LE #define SNDRV_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24_LE #define SNDRV_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32_LE #define SNDRV_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32_LE #define SNDRV_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT_LE #define SNDRV_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64_LE #define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_LE #define SNDRV_PCM_FORMAT_S20 SNDRV_PCM_FORMAT_S20_LE #define SNDRV_PCM_FORMAT_U20 SNDRV_PCM_FORMAT_U20_LE #endif #ifdef SNDRV_BIG_ENDIAN #define SNDRV_PCM_FORMAT_S16 SNDRV_PCM_FORMAT_S16_BE #define SNDRV_PCM_FORMAT_U16 SNDRV_PCM_FORMAT_U16_BE #define SNDRV_PCM_FORMAT_S24 SNDRV_PCM_FORMAT_S24_BE #define SNDRV_PCM_FORMAT_U24 SNDRV_PCM_FORMAT_U24_BE #define SNDRV_PCM_FORMAT_S32 SNDRV_PCM_FORMAT_S32_BE #define SNDRV_PCM_FORMAT_U32 SNDRV_PCM_FORMAT_U32_BE #define SNDRV_PCM_FORMAT_FLOAT SNDRV_PCM_FORMAT_FLOAT_BE #define SNDRV_PCM_FORMAT_FLOAT64 SNDRV_PCM_FORMAT_FLOAT64_BE #define SNDRV_PCM_FORMAT_IEC958_SUBFRAME SNDRV_PCM_FORMAT_IEC958_SUBFRAME_BE #define SNDRV_PCM_FORMAT_S20 SNDRV_PCM_FORMAT_S20_BE #define SNDRV_PCM_FORMAT_U20 SNDRV_PCM_FORMAT_U20_BE #endif typedef int __bitwise snd_pcm_subformat_t; #define SNDRV_PCM_SUBFORMAT_STD ((snd_pcm_subformat_t) 0) #define SNDRV_PCM_SUBFORMAT_MSBITS_MAX ((snd_pcm_subformat_t) 1) #define SNDRV_PCM_SUBFORMAT_MSBITS_20 ((snd_pcm_subformat_t) 2) #define SNDRV_PCM_SUBFORMAT_MSBITS_24 ((snd_pcm_subformat_t) 3) #define SNDRV_PCM_SUBFORMAT_LAST SNDRV_PCM_SUBFORMAT_MSBITS_24 #define SNDRV_PCM_INFO_MMAP 0x00000001 / hardware supports mmap / #define SNDRV_PCM_INFO_MMAP_VALID 0x00000002 / period data are valid during transfer / #define SNDRV_PCM_INFO_DOUBLE 0x00000004 / Double buffering needed for PCM start/stop / #define SNDRV_PCM_INFO_BATCH 0x00000010 / double buffering / #define SNDRV_PCM_INFO_SYNC_APPLPTR 0x00000020 / need the explicit sync of appl_ptr update / #define SNDRV_PCM_INFO_PERFECT_DRAIN 0x00000040 / silencing at the end of stream is not required / #define SNDRV_PCM_INFO_INTERLEAVED 0x00000100 / channels are interleaved / #define SNDRV_PCM_INFO_NONINTERLEAVED 0x00000200 / channels are not interleaved / #define SNDRV_PCM_INFO_COMPLEX 0x00000400 / complex frame organization (mmap only) / #define SNDRV_PCM_INFO_BLOCK_TRANSFER 0x00010000 / hardware transfer block of samples / #define SNDRV_PCM_INFO_OVERRANGE 0x00020000 / hardware supports ADC (capture) overrange detection / #define SNDRV_PCM_INFO_RESUME 0x00040000 / hardware supports stream resume after suspend / #define SNDRV_PCM_INFO_PAUSE 0x00080000 / pause ioctl is supported / #define SNDRV_PCM_INFO_HALF_DUPLEX 0x00100000 / only half duplex / #define SNDRV_PCM_INFO_JOINT_DUPLEX 0x00200000 / playback and capture stream are somewhat correlated / #define SNDRV_PCM_INFO_SYNC_START 0x00400000 / pcm support some kind of sync go / #define SNDRV_PCM_INFO_NO_PERIOD_WAKEUP 0x00800000 / period wakeup can be disabled / #define SNDRV_PCM_INFO_HAS_WALL_CLOCK 0x01000000 / (Deprecated)has audio wall clock for audio/system time sync / #define SNDRV_PCM_INFO_HAS_LINK_ATIME 0x01000000 / report hardware link audio time, reset on startup / #define SNDRV_PCM_INFO_HAS_LINK_ABSOLUTE_ATIME 0x02000000 / report absolute hardware link audio time, not reset on startup / #define SNDRV_PCM_INFO_HAS_LINK_ESTIMATED_ATIME 0x04000000 / report estimated link audio time / #define SNDRV_PCM_INFO_HAS_LINK_SYNCHRONIZED_ATIME 0x08000000 / report synchronized audio/system time / #define SNDRV_PCM_INFO_EXPLICIT_SYNC 0x10000000 / needs explicit sync of pointers and data / #define SNDRV_PCM_INFO_NO_REWINDS 0x20000000 / hardware can only support monotonic changes of appl_ptr / #define SNDRV_PCM_INFO_DRAIN_TRIGGER 0x40000000 / internal kernel flag - trigger in drain / #define SNDRV_PCM_INFO_FIFO_IN_FRAMES 0x80000000 / internal kernel flag - FIFO size is in frames / #if (__BITS_PER_LONG == 32 && defined(__USE_TIME_BITS64)) \|\| defined __KERNEL__ #define __SND_STRUCT_TIME64 #endif typedef int __bitwise snd_pcm_state_t; #define SNDRV_PCM_STATE_OPEN ((snd_pcm_state_t) 0) / stream is open / #define SNDRV_PCM_STATE_SETUP ((snd_pcm_state_t) 1) / stream has a setup / #define SNDRV_PCM_STATE_PREPARED ((snd_pcm_state_t) 2) / stream is ready to start / #define SNDRV_PCM_STATE_RUNNING ((snd_pcm_state_t) 3) / stream is running / #define SNDRV_PCM_STATE_XRUN ((snd_pcm_state_t) 4) / stream reached an xrun / #define SNDRV_PCM_STATE_DRAINING ((snd_pcm_state_t) 5) / stream is draining / #define SNDRV_PCM_STATE_PAUSED ((snd_pcm_state_t) 6) / stream is paused / #define SNDRV_PCM_STATE_SUSPENDED ((snd_pcm_state_t) 7) / hardware is suspended / #define SNDRV_PCM_STATE_DISCONNECTED ((snd_pcm_state_t) 8) / hardware is disconnected / #define SNDRV_PCM_STATE_LAST SNDRV_PCM_STATE_DISCONNECTED enum { SNDRV_PCM_MMAP_OFFSET_DATA = 0x00000000, SNDRV_PCM_MMAP_OFFSET_STATUS_OLD = 0x80000000, SNDRV_PCM_MMAP_OFFSET_CONTROL_OLD = 0x81000000, SNDRV_PCM_MMAP_OFFSET_STATUS_NEW = 0x82000000, SNDRV_PCM_MMAP_OFFSET_CONTROL_NEW = 0x83000000, #ifdef __SND_STRUCT_TIME64 SNDRV_PCM_MMAP_OFFSET_STATUS = SNDRV_PCM_MMAP_OFFSET_STATUS_NEW, SNDRV_PCM_MMAP_OFFSET_CONTROL = SNDRV_PCM_MMAP_OFFSET_CONTROL_NEW, #else SNDRV_PCM_MMAP_OFFSET_STATUS = SNDRV_PCM_MMAP_OFFSET_STATUS_OLD, SNDRV_PCM_MMAP_OFFSET_CONTROL = SNDRV_PCM_MMAP_OFFSET_CONTROL_OLD, #endif }; union snd_pcm_sync_id { unsigned char id[16]; unsigned short id16[8]; unsigned int id32[4]; } __attribute__((deprecated)); struct snd_pcm_info { unsigned int device; / RO/WR (control): device number / unsigned int subdevice; / RO/WR (control): subdevice number / int stream; / RO/WR (control): stream direction / int card; / R: card number / unsigned char id[64]; / ID (user selectable) / unsigned char name[80]; / name of this device / unsigned char subname[32]; / subdevice name / int dev_class; / SNDRV_PCM_CLASS_* / int dev_subclass; / SNDRV_PCM_SUBCLASS_* / unsigned int subdevices_count; unsigned int subdevices_avail; unsigned char pad1[16]; / was: hardware synchronization ID / unsigned char reserved[64]; / reserved for future... / }; typedef int snd_pcm_hw_param_t; #define SNDRV_PCM_HW_PARAM_ACCESS 0 / Access type / #define SNDRV_PCM_HW_PARAM_FORMAT 1 / Format / #define SNDRV_PCM_HW_PARAM_SUBFORMAT 2 / Subformat / #define SNDRV_PCM_HW_PARAM_FIRST_MASK SNDRV_PCM_HW_PARAM_ACCESS #define SNDRV_PCM_HW_PARAM_LAST_MASK SNDRV_PCM_HW_PARAM_SUBFORMAT #define SNDRV_PCM_HW_PARAM_SAMPLE_BITS 8 / Bits per sample / #define SNDRV_PCM_HW_PARAM_FRAME_BITS 9 / Bits per frame / #define SNDRV_PCM_HW_PARAM_CHANNELS 10 / Channels / #define SNDRV_PCM_HW_PARAM_RATE 11 / Approx rate / #define SNDRV_PCM_HW_PARAM_PERIOD_TIME 12 / Approx distance between * interrupts in us / #define SNDRV_PCM_HW_PARAM_PERIOD_SIZE 13 / Approx frames between * interrupts / #define SNDRV_PCM_HW_PARAM_PERIOD_BYTES 14 / Approx bytes between * interrupts / #define SNDRV_PCM_HW_PARAM_PERIODS 15 / Approx interrupts per * buffer / #define SNDRV_PCM_HW_PARAM_BUFFER_TIME 16 / Approx duration of buffer * in us / #define SNDRV_PCM_HW_PARAM_BUFFER_SIZE 17 / Size of buffer in frames / #define SNDRV_PCM_HW_PARAM_BUFFER_BYTES 18 / Size of buffer in bytes / #define SNDRV_PCM_HW_PARAM_TICK_TIME 19 / Approx tick duration in us / #define SNDRV_PCM_HW_PARAM_FIRST_INTERVAL SNDRV_PCM_HW_PARAM_SAMPLE_BITS #define SNDRV_PCM_HW_PARAM_LAST_INTERVAL SNDRV_PCM_HW_PARAM_TICK_TIME #define SNDRV_PCM_HW_PARAMS_NORESAMPLE (1<<0) / avoid rate resampling / #define SNDRV_PCM_HW_PARAMS_EXPORT_BUFFER (1<<1) / export buffer / #define SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP (1<<2) / disable period wakeups / #define SNDRV_PCM_HW_PARAMS_NO_DRAIN_SILENCE (1<<3) / suppress drain with the filling * of the silence samples / struct snd_interval { unsigned int min, max; unsigned int openmin:1, openmax:1, integer:1, empty:1; }; #define SNDRV_MASK_MAX 256 struct snd_mask { __u32 bits[(SNDRV_MASK_MAX+31)/32]; }; struct snd_pcm_hw_params { unsigned int flags; struct snd_mask masks[SNDRV_PCM_HW_PARAM_LAST_MASK - SNDRV_PCM_HW_PARAM_FIRST_MASK + 1]; struct snd_mask mres[5]; / reserved masks / struct snd_interval intervals[SNDRV_PCM_HW_PARAM_LAST_INTERVAL - SNDRV_PCM_HW_PARAM_FIRST_INTERVAL + 1]; struct snd_interval ires[9]; / reserved intervals / unsigned int rmask; / W: requested masks / unsigned int cmask; / R: changed masks / unsigned int info; / R: Info flags for returned setup / unsigned int msbits; / R: used most significant bits (in sample bit-width) / unsigned int rate_num; / R: rate numerator / unsigned int rate_den; / R: rate denominator / snd_pcm_uframes_t fifo_size; / R: chip FIFO size in frames / unsigned char sync[16]; / R: synchronization ID (perfect sync - one clock source) / unsigned char reserved[48]; / reserved for future / }; enum { SNDRV_PCM_TSTAMP_NONE = 0, SNDRV_PCM_TSTAMP_ENABLE, SNDRV_PCM_TSTAMP_LAST = SNDRV_PCM_TSTAMP_ENABLE, }; struct snd_pcm_sw_params { int tstamp_mode; / timestamp mode / unsigned int period_step; unsigned int sleep_min; / min ticks to sleep / snd_pcm_uframes_t avail_min; / min avail frames for wakeup / snd_pcm_uframes_t xfer_align; / obsolete: xfer size need to be a multiple / snd_pcm_uframes_t start_threshold; / min hw_avail frames for automatic start / / * The following two thresholds alleviate playback buffer underruns; when * hw_avail drops below the threshold, the respective action is triggered: / snd_pcm_uframes_t stop_threshold; / - stop playback / snd_pcm_uframes_t silence_threshold; / - pre-fill buffer with silence / snd_pcm_uframes_t silence_size; / max size of silence pre-fill; when >= boundary, * fill played area with silence immediately / snd_pcm_uframes_t boundary; / pointers wrap point / unsigned int proto; / protocol version / unsigned int tstamp_type; / timestamp type (req. proto >= 2.0.12) / unsigned char reserved[56]; / reserved for future / }; struct snd_pcm_channel_info { unsigned int channel; __kernel_off_t offset; / mmap offset / unsigned int first; / offset to first sample in bits / unsigned int step; / samples distance in bits / }; enum { / * first definition for backwards compatibility only, * maps to wallclock/link time for HDAudio playback and DEFAULT/DMA time for everything else / SNDRV_PCM_AUDIO_TSTAMP_TYPE_COMPAT = 0, / timestamp definitions / SNDRV_PCM_AUDIO_TSTAMP_TYPE_DEFAULT = 1, / DMA time, reported as per hw_ptr / SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK = 2, / link time reported by sample or wallclock counter, reset on startup / SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ABSOLUTE = 3, / link time reported by sample or wallclock counter, not reset on startup / SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_ESTIMATED = 4, / link time estimated indirectly / SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED = 5, / link time synchronized with system time / SNDRV_PCM_AUDIO_TSTAMP_TYPE_LAST = SNDRV_PCM_AUDIO_TSTAMP_TYPE_LINK_SYNCHRONIZED }; / explicit padding avoids incompatibility between i386 and x86-64 / typedef struct { unsigned char pad[sizeof(time_t) - sizeof(int)]; } __time_pad; struct snd_pcm_status { snd_pcm_state_t state; / stream state / __time_pad pad1; / align to timespec / struct timespec trigger_tstamp; / time when stream was started/stopped/paused / struct timespec tstamp; / reference timestamp / snd_pcm_uframes_t appl_ptr; / appl ptr / snd_pcm_uframes_t hw_ptr; / hw ptr / snd_pcm_sframes_t delay; / current delay in frames / snd_pcm_uframes_t avail; / number of frames available / snd_pcm_uframes_t avail_max; / max frames available on hw since last status / snd_pcm_uframes_t overrange; / count of ADC (capture) overrange detections from last status / snd_pcm_state_t suspended_state; / suspended stream state / __u32 audio_tstamp_data; / needed for 64-bit alignment, used for configs/report to/from userspace / struct timespec audio_tstamp; / sample counter, wall clock, PHC or on-demand sync'ed / struct timespec driver_tstamp; / useful in case reference system tstamp is reported with delay / __u32 audio_tstamp_accuracy; / in ns units, only valid if indicated in audio_tstamp_data / unsigned char reserved[52-2sizeof(struct timespec)]; /* must be filled with zero / }; / * For mmap operations, we need the 64-bit layout, both for compat mode, * and for y2038 compatibility. For 64-bit applications, the two definitions * are identical, so we keep the traditional version. / #ifdef __SND_STRUCT_TIME64 #define __snd_pcm_mmap_status64 snd_pcm_mmap_status #define __snd_pcm_mmap_control64 snd_pcm_mmap_control #define __snd_pcm_sync_ptr64 snd_pcm_sync_ptr #define __snd_timespec64 timespec struct __snd_timespec { __s32 tv_sec; __s32 tv_nsec; }; #else #define __snd_pcm_mmap_status snd_pcm_mmap_status #define __snd_pcm_mmap_control snd_pcm_mmap_control #define __snd_pcm_sync_ptr snd_pcm_sync_ptr #define __snd_timespec timespec struct __snd_timespec64 { __s64 tv_sec; __s64 tv_nsec; }; #endif struct __snd_pcm_mmap_status { snd_pcm_state_t state; / RO: state - SNDRV_PCM_STATE_XXXX / int pad1; / Needed for 64 bit alignment / snd_pcm_uframes_t hw_ptr; / RO: hw ptr (0...boundary-1) / struct __snd_timespec tstamp; / Timestamp / snd_pcm_state_t suspended_state; / RO: suspended stream state / struct __snd_timespec audio_tstamp; / from sample counter or wall clock / }; struct __snd_pcm_mmap_control { snd_pcm_uframes_t appl_ptr; / RW: appl ptr (0...boundary-1) / snd_pcm_uframes_t avail_min; / RW: min available frames for wakeup / }; #define SNDRV_PCM_SYNC_PTR_HWSYNC (1<<0) / execute hwsync / #define SNDRV_PCM_SYNC_PTR_APPL (1<<1) / get appl_ptr from driver (r/w op) / #define SNDRV_PCM_SYNC_PTR_AVAIL_MIN (1<<2) / get avail_min from driver / struct __snd_pcm_sync_ptr { unsigned int flags; union { struct __snd_pcm_mmap_status status; unsigned char reserved[64]; } s; union { struct __snd_pcm_mmap_control control; unsigned char reserved[64]; } c; }; #if defined(__BYTE_ORDER) ? __BYTE_ORDER == __BIG_ENDIAN : defined(__BIG_ENDIAN) typedef char __pad_before_uframe[sizeof(__u64) - sizeof(snd_pcm_uframes_t)]; typedef char __pad_after_uframe[0]; #endif #if defined(__BYTE_ORDER) ? __BYTE_ORDER == __LITTLE_ENDIAN : defined(__LITTLE_ENDIAN) typedef char __pad_before_uframe[0]; typedef char __pad_after_uframe[sizeof(__u64) - sizeof(snd_pcm_uframes_t)]; #endif struct __snd_pcm_mmap_status64 { snd_pcm_state_t state; / RO: state - SNDRV_PCM_STATE_XXXX / __u32 pad1; / Needed for 64 bit alignment / __pad_before_uframe __pad1; snd_pcm_uframes_t hw_ptr; / RO: hw ptr (0...boundary-1) / __pad_after_uframe __pad2; struct __snd_timespec64 tstamp; / Timestamp / snd_pcm_state_t suspended_state;/ RO: suspended stream state / __u32 pad3; / Needed for 64 bit alignment / struct __snd_timespec64 audio_tstamp; / sample counter or wall clock / }; struct __snd_pcm_mmap_control64 { __pad_before_uframe __pad1; snd_pcm_uframes_t appl_ptr; / RW: appl ptr (0...boundary-1) / __pad_before_uframe __pad2; // This should be __pad_after_uframe, but binary // backwards compatibility constraints prevent a fix. __pad_before_uframe __pad3; snd_pcm_uframes_t avail_min; / RW: min available frames for wakeup / __pad_after_uframe __pad4; }; struct __snd_pcm_sync_ptr64 { __u32 flags; __u32 pad1; union { struct __snd_pcm_mmap_status64 status; unsigned char reserved[64]; } s; union { struct __snd_pcm_mmap_control64 control; unsigned char reserved[64]; } c; }; struct snd_xferi { snd_pcm_sframes_t result; void buf; snd_pcm_uframes_t frames; }; struct snd_xfern { snd_pcm_sframes_t result; void * bufs; snd_pcm_uframes_t frames; }; enum { SNDRV_PCM_TSTAMP_TYPE_GETTIMEOFDAY = 0, / gettimeofday equivalent / SNDRV_PCM_TSTAMP_TYPE_MONOTONIC, / posix_clock_monotonic equivalent / SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW, / monotonic_raw (no NTP) / SNDRV_PCM_TSTAMP_TYPE_LAST = SNDRV_PCM_TSTAMP_TYPE_MONOTONIC_RAW, }; / channel positions / enum { SNDRV_CHMAP_UNKNOWN = 0, SNDRV_CHMAP_NA, / N/A, silent / SNDRV_CHMAP_MONO, / mono stream / / this follows the alsa-lib mixer channel value + 3 / SNDRV_CHMAP_FL, / front left / SNDRV_CHMAP_FR, / front right / SNDRV_CHMAP_RL, / rear left / SNDRV_CHMAP_RR, / rear right / SNDRV_CHMAP_FC, / front center / SNDRV_CHMAP_LFE, / LFE / SNDRV_CHMAP_SL, / side left / SNDRV_CHMAP_SR, / side right / SNDRV_CHMAP_RC, / rear center / / new definitions / SNDRV_CHMAP_FLC, / front left center / SNDRV_CHMAP_FRC, / front right center / SNDRV_CHMAP_RLC, / rear left center / SNDRV_CHMAP_RRC, / rear right center / SNDRV_CHMAP_FLW, / front left wide / SNDRV_CHMAP_FRW, / front right wide / SNDRV_CHMAP_FLH, / front left high / SNDRV_CHMAP_FCH, / front center high / SNDRV_CHMAP_FRH, / front right high / SNDRV_CHMAP_TC, / top center / SNDRV_CHMAP_TFL, / top front left / SNDRV_CHMAP_TFR, / top front right / SNDRV_CHMAP_TFC, / top front center / SNDRV_CHMAP_TRL, / top rear left / SNDRV_CHMAP_TRR, / top rear right / SNDRV_CHMAP_TRC, / top rear center / / new definitions for UAC2 / SNDRV_CHMAP_TFLC, / top front left center / SNDRV_CHMAP_TFRC, / top front right center / SNDRV_CHMAP_TSL, / top side left / SNDRV_CHMAP_TSR, / top side right / SNDRV_CHMAP_LLFE, / left LFE / SNDRV_CHMAP_RLFE, / right LFE / SNDRV_CHMAP_BC, / bottom center / SNDRV_CHMAP_BLC, / bottom left center / SNDRV_CHMAP_BRC, / bottom right center / SNDRV_CHMAP_LAST = SNDRV_CHMAP_BRC, }; #define SNDRV_CHMAP_POSITION_MASK 0xffff #define SNDRV_CHMAP_PHASE_INVERSE (0x01 << 16) #define SNDRV_CHMAP_DRIVER_SPEC (0x02 << 16) #define SNDRV_PCM_IOCTL_PVERSION _IOR('A', 0x00, int) #define SNDRV_PCM_IOCTL_INFO _IOR('A', 0x01, struct snd_pcm_info) #define SNDRV_PCM_IOCTL_TSTAMP _IOW('A', 0x02, int) #define SNDRV_PCM_IOCTL_TTSTAMP _IOW('A', 0x03, int) #define SNDRV_PCM_IOCTL_USER_PVERSION _IOW('A', 0x04, int) #define SNDRV_PCM_IOCTL_HW_REFINE _IOWR('A', 0x10, struct snd_pcm_hw_params) #define SNDRV_PCM_IOCTL_HW_PARAMS _IOWR('A', 0x11, struct snd_pcm_hw_params) #define SNDRV_PCM_IOCTL_HW_FREE _IO('A', 0x12) #define SNDRV_PCM_IOCTL_SW_PARAMS _IOWR('A', 0x13, struct snd_pcm_sw_params) #define SNDRV_PCM_IOCTL_STATUS _IOR('A', 0x20, struct snd_pcm_status) #define SNDRV_PCM_IOCTL_DELAY _IOR('A', 0x21, snd_pcm_sframes_t) #define SNDRV_PCM_IOCTL_HWSYNC _IO('A', 0x22) #define __SNDRV_PCM_IOCTL_SYNC_PTR _IOWR('A', 0x23, struct __snd_pcm_sync_ptr) #define __SNDRV_PCM_IOCTL_SYNC_PTR64 _IOWR('A', 0x23, struct __snd_pcm_sync_ptr64) #define SNDRV_PCM_IOCTL_SYNC_PTR _IOWR('A', 0x23, struct snd_pcm_sync_ptr) #define SNDRV_PCM_IOCTL_STATUS_EXT _IOWR('A', 0x24, struct snd_pcm_status) #define SNDRV_PCM_IOCTL_CHANNEL_INFO _IOR('A', 0x32, struct snd_pcm_channel_info) #define SNDRV_PCM_IOCTL_PREPARE _IO('A', 0x40) #define SNDRV_PCM_IOCTL_RESET _IO('A', 0x41) #define SNDRV_PCM_IOCTL_START _IO('A', 0x42) #define SNDRV_PCM_IOCTL_DROP _IO('A', 0x43) #define SNDRV_PCM_IOCTL_DRAIN _IO('A', 0x44) #define SNDRV_PCM_IOCTL_PAUSE _IOW('A', 0x45, int) #define SNDRV_PCM_IOCTL_REWIND _IOW('A', 0x46, snd_pcm_uframes_t) #define SNDRV_PCM_IOCTL_RESUME _IO('A', 0x47) #define SNDRV_PCM_IOCTL_XRUN _IO('A', 0x48) #define SNDRV_PCM_IOCTL_FORWARD _IOW('A', 0x49, snd_pcm_uframes_t) #define SNDRV_PCM_IOCTL_WRITEI_FRAMES _IOW('A', 0x50, struct snd_xferi) #define SNDRV_PCM_IOCTL_READI_FRAMES _IOR('A', 0x51, struct snd_xferi) #define SNDRV_PCM_IOCTL_WRITEN_FRAMES _IOW('A', 0x52, struct snd_xfern) #define SNDRV_PCM_IOCTL_READN_FRAMES _IOR('A', 0x53, struct snd_xfern) #define SNDRV_PCM_IOCTL_LINK _IOW('A', 0x60, int) #define SNDRV_PCM_IOCTL_UNLINK _IO('A', 0x61) /**************************************************************************** * * * MIDI v1.0 interface * * * ****************************************************************************/ / * Raw MIDI section - /dev/snd/midi?? / #define SNDRV_RAWMIDI_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 5) enum { SNDRV_RAWMIDI_STREAM_OUTPUT = 0, SNDRV_RAWMIDI_STREAM_INPUT, SNDRV_RAWMIDI_STREAM_LAST = SNDRV_RAWMIDI_STREAM_INPUT, }; #define SNDRV_RAWMIDI_INFO_OUTPUT 0x00000001 #define SNDRV_RAWMIDI_INFO_INPUT 0x00000002 #define SNDRV_RAWMIDI_INFO_DUPLEX 0x00000004 #define SNDRV_RAWMIDI_INFO_UMP 0x00000008 #define SNDRV_RAWMIDI_INFO_STREAM_INACTIVE 0x00000010 #define SNDRV_RAWMIDI_DEVICE_UNKNOWN 0 struct snd_rawmidi_info { unsigned int device; / RO/WR (control): device number / unsigned int subdevice; / RO/WR (control): subdevice number / int stream; / WR: stream / int card; / R: card number / unsigned int flags; / SNDRV_RAWMIDI_INFO_XXXX / unsigned char id[64]; / ID (user selectable) / unsigned char name[80]; / name of device / unsigned char subname[32]; / name of active or selected subdevice / unsigned int subdevices_count; unsigned int subdevices_avail; int tied_device; / R: tied rawmidi device (UMP/legacy) / unsigned char reserved[60]; / reserved for future use / }; #define SNDRV_RAWMIDI_MODE_FRAMING_MASK (7<<0) #define SNDRV_RAWMIDI_MODE_FRAMING_SHIFT 0 #define SNDRV_RAWMIDI_MODE_FRAMING_NONE (0<<0) #define SNDRV_RAWMIDI_MODE_FRAMING_TSTAMP (1<<0) #define SNDRV_RAWMIDI_MODE_CLOCK_MASK (7<<3) #define SNDRV_RAWMIDI_MODE_CLOCK_SHIFT 3 #define SNDRV_RAWMIDI_MODE_CLOCK_NONE (0<<3) #define SNDRV_RAWMIDI_MODE_CLOCK_REALTIME (1<<3) #define SNDRV_RAWMIDI_MODE_CLOCK_MONOTONIC (2<<3) #define SNDRV_RAWMIDI_MODE_CLOCK_MONOTONIC_RAW (3<<3) #define SNDRV_RAWMIDI_FRAMING_DATA_LENGTH 16 struct snd_rawmidi_framing_tstamp { / For now, frame_type is always 0. Midi 2.0 is expected to add new * types here. Applications are expected to skip unknown frame types. / __u8 frame_type; __u8 length; / number of valid bytes in data field / __u8 reserved[2]; __u32 tv_nsec; / nanoseconds / __u64 tv_sec; / seconds / __u8 data[SNDRV_RAWMIDI_FRAMING_DATA_LENGTH]; } __attribute__((packed)); struct snd_rawmidi_params { int stream; size_t buffer_size; / queue size in bytes / size_t avail_min; / minimum avail bytes for wakeup / unsigned int no_active_sensing: 1; / do not send active sensing byte in close() / unsigned int mode; / For input data only, frame incoming data / unsigned char reserved[12]; / reserved for future use / }; struct snd_rawmidi_status { int stream; __time_pad pad1; struct timespec tstamp; / Timestamp / size_t avail; / available bytes / size_t xruns; / count of overruns since last status (in bytes) / unsigned char reserved[16]; / reserved for future use / }; / UMP EP info flags / #define SNDRV_UMP_EP_INFO_STATIC_BLOCKS 0x01 / UMP EP Protocol / JRTS capability bits / #define SNDRV_UMP_EP_INFO_PROTO_MIDI_MASK 0x0300 #define SNDRV_UMP_EP_INFO_PROTO_MIDI1 0x0100 / MIDI 1.0 / #define SNDRV_UMP_EP_INFO_PROTO_MIDI2 0x0200 / MIDI 2.0 / #define SNDRV_UMP_EP_INFO_PROTO_JRTS_MASK 0x0003 #define SNDRV_UMP_EP_INFO_PROTO_JRTS_TX 0x0001 / JRTS Transmit / #define SNDRV_UMP_EP_INFO_PROTO_JRTS_RX 0x0002 / JRTS Receive / / UMP Endpoint information / struct snd_ump_endpoint_info { int card; / card number / int device; / device number / unsigned int flags; / additional info / unsigned int protocol_caps; / protocol capabilities / unsigned int protocol; / current protocol / unsigned int num_blocks; / # of function blocks / unsigned short version; / UMP major/minor version / unsigned short family_id; / MIDI device family ID / unsigned short model_id; / MIDI family model ID / unsigned int manufacturer_id; / MIDI manufacturer ID / unsigned char sw_revision[4]; / software revision / unsigned short padding; unsigned char name[128]; / endpoint name string / unsigned char product_id[128]; / unique product id string / unsigned char reserved[32]; } __attribute__((packed)); / UMP direction / #define SNDRV_UMP_DIR_INPUT 0x01 #define SNDRV_UMP_DIR_OUTPUT 0x02 #define SNDRV_UMP_DIR_BIDIRECTION 0x03 / UMP block info flags / #define SNDRV_UMP_BLOCK_IS_MIDI1 (1U << 0) / MIDI 1.0 port w/o restrict / #define SNDRV_UMP_BLOCK_IS_LOWSPEED (1U << 1) / 31.25Kbps B/W MIDI1 port / / UMP block user-interface hint / #define SNDRV_UMP_BLOCK_UI_HINT_UNKNOWN 0x00 #define SNDRV_UMP_BLOCK_UI_HINT_RECEIVER 0x01 #define SNDRV_UMP_BLOCK_UI_HINT_SENDER 0x02 #define SNDRV_UMP_BLOCK_UI_HINT_BOTH 0x03 / UMP groups and blocks / #define SNDRV_UMP_MAX_GROUPS 16 #define SNDRV_UMP_MAX_BLOCKS 32 / UMP Block information / struct snd_ump_block_info { int card; / card number / int device; / device number / unsigned char block_id; / block ID (R/W) / unsigned char direction; / UMP direction / unsigned char active; / Activeness / unsigned char first_group; / first group ID / unsigned char num_groups; / number of groups / unsigned char midi_ci_version; / MIDI-CI support version / unsigned char sysex8_streams; / max number of sysex8 streams / unsigned char ui_hint; / user interface hint / unsigned int flags; / various info flags / unsigned char name[128]; / block name string / unsigned char reserved[32]; } __attribute__((packed)); #define SNDRV_RAWMIDI_IOCTL_PVERSION _IOR('W', 0x00, int) #define SNDRV_RAWMIDI_IOCTL_INFO _IOR('W', 0x01, struct snd_rawmidi_info) #define SNDRV_RAWMIDI_IOCTL_USER_PVERSION _IOW('W', 0x02, int) #define SNDRV_RAWMIDI_IOCTL_PARAMS _IOWR('W', 0x10, struct snd_rawmidi_params) #define SNDRV_RAWMIDI_IOCTL_STATUS _IOWR('W', 0x20, struct snd_rawmidi_status) #define SNDRV_RAWMIDI_IOCTL_DROP _IOW('W', 0x30, int) #define SNDRV_RAWMIDI_IOCTL_DRAIN _IOW('W', 0x31, int) / Additional ioctls for UMP rawmidi devices / #define SNDRV_UMP_IOCTL_ENDPOINT_INFO _IOR('W', 0x40, struct snd_ump_endpoint_info) #define SNDRV_UMP_IOCTL_BLOCK_INFO _IOR('W', 0x41, struct snd_ump_block_info) / * Timer section - /dev/snd/timer / #define SNDRV_TIMER_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 8) enum { SNDRV_TIMER_CLASS_NONE = -1, SNDRV_TIMER_CLASS_SLAVE = 0, SNDRV_TIMER_CLASS_GLOBAL, SNDRV_TIMER_CLASS_CARD, SNDRV_TIMER_CLASS_PCM, SNDRV_TIMER_CLASS_LAST = SNDRV_TIMER_CLASS_PCM, }; / slave timer classes / enum { SNDRV_TIMER_SCLASS_NONE = 0, SNDRV_TIMER_SCLASS_APPLICATION, SNDRV_TIMER_SCLASS_SEQUENCER, / alias / SNDRV_TIMER_SCLASS_OSS_SEQUENCER, / alias / SNDRV_TIMER_SCLASS_LAST = SNDRV_TIMER_SCLASS_OSS_SEQUENCER, }; / global timers (device member) / #define SNDRV_TIMER_GLOBAL_SYSTEM 0 #define SNDRV_TIMER_GLOBAL_RTC 1 / unused / #define SNDRV_TIMER_GLOBAL_HPET 2 #define SNDRV_TIMER_GLOBAL_HRTIMER 3 #define SNDRV_TIMER_GLOBAL_UDRIVEN 4 / info flags / #define SNDRV_TIMER_FLG_SLAVE (1<<0) / cannot be controlled / struct snd_timer_id { int dev_class; int dev_sclass; int card; int device; int subdevice; }; struct snd_timer_ginfo { struct snd_timer_id tid; / requested timer ID / unsigned int flags; / timer flags - SNDRV_TIMER_FLG_* / int card; / card number / unsigned char id[64]; / timer identification / unsigned char name[80]; / timer name / unsigned long reserved0; / reserved for future use / unsigned long resolution; / average period resolution in ns / unsigned long resolution_min; / minimal period resolution in ns / unsigned long resolution_max; / maximal period resolution in ns / unsigned int clients; / active timer clients / unsigned char reserved[32]; }; struct snd_timer_gparams { struct snd_timer_id tid; / requested timer ID / unsigned long period_num; / requested precise period duration (in seconds) - numerator / unsigned long period_den; / requested precise period duration (in seconds) - denominator / unsigned char reserved[32]; }; struct snd_timer_gstatus { struct snd_timer_id tid; / requested timer ID / unsigned long resolution; / current period resolution in ns / unsigned long resolution_num; / precise current period resolution (in seconds) - numerator / unsigned long resolution_den; / precise current period resolution (in seconds) - denominator / unsigned char reserved[32]; }; struct snd_timer_select { struct snd_timer_id id; / bind to timer ID / unsigned char reserved[32]; / reserved / }; struct snd_timer_info { unsigned int flags; / timer flags - SNDRV_TIMER_FLG_* / int card; / card number / unsigned char id[64]; / timer identificator / unsigned char name[80]; / timer name / unsigned long reserved0; / reserved for future use / unsigned long resolution; / average period resolution in ns / unsigned char reserved[64]; / reserved / }; #define SNDRV_TIMER_PSFLG_AUTO (1<<0) / auto start, otherwise one-shot / #define SNDRV_TIMER_PSFLG_EXCLUSIVE (1<<1) / exclusive use, precise start/stop/pause/continue / #define SNDRV_TIMER_PSFLG_EARLY_EVENT (1<<2) / write early event to the poll queue / struct snd_timer_params { unsigned int flags; / flags - SNDRV_TIMER_PSFLG_* / unsigned int ticks; / requested resolution in ticks / unsigned int queue_size; / total size of queue (32-1024) / unsigned int reserved0; / reserved, was: failure locations / unsigned int filter; / event filter (bitmask of SNDRV_TIMER_EVENT_) / unsigned char reserved[60]; /* reserved / }; struct snd_timer_status { struct timespec tstamp; / Timestamp - last update / unsigned int resolution; / current period resolution in ns / unsigned int lost; / counter of master tick lost / unsigned int overrun; / count of read queue overruns / unsigned int queue; / used queue size / unsigned char reserved[64]; / reserved / }; / * This structure describes the userspace-driven timer. Such timers are purely virtual, * and can only be triggered from software (for instance, by userspace application). / struct snd_timer_uinfo { / To pretend being a normal timer, we need to know the resolution in ns. / __u64 resolution; int fd; unsigned int id; unsigned char reserved[16]; }; #define SNDRV_TIMER_IOCTL_PVERSION _IOR('T', 0x00, int) #define SNDRV_TIMER_IOCTL_NEXT_DEVICE _IOWR('T', 0x01, struct snd_timer_id) #define SNDRV_TIMER_IOCTL_TREAD_OLD _IOW('T', 0x02, int) #define SNDRV_TIMER_IOCTL_GINFO _IOWR('T', 0x03, struct snd_timer_ginfo) #define SNDRV_TIMER_IOCTL_GPARAMS _IOW('T', 0x04, struct snd_timer_gparams) #define SNDRV_TIMER_IOCTL_GSTATUS _IOWR('T', 0x05, struct snd_timer_gstatus) #define SNDRV_TIMER_IOCTL_SELECT _IOW('T', 0x10, struct snd_timer_select) #define SNDRV_TIMER_IOCTL_INFO _IOR('T', 0x11, struct snd_timer_info) #define SNDRV_TIMER_IOCTL_PARAMS _IOW('T', 0x12, struct snd_timer_params) #define SNDRV_TIMER_IOCTL_STATUS _IOR('T', 0x14, struct snd_timer_status) / The following four ioctls are changed since 1.0.9 due to confliction / #define SNDRV_TIMER_IOCTL_START _IO('T', 0xa0) #define SNDRV_TIMER_IOCTL_STOP _IO('T', 0xa1) #define SNDRV_TIMER_IOCTL_CONTINUE _IO('T', 0xa2) #define SNDRV_TIMER_IOCTL_PAUSE _IO('T', 0xa3) #define SNDRV_TIMER_IOCTL_TREAD64 _IOW('T', 0xa4, int) #define SNDRV_TIMER_IOCTL_CREATE _IOWR('T', 0xa5, struct snd_timer_uinfo) #define SNDRV_TIMER_IOCTL_TRIGGER _IO('T', 0xa6) #if __BITS_PER_LONG == 64 #define SNDRV_TIMER_IOCTL_TREAD SNDRV_TIMER_IOCTL_TREAD_OLD #else #define SNDRV_TIMER_IOCTL_TREAD ((sizeof(__kernel_long_t) >= sizeof(time_t)) ? \ SNDRV_TIMER_IOCTL_TREAD_OLD : \ SNDRV_TIMER_IOCTL_TREAD64) #endif struct snd_timer_read { unsigned int resolution; unsigned int ticks; }; enum { SNDRV_TIMER_EVENT_RESOLUTION = 0, / val = resolution in ns / SNDRV_TIMER_EVENT_TICK, / val = ticks / SNDRV_TIMER_EVENT_START, / val = resolution in ns / SNDRV_TIMER_EVENT_STOP, / val = 0 / SNDRV_TIMER_EVENT_CONTINUE, / val = resolution in ns / SNDRV_TIMER_EVENT_PAUSE, / val = 0 / SNDRV_TIMER_EVENT_EARLY, / val = 0, early event / SNDRV_TIMER_EVENT_SUSPEND, / val = 0 / SNDRV_TIMER_EVENT_RESUME, / val = resolution in ns / / master timer events for slave timer instances / SNDRV_TIMER_EVENT_MSTART = SNDRV_TIMER_EVENT_START + 10, SNDRV_TIMER_EVENT_MSTOP = SNDRV_TIMER_EVENT_STOP + 10, SNDRV_TIMER_EVENT_MCONTINUE = SNDRV_TIMER_EVENT_CONTINUE + 10, SNDRV_TIMER_EVENT_MPAUSE = SNDRV_TIMER_EVENT_PAUSE + 10, SNDRV_TIMER_EVENT_MSUSPEND = SNDRV_TIMER_EVENT_SUSPEND + 10, SNDRV_TIMER_EVENT_MRESUME = SNDRV_TIMER_EVENT_RESUME + 10, }; struct snd_timer_tread { int event; __time_pad pad1; struct timespec tstamp; unsigned int val; __time_pad pad2; }; /*************************************************************************** * * * Section for driver control interface - /dev/snd/control? * * * ***************************************************************************/ #define SNDRV_CTL_VERSION SNDRV_PROTOCOL_VERSION(2, 0, 9) struct snd_ctl_card_info { int card; / card number / int pad; / reserved for future (was type) / unsigned char id[16]; / ID of card (user selectable) / unsigned char driver[16]; / Driver name / unsigned char name[32]; / Short name of soundcard / unsigned char longname[80]; / name + info text about soundcard / unsigned char reserved_[16]; / reserved for future (was ID of mixer) / unsigned char mixername[80]; / visual mixer identification / unsigned char components[128]; / card components / fine identification, delimited with one space (AC97 etc..) / }; typedef int __bitwise snd_ctl_elem_type_t; #define SNDRV_CTL_ELEM_TYPE_NONE ((snd_ctl_elem_type_t) 0) / invalid / #define SNDRV_CTL_ELEM_TYPE_BOOLEAN ((snd_ctl_elem_type_t) 1) / boolean type / #define SNDRV_CTL_ELEM_TYPE_INTEGER ((snd_ctl_elem_type_t) 2) / integer type / #define SNDRV_CTL_ELEM_TYPE_ENUMERATED ((snd_ctl_elem_type_t) 3) / enumerated type / #define SNDRV_CTL_ELEM_TYPE_BYTES ((snd_ctl_elem_type_t) 4) / byte array / #define SNDRV_CTL_ELEM_TYPE_IEC958 ((snd_ctl_elem_type_t) 5) / IEC958 (S/PDIF) setup / #define SNDRV_CTL_ELEM_TYPE_INTEGER64 ((snd_ctl_elem_type_t) 6) / 64-bit integer type / #define SNDRV_CTL_ELEM_TYPE_LAST SNDRV_CTL_ELEM_TYPE_INTEGER64 typedef int __bitwise snd_ctl_elem_iface_t; #define SNDRV_CTL_ELEM_IFACE_CARD ((snd_ctl_elem_iface_t) 0) / global control / #define SNDRV_CTL_ELEM_IFACE_HWDEP ((snd_ctl_elem_iface_t) 1) / hardware dependent device / #define SNDRV_CTL_ELEM_IFACE_MIXER ((snd_ctl_elem_iface_t) 2) / virtual mixer device / #define SNDRV_CTL_ELEM_IFACE_PCM ((snd_ctl_elem_iface_t) 3) / PCM device / #define SNDRV_CTL_ELEM_IFACE_RAWMIDI ((snd_ctl_elem_iface_t) 4) / RawMidi device / #define SNDRV_CTL_ELEM_IFACE_TIMER ((snd_ctl_elem_iface_t) 5) / timer device / #define SNDRV_CTL_ELEM_IFACE_SEQUENCER ((snd_ctl_elem_iface_t) 6) / sequencer client / #define SNDRV_CTL_ELEM_IFACE_LAST SNDRV_CTL_ELEM_IFACE_SEQUENCER #define SNDRV_CTL_ELEM_ACCESS_READ (1<<0) #define SNDRV_CTL_ELEM_ACCESS_WRITE (1<<1) #define SNDRV_CTL_ELEM_ACCESS_READWRITE (SNDRV_CTL_ELEM_ACCESS_READ\|SNDRV_CTL_ELEM_ACCESS_WRITE) #define SNDRV_CTL_ELEM_ACCESS_VOLATILE (1<<2) / control value may be changed without a notification / / (1 << 3) is unused. / #define SNDRV_CTL_ELEM_ACCESS_TLV_READ (1<<4) / TLV read is possible / #define SNDRV_CTL_ELEM_ACCESS_TLV_WRITE (1<<5) / TLV write is possible / #define SNDRV_CTL_ELEM_ACCESS_TLV_READWRITE (SNDRV_CTL_ELEM_ACCESS_TLV_READ\|SNDRV_CTL_ELEM_ACCESS_TLV_WRITE) #define SNDRV_CTL_ELEM_ACCESS_TLV_COMMAND (1<<6) / TLV command is possible / #define SNDRV_CTL_ELEM_ACCESS_INACTIVE (1<<8) / control does actually nothing, but may be updated / #define SNDRV_CTL_ELEM_ACCESS_LOCK (1<<9) / write lock / #define SNDRV_CTL_ELEM_ACCESS_OWNER (1<<10) / write lock owner / #define SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK (1<<28) / kernel use a TLV callback / #define SNDRV_CTL_ELEM_ACCESS_USER (1<<29) / user space element / / bits 30 and 31 are obsoleted (for indirect access) / / for further details see the ACPI and PCI power management specification / #define SNDRV_CTL_POWER_D0 0x0000 / full On / #define SNDRV_CTL_POWER_D1 0x0100 / partial On / #define SNDRV_CTL_POWER_D2 0x0200 / partial On / #define SNDRV_CTL_POWER_D3 0x0300 / Off / #define SNDRV_CTL_POWER_D3hot (SNDRV_CTL_POWER_D3\|0x0000) / Off, with power / #define SNDRV_CTL_POWER_D3cold (SNDRV_CTL_POWER_D3\|0x0001) / Off, without power / #define SNDRV_CTL_ELEM_ID_NAME_MAXLEN 44 struct snd_ctl_elem_id { unsigned int numid; / numeric identifier, zero = invalid / snd_ctl_elem_iface_t iface; / interface identifier / unsigned int device; / device/client number / unsigned int subdevice; / subdevice (substream) number / unsigned char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; / ASCII name of item / unsigned int index; / index of item / }; struct snd_ctl_elem_list { unsigned int offset; / W: first element ID to get / unsigned int space; / W: count of element IDs to get / unsigned int used; / R: count of element IDs set / unsigned int count; / R: count of all elements / struct snd_ctl_elem_id pids; /* R: IDs / unsigned char reserved[50]; }; struct snd_ctl_elem_info { struct snd_ctl_elem_id id; / W: element ID / snd_ctl_elem_type_t type; / R: value type - SNDRV_CTL_ELEM_TYPE_* / unsigned int access; / R: value access (bitmask) - SNDRV_CTL_ELEM_ACCESS_* / unsigned int count; / count of values / __kernel_pid_t owner; / owner's PID of this control / union { struct { long min; / R: minimum value / long max; / R: maximum value / long step; / R: step (0 variable) / } integer; struct { long long min; / R: minimum value / long long max; / R: maximum value / long long step; / R: step (0 variable) / } integer64; struct { unsigned int items; / R: number of items / unsigned int item; / W: item number / char name[64]; / R: value name / __u64 names_ptr; / W: names list (ELEM_ADD only) / unsigned int names_length; } enumerated; unsigned char reserved[128]; } value; unsigned char reserved[64]; }; struct snd_ctl_elem_value { struct snd_ctl_elem_id id; / W: element ID / unsigned int indirect: 1; / W: indirect access - obsoleted / union { union { long value[128]; long value_ptr; /* obsoleted / } integer; union { long long value[64]; long long value_ptr; /* obsoleted / } integer64; union { unsigned int item[128]; unsigned int item_ptr; /* obsoleted / } enumerated; union { unsigned char data[512]; unsigned char data_ptr; /* obsoleted / } bytes; struct snd_aes_iec958 iec958; } value; / RO / unsigned char reserved[128]; }; struct snd_ctl_tlv { unsigned int numid; / control element numeric identification / unsigned int length; / in bytes aligned to 4 / unsigned int tlv[]; / first TLV / }; #define SNDRV_CTL_IOCTL_PVERSION _IOR('U', 0x00, int) #define SNDRV_CTL_IOCTL_CARD_INFO _IOR('U', 0x01, struct snd_ctl_card_info) #define SNDRV_CTL_IOCTL_ELEM_LIST _IOWR('U', 0x10, struct snd_ctl_elem_list) #define SNDRV_CTL_IOCTL_ELEM_INFO _IOWR('U', 0x11, struct snd_ctl_elem_info) #define SNDRV_CTL_IOCTL_ELEM_READ _IOWR('U', 0x12, struct snd_ctl_elem_value) #define SNDRV_CTL_IOCTL_ELEM_WRITE _IOWR('U', 0x13, struct snd_ctl_elem_value) #define SNDRV_CTL_IOCTL_ELEM_LOCK _IOW('U', 0x14, struct snd_ctl_elem_id) #define SNDRV_CTL_IOCTL_ELEM_UNLOCK _IOW('U', 0x15, struct snd_ctl_elem_id) #define SNDRV_CTL_IOCTL_SUBSCRIBE_EVENTS _IOWR('U', 0x16, int) #define SNDRV_CTL_IOCTL_ELEM_ADD _IOWR('U', 0x17, struct snd_ctl_elem_info) #define SNDRV_CTL_IOCTL_ELEM_REPLACE _IOWR('U', 0x18, struct snd_ctl_elem_info) #define SNDRV_CTL_IOCTL_ELEM_REMOVE _IOWR('U', 0x19, struct snd_ctl_elem_id) #define SNDRV_CTL_IOCTL_TLV_READ _IOWR('U', 0x1a, struct snd_ctl_tlv) #define SNDRV_CTL_IOCTL_TLV_WRITE _IOWR('U', 0x1b, struct snd_ctl_tlv) #define SNDRV_CTL_IOCTL_TLV_COMMAND _IOWR('U', 0x1c, struct snd_ctl_tlv) #define SNDRV_CTL_IOCTL_HWDEP_NEXT_DEVICE _IOWR('U', 0x20, int) #define SNDRV_CTL_IOCTL_HWDEP_INFO _IOR('U', 0x21, struct snd_hwdep_info) #define SNDRV_CTL_IOCTL_PCM_NEXT_DEVICE _IOR('U', 0x30, int) #define SNDRV_CTL_IOCTL_PCM_INFO _IOWR('U', 0x31, struct snd_pcm_info) #define SNDRV_CTL_IOCTL_PCM_PREFER_SUBDEVICE _IOW('U', 0x32, int) #define SNDRV_CTL_IOCTL_RAWMIDI_NEXT_DEVICE _IOWR('U', 0x40, int) #define SNDRV_CTL_IOCTL_RAWMIDI_INFO _IOWR('U', 0x41, struct snd_rawmidi_info) #define SNDRV_CTL_IOCTL_RAWMIDI_PREFER_SUBDEVICE _IOW('U', 0x42, int) #define SNDRV_CTL_IOCTL_UMP_NEXT_DEVICE _IOWR('U', 0x43, int) #define SNDRV_CTL_IOCTL_UMP_ENDPOINT_INFO _IOWR('U', 0x44, struct snd_ump_endpoint_info) #define SNDRV_CTL_IOCTL_UMP_BLOCK_INFO _IOWR('U', 0x45, struct snd_ump_block_info) #define SNDRV_CTL_IOCTL_POWER _IOWR('U', 0xd0, int) #define SNDRV_CTL_IOCTL_POWER_STATE _IOR('U', 0xd1, int) / * Read interface. / enum sndrv_ctl_event_type { SNDRV_CTL_EVENT_ELEM = 0, SNDRV_CTL_EVENT_LAST = SNDRV_CTL_EVENT_ELEM, }; #define SNDRV_CTL_EVENT_MASK_VALUE (1<<0) / element value was changed / #define SNDRV_CTL_EVENT_MASK_INFO (1<<1) / element info was changed / #define SNDRV_CTL_EVENT_MASK_ADD (1<<2) / element was added / #define SNDRV_CTL_EVENT_MASK_TLV (1<<3) / element TLV tree was changed / #define SNDRV_CTL_EVENT_MASK_REMOVE (~0U) / element was removed / struct snd_ctl_event { int type; / event type - SNDRV_CTL_EVENT_* / union { struct { unsigned int mask; struct snd_ctl_elem_id id; } elem; unsigned char data8[60]; } data; }; / * Control names / #define SNDRV_CTL_NAME_NONE "" #define SNDRV_CTL_NAME_PLAYBACK "Playback " #define SNDRV_CTL_NAME_CAPTURE "Capture " #define SNDRV_CTL_NAME_IEC958_NONE "" #define SNDRV_CTL_NAME_IEC958_SWITCH "Switch" #define SNDRV_CTL_NAME_IEC958_VOLUME "Volume" #define SNDRV_CTL_NAME_IEC958_DEFAULT "Default" #define SNDRV_CTL_NAME_IEC958_MASK "Mask" #define SNDRV_CTL_NAME_IEC958_CON_MASK "Con Mask" #define SNDRV_CTL_NAME_IEC958_PRO_MASK "Pro Mask" #define SNDRV_CTL_NAME_IEC958_PCM_STREAM "PCM Stream" #define SNDRV_CTL_NAME_IEC958(expl,direction,what) "IEC958 " expl SNDRV_CTL_NAME_##direction SNDRV_CTL_NAME_IEC958_##what #endif / __SOUND_ASOUND_H */	54.01 KB	2026-03-24 10:01
📄 asound_fm.h /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note / #ifndef __SOUND_ASOUND_FM_H #define __SOUND_ASOUND_FM_H / * Advanced Linux Sound Architecture - ALSA * * Interface file between ALSA driver & user space * Copyright (c) 1994-98 by Jaroslav Kysela <perex@perex.cz>, * 4Front Technologies * * Direct FM control / #define SNDRV_DM_FM_MODE_OPL2 0x00 #define SNDRV_DM_FM_MODE_OPL3 0x01 struct snd_dm_fm_info { unsigned char fm_mode; / OPL mode, see SNDRV_DM_FM_MODE_XXX / unsigned char rhythm; / percussion mode flag / }; / * Data structure composing an FM "note" or sound event. / struct snd_dm_fm_voice { unsigned char op; / operator cell (0 or 1) / unsigned char voice; / FM voice (0 to 17) / unsigned char am; / amplitude modulation / unsigned char vibrato; / vibrato effect / unsigned char do_sustain; / sustain phase / unsigned char kbd_scale; / keyboard scaling / unsigned char harmonic; / 4 bits: harmonic and multiplier / unsigned char scale_level; / 2 bits: decrease output freq rises / unsigned char volume; / 6 bits: volume / unsigned char attack; / 4 bits: attack rate / unsigned char decay; / 4 bits: decay rate / unsigned char sustain; / 4 bits: sustain level / unsigned char release; / 4 bits: release rate / unsigned char feedback; / 3 bits: feedback for op0 / unsigned char connection; / 0 for serial, 1 for parallel / unsigned char left; / stereo left / unsigned char right; / stereo right / unsigned char waveform; / 3 bits: waveform shape / }; / * This describes an FM note by its voice, octave, frequency number (10bit) * and key on/off. / struct snd_dm_fm_note { unsigned char voice; / 0-17 voice channel / unsigned char octave; / 3 bits: what octave to play / unsigned int fnum; / 10 bits: frequency number / unsigned char key_on; / set for active, clear for silent / }; / * FM parameters that apply globally to all voices, and thus are not "notes" / struct snd_dm_fm_params { unsigned char am_depth; / amplitude modulation depth (1=hi) / unsigned char vib_depth; / vibrato depth (1=hi) / unsigned char kbd_split; / keyboard split / unsigned char rhythm; / percussion mode select / / This block is the percussion instrument data / unsigned char bass; unsigned char snare; unsigned char tomtom; unsigned char cymbal; unsigned char hihat; }; / * FM mode ioctl settings / #define SNDRV_DM_FM_IOCTL_INFO _IOR('H', 0x20, struct snd_dm_fm_info) #define SNDRV_DM_FM_IOCTL_RESET _IO ('H', 0x21) #define SNDRV_DM_FM_IOCTL_PLAY_NOTE _IOW('H', 0x22, struct snd_dm_fm_note) #define SNDRV_DM_FM_IOCTL_SET_VOICE _IOW('H', 0x23, struct snd_dm_fm_voice) #define SNDRV_DM_FM_IOCTL_SET_PARAMS _IOW('H', 0x24, struct snd_dm_fm_params) #define SNDRV_DM_FM_IOCTL_SET_MODE _IOW('H', 0x25, int) / for OPL3 only / #define SNDRV_DM_FM_IOCTL_SET_CONNECTION _IOW('H', 0x26, int) / SBI patch management / #define SNDRV_DM_FM_IOCTL_CLEAR_PATCHES _IO ('H', 0x40) #define SNDRV_DM_FM_OSS_IOCTL_RESET 0x20 #define SNDRV_DM_FM_OSS_IOCTL_PLAY_NOTE 0x21 #define SNDRV_DM_FM_OSS_IOCTL_SET_VOICE 0x22 #define SNDRV_DM_FM_OSS_IOCTL_SET_PARAMS 0x23 #define SNDRV_DM_FM_OSS_IOCTL_SET_MODE 0x24 #define SNDRV_DM_FM_OSS_IOCTL_SET_OPL 0x25 / * Patch Record - fixed size for write / #define FM_KEY_SBI "SBI\032" #define FM_KEY_2OP "2OP\032" #define FM_KEY_4OP "4OP\032" struct sbi_patch { unsigned char prog; unsigned char bank; char key[4]; char name[25]; char extension[7]; unsigned char data[32]; }; #endif / __SOUND_ASOUND_FM_H */	3.55 KB	2026-03-24 10:01
📄 compress_offload.h /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note / / * compress_offload.h - compress offload header definations * * Copyright (C) 2011 Intel Corporation * Authors: Vinod Koul <vinod.koul@linux.intel.com> * Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com> / #ifndef __COMPRESS_OFFLOAD_H #define __COMPRESS_OFFLOAD_H #include <linux/types.h> #include <sound/asound.h> #include <sound/compress_params.h> #define SNDRV_COMPRESS_VERSION SNDRV_PROTOCOL_VERSION(0, 3, 0) /* * struct snd_compressed_buffer - compressed buffer * @fragment_size: size of buffer fragment in bytes * @fragments: number of such fragments / struct snd_compressed_buffer { __u32 fragment_size; __u32 fragments; } __attribute__((packed, aligned(4))); /* * struct snd_compr_params - compressed stream params * @buffer: buffer description * @codec: codec parameters * @no_wake_mode: dont wake on fragment elapsed / struct snd_compr_params { struct snd_compressed_buffer buffer; struct snd_codec codec; __u8 no_wake_mode; } __attribute__((packed, aligned(4))); /* * struct snd_compr_tstamp - timestamp descriptor * @byte_offset: Byte offset in ring buffer to DSP * @copied_total: Total number of bytes copied from/to ring buffer to/by DSP * @pcm_frames: Frames decoded or encoded by DSP. This field will evolve by * large steps and should only be used to monitor encoding/decoding * progress. It shall not be used for timing estimates. * @pcm_io_frames: Frames rendered or received by DSP into a mixer or an audio * output/input. This field should be used for A/V sync or time estimates. * @sampling_rate: sampling rate of audio / struct snd_compr_tstamp { __u32 byte_offset; __u32 copied_total; __u32 pcm_frames; __u32 pcm_io_frames; __u32 sampling_rate; } __attribute__((packed, aligned(4))); /* * struct snd_compr_avail - avail descriptor * @avail: Number of bytes available in ring buffer for writing/reading * @tstamp: timestamp information / struct snd_compr_avail { __u64 avail; struct snd_compr_tstamp tstamp; } __attribute__((packed, aligned(4))); enum snd_compr_direction { SND_COMPRESS_PLAYBACK = 0, SND_COMPRESS_CAPTURE, SND_COMPRESS_ACCEL }; /* * struct snd_compr_caps - caps descriptor * @codecs: pointer to array of codecs * @direction: direction supported. Of type snd_compr_direction * @min_fragment_size: minimum fragment supported by DSP * @max_fragment_size: maximum fragment supported by DSP * @min_fragments: min fragments supported by DSP * @max_fragments: max fragments supported by DSP * @num_codecs: number of codecs supported * @reserved: reserved field / struct snd_compr_caps { __u32 num_codecs; __u32 direction; __u32 min_fragment_size; __u32 max_fragment_size; __u32 min_fragments; __u32 max_fragments; __u32 codecs[MAX_NUM_CODECS]; __u32 reserved[11]; } __attribute__((packed, aligned(4))); /* * struct snd_compr_codec_caps - query capability of codec * @codec: codec for which capability is queried * @num_descriptors: number of codec descriptors * @descriptor: array of codec capability descriptor / struct snd_compr_codec_caps { __u32 codec; __u32 num_descriptors; struct snd_codec_desc descriptor[MAX_NUM_CODEC_DESCRIPTORS]; } __attribute__((packed, aligned(4))); /* * enum sndrv_compress_encoder - encoder metadata key * @SNDRV_COMPRESS_ENCODER_PADDING: no of samples appended by the encoder at the * end of the track * @SNDRV_COMPRESS_ENCODER_DELAY: no of samples inserted by the encoder at the * beginning of the track / enum sndrv_compress_encoder { SNDRV_COMPRESS_ENCODER_PADDING = 1, SNDRV_COMPRESS_ENCODER_DELAY = 2, }; /* * struct snd_compr_metadata - compressed stream metadata * @key: key id * @value: key value / struct snd_compr_metadata { __u32 key; __u32 value[8]; } __attribute__((packed, aligned(4))); / flags for struct snd_compr_task / #define SND_COMPRESS_TFLG_NEW_STREAM (1<<0) / mark for the new stream data / /* * struct snd_compr_task - task primitive for non-realtime operation * @seqno: sequence number (task identifier) * @origin_seqno: previous sequence number (task identifier) - for reuse * @input_fd: data input file descriptor (dma-buf) * @output_fd: data output file descriptor (dma-buf) * @input_size: filled data in bytes (from caller, must not exceed fragment size) * @flags: see SND_COMPRESS_TFLG_* defines * @reserved: reserved for future extension / struct snd_compr_task { __u64 seqno; __u64 origin_seqno; int input_fd; int output_fd; __u64 input_size; __u32 flags; __u8 reserved[16]; } __attribute__((packed, aligned(4))); /* * enum snd_compr_state - task state * @SND_COMPRESS_TASK_STATE_IDLE: task is not queued * @SND_COMPRESS_TASK_STATE_ACTIVE: task is in the queue * @SND_COMPRESS_TASK_STATE_FINISHED: task was processed, output is available / enum snd_compr_state { SND_COMPRESS_TASK_STATE_IDLE = 0, SND_COMPRESS_TASK_STATE_ACTIVE, SND_COMPRESS_TASK_STATE_FINISHED }; /* * struct snd_compr_task_status - task status * @seqno: sequence number (task identifier) * @input_size: filled data in bytes (from user space) * @output_size: filled data in bytes (from driver) * @output_flags: reserved for future (all zeros - from driver) * @state: actual task state (SND_COMPRESS_TASK_STATE_) @reserved: reserved for future extension / struct snd_compr_task_status { __u64 seqno; __u64 input_size; __u64 output_size; __u32 output_flags; __u8 state; __u8 reserved[15]; } __attribute__((packed, aligned(4))); / * compress path ioctl definitions * SNDRV_COMPRESS_GET_CAPS: Query capability of DSP * SNDRV_COMPRESS_GET_CODEC_CAPS: Query capability of a codec * SNDRV_COMPRESS_SET_PARAMS: Set codec and stream parameters * Note: only codec params can be changed runtime and stream params cant be * SNDRV_COMPRESS_GET_PARAMS: Query codec params * SNDRV_COMPRESS_TSTAMP: get the current timestamp value * SNDRV_COMPRESS_AVAIL: get the current buffer avail value. * This also queries the tstamp properties * SNDRV_COMPRESS_PAUSE: Pause the running stream * SNDRV_COMPRESS_RESUME: resume a paused stream * SNDRV_COMPRESS_START: Start a stream * SNDRV_COMPRESS_STOP: stop a running stream, discarding ring buffer content * and the buffers currently with DSP * SNDRV_COMPRESS_DRAIN: Play till end of buffers and stop after that * SNDRV_COMPRESS_IOCTL_VERSION: Query the API version / #define SNDRV_COMPRESS_IOCTL_VERSION _IOR('C', 0x00, int) #define SNDRV_COMPRESS_GET_CAPS _IOWR('C', 0x10, struct snd_compr_caps) #define SNDRV_COMPRESS_GET_CODEC_CAPS _IOWR('C', 0x11,\ struct snd_compr_codec_caps) #define SNDRV_COMPRESS_SET_PARAMS _IOW('C', 0x12, struct snd_compr_params) #define SNDRV_COMPRESS_GET_PARAMS _IOR('C', 0x13, struct snd_codec) #define SNDRV_COMPRESS_SET_METADATA _IOW('C', 0x14,\ struct snd_compr_metadata) #define SNDRV_COMPRESS_GET_METADATA _IOWR('C', 0x15,\ struct snd_compr_metadata) #define SNDRV_COMPRESS_TSTAMP _IOR('C', 0x20, struct snd_compr_tstamp) #define SNDRV_COMPRESS_AVAIL _IOR('C', 0x21, struct snd_compr_avail) #define SNDRV_COMPRESS_PAUSE _IO('C', 0x30) #define SNDRV_COMPRESS_RESUME _IO('C', 0x31) #define SNDRV_COMPRESS_START _IO('C', 0x32) #define SNDRV_COMPRESS_STOP _IO('C', 0x33) #define SNDRV_COMPRESS_DRAIN _IO('C', 0x34) #define SNDRV_COMPRESS_NEXT_TRACK _IO('C', 0x35) #define SNDRV_COMPRESS_PARTIAL_DRAIN _IO('C', 0x36) #define SNDRV_COMPRESS_TASK_CREATE _IOWR('C', 0x60, struct snd_compr_task) #define SNDRV_COMPRESS_TASK_FREE _IOW('C', 0x61, __u64) #define SNDRV_COMPRESS_TASK_START _IOWR('C', 0x62, struct snd_compr_task) #define SNDRV_COMPRESS_TASK_STOP _IOW('C', 0x63, __u64) #define SNDRV_COMPRESS_TASK_STATUS _IOWR('C', 0x68, struct snd_compr_task_status) / * TODO * 1. add mmap support * / #define SND_COMPR_TRIGGER_DRAIN 7 /FIXME move this to pcm.h */ #define SND_COMPR_TRIGGER_NEXT_TRACK 8 #define SND_COMPR_TRIGGER_PARTIAL_DRAIN 9 #endif	7.79 KB	2026-03-24 10:01
📄 compress_params.h /* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) AND MIT) / / * compress_params.h - codec types and parameters for compressed data * streaming interface * * Copyright (C) 2011 Intel Corporation * Authors: Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com> * Vinod Koul <vinod.koul@linux.intel.com> * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * The definitions in this file are derived from the OpenMAX AL version 1.1 * and OpenMAX IL v 1.1.2 header files which contain the copyright notice below * and are licensed under the MIT license. * * Copyright (c) 2007-2010 The Khronos Group Inc. / #ifndef __SND_COMPRESS_PARAMS_H #define __SND_COMPRESS_PARAMS_H #include <linux/types.h> / AUDIO CODECS SUPPORTED / #define MAX_NUM_CODECS 32 #define MAX_NUM_CODEC_DESCRIPTORS 32 #define MAX_NUM_BITRATES 32 #define MAX_NUM_SAMPLE_RATES 32 / Codecs are listed linearly to allow for extensibility / #define SND_AUDIOCODEC_PCM ((__u32) 0x00000001) #define SND_AUDIOCODEC_MP3 ((__u32) 0x00000002) #define SND_AUDIOCODEC_AMR ((__u32) 0x00000003) #define SND_AUDIOCODEC_AMRWB ((__u32) 0x00000004) #define SND_AUDIOCODEC_AMRWBPLUS ((__u32) 0x00000005) #define SND_AUDIOCODEC_AAC ((__u32) 0x00000006) #define SND_AUDIOCODEC_WMA ((__u32) 0x00000007) #define SND_AUDIOCODEC_REAL ((__u32) 0x00000008) #define SND_AUDIOCODEC_VORBIS ((__u32) 0x00000009) #define SND_AUDIOCODEC_FLAC ((__u32) 0x0000000A) #define SND_AUDIOCODEC_IEC61937 ((__u32) 0x0000000B) #define SND_AUDIOCODEC_G723_1 ((__u32) 0x0000000C) #define SND_AUDIOCODEC_G729 ((__u32) 0x0000000D) #define SND_AUDIOCODEC_BESPOKE ((__u32) 0x0000000E) #define SND_AUDIOCODEC_ALAC ((__u32) 0x0000000F) #define SND_AUDIOCODEC_APE ((__u32) 0x00000010) #define SND_AUDIOCODEC_MAX SND_AUDIOCODEC_APE / * Profile and modes are listed with bit masks. This allows for a * more compact representation of fields that will not evolve * (in contrast to the list of codecs) / #define SND_AUDIOPROFILE_PCM ((__u32) 0x00000001) / MP3 modes are only useful for encoders / #define SND_AUDIOCHANMODE_MP3_MONO ((__u32) 0x00000001) #define SND_AUDIOCHANMODE_MP3_STEREO ((__u32) 0x00000002) #define SND_AUDIOCHANMODE_MP3_JOINTSTEREO ((__u32) 0x00000004) #define SND_AUDIOCHANMODE_MP3_DUAL ((__u32) 0x00000008) #define SND_AUDIOPROFILE_AMR ((__u32) 0x00000001) / AMR modes are only useful for encoders / #define SND_AUDIOMODE_AMR_DTX_OFF ((__u32) 0x00000001) #define SND_AUDIOMODE_AMR_VAD1 ((__u32) 0x00000002) #define SND_AUDIOMODE_AMR_VAD2 ((__u32) 0x00000004) #define SND_AUDIOSTREAMFORMAT_UNDEFINED ((__u32) 0x00000000) #define SND_AUDIOSTREAMFORMAT_CONFORMANCE ((__u32) 0x00000001) #define SND_AUDIOSTREAMFORMAT_IF1 ((__u32) 0x00000002) #define SND_AUDIOSTREAMFORMAT_IF2 ((__u32) 0x00000004) #define SND_AUDIOSTREAMFORMAT_FSF ((__u32) 0x00000008) #define SND_AUDIOSTREAMFORMAT_RTPPAYLOAD ((__u32) 0x00000010) #define SND_AUDIOSTREAMFORMAT_ITU ((__u32) 0x00000020) #define SND_AUDIOPROFILE_AMRWB ((__u32) 0x00000001) / AMRWB modes are only useful for encoders / #define SND_AUDIOMODE_AMRWB_DTX_OFF ((__u32) 0x00000001) #define SND_AUDIOMODE_AMRWB_VAD1 ((__u32) 0x00000002) #define SND_AUDIOMODE_AMRWB_VAD2 ((__u32) 0x00000004) #define SND_AUDIOPROFILE_AMRWBPLUS ((__u32) 0x00000001) #define SND_AUDIOPROFILE_AAC ((__u32) 0x00000001) / AAC modes are required for encoders and decoders / #define SND_AUDIOMODE_AAC_MAIN ((__u32) 0x00000001) #define SND_AUDIOMODE_AAC_LC ((__u32) 0x00000002) #define SND_AUDIOMODE_AAC_SSR ((__u32) 0x00000004) #define SND_AUDIOMODE_AAC_LTP ((__u32) 0x00000008) #define SND_AUDIOMODE_AAC_HE ((__u32) 0x00000010) #define SND_AUDIOMODE_AAC_SCALABLE ((__u32) 0x00000020) #define SND_AUDIOMODE_AAC_ERLC ((__u32) 0x00000040) #define SND_AUDIOMODE_AAC_LD ((__u32) 0x00000080) #define SND_AUDIOMODE_AAC_HE_PS ((__u32) 0x00000100) #define SND_AUDIOMODE_AAC_HE_MPS ((__u32) 0x00000200) / AAC formats are required for encoders and decoders / #define SND_AUDIOSTREAMFORMAT_MP2ADTS ((__u32) 0x00000001) #define SND_AUDIOSTREAMFORMAT_MP4ADTS ((__u32) 0x00000002) #define SND_AUDIOSTREAMFORMAT_MP4LOAS ((__u32) 0x00000004) #define SND_AUDIOSTREAMFORMAT_MP4LATM ((__u32) 0x00000008) #define SND_AUDIOSTREAMFORMAT_ADIF ((__u32) 0x00000010) #define SND_AUDIOSTREAMFORMAT_MP4FF ((__u32) 0x00000020) #define SND_AUDIOSTREAMFORMAT_RAW ((__u32) 0x00000040) #define SND_AUDIOPROFILE_WMA7 ((__u32) 0x00000001) #define SND_AUDIOPROFILE_WMA8 ((__u32) 0x00000002) #define SND_AUDIOPROFILE_WMA9 ((__u32) 0x00000004) #define SND_AUDIOPROFILE_WMA10 ((__u32) 0x00000008) #define SND_AUDIOPROFILE_WMA9_PRO ((__u32) 0x00000010) #define SND_AUDIOPROFILE_WMA9_LOSSLESS ((__u32) 0x00000020) #define SND_AUDIOPROFILE_WMA10_LOSSLESS ((__u32) 0x00000040) #define SND_AUDIOMODE_WMA_LEVEL1 ((__u32) 0x00000001) #define SND_AUDIOMODE_WMA_LEVEL2 ((__u32) 0x00000002) #define SND_AUDIOMODE_WMA_LEVEL3 ((__u32) 0x00000004) #define SND_AUDIOMODE_WMA_LEVEL4 ((__u32) 0x00000008) #define SND_AUDIOMODE_WMAPRO_LEVELM0 ((__u32) 0x00000010) #define SND_AUDIOMODE_WMAPRO_LEVELM1 ((__u32) 0x00000020) #define SND_AUDIOMODE_WMAPRO_LEVELM2 ((__u32) 0x00000040) #define SND_AUDIOMODE_WMAPRO_LEVELM3 ((__u32) 0x00000080) #define SND_AUDIOSTREAMFORMAT_WMA_ASF ((__u32) 0x00000001) / * Some implementations strip the ASF header and only send ASF packets * to the DSP / #define SND_AUDIOSTREAMFORMAT_WMA_NOASF_HDR ((__u32) 0x00000002) #define SND_AUDIOPROFILE_REALAUDIO ((__u32) 0x00000001) #define SND_AUDIOMODE_REALAUDIO_G2 ((__u32) 0x00000001) #define SND_AUDIOMODE_REALAUDIO_8 ((__u32) 0x00000002) #define SND_AUDIOMODE_REALAUDIO_10 ((__u32) 0x00000004) #define SND_AUDIOMODE_REALAUDIO_SURROUND ((__u32) 0x00000008) #define SND_AUDIOPROFILE_VORBIS ((__u32) 0x00000001) #define SND_AUDIOMODE_VORBIS ((__u32) 0x00000001) #define SND_AUDIOPROFILE_FLAC ((__u32) 0x00000001) / * Define quality levels for FLAC encoders, from LEVEL0 (fast) * to LEVEL8 (best) / #define SND_AUDIOMODE_FLAC_LEVEL0 ((__u32) 0x00000001) #define SND_AUDIOMODE_FLAC_LEVEL1 ((__u32) 0x00000002) #define SND_AUDIOMODE_FLAC_LEVEL2 ((__u32) 0x00000004) #define SND_AUDIOMODE_FLAC_LEVEL3 ((__u32) 0x00000008) #define SND_AUDIOMODE_FLAC_LEVEL4 ((__u32) 0x00000010) #define SND_AUDIOMODE_FLAC_LEVEL5 ((__u32) 0x00000020) #define SND_AUDIOMODE_FLAC_LEVEL6 ((__u32) 0x00000040) #define SND_AUDIOMODE_FLAC_LEVEL7 ((__u32) 0x00000080) #define SND_AUDIOMODE_FLAC_LEVEL8 ((__u32) 0x00000100) #define SND_AUDIOSTREAMFORMAT_FLAC ((__u32) 0x00000001) #define SND_AUDIOSTREAMFORMAT_FLAC_OGG ((__u32) 0x00000002) / IEC61937 payloads without CUVP and preambles / #define SND_AUDIOPROFILE_IEC61937 ((__u32) 0x00000001) / IEC61937 with S/PDIF preambles+CUVP bits in 32-bit containers / #define SND_AUDIOPROFILE_IEC61937_SPDIF ((__u32) 0x00000002) / * IEC modes are mandatory for decoders. Format autodetection * will only happen on the DSP side with mode 0. The PCM mode should * not be used, the PCM codec should be used instead. / #define SND_AUDIOMODE_IEC_REF_STREAM_HEADER ((__u32) 0x00000000) #define SND_AUDIOMODE_IEC_LPCM ((__u32) 0x00000001) #define SND_AUDIOMODE_IEC_AC3 ((__u32) 0x00000002) #define SND_AUDIOMODE_IEC_MPEG1 ((__u32) 0x00000004) #define SND_AUDIOMODE_IEC_MP3 ((__u32) 0x00000008) #define SND_AUDIOMODE_IEC_MPEG2 ((__u32) 0x00000010) #define SND_AUDIOMODE_IEC_AACLC ((__u32) 0x00000020) #define SND_AUDIOMODE_IEC_DTS ((__u32) 0x00000040) #define SND_AUDIOMODE_IEC_ATRAC ((__u32) 0x00000080) #define SND_AUDIOMODE_IEC_SACD ((__u32) 0x00000100) #define SND_AUDIOMODE_IEC_EAC3 ((__u32) 0x00000200) #define SND_AUDIOMODE_IEC_DTS_HD ((__u32) 0x00000400) #define SND_AUDIOMODE_IEC_MLP ((__u32) 0x00000800) #define SND_AUDIOMODE_IEC_DST ((__u32) 0x00001000) #define SND_AUDIOMODE_IEC_WMAPRO ((__u32) 0x00002000) #define SND_AUDIOMODE_IEC_REF_CXT ((__u32) 0x00004000) #define SND_AUDIOMODE_IEC_HE_AAC ((__u32) 0x00008000) #define SND_AUDIOMODE_IEC_HE_AAC2 ((__u32) 0x00010000) #define SND_AUDIOMODE_IEC_MPEG_SURROUND ((__u32) 0x00020000) #define SND_AUDIOPROFILE_G723_1 ((__u32) 0x00000001) #define SND_AUDIOMODE_G723_1_ANNEX_A ((__u32) 0x00000001) #define SND_AUDIOMODE_G723_1_ANNEX_B ((__u32) 0x00000002) #define SND_AUDIOMODE_G723_1_ANNEX_C ((__u32) 0x00000004) #define SND_AUDIOPROFILE_G729 ((__u32) 0x00000001) #define SND_AUDIOMODE_G729_ANNEX_A ((__u32) 0x00000001) #define SND_AUDIOMODE_G729_ANNEX_B ((__u32) 0x00000002) / <FIXME: multichannel encoders aren't supported for now. Would need an additional definition of channel arrangement> / / VBR/CBR definitions / #define SND_RATECONTROLMODE_CONSTANTBITRATE ((__u32) 0x00000001) #define SND_RATECONTROLMODE_VARIABLEBITRATE ((__u32) 0x00000002) / Encoder options / struct snd_enc_wma { __u32 super_block_align; / WMA Type-specific data / }; /* * struct snd_enc_vorbis - Vorbis encoder parameters * @quality: Sets encoding quality to n, between -1 (low) and 10 (high). * In the default mode of operation, the quality level is 3. * Normal quality range is 0 - 10. * @managed: Boolean. Set bitrate management mode. This turns off the * normal VBR encoding, but allows hard or soft bitrate constraints to be * enforced by the encoder. This mode can be slower, and may also be * lower quality. It is primarily useful for streaming. * @max_bit_rate: Enabled only if managed is TRUE * @min_bit_rate: Enabled only if managed is TRUE * @downmix: Boolean. Downmix input from stereo to mono (has no effect on * non-stereo streams). Useful for lower-bitrate encoding. * * These options were extracted from the OpenMAX IL spec and Gstreamer vorbisenc * properties * * For best quality users should specify VBR mode and set quality levels. / struct snd_enc_vorbis { __s32 quality; __u32 managed; __u32 max_bit_rate; __u32 min_bit_rate; __u32 downmix; } __attribute__((packed, aligned(4))); /* * struct snd_enc_real - RealAudio encoder parameters * @quant_bits: number of coupling quantization bits in the stream * @start_region: coupling start region in the stream * @num_regions: number of regions value * * These options were extracted from the OpenMAX IL spec / struct snd_enc_real { __u32 quant_bits; __u32 start_region; __u32 num_regions; } __attribute__((packed, aligned(4))); /* * struct snd_enc_flac - FLAC encoder parameters * @num: serial number, valid only for OGG formats * needs to be set by application * @gain: Add replay gain tags * * These options were extracted from the FLAC online documentation * at http://flac.sourceforge.net/documentation_tools_flac.html * * To make the API simpler, it is assumed that the user will select quality * profiles. Additional options that affect encoding quality and speed can * be added at a later stage if needed. * * By default the Subset format is used by encoders. * * TAGS such as pictures, etc, cannot be handled by an offloaded encoder and are * not supported in this API. / struct snd_enc_flac { __u32 num; __u32 gain; } __attribute__((packed, aligned(4))); struct snd_enc_generic { __u32 bw; / encoder bandwidth / __s32 reserved[15]; / Can be used for SND_AUDIOCODEC_BESPOKE / } __attribute__((packed, aligned(4))); struct snd_dec_flac { __u16 sample_size; __u16 min_blk_size; __u16 max_blk_size; __u16 min_frame_size; __u16 max_frame_size; __u16 reserved; } __attribute__((packed, aligned(4))); struct snd_dec_wma { __u32 encoder_option; __u32 adv_encoder_option; __u32 adv_encoder_option2; __u32 reserved; } __attribute__((packed, aligned(4))); struct snd_dec_alac { __u32 frame_length; __u8 compatible_version; __u8 pb; __u8 mb; __u8 kb; __u32 max_run; __u32 max_frame_bytes; } __attribute__((packed, aligned(4))); struct snd_dec_ape { __u16 compatible_version; __u16 compression_level; __u32 format_flags; __u32 blocks_per_frame; __u32 final_frame_blocks; __u32 total_frames; __u32 seek_table_present; } __attribute__((packed, aligned(4))); union snd_codec_options { struct snd_enc_wma wma; struct snd_enc_vorbis vorbis; struct snd_enc_real real; struct snd_enc_flac flac; struct snd_enc_generic generic; struct snd_dec_flac flac_d; struct snd_dec_wma wma_d; struct snd_dec_alac alac_d; struct snd_dec_ape ape_d; struct { __u32 out_sample_rate; } src_d; } __attribute__((packed, aligned(4))); struct snd_codec_desc_src { __u32 out_sample_rate_min; __u32 out_sample_rate_max; } __attribute__((packed, aligned(4))); /* struct snd_codec_desc - description of codec capabilities * @max_ch: Maximum number of audio channels * @sample_rates: Sampling rates in Hz, use values like 48000 for this * @num_sample_rates: Number of valid values in sample_rates array * @bit_rate: Indexed array containing supported bit rates * @num_bitrates: Number of valid values in bit_rate array * @rate_control: value is specified by SND_RATECONTROLMODE defines. * @profiles: Supported profiles. See SND_AUDIOPROFILE defines. * @modes: Supported modes. See SND_AUDIOMODE defines * @formats: Supported formats. See SND_AUDIOSTREAMFORMAT defines * @min_buffer: Minimum buffer size handled by codec implementation * @pcm_formats: Output (for decoders) or input (for encoders) * PCM formats (required to accel mode, 0 for other modes) * @u_space: union space (for codec dependent data) * @reserved: reserved for future use * * This structure provides a scalar value for profiles, modes and stream * format fields. * If an implementation supports multiple combinations, they will be listed as * codecs with different descriptors, for example there would be 2 descriptors * for AAC-RAW and AAC-ADTS. * This entails some redundancy but makes it easier to avoid invalid * configurations. * / struct snd_codec_desc { __u32 max_ch; __u32 sample_rates[MAX_NUM_SAMPLE_RATES]; __u32 num_sample_rates; __u32 bit_rate[MAX_NUM_BITRATES]; __u32 num_bitrates; __u32 rate_control; __u32 profiles; __u32 modes; __u32 formats; __u32 min_buffer; __u32 pcm_formats; union { __u32 u_space[6]; struct snd_codec_desc_src src; } __attribute__((packed, aligned(4))); __u32 reserved[8]; } __attribute__((packed, aligned(4))); /* struct snd_codec * @id: Identifies the supported audio encoder/decoder. * See SND_AUDIOCODEC macros. * @ch_in: Number of input audio channels * @ch_out: Number of output channels. In case of contradiction between * this field and the channelMode field, the channelMode field * overrides. * @sample_rate: Audio sample rate of input data in Hz, use values like 48000 * for this. * @bit_rate: Bitrate of encoded data. May be ignored by decoders * @rate_control: Encoding rate control. See SND_RATECONTROLMODE defines. * Encoders may rely on profiles for quality levels. * May be ignored by decoders. * @profile: Mandatory for encoders, can be mandatory for specific * decoders as well. See SND_AUDIOPROFILE defines. * @level: Supported level (Only used by WMA at the moment) * @ch_mode: Channel mode for encoder. See SND_AUDIOCHANMODE defines * @format: Format of encoded bistream. Mandatory when defined. * See SND_AUDIOSTREAMFORMAT defines. * @align: Block alignment in bytes of an audio sample. * Only required for PCM or IEC formats. * @options: encoder-specific settings * @pcm_format: Output (for decoders) or input (for encoders) * PCM formats (required to accel mode, 0 for other modes) * @reserved: reserved for future use */ struct snd_codec { __u32 id; __u32 ch_in; __u32 ch_out; __u32 sample_rate; __u32 bit_rate; __u32 rate_control; __u32 profile; __u32 level; __u32 ch_mode; __u32 format; __u32 align; union snd_codec_options options; __u32 pcm_format; __u32 reserved[2]; } __attribute__((packed, aligned(4))); #endif	16.69 KB	2026-03-24 10:01
📄 emu10k1.h /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note / / * Copyright (c) by Jaroslav Kysela <perex@perex.cz>, * Creative Labs, Inc. * Definitions for EMU10K1 (SB Live!) chips / #ifndef __SOUND_EMU10K1_H #define __SOUND_EMU10K1_H #ifdef __linux__ #include <linux/types.h> #endif / * ---- FX8010 ---- / #define EMU10K1_FX8010_PCM_COUNT 8 / * Following definition is copied from linux/types.h to support compiling * this header file in userspace since they are not generally available for * uapi headers. / #define __EMU10K1_DECLARE_BITMAP(name,bits) \ unsigned long name[(bits) / (sizeof(unsigned long) 8)] /* instruction set / #define iMAC0 0x00 / R = A + (X * Y >> 31) ; saturation / #define iMAC1 0x01 / R = A + (-X * Y >> 31) ; saturation / #define iMAC2 0x02 / R = A + (X * Y >> 31) ; wraparound / #define iMAC3 0x03 / R = A + (-X * Y >> 31) ; wraparound / #define iMACINT0 0x04 / R = A + X * Y ; saturation / #define iMACINT1 0x05 / R = A + X * Y ; wraparound (31-bit) / #define iACC3 0x06 / R = A + X + Y ; saturation / #define iMACMV 0x07 / R = A, acc += X * Y >> 31 / #define iANDXOR 0x08 / R = (A & X) ^ Y / #define iTSTNEG 0x09 / R = (A >= Y) ? X : ~X / #define iLIMITGE 0x0a / R = (A >= Y) ? X : Y / #define iLIMITLT 0x0b / R = (A < Y) ? X : Y / #define iLOG 0x0c / R = linear_data, A (log_data), X (max_exp), Y (format_word) / #define iEXP 0x0d / R = log_data, A (linear_data), X (max_exp), Y (format_word) / #define iINTERP 0x0e / R = A + (X * (Y - A) >> 31) ; saturation / #define iSKIP 0x0f / R = A (cc_reg), X (count), Y (cc_test) / #define LOWORD_OPX_MASK 0x000ffc00 / Instruction operand X / #define LOWORD_OPY_MASK 0x000003ff / Instruction operand Y / #define HIWORD_OPCODE_MASK 0x00f00000 / Instruction opcode / #define HIWORD_RESULT_MASK 0x000ffc00 / Instruction result / #define HIWORD_OPA_MASK 0x000003ff / Instruction operand A / / Audigy Soundcards have a different instruction format / #define A_LOWORD_OPX_MASK 0x007ff000 #define A_LOWORD_OPY_MASK 0x000007ff #define A_HIWORD_OPCODE_MASK 0x0f000000 #define A_HIWORD_RESULT_MASK 0x007ff000 #define A_HIWORD_OPA_MASK 0x000007ff / GPRs / #define FXBUS(x) (0x00 + (x)) / x = 0x00 - 0x0f / #define EXTIN(x) (0x10 + (x)) / x = 0x00 - 0x0f / #define EXTOUT(x) (0x20 + (x)) / x = 0x00 - 0x0f physical outs -> FXWC low 16 bits / #define FXBUS2(x) (0x30 + (x)) / x = 0x00 - 0x0f copies of fx buses for capture -> FXWC high 16 bits / / NB: 0x31 and 0x32 are shared with Center/LFE on SB live 5.1 / #define A_FXBUS(x) (0x00 + (x)) / x = 0x00 - 0x3f FX buses / #define A_EXTIN(x) (0x40 + (x)) / x = 0x00 - 0x0f physical ins / #define A_P16VIN(x) (0x50 + (x)) / x = 0x00 - 0x0f p16v ins (A2 only) "EMU32 inputs" / #define A_EXTOUT(x) (0x60 + (x)) / x = 0x00 - 0x1f physical outs -> A_FXWC1 0x79-7f unknown / #define A_FXBUS2(x) (0x80 + (x)) / x = 0x00 - 0x1f extra outs used for EFX capture -> A_FXWC2 / #define A_EMU32OUTH(x) (0xa0 + (x)) / x = 0x00 - 0x0f "EMU32_OUT_10 - _1F" / #define A_EMU32OUTL(x) (0xb0 + (x)) / x = 0x00 - 0x0f "EMU32_OUT_01 - _0F" / #define A3_EMU32IN(x) (0x160 + (x)) / x = 0x00 - 0x1f "EMU32_IN_00 - _1F" - Only when .device = 0x0008 / #define A3_EMU32OUT(x) (0x1E0 + (x)) / x = 0x00 - 0x1f "EMU32_OUT_00 - _1F" - Only when .device = 0x0008 / #define C_00000000 0x40 #define C_00000001 0x41 #define C_00000002 0x42 #define C_00000003 0x43 #define C_00000004 0x44 #define C_00000008 0x45 #define C_00000010 0x46 #define C_00000020 0x47 #define C_00000100 0x48 #define C_00010000 0x49 #define C_00080000 0x4a #define C_10000000 0x4b #define C_20000000 0x4c #define C_40000000 0x4d #define C_80000000 0x4e #define C_7fffffff 0x4f #define C_ffffffff 0x50 #define C_fffffffe 0x51 #define C_c0000000 0x52 #define C_4f1bbcdc 0x53 #define C_5a7ef9db 0x54 #define C_00100000 0x55 / ?? / #define GPR_ACCU 0x56 / ACCUM, accumulator / #define GPR_COND 0x57 / CCR, condition register / #define GPR_NOISE0 0x58 / noise source / #define GPR_NOISE1 0x59 / noise source / #define GPR_IRQ 0x5a / IRQ register / #define GPR_DBAC 0x5b / TRAM Delay Base Address Counter / / Audigy constants / #define A_C_00000000 0xc0 #define A_C_00000001 0xc1 #define A_C_00000002 0xc2 #define A_C_00000003 0xc3 #define A_C_00000004 0xc4 #define A_C_00000008 0xc5 #define A_C_00000010 0xc6 #define A_C_00000020 0xc7 #define A_C_00000100 0xc8 #define A_C_00010000 0xc9 #define A_C_00000800 0xca #define A_C_10000000 0xcb #define A_C_20000000 0xcc #define A_C_40000000 0xcd #define A_C_80000000 0xce #define A_C_7fffffff 0xcf #define A_C_ffffffff 0xd0 #define A_C_fffffffe 0xd1 #define A_C_c0000000 0xd2 #define A_C_4f1bbcdc 0xd3 #define A_C_5a7ef9db 0xd4 #define A_C_00100000 0xd5 #define A_GPR_ACCU 0xd6 / ACCUM, accumulator / #define A_GPR_COND 0xd7 / CCR, condition register / #define A_GPR_NOISE0 0xd8 / noise source / #define A_GPR_NOISE1 0xd9 / noise source / #define A_GPR_IRQ 0xda / IRQ register / #define A_GPR_DBAC 0xdb / TRAM Delay Base Address Counter - internal / #define A_GPR_DBACE 0xde / TRAM Delay Base Address Counter - external / / Each FX general purpose register is 32 bits in length, all bits are used / #define FXGPREGBASE 0x100 / FX general purpose registers base / #define A_FXGPREGBASE 0x400 / Audigy GPRs, 0x400 to 0x5ff / #define A_TANKMEMCTLREGBASE 0x100 / Tank memory control registers base - only for Audigy / #define A_TANKMEMCTLREG_MASK 0x1f / only 5 bits used - only for Audigy / / Tank audio data is logarithmically compressed down to 16 bits before writing to TRAM and is / / decompressed back to 20 bits on a read. There are a total of 160 locations, the last 32 / / locations are for external TRAM. / #define TANKMEMDATAREGBASE 0x200 / Tank memory data registers base / #define TANKMEMDATAREG_MASK 0x000fffff / 20 bit tank audio data field / / Combined address field and memory opcode or flag field. 160 locations, last 32 are external / #define TANKMEMADDRREGBASE 0x300 / Tank memory address registers base / #define TANKMEMADDRREG_ADDR_MASK 0x000fffff / 20 bit tank address field / #define TANKMEMADDRREG_CLEAR 0x00800000 / Clear tank memory / #define TANKMEMADDRREG_ALIGN 0x00400000 / Align read or write relative to tank access / #define TANKMEMADDRREG_WRITE 0x00200000 / Write to tank memory / #define TANKMEMADDRREG_READ 0x00100000 / Read from tank memory / #define GPR(x) (FXGPREGBASE + (x)) / free GPRs: x = 0x00 - 0xff / #define ITRAM_DATA(x) (TANKMEMDATAREGBASE + 0x00 + (x)) / x = 0x00 - 0x7f / #define ETRAM_DATA(x) (TANKMEMDATAREGBASE + 0x80 + (x)) / x = 0x00 - 0x1f / #define ITRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x00 + (x)) / x = 0x00 - 0x7f / #define ETRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x80 + (x)) / x = 0x00 - 0x1f / #define A_GPR(x) (A_FXGPREGBASE + (x)) #define A_ITRAM_DATA(x) (TANKMEMDATAREGBASE + 0x00 + (x)) / x = 0x00 - 0xbf / #define A_ETRAM_DATA(x) (TANKMEMDATAREGBASE + 0xc0 + (x)) / x = 0x00 - 0x3f / #define A_ITRAM_ADDR(x) (TANKMEMADDRREGBASE + 0x00 + (x)) / x = 0x00 - 0xbf / #define A_ETRAM_ADDR(x) (TANKMEMADDRREGBASE + 0xc0 + (x)) / x = 0x00 - 0x3f / #define A_ITRAM_CTL(x) (A_TANKMEMCTLREGBASE + 0x00 + (x)) / x = 0x00 - 0xbf / #define A_ETRAM_CTL(x) (A_TANKMEMCTLREGBASE + 0xc0 + (x)) / x = 0x00 - 0x3f / / cc_reg constants / #define CC_REG_NORMALIZED C_00000001 #define CC_REG_BORROW C_00000002 #define CC_REG_MINUS C_00000004 #define CC_REG_ZERO C_00000008 #define CC_REG_SATURATE C_00000010 #define CC_REG_NONZERO C_00000100 #define A_CC_REG_NORMALIZED A_C_00000001 #define A_CC_REG_BORROW A_C_00000002 #define A_CC_REG_MINUS A_C_00000004 #define A_CC_REG_ZERO A_C_00000008 #define A_CC_REG_SATURATE A_C_00000010 #define A_CC_REG_NONZERO A_C_00000100 / FX buses / // These are arbitrary mappings; our DSP code simply expects // the config files to route the channels this way. // The numbers are documented in {audigy,sb-live}-mixer.rst. #define FXBUS_PCM_LEFT 0x00 #define FXBUS_PCM_RIGHT 0x01 #define FXBUS_PCM_LEFT_REAR 0x02 #define FXBUS_PCM_RIGHT_REAR 0x03 #define FXBUS_MIDI_LEFT 0x04 #define FXBUS_MIDI_RIGHT 0x05 #define FXBUS_PCM_CENTER 0x06 #define FXBUS_PCM_LFE 0x07 #define FXBUS_PCM_LEFT_FRONT 0x08 #define FXBUS_PCM_RIGHT_FRONT 0x09 #define FXBUS_MIDI_REVERB 0x0c #define FXBUS_MIDI_CHORUS 0x0d #define FXBUS_PCM_LEFT_SIDE 0x0e #define FXBUS_PCM_RIGHT_SIDE 0x0f #define FXBUS_PT_LEFT 0x14 #define FXBUS_PT_RIGHT 0x15 / Inputs / #define EXTIN_AC97_L 0x00 / AC'97 capture channel - left / #define EXTIN_AC97_R 0x01 / AC'97 capture channel - right / #define EXTIN_SPDIF_CD_L 0x02 / internal S/PDIF CD - onboard - left / #define EXTIN_SPDIF_CD_R 0x03 / internal S/PDIF CD - onboard - right / #define EXTIN_ZOOM_L 0x04 / Zoom Video I2S - left / #define EXTIN_ZOOM_R 0x05 / Zoom Video I2S - right / #define EXTIN_TOSLINK_L 0x06 / LiveDrive - TOSLink Optical - left / #define EXTIN_TOSLINK_R 0x07 / LiveDrive - TOSLink Optical - right / #define EXTIN_LINE1_L 0x08 / LiveDrive - Line/Mic 1 - left / #define EXTIN_LINE1_R 0x09 / LiveDrive - Line/Mic 1 - right / #define EXTIN_COAX_SPDIF_L 0x0a / LiveDrive - Coaxial S/PDIF - left / #define EXTIN_COAX_SPDIF_R 0x0b / LiveDrive - Coaxial S/PDIF - right / #define EXTIN_LINE2_L 0x0c / LiveDrive - Line/Mic 2 - left / #define EXTIN_LINE2_R 0x0d / LiveDrive - Line/Mic 2 - right / / Outputs / #define EXTOUT_AC97_L 0x00 / AC'97 playback channel - left / #define EXTOUT_AC97_R 0x01 / AC'97 playback channel - right / #define EXTOUT_TOSLINK_L 0x02 / LiveDrive - TOSLink Optical - left / #define EXTOUT_TOSLINK_R 0x03 / LiveDrive - TOSLink Optical - right / #define EXTOUT_AC97_CENTER 0x04 / SB Live 5.1 - center / #define EXTOUT_AC97_LFE 0x05 / SB Live 5.1 - LFE / #define EXTOUT_HEADPHONE_L 0x06 / LiveDrive - Headphone - left / #define EXTOUT_HEADPHONE_R 0x07 / LiveDrive - Headphone - right / #define EXTOUT_REAR_L 0x08 / Rear channel - left / #define EXTOUT_REAR_R 0x09 / Rear channel - right / #define EXTOUT_ADC_CAP_L 0x0a / ADC Capture buffer - left / #define EXTOUT_ADC_CAP_R 0x0b / ADC Capture buffer - right / #define EXTOUT_MIC_CAP 0x0c / MIC Capture buffer / #define EXTOUT_AC97_REAR_L 0x0d / SB Live 5.1 (c) 2003 - Rear Left / #define EXTOUT_AC97_REAR_R 0x0e / SB Live 5.1 (c) 2003 - Rear Right / #define EXTOUT_ACENTER 0x11 / Analog Center / #define EXTOUT_ALFE 0x12 / Analog LFE / / Audigy Inputs / #define A_EXTIN_AC97_L 0x00 / AC'97 capture channel - left / #define A_EXTIN_AC97_R 0x01 / AC'97 capture channel - right / #define A_EXTIN_SPDIF_CD_L 0x02 / digital CD left / #define A_EXTIN_SPDIF_CD_R 0x03 / digital CD left / #define A_EXTIN_OPT_SPDIF_L 0x04 / audigy drive Optical SPDIF - left / #define A_EXTIN_OPT_SPDIF_R 0x05 / right / #define A_EXTIN_LINE2_L 0x08 / audigy drive line2/mic2 - left / #define A_EXTIN_LINE2_R 0x09 / right / #define A_EXTIN_ADC_L 0x0a / Philips ADC - left / #define A_EXTIN_ADC_R 0x0b / right / #define A_EXTIN_AUX2_L 0x0c / audigy drive aux2 - left / #define A_EXTIN_AUX2_R 0x0d / - right / / Audigiy Outputs / #define A_EXTOUT_FRONT_L 0x00 / digital front left / #define A_EXTOUT_FRONT_R 0x01 / right / #define A_EXTOUT_CENTER 0x02 / digital front center / #define A_EXTOUT_LFE 0x03 / digital front lfe / #define A_EXTOUT_HEADPHONE_L 0x04 / headphone audigy drive left / #define A_EXTOUT_HEADPHONE_R 0x05 / right / #define A_EXTOUT_REAR_L 0x06 / digital rear left / #define A_EXTOUT_REAR_R 0x07 / right / #define A_EXTOUT_AFRONT_L 0x08 / analog front left / #define A_EXTOUT_AFRONT_R 0x09 / right / #define A_EXTOUT_ACENTER 0x0a / analog center / #define A_EXTOUT_ALFE 0x0b / analog LFE / #define A_EXTOUT_ASIDE_L 0x0c / analog side left - Audigy 2 ZS / #define A_EXTOUT_ASIDE_R 0x0d / right - Audigy 2 ZS / #define A_EXTOUT_AREAR_L 0x0e / analog rear left / #define A_EXTOUT_AREAR_R 0x0f / right / #define A_EXTOUT_AC97_L 0x10 / AC97 left (front) / #define A_EXTOUT_AC97_R 0x11 / right / #define A_EXTOUT_ADC_CAP_L 0x16 / ADC capture buffer left / #define A_EXTOUT_ADC_CAP_R 0x17 / right / #define A_EXTOUT_MIC_CAP 0x18 / Mic capture buffer / / Definitions for debug register. Note that these are for emu10k1 ONLY. / #define EMU10K1_DBG_ZC 0x80000000 / zero tram counter / #define EMU10K1_DBG_SATURATION_OCCURED 0x02000000 / saturation control / #define EMU10K1_DBG_SATURATION_ADDR 0x01ff0000 / saturation address / #define EMU10K1_DBG_SINGLE_STEP 0x00008000 / single step mode / #define EMU10K1_DBG_STEP 0x00004000 / start single step / #define EMU10K1_DBG_CONDITION_CODE 0x00003e00 / condition code / #define EMU10K1_DBG_SINGLE_STEP_ADDR 0x000001ff / single step address / / Definitions for emu10k2 debug register. / #define A_DBG_ZC 0x40000000 / zero tram counter / #define A_DBG_SATURATION_OCCURED 0x20000000 #define A_DBG_SATURATION_ADDR 0x0ffc0000 #define A_DBG_SINGLE_STEP 0x00020000 / Set to zero to start dsp / #define A_DBG_STEP 0x00010000 #define A_DBG_CONDITION_CODE 0x0000f800 #define A_DBG_STEP_ADDR 0x000003ff struct snd_emu10k1_fx8010_info { unsigned int internal_tram_size; / in samples / unsigned int external_tram_size; / in samples / char fxbus_names[16][32]; / names of FXBUSes / char extin_names[16][32]; / names of external inputs / char extout_names[32][32]; / names of external outputs / unsigned int gpr_controls; / count of GPR controls / }; #define EMU10K1_GPR_TRANSLATION_NONE 0 #define EMU10K1_GPR_TRANSLATION_TABLE100 1 #define EMU10K1_GPR_TRANSLATION_BASS 2 #define EMU10K1_GPR_TRANSLATION_TREBLE 3 #define EMU10K1_GPR_TRANSLATION_ONOFF 4 #define EMU10K1_GPR_TRANSLATION_NEGATE 5 #define EMU10K1_GPR_TRANSLATION_NEG_TABLE100 6 enum emu10k1_ctl_elem_iface { EMU10K1_CTL_ELEM_IFACE_MIXER = 2, / virtual mixer device / EMU10K1_CTL_ELEM_IFACE_PCM = 3, / PCM device / }; struct emu10k1_ctl_elem_id { unsigned int pad; / don't use / int iface; / interface identifier / unsigned int device; / device/client number / unsigned int subdevice; / subdevice (substream) number / unsigned char name[44]; / ASCII name of item / unsigned int index; / index of item / }; struct snd_emu10k1_fx8010_control_gpr { struct emu10k1_ctl_elem_id id; / full control ID definition / unsigned int vcount; / visible count / unsigned int count; / count of GPR (1..16) / unsigned short gpr[32]; / GPR number(s) / int value[32]; / initial values / int min; / minimum range / int max; / maximum range / unsigned int translation; / translation type (EMU10K1_GPR_TRANSLATION) / const unsigned int tlv; }; / old ABI without TLV support / struct snd_emu10k1_fx8010_control_old_gpr { struct emu10k1_ctl_elem_id id; unsigned int vcount; unsigned int count; unsigned short gpr[32]; unsigned int value[32]; unsigned int min; unsigned int max; unsigned int translation; }; struct snd_emu10k1_fx8010_code { char name[128]; __EMU10K1_DECLARE_BITMAP(gpr_valid, 0x200); / bitmask of valid initializers / __u32 gpr_map; /* initializers / unsigned int gpr_add_control_count; / count of GPR controls to add/replace / struct snd_emu10k1_fx8010_control_gpr gpr_add_controls; /* GPR controls to add/replace / unsigned int gpr_del_control_count; / count of GPR controls to remove / struct emu10k1_ctl_elem_id gpr_del_controls; /* IDs of GPR controls to remove / unsigned int gpr_list_control_count; / count of GPR controls to list / unsigned int gpr_list_control_total; / total count of GPR controls / struct snd_emu10k1_fx8010_control_gpr gpr_list_controls; /* listed GPR controls / __EMU10K1_DECLARE_BITMAP(tram_valid, 0x100); / bitmask of valid initializers / __u32 tram_data_map; /* data initializers / __u32 tram_addr_map; /* map initializers / __EMU10K1_DECLARE_BITMAP(code_valid, 1024); / bitmask of valid instructions / __u32 code; /* one instruction - 64 bits / }; struct snd_emu10k1_fx8010_tram { unsigned int address; / 31.bit == 1 -> external TRAM / unsigned int size; / size in samples (4 bytes) / unsigned int samples; /* pointer to samples (20-bit) / / NULL->clear memory / }; struct snd_emu10k1_fx8010_pcm_rec { unsigned int substream; / substream number / unsigned int res1; / reserved / unsigned int channels; / 16-bit channels count, zero = remove this substream / unsigned int tram_start; / ring buffer position in TRAM (in samples) / unsigned int buffer_size; / count of buffered samples / unsigned short gpr_size; / GPR containing size of ringbuffer in samples (host) / unsigned short gpr_ptr; / GPR containing current pointer in the ring buffer (host = reset, FX8010) / unsigned short gpr_count; / GPR containing count of samples between two interrupts (host) / unsigned short gpr_tmpcount; / GPR containing current count of samples to interrupt (host = set, FX8010) / unsigned short gpr_trigger; / GPR containing trigger (activate) information (host) / unsigned short gpr_running; / GPR containing info if PCM is running (FX8010) / unsigned char pad; / reserved / unsigned char etram[32]; / external TRAM address & data (one per channel) / unsigned int res2; / reserved / }; #define SNDRV_EMU10K1_VERSION SNDRV_PROTOCOL_VERSION(1, 0, 1) #define SNDRV_EMU10K1_IOCTL_INFO _IOR ('H', 0x10, struct snd_emu10k1_fx8010_info) #define SNDRV_EMU10K1_IOCTL_CODE_POKE _IOW ('H', 0x11, struct snd_emu10k1_fx8010_code) #define SNDRV_EMU10K1_IOCTL_CODE_PEEK _IOWR('H', 0x12, struct snd_emu10k1_fx8010_code) #define SNDRV_EMU10K1_IOCTL_TRAM_SETUP _IOW ('H', 0x20, int) #define SNDRV_EMU10K1_IOCTL_TRAM_POKE _IOW ('H', 0x21, struct snd_emu10k1_fx8010_tram) #define SNDRV_EMU10K1_IOCTL_TRAM_PEEK _IOWR('H', 0x22, struct snd_emu10k1_fx8010_tram) #define SNDRV_EMU10K1_IOCTL_PCM_POKE _IOW ('H', 0x30, struct snd_emu10k1_fx8010_pcm_rec) #define SNDRV_EMU10K1_IOCTL_PCM_PEEK _IOWR('H', 0x31, struct snd_emu10k1_fx8010_pcm_rec) #define SNDRV_EMU10K1_IOCTL_PVERSION _IOR ('H', 0x40, int) #define SNDRV_EMU10K1_IOCTL_STOP _IO ('H', 0x80) #define SNDRV_EMU10K1_IOCTL_CONTINUE _IO ('H', 0x81) #define SNDRV_EMU10K1_IOCTL_ZERO_TRAM_COUNTER _IO ('H', 0x82) #define SNDRV_EMU10K1_IOCTL_SINGLE_STEP _IOW ('H', 0x83, int) #define SNDRV_EMU10K1_IOCTL_DBG_READ _IOR ('H', 0x84, int) #endif / __SOUND_EMU10K1_H */	18.45 KB	2026-03-24 10:01
📄 fcp.h /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note / / * Focusrite Control Protocol Driver for ALSA * * Copyright (c) 2024-2025 by Geoffrey D. Bennett <g at b4.vu> / / * DOC: FCP (Focusrite Control Protocol) User-Space API * * This header defines the interface between the FCP kernel driver and * user-space programs to enable the use of the proprietary features * available in Focusrite USB audio interfaces. This includes Scarlett * 2nd Gen, 3rd Gen, 4th Gen, Clarett USB, Clarett+, and Vocaster * series devices. * * The interface is provided via ALSA's hwdep interface. Opening the * hwdep device requires CAP_SYS_RAWIO privileges as this interface * provides near-direct access. * * For details on the FCP protocol, refer to the kernel scarlett2 * driver in sound/usb/mixer_scarlett2.c and the fcp-support project * at https://github.com/geoffreybennett/fcp-support * * For examples of using these IOCTLs, see the fcp-server source in * the fcp-support project. * * IOCTL Interface * -------------- * FCP_IOCTL_PVERSION: * Returns the protocol version supported by the driver. * * FCP_IOCTL_INIT: * Initialises the protocol and synchronises sequence numbers * between the driver and device. Must be called at least once * before sending commands. Can be safely called again at any time. * * FCP_IOCTL_CMD: * Sends an FCP command to the device and returns the response. * Requires prior initialisation via FCP_IOCTL_INIT. * * FCP_IOCTL_SET_METER_MAP: * Configures the Level Meter control's mapping between device * meters and control channels. Requires FCP_IOCTL_INIT to have been * called first. The map size and number of slots cannot be changed * after initial configuration, although the map itself can be * updated. Once configured, the Level Meter remains functional even * after the hwdep device is closed. * * FCP_IOCTL_SET_METER_LABELS: * Set the labels for the Level Meter control. Requires * FCP_IOCTL_SET_METER_MAP to have been called first. labels[] * should contain a sequence of null-terminated labels corresponding * to the control's channels. / #ifndef __UAPI_SOUND_FCP_H #define __UAPI_SOUND_FCP_H #include <linux/types.h> #include <linux/ioctl.h> #define FCP_HWDEP_MAJOR 2 #define FCP_HWDEP_MINOR 0 #define FCP_HWDEP_SUBMINOR 0 #define FCP_HWDEP_VERSION \ ((FCP_HWDEP_MAJOR << 16) \| \ (FCP_HWDEP_MINOR << 8) \| \ FCP_HWDEP_SUBMINOR) #define FCP_HWDEP_VERSION_MAJOR(v) (((v) >> 16) & 0xFF) #define FCP_HWDEP_VERSION_MINOR(v) (((v) >> 8) & 0xFF) #define FCP_HWDEP_VERSION_SUBMINOR(v) ((v) & 0xFF) / Get protocol version / #define FCP_IOCTL_PVERSION _IOR('S', 0x60, int) / Start the protocol / / Step 0 and step 2 responses are variable length and placed in * resp[] one after the other. / struct fcp_init { __u16 step0_resp_size; __u16 step2_resp_size; __u32 init1_opcode; __u32 init2_opcode; __u8 resp[]; } __attribute__((packed)); #define FCP_IOCTL_INIT _IOWR('S', 0x64, struct fcp_init) / Perform a command / / The request data is placed in data[] and the response data will * overwrite it. / struct fcp_cmd { __u32 opcode; __u16 req_size; __u16 resp_size; __u8 data[]; } __attribute__((packed)); #define FCP_IOCTL_CMD _IOWR('S', 0x65, struct fcp_cmd) / Set the meter map / struct fcp_meter_map { __u16 map_size; __u16 meter_slots; __s16 map[]; } __attribute__((packed)); #define FCP_IOCTL_SET_METER_MAP _IOW('S', 0x66, struct fcp_meter_map) / Set the meter labels / struct fcp_meter_labels { __u16 labels_size; char labels[]; } __attribute__((packed)); #define FCP_IOCTL_SET_METER_LABELS _IOW('S', 0x67, struct fcp_meter_labels) #endif / __UAPI_SOUND_FCP_H */	3.65 KB	2026-03-24 10:01
📄 firewire.h /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note / #ifndef _SOUND_FIREWIRE_H_INCLUDED #define _SOUND_FIREWIRE_H_INCLUDED #include <linux/ioctl.h> #include <linux/types.h> / events can be read() from the hwdep device / #define SNDRV_FIREWIRE_EVENT_LOCK_STATUS 0x000010cc #define SNDRV_FIREWIRE_EVENT_DICE_NOTIFICATION 0xd1ce004e #define SNDRV_FIREWIRE_EVENT_EFW_RESPONSE 0x4e617475 #define SNDRV_FIREWIRE_EVENT_DIGI00X_MESSAGE 0x746e736c #define SNDRV_FIREWIRE_EVENT_MOTU_NOTIFICATION 0x64776479 #define SNDRV_FIREWIRE_EVENT_TASCAM_CONTROL 0x7473636d #define SNDRV_FIREWIRE_EVENT_MOTU_REGISTER_DSP_CHANGE 0x4d545244 #define SNDRV_FIREWIRE_EVENT_FF400_MESSAGE 0x4f6c6761 struct snd_firewire_event_common { unsigned int type; / SNDRV_FIREWIRE_EVENT_xxx / }; struct snd_firewire_event_lock_status { unsigned int type; unsigned int status; / 0/1 = unlocked/locked / }; struct snd_firewire_event_dice_notification { unsigned int type; unsigned int notification; / DICE-specific bits / }; #define SND_EFW_TRANSACTION_USER_SEQNUM_MAX ((__u32)((__u16)~0) - 1) / each field should be in big endian / struct snd_efw_transaction { __be32 length; __be32 version; __be32 seqnum; __be32 category; __be32 command; __be32 status; __be32 params[]; }; struct snd_firewire_event_efw_response { unsigned int type; __be32 response[]; / some responses / }; struct snd_firewire_event_digi00x_message { unsigned int type; __u32 message; / Digi00x-specific message / }; struct snd_firewire_event_motu_notification { unsigned int type; __u32 message; / MOTU-specific bits. / }; struct snd_firewire_tascam_change { unsigned int index; __be32 before; __be32 after; }; struct snd_firewire_event_tascam_control { unsigned int type; struct snd_firewire_tascam_change changes[]; }; struct snd_firewire_event_motu_register_dsp_change { unsigned int type; __u32 count; / The number of changes. / __u32 changes[]; / Encoded event for change of register DSP. / }; /* * struct snd_firewire_event_ff400_message - the container for message from Fireface 400 when * operating hardware knob. * * @type: Fixed to SNDRV_FIREWIRE_EVENT_FF400_MESSAGE. * @message_count: The number of messages. * @messages.message: The messages expressing hardware knob operation. * @messages.tstamp: The isochronous cycle at which the request subaction of asynchronous * transaction was sent to deliver the message. It has 16 bit unsigned integer * value. The higher 3 bits of value expresses the lower three bits of second * field in the format of CYCLE_TIME, up to 7. The rest 13 bits expresses cycle * field up to 7999. * * The structure expresses message transmitted by Fireface 400 when operating hardware knob. / struct snd_firewire_event_ff400_message { unsigned int type; unsigned int message_count; struct { __u32 message; __u32 tstamp; } messages[]; }; union snd_firewire_event { struct snd_firewire_event_common common; struct snd_firewire_event_lock_status lock_status; struct snd_firewire_event_dice_notification dice_notification; struct snd_firewire_event_efw_response efw_response; struct snd_firewire_event_digi00x_message digi00x_message; struct snd_firewire_event_tascam_control tascam_control; struct snd_firewire_event_motu_notification motu_notification; struct snd_firewire_event_motu_register_dsp_change motu_register_dsp_change; struct snd_firewire_event_ff400_message ff400_message; }; #define SNDRV_FIREWIRE_IOCTL_GET_INFO _IOR('H', 0xf8, struct snd_firewire_get_info) #define SNDRV_FIREWIRE_IOCTL_LOCK _IO('H', 0xf9) #define SNDRV_FIREWIRE_IOCTL_UNLOCK _IO('H', 0xfa) #define SNDRV_FIREWIRE_IOCTL_TASCAM_STATE _IOR('H', 0xfb, struct snd_firewire_tascam_state) #define SNDRV_FIREWIRE_IOCTL_MOTU_REGISTER_DSP_METER _IOR('H', 0xfc, struct snd_firewire_motu_register_dsp_meter) #define SNDRV_FIREWIRE_IOCTL_MOTU_COMMAND_DSP_METER _IOR('H', 0xfd, struct snd_firewire_motu_command_dsp_meter) #define SNDRV_FIREWIRE_IOCTL_MOTU_REGISTER_DSP_PARAMETER _IOR('H', 0xfe, struct snd_firewire_motu_register_dsp_parameter) #define SNDRV_FIREWIRE_TYPE_DICE 1 #define SNDRV_FIREWIRE_TYPE_FIREWORKS 2 #define SNDRV_FIREWIRE_TYPE_BEBOB 3 #define SNDRV_FIREWIRE_TYPE_OXFW 4 #define SNDRV_FIREWIRE_TYPE_DIGI00X 5 #define SNDRV_FIREWIRE_TYPE_TASCAM 6 #define SNDRV_FIREWIRE_TYPE_MOTU 7 #define SNDRV_FIREWIRE_TYPE_FIREFACE 8 struct snd_firewire_get_info { unsigned int type; / SNDRV_FIREWIRE_TYPE_xxx / unsigned int card; / same as fw_cdev_get_info.card / unsigned char guid[8]; char device_name[16]; / device node in /dev / }; / * SNDRV_FIREWIRE_IOCTL_LOCK prevents the driver from streaming. * Returns -EBUSY if the driver is already streaming. / #define SNDRV_FIREWIRE_TASCAM_STATE_COUNT 64 struct snd_firewire_tascam_state { __be32 data[SNDRV_FIREWIRE_TASCAM_STATE_COUNT]; }; / * In below MOTU models, software is allowed to control their DSP by accessing to registers. * - 828mk2 * - 896hd * - Traveler * - 8 pre * - Ultralite * - 4 pre * - Audio Express * * On the other hand, the status of DSP is split into specific messages included in the sequence of * isochronous packet. ALSA firewire-motu driver gathers the messages and allow userspace applications * to read it via ioctl. In 828mk2, 896hd, and Traveler, hardware meter for all of physical inputs * are put into the message, while one pair of physical outputs is selected. The selection is done by * LSB one byte in asynchronous write quadlet transaction to 0x'ffff'f000'0b2c. * * I note that V3HD/V4HD uses asynchronous transaction for the purpose. The destination address is * registered to 0x'ffff'f000'0b38 and '0b3c by asynchronous write quadlet request. The size of * message differs between 23 and 51 quadlets. For the case, the number of mixer bus can be extended * up to 12. / #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_INPUT_COUNT 24 #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_OUTPUT_COUNT 24 #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_COUNT \ (SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_INPUT_COUNT + SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_OUTPUT_COUNT) /* * struct snd_firewire_motu_register_dsp_meter - the container for meter information in DSP * controlled by register access * @data: Signal level meters. The mapping between position and input/output channel is * model-dependent. * * The structure expresses the part of DSP status for hardware meter. The u8 storage includes linear * value for audio signal level between 0x00 and 0x7f. / struct snd_firewire_motu_register_dsp_meter { __u8 data[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_COUNT]; }; #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT 4 #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT 20 #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_INPUT_COUNT 10 #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_ALIGNED_INPUT_COUNT (SNDRV_FIREWIRE_MOTU_REGISTER_DSP_INPUT_COUNT + 2) /* * snd_firewire_motu_register_dsp_parameter - the container for parameters of DSP controlled * by register access. * @mixer.source.gain: The gain of source to mixer. * @mixer.source.pan: The L/R balance of source to mixer. * @mixer.source.flag: The flag of source to mixer, including mute, solo. * @mixer.source.paired_balance: The L/R balance of paired source to mixer, only for 4 pre and * Audio Express. * @mixer.source.paired_width: The width of paired source to mixer, only for 4 pre and * Audio Express. * @mixer.output.paired_volume: The volume of paired output from mixer. * @mixer.output.paired_flag: The flag of paired output from mixer. * @output.main_paired_volume: The volume of paired main output. * @output.hp_paired_volume: The volume of paired hp output. * @output.hp_paired_assignment: The source assigned to paired hp output. * @output.reserved: Padding for 32 bit alignment for future extension. * @line_input.boost_flag: The flags of boost for line inputs, only for 828mk2 and Traveler. * @line_input.nominal_level_flag: The flags of nominal level for line inputs, only for 828mk2 and * Traveler. * @line_input.reserved: Padding for 32 bit alignment for future extension. * @input.gain_and_invert: The value including gain and invert for input, only for Ultralite, 4 pre * and Audio Express. * @input.flag: The flag of input; e.g. jack detection, phantom power, and pad, only for Ultralite, * 4 pre and Audio express. * @reserved: Padding so that the size of structure is kept to 512 byte, but for future extension. * * The structure expresses the set of parameters for DSP controlled by register access. / struct snd_firewire_motu_register_dsp_parameter { struct { struct { __u8 gain[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; __u8 pan[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; __u8 flag[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; __u8 paired_balance[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; __u8 paired_width[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; } source[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT]; struct { __u8 paired_volume[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT]; __u8 paired_flag[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT]; } output; } mixer; struct { __u8 main_paired_volume; __u8 hp_paired_volume; __u8 hp_paired_assignment; __u8 reserved[5]; } output; struct { __u8 boost_flag; __u8 nominal_level_flag; __u8 reserved[6]; } line_input; struct { __u8 gain_and_invert[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_ALIGNED_INPUT_COUNT]; __u8 flag[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_ALIGNED_INPUT_COUNT]; } input; __u8 reserved[64]; }; / * In below MOTU models, software is allowed to control their DSP by command in frame of * asynchronous transaction to 0x'ffff'0001'0000: * * - 828 mk3 (FireWire only and Hybrid) * - 896 mk3 (FireWire only and Hybrid) * - Ultralite mk3 (FireWire only and Hybrid) * - Traveler mk3 * - Track 16 * * On the other hand, the states of hardware meter is split into specific messages included in the * sequence of isochronous packet. ALSA firewire-motu driver gathers the message and allow userspace * application to read it via ioctl. / #define SNDRV_FIREWIRE_MOTU_COMMAND_DSP_METER_COUNT 400 /* * struct snd_firewire_motu_command_dsp_meter - the container for meter information in DSP * controlled by command * @data: Signal level meters. The mapping between position and signal channel is model-dependent. * * The structure expresses the part of DSP status for hardware meter. The 32 bit storage is * estimated to include IEEE 764 32 bit single precision floating point (binary32) value. It is * expected to be linear value (not logarithm) for audio signal level between 0.0 and +1.0. / struct snd_firewire_motu_command_dsp_meter { float data[SNDRV_FIREWIRE_MOTU_COMMAND_DSP_METER_COUNT]; }; #endif / _SOUND_FIREWIRE_H_INCLUDED */	10.76 KB	2026-03-24 10:01
📄 hdsp.h /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note / #ifndef __SOUND_HDSP_H #define __SOUND_HDSP_H / * Copyright (C) 2003 Thomas Charbonnel (thomas@undata.org) / #ifdef __linux__ #include <linux/types.h> #endif #define HDSP_MATRIX_MIXER_SIZE 2048 enum HDSP_IO_Type { Digiface, Multiface, H9652, H9632, RPM, Undefined, }; struct hdsp_peak_rms { __u32 input_peaks[26]; __u32 playback_peaks[26]; __u32 output_peaks[28]; __u64 input_rms[26]; __u64 playback_rms[26]; / These are only used for H96xx cards / __u64 output_rms[26]; }; #define SNDRV_HDSP_IOCTL_GET_PEAK_RMS _IOR('H', 0x40, struct hdsp_peak_rms) struct hdsp_config_info { unsigned char pref_sync_ref; unsigned char wordclock_sync_check; unsigned char spdif_sync_check; unsigned char adatsync_sync_check; unsigned char adat_sync_check[3]; unsigned char spdif_in; unsigned char spdif_out; unsigned char spdif_professional; unsigned char spdif_emphasis; unsigned char spdif_nonaudio; unsigned int spdif_sample_rate; unsigned int system_sample_rate; unsigned int autosync_sample_rate; unsigned char system_clock_mode; unsigned char clock_source; unsigned char autosync_ref; unsigned char line_out; unsigned char passthru; unsigned char da_gain; unsigned char ad_gain; unsigned char phone_gain; unsigned char xlr_breakout_cable; unsigned char analog_extension_board; }; #define SNDRV_HDSP_IOCTL_GET_CONFIG_INFO _IOR('H', 0x41, struct hdsp_config_info) struct hdsp_firmware { void firmware_data; /* 24413 x 4 bytes / }; #define SNDRV_HDSP_IOCTL_UPLOAD_FIRMWARE _IOW('H', 0x42, struct hdsp_firmware) struct hdsp_version { enum HDSP_IO_Type io_type; unsigned short firmware_rev; }; #define SNDRV_HDSP_IOCTL_GET_VERSION _IOR('H', 0x43, struct hdsp_version) struct hdsp_mixer { unsigned short matrix[HDSP_MATRIX_MIXER_SIZE]; }; #define SNDRV_HDSP_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdsp_mixer) struct hdsp_9632_aeb { int aebi; int aebo; }; #define SNDRV_HDSP_IOCTL_GET_9632_AEB _IOR('H', 0x45, struct hdsp_9632_aeb) #endif / __SOUND_HDSP_H */	2.03 KB	2026-03-24 10:01
📄 hdspm.h /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note / #ifndef __SOUND_HDSPM_H #define __SOUND_HDSPM_H / * Copyright (C) 2003 Winfried Ritsch (IEM) * based on hdsp.h from Thomas Charbonnel (thomas@undata.org) / #ifdef __linux__ #include <linux/types.h> #endif / Maximum channels is 64 even on 56Mode you have 64playbacks to matrix / #define HDSPM_MAX_CHANNELS 64 enum hdspm_io_type { MADI, MADIface, AIO, AES32, RayDAT }; enum hdspm_speed { ss, ds, qs }; / -------------------- IOCTL Peak/RMS Meters -------------------- / struct hdspm_peak_rms { __u32 input_peaks[64]; __u32 playback_peaks[64]; __u32 output_peaks[64]; __u64 input_rms[64]; __u64 playback_rms[64]; __u64 output_rms[64]; __u8 speed; / enum {ss, ds, qs} / int status2; }; #define SNDRV_HDSPM_IOCTL_GET_PEAK_RMS \ _IOR('H', 0x42, struct hdspm_peak_rms) / ------------ CONFIG block IOCTL ---------------------- / struct hdspm_config { unsigned char pref_sync_ref; unsigned char wordclock_sync_check; unsigned char madi_sync_check; unsigned int system_sample_rate; unsigned int autosync_sample_rate; unsigned char system_clock_mode; unsigned char clock_source; unsigned char autosync_ref; unsigned char line_out; unsigned int passthru; unsigned int analog_out; }; #define SNDRV_HDSPM_IOCTL_GET_CONFIG \ _IOR('H', 0x41, struct hdspm_config) / * If there's a TCO (TimeCode Option) board installed, * there are further options and status data available. * The hdspm_ltc structure contains the current SMPTE * timecode and some status information and can be * obtained via SNDRV_HDSPM_IOCTL_GET_LTC or in the * hdspm_status struct. / enum hdspm_ltc_format { format_invalid, fps_24, fps_25, fps_2997, fps_30 }; enum hdspm_ltc_frame { frame_invalid, drop_frame, full_frame }; enum hdspm_ltc_input_format { ntsc, pal, no_video }; struct hdspm_ltc { unsigned int ltc; enum hdspm_ltc_format format; enum hdspm_ltc_frame frame; enum hdspm_ltc_input_format input_format; }; #define SNDRV_HDSPM_IOCTL_GET_LTC _IOR('H', 0x46, struct hdspm_ltc) / * The status data reflects the device's current state * as determined by the card's configuration and * connection status. / enum hdspm_sync { hdspm_sync_no_lock = 0, hdspm_sync_lock = 1, hdspm_sync_sync = 2 }; enum hdspm_madi_input { hdspm_input_optical = 0, hdspm_input_coax = 1 }; enum hdspm_madi_channel_format { hdspm_format_ch_64 = 0, hdspm_format_ch_56 = 1 }; enum hdspm_madi_frame_format { hdspm_frame_48 = 0, hdspm_frame_96 = 1 }; enum hdspm_syncsource { syncsource_wc = 0, syncsource_madi = 1, syncsource_tco = 2, syncsource_sync = 3, syncsource_none = 4 }; struct hdspm_status { __u8 card_type; / enum hdspm_io_type / enum hdspm_syncsource autosync_source; __u64 card_clock; __u32 master_period; union { struct { __u8 sync_wc; / enum hdspm_sync / __u8 sync_madi; / enum hdspm_sync / __u8 sync_tco; / enum hdspm_sync / __u8 sync_in; / enum hdspm_sync / __u8 madi_input; / enum hdspm_madi_input / __u8 channel_format; / enum hdspm_madi_channel_format / __u8 frame_format; / enum hdspm_madi_frame_format / } madi; } card_specific; }; #define SNDRV_HDSPM_IOCTL_GET_STATUS \ _IOR('H', 0x47, struct hdspm_status) / * Get information about the card and its add-ons. / #define HDSPM_ADDON_TCO 1 struct hdspm_version { __u8 card_type; / enum hdspm_io_type / char cardname[20]; unsigned int serial; unsigned short firmware_rev; int addons; }; #define SNDRV_HDSPM_IOCTL_GET_VERSION _IOR('H', 0x48, struct hdspm_version) / ------------- get Matrix Mixer IOCTL --------------- / / MADI mixer: 64inputs+64playback in 64outputs = 8192 => 4Byte = 32768 Bytes / / organisation is 64 channelfader in a continuous memory block / / equivalent to hardware definition, maybe for future feature of mmap of * them / / each of 64 outputs has 64 infader and 64 outfader: Ins to Outs mixer[out].in[in], Outstreams to Outs mixer[out].pb[pb] / #define HDSPM_MIXER_CHANNELS HDSPM_MAX_CHANNELS struct hdspm_channelfader { unsigned int in[HDSPM_MIXER_CHANNELS]; unsigned int pb[HDSPM_MIXER_CHANNELS]; }; struct hdspm_mixer { struct hdspm_channelfader ch[HDSPM_MIXER_CHANNELS]; }; struct hdspm_mixer_ioctl { struct hdspm_mixer mixer; }; /* use indirect access due to the limit of ioctl bit size */ #define SNDRV_HDSPM_IOCTL_GET_MIXER _IOR('H', 0x44, struct hdspm_mixer_ioctl) #endif	4.38 KB	2026-03-24 10:01
📁 intel	-	2026-03-24 10:01
📄 sb16_csp.h /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note / / * Copyright (c) 1999 by Uros Bizjak <uros@kss-loka.si> * Takashi Iwai <tiwai@suse.de> * * SB16ASP/AWE32 CSP control / #ifndef __SOUND_SB16_CSP_H #define __SOUND_SB16_CSP_H / CSP modes / #define SNDRV_SB_CSP_MODE_NONE 0x00 #define SNDRV_SB_CSP_MODE_DSP_READ 0x01 / Record from DSP / #define SNDRV_SB_CSP_MODE_DSP_WRITE 0x02 / Play to DSP / #define SNDRV_SB_CSP_MODE_QSOUND 0x04 / QSound / / CSP load flags / #define SNDRV_SB_CSP_LOAD_FROMUSER 0x01 #define SNDRV_SB_CSP_LOAD_INITBLOCK 0x02 / CSP sample width / #define SNDRV_SB_CSP_SAMPLE_8BIT 0x01 #define SNDRV_SB_CSP_SAMPLE_16BIT 0x02 / CSP channels / #define SNDRV_SB_CSP_MONO 0x01 #define SNDRV_SB_CSP_STEREO 0x02 / CSP rates / #define SNDRV_SB_CSP_RATE_8000 0x01 #define SNDRV_SB_CSP_RATE_11025 0x02 #define SNDRV_SB_CSP_RATE_22050 0x04 #define SNDRV_SB_CSP_RATE_44100 0x08 #define SNDRV_SB_CSP_RATE_ALL 0x0f / CSP running state / #define SNDRV_SB_CSP_ST_IDLE 0x00 #define SNDRV_SB_CSP_ST_LOADED 0x01 #define SNDRV_SB_CSP_ST_RUNNING 0x02 #define SNDRV_SB_CSP_ST_PAUSED 0x04 #define SNDRV_SB_CSP_ST_AUTO 0x08 #define SNDRV_SB_CSP_ST_QSOUND 0x10 / maximum QSound value (180 degrees right) / #define SNDRV_SB_CSP_QSOUND_MAX_RIGHT 0x20 / maximum microcode RIFF file size / #define SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE 0x3000 / microcode header / struct snd_sb_csp_mc_header { char codec_name[16]; / id name of codec / unsigned short func_req; / requested function / }; / microcode to be loaded / struct snd_sb_csp_microcode { struct snd_sb_csp_mc_header info; unsigned char data[SNDRV_SB_CSP_MAX_MICROCODE_FILE_SIZE]; }; / start CSP with sample_width in mono/stereo / struct snd_sb_csp_start { int sample_width; / sample width, look above / int channels; / channels, look above / }; / CSP information / struct snd_sb_csp_info { char codec_name[16]; / id name of codec / unsigned short func_nr; / function number / unsigned int acc_format; / accepted PCM formats / unsigned short acc_channels; / accepted channels / unsigned short acc_width; / accepted sample width / unsigned short acc_rates; / accepted sample rates / unsigned short csp_mode; / CSP mode, see above / unsigned short run_channels; / current channels / unsigned short run_width; / current sample width / unsigned short version; / version id: 0x10 - 0x1f / unsigned short state; / state bits / }; / HWDEP controls / / get CSP information / #define SNDRV_SB_CSP_IOCTL_INFO _IOR('H', 0x10, struct snd_sb_csp_info) / load microcode to CSP / / NOTE: struct snd_sb_csp_microcode overflows the max size (13 bits) * defined for some architectures like MIPS, and it leads to build errors. * (x86 and co have 14-bit size, thus it's valid, though.) * As a workaround for skipping the size-limit check, here we don't use the * normal _IOW() macro but _IOC() with the manual argument. / #define SNDRV_SB_CSP_IOCTL_LOAD_CODE \ _IOC(_IOC_WRITE, 'H', 0x11, sizeof(struct snd_sb_csp_microcode)) / unload microcode from CSP / #define SNDRV_SB_CSP_IOCTL_UNLOAD_CODE _IO('H', 0x12) / start CSP / #define SNDRV_SB_CSP_IOCTL_START _IOW('H', 0x13, struct snd_sb_csp_start) / stop CSP / #define SNDRV_SB_CSP_IOCTL_STOP _IO('H', 0x14) / pause CSP and DMA transfer / #define SNDRV_SB_CSP_IOCTL_PAUSE _IO('H', 0x15) / restart CSP and DMA transfer / #define SNDRV_SB_CSP_IOCTL_RESTART _IO('H', 0x16) #endif / __SOUND_SB16_CSP_H */	3.48 KB	2026-03-24 10:01
📄 scarlett2.h /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note / / * Focusrite Scarlett 2 Protocol Driver for ALSA * (including Scarlett 2nd Gen, 3rd Gen, 4th Gen, Clarett USB, and * Clarett+ series products) * * Copyright (c) 2023 by Geoffrey D. Bennett <g at b4.vu> / #ifndef __UAPI_SOUND_SCARLETT2_H #define __UAPI_SOUND_SCARLETT2_H #include <linux/types.h> #include <linux/ioctl.h> #define SCARLETT2_HWDEP_MAJOR 1 #define SCARLETT2_HWDEP_MINOR 0 #define SCARLETT2_HWDEP_SUBMINOR 0 #define SCARLETT2_HWDEP_VERSION \ ((SCARLETT2_HWDEP_MAJOR << 16) \| \ (SCARLETT2_HWDEP_MINOR << 8) \| \ SCARLETT2_HWDEP_SUBMINOR) #define SCARLETT2_HWDEP_VERSION_MAJOR(v) (((v) >> 16) & 0xFF) #define SCARLETT2_HWDEP_VERSION_MINOR(v) (((v) >> 8) & 0xFF) #define SCARLETT2_HWDEP_VERSION_SUBMINOR(v) ((v) & 0xFF) / Get protocol version / #define SCARLETT2_IOCTL_PVERSION _IOR('S', 0x60, int) / Reboot / #define SCARLETT2_IOCTL_REBOOT _IO('S', 0x61) / Select flash segment / #define SCARLETT2_SEGMENT_ID_SETTINGS 0 #define SCARLETT2_SEGMENT_ID_FIRMWARE 1 #define SCARLETT2_SEGMENT_ID_COUNT 2 #define SCARLETT2_IOCTL_SELECT_FLASH_SEGMENT _IOW('S', 0x62, int) / Erase selected flash segment / #define SCARLETT2_IOCTL_ERASE_FLASH_SEGMENT _IO('S', 0x63) / Get selected flash segment erase progress * 1 through to num_blocks, or 255 for complete / struct scarlett2_flash_segment_erase_progress { unsigned char progress; unsigned char num_blocks; }; #define SCARLETT2_IOCTL_GET_ERASE_PROGRESS \ _IOR('S', 0x64, struct scarlett2_flash_segment_erase_progress) #endif / __UAPI_SOUND_SCARLETT2_H */	1.58 KB	2026-03-24 10:01
📄 sfnt_info.h /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note / #ifndef __SOUND_SFNT_INFO_H #define __SOUND_SFNT_INFO_H / * Patch record compatible with AWE driver on OSS * * Copyright (C) 1999-2000 Takashi Iwai / #include <sound/asound.h> / * patch information record / #ifdef SNDRV_BIG_ENDIAN #define SNDRV_OSS_PATCHKEY(id) (0xfd00\|id) #else #define SNDRV_OSS_PATCHKEY(id) ((id<<8)\|0xfd) #endif / patch interface header: 16 bytes / struct soundfont_patch_info { unsigned short key; / use the key below / #define SNDRV_OSS_SOUNDFONT_PATCH SNDRV_OSS_PATCHKEY(0x07) short device_no; / synthesizer number / unsigned short sf_id; / file id (should be zero) / short optarg; / optional argument / int len; / data length (without this header) / short type; / patch operation type / #define SNDRV_SFNT_LOAD_INFO 0 / awe_voice_rec / #define SNDRV_SFNT_LOAD_DATA 1 / awe_sample_info / #define SNDRV_SFNT_OPEN_PATCH 2 / awe_open_parm / #define SNDRV_SFNT_CLOSE_PATCH 3 / none / / 4 is obsolete / #define SNDRV_SFNT_REPLACE_DATA 5 / awe_sample_info (optarg=#channels)/ #define SNDRV_SFNT_MAP_PRESET 6 / awe_voice_map / / 7 is not used / #define SNDRV_SFNT_PROBE_DATA 8 / optarg=sample / #define SNDRV_SFNT_REMOVE_INFO 9 / optarg=(bank<<8)\|instr / short reserved; / word alignment data / / the actual patch data begins after this / }; / * open patch / #define SNDRV_SFNT_PATCH_NAME_LEN 32 struct soundfont_open_parm { unsigned short type; / sample type / #define SNDRV_SFNT_PAT_TYPE_MISC 0 #define SNDRV_SFNT_PAT_TYPE_GUS 6 #define SNDRV_SFNT_PAT_TYPE_MAP 7 #define SNDRV_SFNT_PAT_LOCKED 0x100 / lock the samples / #define SNDRV_SFNT_PAT_SHARED 0x200 / sample is shared / short reserved; char name[SNDRV_SFNT_PATCH_NAME_LEN]; }; / * raw voice information record / / wave table envelope & effect parameters to control EMU8000 / struct soundfont_voice_parm { unsigned short moddelay; / modulation delay (0x8000) / unsigned short modatkhld; / modulation attack & hold time (0x7f7f) / unsigned short moddcysus; / modulation decay & sustain (0x7f7f) / unsigned short modrelease; / modulation release time (0x807f) / short modkeyhold, modkeydecay; / envelope change per key (not used) / unsigned short voldelay; / volume delay (0x8000) / unsigned short volatkhld; / volume attack & hold time (0x7f7f) / unsigned short voldcysus; / volume decay & sustain (0x7f7f) / unsigned short volrelease; / volume release time (0x807f) / short volkeyhold, volkeydecay; / envelope change per key (not used) / unsigned short lfo1delay; / LFO1 delay (0x8000) / unsigned short lfo2delay; / LFO2 delay (0x8000) / unsigned short pefe; / modulation pitch & cutoff (0x0000) / unsigned short fmmod; / LFO1 pitch & cutoff (0x0000) / unsigned short tremfrq; / LFO1 volume & freq (0x0000) / unsigned short fm2frq2; / LFO2 pitch & freq (0x0000) / unsigned char cutoff; / initial cutoff (0xff) / unsigned char filterQ; / initial filter Q [0-15] (0x0) / unsigned char chorus; / chorus send (0x00) / unsigned char reverb; / reverb send (0x00) / unsigned short reserved[4]; / not used / }; / wave table parameters: 92 bytes / struct soundfont_voice_info { unsigned short sf_id; / file id (should be zero) / unsigned short sample; / sample id / int start, end; / sample offset correction / int loopstart, loopend; / loop offset correction / short rate_offset; / sample rate pitch offset / unsigned short mode; / sample mode / #define SNDRV_SFNT_MODE_ROMSOUND 0x8000 #define SNDRV_SFNT_MODE_STEREO 1 #define SNDRV_SFNT_MODE_LOOPING 2 #define SNDRV_SFNT_MODE_NORELEASE 4 / obsolete / #define SNDRV_SFNT_MODE_INIT_PARM 8 short root; / midi root key / short tune; / pitch tuning (in cents) / unsigned char low, high; / key note range / unsigned char vellow, velhigh; / velocity range / signed char fixkey, fixvel; / fixed key, velocity / signed char pan, fixpan; / panning, fixed panning / short exclusiveClass; / exclusive class (0 = none) / unsigned char amplitude; / sample volume (127 max) / unsigned char attenuation; / attenuation (0.375dB) / short scaleTuning; / pitch scale tuning(%), normally 100 / struct soundfont_voice_parm parm; / voice envelope parameters / unsigned short sample_mode; / sample mode_flag (set by driver) / }; / instrument info header: 4 bytes / struct soundfont_voice_rec_hdr { unsigned char bank; / midi bank number / unsigned char instr; / midi preset number / char nvoices; / number of voices / char write_mode; / write mode; normally 0 / #define SNDRV_SFNT_WR_APPEND 0 / append anyway / #define SNDRV_SFNT_WR_EXCLUSIVE 1 / skip if already exists / #define SNDRV_SFNT_WR_REPLACE 2 / replace if already exists / }; / * sample wave information / / wave table sample header: 32 bytes / struct soundfont_sample_info { unsigned short sf_id; / file id (should be zero) / unsigned short sample; / sample id / int start, end; / start & end offset / int loopstart, loopend; / loop start & end offset / int size; / size (0 = ROM) / short dummy; / not used / unsigned short mode_flags; / mode flags / #define SNDRV_SFNT_SAMPLE_8BITS 1 / wave data is 8bits / #define SNDRV_SFNT_SAMPLE_UNSIGNED 2 / wave data is unsigned / #define SNDRV_SFNT_SAMPLE_NO_BLANK 4 / no blank loop is attached / #define SNDRV_SFNT_SAMPLE_SINGLESHOT 8 / single-shot w/o loop / #define SNDRV_SFNT_SAMPLE_BIDIR_LOOP 16 / bidirectional looping / #define SNDRV_SFNT_SAMPLE_STEREO_LEFT 32 / stereo left sound / #define SNDRV_SFNT_SAMPLE_STEREO_RIGHT 64 / stereo right sound / #define SNDRV_SFNT_SAMPLE_REVERSE_LOOP 128 / reverse looping / unsigned int truesize; / used memory size (set by driver) / }; / * voice preset mapping (aliasing) / struct soundfont_voice_map { int map_bank, map_instr, map_key; / key = -1 means all keys / int src_bank, src_instr, src_key; }; / * ioctls for hwdep / #define SNDRV_EMUX_HWDEP_NAME "Emux WaveTable" #define SNDRV_EMUX_VERSION ((1 << 16) \| (0 << 8) \| 0) / 1.0.0 / struct snd_emux_misc_mode { int port; / -1 = all / int mode; int value; int value2; / reserved / }; #define SNDRV_EMUX_IOCTL_VERSION _IOR('H', 0x80, unsigned int) #define SNDRV_EMUX_IOCTL_LOAD_PATCH _IOWR('H', 0x81, struct soundfont_patch_info) #define SNDRV_EMUX_IOCTL_RESET_SAMPLES _IO('H', 0x82) #define SNDRV_EMUX_IOCTL_REMOVE_LAST_SAMPLES _IO('H', 0x83) #define SNDRV_EMUX_IOCTL_MEM_AVAIL _IOW('H', 0x84, int) #define SNDRV_EMUX_IOCTL_MISC_MODE _IOWR('H', 0x84, struct snd_emux_misc_mode) #endif / __SOUND_SFNT_INFO_H */	6.6 KB	2026-03-24 10:01
📄 skl-tplg-interface.h /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note / / * skl-tplg-interface.h - Intel DSP FW private data interface * * Copyright (C) 2015 Intel Corp * Author: Jeeja KP <jeeja.kp@intel.com> * Nilofer, Samreen <samreen.nilofer@intel.com> / #ifndef __HDA_TPLG_INTERFACE_H__ #define __HDA_TPLG_INTERFACE_H__ #include <linux/types.h> / * Default types range from 0~12. type can range from 0 to 0xff * SST types start at higher to avoid any overlapping in future / #define SKL_CONTROL_TYPE_BYTE_TLV 0x100 #define SKL_CONTROL_TYPE_MIC_SELECT 0x102 #define SKL_CONTROL_TYPE_MULTI_IO_SELECT 0x103 #define SKL_CONTROL_TYPE_MULTI_IO_SELECT_DMIC 0x104 #define HDA_SST_CFG_MAX 900 / size of copier cfg/ #define MAX_IN_QUEUE 8 #define MAX_OUT_QUEUE 8 #define SKL_UUID_STR_SZ 40 / Event types goes here / / Reserve event type 0 for no event handlers / enum skl_event_types { SKL_EVENT_NONE = 0, SKL_MIXER_EVENT, SKL_MUX_EVENT, SKL_VMIXER_EVENT, SKL_PGA_EVENT }; /* * enum skl_ch_cfg - channel configuration * * @SKL_CH_CFG_MONO: One channel only * @SKL_CH_CFG_STEREO: L & R * @SKL_CH_CFG_2_1: L, R & LFE * @SKL_CH_CFG_3_0: L, C & R * @SKL_CH_CFG_3_1: L, C, R & LFE * @SKL_CH_CFG_QUATRO: L, R, Ls & Rs * @SKL_CH_CFG_4_0: L, C, R & Cs * @SKL_CH_CFG_5_0: L, C, R, Ls & Rs * @SKL_CH_CFG_5_1: L, C, R, Ls, Rs & LFE * @SKL_CH_CFG_DUAL_MONO: One channel replicated in two * @SKL_CH_CFG_I2S_DUAL_STEREO_0: Stereo(L,R) in 4 slots, 1st stream:[ L, R, -, - ] * @SKL_CH_CFG_I2S_DUAL_STEREO_1: Stereo(L,R) in 4 slots, 2nd stream:[ -, -, L, R ] * @SKL_CH_CFG_INVALID: Invalid / enum skl_ch_cfg { SKL_CH_CFG_MONO = 0, SKL_CH_CFG_STEREO = 1, SKL_CH_CFG_2_1 = 2, SKL_CH_CFG_3_0 = 3, SKL_CH_CFG_3_1 = 4, SKL_CH_CFG_QUATRO = 5, SKL_CH_CFG_4_0 = 6, SKL_CH_CFG_5_0 = 7, SKL_CH_CFG_5_1 = 8, SKL_CH_CFG_DUAL_MONO = 9, SKL_CH_CFG_I2S_DUAL_STEREO_0 = 10, SKL_CH_CFG_I2S_DUAL_STEREO_1 = 11, SKL_CH_CFG_7_1 = 12, SKL_CH_CFG_4_CHANNEL = SKL_CH_CFG_7_1, SKL_CH_CFG_INVALID }; enum skl_module_type { SKL_MODULE_TYPE_MIXER = 0, SKL_MODULE_TYPE_COPIER, SKL_MODULE_TYPE_UPDWMIX, SKL_MODULE_TYPE_SRCINT, SKL_MODULE_TYPE_ALGO, SKL_MODULE_TYPE_BASE_OUTFMT, SKL_MODULE_TYPE_KPB, SKL_MODULE_TYPE_MIC_SELECT, }; enum skl_core_affinity { SKL_AFFINITY_CORE_0 = 0, SKL_AFFINITY_CORE_1, SKL_AFFINITY_CORE_MAX }; enum skl_pipe_conn_type { SKL_PIPE_CONN_TYPE_NONE = 0, SKL_PIPE_CONN_TYPE_FE, SKL_PIPE_CONN_TYPE_BE }; enum skl_hw_conn_type { SKL_CONN_NONE = 0, SKL_CONN_SOURCE = 1, SKL_CONN_SINK = 2 }; enum skl_dev_type { SKL_DEVICE_BT = 0x0, SKL_DEVICE_DMIC = 0x1, SKL_DEVICE_I2S = 0x2, SKL_DEVICE_SLIMBUS = 0x3, SKL_DEVICE_HDALINK = 0x4, SKL_DEVICE_HDAHOST = 0x5, SKL_DEVICE_NONE }; /* * enum skl_interleaving - interleaving style * * @SKL_INTERLEAVING_PER_CHANNEL: [s1_ch1...s1_chN,...,sM_ch1...sM_chN] * @SKL_INTERLEAVING_PER_SAMPLE: [s1_ch1...sM_ch1,...,s1_chN...sM_chN] / enum skl_interleaving { SKL_INTERLEAVING_PER_CHANNEL = 0, SKL_INTERLEAVING_PER_SAMPLE = 1, }; enum skl_sample_type { SKL_SAMPLE_TYPE_INT_MSB = 0, SKL_SAMPLE_TYPE_INT_LSB = 1, SKL_SAMPLE_TYPE_INT_SIGNED = 2, SKL_SAMPLE_TYPE_INT_UNSIGNED = 3, SKL_SAMPLE_TYPE_FLOAT = 4 }; enum module_pin_type { / All pins of the module takes same PCM inputs or outputs * e.g. mixout / SKL_PIN_TYPE_HOMOGENEOUS, / All pins of the module takes different PCM inputs or outputs * e.g mux */ SKL_PIN_TYPE_HETEROGENEOUS, }; enum skl_module_param_type { SKL_PARAM_DEFAULT = 0, SKL_PARAM_INIT, SKL_PARAM_SET, SKL_PARAM_BIND }; struct skl_dfw_algo_data { __u32 set_params:2; __u32 rsvd:30; __u32 param_id; __u32 max; char params[]; } __attribute__((packed)); enum skl_tkn_dir { SKL_DIR_IN, SKL_DIR_OUT }; enum skl_tuple_type { SKL_TYPE_TUPLE, SKL_TYPE_DATA }; #endif	3.72 KB	2026-03-24 10:01
📄 snd_ar_tokens.h /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note / #ifndef __SND_AR_TOKENS_H__ #define __SND_AR_TOKENS_H__ #define APM_SUB_GRAPH_PERF_MODE_LOW_POWER 0x1 #define APM_SUB_GRAPH_PERF_MODE_LOW_LATENCY 0x2 #define APM_SUB_GRAPH_DIRECTION_TX 0x1 #define APM_SUB_GRAPH_DIRECTION_RX 0x2 /* Scenario ID Audio Playback / #define APM_SUB_GRAPH_SID_AUDIO_PLAYBACK 0x1 / Scenario ID Audio Record / #define APM_SUB_GRAPH_SID_AUDIO_RECORD 0x2 / Scenario ID Voice call. / #define APM_SUB_GRAPH_SID_VOICE_CALL 0x3 / container capability ID Pre/Post Processing (PP) / #define APM_CONTAINER_CAP_ID_PP 0x1 / container capability ID Compression/Decompression (CD) / #define APM_CONTAINER_CAP_ID_CD 0x2 / container capability ID End Point(EP) / #define APM_CONTAINER_CAP_ID_EP 0x3 / container capability ID Offload (OLC) / #define APM_CONTAINER_CAP_ID_OLC 0x4 / container graph position Stream / #define APM_CONT_GRAPH_POS_STREAM 0x1 / container graph position Per Stream Per Device/ #define APM_CONT_GRAPH_POS_PER_STR_PER_DEV 0x2 / container graph position Stream-Device / #define APM_CONT_GRAPH_POS_STR_DEV 0x3 / container graph position Global Device / #define APM_CONT_GRAPH_POS_GLOBAL_DEV 0x4 #define APM_PROC_DOMAIN_ID_MDSP 0x1 #define APM_PROC_DOMAIN_ID_ADSP 0x2 #define APM_PROC_DOMAIN_ID_SDSP 0x4 #define APM_PROC_DOMAIN_ID_CDSP 0x5 #define PCM_INTERLEAVED 1 #define PCM_DEINTERLEAVED_PACKED 2 #define PCM_DEINTERLEAVED_UNPACKED 3 #define AR_I2S_WS_SRC_EXTERNAL 0 #define AR_I2S_WS_SRC_INTERNAL 1 enum ar_event_types { AR_EVENT_NONE = 0, AR_PGA_DAPM_EVENT }; / * Kcontrol IDs / #define SND_SOC_AR_TPLG_FE_BE_GRAPH_CTL_MIX 256 #define SND_SOC_AR_TPLG_VOL_CTL 257 /* * %AR_TKN_U32_SUB_GRAPH_INSTANCE_ID: Sub Graph Instance Id * * %AR_TKN_U32_SUB_GRAPH_PERF_MODE: Performance mode of subgraph * APM_SUB_GRAPH_PERF_MODE_LOW_POWER = 1, * APM_SUB_GRAPH_PERF_MODE_LOW_LATENCY = 2 * * %AR_TKN_U32_SUB_GRAPH_DIRECTION: Direction of subgraph * APM_SUB_GRAPH_DIRECTION_TX = 1, * APM_SUB_GRAPH_DIRECTION_RX = 2 * * %AR_TKN_U32_SUB_GRAPH_SCENARIO_ID: Scenario ID for subgraph * APM_SUB_GRAPH_SID_AUDIO_PLAYBACK = 1, * APM_SUB_GRAPH_SID_AUDIO_RECORD = 2, * APM_SUB_GRAPH_SID_VOICE_CALL = 3 * * %AR_TKN_U32_CONTAINER_INSTANCE_ID: Container Instance ID * * %AR_TKN_U32_CONTAINER_CAPABILITY_ID: Container capability ID * APM_CONTAINER_CAP_ID_PP = 1, * APM_CONTAINER_CAP_ID_CD = 2, * APM_CONTAINER_CAP_ID_EP = 3, * APM_CONTAINER_CAP_ID_OLC = 4 * * %AR_TKN_U32_CONTAINER_STACK_SIZE: Stack size in the container. * * %AR_TKN_U32_CONTAINER_GRAPH_POS: Graph Position * APM_CONT_GRAPH_POS_STREAM = 1, * APM_CONT_GRAPH_POS_PER_STR_PER_DEV = 2, * APM_CONT_GRAPH_POS_STR_DEV = 3, * APM_CONT_GRAPH_POS_GLOBAL_DEV = 4 * * %AR_TKN_U32_CONTAINER_PROC_DOMAIN: Processor domain of container * APM_PROC_DOMAIN_ID_MDSP = 1, * APM_PROC_DOMAIN_ID_ADSP = 2, * APM_PROC_DOMAIN_ID_SDSP = 4, * APM_PROC_DOMAIN_ID_CDSP = 5 * * %AR_TKN_U32_MODULE_ID: Module ID * * %AR_TKN_U32_MODULE_INSTANCE_ID: Module Instance ID. * * %AR_TKN_U32_MODULE_MAX_IP_PORTS: Module maximum input ports * * %AR_TKN_U32_MODULE_MAX_OP_PORTS: Module maximum output ports. * * %AR_TKN_U32_MODULE_IN_PORTS: Number of in ports * * %AR_TKN_U32_MODULE_OUT_PORTS: Number of out ports. * * %AR_TKN_U32_MODULE_SRC_OP_PORT_ID: Source module output port ID * * %AR_TKN_U32_MODULE_DST_IN_PORT_ID: Destination module input port ID * * %AR_TKN_U32_MODULE_HW_IF_IDX: Interface index types for I2S/LPAIF * * %AR_TKN_U32_MODULE_HW_IF_TYPE: Interface type * LPAIF = 0, * LPAIF_RXTX = 1, * LPAIF_WSA = 2, * LPAIF_VA = 3, * LPAIF_AXI = 4 * * %AR_TKN_U32_MODULE_FMT_INTERLEAVE: PCM Interleaving * PCM_INTERLEAVED = 1, * PCM_DEINTERLEAVED_PACKED = 2, * PCM_DEINTERLEAVED_UNPACKED = 3 * * %AR_TKN_U32_MODULE_FMT_DATA: data format * FIXED POINT = 1, * IEC60958 PACKETIZED = 3, * IEC60958 PACKETIZED NON LINEAR = 8, * COMPR OVER PCM PACKETIZED = 7, * IEC61937 PACKETIZED = 2, * GENERIC COMPRESSED = 5 * * %AR_TKN_U32_MODULE_FMT_SAMPLE_RATE: sample rate * * %AR_TKN_U32_MODULE_FMT_BIT_DEPTH: bit depth * * %AR_TKN_U32_MODULE_SD_LINE_IDX: I2S serial data line idx * I2S_SD0 = 1, * I2S_SD1 = 2, * I2S_SD2 = 3, * I2S_SD3 = 4, * I2S_QUAD01 = 5, * I2S_QUAD23 = 6, * I2S_6CHS = 7, * I2S_8CHS = 8 * * %AR_TKN_U32_MODULE_WS_SRC: Word Select Source * AR_I2S_WS_SRC_EXTERNAL = 0, * AR_I2S_WS_SRC_INTERNAL = 1, * * %AR_TKN_U32_MODULE_FRAME_SZ_FACTOR: Frame size factor * * %AR_TKN_U32_MODULE_LOG_CODE: Log Module Code * * %AR_TKN_U32_MODULE_LOG_TAP_POINT_ID: logging tap point of this module * * %AR_TKN_U32_MODULE_LOG_MODE: logging mode * LOG_WAIT = 0, * LOG_IMMEDIATELY = 1 * * %AR_TKN_DAI_INDEX: dai index * / / DAI Tokens / #define AR_TKN_DAI_INDEX 1 / SUB GRAPH Tokens / #define AR_TKN_U32_SUB_GRAPH_INSTANCE_ID 2 #define AR_TKN_U32_SUB_GRAPH_PERF_MODE 3 #define AR_TKN_U32_SUB_GRAPH_DIRECTION 4 #define AR_TKN_U32_SUB_GRAPH_SCENARIO_ID 5 / Container Tokens / #define AR_TKN_U32_CONTAINER_INSTANCE_ID 100 #define AR_TKN_U32_CONTAINER_CAPABILITY_ID 101 #define AR_TKN_U32_CONTAINER_STACK_SIZE 102 #define AR_TKN_U32_CONTAINER_GRAPH_POS 103 #define AR_TKN_U32_CONTAINER_PROC_DOMAIN 104 / Module Tokens / #define AR_TKN_U32_MODULE_ID 200 #define AR_TKN_U32_MODULE_INSTANCE_ID 201 #define AR_TKN_U32_MODULE_MAX_IP_PORTS 202 #define AR_TKN_U32_MODULE_MAX_OP_PORTS 203 #define AR_TKN_U32_MODULE_IN_PORTS 204 #define AR_TKN_U32_MODULE_OUT_PORTS 205 #define AR_TKN_U32_MODULE_SRC_OP_PORT_ID 206 #define AR_TKN_U32_MODULE_DST_IN_PORT_ID 207 #define AR_TKN_U32_MODULE_SRC_INSTANCE_ID 208 #define AR_TKN_U32_MODULE_DST_INSTANCE_ID 209 #define AR_TKN_U32_MODULE_SRC_OP_PORT_ID1 210 #define AR_TKN_U32_MODULE_DST_IN_PORT_ID1 211 #define AR_TKN_U32_MODULE_DST_INSTANCE_ID1 212 #define AR_TKN_U32_MODULE_SRC_OP_PORT_ID2 213 #define AR_TKN_U32_MODULE_DST_IN_PORT_ID2 214 #define AR_TKN_U32_MODULE_DST_INSTANCE_ID2 215 #define AR_TKN_U32_MODULE_SRC_OP_PORT_ID3 216 #define AR_TKN_U32_MODULE_DST_IN_PORT_ID3 217 #define AR_TKN_U32_MODULE_DST_INSTANCE_ID3 218 #define AR_TKN_U32_MODULE_SRC_OP_PORT_ID4 219 #define AR_TKN_U32_MODULE_DST_IN_PORT_ID4 220 #define AR_TKN_U32_MODULE_DST_INSTANCE_ID4 221 #define AR_TKN_U32_MODULE_SRC_OP_PORT_ID5 222 #define AR_TKN_U32_MODULE_DST_IN_PORT_ID5 223 #define AR_TKN_U32_MODULE_DST_INSTANCE_ID5 224 #define AR_TKN_U32_MODULE_SRC_OP_PORT_ID6 225 #define AR_TKN_U32_MODULE_DST_IN_PORT_ID6 226 #define AR_TKN_U32_MODULE_DST_INSTANCE_ID6 227 #define AR_TKN_U32_MODULE_SRC_OP_PORT_ID7 228 #define AR_TKN_U32_MODULE_DST_IN_PORT_ID7 229 #define AR_TKN_U32_MODULE_DST_INSTANCE_ID7 230 #define AR_TKN_U32_MODULE_HW_IF_IDX 250 #define AR_TKN_U32_MODULE_HW_IF_TYPE 251 #define AR_TKN_U32_MODULE_FMT_INTERLEAVE 252 #define AR_TKN_U32_MODULE_FMT_DATA 253 #define AR_TKN_U32_MODULE_FMT_SAMPLE_RATE 254 #define AR_TKN_U32_MODULE_FMT_BIT_DEPTH 255 #define AR_TKN_U32_MODULE_SD_LINE_IDX 256 #define AR_TKN_U32_MODULE_WS_SRC 257 #define AR_TKN_U32_MODULE_FRAME_SZ_FACTOR 258 #define AR_TKN_U32_MODULE_LOG_CODE 259 #define AR_TKN_U32_MODULE_LOG_TAP_POINT_ID 260 #define AR_TKN_U32_MODULE_LOG_MODE 261 #endif / __SND_AR_TOKENS_H__ */	7.48 KB	2026-03-24 10:01
📄 snd_sst_tokens.h /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note / / * snd_sst_tokens.h - Intel SST tokens definition * * Copyright (C) 2016 Intel Corp * Author: Shreyas NC <shreyas.nc@intel.com> / #ifndef __SND_SST_TOKENS_H__ #define __SND_SST_TOKENS_H__ /* * %SKL_TKN_UUID: Module UUID * * %SKL_TKN_U8_BLOCK_TYPE: Type of the private data block.Can be: * tuples, bytes, short and words * * %SKL_TKN_U8_IN_PIN_TYPE: Input pin type, * homogenous=0, heterogenous=1 * * %SKL_TKN_U8_OUT_PIN_TYPE: Output pin type, * homogenous=0, heterogenous=1 * %SKL_TKN_U8_DYN_IN_PIN: Configure Input pin dynamically * if true * * %SKL_TKN_U8_DYN_OUT_PIN: Configure Output pin dynamically * if true * * %SKL_TKN_U8_IN_QUEUE_COUNT: Store the number of Input pins * * %SKL_TKN_U8_OUT_QUEUE_COUNT: Store the number of Output pins * * %SKL_TKN_U8_TIME_SLOT: TDM slot number * * %SKL_TKN_U8_CORE_ID: Stores module affinity value.Can take * the values: * SKL_AFFINITY_CORE_0 = 0, * SKL_AFFINITY_CORE_1, * SKL_AFFINITY_CORE_MAX * * %SKL_TKN_U8_MOD_TYPE: Module type value. * * %SKL_TKN_U8_CONN_TYPE: Module connection type can be a FE, * BE or NONE as defined : * SKL_PIPE_CONN_TYPE_NONE = 0, * SKL_PIPE_CONN_TYPE_FE = 1 (HOST_DMA) * SKL_PIPE_CONN_TYPE_BE = 2 (LINK_DMA) * * %SKL_TKN_U8_DEV_TYPE: Type of device to which the module is * connected * Can take the values: * SKL_DEVICE_BT = 0x0, * SKL_DEVICE_DMIC = 0x1, * SKL_DEVICE_I2S = 0x2, * SKL_DEVICE_SLIMBUS = 0x3, * SKL_DEVICE_HDALINK = 0x4, * SKL_DEVICE_HDAHOST = 0x5, * SKL_DEVICE_NONE * * %SKL_TKN_U8_HW_CONN_TYPE: Connection type of the HW to which the * module is connected * SKL_CONN_NONE = 0, * SKL_CONN_SOURCE = 1, * SKL_CONN_SINK = 2 * * %SKL_TKN_U16_PIN_INST_ID: Stores the pin instance id * * %SKL_TKN_U16_MOD_INST_ID: Stores the mdule instance id * * %SKL_TKN_U32_MAX_MCPS: Module max mcps value * * %SKL_TKN_U32_MEM_PAGES: Module resource pages * * %SKL_TKN_U32_OBS: Stores Output Buffer size * * %SKL_TKN_U32_IBS: Stores input buffer size * * %SKL_TKN_U32_VBUS_ID: Module VBUS_ID. PDM=0, SSP0=0, * SSP1=1,SSP2=2, * SSP3=3, SSP4=4, * SSP5=5, SSP6=6,INVALID * * %SKL_TKN_U32_PARAMS_FIXUP: Module Params fixup mask * %SKL_TKN_U32_CONVERTER: Module params converter mask * %SKL_TKN_U32_PIPE_ID: Stores the pipe id * * %SKL_TKN_U32_PIPE_CONN_TYPE: Type of the token to which the pipe is * connected to. It can be * SKL_PIPE_CONN_TYPE_NONE = 0, * SKL_PIPE_CONN_TYPE_FE = 1 (HOST_DMA), * SKL_PIPE_CONN_TYPE_BE = 2 (LINK_DMA), * * %SKL_TKN_U32_PIPE_PRIORITY: Pipe priority value * %SKL_TKN_U32_PIPE_MEM_PGS: Pipe resource pages * * %SKL_TKN_U32_DIR_PIN_COUNT: Value for the direction to set input/output * formats and the pin count. * The first 4 bits have the direction * value and the next 4 have * the pin count value. * SKL_DIR_IN = 0, SKL_DIR_OUT = 1. * The input and output formats * share the same set of tokens * with the distinction between input * and output made by reading direction * token. * * %SKL_TKN_U32_FMT_CH: Supported channel count * * %SKL_TKN_U32_FMT_FREQ: Supported frequency/sample rate * * %SKL_TKN_U32_FMT_BIT_DEPTH: Supported container size * * %SKL_TKN_U32_FMT_SAMPLE_SIZE:Number of samples in the container * * %SKL_TKN_U32_FMT_CH_CONFIG: Supported channel configurations for the * input/output. * * %SKL_TKN_U32_FMT_INTERLEAVE: Interleaving style which can be per * channel or per sample. The values can be : * SKL_INTERLEAVING_PER_CHANNEL = 0, * SKL_INTERLEAVING_PER_SAMPLE = 1, * * %SKL_TKN_U32_FMT_SAMPLE_TYPE: * Specifies the sample type. Can take the * values: SKL_SAMPLE_TYPE_INT_MSB = 0, * SKL_SAMPLE_TYPE_INT_LSB = 1, * SKL_SAMPLE_TYPE_INT_SIGNED = 2, * SKL_SAMPLE_TYPE_INT_UNSIGNED = 3, * SKL_SAMPLE_TYPE_FLOAT = 4 * * %SKL_TKN_U32_CH_MAP: Channel map values * %SKL_TKN_U32_MOD_SET_PARAMS: It can take these values: * SKL_PARAM_DEFAULT, SKL_PARAM_INIT, * SKL_PARAM_SET, SKL_PARAM_BIND * * %SKL_TKN_U32_MOD_PARAM_ID: ID of the module params * * %SKL_TKN_U32_CAPS_SET_PARAMS: * Set params value * * %SKL_TKN_U32_CAPS_PARAMS_ID: Params ID * * %SKL_TKN_U32_CAPS_SIZE: Caps size * * %SKL_TKN_U32_PROC_DOMAIN: Specify processing domain * * %SKL_TKN_U32_LIB_COUNT: Specifies the number of libraries * * %SKL_TKN_STR_LIB_NAME: Specifies the library name * * %SKL_TKN_U32_PMODE: Specifies the power mode for pipe * * %SKL_TKL_U32_D0I3_CAPS: Specifies the D0i3 capability for module * * %SKL_TKN_U32_DMA_BUF_SIZE: DMA buffer size in millisec * * %SKL_TKN_U32_PIPE_DIR: Specifies pipe direction. Can be * playback/capture. * * %SKL_TKN_U32_NUM_CONFIGS: Number of pipe configs * * %SKL_TKN_U32_PATH_MEM_PGS: Size of memory (in pages) required for pipeline * and its data * * %SKL_TKN_U32_PIPE_CONFIG_ID: Config id for the modules in the pipe * and PCM params supported by that pipe * config. This is used as index to fill * up the pipe config and module config * structure. * * %SKL_TKN_U32_CFG_FREQ: * %SKL_TKN_U8_CFG_CHAN: * %SKL_TKN_U8_CFG_BPS: PCM params (freq, channels, bits per sample) * supported for each of the pipe configs. * * %SKL_TKN_CFG_MOD_RES_ID: Module's resource index for each of the * pipe config * * %SKL_TKN_CFG_MOD_FMT_ID: Module's interface index for each of the * pipe config * * %SKL_TKN_U8_NUM_MOD: Number of modules in the manifest * * %SKL_TKN_MM_U8_MOD_IDX: Current index of the module in the manifest * * %SKL_TKN_MM_U8_NUM_RES: Number of resources for the module * * %SKL_TKN_MM_U8_NUM_INTF: Number of interfaces for the module * * %SKL_TKN_MM_U32_RES_ID: Resource index for the resource info to * be filled into. * A module can support multiple resource * configuration and is represnted as a * resource table. This index is used to * fill information into appropriate index. * * %SKL_TKN_MM_U32_CPS: DSP cycles per second * * %SKL_TKN_MM_U32_DMA_SIZE: Allocated buffer size for gateway DMA * * %SKL_TKN_MM_U32_CPC: DSP cycles allocated per frame * * %SKL_TKN_MM_U32_RES_PIN_ID: Resource pin index in the module * * %SKL_TKN_MM_U32_INTF_PIN_ID: Interface index in the module * * %SKL_TKN_MM_U32_PIN_BUF: Buffer size of the module pin * * %SKL_TKN_MM_U32_FMT_ID: Format index for each of the interface/ * format information to be filled into. * * %SKL_TKN_MM_U32_NUM_IN_FMT: Number of input formats * %SKL_TKN_MM_U32_NUM_OUT_FMT: Number of output formats * * %SKL_TKN_U32_ASTATE_IDX: Table Index for the A-State entry to be filled * with kcps and clock source * * %SKL_TKN_U32_ASTATE_COUNT: Number of valid entries in A-State table * * %SKL_TKN_U32_ASTATE_KCPS: Specifies the core load threshold (in kilo * cycles per second) below which DSP is clocked * from source specified by clock source. * * %SKL_TKN_U32_ASTATE_CLK_SRC: Clock source for A-State entry * * %SKL_TKN_U32_FMT_CFG_IDX: Format config index * * module_id and loadable flags dont have tokens as these values will be * read from the DSP FW manifest * * Tokens defined can be used either in the manifest or widget private data. * * SKL_TKN_MM is used as a suffix for all tokens that represent * module data in the manifest. / enum SKL_TKNS { SKL_TKN_UUID = 1, SKL_TKN_U8_NUM_BLOCKS, SKL_TKN_U8_BLOCK_TYPE, SKL_TKN_U8_IN_PIN_TYPE, SKL_TKN_U8_OUT_PIN_TYPE, SKL_TKN_U8_DYN_IN_PIN, SKL_TKN_U8_DYN_OUT_PIN, SKL_TKN_U8_IN_QUEUE_COUNT, SKL_TKN_U8_OUT_QUEUE_COUNT, SKL_TKN_U8_TIME_SLOT, SKL_TKN_U8_CORE_ID, SKL_TKN_U8_MOD_TYPE, SKL_TKN_U8_CONN_TYPE, SKL_TKN_U8_DEV_TYPE, SKL_TKN_U8_HW_CONN_TYPE, SKL_TKN_U16_MOD_INST_ID, SKL_TKN_U16_BLOCK_SIZE, SKL_TKN_U32_MAX_MCPS, SKL_TKN_U32_MEM_PAGES, SKL_TKN_U32_OBS, SKL_TKN_U32_IBS, SKL_TKN_U32_VBUS_ID, SKL_TKN_U32_PARAMS_FIXUP, SKL_TKN_U32_CONVERTER, SKL_TKN_U32_PIPE_ID, SKL_TKN_U32_PIPE_CONN_TYPE, SKL_TKN_U32_PIPE_PRIORITY, SKL_TKN_U32_PIPE_MEM_PGS, SKL_TKN_U32_DIR_PIN_COUNT, SKL_TKN_U32_FMT_CH, SKL_TKN_U32_FMT_FREQ, SKL_TKN_U32_FMT_BIT_DEPTH, SKL_TKN_U32_FMT_SAMPLE_SIZE, SKL_TKN_U32_FMT_CH_CONFIG, SKL_TKN_U32_FMT_INTERLEAVE, SKL_TKN_U32_FMT_SAMPLE_TYPE, SKL_TKN_U32_FMT_CH_MAP, SKL_TKN_U32_PIN_MOD_ID, SKL_TKN_U32_PIN_INST_ID, SKL_TKN_U32_MOD_SET_PARAMS, SKL_TKN_U32_MOD_PARAM_ID, SKL_TKN_U32_CAPS_SET_PARAMS, SKL_TKN_U32_CAPS_PARAMS_ID, SKL_TKN_U32_CAPS_SIZE, SKL_TKN_U32_PROC_DOMAIN, SKL_TKN_U32_LIB_COUNT, SKL_TKN_STR_LIB_NAME, SKL_TKN_U32_PMODE, SKL_TKL_U32_D0I3_CAPS, / Typo added at v4.10 */ SKL_TKN_U32_D0I3_CAPS = SKL_TKL_U32_D0I3_CAPS, SKL_TKN_U32_DMA_BUF_SIZE, SKL_TKN_U32_PIPE_DIRECTION, SKL_TKN_U32_PIPE_CONFIG_ID, SKL_TKN_U32_NUM_CONFIGS, SKL_TKN_U32_PATH_MEM_PGS, SKL_TKN_U32_CFG_FREQ, SKL_TKN_U8_CFG_CHAN, SKL_TKN_U8_CFG_BPS, SKL_TKN_CFG_MOD_RES_ID, SKL_TKN_CFG_MOD_FMT_ID, SKL_TKN_U8_NUM_MOD, SKL_TKN_MM_U8_MOD_IDX, SKL_TKN_MM_U8_NUM_RES, SKL_TKN_MM_U8_NUM_INTF, SKL_TKN_MM_U32_RES_ID, SKL_TKN_MM_U32_CPS, SKL_TKN_MM_U32_DMA_SIZE, SKL_TKN_MM_U32_CPC, SKL_TKN_MM_U32_RES_PIN_ID, SKL_TKN_MM_U32_INTF_PIN_ID, SKL_TKN_MM_U32_PIN_BUF, SKL_TKN_MM_U32_FMT_ID, SKL_TKN_MM_U32_NUM_IN_FMT, SKL_TKN_MM_U32_NUM_OUT_FMT, SKL_TKN_U32_ASTATE_IDX, SKL_TKN_U32_ASTATE_COUNT, SKL_TKN_U32_ASTATE_KCPS, SKL_TKN_U32_ASTATE_CLK_SRC, SKL_TKN_U32_FMT_CFG_IDX = 96, SKL_TKN_MAX = SKL_TKN_U32_FMT_CFG_IDX, }; #endif	11.48 KB	2026-03-24 10:01
📁 sof	-	2026-03-27 02:43
📄 tlv.h /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note / #ifndef __UAPI_SOUND_TLV_H #define __UAPI_SOUND_TLV_H #define SNDRV_CTL_TLVT_CONTAINER 0 / one level down - group of TLVs / #define SNDRV_CTL_TLVT_DB_SCALE 1 / dB scale / #define SNDRV_CTL_TLVT_DB_LINEAR 2 / linear volume / #define SNDRV_CTL_TLVT_DB_RANGE 3 / dB range container / #define SNDRV_CTL_TLVT_DB_MINMAX 4 / dB scale with min/max / #define SNDRV_CTL_TLVT_DB_MINMAX_MUTE 5 / dB scale with min/max with mute / / * channel-mapping TLV items * TLV length must match with num_channels / #define SNDRV_CTL_TLVT_CHMAP_FIXED 0x101 / fixed channel position / #define SNDRV_CTL_TLVT_CHMAP_VAR 0x102 / channels freely swappable / #define SNDRV_CTL_TLVT_CHMAP_PAIRED 0x103 / pair-wise swappable / #define SNDRV_CTL_TLVT_FCP_CHANNEL_LABELS 0x110 / channel labels / / * TLV structure is right behind the struct snd_ctl_tlv: * unsigned int type - see SNDRV_CTL_TLVT_* * unsigned int length * .... data aligned to sizeof(unsigned int), use * block_length = (length + (sizeof(unsigned int) - 1)) & * ~(sizeof(unsigned int) - 1)) .... / #define SNDRV_CTL_TLVD_ITEM(type, ...) \ (type), SNDRV_CTL_TLVD_LENGTH(__VA_ARGS__), __VA_ARGS__ #define SNDRV_CTL_TLVD_LENGTH(...) \ ((unsigned int)sizeof((const unsigned int[]) { __VA_ARGS__ })) / Accessor offsets for TLV data items / #define SNDRV_CTL_TLVO_TYPE 0 #define SNDRV_CTL_TLVO_LEN 1 #define SNDRV_CTL_TLVD_CONTAINER_ITEM(...) \ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_CONTAINER, __VA_ARGS__) #define SNDRV_CTL_TLVD_DECLARE_CONTAINER(name, ...) \ unsigned int name[] = { \ SNDRV_CTL_TLVD_CONTAINER_ITEM(__VA_ARGS__) \ } #define SNDRV_CTL_TLVD_DB_SCALE_MASK 0xffff #define SNDRV_CTL_TLVD_DB_SCALE_MUTE 0x10000 #define SNDRV_CTL_TLVD_DB_SCALE_ITEM(min, step, mute) \ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_SCALE, \ (min), \ ((step) & SNDRV_CTL_TLVD_DB_SCALE_MASK) \| \ ((mute) ? SNDRV_CTL_TLVD_DB_SCALE_MUTE : 0)) #define SNDRV_CTL_TLVD_DECLARE_DB_SCALE(name, min, step, mute) \ unsigned int name[] = { \ SNDRV_CTL_TLVD_DB_SCALE_ITEM(min, step, mute) \ } / Accessor offsets for min, mute and step items in dB scale type TLV / #define SNDRV_CTL_TLVO_DB_SCALE_MIN 2 #define SNDRV_CTL_TLVO_DB_SCALE_MUTE_AND_STEP 3 / dB scale specified with min/max values instead of step / #define SNDRV_CTL_TLVD_DB_MINMAX_ITEM(min_dB, max_dB) \ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_MINMAX, (min_dB), (max_dB)) #define SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) \ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_MINMAX_MUTE, (min_dB), (max_dB)) #define SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(name, min_dB, max_dB) \ unsigned int name[] = { \ SNDRV_CTL_TLVD_DB_MINMAX_ITEM(min_dB, max_dB) \ } #define SNDRV_CTL_TLVD_DECLARE_DB_MINMAX_MUTE(name, min_dB, max_dB) \ unsigned int name[] = { \ SNDRV_CTL_TLVD_DB_MINMAX_MUTE_ITEM(min_dB, max_dB) \ } / Accessor offsets for min, max items in db-minmax types of TLV. / #define SNDRV_CTL_TLVO_DB_MINMAX_MIN 2 #define SNDRV_CTL_TLVO_DB_MINMAX_MAX 3 / linear volume between min_dB and max_dB (.01dB unit) / #define SNDRV_CTL_TLVD_DB_LINEAR_ITEM(min_dB, max_dB) \ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_LINEAR, (min_dB), (max_dB)) #define SNDRV_CTL_TLVD_DECLARE_DB_LINEAR(name, min_dB, max_dB) \ unsigned int name[] = { \ SNDRV_CTL_TLVD_DB_LINEAR_ITEM(min_dB, max_dB) \ } / Accessor offsets for min, max items in db-linear type of TLV. / #define SNDRV_CTL_TLVO_DB_LINEAR_MIN 2 #define SNDRV_CTL_TLVO_DB_LINEAR_MAX 3 / dB range container: * Items in dB range container must be ordered by their values and by their * dB values. This implies that larger values must correspond with larger * dB values (which is also required for all other mixer controls). / / Each item is: <min> <max> <TLV> */ #define SNDRV_CTL_TLVD_DB_RANGE_ITEM(...) \ SNDRV_CTL_TLVD_ITEM(SNDRV_CTL_TLVT_DB_RANGE, __VA_ARGS__) #define SNDRV_CTL_TLVD_DECLARE_DB_RANGE(name, ...) \ unsigned int name[] = { \ SNDRV_CTL_TLVD_DB_RANGE_ITEM(__VA_ARGS__) \ } #define SNDRV_CTL_TLVD_DB_GAIN_MUTE -9999999 #endif	4.05 KB	2026-03-24 10:01
📄 usb_stream.h /* SPDX-License-Identifier: GPL-2.0+ WITH Linux-syscall-note / / * Copyright (C) 2007, 2008 Karsten Wiese <fzu@wemgehoertderstaat.de> / #ifndef __SOUND_USB_STREAM_H #define __SOUND_USB_STREAM_H #define USB_STREAM_INTERFACE_VERSION 2 #define SNDRV_USB_STREAM_IOCTL_SET_PARAMS \ _IOW('H', 0x90, struct usb_stream_config) struct usb_stream_packet { unsigned offset; unsigned length; }; struct usb_stream_config { unsigned version; unsigned sample_rate; unsigned period_frames; unsigned frame_size; }; struct usb_stream { struct usb_stream_config cfg; unsigned read_size; unsigned write_size; int period_size; unsigned state; int idle_insize; int idle_outsize; int sync_packet; unsigned insize_done; unsigned periods_done; unsigned periods_polled; struct usb_stream_packet outpacket[2]; unsigned inpackets; unsigned inpacket_head; unsigned inpacket_split; unsigned inpacket_split_at; unsigned next_inpacket_split; unsigned next_inpacket_split_at; struct usb_stream_packet inpacket[]; }; enum usb_stream_state { usb_stream_invalid, usb_stream_stopped, usb_stream_sync0, usb_stream_sync1, usb_stream_ready, usb_stream_running, usb_stream_xrun, }; #endif / __SOUND_USB_STREAM_H */	1.21 KB	2026-03-24 10:01

Edit File:

Terminal