usbdaudio.h

Go to the documentation of this file.

//*****************************************************************************
//
// usbdaudio.h - USB audio device class driver.
//
// Copyright (c) 2009-2017 Texas Instruments Incorporated.  All rights reserved.
// Software License Agreement
// 
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
// 
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
// 
//
//*****************************************************************************

#ifndef __USBDAUDIO_H__
#define __USBDAUDIO_H__

//*****************************************************************************
//
// If building with a C++ compiler, make all of the definitions in this header
// have a C binding.
//
//*****************************************************************************
#ifdef __cplusplus
extern "C"
{
#endif

//*****************************************************************************
//
//
//*****************************************************************************

typedef void (* tUSBAudioBufferCallback)(void *pvBuffer, uint32_t ui32Param,
                                         uint32_t ui32Event);

//*****************************************************************************
//
// PRIVATE
//
// This structure defines the private instance data and state variables for the
// audio device class.  The memory for this structure is pointed to by
// the pi16PrivateData field in the tUSBDAudioDevice structure passed on
// USBDAudioInit() and should not be modified by any code outside of the audio
// device.
//
//*****************************************************************************
typedef struct
{
    //
    // Base address for the USB controller.
    //
    uint32_t ui32USBBase;

    //
    // The device info to interact with the lower level DCD code.
    //
    tDeviceInfo sDevInfo;

    //
    // The maximum volume expressed as an 8.8 signed value.
    //
    int16_t i16VolumeMax;

    //
    // The minimum volume expressed as an 8.8 signed value.
    //
    int16_t i16VolumeMin;

    //
    // The minimum volume step expressed as an 8.8 signed value.
    //
    int16_t i16VolumeStep;

    struct
    {
        //
        // Pointer to a buffer provided by caller.
        //
        void *pvData;

        //
        // Size of the data area provided in pvData in bytes.
        //
        uint32_t ui32Size;

        //
        // Number of valid bytes copied into the pvData area.
        //
        uint32_t ui32NumBytes;

        //
        // The buffer callback for this function.
        //
        tUSBAudioBufferCallback pfnCallback;
    }
    sBuffer;

    //
    // Pending request type.
    //
    uint16_t ui16RequestType;

    //
    // Pending request.
    //
    uint8_t ui8Request;

    //
    // Pending update value.
    //
    uint16_t ui16Update;

    //
    // Current Volume setting.
    //
    int16_t i16Volume;

    //
    // Current Mute setting.
    //
    uint8_t ui8Mute;

    //
    // Current Sample rate, this is not writable but the host will try.
    //
    uint32_t ui32SampleRate;

    //
    // The OUT endpoint in use by this instance.
    //
    uint8_t ui8OUTEndpoint;

    //
    // The OUT endpoint DMA channel in use by this instance.
    //
    uint8_t ui8OUTDMA;

    //
    // The control interface number associated with this instance.
    //
    uint8_t ui8InterfaceControl;

    //
    // The audio interface number associated with this instance.
    //
    uint8_t ui8InterfaceAudio;

    //
    // A copy of the DMA instance data used with calls to USBLibDMA functions.
    //
    tUSBDMAInstance *psDMAInstance;
}
tAudioInstance;

//*****************************************************************************
//
// This is the size of the g_pui8IADAudioDescriptor array in bytes.
//
//*****************************************************************************
#define AUDIODESCRIPTOR_SIZE    (8)

//*****************************************************************************
//
// This is the size of the g_pui8AudioControlInterface array in bytes.
//
//*****************************************************************************
#define CONTROLINTERFACE_SIZE   (52)

//*****************************************************************************
//
// This is the size of the g_pui8AudioStreamInterface array in bytes.
//
//*****************************************************************************
#define STREAMINTERFACE_SIZE    (52)

//*****************************************************************************
//
//
//*****************************************************************************
#define COMPOSITE_DAUDIO_SIZE   (AUDIODESCRIPTOR_SIZE +                       \
                                 CONTROLINTERFACE_SIZE + STREAMINTERFACE_SIZE)

//*****************************************************************************
//
//
//*****************************************************************************
typedef struct
{
    //
    //
    const uint16_t ui16VID;

    //
    //
    const uint16_t ui16PID;

    //
    //
    const char pcVendor[8];

    //
    //
    const char pcProduct[16];

    //
    //
    const char pcVersion[4];

    //
    //
    const uint16_t ui16MaxPowermA;

    //
    //
    const uint8_t ui8PwrAttributes;

    //
    //
    const tUSBCallback pfnCallback;

    //
    //
    const uint8_t * const *ppui8StringDescriptors;

    //
    //
    const uint32_t ui32NumStringDescriptors;

    //
    //
    const int16_t i16VolumeMax;

    //
    //
    const int16_t i16VolumeMin;

    //
    //
    const int16_t i16VolumeStep;

    //
    //
    tAudioInstance sPrivateData;
}
tUSBDAudioDevice;

//*****************************************************************************
//
// Audio specific device class driver events
//
//*****************************************************************************

//*****************************************************************************
//
//
//*****************************************************************************
#define USBD_AUDIO_EVENT_IDLE   (USBD_AUDIO_EVENT_BASE + 0)

//*****************************************************************************
//
//
//*****************************************************************************
#define USBD_AUDIO_EVENT_ACTIVE (USBD_AUDIO_EVENT_BASE + 1)

//*****************************************************************************
//
//
//*****************************************************************************
#define USBD_AUDIO_EVENT_DATAOUT (USBD_AUDIO_EVENT_BASE + 2)

//*****************************************************************************
//
//
//*****************************************************************************
#define USBD_AUDIO_EVENT_VOLUME (USBD_AUDIO_EVENT_BASE + 4)

//*****************************************************************************
//
//
//*****************************************************************************
#define USBD_AUDIO_EVENT_MUTE   (USBD_AUDIO_EVENT_BASE + 5)

//*****************************************************************************
//
// API Function Prototypes
//
//*****************************************************************************
extern void *USBDAudioInit(uint32_t ui32Index,
                           tUSBDAudioDevice *psAudioDevice);
extern void *USBDAudioCompositeInit(uint32_t ui32Index,
                                    tUSBDAudioDevice *psAudioDevice,
                                    tCompositeEntry *psCompEntry);
extern void USBDAudioTerm(void *pvAudioDevice);
extern int32_t USBAudioBufferOut(void *pvAudioDevice, void *pvBuffer,
                                 uint32_t ui32Size,
                                 tUSBAudioBufferCallback pfnCallback);

//*****************************************************************************
//
// Close the Doxygen group.
//
//*****************************************************************************

//*****************************************************************************
//
// Mark the end of the C bindings section for C++ compilers.
//
//*****************************************************************************
#ifdef __cplusplus
}
#endif

#endif