Revision 6ebafa20

View differences:

Descriptors.c
1
/*
2
             LUFA Library
3
     Copyright (C) Dean Camera, 2011.
4

  
5
  dean [at] fourwalledcubicle [dot] com
6
           www.lufa-lib.org
7
*/
8

  
9
/*
10
  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
11
  Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
12

  
13
  Permission to use, copy, modify, distribute, and sell this
14
  software and its documentation for any purpose is hereby granted
15
  without fee, provided that the above copyright notice appear in
16
  all copies and that both that the copyright notice and this
17
  permission notice and warranty disclaimer appear in supporting
18
  documentation, and that the name of the author not be used in
19
  advertising or publicity pertaining to distribution of the
20
  software without specific, written prior permission.
21

  
22
  The author disclaim all warranties with regard to this
23
  software, including all implied warranties of merchantability
24
  and fitness.  In no event shall the author be liable for any
25
  special, indirect or consequential damages or any damages
26
  whatsoever resulting from loss of use, data or profits, whether
27
  in an action of contract, negligence or other tortious action,
28
  arising out of or in connection with the use or performance of
29
  this software.
30
*/
31

  
32
/** \file
33
 *
34
 *  USB Device Descriptors, for library use when in USB device mode. Descriptors are special
35
 *  computer-readable structures which the host requests upon device enumeration, to determine
36
 *  the device's capabilities and functions.
37
 */
38

  
39
#include "Descriptors.h"
40

  
41
/** HID class report descriptor. This is a special descriptor constructed with values from the
42
 *  USBIF HID class specification to describe the reports and capabilities of the HID device. This
43
 *  descriptor is parsed by the host and its contents used to determine what data (and in what encoding)
44
 *  the device will send, and what it may be sent back from the host. Refer to the HID specification for
45
 *  more details on HID report descriptors.
46
 */
47
const USB_Descriptor_HIDReport_Datatype_t PROGMEM KeyboardReport[] =
48
{
49
	HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
50
	HID_RI_USAGE(8, 0x06), /* Keyboard */
51
	HID_RI_COLLECTION(8, 0x01), /* Application */
52
	    HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
53
	    HID_RI_USAGE_MINIMUM(8, 0xE0), /* Keyboard Left Control */
54
	    HID_RI_USAGE_MAXIMUM(8, 0xE7), /* Keyboard Right GUI */
55
	    HID_RI_LOGICAL_MINIMUM(8, 0x00),
56
	    HID_RI_LOGICAL_MAXIMUM(8, 0x01),
57
	    HID_RI_REPORT_SIZE(8, 0x01),
58
	    HID_RI_REPORT_COUNT(8, 0x08),
59
	    HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
60
	    HID_RI_REPORT_COUNT(8, 0x01),
61
	    HID_RI_REPORT_SIZE(8, 0x08),
62
	    HID_RI_INPUT(8, HID_IOF_CONSTANT),
63
	    HID_RI_USAGE_PAGE(8, 0x08), /* LEDs */
64
	    HID_RI_USAGE_MINIMUM(8, 0x01), /* Num Lock */
65
	    HID_RI_USAGE_MAXIMUM(8, 0x05), /* Kana */
66
	    HID_RI_REPORT_COUNT(8, 0x05),
67
	    HID_RI_REPORT_SIZE(8, 0x01),
68
	    HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
69
	    HID_RI_REPORT_COUNT(8, 0x01),
70
	    HID_RI_REPORT_SIZE(8, 0x03),
71
	    HID_RI_OUTPUT(8, HID_IOF_CONSTANT),
72
	    HID_RI_LOGICAL_MINIMUM(8, 0x00),
73
	    HID_RI_LOGICAL_MAXIMUM(8, 0x65),
74
	    HID_RI_USAGE_PAGE(8, 0x07), /* Keyboard */
75
	    HID_RI_USAGE_MINIMUM(8, 0x00), /* Reserved (no event indicated) */
76
	    HID_RI_USAGE_MAXIMUM(8, 0x65), /* Keyboard Application */
77
	    HID_RI_REPORT_COUNT(8, 0x06),
78
	    HID_RI_REPORT_SIZE(8, 0x08),
79
	    HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
80
	HID_RI_END_COLLECTION(0),
81
};
82

  
83
/** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall
84
 *  device characteristics, including the supported USB version, control endpoint size and the
85
 *  number of device configurations. The descriptor is read out by the USB host when the enumeration
86
 *  process begins.
87
 */
88
const USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
89
{
90
	.Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
91

  
92
	.USBSpecification       = VERSION_BCD(01.10),
93
	.Class                  = USB_CSCP_NoDeviceClass,
94
	.SubClass               = USB_CSCP_NoDeviceSubclass,
95
	.Protocol               = USB_CSCP_NoDeviceProtocol,
96

  
97
	.Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,
98

  
99
	.VendorID               = 0x03EB,
100
	.ProductID              = 0x2042,
101
	.ReleaseNumber          = VERSION_BCD(00.01),
102

  
103
	.ManufacturerStrIndex   = 0x01,
104
	.ProductStrIndex        = 0x02,
105
	.SerialNumStrIndex      = NO_DESCRIPTOR,
106

  
107
	.NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
108
};
109

  
110
/** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage
111
 *  of the device in one of its supported configurations, including information about any device interfaces
112
 *  and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting
113
 *  a configuration so that the host may correctly communicate with the USB device.
114
 */
115
const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
116
{
117
	.Config =
118
		{
119
			.Header                 = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
120

  
121
			.TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
122
			.TotalInterfaces        = 1,
123

  
124
			.ConfigurationNumber    = 1,
125
			.ConfigurationStrIndex  = NO_DESCRIPTOR,
126

  
127
			.ConfigAttributes       = (USB_CONFIG_ATTR_BUSPOWERED | USB_CONFIG_ATTR_SELFPOWERED),
128

  
129
			.MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
130
		},
131

  
132
	.HID_Interface =
133
		{
134
			.Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
135

  
136
			.InterfaceNumber        = 0x00,
137
			.AlternateSetting       = 0x00,
138

  
139
			.TotalEndpoints         = 2,
140

  
141
			.Class                  = HID_CSCP_HIDClass,
142
			.SubClass               = HID_CSCP_BootSubclass,
143
			.Protocol               = HID_CSCP_KeyboardBootProtocol,
144

  
145
			.InterfaceStrIndex      = NO_DESCRIPTOR
146
		},
147

  
148
	.HID_KeyboardHID =
149
		{
150
			.Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
151

  
152
			.HIDSpec                = VERSION_BCD(01.11),
153
			.CountryCode            = 0x00,
154
			.TotalReportDescriptors = 1,
155
			.HIDReportType          = HID_DTYPE_Report,
156
			.HIDReportLength        = sizeof(KeyboardReport)
157
		},
158

  
159
	.HID_ReportINEndpoint =
160
		{
161
			.Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
162

  
163
			.EndpointAddress        = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM),
164
			.Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
165
			.EndpointSize           = KEYBOARD_EPSIZE,
166
			.PollingIntervalMS      = 0x01
167
		},
168

  
169
	.HID_ReportOUTEndpoint =
