usb_audio.h

Go to the documentation of this file.

/*
 * USB audio class core header
 *
 * Copyright (c) 2020 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_USB_CLASS_AUDIO_H_
#define ZEPHYR_INCLUDE_USB_CLASS_AUDIO_H_
 
#include <zephyr/usb/usb_ch9.h>
#include <zephyr/device.h>
#include <zephyr/net/buf.h>
#include <zephyr/sys/util.h>
 
enum usb_audio_int_subclass_codes {
        USB_AUDIO_SUBCLASS_UNDEFINED    = 0x00,
        USB_AUDIO_AUDIOCONTROL          = 0x01,
        USB_AUDIO_AUDIOSTREAMING        = 0x02,
        USB_AUDIO_MIDISTREAMING         = 0x03
};
 
enum usb_audio_cs_ac_int_desc_subtypes {
        USB_AUDIO_AC_DESCRIPTOR_UNDEFINED       = 0x00,
        USB_AUDIO_HEADER                        = 0x01,
        USB_AUDIO_INPUT_TERMINAL                = 0x02,
        USB_AUDIO_OUTPUT_TERMINAL               = 0x03,
        USB_AUDIO_MIXER_UNIT                    = 0x04,
        USB_AUDIO_SELECTOR_UNIT                 = 0x05,
        USB_AUDIO_FEATURE_UNIT                  = 0x06,
        USB_AUDIO_PROCESSING_UNIT               = 0x07,
        USB_AUDIO_EXTENSION_UNIT                = 0x08
};
 
enum usb_audio_cs_as_int_desc_subtypes {
        USB_AUDIO_AS_DESCRIPTOR_UNDEFINED       = 0x00,
        USB_AUDIO_AS_GENERAL                    = 0x01,
        USB_AUDIO_FORMAT_TYPE                   = 0x02,
        USB_AUDIO_FORMAT_SPECIFIC               = 0x03
};
 
enum usb_audio_cs_req_codes {
        USB_AUDIO_REQUEST_CODE_UNDEFINED        = 0x00,
        USB_AUDIO_SET_CUR                       = 0x01,
        USB_AUDIO_GET_CUR                       = 0x81,
        USB_AUDIO_SET_MIN                       = 0x02,
        USB_AUDIO_GET_MIN                       = 0x82,
        USB_AUDIO_SET_MAX                       = 0x03,
        USB_AUDIO_GET_MAX                       = 0x83,
        USB_AUDIO_SET_RES                       = 0x04,
        USB_AUDIO_GET_RES                       = 0x84,
        USB_AUDIO_SET_MEM                       = 0x05,
        USB_AUDIO_GET_MEM                       = 0x85,
        USB_AUDIO_GET_STAT                      = 0xFF
};
 
enum usb_audio_fucs {
        USB_AUDIO_FU_CONTROL_UNDEFINED          = 0x00,
        USB_AUDIO_FU_MUTE_CONTROL               = 0x01,
        USB_AUDIO_FU_VOLUME_CONTROL             = 0x02,
        USB_AUDIO_FU_BASS_CONTROL               = 0x03,
        USB_AUDIO_FU_MID_CONTROL                = 0x04,
        USB_AUDIO_FU_TREBLE_CONTROL             = 0x05,
        USB_AUDIO_FU_GRAPHIC_EQUALIZER_CONTROL  = 0x06,
        USB_AUDIO_FU_AUTOMATIC_GAIN_CONTROL     = 0x07,
        USB_AUDIO_FU_DELAY_CONTROL              = 0x08,
        USB_AUDIO_FU_BASS_BOOST_CONTROL         = 0x09,
        USB_AUDIO_FU_LOUDNESS_CONTROL           = 0x0A
};
 
enum usb_audio_terminal_types {
        /* USB Terminal Types */
        USB_AUDIO_USB_UNDEFINED   = 0x0100,
        USB_AUDIO_USB_STREAMING   = 0x0101,
        USB_AUDIO_USB_VENDOR_SPEC = 0x01FF,
 
        /* Input Terminal Types */
        USB_AUDIO_IN_UNDEFINED      = 0x0200,
        USB_AUDIO_IN_MICROPHONE     = 0x0201,
        USB_AUDIO_IN_DESKTOP_MIC    = 0x0202,
        USB_AUDIO_IN_PERSONAL_MIC   = 0x0203,
        USB_AUDIO_IN_OM_DIR_MIC     = 0x0204,
        USB_AUDIO_IN_MIC_ARRAY      = 0x0205,
        USB_AUDIO_IN_PROC_MIC_ARRAY = 0x0205,
 
        /* Output Terminal Types */
        USB_AUDIO_OUT_UNDEFINED         = 0x0300,
        USB_AUDIO_OUT_SPEAKER           = 0x0301,
        USB_AUDIO_OUT_HEADPHONES        = 0x0302,
        USB_AUDIO_OUT_HEAD_AUDIO        = 0x0303,
        USB_AUDIO_OUT_DESKTOP_SPEAKER   = 0x0304,
        USB_AUDIO_OUT_ROOM_SPEAKER      = 0x0305,
        USB_AUDIO_OUT_COMM_SPEAKER      = 0x0306,
        USB_AUDIO_OUT_LOW_FREQ_SPEAKER  = 0x0307,
 
        /* Bi-directional Terminal Types */
        USB_AUDIO_IO_UNDEFINED                  = 0x0400,
        USB_AUDIO_IO_HANDSET                    = 0x0401,
        USB_AUDIO_IO_HEADSET                    = 0x0402,
        USB_AUDIO_IO_SPEAKERPHONE_ECHO_NONE     = 0x0403,
        USB_AUDIO_IO_SPEAKERPHONE_ECHO_SUP      = 0x0404,
        USB_AUDIO_IO_SPEAKERPHONE_ECHO_CAN      = 0x0405,
};
 
enum usb_audio_direction {
        USB_AUDIO_IN = 0x00,
        USB_AUDIO_OUT = 0x01
};
 
struct usb_audio_fu_evt {
        enum usb_audio_direction dir;
        enum usb_audio_fucs cs;
        uint8_t channel;
        uint8_t val_len;
        const void *val;
};
 
typedef void (*usb_audio_data_request_cb_t)(const struct device *dev);
 
typedef void (*usb_audio_data_completion_cb_t)(const struct device *dev,
                                               struct net_buf *buffer,
                                               size_t size);
 
typedef void (*usb_audio_feature_updated_cb_t)(const struct device *dev,
                                               const struct usb_audio_fu_evt *evt);
 
struct usb_audio_ops {
        /* Callback called when data could be send */
        usb_audio_data_request_cb_t data_request_cb;
 
        /* Callback called when data were successfully written with sending
         * capable device. Applicable for headset and microphone. Unused for
         * headphones.
         */
        usb_audio_data_completion_cb_t data_written_cb;
 
        /* Callback called when data were successfully received by receive
         * capable device. Applicable for headset and headphones. Unused for
         * microphone.
         */
        usb_audio_data_completion_cb_t data_received_cb;
 
        /* Callback called when features were modified by the Host */
        usb_audio_feature_updated_cb_t feature_update_cb;
};
 
size_t usb_audio_get_in_frame_size(const struct device *dev);
 
void usb_audio_register(const struct device *dev,
                        const struct usb_audio_ops *ops);
 
int usb_audio_send(const struct device *dev, struct net_buf *buffer,
                   size_t len);
 
#endif /* ZEPHYR_INCLUDE_USB_CLASS_AUDIO_H_ */