mirror of
https://github.com/AetherDroid/android_kernel_samsung_on5xelte.git
synced 2025-09-08 01:08:03 -04:00
Fixed MTP to work with TWRP
This commit is contained in:
awab228
commit
f6dfaef42e
50820 changed files with 20846062 additions and 0 deletions
10
samples/uhid/Makefile
Normal file
10
samples/uhid/Makefile
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
# kbuild trick to avoid linker error. Can be omitted if a module is built.
|
||||
obj- := dummy.o
|
||||
|
||||
# List of programs to build
|
||||
hostprogs-y := uhid-example
|
||||
|
||||
# Tell kbuild to always build the programs
|
||||
always := $(hostprogs-y)
|
||||
|
||||
HOSTCFLAGS_uhid-example.o += -I$(objtree)/usr/include
|
||||
464
samples/uhid/uhid-example.c
Normal file
464
samples/uhid/uhid-example.c
Normal file
|
|
@ -0,0 +1,464 @@
|
|||
/*
|
||||
* UHID Example
|
||||
*
|
||||
* Copyright (c) 2012-2013 David Herrmann <dh.herrmann@gmail.com>
|
||||
*
|
||||
* The code may be used by anyone for any purpose,
|
||||
* and can serve as a starting point for developing
|
||||
* applications using uhid.
|
||||
*/
|
||||
|
||||
/*
|
||||
* UHID Example
|
||||
* This example emulates a basic 3 buttons mouse with wheel over UHID. Run this
|
||||
* program as root and then use the following keys to control the mouse:
|
||||
* q: Quit the application
|
||||
* 1: Toggle left button (down, up, ...)
|
||||
* 2: Toggle right button
|
||||
* 3: Toggle middle button
|
||||
* a: Move mouse left
|
||||
* d: Move mouse right
|
||||
* w: Move mouse up
|
||||
* s: Move mouse down
|
||||
* r: Move wheel up
|
||||
* f: Move wheel down
|
||||
*
|
||||
* Additionally to 3 button mouse, 3 keyboard LEDs are also supported (LED_NUML,
|
||||
* LED_CAPSL and LED_SCROLLL). The device doesn't generate any related keyboard
|
||||
* events, though. You need to manually write the EV_LED/LED_XY/1 activation
|
||||
* input event to the evdev device to see it being sent to this device.
|
||||
*
|
||||
* If uhid is not available as /dev/uhid, then you can pass a different path as
|
||||
* first argument.
|
||||
* If <linux/uhid.h> is not installed in /usr, then compile this with:
|
||||
* gcc -o ./uhid_test -Wall -I./include ./samples/uhid/uhid-example.c
|
||||
* And ignore the warning about kernel headers. However, it is recommended to
|
||||
* use the installed uhid.h if available.
|
||||
*/
|
||||
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <poll.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <termios.h>
|
||||
#include <unistd.h>
|
||||
#include <linux/uhid.h>
|
||||
|
||||
/*
|
||||
* HID Report Desciptor
|
||||
* We emulate a basic 3 button mouse with wheel and 3 keyboard LEDs. This is
|
||||
* the report-descriptor as the kernel will parse it:
|
||||
*
|
||||
* INPUT(1)[INPUT]
|
||||
* Field(0)
|
||||
* Physical(GenericDesktop.Pointer)
|
||||
* Application(GenericDesktop.Mouse)
|
||||
* Usage(3)
|
||||
* Button.0001
|
||||
* Button.0002
|
||||
* Button.0003
|
||||
* Logical Minimum(0)
|
||||
* Logical Maximum(1)
|
||||
* Report Size(1)
|
||||
* Report Count(3)
|
||||
* Report Offset(0)
|
||||
* Flags( Variable Absolute )
|
||||
* Field(1)
|
||||
* Physical(GenericDesktop.Pointer)
|
||||
* Application(GenericDesktop.Mouse)
|
||||
* Usage(3)
|
||||
* GenericDesktop.X
|
||||
* GenericDesktop.Y
|
||||
* GenericDesktop.Wheel
|
||||
* Logical Minimum(-128)
|
||||
* Logical Maximum(127)
|
||||
* Report Size(8)
|
||||
* Report Count(3)
|
||||
* Report Offset(8)
|
||||
* Flags( Variable Relative )
|
||||
* OUTPUT(2)[OUTPUT]
|
||||
* Field(0)
|
||||
* Application(GenericDesktop.Keyboard)
|
||||
* Usage(3)
|
||||
* LED.NumLock
|
||||
* LED.CapsLock
|
||||
* LED.ScrollLock
|
||||
* Logical Minimum(0)
|
||||
* Logical Maximum(1)
|
||||
* Report Size(1)
|
||||
* Report Count(3)
|
||||
* Report Offset(0)
|
||||
* Flags( Variable Absolute )
|
||||
*
|
||||
* This is the mapping that we expect:
|
||||
* Button.0001 ---> Key.LeftBtn
|
||||
* Button.0002 ---> Key.RightBtn
|
||||
* Button.0003 ---> Key.MiddleBtn
|
||||
* GenericDesktop.X ---> Relative.X
|
||||
* GenericDesktop.Y ---> Relative.Y
|
||||
* GenericDesktop.Wheel ---> Relative.Wheel
|
||||
* LED.NumLock ---> LED.NumLock
|
||||
* LED.CapsLock ---> LED.CapsLock
|
||||
* LED.ScrollLock ---> LED.ScrollLock
|
||||
*
|
||||
* This information can be verified by reading /sys/kernel/debug/hid/<dev>/rdesc
|
||||
* This file should print the same information as showed above.
|
||||
*/
|
||||
|
||||
static unsigned char rdesc[] = {
|
||||
0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
|
||||
0x09, 0x02, /* USAGE (Mouse) */
|
||||
0xa1, 0x01, /* COLLECTION (Application) */
|
||||
0x09, 0x01, /* USAGE (Pointer) */
|
||||
0xa1, 0x00, /* COLLECTION (Physical) */
|
||||
0x85, 0x01, /* REPORT_ID (1) */
|
||||
0x05, 0x09, /* USAGE_PAGE (Button) */
|
||||
0x19, 0x01, /* USAGE_MINIMUM (Button 1) */
|
||||
0x29, 0x03, /* USAGE_MAXIMUM (Button 3) */
|
||||
0x15, 0x00, /* LOGICAL_MINIMUM (0) */
|
||||
0x25, 0x01, /* LOGICAL_MAXIMUM (1) */
|
||||
0x95, 0x03, /* REPORT_COUNT (3) */
|
||||
0x75, 0x01, /* REPORT_SIZE (1) */
|
||||
0x81, 0x02, /* INPUT (Data,Var,Abs) */
|
||||
0x95, 0x01, /* REPORT_COUNT (1) */
|
||||
0x75, 0x05, /* REPORT_SIZE (5) */
|
||||
0x81, 0x01, /* INPUT (Cnst,Var,Abs) */
|
||||
0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
|
||||
0x09, 0x30, /* USAGE (X) */
|
||||
0x09, 0x31, /* USAGE (Y) */
|
||||
0x09, 0x38, /* USAGE (WHEEL) */
|
||||
0x15, 0x81, /* LOGICAL_MINIMUM (-127) */
|
||||
0x25, 0x7f, /* LOGICAL_MAXIMUM (127) */
|
||||
0x75, 0x08, /* REPORT_SIZE (8) */
|
||||
0x95, 0x03, /* REPORT_COUNT (3) */
|
||||
0x81, 0x06, /* INPUT (Data,Var,Rel) */
|
||||
0xc0, /* END_COLLECTION */
|
||||
0xc0, /* END_COLLECTION */
|
||||
0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
|
||||
0x09, 0x06, /* USAGE (Keyboard) */
|
||||
0xa1, 0x01, /* COLLECTION (Application) */
|
||||
0x85, 0x02, /* REPORT_ID (2) */
|
||||
0x05, 0x08, /* USAGE_PAGE (Led) */
|
||||
0x19, 0x01, /* USAGE_MINIMUM (1) */
|
||||
0x29, 0x03, /* USAGE_MAXIMUM (3) */
|
||||
0x15, 0x00, /* LOGICAL_MINIMUM (0) */
|
||||
0x25, 0x01, /* LOGICAL_MAXIMUM (1) */
|
||||
0x95, 0x03, /* REPORT_COUNT (3) */
|
||||
0x75, 0x01, /* REPORT_SIZE (1) */
|
||||
0x91, 0x02, /* Output (Data,Var,Abs) */
|
||||
0x95, 0x01, /* REPORT_COUNT (1) */
|
||||
0x75, 0x05, /* REPORT_SIZE (5) */
|
||||
0x91, 0x01, /* Output (Cnst,Var,Abs) */
|
||||
0xc0, /* END_COLLECTION */
|
||||
};
|
||||
|
||||
static int uhid_write(int fd, const struct uhid_event *ev)
|
||||
{
|
||||
ssize_t ret;
|
||||
|
||||
ret = write(fd, ev, sizeof(*ev));
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Cannot write to uhid: %m\n");
|
||||
return -errno;
|
||||
} else if (ret != sizeof(*ev)) {
|
||||
fprintf(stderr, "Wrong size written to uhid: %ld != %lu\n",
|
||||
ret, sizeof(ev));
|
||||
return -EFAULT;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static int create(int fd)
|
||||
{
|
||||
struct uhid_event ev;
|
||||
|
||||
memset(&ev, 0, sizeof(ev));
|
||||
ev.type = UHID_CREATE;
|
||||
strcpy((char*)ev.u.create.name, "test-uhid-device");
|
||||
ev.u.create.rd_data = rdesc;
|
||||
ev.u.create.rd_size = sizeof(rdesc);
|
||||
ev.u.create.bus = BUS_USB;
|
||||
ev.u.create.vendor = 0x15d9;
|
||||
ev.u.create.product = 0x0a37;
|
||||
ev.u.create.version = 0;
|
||||
ev.u.create.country = 0;
|
||||
|
||||
return uhid_write(fd, &ev);
|
||||
}
|
||||
|
||||
static void destroy(int fd)
|
||||
{
|
||||
struct uhid_event ev;
|
||||
|
||||
memset(&ev, 0, sizeof(ev));
|
||||
ev.type = UHID_DESTROY;
|
||||
|
||||
uhid_write(fd, &ev);
|
||||
}
|
||||
|
||||
/* This parses raw output reports sent by the kernel to the device. A normal
|
||||
* uhid program shouldn't do this but instead just forward the raw report.
|
||||
* However, for ducomentational purposes, we try to detect LED events here and
|
||||
* print debug messages for it. */
|
||||
static void handle_output(struct uhid_event *ev)
|
||||
{
|
||||
/* LED messages are adverised via OUTPUT reports; ignore the rest */
|
||||
if (ev->u.output.rtype != UHID_OUTPUT_REPORT)
|
||||
return;
|
||||
/* LED reports have length 2 bytes */
|
||||
if (ev->u.output.size != 2)
|
||||
return;
|
||||
/* first byte is report-id which is 0x02 for LEDs in our rdesc */
|
||||
if (ev->u.output.data[0] != 0x2)
|
||||
return;
|
||||
|
||||
/* print flags payload */
|
||||
fprintf(stderr, "LED output report received with flags %x\n",
|
||||
ev->u.output.data[1]);
|
||||
}
|
||||
|
||||
static int event(int fd)
|
||||
{
|
||||
struct uhid_event ev;
|
||||
ssize_t ret;
|
||||
|
||||
memset(&ev, 0, sizeof(ev));
|
||||
ret = read(fd, &ev, sizeof(ev));
|
||||
if (ret == 0) {
|
||||
fprintf(stderr, "Read HUP on uhid-cdev\n");
|
||||
return -EFAULT;
|
||||
} else if (ret < 0) {
|
||||
fprintf(stderr, "Cannot read uhid-cdev: %m\n");
|
||||
return -errno;
|
||||
} else if (ret != sizeof(ev)) {
|
||||
fprintf(stderr, "Invalid size read from uhid-dev: %ld != %lu\n",
|
||||
ret, sizeof(ev));
|
||||
return -EFAULT;
|
||||
}
|
||||
|
||||
switch (ev.type) {
|
||||
case UHID_START:
|
||||
fprintf(stderr, "UHID_START from uhid-dev\n");
|
||||
break;
|
||||
case UHID_STOP:
|
||||
fprintf(stderr, "UHID_STOP from uhid-dev\n");
|
||||
break;
|
||||
case UHID_OPEN:
|
||||
fprintf(stderr, "UHID_OPEN from uhid-dev\n");
|
||||
break;
|
||||
case UHID_CLOSE:
|
||||
fprintf(stderr, "UHID_CLOSE from uhid-dev\n");
|
||||
break;
|
||||
case UHID_OUTPUT:
|
||||
fprintf(stderr, "UHID_OUTPUT from uhid-dev\n");
|
||||
handle_output(&ev);
|
||||
break;
|
||||
case UHID_OUTPUT_EV:
|
||||
fprintf(stderr, "UHID_OUTPUT_EV from uhid-dev\n");
|
||||
break;
|
||||
default:
|
||||
fprintf(stderr, "Invalid event from uhid-dev: %u\n", ev.type);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool btn1_down;
|
||||
static bool btn2_down;
|
||||
static bool btn3_down;
|
||||
static signed char abs_hor;
|
||||
static signed char abs_ver;
|
||||
static signed char wheel;
|
||||
|
||||
static int send_event(int fd)
|
||||
{
|
||||
struct uhid_event ev;
|
||||
|
||||
memset(&ev, 0, sizeof(ev));
|
||||
ev.type = UHID_INPUT;
|
||||
ev.u.input.size = 5;
|
||||
|
||||
ev.u.input.data[0] = 0x1;
|
||||
if (btn1_down)
|
||||
ev.u.input.data[1] |= 0x1;
|
||||
if (btn2_down)
|
||||
ev.u.input.data[1] |= 0x2;
|
||||
if (btn3_down)
|
||||
ev.u.input.data[1] |= 0x4;
|
||||
|
||||
ev.u.input.data[2] = abs_hor;
|
||||
ev.u.input.data[3] = abs_ver;
|
||||
ev.u.input.data[4] = wheel;
|
||||
|
||||
return uhid_write(fd, &ev);
|
||||
}
|
||||
|
||||
static int keyboard(int fd)
|
||||
{
|
||||
char buf[128];
|
||||
ssize_t ret, i;
|
||||
|
||||
ret = read(STDIN_FILENO, buf, sizeof(buf));
|
||||
if (ret == 0) {
|
||||
fprintf(stderr, "Read HUP on stdin\n");
|
||||
return -EFAULT;
|
||||
} else if (ret < 0) {
|
||||
fprintf(stderr, "Cannot read stdin: %m\n");
|
||||
return -errno;
|
||||
}
|
||||
|
||||
for (i = 0; i < ret; ++i) {
|
||||
switch (buf[i]) {
|
||||
case '1':
|
||||
btn1_down = !btn1_down;
|
||||
ret = send_event(fd);
|
||||
if (ret)
|
||||
return ret;
|
||||
break;
|
||||
case '2':
|
||||
btn2_down = !btn2_down;
|
||||
ret = send_event(fd);
|
||||
if (ret)
|
||||
return ret;
|
||||
break;
|
||||
case '3':
|
||||
btn3_down = !btn3_down;
|
||||
ret = send_event(fd);
|
||||
if (ret)
|
||||
return ret;
|
||||
break;
|
||||
case 'a':
|
||||
abs_hor = -20;
|
||||
ret = send_event(fd);
|
||||
abs_hor = 0;
|
||||
if (ret)
|
||||
return ret;
|
||||
break;
|
||||
case 'd':
|
||||
abs_hor = 20;
|
||||
ret = send_event(fd);
|
||||
abs_hor = 0;
|
||||
if (ret)
|
||||
return ret;
|
||||
break;
|
||||
case 'w':
|
||||
abs_ver = -20;
|
||||
ret = send_event(fd);
|
||||
abs_ver = 0;
|
||||
if (ret)
|
||||
return ret;
|
||||
break;
|
||||
case 's':
|
||||
abs_ver = 20;
|
||||
ret = send_event(fd);
|
||||
abs_ver = 0;
|
||||
if (ret)
|
||||
return ret;
|
||||
break;
|
||||
case 'r':
|
||||
wheel = 1;
|
||||
ret = send_event(fd);
|
||||
wheel = 0;
|
||||
if (ret)
|
||||
return ret;
|
||||
break;
|
||||
case 'f':
|
||||
wheel = -1;
|
||||
ret = send_event(fd);
|
||||
wheel = 0;
|
||||
if (ret)
|
||||
return ret;
|
||||
break;
|
||||
case 'q':
|
||||
return -ECANCELED;
|
||||
default:
|
||||
fprintf(stderr, "Invalid input: %c\n", buf[i]);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int fd;
|
||||
const char *path = "/dev/uhid";
|
||||
struct pollfd pfds[2];
|
||||
int ret;
|
||||
struct termios state;
|
||||
|
||||
ret = tcgetattr(STDIN_FILENO, &state);
|
||||
if (ret) {
|
||||
fprintf(stderr, "Cannot get tty state\n");
|
||||
} else {
|
||||
state.c_lflag &= ~ICANON;
|
||||
state.c_cc[VMIN] = 1;
|
||||
ret = tcsetattr(STDIN_FILENO, TCSANOW, &state);
|
||||
if (ret)
|
||||
fprintf(stderr, "Cannot set tty state\n");
|
||||
}
|
||||
|
||||
if (argc >= 2) {
|
||||
if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
|
||||
fprintf(stderr, "Usage: %s [%s]\n", argv[0], path);
|
||||
return EXIT_SUCCESS;
|
||||
} else {
|
||||
path = argv[1];
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(stderr, "Open uhid-cdev %s\n", path);
|
||||
fd = open(path, O_RDWR | O_CLOEXEC);
|
||||
if (fd < 0) {
|
||||
fprintf(stderr, "Cannot open uhid-cdev %s: %m\n", path);
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
fprintf(stderr, "Create uhid device\n");
|
||||
ret = create(fd);
|
||||
if (ret) {
|
||||
close(fd);
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
pfds[0].fd = STDIN_FILENO;
|
||||
pfds[0].events = POLLIN;
|
||||
pfds[1].fd = fd;
|
||||
pfds[1].events = POLLIN;
|
||||
|
||||
fprintf(stderr, "Press 'q' to quit...\n");
|
||||
while (1) {
|
||||
ret = poll(pfds, 2, -1);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Cannot poll for fds: %m\n");
|
||||
break;
|
||||
}
|
||||
if (pfds[0].revents & POLLHUP) {
|
||||
fprintf(stderr, "Received HUP on stdin\n");
|
||||
break;
|
||||
}
|
||||
if (pfds[1].revents & POLLHUP) {
|
||||
fprintf(stderr, "Received HUP on uhid-cdev\n");
|
||||
break;
|
||||
}
|
||||
|
||||
if (pfds[0].revents & POLLIN) {
|
||||
ret = keyboard(fd);
|
||||
if (ret)
|
||||
break;
|
||||
}
|
||||
if (pfds[1].revents & POLLIN) {
|
||||
ret = event(fd);
|
||||
if (ret)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(stderr, "Destroy uhid device\n");
|
||||
destroy(fd);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue