diff options
author | Ryan <fauxpark@gmail.com> | 2021-08-18 18:20:25 +1000 |
---|---|---|
committer | GitHub <noreply@github.com> | 2021-08-18 18:20:25 +1000 |
commit | b16091659cc9a724a8800f77e631643b4ab089ad (patch) | |
tree | e44933472c6d100bd4fc5d8a693d9d21e3c32f6f /lib/usbhost/USB_Host_Shield_2.0/hidboot.h | |
parent | cf5e40c25139ff64ff246f1c6280e983ef75551c (diff) | |
download | qmk_firmware-b16091659cc9a724a8800f77e631643b4ab089ad.tar.gz qmk_firmware-b16091659cc9a724a8800f77e631643b4ab089ad.zip |
Move USB Host Shield and Arduino core to `lib/` (#13973)
Diffstat (limited to 'lib/usbhost/USB_Host_Shield_2.0/hidboot.h')
-rw-r--r-- | lib/usbhost/USB_Host_Shield_2.0/hidboot.h | 618 |
1 files changed, 618 insertions, 0 deletions
diff --git a/lib/usbhost/USB_Host_Shield_2.0/hidboot.h b/lib/usbhost/USB_Host_Shield_2.0/hidboot.h new file mode 100644 index 000000000..fb63ec5e5 --- /dev/null +++ b/lib/usbhost/USB_Host_Shield_2.0/hidboot.h | |||
@@ -0,0 +1,618 @@ | |||
1 | /* Copyright (C) 2011 Circuits At Home, LTD. All rights reserved. | ||
2 | |||
3 | This software may be distributed and modified under the terms of the GNU | ||
4 | General Public License version 2 (GPL2) as published by the Free Software | ||
5 | Foundation and appearing in the file GPL2.TXT included in the packaging of | ||
6 | this file. Please note that GPL2 Section 2[b] requires that all works based | ||
7 | on this software must also be made publicly available under the terms of | ||
8 | the GPL2 ("Copyleft"). | ||
9 | |||
10 | Contact information | ||
11 | ------------------- | ||
12 | |||
13 | Circuits At Home, LTD | ||
14 | Web : http://www.circuitsathome.com | ||
15 | e-mail : support@circuitsathome.com | ||
16 | */ | ||
17 | #if !defined(__HIDBOOT_H__) | ||
18 | #define __HIDBOOT_H__ | ||
19 | |||
20 | #include "hid.h" | ||
21 | |||
22 | #define UHS_HID_BOOT_KEY_ZERO 0x27 | ||
23 | #define UHS_HID_BOOT_KEY_ENTER 0x28 | ||
24 | #define UHS_HID_BOOT_KEY_SPACE 0x2c | ||
25 | #define UHS_HID_BOOT_KEY_CAPS_LOCK 0x39 | ||
26 | #define UHS_HID_BOOT_KEY_SCROLL_LOCK 0x47 | ||
27 | #define UHS_HID_BOOT_KEY_NUM_LOCK 0x53 | ||
28 | #define UHS_HID_BOOT_KEY_ZERO2 0x62 | ||
29 | #define UHS_HID_BOOT_KEY_PERIOD 0x63 | ||
30 | |||
31 | // Don't worry, GCC will optimize the result to a final value. | ||
32 | #define bitsEndpoints(p) ((((p) & HID_PROTOCOL_KEYBOARD)? 2 : 0) | (((p) & HID_PROTOCOL_MOUSE)? 1 : 0)) | ||
33 | #define totalEndpoints(p) ((bitsEndpoints(p) == 3) ? 3 : 2) | ||
34 | #define epMUL(p) ((((p) & HID_PROTOCOL_KEYBOARD)? 1 : 0) + (((p) & HID_PROTOCOL_MOUSE)? 1 : 0)) | ||
35 | |||
36 | // Already defined in hid.h | ||
37 | // #define HID_MAX_HID_CLASS_DESCRIPTORS 5 | ||
38 | |||
39 | struct MOUSEINFO { | ||
40 | |||
41 | struct { | ||
42 | uint8_t bmLeftButton : 1; | ||
43 | uint8_t bmRightButton : 1; | ||
44 | uint8_t bmMiddleButton : 1; | ||
45 | uint8_t bmDummy : 5; | ||
46 | }; | ||
47 | int8_t dX; | ||
48 | int8_t dY; | ||
49 | }; | ||
50 | |||
51 | class MouseReportParser : public HIDReportParser { | ||
52 | |||
53 | union { | ||
54 | MOUSEINFO mouseInfo; | ||
55 | uint8_t bInfo[sizeof (MOUSEINFO)]; | ||
56 | } prevState; | ||
57 | |||
58 | public: | ||
59 | void Parse(HID *hid, bool is_rpt_id, uint8_t len, uint8_t *buf); | ||
60 | |||
61 | protected: | ||
62 | |||
63 | virtual void OnMouseMove(MOUSEINFO *mi) { | ||
64 | }; | ||
65 | |||
66 | virtual void OnLeftButtonUp(MOUSEINFO *mi) { | ||
67 | }; | ||
68 | |||
69 | virtual void OnLeftButtonDown(MOUSEINFO *mi) { | ||
70 | }; | ||
71 | |||
72 | virtual void OnRightButtonUp(MOUSEINFO *mi) { | ||
73 | }; | ||
74 | |||
75 | virtual void OnRightButtonDown(MOUSEINFO *mi) { | ||
76 | }; | ||
77 | |||
78 | virtual void OnMiddleButtonUp(MOUSEINFO *mi) { | ||
79 | }; | ||
80 | |||
81 | virtual void OnMiddleButtonDown(MOUSEINFO *mi) { | ||
82 | }; | ||
83 | }; | ||
84 | |||
85 | struct MODIFIERKEYS { | ||
86 | uint8_t bmLeftCtrl : 1; | ||
87 | uint8_t bmLeftShift : 1; | ||
88 | uint8_t bmLeftAlt : 1; | ||
89 | uint8_t bmLeftGUI : 1; | ||
90 | uint8_t bmRightCtrl : 1; | ||
91 | uint8_t bmRightShift : 1; | ||
92 | uint8_t bmRightAlt : 1; | ||
93 | uint8_t bmRightGUI : 1; | ||
94 | }; | ||
95 | |||
96 | struct KBDINFO { | ||
97 | |||
98 | struct { | ||
99 | uint8_t bmLeftCtrl : 1; | ||
100 | uint8_t bmLeftShift : 1; | ||
101 | uint8_t bmLeftAlt : 1; | ||
102 | uint8_t bmLeftGUI : 1; | ||
103 | uint8_t bmRightCtrl : 1; | ||
104 | uint8_t bmRightShift : 1; | ||
105 | uint8_t bmRightAlt : 1; | ||
106 | uint8_t bmRightGUI : 1; | ||
107 | }; | ||
108 | uint8_t bReserved; | ||
109 | uint8_t Keys[6]; | ||
110 | }; | ||
111 | |||
112 | struct KBDLEDS { | ||
113 | uint8_t bmNumLock : 1; | ||
114 | uint8_t bmCapsLock : 1; | ||
115 | uint8_t bmScrollLock : 1; | ||
116 | uint8_t bmCompose : 1; | ||
117 | uint8_t bmKana : 1; | ||
118 | uint8_t bmReserved : 3; | ||
119 | }; | ||
120 | |||
121 | class KeyboardReportParser : public HIDReportParser { | ||
122 | static const uint8_t numKeys[10]; | ||
123 | static const uint8_t symKeysUp[12]; | ||
124 | static const uint8_t symKeysLo[12]; | ||
125 | static const uint8_t padKeys[5]; | ||
126 | |||
127 | protected: | ||
128 | |||
129 | union { | ||
130 | KBDINFO kbdInfo; | ||
131 | uint8_t bInfo[sizeof (KBDINFO)]; | ||
132 | } prevState; | ||
133 | |||
134 | union { | ||
135 | KBDLEDS kbdLeds; | ||
136 | uint8_t bLeds; | ||
137 | } kbdLockingKeys; | ||
138 | |||
139 | uint8_t OemToAscii(uint8_t mod, uint8_t key); | ||
140 | |||
141 | public: | ||
142 | |||
143 | KeyboardReportParser() { | ||
144 | kbdLockingKeys.bLeds = 0; | ||
145 | }; | ||
146 | |||
147 | void Parse(HID *hid, bool is_rpt_id, uint8_t len, uint8_t *buf); | ||
148 | |||
149 | protected: | ||
150 | |||
151 | virtual uint8_t HandleLockingKeys(HID* hid, uint8_t key) { | ||
152 | uint8_t old_keys = kbdLockingKeys.bLeds; | ||
153 | |||
154 | switch(key) { | ||
155 | case UHS_HID_BOOT_KEY_NUM_LOCK: | ||
156 | kbdLockingKeys.kbdLeds.bmNumLock = ~kbdLockingKeys.kbdLeds.bmNumLock; | ||
157 | break; | ||
158 | case UHS_HID_BOOT_KEY_CAPS_LOCK: | ||
159 | kbdLockingKeys.kbdLeds.bmCapsLock = ~kbdLockingKeys.kbdLeds.bmCapsLock; | ||
160 | break; | ||
161 | case UHS_HID_BOOT_KEY_SCROLL_LOCK: | ||
162 | kbdLockingKeys.kbdLeds.bmScrollLock = ~kbdLockingKeys.kbdLeds.bmScrollLock; | ||
163 | break; | ||
164 | } | ||
165 | |||
166 | if(old_keys != kbdLockingKeys.bLeds && hid) | ||
167 | return (hid->SetReport(0, 0/*hid->GetIface()*/, 2, 0, 1, &kbdLockingKeys.bLeds)); | ||
168 | |||
169 | return 0; | ||
170 | }; | ||
171 | |||
172 | virtual void OnControlKeysChanged(uint8_t before, uint8_t after) { | ||
173 | }; | ||
174 | |||
175 | virtual void OnKeyDown(uint8_t mod, uint8_t key) { | ||
176 | }; | ||
177 | |||
178 | virtual void OnKeyUp(uint8_t mod, uint8_t key) { | ||
179 | }; | ||
180 | |||
181 | virtual const uint8_t *getNumKeys() { | ||
182 | return numKeys; | ||
183 | }; | ||
184 | |||
185 | virtual const uint8_t *getSymKeysUp() { | ||
186 | return symKeysUp; | ||
187 | }; | ||
188 | |||
189 | virtual const uint8_t *getSymKeysLo() { | ||
190 | return symKeysLo; | ||
191 | }; | ||
192 | |||
193 | virtual const uint8_t *getPadKeys() { | ||
194 | return padKeys; | ||
195 | }; | ||
196 | }; | ||
197 | |||
198 | template <const uint8_t BOOT_PROTOCOL> | ||
199 | class HIDBoot : public HID //public USBDeviceConfig, public UsbConfigXtracter | ||
200 | { | ||
201 | EpInfo epInfo[totalEndpoints(BOOT_PROTOCOL)]; | ||
202 | HIDReportParser *pRptParser[epMUL(BOOT_PROTOCOL)]; | ||
203 | |||
204 | uint8_t bConfNum; // configuration number | ||
205 | uint8_t bIfaceNum; // Interface Number | ||
206 | uint8_t bNumIface; // number of interfaces in the configuration | ||
207 | uint8_t bNumEP; // total number of EP in the configuration | ||
208 | uint32_t qNextPollTime; // next poll time | ||
209 | bool bPollEnable; // poll enable flag | ||
210 | uint8_t bInterval; // largest interval | ||
211 | |||
212 | void Initialize(); | ||
213 | |||
214 | virtual HIDReportParser* GetReportParser(uint8_t id) { | ||
215 | return pRptParser[id]; | ||
216 | }; | ||
217 | |||
218 | public: | ||
219 | HIDBoot(USB *p); | ||
220 | |||
221 | virtual bool SetReportParser(uint8_t id, HIDReportParser *prs) { | ||
222 | pRptParser[id] = prs; | ||
223 | return true; | ||
224 | }; | ||
225 | |||
226 | // USBDeviceConfig implementation | ||
227 | uint8_t Init(uint8_t parent, uint8_t port, bool lowspeed); | ||
228 | uint8_t Release(); | ||
229 | uint8_t Poll(); | ||
230 | |||
231 | virtual uint8_t GetAddress() { | ||
232 | return bAddress; | ||
233 | }; | ||
234 | |||
235 | virtual bool isReady() { | ||
236 | return bPollEnable; | ||
237 | }; | ||
238 | |||
239 | // UsbConfigXtracter implementation | ||
240 | // Method should be defined here if virtual. | ||
241 | virtual void EndpointXtract(uint8_t conf, uint8_t iface, uint8_t alt, uint8_t proto, const USB_ENDPOINT_DESCRIPTOR *ep); | ||
242 | |||
243 | virtual bool DEVCLASSOK(uint8_t klass) { | ||
244 | return (klass == USB_CLASS_HID); | ||
245 | } | ||
246 | |||
247 | virtual bool DEVSUBCLASSOK(uint8_t subklass) { | ||
248 | return (subklass == BOOT_PROTOCOL); | ||
249 | } | ||
250 | }; | ||
251 | |||
252 | template <const uint8_t BOOT_PROTOCOL> | ||
253 | HIDBoot<BOOT_PROTOCOL>::HIDBoot(USB *p) : | ||
254 | HID(p), | ||
255 | qNextPollTime(0), | ||
256 | bPollEnable(false) { | ||
257 | Initialize(); | ||
258 | |||
259 | for(int i = 0; i < epMUL(BOOT_PROTOCOL); i++) { | ||
260 | pRptParser[i] = NULL; | ||
261 | } | ||
262 | if(pUsb) | ||
263 | pUsb->RegisterDeviceClass(this); | ||
264 | } | ||
265 | |||
266 | template <const uint8_t BOOT_PROTOCOL> | ||
267 | void HIDBoot<BOOT_PROTOCOL>::Initialize() { | ||
268 | for(int i = 0; i < totalEndpoints(BOOT_PROTOCOL); i++) { | ||
269 | epInfo[i].epAddr = 0; | ||
270 | epInfo[i].maxPktSize = (i) ? 0 : 8; | ||
271 | epInfo[i].epAttribs = 0; | ||
272 | epInfo[i].bmNakPower = (i) ? USB_NAK_NOWAIT : USB_NAK_MAX_POWER; | ||
273 | } | ||
274 | bNumEP = 1; | ||
275 | bNumIface = 0; | ||
276 | bConfNum = 0; | ||
277 | } | ||
278 | |||
279 | template <const uint8_t BOOT_PROTOCOL> | ||
280 | uint8_t HIDBoot<BOOT_PROTOCOL>::Init(uint8_t parent, uint8_t port, bool lowspeed) { | ||
281 | const uint8_t constBufSize = sizeof (USB_DEVICE_DESCRIPTOR); | ||
282 | |||
283 | uint8_t buf[constBufSize]; | ||
284 | uint8_t rcode; | ||
285 | UsbDevice *p = NULL; | ||
286 | EpInfo *oldep_ptr = NULL; | ||
287 | uint8_t len = 0; | ||
288 | //uint16_t cd_len = 0; | ||
289 | |||
290 | uint8_t num_of_conf; // number of configurations | ||
291 | //uint8_t num_of_intf; // number of interfaces | ||
292 | |||
293 | AddressPool &addrPool = pUsb->GetAddressPool(); | ||
294 | |||
295 | USBTRACE("BM Init\r\n"); | ||
296 | //USBTRACE2("totalEndpoints:", (uint8_t) (totalEndpoints(BOOT_PROTOCOL))); | ||
297 | //USBTRACE2("epMUL:", epMUL(BOOT_PROTOCOL)); | ||
298 | |||
299 | if(bAddress) | ||
300 | return USB_ERROR_CLASS_INSTANCE_ALREADY_IN_USE; | ||
301 | |||
302 | bInterval = 0; | ||
303 | // Get pointer to pseudo device with address 0 assigned | ||
304 | p = addrPool.GetUsbDevicePtr(0); | ||
305 | |||
306 | if(!p) | ||
307 | return USB_ERROR_ADDRESS_NOT_FOUND_IN_POOL; | ||
308 | |||
309 | if(!p->epinfo) { | ||
310 | USBTRACE("epinfo\r\n"); | ||
311 | return USB_ERROR_EPINFO_IS_NULL; | ||
312 | } | ||
313 | |||
314 | // Save old pointer to EP_RECORD of address 0 | ||
315 | oldep_ptr = p->epinfo; | ||
316 | |||
317 | // Temporary assign new pointer to epInfo to p->epinfo in order to avoid toggle inconsistence | ||
318 | p->epinfo = epInfo; | ||
319 | |||
320 | p->lowspeed = lowspeed; | ||
321 | |||
322 | // Get device descriptor | ||
323 | rcode = pUsb->getDevDescr(0, 0, 8, (uint8_t*)buf); | ||
324 | |||
325 | if(!rcode) | ||
326 | len = (buf[0] > constBufSize) ? constBufSize : buf[0]; | ||
327 | |||
328 | if(rcode) { | ||
329 | // Restore p->epinfo | ||
330 | p->epinfo = oldep_ptr; | ||
331 | |||
332 | goto FailGetDevDescr; | ||
333 | } | ||
334 | |||
335 | // Restore p->epinfo | ||
336 | p->epinfo = oldep_ptr; | ||
337 | |||
338 | // Allocate new address according to device class | ||
339 | bAddress = addrPool.AllocAddress(parent, false, port); | ||
340 | |||
341 | if(!bAddress) | ||
342 | return USB_ERROR_OUT_OF_ADDRESS_SPACE_IN_POOL; | ||
343 | |||
344 | // Extract Max Packet Size from the device descriptor | ||
345 | epInfo[0].maxPktSize = (uint8_t)((USB_DEVICE_DESCRIPTOR*)buf)->bMaxPacketSize0; | ||
346 | |||
347 | // Assign new address to the device | ||
348 | rcode = pUsb->setAddr(0, 0, bAddress); | ||
349 | |||
350 | if(rcode) { | ||
351 | p->lowspeed = false; | ||
352 | addrPool.FreeAddress(bAddress); | ||
353 | bAddress = 0; | ||
354 | USBTRACE2("setAddr:", rcode); | ||
355 | return rcode; | ||
356 | } | ||
357 | //delay(2); //per USB 2.0 sect.9.2.6.3 | ||
358 | |||
359 | USBTRACE2("Addr:", bAddress); | ||
360 | |||
361 | p->lowspeed = false; | ||
362 | |||
363 | p = addrPool.GetUsbDevicePtr(bAddress); | ||
364 | |||
365 | if(!p) | ||
366 | return USB_ERROR_ADDRESS_NOT_FOUND_IN_POOL; | ||
367 | |||
368 | p->lowspeed = lowspeed; | ||
369 | |||
370 | if(len) | ||
371 | rcode = pUsb->getDevDescr(bAddress, 0, len, (uint8_t*)buf); | ||
372 | |||
373 | if(rcode) | ||
374 | goto FailGetDevDescr; | ||
375 | |||
376 | num_of_conf = ((USB_DEVICE_DESCRIPTOR*)buf)->bNumConfigurations; | ||
377 | |||
378 | USBTRACE2("NC:", num_of_conf); | ||
379 | |||
380 | // GCC will optimize unused stuff away. | ||
381 | if((BOOT_PROTOCOL & (HID_PROTOCOL_KEYBOARD | HID_PROTOCOL_MOUSE)) == (HID_PROTOCOL_KEYBOARD | HID_PROTOCOL_MOUSE)) { | ||
382 | USBTRACE("HID_PROTOCOL_KEYBOARD AND MOUSE\r\n"); | ||
383 | ConfigDescParser< | ||
384 | USB_CLASS_HID, | ||
385 | HID_BOOT_INTF_SUBCLASS, | ||
386 | HID_PROTOCOL_KEYBOARD | HID_PROTOCOL_MOUSE, | ||
387 | CP_MASK_COMPARE_ALL > confDescrParser(this); | ||
388 | confDescrParser.SetOR(); // Use the OR variant. | ||
389 | for(uint8_t i = 0; i < num_of_conf; i++) { | ||
390 | pUsb->getConfDescr(bAddress, 0, i, &confDescrParser); | ||
391 | if(bNumEP == (uint8_t)(totalEndpoints(BOOT_PROTOCOL))) | ||
392 | break; | ||
393 | } | ||
394 | } else { | ||
395 | // GCC will optimize unused stuff away. | ||
396 | if(BOOT_PROTOCOL & HID_PROTOCOL_KEYBOARD) { | ||
397 | USBTRACE("HID_PROTOCOL_KEYBOARD\r\n"); | ||
398 | for(uint8_t i = 0; i < num_of_conf; i++) { | ||
399 | ConfigDescParser< | ||
400 | USB_CLASS_HID, | ||
401 | HID_BOOT_INTF_SUBCLASS, | ||
402 | HID_PROTOCOL_KEYBOARD, | ||
403 | CP_MASK_COMPARE_ALL> confDescrParserA(this); | ||
404 | |||
405 | pUsb->getConfDescr(bAddress, 0, i, &confDescrParserA); | ||
406 | if(bNumEP == (uint8_t)(totalEndpoints(BOOT_PROTOCOL))) | ||
407 | break; | ||
408 | } | ||
409 | } | ||
410 | |||
411 | // GCC will optimize unused stuff away. | ||
412 | if(BOOT_PROTOCOL & HID_PROTOCOL_MOUSE) { | ||
413 | USBTRACE("HID_PROTOCOL_MOUSE\r\n"); | ||
414 | for(uint8_t i = 0; i < num_of_conf; i++) { | ||
415 | ConfigDescParser< | ||
416 | USB_CLASS_HID, | ||
417 | HID_BOOT_INTF_SUBCLASS, | ||
418 | HID_PROTOCOL_MOUSE, | ||
419 | CP_MASK_COMPARE_ALL> confDescrParserB(this); | ||
420 | |||
421 | pUsb->getConfDescr(bAddress, 0, i, &confDescrParserB); | ||
422 | if(bNumEP == ((uint8_t)(totalEndpoints(BOOT_PROTOCOL)))) | ||
423 | break; | ||
424 | |||
425 | } | ||
426 | } | ||
427 | } | ||
428 | USBTRACE2("bNumEP:", bNumEP); | ||
429 | |||
430 | if(bNumEP != (uint8_t)(totalEndpoints(BOOT_PROTOCOL))) { | ||
431 | rcode = USB_DEV_CONFIG_ERROR_DEVICE_NOT_SUPPORTED; | ||
432 | goto Fail; | ||
433 | } | ||
434 | |||
435 | // Assign epInfo to epinfo pointer | ||
436 | rcode = pUsb->setEpInfoEntry(bAddress, bNumEP, epInfo); | ||
437 | //USBTRACE2("setEpInfoEntry returned ", rcode); | ||
438 | USBTRACE2("Cnf:", bConfNum); | ||
439 | |||
440 | delay(1000); | ||
441 | |||
442 | // Set Configuration Value | ||
443 | rcode = pUsb->setConf(bAddress, 0, bConfNum); | ||
444 | |||
445 | if(rcode) | ||
446 | goto FailSetConfDescr; | ||
447 | |||
448 | delay(1000); | ||
449 | |||
450 | USBTRACE2("bIfaceNum:", bIfaceNum); | ||
451 | USBTRACE2("bNumIface:", bNumIface); | ||
452 | |||
453 | // Yes, mouse wants SetProtocol and SetIdle too! | ||
454 | for(uint8_t i = 0; i < epMUL(BOOT_PROTOCOL); i++) { | ||
455 | USBTRACE2("\r\nInterface:", i); | ||
456 | rcode = SetProtocol(i, HID_BOOT_PROTOCOL); | ||
457 | if(rcode) goto FailSetProtocol; | ||
458 | USBTRACE2("PROTOCOL SET HID_BOOT rcode:", rcode); | ||
459 | rcode = SetIdle(i, 0, 0); | ||
460 | USBTRACE2("SET_IDLE rcode:", rcode); | ||
461 | // if(rcode) goto FailSetIdle; This can fail. | ||
462 | // Get the RPIPE and just throw it away. | ||
463 | SinkParser<USBReadParser, uint16_t, uint16_t> sink; | ||
464 | rcode = GetReportDescr(i, &sink); | ||
465 | USBTRACE2("RPIPE rcode:", rcode); | ||
466 | } | ||
467 | |||
468 | // Get RPIPE and throw it away. | ||
469 | |||
470 | if(BOOT_PROTOCOL & HID_PROTOCOL_KEYBOARD) { | ||
471 | // Wake keyboard interface by twinkling up to 5 LEDs that are in the spec. | ||
472 | // kana, compose, scroll, caps, num | ||
473 | rcode = 0x20; // Reuse rcode. | ||
474 | while(rcode) { | ||
475 | rcode >>= 1; | ||
476 | // Ignore any error returned, we don't care if LED is not supported | ||
477 | SetReport(0, 0, 2, 0, 1, &rcode); // Eventually becomes zero (All off) | ||
478 | delay(25); | ||
479 | } | ||
480 | } | ||
481 | USBTRACE("BM configured\r\n"); | ||
482 | |||
483 | bPollEnable = true; | ||
484 | return 0; | ||
485 | |||
486 | FailGetDevDescr: | ||
487 | #ifdef DEBUG_USB_HOST | ||
488 | NotifyFailGetDevDescr(); | ||
489 | goto Fail; | ||
490 | #endif | ||
491 | |||
492 | //FailSetDevTblEntry: | ||
493 | //#ifdef DEBUG_USB_HOST | ||
494 | // NotifyFailSetDevTblEntry(); | ||
495 | // goto Fail; | ||
496 | //#endif | ||
497 | |||
498 | //FailGetConfDescr: | ||
499 | //#ifdef DEBUG_USB_HOST | ||
500 | // NotifyFailGetConfDescr(); | ||
501 | // goto Fail; | ||
502 | //#endif | ||
503 | |||
504 | FailSetConfDescr: | ||
505 | #ifdef DEBUG_USB_HOST | ||
506 | NotifyFailSetConfDescr(); | ||
507 | goto Fail; | ||
508 | #endif | ||
509 | |||
510 | FailSetProtocol: | ||
511 | #ifdef DEBUG_USB_HOST | ||
512 | USBTRACE("SetProto:"); | ||
513 | goto Fail; | ||
514 | #endif | ||
515 | |||
516 | //FailSetIdle: | ||
517 | //#ifdef DEBUG_USB_HOST | ||
518 | // USBTRACE("SetIdle:"); | ||
519 | //#endif | ||
520 | |||
521 | Fail: | ||
522 | #ifdef DEBUG_USB_HOST | ||
523 | NotifyFail(rcode); | ||
524 | #endif | ||
525 | Release(); | ||
526 | |||
527 | return rcode; | ||
528 | } | ||
529 | |||
530 | template <const uint8_t BOOT_PROTOCOL> | ||
531 | void HIDBoot<BOOT_PROTOCOL>::EndpointXtract(uint8_t conf, uint8_t iface, uint8_t alt, uint8_t proto, const USB_ENDPOINT_DESCRIPTOR *pep) { | ||
532 | |||
533 | // If the first configuration satisfies, the others are not considered. | ||
534 | //if(bNumEP > 1 && conf != bConfNum) | ||
535 | if(bNumEP == totalEndpoints(BOOT_PROTOCOL)) | ||
536 | return; | ||
537 | |||
538 | bConfNum = conf; | ||
539 | bIfaceNum = iface; | ||
540 | |||
541 | if((pep->bmAttributes & 0x03) == 3 && (pep->bEndpointAddress & 0x80) == 0x80) { | ||
542 | if(pep->bInterval > bInterval) bInterval = pep->bInterval; | ||
543 | |||
544 | // Fill in the endpoint info structure | ||
545 | epInfo[bNumEP].epAddr = (pep->bEndpointAddress & 0x0F); | ||
546 | epInfo[bNumEP].maxPktSize = (uint8_t)pep->wMaxPacketSize; | ||
547 | epInfo[bNumEP].epAttribs = 0; | ||
548 | epInfo[bNumEP].bmNakPower = USB_NAK_NOWAIT; | ||
549 | bNumEP++; | ||
550 | |||
551 | } | ||
552 | } | ||
553 | |||
554 | template <const uint8_t BOOT_PROTOCOL> | ||
555 | uint8_t HIDBoot<BOOT_PROTOCOL>::Release() { | ||
556 | pUsb->GetAddressPool().FreeAddress(bAddress); | ||
557 | |||
558 | bConfNum = 0; | ||
559 | bIfaceNum = 0; | ||
560 | bNumEP = 1; | ||
561 | bAddress = 0; | ||
562 | qNextPollTime = 0; | ||
563 | bPollEnable = false; | ||
564 | |||
565 | return 0; | ||
566 | } | ||
567 | |||
568 | template <const uint8_t BOOT_PROTOCOL> | ||
569 | uint8_t HIDBoot<BOOT_PROTOCOL>::Poll() { | ||
570 | uint8_t rcode = 0; | ||
571 | |||
572 | if(bPollEnable && ((long)(millis() - qNextPollTime) >= 0L)) { | ||
573 | |||
574 | // To-do: optimize manually, using the for loop only if needed. | ||
575 | for(int i = 0; i < epMUL(BOOT_PROTOCOL); i++) { | ||
576 | const uint16_t const_buff_len = 16; | ||
577 | uint8_t buf[const_buff_len]; | ||
578 | |||
579 | USBTRACE3("(hidboot.h) i=", i, 0x81); | ||
580 | USBTRACE3("(hidboot.h) epInfo[epInterruptInIndex + i].epAddr=", epInfo[epInterruptInIndex + i].epAddr, 0x81); | ||
581 | USBTRACE3("(hidboot.h) epInfo[epInterruptInIndex + i].maxPktSize=", epInfo[epInterruptInIndex + i].maxPktSize, 0x81); | ||
582 | uint16_t read = (uint16_t)epInfo[epInterruptInIndex + i].maxPktSize; | ||
583 | |||
584 | rcode = pUsb->inTransfer(bAddress, epInfo[epInterruptInIndex + i].epAddr, &read, buf); | ||
585 | // SOME buggy dongles report extra keys (like sleep) using a 2 byte packet on the wrong endpoint. | ||
586 | // Since keyboard and mice must report at least 3 bytes, we ignore the extra data. | ||
587 | if(!rcode && read > 2) { | ||
588 | if(pRptParser[i]) | ||
589 | pRptParser[i]->Parse((HID*)this, 0, (uint8_t)read, buf); | ||
590 | #ifdef DEBUG_USB_HOST | ||
591 | // We really don't care about errors and anomalies unless we are debugging. | ||
592 | } else { | ||
593 | if(rcode != hrNAK) { | ||
594 | USBTRACE3("(hidboot.h) Poll:", rcode, 0x81); | ||
595 | } | ||
596 | if(!rcode && read) { | ||
597 | USBTRACE3("(hidboot.h) Strange read count: ", read, 0x80); | ||
598 | USBTRACE3("(hidboot.h) Interface:", i, 0x80); | ||
599 | } | ||
600 | } | ||
601 | |||
602 | if(!rcode && read && (UsbDEBUGlvl > 0x7f)) { | ||
603 | for(uint8_t i = 0; i < read; i++) { | ||
604 | PrintHex<uint8_t > (buf[i], 0x80); | ||
605 | USBTRACE1(" ", 0x80); | ||
606 | } | ||
607 | if(read) | ||
608 | USBTRACE1("\r\n", 0x80); | ||
609 | #endif | ||
610 | } | ||
611 | |||
612 | } | ||
613 | qNextPollTime = millis() + bInterval; | ||
614 | } | ||
615 | return rcode; | ||
616 | } | ||
617 | |||
618 | #endif // __HIDBOOTMOUSE_H__ | ||