]> git.gir.st - tmk_keyboard.git/blob - protocol/lufa/descriptor.c
git://git.gir.st / tmk_keyboard.git / blob
? search:


d88b59654c112b6646d1b4993e4e6d3a282004e7
[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
61 HID_RI_REPORT_COUNT(8, 0x01),
62 HID_RI_REPORT_SIZE(8, 0x08),
63 HID_RI_INPUT(8, HID_IOF_CONSTANT), /* reserved */
64
65 HID_RI_USAGE_PAGE(8, 0x08), /* LEDs */
66 HID_RI_USAGE_MINIMUM(8, 0x01), /* Num Lock */
67 HID_RI_USAGE_MAXIMUM(8, 0x05), /* Kana */
68 HID_RI_REPORT_COUNT(8, 0x05),
69 HID_RI_REPORT_SIZE(8, 0x01),
70 HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
71 HID_RI_REPORT_COUNT(8, 0x01),
72 HID_RI_REPORT_SIZE(8, 0x03),
73 HID_RI_OUTPUT(8, HID_IOF_CONSTANT),
74
75 HID_RI_USAGE_PAGE(8, 0x07), /* Keyboard */
76 HID_RI_USAGE_MINIMUM(8, 0x00), /* Reserved (no event indicated) */
77 HID_RI_USAGE_MAXIMUM(8, 0xFF), /* Keyboard Application */
78 HID_RI_LOGICAL_MINIMUM(8, 0x00),
79 HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
80 HID_RI_REPORT_COUNT(8, 0x06),
81 HID_RI_REPORT_SIZE(8, 0x08),
82 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
83 HID_RI_END_COLLECTION(0),
84 };
85
86 #ifdef MOUSE_ENABLE
87 const USB_Descriptor_HIDReport_Datatype_t PROGMEM MouseReport[] =
88 {
89 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
90 HID_RI_USAGE(8, 0x02), /* Mouse */
91 HID_RI_COLLECTION(8, 0x01), /* Application */
92 HID_RI_USAGE(8, 0x01), /* Pointer */
93 HID_RI_COLLECTION(8, 0x00), /* Physical */
94
95 HID_RI_USAGE_PAGE(8, 0x09), /* Button */
96 HID_RI_USAGE_MINIMUM(8, 0x01), /* Button 1 */
97 HID_RI_USAGE_MAXIMUM(8, 0x05), /* Button 5 */
98 HID_RI_LOGICAL_MINIMUM(8, 0x00),
99 HID_RI_LOGICAL_MAXIMUM(8, 0x01),
100 HID_RI_REPORT_COUNT(8, 0x05),
101 HID_RI_REPORT_SIZE(8, 0x01),
102 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
103 HID_RI_REPORT_COUNT(8, 0x01),
104 HID_RI_REPORT_SIZE(8, 0x03),
105 HID_RI_INPUT(8, HID_IOF_CONSTANT),
106
107 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
108 HID_RI_USAGE(8, 0x30), /* Usage X */
109 HID_RI_USAGE(8, 0x31), /* Usage Y */
110 HID_RI_LOGICAL_MINIMUM(8, -127),
111 HID_RI_LOGICAL_MAXIMUM(8, 127),
112 HID_RI_REPORT_COUNT(8, 0x02),
113 HID_RI_REPORT_SIZE(8, 0x08),
114 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
115
116 HID_RI_USAGE(8, 0x38), /* Wheel */
117 HID_RI_LOGICAL_MINIMUM(8, -127),
118 HID_RI_LOGICAL_MAXIMUM(8, 127),
119 HID_RI_REPORT_COUNT(8, 0x01),
120 HID_RI_REPORT_SIZE(8, 0x08),
121 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
122
123 HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
124 HID_RI_USAGE(16, 0x0238), /* AC Pan (Horizontal wheel) */
125 HID_RI_LOGICAL_MINIMUM(8, -127),
126 HID_RI_LOGICAL_MAXIMUM(8, 127),
127 HID_RI_REPORT_COUNT(8, 0x01),
128 HID_RI_REPORT_SIZE(8, 0x08),
129 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_RELATIVE),
130
131 HID_RI_END_COLLECTION(0),
132 HID_RI_END_COLLECTION(0),
133 };
134 #endif
135
136 #ifdef EXTRAKEY_ENABLE
137 const USB_Descriptor_HIDReport_Datatype_t PROGMEM ExtrakeyReport[] =
138 {
139 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
140 HID_RI_USAGE(8, 0x80), /* System Control */
141 HID_RI_COLLECTION(8, 0x01), /* Application */
142 HID_RI_REPORT_ID(8, REPORT_ID_SYSTEM),
143 HID_RI_LOGICAL_MINIMUM(16, 0x0001),
144 HID_RI_LOGICAL_MAXIMUM(16, 0x00B7),
145 HID_RI_USAGE_MINIMUM(16, 0x0001), /* System Power Down */
146 HID_RI_USAGE_MAXIMUM(16, 0x00B7), /* System Display LCD Autoscale */
147 HID_RI_REPORT_SIZE(8, 16),
148 HID_RI_REPORT_COUNT(8, 1),
149 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
150 HID_RI_END_COLLECTION(0),
151
152 HID_RI_USAGE_PAGE(8, 0x0C), /* Consumer */
153 HID_RI_USAGE(8, 0x01), /* Consumer Control */
154 HID_RI_COLLECTION(8, 0x01), /* Application */
155 HID_RI_REPORT_ID(8, REPORT_ID_CONSUMER),
156 HID_RI_LOGICAL_MINIMUM(16, 0x0001),
157 HID_RI_LOGICAL_MAXIMUM(16, 0x029C),
158 HID_RI_USAGE_MINIMUM(16, 0x0001), /* +10 */
159 HID_RI_USAGE_MAXIMUM(16, 0x029C), /* AC Distribute Vertically */
160 HID_RI_REPORT_SIZE(8, 16),
161 HID_RI_REPORT_COUNT(8, 1),
162 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_ARRAY | HID_IOF_ABSOLUTE),
163 HID_RI_END_COLLECTION(0),
164 };
165 #endif
166
167 #ifdef CONSOLE_ENABLE
168 const USB_Descriptor_HIDReport_Datatype_t PROGMEM ConsoleReport[] =
169 {
170 HID_RI_USAGE_PAGE(16, 0xFF31), /* Vendor Page(PJRC Teensy compatible) */
171 HID_RI_USAGE(8, 0x74), /* Vendor Usage(PJRC Teensy compatible) */
172 HID_RI_COLLECTION(8, 0x01), /* Application */
173 HID_RI_USAGE(8, 0x75), /* Vendor Usage 0x75 */
174 HID_RI_LOGICAL_MINIMUM(8, 0x00),
175 HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
176 HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
177 HID_RI_REPORT_SIZE(8, 0x08),
178 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
179 HID_RI_USAGE(8, 0x76), /* Vendor Usage 0x76 */
180 HID_RI_LOGICAL_MINIMUM(8, 0x00),
181 HID_RI_LOGICAL_MAXIMUM(8, 0xFF),
182 HID_RI_REPORT_COUNT(8, CONSOLE_EPSIZE),
183 HID_RI_REPORT_SIZE(8, 0x08),
184 HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
185 HID_RI_END_COLLECTION(0),
186 };
187 #endif
188
189 #ifdef NKRO_ENABLE
190 const USB_Descriptor_HIDReport_Datatype_t PROGMEM NKROReport[] =
191 {
192 HID_RI_USAGE_PAGE(8, 0x01), /* Generic Desktop */
193 HID_RI_USAGE(8, 0x06), /* Keyboard */
194 HID_RI_COLLECTION(8, 0x01), /* Application */
195 HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
196 HID_RI_USAGE_MINIMUM(8, 0xE0), /* Keyboard Left Control */
197 HID_RI_USAGE_MAXIMUM(8, 0xE7), /* Keyboard Right GUI */
198 HID_RI_LOGICAL_MINIMUM(8, 0x00),
199 HID_RI_LOGICAL_MAXIMUM(8, 0x01),
200 HID_RI_REPORT_COUNT(8, 0x08),
201 HID_RI_REPORT_SIZE(8, 0x01),
202 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
203
204 HID_RI_USAGE_PAGE(8, 0x08), /* LEDs */
205 HID_RI_USAGE_MINIMUM(8, 0x01), /* Num Lock */
206 HID_RI_USAGE_MAXIMUM(8, 0x05), /* Kana */
207 HID_RI_REPORT_COUNT(8, 0x05),
208 HID_RI_REPORT_SIZE(8, 0x01),
209 HID_RI_OUTPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE | HID_IOF_NON_VOLATILE),
210 HID_RI_REPORT_COUNT(8, 0x01),
211 HID_RI_REPORT_SIZE(8, 0x03),
212 HID_RI_OUTPUT(8, HID_IOF_CONSTANT),
213
214 HID_RI_USAGE_PAGE(8, 0x07), /* Key Codes */
215 HID_RI_USAGE_MINIMUM(8, 0x00), /* Keyboard 0 */
216 HID_RI_USAGE_MAXIMUM(8, (NKRO_EPSIZE-1)*8-1), /* Keyboard Right GUI */
217 HID_RI_LOGICAL_MINIMUM(8, 0x00),
218 HID_RI_LOGICAL_MAXIMUM(8, 0x01),
219 HID_RI_REPORT_COUNT(8, (NKRO_EPSIZE-1)*8),
220 HID_RI_REPORT_SIZE(8, 0x01),
221 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
222 HID_RI_END_COLLECTION(0),
223 };
224 #endif
225
226 /*******************************************************************************
227 * Device Descriptors
228 ******************************************************************************/
229 const USB_Descriptor_Device_t PROGMEM DeviceDescriptor =
230 {
231 .Header = {.Size = sizeof(USB_Descriptor_Device_t), .Type = DTYPE_Device},
232
233 .USBSpecification = VERSION_BCD(01.10),
234 .Class = USB_CSCP_NoDeviceClass,
235 .SubClass = USB_CSCP_NoDeviceSubclass,
236 .Protocol = USB_CSCP_NoDeviceProtocol,
237
238 .Endpoint0Size = FIXED_CONTROL_ENDPOINT_SIZE,
239
240 /* specified in config.h */
241 .VendorID = VENDOR_ID,
242 .ProductID = PRODUCT_ID,
243 .ReleaseNumber = DEVICE_VER,
244
245 .ManufacturerStrIndex = 0x01,
246 .ProductStrIndex = 0x02,
247 .SerialNumStrIndex = NO_DESCRIPTOR,
248
249 .NumberOfConfigurations = FIXED_NUM_CONFIGURATIONS
250 };
251
252 /*******************************************************************************
253 * Configuration Descriptors
254 ******************************************************************************/
255 const USB_Descriptor_Configuration_t PROGMEM ConfigurationDescriptor =
256 {
257 .Config =
258 {
259 .Header = {.Size = sizeof(USB_Descriptor_Configuration_Header_t), .Type = DTYPE_Configuration},
260
261 .TotalConfigurationSize = sizeof(USB_Descriptor_Configuration_t),
262 .TotalInterfaces = TOTAL_INTERFACES,
263
264 .ConfigurationNumber = 1,
265 .ConfigurationStrIndex = NO_DESCRIPTOR,
266
267 .ConfigAttributes = (USB_CONFIG_ATTR_RESERVED | USB_CONFIG_ATTR_REMOTEWAKEUP),
268
269 .MaxPowerConsumption = USB_CONFIG_POWER_MA(100)
270 },
271
272 /*
273 * Keyboard
274 */
275 .Keyboard_Interface =
276 {
277 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
278
279 .InterfaceNumber = KEYBOARD_INTERFACE,
280 .AlternateSetting = 0x00,
281
282 .TotalEndpoints = 1,
283
284 .Class = HID_CSCP_HIDClass,
285 .SubClass = HID_CSCP_BootSubclass,
286 .Protocol = HID_CSCP_KeyboardBootProtocol,
287
288 .InterfaceStrIndex = NO_DESCRIPTOR
289 },
290
291 .Keyboard_HID =
292 {
293 .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
294
295 .HIDSpec = VERSION_BCD(01.11),
296 .CountryCode = 0x00,
297 .TotalReportDescriptors = 1,
298 .HIDReportType = HID_DTYPE_Report,
299 .HIDReportLength = sizeof(KeyboardReport)
300 },
301
302 .Keyboard_INEndpoint =
303 {
304 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
305
306 .EndpointAddress = (ENDPOINT_DIR_IN | KEYBOARD_IN_EPNUM),
307 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
308 .EndpointSize = KEYBOARD_EPSIZE,
309 .PollingIntervalMS = 0x0A
310 },
311
312 /*
313 * Mouse
314 */
315 #ifdef MOUSE_ENABLE
316 .Mouse_Interface =
317 {
318 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
319
320 .InterfaceNumber = MOUSE_INTERFACE,
321 .AlternateSetting = 0x00,
322
323 .TotalEndpoints = 1,
324
325 .Class = HID_CSCP_HIDClass,
326 .SubClass = HID_CSCP_BootSubclass,
327 .Protocol = HID_CSCP_MouseBootProtocol,
328
329 .InterfaceStrIndex = NO_DESCRIPTOR
330 },
331
332 .Mouse_HID =
333 {
334 .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
335
336 .HIDSpec = VERSION_BCD(01.11),
337 .CountryCode = 0x00,
338 .TotalReportDescriptors = 1,
339 .HIDReportType = HID_DTYPE_Report,
340 .HIDReportLength = sizeof(MouseReport)
341 },
342
343 .Mouse_INEndpoint =
344 {
345 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
346
347 .EndpointAddress = (ENDPOINT_DIR_IN | MOUSE_IN_EPNUM),
348 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
349 .EndpointSize = MOUSE_EPSIZE,
350 .PollingIntervalMS = 0x0A
351 },
352 #endif
353
354 /*
355 * Extra
356 */
357 #ifdef EXTRAKEY_ENABLE
358 .Extrakey_Interface =
359 {
360 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
361
362 .InterfaceNumber = EXTRAKEY_INTERFACE,
363 .AlternateSetting = 0x00,
364
365 .TotalEndpoints = 1,
366
367 .Class = HID_CSCP_HIDClass,
368 .SubClass = HID_CSCP_NonBootSubclass,
369 .Protocol = HID_CSCP_NonBootProtocol,
370
371 .InterfaceStrIndex = NO_DESCRIPTOR
372 },
373
374 .Extrakey_HID =
375 {
376 .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
377
378 .HIDSpec = VERSION_BCD(01.11),
379 .CountryCode = 0x00,
380 .TotalReportDescriptors = 1,
381 .HIDReportType = HID_DTYPE_Report,
382 .HIDReportLength = sizeof(ExtrakeyReport)
383 },
384
385 .Extrakey_INEndpoint =
386 {
387 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
388
389 .EndpointAddress = (ENDPOINT_DIR_IN | EXTRAKEY_IN_EPNUM),
390 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
391 .EndpointSize = EXTRAKEY_EPSIZE,
392 .PollingIntervalMS = 0x0A
393 },
394 #endif
395
396 /*
397 * Console
398 */
399 #ifdef CONSOLE_ENABLE
400 .Console_Interface =
401 {
402 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
403
404 .InterfaceNumber = CONSOLE_INTERFACE,
405 .AlternateSetting = 0x00,
406
407 .TotalEndpoints = 2,
408
409 .Class = HID_CSCP_HIDClass,
410 .SubClass = HID_CSCP_NonBootSubclass,
411 .Protocol = HID_CSCP_NonBootProtocol,
412
413 .InterfaceStrIndex = NO_DESCRIPTOR
414 },
415
416 .Console_HID =
417 {
418 .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
419
420 .HIDSpec = VERSION_BCD(01.11),
421 .CountryCode = 0x00,
422 .TotalReportDescriptors = 1,
423 .HIDReportType = HID_DTYPE_Report,
424 .HIDReportLength = sizeof(ConsoleReport)
425 },
426
427 .Console_INEndpoint =
428 {
429 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
430
431 .EndpointAddress = (ENDPOINT_DIR_IN | CONSOLE_IN_EPNUM),
432 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
433 .EndpointSize = CONSOLE_EPSIZE,
434 .PollingIntervalMS = 0x01
435 },
436
437 .Console_OUTEndpoint =
438 {
439 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
440
441 .EndpointAddress = (ENDPOINT_DIR_OUT | CONSOLE_OUT_EPNUM),
442 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
443 .EndpointSize = CONSOLE_EPSIZE,
444 .PollingIntervalMS = 0x01
445 },
446 #endif
447
448 /*
449 * NKRO
450 */
451 #ifdef NKRO_ENABLE
452 .NKRO_Interface =
453 {
454 .Header = {.Size = sizeof(USB_Descriptor_Interface_t), .Type = DTYPE_Interface},
455
456 .InterfaceNumber = NKRO_INTERFACE,
457 .AlternateSetting = 0x00,
458
459 .TotalEndpoints = 1,
460
461 .Class = HID_CSCP_HIDClass,
462 .SubClass = HID_CSCP_NonBootSubclass,
463 .Protocol = HID_CSCP_NonBootProtocol,
464
465 .InterfaceStrIndex = NO_DESCRIPTOR
466 },
467
468 .NKRO_HID =
469 {
470 .Header = {.Size = sizeof(USB_HID_Descriptor_HID_t), .Type = HID_DTYPE_HID},
471
472 .HIDSpec = VERSION_BCD(01.11),
473 .CountryCode = 0x00,
474 .TotalReportDescriptors = 1,
475 .HIDReportType = HID_DTYPE_Report,
476 .HIDReportLength = sizeof(NKROReport)
477 },
478
479 .NKRO_INEndpoint =
480 {
481 .Header = {.Size = sizeof(USB_Descriptor_Endpoint_t), .Type = DTYPE_Endpoint},
482
483 .EndpointAddress = (ENDPOINT_DIR_IN | NKRO_IN_EPNUM),
484 .Attributes = (EP_TYPE_INTERRUPT | ENDPOINT_ATTR_NO_SYNC | ENDPOINT_USAGE_DATA),
485 .EndpointSize = NKRO_EPSIZE,
486 .PollingIntervalMS = 0x01
487 },
488 #endif
489 };
490
491
492 /*******************************************************************************
493 * String Descriptors
494 ******************************************************************************/
495 const USB_Descriptor_String_t PROGMEM LanguageString =
496 {
497 .Header = {.Size = USB_STRING_LEN(1), .Type = DTYPE_String},
498
499 .UnicodeString = {LANGUAGE_ID_ENG}
500 };
501
502 const USB_Descriptor_String_t PROGMEM ManufacturerString =
503 {
504 /* subtract 1 for null terminator */
505 .Header = {.Size = USB_STRING_LEN(sizeof(STR(MANUFACTURER))-1), .Type = DTYPE_String},
506
507 .UnicodeString = LSTR(MANUFACTURER)
508 };
509
510 const USB_Descriptor_String_t PROGMEM ProductString =
511 {
512 /* subtract 1 for null terminator */
513 .Header = {.Size = USB_STRING_LEN(sizeof(STR(PRODUCT))-1), .Type = DTYPE_String},
514
515 .UnicodeString = LSTR(PRODUCT)
516 };
517
518
519 /** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"
520 * documentation) by the application code so that the address and size of a requested descriptor can be given
521 * to the USB library. When the device receives a Get Descriptor request on the control endpoint, this function
522 * is called so that the descriptor details can be passed back and the appropriate descriptor sent back to the
523 * USB host.
524 */
525 uint16_t CALLBACK_USB_GetDescriptor(const uint16_t wValue,
526 const uint8_t wIndex,
527 const void** const DescriptorAddress)
528 {
529 const uint8_t DescriptorType = (wValue >> 8);
530 const uint8_t DescriptorIndex = (wValue & 0xFF);
531
532 const void* Address = NULL;
533 uint16_t Size = NO_DESCRIPTOR;
534
535 switch (DescriptorType)
536 {
537 case DTYPE_Device:
538 Address = &DeviceDescriptor;
539 Size = sizeof(USB_Descriptor_Device_t);
540 break;
541 case DTYPE_Configuration:
542 Address = &ConfigurationDescriptor;
543 Size = sizeof(USB_Descriptor_Configuration_t);
544 break;
545 case DTYPE_String:
546 switch (DescriptorIndex )
547 {
548 case 0x00:
549 Address = &LanguageString;
550 Size = pgm_read_byte(&LanguageString.Header.Size);
551 break;
552 case 0x01:
553 Address = &ManufacturerString;
554 Size = pgm_read_byte(&ManufacturerString.Header.Size);
555 break;
556 case 0x02:
557 Address = &ProductString;
558 Size = pgm_read_byte(&ProductString.Header.Size);
559 break;
560 }
561 break;
562 case HID_DTYPE_HID:
563 switch (wIndex) {
564 case KEYBOARD_INTERFACE:
565 Address = &ConfigurationDescriptor.Keyboard_HID;
566 Size = sizeof(USB_HID_Descriptor_HID_t);
567 break;
568 #ifdef MOUSE_ENABLE
569 case MOUSE_INTERFACE:
570 Address = &ConfigurationDescriptor.Mouse_HID;
571 Size = sizeof(USB_HID_Descriptor_HID_t);
572 break;
573 #endif
574 #ifdef EXTRAKEY_ENABLE
575 case EXTRAKEY_INTERFACE:
576 Address = &ConfigurationDescriptor.Extrakey_HID;
577 Size = sizeof(USB_HID_Descriptor_HID_t);
578 break;
579 #endif
580 #ifdef CONSOLE_ENABLE
581 case CONSOLE_INTERFACE:
582 Address = &ConfigurationDescriptor.Console_HID;
583 Size = sizeof(USB_HID_Descriptor_HID_t);
584 break;
585 #endif
586 #ifdef NKRO_ENABLE
587 case NKRO_INTERFACE:
588 Address = &ConfigurationDescriptor.NKRO_HID;
589 Size = sizeof(USB_HID_Descriptor_HID_t);
590 break;
591 #endif
592 }
593 break;
594 case HID_DTYPE_Report:
595 switch (wIndex) {
596 case KEYBOARD_INTERFACE:
597 Address = &KeyboardReport;
598 Size = sizeof(KeyboardReport);
599 break;
600 #ifdef MOUSE_ENABLE
601 case MOUSE_INTERFACE:
602 Address = &MouseReport;
603 Size = sizeof(MouseReport);
604 break;
605 #endif
606 #ifdef EXTRAKEY_ENABLE
607 case EXTRAKEY_INTERFACE:
608 Address = &ExtrakeyReport;
609 Size = sizeof(ExtrakeyReport);
610 break;
611 #endif
612 #ifdef CONSOLE_ENABLE
613 case CONSOLE_INTERFACE:
614 Address = &ConsoleReport;
615 Size = sizeof(ConsoleReport);
616 break;
617 #endif
618 #ifdef NKRO_ENABLE
619 case NKRO_INTERFACE:
620 Address = &NKROReport;
621 Size = sizeof(NKROReport);
622 break;
623 #endif
624 }
625 break;
626 }
627
628 *DescriptorAddress = Address;
629 return Size;
630 }
custom keymap for my minivan; forked from http://github.com/evangs/tmk_keyboard
Imprint / Impressum