From ceeb8a7b8369b60a6991537df170ef5e5c655e00 Mon Sep 17 00:00:00 2001 From: iretq Date: Sat, 25 Apr 2026 00:32:04 -0300 Subject: [PATCH] recipes: add evtest and libevdev --- patches/libevdev/jinx-working-patch.patch | 1813 +++++++++++++++++++++ recipes/evtest | 18 + recipes/libevdev | 18 + source-recipes/evtest | 10 + source-recipes/libevdev | 9 + 5 files changed, 1868 insertions(+) create mode 100644 patches/libevdev/jinx-working-patch.patch create mode 100644 recipes/evtest create mode 100644 recipes/libevdev create mode 100644 source-recipes/evtest create mode 100644 source-recipes/libevdev diff --git a/patches/libevdev/jinx-working-patch.patch b/patches/libevdev/jinx-working-patch.patch new file mode 100644 index 00000000..b80bae0a --- /dev/null +++ b/patches/libevdev/jinx-working-patch.patch @@ -0,0 +1,1813 @@ +diff --git libevdev-workdir/include/linux/astral/input-event-codes.h libevdev-workdir/include/linux/astral/input-event-codes.h +new file mode 100644 +index 0000000..30f3c9e +--- /dev/null ++++ libevdev-workdir/include/linux/astral/input-event-codes.h +@@ -0,0 +1,1003 @@ ++/* SPDX-License-Identifier: GPL-2.0-only WITH Linux-syscall-note */ ++/* ++ * Input event codes ++ * ++ * *** IMPORTANT *** ++ * This file is not only included from C-code but also from devicetree source ++ * files. As such this file MUST only contain comments and defines. ++ * ++ * Copyright (c) 1999-2002 Vojtech Pavlik ++ * Copyright (c) 2015 Hans de Goede ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 as published by ++ * the Free Software Foundation. ++ */ ++#ifndef _UAPI_INPUT_EVENT_CODES_H ++#define _UAPI_INPUT_EVENT_CODES_H ++ ++/* ++ * Device properties and quirks ++ */ ++ ++#define INPUT_PROP_POINTER 0x00 /* needs a pointer */ ++#define INPUT_PROP_DIRECT 0x01 /* direct input devices */ ++#define INPUT_PROP_BUTTONPAD 0x02 /* has button(s) under pad */ ++#define INPUT_PROP_SEMI_MT 0x03 /* touch rectangle only */ ++#define INPUT_PROP_TOPBUTTONPAD 0x04 /* softbuttons at top of pad */ ++#define INPUT_PROP_POINTING_STICK 0x05 /* is a pointing stick */ ++#define INPUT_PROP_ACCELEROMETER 0x06 /* has accelerometer */ ++#define INPUT_PROP_PRESSUREPAD 0x07 /* pressure triggers clicks */ ++ ++#define INPUT_PROP_MAX 0x1f ++#define INPUT_PROP_CNT (INPUT_PROP_MAX + 1) ++ ++/* ++ * Event types ++ */ ++ ++#define EV_SYN 0x00 ++#define EV_KEY 0x01 ++#define EV_REL 0x02 ++#define EV_ABS 0x03 ++#define EV_MSC 0x04 ++#define EV_SW 0x05 ++#define EV_LED 0x11 ++#define EV_SND 0x12 ++#define EV_REP 0x14 ++#define EV_FF 0x15 ++#define EV_PWR 0x16 ++#define EV_FF_STATUS 0x17 ++#define EV_MAX 0x1f ++#define EV_CNT (EV_MAX+1) ++ ++/* ++ * Synchronization events. ++ */ ++ ++#define SYN_REPORT 0 ++#define SYN_CONFIG 1 ++#define SYN_MT_REPORT 2 ++#define SYN_DROPPED 3 ++#define SYN_MAX 0xf ++#define SYN_CNT (SYN_MAX+1) ++ ++/* ++ * Keys and buttons ++ * ++ * Most of the keys/buttons are modeled after USB HUT 1.12 ++ * (see http://www.usb.org/developers/hidpage). ++ * Abbreviations in the comments: ++ * AC - Application Control ++ * AL - Application Launch Button ++ * SC - System Control ++ */ ++ ++#define KEY_RESERVED 0 ++#define KEY_ESC 1 ++#define KEY_1 2 ++#define KEY_2 3 ++#define KEY_3 4 ++#define KEY_4 5 ++#define KEY_5 6 ++#define KEY_6 7 ++#define KEY_7 8 ++#define KEY_8 9 ++#define KEY_9 10 ++#define KEY_0 11 ++#define KEY_MINUS 12 ++#define KEY_EQUAL 13 ++#define KEY_BACKSPACE 14 ++#define KEY_TAB 15 ++#define KEY_Q 16 ++#define KEY_W 17 ++#define KEY_E 18 ++#define KEY_R 19 ++#define KEY_T 20 ++#define KEY_Y 21 ++#define KEY_U 22 ++#define KEY_I 23 ++#define KEY_O 24 ++#define KEY_P 25 ++#define KEY_LEFTBRACE 26 ++#define KEY_RIGHTBRACE 27 ++#define KEY_ENTER 28 ++#define KEY_LEFTCTRL 29 ++#define KEY_A 30 ++#define KEY_S 31 ++#define KEY_D 32 ++#define KEY_F 33 ++#define KEY_G 34 ++#define KEY_H 35 ++#define KEY_J 36 ++#define KEY_K 37 ++#define KEY_L 38 ++#define KEY_SEMICOLON 39 ++#define KEY_APOSTROPHE 40 ++#define KEY_GRAVE 41 ++#define KEY_LEFTSHIFT 42 ++#define KEY_BACKSLASH 43 ++#define KEY_Z 44 ++#define KEY_X 45 ++#define KEY_C 46 ++#define KEY_V 47 ++#define KEY_B 48 ++#define KEY_N 49 ++#define KEY_M 50 ++#define KEY_COMMA 51 ++#define KEY_DOT 52 ++#define KEY_SLASH 53 ++#define KEY_RIGHTSHIFT 54 ++#define KEY_KPASTERISK 55 ++#define KEY_LEFTALT 56 ++#define KEY_SPACE 57 ++#define KEY_CAPSLOCK 58 ++#define KEY_F1 59 ++#define KEY_F2 60 ++#define KEY_F3 61 ++#define KEY_F4 62 ++#define KEY_F5 63 ++#define KEY_F6 64 ++#define KEY_F7 65 ++#define KEY_F8 66 ++#define KEY_F9 67 ++#define KEY_F10 68 ++#define KEY_NUMLOCK 69 ++#define KEY_SCROLLLOCK 70 ++#define KEY_KP7 71 ++#define KEY_KP8 72 ++#define KEY_KP9 73 ++#define KEY_KPMINUS 74 ++#define KEY_KP4 75 ++#define KEY_KP5 76 ++#define KEY_KP6 77 ++#define KEY_KPPLUS 78 ++#define KEY_KP1 79 ++#define KEY_KP2 80 ++#define KEY_KP3 81 ++#define KEY_KP0 82 ++#define KEY_KPDOT 83 ++ ++#define KEY_ZENKAKUHANKAKU 85 ++#define KEY_102ND 86 ++#define KEY_F11 87 ++#define KEY_F12 88 ++#define KEY_RO 89 ++#define KEY_KATAKANA 90 ++#define KEY_HIRAGANA 91 ++#define KEY_HENKAN 92 ++#define KEY_KATAKANAHIRAGANA 93 ++#define KEY_MUHENKAN 94 ++#define KEY_KPJPCOMMA 95 ++#define KEY_KPENTER 96 ++#define KEY_RIGHTCTRL 97 ++#define KEY_KPSLASH 98 ++#define KEY_SYSRQ 99 ++#define KEY_RIGHTALT 100 ++#define KEY_LINEFEED 101 ++#define KEY_HOME 102 ++#define KEY_UP 103 ++#define KEY_PAGEUP 104 ++#define KEY_LEFT 105 ++#define KEY_RIGHT 106 ++#define KEY_END 107 ++#define KEY_DOWN 108 ++#define KEY_PAGEDOWN 109 ++#define KEY_INSERT 110 ++#define KEY_DELETE 111 ++#define KEY_MACRO 112 ++#define KEY_MUTE 113 ++#define KEY_VOLUMEDOWN 114 ++#define KEY_VOLUMEUP 115 ++#define KEY_POWER 116 /* SC System Power Down */ ++#define KEY_KPEQUAL 117 ++#define KEY_KPPLUSMINUS 118 ++#define KEY_PAUSE 119 ++#define KEY_SCALE 120 /* AL Compiz Scale (Expose) */ ++ ++#define KEY_KPCOMMA 121 ++#define KEY_HANGEUL 122 ++#define KEY_HANGUEL KEY_HANGEUL ++#define KEY_HANJA 123 ++#define KEY_YEN 124 ++#define KEY_LEFTMETA 125 ++#define KEY_RIGHTMETA 126 ++#define KEY_COMPOSE 127 ++ ++#define KEY_STOP 128 /* AC Stop */ ++#define KEY_AGAIN 129 ++#define KEY_PROPS 130 /* AC Properties */ ++#define KEY_UNDO 131 /* AC Undo */ ++#define KEY_FRONT 132 ++#define KEY_COPY 133 /* AC Copy */ ++#define KEY_OPEN 134 /* AC Open */ ++#define KEY_PASTE 135 /* AC Paste */ ++#define KEY_FIND 136 /* AC Search */ ++#define KEY_CUT 137 /* AC Cut */ ++#define KEY_HELP 138 /* AL Integrated Help Center */ ++#define KEY_MENU 139 /* Menu (show menu) */ ++#define KEY_CALC 140 /* AL Calculator */ ++#define KEY_SETUP 141 ++#define KEY_SLEEP 142 /* SC System Sleep */ ++#define KEY_WAKEUP 143 /* System Wake Up */ ++#define KEY_FILE 144 /* AL Local Machine Browser */ ++#define KEY_SENDFILE 145 ++#define KEY_DELETEFILE 146 ++#define KEY_XFER 147 ++#define KEY_PROG1 148 ++#define KEY_PROG2 149 ++#define KEY_WWW 150 /* AL Internet Browser */ ++#define KEY_MSDOS 151 ++#define KEY_COFFEE 152 /* AL Terminal Lock/Screensaver */ ++#define KEY_SCREENLOCK KEY_COFFEE ++#define KEY_ROTATE_DISPLAY 153 /* Display orientation for e.g. tablets */ ++#define KEY_DIRECTION KEY_ROTATE_DISPLAY ++#define KEY_CYCLEWINDOWS 154 ++#define KEY_MAIL 155 ++#define KEY_BOOKMARKS 156 /* AC Bookmarks */ ++#define KEY_COMPUTER 157 ++#define KEY_BACK 158 /* AC Back */ ++#define KEY_FORWARD 159 /* AC Forward */ ++#define KEY_CLOSECD 160 ++#define KEY_EJECTCD 161 ++#define KEY_EJECTCLOSECD 162 ++#define KEY_NEXTSONG 163 ++#define KEY_PLAYPAUSE 164 ++#define KEY_PREVIOUSSONG 165 ++#define KEY_STOPCD 166 ++#define KEY_RECORD 167 ++#define KEY_REWIND 168 ++#define KEY_PHONE 169 /* Media Select Telephone */ ++#define KEY_ISO 170 ++#define KEY_CONFIG 171 /* AL Consumer Control Configuration */ ++#define KEY_HOMEPAGE 172 /* AC Home */ ++#define KEY_REFRESH 173 /* AC Refresh */ ++#define KEY_EXIT 174 /* AC Exit */ ++#define KEY_MOVE 175 ++#define KEY_EDIT 176 ++#define KEY_SCROLLUP 177 ++#define KEY_SCROLLDOWN 178 ++#define KEY_KPLEFTPAREN 179 ++#define KEY_KPRIGHTPAREN 180 ++#define KEY_NEW 181 /* AC New */ ++#define KEY_REDO 182 /* AC Redo/Repeat */ ++ ++#define KEY_F13 183 ++#define KEY_F14 184 ++#define KEY_F15 185 ++#define KEY_F16 186 ++#define KEY_F17 187 ++#define KEY_F18 188 ++#define KEY_F19 189 ++#define KEY_F20 190 ++#define KEY_F21 191 ++#define KEY_F22 192 ++#define KEY_F23 193 ++#define KEY_F24 194 ++ ++#define KEY_PLAYCD 200 ++#define KEY_PAUSECD 201 ++#define KEY_PROG3 202 ++#define KEY_PROG4 203 ++#define KEY_ALL_APPLICATIONS 204 /* AC Desktop Show All Applications */ ++#define KEY_DASHBOARD KEY_ALL_APPLICATIONS ++#define KEY_SUSPEND 205 ++#define KEY_CLOSE 206 /* AC Close */ ++#define KEY_PLAY 207 ++#define KEY_FASTFORWARD 208 ++#define KEY_BASSBOOST 209 ++#define KEY_PRINT 210 /* AC Print */ ++#define KEY_HP 211 ++#define KEY_CAMERA 212 ++#define KEY_SOUND 213 ++#define KEY_QUESTION 214 ++#define KEY_EMAIL 215 ++#define KEY_CHAT 216 ++#define KEY_SEARCH 217 ++#define KEY_CONNECT 218 ++#define KEY_FINANCE 219 /* AL Checkbook/Finance */ ++#define KEY_SPORT 220 ++#define KEY_SHOP 221 ++#define KEY_ALTERASE 222 ++#define KEY_CANCEL 223 /* AC Cancel */ ++#define KEY_BRIGHTNESSDOWN 224 ++#define KEY_BRIGHTNESSUP 225 ++#define KEY_MEDIA 226 ++ ++#define KEY_SWITCHVIDEOMODE 227 /* Cycle between available video ++ outputs (Monitor/LCD/TV-out/etc) */ ++#define KEY_KBDILLUMTOGGLE 228 ++#define KEY_KBDILLUMDOWN 229 ++#define KEY_KBDILLUMUP 230 ++ ++#define KEY_SEND 231 /* AC Send */ ++#define KEY_REPLY 232 /* AC Reply */ ++#define KEY_FORWARDMAIL 233 /* AC Forward Msg */ ++#define KEY_SAVE 234 /* AC Save */ ++#define KEY_DOCUMENTS 235 ++ ++#define KEY_BATTERY 236 ++ ++#define KEY_BLUETOOTH 237 ++#define KEY_WLAN 238 ++#define KEY_UWB 239 ++ ++#define KEY_UNKNOWN 240 ++ ++#define KEY_VIDEO_NEXT 241 /* drive next video source */ ++#define KEY_VIDEO_PREV 242 /* drive previous video source */ ++#define KEY_BRIGHTNESS_CYCLE 243 /* brightness up, after max is min */ ++#define KEY_BRIGHTNESS_AUTO 244 /* Set Auto Brightness: manual ++ brightness control is off, ++ rely on ambient */ ++#define KEY_BRIGHTNESS_ZERO KEY_BRIGHTNESS_AUTO ++#define KEY_DISPLAY_OFF 245 /* display device to off state */ ++ ++#define KEY_WWAN 246 /* Wireless WAN (LTE, UMTS, GSM, etc.) */ ++#define KEY_WIMAX KEY_WWAN ++#define KEY_RFKILL 247 /* Key that controls all radios */ ++ ++#define KEY_MICMUTE 248 /* Mute / unmute the microphone */ ++ ++/* Code 255 is reserved for special needs of AT keyboard driver */ ++ ++#define BTN_MISC 0x100 ++#define BTN_0 0x100 ++#define BTN_1 0x101 ++#define BTN_2 0x102 ++#define BTN_3 0x103 ++#define BTN_4 0x104 ++#define BTN_5 0x105 ++#define BTN_6 0x106 ++#define BTN_7 0x107 ++#define BTN_8 0x108 ++#define BTN_9 0x109 ++ ++#define BTN_MOUSE 0x110 ++#define BTN_LEFT 0x110 ++#define BTN_RIGHT 0x111 ++#define BTN_MIDDLE 0x112 ++#define BTN_SIDE 0x113 ++#define BTN_EXTRA 0x114 ++#define BTN_FORWARD 0x115 ++#define BTN_BACK 0x116 ++#define BTN_TASK 0x117 ++ ++#define BTN_JOYSTICK 0x120 ++#define BTN_TRIGGER 0x120 ++#define BTN_THUMB 0x121 ++#define BTN_THUMB2 0x122 ++#define BTN_TOP 0x123 ++#define BTN_TOP2 0x124 ++#define BTN_PINKIE 0x125 ++#define BTN_BASE 0x126 ++#define BTN_BASE2 0x127 ++#define BTN_BASE3 0x128 ++#define BTN_BASE4 0x129 ++#define BTN_BASE5 0x12a ++#define BTN_BASE6 0x12b ++#define BTN_DEAD 0x12f ++ ++#define BTN_GAMEPAD 0x130 ++#define BTN_SOUTH 0x130 ++#define BTN_A BTN_SOUTH ++#define BTN_EAST 0x131 ++#define BTN_B BTN_EAST ++#define BTN_C 0x132 ++#define BTN_NORTH 0x133 ++#define BTN_X BTN_NORTH ++#define BTN_WEST 0x134 ++#define BTN_Y BTN_WEST ++#define BTN_Z 0x135 ++#define BTN_TL 0x136 ++#define BTN_TR 0x137 ++#define BTN_TL2 0x138 ++#define BTN_TR2 0x139 ++#define BTN_SELECT 0x13a ++#define BTN_START 0x13b ++#define BTN_MODE 0x13c ++#define BTN_THUMBL 0x13d ++#define BTN_THUMBR 0x13e ++ ++#define BTN_DIGI 0x140 ++#define BTN_TOOL_PEN 0x140 ++#define BTN_TOOL_RUBBER 0x141 ++#define BTN_TOOL_BRUSH 0x142 ++#define BTN_TOOL_PENCIL 0x143 ++#define BTN_TOOL_AIRBRUSH 0x144 ++#define BTN_TOOL_FINGER 0x145 ++#define BTN_TOOL_MOUSE 0x146 ++#define BTN_TOOL_LENS 0x147 ++#define BTN_TOOL_QUINTTAP 0x148 /* Five fingers on trackpad */ ++#define BTN_STYLUS3 0x149 ++#define BTN_TOUCH 0x14a ++#define BTN_STYLUS 0x14b ++#define BTN_STYLUS2 0x14c ++#define BTN_TOOL_DOUBLETAP 0x14d ++#define BTN_TOOL_TRIPLETAP 0x14e ++#define BTN_TOOL_QUADTAP 0x14f /* Four fingers on trackpad */ ++ ++#define BTN_WHEEL 0x150 ++#define BTN_GEAR_DOWN 0x150 ++#define BTN_GEAR_UP 0x151 ++ ++#define KEY_OK 0x160 ++#define KEY_SELECT 0x161 ++#define KEY_GOTO 0x162 ++#define KEY_CLEAR 0x163 ++#define KEY_POWER2 0x164 ++#define KEY_OPTION 0x165 ++#define KEY_INFO 0x166 /* AL OEM Features/Tips/Tutorial */ ++#define KEY_TIME 0x167 ++#define KEY_VENDOR 0x168 ++#define KEY_ARCHIVE 0x169 ++#define KEY_PROGRAM 0x16a /* Media Select Program Guide */ ++#define KEY_CHANNEL 0x16b ++#define KEY_FAVORITES 0x16c ++#define KEY_EPG 0x16d ++#define KEY_PVR 0x16e /* Media Select Home */ ++#define KEY_MHP 0x16f ++#define KEY_LANGUAGE 0x170 ++#define KEY_TITLE 0x171 ++#define KEY_SUBTITLE 0x172 ++#define KEY_ANGLE 0x173 ++#define KEY_FULL_SCREEN 0x174 /* AC View Toggle */ ++#define KEY_ZOOM KEY_FULL_SCREEN ++#define KEY_MODE 0x175 ++#define KEY_KEYBOARD 0x176 ++#define KEY_ASPECT_RATIO 0x177 /* HUTRR37: Aspect */ ++#define KEY_SCREEN KEY_ASPECT_RATIO ++#define KEY_PC 0x178 /* Media Select Computer */ ++#define KEY_TV 0x179 /* Media Select TV */ ++#define KEY_TV2 0x17a /* Media Select Cable */ ++#define KEY_VCR 0x17b /* Media Select VCR */ ++#define KEY_VCR2 0x17c /* VCR Plus */ ++#define KEY_SAT 0x17d /* Media Select Satellite */ ++#define KEY_SAT2 0x17e ++#define KEY_CD 0x17f /* Media Select CD */ ++#define KEY_TAPE 0x180 /* Media Select Tape */ ++#define KEY_RADIO 0x181 ++#define KEY_TUNER 0x182 /* Media Select Tuner */ ++#define KEY_PLAYER 0x183 ++#define KEY_TEXT 0x184 ++#define KEY_DVD 0x185 /* Media Select DVD */ ++#define KEY_AUX 0x186 ++#define KEY_MP3 0x187 ++#define KEY_AUDIO 0x188 /* AL Audio Browser */ ++#define KEY_VIDEO 0x189 /* AL Movie Browser */ ++#define KEY_DIRECTORY 0x18a ++#define KEY_LIST 0x18b ++#define KEY_MEMO 0x18c /* Media Select Messages */ ++#define KEY_CALENDAR 0x18d ++#define KEY_RED 0x18e ++#define KEY_GREEN 0x18f ++#define KEY_YELLOW 0x190 ++#define KEY_BLUE 0x191 ++#define KEY_CHANNELUP 0x192 /* Channel Increment */ ++#define KEY_CHANNELDOWN 0x193 /* Channel Decrement */ ++#define KEY_FIRST 0x194 ++#define KEY_LAST 0x195 /* Recall Last */ ++#define KEY_AB 0x196 ++#define KEY_NEXT 0x197 ++#define KEY_RESTART 0x198 ++#define KEY_SLOW 0x199 ++#define KEY_SHUFFLE 0x19a ++#define KEY_BREAK 0x19b ++#define KEY_PREVIOUS 0x19c ++#define KEY_DIGITS 0x19d ++#define KEY_TEEN 0x19e ++#define KEY_TWEN 0x19f ++#define KEY_VIDEOPHONE 0x1a0 /* Media Select Video Phone */ ++#define KEY_GAMES 0x1a1 /* Media Select Games */ ++#define KEY_ZOOMIN 0x1a2 /* AC Zoom In */ ++#define KEY_ZOOMOUT 0x1a3 /* AC Zoom Out */ ++#define KEY_ZOOMRESET 0x1a4 /* AC Zoom */ ++#define KEY_WORDPROCESSOR 0x1a5 /* AL Word Processor */ ++#define KEY_EDITOR 0x1a6 /* AL Text Editor */ ++#define KEY_SPREADSHEET 0x1a7 /* AL Spreadsheet */ ++#define KEY_GRAPHICSEDITOR 0x1a8 /* AL Graphics Editor */ ++#define KEY_PRESENTATION 0x1a9 /* AL Presentation App */ ++#define KEY_DATABASE 0x1aa /* AL Database App */ ++#define KEY_NEWS 0x1ab /* AL Newsreader */ ++#define KEY_VOICEMAIL 0x1ac /* AL Voicemail */ ++#define KEY_ADDRESSBOOK 0x1ad /* AL Contacts/Address Book */ ++#define KEY_MESSENGER 0x1ae /* AL Instant Messaging */ ++#define KEY_DISPLAYTOGGLE 0x1af /* Turn display (LCD) on and off */ ++#define KEY_BRIGHTNESS_TOGGLE KEY_DISPLAYTOGGLE ++#define KEY_SPELLCHECK 0x1b0 /* AL Spell Check */ ++#define KEY_LOGOFF 0x1b1 /* AL Logoff */ ++ ++#define KEY_DOLLAR 0x1b2 ++#define KEY_EURO 0x1b3 ++ ++#define KEY_FRAMEBACK 0x1b4 /* Consumer - transport controls */ ++#define KEY_FRAMEFORWARD 0x1b5 ++#define KEY_CONTEXT_MENU 0x1b6 /* GenDesc - system context menu */ ++#define KEY_MEDIA_REPEAT 0x1b7 /* Consumer - transport control */ ++#define KEY_10CHANNELSUP 0x1b8 /* 10 channels up (10+) */ ++#define KEY_10CHANNELSDOWN 0x1b9 /* 10 channels down (10-) */ ++#define KEY_IMAGES 0x1ba /* AL Image Browser */ ++#define KEY_NOTIFICATION_CENTER 0x1bc /* Show/hide the notification center */ ++#define KEY_PICKUP_PHONE 0x1bd /* Answer incoming call */ ++#define KEY_HANGUP_PHONE 0x1be /* Decline incoming call */ ++#define KEY_LINK_PHONE 0x1bf /* AL Phone Syncing */ ++ ++#define KEY_DEL_EOL 0x1c0 ++#define KEY_DEL_EOS 0x1c1 ++#define KEY_INS_LINE 0x1c2 ++#define KEY_DEL_LINE 0x1c3 ++ ++#define KEY_FN 0x1d0 ++#define KEY_FN_ESC 0x1d1 ++#define KEY_FN_F1 0x1d2 ++#define KEY_FN_F2 0x1d3 ++#define KEY_FN_F3 0x1d4 ++#define KEY_FN_F4 0x1d5 ++#define KEY_FN_F5 0x1d6 ++#define KEY_FN_F6 0x1d7 ++#define KEY_FN_F7 0x1d8 ++#define KEY_FN_F8 0x1d9 ++#define KEY_FN_F9 0x1da ++#define KEY_FN_F10 0x1db ++#define KEY_FN_F11 0x1dc ++#define KEY_FN_F12 0x1dd ++#define KEY_FN_1 0x1de ++#define KEY_FN_2 0x1df ++#define KEY_FN_D 0x1e0 ++#define KEY_FN_E 0x1e1 ++#define KEY_FN_F 0x1e2 ++#define KEY_FN_S 0x1e3 ++#define KEY_FN_B 0x1e4 ++#define KEY_FN_RIGHT_SHIFT 0x1e5 ++ ++#define KEY_BRL_DOT1 0x1f1 ++#define KEY_BRL_DOT2 0x1f2 ++#define KEY_BRL_DOT3 0x1f3 ++#define KEY_BRL_DOT4 0x1f4 ++#define KEY_BRL_DOT5 0x1f5 ++#define KEY_BRL_DOT6 0x1f6 ++#define KEY_BRL_DOT7 0x1f7 ++#define KEY_BRL_DOT8 0x1f8 ++#define KEY_BRL_DOT9 0x1f9 ++#define KEY_BRL_DOT10 0x1fa ++ ++#define KEY_NUMERIC_0 0x200 /* used by phones, remote controls, */ ++#define KEY_NUMERIC_1 0x201 /* and other keypads */ ++#define KEY_NUMERIC_2 0x202 ++#define KEY_NUMERIC_3 0x203 ++#define KEY_NUMERIC_4 0x204 ++#define KEY_NUMERIC_5 0x205 ++#define KEY_NUMERIC_6 0x206 ++#define KEY_NUMERIC_7 0x207 ++#define KEY_NUMERIC_8 0x208 ++#define KEY_NUMERIC_9 0x209 ++#define KEY_NUMERIC_STAR 0x20a ++#define KEY_NUMERIC_POUND 0x20b ++#define KEY_NUMERIC_A 0x20c /* Phone key A - HUT Telephony 0xb9 */ ++#define KEY_NUMERIC_B 0x20d ++#define KEY_NUMERIC_C 0x20e ++#define KEY_NUMERIC_D 0x20f ++ ++#define KEY_CAMERA_FOCUS 0x210 ++#define KEY_WPS_BUTTON 0x211 /* WiFi Protected Setup key */ ++ ++#define KEY_TOUCHPAD_TOGGLE 0x212 /* Request switch touchpad on or off */ ++#define KEY_TOUCHPAD_ON 0x213 ++#define KEY_TOUCHPAD_OFF 0x214 ++ ++#define KEY_CAMERA_ZOOMIN 0x215 ++#define KEY_CAMERA_ZOOMOUT 0x216 ++#define KEY_CAMERA_UP 0x217 ++#define KEY_CAMERA_DOWN 0x218 ++#define KEY_CAMERA_LEFT 0x219 ++#define KEY_CAMERA_RIGHT 0x21a ++ ++#define KEY_ATTENDANT_ON 0x21b ++#define KEY_ATTENDANT_OFF 0x21c ++#define KEY_ATTENDANT_TOGGLE 0x21d /* Attendant call on or off */ ++#define KEY_LIGHTS_TOGGLE 0x21e /* Reading light on or off */ ++ ++#define BTN_DPAD_UP 0x220 ++#define BTN_DPAD_DOWN 0x221 ++#define BTN_DPAD_LEFT 0x222 ++#define BTN_DPAD_RIGHT 0x223 ++ ++#define BTN_GRIPL 0x224 ++#define BTN_GRIPR 0x225 ++#define BTN_GRIPL2 0x226 ++#define BTN_GRIPR2 0x227 ++ ++#define KEY_ALS_TOGGLE 0x230 /* Ambient light sensor */ ++#define KEY_ROTATE_LOCK_TOGGLE 0x231 /* Display rotation lock */ ++#define KEY_REFRESH_RATE_TOGGLE 0x232 /* Display refresh rate toggle */ ++ ++#define KEY_BUTTONCONFIG 0x240 /* AL Button Configuration */ ++#define KEY_TASKMANAGER 0x241 /* AL Task/Project Manager */ ++#define KEY_JOURNAL 0x242 /* AL Log/Journal/Timecard */ ++#define KEY_CONTROLPANEL 0x243 /* AL Control Panel */ ++#define KEY_APPSELECT 0x244 /* AL Select Task/Application */ ++#define KEY_SCREENSAVER 0x245 /* AL Screen Saver */ ++#define KEY_VOICECOMMAND 0x246 /* Listening Voice Command */ ++#define KEY_ASSISTANT 0x247 /* AL Context-aware desktop assistant */ ++#define KEY_KBD_LAYOUT_NEXT 0x248 /* AC Next Keyboard Layout Select */ ++#define KEY_EMOJI_PICKER 0x249 /* Show/hide emoji picker (HUTRR101) */ ++#define KEY_DICTATE 0x24a /* Start or Stop Voice Dictation Session (HUTRR99) */ ++#define KEY_CAMERA_ACCESS_ENABLE 0x24b /* Enables programmatic access to camera devices. (HUTRR72) */ ++#define KEY_CAMERA_ACCESS_DISABLE 0x24c /* Disables programmatic access to camera devices. (HUTRR72) */ ++#define KEY_CAMERA_ACCESS_TOGGLE 0x24d /* Toggles the current state of the camera access control. (HUTRR72) */ ++#define KEY_ACCESSIBILITY 0x24e /* Toggles the system bound accessibility UI/command (HUTRR116) */ ++#define KEY_DO_NOT_DISTURB 0x24f /* Toggles the system-wide "Do Not Disturb" control (HUTRR94)*/ ++ ++#define KEY_BRIGHTNESS_MIN 0x250 /* Set Brightness to Minimum */ ++#define KEY_BRIGHTNESS_MAX 0x251 /* Set Brightness to Maximum */ ++ ++/* ++ * Keycodes for hotkeys toggling the electronic privacy screen found on some ++ * laptops on/off. Note when the embedded-controller turns on/off the eprivacy ++ * screen itself then the state should be reported through drm connecter props: ++ * https://www.kernel.org/doc/html/latest/gpu/drm-kms.html#standard-connector-properties ++ * Except when implementing the drm connecter properties API is not possible ++ * because e.g. the firmware does not allow querying the presence and/or status ++ * of the eprivacy screen at boot. ++ */ ++#define KEY_EPRIVACY_SCREEN_ON 0x252 ++#define KEY_EPRIVACY_SCREEN_OFF 0x253 ++ ++#define KEY_KBDINPUTASSIST_PREV 0x260 ++#define KEY_KBDINPUTASSIST_NEXT 0x261 ++#define KEY_KBDINPUTASSIST_PREVGROUP 0x262 ++#define KEY_KBDINPUTASSIST_NEXTGROUP 0x263 ++#define KEY_KBDINPUTASSIST_ACCEPT 0x264 ++#define KEY_KBDINPUTASSIST_CANCEL 0x265 ++ ++/* Diagonal movement keys */ ++#define KEY_RIGHT_UP 0x266 ++#define KEY_RIGHT_DOWN 0x267 ++#define KEY_LEFT_UP 0x268 ++#define KEY_LEFT_DOWN 0x269 ++ ++#define KEY_ROOT_MENU 0x26a /* Show Device's Root Menu */ ++/* Show Top Menu of the Media (e.g. DVD) */ ++#define KEY_MEDIA_TOP_MENU 0x26b ++#define KEY_NUMERIC_11 0x26c ++#define KEY_NUMERIC_12 0x26d ++/* ++ * Toggle Audio Description: refers to an audio service that helps blind and ++ * visually impaired consumers understand the action in a program. Note: in ++ * some countries this is referred to as "Video Description". ++ */ ++#define KEY_AUDIO_DESC 0x26e ++#define KEY_3D_MODE 0x26f ++#define KEY_NEXT_FAVORITE 0x270 ++#define KEY_STOP_RECORD 0x271 ++#define KEY_PAUSE_RECORD 0x272 ++#define KEY_VOD 0x273 /* Video on Demand */ ++#define KEY_UNMUTE 0x274 ++#define KEY_FASTREVERSE 0x275 ++#define KEY_SLOWREVERSE 0x276 ++/* ++ * Control a data application associated with the currently viewed channel, ++ * e.g. teletext or data broadcast application (MHEG, MHP, HbbTV, etc.) ++ */ ++#define KEY_DATA 0x277 ++#define KEY_ONSCREEN_KEYBOARD 0x278 ++/* Electronic privacy screen control */ ++#define KEY_PRIVACY_SCREEN_TOGGLE 0x279 ++ ++/* Select an area of screen to be copied */ ++#define KEY_SELECTIVE_SCREENSHOT 0x27a ++ ++/* Move the focus to the next or previous user controllable element within a UI container */ ++#define KEY_NEXT_ELEMENT 0x27b ++#define KEY_PREVIOUS_ELEMENT 0x27c ++ ++/* Toggle Autopilot engagement */ ++#define KEY_AUTOPILOT_ENGAGE_TOGGLE 0x27d ++ ++/* Shortcut Keys */ ++#define KEY_MARK_WAYPOINT 0x27e ++#define KEY_SOS 0x27f ++#define KEY_NAV_CHART 0x280 ++#define KEY_FISHING_CHART 0x281 ++#define KEY_SINGLE_RANGE_RADAR 0x282 ++#define KEY_DUAL_RANGE_RADAR 0x283 ++#define KEY_RADAR_OVERLAY 0x284 ++#define KEY_TRADITIONAL_SONAR 0x285 ++#define KEY_CLEARVU_SONAR 0x286 ++#define KEY_SIDEVU_SONAR 0x287 ++#define KEY_NAV_INFO 0x288 ++#define KEY_BRIGHTNESS_MENU 0x289 ++ ++/* ++ * Some keyboards have keys which do not have a defined meaning, these keys ++ * are intended to be programmed / bound to macros by the user. For most ++ * keyboards with these macro-keys the key-sequence to inject, or action to ++ * take, is all handled by software on the host side. So from the kernel's ++ * point of view these are just normal keys. ++ * ++ * The KEY_MACRO# codes below are intended for such keys, which may be labeled ++ * e.g. G1-G18, or S1 - S30. The KEY_MACRO# codes MUST NOT be used for keys ++ * where the marking on the key does indicate a defined meaning / purpose. ++ * ++ * The KEY_MACRO# codes MUST also NOT be used as fallback for when no existing ++ * KEY_FOO define matches the marking / purpose. In this case a new KEY_FOO ++ * define MUST be added. ++ */ ++#define KEY_MACRO1 0x290 ++#define KEY_MACRO2 0x291 ++#define KEY_MACRO3 0x292 ++#define KEY_MACRO4 0x293 ++#define KEY_MACRO5 0x294 ++#define KEY_MACRO6 0x295 ++#define KEY_MACRO7 0x296 ++#define KEY_MACRO8 0x297 ++#define KEY_MACRO9 0x298 ++#define KEY_MACRO10 0x299 ++#define KEY_MACRO11 0x29a ++#define KEY_MACRO12 0x29b ++#define KEY_MACRO13 0x29c ++#define KEY_MACRO14 0x29d ++#define KEY_MACRO15 0x29e ++#define KEY_MACRO16 0x29f ++#define KEY_MACRO17 0x2a0 ++#define KEY_MACRO18 0x2a1 ++#define KEY_MACRO19 0x2a2 ++#define KEY_MACRO20 0x2a3 ++#define KEY_MACRO21 0x2a4 ++#define KEY_MACRO22 0x2a5 ++#define KEY_MACRO23 0x2a6 ++#define KEY_MACRO24 0x2a7 ++#define KEY_MACRO25 0x2a8 ++#define KEY_MACRO26 0x2a9 ++#define KEY_MACRO27 0x2aa ++#define KEY_MACRO28 0x2ab ++#define KEY_MACRO29 0x2ac ++#define KEY_MACRO30 0x2ad ++ ++/* ++ * Some keyboards with the macro-keys described above have some extra keys ++ * for controlling the host-side software responsible for the macro handling: ++ * -A macro recording start/stop key. Note that not all keyboards which emit ++ * KEY_MACRO_RECORD_START will also emit KEY_MACRO_RECORD_STOP if ++ * KEY_MACRO_RECORD_STOP is not advertised, then KEY_MACRO_RECORD_START ++ * should be interpreted as a recording start/stop toggle; ++ * -Keys for switching between different macro (pre)sets, either a key for ++ * cycling through the configured presets or keys to directly select a preset. ++ */ ++#define KEY_MACRO_RECORD_START 0x2b0 ++#define KEY_MACRO_RECORD_STOP 0x2b1 ++#define KEY_MACRO_PRESET_CYCLE 0x2b2 ++#define KEY_MACRO_PRESET1 0x2b3 ++#define KEY_MACRO_PRESET2 0x2b4 ++#define KEY_MACRO_PRESET3 0x2b5 ++ ++/* ++ * Some keyboards have a buildin LCD panel where the contents are controlled ++ * by the host. Often these have a number of keys directly below the LCD ++ * intended for controlling a menu shown on the LCD. These keys often don't ++ * have any labeling so we just name them KEY_KBD_LCD_MENU# ++ */ ++#define KEY_KBD_LCD_MENU1 0x2b8 ++#define KEY_KBD_LCD_MENU2 0x2b9 ++#define KEY_KBD_LCD_MENU3 0x2ba ++#define KEY_KBD_LCD_MENU4 0x2bb ++#define KEY_KBD_LCD_MENU5 0x2bc ++ ++/* Performance Boost key (Alienware)/G-Mode key (Dell) */ ++#define KEY_PERFORMANCE 0x2bd ++ ++#define BTN_TRIGGER_HAPPY 0x2c0 ++#define BTN_TRIGGER_HAPPY1 0x2c0 ++#define BTN_TRIGGER_HAPPY2 0x2c1 ++#define BTN_TRIGGER_HAPPY3 0x2c2 ++#define BTN_TRIGGER_HAPPY4 0x2c3 ++#define BTN_TRIGGER_HAPPY5 0x2c4 ++#define BTN_TRIGGER_HAPPY6 0x2c5 ++#define BTN_TRIGGER_HAPPY7 0x2c6 ++#define BTN_TRIGGER_HAPPY8 0x2c7 ++#define BTN_TRIGGER_HAPPY9 0x2c8 ++#define BTN_TRIGGER_HAPPY10 0x2c9 ++#define BTN_TRIGGER_HAPPY11 0x2ca ++#define BTN_TRIGGER_HAPPY12 0x2cb ++#define BTN_TRIGGER_HAPPY13 0x2cc ++#define BTN_TRIGGER_HAPPY14 0x2cd ++#define BTN_TRIGGER_HAPPY15 0x2ce ++#define BTN_TRIGGER_HAPPY16 0x2cf ++#define BTN_TRIGGER_HAPPY17 0x2d0 ++#define BTN_TRIGGER_HAPPY18 0x2d1 ++#define BTN_TRIGGER_HAPPY19 0x2d2 ++#define BTN_TRIGGER_HAPPY20 0x2d3 ++#define BTN_TRIGGER_HAPPY21 0x2d4 ++#define BTN_TRIGGER_HAPPY22 0x2d5 ++#define BTN_TRIGGER_HAPPY23 0x2d6 ++#define BTN_TRIGGER_HAPPY24 0x2d7 ++#define BTN_TRIGGER_HAPPY25 0x2d8 ++#define BTN_TRIGGER_HAPPY26 0x2d9 ++#define BTN_TRIGGER_HAPPY27 0x2da ++#define BTN_TRIGGER_HAPPY28 0x2db ++#define BTN_TRIGGER_HAPPY29 0x2dc ++#define BTN_TRIGGER_HAPPY30 0x2dd ++#define BTN_TRIGGER_HAPPY31 0x2de ++#define BTN_TRIGGER_HAPPY32 0x2df ++#define BTN_TRIGGER_HAPPY33 0x2e0 ++#define BTN_TRIGGER_HAPPY34 0x2e1 ++#define BTN_TRIGGER_HAPPY35 0x2e2 ++#define BTN_TRIGGER_HAPPY36 0x2e3 ++#define BTN_TRIGGER_HAPPY37 0x2e4 ++#define BTN_TRIGGER_HAPPY38 0x2e5 ++#define BTN_TRIGGER_HAPPY39 0x2e6 ++#define BTN_TRIGGER_HAPPY40 0x2e7 ++ ++/* We avoid low common keys in module aliases so they don't get huge. */ ++#define KEY_MIN_INTERESTING KEY_MUTE ++#define KEY_MAX 0x2ff ++#define KEY_CNT (KEY_MAX+1) ++ ++/* ++ * Relative axes ++ */ ++ ++#define REL_X 0x00 ++#define REL_Y 0x01 ++#define REL_Z 0x02 ++#define REL_RX 0x03 ++#define REL_RY 0x04 ++#define REL_RZ 0x05 ++#define REL_HWHEEL 0x06 ++#define REL_DIAL 0x07 ++#define REL_WHEEL 0x08 ++#define REL_MISC 0x09 ++/* ++ * 0x0a is reserved and should not be used in input drivers. ++ * It was used by HID as REL_MISC+1 and userspace needs to detect if ++ * the next REL_* event is correct or is just REL_MISC + n. ++ * We define here REL_RESERVED so userspace can rely on it and detect ++ * the situation described above. ++ */ ++#define REL_RESERVED 0x0a ++#define REL_WHEEL_HI_RES 0x0b ++#define REL_HWHEEL_HI_RES 0x0c ++#define REL_MAX 0x0f ++#define REL_CNT (REL_MAX+1) ++ ++/* ++ * Absolute axes ++ */ ++ ++#define ABS_X 0x00 ++#define ABS_Y 0x01 ++#define ABS_Z 0x02 ++#define ABS_RX 0x03 ++#define ABS_RY 0x04 ++#define ABS_RZ 0x05 ++#define ABS_THROTTLE 0x06 ++#define ABS_RUDDER 0x07 ++#define ABS_WHEEL 0x08 ++#define ABS_GAS 0x09 ++#define ABS_BRAKE 0x0a ++#define ABS_HAT0X 0x10 ++#define ABS_HAT0Y 0x11 ++#define ABS_HAT1X 0x12 ++#define ABS_HAT1Y 0x13 ++#define ABS_HAT2X 0x14 ++#define ABS_HAT2Y 0x15 ++#define ABS_HAT3X 0x16 ++#define ABS_HAT3Y 0x17 ++#define ABS_PRESSURE 0x18 ++#define ABS_DISTANCE 0x19 ++#define ABS_TILT_X 0x1a ++#define ABS_TILT_Y 0x1b ++#define ABS_TOOL_WIDTH 0x1c ++ ++#define ABS_VOLUME 0x20 ++#define ABS_PROFILE 0x21 ++ ++#define ABS_MISC 0x28 ++ ++/* ++ * 0x2e is reserved and should not be used in input drivers. ++ * It was used by HID as ABS_MISC+6 and userspace needs to detect if ++ * the next ABS_* event is correct or is just ABS_MISC + n. ++ * We define here ABS_RESERVED so userspace can rely on it and detect ++ * the situation described above. ++ */ ++#define ABS_RESERVED 0x2e ++ ++#define ABS_MT_SLOT 0x2f /* MT slot being modified */ ++#define ABS_MT_TOUCH_MAJOR 0x30 /* Major axis of touching ellipse */ ++#define ABS_MT_TOUCH_MINOR 0x31 /* Minor axis (omit if circular) */ ++#define ABS_MT_WIDTH_MAJOR 0x32 /* Major axis of approaching ellipse */ ++#define ABS_MT_WIDTH_MINOR 0x33 /* Minor axis (omit if circular) */ ++#define ABS_MT_ORIENTATION 0x34 /* Ellipse orientation */ ++#define ABS_MT_POSITION_X 0x35 /* Center X touch position */ ++#define ABS_MT_POSITION_Y 0x36 /* Center Y touch position */ ++#define ABS_MT_TOOL_TYPE 0x37 /* Type of touching device */ ++#define ABS_MT_BLOB_ID 0x38 /* Group a set of packets as a blob */ ++#define ABS_MT_TRACKING_ID 0x39 /* Unique ID of initiated contact */ ++#define ABS_MT_PRESSURE 0x3a /* Pressure on contact area */ ++#define ABS_MT_DISTANCE 0x3b /* Contact hover distance */ ++#define ABS_MT_TOOL_X 0x3c /* Center X tool position */ ++#define ABS_MT_TOOL_Y 0x3d /* Center Y tool position */ ++ ++ ++#define ABS_MAX 0x3f ++#define ABS_CNT (ABS_MAX+1) ++ ++/* ++ * Switch events ++ */ ++ ++#define SW_LID 0x00 /* set = lid shut */ ++#define SW_TABLET_MODE 0x01 /* set = tablet mode */ ++#define SW_HEADPHONE_INSERT 0x02 /* set = inserted */ ++#define SW_RFKILL_ALL 0x03 /* rfkill master switch, type "any" ++ set = radio enabled */ ++#define SW_RADIO SW_RFKILL_ALL /* deprecated */ ++#define SW_MICROPHONE_INSERT 0x04 /* set = inserted */ ++#define SW_DOCK 0x05 /* set = plugged into dock */ ++#define SW_LINEOUT_INSERT 0x06 /* set = inserted */ ++#define SW_JACK_PHYSICAL_INSERT 0x07 /* set = mechanical switch set */ ++#define SW_VIDEOOUT_INSERT 0x08 /* set = inserted */ ++#define SW_CAMERA_LENS_COVER 0x09 /* set = lens covered */ ++#define SW_KEYPAD_SLIDE 0x0a /* set = keypad slide out */ ++#define SW_FRONT_PROXIMITY 0x0b /* set = front proximity sensor active */ ++#define SW_ROTATE_LOCK 0x0c /* set = rotate locked/disabled */ ++#define SW_LINEIN_INSERT 0x0d /* set = inserted */ ++#define SW_MUTE_DEVICE 0x0e /* set = device disabled */ ++#define SW_PEN_INSERTED 0x0f /* set = pen inserted */ ++#define SW_MACHINE_COVER 0x10 /* set = cover closed */ ++#define SW_USB_INSERT 0x11 /* set = USB audio device connected */ ++#define SW_MAX 0x11 ++#define SW_CNT (SW_MAX+1) ++ ++/* ++ * Misc events ++ */ ++ ++#define MSC_SERIAL 0x00 ++#define MSC_PULSELED 0x01 ++#define MSC_GESTURE 0x02 ++#define MSC_RAW 0x03 ++#define MSC_SCAN 0x04 ++#define MSC_TIMESTAMP 0x05 ++#define MSC_MAX 0x07 ++#define MSC_CNT (MSC_MAX+1) ++ ++/* ++ * LEDs ++ */ ++ ++#define LED_NUML 0x00 ++#define LED_CAPSL 0x01 ++#define LED_SCROLLL 0x02 ++#define LED_COMPOSE 0x03 ++#define LED_KANA 0x04 ++#define LED_SLEEP 0x05 ++#define LED_SUSPEND 0x06 ++#define LED_MUTE 0x07 ++#define LED_MISC 0x08 ++#define LED_MAIL 0x09 ++#define LED_CHARGING 0x0a ++#define LED_MAX 0x0f ++#define LED_CNT (LED_MAX+1) ++ ++/* ++ * Autorepeat values ++ */ ++ ++#define REP_DELAY 0x00 ++#define REP_PERIOD 0x01 ++#define REP_MAX 0x01 ++#define REP_CNT (REP_MAX+1) ++ ++/* ++ * Sounds ++ */ ++ ++#define SND_CLICK 0x00 ++#define SND_BELL 0x01 ++#define SND_TONE 0x02 ++#define SND_MAX 0x07 ++#define SND_CNT (SND_MAX+1) ++ ++#endif +diff --git libevdev-workdir/include/linux/astral/input.h libevdev-workdir/include/linux/astral/input.h +new file mode 100644 +index 0000000..5285f88 +--- /dev/null ++++ libevdev-workdir/include/linux/astral/input.h +@@ -0,0 +1,539 @@ ++/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ ++/* ++ * Copyright (c) 1999-2002 Vojtech Pavlik ++ * ++ * This program is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 as published by ++ * the Free Software Foundation. ++ */ ++#ifndef _UAPI_INPUT_H ++#define _UAPI_INPUT_H ++ ++ ++#ifndef __KERNEL__ ++#include ++#include ++#include ++#include ++#endif ++ ++#include "input-event-codes.h" ++ ++/* ++ * The event structure itself ++ * Note that __USE_TIME_BITS64 is defined by libc based on ++ * application's request to use 64 bit time_t. ++ */ ++ ++struct input_event { ++#if (__BITS_PER_LONG != 32 || !defined(__USE_TIME_BITS64)) && !defined(__KERNEL__) ++ struct timeval time; ++#define input_event_sec time.tv_sec ++#define input_event_usec time.tv_usec ++#else ++ __kernel_ulong_t __sec; ++#if defined(__sparc__) && defined(__arch64__) ++ unsigned int __usec; ++ unsigned int __pad; ++#else ++ __kernel_ulong_t __usec; ++#endif ++#define input_event_sec __sec ++#define input_event_usec __usec ++#endif ++ __u16 type; ++ __u16 code; ++ __s32 value; ++}; ++ ++/* ++ * Protocol version. ++ */ ++ ++#define EV_VERSION 0x010001 ++ ++/* ++ * IOCTLs (0x00 - 0x7f) ++ */ ++ ++struct input_id { ++ __u16 bustype; ++ __u16 vendor; ++ __u16 product; ++ __u16 version; ++}; ++ ++/** ++ * struct input_absinfo - used by EVIOCGABS/EVIOCSABS ioctls ++ * @value: latest reported value for the axis. ++ * @minimum: specifies minimum value for the axis. ++ * @maximum: specifies maximum value for the axis. ++ * @fuzz: specifies fuzz value that is used to filter noise from ++ * the event stream. ++ * @flat: values that are within this value will be discarded by ++ * joydev interface and reported as 0 instead. ++ * @resolution: specifies resolution for the values reported for ++ * the axis. ++ * ++ * Note that input core does not clamp reported values to the ++ * [minimum, maximum] limits, such task is left to userspace. ++ * ++ * The default resolution for main axes (ABS_X, ABS_Y, ABS_Z, ++ * ABS_MT_POSITION_X, ABS_MT_POSITION_Y) is reported in units ++ * per millimeter (units/mm), resolution for rotational axes ++ * (ABS_RX, ABS_RY, ABS_RZ) is reported in units per radian. ++ * The resolution for the size axes (ABS_MT_TOUCH_MAJOR, ++ * ABS_MT_TOUCH_MINOR, ABS_MT_WIDTH_MAJOR, ABS_MT_WIDTH_MINOR) ++ * is reported in units per millimeter (units/mm). ++ * When INPUT_PROP_ACCELEROMETER is set the resolution changes. ++ * The main axes (ABS_X, ABS_Y, ABS_Z) are then reported in ++ * units per g (units/g) and in units per degree per second ++ * (units/deg/s) for rotational axes (ABS_RX, ABS_RY, ABS_RZ). ++ */ ++struct input_absinfo { ++ __s32 value; ++ __s32 minimum; ++ __s32 maximum; ++ __s32 fuzz; ++ __s32 flat; ++ __s32 resolution; ++}; ++ ++/** ++ * struct input_keymap_entry - used by EVIOCGKEYCODE/EVIOCSKEYCODE ioctls ++ * @scancode: scancode represented in machine-endian form. ++ * @len: length of the scancode that resides in @scancode buffer. ++ * @index: index in the keymap, may be used instead of scancode ++ * @flags: allows to specify how kernel should handle the request. For ++ * example, setting INPUT_KEYMAP_BY_INDEX flag indicates that kernel ++ * should perform lookup in keymap by @index instead of @scancode ++ * @keycode: key code assigned to this scancode ++ * ++ * The structure is used to retrieve and modify keymap data. Users have ++ * option of performing lookup either by @scancode itself or by @index ++ * in keymap entry. EVIOCGKEYCODE will also return scancode or index ++ * (depending on which element was used to perform lookup). ++ */ ++struct input_keymap_entry { ++#define INPUT_KEYMAP_BY_INDEX (1 << 0) ++ __u8 flags; ++ __u8 len; ++ __u16 index; ++ __u32 keycode; ++ __u8 scancode[32]; ++}; ++ ++struct input_mask { ++ __u32 type; ++ __u32 codes_size; ++ __u64 codes_ptr; ++}; ++ ++#define EVIOCGVERSION _IOR('E', 0x01, int) /* get driver version */ ++#define EVIOCGID _IOR('E', 0x02, struct input_id) /* get device ID */ ++#define EVIOCGREP _IOR('E', 0x03, unsigned int[2]) /* get repeat settings */ ++#define EVIOCSREP _IOW('E', 0x03, unsigned int[2]) /* set repeat settings */ ++ ++#define EVIOCGKEYCODE _IOR('E', 0x04, unsigned int[2]) /* get keycode */ ++#define EVIOCGKEYCODE_V2 _IOR('E', 0x04, struct input_keymap_entry) ++#define EVIOCSKEYCODE _IOW('E', 0x04, unsigned int[2]) /* set keycode */ ++#define EVIOCSKEYCODE_V2 _IOW('E', 0x04, struct input_keymap_entry) ++ ++#define EVIOCGNAME(len) _IOC(_IOC_READ, 'E', 0x06, len) /* get device name */ ++#define EVIOCGPHYS(len) _IOC(_IOC_READ, 'E', 0x07, len) /* get physical location */ ++#define EVIOCGUNIQ(len) _IOC(_IOC_READ, 'E', 0x08, len) /* get unique identifier */ ++#define EVIOCGPROP(len) _IOC(_IOC_READ, 'E', 0x09, len) /* get device properties */ ++ ++/** ++ * EVIOCGMTSLOTS(len) - get MT slot values ++ * @len: size of the data buffer in bytes ++ * ++ * The ioctl buffer argument should be binary equivalent to ++ * ++ * struct input_mt_request_layout { ++ * __u32 code; ++ * __s32 values[num_slots]; ++ * }; ++ * ++ * where num_slots is the (arbitrary) number of MT slots to extract. ++ * ++ * The ioctl size argument (len) is the size of the buffer, which ++ * should satisfy len = (num_slots + 1) * sizeof(__s32). If len is ++ * too small to fit all available slots, the first num_slots are ++ * returned. ++ * ++ * Before the call, code is set to the wanted ABS_MT event type. On ++ * return, values[] is filled with the slot values for the specified ++ * ABS_MT code. ++ * ++ * If the request code is not an ABS_MT value, -EINVAL is returned. ++ */ ++#define EVIOCGMTSLOTS(len) _IOC(_IOC_READ, 'E', 0x0a, len) ++ ++#define EVIOCGKEY(len) _IOC(_IOC_READ, 'E', 0x18, len) /* get global key state */ ++#define EVIOCGLED(len) _IOC(_IOC_READ, 'E', 0x19, len) /* get all LEDs */ ++#define EVIOCGSND(len) _IOC(_IOC_READ, 'E', 0x1a, len) /* get all sounds status */ ++#define EVIOCGSW(len) _IOC(_IOC_READ, 'E', 0x1b, len) /* get all switch states */ ++ ++#define EVIOCGBIT(ev,len) _IOC(_IOC_READ, 'E', 0x20 + (ev), len) /* get event bits */ ++#define EVIOCGABS(abs) _IOR('E', 0x40 + (abs), struct input_absinfo) /* get abs value/limits */ ++#define EVIOCSABS(abs) _IOW('E', 0xc0 + (abs), struct input_absinfo) /* set abs value/limits */ ++ ++#define EVIOCSFF _IOW('E', 0x80, struct ff_effect) /* send a force effect to a force feedback device */ ++#define EVIOCRMFF _IOW('E', 0x81, int) /* Erase a force effect */ ++#define EVIOCGEFFECTS _IOR('E', 0x84, int) /* Report number of effects playable at the same time */ ++ ++#define EVIOCGRAB _IOW('E', 0x90, int) /* Grab/Release device */ ++#define EVIOCREVOKE _IOW('E', 0x91, int) /* Revoke device access */ ++ ++/** ++ * EVIOCGMASK - Retrieve current event mask ++ * ++ * This ioctl allows user to retrieve the current event mask for specific ++ * event type. The argument must be of type "struct input_mask" and ++ * specifies the event type to query, the address of the receive buffer and ++ * the size of the receive buffer. ++ * ++ * The event mask is a per-client mask that specifies which events are ++ * forwarded to the client. Each event code is represented by a single bit ++ * in the event mask. If the bit is set, the event is passed to the client ++ * normally. Otherwise, the event is filtered and will never be queued on ++ * the client's receive buffer. ++ * ++ * Event masks do not affect global state of the input device. They only ++ * affect the file descriptor they are applied to. ++ * ++ * The default event mask for a client has all bits set, i.e. all events ++ * are forwarded to the client. If the kernel is queried for an unknown ++ * event type or if the receive buffer is larger than the number of ++ * event codes known to the kernel, the kernel returns all zeroes for those ++ * codes. ++ * ++ * At maximum, codes_size bytes are copied. ++ * ++ * This ioctl may fail with ENODEV in case the file is revoked, EFAULT ++ * if the receive-buffer points to invalid memory, or EINVAL if the kernel ++ * does not implement the ioctl. ++ */ ++#define EVIOCGMASK _IOR('E', 0x92, struct input_mask) /* Get event-masks */ ++ ++/** ++ * EVIOCSMASK - Set event mask ++ * ++ * This ioctl is the counterpart to EVIOCGMASK. Instead of receiving the ++ * current event mask, this changes the client's event mask for a specific ++ * type. See EVIOCGMASK for a description of event-masks and the ++ * argument-type. ++ * ++ * This ioctl provides full forward compatibility. If the passed event type ++ * is unknown to the kernel, or if the number of event codes specified in ++ * the mask is bigger than what is known to the kernel, the ioctl is still ++ * accepted and applied. However, any unknown codes are left untouched and ++ * stay cleared. That means, the kernel always filters unknown codes ++ * regardless of what the client requests. If the new mask doesn't cover ++ * all known event-codes, all remaining codes are automatically cleared and ++ * thus filtered. ++ * ++ * This ioctl may fail with ENODEV in case the file is revoked. EFAULT is ++ * returned if the receive-buffer points to invalid memory. EINVAL is returned ++ * if the kernel does not implement the ioctl. ++ */ ++#define EVIOCSMASK _IOW('E', 0x93, struct input_mask) /* Set event-masks */ ++ ++#define EVIOCSCLOCKID _IOW('E', 0xa0, int) /* Set clockid to be used for timestamps */ ++ ++/* ++ * IDs. ++ */ ++ ++#define ID_BUS 0 ++#define ID_VENDOR 1 ++#define ID_PRODUCT 2 ++#define ID_VERSION 3 ++ ++#define BUS_PCI 0x01 ++#define BUS_ISAPNP 0x02 ++#define BUS_USB 0x03 ++#define BUS_HIL 0x04 ++#define BUS_BLUETOOTH 0x05 ++#define BUS_VIRTUAL 0x06 ++ ++#define BUS_ISA 0x10 ++#define BUS_I8042 0x11 ++#define BUS_XTKBD 0x12 ++#define BUS_RS232 0x13 ++#define BUS_GAMEPORT 0x14 ++#define BUS_PARPORT 0x15 ++#define BUS_AMIGA 0x16 ++#define BUS_ADB 0x17 ++#define BUS_I2C 0x18 ++#define BUS_HOST 0x19 ++#define BUS_GSC 0x1A ++#define BUS_ATARI 0x1B ++#define BUS_SPI 0x1C ++#define BUS_RMI 0x1D ++#define BUS_CEC 0x1E ++#define BUS_INTEL_ISHTP 0x1F ++#define BUS_AMD_SFH 0x20 ++#define BUS_SDW 0x21 ++ ++/* ++ * MT_TOOL types ++ */ ++#define MT_TOOL_FINGER 0x00 ++#define MT_TOOL_PEN 0x01 ++#define MT_TOOL_PALM 0x02 ++#define MT_TOOL_DIAL 0x0a ++#define MT_TOOL_MAX 0x0f ++ ++/* ++ * Values describing the status of a force-feedback effect ++ */ ++#define FF_STATUS_STOPPED 0x00 ++#define FF_STATUS_PLAYING 0x01 ++#define FF_STATUS_MAX 0x01 ++ ++/* ++ * Structures used in ioctls to upload effects to a device ++ * They are pieces of a bigger structure (called ff_effect) ++ */ ++ ++/* ++ * All duration values are expressed in ms. Values above 32767 ms (0x7fff) ++ * should not be used and have unspecified results. ++ */ ++ ++/** ++ * struct ff_replay - defines scheduling of the force-feedback effect ++ * @length: duration of the effect ++ * @delay: delay before effect should start playing ++ */ ++struct ff_replay { ++ __u16 length; ++ __u16 delay; ++}; ++ ++/** ++ * struct ff_trigger - defines what triggers the force-feedback effect ++ * @button: number of the button triggering the effect ++ * @interval: controls how soon the effect can be re-triggered ++ */ ++struct ff_trigger { ++ __u16 button; ++ __u16 interval; ++}; ++ ++/** ++ * struct ff_envelope - generic force-feedback effect envelope ++ * @attack_length: duration of the attack (ms) ++ * @attack_level: level at the beginning of the attack ++ * @fade_length: duration of fade (ms) ++ * @fade_level: level at the end of fade ++ * ++ * The @attack_level and @fade_level are absolute values; when applying ++ * envelope force-feedback core will convert to positive/negative ++ * value based on polarity of the default level of the effect. ++ * Valid range for the attack and fade levels is 0x0000 - 0x7fff ++ */ ++struct ff_envelope { ++ __u16 attack_length; ++ __u16 attack_level; ++ __u16 fade_length; ++ __u16 fade_level; ++}; ++ ++/** ++ * struct ff_constant_effect - defines parameters of a constant force-feedback effect ++ * @level: strength of the effect; may be negative ++ * @envelope: envelope data ++ */ ++struct ff_constant_effect { ++ __s16 level; ++ struct ff_envelope envelope; ++}; ++ ++/** ++ * struct ff_ramp_effect - defines parameters of a ramp force-feedback effect ++ * @start_level: beginning strength of the effect; may be negative ++ * @end_level: final strength of the effect; may be negative ++ * @envelope: envelope data ++ */ ++struct ff_ramp_effect { ++ __s16 start_level; ++ __s16 end_level; ++ struct ff_envelope envelope; ++}; ++ ++/** ++ * struct ff_condition_effect - defines a spring or friction force-feedback effect ++ * @right_saturation: maximum level when joystick moved all way to the right ++ * @left_saturation: same for the left side ++ * @right_coeff: controls how fast the force grows when the joystick moves ++ * to the right ++ * @left_coeff: same for the left side ++ * @deadband: size of the dead zone, where no force is produced ++ * @center: position of the dead zone ++ */ ++struct ff_condition_effect { ++ __u16 right_saturation; ++ __u16 left_saturation; ++ ++ __s16 right_coeff; ++ __s16 left_coeff; ++ ++ __u16 deadband; ++ __s16 center; ++}; ++ ++/** ++ * struct ff_periodic_effect - defines parameters of a periodic force-feedback effect ++ * @waveform: kind of the effect (wave) ++ * @period: period of the wave (ms) ++ * @magnitude: peak value ++ * @offset: mean value of the wave (roughly) ++ * @phase: 'horizontal' shift ++ * @envelope: envelope data ++ * @custom_len: number of samples (FF_CUSTOM only) ++ * @custom_data: buffer of samples (FF_CUSTOM only) ++ * ++ * Known waveforms - FF_SQUARE, FF_TRIANGLE, FF_SINE, FF_SAW_UP, ++ * FF_SAW_DOWN, FF_CUSTOM. The exact syntax FF_CUSTOM is undefined ++ * for the time being as no driver supports it yet. ++ * ++ * Note: the data pointed by custom_data is copied by the driver. ++ * You can therefore dispose of the memory after the upload/update. ++ */ ++struct ff_periodic_effect { ++ __u16 waveform; ++ __u16 period; ++ __s16 magnitude; ++ __s16 offset; ++ __u16 phase; ++ ++ struct ff_envelope envelope; ++ ++ __u32 custom_len; ++ __s16 *custom_data; ++}; ++ ++/** ++ * struct ff_rumble_effect - defines parameters of a periodic force-feedback effect ++ * @strong_magnitude: magnitude of the heavy motor ++ * @weak_magnitude: magnitude of the light one ++ * ++ * Some rumble pads have two motors of different weight. Strong_magnitude ++ * represents the magnitude of the vibration generated by the heavy one. ++ */ ++struct ff_rumble_effect { ++ __u16 strong_magnitude; ++ __u16 weak_magnitude; ++}; ++ ++/** ++ * struct ff_haptic_effect ++ * @hid_usage: hid_usage according to Haptics page (WAVEFORM_CLICK, etc.) ++ * @vendor_id: the waveform vendor ID if hid_usage is in the vendor-defined range ++ * @vendor_waveform_page: the vendor waveform page if hid_usage is in the vendor-defined range ++ * @intensity: strength of the effect as percentage ++ * @repeat_count: number of times to retrigger effect ++ * @retrigger_period: time before effect is retriggered (in ms) ++ */ ++struct ff_haptic_effect { ++ __u16 hid_usage; ++ __u16 vendor_id; ++ __u8 vendor_waveform_page; ++ __u16 intensity; ++ __u16 repeat_count; ++ __u16 retrigger_period; ++}; ++ ++/** ++ * struct ff_effect - defines force feedback effect ++ * @type: type of the effect (FF_CONSTANT, FF_PERIODIC, FF_RAMP, FF_SPRING, ++ * FF_FRICTION, FF_DAMPER, FF_RUMBLE, FF_INERTIA, or FF_CUSTOM) ++ * @id: an unique id assigned to an effect ++ * @direction: direction of the effect ++ * @trigger: trigger conditions (struct ff_trigger) ++ * @replay: scheduling of the effect (struct ff_replay) ++ * @u: effect-specific structure (one of ff_constant_effect, ff_ramp_effect, ++ * ff_periodic_effect, ff_condition_effect, ff_rumble_effect) further ++ * defining effect parameters ++ * ++ * This structure is sent through ioctl from the application to the driver. ++ * To create a new effect application should set its @id to -1; the kernel ++ * will return assigned @id which can later be used to update or delete ++ * this effect. ++ * ++ * Direction of the effect is encoded as follows: ++ * 0 deg -> 0x0000 (down) ++ * 90 deg -> 0x4000 (left) ++ * 180 deg -> 0x8000 (up) ++ * 270 deg -> 0xC000 (right) ++ */ ++struct ff_effect { ++ __u16 type; ++ __s16 id; ++ __u16 direction; ++ struct ff_trigger trigger; ++ struct ff_replay replay; ++ ++ union { ++ struct ff_constant_effect constant; ++ struct ff_ramp_effect ramp; ++ struct ff_periodic_effect periodic; ++ struct ff_condition_effect condition[2]; /* One for each axis */ ++ struct ff_rumble_effect rumble; ++ struct ff_haptic_effect haptic; ++ } u; ++}; ++ ++/* ++ * Force feedback effect types ++ */ ++ ++#define FF_HAPTIC 0x4f ++#define FF_RUMBLE 0x50 ++#define FF_PERIODIC 0x51 ++#define FF_CONSTANT 0x52 ++#define FF_SPRING 0x53 ++#define FF_FRICTION 0x54 ++#define FF_DAMPER 0x55 ++#define FF_INERTIA 0x56 ++#define FF_RAMP 0x57 ++ ++#define FF_EFFECT_MIN FF_HAPTIC ++#define FF_EFFECT_MAX FF_RAMP ++ ++/* ++ * Force feedback periodic effect types ++ */ ++ ++#define FF_SQUARE 0x58 ++#define FF_TRIANGLE 0x59 ++#define FF_SINE 0x5a ++#define FF_SAW_UP 0x5b ++#define FF_SAW_DOWN 0x5c ++#define FF_CUSTOM 0x5d ++ ++#define FF_WAVEFORM_MIN FF_SQUARE ++#define FF_WAVEFORM_MAX FF_CUSTOM ++ ++/* ++ * Set ff device properties ++ */ ++ ++#define FF_GAIN 0x60 ++#define FF_AUTOCENTER 0x61 ++ ++/* ++ * ff->playback(effect_id = FF_GAIN) is the first effect_id to ++ * cause a collision with another ff method, in this case ff->set_gain(). ++ * Therefore the greatest safe value for effect_id is FF_GAIN - 1, ++ * and thus the total number of effects should never exceed FF_GAIN. ++ */ ++#define FF_MAX_EFFECTS FF_GAIN ++ ++#define FF_MAX 0x7f ++#define FF_CNT (FF_MAX+1) ++ ++#endif /* _UAPI_INPUT_H */ +diff --git libevdev-workdir/include/linux/astral/uinput.h libevdev-workdir/include/linux/astral/uinput.h +new file mode 100644 +index 0000000..434f02d +--- /dev/null ++++ libevdev-workdir/include/linux/astral/uinput.h +@@ -0,0 +1,231 @@ ++/* ++ * User level driver support for input subsystem ++ * ++ * Heavily based on evdev.c by Vojtech Pavlik ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ * ++ * Author: Aristeu Sergio Rozanski Filho ++ * ++ * Changes/Revisions: ++ * 0.5 08/13/2015 (David Herrmann & ++ * Benjamin Tissoires ) ++ * - add UI_DEV_SETUP ioctl ++ * - add UI_ABS_SETUP ioctl ++ * - add UI_GET_VERSION ioctl ++ * 0.4 01/09/2014 (Benjamin Tissoires ) ++ * - add UI_GET_SYSNAME ioctl ++ * 0.3 24/05/2006 (Anssi Hannula ) ++ * - update ff support for the changes in kernel interface ++ * - add UINPUT_VERSION ++ * 0.2 16/10/2004 (Micah Dowty ) ++ * - added force feedback support ++ * - added UI_SET_PHYS ++ * 0.1 20/06/2002 ++ * - first public version ++ */ ++#ifndef __UINPUT_H_ ++#define __UINPUT_H_ ++ ++#include ++#include ++ ++#define UINPUT_VERSION 5 ++#define UINPUT_MAX_NAME_SIZE 80 ++ ++struct uinput_ff_upload { ++ __u32 request_id; ++ __s32 retval; ++ struct ff_effect effect; ++ struct ff_effect old; ++}; ++ ++struct uinput_ff_erase { ++ __u32 request_id; ++ __s32 retval; ++ __u32 effect_id; ++}; ++ ++/* ioctl */ ++#define UINPUT_IOCTL_BASE 'U' ++#define UI_DEV_CREATE _IO(UINPUT_IOCTL_BASE, 1) ++#define UI_DEV_DESTROY _IO(UINPUT_IOCTL_BASE, 2) ++ ++struct uinput_setup { ++ struct input_id id; ++ char name[UINPUT_MAX_NAME_SIZE]; ++ __u32 ff_effects_max; ++}; ++ ++/** ++ * UI_DEV_SETUP - Set device parameters for setup ++ * ++ * This ioctl sets parameters for the input device to be created. It ++ * supersedes the old "struct uinput_user_dev" method, which wrote this data ++ * via write(). To actually set the absolute axes UI_ABS_SETUP should be ++ * used. ++ * ++ * The ioctl takes a "struct uinput_setup" object as argument. The fields of ++ * this object are as follows: ++ * id: See the description of "struct input_id". This field is ++ * copied unchanged into the new device. ++ * name: This is used unchanged as name for the new device. ++ * ff_effects_max: This limits the maximum numbers of force-feedback effects. ++ * See below for a description of FF with uinput. ++ * ++ * This ioctl can be called multiple times and will overwrite previous values. ++ * If this ioctl fails with -EINVAL, it is recommended to use the old ++ * "uinput_user_dev" method via write() as a fallback, in case you run on an ++ * old kernel that does not support this ioctl. ++ * ++ * This ioctl may fail with -EINVAL if it is not supported or if you passed ++ * incorrect values, -ENOMEM if the kernel runs out of memory or -EFAULT if the ++ * passed uinput_setup object cannot be read/written. ++ * If this call fails, partial data may have already been applied to the ++ * internal device. ++ */ ++#define UI_DEV_SETUP _IOW(UINPUT_IOCTL_BASE, 3, struct uinput_setup) ++ ++struct uinput_abs_setup { ++ __u16 code; /* axis code */ ++ /* __u16 filler; */ ++ struct input_absinfo absinfo; ++}; ++ ++/** ++ * UI_ABS_SETUP - Set absolute axis information for the device to setup ++ * ++ * This ioctl sets one absolute axis information for the input device to be ++ * created. It supersedes the old "struct uinput_user_dev" method, which wrote ++ * part of this data and the content of UI_DEV_SETUP via write(). ++ * ++ * The ioctl takes a "struct uinput_abs_setup" object as argument. The fields ++ * of this object are as follows: ++ * code: The corresponding input code associated with this axis ++ * (ABS_X, ABS_Y, etc...) ++ * absinfo: See "struct input_absinfo" for a description of this field. ++ * This field is copied unchanged into the kernel for the ++ * specified axis. If the axis is not enabled via ++ * UI_SET_ABSBIT, this ioctl will enable it. ++ * ++ * This ioctl can be called multiple times and will overwrite previous values. ++ * If this ioctl fails with -EINVAL, it is recommended to use the old ++ * "uinput_user_dev" method via write() as a fallback, in case you run on an ++ * old kernel that does not support this ioctl. ++ * ++ * This ioctl may fail with -EINVAL if it is not supported or if you passed ++ * incorrect values, -ENOMEM if the kernel runs out of memory or -EFAULT if the ++ * passed uinput_setup object cannot be read/written. ++ * If this call fails, partial data may have already been applied to the ++ * internal device. ++ */ ++#define UI_ABS_SETUP _IOW(UINPUT_IOCTL_BASE, 4, struct uinput_abs_setup) ++ ++#define UI_SET_EVBIT _IOW(UINPUT_IOCTL_BASE, 100, int) ++#define UI_SET_KEYBIT _IOW(UINPUT_IOCTL_BASE, 101, int) ++#define UI_SET_RELBIT _IOW(UINPUT_IOCTL_BASE, 102, int) ++#define UI_SET_ABSBIT _IOW(UINPUT_IOCTL_BASE, 103, int) ++#define UI_SET_MSCBIT _IOW(UINPUT_IOCTL_BASE, 104, int) ++#define UI_SET_LEDBIT _IOW(UINPUT_IOCTL_BASE, 105, int) ++#define UI_SET_SNDBIT _IOW(UINPUT_IOCTL_BASE, 106, int) ++#define UI_SET_FFBIT _IOW(UINPUT_IOCTL_BASE, 107, int) ++#define UI_SET_PHYS _IOW(UINPUT_IOCTL_BASE, 108, char*) ++#define UI_SET_SWBIT _IOW(UINPUT_IOCTL_BASE, 109, int) ++#define UI_SET_PROPBIT _IOW(UINPUT_IOCTL_BASE, 110, int) ++ ++#define UI_BEGIN_FF_UPLOAD _IOWR(UINPUT_IOCTL_BASE, 200, struct uinput_ff_upload) ++#define UI_END_FF_UPLOAD _IOW(UINPUT_IOCTL_BASE, 201, struct uinput_ff_upload) ++#define UI_BEGIN_FF_ERASE _IOWR(UINPUT_IOCTL_BASE, 202, struct uinput_ff_erase) ++#define UI_END_FF_ERASE _IOW(UINPUT_IOCTL_BASE, 203, struct uinput_ff_erase) ++ ++/** ++ * UI_GET_SYSNAME - get the sysfs name of the created uinput device ++ * ++ * @return the sysfs name of the created virtual input device. ++ * The complete sysfs path is then /sys/devices/virtual/input/--NAME-- ++ * Usually, it is in the form "inputN" ++ */ ++#define UI_GET_SYSNAME(len) _IOC(_IOC_READ, UINPUT_IOCTL_BASE, 44, len) ++ ++/** ++ * UI_GET_VERSION - Return version of uinput protocol ++ * ++ * This writes uinput protocol version implemented by the kernel into ++ * the integer pointed to by the ioctl argument. The protocol version ++ * is hard-coded in the kernel and is independent of the uinput device. ++ */ ++#define UI_GET_VERSION _IOR(UINPUT_IOCTL_BASE, 45, unsigned int) ++ ++/* ++ * To write a force-feedback-capable driver, the upload_effect ++ * and erase_effect callbacks in input_dev must be implemented. ++ * The uinput driver will generate a fake input event when one of ++ * these callbacks are invoked. The userspace code then uses ++ * ioctls to retrieve additional parameters and send the return code. ++ * The callback blocks until this return code is sent. ++ * ++ * The described callback mechanism is only used if ff_effects_max ++ * is set. ++ * ++ * To implement upload_effect(): ++ * 1. Wait for an event with type == EV_UINPUT and code == UI_FF_UPLOAD. ++ * A request ID will be given in 'value'. ++ * 2. Allocate a uinput_ff_upload struct, fill in request_id with ++ * the 'value' from the EV_UINPUT event. ++ * 3. Issue a UI_BEGIN_FF_UPLOAD ioctl, giving it the ++ * uinput_ff_upload struct. It will be filled in with the ++ * ff_effects passed to upload_effect(). ++ * 4. Perform the effect upload, and place a return code back into ++ the uinput_ff_upload struct. ++ * 5. Issue a UI_END_FF_UPLOAD ioctl, also giving it the ++ * uinput_ff_upload_effect struct. This will complete execution ++ * of our upload_effect() handler. ++ * ++ * To implement erase_effect(): ++ * 1. Wait for an event with type == EV_UINPUT and code == UI_FF_ERASE. ++ * A request ID will be given in 'value'. ++ * 2. Allocate a uinput_ff_erase struct, fill in request_id with ++ * the 'value' from the EV_UINPUT event. ++ * 3. Issue a UI_BEGIN_FF_ERASE ioctl, giving it the ++ * uinput_ff_erase struct. It will be filled in with the ++ * effect ID passed to erase_effect(). ++ * 4. Perform the effect erasure, and place a return code back ++ * into the uinput_ff_erase struct. ++ * 5. Issue a UI_END_FF_ERASE ioctl, also giving it the ++ * uinput_ff_erase_effect struct. This will complete execution ++ * of our erase_effect() handler. ++ */ ++ ++/* ++ * This is the new event type, used only by uinput. ++ * 'code' is UI_FF_UPLOAD or UI_FF_ERASE, and 'value' ++ * is the unique request ID. This number was picked ++ * arbitrarily, above EV_MAX (since the input system ++ * never sees it) but in the range of a 16-bit int. ++ */ ++#define EV_UINPUT 0x0101 ++#define UI_FF_UPLOAD 1 ++#define UI_FF_ERASE 2 ++ ++struct uinput_user_dev { ++ char name[UINPUT_MAX_NAME_SIZE]; ++ struct input_id id; ++ __u32 ff_effects_max; ++ __s32 absmax[ABS_CNT]; ++ __s32 absmin[ABS_CNT]; ++ __s32 absfuzz[ABS_CNT]; ++ __s32 absflat[ABS_CNT]; ++}; ++#endif /* __UINPUT_H_ */ +diff --git libevdev-clean/include/linux/input.h libevdev-workdir/include/linux/input.h +index 03c512e..0f50d0b 100644 +--- libevdev-clean/include/linux/input.h ++++ libevdev-workdir/include/linux/input.h +@@ -2,4 +2,6 @@ + #include "linux/input.h" + #elif __FreeBSD__ + #include "freebsd/input.h" ++#elif __astral__ ++#include "astral/input.h" + #endif +diff --git libevdev-clean/include/linux/uinput.h libevdev-workdir/include/linux/uinput.h +index 1ef4e3b..fc7dc83 100644 +--- libevdev-clean/include/linux/uinput.h ++++ libevdev-workdir/include/linux/uinput.h +@@ -2,4 +2,6 @@ + #include "linux/uinput.h" + #elif __FreeBSD__ + #include "freebsd/uinput.h" ++#elif __astral__ ++#include "astral/uinput.h" + #endif diff --git a/recipes/evtest b/recipes/evtest new file mode 100644 index 00000000..6ba196e2 --- /dev/null +++ b/recipes/evtest @@ -0,0 +1,18 @@ +name=evtest +revision=1 +from_source=evtest +imagedeps="gcc" +hostdeps="xgcc xbinutils pkgconfig automake autoconf" +deps="base libevdev" + +configure() { + ${source_dir}/configure --prefix=${prefix} --host=x86_64-astral --disable-static +} + +build() { + make -j${parallelism} +} + +package() { + make DESTDIR=${dest_dir} install +} diff --git a/recipes/libevdev b/recipes/libevdev new file mode 100644 index 00000000..a274cb2c --- /dev/null +++ b/recipes/libevdev @@ -0,0 +1,18 @@ +name=libevdev +revision=1 +from_source=libevdev +imagedeps="gcc meson ninja-build" +hostdeps="xgcc xbinutils pkgconfig" +deps="base" + +configure() { + meson --cross-file ${base_dir}/util/crossfile --prefix=${prefix} --buildtype=release -Ddocumentation=disabled -Dtests=disabled ${source_dir} +} + +build() { + ninja -j${parallelism} +} + +package() { + DESTDIR=${dest_dir} ninja install +} diff --git a/source-recipes/evtest b/source-recipes/evtest new file mode 100644 index 00000000..f8a45c11 --- /dev/null +++ b/source-recipes/evtest @@ -0,0 +1,10 @@ +name=evtest +version=1.36 +source_method=tarball +tarball_url="https://gitlab.freedesktop.org/libevdev/evtest/-/archive/evtest-${version}/evtest-evtest-${version}.tar.gz" +tarball_sha512="da48df0045c4714ef09e80210de2df1e4dac5281b9c390a78b2fb94626855c0d8df1f31f5d129c5f3cef98b6f5ddfe020de7602119e6603e568bd02cc80c5546" +hostdeps="autoconf automake libtool pkgconfig" + +prepare() { + autoreconf -fvi +} diff --git a/source-recipes/libevdev b/source-recipes/libevdev new file mode 100644 index 00000000..25f3f46e --- /dev/null +++ b/source-recipes/libevdev @@ -0,0 +1,9 @@ +name=libevdev +version=1.13.6 +source_method=tarball +tarball_url="https://www.freedesktop.org/software/libevdev/libevdev-${version}.tar.xz" +tarball_sha512="367081bf587dd63845086714e0b51ec0f9eb107d4c32cc387cf60d3c41ad3cb31a64b1c74e25116b5bc900d6c34e82694697e942bb646f7161b0670b70d1b54d" + +prepare() { + true +}