170
		{
171
			.Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
172

  
173
			.EndpointAddress        = (ENDPOINT_DIR_OUT | KEYBOARD_OUT_EPNUM),
174
			.Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
175
			.EndpointSize           = KEYBOARD_EPSIZE,
176
			.PollingIntervalMS      = 0x01
177
		}
178
};
179

  
180
/** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests
181
 *  the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate
182
 *  via the language ID table available at USB.org what languages the device supports for its string descriptors.
183
 */
184
const USB_Descriptor_String_t PROGMEM LanguageString =
185
{
186
	.Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
187

  
188
	.UnicodeString          = {LANGUAGE_ID_ENG}
189
};
190

  
191
/** Manufacturer descriptor string. This is a Unicode string containing the manufacturer's details in human readable
192
 *  form, and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
193
 *  Descriptor.
194
 */
195
const USB_Descriptor_String_t PROGMEM ManufacturerString =
196
{
197
	.Header                 = {.Size = USB_STRING_LEN(8), .Type = DTYPE_String},
198

  
199
	.UnicodeString          = L"imp tech"
200
};
201

  
202
/** Product descriptor string. This is a Unicode string containing the product's details in human readable form,
203
 *  and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
204
 *  Descriptor.
205
 */
206
const USB_Descriptor_String_t PROGMEM ProductString =
207
{
208
	.Header                 = {.Size = USB_STRING_LEN(10), .Type = DTYPE_String},
209

  
210
	.UnicodeString          = L"tasta v0.2"
211
};
212

  
213
/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
214
 *  documentation) by the application code so that the address and size of a requested descriptor can be given
215
 *  to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
216
 *  is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
217
 *  USB host.
218
 */
219
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
220
                                    const uint8_t wIndex,
221
                                    const void** const DescriptorAddress)
222
{
223
	const uint8_t  DescriptorType   = (wValue >> 8);
224
	const uint8_t  DescriptorNumber = (wValue & 0xFF);
225

  
226
	const void* Address = NULL;
227
	uint16_t    Size    = NO_DESCRIPTOR;
228

  
229
	switch (DescriptorType)
230
	{
231
		case DTYPE_Device:
232
			Address = &DeviceDescriptor;
233
			Size    = sizeof(USB_Descriptor_Device_t);
234
			break;
235
		case DTYPE_Configuration:
236
			Address = &ConfigurationDescriptor;
237
			Size    = sizeof(USB_Descriptor_Configuration_t);
238
			break;
239
		case DTYPE_String:
240
			switch (DescriptorNumber)
241
			{
242
				case 0x00:
243
					Address = &LanguageString;
244
					Size    = pgm_read_byte(&LanguageString.Header.Size);
245
					break;
246
				case 0x01:
247
					Address = &ManufacturerString;
248
					Size    = pgm_read_byte(&ManufacturerString.Header.Size);
249
					break;
250
				case 0x02:
251
					Address = &ProductString;
252
					Size    = pgm_read_byte(&ProductString.Header.Size);
253
					break;
254
			}
255

  
256
			break;
257
		case HID_DTYPE_HID:
258
			Address = &ConfigurationDescriptor.HID_KeyboardHID;
259
			Size    = sizeof(USB_HID_Descriptor_HID_t);
260
			break;
261
		case HID_DTYPE_Report:
262
			Address = &KeyboardReport;
263
			Size    = sizeof(KeyboardReport);
264
			break;
265
	}
266

  
267
	*DescriptorAddress = Address;
268
	return Size;
269
}
270

  
1
/*
2
             LUFA Library
3
     Copyright (C) Dean Camera, 2011.
4

  
5
  dean [at] fourwalledcubicle [dot] com
6
           www.lufa-lib.org
7
*/
8

  
9
/*
10
  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
11
  Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
12

  
13
  Permission to use, copy, modify, distribute, and sell this
14
  software and its documentation for any purpose is hereby granted
15
  without fee, provided that the above copyright notice appear in
16
  all copies and that both that the copyright notice and this
17
  permission notice and warranty disclaimer appear in supporting
18
  documentation, and that the name of the author not be used in
19
  advertising or publicity pertaining to distribution of the
20
  software without specific, written prior permission.
21

  
22
  The author disclaim all warranties with regard to this
23
  software, including all implied warranties of merchantability
24
  and fitness.  In no event shall the author be liable for any
25
  special, indirect or consequential damages or any damages
26
  whatsoever resulting from loss of use, data or profits, whether
27
  in an action of contract, negligence or other tortious action,
28
  arising out of or in connection with the use or performance of
29
  this software.
30
*/
31

  
32
/** \file
33
 *
34
 *  USB Device Descriptors, for library use when in USB device mode. Descriptors are special
35
 *  computer-readable structures which the host requests upon device enumeration, to determine
36
 *  the device's capabilities and functions.
37
 */
38

  
39
#include "Descriptors.h"
40

  
41
/** HID class report descriptor. This is a special descriptor constructed with values from the
42
 *  USBIF HID class specification to describe the reports and capabilities of the HID device. This
43
 *  descriptor is parsed by the host and its contents used to determine what data (and in what encoding)
44
 *  the device will send, and what it may be sent back from the host. Refer to the HID specification for
45
 *  more details on HID report descriptors.
46
 */
47
const USB_Descriptor_HIDReport_Datatype_t PROGMEM KeyboardReport[] =
48
{
49
	HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
50
	HID_RI_USAGE(8, 0x06), /* Keyboard */
51
	HID_RI_COLLECTION(8, 0x01), /* Application */
52
	    HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
53
	    HID_RI_USAGE_MINIMUM(8, 0xE0), /* Keyboard Left Control */
54
	    HID_RI_USAGE_MAXIMUM(8, 0xE7), /* Keyboard Right GUI */
55
	    HID_RI_LOGICAL_MINIMUM(8, 0x00),
56
	    HID_RI_LOGICAL_MAXIMUM(8, 0x01),
57
	    HID_RI_REPORT_SIZE(8, 0x01),
58
	    HID_RI_REPORT_COUNT(8, 0x08),
59
	    HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
60
	    HID_RI_REPORT_COUNT(8, 0x01),
61
	    HID_RI_REPORT_SIZE(8, 0x08),
62
	    HID_RI_INPUT(8, HID_IOF_CONSTANT),
63
	    HID_RI_USAGE_PAGE(8, 0x08), /* LEDs */
64
	    HID_RI_USAGE_MINIMUM(8, 0x01), /* Num Lock */
65
	    HID_RI_USAGE_MAXIMUM(8, 0x05), /* Kana */
66
	    HID_RI_REPORT_COUNT(8, 0x05),
67
	    HID_RI_REPORT_SIZE(8, 0x01),
68
	    HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
69
	    HID_RI_REPORT_COUNT(8, 0x01),
70
	    HID_RI_REPORT_SIZE(8, 0x03),
71
	    HID_RI_OUTPUT(8, HID_IOF_CONSTANT),
72
	    HID_RI_LOGICAL_MINIMUM(8, 0x00),
73
	    HID_RI_LOGICAL_MAXIMUM(8, 0x65),
74
	    HID_RI_USAGE_PAGE(8, 0x07), /* Keyboard */
75
	    HID_RI_USAGE_MINIMUM(8, 0x00), /* Reserved (no event indicated) */
76
	    HID_RI_USAGE_MAXIMUM(8, 0x65), /* Keyboard Application */
77
	    HID_RI_REPORT_COUNT(8, 0x06),
78
	    HID_RI_REPORT_SIZE(8, 0x08),
79
	    HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
80
	HID_RI_END_COLLECTION(0),
81
};
82

  
83
/** Device descriptor structure. This descriptor, located in FLASH memory, describes the overall
84
 *  device characteristics, including the supported USB version, control endpoint size and the
85
 *  number of device configurations. The descriptor is read out by the USB host when the enumeration
86
 *  process begins.
87
 */
