mirror of
https://github.com/gdsports/USBHost_t36
synced 2024-11-21 16:45:04 -05:00
99 lines
3.5 KiB
C++
99 lines
3.5 KiB
C++
/* USB EHCI Host for Teensy 3.6
|
|
* Copyright 2017 Paul Stoffregen (paul@pjrc.com)
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included
|
|
* in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
#include <Arduino.h>
|
|
#include "USBHost_t36.h" // Read this header first for key info
|
|
|
|
|
|
void KeyboardController::init()
|
|
{
|
|
contribute_Pipes(mypipes, sizeof(mypipes)/sizeof(Pipe_t));
|
|
contribute_Transfers(mytransfers, sizeof(mytransfers)/sizeof(Transfer_t));
|
|
driver_ready_for_device(this);
|
|
}
|
|
|
|
bool KeyboardController::claim(Device_t *dev, int type, const uint8_t *descriptors, uint32_t len)
|
|
{
|
|
println("KeyboardController claim this=", (uint32_t)this, HEX);
|
|
|
|
// only claim at interface level
|
|
if (type != 1) return false;
|
|
if (len < 9+9+7) return false;
|
|
|
|
uint32_t numendpoint = descriptors[4];
|
|
if (numendpoint < 1) return false;
|
|
if (descriptors[5] != 3) return false; // bInterfaceClass, 3 = HID
|
|
if (descriptors[6] != 1) return false; // bInterfaceSubClass, 1 = Boot Device
|
|
if (descriptors[7] != 1) return false; // bInterfaceProtocol, 1 = Keyboard
|
|
if (descriptors[9] != 9) return false;
|
|
if (descriptors[10] != 33) return false; // HID descriptor (ignored, Boot Protocol)
|
|
if (descriptors[18] != 7) return false;
|
|
if (descriptors[19] != 5) return false; // endpoint descriptor
|
|
uint32_t endpoint = descriptors[20];
|
|
println("ep = ", endpoint, HEX);
|
|
if ((endpoint & 0xF0) != 0x80) return false; // must be IN direction
|
|
endpoint &= 0x0F;
|
|
if (endpoint == 0) return false;
|
|
if (descriptors[21] != 3) return false; // must be interrupt type
|
|
uint32_t size = descriptors[22] | (descriptors[23] << 8);
|
|
println("packet size = ", size);
|
|
if (size != 8) return false; // must be 8 bytes for Keyboard Boot Protocol
|
|
uint32_t interval = descriptors[24];
|
|
println("polling interval = ", interval);
|
|
datapipe = new_Pipe(dev, 3, endpoint, 1, 8, interval);
|
|
datapipe->callback_function = callback;
|
|
queue_Data_Transfer(datapipe, report, 8, this);
|
|
mk_setup(setup, 0x21, 10, 0, 0, 0); // 10=SET_IDLE
|
|
queue_Control_Transfer(dev, &setup, NULL, this);
|
|
return true;
|
|
}
|
|
|
|
void KeyboardController::control(const Transfer_t *transfer)
|
|
{
|
|
}
|
|
|
|
void KeyboardController::callback(const Transfer_t *transfer)
|
|
{
|
|
println("KeyboardController Callback (static)");
|
|
if (transfer->driver) {
|
|
((KeyboardController *)(transfer->driver))->new_data(transfer);
|
|
}
|
|
}
|
|
|
|
void KeyboardController::new_data(const Transfer_t *transfer)
|
|
{
|
|
println("KeyboardController Callback (member)");
|
|
print(" KB Data: ");
|
|
print_hexbytes(transfer->buffer, 8);
|
|
// TODO: parse the new data
|
|
queue_Data_Transfer(datapipe, report, 8, this);
|
|
}
|
|
|
|
void KeyboardController::disconnect()
|
|
{
|
|
// TODO: free resources
|
|
}
|
|
|
|
|
|
|