Warning: This file is not a C or C++ file. It does not have highlighting.
| 1 | /* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ |
|---|---|
| 2 | #ifndef _UAPI_SOUND_FIREWIRE_H_INCLUDED |
| 3 | #define _UAPI_SOUND_FIREWIRE_H_INCLUDED |
| 4 | |
| 5 | #include <linux/ioctl.h> |
| 6 | #include <linux/types.h> |
| 7 | |
| 8 | /* events can be read() from the hwdep device */ |
| 9 | |
| 10 | #define SNDRV_FIREWIRE_EVENT_LOCK_STATUS 0x000010cc |
| 11 | #define SNDRV_FIREWIRE_EVENT_DICE_NOTIFICATION 0xd1ce004e |
| 12 | #define SNDRV_FIREWIRE_EVENT_EFW_RESPONSE 0x4e617475 |
| 13 | #define SNDRV_FIREWIRE_EVENT_DIGI00X_MESSAGE 0x746e736c |
| 14 | #define SNDRV_FIREWIRE_EVENT_MOTU_NOTIFICATION 0x64776479 |
| 15 | #define SNDRV_FIREWIRE_EVENT_TASCAM_CONTROL 0x7473636d |
| 16 | #define SNDRV_FIREWIRE_EVENT_MOTU_REGISTER_DSP_CHANGE 0x4d545244 |
| 17 | #define SNDRV_FIREWIRE_EVENT_FF400_MESSAGE 0x4f6c6761 |
| 18 | |
| 19 | struct snd_firewire_event_common { |
| 20 | unsigned int type; /* SNDRV_FIREWIRE_EVENT_xxx */ |
| 21 | }; |
| 22 | |
| 23 | struct snd_firewire_event_lock_status { |
| 24 | unsigned int type; |
| 25 | unsigned int status; /* 0/1 = unlocked/locked */ |
| 26 | }; |
| 27 | |
| 28 | struct snd_firewire_event_dice_notification { |
| 29 | unsigned int type; |
| 30 | unsigned int notification; /* DICE-specific bits */ |
| 31 | }; |
| 32 | |
| 33 | #define SND_EFW_TRANSACTION_USER_SEQNUM_MAX ((__u32)((__u16)~0) - 1) |
| 34 | /* each field should be in big endian */ |
| 35 | struct snd_efw_transaction { |
| 36 | __be32 length; |
| 37 | __be32 version; |
| 38 | __be32 seqnum; |
| 39 | __be32 category; |
| 40 | __be32 command; |
| 41 | __be32 status; |
| 42 | __be32 params[]; |
| 43 | }; |
| 44 | struct snd_firewire_event_efw_response { |
| 45 | unsigned int type; |
| 46 | __be32 response[]; /* some responses */ |
| 47 | }; |
| 48 | |
| 49 | struct snd_firewire_event_digi00x_message { |
| 50 | unsigned int type; |
| 51 | __u32 message; /* Digi00x-specific message */ |
| 52 | }; |
| 53 | |
| 54 | struct snd_firewire_event_motu_notification { |
| 55 | unsigned int type; |
| 56 | __u32 message; /* MOTU-specific bits. */ |
| 57 | }; |
| 58 | |
| 59 | struct snd_firewire_tascam_change { |
| 60 | unsigned int index; |
| 61 | __be32 before; |
| 62 | __be32 after; |
| 63 | }; |
| 64 | |
| 65 | struct snd_firewire_event_tascam_control { |
| 66 | unsigned int type; |
| 67 | struct snd_firewire_tascam_change changes[]; |
| 68 | }; |
| 69 | |
| 70 | struct snd_firewire_event_motu_register_dsp_change { |
| 71 | unsigned int type; |
| 72 | __u32 count; /* The number of changes. */ |
| 73 | __u32 changes[]; /* Encoded event for change of register DSP. */ |
| 74 | }; |
| 75 | |
| 76 | /** |
| 77 | * struct snd_firewire_event_ff400_message - the container for message from Fireface 400 when |
| 78 | * operating hardware knob. |
| 79 | * |
| 80 | * @type: Fixed to SNDRV_FIREWIRE_EVENT_FF400_MESSAGE. |
| 81 | * @message_count: The number of messages. |
| 82 | * @messages.message: The messages expressing hardware knob operation. |
| 83 | * @messages.tstamp: The isochronous cycle at which the request subaction of asynchronous |
| 84 | * transaction was sent to deliver the message. It has 16 bit unsigned integer |
| 85 | * value. The higher 3 bits of value expresses the lower three bits of second |
| 86 | * field in the format of CYCLE_TIME, up to 7. The rest 13 bits expresses cycle |
| 87 | * field up to 7999. |
| 88 | * |
| 89 | * The structure expresses message transmitted by Fireface 400 when operating hardware knob. |
| 90 | */ |
| 91 | struct snd_firewire_event_ff400_message { |
| 92 | unsigned int type; |
| 93 | unsigned int message_count; |
| 94 | struct { |
| 95 | __u32 message; |
| 96 | __u32 tstamp; |
| 97 | } messages[]; |
| 98 | }; |
| 99 | |
| 100 | union snd_firewire_event { |
| 101 | struct snd_firewire_event_common common; |
| 102 | struct snd_firewire_event_lock_status lock_status; |
| 103 | struct snd_firewire_event_dice_notification dice_notification; |
| 104 | struct snd_firewire_event_efw_response efw_response; |
| 105 | struct snd_firewire_event_digi00x_message digi00x_message; |
| 106 | struct snd_firewire_event_tascam_control tascam_control; |
| 107 | struct snd_firewire_event_motu_notification motu_notification; |
| 108 | struct snd_firewire_event_motu_register_dsp_change motu_register_dsp_change; |
| 109 | struct snd_firewire_event_ff400_message ff400_message; |
| 110 | }; |
| 111 | |
| 112 | |
| 113 | #define SNDRV_FIREWIRE_IOCTL_GET_INFO _IOR('H', 0xf8, struct snd_firewire_get_info) |
| 114 | #define SNDRV_FIREWIRE_IOCTL_LOCK _IO('H', 0xf9) |
| 115 | #define SNDRV_FIREWIRE_IOCTL_UNLOCK _IO('H', 0xfa) |
| 116 | #define SNDRV_FIREWIRE_IOCTL_TASCAM_STATE _IOR('H', 0xfb, struct snd_firewire_tascam_state) |
| 117 | #define SNDRV_FIREWIRE_IOCTL_MOTU_REGISTER_DSP_METER _IOR('H', 0xfc, struct snd_firewire_motu_register_dsp_meter) |
| 118 | #define SNDRV_FIREWIRE_IOCTL_MOTU_COMMAND_DSP_METER _IOR('H', 0xfd, struct snd_firewire_motu_command_dsp_meter) |
| 119 | #define SNDRV_FIREWIRE_IOCTL_MOTU_REGISTER_DSP_PARAMETER _IOR('H', 0xfe, struct snd_firewire_motu_register_dsp_parameter) |
| 120 | |
| 121 | #define SNDRV_FIREWIRE_TYPE_DICE 1 |
| 122 | #define SNDRV_FIREWIRE_TYPE_FIREWORKS 2 |
| 123 | #define SNDRV_FIREWIRE_TYPE_BEBOB 3 |
| 124 | #define SNDRV_FIREWIRE_TYPE_OXFW 4 |
| 125 | #define SNDRV_FIREWIRE_TYPE_DIGI00X 5 |
| 126 | #define SNDRV_FIREWIRE_TYPE_TASCAM 6 |
| 127 | #define SNDRV_FIREWIRE_TYPE_MOTU 7 |
| 128 | #define SNDRV_FIREWIRE_TYPE_FIREFACE 8 |
| 129 | |
| 130 | struct snd_firewire_get_info { |
| 131 | unsigned int type; /* SNDRV_FIREWIRE_TYPE_xxx */ |
| 132 | unsigned int card; /* same as fw_cdev_get_info.card */ |
| 133 | unsigned char guid[8]; |
| 134 | char device_name[16]; /* device node in /dev */ |
| 135 | }; |
| 136 | |
| 137 | /* |
| 138 | * SNDRV_FIREWIRE_IOCTL_LOCK prevents the driver from streaming. |
| 139 | * Returns -EBUSY if the driver is already streaming. |
| 140 | */ |
| 141 | |
| 142 | #define SNDRV_FIREWIRE_TASCAM_STATE_COUNT 64 |
| 143 | |
| 144 | struct snd_firewire_tascam_state { |
| 145 | __be32 data[SNDRV_FIREWIRE_TASCAM_STATE_COUNT]; |
| 146 | }; |
| 147 | |
| 148 | /* |
| 149 | * In below MOTU models, software is allowed to control their DSP by accessing to registers. |
| 150 | * - 828mk2 |
| 151 | * - 896hd |
| 152 | * - Traveler |
| 153 | * - 8 pre |
| 154 | * - Ultralite |
| 155 | * - 4 pre |
| 156 | * - Audio Express |
| 157 | * |
| 158 | * On the other hand, the status of DSP is split into specific messages included in the sequence of |
| 159 | * isochronous packet. ALSA firewire-motu driver gathers the messages and allow userspace applications |
| 160 | * to read it via ioctl. In 828mk2, 896hd, and Traveler, hardware meter for all of physical inputs |
| 161 | * are put into the message, while one pair of physical outputs is selected. The selection is done by |
| 162 | * LSB one byte in asynchronous write quadlet transaction to 0x'ffff'f000'0b2c. |
| 163 | * |
| 164 | * I note that V3HD/V4HD uses asynchronous transaction for the purpose. The destination address is |
| 165 | * registered to 0x'ffff'f000'0b38 and '0b3c by asynchronous write quadlet request. The size of |
| 166 | * message differs between 23 and 51 quadlets. For the case, the number of mixer bus can be extended |
| 167 | * up to 12. |
| 168 | */ |
| 169 | |
| 170 | #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_INPUT_COUNT 24 |
| 171 | #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_OUTPUT_COUNT 24 |
| 172 | #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_COUNT \ |
| 173 | (SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_INPUT_COUNT + SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_OUTPUT_COUNT) |
| 174 | |
| 175 | /** |
| 176 | * struct snd_firewire_motu_register_dsp_meter - the container for meter information in DSP |
| 177 | * controlled by register access |
| 178 | * @data: Signal level meters. The mapping between position and input/output channel is |
| 179 | * model-dependent. |
| 180 | * |
| 181 | * The structure expresses the part of DSP status for hardware meter. The u8 storage includes linear |
| 182 | * value for audio signal level between 0x00 and 0x7f. |
| 183 | */ |
| 184 | struct snd_firewire_motu_register_dsp_meter { |
| 185 | __u8 data[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_METER_COUNT]; |
| 186 | }; |
| 187 | |
| 188 | #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT 4 |
| 189 | #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT 20 |
| 190 | #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_INPUT_COUNT 10 |
| 191 | #define SNDRV_FIREWIRE_MOTU_REGISTER_DSP_ALIGNED_INPUT_COUNT (SNDRV_FIREWIRE_MOTU_REGISTER_DSP_INPUT_COUNT + 2) |
| 192 | |
| 193 | /** |
| 194 | * snd_firewire_motu_register_dsp_parameter - the container for parameters of DSP controlled |
| 195 | * by register access. |
| 196 | * @mixer.source.gain: The gain of source to mixer. |
| 197 | * @mixer.source.pan: The L/R balance of source to mixer. |
| 198 | * @mixer.source.flag: The flag of source to mixer, including mute, solo. |
| 199 | * @mixer.source.paired_balance: The L/R balance of paired source to mixer, only for 4 pre and |
| 200 | * Audio Express. |
| 201 | * @mixer.source.paired_width: The width of paired source to mixer, only for 4 pre and |
| 202 | * Audio Express. |
| 203 | * @mixer.output.paired_volume: The volume of paired output from mixer. |
| 204 | * @mixer.output.paired_flag: The flag of paired output from mixer. |
| 205 | * @output.main_paired_volume: The volume of paired main output. |
| 206 | * @output.hp_paired_volume: The volume of paired hp output. |
| 207 | * @output.hp_paired_assignment: The source assigned to paired hp output. |
| 208 | * @output.reserved: Padding for 32 bit alignment for future extension. |
| 209 | * @line_input.boost_flag: The flags of boost for line inputs, only for 828mk2 and Traveler. |
| 210 | * @line_input.nominal_level_flag: The flags of nominal level for line inputs, only for 828mk2 and |
| 211 | * Traveler. |
| 212 | * @line_input.reserved: Padding for 32 bit alignment for future extension. |
| 213 | * @input.gain_and_invert: The value including gain and invert for input, only for Ultralite, 4 pre |
| 214 | * and Audio Express. |
| 215 | * @input.flag: The flag of input; e.g. jack detection, phantom power, and pad, only for Ultralite, |
| 216 | * 4 pre and Audio express. |
| 217 | * @reserved: Padding so that the size of structure is kept to 512 byte, but for future extension. |
| 218 | * |
| 219 | * The structure expresses the set of parameters for DSP controlled by register access. |
| 220 | */ |
| 221 | struct snd_firewire_motu_register_dsp_parameter { |
| 222 | struct { |
| 223 | struct { |
| 224 | __u8 gain[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; |
| 225 | __u8 pan[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; |
| 226 | __u8 flag[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; |
| 227 | __u8 paired_balance[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; |
| 228 | __u8 paired_width[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_SRC_COUNT]; |
| 229 | } source[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT]; |
| 230 | struct { |
| 231 | __u8 paired_volume[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT]; |
| 232 | __u8 paired_flag[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_MIXER_COUNT]; |
| 233 | } output; |
| 234 | } mixer; |
| 235 | struct { |
| 236 | __u8 main_paired_volume; |
| 237 | __u8 hp_paired_volume; |
| 238 | __u8 hp_paired_assignment; |
| 239 | __u8 reserved[5]; |
| 240 | } output; |
| 241 | struct { |
| 242 | __u8 boost_flag; |
| 243 | __u8 nominal_level_flag; |
| 244 | __u8 reserved[6]; |
| 245 | } line_input; |
| 246 | struct { |
| 247 | __u8 gain_and_invert[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_ALIGNED_INPUT_COUNT]; |
| 248 | __u8 flag[SNDRV_FIREWIRE_MOTU_REGISTER_DSP_ALIGNED_INPUT_COUNT]; |
| 249 | } input; |
| 250 | __u8 reserved[64]; |
| 251 | }; |
| 252 | |
| 253 | /* |
| 254 | * In below MOTU models, software is allowed to control their DSP by command in frame of |
| 255 | * asynchronous transaction to 0x'ffff'0001'0000: |
| 256 | * |
| 257 | * - 828 mk3 (FireWire only and Hybrid) |
| 258 | * - 896 mk3 (FireWire only and Hybrid) |
| 259 | * - Ultralite mk3 (FireWire only and Hybrid) |
| 260 | * - Traveler mk3 |
| 261 | * - Track 16 |
| 262 | * |
| 263 | * On the other hand, the states of hardware meter is split into specific messages included in the |
| 264 | * sequence of isochronous packet. ALSA firewire-motu driver gathers the message and allow userspace |
| 265 | * application to read it via ioctl. |
| 266 | */ |
| 267 | |
| 268 | #define SNDRV_FIREWIRE_MOTU_COMMAND_DSP_METER_COUNT 400 |
| 269 | |
| 270 | /** |
| 271 | * struct snd_firewire_motu_command_dsp_meter - the container for meter information in DSP |
| 272 | * controlled by command |
| 273 | * @data: Signal level meters. The mapping between position and signal channel is model-dependent. |
| 274 | * |
| 275 | * The structure expresses the part of DSP status for hardware meter. The 32 bit storage is |
| 276 | * estimated to include IEEE 764 32 bit single precision floating point (binary32) value. It is |
| 277 | * expected to be linear value (not logarithm) for audio signal level between 0.0 and +1.0. |
| 278 | */ |
| 279 | struct snd_firewire_motu_command_dsp_meter { |
| 280 | #ifdef __KERNEL__ |
| 281 | __u32 data[SNDRV_FIREWIRE_MOTU_COMMAND_DSP_METER_COUNT]; |
| 282 | #else |
| 283 | float data[SNDRV_FIREWIRE_MOTU_COMMAND_DSP_METER_COUNT]; |
| 284 | #endif |
| 285 | }; |
| 286 | |
| 287 | #endif /* _UAPI_SOUND_FIREWIRE_H_INCLUDED */ |
| 288 |
Warning: This file is not a C or C++ file. It does not have highlighting.
