/elec/audio-switcher : revision 1

1

/*

2

LUFA Library

3

Copyright (C) Dean Camera, 2012.

4

5

dean [at] fourwalledcubicle [dot] com

6

www.lufa-lib.org

7

*/

8

9

/*

10

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

/** \file

32

*

33

* USB Device Descriptors, for library use when in USB device mode. Descriptors are special

34

* computer-readable structures which the host requests upon device enumeration, to determine

35

* the device's capabilities and functions.

36

*/

37

38

#include "Descriptors.h"

39

40

41

/** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall

42

* device characteristics, including the supported USB version, control endpoint size and the

43

* number of device configurations. The descriptor is read out by the USB host when the enumeration

44

* process begins.

45

*/

46

const USB_Descriptor_Device_t PROGMEM DeviceDescriptor =

47

{

48

.Header = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},

49

50

.USBSpecification = VERSION_BCD(01.10),

51

.Class = CDC_CSCP_CDCClass,

52

.SubClass = CDC_CSCP_NoSpecificSubclass,

53

.Protocol = CDC_CSCP_NoSpecificProtocol,

54

55

.Endpoint0Size = FIXED_CONTROL_ENDPOINT_SIZE,

56

57

.VendorID = 0x03EB,

58

.ProductID = 0x2044,

59

.ReleaseNumber = VERSION_BCD(00.01),

60

61

.ManufacturerStrIndex = 0x01,

62

.ProductStrIndex = 0x02,

63

.SerialNumStrIndex = USE_INTERNAL_SERIAL,

64

65

.NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS

66

};

67

68

/** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage

69

* of the device in one of its supported configurations, including information about any device interfaces

70

* and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting

71

* a configuration so that the host may correctly communicate with the USB device.

72

*/

73

const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =

74

{

75

.Config =

76

{

77

.Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},

78

79

.TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),

80

.TotalInterfaces = 2,

81

82

.ConfigurationNumber = 1,

83

.ConfigurationStrIndex = NO_DESCRIPTOR,

84

85

.ConfigAttributes = (USB_CONFIG_ATTR_RESERVED | USB_CONFIG_ATTR_SELFPOWERED),

86

87

.MaxPowerConsumption = USB_CONFIG_POWER_MA(100)

88

},

89

90

.CDC_CCI_Interface =

91

{

92

.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

93

94

.InterfaceNumber = 0,

95

.AlternateSetting = 0,

96

97

.TotalEndpoints = 1,

98

99

.Class = CDC_CSCP_CDCClass,

100

.SubClass = CDC_CSCP_ACMSubclass,

101

.Protocol = CDC_CSCP_ATCommandProtocol,

102

103

.InterfaceStrIndex = NO_DESCRIPTOR

104

},

105

106

.CDC_Functional_Header =

107

{

108

.Header = {.Size = sizeof(USB_CDC_Descriptor_FunctionalHeader_t), .Type = DTYPE_CSInterface},

109

.Subtype = CDC_DSUBTYPE_CSInterface_Header,

110

111

.CDCSpecification = VERSION_BCD(01.10),

112

},

113

114

.CDC_Functional_ACM =

115

{

116

.Header = {.Size = sizeof(USB_CDC_Descriptor_FunctionalACM_t), .Type = DTYPE_CSInterface},

117

.Subtype = CDC_DSUBTYPE_CSInterface_ACM,

118

119

.Capabilities = 0x06,

120

},

121

122

.CDC_Functional_Union =

123

{

124

.Header = {.Size = sizeof(USB_CDC_Descriptor_FunctionalUnion_t), .Type = DTYPE_CSInterface},

125

.Subtype = CDC_DSUBTYPE_CSInterface_Union,

126

127

.MasterInterfaceNumber = 0,

128

.SlaveInterfaceNumber = 1,

129

},

130

131

.CDC_NotificationEndpoint =

132

{

133

.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},

134

135

.EndpointAddress = CDC_NOTIFICATION_EPADDR,

136

.Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),

