]> git.gir.st - tmk_keyboard.git/blob - protocol/lufa/descriptor.c
git://git.gir.st / tmk_keyboard.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix USB Descriptors
[tmk_keyboard.git] / protocol / lufa / descriptor.c
1 /*
2 * Copyright 2012 Jun Wako <wakojun@gmail.com>
3 * This file is based on:
4 * LUFA-120219/Demos/Device/Lowlevel/KeyboardMouse
5 * LUFA-120219/Demos/Device/Lowlevel/GenericHID
6 */
7
8 /*
9 LUFA Library
10 Copyright (C) Dean Camera, 2012.
11
12 dean [at] fourwalledcubicle [dot] com
13 www.lufa-lib.org
14 */
15
16 /*
17 Copyright 2012 Dean Camera (dean [at] fourwalledcubicle [dot] com)
18 Copyright 2010 Denver Gingerich (denver [at] ossguy [dot] com)
19
20 Permission to use, copy, modify, distribute, and sell this
21 software and its documentation for any purpose is hereby granted
22 without fee, provided that the above copyright notice appear in
23 all copies and that both that the copyright notice and this
24 permission notice and warranty disclaimer appear in supporting
25 documentation, and that the name of the author not be used in
26 advertising or publicity pertaining to distribution of the
27 software without specific, written prior permission.
28
29 The author disclaim all warranties with regard to this
30 software, including all implied warranties of merchantability
31 and fitness. In no event shall the author be liable for any
32 special, indirect or consequential damages or any damages
33 whatsoever resulting from loss of use, data or profits, whether
34 in an action of contract, negligence or other tortious action,
35 arising out of or in connection with the use or performance of
36 this software.
37 */
38
39 #include "util.h"
40 #include "report.h"
41 #include "descriptor.h"
42
43
44 /*******************************************************************************
45 * 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_COUNT(8, 0x08),
58 HID_RI_REPORT_SIZE(8, 0x01),
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_USAGE_PAGE(8, 0x07), /* Keyboard */
73 HID_RI_USAGE_MINIMUM(8, 0x00), /* Reserved (no event indicated) */
74 HID_RI_USAGE_MAXIMUM(8, 0xFF), /* Keyboard Application */
75 HID_RI_LOGICAL_MINIMUM(8, 0x00),
76 HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
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 #ifdef MOUSE_ENABLE
84 const USB_Descriptor_HIDReport_Datatype_t PROGMEM MouseReport[] =
85 {
86 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
87 HID_RI_USAGE(8, 0x02), /* Mouse */
88 HID_RI_COLLECTION(8, 0x01), /* Application */
89 HID_RI_USAGE(8, 0x01), /* Pointer */
90 HID_RI_COLLECTION(8, 0x00), /* Physical */
91
92 HID_RI_USAGE_PAGE(8, 0x09), /* Button */
93 HID_RI_USAGE_MINIMUM(8, 0x01), /* Button 1 */
94 HID_RI_USAGE_MAXIMUM(8, 0x05), /* Button 5 */
95 HID_RI_LOGICAL_MINIMUM(8, 0x00),
96 HID_RI_LOGICAL_MAXIMUM(8, 0x01),
97 HID_RI_REPORT_COUNT(8, 0x05),
98 HID_RI_REPORT_SIZE(8, 0x01),
99 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
100 HID_RI_REPORT_COUNT(8, 0x01),
101 HID_RI_REPORT_SIZE(8, 0x03),
102 HID_RI_INPUT(8, HID_IOF_CONSTANT),
103
104 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
105 HID_RI_USAGE(8, 0x30), /* Usage X */
106 HID_RI_USAGE(8, 0x31), /* Usage Y */
107 HID_RI_LOGICAL_MINIMUM(8, -127),
108 HID_RI_LOGICAL_MAXIMUM(8, 127),
109 HID_RI_REPORT_COUNT(8, 0x02),
110 HID_RI_REPORT_SIZE(8, 0x08),
111 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
112
113 HID_RI_USAGE(8, 0x38), /* Wheel */
114 HID_RI_LOGICAL_MINIMUM(8, -127),
115 HID_RI_LOGICAL_MAXIMUM(8, 127),
116 HID_RI_REPORT_COUNT(8, 0x01),
117 HID_RI_REPORT_SIZE(8, 0x08),
118 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
119
120 HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
121 HID_RI_USAGE(16, 0x0238), /* AC Pan (Horizontal wheel) */
122 HID_RI_LOGICAL_MINIMUM(8, -127),
123 HID_RI_LOGICAL_MAXIMUM(8, 127),
124 HID_RI_REPORT_COUNT(8, 0x01),
125 HID_RI_REPORT_SIZE(8, 0x08),
126 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
127
128 HID_RI_END_COLLECTION(0),
129 HID_RI_END_COLLECTION(0),
130 };
131 #endif
132
133 #ifdef EXTRAKEY_ENABLE
134 const USB_Descriptor_HIDReport_Datatype_t PROGMEM ExtrakeyReport[] =
135 {
136 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
137 HID_RI_USAGE(8, 0x80), /* System Control */
138 HID_RI_COLLECTION(8, 0x01), /* Application */
139 HID_RI_REPORT_ID(8, REPORT_ID_SYSTEM),
140 HID_RI_LOGICAL_MINIMUM(16, 0x0001),
141 HID_RI_LOGICAL_MAXIMUM(16, 0x00B7),
142 HID_RI_USAGE_MINIMUM(16, 0x0001), /* System Power Down */
143 HID_RI_USAGE_MAXIMUM(16, 0x00B7), /* System Display LCD Autoscale */
144 HID_RI_REPORT_SIZE(8, 16),
145 HID_RI_REPORT_COUNT(8, 1),
146 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
147 HID_RI_END_COLLECTION(0),
148
149 HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
150 HID_RI_USAGE(8, 0x01), /* Consumer Control */
151 HID_RI_COLLECTION(8, 0x01), /* Application */
152 HID_RI_REPORT_ID(8, REPORT_ID_CONSUMER),
153 HID_RI_LOGICAL_MINIMUM(16, 0x0001),
154 HID_RI_LOGICAL_MAXIMUM(16, 0x029C),
155 HID_RI_USAGE_MINIMUM(16, 0x0001), /* +10 */
156 HID_RI_USAGE_MAXIMUM(16, 0x029C), /* AC Distribute Vertically */
157 HID_RI_REPORT_SIZE(8, 16),
158 HID_RI_REPORT_COUNT(8, 1),
159 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
160 HID_RI_END_COLLECTION(0),
161 };
162 #endif
163
164 #ifdef CONSOLE_ENABLE
165 const USB_Descriptor_HIDReport_Datatype_t PROGMEM ConsoleReport[] =
166 {
167 HID_RI_USAGE_PAGE(16, 0xFF31), /* Vendor Page(PJRC Teensy compatible) */
168 HID_RI_USAGE(8, 0x74), /* Vendor Usage(PJRC Teensy compatible) */
169 HID_RI_COLLECTION(8, 0x01), /* Application */
170 HID_RI_USAGE(8, 0x75), /* Vendor Usage 0x75 */
171 HID_RI_LOGICAL_MINIMUM(8, 0x00),
172 HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
173 HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
174 HID_RI_REPORT_SIZE(8, 0x08),
175 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
176 HID_RI_USAGE(8, 0x76), /* Vendor Usage 0x76 */
177 HID_RI_LOGICAL_MINIMUM(8, 0x00),
178 HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
179 HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
180 HID_RI_REPORT_SIZE(8, 0x08),
181 HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
182 HID_RI_END_COLLECTION(0),
183 };
184 #endif
185
186 #ifdef NKRO_ENABLE
187 const USB_Descriptor_HIDReport_Datatype_t PROGMEM NKROReport[] =
188 {
189 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
190 HID_RI_USAGE(8, 0x06), /* Keyboard */
191 HID_RI_COLLECTION(8, 0x01), /* Application */
192 HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
193 HID_RI_USAGE_MINIMUM(8, 0xE0), /* Keyboard Left Control */
194 HID_RI_USAGE_MAXIMUM(8, 0xE7), /* Keyboard Right GUI */
195 HID_RI_LOGICAL_MINIMUM(8, 0x00),
196 HID_RI_LOGICAL_MAXIMUM(8, 0x01),
197 HID_RI_REPORT_COUNT(8, 0x08),
198 HID_RI_REPORT_SIZE(8, 0x01),
199 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
200
201 HID_RI_USAGE_PAGE(8, 0x08), /* LEDs */
202 HID_RI_USAGE_MINIMUM(8, 0x01), /* Num Lock */
203 HID_RI_USAGE_MAXIMUM(8, 0x05), /* Kana */
204 HID_RI_REPORT_COUNT(8, 0x05),
205 HID_RI_REPORT_SIZE(8, 0x01),
206 HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
207 HID_RI_REPORT_COUNT(8, 0x01),
208 HID_RI_REPORT_SIZE(8, 0x03),
209 HID_RI_OUTPUT(8, HID_IOF_CONSTANT),
210
211 HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
212 HID_RI_USAGE_MINIMUM(8, 0x00), /* Keyboard 0 */
213 HID_RI_USAGE_MAXIMUM(8, NKRO_SIZE*8-1), /* Keyboard Right GUI */
214 HID_RI_LOGICAL_MINIMUM(8, 0x00),
215 HID_RI_LOGICAL_MAXIMUM(8, 0x01),
216 HID_RI_REPORT_COUNT(8, NKRO_SIZE*8),
217 HID_RI_REPORT_SIZE(8, 0x01),
218 };
219 #endif
220
221 /*******************************************************************************
222 * Device Descriptors
223 ******************************************************************************/
224 const USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
225 {
226 .Header = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
227
228 .USBSpecification = VERSION_BCD(01.10),
229 .Class = USB_CSCP_NoDeviceClass,
230 .SubClass = USB_CSCP_NoDeviceSubclass,
231 .Protocol = USB_CSCP_NoDeviceProtocol,
232
233 .Endpoint0Size = 8,
234
235 /* specified in config.h */
236 .VendorID = VENDOR_ID,
237 .ProductID = PRODUCT_ID,
238 .ReleaseNumber = DEVICE_VER,
239
240 .ManufacturerStrIndex = 0x01,
241 .ProductStrIndex = 0x02,
242 .SerialNumStrIndex = NO_DESCRIPTOR,
243
244 .NumberOfConfigurations = 1
245 };
246
247 /*******************************************************************************
248 * Configuration Descriptors
249 ******************************************************************************/
250 const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
251 {
252 .Config =
253 {
254 .Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
255
256 .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
257 .TotalInterfaces = TOTAL_INTERFACES,
258
259 .ConfigurationNumber = 1,
260 .ConfigurationStrIndex = NO_DESCRIPTOR,
261
262 .ConfigAttributes = (USB_CONFIG_ATTR_RESERVED | USB_CONFIG_ATTR_REMOTEWAKEUP),
263
264 .MaxPowerConsumption = USB_CONFIG_POWER_MA(100)
265 },
266
267 /*
268 * Keyboard
269 */
270 .Keyboard_Interface =
271 {
272 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
273
274 .InterfaceNumber = KEYBOARD_INTERFACE,
275 .AlternateSetting = 0x00,
276
277 .TotalEndpoints = 1,
278
279 .Class = HID_CSCP_HIDClass,
280 .SubClass = HID_CSCP_BootSubclass,
281 .Protocol = HID_CSCP_KeyboardBootProtocol,
282
283 .InterfaceStrIndex = NO_DESCRIPTOR
284 },
285
286 .Keyboard_HID =
287 {
288 .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
289
290 .HIDSpec = VERSION_BCD(01.11),
291 .CountryCode = 0x00,
292 .TotalReportDescriptors = 1,
293 .HIDReportType = HID_DTYPE_Report,
294 .HIDReportLength = sizeof(KeyboardReport)
295 },
296
297 .Keyboard_INEndpoint =
298 {
299 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
300
301 .EndpointAddress = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM),
302 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
303 .EndpointSize = KEYBOARD_EPSIZE,
304 .PollingIntervalMS = 0x01
305 },
306
307 /*
308 * Mouse
309 */
310 #ifdef MOUSE_ENABLE
311 .Mouse_Interface =
312 {
313 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
314
315 .InterfaceNumber = MOUSE_INTERFACE,
316 .AlternateSetting = 0x00,
317
318 .TotalEndpoints = 1,
319
320 .Class = HID_CSCP_HIDClass,
321 .SubClass = HID_CSCP_BootSubclass,
322 .Protocol = HID_CSCP_MouseBootProtocol,
323
324 .InterfaceStrIndex = NO_DESCRIPTOR
325 },
326
327 .Mouse_HID =
328 {
329 .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
330
331 .HIDSpec = VERSION_BCD(01.11),
332 .CountryCode = 0x00,
333 .TotalReportDescriptors = 1,
334 .HIDReportType = HID_DTYPE_Report,
335 .HIDReportLength = sizeof(MouseReport)
336 },
337
338 .Mouse_INEndpoint =
339 {
340 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
341
342 .EndpointAddress = (ENDPOINT_DIR_IN | MOUSE_IN_EPNUM),
343 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
344 .EndpointSize = MOUSE_EPSIZE,
345 .PollingIntervalMS = 0x01
346 },
347 #endif
348
349 /*
350 * Extra
351 */
352 #ifdef EXTRAKEY_ENABLE
353 .Extrakey_Interface =
354 {
355 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
356
357 .InterfaceNumber = EXTRAKEY_INTERFACE,
358 .AlternateSetting = 0x00,
359
360 .TotalEndpoints = 1,
361
362 .Class = HID_CSCP_HIDClass,
363 .SubClass = HID_CSCP_NonBootSubclass,
364 .Protocol = HID_CSCP_NonBootProtocol,
365
366 .InterfaceStrIndex = NO_DESCRIPTOR
367 },
368
369 .Extrakey_HID =
370 {
371 .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
372
373 .HIDSpec = VERSION_BCD(01.11),
374 .CountryCode = 0x00,
375 .TotalReportDescriptors = 1,
376 .HIDReportType = HID_DTYPE_Report,
377 .HIDReportLength = sizeof(ExtrakeyReport)
378 },
379
380 .Extrakey_INEndpoint =
381 {
382 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
383
384 .EndpointAddress = (ENDPOINT_DIR_IN | EXTRAKEY_IN_EPNUM),
385 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
386 .EndpointSize = EXTRAKEY_EPSIZE,
387 .PollingIntervalMS = 0x01
388 },
389 #endif
390
391 /*
392 * Console
393 */
394 #ifdef CONSOLE_ENABLE
395 .Console_Interface =
396 {
397 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
398
399 .InterfaceNumber = CONSOLE_INTERFACE,
400 .AlternateSetting = 0x00,
401
402 .TotalEndpoints = 2,
403
404 .Class = HID_CSCP_HIDClass,
405 .SubClass = HID_CSCP_NonBootSubclass,
406 .Protocol = HID_CSCP_NonBootProtocol,
407
408 .InterfaceStrIndex = NO_DESCRIPTOR
409 },
410
411 .Console_HID =
412 {
413 .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
414
415 .HIDSpec = VERSION_BCD(01.11),
416 .CountryCode = 0x00,
417 .TotalReportDescriptors = 1,
418 .HIDReportType = HID_DTYPE_Report,
419 .HIDReportLength = sizeof(ConsoleReport)
420 },
421
422 .Console_INEndpoint =
423 {
424 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
425
426 .EndpointAddress = (ENDPOINT_DIR_IN | CONSOLE_IN_EPNUM),
427 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
428 .EndpointSize = CONSOLE_EPSIZE,
429 .PollingIntervalMS = 0x01
430 },
431
432 .Console_OUTEndpoint =
433 {
434 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
435
436 .EndpointAddress = (ENDPOINT_DIR_OUT | CONSOLE_OUT_EPNUM),
437 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
438 .EndpointSize = CONSOLE_EPSIZE,
439 .PollingIntervalMS = 0x01
440 },
441 #endif
442 };
443
444
445 /*******************************************************************************
446 * String Descriptors
447 ******************************************************************************/
448 const USB_Descriptor_String_t PROGMEM LanguageString =
449 {
450 .Header = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
451
452 .UnicodeString = {LANGUAGE_ID_ENG}
453 };
454
455 const USB_Descriptor_String_t PROGMEM ManufacturerString =
456 {
457 /* subtract 1 for null terminator */
458 .Header = {.Size = USB_STRING_LEN(sizeof(STR(MANUFACTURER))-1), .Type = DTYPE_String},
459
460 .UnicodeString = LSTR(MANUFACTURER)
461 };
462
463 const USB_Descriptor_String_t PROGMEM ProductString =
464 {
465 /* subtract 1 for null terminator */
466 .Header = {.Size = USB_STRING_LEN(sizeof(STR(PRODUCT))-1), .Type = DTYPE_String},
467
468 .UnicodeString = LSTR(PRODUCT)
469 };
470
471
472 /** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
473 * documentation) by the application code so that the address and size of a requested descriptor can be given
474 * to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
475 * is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
476 * USB host.
477 */
478 uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
479 const uint8_t wIndex,
480 const void** const DescriptorAddress)
481 {
482 const uint8_t DescriptorType = (wValue >> 8);
483 const uint8_t DescriptorIndex = (wValue & 0xFF);
484
485 const void* Address = NULL;
486 uint16_t Size = NO_DESCRIPTOR;
487
488 switch (DescriptorType)
489 {
490 case DTYPE_Device:
491 Address = &DeviceDescriptor;
492 Size = sizeof(USB_Descriptor_Device_t);
493 break;
494 case DTYPE_Configuration:
495 Address = &ConfigurationDescriptor;
496 Size = sizeof(USB_Descriptor_Configuration_t);
497 break;
498 case DTYPE_String:
499 switch (DescriptorIndex )
500 {
501 case 0x00:
502 Address = &LanguageString;
503 Size = pgm_read_byte(&LanguageString.Header.Size);
504 break;
505 case 0x01:
506 Address = &ManufacturerString;
507 Size = pgm_read_byte(&ManufacturerString.Header.Size);
508 break;
509 case 0x02:
510 Address = &ProductString;
511 Size = pgm_read_byte(&ProductString.Header.Size);
512 break;
513 }
514 break;
515 case HID_DTYPE_HID:
516 switch (wIndex) {
517 case KEYBOARD_INTERFACE:
518 Address = &ConfigurationDescriptor.Keyboard_HID;
519 Size = sizeof(USB_HID_Descriptor_HID_t);
520 break;
521 #ifdef MOUSE_ENABLE
522 case MOUSE_INTERFACE:
523 Address = &ConfigurationDescriptor.Mouse_HID;
524 Size = sizeof(USB_HID_Descriptor_HID_t);
525 break;
526 #endif
527 #ifdef EXTRAKEY_ENABLE
528 case EXTRAKEY_INTERFACE:
529 Address = &ConfigurationDescriptor.Extrakey_HID;
530 Size = sizeof(USB_HID_Descriptor_HID_t);
531 break;
532 #endif
533 #ifdef CONSOLE_ENABLE
534 case CONSOLE_INTERFACE:
535 Address = &ConfigurationDescriptor.Console_HID;
536 Size = sizeof(USB_HID_Descriptor_HID_t);
537 break;
538 #endif
539 }
540 break;
541 case HID_DTYPE_Report:
542 switch (wIndex) {
543 case KEYBOARD_INTERFACE:
544 Address = &KeyboardReport;
545 Size = sizeof(KeyboardReport);
546 break;
547 #ifdef MOUSE_ENABLE
548 case MOUSE_INTERFACE:
549 Address = &MouseReport;
550 Size = sizeof(MouseReport);
551 break;
552 #endif
553 #ifdef EXTRAKEY_ENABLE
554 case EXTRAKEY_INTERFACE:
555 Address = &ExtrakeyReport;
556 Size = sizeof(ExtrakeyReport);
557 break;
558 #endif
559 #ifdef CONSOLE_ENABLE
560 case CONSOLE_INTERFACE:
561 Address = &ConsoleReport;
562 Size = sizeof(ConsoleReport);
563 break;
564 #endif
565 }
566 break;
567 }
568
569 *DescriptorAddress = Address;
570 return Size;
571 }
custom keymap for my minivan; forked from http://github.com/evangs/tmk_keyboard
Imprint / Impressum