88
const USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
89
{
90
	.Header                 = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
91

  
92
	.USBSpecification       = VERSION_BCD(01.10),
93
	.Class                  = USB_CSCP_NoDeviceClass,
94
	.SubClass               = USB_CSCP_NoDeviceSubclass,
95
	.Protocol               = USB_CSCP_NoDeviceProtocol,
96

  
97
	.Endpoint0Size          = FIXED_CONTROL_ENDPOINT_SIZE,
98

  
99
	.VendorID               = 0x03EB,
100
	.ProductID              = 0x2042,
101
	.ReleaseNumber          = VERSION_BCD(00.01),
102

  
103
	.ManufacturerStrIndex   = 0x01,
104
	.ProductStrIndex        = 0x02,
105
	.SerialNumStrIndex      = NO_DESCRIPTOR,
106

  
107
	.NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
108
};
109

  
110
/** Configuration descriptor structure. This descriptor, located in FLASH memory, describes the usage
111
 *  of the device in one of its supported configurations, including information about any device interfaces
112
 *  and endpoints. The descriptor is read out by the USB host during the enumeration process when selecting
113
 *  a configuration so that the host may correctly communicate with the USB device.
114
 */
115
const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
116
{
117
	.Config =
118
		{
119
			.Header                 = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
120

  
121
			.TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
122
			.TotalInterfaces        = 1,
123

  
124
			.ConfigurationNumber    = 1,
125
			.ConfigurationStrIndex  = NO_DESCRIPTOR,
126

  
127
			.ConfigAttributes       = (USB_CONFIG_ATTR_BUSPOWERED | USB_CONFIG_ATTR_SELFPOWERED),
128

  
129
			.MaxPowerConsumption    = USB_CONFIG_POWER_MA(100)
130
		},
131

  
132
	.HID_Interface =
133
		{
134
			.Header                 = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
135

  
136
			.InterfaceNumber        = 0x00,
137
			.AlternateSetting       = 0x00,
138

  
139
			.TotalEndpoints         = 2,
140

  
141
			.Class                  = HID_CSCP_HIDClass,
142
			.SubClass               = HID_CSCP_BootSubclass,
143
			.Protocol               = HID_CSCP_KeyboardBootProtocol,
144

  
145
			.InterfaceStrIndex      = NO_DESCRIPTOR
146
		},
147

  
148
	.HID_KeyboardHID =
149
		{
150
			.Header                 = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
151

  
152
			.HIDSpec                = VERSION_BCD(01.11),
153
			.CountryCode            = 0x00,
154
			.TotalReportDescriptors = 1,
155
			.HIDReportType          = HID_DTYPE_Report,
156
			.HIDReportLength        = sizeof(KeyboardReport)
157
		},
158

  
159
	.HID_ReportINEndpoint =
160
		{
161
			.Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
162

  
163
			.EndpointAddress        = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM),
164
			.Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
165
			.EndpointSize           = KEYBOARD_EPSIZE,
166
			.PollingIntervalMS      = 0x01
167
		},
168

  
169
	.HID_ReportOUTEndpoint =
170
		{
171
			.Header                 = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
172

  
173
			.EndpointAddress        = (ENDPOINT_DIR_OUT | KEYBOARD_OUT_EPNUM),
174
			.Attributes             = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
175
			.EndpointSize           = KEYBOARD_EPSIZE,
176
			.PollingIntervalMS      = 0x01
177
		}
178
};
179

  
180
/** Language descriptor structure. This descriptor, located in FLASH memory, is returned when the host requests
181
 *  the string descriptor with index 0 (the first index). It is actually an array of 16-bit integers, which indicate
182
 *  via the language ID table available at USB.org what languages the device supports for its string descriptors.
183
 */
184
const USB_Descriptor_String_t PROGMEM LanguageString =
185
{
186
	.Header                 = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
187

  
188
	.UnicodeString          = {LANGUAGE_ID_ENG}
189
};
190

  
191
/** Manufacturer descriptor string. This is a Unicode string containing the manufacturer's details in human readable
192
 *  form, and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
193
 *  Descriptor.
194
 */
195
const USB_Descriptor_String_t PROGMEM ManufacturerString =
196
{
197
	.Header                 = {.Size = USB_STRING_LEN(8), .Type = DTYPE_String},
198

  
199
	.UnicodeString          = L"imp tech"
200
};
201

  
202
/** Product descriptor string. This is a Unicode string containing the product's details in human readable form,
203
 *  and is read out upon request by the host when the appropriate string ID is requested, listed in the Device
204
 *  Descriptor.
205
 */
206
const USB_Descriptor_String_t PROGMEM ProductString =
207
{
208
	.Header                 = {.Size = USB_STRING_LEN(10), .Type = DTYPE_String},
209

  
210
	.UnicodeString          = L"tasta v0.2"
211
};
212

  
213
/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
214
 *  documentation) by the application code so that the address and size of a requested descriptor can be given
215
 *  to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
216
 *  is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
217
 *  USB host.
218
 */
219
uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
220
                                    const uint8_t wIndex,
221
                                    const void** const DescriptorAddress)
