Changeset 110c692 in avrstuff


Ignore:
Timestamp:
Feb 7, 2023, 6:24:17 PM (15 months ago)
Author:
PulkoMandy <pulkomandy@…>
Branches:
main
Children:
8d96947
Parents:
a6ad6e8
git-author:
Adrien Destugues <adrien.destugues@…> (07/02/2023 12:57:25)
git-committer:
PulkoMandy <pulkomandy@…> (07/02/2023 18:24:17)
Message:

pcw2hid: start hacking the code together

Completely untested. Keyboard scan should be working (if the CPU is fast
enough). Not sure if waiting for the host to ask for a report before we
start scanning the keyboard is a good idea, or if we should do that
under pin change interrupt. HID descriptor is not written yet and
probably the keyboard matrix should be shuffled around to match the
descriptor?

Location:
kbd/pcw2hid/code
Files:
1 added
1 deleted
2 edited
2 moved

Legend:

Unmodified
Added
Removed

  • kbd/pcw2hid/code/Descriptors.c

    ra6ad6e8 r110c692  
    111111                                HID_RI_END_COLLECTION(0),
    112112
    113                         HID_RI_END_COLLECTION(0),
    114 
    115                         HID_RI_USAGE_PAGE(8, 0x01),
    116                         HID_RI_USAGE(8, 0x04),
    117                         HID_RI_COLLECTION(8, 0x01),
    118 
    119                                 0x85, 0x02, // Report ID 2
    120 
    121                                 // 15 constant bytes
    122                                 HID_RI_REPORT_SIZE(8, 15),
    123                                 HID_RI_REPORT_COUNT(8, 0x01),
    124                                 HID_RI_INPUT(8, HID_IOF_CONSTANT),
    125 
    126                                 HID_RI_USAGE_PAGE(8, 0x09),
    127                                 HID_RI_LOGICAL_MINIMUM(8, 0x00),
    128                                 HID_RI_LOGICAL_MAXIMUM(8, 0x01),
    129 
    130                                 HID_RI_USAGE_MINIMUM(8, 7),
    131                                 HID_RI_USAGE_MAXIMUM(8, 9),
    132                                 HID_RI_USAGE(8, 4),
    133                                 HID_RI_REPORT_SIZE(8, 0x01),
    134                                 HID_RI_REPORT_COUNT(8, 4),
    135                                 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    136 
    137                                 HID_RI_REPORT_SIZE(8, 1),
    138                                 HID_RI_REPORT_COUNT(8, 0x01),
    139                                 HID_RI_INPUT(8, HID_IOF_CONSTANT),
    140 
    141                                 HID_RI_USAGE(8, 10),
    142                                 HID_RI_USAGE_MINIMUM(8, 1),
    143                                 HID_RI_USAGE_MAXIMUM(8, 3),
    144                                 HID_RI_REPORT_SIZE(8, 0x01),
    145                                 HID_RI_REPORT_COUNT(8, 4),
    146                                 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    147 
    148                                 HID_RI_REPORT_SIZE(8, 1),
    149                                 HID_RI_REPORT_COUNT(8, 0x01),
    150                                 HID_RI_INPUT(8, HID_IOF_CONSTANT),
    151 
    152                                 HID_RI_USAGE_MINIMUM(8, 5),
    153                                 HID_RI_USAGE_MAXIMUM(8, 6),
    154                                 HID_RI_REPORT_SIZE(8, 0x01),
    155                                 HID_RI_REPORT_COUNT(8, 2),
    156                                 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    157 
    158                                 HID_RI_USAGE_PAGE(8, 0x01),
    159                                 HID_RI_USAGE(8, 0x01),
    160                                 HID_RI_COLLECTION(8, 0x00),
    161                                         HID_RI_USAGE(8, 0x31),
    162                                         HID_RI_LOGICAL_MINIMUM(8, -2),
    163                                         HID_RI_LOGICAL_MAXIMUM(8, 1),
    164                                         HID_RI_REPORT_COUNT(8, 1),
    165                                         HID_RI_REPORT_SIZE(8, 2),
    166                                         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    167 
    168                                         HID_RI_REPORT_SIZE(8, 1),
    169                                         HID_RI_REPORT_COUNT(8, 0x01),
    170                                         HID_RI_INPUT(8, HID_IOF_CONSTANT),
    171 
    172                                         HID_RI_USAGE(8, 0x30),
    173                                         HID_RI_LOGICAL_MINIMUM(8, -2),
    174                                         HID_RI_LOGICAL_MAXIMUM(8, 1),
    175                                         HID_RI_REPORT_COUNT(8, 1),
    176                                         HID_RI_REPORT_SIZE(8, 2),
    177                                         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    178                                 HID_RI_END_COLLECTION(0),
    179 
    180                         HID_RI_END_COLLECTION(0),
    181 
    182                         HID_RI_USAGE_PAGE(8, 0x01),
    183                         HID_RI_USAGE(8, 0x04),
    184                         HID_RI_COLLECTION(8, 0x01),
    185 
    186                                 0x85, 0x03, // Report ID 3
    187 
    188                                 // 15 constant bytes
    189                                 HID_RI_REPORT_SIZE(8, 15),
    190                                 HID_RI_REPORT_COUNT(8, 0x01),
    191                                 HID_RI_INPUT(8, HID_IOF_CONSTANT),
    192 
    193                                 HID_RI_USAGE_PAGE(8, 0x09),
    194                                 HID_RI_LOGICAL_MINIMUM(8, 0x00),
    195                                 HID_RI_LOGICAL_MAXIMUM(8, 0x01),
    196 
    197                                 HID_RI_USAGE_MINIMUM(8, 7),
    198                                 HID_RI_USAGE_MAXIMUM(8, 9),
    199                                 HID_RI_USAGE(8, 4),
    200                                 HID_RI_REPORT_SIZE(8, 0x01),
    201                                 HID_RI_REPORT_COUNT(8, 4),
    202                                 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    203 
    204                                 HID_RI_REPORT_SIZE(8, 1),
    205                                 HID_RI_REPORT_COUNT(8, 0x01),
    206                                 HID_RI_INPUT(8, HID_IOF_CONSTANT),
    207 
    208                                 HID_RI_USAGE(8, 10),
    209                                 HID_RI_USAGE_MINIMUM(8, 1),
    210                                 HID_RI_USAGE_MAXIMUM(8, 3),
    211                                 HID_RI_REPORT_SIZE(8, 0x01),
    212                                 HID_RI_REPORT_COUNT(8, 4),
    213                                 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    214 
    215                                 HID_RI_REPORT_SIZE(8, 1),
    216                                 HID_RI_REPORT_COUNT(8, 0x01),
    217                                 HID_RI_INPUT(8, HID_IOF_CONSTANT),
    218 
    219                                 HID_RI_USAGE_MINIMUM(8, 5),
    220                                 HID_RI_USAGE_MAXIMUM(8, 6),
    221                                 HID_RI_REPORT_SIZE(8, 0x01),
    222                                 HID_RI_REPORT_COUNT(8, 2),
    223                                 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    224 
    225                                 HID_RI_USAGE_PAGE(8, 0x01),
    226                                 HID_RI_USAGE(8, 0x01),
    227                                 HID_RI_COLLECTION(8, 0x00),
    228                                         HID_RI_USAGE(8, 0x31),
    229                                         HID_RI_LOGICAL_MINIMUM(8, -2),
    230                                         HID_RI_LOGICAL_MAXIMUM(8, 1),
    231                                         HID_RI_REPORT_COUNT(8, 1),
    232                                         HID_RI_REPORT_SIZE(8, 2),
    233                                         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    234 
    235                                         HID_RI_REPORT_SIZE(8, 1),
    236                                         HID_RI_REPORT_COUNT(8, 0x01),
    237                                         HID_RI_INPUT(8, HID_IOF_CONSTANT),
    238 
    239                                         HID_RI_USAGE(8, 0x30),
    240                                         HID_RI_LOGICAL_MINIMUM(8, -2),
    241                                         HID_RI_LOGICAL_MAXIMUM(8, 1),
    242                                         HID_RI_REPORT_COUNT(8, 1),
    243                                         HID_RI_REPORT_SIZE(8, 2),
    244                                         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    245                                 HID_RI_END_COLLECTION(0),
    246 
    247                         HID_RI_END_COLLECTION(0),
    248 
    249                         HID_RI_USAGE_PAGE(8, 0x01),
    250                         HID_RI_USAGE(8, 0x04),
    251                         HID_RI_COLLECTION(8, 0x01),
    252 
    253                                 0x85, 0x04, // Report ID 4
    254 
    255                                 // 15 constant bytes
    256                                 HID_RI_REPORT_SIZE(8, 15),
    257                                 HID_RI_REPORT_COUNT(8, 0x01),
    258                                 HID_RI_INPUT(8, HID_IOF_CONSTANT),
    259 
    260                                 HID_RI_USAGE_PAGE(8, 0x09),
    261                                 HID_RI_LOGICAL_MINIMUM(8, 0x00),
    262                                 HID_RI_LOGICAL_MAXIMUM(8, 0x01),
    263 
    264                                 HID_RI_USAGE_MINIMUM(8, 7),
    265                                 HID_RI_USAGE_MAXIMUM(8, 9),
    266                                 HID_RI_USAGE(8, 4),
    267                                 HID_RI_REPORT_SIZE(8, 0x01),
    268                                 HID_RI_REPORT_COUNT(8, 4),
    269                                 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    270 
    271                                 HID_RI_REPORT_SIZE(8, 1),
    272                                 HID_RI_REPORT_COUNT(8, 0x01),
    273                                 HID_RI_INPUT(8, HID_IOF_CONSTANT),
    274 
    275                                 HID_RI_USAGE(8, 10),
    276                                 HID_RI_USAGE_MINIMUM(8, 1),
    277                                 HID_RI_USAGE_MAXIMUM(8, 3),
    278                                 HID_RI_REPORT_SIZE(8, 0x01),
    279                                 HID_RI_REPORT_COUNT(8, 4),
    280                                 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    281 
    282                                 HID_RI_REPORT_SIZE(8, 1),
    283                                 HID_RI_REPORT_COUNT(8, 0x01),
    284                                 HID_RI_INPUT(8, HID_IOF_CONSTANT),
    285 
    286                                 HID_RI_USAGE_MINIMUM(8, 5),
    287                                 HID_RI_USAGE_MAXIMUM(8, 6),
    288                                 HID_RI_REPORT_SIZE(8, 0x01),
    289                                 HID_RI_REPORT_COUNT(8, 2),
    290                                 HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    291 
    292                                 HID_RI_USAGE_PAGE(8, 0x01),
    293                                 HID_RI_USAGE(8, 0x01),
    294                                 HID_RI_COLLECTION(8, 0x00),
    295                                         HID_RI_USAGE(8, 0x31),
    296                                         HID_RI_LOGICAL_MINIMUM(8, -2),
    297                                         HID_RI_LOGICAL_MAXIMUM(8, 1),
    298                                         HID_RI_REPORT_COUNT(8, 1),
    299                                         HID_RI_REPORT_SIZE(8, 2),
    300                                         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    301 
    302                                         HID_RI_REPORT_SIZE(8, 1),
    303                                         HID_RI_REPORT_COUNT(8, 0x01),
    304                                         HID_RI_INPUT(8, HID_IOF_CONSTANT),
    305 
    306                                         HID_RI_USAGE(8, 0x30),
    307                                         HID_RI_LOGICAL_MINIMUM(8, -2),
    308                                         HID_RI_LOGICAL_MAXIMUM(8, 1),
    309                                         HID_RI_REPORT_COUNT(8, 1),
    310                                         HID_RI_REPORT_SIZE(8, 2),
    311                                         HID_RI_INPUT(8, HID_IOF_DATA | HID_IOF_VARIABLE | HID_IOF_ABSOLUTE),
    312                                 HID_RI_END_COLLECTION(0),
    313 
    314113                        HID_RI_END_COLLECTION(0)
    315114};
    … …  
    418217 *  Descriptor.
    419218 */
    420 const USB_Descriptor_String_t PROGMEM ProductString = USB_STRING_DESCRIPTOR(L"Gravis GrIP gamepads");
     219const USB_Descriptor_String_t PROGMEM ProductString = USB_STRING_DESCRIPTOR(L"Amstrad PCW Keyboard");
    421220
    422221/** This function is called by the library when in device mode, and must be overridden (see library "USB Descriptors"

  • kbd/pcw2hid/code/Descriptors.h

    ra6ad6e8 r110c692  
    8282
    8383                /** Size in bytes of the Joystick HID reporting IN endpoint. */
    84                 #define JOYSTICK_EPSIZE              8
     84                #define JOYSTICK_EPSIZE              16
    8585
    8686        /* Function Prototypes: */

  • kbd/pcw2hid/code/Keyboard.c

    ra6ad6e8 r110c692  
    3535 */
    3636
    37 #include "Joystick.h"
     37#include "Keyboard.h"
    3838
    39 extern void GrIP_Init();
    40 extern uint8_t GrIP_Read(uint32_t*, uint8_t);
     39extern void PCW_Init();
     40extern void scanall();
    4141
    4242/** Buffer to hold the previously generated HID report, for comparison purposes inside the HID class driver. */
    … …  
    104104
    105105        /* Hardware Initialization */
    106         GrIP_Init();
     106        PCW_Init();
    107107        LEDs_Init();
    108108        Buttons_Init();
    … …  
    162162                                         uint16_t* const ReportSize)
    163163{
    164         *ReportID = GrIP_Read(ReportData, *ReportID) + 1;
     164        uint8_t* matrix = scanall();
     165        *ReportID = 1;
    165166
    166         // Flip the up/down axis in the right direction for USB reports
    167         uint8_t* data = (uint8_t*)ReportData;
    168         uint8_t up = data[3] & 0x08;
    169         uint8_t down = data[3] & 0x10;
    170         data[3] ^= up | down;
    171         data[3] ^= (up << 1) | (down >> 1);
    172 
    173         *ReportSize = 4;
     167        *ReportSize = 16;
     168        for (int i = 0; i < 16; i++) {
     169                ReportData[i] = matrix[i];
     170        }
    174171        return true;
    175172}
Note: See TracChangeset for help on using the changeset viewer.