137

.EndpointSize = CDC_NOTIFICATION_EPSIZE,

138

.PollingIntervalMS = 0xFF

139

},

140

141

.CDC_DCI_Interface =

142

{

143

.Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},

144

145

.InterfaceNumber = 1,

146

.AlternateSetting = 0,

147

148

.TotalEndpoints = 2,

149

150

.Class = CDC_CSCP_CDCDataClass,

151

.SubClass = CDC_CSCP_NoDataSubclass,

152

.Protocol = CDC_CSCP_NoDataProtocol,

153

154

.InterfaceStrIndex = NO_DESCRIPTOR

155

},

156

157

.CDC_DataOutEndpoint =

158

{

159

.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},

160

161

.EndpointAddress = CDC_RX_EPADDR,

162

.Attributes = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),

163

.EndpointSize = CDC_TXRX_EPSIZE,

164

.PollingIntervalMS = 0x05

165

},

166

167

.CDC_DataInEndpoint =

168

{

169

.Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},

170

171

.EndpointAddress = CDC_TX_EPADDR,

172

.Attributes = (EP_TYPE_BULK | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),

173

.EndpointSize = CDC_TXRX_EPSIZE,

174

.PollingIntervalMS = 0x05

175

}

176

};

177

178

/** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests

179

* the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate

180

* via the language ID table available at USB.org what languages the device supports for its string descriptors.

181

*/

182

const USB_Descriptor_String_t PROGMEM LanguageString =

183

{

184

.Header = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},

185

186

.UnicodeString = {LANGUAGE_ID_ENG}

187

};

188

189

/** Manufacturer descriptor string. This is a Unicode string containing the manufacturer's details in human readable

190

* form, and is read out upon request by the host when the appropriate string ID is requested, listed in the Device

191

* Descriptor.

192

*/

193

const USB_Descriptor_String_t PROGMEM ManufacturerString =

194

{

195

.Header = {.Size = USB_STRING_LEN(11), .Type = DTYPE_String},

196

197

.UnicodeString = L"Dean Camera"

198

};

199

200

/** Product descriptor string. This is a Unicode string containing the product's details in human readable form,

201

* and is read out upon request by the host when the appropriate string ID is requested, listed in the Device

202

* Descriptor.

203

*/

204

const USB_Descriptor_String_t PROGMEM ProductString =

205

{

206

.Header = {.Size = USB_STRING_LEN(13), .Type = DTYPE_String},

207

208

.UnicodeString = L"LUFA CDC Demo"

209

};

210

211

/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"

212

* documentation) by the application code so that the address and size of a requested descriptor can be given

213

* to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function

214

* is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the

215

* USB host.

216

*/

217

uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,

218

const uint8_t wIndex,

219

const void** const DescriptorAddress)

220

{

221

const uint8_t DescriptorType = (wValue >> 8);

222

const uint8_t DescriptorNumber = (wValue & 0xFF);

223

224

const void* Address = NULL;

225

uint16_t Size = NO_DESCRIPTOR;

226

227

switch (DescriptorType)

228

{

229

case DTYPE_Device:

230

Address = &DeviceDescriptor;

231

Size = sizeof(USB_Descriptor_Device_t);

232

break;

233

case DTYPE_Configuration:

234

Address = &ConfigurationDescriptor;

235

Size = sizeof(USB_Descriptor_Configuration_t);

236

break;

237

case DTYPE_String:

238

switch (DescriptorNumber)

239

{

240

case 0x00:

241

Address = &LanguageString;

242

Size = pgm_read_byte(&LanguageString.Header.Size);

243

break;

244

case 0x01:

245

Address = &ManufacturerString;

246

Size = pgm_read_byte(&ManufacturerString.Header.Size);

247

break;

248

case 0x02:

249

Address = &ProductString;

250

Size = pgm_read_byte(&ProductString.Header.Size);

251

break;

252

}

253

254

break;

255

}

256

257

*DescriptorAddress = Address;

258

return Size;

259

}

260