diff options
Diffstat (limited to 'drivers/hid')
24 files changed, 702 insertions, 965 deletions
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig index 4070b7386e9d..1aeb80e52424 100644 --- a/drivers/hid/Kconfig +++ b/drivers/hid/Kconfig @@ -785,6 +785,11 @@ config HID_SUNPLUS config HID_RMI tristate "Synaptics RMI4 device support" depends on HID + select RMI4_CORE + select RMI4_F03 + select RMI4_F11 + select RMI4_F12 + select RMI4_F30 ---help--- Support for Synaptics RMI4 touchpads. Say Y here if you have a Synaptics RMI4 touchpads over i2c-hid or usbhid diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c index ea36b557d5ee..e9e87d337446 100644 --- a/drivers/hid/hid-core.c +++ b/drivers/hid/hid-core.c @@ -43,7 +43,6 @@ */ #define DRIVER_DESC "HID core driver" -#define DRIVER_LICENSE "GPL" int hid_debug = 0; module_param_named(debug, hid_debug, int, 0600); @@ -724,13 +723,7 @@ static void hid_scan_collection(struct hid_parser *parser, unsigned type) hid->group = HID_GROUP_SENSOR_HUB; if (hid->vendor == USB_VENDOR_ID_MICROSOFT && - (hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3 || - hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2 || - hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP || - hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_4 || - hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_2 || - hid->product == USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_JP || - hid->product == USB_DEVICE_ID_MS_POWER_COVER) && + hid->product == USB_DEVICE_ID_MS_POWER_COVER && hid->group == HID_GROUP_MULTITOUCH) hid->group = HID_GROUP_GENERIC; @@ -826,14 +819,16 @@ static int hid_scan_report(struct hid_device *hid) hid->group = HID_GROUP_WACOM; break; case USB_VENDOR_ID_SYNAPTICS: - if (hid->group == HID_GROUP_GENERIC) + if (hid->group == HID_GROUP_GENERIC || + hid->group == HID_GROUP_MULTITOUCH_WIN_8) if ((parser->scan_flags & HID_SCAN_FLAG_VENDOR_SPECIFIC) && (parser->scan_flags & HID_SCAN_FLAG_GD_POINTER)) /* * hid-rmi should take care of them, * not hid-generic */ - hid->group = HID_GROUP_RMI; + if (IS_ENABLED(CONFIG_HID_RMI)) + hid->group = HID_GROUP_RMI; break; } @@ -1887,6 +1882,9 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011) }, #if IS_ENABLED(CONFIG_HID_MAYFLASH) { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3) }, + { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_DOLPHINBAR) }, + { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE1) }, + { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE2) }, #endif { HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, USB_DEVICE_ID_DREAM_CHEEKY_WN) }, { HID_USB_DEVICE(USB_VENDOR_ID_DREAM_CHEEKY, USB_DEVICE_ID_DREAM_CHEEKY_FA) }, @@ -1933,6 +1931,7 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) }, { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) }, #endif + { HID_USB_DEVICE(USB_VENDOR_ID_LG, USB_DEVICE_ID_LG_MELFAS_MT) }, { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER) }, { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER) }, { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2) }, @@ -1985,12 +1984,6 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K) }, { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0) }, { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_OFFICE_KB) }, - { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3) }, - { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2) }, - { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP) }, - { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4) }, - { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_2) }, - { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_JP) }, { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_7K) }, { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_600) }, { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3KV1) }, @@ -2126,6 +2119,7 @@ static const struct hid_device_id hid_have_special_driver[] = { { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO, USB_DEVICE_ID_NINTENDO_WIIMOTE2) }, { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14) }, { HID_USB_DEVICE(USB_VENDOR_ID_CMEDIA, USB_DEVICE_ID_CM6533) }, + { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) }, { } }; @@ -2314,7 +2308,7 @@ __ATTRIBUTE_GROUPS(hid_dev); static int hid_uevent(struct device *dev, struct kobj_uevent_env *env) { - struct hid_device *hdev = to_hid_device(dev); + struct hid_device *hdev = to_hid_device(dev); if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X", hdev->bus, hdev->vendor, hdev->product)) @@ -2867,5 +2861,5 @@ module_exit(hid_exit); MODULE_AUTHOR("Andreas Gal"); MODULE_AUTHOR("Vojtech Pavlik"); MODULE_AUTHOR("Jiri Kosina"); -MODULE_LICENSE(DRIVER_LICENSE); +MODULE_LICENSE("GPL"); diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h index 350accfee8e8..86c95d30ac80 100644 --- a/drivers/hid/hid-ids.h +++ b/drivers/hid/hid-ids.h @@ -323,7 +323,8 @@ #define USB_DEVICE_ID_DRAGONRISE_WIIU 0x1800 #define USB_DEVICE_ID_DRAGONRISE_PS3 0x1801 #define USB_DEVICE_ID_DRAGONRISE_DOLPHINBAR 0x1803 -#define USB_DEVICE_ID_DRAGONRISE_GAMECUBE 0x1843 +#define USB_DEVICE_ID_DRAGONRISE_GAMECUBE1 0x1843 +#define USB_DEVICE_ID_DRAGONRISE_GAMECUBE2 0x1844 #define USB_VENDOR_ID_DWAV 0x0eef #define USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER 0x0001 @@ -630,9 +631,11 @@ #define USB_DEVICE_ID_LENOVO_CUSBKBD 0x6047 #define USB_DEVICE_ID_LENOVO_CBTKBD 0x6048 #define USB_DEVICE_ID_LENOVO_TPPRODOCK 0x6067 +#define USB_DEVICE_ID_LENOVO_X1_COVER 0x6085 #define USB_VENDOR_ID_LG 0x1fd2 #define USB_DEVICE_ID_LG_MULTITOUCH 0x0064 +#define USB_DEVICE_ID_LG_MELFAS_MT 0x6007 #define USB_VENDOR_ID_LOGITECH 0x046d #define USB_DEVICE_ID_LOGITECH_AUDIOHUB 0x0a0e @@ -725,12 +728,6 @@ #define USB_DEVICE_ID_MS_SURFACE_PRO_2 0x0799 #define USB_DEVICE_ID_MS_TOUCH_COVER_2 0x07a7 #define USB_DEVICE_ID_MS_TYPE_COVER_2 0x07a9 -#define USB_DEVICE_ID_MS_TYPE_COVER_PRO_3 0x07dc -#define USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2 0x07e2 -#define USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP 0x07dd -#define USB_DEVICE_ID_MS_TYPE_COVER_PRO_4 0x07e4 -#define USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_2 0x07e8 -#define USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_JP 0x07e9 #define USB_DEVICE_ID_MS_POWER_COVER 0x07da #define USB_VENDOR_ID_MOJO 0x8282 diff --git a/drivers/hid/hid-mf.c b/drivers/hid/hid-mf.c index d9090765a6e5..03f10516131d 100644 --- a/drivers/hid/hid-mf.c +++ b/drivers/hid/hid-mf.c @@ -6,12 +6,14 @@ * * Tested with: * 0079:1801 "DragonRise Inc. Mayflash PS3 Game Controller Adapter" + * 0079:1803 "DragonRise Inc. Mayflash Wireless Sensor DolphinBar" + * 0079:1843 "DragonRise Inc. Mayflash GameCube Game Controller Adapter" + * 0079:1844 "DragonRise Inc. Mayflash GameCube Game Controller Adapter (v04)" * * The following adapters probably work too, but need to be tested: * 0079:1800 "DragonRise Inc. Mayflash WIIU Game Controller Adapter" - * 0079:1843 "DragonRise Inc. Mayflash GameCube Game Controller Adapter" * - * Copyright (c) 2016 Marcel Hasler <mahasler@gmail.com> + * Copyright (c) 2016-2017 Marcel Hasler <mahasler@gmail.com> */ /* @@ -125,8 +127,8 @@ static int mf_probe(struct hid_device *hid, const struct hid_device_id *id) dev_dbg(&hid->dev, "Mayflash HID hardware probe...\n"); - /* Split device into four inputs */ - hid->quirks |= HID_QUIRK_MULTI_INPUT; + /* Apply quirks as needed */ + hid->quirks |= id->driver_data; error = hid_parse(hid); if (error) { @@ -151,7 +153,14 @@ static int mf_probe(struct hid_device *hid, const struct hid_device_id *id) } static const struct hid_device_id mf_devices[] = { - { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3), }, + { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3), + .driver_data = HID_QUIRK_MULTI_INPUT }, + { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_DOLPHINBAR), + .driver_data = HID_QUIRK_MULTI_INPUT }, + { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE1), + .driver_data = HID_QUIRK_MULTI_INPUT }, + { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE2), + .driver_data = 0 }, /* No quirk required */ { } }; MODULE_DEVICE_TABLE(hid, mf_devices); diff --git a/drivers/hid/hid-microsoft.c b/drivers/hid/hid-microsoft.c index 74b7b84a0420..96e7d3231d2f 100644 --- a/drivers/hid/hid-microsoft.c +++ b/drivers/hid/hid-microsoft.c @@ -274,18 +274,6 @@ static const struct hid_device_id ms_devices[] = { .driver_data = MS_NOGET }, { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500), .driver_data = MS_DUPLICATE_USAGES }, - { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3), - .driver_data = MS_HIDINPUT }, - { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2), - .driver_data = MS_HIDINPUT }, - { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP), - .driver_data = MS_HIDINPUT }, - { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4), - .driver_data = MS_HIDINPUT }, - { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_2), - .driver_data = MS_HIDINPUT }, - { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_JP), - .driver_data = MS_HIDINPUT }, { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER), .driver_data = MS_HIDINPUT }, { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_KEYBOARD), diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c index 6dca66806844..692647485a53 100644 --- a/drivers/hid/hid-multitouch.c +++ b/drivers/hid/hid-multitouch.c @@ -68,6 +68,7 @@ MODULE_LICENSE("GPL"); #define MT_QUIRK_HOVERING (1 << 11) #define MT_QUIRK_CONTACT_CNT_ACCURATE (1 << 12) #define MT_QUIRK_FORCE_GET_FEATURE (1 << 13) +#define MT_QUIRK_FIX_CONST_CONTACT_ID (1 << 14) #define MT_INPUTMODE_TOUCHSCREEN 0x02 #define MT_INPUTMODE_TOUCHPAD 0x03 @@ -157,6 +158,7 @@ static void mt_post_parse(struct mt_device *td); #define MT_CLS_FLATFROG 0x0107 #define MT_CLS_GENERALTOUCH_TWOFINGERS 0x0108 #define MT_CLS_GENERALTOUCH_PWT_TENFINGERS 0x0109 +#define MT_CLS_LG 0x010a #define MT_CLS_VTL 0x0110 #define MT_DEFAULT_MAXCONTACT 10 @@ -263,6 +265,12 @@ static struct mt_class mt_classes[] = { .sn_move = 2048, .maxcontacts = 40, }, + { .name = MT_CLS_LG, + .quirks = MT_QUIRK_ALWAYS_VALID | + MT_QUIRK_FIX_CONST_CONTACT_ID | + MT_QUIRK_IGNORE_DUPLICATES | + MT_QUIRK_HOVERING | + MT_QUIRK_CONTACT_CNT_ACCURATE }, { .name = MT_CLS_VTL, .quirks = MT_QUIRK_ALWAYS_VALID | MT_QUIRK_CONTACT_CNT_ACCURATE | @@ -1078,6 +1086,34 @@ static int mt_input_configured(struct hid_device *hdev, struct hid_input *hi) return 0; } +static void mt_fix_const_field(struct hid_field *field, unsigned int usage) +{ + if (field->usage[0].hid != usage || + !(field->flags & HID_MAIN_ITEM_CONSTANT)) + return; + + field->flags &= ~HID_MAIN_ITEM_CONSTANT; + field->flags |= HID_MAIN_ITEM_VARIABLE; +} + +static void mt_fix_const_fields(struct hid_device *hdev, unsigned int usage) +{ + struct hid_report *report; + int i; + + list_for_each_entry(report, + &hdev->report_enum[HID_INPUT_REPORT].report_list, + list) { + + if (!report->maxfield) + continue; + + for (i = 0; i < report->maxfield; i++) + if (report->field[i]->maxusage >= 1) + mt_fix_const_field(report->field[i], usage); + } +} + static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret, i; @@ -1151,6 +1187,9 @@ static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id) if (ret != 0) return ret; + if (mtclass->quirks & MT_QUIRK_FIX_CONST_CONTACT_ID) + mt_fix_const_fields(hdev, HID_DG_CONTACTID); + ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (ret) return ret; @@ -1398,6 +1437,11 @@ static const struct hid_device_id mt_devices[] = { MT_USB_DEVICE(USB_VENDOR_ID_ILITEK, USB_DEVICE_ID_ILITEK_MULTITOUCH) }, + /* LG Melfas panel */ + { .driver_data = MT_CLS_LG, + HID_USB_DEVICE(USB_VENDOR_ID_LG, + USB_DEVICE_ID_LG_MELFAS_MT) }, + /* MosArt panels */ { .driver_data = MT_CLS_CONFIDENCE_MINUS_ONE, MT_USB_DEVICE(USB_VENDOR_ID_ASUS, diff --git a/drivers/hid/hid-picolcd_cir.c b/drivers/hid/hid-picolcd_cir.c index 96286510f42e..8ffbb6f65a65 100644 --- a/drivers/hid/hid-picolcd_cir.c +++ b/drivers/hid/hid-picolcd_cir.c @@ -108,13 +108,12 @@ int picolcd_init_cir(struct picolcd_data *data, struct hid_report *report) struct rc_dev *rdev; int ret = 0; - rdev = rc_allocate_device(); + rdev = rc_allocate_device(RC_DRIVER_IR_RAW); if (!rdev) return -ENOMEM; rdev->priv = data; - rdev->driver_type = RC_DRIVER_IR_RAW; - rdev->allowed_protocols = RC_BIT_ALL; + rdev->allowed_protocols = RC_BIT_ALL_IR_DECODER; rdev->open = picolcd_cir_open; rdev->close = picolcd_cir_close; rdev->input_name = data->hdev->name; diff --git a/drivers/hid/hid-rmi.c b/drivers/hid/hid-rmi.c index be89bcbf6a71..5b40c2614599 100644 --- a/drivers/hid/hid-rmi.c +++ b/drivers/hid/hid-rmi.c @@ -14,11 +14,14 @@ #include <linux/hid.h> #include <linux/input.h> #include <linux/input/mt.h> +#include <linux/irq.h> +#include <linux/irqdomain.h> #include <linux/module.h> #include <linux/pm.h> #include <linux/slab.h> #include <linux/wait.h> #include <linux/sched.h> +#include <linux/rmi.h> #include "hid-ids.h" #define RMI_MOUSE_REPORT_ID 0x01 /* Mouse emulation Report */ @@ -33,9 +36,6 @@ #define RMI_READ_DATA_PENDING 1 #define RMI_STARTED 2 -#define RMI_SLEEP_NORMAL 0x0 -#define RMI_SLEEP_DEEP_SLEEP 0x1 - /* device flags */ #define RMI_DEVICE BIT(0) #define RMI_DEVICE_HAS_PHYS_BUTTONS BIT(1) @@ -54,25 +54,12 @@ enum rmi_mode_type { RMI_MODE_NO_PACKED_ATTN_REPORTS = 2, }; -struct rmi_function { - unsigned page; /* page of the function */ - u16 query_base_addr; /* base address for queries */ - u16 command_base_addr; /* base address for commands */ - u16 control_base_addr; /* base address for controls */ - u16 data_base_addr; /* base address for datas */ - unsigned int interrupt_base; /* cross-function interrupt number - * (uniq in the device)*/ - unsigned int interrupt_count; /* number of interrupts */ - unsigned int report_size; /* size of a report */ - unsigned long irq_mask; /* mask of the interrupts - * (to be applied against ATTN IRQ) */ -}; - /** * struct rmi_data - stores information for hid communication * * @page_mutex: Locks current page to avoid changing pages in unexpected ways. * @page: Keeps track of the current virtual page + * @xport: transport device to be registered with the RMI4 core. * * @wait: Used for waiting for read data * @@ -84,26 +71,18 @@ struct rmi_function { * * @flags: flags for the current device (started, reading, etc...) * - * @f11: placeholder of internal RMI function F11 description - * @f30: placeholder of internal RMI function F30 description - * - * @max_fingers: maximum finger count reported by the device - * @max_x: maximum x value reported by the device - * @max_y: maximum y value reported by the device - * - * @gpio_led_count: count of GPIOs + LEDs reported by F30 - * @button_count: actual physical buttons count - * @button_mask: button mask used to decode GPIO ATTN reports - * @button_state_mask: pull state of the buttons - * - * @input: pointer to the kernel input device - * * @reset_work: worker which will be called in case of a mouse report * @hdev: pointer to the struct hid_device + * + * @device_flags: flags which describe the device + * + * @domain: the IRQ domain allocated for this RMI4 device + * @rmi_irq: the irq that will be used to generate events to rmi-core */ struct rmi_data { struct mutex page_mutex; int page; + struct rmi_transport_dev xport; wait_queue_head_t wait; @@ -115,34 +94,13 @@ struct rmi_data { unsigned long flags; - struct rmi_function f01; - struct rmi_function f11; - struct rmi_function f30; - - unsigned int max_fingers; - unsigned int max_x; - unsigned int max_y; - unsigned int x_size_mm; - unsigned int y_size_mm; - bool read_f11_ctrl_regs; - u8 f11_ctrl_regs[RMI_F11_CTRL_REG_COUNT]; - - unsigned int gpio_led_count; - unsigned int button_count; - unsigned long button_mask; - unsigned long button_state_mask; - - struct input_dev *input; - struct work_struct reset_work; struct hid_device *hdev; unsigned long device_flags; - unsigned long firmware_id; - u8 f01_ctrl0; - u8 interrupt_enable_mask; - bool restore_interrupt_mask; + struct irq_domain *domain; + int rmi_irq; }; #define RMI_PAGE(addr) (((addr) >> 8) & 0xff) @@ -220,10 +178,11 @@ static int rmi_write_report(struct hid_device *hdev, u8 *report, int len) return ret; } -static int rmi_read_block(struct hid_device *hdev, u16 addr, void *buf, - const int len) +static int rmi_hid_read_block(struct rmi_transport_dev *xport, u16 addr, + void *buf, size_t len) { - struct rmi_data *data = hid_get_drvdata(hdev); + struct rmi_data *data = container_of(xport, struct rmi_data, xport); + struct hid_device *hdev = data->hdev; int ret; int bytes_read; int bytes_needed; @@ -292,15 +251,11 @@ exit: return ret; } -static inline int rmi_read(struct hid_device *hdev, u16 addr, void *buf) -{ - return rmi_read_block(hdev, addr, buf, 1); -} - -static int rmi_write_block(struct hid_device *hdev, u16 addr, void *buf, - const int len) +static int rmi_hid_write_block(struct rmi_transport_dev *xport, u16 addr, + const void *buf, size_t len) { - struct rmi_data *data = hid_get_drvdata(hdev); + struct rmi_data *data = container_of(xport, struct rmi_data, xport); + struct hid_device *hdev = data->hdev; int ret; mutex_lock(&data->page_mutex); @@ -332,62 +287,20 @@ exit: return ret; } -static inline int rmi_write(struct hid_device *hdev, u16 addr, void *buf) -{ - return rmi_write_block(hdev, addr, buf, 1); -} - -static void rmi_f11_process_touch(struct rmi_data *hdata, int slot, - u8 finger_state, u8 *touch_data) -{ - int x, y, wx, wy; - int wide, major, minor; - int z; - - input_mt_slot(hdata->input, slot); - input_mt_report_slot_state(hdata->input, MT_TOOL_FINGER, - finger_state == 0x01); - if (finger_state == 0x01) { - x = (touch_data[0] << 4) | (touch_data[2] & 0x0F); - y = (touch_data[1] << 4) | (touch_data[2] >> 4); - wx = touch_data[3] & 0x0F; - wy = touch_data[3] >> 4; - wide = (wx > wy); - major = max(wx, wy); - minor = min(wx, wy); - z = touch_data[4]; - - /* y is inverted */ - y = hdata->max_y - y; - - input_event(hdata->input, EV_ABS, ABS_MT_POSITION_X, x); - input_event(hdata->input, EV_ABS, ABS_MT_POSITION_Y, y); - input_event(hdata->input, EV_ABS, ABS_MT_ORIENTATION, wide); - input_event(hdata->input, EV_ABS, ABS_MT_PRESSURE, z); - input_event(hdata->input, EV_ABS, ABS_MT_TOUCH_MAJOR, major); - input_event(hdata->input, EV_ABS, ABS_MT_TOUCH_MINOR, minor); - } -} - static int rmi_reset_attn_mode(struct hid_device *hdev) { struct rmi_data *data = hid_get_drvdata(hdev); + struct rmi_device *rmi_dev = data->xport.rmi_dev; int ret; ret = rmi_set_mode(hdev, RMI_MODE_ATTN_REPORTS); if (ret) return ret; - if (data->restore_interrupt_mask) { - ret = rmi_write(hdev, data->f01.control_base_addr + 1, - &data->interrupt_enable_mask); - if (ret) { - hid_err(hdev, "can not write F01 control register\n"); - return ret; - } - } + if (test_bit(RMI_STARTED, &data->flags)) + ret = rmi_dev->driver->reset_handler(rmi_dev); - return 0; + return ret; } static void rmi_reset_work(struct work_struct *work) @@ -399,102 +312,22 @@ static void rmi_reset_work(struct work_struct *work) rmi_reset_attn_mode(hdata->hdev); } -static inline int rmi_schedule_reset(struct hid_device *hdev) -{ - struct rmi_data *hdata = hid_get_drvdata(hdev); - return schedule_work(&hdata->reset_work); -} - -static int rmi_f11_input_event(struct hid_device *hdev, u8 irq, u8 *data, - int size) -{ - struct rmi_data *hdata = hid_get_drvdata(hdev); - int offset; - int i; - - if (!(irq & hdata->f11.irq_mask) || size <= 0) - return 0; - - offset = (hdata->max_fingers >> 2) + 1; - for (i = 0; i < hdata->max_fingers; i++) { - int fs_byte_position = i >> 2; - int fs_bit_position = (i & 0x3) << 1; - int finger_state = (data[fs_byte_position] >> fs_bit_position) & - 0x03; - int position = offset + 5 * i; - - if (position + 5 > size) { - /* partial report, go on with what we received */ - printk_once(KERN_WARNING - "%s %s: Detected incomplete finger report. Finger reports may occasionally get dropped on this platform.\n", - dev_driver_string(&hdev->dev), - dev_name(&hdev->dev)); - hid_dbg(hdev, "Incomplete finger report\n"); - break; - } - - rmi_f11_process_touch(hdata, i, finger_state, &data[position]); - } - input_mt_sync_frame(hdata->input); - input_sync(hdata->input); - return hdata->f11.report_size; -} - -static int rmi_f30_input_event(struct hid_device *hdev, u8 irq, u8 *data, - int size) +static int rmi_input_event(struct hid_device *hdev, u8 *data, int size) { struct rmi_data *hdata = hid_get_drvdata(hdev); - int i; - int button = 0; - bool value; + struct rmi_device *rmi_dev = hdata->xport.rmi_dev; + unsigned long flags; - if (!(irq & hdata->f30.irq_mask)) + if (!(test_bit(RMI_STARTED, &hdata->flags))) return 0; - if (size < (int)hdata->f30.report_size) { - hid_warn(hdev, "Click Button pressed, but the click data is missing\n"); - return 0; - } + local_irq_save(flags); - for (i = 0; i < hdata->gpio_led_count; i++) { - if (test_bit(i, &hdata->button_mask)) { - value = (data[i / 8] >> (i & 0x07)) & BIT(0); - if (test_bit(i, &hdata->button_state_mask)) - value = !value; - input_event(hdata->input, EV_KEY, BTN_LEFT + button++, - value); - } - } - return hdata->f30.report_size; -} - -static int rmi_input_event(struct hid_device *hdev, u8 *data, int size) -{ - struct rmi_data *hdata = hid_get_drvdata(hdev); - unsigned long irq_mask = 0; - unsigned index = 2; + rmi_set_attn_data(rmi_dev, data[1], &data[2], size - 2); - if (!(test_bit(RMI_STARTED, &hdata->flags))) - return 0; + generic_handle_irq(hdata->rmi_irq); - irq_mask |= hdata->f11.irq_mask; - irq_mask |= hdata->f30.irq_mask; - - if (data[1] & ~irq_mask) - hid_dbg(hdev, "unknown intr source:%02lx %s:%d\n", - data[1] & ~irq_mask, __FILE__, __LINE__); - - if (hdata->f11.interrupt_base < hdata->f30.interrupt_base) { - index += rmi_f11_input_event(hdev, data[1], &data[index], - size - index); - index += rmi_f30_input_event(hdev, data[1], &data[index], - size - index); - } else { - index += rmi_f30_input_event(hdev, data[1], &data[index], - size - index); - index += rmi_f11_input_event(hdev, data[1], &data[index], - size - index); - } + local_irq_restore(flags); return 1; } @@ -568,7 +401,7 @@ static int rmi_event(struct hid_device *hdev, struct hid_field *field, return 1; } - rmi_schedule_reset(hdev); + schedule_work(&data->reset_work); return 1; } @@ -576,637 +409,71 @@ static int rmi_event(struct hid_device *hdev, struct hid_field *field, } #ifdef CONFIG_PM -static int rmi_set_sleep_mode(struct hid_device *hdev, int sleep_mode) -{ - struct rmi_data *data = hid_get_drvdata(hdev); - int ret; - u8 f01_ctrl0; - - f01_ctrl0 = (data->f01_ctrl0 & ~0x3) | sleep_mode; - - ret = rmi_write(hdev, data->f01.control_base_addr, - &f01_ctrl0); - if (ret) { - hid_err(hdev, "can not write sleep mode\n"); - return ret; - } - - return 0; -} - static int rmi_suspend(struct hid_device *hdev, pm_message_t message) { struct rmi_data *data = hid_get_drvdata(hdev); - int ret; - u8 buf[RMI_F11_CTRL_REG_COUNT]; - - if (!(data->device_flags & RMI_DEVICE)) - return 0; - - ret = rmi_read_block(hdev, data->f11.control_base_addr, buf, - RMI_F11_CTRL_REG_COUNT); - if (ret) - hid_warn(hdev, "can not read F11 control registers\n"); - else - memcpy(data->f11_ctrl_regs, buf, RMI_F11_CTRL_REG_COUNT); - - - if (!device_may_wakeup(hdev->dev.parent)) - return rmi_set_sleep_mode(hdev, RMI_SLEEP_DEEP_SLEEP); - - return 0; -} - -static int rmi_post_reset(struct hid_device *hdev) -{ - struct rmi_data *data = hid_get_drvdata(hdev); + struct rmi_device *rmi_dev = data->xport.rmi_dev; int ret; if (!(data->device_flags & RMI_DEVICE)) return 0; - ret = rmi_reset_attn_mode(hdev); + ret = rmi_driver_suspend(rmi_dev, false); if (ret) { - hid_err(hdev, "can not set rmi mode\n"); + hid_warn(hdev, "Failed to suspend device: %d\n", ret); return ret; } - if (data->read_f11_ctrl_regs) { - ret = rmi_write_block(hdev, data->f11.control_base_addr, - data->f11_ctrl_regs, RMI_F11_CTRL_REG_COUNT); - if (ret) - hid_warn(hdev, - "can not write F11 control registers after reset\n"); - } - - if (!device_may_wakeup(hdev->dev.parent)) { - ret = rmi_set_sleep_mode(hdev, RMI_SLEEP_NORMAL); - if (ret) { - hid_err(hdev, "can not write sleep mode\n"); - return ret; - } - } - - return ret; + return 0; } static int rmi_post_resume(struct hid_device *hdev) { struct rmi_data *data = hid_get_drvdata(hdev); + struct rmi_device *rmi_dev = data->xport.rmi_dev; + int ret; if (!(data->device_flags & RMI_DEVICE)) return 0; - return rmi_reset_attn_mode(hdev); -} -#endif /* CONFIG_PM */ - -#define RMI4_MAX_PAGE 0xff -#define RMI4_PAGE_SIZE 0x0100 - -#define PDT_START_SCAN_LOCATION 0x00e9 -#define PDT_END_SCAN_LOCATION 0x0005 -#define RMI4_END_OF_PDT(id) ((id) == 0x00 || (id) == 0xff) - -struct pdt_entry { - u8 query_base_addr:8; - u8 command_base_addr:8; - u8 control_base_addr:8; - u8 data_base_addr:8; - u8 interrupt_source_count:3; - u8 bits3and4:2; - u8 function_version:2; - u8 bit7:1; - u8 function_number:8; -} __attribute__((__packed__)); - -static inline unsigned long rmi_gen_mask(unsigned irq_base, unsigned irq_count) -{ - return GENMASK(irq_count + irq_base - 1, irq_base); -} - -static void rmi_register_function(struct rmi_data *data, - struct pdt_entry *pdt_entry, int page, unsigned interrupt_count) -{ - struct rmi_function *f = NULL; - u16 page_base = page << 8; - - switch (pdt_entry->function_number) { - case 0x01: - f = &data->f01; - break; - case 0x11: - f = &data->f11; - break; - case 0x30: - f = &data->f30; - break; - } - - if (f) { - f->page = page; - f->query_base_addr = page_base | pdt_entry->query_base_addr; - f->command_base_addr = page_base | pdt_entry->command_base_addr; - f->control_base_addr = page_base | pdt_entry->control_base_addr; - f->data_base_addr = page_base | pdt_entry->data_base_addr; - f->interrupt_base = interrupt_count; - f->interrupt_count = pdt_entry->interrupt_source_count; - f->irq_mask = rmi_gen_mask(f->interrupt_base, - f->interrupt_count); - data->interrupt_enable_mask |= f->irq_mask; - } -} - -static int rmi_scan_pdt(struct hid_device *hdev) -{ - struct rmi_data *data = hid_get_drvdata(hdev); - struct pdt_entry entry; - int page; - bool page_has_function; - int i; - int retval; - int interrupt = 0; - u16 page_start, pdt_start , pdt_end; - - hid_info(hdev, "Scanning PDT...\n"); - - for (page = 0; (page <= RMI4_MAX_PAGE); page++) { - page_start = RMI4_PAGE_SIZE * page; - pdt_start = page_start + PDT_START_SCAN_LOCATION; - pdt_end = page_start + PDT_END_SCAN_LOCATION; - - page_has_function = false; - for (i = pdt_start; i >= pdt_end; i -= sizeof(entry)) { - retval = rmi_read_block(hdev, i, &entry, sizeof(entry)); - if (retval) { - hid_err(hdev, - "Read of PDT entry at %#06x failed.\n", - i); - goto error_exit; - } - - if (RMI4_END_OF_PDT(entry.function_number)) - break; - - page_has_function = true; - - hid_info(hdev, "Found F%02X on page %#04x\n", - entry.function_number, page); - - rmi_register_function(data, &entry, page, interrupt); - interrupt += entry.interrupt_source_count; - } - - if (!page_has_function) - break; - } - - hid_info(hdev, "%s: Done with PDT scan.\n", __func__); - retval = 0; - -error_exit: - return retval; -} - -#define RMI_DEVICE_F01_BASIC_QUERY_LEN 11 - -static int rmi_populate_f01(struct hid_device *hdev) -{ - struct rmi_data *data = hid_get_drvdata(hdev); - u8 basic_queries[RMI_DEVICE_F01_BASIC_QUERY_LEN]; - u8 info[3]; - int ret; - bool has_query42; - bool has_lts; - bool has_sensor_id; - bool has_ds4_queries = false; - bool has_build_id_query = false; - bool has_package_id_query = false; - u16 query_offset = data->f01.query_base_addr; - u16 prod_info_addr; - u8 ds4_query_len; - - ret = rmi_read_block(hdev, query_offset, basic_queries, - RMI_DEVICE_F01_BASIC_QUERY_LEN); - if (ret) { - hid_err(hdev, "Can not read basic queries from Function 0x1.\n"); - return ret; - } - - has_lts = !!(basic_queries[0] & BIT(2)); - has_sensor_id = !!(basic_queries[1] & BIT(3)); - has_query42 = !!(basic_queries[1] & BIT(7)); - - query_offset += 11; - prod_info_addr = query_offset + 6; - query_offset += 10; - - if (has_lts) - query_offset += 20; - - if (has_sensor_id) - query_offset++; - - if (has_query42) { - ret = rmi_read(hdev, query_offset, info); - if (ret) { - hid_err(hdev, "Can not read query42.\n"); - return ret; - } - has_ds4_queries = !!(info[0] & BIT(0)); - query_offset++; - } - - if (has_ds4_queries) { - ret = rmi_read(hdev, query_offset, &ds4_query_len); - if (ret) { - hid_err(hdev, "Can not read DS4 Query length.\n"); - return ret; - } - query_offset++; - - if (ds4_query_len > 0) { - ret = rmi_read(hdev, query_offset, info); - if (ret) { - hid_err(hdev, "Can not read DS4 query.\n"); - return ret; - } - - has_package_id_query = !!(info[0] & BIT(0)); - has_build_id_query = !!(info[0] & BIT(1)); - } - } - - if (has_package_id_query) - prod_info_addr++; - - if (has_build_id_query) { - ret = rmi_read_block(hdev, prod_info_addr, info, 3); - if (ret) { - hid_err(hdev, "Can not read product info.\n"); - return ret; - } - - data->firmware_id = info[1] << 8 | info[0]; - data->firmware_id += info[2] * 65536; - } - - ret = rmi_read_block(hdev, data->f01.control_base_addr, info, - 2); - - if (ret) { - hid_err(hdev, "can not read f01 ctrl registers\n"); - return ret; - } - - data->f01_ctrl0 = info[0]; - - if (!info[1]) { - /* - * Do to a firmware bug in some touchpads the F01 interrupt - * enable control register will be cleared on reset. - * This will stop the touchpad from reporting data, so - * if F01 CTRL1 is 0 then we need to explicitly enable - * interrupts for the functions we want data for. - */ - data->restore_interrupt_mask = true; - - ret = rmi_write(hdev, data->f01.control_base_addr + 1, - &data->interrupt_enable_mask); - if (ret) { - hid_err(hdev, "can not write to control reg 1: %d.\n", - ret); - return ret; - } - } - - return 0; -} - -static int rmi_populate_f11(struct hid_device *hdev) -{ - struct rmi_data *data = hid_get_drvdata(hdev); - u8 buf[20]; - int ret; - bool has_query9; - bool has_query10 = false; - bool has_query11; - bool has_query12; - bool has_query27; - bool has_query28; - bool has_query36 = false; - bool has_physical_props; - bool has_gestures; - bool has_rel; - bool has_data40 = false; - bool has_dribble = false; - bool has_palm_detect = false; - unsigned x_size, y_size; - u16 query_offset; - - if (!data->f11.query_base_addr) { - hid_err(hdev, "No 2D sensor found, giving up.\n"); - return -ENODEV; - } - - /* query 0 contains some useful information */ - ret = rmi_read(hdev, data->f11.query_base_addr, buf); - if (ret) { - hid_err(hdev, "can not get query 0: %d.\n", ret); - return ret; - } - has_query9 = !!(buf[0] & BIT(3)); - has_query11 = !!(buf[0] & BIT(4)); - has_query12 = !!(buf[0] & BIT(5)); - has_query27 = !!(buf[0] & BIT(6)); - has_query28 = !!(buf[0] & BIT(7)); - - /* query 1 to get the max number of fingers */ - ret = rmi_read(hdev, data->f11.query_base_addr + 1, buf); - if (ret) { - hid_err(hdev, "can not get NumberOfFingers: %d.\n", ret); - return ret; - } - data->max_fingers = (buf[0] & 0x07) + 1; - if (data->max_fingers > 5) - data->max_fingers = 10; - - data->f11.report_size = data->max_fingers * 5 + - DIV_ROUND_UP(data->max_fingers, 4); - - if (!(buf[0] & BIT(4))) { - hid_err(hdev, "No absolute events, giving up.\n"); - return -ENODEV; - } - - has_rel = !!(buf[0] & BIT(3)); - has_gestures = !!(buf[0] & BIT(5)); - - ret = rmi_read(hdev, data->f11.query_base_addr + 5, buf); - if (ret) { - hid_err(hdev, "can not get absolute data sources: %d.\n", ret); + ret = rmi_reset_attn_mode(hdev); + if (ret) return ret; - } - - has_dribble = !!(buf[0] & BIT(4)); - - /* - * At least 4 queries are guaranteed to be present in F11 - * +1 for query 5 which is present since absolute events are - * reported and +1 for query 12. - */ - query_offset = 6; - - if (has_rel) - ++query_offset; /* query 6 is present */ - - if (has_gestures) { - /* query 8 to find out if query 10 exists */ - ret = rmi_read(hdev, - data->f11.query_base_addr + query_offset + 1, buf); - if (ret) { - hid_err(hdev, "can not read gesture information: %d.\n", - ret); - return ret; - } - has_palm_detect = !!(buf[0] & BIT(0)); - has_query10 = !!(buf[0] & BIT(2)); - - query_offset += 2; /* query 7 and 8 are present */ - } - - if (has_query9) - ++query_offset; - - if (has_query10) - ++query_offset; - - if (has_query11) - ++query_offset; - - /* query 12 to know if the physical properties are reported */ - if (has_query12) { - ret = rmi_read(hdev, data->f11.query_base_addr - + query_offset, buf); - if (ret) { - hid_err(hdev, "can not get query 12: %d.\n", ret); - return ret; - } - has_physical_props = !!(buf[0] & BIT(5)); - - if (has_physical_props) { - query_offset += 1; - ret = rmi_read_block(hdev, - data->f11.query_base_addr - + query_offset, buf, 4); - if (ret) { - hid_err(hdev, "can not read query 15-18: %d.\n", - ret); - return ret; - } - - x_size = buf[0] | (buf[1] << 8); - y_size = buf[2] | (buf[3] << 8); - - data->x_size_mm = DIV_ROUND_CLOSEST(x_size, 10); - data->y_size_mm = DIV_ROUND_CLOSEST(y_size, 10); - - hid_info(hdev, "%s: size in mm: %d x %d\n", - __func__, data->x_size_mm, data->y_size_mm); - - /* - * query 15 - 18 contain the size of the sensor - * and query 19 - 26 contain bezel dimensions - */ - query_offset += 12; - } - } - - if (has_query27) - ++query_offset; - if (has_query28) { - ret = rmi_read(hdev, data->f11.query_base_addr - + query_offset, buf); - if (ret) { - hid_err(hdev, "can not get query 28: %d.\n", ret); - return ret; - } - - has_query36 = !!(buf[0] & BIT(6)); - } - - if (has_query36) { - query_offset += 2; - ret = rmi_read(hdev, data->f11.query_base_addr - + query_offset, buf); - if (ret) { - hid_err(hdev, "can not get query 36: %d.\n", ret); - return ret; - } - - has_data40 = !!(buf[0] & BIT(5)); - } - - - if (has_data40) - data->f11.report_size += data->max_fingers * 2; - - ret = rmi_read_block(hdev, data->f11.control_base_addr, - data->f11_ctrl_regs, RMI_F11_CTRL_REG_COUNT); + ret = rmi_driver_resume(rmi_dev, false); if (ret) { - hid_err(hdev, "can not read ctrl block of size 11: %d.\n", ret); + hid_warn(hdev, "Failed to resume device: %d\n", ret); return ret; } - /* data->f11_ctrl_regs now contains valid register data */ - data->read_f11_ctrl_regs = true; - - data->max_x = data->f11_ctrl_regs[6] | (data->f11_ctrl_regs[7] << 8); - data->max_y = data->f11_ctrl_regs[8] | (data->f11_ctrl_regs[9] << 8); - - if (has_dribble) { - data->f11_ctrl_regs[0] = data->f11_ctrl_regs[0] & ~BIT(6); - ret = rmi_write(hdev, data->f11.control_base_addr, - data->f11_ctrl_regs); - if (ret) { - hid_err(hdev, "can not write to control reg 0: %d.\n", - ret); - return ret; - } - } - - if (has_palm_detect) { - data->f11_ctrl_regs[11] = data->f11_ctrl_regs[11] & ~BIT(0); - ret = rmi_write(hdev, data->f11.control_base_addr + 11, - &data->f11_ctrl_regs[11]); - if (ret) { - hid_err(hdev, "can not write to control reg 11: %d.\n", - ret); - return ret; - } - } - - return 0; -} - -static int rmi_populate_f30(struct hid_device *hdev) -{ - struct rmi_data *data = hid_get_drvdata(hdev); - u8 buf[20]; - int ret; - bool has_gpio, has_led; - unsigned bytes_per_ctrl; - u8 ctrl2_addr; - int ctrl2_3_length; - int i; - - /* function F30 is for physical buttons */ - if (!data->f30.query_base_addr) { - hid_err(hdev, "No GPIO/LEDs found, giving up.\n"); - return -ENODEV; - } - - ret = rmi_read_block(hdev, data->f30.query_base_addr, buf, 2); - if (ret) { - hid_err(hdev, "can not get F30 query registers: %d.\n", ret); - return ret; - } - - has_gpio = !!(buf[0] & BIT(3)); - has_led = !!(buf[0] & BIT(2)); - data->gpio_led_count = buf[1] & 0x1f; - - /* retrieve ctrl 2 & 3 registers */ - bytes_per_ctrl = (data->gpio_led_count + 7) / 8; - /* Ctrl0 is present only if both has_gpio and has_led are set*/ - ctrl2_addr = (has_gpio && has_led) ? bytes_per_ctrl : 0; - /* Ctrl1 is always be present */ - ctrl2_addr += bytes_per_ctrl; - ctrl2_3_length = 2 * bytes_per_ctrl; - - data->f30.report_size = bytes_per_ctrl; - - ret = rmi_read_block(hdev, data->f30.control_base_addr + ctrl2_addr, - buf, ctrl2_3_length); - if (ret) { - hid_err(hdev, "can not read ctrl 2&3 block of size %d: %d.\n", - ctrl2_3_length, ret); - return ret; - } - - for (i = 0; i < data->gpio_led_count; i++) { - int byte_position = i >> 3; - int bit_position = i & 0x07; - u8 dir_byte = buf[byte_position]; - u8 data_byte = buf[byte_position + bytes_per_ctrl]; - bool dir = (dir_byte >> bit_position) & BIT(0); - bool dat = (data_byte >> bit_position) & BIT(0); - - if (dir == 0) { - /* input mode */ - if (dat) { - /* actual buttons have pull up resistor */ - data->button_count++; - set_bit(i, &data->button_mask); - set_bit(i, &data->button_state_mask); - } - } - - } - return 0; } +#endif /* CONFIG_PM */ -static int rmi_populate(struct hid_device *hdev) +static int rmi_hid_reset(struct rmi_transport_dev *xport, u16 reset_addr) { - struct rmi_data *data = hid_get_drvdata(hdev); - int ret; - - ret = rmi_scan_pdt(hdev); - if (ret) { - hid_err(hdev, "PDT scan failed with code %d.\n", ret); - return ret; - } - - ret = rmi_populate_f01(hdev); - if (ret) { - hid_err(hdev, "Error while initializing F01 (%d).\n", ret); - return ret; - } - - ret = rmi_populate_f11(hdev); - if (ret) { - hid_err(hdev, "Error while initializing F11 (%d).\n", ret); - return ret; - } - - if (!(data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS)) { - ret = rmi_populate_f30(hdev); - if (ret) - hid_warn(hdev, "Error while initializing F30 (%d).\n", ret); - } + struct rmi_data *data = container_of(xport, struct rmi_data, xport); + struct hid_device *hdev = data->hdev; - return 0; + return rmi_reset_attn_mode(hdev); } static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi) { struct rmi_data *data = hid_get_drvdata(hdev); struct input_dev *input = hi->input; - int ret; - int res_x, res_y, i; + int ret = 0; + + if (!(data->device_flags & RMI_DEVICE)) + return 0; - data->input = input; + data->xport.input = input; hid_dbg(hdev, "Opening low level driver\n"); ret = hid_hw_open(hdev); if (ret) return ret; - if (!(data->device_flags & RMI_DEVICE)) - return 0; - /* Allow incoming hid reports */ hid_device_io_start(hdev); @@ -1222,40 +489,10 @@ static int rmi_input_configured(struct hid_device *hdev, struct hid_input *hi) goto exit; } - ret = rmi_populate(hdev); - if (ret) - goto exit; - - hid_info(hdev, "firmware id: %ld\n", data->firmware_id); - - __set_bit(EV_ABS, input->evbit); - input_set_abs_params(input, ABS_MT_POSITION_X, 1, data->max_x, 0, 0); - input_set_abs_params(input, ABS_MT_POSITION_Y, 1, data->max_y, 0, 0); - - if (data->x_size_mm && data->y_size_mm) { - res_x = (data->max_x - 1) / data->x_size_mm; - res_y = (data->max_y - 1) / data->y_size_mm; - - input_abs_set_res(input, ABS_MT_POSITION_X, res_x); - input_abs_set_res(input, ABS_MT_POSITION_Y, res_y); - } - - input_set_abs_params(input, ABS_MT_ORIENTATION, 0, 1, 0, 0); - input_set_abs_params(input, ABS_MT_PRESSURE, 0, 0xff, 0, 0); - input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 0x0f, 0, 0); - input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 0, 0x0f, 0, 0); - - ret = input_mt_init_slots(input, data->max_fingers, INPUT_MT_POINTER); - if (ret < 0) + ret = rmi_register_transport_device(&data->xport); + if (ret < 0) { + dev_err(&hdev->dev, "failed to register transport driver\n"); goto exit; - - if (data->button_count) { - __set_bit(EV_KEY, input->evbit); - for (i = 0; i < data->button_count; i++) - __set_bit(BTN_LEFT + i, input->keybit); - - if (data->button_count == 1) - __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); } set_bit(RMI_STARTED, &data->flags); @@ -1304,6 +541,71 @@ static int rmi_check_valid_report_id(struct hid_device *hdev, unsigned type, return 0; } +static struct rmi_device_platform_data rmi_hid_pdata = { + .sensor_pdata = { + .sensor_type = rmi_sensor_touchpad, + .axis_align.flip_y = true, + .dribble = RMI_REG_STATE_ON, + .palm_detect = RMI_REG_STATE_OFF, + }, +}; + +static const struct rmi_transport_ops hid_rmi_ops = { + .write_block = rmi_hid_write_block, + .read_block = rmi_hid_read_block, + .reset = rmi_hid_reset, +}; + +static void rmi_irq_teardown(void *data) +{ + struct rmi_data *hdata = data; + struct irq_domain *domain = hdata->domain; + + if (!domain) + return; + + irq_dispose_mapping(irq_find_mapping(domain, 0)); + + irq_domain_remove(domain); + hdata->domain = NULL; + hdata->rmi_irq = 0; +} + +static int rmi_irq_map(struct irq_domain *h, unsigned int virq, + irq_hw_number_t hw_irq_num) +{ + irq_set_chip_and_handler(virq, &dummy_irq_chip, handle_simple_irq); + + return 0; +} + +static const struct irq_domain_ops rmi_irq_ops = { + .map = rmi_irq_map, +}; + +static int rmi_setup_irq_domain(struct hid_device *hdev) +{ + struct rmi_data *hdata = hid_get_drvdata(hdev); + int ret; + + hdata->domain = irq_domain_create_linear(hdev->dev.fwnode, 1, + &rmi_irq_ops, hdata); + if (!hdata->domain) + return -ENOMEM; + + ret = devm_add_action_or_reset(&hdev->dev, &rmi_irq_teardown, hdata); + if (ret) + return ret; + + hdata->rmi_irq = irq_create_mapping(hdata->domain, 0); + if (hdata->rmi_irq <= 0) { + hid_err(hdev, "Can't allocate an IRQ\n"); + return hdata->rmi_irq < 0 ? hdata->rmi_irq : -ENXIO; + } + + return 0; +} + static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id) { struct rmi_data *data = NULL; @@ -1365,8 +667,8 @@ static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id) data->writeReport = devm_kzalloc(&hdev->dev, alloc_size, GFP_KERNEL); if (!data->writeReport) { - ret = -ENOMEM; - return ret; + hid_err(hdev, "failed to allocate buffer for HID reports\n"); + return -ENOMEM; } data->readReport = data->writeReport + data->output_report_size; @@ -1375,6 +677,21 @@ static int rmi_probe(struct hid_device *hdev, const struct hid_device_id *id) mutex_init(&data->page_mutex); + ret = rmi_setup_irq_domain(hdev); + if (ret) { + hid_err(hdev, "failed to allocate IRQ domain\n"); + return ret; + } + + if (data->device_flags & RMI_DEVICE_HAS_PHYS_BUTTONS) + rmi_hid_pdata.f30_data.disable = true; + + data->xport.dev = hdev->dev.parent; + data->xport.pdata = rmi_hid_pdata; + data->xport.pdata.irq = data->rmi_irq; + data->xport.proto_name = "hid"; + data->xport.ops = &hid_rmi_ops; + start: ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (ret) { @@ -1382,17 +699,6 @@ start: return ret; } - if ((data->device_flags & RMI_DEVICE) && - !test_bit(RMI_STARTED, &data->flags)) - /* - * The device maybe in the bootloader if rmi_input_configured - * failed to find F11 in the PDT. Print an error, but don't - * return an error from rmi_probe so that hidraw will be - * accessible from userspace. That way a userspace tool - * can be used to reload working firmware on the touchpad. - */ - hid_err(hdev, "Device failed to be properly configured\n"); - return 0; } @@ -1401,6 +707,8 @@ static void rmi_remove(struct hid_device *hdev) struct rmi_data *hdata = hid_get_drvdata(hdev); clear_bit(RMI_STARTED, &hdata->flags); + cancel_work_sync(&hdata->reset_work); + rmi_unregister_transport_device(&hdata->xport); hid_hw_stop(hdev); } @@ -1408,6 +716,7 @@ static void rmi_remove(struct hid_device *hdev) static const struct hid_device_id rmi_id[] = { { HID_USB_DEVICE(USB_VENDOR_ID_RAZER, USB_DEVICE_ID_RAZER_BLADE_14), .driver_data = RMI_DEVICE_HAS_PHYS_BUTTONS }, + { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_COVER) }, { HID_DEVICE(HID_BUS_ANY, HID_GROUP_RMI, HID_ANY_ID, HID_ANY_ID) }, { } }; @@ -1425,7 +734,7 @@ static struct hid_driver rmi_driver = { #ifdef CONFIG_PM .suspend = rmi_suspend, .resume = rmi_post_resume, - .reset_resume = rmi_post_reset, + .reset_resume = rmi_post_resume, #endif }; diff --git a/drivers/hid/intel-ish-hid/ipc/hw-ish-regs.h b/drivers/hid/intel-ish-hid/ipc/hw-ish-regs.h index ab68afcba2a2..a5897b9c0956 100644 --- a/drivers/hid/intel-ish-hid/ipc/hw-ish-regs.h +++ b/drivers/hid/intel-ish-hid/ipc/hw-ish-regs.h @@ -111,6 +111,14 @@ #define IPC_ILUP_BIT (1<<IPC_ILUP_OFFS) /* + * ISH FW status bits in ISH FW Status Register + */ +#define IPC_ISH_FWSTS_SHIFT 12 +#define IPC_ISH_FWSTS_MASK GENMASK(15, 12) +#define IPC_GET_ISH_FWSTS(status) \ + (((status) & IPC_ISH_FWSTS_MASK) >> IPC_ISH_FWSTS_SHIFT) + +/* * FW status bits (relevant) */ #define IPC_FWSTS_ILUP 0x1 diff --git a/drivers/hid/intel-ish-hid/ipc/hw-ish.h b/drivers/hid/intel-ish-hid/ipc/hw-ish.h index 46615a03e78f..fd34307a7a70 100644 --- a/drivers/hid/intel-ish-hid/ipc/hw-ish.h +++ b/drivers/hid/intel-ish-hid/ipc/hw-ish.h @@ -61,6 +61,18 @@ struct ish_hw { void __iomem *mem_addr; }; +/* + * ISH FW status type + */ +enum { + FWSTS_AFTER_RESET = 0, + FWSTS_WAIT_FOR_HOST = 4, + FWSTS_START_KERNEL_DMA = 5, + FWSTS_FW_IS_RUNNING = 7, + FWSTS_SENSOR_APP_LOADED = 8, + FWSTS_SENSOR_APP_RUNNING = 15 +}; + #define to_ish_hw(dev) (struct ish_hw *)((dev)->hw) irqreturn_t ish_irq_handler(int irq, void *dev_id); diff --git a/drivers/hid/intel-ish-hid/ipc/pci-ish.c b/drivers/hid/intel-ish-hid/ipc/pci-ish.c index 20d647d2dd2c..8df81dc84529 100644 --- a/drivers/hid/intel-ish-hid/ipc/pci-ish.c +++ b/drivers/hid/intel-ish-hid/ipc/pci-ish.c @@ -24,7 +24,6 @@ #include <linux/sched.h> #include <linux/interrupt.h> #include <linux/workqueue.h> -#include <linux/miscdevice.h> #define CREATE_TRACE_POINTS #include <trace/events/intel_ish.h> #include "ishtp-dev.h" @@ -47,7 +46,8 @@ MODULE_DEVICE_TABLE(pci, ish_pci_tbl); * * Callback to direct log messages to Linux trace buffers */ -static void ish_event_tracer(struct ishtp_device *dev, char *format, ...) +static __printf(2, 3) +void ish_event_tracer(struct ishtp_device *dev, const char *format, ...) { if (trace_ishtp_dump_enabled()) { va_list args; @@ -205,12 +205,15 @@ static void ish_remove(struct pci_dev *pdev) #ifdef CONFIG_PM static struct device *ish_resume_device; +/* 50ms to get resume response */ +#define WAIT_FOR_RESUME_ACK_MS 50 + /** * ish_resume_handler() - Work function to complete resume * @work: work struct * * The resume work function to complete resume function asynchronously. - * There are two types of platforms, one where ISH is not powered off, + * There are two resume paths, one where ISH is not powered off, * in that case a simple resume message is enough, others we need * a reset sequence. */ @@ -218,20 +221,31 @@ static void ish_resume_handler(struct work_struct *work) { struct pci_dev *pdev = to_pci_dev(ish_resume_device); struct ishtp_device *dev = pci_get_drvdata(pdev); + uint32_t fwsts; int ret; - ishtp_send_resume(dev); + /* Get ISH FW status */ + fwsts = IPC_GET_ISH_FWSTS(dev->ops->get_fw_status(dev)); - /* 50 ms to get resume response */ - if (dev->resume_flag) - ret = wait_event_interruptible_timeout(dev->resume_wait, - !dev->resume_flag, - msecs_to_jiffies(50)); + /* + * If currently, in ISH FW, sensor app is loaded or beyond that, + * it means ISH isn't powered off, in this case, send a resume message. + */ + if (fwsts >= FWSTS_SENSOR_APP_LOADED) { + ishtp_send_resume(dev); + + /* Waiting to get resume response */ + if (dev->resume_flag) + ret = wait_event_interruptible_timeout(dev->resume_wait, + !dev->resume_flag, + msecs_to_jiffies(WAIT_FOR_RESUME_ACK_MS)); + } /* - * If no resume response. This platform is not S0ix compatible - * So on resume full reboot of ISH processor will happen, so - * need to go through init sequence again + * If in ISH FW, sensor app isn't loaded yet, or no resume response. + * That means this platform is not S0ix compatible, or something is + * wrong with ISH FW. So on resume, full reboot of ISH processor will + * happen, so need to go through init sequence again. */ if (dev->resume_flag) ish_init(dev); diff --git a/drivers/hid/intel-ish-hid/ishtp-hid.c b/drivers/hid/intel-ish-hid/ishtp-hid.c index 277983aa1d90..cd23903ddcf1 100644 --- a/drivers/hid/intel-ish-hid/ishtp-hid.c +++ b/drivers/hid/intel-ish-hid/ishtp-hid.c @@ -208,7 +208,7 @@ int ishtp_hid_probe(unsigned int cur_hid_dev, hid->version = le16_to_cpu(ISH_HID_VERSION); hid->vendor = le16_to_cpu(ISH_HID_VENDOR); hid->product = le16_to_cpu(ISH_HID_PRODUCT); - snprintf(hid->name, sizeof(hid->name), "%s %04hX:%04hX", "hid-ishtp", + snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X", "hid-ishtp", hid->vendor, hid->product); rv = hid_add_device(hid); diff --git a/drivers/hid/intel-ish-hid/ishtp/bus.c b/drivers/hid/intel-ish-hid/ishtp/bus.c index f4cbc744e657..5f382fedc2ab 100644 --- a/drivers/hid/intel-ish-hid/ishtp/bus.c +++ b/drivers/hid/intel-ish-hid/ishtp/bus.c @@ -358,7 +358,7 @@ static void ishtp_cl_dev_release(struct device *dev) kfree(to_ishtp_cl_device(dev)); } -static struct device_type ishtp_cl_device_type = { +static const struct device_type ishtp_cl_device_type = { .release = ishtp_cl_dev_release, }; diff --git a/drivers/hid/intel-ish-hid/ishtp/hbm.c b/drivers/hid/intel-ish-hid/ishtp/hbm.c index 59460b66e689..b7213608ce43 100644 --- a/drivers/hid/intel-ish-hid/ishtp/hbm.c +++ b/drivers/hid/intel-ish-hid/ishtp/hbm.c @@ -19,7 +19,6 @@ #include <linux/sched.h> #include <linux/wait.h> #include <linux/spinlock.h> -#include <linux/miscdevice.h> #include "ishtp-dev.h" #include "hbm.h" #include "client.h" diff --git a/drivers/hid/intel-ish-hid/ishtp/init.c b/drivers/hid/intel-ish-hid/ishtp/init.c index ac364418e17c..d27e03526acd 100644 --- a/drivers/hid/intel-ish-hid/ishtp/init.c +++ b/drivers/hid/intel-ish-hid/ishtp/init.c @@ -16,7 +16,6 @@ #include <linux/export.h> #include <linux/slab.h> #include <linux/sched.h> -#include <linux/miscdevice.h> #include "ishtp-dev.h" #include "hbm.h" #include "client.h" diff --git a/drivers/hid/intel-ish-hid/ishtp/ishtp-dev.h b/drivers/hid/intel-ish-hid/ishtp/ishtp-dev.h index a94f9a8a96a0..6a6d927b78b0 100644 --- a/drivers/hid/intel-ish-hid/ishtp/ishtp-dev.h +++ b/drivers/hid/intel-ish-hid/ishtp/ishtp-dev.h @@ -238,7 +238,8 @@ struct ishtp_device { uint64_t ishtp_host_dma_rx_buf_phys; /* Dump to trace buffers if enabled*/ - void (*print_log)(struct ishtp_device *dev, char *format, ...); + __printf(2, 3) void (*print_log)(struct ishtp_device *dev, + const char *format, ...); /* Debug stats */ unsigned int ipc_rx_cnt; diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c index 333108ef18cf..961bc6fdd2d9 100644 --- a/drivers/hid/usbhid/hid-core.c +++ b/drivers/hid/usbhid/hid-core.c @@ -43,7 +43,6 @@ */ #define DRIVER_DESC "USB HID core driver" -#define DRIVER_LICENSE "GPL" /* * Module parameters. @@ -1660,4 +1659,4 @@ MODULE_AUTHOR("Andreas Gal"); MODULE_AUTHOR("Vojtech Pavlik"); MODULE_AUTHOR("Jiri Kosina"); MODULE_DESCRIPTION(DRIVER_DESC); -MODULE_LICENSE(DRIVER_LICENSE); +MODULE_LICENSE("GPL"); diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c index 30a2977e2645..d6847a664446 100644 --- a/drivers/hid/usbhid/hid-quirks.c +++ b/drivers/hid/usbhid/hid-quirks.c @@ -85,7 +85,7 @@ static const struct hid_blacklist { { USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_WIIU, HID_QUIRK_MULTI_INPUT }, { USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_PS3, HID_QUIRK_MULTI_INPUT }, { USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_DOLPHINBAR, HID_QUIRK_MULTI_INPUT }, - { USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE, HID_QUIRK_MULTI_INPUT }, + { USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_GAMECUBE1, HID_QUIRK_MULTI_INPUT }, { USB_VENDOR_ID_ELAN, HID_ANY_ID, HID_QUIRK_ALWAYS_POLL }, { USB_VENDOR_ID_ELO, USB_DEVICE_ID_ELO_TS2700, HID_QUIRK_NOGET }, { USB_VENDOR_ID_FORMOSA, USB_DEVICE_ID_FORMOSA_IR_RECEIVER, HID_QUIRK_NO_INIT_REPORTS }, @@ -103,12 +103,6 @@ static const struct hid_blacklist { { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_SURFACE_PRO_2, HID_QUIRK_NO_INIT_REPORTS }, { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_2, HID_QUIRK_NO_INIT_REPORTS }, { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TOUCH_COVER_2, HID_QUIRK_NO_INIT_REPORTS }, - { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3, HID_QUIRK_NO_INIT_REPORTS }, - { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2, HID_QUIRK_NO_INIT_REPORTS }, - { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP, HID_QUIRK_NO_INIT_REPORTS }, - { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4, HID_QUIRK_NO_INIT_REPORTS }, - { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_2, HID_QUIRK_NO_INIT_REPORTS }, - { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_4_JP, HID_QUIRK_NO_INIT_REPORTS }, { USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER, HID_QUIRK_NO_INIT_REPORTS }, { USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL, HID_QUIRK_NO_INIT_REPORTS }, { USB_VENDOR_ID_NEXIO, USB_DEVICE_ID_NEXIO_MULTITOUCH_PTI0750, HID_QUIRK_NO_INIT_REPORTS }, @@ -297,7 +291,7 @@ static void usbhid_remove_all_dquirks(void) } -/** +/** * usbhid_quirks_init: apply USB HID quirks specified at module load time */ int usbhid_quirks_init(char **quirks_param) @@ -361,7 +355,7 @@ static const struct hid_blacklist *usbhid_exists_squirk(const u16 idVendor, if (bl_entry != NULL) dbg_hid("Found squirk 0x%x for USB HID vendor 0x%hx prod 0x%hx\n", - bl_entry->quirks, bl_entry->idVendor, + bl_entry->quirks, bl_entry->idVendor, bl_entry->idProduct); return bl_entry; } diff --git a/drivers/hid/usbhid/usbkbd.c b/drivers/hid/usbhid/usbkbd.c index 9a332e683db7..7fb2d1e4f5dd 100644 --- a/drivers/hid/usbhid/usbkbd.c +++ b/drivers/hid/usbhid/usbkbd.c @@ -39,11 +39,10 @@ #define DRIVER_VERSION "" #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>" #define DRIVER_DESC "USB HID Boot Protocol keyboard driver" -#define DRIVER_LICENSE "GPL" MODULE_AUTHOR(DRIVER_AUTHOR); MODULE_DESCRIPTION(DRIVER_DESC); -MODULE_LICENSE(DRIVER_LICENSE); +MODULE_LICENSE("GPL"); static const unsigned char usb_kbd_keycode[256] = { 0, 0, 0, 0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38, diff --git a/drivers/hid/usbhid/usbmouse.c b/drivers/hid/usbhid/usbmouse.c index bf16d72dc370..dd911c5241d8 100644 --- a/drivers/hid/usbhid/usbmouse.c +++ b/drivers/hid/usbhid/usbmouse.c @@ -42,11 +42,10 @@ #define DRIVER_VERSION "v1.6" #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>" #define DRIVER_DESC "USB HID Boot Protocol mouse driver" -#define DRIVER_LICENSE "GPL" MODULE_AUTHOR(DRIVER_AUTHOR); MODULE_DESCRIPTION(DRIVER_DESC); -MODULE_LICENSE(DRIVER_LICENSE); +MODULE_LICENSE("GPL"); struct usb_mouse { char name[128]; diff --git a/drivers/hid/wacom.h b/drivers/hid/wacom.h index d303e413306d..38ee2125412f 100644 --- a/drivers/hid/wacom.h +++ b/drivers/hid/wacom.h @@ -102,7 +102,6 @@ #define DRIVER_VERSION "v2.00" #define DRIVER_AUTHOR "Vojtech Pavlik <vojtech@ucw.cz>" #define DRIVER_DESC "USB Wacom tablet driver" -#define DRIVER_LICENSE "GPL" #define USB_VENDOR_ID_WACOM 0x056a #define USB_VENDOR_ID_LENOVO 0x17ef @@ -166,7 +165,9 @@ struct wacom { struct work_struct wireless_work; struct work_struct battery_work; struct work_struct remote_work; + struct delayed_work init_work; struct wacom_remote *remote; + bool generic_has_leds; struct wacom_leds { struct wacom_group_leds *groups; unsigned int count; @@ -218,4 +219,6 @@ enum led_brightness wacom_leds_brightness_get(struct wacom_led *led); struct wacom_led *wacom_led_find(struct wacom *wacom, unsigned int group, unsigned int id); struct wacom_led *wacom_led_next(struct wacom *wacom, struct wacom_led *cur); +int wacom_equivalent_usage(int usage); +int wacom_initialize_leds(struct wacom *wacom); #endif diff --git a/drivers/hid/wacom_sys.c b/drivers/hid/wacom_sys.c index 8aeca038cc73..be8f7e2a026f 100644 --- a/drivers/hid/wacom_sys.c +++ b/drivers/hid/wacom_sys.c @@ -16,15 +16,7 @@ #include <linux/input/mt.h> #define WAC_MSG_RETRIES 5 - -#define WAC_CMD_WL_LED_CONTROL 0x03 -#define WAC_CMD_LED_CONTROL 0x20 -#define WAC_CMD_ICON_START 0x21 -#define WAC_CMD_ICON_XFER 0x23 -#define WAC_CMD_ICON_BT_XFER 0x26 #define WAC_CMD_RETRIES 10 -#define WAC_CMD_DELETE_PAIRING 0x20 -#define WAC_CMD_UNPAIR_ALL 0xFF #define DEV_ATTR_RW_PERM (S_IRUGO | S_IWUSR | S_IWGRP) #define DEV_ATTR_WO_PERM (S_IWUSR | S_IWGRP) @@ -120,11 +112,12 @@ static void wacom_feature_mapping(struct hid_device *hdev, struct wacom *wacom = hid_get_drvdata(hdev); struct wacom_features *features = &wacom->wacom_wac.features; struct hid_data *hid_data = &wacom->wacom_wac.hid_data; + unsigned int equivalent_usage = wacom_equivalent_usage(usage->hid); u8 *data; int ret; int n; - switch (usage->hid) { + switch (equivalent_usage) { case HID_DG_CONTACTMAX: /* leave touch_max as is if predefined */ if (!features->touch_max) { @@ -333,8 +326,14 @@ static void wacom_post_parse_hid(struct hid_device *hdev, if (features->type == HID_GENERIC) { /* Any last-minute generic device setup */ if (features->touch_max > 1) { - input_mt_init_slots(wacom_wac->touch_input, wacom_wac->features.touch_max, - INPUT_MT_DIRECT); + if (features->device_type & WACOM_DEVICETYPE_DIRECT) + input_mt_init_slots(wacom_wac->touch_input, + wacom_wac->features.touch_max, + INPUT_MT_DIRECT); + else + input_mt_init_slots(wacom_wac->touch_input, + wacom_wac->features.touch_max, + INPUT_MT_POINTER); } } } @@ -497,11 +496,11 @@ static int wacom_bt_query_tablet_data(struct hid_device *hdev, u8 speed, * from the tablet, it is necessary to switch the tablet out of this * mode and into one which sends the full range of tablet data. */ -static int wacom_query_tablet_data(struct hid_device *hdev, - struct wacom_features *features) +static int _wacom_query_tablet_data(struct wacom *wacom) { - struct wacom *wacom = hid_get_drvdata(hdev); + struct hid_device *hdev = wacom->hdev; struct wacom_wac *wacom_wac = &wacom->wacom_wac; + struct wacom_features *features = &wacom_wac->features; if (hdev->bus == BUS_BLUETOOTH) return wacom_bt_query_tablet_data(hdev, 1, features); @@ -757,9 +756,6 @@ static int wacom_led_control(struct wacom *wacom) unsigned char report_id = WAC_CMD_LED_CONTROL; int buf_size = 9; - if (!hid_get_drvdata(wacom->hdev)) - return -ENODEV; - if (!wacom->led.groups) return -ENOTSUPP; @@ -767,12 +763,21 @@ static int wacom_led_control(struct wacom *wacom) report_id = WAC_CMD_WL_LED_CONTROL; buf_size = 13; } + else if (wacom->wacom_wac.features.type == INTUOSP2_BT) { + report_id = WAC_CMD_WL_INTUOSP2; + buf_size = 51; + } buf = kzalloc(buf_size, GFP_KERNEL); if (!buf) return -ENOMEM; - if (wacom->wacom_wac.features.type >= INTUOS5S && - wacom->wacom_wac.features.type <= INTUOSPL) { + if (wacom->wacom_wac.features.type == HID_GENERIC) { + buf[0] = WAC_CMD_LED_CONTROL_GENERIC; + buf[1] = wacom->led.llv; + buf[2] = wacom->led.groups[0].select & 0x03; + + } else if ((wacom->wacom_wac.features.type >= INTUOS5S && + wacom->wacom_wac.features.type <= INTUOSPL)) { /* * Touch Ring and crop mark LED luminance may take on * one of four values: @@ -792,6 +797,16 @@ static int wacom_led_control(struct wacom *wacom) } else buf[1] = led_bits; } + else if (wacom->wacom_wac.features.type == INTUOSP2_BT) { + buf[0] = report_id; + buf[4] = 100; // Power Connection LED (ORANGE) + buf[5] = 100; // BT Connection LED (BLUE) + buf[6] = 100; // Paper Mode (RED?) + buf[7] = 100; // Paper Mode (GREEN?) + buf[8] = 100; // Paper Mode (BLUE?) + buf[9] = wacom->led.llv; + buf[10] = wacom->led.groups[0].select & 0x03; + } else { int led = wacom->led.groups[0].select | 0x4; @@ -1032,6 +1047,17 @@ static struct attribute_group intuos5_led_attr_group = { .attrs = intuos5_led_attrs, }; +static struct attribute *generic_led_attrs[] = { + &dev_attr_status0_luminance.attr, + &dev_attr_status_led0_select.attr, + NULL +}; + +static struct attribute_group generic_led_attr_group = { + .name = "wacom_led", + .attrs = generic_led_attrs, +}; + struct wacom_sysfs_group_devres { struct attribute_group *group; struct kobject *root; @@ -1353,7 +1379,7 @@ static int wacom_leds_alloc_and_register(struct wacom *wacom, int group_count, return 0; } -static int wacom_initialize_leds(struct wacom *wacom) +int wacom_initialize_leds(struct wacom *wacom) { int error; @@ -1362,6 +1388,23 @@ static int wacom_initialize_leds(struct wacom *wacom) /* Initialize default values */ switch (wacom->wacom_wac.features.type) { + case HID_GENERIC: + if (!wacom->generic_has_leds) + return 0; + wacom->led.llv = 100; + wacom->led.max_llv = 100; + + error = wacom_leds_alloc_and_register(wacom, 1, 4, false); + if (error) { + hid_err(wacom->hdev, + "cannot create leds err: %d\n", error); + return error; + } + + error = wacom_devm_sysfs_create_group(wacom, + &generic_led_attr_group); + break; + case INTUOS4S: case INTUOS4: case INTUOS4WL: @@ -1420,6 +1463,17 @@ static int wacom_initialize_leds(struct wacom *wacom) &intuos5_led_attr_group); break; + case INTUOSP2_BT: + wacom->led.llv = 50; + wacom->led.max_llv = 100; + error = wacom_leds_alloc_and_register(wacom, 1, 4, false); + if (error) { + hid_err(wacom->hdev, + "cannot create leds err: %d\n", error); + return error; + } + return 0; + case REMOTE: wacom->led.llv = 255; wacom->led.max_llv = 255; @@ -1440,11 +1494,23 @@ static int wacom_initialize_leds(struct wacom *wacom) "cannot create sysfs group err: %d\n", error); return error; } - wacom_led_control(wacom); return 0; } +static void wacom_init_work(struct work_struct *work) +{ + struct wacom *wacom = container_of(work, struct wacom, init_work.work); + + _wacom_query_tablet_data(wacom); + wacom_led_control(wacom); +} + +static void wacom_query_tablet_data(struct wacom *wacom) +{ + schedule_delayed_work(&wacom->init_work, msecs_to_jiffies(1000)); +} + static enum power_supply_property wacom_battery_props[] = { POWER_SUPPLY_PROP_MODEL_NAME, POWER_SUPPLY_PROP_PRESENT, @@ -2020,6 +2086,24 @@ static void wacom_release_resources(struct wacom *wacom) wacom->wacom_wac.pad_input = NULL; } +static void wacom_set_shared_values(struct wacom_wac *wacom_wac) +{ + if (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH) { + wacom_wac->shared->type = wacom_wac->features.type; + wacom_wac->shared->touch_input = wacom_wac->touch_input; + } + + if (wacom_wac->has_mute_touch_switch) + wacom_wac->shared->has_mute_touch_switch = true; + + if (wacom_wac->shared->has_mute_touch_switch && + wacom_wac->shared->touch_input) { + set_bit(EV_SW, wacom_wac->shared->touch_input->evbit); + input_set_capability(wacom_wac->shared->touch_input, EV_SW, + SW_MUTE_DEVICE); + } +} + static int wacom_parse_and_register(struct wacom *wacom, bool wireless) { struct wacom_wac *wacom_wac = &wacom->wacom_wac; @@ -2118,7 +2202,7 @@ static int wacom_parse_and_register(struct wacom *wacom, bool wireless) if (!wireless) { /* Note that if query fails it is not a hard failure */ - wacom_query_tablet_data(hdev, features); + wacom_query_tablet_data(wacom); } /* touch only Bamboo doesn't support pen */ @@ -2139,13 +2223,7 @@ static int wacom_parse_and_register(struct wacom *wacom, bool wireless) if (features->device_type & WACOM_DEVICETYPE_WL_MONITOR) error = hid_hw_open(hdev); - if ((wacom_wac->features.type == INTUOSHT || - wacom_wac->features.type == INTUOSHT2) && - (wacom_wac->features.device_type & WACOM_DEVICETYPE_TOUCH)) { - wacom_wac->shared->type = wacom_wac->features.type; - wacom_wac->shared->touch_input = wacom_wac->touch_input; - } - + wacom_set_shared_values(wacom_wac); devres_close_group(&hdev->dev, wacom); return 0; @@ -2450,6 +2528,7 @@ static int wacom_probe(struct hid_device *hdev, wacom->usbdev = dev; wacom->intf = intf; mutex_init(&wacom->lock); + INIT_DELAYED_WORK(&wacom->init_work, wacom_init_work); INIT_WORK(&wacom->wireless_work, wacom_wireless_work); INIT_WORK(&wacom->battery_work, wacom_battery_work); INIT_WORK(&wacom->remote_work, wacom_remote_work); @@ -2491,12 +2570,17 @@ static void wacom_remove(struct hid_device *hdev) hid_hw_stop(hdev); + cancel_delayed_work_sync(&wacom->init_work); cancel_work_sync(&wacom->wireless_work); cancel_work_sync(&wacom->battery_work); cancel_work_sync(&wacom->remote_work); if (hdev->bus == BUS_BLUETOOTH) device_remove_file(&hdev->dev, &dev_attr_speed); + /* make sure we don't trigger the LEDs */ + wacom_led_groups_release(wacom); + wacom_release_resources(wacom); + hid_set_drvdata(hdev, NULL); } @@ -2504,12 +2588,11 @@ static void wacom_remove(struct hid_device *hdev) static int wacom_resume(struct hid_device *hdev) { struct wacom *wacom = hid_get_drvdata(hdev); - struct wacom_features *features = &wacom->wacom_wac.features; mutex_lock(&wacom->lock); /* switch to wacom mode first */ - wacom_query_tablet_data(hdev, features); + _wacom_query_tablet_data(wacom); wacom_led_control(wacom); mutex_unlock(&wacom->lock); @@ -2540,4 +2623,4 @@ module_hid_driver(wacom_driver); MODULE_VERSION(DRIVER_VERSION); MODULE_AUTHOR(DRIVER_AUTHOR); MODULE_DESCRIPTION(DRIVER_DESC); -MODULE_LICENSE(DRIVER_LICENSE); +MODULE_LICENSE("GPL"); diff --git a/drivers/hid/wacom_wac.c b/drivers/hid/wacom_wac.c index 672145b0d8f5..4aa3de9f1163 100644 --- a/drivers/hid/wacom_wac.c +++ b/drivers/hid/wacom_wac.c @@ -43,6 +43,8 @@ static void wacom_report_numbered_buttons(struct input_dev *input_dev, static int wacom_numbered_button_to_key(int n); +static void wacom_update_led(struct wacom *wacom, int button_count, int mask, + int group); /* * Percent of battery capacity for Graphire. * 8th value means AC online and show 100% capacity. @@ -1192,6 +1194,166 @@ static int wacom_wac_finger_count_touches(struct wacom_wac *wacom) return count; } +static void wacom_intuos_pro2_bt_pen(struct wacom_wac *wacom) +{ + const int pen_frame_len = 14; + const int pen_frames = 7; + + struct input_dev *pen_input = wacom->pen_input; + unsigned char *data = wacom->data; + int i; + + wacom->serial[0] = get_unaligned_le64(&data[99]); + wacom->id[0] = get_unaligned_le16(&data[107]); + if (wacom->serial[0] >> 52 == 1) { + /* Add back in missing bits of ID for non-USI pens */ + wacom->id[0] |= (wacom->serial[0] >> 32) & 0xFFFFF; + } + wacom->tool[0] = wacom_intuos_get_tool_type(wacom_intuos_id_mangle(wacom->id[0])); + + for (i = 0; i < pen_frames; i++) { + unsigned char *frame = &data[i*pen_frame_len + 1]; + bool valid = frame[0] & 0x80; + bool prox = frame[0] & 0x40; + bool range = frame[0] & 0x20; + + if (!valid) + continue; + + if (range) { + input_report_abs(pen_input, ABS_X, get_unaligned_le16(&frame[1])); + input_report_abs(pen_input, ABS_Y, get_unaligned_le16(&frame[3])); + input_report_abs(pen_input, ABS_TILT_X, frame[7]); + input_report_abs(pen_input, ABS_TILT_Y, frame[8]); + input_report_abs(pen_input, ABS_Z, get_unaligned_le16(&frame[9])); + input_report_abs(pen_input, ABS_WHEEL, get_unaligned_le16(&frame[11])); + } + input_report_abs(pen_input, ABS_PRESSURE, get_unaligned_le16(&frame[5])); + input_report_abs(pen_input, ABS_DISTANCE, range ? frame[13] : wacom->features.distance_max); + + input_report_key(pen_input, BTN_TOUCH, frame[0] & 0x01); + input_report_key(pen_input, BTN_STYLUS, frame[0] & 0x02); + input_report_key(pen_input, BTN_STYLUS2, frame[0] & 0x04); + + input_report_key(pen_input, wacom->tool[0], prox); + input_event(pen_input, EV_MSC, MSC_SERIAL, wacom->serial[0]); + input_report_abs(pen_input, ABS_MISC, + wacom_intuos_id_mangle(wacom->id[0])); /* report tool id */ + + wacom->shared->stylus_in_proximity = prox; + + input_sync(pen_input); + } +} + +static void wacom_intuos_pro2_bt_touch(struct wacom_wac *wacom) +{ + const int finger_touch_len = 8; + const int finger_frames = 4; + const int finger_frame_len = 43; + + struct input_dev *touch_input = wacom->touch_input; + unsigned char *data = wacom->data; + int num_contacts_left = 5; + int i, j; + + for (i = 0; i < finger_frames; i++) { + unsigned char *frame = &data[i*finger_frame_len + 109]; + int current_num_contacts = frame[0] & 0x7F; + int contacts_to_send; + + if (!(frame[0] & 0x80)) + continue; + + /* + * First packet resets the counter since only the first + * packet in series will have non-zero current_num_contacts. + */ + if (current_num_contacts) + wacom->num_contacts_left = current_num_contacts; + + contacts_to_send = min(num_contacts_left, wacom->num_contacts_left); + + for (j = 0; j < contacts_to_send; j++) { + unsigned char *touch = &frame[j*finger_touch_len + 1]; + int slot = input_mt_get_slot_by_key(touch_input, touch[0]); + int x = get_unaligned_le16(&touch[2]); + int y = get_unaligned_le16(&touch[4]); + int w = touch[6] * input_abs_get_res(touch_input, ABS_MT_POSITION_X); + int h = touch[7] * input_abs_get_res(touch_input, ABS_MT_POSITION_Y); + + if (slot < 0) + continue; + + input_mt_slot(touch_input, slot); + input_mt_report_slot_state(touch_input, MT_TOOL_FINGER, touch[1] & 0x01); + input_report_abs(touch_input, ABS_MT_POSITION_X, x); + input_report_abs(touch_input, ABS_MT_POSITION_Y, y); + input_report_abs(touch_input, ABS_MT_TOUCH_MAJOR, max(w, h)); + input_report_abs(touch_input, ABS_MT_TOUCH_MINOR, min(w, h)); + input_report_abs(touch_input, ABS_MT_ORIENTATION, w > h); + } + + input_mt_sync_frame(touch_input); + + wacom->num_contacts_left -= contacts_to_send; + if (wacom->num_contacts_left <= 0) { + wacom->num_contacts_left = 0; + wacom->shared->touch_down = wacom_wac_finger_count_touches(wacom); + } + } + + input_report_switch(touch_input, SW_MUTE_DEVICE, !(data[281] >> 7)); + input_sync(touch_input); +} + +static void wacom_intuos_pro2_bt_pad(struct wacom_wac *wacom) +{ + struct input_dev *pad_input = wacom->pad_input; + unsigned char *data = wacom->data; + + int buttons = (data[282] << 1) | ((data[281] >> 6) & 0x01); + int ring = data[285]; + int prox = buttons | (ring & 0x80); + + wacom_report_numbered_buttons(pad_input, 9, buttons); + + input_report_abs(pad_input, ABS_WHEEL, (ring & 0x80) ? (ring & 0x7f) : 0); + + input_report_key(pad_input, wacom->tool[1], prox ? 1 : 0); + input_report_abs(pad_input, ABS_MISC, prox ? PAD_DEVICE_ID : 0); + input_event(pad_input, EV_MSC, MSC_SERIAL, 0xffffffff); + + input_sync(pad_input); +} + +static void wacom_intuos_pro2_bt_battery(struct wacom_wac *wacom) +{ + unsigned char *data = wacom->data; + + bool chg = data[284] & 0x80; + int battery_status = data[284] & 0x7F; + + wacom_notify_battery(wacom, battery_status, chg, 1, chg); +} + +static int wacom_intuos_pro2_bt_irq(struct wacom_wac *wacom, size_t len) +{ + unsigned char *data = wacom->data; + + if (data[0] != 0x80) { + dev_dbg(wacom->pen_input->dev.parent, + "%s: received unknown report #%d\n", __func__, data[0]); + return 0; + } + + wacom_intuos_pro2_bt_pen(wacom); + wacom_intuos_pro2_bt_touch(wacom); + wacom_intuos_pro2_bt_pad(wacom); + wacom_intuos_pro2_bt_battery(wacom); + return 0; +} + static int wacom_24hdt_irq(struct wacom_wac *wacom) { struct input_dev *input = wacom->touch_input; @@ -1446,7 +1608,7 @@ static int wacom_tpc_irq(struct wacom_wac *wacom, size_t len) return 0; } -static int wacom_equivalent_usage(int usage) +int wacom_equivalent_usage(int usage) { if ((usage & HID_USAGE_PAGE) == WACOM_HID_UP_WACOMDIGITIZER) { int subpage = (usage & 0xFF00) << 8; @@ -1473,6 +1635,16 @@ static int wacom_equivalent_usage(int usage) return subpage | subusage; } + if ((usage & HID_USAGE_PAGE) == WACOM_HID_UP_WACOMTOUCH) { + int subpage = (usage & 0xFF00) << 8; + int subusage = (usage & 0xFF); + + if (subpage == HID_UP_UNDEFINED) + subpage = WACOM_HID_SP_DIGITIZER; + + return subpage | subusage; + } + return usage; } @@ -1552,12 +1724,14 @@ static void wacom_wac_pad_usage_mapping(struct hid_device *hdev, wacom_map_usage(input, usage, field, EV_ABS, ABS_Z, 0); features->device_type |= WACOM_DEVICETYPE_PAD; break; + case WACOM_HID_WD_BUTTONCENTER: + wacom->generic_has_leds = true; + /* fall through */ case WACOM_HID_WD_BUTTONHOME: case WACOM_HID_WD_BUTTONUP: case WACOM_HID_WD_BUTTONDOWN: case WACOM_HID_WD_BUTTONLEFT: case WACOM_HID_WD_BUTTONRIGHT: - case WACOM_HID_WD_BUTTONCENTER: wacom_map_usage(input, usage, field, EV_KEY, wacom_numbered_button_to_key(features->numbered_buttons), 0); @@ -1565,7 +1739,17 @@ static void wacom_wac_pad_usage_mapping(struct hid_device *hdev, features->device_type |= WACOM_DEVICETYPE_PAD; break; case WACOM_HID_WD_TOUCHONOFF: - wacom_map_usage(input, usage, field, EV_SW, SW_MUTE_DEVICE, 0); + /* + * This usage, which is used to mute touch events, comes + * from the pad packet, but is reported on the touch + * interface. Because the touch interface may not have + * been created yet, we cannot call wacom_map_usage(). In + * order to process this usage when we receive it, we set + * the usage type and code directly. + */ + wacom_wac->has_mute_touch_switch = true; + usage->type = EV_SW; + usage->code = SW_MUTE_DEVICE; features->device_type |= WACOM_DEVICETYPE_PAD; break; case WACOM_HID_WD_TOUCHSTRIP: @@ -1580,6 +1764,10 @@ static void wacom_wac_pad_usage_mapping(struct hid_device *hdev, wacom_map_usage(input, usage, field, EV_ABS, ABS_WHEEL, 0); features->device_type |= WACOM_DEVICETYPE_PAD; break; + case WACOM_HID_WD_TOUCHRINGSTATUS: + wacom_map_usage(input, usage, field, EV_ABS, ABS_WHEEL, 0); + features->device_type |= WACOM_DEVICETYPE_PAD; + break; } switch (equivalent_usage & 0xfffffff0) { @@ -1622,17 +1810,40 @@ static void wacom_wac_pad_event(struct hid_device *hdev, struct hid_field *field struct input_dev *input = wacom_wac->pad_input; struct wacom_features *features = &wacom_wac->features; unsigned equivalent_usage = wacom_equivalent_usage(usage->hid); + int i; + + /* + * Avoid reporting this event and setting inrange_state if this usage + * hasn't been mapped. + */ + if (!usage->type) + return; if (wacom_equivalent_usage(field->physical) == HID_DG_TABLETFUNCTIONKEY) { - wacom_wac->hid_data.inrange_state |= value; + if (usage->hid != WACOM_HID_WD_TOUCHRING) + wacom_wac->hid_data.inrange_state |= value; } switch (equivalent_usage) { case WACOM_HID_WD_TOUCHRINGSTATUS: + if (!value) + input_event(input, usage->type, usage->code, 0); break; + case WACOM_HID_WD_TOUCHONOFF: + if (wacom_wac->shared->touch_input) { + input_report_switch(wacom_wac->shared->touch_input, + SW_MUTE_DEVICE, !value); + input_sync(wacom_wac->shared->touch_input); + } + break; + + case WACOM_HID_WD_BUTTONCENTER: + for (i = 0; i < wacom->led.count; i++) + wacom_update_led(wacom, features->numbered_buttons, + value, i); + /* fall through*/ default: - features->input_event_flag = true; input_event(input, usage->type, usage->code, value); break; } @@ -1670,20 +1881,15 @@ static void wacom_wac_pad_report(struct hid_device *hdev, { struct wacom *wacom = hid_get_drvdata(hdev); struct wacom_wac *wacom_wac = &wacom->wacom_wac; - struct wacom_features *features = &wacom_wac->features; struct input_dev *input = wacom_wac->pad_input; bool active = wacom_wac->hid_data.inrange_state != 0; /* report prox for expresskey events */ if (wacom_equivalent_usage(report->field[0]->physical) == HID_DG_TABLETFUNCTIONKEY) { - features->input_event_flag = true; input_event(input, EV_ABS, ABS_MISC, active ? PAD_DEVICE_ID : 0); - } - - if (features->input_event_flag) { - features->input_event_flag = false; input_sync(input); } + } static void wacom_wac_pen_usage_mapping(struct hid_device *hdev, @@ -2058,8 +2264,10 @@ static void wacom_wac_finger_pre_report(struct hid_device *hdev, for (j = 0; j < field->maxusage; j++) { struct hid_usage *usage = &field->usage[j]; + unsigned int equivalent_usage = + wacom_equivalent_usage(usage->hid); - switch (usage->hid) { + switch (equivalent_usage) { case HID_GD_X: case HID_GD_Y: case HID_DG_WIDTH: @@ -2068,7 +2276,7 @@ static void wacom_wac_finger_pre_report(struct hid_device *hdev, case HID_DG_INRANGE: case HID_DG_INVERT: case HID_DG_TIPSWITCH: - hid_data->last_slot_field = usage->hid; + hid_data->last_slot_field = equivalent_usage; break; case HID_DG_CONTACTCOUNT: hid_data->cc_report = report->id; @@ -2123,8 +2331,8 @@ void wacom_wac_usage_mapping(struct hid_device *hdev, struct wacom_wac *wacom_wac = &wacom->wacom_wac; struct wacom_features *features = &wacom_wac->features; - /* currently, only direct devices have proper hid report descriptors */ - features->device_type |= WACOM_DEVICETYPE_DIRECT; + if (WACOM_DIRECT_DEVICE(field)) + features->device_type |= WACOM_DEVICETYPE_DIRECT; if (WACOM_PAD_FIELD(field)) wacom_wac_pad_usage_mapping(hdev, field, usage); @@ -2142,6 +2350,9 @@ void wacom_wac_event(struct hid_device *hdev, struct hid_field *field, if (wacom->wacom_wac.features.type != HID_GENERIC) return; + if (value > field->logical_maximum || value < field->logical_minimum) + return; + if (WACOM_PAD_FIELD(field)) { wacom_wac_pad_battery_event(hdev, field, usage, value); if (wacom->wacom_wac.pad_input) @@ -2669,6 +2880,10 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t len) sync = wacom_intuos_irq(wacom_wac); break; + case INTUOSP2_BT: + sync = wacom_intuos_pro2_bt_irq(wacom_wac, len); + break; + case TABLETPC: case TABLETPCE: case TABLETPC2FG: @@ -2779,8 +2994,6 @@ void wacom_setup_device_quirks(struct wacom *wacom) struct wacom_features *features = &wacom->wacom_wac.features; /* The pen and pad share the same interface on most devices */ - if (features->numbered_buttons > 0) - features->device_type |= WACOM_DEVICETYPE_PAD; if (features->type == GRAPHIRE_BT || features->type == WACOM_G4 || features->type == DTUS || (features->type >= INTUOS3S && features->type <= WACOM_MO)) { @@ -2840,6 +3053,13 @@ void wacom_setup_device_quirks(struct wacom *wacom) if (features->type == REMOTE) features->device_type = WACOM_DEVICETYPE_PAD; + if (features->type == INTUOSP2_BT) { + features->device_type |= WACOM_DEVICETYPE_PEN | + WACOM_DEVICETYPE_PAD | + WACOM_DEVICETYPE_TOUCH; + features->quirks |= WACOM_QUIRK_BATTERY; + } + switch (features->type) { case PL: case DTU: @@ -2986,6 +3206,7 @@ int wacom_setup_pen_input_capabilities(struct input_dev *input_dev, case INTUOSPL: case INTUOS5S: case INTUOSPS: + case INTUOSP2_BT: input_set_abs_params(input_dev, ABS_DISTANCE, 0, features->distance_max, features->distance_fuzz, 0); @@ -3094,6 +3315,27 @@ int wacom_setup_touch_input_capabilities(struct input_dev *input_dev, } switch (features->type) { + case INTUOSP2_BT: + input_dev->evbit[0] |= BIT_MASK(EV_SW); + __set_bit(SW_MUTE_DEVICE, input_dev->swbit); + + if (wacom_wac->shared->touch->product == 0x361) { + input_set_abs_params(input_dev, ABS_MT_POSITION_X, + 0, 12440, 4, 0); + input_set_abs_params(input_dev, ABS_MT_POSITION_Y, + 0, 8640, 4, 0); + } + else if (wacom_wac->shared->touch->product == 0x360) { + input_set_abs_params(input_dev, ABS_MT_POSITION_X, + 0, 8960, 4, 0); + input_set_abs_params(input_dev, ABS_MT_POSITION_Y, + 0, 5920, 4, 0); + } + input_abs_set_res(input_dev, ABS_MT_POSITION_X, 40); + input_abs_set_res(input_dev, ABS_MT_POSITION_X, 40); + + /* fall through */ + case INTUOS5: case INTUOS5L: case INTUOSPM: @@ -3290,6 +3532,9 @@ int wacom_setup_pad_input_capabilities(struct input_dev *input_dev, { struct wacom_features *features = &wacom_wac->features; + if ((features->type == HID_GENERIC) && features->numbered_buttons > 0) + features->device_type |= WACOM_DEVICETYPE_PAD; + if (!(features->device_type & WACOM_DEVICETYPE_PAD)) return -ENODEV; @@ -3391,6 +3636,7 @@ int wacom_setup_pad_input_capabilities(struct input_dev *input_dev, case INTUOSPL: case INTUOS5S: case INTUOSPS: + case INTUOSP2_BT: input_set_abs_params(input_dev, ABS_WHEEL, 0, 71, 0, 0); break; @@ -3949,6 +4195,12 @@ static const struct wacom_features wacom_features_0x343 = DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4, WACOM_DTU_OFFSET, WACOM_DTU_OFFSET, WACOM_DTU_OFFSET, WACOM_DTU_OFFSET }; +static const struct wacom_features wacom_features_0x360 = + { "Wacom Intuos Pro M", 44800, 29600, 8191, 63, + INTUOSP2_BT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 9, .touch_max = 10 }; +static const struct wacom_features wacom_features_0x361 = + { "Wacom Intuos Pro L", 62200, 43200, 8191, 63, + INTUOSP2_BT, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 9, .touch_max = 10 }; static const struct wacom_features wacom_features_HID_ANY_ID = { "Wacom HID", .type = HID_GENERIC, .oVid = HID_ANY_ID, .oPid = HID_ANY_ID }; @@ -4115,6 +4367,8 @@ const struct hid_device_id wacom_ids[] = { { USB_DEVICE_WACOM(0x33D) }, { USB_DEVICE_WACOM(0x33E) }, { USB_DEVICE_WACOM(0x343) }, + { BT_DEVICE_WACOM(0x360) }, + { BT_DEVICE_WACOM(0x361) }, { USB_DEVICE_WACOM(0x4001) }, { USB_DEVICE_WACOM(0x4004) }, { USB_DEVICE_WACOM(0x5000) }, @@ -4123,6 +4377,7 @@ const struct hid_device_id wacom_ids[] = { { USB_DEVICE_WACOM(HID_ANY_ID) }, { I2C_DEVICE_WACOM(HID_ANY_ID) }, + { BT_DEVICE_WACOM(HID_ANY_ID) }, { } }; MODULE_DEVICE_TABLE(hid, wacom_ids); diff --git a/drivers/hid/wacom_wac.h b/drivers/hid/wacom_wac.h index fb0e50acb10d..857ccee16f38 100644 --- a/drivers/hid/wacom_wac.h +++ b/drivers/hid/wacom_wac.h @@ -12,8 +12,8 @@ #include <linux/types.h> #include <linux/hid.h> -/* maximum packet length for USB devices */ -#define WACOM_PKGLEN_MAX 192 +/* maximum packet length for USB/BT devices */ +#define WACOM_PKGLEN_MAX 361 #define WACOM_NAME_MAX 64 #define WACOM_MAX_REMOTES 5 @@ -72,6 +72,17 @@ #define WACOM_REPORT_REMOTE 17 #define WACOM_REPORT_INTUOSHT2_ID 8 +/* wacom command report ids */ +#define WAC_CMD_WL_LED_CONTROL 0x03 +#define WAC_CMD_LED_CONTROL 0x20 +#define WAC_CMD_ICON_START 0x21 +#define WAC_CMD_ICON_XFER 0x23 +#define WAC_CMD_ICON_BT_XFER 0x26 +#define WAC_CMD_DELETE_PAIRING 0x20 +#define WAC_CMD_LED_CONTROL_GENERIC 0x32 +#define WAC_CMD_UNPAIR_ALL 0xFF +#define WAC_CMD_WL_INTUOSP2 0x82 + /* device quirks */ #define WACOM_QUIRK_BBTOUCH_LOWRES 0x0001 #define WACOM_QUIRK_SENSE 0x0002 @@ -91,6 +102,7 @@ #define WACOM_HID_SP_DIGITIZER 0x000d0000 #define WACOM_HID_SP_DIGITIZERINFO 0x00100000 #define WACOM_HID_WD_DIGITIZER (WACOM_HID_UP_WACOMDIGITIZER | 0x01) +#define WACOM_HID_WD_PEN (WACOM_HID_UP_WACOMDIGITIZER | 0x02) #define WACOM_HID_WD_SENSE (WACOM_HID_UP_WACOMDIGITIZER | 0x36) #define WACOM_HID_WD_DIGITIZERFNKEYS (WACOM_HID_UP_WACOMDIGITIZER | 0x39) #define WACOM_HID_WD_SERIALHI (WACOM_HID_UP_WACOMDIGITIZER | 0x5c) @@ -104,6 +116,7 @@ #define WACOM_HID_WD_ACCELEROMETER_Y (WACOM_HID_UP_WACOMDIGITIZER | 0x0402) #define WACOM_HID_WD_ACCELEROMETER_Z (WACOM_HID_UP_WACOMDIGITIZER | 0x0403) #define WACOM_HID_WD_BATTERY_CHARGING (WACOM_HID_UP_WACOMDIGITIZER | 0x0404) +#define WACOM_HID_WD_TOUCHONOFF (WACOM_HID_UP_WACOMDIGITIZER | 0x0454) #define WACOM_HID_WD_BATTERY_LEVEL (WACOM_HID_UP_WACOMDIGITIZER | 0x043b) #define WACOM_HID_WD_EXPRESSKEY00 (WACOM_HID_UP_WACOMDIGITIZER | 0x0910) #define WACOM_HID_WD_EXPRESSKEYCAP00 (WACOM_HID_UP_WACOMDIGITIZER | 0x0950) @@ -113,7 +126,6 @@ #define WACOM_HID_WD_BUTTONLEFT (WACOM_HID_UP_WACOMDIGITIZER | 0x0993) #define WACOM_HID_WD_BUTTONRIGHT (WACOM_HID_UP_WACOMDIGITIZER | 0x0994) #define WACOM_HID_WD_BUTTONCENTER (WACOM_HID_UP_WACOMDIGITIZER | 0x0995) -#define WACOM_HID_WD_TOUCHONOFF (WACOM_HID_UP_WACOMDIGITIZER | 0x0996) #define WACOM_HID_WD_FINGERWHEEL (WACOM_HID_UP_WACOMDIGITIZER | 0x0d03) #define WACOM_HID_WD_OFFSETLEFT (WACOM_HID_UP_WACOMDIGITIZER | 0x0d30) #define WACOM_HID_WD_OFFSETTOP (WACOM_HID_UP_WACOMDIGITIZER | 0x0d31) @@ -127,6 +139,12 @@ #define WACOM_HID_UP_G11 0xff110000 #define WACOM_HID_G11_PEN (WACOM_HID_UP_G11 | 0x02) #define WACOM_HID_G11_TOUCHSCREEN (WACOM_HID_UP_G11 | 0x11) +#define WACOM_HID_UP_WACOMTOUCH 0xff000000 +#define WACOM_HID_WT_TOUCHSCREEN (WACOM_HID_UP_WACOMTOUCH | 0x04) +#define WACOM_HID_WT_TOUCHPAD (WACOM_HID_UP_WACOMTOUCH | 0x05) +#define WACOM_HID_WT_CONTACTMAX (WACOM_HID_UP_WACOMTOUCH | 0x55) +#define WACOM_HID_WT_X (WACOM_HID_UP_WACOMTOUCH | 0x130) +#define WACOM_HID_WT_Y (WACOM_HID_UP_WACOMTOUCH | 0x131) #define WACOM_PAD_FIELD(f) (((f)->physical == HID_DG_TABLETFUNCTIONKEY) || \ ((f)->physical == WACOM_HID_WD_DIGITIZERFNKEYS) || \ @@ -144,7 +162,14 @@ ((f)->physical == HID_DG_FINGER) || \ ((f)->application == HID_DG_TOUCHSCREEN) || \ ((f)->application == WACOM_HID_G9_TOUCHSCREEN) || \ - ((f)->application == WACOM_HID_G11_TOUCHSCREEN)) + ((f)->application == WACOM_HID_G11_TOUCHSCREEN) || \ + ((f)->application == WACOM_HID_WT_TOUCHPAD) || \ + ((f)->application == HID_DG_TOUCHPAD)) + +#define WACOM_DIRECT_DEVICE(f) (((f)->application == HID_DG_TOUCHSCREEN) || \ + ((f)->application == WACOM_HID_WT_TOUCHSCREEN) || \ + ((f)->application == HID_DG_PEN) || \ + ((f)->application == WACOM_HID_WD_PEN)) enum { PENPARTNER = 0, @@ -170,6 +195,7 @@ enum { INTUOSPS, INTUOSPM, INTUOSPL, + INTUOSP2_BT, WACOM_21UX2, WACOM_22HD, DTK, @@ -232,7 +258,6 @@ struct wacom_features { int pktlen; bool check_for_hid_type; int hid_type; - bool input_event_flag; }; struct wacom_shared { @@ -244,6 +269,7 @@ struct wacom_shared { struct input_dev *touch_input; struct hid_device *pen; struct hid_device *touch; + bool has_mute_touch_switch; }; struct hid_data { @@ -300,6 +326,7 @@ struct wacom_wac { int mode_report; int mode_value; struct hid_data hid_data; + bool has_mute_touch_switch; }; #endif |