222
{
223
	const uint8_t  DescriptorType   = (wValue >> 8);
224
	const uint8_t  DescriptorNumber = (wValue & 0xFF);
225

  
226
	const void* Address = NULL;
227
	uint16_t    Size    = NO_DESCRIPTOR;
228

  
229
	switch (DescriptorType)
230
	{
231
		case DTYPE_Device:
232
			Address = &DeviceDescriptor;
233
			Size    = sizeof(USB_Descriptor_Device_t);
234
			break;
235
		case DTYPE_Configuration:
236
			Address = &ConfigurationDescriptor;
237
			Size    = sizeof(USB_Descriptor_Configuration_t);
238
			break;
239
		case DTYPE_String:
240
			switch (DescriptorNumber)
241
			{
242
				case 0x00:
243
					Address = &LanguageString;
244
					Size    = pgm_read_byte(&LanguageString.Header.Size);
245
					break;
246
				case 0x01:
247
					Address = &ManufacturerString;
248
					Size    = pgm_read_byte(&ManufacturerString.Header.Size);
249
					break;
250
				case 0x02:
251
					Address = &ProductString;
252
					Size    = pgm_read_byte(&ProductString.Header.Size);
253
					break;
254
			}
255

  
256
			break;
257
		case HID_DTYPE_HID:
258
			Address = &ConfigurationDescriptor.HID_KeyboardHID;
259
			Size    = sizeof(USB_HID_Descriptor_HID_t);
260
			break;
261
		case HID_DTYPE_Report:
262
			Address = &KeyboardReport;
263
			Size    = sizeof(KeyboardReport);
264
			break;
265
	}
266

  
267
	*DescriptorAddress = Address;
268
	return Size;
269
}
270

  
Descriptors.h
1
/*
2
             LUFA Library
3
     Copyright (C) Dean Camera, 2011.
4

  
5
  dean [at] fourwalledcubicle [dot] com
6
           www.lufa-lib.org
7
*/
8

  
9
/*
10
  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
11
  Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
12

  
13
  Permission to use, copy, modify, distribute, and sell this
14
  software and its documentation for any purpose is hereby granted
15
  without fee, provided that the above copyright notice appear in
16
  all copies and that both that the copyright notice and this
17
  permission notice and warranty disclaimer appear in supporting
18
  documentation, and that the name of the author not be used in
19
  advertising or publicity pertaining to distribution of the
20
  software without specific, written prior permission.
21

  
22
  The author disclaim all warranties with regard to this
23
  software, including all implied warranties of merchantability
24
  and fitness.  In no event shall the author be liable for any
25
  special, indirect or consequential damages or any damages
26
  whatsoever resulting from loss of use, data or profits, whether
27
  in an action of contract, negligence or other tortious action,
28
  arising out of or in connection with the use or performance of
29
  this software.
30
*/
31

  
32
/** \file
33
 *
34
 *  Header file for Descriptors.c.
35
 */
36

  
37
#ifndef _DESCRIPTORS_H_
38
#define _DESCRIPTORS_H_
39

  
40
	/* Includes: */
41
		#include <LUFA/Drivers/USB/USB.h>
42

  
43
		#include <avr/pgmspace.h>
44

  
45
	/* Type Defines: */
46
		/** Type define for the device configuration descriptor structure. This must be defined in the
47
		 *  application code, as the configuration descriptor contains several sub-descriptors which
48
		 *  vary between devices, and which describe the device's usage to the host.
49
		 */
50
		typedef struct
51
		{
52
			USB_Descriptor_Configuration_Header_t Config;
53

  
54
			// Keyboard HID Interface
55
			USB_Descriptor_Interface_t            HID_Interface;
56
			USB_HID_Descriptor_HID_t              HID_KeyboardHID;
57
	        USB_Descriptor_Endpoint_t             HID_ReportINEndpoint;
58
	        USB_Descriptor_Endpoint_t             HID_ReportOUTEndpoint;
59
		} USB_Descriptor_Configuration_t;
60

  
61
	/* Macros: */
62
		/** Endpoint number of the Keyboard HID reporting IN endpoint. */
63
		#define KEYBOARD_IN_EPNUM         1
64

  
65
		/** Endpoint number of the Keyboard HID reporting OUT endpoint. */
66
		#define KEYBOARD_OUT_EPNUM        2
67

  
68
		/** Size in bytes of the Keyboard HID reporting IN and OUT endpoints. */
69
		#define KEYBOARD_EPSIZE           8
70

  
71
	/* Function Prototypes: */
72
		uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
73
		                                    const uint8_t wIndex,
74
		                                    const void** const DescriptorAddress)
75
		                                    ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(3);
76

  
77
#endif
78

  
1
/*
2
             LUFA Library
3
     Copyright (C) Dean Camera, 2011.
4

  
5
  dean [at] fourwalledcubicle [dot] com
6
           www.lufa-lib.org
7
*/
8

  
9
/*
10
  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
11
  Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
12

  
13
  Permission to use, copy, modify, distribute, and sell this
14
  software and its documentation for any purpose is hereby granted
15
  without fee, provided that the above copyright notice appear in
16
  all copies and that both that the copyright notice and this
17
  permission notice and warranty disclaimer appear in supporting
18
  documentation, and that the name of the author not be used in
19
  advertising or publicity pertaining to distribution of the
20
  software without specific, written prior permission.
21

  
22
  The author disclaim all warranties with regard to this
23
  software, including all implied warranties of merchantability
24
  and fitness.  In no event shall the author be liable for any
25
  special, indirect or consequential damages or any damages
26
  whatsoever resulting from loss of use, data or profits, whether
27
  in an action of contract, negligence or other tortious action,
28
  arising out of or in connection with the use or performance of
29
  this software.
30
*/
31

  
32
/** \file
33
 *
34
 *  Header file for Descriptors.c.
35
 */
36

  
37
#ifndef _DESCRIPTORS_H_
38
#define _DESCRIPTORS_H_
39

  
40
	/* Includes: */
41
		#include <LUFA/Drivers/USB/USB.h>
42

  
43
		#include <avr/pgmspace.h>
44

  
45
	/* Type Defines: */
46
		/** Type define for the device configuration descriptor structure. This must be defined in the
47
		 *  application code, as the configuration descriptor contains several sub-descriptors which
48
		 *  vary between devices, and which describe the device's usage to the host.
49
		 */
50
		typedef struct
51
		{
52
			USB_Descriptor_Configuration_Header_t Config;
53

  
54
			// Keyboard HID Interface
55
			USB_Descriptor_Interface_t            HID_Interface;
56
			USB_HID_Descriptor_HID_t              HID_KeyboardHID;
57
	        USB_Descriptor_Endpoint_t             HID_ReportINEndpoint;
58
	        USB_Descriptor_Endpoint_t             HID_ReportOUTEndpoint;
59
		} USB_Descriptor_Configuration_t;
60

  
61
	/* Macros: */
62
		/** Endpoint number of the Keyboard HID reporting IN endpoint. */
63
		#define KEYBOARD_IN_EPNUM         1
64

  
65
		/** Endpoint number of the Keyboard HID reporting OUT endpoint. */
66
		#define KEYBOARD_OUT_EPNUM        2
67

  
68
		/** Size in bytes of the Keyboard HID reporting IN and OUT endpoints. */
69
		#define KEYBOARD_EPSIZE           8
70

  
71
	/* Function Prototypes: */
72
		uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
73
		                                    const uint8_t wIndex,
74
		                                    const void** const DescriptorAddress)
75
		                                    ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(3);
76

  
77
#endif
78

  
Keyboard.c
1
/*
2
             LUFA Library
3
     Copyright (C) Dean Camera, 2011.
4

  
5
  dean [at] fourwalledcubicle [dot] com
6
           www.lufa-lib.org
7
*/
8

  
9
/*
10
  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
11
  Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
12

  
13
  Permission to use, copy, modify, distribute, and sell this
14
  software and its documentation for any purpose is hereby granted
15
  without fee, provided that the above copyright notice appear in
16
  all copies and that both that the copyright notice and this
17
  permission notice and warranty disclaimer appear in supporting
18
  documentation, and that the name of the author not be used in
19
  advertising or publicity pertaining to distribution of the
20
  software without specific, written prior permission.
21

  
22
  The author disclaim all warranties with regard to this
23
  software, including all implied warranties of merchantability
24
  and fitness.  In no event shall the author be liable for any
25
  special, indirect or consequential damages or any damages
26
  whatsoever resulting from loss of use, data or profits, whether
27
  in an action of contract, negligence or other tortious action,
28
  arising out of or in connection with the use or performance of
29
  this software.
30
*/
31

  
32
/** \file
33
 *
34
 *  Main source file for the Keyboard demo. This file contains the main tasks of the demo and
35
 *  is responsible for the initial application hardware configuration.
36
 */
