--- /dev/null
+/*
+
+SiI8348 Linux Driver
+
+Copyright (C) 2013 Silicon Image, Inc.
+
+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 version 2.
+This program is distributed AS-IS WITHOUT ANY WARRANTY of any
+kind, whether express or implied; INCLUDING without the implied warranty
+of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE or NON-INFRINGEMENT. See
+the GNU General Public License for more details at http://www.gnu.org/licenses/gpl-2.0.html.
+
+*/
+
+/**
+ @file si_mdt_inputdev.c
+*/
+#include "sii_hal.h"
+
+#ifdef MEDIA_DATA_TUNNEL_SUPPORT
+
+#include <linux/input.h>
+#include <linux/cdev.h>
+#include <linux/hrtimer.h>
+
+#include "si_fw_macros.h"
+#include "si_mhl_defs.h"
+#include "si_infoframe.h"
+#include "si_edid.h"
+#include "si_mhl2_edid_3d_api.h"
+#include "si_mhl_tx_hw_drv_api.h"
+#include "si_mdt_inputdev.h"
+#include "mhl_linux_tx.h"
+#include "platform.h"
+#ifdef KERNEL_2_6_38_AND_LATER
+#include <linux/input/mt.h>
+#endif
+#include <linux/kernel.h>
+
+/* keycode map from usbkbd.c */
+uint8_t usb_kbd_keycode[256] = {
+ 0, 0, 0, 0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
+ 50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44, 2, 3,
+ 4, 5, 6, 7, 8, 9, 10, 11, 28, 1, 14, 15, 57, 12, 13, 26,
+ 27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
+ 65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
+ 105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
+ 72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
+ 191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
+ 115,114, 0, 0, 0,121, 0, 89, 93,124, 92, 94, 95, 0, 0, 0,
+ 122,123, 90, 91, 85, 0, 0, 0, 0, 0,150,155, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 200,201,207,208,213,215,216,217,226,139,172, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
+ 150,158,159,128,136,177,178,176,142,152,173,140
+};
+
+// Local, helper functions
+static bool is_mdt_dev_active(struct mhl_dev_context *dev_context, enum mdt_dev_types_e dev_type) {
+ if (dev_context->mdt_devs.is_dev_registered[dev_type]==INPUT_ACTIVE)
+ return true;
+ else
+ return false;
+}
+
+static bool is_mdt_dev_waiting(struct mhl_dev_context *dev_context, enum mdt_dev_types_e dev_type) {
+ if (dev_context->mdt_devs.is_dev_registered[dev_type]==INPUT_WAITING_FOR_REGISTRATION)
+ return true;
+ else
+ return false;
+}
+
+static void destroy_mouse(struct mhl_dev_context *dev_context)
+{
+ if (dev_context->mdt_devs.dev_mouse == NULL)
+ return;
+
+ MHL_TX_DBG_INFO(dev_context, "Unregistering mouse: %p\n",dev_context->mdt_devs.dev_mouse);
+ input_unregister_device(dev_context->mdt_devs.dev_mouse);
+ MHL_TX_DBG_INFO(dev_context, "Freeing mouse: %p\n",dev_context->mdt_devs.dev_mouse);
+ input_free_device(dev_context->mdt_devs.dev_mouse);
+ dev_context->mdt_devs.dev_mouse = NULL;
+}
+
+static void destroy_keyboard(struct mhl_dev_context *dev_context)
+{
+ if (dev_context->mdt_devs.dev_keyboard == NULL)
+ return;
+
+ MHL_TX_DBG_INFO(dev_context, "Unregistering keyboard: %p\n",dev_context->mdt_devs.dev_keyboard);
+ input_unregister_device(dev_context->mdt_devs.dev_keyboard);
+ MHL_TX_DBG_INFO(dev_context, "Freeing keyboard: %p\n",dev_context->mdt_devs.dev_keyboard);
+ input_free_device(dev_context->mdt_devs.dev_keyboard);
+ dev_context->mdt_devs.dev_keyboard = NULL;
+}
+
+static void destroy_touchscreen(struct mhl_dev_context *dev_context)
+{
+ if (dev_context->mdt_devs.dev_touchscreen == NULL)
+ return;
+
+ MHL_TX_DBG_INFO(dev_context, "Unregistering mouse: %p\n",dev_context->mdt_devs.dev_touchscreen);
+ input_unregister_device(dev_context->mdt_devs.dev_touchscreen);
+ MHL_TX_DBG_INFO(dev_context, "Freeing mouse: %p\n",dev_context->mdt_devs.dev_touchscreen);
+ input_free_device(dev_context->mdt_devs.dev_touchscreen);
+ dev_context->mdt_devs.dev_touchscreen = NULL;
+ memset(dev_context->mdt_devs.prior_touch_events, 0,
+ MAX_TOUCH_CONTACTS * sizeof(dev_context->mdt_devs.prior_touch_events[0]));
+}
+
+int init_mdt_keyboard(struct mhl_dev_context *dev_context)
+{
+ int i;
+ uint8_t error;
+ struct input_dev *dev_keyboard;
+
+ dev_keyboard = input_allocate_device();
+ if (!dev_keyboard) {
+ MHL_TX_DBG_ERR(dev_context, "Not enough memory\n");
+ return -ENOMEM;
+ }
+ MHL_TX_DBG_INFO(dev_context, "Allocated keyboard: %p\n",dev_keyboard);
+
+ set_bit(EV_KEY, dev_keyboard->evbit);
+ set_bit(EV_REP, dev_keyboard->evbit);
+
+ dev_keyboard->phys = "mdt_kbd/input0";
+ dev_keyboard->name = "MDTkeyboard";
+ dev_keyboard->keycode = usb_kbd_keycode;
+ dev_keyboard->keycodesize= sizeof(unsigned char);
+ dev_keyboard->keycodemax = ARRAY_SIZE(usb_kbd_keycode);
+
+ for (i = 1; i < 256; i++)
+ set_bit(usb_kbd_keycode[i], dev_keyboard->keybit);
+
+ dev_keyboard->id.bustype = BUS_VIRTUAL;
+ dev_keyboard->id.vendor = 0x1095;
+ dev_keyboard->id.product = MHL_PRODUCT_NUM;
+
+ /* Use version to distinguish between devices */
+ dev_keyboard->id.version = 0xA;
+
+ error = input_register_device(dev_keyboard);
+ if (error) {
+ MHL_TX_DBG_ERR(dev_context, "Failed to register device\n");
+ input_free_device(dev_keyboard);
+ return error;
+ }
+
+ MHL_TX_DBG_INFO(dev_context, "Registered keyboard: %p\n",dev_keyboard);
+
+ dev_context->mdt_devs.dev_keyboard = dev_keyboard;
+
+ return 0;
+}
+
+int init_mdt_mouse(struct mhl_dev_context *dev_context)
+{
+ uint8_t error;
+ struct input_dev *dev_mouse;
+
+ dev_mouse = input_allocate_device();
+ if (!dev_mouse) {
+ MHL_TX_DBG_ERR(dev_context, "Not enough memory\n");
+ return -ENOMEM;
+ }
+ MHL_TX_DBG_INFO(dev_context, "Allocated mouse: %p\n",dev_mouse);
+
+ set_bit(EV_REL, dev_mouse->evbit);
+ set_bit(EV_KEY, dev_mouse->evbit);
+ set_bit(BTN_LEFT, dev_mouse->keybit);
+ set_bit(BTN_RIGHT, dev_mouse->keybit);
+ set_bit(BTN_MIDDLE, dev_mouse->keybit);
+ set_bit(BTN_SIDE, dev_mouse->keybit);
+ set_bit(BTN_EXTRA, dev_mouse->keybit);
+ set_bit(REL_X, dev_mouse->relbit);
+ set_bit(REL_Y, dev_mouse->relbit);
+ set_bit(REL_WHEEL, dev_mouse->relbit);
+ #if (RIGHT_MOUSE_BUTTON_IS_ESC == 1)
+ set_bit(KEY_ESC, dev_mouse->keybit);
+ dev_context->mdt_devs.prior_right_button = 0;
+ #endif
+
+ dev_mouse->phys = "mdt_mouse/input0";
+ dev_mouse->name = "MDTmouse";
+ dev_mouse->id.bustype = BUS_VIRTUAL;
+ dev_mouse->id.vendor = 0x1095;
+ dev_mouse->id.product = MHL_PRODUCT_NUM;
+
+ /* Use version to distinguish between devices */
+ dev_mouse->id.version = 0xB;
+
+ error = input_register_device(dev_mouse);
+ if (error) {
+ MHL_TX_DBG_ERR(dev_context, "Failed to register device\n");
+ input_free_device(dev_mouse);
+ return error;
+ }
+
+ MHL_TX_DBG_INFO(dev_context, "Registered mouse: %p\n",dev_mouse);
+
+ dev_context->mdt_devs.dev_mouse = dev_mouse;
+
+ return 0;
+}
+
+
+int init_mdt_touchscreen(struct mhl_dev_context *dev_context)
+{
+ uint8_t error;
+ struct input_dev *dev_touchscreen;
+
+ dev_touchscreen = input_allocate_device();
+ if (!dev_touchscreen) {
+ MHL_TX_DBG_ERR(dev_context, "Not enough memory\n");
+ return -ENOMEM;
+ }
+
+ MHL_TX_DBG_INFO(dev_context, "Allocated touch screen: %p\n",dev_touchscreen);
+
+ #if !defined(SINGLE_TOUCH) && defined(KERNEL_2_6_38_AND_LATER)
+ input_mt_init_slots (dev_touchscreen, MAX_TOUCH_CONTACTS);
+ #endif
+
+ dev_touchscreen->phys = "mdt_touch/input0";
+ dev_touchscreen->name = "MDTtouchscreen";
+ dev_touchscreen->id.bustype = BUS_VIRTUAL;
+ dev_touchscreen->id.vendor = 0x1095;
+ dev_touchscreen->id.product = MHL_PRODUCT_NUM;
+
+ /* use version to distinguish between devices */
+ dev_touchscreen->id.version = 0xC;
+
+
+#if defined(SINGLE_TOUCH)
+ __set_bit(EV_ABS, dev_touchscreen->evbit);
+ __set_bit(ABS_X, dev_touchscreen->absbit);
+ __set_bit(ABS_Y, dev_touchscreen->absbit);
+ __set_bit(EV_KEY, dev_touchscreen->evbit);
+ #if (CORNER_BUTTON == 1)
+ __set_bit(KEY_ESC, dev_touchscreen->keybit);
+ #endif
+ __set_bit(BTN_TOUCH, dev_touchscreen->keybit);
+ #ifdef KERNEL_2_6_38_AND_LATER
+ __set_bit(INPUT_PROP_DIRECT, dev_touchscreen->propbit);
+ #endif
+ input_set_abs_params( dev_touchscreen, ABS_X, 0, dev_context->mdt_devs.x_max, 0, 0);
+ input_set_abs_params( dev_touchscreen, ABS_Y, 0, dev_context->mdt_devs.y_max, 0, 0);
+#else
+
+ __set_bit(EV_ABS, dev_touchscreen->evbit);
+ __set_bit(EV_KEY, dev_touchscreen->evbit);
+ #ifdef KERNEL_2_6_38_AND_LATER
+ __set_bit(EV_SYN, dev_touchscreen->evbit);
+ __set_bit(MT_TOOL_FINGER, dev_touchscreen->keybit);
+ __set_bit(INPUT_PROP_DIRECT,dev_touchscreen->propbit);
+ input_mt_init_slots (dev_touchscreen, MAX_TOUCH_CONTACTS);
+ #else
+ __set_bit(BTN_TOUCH, dev_touchscreen->keybit);
+ input_set_abs_params( dev_touchscreen, ABS_MT_WIDTH_MAJOR, 0, 3, 0, 0);
+ input_set_abs_params( dev_touchscreen, ABS_MT_TRACKING_ID, 0, 3, 0, 0);
+ #endif
+ #if (CORNER_BUTTON == 1)
+ __set_bit(KEY_ESC, dev_touchscreen->keybit);
+ #endif
+ input_set_abs_params( dev_touchscreen, ABS_MT_TOUCH_MAJOR, 0, 30, 0, 0);
+ input_set_abs_params( dev_touchscreen, ABS_MT_PRESSURE, 0, 255, 0, 0);
+ input_set_abs_params( dev_touchscreen, ABS_MT_POSITION_X, 0, dev_context->mdt_devs.x_max, 0, 0);
+ input_set_abs_params( dev_touchscreen, ABS_MT_POSITION_Y, 0, dev_context->mdt_devs.y_max, 0, 0);
+
+#endif
+
+#if (JB_421 == 1) && (ICS_BAR == 1)
+ #if (Y_BUTTON_RECENTAPPS_TOP != 0)
+ __set_bit(KEY_MENU, dev_touchscreen->keybit);
+ #endif
+ #if (Y_BUTTON_HOME_TOP != 0)
+ __set_bit(KEY_HOMEPAGE, dev_touchscreen->keybit);
+ #endif
+ #if (Y_BUTTON_BACK_TOP != 0)
+ __set_bit(KEY_BACK, dev_touchscreen->keybit);
+ #endif
+#endif
+
+
+ error = input_register_device(dev_touchscreen);
+ if (error) {
+ MHL_TX_DBG_ERR(dev_context, "Failed to register device\n");
+ input_free_device(dev_touchscreen);
+ return error;
+ }
+ MHL_TX_DBG_INFO(dev_context, "Registered touchscreen: %p\n",dev_touchscreen);
+
+ dev_context->mdt_devs.dev_touchscreen = dev_touchscreen;
+
+ /* initialize history; in parcitular initialize state elements with MDT_TOUCH_INACTIVE */
+ memset(dev_context->mdt_devs.prior_touch_events, 0, MAX_TOUCH_CONTACTS * sizeof(dev_context->mdt_devs.prior_touch_events[0]));
+
+ return 0;
+}
+
+static int destroy_device(struct mhl_dev_context *dev_context, enum mdt_dev_types_e mdt_device_type)
+{
+ if ((mdt_device_type >= MDT_TYPE_COUNT) ||
+ (is_mdt_dev_active(dev_context, mdt_device_type) == 0)) {
+ MHL_TX_DBG_INFO(dev_context, "FAILURE. Invalid disconnect request. mdt_device_type=0x%x\n", mdt_device_type);
+ return REGISTRATION_ERROR;
+ }
+
+ switch (mdt_device_type) {
+ case MDT_TYPE_MOUSE:
+ destroy_mouse(dev_context);
+ break;
+ case MDT_TYPE_KEYBOARD:
+ destroy_keyboard(dev_context);
+ break;
+ case MDT_TYPE_TOUCHSCREEN:
+ destroy_touchscreen(dev_context);
+ break;
+ #if 0
+ case MDT_TYPE_GAME:
+ if (!cancel_delayed_work( &(dev_context->mdt_devs.repeat_for_gamepad) ))
+ flush_workqueue(dev_context->mdt_devs.mdt_joystick_wq);
+
+ /* deregister only if not shared */
+ if (is_mdt_dev_active(dev_context, MDT_TYPE_MOUSE) == 0)
+ destroy_mouse(dev_context);
+
+ if (is_mdt_dev_active(dev_context, MDT_TYPE_KEYBOARD) == 0)
+ destroy_keyboard(dev_context);
+ break;
+ #endif
+ case MDT_TYPE_COUNT:
+ /*
+ * This case is out of range.
+ * Code is included to avoid compiler warning.
+ */
+ break;
+ }
+
+ dev_context->mdt_devs.is_dev_registered[mdt_device_type] = INPUT_WAITING_FOR_REGISTRATION;
+
+ MHL_TX_DBG_INFO(dev_context, "SUCCESS. Disconnect event handled for %d device type.\n", mdt_device_type);
+
+ return REGISTRATION_SUCCESS;
+}
+
+// The recursive piece of the registeration function.
+static int registration_helper(struct mhl_dev_context *dev_context, enum mdt_dev_types_e mdt_device_type)
+{
+ switch (mdt_device_type) {
+ case MDT_TYPE_KEYBOARD:
+ if (dev_context->mdt_devs.dev_keyboard != 0)
+ return REGISTRATION_SUCCESS;
+ return init_mdt_keyboard(dev_context);
+ break;
+ case MDT_TYPE_MOUSE:
+ if (dev_context->mdt_devs.dev_mouse != 0 )
+ return REGISTRATION_SUCCESS;
+ if (init_mdt_mouse(dev_context) != REGISTRATION_SUCCESS)
+ return REGISTRATION_ERROR;
+
+ /* Do not support both a pointer and touch. */
+ destroy_device(dev_context, MDT_TYPE_TOUCHSCREEN);
+ break;
+ case MDT_TYPE_TOUCHSCREEN:
+ if (dev_context->mdt_devs.dev_touchscreen != 0)
+ return REGISTRATION_SUCCESS;
+ if (init_mdt_touchscreen(dev_context) != REGISTRATION_SUCCESS)
+ return REGISTRATION_ERROR;
+
+ /* Do not support both a pointer and touch. */
+ destroy_device(dev_context, MDT_TYPE_MOUSE);
+ break;
+ #if 0
+ case MDT_TYPE_GAME:
+ if (registration_helper(MDT_TYPE_KEYBOARD) == REGISTRATION_ERROR)
+ return REGISTRATION_ERROR;
+ if (registration_helper(MDT_TYPE_MOUSE) == REGISTRATION_ERROR)
+ return REGISTRATION_ERROR;
+ break;
+ #endif
+ case MDT_TYPE_COUNT:
+ /*
+ * This case is out of range.
+ * Code is included to avoid compiler warning.
+ */
+ break;
+ }
+
+ return REGISTRATION_SUCCESS;
+}
+
+static int register_device(struct mhl_dev_context *dev_context, enum mdt_dev_types_e mdt_device_type)
+{
+ uint8_t error = 0;
+
+ if ((mdt_device_type >= MDT_TYPE_COUNT) ||
+ (is_mdt_dev_waiting(dev_context, mdt_device_type) == false))
+ return REGISTRATION_ERROR;
+
+ /* Call recursive part of the function.
+ Don't update is_dev_registered there. */
+ error = registration_helper(dev_context, mdt_device_type);
+
+ if (error != REGISTRATION_SUCCESS) {
+ dev_context->mdt_devs.is_dev_registered[mdt_device_type] = INPUT_DISABLED;
+ MHL_TX_DBG_INFO(dev_context, "SUCCESS. Device type %d registered.\n", mdt_device_type);
+ } else {
+ dev_context->mdt_devs.is_dev_registered[mdt_device_type] = INPUT_ACTIVE;
+ MHL_TX_DBG_INFO(dev_context, "FAILURE. Device type %d registration failed.\n", mdt_device_type);
+ }
+
+ return error;
+}
+
+void generate_event_keyboard(struct mhl_dev_context *dev_context,
+ struct mdt_packet *keyboard_packet)
+{
+ struct input_dev *dev_keyboard = dev_context->mdt_devs.dev_keyboard;
+ uint8_t *keycodes_new = dev_context->mdt_devs.keycodes_new;
+ uint8_t *keycodes_old = dev_context->mdt_devs.keycodes_old;
+ int i;
+
+ //register_device(dev_context, MDT_TYPE_KEYBOARD);
+
+ memcpy(keycodes_new, &keyboard_packet->header, HID_INPUT_REPORT);
+ MHL_TX_DBG_INFO(dev_context, "Key (scancode %02X) asserted.\n",
+ keycodes_new[1]);
+
+ if (dev_keyboard == 0) {
+ MHL_TX_DBG_INFO(dev_context, "MDT_ERR_NOKEY\n");
+ return;
+ }
+
+ /* following code was copied from usbkbd.c */
+ /* generate events for CRL, SHIFT, and ALT keys */
+ for (i = 0; i < 3; i++)
+ input_report_key(dev_keyboard,
+ usb_kbd_keycode[i + 224],
+ (keycodes_new[0] >> i) & 1);
+
+ /*
+ * Generate key press/release events for the
+ * remaining bytes in the input packet
+ */
+ for (i = 1; i < 7; i++) {
+ /* If keycode in pervious HID payload doesn't appear
+ * in NEW HID payload, generate de-assertion event
+ */
+ if ((keycodes_old[i] > 3) &&
+ ((uint8_t *)memscan(keycodes_new + 1, keycodes_old[i], 6) ==
+ ((uint8_t *)(keycodes_new) + 7))) {
+ if (usb_kbd_keycode[keycodes_old[i]]) {
+ input_report_key(dev_keyboard, usb_kbd_keycode[keycodes_old[i]], 0);
+ } else {
+ MHL_TX_DBG_INFO(dev_context, "Unknown key (scancode %#x) "
+ "released.\n", keycodes_old[i]);
+ }
+ }
+
+ /* If keycode in NEW HID paylaod doesn't appear in previous
+ * HID payload, generate assertion event
+ */
+ if (keycodes_new[i] > 3 &&
+ memscan(keycodes_old + 1, keycodes_new[i], 6) == keycodes_old + 7) {
+ if (usb_kbd_keycode[keycodes_new[i]]) {
+ input_report_key(dev_keyboard, usb_kbd_keycode[keycodes_new[i]], 1);
+ } else {
+ MHL_TX_DBG_INFO(dev_context, "Unknown key (scancode %#x) "
+ "pressed.\n", keycodes_new[i]);
+ }
+ }
+ }
+
+ input_sync(dev_keyboard);
+
+ /* NEW HID payload is now OLD */
+ memcpy(keycodes_old, keycodes_new, HID_INPUT_REPORT);
+}
+
+static void mdt_toggle_keycode(struct input_dev *hid_device
+ ,unsigned char keycode)
+{
+ if (NULL == hid_device)
+ return;
+
+ input_report_key(hid_device, keycode, KEY_PRESSED);
+ input_sync(hid_device);
+
+ input_report_key(hid_device, keycode, KEY_RELEASED);
+ input_sync(hid_device);
+}
+
+void mdt_toggle_keyboard_keycode(struct mhl_dev_context *dev_context
+ ,unsigned char keycode)
+{
+ mdt_toggle_keycode(dev_context->mdt_devs.dev_keyboard, keycode);
+}
+
+void generate_event_mouse(struct mhl_dev_context *dev_context,
+ struct mdt_packet *mousePacket)
+{
+ struct input_dev *dev_mouse = dev_context->mdt_devs.dev_mouse;
+
+ //register_device(dev_context, MDT_TYPE_MOUSE);
+
+ MHL_TX_DBG_INFO(dev_context, "mouse buttons (0x%02x)\n",
+ mousePacket->header & MDT_HDR_MOUSE_BUTTON_MASK);
+
+ if (dev_mouse == 0) {
+ MHL_TX_DBG_ERR(dev_context, "MDT_ERR_NOMOUSE\n");
+ return;
+ }
+
+ /* Translate and report mouse button changes */
+ input_report_key(dev_mouse, BTN_LEFT,
+ mousePacket->header & MDT_HDR_MOUSE_BUTTON_1);
+
+ #if (RIGHT_MOUSE_BUTTON_IS_ESC == 1)
+ if (mousePacket->header & MDT_HDR_MOUSE_BUTTON_2) {
+ if (!dev_context->mdt_devs.prior_right_button) {
+ dev_context->mdt_devs.prior_right_button = 1;
+ mdt_toggle_keycode(dev_mouse, KEY_ESC);
+ }
+ } else
+ dev_context->mdt_devs.prior_right_button = 0;
+ #else
+ input_report_key(dev_mouse, BTN_RIGHT,
+ mousePacket->header & MDT_HDR_MOUSE_BUTTON_2);
+ #endif
+ input_report_key(dev_mouse, BTN_MIDDLE,
+ mousePacket->header & MDT_HDR_MOUSE_BUTTON_3);
+
+ input_report_rel(dev_mouse, REL_X,
+ mousePacket->event.mouse.x_displacement);
+
+ input_report_rel(dev_mouse, REL_Y,
+ mousePacket->event.mouse.y_displacement);
+
+ input_report_rel(dev_mouse, REL_WHEEL,
+ mousePacket->event.mouse.z_displacement);
+
+ input_sync(dev_mouse);
+}
+
+static uint8_t process_touch_packet(struct mhl_dev_context *dev_context,
+ struct mdt_packet *touchPacket)
+{
+ struct mdt_touch_history_t *prior_event;
+ int abs_x, abs_y;
+ uint8_t isTouched = (touchPacket->header & 0x01);
+ uint8_t contactID = ((touchPacket->header & 0x06) >> 1);
+
+ prior_event = (struct mdt_touch_history_t *)&(dev_context->mdt_devs.prior_touch_events[contactID]);
+
+ abs_x = touchPacket->event.touch_pad.x_abs_coordinate[MDT_TOUCH_X_LOW] |
+ (touchPacket->event.touch_pad.x_abs_coordinate[MDT_TOUCH_X_HIGH] << 8);
+ abs_y = touchPacket->event.touch_pad.y_abs_coordinate[MDT_TOUCH_Y_LOW] |
+ (touchPacket->event.touch_pad.y_abs_coordinate[MDT_TOUCH_Y_HIGH] << 8);
+
+ #if (CORNER_BUTTON == 1)
+ /* Handle LOWER RIGHT corner like a EXIT button (ESC key) */
+ if (( abs_x > X_CORNER_RIGHT_LOWER ) && ( abs_y > Y_CORNER_RIGHT_LOWER )) {
+ if (isTouched != dev_context->mdt_devs.prior_touch_button)
+ {
+ dev_context->mdt_devs.prior_touch_button = isTouched;
+ if (isTouched)
+ mdt_toggle_keycode(dev_context->mdt_devs.dev_touchscreen, KEY_ESC);
+ }
+ return 0xFF;
+ }
+ #elif (ICS_BAR == 1)
+ /* JB421 doesn't allow this driver to trigger buttons on the bar.
+ implement custom buttons to workaround the problem. */
+ if ((isTouched != dev_context->mdt_devs.prior_touch_button)
+ && ( abs_x >= X_BUTTON_BAR_START)) {
+ if (( abs_y > Y_BUTTON_RECENTAPPS_TOP) && ( abs_y < Y_BUTTON_RECENTAPPS_BOTTOM))
+ mdt_toggle_keycode(dev_context->mdt_devs.dev_touchscreen, KEY_MENU);
+ else if (( abs_y > Y_BUTTON_HOME_TOP) && ( abs_y < Y_BUTTON_HOME_BOTTOM))
+ mdt_toggle_keycode(dev_context->mdt_devs.dev_touchscreen, KEY_HOMEPAGE);
+ else if (( abs_y > Y_BUTTON_BACK_TOP) && ( abs_y < Y_BUTTON_BACK_BOTTOM))
+ mdt_toggle_keycode(dev_context->mdt_devs.dev_touchscreen, KEY_BACK);
+ return 0xFF;
+ }
+ #endif
+
+ /* support dynamic configuration through ATTRIBUTES */
+ if (dev_context->mdt_devs.swap_xy != 0) {
+ prior_event->abs_x = abs_y;
+ prior_event->abs_y = abs_x;
+ } else {
+ prior_event->abs_x = abs_x;
+ prior_event->abs_y = abs_y;
+ }
+
+ if ((dev_context->mdt_devs.x_raw != 0) &&
+ (dev_context->mdt_devs.x_screen != 0) && (prior_event->abs_x != 0)) {
+ prior_event->abs_x *= dev_context->mdt_devs.x_screen;
+ prior_event->abs_x /= dev_context->mdt_devs.x_raw;
+ }
+
+ if ((dev_context->mdt_devs.y_raw != 0) &&
+ (dev_context->mdt_devs.y_screen != 0) && (prior_event->abs_y != 0)) {
+ prior_event->abs_y *= dev_context->mdt_devs.y_screen;
+ prior_event->abs_y /= dev_context->mdt_devs.y_raw;
+ }
+
+ if ((dev_context->mdt_devs.swap_leftright) &&
+ (dev_context->mdt_devs.x_max >= prior_event->abs_x))
+ prior_event->abs_x = (dev_context->mdt_devs.x_max - prior_event->abs_x);
+
+ if ((dev_context->mdt_devs.swap_updown) &&
+ (dev_context->mdt_devs.y_max >= prior_event->abs_y))
+ prior_event->abs_y = (dev_context->mdt_devs.y_max - prior_event->abs_y);
+
+ prior_event->abs_x += dev_context->mdt_devs.x_shift;
+ prior_event->abs_y += dev_context->mdt_devs.y_shift;
+
+ if (isTouched == 0) {
+ if (prior_event->isTouched == 0)
+ /* Multiple release events; declare contact inactive & ignore */
+ prior_event->state = MDT_TOUCH_INACTIVE;
+ } else {
+ prior_event->state = MDT_TOUCH_ACTIVE;
+ }
+ prior_event->isTouched = isTouched;
+
+ return contactID;
+}
+#if defined(SINGLE_TOUCH)
+static void submit_touchscreen_events_as_single_touch(struct mhl_dev_context *dev_context)
+{
+ struct input_dev *dev_ts = dev_context->mdt_devs.dev_touchscreen;
+ struct mdt_touch_history_t *prior_event;
+
+ prior_event = &(dev_context->mdt_devs.prior_touch_events[0]);
+ input_report_key(dev_ts, BTN_TOUCH, prior_event->isTouched);
+ input_report_abs(dev_ts, ABS_X, prior_event->abs_x);
+ input_report_abs(dev_ts, ABS_Y, prior_event->abs_y);
+}
+#elif defined(KERNEL_2_6_38_AND_LATER)
+static void submit_touchscreen_events_with_proto_B(struct mhl_dev_context *dev_context,
+ uint8_t contactID)
+{
+ struct input_dev *dev_ts = dev_context->mdt_devs.dev_touchscreen;
+ struct mdt_touch_history_t *prior_event;
+ uint8_t i;
+ uint8_t counter = 0;
+
+ for (i=0; i< MAX_TOUCH_CONTACTS; i++) {
+
+ prior_event = &(dev_context->mdt_devs.prior_touch_events[i]);
+
+ if (prior_event->state == MDT_TOUCH_INACTIVE)
+ continue;
+
+ input_mt_slot(dev_ts, i);
+ input_mt_report_slot_state(dev_ts, MT_TOOL_FINGER, prior_event->isTouched);
+
+ /* Event already handled; don't handle it again. */
+ if (prior_event->isTouched == 0) {
+ prior_event->state = MDT_TOUCH_INACTIVE;
+ } else {
+ counter++;
+ input_report_abs(dev_ts, ABS_MT_TOUCH_MAJOR,15);
+ input_report_abs(dev_ts, ABS_MT_PRESSURE, 50);
+ input_report_abs(dev_ts, ABS_MT_POSITION_X, prior_event->abs_x);
+ input_report_abs(dev_ts, ABS_MT_POSITION_Y, prior_event->abs_y);
+ }
+
+ /* BTN_TOUCH breaks support brokend as of JB42 */
+ #if !defined(JB_421)
+ if (counter == 1)
+ input_report_key(dev_ts, BTN_TOUCH, 1);
+ else
+ input_report_key(dev_ts, BTN_TOUCH, 0);
+ #endif
+}
+#else
+static void submit_touchscreen_events_with_proto_A(struct mhl_dev_context *dev_context,
+ uint8_t contactID)
+{
+ struct input_dev *dev_ts = dev_context->mdt_devs.dev_touchscreen;
+ struct mdt_touch_history_t *prior_event;
+ uint8_t i;
+ uint8_t count = 0;
+
+ for (i=0; i< MAX_TOUCH_CONTACTS; i++) {
+ prior_event = &(dev_context->mdt_devs.prior_touch_events[i]);
+
+ if (prior_event->state == MDT_TOUCH_INACTIVE)
+ continue;
+
+ count++;
+
+ if (prior_event->isTouched == 0) //Event handled; don't handle it again.
+ prior_event->state = MDT_TOUCH_INACTIVE;
+
+ input_report_key(dev_ts, BTN_TOUCH, prior_event->isTouched);
+ input_report_abs(dev_ts, ABS_MT_TOUCH_MAJOR, prior_event->isTouched);
+ input_report_abs(dev_ts, ABS_MT_TRACKING_ID, i);
+ input_report_abs(dev_ts, ABS_MT_WIDTH_MAJOR, 1);
+ input_report_abs(dev_ts, ABS_MT_POSITION_X, prior_event->abs_x);
+ input_report_abs(dev_ts,ABS_MT_POSITION_Y, prior_event->abs_y);
+ input_mt_sync(dev_ts);
+ }
+
+ if (count == 0)
+ input_mt_sync(dev_ts);
+}
+#endif
+
+static void generate_event_touchscreen(struct mhl_dev_context *dev_context,
+ struct mdt_packet *touchPacket)
+{
+ struct input_dev *dev_ts = dev_context->mdt_devs.dev_touchscreen;
+ uint8_t contactID;
+
+ //register_device(dev_context, MDT_TYPE_TOUCHSCREEN);
+
+ if (dev_ts == 0 ) {
+ MHL_TX_DBG_ERR(dev_context, "MDT_ERR_NOTOUCHSCREEN\n");
+ return;
+ }
+
+ /* process touch packet into prior_touch_events */
+ contactID = process_touch_packet(dev_context, touchPacket);
+ if (contactID == 0xFF)
+ return;
+
+ #if defined(SINGLE_TOUCH)
+ submit_touchscreen_events_as_single_touch(dev_context);
+ #elif defined(KERNEL_2_6_38_AND_LATER)
+ submit_touchscreen_events_with_proto_B(dev_context, contactID);
+ #else
+ submit_touchscreen_events_with_proto_A(dev_context, contactID);
+ #endif
+ /* generate touchscreen assertion */
+ input_sync(dev_ts);
+}
+
+static bool process_hotplug_packet(struct mhl_dev_context *dev_context, struct mdt_packet *hotplug_packet)
+{
+ /* 'M' previoulsy found to be in the header byte */
+ if ((hotplug_packet->event.hotplug.sub_header_d != D_CHAR) &&
+ (hotplug_packet->event.hotplug.sub_header_t != T_CHAR) &&
+ (hotplug_packet->event.hotplug.mdt_version != MDT_VERSION))
+ return false;
+
+ /* in the future, support response with ACK or NACK */
+ MHL_TX_DBG_INFO(dev_context, "HP packet. Device type: %02x. Event: %02x.\n",
+ hotplug_packet->event.hotplug.device_type, hotplug_packet->event.hotplug.event_code );
+ switch (hotplug_packet->event.hotplug.event_code) {
+ case NOTICE_DEV_PLUG:
+ register_device(dev_context, hotplug_packet->event.hotplug.device_type);
+ break;
+ case NOTICE_DEV_UNPLUG:
+ destroy_device(dev_context, hotplug_packet->event.hotplug.device_type);
+ break;
+ default:
+ return false;
+ }
+ return true;
+}
+
+
+bool si_mhl_tx_mdt_process_packet(struct mhl_dev_context *dev_context,void *packet)
+{
+ struct mdt_packet *mdt_event_packet=(struct mdt_packet *)packet;
+
+ if (!(MDT_HDR_IS_HID & mdt_event_packet->header)) {
+ if (M_CHAR == mdt_event_packet->header)
+ return process_hotplug_packet(dev_context, mdt_event_packet);
+
+ MHL_TX_DBG_INFO(dev_context, "Ignoring non-HID packet\n");
+ return false;
+ }
+
+ if (MDT_HDR_IS_KEYBOARD & mdt_event_packet->header) {
+ generate_event_keyboard(dev_context, mdt_event_packet);
+
+ } else if (!(MDT_HDR_IS_KEYBOARD & mdt_event_packet->header) &&
+ (!(MDT_HDR_IS_NOT_MOUSE & mdt_event_packet->header))) {
+ generate_event_mouse(dev_context, mdt_event_packet);
+
+ } else if (!(MDT_HDR_IS_KEYBOARD & mdt_event_packet->header) &&
+ (MDT_HDR_IS_NOT_MOUSE & mdt_event_packet->header)) {
+ generate_event_touchscreen(dev_context, mdt_event_packet);
+
+ } else if (!(MDT_HDR_IS_KEYBOARD & mdt_event_packet->header) &&
+ (MDT_HDR_IS_NOT_MOUSE & mdt_event_packet->header) &&
+ (MDT_HDR_IS_NOT_LAST & mdt_event_packet->header)) {
+
+ MHL_TX_DBG_INFO(dev_context, "Unsupported gaming controller "\
+ "event received\n");
+ } else {
+ MHL_TX_DBG_INFO(dev_context, "Event is either not an HID event or "\
+ "is an an unknown HID event type\n");
+ return false;
+ }
+
+ /* Consume the write burst event as an MDT event */
+ return true;
+}
+
+/*
+int mdt_init(struct mhl_dev_context *dev_context)
+{
+ int status;
+ MHL_TX_DBG_INFO(dev_context, "mdt_init!!!!!!!!!!!!!!.\n");
+
+ status = init_mdt_keyboard(dev_context);
+ if (status < 0){
+ MHL_TX_DBG_INFO(dev_context, "Keyboard registration failure.\n");
+ goto exit;
+ }
+
+ status = init_mdt_mouse(dev_context);
+ if (status < 0){
+ MHL_TX_DBG_INFO(dev_context, "Mouse registration failure.\n");
+ MHL_TX_DBG_INFO(dev_context, "Unregistering keyboard: %p\n",dev_context->mdt_devs.dev_keyboard);
+ input_unregister_device(dev_context->mdt_devs.dev_keyboard);
+ }
+exit:
+ return status;
+}
+*/
+
+
+void mdt_destroy(struct mhl_dev_context *dev_context)
+{
+ MHL_TX_DBG_INFO(dev_context, "mdt_destroy!!!!!!!!!!!!!!.\n");
+ destroy_device(dev_context, MDT_TYPE_KEYBOARD);
+ destroy_device(dev_context, MDT_TYPE_MOUSE);
+ destroy_device(dev_context, MDT_TYPE_TOUCHSCREEN);
+}
+
+#endif
projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blobdiff