LUFA/Drivers/USB/Class/Host/MIDI.c

   1 /*
   2              LUFA Library
   3      Copyright (C) Dean Camera, 2010.
   4
   5   dean [at] fourwalledcubicle [dot] com
   6            www.lufa-lib.org
   7 */
   8
   9 /*
  10   Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)
  11
  12   Permission to use, copy, modify, distribute, and sell this
  13   software and its documentation for any purpose is hereby granted
  14   without fee, provided that the above copyright notice appear in
  15   all copies and that both that the copyright notice and this
  16   permission notice and warranty disclaimer appear in supporting
  17   documentation, and that the name of the author not be used in
  18   advertising or publicity pertaining to distribution of the
  19   software without specific, written prior permission.
  20
  21   The author disclaim all warranties with regard to this
  22   software, including all implied warranties of merchantability
  23   and fitness.  In no event shall the author be liable for any
  24   special, indirect or consequential damages or any damages
  25   whatsoever resulting from loss of use, data or profits, whether
  26   in an action of contract, negligence or other tortious action,
  27   arising out of or in connection with the use or performance of
  28   this software.
  29 */
  30
  31 #define  __INCLUDE_FROM_USB_DRIVER
  32 #include "../../HighLevel/USBMode.h"
  33 #if defined(USB_CAN_BE_HOST)
  34
  35 #define  __INCLUDE_FROM_MIDI_DRIVER
  36 #define  __INCLUDE_FROM_MIDI_HOST_C
  37 #include "MIDI.h"
  38
  39 uint8_t MIDI_Host_ConfigurePipes(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo,
  40                                  uint16_t ConfigDescriptorSize,
  41                                  void* ConfigDescriptorData)
  42 {
  43         USB_Descriptor_Endpoint_t*  DataINEndpoint  = NULL;
  44         USB_Descriptor_Endpoint_t*  DataOUTEndpoint = NULL;
  45         USB_Descriptor_Interface_t* MIDIInterface   = NULL;
  46
  47         memset(&MIDIInterfaceInfo->State, 0x00, sizeof(MIDIInterfaceInfo->State));
  48
  49         if (DESCRIPTOR_TYPE(ConfigDescriptorData) != DTYPE_Configuration)
  50           return MIDI_ENUMERROR_InvalidConfigDescriptor;
  51
  52         while (!(DataINEndpoint) || !(DataOUTEndpoint))
  53         {
  54                 if (!(MIDIInterface) ||
  55                     USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  56                                               DCOMP_MIDI_Host_NextMIDIStreamingDataEndpoint) != DESCRIPTOR_SEARCH_COMP_Found)
  57                 {
  58                         if (USB_GetNextDescriptorComp(&ConfigDescriptorSize, &ConfigDescriptorData,
  59                                                       DCOMP_MIDI_Host_NextMIDIStreamingInterface) != DESCRIPTOR_SEARCH_COMP_Found)
  60                         {
  61                                 return MIDI_ENUMERROR_NoCompatibleInterfaceFound;
  62                         }
  63
  64                         MIDIInterface = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Interface_t);
  65
  66                         DataINEndpoint  = NULL;
  67                         DataOUTEndpoint = NULL;
  68
  69                         continue;
  70                 }
  71
  72                 USB_Descriptor_Endpoint_t* EndpointData = DESCRIPTOR_PCAST(ConfigDescriptorData, USB_Descriptor_Endpoint_t);
  73
  74                 if (EndpointData->EndpointAddress & ENDPOINT_DESCRIPTOR_DIR_IN)
  75                   DataINEndpoint  = EndpointData;
  76                 else
  77                   DataOUTEndpoint = EndpointData;
  78         }
  79
  80         for (uint8_t PipeNum = 1; PipeNum < PIPE_TOTAL_PIPES; PipeNum++)
  81         {
  82                 if (PipeNum == MIDIInterfaceInfo->Config.DataINPipeNumber)
  83                 {
  84                         Pipe_ConfigurePipe(PipeNum, EP_TYPE_BULK, PIPE_TOKEN_IN,
  85                                            DataINEndpoint->EndpointAddress, DataINEndpoint->EndpointSize,
  86                                            MIDIInterfaceInfo->Config.DataINPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  87
  88                         MIDIInterfaceInfo->State.DataINPipeSize = DataINEndpoint->EndpointSize;
  89                 }
  90                 else if (PipeNum == MIDIInterfaceInfo->Config.DataOUTPipeNumber)
  91                 {
  92                         Pipe_ConfigurePipe(PipeNum, EP_TYPE_BULK, PIPE_TOKEN_OUT,
  93                                            DataOUTEndpoint->EndpointAddress, DataOUTEndpoint->EndpointSize,
  94                                            MIDIInterfaceInfo->Config.DataOUTPipeDoubleBank ? PIPE_BANK_DOUBLE : PIPE_BANK_SINGLE);
  95
  96                         MIDIInterfaceInfo->State.DataOUTPipeSize = DataOUTEndpoint->EndpointSize;
  97                 }
  98         }
  99
 100         MIDIInterfaceInfo->State.InterfaceNumber = MIDIInterface->InterfaceNumber;
 101         MIDIInterfaceInfo->State.IsActive = true;
 102
 103         return MIDI_ENUMERROR_NoError;
 104 }
 105
 106 static uint8_t DCOMP_MIDI_Host_NextMIDIStreamingInterface(void* const CurrentDescriptor)
 107 {
 108         USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
 109
 110         if (Header->Type == DTYPE_Interface)
 111         {
 112                 USB_Descriptor_Interface_t* Interface = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Interface_t);
 113
 114                 if ((Interface->Class    == AUDIO_CSCP_AudioClass)            &&
 115                     (Interface->SubClass == AUDIO_CSCP_MIDIStreamingSubclass) &&
 116                     (Interface->Protocol == AUDIO_CSCP_StreamingProtocol))
 117                 {
 118                         return DESCRIPTOR_SEARCH_Found;
 119                 }
 120         }
 121
 122         return DESCRIPTOR_SEARCH_NotFound;
 123 }
 124
 125 static uint8_t DCOMP_MIDI_Host_NextMIDIStreamingDataEndpoint(void* const CurrentDescriptor)
 126 {
 127         USB_Descriptor_Header_t* Header = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Header_t);
 128
 129         if (Header->Type == DTYPE_Endpoint)
 130         {
 131                 USB_Descriptor_Endpoint_t* Endpoint = DESCRIPTOR_PCAST(CurrentDescriptor, USB_Descriptor_Endpoint_t);
 132
 133                 uint8_t EndpointType = (Endpoint->Attributes & EP_TYPE_MASK);
 134
 135                 if ((EndpointType == EP_TYPE_BULK) && !(Pipe_IsEndpointBound(Endpoint->EndpointAddress)))
 136                   return DESCRIPTOR_SEARCH_Found;
 137         }
 138         else if (Header->Type == DTYPE_Interface)
 139         {
 140                 return DESCRIPTOR_SEARCH_Fail;
 141         }
 142
 143         return DESCRIPTOR_SEARCH_NotFound;
 144 }
 145
 146 void MIDI_Host_USBTask(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo)
 147 {
 148         if ((USB_HostState != HOST_STATE_Configured) || !(MIDIInterfaceInfo->State.IsActive))
 149           return;
 150
 151         #if !defined(NO_CLASS_DRIVER_AUTOFLUSH)
 152         MIDI_Host_Flush(MIDIInterfaceInfo);
 153         #endif
 154 }
 155
 156 uint8_t MIDI_Host_Flush(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo)
 157 {
 158         if ((USB_HostState != HOST_STATE_Configured) || !(MIDIInterfaceInfo->State.IsActive))
 159           return PIPE_RWSTREAM_DeviceDisconnected;
 160
 161         uint8_t ErrorCode;
 162
 163         Pipe_SelectPipe(MIDIInterfaceInfo->Config.DataOUTPipeNumber);
 164
 165         if (Pipe_BytesInPipe())
 166         {
 167                 Pipe_ClearOUT();
 168
 169                 if ((ErrorCode = Pipe_WaitUntilReady()) != PIPE_READYWAIT_NoError)
 170                   return ErrorCode;
 171         }
 172
 173         return PIPE_READYWAIT_NoError;
 174 }
 175
 176 uint8_t MIDI_Host_SendEventPacket(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo,
 177                                   MIDI_EventPacket_t* const Event)
 178 {
 179         if ((USB_HostState != HOST_STATE_Configured) || !(MIDIInterfaceInfo->State.IsActive))
 180           return HOST_SENDCONTROL_DeviceDisconnected;
 181
 182         uint8_t ErrorCode;
 183
 184         Pipe_SelectPipe(MIDIInterfaceInfo->Config.DataOUTPipeNumber);
 185
 186         if ((ErrorCode = Pipe_Write_Stream_LE(Event, sizeof(MIDI_EventPacket_t), NO_STREAM_CALLBACK)) != PIPE_RWSTREAM_NoError)
 187           return ErrorCode;
 188
 189         if (!(Pipe_IsReadWriteAllowed()))
 190           Pipe_ClearOUT();
 191
 192         return PIPE_RWSTREAM_NoError;
 193 }
 194
 195 bool MIDI_Host_ReceiveEventPacket(USB_ClassInfo_MIDI_Host_t* const MIDIInterfaceInfo,
 196                                   MIDI_EventPacket_t* const Event)
 197 {
 198         if ((USB_HostState != HOST_STATE_Configured) || !(MIDIInterfaceInfo->State.IsActive))
 199           return HOST_SENDCONTROL_DeviceDisconnected;
 200
 201         Pipe_SelectPipe(MIDIInterfaceInfo->Config.DataINPipeNumber);
 202
 203         if (!(Pipe_IsReadWriteAllowed()))
 204           return false;
 205
 206         Pipe_Read_Stream_LE(Event, sizeof(MIDI_EventPacket_t), NO_STREAM_CALLBACK);
 207
 208         if (!(Pipe_IsReadWriteAllowed()))
 209           Pipe_ClearIN();
 210
 211         return true;
 212 }
 213
 214 #endif
 215