37

  
38
#include "Keyboard.h"
39

  
40
/** Indicates what report mode the host has requested, true for normal HID reporting mode, false for special boot
41
 *  protocol reporting mode.
42
 */
43
static bool UsingReportProtocol = true;
44

  
45
/** Current Idle period. This is set by the host via a Set Idle HID class request to silence the device's reports
46
 *  for either the entire idle duration, or until the report status changes (e.g. the user presses a key).
47
 */
48
static uint16_t IdleCount = 500;
49

  
50
/** Current Idle period remaining. When the IdleCount value is set, this tracks the remaining number of idle
51
 *  milliseconds. This is separate to the IdleCount timer and is incremented and compared as the host may request
52
 *  the current idle period via a Get Idle HID class request, thus its value must be preserved.
53
 */
54
static uint16_t IdleMSRemaining = 0;
55

  
56

  
57
/** Main program entry point. This routine configures the hardware required by the application, then
58
 *  enters a loop to run the application tasks in sequence.
59
 */
60
int main(void)
61
{
62
	SetupHardware();
63

  
64
	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
65
	sei();
66

  
67
	for (;;)
68
	{
69
		HID_Task();
70
		USB_USBTask();
71
	}
72
}
73

  
74
/** Configures the board hardware and chip peripherals for the demo's functionality. */
75
void SetupHardware(void)
76
{
77
	/* Disable watchdog if enabled by bootloader/fuses */
78
	MCUSR &= ~(1 << WDRF);
79
	wdt_disable();
80

  
81
	/* Disable clock division */
82
	clock_prescale_set(clock_div_1);
83

  
84
	/* Hardware Initialization */
85
	LEDs_Init();
86
	USB_Init();
87
}
88

  
89
/** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
90
 *  starts the library USB task to begin the enumeration and USB management process.
91
 */
92
void EVENT_USB_Device_Connect(void)
93
{
94
	/* Indicate USB enumerating */
95
	LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
96

  
97
	/* Default to report protocol on connect */
98
	UsingReportProtocol = true;
99
}
100

  
101
/** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
102
 *  the status LEDs.
103
 */
104
void EVENT_USB_Device_Disconnect(void)
105
{
106
	/* Indicate USB not ready */
107
	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
108
}
109

  
110
/** Event handler for the USB_ConfigurationChanged event. This is fired when the host sets the current configuration
111
 *  of the USB device after enumeration, and configures the keyboard device endpoints.
112
 */
113
void EVENT_USB_Device_ConfigurationChanged(void)
114
{
115
	bool ConfigSuccess = true;
116

  
117
	/* Setup HID Report Endpoints */
118
	ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
119
	                                            KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
120
	ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
121
	                                            KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
122

  
123
	/* Turn on Start-of-Frame events for tracking HID report period expiry */
124
	USB_Device_EnableSOFEvents();
125

  
126
	/* Indicate endpoint configuration success or failure */
127
	LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
128
}
129

  
130
/** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
131
 *  the device from the USB host before passing along unhandled control requests to the library for processing
132
 *  internally.
133
 */
134
void EVENT_USB_Device_ControlRequest(void)
135
{
136
	/* Handle HID Class specific requests */
137
	switch (USB_ControlRequest.bRequest)
138
	{
139
		case HID_REQ_GetReport:
140
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
141
			{
142
				USB_KeyboardReport_Data_t KeyboardReportData;
143

  
144
				/* Create the next keyboard report for transmission to the host */
145
				CreateKeyboardReport(&KeyboardReportData);
146

  
147
				Endpoint_ClearSETUP();
148

  
149
				/* Write the report data to the control endpoint */
150
				Endpoint_Write_Control_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
151
				Endpoint_ClearOUT();
152
			}
153

  
154
			break;
155
		case HID_REQ_SetReport:
156
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
157
			{
158
				Endpoint_ClearSETUP();
159

  
160
				/* Wait until the LED report has been sent by the host */
161
				while (!(Endpoint_IsOUTReceived()))
162
				{
163
					if (USB_DeviceState == DEVICE_STATE_Unattached)
164
					  return;
165
				}
166

  
167
				/* Read in the LED report from the host */
168
				uint8_t LEDStatus = Endpoint_Read_8();
169

  
170
				Endpoint_ClearOUT();
171
				Endpoint_ClearStatusStage();
172

  
173
				/* Process the incoming LED report */
174
				ProcessLEDReport(LEDStatus);
175
			}
176

  
177
			break;
178
		case HID_REQ_GetProtocol:
179
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
180
			{
181
				Endpoint_ClearSETUP();
182

  
183
				/* Write the current protocol flag to the host */
184
				Endpoint_Write_8(UsingReportProtocol);
185

  
186
				Endpoint_ClearIN();
187
				Endpoint_ClearStatusStage();
188
			}
189

  
190
			break;
191
		case HID_REQ_SetProtocol:
192
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
193
			{
194
				Endpoint_ClearSETUP();
195
				Endpoint_ClearStatusStage();
196

  
197
				/* Set or clear the flag depending on what the host indicates that the current Protocol should be */
198
				UsingReportProtocol = (USB_ControlRequest.wValue != 0);
199
			}
200

  
201
			break;
202
		case HID_REQ_SetIdle:
203
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
204
			{
205
				Endpoint_ClearSETUP();
206
				Endpoint_ClearStatusStage();
207

  
208
				/* Get idle period in MSB, IdleCount must be multiplied by 4 to get number of milliseconds */
209
				IdleCount = ((USB_ControlRequest.wValue & 0xFF00) >> 6);
210
			}
211

  
212
			break;
213
		case HID_REQ_GetIdle:
214
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
215
			{
216
				Endpoint_ClearSETUP();
217

  
218
				/* Write the current idle duration to the host, must be divided by 4 before sent to host */
219
				Endpoint_Write_8(IdleCount >> 2);
220

  
221
				Endpoint_ClearIN();
222
				Endpoint_ClearStatusStage();
223
			}
224

  
225
			break;
226
	}
227
}
228

  
229
/** Event handler for the USB device Start Of Frame event. */
230
void EVENT_USB_Device_StartOfFrame(void)
231
{
232
	/* One millisecond has elapsed, decrement the idle time remaining counter if it has not already elapsed */
233
	if (IdleMSRemaining)
234
	  IdleMSRemaining--;
235
}
236

  
237
/** Fills the given HID report data structure with the next HID report to send to the host.
238
 *
239
 *  \param[out] ReportData  Pointer to a HID report data structure to be filled
240
 */
241
void CreateKeyboardReport(USB_KeyboardReport_Data_t* const ReportData)
242
{
243
	uint8_t UsedKeyCodes      = 0;
244

  
245
	/* Clear the report contents */
246
	memset(ReportData, 0, sizeof(USB_KeyboardReport_Data_t));
247

  
248
	/* Make sent key uppercase by indicating that the left shift key is pressed */
249
	ReportData->Modifier = HID_KEYBOARD_MODIFER_LEFTSHIFT;
250
}
251

  
252
/** Processes a received LED report, and updates the board LEDs states to match.
253
 *
254
 *  \param[in] LEDReport  LED status report from the host
255
 */
256
void ProcessLEDReport(const uint8_t LEDReport)
257
{
258
	uint8_t LEDMask = LEDS_LED2;
259

  
260
	if (LEDReport & HID_KEYBOARD_LED_NUMLOCK)
261
	  LEDMask |= LEDS_LED1;
262

  
263
	if (LEDReport & HID_KEYBOARD_LED_CAPSLOCK)
264
	  LEDMask |= LEDS_LED3;
265

  
266
	if (LEDReport & HID_KEYBOARD_LED_SCROLLLOCK)
267
	  LEDMask |= LEDS_LED4;
268

  
269
	/* Set the status LEDs to the current Keyboard LED status */
270
	LEDs_SetAllLEDs(LEDMask);
271
}
272

  
273
/** Sends the next HID report to the host, via the keyboard data endpoint. */
274
void SendNextReport(void)
275
{
276
	static USB_KeyboardReport_Data_t PrevKeyboardReportData;
277
	USB_KeyboardReport_Data_t        KeyboardReportData;
278
	bool                             SendReport = true;
279

  
280
	/* Create the next keyboard report for transmission to the host */
281
	CreateKeyboardReport(&KeyboardReportData);
282

  
283
	/* Check to see if the report data has changed - if so a report MUST be sent */
284
	SendReport = (memcmp(&PrevKeyboardReportData, &KeyboardReportData, sizeof(USB_KeyboardReport_Data_t)) != 0);
285

  
286
	/* Check if the idle period is set and has elapsed */
287
	if (IdleCount && (!(IdleMSRemaining)))
288
	{
289
		/* Reset the idle time remaining counter */
290
		IdleMSRemaining = IdleCount;
291

  
292
		/* Idle period is set and has elapsed, must send a report to the host */
293
		SendReport = true;
294
	}
295

  
296
	/* Select the Keyboard Report Endpoint */
297
	Endpoint_SelectEndpoint(KEYBOARD_IN_EPNUM);
298

  
299
	/* Check if Keyboard Endpoint Ready for Read/Write and if we should send a new report */
300
	if (Endpoint_IsReadWriteAllowed() && SendReport)
301
	{
302
		/* Save the current report data for later comparison to check for changes */
303
		PrevKeyboardReportData = KeyboardReportData;
304

  
305
		/* Write Keyboard Report Data */
306
		Endpoint_Write_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData), NULL);
307

  
308
		/* Finalize the stream transfer to send the last packet */
309
		Endpoint_ClearIN();
310
	}
311
}
312

  
313
/** Reads the next LED status report from the host from the LED data endpoint, if one has been sent. */
314
void ReceiveNextReport(void)
315
{
316
	/* Select the Keyboard LED Report Endpoint */
317
	Endpoint_SelectEndpoint(KEYBOARD_OUT_EPNUM);
318

  
319
	/* Check if Keyboard LED Endpoint contains a packet */
320
	if (Endpoint_IsOUTReceived())
321
	{
322
		/* Check to see if the packet contains data */
323
		if (Endpoint_IsReadWriteAllowed())
324
		{
325
			/* Read in the LED report from the host */
326
			uint8_t LEDReport = Endpoint_Read_8();
327

  
328
			/* Process the read LED report from the host */
329
			ProcessLEDReport(LEDReport);
330
		}
331

  
332
		/* Handshake the OUT Endpoint - clear endpoint and ready for next report */
333
		Endpoint_ClearOUT();
334
	}
335
}
336

  
337
/** Function to manage HID report generation and transmission to the host, when in report mode. */
338
void HID_Task(void)
339
{
340
	/* Device must be connected and configured for the task to run */
341
	if (USB_DeviceState != DEVICE_STATE_Configured)
342
	  return;
343

  
344
	/* Send the next keypress report to the host */
345
	SendNextReport();
346

  
347
	/* Process the LED report sent from the host */
348
	ReceiveNextReport();
349
}
350

  
1
/*
2
             LUFA Library
3
     Copyright (C) Dean Camera, 2011.
4

  
5
  dean [at] fourwalledcubicle [dot] com
6
           www.lufa-lib.org
7
*/
8

  
9
/*
10
  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
11
  Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
12

  
13
  Permission to use, copy, modify, distribute, and sell this
14
  software and its documentation for any purpose is hereby granted
15
  without fee, provided that the above copyright notice appear in
16
  all copies and that both that the copyright notice and this
17
  permission notice and warranty disclaimer appear in supporting
18
  documentation, and that the name of the author not be used in
19
  advertising or publicity pertaining to distribution of the
20
  software without specific, written prior permission.
21

  
22
  The author disclaim all warranties with regard to this
23
  software, including all implied warranties of merchantability
24
  and fitness.  In no event shall the author be liable for any
25
  special, indirect or consequential damages or any damages
26
  whatsoever resulting from loss of use, data or profits, whether
27
  in an action of contract, negligence or other tortious action,
28
  arising out of or in connection with the use or performance of
29
  this software.
30
*/
31

  
32
/** \file
33
 *
34
 *  Main source file for the Keyboard demo. This file contains the main tasks of the demo and
35
 *  is responsible for the initial application hardware configuration.
36
 */
37

  
38
#include "Keyboard.h"
39

  
40
/** Indicates what report mode the host has requested, true for normal HID reporting mode, false for special boot
41
 *  protocol reporting mode.
42
 */
43
static bool UsingReportProtocol = true;
44

  
45
/** Current Idle period. This is set by the host via a Set Idle HID class request to silence the device's reports
46
 *  for either the entire idle duration, or until the report status changes (e.g. the user presses a key).
47
 */
48
static uint16_t IdleCount = 500;
49

  
50
/** Current Idle period remaining. When the IdleCount value is set, this tracks the remaining number of idle
51
 *  milliseconds. This is separate to the IdleCount timer and is incremented and compared as the host may request
52
 *  the current idle period via a Get Idle HID class request, thus its value must be preserved.
53
 */
54
static uint16_t IdleMSRemaining = 0;
55

  
56
static uint16_t foo = 0;
57
/** Main program entry point. This routine configures the hardware required by the application, then
58
 *  enters a loop to run the application tasks in sequence.
59
 */
60
int main(void)
61
{
62
	SetupHardware();
63

  
64
	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
65
	sei();
66

  
67
	for (;;)
68
	{
69
		HID_Task();
70
		USB_USBTask();
71
	}
72
}
73

  
74
/** Configures the board hardware and chip peripherals for the demo's functionality. */
75
void SetupHardware(void)
76
{
77
	/* Disable watchdog if enabled by bootloader/fuses */
78
	MCUSR &= ~(1 << WDRF);
79
	wdt_disable();
80

  
81
	/* Disable clock division */
82
	clock_prescale_set(clock_div_1);
83

  
84
	/* Hardware Initialization */
85
	LEDs_Init();
86
	USB_Init();
87
}
88

  
89
/** Event handler for the USB_Connect event. This indicates that the device is enumerating via the status LEDs and
90
 *  starts the library USB task to begin the enumeration and USB management process.
91
 */
92
void EVENT_USB_Device_Connect(void)
93
{
94
	/* Indicate USB enumerating */
95
	LEDs_SetAllLEDs(LEDMASK_USB_ENUMERATING);
96

  
97
	/* Default to report protocol on connect */
98
	UsingReportProtocol = true;
99
}
100

  
101
/** Event handler for the USB_Disconnect event. This indicates that the device is no longer connected to a host via
102
 *  the status LEDs.
103
 */
104
void EVENT_USB_Device_Disconnect(void)
105
{
106
	/* Indicate USB not ready */
107
	LEDs_SetAllLEDs(LEDMASK_USB_NOTREADY);
108
}
109

  
110
/** Event handler for the USB_ConfigurationChanged event. This is fired when the host sets the current configuration
111
 *  of the USB device after enumeration, and configures the keyboard device endpoints.
112
 */
113
void EVENT_USB_Device_ConfigurationChanged(void)
114
{
115
	bool ConfigSuccess = true;
116

  
117
	/* Setup HID Report Endpoints */
118
	ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_IN_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_IN,
119
	                                            KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
120
	ConfigSuccess &= Endpoint_ConfigureEndpoint(KEYBOARD_OUT_EPNUM, EP_TYPE_INTERRUPT, ENDPOINT_DIR_OUT,
121
	                                            KEYBOARD_EPSIZE, ENDPOINT_BANK_SINGLE);
122

  
123
	/* Turn on Start-of-Frame events for tracking HID report period expiry */
124
	USB_Device_EnableSOFEvents();
125

  
126
	/* Indicate endpoint configuration success or failure */
127
	LEDs_SetAllLEDs(ConfigSuccess ? LEDMASK_USB_READY : LEDMASK_USB_ERROR);
128
}
129

  
130
/** Event handler for the USB_ControlRequest event. This is used to catch and process control requests sent to
131
 *  the device from the USB host before passing along unhandled control requests to the library for processing
132
 *  internally.
133
 */
134
void EVENT_USB_Device_ControlRequest(void)
135
{
136
	/* Handle HID Class specific requests */
137
	switch (USB_ControlRequest.bRequest)
138
	{
139
		case HID_REQ_GetReport:
140
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
141
			{
142
				USB_KeyboardReport_Data_t KeyboardReportData;
143

  
144
				/* Create the next keyboard report for transmission to the host */
145
				CreateKeyboardReport(&KeyboardReportData);
146

  
147
				Endpoint_ClearSETUP();
148

  
149
				/* Write the report data to the control endpoint */
150
				Endpoint_Write_Control_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData));
151
				Endpoint_ClearOUT();
152
			}
153

  
154
			break;
155
		case HID_REQ_SetReport:
156
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
157
			{
158
				Endpoint_ClearSETUP();
159

  
160
				/* Wait until the LED report has been sent by the host */
161
				while (!(Endpoint_IsOUTReceived()))
162
				{
163
					if (USB_DeviceState == DEVICE_STATE_Unattached)
164
					  return;
165
				}
166

  
167
				/* Read in the LED report from the host */
168
				uint8_t LEDStatus = Endpoint_Read_8();
169

  
170
				Endpoint_ClearOUT();
171
				Endpoint_ClearStatusStage();
172

  
173
				/* Process the incoming LED report */
174
				ProcessLEDReport(LEDStatus);
175
			}
176

  
177
			break;
178
		case HID_REQ_GetProtocol:
179
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
180
			{
181
				Endpoint_ClearSETUP();
182

  
183
				/* Write the current protocol flag to the host */
184
				Endpoint_Write_8(UsingReportProtocol);
185

  
186
				Endpoint_ClearIN();
187
				Endpoint_ClearStatusStage();
188
			}
189

  
190
			break;
191
		case HID_REQ_SetProtocol:
192
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
193
			{
194
				Endpoint_ClearSETUP();
195
				Endpoint_ClearStatusStage();
196

  
197
				/* Set or clear the flag depending on what the host indicates that the current Protocol should be */
198
				UsingReportProtocol = (USB_ControlRequest.wValue != 0);
199
			}
200

  
201
			break;
202
		case HID_REQ_SetIdle:
203
			if (USB_ControlRequest.bmRequestType == (REQDIR_HOSTTODEVICE | REQTYPE_CLASS | REQREC_INTERFACE))
204
			{
205
				Endpoint_ClearSETUP();
206
				Endpoint_ClearStatusStage();
207

  
208
				/* Get idle period in MSB, IdleCount must be multiplied by 4 to get number of milliseconds */
209
				IdleCount = ((USB_ControlRequest.wValue & 0xFF00) >> 6);
210
			}
211

  
212
			break;
213
		case HID_REQ_GetIdle:
214
			if (USB_ControlRequest.bmRequestType == (REQDIR_DEVICETOHOST | REQTYPE_CLASS | REQREC_INTERFACE))
215
			{
216
				Endpoint_ClearSETUP();
217

  
218
				/* Write the current idle duration to the host, must be divided by 4 before sent to host */
219
				Endpoint_Write_8(IdleCount >> 2);
220

  
221
				Endpoint_ClearIN();
222
				Endpoint_ClearStatusStage();
223
			}
224

  
225
			break;
226
	}
227
}
228

  
229
/** Event handler for the USB device Start Of Frame event. */
230
void EVENT_USB_Device_StartOfFrame(void)
231
{
232
	/* One millisecond has elapsed, decrement the idle time remaining counter if it has not already elapsed */
233
	if (IdleMSRemaining)
234
	  IdleMSRemaining--;
235
}
236

  
237
/** Fills the given HID report data structure with the next HID report to send to the host.
238
 *
239
 *  \param[out] ReportData  Pointer to a HID report data structure to be filled
240
 */
241
void CreateKeyboardReport(USB_KeyboardReport_Data_t* const ReportData)
242
{
243
	uint8_t UsedKeyCodes      = 0;
244

  
245
	/* Clear the report contents */
246
	memset(ReportData, 0, sizeof(USB_KeyboardReport_Data_t));
247
	/* Make sent key uppercase by indicating that the left shift key is pressed */
248
	//ReportData->Modifier = HID_KEYBOARD_MODIFER_LEFTSHIFT;
249
	if(foo%5000){
250
		UsedKeyCodes = 2;
251
		ReportData->KeyCode[0] = HID_KEYBOARD_SC_L; 
252
		ReportData->KeyCode[1] = HID_KEYBOARD_SC_A;
253
	}
254
	foo++;
255
}
256

  
257
/** Processes a received LED report, and updates the board LEDs states to match.
258
 *
259
 *  \param[in] LEDReport  LED status report from the host
260
 */
261
void ProcessLEDReport(const uint8_t LEDReport)
262
{
263
	uint8_t LEDMask = LEDS_LED2;
264

  
265
	if (LEDReport & HID_KEYBOARD_LED_NUMLOCK)
266
	  LEDMask |= LEDS_LED1;
267

  
268
	if (LEDReport & HID_KEYBOARD_LED_CAPSLOCK)
269
	  LEDMask |= LEDS_LED3;
270

  
271
	if (LEDReport & HID_KEYBOARD_LED_SCROLLLOCK)
272
	  LEDMask |= LEDS_LED4;
273

  
274
	/* Set the status LEDs to the current Keyboard LED status */
275
	LEDs_SetAllLEDs(LEDMask);
276
}
277

  
278
/** Sends the next HID report to the host, via the keyboard data endpoint. */
279
void SendNextReport(void)
280
{
281
	static USB_KeyboardReport_Data_t PrevKeyboardReportData;
282
	USB_KeyboardReport_Data_t        KeyboardReportData;
283
	bool                             SendReport = true;
284

  
285
	/* Create the next keyboard report for transmission to the host */
286
	CreateKeyboardReport(&KeyboardReportData);
287

  
288
	/* Check to see if the report data has changed - if so a report MUST be sent */
289
	SendReport = (memcmp(&PrevKeyboardReportData, &KeyboardReportData, sizeof(USB_KeyboardReport_Data_t)) != 0);
290

  
291
	/* Check if the idle period is set and has elapsed */
292
	if (IdleCount && (!(IdleMSRemaining)))
293
	{
294
		/* Reset the idle time remaining counter */
295
		IdleMSRemaining = IdleCount;
296

  
297
		/* Idle period is set and has elapsed, must send a report to the host */
298
		SendReport = true;
299
	}
300

  
301
	/* Select the Keyboard Report Endpoint */
302
	Endpoint_SelectEndpoint(KEYBOARD_IN_EPNUM);
303

  
304
	/* Check if Keyboard Endpoint Ready for Read/Write and if we should send a new report */
305
	if (Endpoint_IsReadWriteAllowed() && SendReport)
306
	{
307
		/* Save the current report data for later comparison to check for changes */
308
		PrevKeyboardReportData = KeyboardReportData;
309

  
310
		/* Write Keyboard Report Data */
311
		Endpoint_Write_Stream_LE(&KeyboardReportData, sizeof(KeyboardReportData), NULL);
312

  
313
		/* Finalize the stream transfer to send the last packet */
314
		Endpoint_ClearIN();
315
	}
316
}
317

  
318
/** Reads the next LED status report from the host from the LED data endpoint, if one has been sent. */
319
void ReceiveNextReport(void)
320
{
321
	/* Select the Keyboard LED Report Endpoint */
322
	Endpoint_SelectEndpoint(KEYBOARD_OUT_EPNUM);
323

  
324
	/* Check if Keyboard LED Endpoint contains a packet */
325
	if (Endpoint_IsOUTReceived())
326
	{
327
		/* Check to see if the packet contains data */
328
		if (Endpoint_IsReadWriteAllowed())
329
		{
330
			/* Read in the LED report from the host */
331
			uint8_t LEDReport = Endpoint_Read_8();
332

  
333
			/* Process the read LED report from the host */
334
			ProcessLEDReport(LEDReport);
335
		}
336

  
337
		/* Handshake the OUT Endpoint - clear endpoint and ready for next report */
338
		Endpoint_ClearOUT();
339
	}
340
}
341

  
342
/** Function to manage HID report generation and transmission to the host, when in report mode. */
343
void HID_Task(void)
344
{
345
	/* Device must be connected and configured for the task to run */
346
	if (USB_DeviceState != DEVICE_STATE_Configured)
347
	  return;
348

  
349
	/* Send the next keypress report to the host */
350
	SendNextReport();
351

  
352
	/* Process the LED report sent from the host */
353
	ReceiveNextReport();
354
}
355

  
Keyboard.h
1
/*
2
             LUFA Library
3
     Copyright (C) Dean Camera, 2011.
4

  
5
  dean [at] fourwalledcubicle [dot] com
6
           www.lufa-lib.org
7
*/
8

  
9
/*
10
  Copyright 2011  Dean Camera (dean [at] fourwalledcubicle [dot] com)
11
  Copyright 2010  Denver Gingerich (denver [at] ossguy [dot] com)
12

  
13
  Permission to use, copy, modify, distribute, and sell this
14
  software and its documentation for any purpose is hereby granted
15
  without fee, provided that the above copyright notice appear in
16
  all copies and that both that the copyright notice and this
17
  permission notice and warranty disclaimer appear in supporting
18
  documentation, and that the name of the author not be used in
19
  advertising or publicity pertaining to distribution of the
20
  software without specific, written prior permission.
21

  
22
  The author disclaim all warranties with regard to this
23
  software, including all implied warranties of merchantability
24
  and fitness.  In no event shall the author be liable for any
25
  special, indirect or consequential damages or any damages
26
  whatsoever resulting from loss of use, data or profits, whether
27
  in an action of contract, negligence or other tortious action,
28
  arising out of or in connection with the use or performance of
29
  this software.
30
*/
31

  
32
/** \file
33
 *
34
 *  Header file for Keyboard.c.
35
 */
36

  
37
#ifndef _KEYBOARD_H_
38
#define _KEYBOARD_H_
39

  
40
	/* Includes: */
41
		#include <avr/io.h>
42
		#include <avr/wdt.h>
43
		#include <avr/power.h>
44
		#include <avr/interrupt.h>
45
		#include <stdbool.h>
46
		#include <string.h>
47

  
48
		#include "Descriptors.h"
49

  
50
		#include <LUFA/Version.h>
51
		#include <LUFA/Drivers/USB/USB.h>
52
		#include <LUFA/Drivers/Board/LEDs.h>
53

  
54
	/* Macros: */
55
		/** LED mask for the library LED driver, to indicate that the USB interface is not ready. */
56
		#define LEDMASK_USB_NOTREADY        LEDS_LED1
57

  
58
		/** LED mask for the library LED driver, to indicate that the USB interface is enumerating. */
59
		#define LEDMASK_USB_ENUMERATING     (LEDS_LED2 | LEDS_LED3)
60

  
61
		/** LED mask for the library LED driver, to indicate that the USB interface is ready. */
62
		#define LEDMASK_USB_READY           (LEDS_LED2 | LEDS_LED4)
63

  
64
		/** LED mask for the library LED driver, to indicate that an error has occurred in the USB interface. */
65
		#define LEDMASK_USB_ERROR           (LEDS_LED1 | LEDS_LED3)
66

  
67
	/* Function Prototypes: */
68
		void SetupHardware(void);
69
		void HID_Task(void);
70

  
71
		void EVENT_USB_Device_Connect(void);
72
		void EVENT_USB_Device_Disconnect(void);
73
		void EVENT_USB_Device_ConfigurationChanged(void);
74
		void EVENT_USB_Device_ControlRequest(void);
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff