Commit b4dd05de authored by Linus Torvalds's avatar Linus Torvalds

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid

Pull HID updates from Jiri Kosina:

 - support for U2F Zero device, from Andrej Shadura

 - logitech-dj has historically been treating devices behind
   non-unifying receivers as generic devices, using the HID emulation in
   the receiver. That had several shortcomings (special keys handling,
   battery level monitoring, etc). The driver has been reworked to
   enumarate (and directly communicate with) the devices behind the
   receiver, to avoid the (too) generic HID implementation in the
   receiver itself. All the work done by Benjamin Tissoires and Hans de
   Goede.

 - restructuring of intel-ish driver in order to allow for multiple
   clients of the ISH implementation, from Srinivas Pandruvada

 - several other smaller fixes and assorted device ID additions

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid: (68 commits)
  HID: logitech-dj: fix spelling in printk
  HID: input: fix assignment of .value
  HID: input: make sure the wheel high resolution multiplier is set
  HID: logitech-dj: add usbhid dependency in Kconfig
  HID: logitech-hidpp: add support for HID++ 1.0 consumer keys reports
  HID: logitech-hidpp: add support for HID++ 1.0 extra mouse buttons reports
  HID: logitech-hidpp: add support for HID++ 1.0 wheel reports
  HID: logitech-hidpp: make hidpp10_set_register_bit a bit more generic
  HID: logitech-hidpp: add input_device ptr to struct hidpp_device
  HID: logitech-hidpp: do not hardcode very long report length
  HID: logitech-hidpp: handle devices attached to 27MHz wireless receivers
  HID: logitech-hidpp: use RAP instead of FAP to get the protocol version
  HID: logitech-hidpp: remove unused origin_is_hid_core function parameter
  HID: logitech-hidpp: remove double assignment from __hidpp_send_report
  HID: logitech-hidpp: do not make failure to get the name fatal
  HID: logitech-hidpp: ignore very-short or empty names
  HID: logitech-hidpp: make .probe usbhid capable
  HID: logitech-hidpp: allow non HID++ devices to be handled by this module
  HID: logitech-dj: add support for Logitech Bluetooth Mini-Receiver
  HID: logitech-dj: make appending of the HID++ descriptors conditional
  ...
parents 80104bb0 63b6f0b8
......@@ -231,6 +231,16 @@ config HID_COUGAR
Supported devices:
- Cougar 500k Gaming Keyboard
config HID_MACALLY
tristate "Macally devices"
depends on HID
help
Support for Macally devices that are not fully compliant with the
HID standard.
supported devices:
- Macally ikey keyboard
config HID_PRODIKEYS
tristate "Prodikeys PC-MIDI Keyboard support"
depends on HID && SND
......@@ -511,6 +521,7 @@ config HID_LOGITECH
config HID_LOGITECH_DJ
tristate "Logitech Unifying receivers full support"
depends on USB_HID
depends on HIDRAW
depends on HID_LOGITECH
select HID_LOGITECH_HIDPP
......@@ -1003,6 +1014,22 @@ config HID_UDRAW_PS3
Say Y here if you want to use the THQ uDraw gaming tablet for
the PS3.
config HID_U2FZERO
tristate "U2F Zero LED and RNG support"
depends on USB_HID
depends on LEDS_CLASS
depends on HW_RANDOM
help
Support for the LED of the U2F Zero device.
U2F Zero supports custom commands for blinking the LED
and getting data from the internal hardware RNG.
The internal hardware can be used to feed the enthropy pool.
U2F Zero only supports blinking its LED, so this driver doesn't
allow setting the brightness to anything but 1, which will
trigger a single blink and immediately reset to back 0.
config HID_WACOM
tristate "Wacom Intuos/Graphire tablet support (USB)"
depends on USB_HID
......
......@@ -65,6 +65,7 @@ obj-$(CONFIG_HID_LENOVO) += hid-lenovo.o
obj-$(CONFIG_HID_LOGITECH) += hid-logitech.o
obj-$(CONFIG_HID_LOGITECH_DJ) += hid-logitech-dj.o
obj-$(CONFIG_HID_LOGITECH_HIDPP) += hid-logitech-hidpp.o
obj-$(CONFIG_HID_MACALLY) += hid-macally.o
obj-$(CONFIG_HID_MAGICMOUSE) += hid-magicmouse.o
obj-$(CONFIG_HID_MALTRON) += hid-maltron.o
obj-$(CONFIG_HID_MAYFLASH) += hid-mf.o
......@@ -109,6 +110,7 @@ obj-$(CONFIG_HID_THRUSTMASTER) += hid-tmff.o
obj-$(CONFIG_HID_TIVO) += hid-tivo.o
obj-$(CONFIG_HID_TOPSEED) += hid-topseed.o
obj-$(CONFIG_HID_TWINHAN) += hid-twinhan.o
obj-$(CONFIG_HID_U2FZERO) += hid-u2fzero.o
hid-uclogic-objs := hid-uclogic-core.o \
hid-uclogic-rdesc.o \
hid-uclogic-params.o
......@@ -134,3 +136,4 @@ obj-$(CONFIG_USB_KBD) += usbhid/
obj-$(CONFIG_I2C_HID) += i2c-hid/
obj-$(CONFIG_INTEL_ISH_HID) += intel-ish-hid/
obj-$(INTEL_ISH_FIRMWARE_DOWNLOADER) += intel-ish-hid/
......@@ -30,6 +30,7 @@
#include <linux/vmalloc.h>
#include <linux/sched.h>
#include <linux/semaphore.h>
#include <linux/async.h>
#include <linux/hid.h>
#include <linux/hiddev.h>
......@@ -218,13 +219,14 @@ static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
* Add a usage to the temporary parser table.
*/
static int hid_add_usage(struct hid_parser *parser, unsigned usage)
static int hid_add_usage(struct hid_parser *parser, unsigned usage, u8 size)
{
if (parser->local.usage_index >= HID_MAX_USAGES) {
hid_err(parser->device, "usage index exceeded\n");
return -1;
}
parser->local.usage[parser->local.usage_index] = usage;
parser->local.usage_size[parser->local.usage_index] = size;
parser->local.collection_index[parser->local.usage_index] =
parser->collection_stack_ptr ?
parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
......@@ -486,10 +488,7 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
return 0;
}
if (item->size <= 2)
data = (parser->global.usage_page << 16) + data;
return hid_add_usage(parser, data);
return hid_add_usage(parser, data, item->size);
case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
......@@ -498,9 +497,6 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
return 0;
}
if (item->size <= 2)
data = (parser->global.usage_page << 16) + data;
parser->local.usage_minimum = data;
return 0;
......@@ -511,9 +507,6 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
return 0;
}
if (item->size <= 2)
data = (parser->global.usage_page << 16) + data;
count = data - parser->local.usage_minimum;
if (count + parser->local.usage_index >= HID_MAX_USAGES) {
/*
......@@ -533,7 +526,7 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
}
for (n = parser->local.usage_minimum; n <= data; n++)
if (hid_add_usage(parser, n)) {
if (hid_add_usage(parser, n, item->size)) {
dbg_hid("hid_add_usage failed\n");
return -1;
}
......@@ -547,6 +540,22 @@ static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
return 0;
}
/*
* Concatenate Usage Pages into Usages where relevant:
* As per specification, 6.2.2.8: "When the parser encounters a main item it
* concatenates the last declared Usage Page with a Usage to form a complete
* usage value."
*/
static void hid_concatenate_usage_page(struct hid_parser *parser)
{
int i;
for (i = 0; i < parser->local.usage_index; i++)
if (parser->local.usage_size[i] <= 2)
parser->local.usage[i] += parser->global.usage_page << 16;
}
/*
* Process a main item.
*/
......@@ -556,6 +565,8 @@ static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
__u32 data;
int ret;
hid_concatenate_usage_page(parser);
data = item_udata(item);
switch (item->tag) {
......@@ -765,6 +776,8 @@ static int hid_scan_main(struct hid_parser *parser, struct hid_item *item)
__u32 data;
int i;
hid_concatenate_usage_page(parser);
data = item_udata(item);
switch (item->tag) {
......@@ -1624,7 +1637,7 @@ static struct hid_report *hid_get_report(struct hid_report_enum *report_enum,
* Implement a generic .request() callback, using .raw_request()
* DO NOT USE in hid drivers directly, but through hid_hw_request instead.
*/
void __hid_request(struct hid_device *hid, struct hid_report *report,
int __hid_request(struct hid_device *hid, struct hid_report *report,
int reqtype)
{
char *buf;
......@@ -1633,7 +1646,7 @@ void __hid_request(struct hid_device *hid, struct hid_report *report,
buf = hid_alloc_report_buf(report, GFP_KERNEL);
if (!buf)
return;
return -ENOMEM;
len = hid_report_len(report);
......@@ -1650,8 +1663,11 @@ void __hid_request(struct hid_device *hid, struct hid_report *report,
if (reqtype == HID_REQ_GET_REPORT)
hid_input_report(hid, report->type, buf, ret, 0);
ret = 0;
out:
kfree(buf);
return ret;
}
EXPORT_SYMBOL_GPL(__hid_request);
......@@ -2349,6 +2365,15 @@ int hid_add_device(struct hid_device *hdev)
dev_set_name(&hdev->dev, "%04X:%04X:%04X.%04X", hdev->bus,
hdev->vendor, hdev->product, atomic_inc_return(&id));
/*
* Try loading the module for the device before the add, so that we do
* not first have hid-generic binding only to have it replaced
* immediately afterwards with a specialized driver.
*/
if (!current_is_async())
request_module("hid:b%04Xg%04Xv%08Xp%08X", hdev->bus,
hdev->group, hdev->vendor, hdev->product);
hid_debug_register(hdev, dev_name(&hdev->dev));
ret = device_add(&hdev->dev);
if (!ret)
......
......@@ -323,6 +323,7 @@
#define USB_DEVICE_ID_CYGNAL_RADIO_SI470X 0x818a
#define USB_DEVICE_ID_FOCALTECH_FTXXXX_MULTITOUCH 0x81b9
#define USB_DEVICE_ID_CYGNAL_CP2112 0xea90
#define USB_DEVICE_ID_U2F_ZERO 0x8acf
#define USB_DEVICE_ID_CYGNAL_RADIO_SI4713 0x8244
......@@ -762,8 +763,12 @@
#define USB_DEVICE_ID_S510_RECEIVER_2 0xc517
#define USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500 0xc512
#define USB_DEVICE_ID_MX3000_RECEIVER 0xc513
#define USB_DEVICE_ID_LOGITECH_27MHZ_MOUSE_RECEIVER 0xc51b
#define USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER 0xc52b
#define USB_DEVICE_ID_LOGITECH_NANO_RECEIVER 0xc52f
#define USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2 0xc532
#define USB_DEVICE_ID_LOGITECH_NANO_RECEIVER_2 0xc534
#define USB_DEVICE_ID_LOGITECH_NANO_RECEIVER_GAMING 0xc539
#define USB_DEVICE_ID_SPACETRAVELLER 0xc623
#define USB_DEVICE_ID_SPACENAVIGATOR 0xc626
#define USB_DEVICE_ID_DINOVO_DESKTOP 0xc704
......@@ -1034,6 +1039,7 @@
#define USB_DEVICE_ID_SINO_LITE_CONTROLLER 0x3008
#define USB_VENDOR_ID_SOLID_YEAR 0x060b
#define USB_DEVICE_ID_MACALLY_IKEY_KEYBOARD 0x0001
#define USB_DEVICE_ID_COUGAR_500K_GAMING_KEYBOARD 0x500a
#define USB_DEVICE_ID_COUGAR_700K_GAMING_KEYBOARD 0x700a
......@@ -1083,7 +1089,6 @@
#define USB_DEVICE_ID_SYNAPTICS_HD 0x0ac3
#define USB_DEVICE_ID_SYNAPTICS_QUAD_HD 0x1ac3
#define USB_DEVICE_ID_SYNAPTICS_TP_V103 0x5710
#define I2C_DEVICE_ID_SYNAPTICS_7E7E 0x7e7e
#define USB_VENDOR_ID_TEXAS_INSTRUMENTS 0x2047
#define USB_DEVICE_ID_TEXAS_INSTRUMENTS_LENOVO_YOGA 0x0855
......
......@@ -1557,52 +1557,71 @@ static void hidinput_close(struct input_dev *dev)
hid_hw_close(hid);
}
static void hidinput_change_resolution_multipliers(struct hid_device *hid)
static bool __hidinput_change_resolution_multipliers(struct hid_device *hid,
struct hid_report *report, bool use_logical_max)
{
struct hid_report_enum *rep_enum;
struct hid_report *rep;
struct hid_usage *usage;
int i, j;
rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
list_for_each_entry(rep, &rep_enum->report_list, list) {
bool update_needed = false;
int i, j;
if (rep->maxfield == 0)
continue;
if (report->maxfield == 0)
return false;
/*
* If we have more than one feature within this report we
* need to fill in the bits from the others before we can
* overwrite the ones for the Resolution Multiplier.
*/
if (rep->maxfield > 1) {
hid_hw_request(hid, rep, HID_REQ_GET_REPORT);
if (report->maxfield > 1) {
hid_hw_request(hid, report, HID_REQ_GET_REPORT);
hid_hw_wait(hid);
}
for (i = 0; i < rep->maxfield; i++) {
__s32 logical_max = rep->field[i]->logical_maximum;
for (i = 0; i < report->maxfield; i++) {
__s32 value = use_logical_max ?
report->field[i]->logical_maximum :
report->field[i]->logical_minimum;
/* There is no good reason for a Resolution
* Multiplier to have a count other than 1.
* Ignore that case.
*/
if (rep->field[i]->report_count != 1)
if (report->field[i]->report_count != 1)
continue;
for (j = 0; j < rep->field[i]->maxusage; j++) {
usage = &rep->field[i]->usage[j];
for (j = 0; j < report->field[i]->maxusage; j++) {
usage = &report->field[i]->usage[j];
if (usage->hid != HID_GD_RESOLUTION_MULTIPLIER)
continue;
*rep->field[i]->value = logical_max;
report->field[i]->value[j] = value;
update_needed = true;
}
}
if (update_needed)
hid_hw_request(hid, rep, HID_REQ_SET_REPORT);
return update_needed;
}
static void hidinput_change_resolution_multipliers(struct hid_device *hid)
{
struct hid_report_enum *rep_enum;
struct hid_report *rep;
int ret;
rep_enum = &hid->report_enum[HID_FEATURE_REPORT];
list_for_each_entry(rep, &rep_enum->report_list, list) {
bool update_needed = __hidinput_change_resolution_multipliers(hid,
rep, true);
if (update_needed) {
ret = __hid_request(hid, rep, HID_REQ_SET_REPORT);
if (ret) {
__hidinput_change_resolution_multipliers(hid,
rep, false);
return;
}
}
}
/* refresh our structs */
......
......@@ -876,8 +876,6 @@ static const struct hid_device_id lg_devices[] = {
.driver_data = LG_RDESC | LG_WIRELESS },
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER),
.driver_data = LG_RDESC | LG_WIRELESS },
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2),
.driver_data = LG_RDESC | LG_WIRELESS },
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER),
.driver_data = LG_BAD_RELATIVE_KEYS },
......
......@@ -25,13 +25,14 @@
#include <linux/device.h>
#include <linux/hid.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/kfifo.h>
#include <linux/delay.h>
#include <linux/usb.h> /* For to_usb_interface for kvm extra intf check */
#include <asm/unaligned.h>
#include "hid-ids.h"
#define DJ_MAX_PAIRED_DEVICES 6
#define DJ_MAX_NUMBER_NOTIFICATIONS 8
#define DJ_MAX_NUMBER_NOTIFS 8
#define DJ_RECEIVER_INDEX 0
#define DJ_DEVICE_INDEX_MIN 1
#define DJ_DEVICE_INDEX_MAX 6
......@@ -74,7 +75,6 @@
/* Device Un-Paired Notification */
#define REPORT_TYPE_NOTIF_DEVICE_UNPAIRED 0x40
/* Connection Status Notification */
#define REPORT_TYPE_NOTIF_CONNECTION_STATUS 0x42
#define CONNECTION_STATUS_PARAM_STATUS 0x00
......@@ -94,12 +94,43 @@
#define REPORT_TYPE_LEDS 0x0E
/* RF Report types bitfield */
#define STD_KEYBOARD 0x00000002
#define STD_MOUSE 0x00000004
#define MULTIMEDIA 0x00000008
#define POWER_KEYS 0x00000010
#define MEDIA_CENTER 0x00000100
#define KBD_LEDS 0x00004000
#define STD_KEYBOARD BIT(1)
#define STD_MOUSE BIT(2)
#define MULTIMEDIA BIT(3)
#define POWER_KEYS BIT(4)
#define MEDIA_CENTER BIT(8)
#define KBD_LEDS BIT(14)
/* Fake (bitnr > NUMBER_OF_HID_REPORTS) bit to track HID++ capability */
#define HIDPP BIT_ULL(63)
/* HID++ Device Connected Notification */
#define REPORT_TYPE_NOTIF_DEVICE_CONNECTED 0x41
#define HIDPP_PARAM_PROTO_TYPE 0x00
#define HIDPP_PARAM_DEVICE_INFO 0x01
#define HIDPP_PARAM_EQUAD_LSB 0x02
#define HIDPP_PARAM_EQUAD_MSB 0x03
#define HIDPP_PARAM_27MHZ_DEVID 0x03
#define HIDPP_DEVICE_TYPE_MASK GENMASK(3, 0)
#define HIDPP_LINK_STATUS_MASK BIT(6)
#define HIDPP_MANUFACTURER_MASK BIT(7)
#define HIDPP_DEVICE_TYPE_KEYBOARD 1
#define HIDPP_DEVICE_TYPE_MOUSE 2
#define HIDPP_SET_REGISTER 0x80
#define HIDPP_GET_LONG_REGISTER 0x83
#define HIDPP_REG_CONNECTION_STATE 0x02
#define HIDPP_REG_PAIRING_INFORMATION 0xB5
#define HIDPP_PAIRING_INFORMATION 0x20
#define HIDPP_FAKE_DEVICE_ARRIVAL 0x02
enum recvr_type {
recvr_type_dj,
recvr_type_hidpp,
recvr_type_gaming_hidpp,
recvr_type_27mhz,
recvr_type_bluetooth,
};
struct dj_report {
u8 report_id;
......@@ -108,23 +139,51 @@ struct dj_report {
u8 report_params[DJREPORT_SHORT_LENGTH - 3];
};
struct hidpp_event {
u8 report_id;
u8 device_index;
u8 sub_id;
u8 params[HIDPP_REPORT_LONG_LENGTH - 3U];
} __packed;
struct dj_receiver_dev {
struct hid_device *hdev;
struct hid_device *mouse;
struct hid_device *keyboard;
struct hid_device *hidpp;
struct dj_device *paired_dj_devices[DJ_MAX_PAIRED_DEVICES +
DJ_DEVICE_INDEX_MIN];
struct list_head list;
struct kref kref;
struct work_struct work;
struct kfifo notif_fifo;
unsigned long last_query; /* in jiffies */
bool ready;
enum recvr_type type;
unsigned int unnumbered_application;
spinlock_t lock;
bool querying_devices;
};
struct dj_device {
struct hid_device *hdev;
struct dj_receiver_dev *dj_receiver_dev;
u32 reports_supported;
u64 reports_supported;
u8 device_index;
};
#define WORKITEM_TYPE_EMPTY 0
#define WORKITEM_TYPE_PAIRED 1
#define WORKITEM_TYPE_UNPAIRED 2
#define WORKITEM_TYPE_UNKNOWN 255
struct dj_workitem {
u8 type; /* WORKITEM_TYPE_* */
u8 device_index;
u8 device_type;
u8 quad_id_msb;
u8 quad_id_lsb;
u64 reports_supported;
};
/* Keyboard descriptor (1) */
static const char kbd_descriptor[] = {
0x05, 0x01, /* USAGE_PAGE (generic Desktop) */
......@@ -200,6 +259,131 @@ static const char mse_descriptor[] = {
0xC0, /* END_COLLECTION */
};
/* Mouse descriptor (2) for 27 MHz receiver, only 8 buttons */
static const char mse_27mhz_descriptor[] = {
0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
0x09, 0x02, /* USAGE (Mouse) */
0xA1, 0x01, /* COLLECTION (Application) */
0x85, 0x02, /* REPORT_ID = 2 */
0x09, 0x01, /* USAGE (pointer) */
0xA1, 0x00, /* COLLECTION (physical) */
0x05, 0x09, /* USAGE_PAGE (buttons) */
0x19, 0x01, /* USAGE_MIN (1) */
0x29, 0x08, /* USAGE_MAX (8) */
0x15, 0x00, /* LOGICAL_MIN (0) */
0x25, 0x01, /* LOGICAL_MAX (1) */
0x95, 0x08, /* REPORT_COUNT (8) */
0x75, 0x01, /* REPORT_SIZE (1) */
0x81, 0x02, /* INPUT (data var abs) */
0x05, 0x01, /* USAGE_PAGE (generic desktop) */
0x16, 0x01, 0xF8, /* LOGICAL_MIN (-2047) */
0x26, 0xFF, 0x07, /* LOGICAL_MAX (2047) */
0x75, 0x0C, /* REPORT_SIZE (12) */
0x95, 0x02, /* REPORT_COUNT (2) */
0x09, 0x30, /* USAGE (X) */
0x09, 0x31, /* USAGE (Y) */
0x81, 0x06, /* INPUT */
0x15, 0x81, /* LOGICAL_MIN (-127) */
0x25, 0x7F, /* LOGICAL_MAX (127) */
0x75, 0x08, /* REPORT_SIZE (8) */
0x95, 0x01, /* REPORT_COUNT (1) */
0x09, 0x38, /* USAGE (wheel) */
0x81, 0x06, /* INPUT */
0x05, 0x0C, /* USAGE_PAGE(consumer) */
0x0A, 0x38, 0x02, /* USAGE(AC Pan) */
0x95, 0x01, /* REPORT_COUNT (1) */
0x81, 0x06, /* INPUT */
0xC0, /* END_COLLECTION */
0xC0, /* END_COLLECTION */
};
/* Mouse descriptor (2) for Bluetooth receiver, low-res hwheel, 12 buttons */
static const char mse_bluetooth_descriptor[] = {
0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
0x09, 0x02, /* USAGE (Mouse) */
0xA1, 0x01, /* COLLECTION (Application) */
0x85, 0x02, /* REPORT_ID = 2 */
0x09, 0x01, /* USAGE (pointer) */
0xA1, 0x00, /* COLLECTION (physical) */
0x05, 0x09, /* USAGE_PAGE (buttons) */
0x19, 0x01, /* USAGE_MIN (1) */
0x29, 0x08, /* USAGE_MAX (8) */
0x15, 0x00, /* LOGICAL_MIN (0) */
0x25, 0x01, /* LOGICAL_MAX (1) */
0x95, 0x08, /* REPORT_COUNT (8) */
0x75, 0x01, /* REPORT_SIZE (1) */
0x81, 0x02, /* INPUT (data var abs) */
0x05, 0x01, /* USAGE_PAGE (generic desktop) */
0x16, 0x01, 0xF8, /* LOGICAL_MIN (-2047) */
0x26, 0xFF, 0x07, /* LOGICAL_MAX (2047) */
0x75, 0x0C, /* REPORT_SIZE (12) */
0x95, 0x02, /* REPORT_COUNT (2) */
0x09, 0x30, /* USAGE (X) */
0x09, 0x31, /* USAGE (Y) */
0x81, 0x06, /* INPUT */
0x15, 0x81, /* LOGICAL_MIN (-127) */
0x25, 0x7F, /* LOGICAL_MAX (127) */
0x75, 0x08, /* REPORT_SIZE (8) */
0x95, 0x01, /* REPORT_COUNT (1) */
0x09, 0x38, /* USAGE (wheel) */
0x81, 0x06, /* INPUT */
0x05, 0x0C, /* USAGE_PAGE(consumer) */
0x0A, 0x38, 0x02, /* USAGE(AC Pan) */
0x15, 0xF9, /* LOGICAL_MIN (-7) */
0x25, 0x07, /* LOGICAL_MAX (7) */
0x75, 0x04, /* REPORT_SIZE (4) */
0x95, 0x01, /* REPORT_COUNT (1) */
0x81, 0x06, /* INPUT */
0x05, 0x09, /* USAGE_PAGE (buttons) */
0x19, 0x09, /* USAGE_MIN (9) */
0x29, 0x0C, /* USAGE_MAX (12) */
0x15, 0x00, /* LOGICAL_MIN (0) */
0x25, 0x01, /* LOGICAL_MAX (1) */
0x75, 0x01, /* REPORT_SIZE (1) */
0x95, 0x04, /* REPORT_COUNT (4) */
0x81, 0x06, /* INPUT */
0xC0, /* END_COLLECTION */
0xC0, /* END_COLLECTION */
};
/* Gaming Mouse descriptor (2) */
static const char mse_high_res_descriptor[] = {
0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
0x09, 0x02, /* USAGE (Mouse) */
0xA1, 0x01, /* COLLECTION (Application) */
0x85, 0x02, /* REPORT_ID = 2 */
0x09, 0x01, /* USAGE (pointer) */
0xA1, 0x00, /* COLLECTION (physical) */
0x05, 0x09, /* USAGE_PAGE (buttons) */
0x19, 0x01, /* USAGE_MIN (1) */
0x29, 0x10, /* USAGE_MAX (16) */
0x15, 0x00, /* LOGICAL_MIN (0) */
0x25, 0x01, /* LOGICAL_MAX (1) */
0x95, 0x10, /* REPORT_COUNT (16) */
0x75, 0x01, /* REPORT_SIZE (1) */
0x81, 0x02, /* INPUT (data var abs) */
0x05, 0x01, /* USAGE_PAGE (generic desktop) */
0x16, 0x01, 0x80, /* LOGICAL_MIN (-32767) */
0x26, 0xFF, 0x7F, /* LOGICAL_MAX (32767) */
0x75, 0x10, /* REPORT_SIZE (16) */
0x95, 0x02, /* REPORT_COUNT (2) */
0x09, 0x30, /* USAGE (X) */
0x09, 0x31, /* USAGE (Y) */
0x81, 0x06, /* INPUT */
0x15, 0x81, /* LOGICAL_MIN (-127) */
0x25, 0x7F, /* LOGICAL_MAX (127) */
0x75, 0x08, /* REPORT_SIZE (8) */
0x95, 0x01, /* REPORT_COUNT (1) */
0x09, 0x38, /* USAGE (wheel) */
0x81, 0x06, /* INPUT */
0x05, 0x0C, /* USAGE_PAGE(consumer) */
0x0A, 0x38, 0x02, /* USAGE(AC Pan) */
0x95, 0x01, /* REPORT_COUNT (1) */
0x81, 0x06, /* INPUT */
0xC0, /* END_COLLECTION */
0xC0, /* END_COLLECTION */
};
/* Consumer Control descriptor (3) */
static const char consumer_descriptor[] = {
0x05, 0x0C, /* USAGE_PAGE (Consumer Devices) */
......@@ -308,7 +492,7 @@ static const char hidpp_descriptor[] = {
/* Make sure all descriptors are present here */
#define MAX_RDESC_SIZE \
(sizeof(kbd_descriptor) + \
sizeof(mse_descriptor) + \
sizeof(mse_bluetooth_descriptor) + \
sizeof(consumer_descriptor) + \
sizeof(syscontrol_descriptor) + \
sizeof(media_descriptor) + \
......@@ -341,51 +525,160 @@ static const u8 hid_reportid_size_map[NUMBER_OF_HID_REPORTS] = {
static struct hid_ll_driver logi_dj_ll_driver;
static int logi_dj_recv_query_paired_devices(struct dj_receiver_dev *djrcv_dev);
static void delayedwork_callback(struct work_struct *work);
static LIST_HEAD(dj_hdev_list);
static DEFINE_MUTEX(dj_hdev_list_lock);
/*
* dj/HID++ receivers are really a single logical entity, but for BIOS/Windows
* compatibility they have multiple USB interfaces. On HID++ receivers we need
* to listen for input reports on both interfaces. The functions below are used
* to create a single struct dj_receiver_dev for all interfaces belonging to
* a single USB-device / receiver.
*/
static struct dj_receiver_dev *dj_find_receiver_dev(struct hid_device *hdev,
enum recvr_type type)
{
struct dj_receiver_dev *djrcv_dev;
char sep;
/*
* The bluetooth receiver contains a built-in hub and has separate
* USB-devices for the keyboard and mouse interfaces.
*/
sep = (type == recvr_type_bluetooth) ? '.' : '/';
/* Try to find an already-probed interface from the same device */
list_for_each_entry(djrcv_dev, &dj_hdev_list, list) {
if (djrcv_dev->mouse &&
hid_compare_device_paths(hdev, djrcv_dev->mouse, sep)) {
kref_get(&djrcv_dev->kref);
return djrcv_dev;
}
if (djrcv_dev->keyboard &&
hid_compare_device_paths(hdev, djrcv_dev->keyboard, sep)) {
kref_get(&djrcv_dev->kref);
return djrcv_dev;
}
if (djrcv_dev->hidpp &&
hid_compare_device_paths(hdev, djrcv_dev->hidpp, sep)) {
kref_get(&djrcv_dev->kref);
return djrcv_dev;
}
}
return NULL;
}
static void dj_release_receiver_dev(struct kref *kref)
{
struct dj_receiver_dev *djrcv_dev = container_of(kref, struct dj_receiver_dev, kref);
list_del(&djrcv_dev->list);
kfifo_free(&djrcv_dev->notif_fifo);
kfree(djrcv_dev);
}
static void dj_put_receiver_dev(struct hid_device *hdev)
{
struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
mutex_lock(&dj_hdev_list_lock);
if (djrcv_dev->mouse == hdev)
djrcv_dev->mouse = NULL;
if (djrcv_dev->keyboard == hdev)
djrcv_dev->keyboard = NULL;
if (djrcv_dev->hidpp == hdev)
djrcv_dev->hidpp = NULL;
kref_put(&djrcv_dev->kref, dj_release_receiver_dev);
mutex_unlock(&dj_hdev_list_lock);
}
static struct dj_receiver_dev *dj_get_receiver_dev(struct hid_device *hdev,
enum recvr_type type,
unsigned int application,
bool is_hidpp)
{
struct dj_receiver_dev *djrcv_dev;
mutex_lock(&dj_hdev_list_lock);
djrcv_dev = dj_find_receiver_dev(hdev, type);
if (!djrcv_dev) {
djrcv_dev = kzalloc(sizeof(*djrcv_dev), GFP_KERNEL);
if (!djrcv_dev)
goto out;
INIT_WORK(&djrcv_dev->work, delayedwork_callback);
spin_lock_init(&djrcv_dev->lock);
if (kfifo_alloc(&djrcv_dev->notif_fifo,
DJ_MAX_NUMBER_NOTIFS * sizeof(struct dj_workitem),
GFP_KERNEL)) {
kfree(djrcv_dev);
djrcv_dev = NULL;
goto out;
}
kref_init(&djrcv_dev->kref);
list_add_tail(&djrcv_dev->list, &dj_hdev_list);
djrcv_dev->last_query = jiffies;
djrcv_dev->type = type;
}
if (application == HID_GD_KEYBOARD)
djrcv_dev->keyboard = hdev;
if (application == HID_GD_MOUSE)
djrcv_dev->mouse = hdev;
if (is_hidpp)
djrcv_dev->hidpp = hdev;
hid_set_drvdata(hdev, djrcv_dev);
out:
mutex_unlock(&dj_hdev_list_lock);
return djrcv_dev;
}
static void logi_dj_recv_destroy_djhid_device(struct dj_receiver_dev *djrcv_dev,
struct dj_report *dj_report)
struct dj_workitem *workitem)
{
/* Called in delayed work context */
struct dj_device *dj_dev;
unsigned long flags;
spin_lock_irqsave(&djrcv_dev->lock, flags);
dj_dev = djrcv_dev->paired_dj_devices[dj_report->device_index];
djrcv_dev->paired_dj_devices[dj_report->device_index] = NULL;
dj_dev = djrcv_dev->paired_dj_devices[workitem->device_index];
djrcv_dev->paired_dj_devices[workitem->device_index] = NULL;
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
if (dj_dev != NULL) {
hid_destroy_device(dj_dev->hdev);
kfree(dj_dev);
} else {
dev_err(&djrcv_dev->hdev->dev, "%s: can't destroy a NULL device\n",
hid_err(djrcv_dev->hidpp, "%s: can't destroy a NULL device\n",
__func__);
}
}
static void logi_dj_recv_add_djhid_device(struct dj_receiver_dev *djrcv_dev,
struct dj_report *dj_report)
struct dj_workitem *workitem)
{
/* Called in delayed work context */
struct hid_device *djrcv_hdev = djrcv_dev->hdev;
struct usb_interface *intf = to_usb_interface(djrcv_hdev->dev.parent);
struct usb_device *usbdev = interface_to_usbdev(intf);
struct hid_device *djrcv_hdev = djrcv_dev->hidpp;
struct hid_device *dj_hiddev;
struct dj_device *dj_dev;
u8 device_index = workitem->device_index;
unsigned long flags;
/* Device index goes from 1 to 6, we need 3 bytes to store the
* semicolon, the index, and a null terminator
*/
unsigned char tmpstr[3];
if (dj_report->report_params[DEVICE_PAIRED_PARAM_SPFUNCTION] &
SPFUNCTION_DEVICE_LIST_EMPTY) {
dbg_hid("%s: device list is empty\n", __func__);
djrcv_dev->querying_devices = false;
return;
}
if (djrcv_dev->paired_dj_devices[dj_report->device_index]) {
/* We are the only one ever adding a device, no need to lock */
if (djrcv_dev->paired_dj_devices[device_index]) {
/* The device is already known. No need to reallocate it. */
dbg_hid("%s: device is already known\n", __func__);
return;
......@@ -393,8 +686,7 @@ static void logi_dj_recv_add_djhid_device(struct dj_receiver_dev *djrcv_dev,
dj_hiddev = hid_allocate_device();
if (IS_ERR(dj_hiddev)) {
dev_err(&djrcv_hdev->dev, "%s: hid_allocate_device failed\n",
__func__);
hid_err(djrcv_hdev, "%s: hid_allocate_dev failed\n", __func__);
return;
}
......@@ -402,48 +694,67 @@ static void logi_dj_recv_add_djhid_device(struct dj_receiver_dev *djrcv_dev,
dj_hiddev->dev.parent = &djrcv_hdev->dev;
dj_hiddev->bus = BUS_USB;
dj_hiddev->vendor = le16_to_cpu(usbdev->descriptor.idVendor);
dj_hiddev->product =
(dj_report->report_params[DEVICE_PAIRED_PARAM_EQUAD_ID_MSB]
<< 8) |
dj_report->report_params[DEVICE_PAIRED_PARAM_EQUAD_ID_LSB];
dj_hiddev->vendor = djrcv_hdev->vendor;
dj_hiddev->product = (workitem->quad_id_msb << 8) |
workitem->quad_id_lsb;
if (workitem->device_type) {
const char *type_str = "Device";
switch (workitem->device_type) {
case 0x01: type_str = "Keyboard"; break;
case 0x02: type_str = "Mouse"; break;
case 0x03: type_str = "Numpad"; break;
case 0x04: type_str = "Presenter"; break;
case 0x07: type_str = "Remote Control"; break;
case 0x08: type_str = "Trackball"; break;
case 0x09: type_str = "Touchpad"; break;
}
snprintf(dj_hiddev->name, sizeof(dj_hiddev->name),
"Logitech Wireless %s PID:%04x",
type_str, dj_hiddev->product);
} else {
snprintf(dj_hiddev->name, sizeof(dj_hiddev->name),
"Logitech Unifying Device. Wireless PID:%04x",
dj_hiddev->product);
}
if (djrcv_dev->type == recvr_type_27mhz)
dj_hiddev->group = HID_GROUP_LOGITECH_27MHZ_DEVICE;
else
dj_hiddev->group = HID_GROUP_LOGITECH_DJ_DEVICE;
usb_make_path(usbdev, dj_hiddev->phys, sizeof(dj_hiddev->phys));
snprintf(tmpstr, sizeof(tmpstr), ":%d", dj_report->device_index);
memcpy(dj_hiddev->phys, djrcv_hdev->phys, sizeof(djrcv_hdev->phys));
snprintf(tmpstr, sizeof(tmpstr), ":%d", device_index);
strlcat(dj_hiddev->phys, tmpstr, sizeof(dj_hiddev->phys));
dj_dev = kzalloc(sizeof(struct dj_device), GFP_KERNEL);
if (!dj_dev) {
dev_err(&djrcv_hdev->dev, "%s: failed allocating dj_device\n",
__func__);
hid_err(djrcv_hdev, "%s: failed allocating dj_dev\n", __func__);
goto dj_device_allocate_fail;
}
dj_dev->reports_supported = get_unaligned_le32(
dj_report->report_params + DEVICE_PAIRED_RF_REPORT_TYPE);
dj_dev->reports_supported = workitem->reports_supported;
dj_dev->hdev = dj_hiddev;
dj_dev->dj_receiver_dev = djrcv_dev;
dj_dev->device_index = dj_report->device_index;
dj_dev->device_index = device_index;
dj_hiddev->driver_data = dj_dev;
djrcv_dev->paired_dj_devices[dj_report->device_index] = dj_dev;
spin_lock_irqsave(&djrcv_dev->lock, flags);
djrcv_dev->paired_dj_devices[device_index] = dj_dev;
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
if (hid_add_device(dj_hiddev)) {
dev_err(&djrcv_hdev->dev, "%s: failed adding dj_device\n",
__func__);
hid_err(djrcv_hdev, "%s: failed adding dj_device\n", __func__);
goto hid_add_device_fail;
}
return;
hid_add_device_fail:
djrcv_dev->paired_dj_devices[dj_report->device_index] = NULL;
spin_lock_irqsave(&djrcv_dev->lock, flags);
djrcv_dev->paired_dj_devices[device_index] = NULL;
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
kfree(dj_dev);
dj_device_allocate_fail:
hid_destroy_device(dj_hiddev);
......@@ -454,7 +765,7 @@ static void delayedwork_callback(struct work_struct *work)
struct dj_receiver_dev *djrcv_dev =
container_of(work, struct dj_receiver_dev, work);
struct dj_report dj_report;
struct dj_workitem workitem;
unsigned long flags;
int count;
int retval;
......@@ -463,67 +774,229 @@ static void delayedwork_callback(struct work_struct *work)
spin_lock_irqsave(&djrcv_dev->lock, flags);
count = kfifo_out(&djrcv_dev->notif_fifo, &dj_report,
sizeof(struct dj_report));
/*
* Since we attach to multiple interfaces, we may get scheduled before
* we are bound to the HID++ interface, catch this.
*/
if (!djrcv_dev->ready) {
pr_warn("%s: delayedwork queued before hidpp interface was enumerated\n",
__func__);
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
return;
}
count = kfifo_out(&djrcv_dev->notif_fifo, &workitem, sizeof(workitem));
if (count != sizeof(struct dj_report)) {
dev_err(&djrcv_dev->hdev->dev, "%s: workitem triggered without "
"notifications available\n", __func__);
if (count != sizeof(workitem)) {
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
return;
}
if (!kfifo_is_empty(&djrcv_dev->notif_fifo)) {
if (schedule_work(&djrcv_dev->work) == 0) {
dbg_hid("%s: did not schedule the work item, was "
"already queued\n", __func__);
if (!kfifo_is_empty(&djrcv_dev->notif_fifo))
schedule_work(&djrcv_dev->work);
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
switch (workitem.type) {
case WORKITEM_TYPE_PAIRED:
logi_dj_recv_add_djhid_device(djrcv_dev, &workitem);
break;
case WORKITEM_TYPE_UNPAIRED:
logi_dj_recv_destroy_djhid_device(djrcv_dev, &workitem);
break;
case WORKITEM_TYPE_UNKNOWN:
retval = logi_dj_recv_query_paired_devices(djrcv_dev);
if (retval) {
hid_err(djrcv_dev->hidpp, "%s: logi_dj_recv_query_paired_devices error: %d\n",
__func__, retval);
}
break;
case WORKITEM_TYPE_EMPTY:
dbg_hid("%s: device list is empty\n", __func__);
break;
}
}
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
/*
* Sometimes we receive reports for which we do not have a paired dj_device
* associated with the device_index or report-type to forward the report to.
* This means that the original "device paired" notification corresponding
* to the dj_device never arrived to this driver. Possible reasons for this are:
* 1) hid-core discards all packets coming from a device during probe().
* 2) if the receiver is plugged into a KVM switch then the pairing reports
* are only forwarded to it if the focus is on this PC.
* This function deals with this by re-asking the receiver for the list of
* connected devices in the delayed work callback.
* This function MUST be called with djrcv->lock held.
*/
static void logi_dj_recv_queue_unknown_work(struct dj_receiver_dev *djrcv_dev)
{
struct dj_workitem workitem = { .type = WORKITEM_TYPE_UNKNOWN };
/* Rate limit queries done because of unhandeled reports to 2/sec */
if (time_before(jiffies, djrcv_dev->last_query + HZ / 2))
return;
kfifo_in(&djrcv_dev->notif_fifo, &workitem, sizeof(workitem));
schedule_work(&djrcv_dev->work);
}
static void logi_dj_recv_queue_notification(struct dj_receiver_dev *djrcv_dev,
struct dj_report *dj_report)
{
/* We are called from atomic context (tasklet && djrcv->lock held) */
struct dj_workitem workitem = {
.device_index = dj_report->device_index,
};
switch (dj_report.report_type) {
switch (dj_report->report_type) {
case REPORT_TYPE_NOTIF_DEVICE_PAIRED:
logi_dj_recv_add_djhid_device(djrcv_dev, &dj_report);
workitem.type = WORKITEM_TYPE_PAIRED;
if (dj_report->report_params[DEVICE_PAIRED_PARAM_SPFUNCTION] &
SPFUNCTION_DEVICE_LIST_EMPTY) {
workitem.type = WORKITEM_TYPE_EMPTY;
break;
}
/* fall-through */
case REPORT_TYPE_NOTIF_DEVICE_UNPAIRED:
logi_dj_recv_destroy_djhid_device(djrcv_dev, &dj_report);
workitem.quad_id_msb =
dj_report->report_params[DEVICE_PAIRED_PARAM_EQUAD_ID_MSB];
workitem.quad_id_lsb =
dj_report->report_params[DEVICE_PAIRED_PARAM_EQUAD_ID_LSB];
workitem.reports_supported = get_unaligned_le32(
dj_report->report_params +
DEVICE_PAIRED_RF_REPORT_TYPE);
workitem.reports_supported |= HIDPP;
if (dj_report->report_type == REPORT_TYPE_NOTIF_DEVICE_UNPAIRED)
workitem.type = WORKITEM_TYPE_UNPAIRED;
break;
default:
/* A normal report (i. e. not belonging to a pair/unpair notification)
* arriving here, means that the report arrived but we did not have a
* paired dj_device associated to the report's device_index, this
* means that the original "device paired" notification corresponding
* to this dj_device never arrived to this driver. The reason is that
* hid-core discards all packets coming from a device while probe() is
* executing. */
if (!djrcv_dev->paired_dj_devices[dj_report.device_index]) {
/* ok, we don't know the device, just re-ask the
* receiver for the list of connected devices. */
retval = logi_dj_recv_query_paired_devices(djrcv_dev);
if (!retval) {
/* everything went fine, so just leave */
break;
logi_dj_recv_queue_unknown_work(djrcv_dev);
return;
}
dev_err(&djrcv_dev->hdev->dev,
"%s:logi_dj_recv_query_paired_devices "
"error:%d\n", __func__, retval);
kfifo_in(&djrcv_dev->notif_fifo, &workitem, sizeof(workitem));
schedule_work(&djrcv_dev->work);
}
static void logi_hidpp_dev_conn_notif_equad(struct hidpp_event *hidpp_report,
struct dj_workitem *workitem)
{
workitem->type = WORKITEM_TYPE_PAIRED;
workitem->device_type = hidpp_report->params[HIDPP_PARAM_DEVICE_INFO] &
HIDPP_DEVICE_TYPE_MASK;
workitem->quad_id_msb = hidpp_report->params[HIDPP_PARAM_EQUAD_MSB];
workitem->quad_id_lsb = hidpp_report->params[HIDPP_PARAM_EQUAD_LSB];
switch (workitem->device_type) {
case REPORT_TYPE_KEYBOARD:
workitem->reports_supported |= STD_KEYBOARD | MULTIMEDIA |
POWER_KEYS | MEDIA_CENTER |
HIDPP;
break;
case REPORT_TYPE_MOUSE:
workitem->reports_supported |= STD_MOUSE | HIDPP;
break;
}
dbg_hid("%s: unexpected report type\n", __func__);
}
static void logi_hidpp_dev_conn_notif_27mhz(struct hid_device *hdev,
struct hidpp_event *hidpp_report,
struct dj_workitem *workitem)
{
workitem->type = WORKITEM_TYPE_PAIRED;
workitem->quad_id_lsb = hidpp_report->params[HIDPP_PARAM_27MHZ_DEVID];
switch (hidpp_report->device_index) {
case 1: /* Index 1 is always a mouse */
case 2: /* Index 2 is always a mouse */
workitem->device_type = HIDPP_DEVICE_TYPE_MOUSE;
workitem->reports_supported |= STD_MOUSE | HIDPP;
break;
case 3: /* Index 3 is always the keyboard */
case 4: /* Index 4 is used for an optional separate numpad */
workitem->device_type = HIDPP_DEVICE_TYPE_KEYBOARD;
workitem->reports_supported |= STD_KEYBOARD | MULTIMEDIA |
POWER_KEYS | HIDPP;
break;
default:
hid_warn(hdev, "%s: unexpected device-index %d", __func__,
hidpp_report->device_index);
}
}
static void logi_dj_recv_queue_notification(struct dj_receiver_dev *djrcv_dev,
struct dj_report *dj_report)
static void logi_hidpp_recv_queue_notif(struct hid_device *hdev,
struct hidpp_event *hidpp_report)
{
/* We are called from atomic context (tasklet && djrcv->lock held) */
struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
const char *device_type = "UNKNOWN";
struct dj_workitem workitem = {
.type = WORKITEM_TYPE_EMPTY,
.device_index = hidpp_report->device_index,
};
switch (hidpp_report->params[HIDPP_PARAM_PROTO_TYPE]) {
case 0x01:
device_type = "Bluetooth";
/* Bluetooth connect packet contents is the same as (e)QUAD */
logi_hidpp_dev_conn_notif_equad(hidpp_report, &workitem);
if (!(hidpp_report->params[HIDPP_PARAM_DEVICE_INFO] &
HIDPP_MANUFACTURER_MASK)) {
hid_info(hdev, "Non Logitech device connected on slot %d\n",
hidpp_report->device_index);
workitem.reports_supported &= ~HIDPP;
}
break;
case 0x02:
device_type = "27 Mhz";
logi_hidpp_dev_conn_notif_27mhz(hdev, hidpp_report, &workitem);
break;
case 0x03:
device_type = "QUAD or eQUAD";
logi_hidpp_dev_conn_notif_equad(hidpp_report, &workitem);
break;
case 0x04:
device_type = "eQUAD step 4 DJ";
logi_hidpp_dev_conn_notif_equad(hidpp_report, &workitem);
break;
case 0x05:
device_type = "DFU Lite";
break;
case 0x06:
device_type = "eQUAD step 4 Lite";
logi_hidpp_dev_conn_notif_equad(hidpp_report, &workitem);
break;
case 0x07:
device_type = "eQUAD step 4 Gaming";
break;
case 0x08:
device_type = "eQUAD step 4 for gamepads";
break;
case 0x0a:
device_type = "eQUAD nano Lite";
logi_hidpp_dev_conn_notif_equad(hidpp_report, &workitem);
break;
case 0x0c:
device_type = "eQUAD Lightspeed";
logi_hidpp_dev_conn_notif_equad(hidpp_report, &workitem);
workitem.reports_supported |= STD_KEYBOARD;
break;
}
kfifo_in(&djrcv_dev->notif_fifo, dj_report, sizeof(struct dj_report));
if (schedule_work(&djrcv_dev->work) == 0) {
dbg_hid("%s: did not schedule the work item, was already "
"queued\n", __func__);
if (workitem.type == WORKITEM_TYPE_EMPTY) {
hid_warn(hdev,
"unusable device of type %s (0x%02x) connected on slot %d",
device_type,
hidpp_report->params[HIDPP_PARAM_PROTO_TYPE],
hidpp_report->device_index);
return;
}
hid_info(hdev, "device of type %s (0x%02x) connected on slot %d",
device_type, hidpp_report->params[HIDPP_PARAM_PROTO_TYPE],
hidpp_report->device_index);
kfifo_in(&djrcv_dev->notif_fifo, &workitem, sizeof(workitem));
schedule_work(&djrcv_dev->work);
}
static void logi_dj_recv_forward_null_report(struct dj_receiver_dev *djrcv_dev,
......@@ -552,7 +1025,7 @@ static void logi_dj_recv_forward_null_report(struct dj_receiver_dev *djrcv_dev,
}
}
static void logi_dj_recv_forward_report(struct dj_receiver_dev *djrcv_dev,
static void logi_dj_recv_forward_dj(struct dj_receiver_dev *djrcv_dev,
struct dj_report *dj_report)
{
/* We are called from atomic context (tasklet && djrcv->lock held) */
......@@ -573,7 +1046,7 @@ static void logi_dj_recv_forward_report(struct dj_receiver_dev *djrcv_dev,
}
}
static void logi_dj_recv_forward_hidpp(struct dj_device *dj_dev, u8 *data,
static void logi_dj_recv_forward_report(struct dj_device *dj_dev, u8 *data,
int size)
{
/* We are called from atomic context (tasklet && djrcv->lock held) */
......@@ -581,10 +1054,40 @@ static void logi_dj_recv_forward_hidpp(struct dj_device *dj_dev, u8 *data,
dbg_hid("hid_input_report error\n");
}
static void logi_dj_recv_forward_input_report(struct hid_device *hdev,
u8 *data, int size)
{
struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
struct dj_device *dj_dev;
unsigned long flags;
u8 report = data[0];
int i;
if (report > REPORT_TYPE_RFREPORT_LAST) {
hid_err(hdev, "Unexpected input report number %d\n", report);
return;
}
spin_lock_irqsave(&djrcv_dev->lock, flags);
for (i = 0; i < (DJ_MAX_PAIRED_DEVICES + DJ_DEVICE_INDEX_MIN); i++) {
dj_dev = djrcv_dev->paired_dj_devices[i];
if (dj_dev && (dj_dev->reports_supported & BIT(report))) {
logi_dj_recv_forward_report(dj_dev, data, size);
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
return;
}
}
logi_dj_recv_queue_unknown_work(djrcv_dev);
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
dbg_hid("No dj-devs handling input report number %d\n", report);
}
static int logi_dj_recv_send_report(struct dj_receiver_dev *djrcv_dev,
struct dj_report *dj_report)
{
struct hid_device *hdev = djrcv_dev->hdev;
struct hid_device *hdev = djrcv_dev->hidpp;
struct hid_report *report;
struct hid_report_enum *output_report_enum;
u8 *data = (u8 *)(&dj_report->device_index);
......@@ -594,7 +1097,7 @@ static int logi_dj_recv_send_report(struct dj_receiver_dev *djrcv_dev,
report = output_report_enum->report_id_hash[REPORT_ID_DJ_SHORT];
if (!report) {
dev_err(&hdev->dev, "%s: unable to find dj report\n", __func__);
hid_err(hdev, "%s: unable to find dj report\n", __func__);
return -ENODEV;
}
......@@ -606,14 +1109,40 @@ static int logi_dj_recv_send_report(struct dj_receiver_dev *djrcv_dev,
return 0;
}
static int logi_dj_recv_query_hidpp_devices(struct dj_receiver_dev *djrcv_dev)
{
const u8 template[] = {REPORT_ID_HIDPP_SHORT,
HIDPP_RECEIVER_INDEX,
HIDPP_SET_REGISTER,
HIDPP_REG_CONNECTION_STATE,
HIDPP_FAKE_DEVICE_ARRIVAL,
0x00, 0x00};
u8 *hidpp_report;
int retval;
hidpp_report = kmemdup(template, sizeof(template), GFP_KERNEL);
if (!hidpp_report)
return -ENOMEM;
retval = hid_hw_raw_request(djrcv_dev->hidpp,
REPORT_ID_HIDPP_SHORT,
hidpp_report, sizeof(template),
HID_OUTPUT_REPORT,
HID_REQ_SET_REPORT);
kfree(hidpp_report);
return 0;
}
static int logi_dj_recv_query_paired_devices(struct dj_receiver_dev *djrcv_dev)
{
struct dj_report *dj_report;
int retval;
/* no need to protect djrcv_dev->querying_devices */
if (djrcv_dev->querying_devices)
return 0;
djrcv_dev->last_query = jiffies;
if (djrcv_dev->type != recvr_type_dj)
return logi_dj_recv_query_hidpp_devices(djrcv_dev);
dj_report = kzalloc(sizeof(struct dj_report), GFP_KERNEL);
if (!dj_report)
......@@ -630,27 +1159,33 @@ static int logi_dj_recv_query_paired_devices(struct dj_receiver_dev *djrcv_dev)
static int logi_dj_recv_switch_to_dj_mode(struct dj_receiver_dev *djrcv_dev,
unsigned timeout)
{
struct hid_device *hdev = djrcv_dev->hdev;
struct hid_device *hdev = djrcv_dev->hidpp;
struct dj_report *dj_report;
u8 *buf;
int retval;
int retval = 0;
dj_report = kzalloc(sizeof(struct dj_report), GFP_KERNEL);
if (!dj_report)
return -ENOMEM;
if (djrcv_dev->type == recvr_type_dj) {
dj_report->report_id = REPORT_ID_DJ_SHORT;
dj_report->device_index = 0xFF;
dj_report->report_type = REPORT_TYPE_CMD_SWITCH;
dj_report->report_params[CMD_SWITCH_PARAM_DEVBITFIELD] = 0x3F;
dj_report->report_params[CMD_SWITCH_PARAM_TIMEOUT_SECONDS] = (u8)timeout;
dj_report->report_params[CMD_SWITCH_PARAM_TIMEOUT_SECONDS] =
(u8)timeout;
retval = logi_dj_recv_send_report(djrcv_dev, dj_report);
/*
* Ugly sleep to work around a USB 3.0 bug when the receiver is still
* processing the "switch-to-dj" command while we send an other command.
* Ugly sleep to work around a USB 3.0 bug when the receiver is
* still processing the "switch-to-dj" command while we send an
* other command.
* 50 msec should gives enough time to the receiver to be ready.
*/
msleep(50);
}
/*
* Magical bits to set up hidpp notifications when the dj devices
......@@ -682,22 +1217,28 @@ static int logi_dj_recv_switch_to_dj_mode(struct dj_receiver_dev *djrcv_dev,
static int logi_dj_ll_open(struct hid_device *hid)
{
dbg_hid("%s:%s\n", __func__, hid->phys);
dbg_hid("%s: %s\n", __func__, hid->phys);
return 0;
}
static void logi_dj_ll_close(struct hid_device *hid)
{
dbg_hid("%s:%s\n", __func__, hid->phys);
dbg_hid("%s: %s\n", __func__, hid->phys);
}
/*
* Register 0xB5 is "pairing information". It is solely intended for the
* receiver, so do not overwrite the device index.
*/
static u8 unifying_pairing_query[] = {0x10, 0xff, 0x83, 0xb5};
static u8 unifying_pairing_answer[] = {0x11, 0xff, 0x83, 0xb5};
static u8 unifying_pairing_query[] = { REPORT_ID_HIDPP_SHORT,
HIDPP_RECEIVER_INDEX,
HIDPP_GET_LONG_REGISTER,
HIDPP_REG_PAIRING_INFORMATION };
static u8 unifying_pairing_answer[] = { REPORT_ID_HIDPP_LONG,
HIDPP_RECEIVER_INDEX,
HIDPP_GET_LONG_REGISTER,
HIDPP_REG_PAIRING_INFORMATION };
static int logi_dj_ll_raw_request(struct hid_device *hid,
unsigned char reportnum, __u8 *buf,
......@@ -721,13 +1262,23 @@ static int logi_dj_ll_raw_request(struct hid_device *hid,
buf[4] = (buf[4] & 0xf0) | (djdev->device_index - 1);
else
buf[1] = djdev->device_index;
return hid_hw_raw_request(djrcv_dev->hdev, reportnum, buf,
return hid_hw_raw_request(djrcv_dev->hidpp, reportnum, buf,
count, report_type, reqtype);
}
if (buf[0] != REPORT_TYPE_LEDS)
return -EINVAL;
if (djrcv_dev->type != recvr_type_dj && count >= 2) {
if (!djrcv_dev->keyboard) {
hid_warn(hid, "Received REPORT_TYPE_LEDS request before the keyboard interface was enumerated\n");
return 0;
}
/* usbhid overrides the report ID and ignores the first byte */
return hid_hw_raw_request(djrcv_dev->keyboard, 0, buf, count,
report_type, reqtype);
}
out_buf = kzalloc(DJREPORT_SHORT_LENGTH, GFP_ATOMIC);
if (!out_buf)
return -ENOMEM;
......@@ -739,7 +1290,7 @@ static int logi_dj_ll_raw_request(struct hid_device *hid,
out_buf[1] = djdev->device_index;
memcpy(out_buf + 2, buf, count);
ret = hid_hw_raw_request(djrcv_dev->hdev, out_buf[0], out_buf,
ret = hid_hw_raw_request(djrcv_dev->hidpp, out_buf[0], out_buf,
DJREPORT_SHORT_LENGTH, report_type, reqtype);
kfree(out_buf);
......@@ -769,41 +1320,55 @@ static int logi_dj_ll_parse(struct hid_device *hid)
return -ENOMEM;
if (djdev->reports_supported & STD_KEYBOARD) {
dbg_hid("%s: sending a kbd descriptor, reports_supported: %x\n",
dbg_hid("%s: sending a kbd descriptor, reports_supported: %llx\n",
__func__, djdev->reports_supported);
rdcat(rdesc, &rsize, kbd_descriptor, sizeof(kbd_descriptor));
}
if (djdev->reports_supported & STD_MOUSE) {
dbg_hid("%s: sending a mouse descriptor, reports_supported: "
"%x\n", __func__, djdev->reports_supported);
rdcat(rdesc, &rsize, mse_descriptor, sizeof(mse_descriptor));
dbg_hid("%s: sending a mouse descriptor, reports_supported: %llx\n",
__func__, djdev->reports_supported);
if (djdev->dj_receiver_dev->type == recvr_type_gaming_hidpp)
rdcat(rdesc, &rsize, mse_high_res_descriptor,
sizeof(mse_high_res_descriptor));
else if (djdev->dj_receiver_dev->type == recvr_type_27mhz)
rdcat(rdesc, &rsize, mse_27mhz_descriptor,
sizeof(mse_27mhz_descriptor));
else if (djdev->dj_receiver_dev->type == recvr_type_bluetooth)
rdcat(rdesc, &rsize, mse_bluetooth_descriptor,
sizeof(mse_bluetooth_descriptor));
else
rdcat(rdesc, &rsize, mse_descriptor,
sizeof(mse_descriptor));
}
if (djdev->reports_supported & MULTIMEDIA) {
dbg_hid("%s: sending a multimedia report descriptor: %x\n",
dbg_hid("%s: sending a multimedia report descriptor: %llx\n",
__func__, djdev->reports_supported);
rdcat(rdesc, &rsize, consumer_descriptor, sizeof(consumer_descriptor));
}
if (djdev->reports_supported & POWER_KEYS) {
dbg_hid("%s: sending a power keys report descriptor: %x\n",
dbg_hid("%s: sending a power keys report descriptor: %llx\n",
__func__, djdev->reports_supported);
rdcat(rdesc, &rsize, syscontrol_descriptor, sizeof(syscontrol_descriptor));
}
if (djdev->reports_supported & MEDIA_CENTER) {
dbg_hid("%s: sending a media center report descriptor: %x\n",
dbg_hid("%s: sending a media center report descriptor: %llx\n",
__func__, djdev->reports_supported);
rdcat(rdesc, &rsize, media_descriptor, sizeof(media_descriptor));
}
if (djdev->reports_supported & KBD_LEDS) {
dbg_hid("%s: need to send kbd leds report descriptor: %x\n",
dbg_hid("%s: need to send kbd leds report descriptor: %llx\n",
__func__, djdev->reports_supported);
}
rdcat(rdesc, &rsize, hidpp_descriptor, sizeof(hidpp_descriptor));
if (djdev->reports_supported & HIDPP) {
rdcat(rdesc, &rsize, hidpp_descriptor,
sizeof(hidpp_descriptor));
}
retval = hid_parse_report(hid, rdesc, rsize);
kfree(rdesc);
......@@ -866,7 +1431,7 @@ static int logi_dj_dj_event(struct hid_device *hdev,
* so ignore those reports too.
*/
if (dj_report->device_index != DJ_RECEIVER_INDEX)
dev_err(&hdev->dev, "%s: invalid device index:%d\n",
hid_err(hdev, "%s: invalid device index:%d\n",
__func__, dj_report->device_index);
return false;
}
......@@ -893,7 +1458,7 @@ static int logi_dj_dj_event(struct hid_device *hdev,
}
break;
default:
logi_dj_recv_forward_report(djrcv_dev, dj_report);
logi_dj_recv_forward_dj(djrcv_dev, dj_report);
}
out:
......@@ -907,9 +1472,10 @@ static int logi_dj_hidpp_event(struct hid_device *hdev,
int size)
{
struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
struct dj_report *dj_report = (struct dj_report *) data;
struct hidpp_event *hidpp_report = (struct hidpp_event *) data;
struct dj_device *dj_dev;
unsigned long flags;
u8 device_index = dj_report->device_index;
u8 device_index = hidpp_report->device_index;
if (device_index == HIDPP_RECEIVER_INDEX) {
/* special case were the device wants to know its unifying
......@@ -937,21 +1503,42 @@ static int logi_dj_hidpp_event(struct hid_device *hdev,
* This driver can ignore safely the receiver notifications,
* so ignore those reports too.
*/
dev_err(&hdev->dev, "%s: invalid device index:%d\n",
__func__, dj_report->device_index);
hid_err(hdev, "%s: invalid device index:%d\n", __func__,
hidpp_report->device_index);
return false;
}
spin_lock_irqsave(&djrcv_dev->lock, flags);
if (!djrcv_dev->paired_dj_devices[device_index])
/* received an event for an unknown device, bail out */
goto out;
dj_dev = djrcv_dev->paired_dj_devices[device_index];
logi_dj_recv_forward_hidpp(djrcv_dev->paired_dj_devices[device_index],
data, size);
/*
* With 27 MHz receivers, we do not get an explicit unpair event,
* remove the old device if the user has paired a *different* device.
*/
if (djrcv_dev->type == recvr_type_27mhz && dj_dev &&
hidpp_report->sub_id == REPORT_TYPE_NOTIF_DEVICE_CONNECTED &&
hidpp_report->params[HIDPP_PARAM_PROTO_TYPE] == 0x02 &&
hidpp_report->params[HIDPP_PARAM_27MHZ_DEVID] !=
dj_dev->hdev->product) {
struct dj_workitem workitem = {
.device_index = hidpp_report->device_index,
.type = WORKITEM_TYPE_UNPAIRED,
};
kfifo_in(&djrcv_dev->notif_fifo, &workitem, sizeof(workitem));
/* logi_hidpp_recv_queue_notif will queue the work */
dj_dev = NULL;
}
if (dj_dev) {
logi_dj_recv_forward_report(dj_dev, data, size);
} else {
if (hidpp_report->sub_id == REPORT_TYPE_NOTIF_DEVICE_CONNECTED)
logi_hidpp_recv_queue_notif(hdev, hidpp_report);
else
logi_dj_recv_queue_unknown_work(djrcv_dev);
}
out:
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
return false;
......@@ -961,112 +1548,176 @@ static int logi_dj_raw_event(struct hid_device *hdev,
struct hid_report *report, u8 *data,
int size)
{
struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
dbg_hid("%s, size:%d\n", __func__, size);
if (!djrcv_dev)
return 0;
if (!hdev->report_enum[HID_INPUT_REPORT].numbered) {
if (djrcv_dev->unnumbered_application == HID_GD_KEYBOARD) {
/*
* For the keyboard, we can reuse the same report by
* using the second byte which is constant in the USB
* HID report descriptor.
*/
data[1] = data[0];
data[0] = REPORT_TYPE_KEYBOARD;
logi_dj_recv_forward_input_report(hdev, data, size);
/* restore previous state */
data[0] = data[1];
data[1] = 0;
}
/* The 27 MHz mouse-only receiver sends unnumbered mouse data */
if (djrcv_dev->unnumbered_application == HID_GD_MOUSE &&
size == 6) {
u8 mouse_report[7];
/* Prepend report id */
mouse_report[0] = REPORT_TYPE_MOUSE;
memcpy(mouse_report + 1, data, 6);
logi_dj_recv_forward_input_report(hdev, mouse_report, 7);
}
return false;
}
switch (data[0]) {
case REPORT_ID_DJ_SHORT:
if (size != DJREPORT_SHORT_LENGTH) {
dev_err(&hdev->dev, "DJ report of bad size (%d)", size);
hid_err(hdev, "Short DJ report bad size (%d)", size);
return false;
}
return logi_dj_dj_event(hdev, report, data, size);
case REPORT_ID_DJ_LONG:
if (size != DJREPORT_LONG_LENGTH) {
hid_err(hdev, "Long DJ report bad size (%d)", size);
return false;
}
return logi_dj_dj_event(hdev, report, data, size);
case REPORT_ID_HIDPP_SHORT:
if (size != HIDPP_REPORT_SHORT_LENGTH) {
dev_err(&hdev->dev,
"Short HID++ report of bad size (%d)", size);
hid_err(hdev, "Short HID++ report bad size (%d)", size);
return false;
}
return logi_dj_hidpp_event(hdev, report, data, size);
case REPORT_ID_HIDPP_LONG:
if (size != HIDPP_REPORT_LONG_LENGTH) {
dev_err(&hdev->dev,
"Long HID++ report of bad size (%d)", size);
hid_err(hdev, "Long HID++ report bad size (%d)", size);
return false;
}
return logi_dj_hidpp_event(hdev, report, data, size);
}
logi_dj_recv_forward_input_report(hdev, data, size);
return false;
}
static int logi_dj_probe(struct hid_device *hdev,
const struct hid_device_id *id)
{
struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
struct hid_report_enum *rep_enum;
struct hid_report *rep;
struct dj_receiver_dev *djrcv_dev;
struct usb_interface *intf;
unsigned int no_dj_interfaces = 0;
bool has_hidpp = false;
unsigned long flags;
int retval;
dbg_hid("%s called for ifnum %d\n", __func__,
intf->cur_altsetting->desc.bInterfaceNumber);
/*
* Call to usbhid to fetch the HID descriptors of the current
* interface subsequently call to the hid/hid-core to parse the
* fetched descriptors.
*/
retval = hid_parse(hdev);
if (retval) {
hid_err(hdev, "%s: parse failed\n", __func__);
return retval;
}
/* Ignore interfaces 0 and 1, they will not carry any data, dont create
* any hid_device for them */
if (intf->cur_altsetting->desc.bInterfaceNumber !=
LOGITECH_DJ_INTERFACE_NUMBER) {
dbg_hid("%s: ignoring ifnum %d\n", __func__,
intf->cur_altsetting->desc.bInterfaceNumber);
/*
* Some KVMs add an extra interface for e.g. mouse emulation. If we
* treat these as logitech-dj interfaces then this causes input events
* reported through this extra interface to not be reported correctly.
* To avoid this, we treat these as generic-hid devices.
*/
switch (id->driver_data) {
case recvr_type_dj: no_dj_interfaces = 3; break;
case recvr_type_hidpp: no_dj_interfaces = 2; break;
case recvr_type_gaming_hidpp: no_dj_interfaces = 3; break;
case recvr_type_27mhz: no_dj_interfaces = 2; break;
case recvr_type_bluetooth: no_dj_interfaces = 2; break;
}
if (hid_is_using_ll_driver(hdev, &usb_hid_driver)) {
intf = to_usb_interface(hdev->dev.parent);
if (intf && intf->altsetting->desc.bInterfaceNumber >=
no_dj_interfaces) {
hdev->quirks |= HID_QUIRK_INPUT_PER_APP;
return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
}
}
rep_enum = &hdev->report_enum[HID_INPUT_REPORT];
/* no input reports, bail out */
if (list_empty(&rep_enum->report_list))
return -ENODEV;
/*
* Check for the HID++ application.
* Note: we should theoretically check for HID++ and DJ
* collections, but this will do.
*/
list_for_each_entry(rep, &rep_enum->report_list, list) {
if (rep->application == 0xff000001)
has_hidpp = true;
}
/* Treat interface 2 */
/*
* Ignore interfaces without DJ/HID++ collection, they will not carry
* any data, dont create any hid_device for them.
*/
if (!has_hidpp && id->driver_data == recvr_type_dj)
return -ENODEV;
djrcv_dev = kzalloc(sizeof(struct dj_receiver_dev), GFP_KERNEL);
/* get the current application attached to the node */
rep = list_first_entry(&rep_enum->report_list, struct hid_report, list);
djrcv_dev = dj_get_receiver_dev(hdev, id->driver_data,
rep->application, has_hidpp);
if (!djrcv_dev) {
dev_err(&hdev->dev,
"%s:failed allocating dj_receiver_dev\n", __func__);
hid_err(hdev, "%s: dj_get_receiver_dev failed\n", __func__);
return -ENOMEM;
}
djrcv_dev->hdev = hdev;
INIT_WORK(&djrcv_dev->work, delayedwork_callback);
spin_lock_init(&djrcv_dev->lock);
if (kfifo_alloc(&djrcv_dev->notif_fifo,
DJ_MAX_NUMBER_NOTIFICATIONS * sizeof(struct dj_report),
GFP_KERNEL)) {
dev_err(&hdev->dev,
"%s:failed allocating notif_fifo\n", __func__);
kfree(djrcv_dev);
return -ENOMEM;
}
hid_set_drvdata(hdev, djrcv_dev);
/* Call to usbhid to fetch the HID descriptors of interface 2 and
* subsequently call to the hid/hid-core to parse the fetched
* descriptors, this will in turn create the hidraw and hiddev nodes
* for interface 2 of the receiver */
retval = hid_parse(hdev);
if (retval) {
dev_err(&hdev->dev,
"%s:parse of interface 2 failed\n", __func__);
goto hid_parse_fail;
}
if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, REPORT_ID_DJ_SHORT,
0, DJREPORT_SHORT_LENGTH - 1)) {
retval = -ENODEV;
goto hid_parse_fail;
}
if (!rep_enum->numbered)
djrcv_dev->unnumbered_application = rep->application;
/* Starts the usb device and connects to upper interfaces hiddev and
* hidraw */
retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
retval = hid_hw_start(hdev, HID_CONNECT_HIDRAW|HID_CONNECT_HIDDEV);
if (retval) {
dev_err(&hdev->dev,
"%s:hid_hw_start returned error\n", __func__);
hid_err(hdev, "%s: hid_hw_start returned error\n", __func__);
goto hid_hw_start_fail;
}
if (has_hidpp) {
retval = logi_dj_recv_switch_to_dj_mode(djrcv_dev, 0);
if (retval < 0) {
dev_err(&hdev->dev,
"%s:logi_dj_recv_switch_to_dj_mode returned error:%d\n",
hid_err(hdev, "%s: logi_dj_recv_switch_to_dj_mode returned error:%d\n",
__func__, retval);
goto switch_to_dj_mode_fail;
}
}
/* This is enabling the polling urb on the IN endpoint */
retval = hid_hw_open(hdev);
if (retval < 0) {
dev_err(&hdev->dev, "%s:hid_hw_open returned error:%d\n",
hid_err(hdev, "%s: hid_hw_open returned error:%d\n",
__func__, retval);
goto llopen_failed;
}
......@@ -1074,12 +1725,17 @@ static int logi_dj_probe(struct hid_device *hdev,
/* Allow incoming packets to arrive: */
hid_device_io_start(hdev);
if (has_hidpp) {
spin_lock_irqsave(&djrcv_dev->lock, flags);
djrcv_dev->ready = true;
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
retval = logi_dj_recv_query_paired_devices(djrcv_dev);
if (retval < 0) {
dev_err(&hdev->dev, "%s:logi_dj_recv_query_paired_devices "
"error:%d\n", __func__, retval);
hid_err(hdev, "%s: logi_dj_recv_query_paired_devices error:%d\n",
__func__, retval);
goto logi_dj_recv_query_paired_devices_failed;
}
}
return retval;
......@@ -1091,12 +1747,8 @@ static int logi_dj_probe(struct hid_device *hdev,
hid_hw_stop(hdev);
hid_hw_start_fail:
hid_parse_fail:
kfifo_free(&djrcv_dev->notif_fifo);
kfree(djrcv_dev);
hid_set_drvdata(hdev, NULL);
dj_put_receiver_dev(hdev);
return retval;
}
#ifdef CONFIG_PM
......@@ -1105,10 +1757,12 @@ static int logi_dj_reset_resume(struct hid_device *hdev)
int retval;
struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
if (!djrcv_dev || djrcv_dev->hidpp != hdev)
return 0;
retval = logi_dj_recv_switch_to_dj_mode(djrcv_dev, 0);
if (retval < 0) {
dev_err(&hdev->dev,
"%s:logi_dj_recv_switch_to_dj_mode returned error:%d\n",
hid_err(hdev, "%s: logi_dj_recv_switch_to_dj_mode returned error:%d\n",
__func__, retval);
}
......@@ -1120,39 +1774,83 @@ static void logi_dj_remove(struct hid_device *hdev)
{
struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
struct dj_device *dj_dev;
unsigned long flags;
int i;
dbg_hid("%s\n", __func__);
if (!djrcv_dev)
return hid_hw_stop(hdev);
/*
* This ensures that if the work gets requeued from another
* interface of the same receiver it will be a no-op.
*/
spin_lock_irqsave(&djrcv_dev->lock, flags);
djrcv_dev->ready = false;
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
cancel_work_sync(&djrcv_dev->work);
hid_hw_close(hdev);
hid_hw_stop(hdev);
/* I suppose that at this point the only context that can access
* the djrecv_data is this thread as the work item is guaranteed to
* have finished and no more raw_event callbacks should arrive after
* the remove callback was triggered so no locks are put around the
* code below */
/*
* For proper operation we need access to all interfaces, so we destroy
* the paired devices when we're unbound from any interface.
*
* Note we may still be bound to other interfaces, sharing the same
* djrcv_dev, so we need locking here.
*/
for (i = 0; i < (DJ_MAX_PAIRED_DEVICES + DJ_DEVICE_INDEX_MIN); i++) {
spin_lock_irqsave(&djrcv_dev->lock, flags);
dj_dev = djrcv_dev->paired_dj_devices[i];
djrcv_dev->paired_dj_devices[i] = NULL;
spin_unlock_irqrestore(&djrcv_dev->lock, flags);
if (dj_dev != NULL) {
hid_destroy_device(dj_dev->hdev);
kfree(dj_dev);
djrcv_dev->paired_dj_devices[i] = NULL;
}
}
kfifo_free(&djrcv_dev->notif_fifo);
kfree(djrcv_dev);
hid_set_drvdata(hdev, NULL);
dj_put_receiver_dev(hdev);
}
static const struct hid_device_id logi_dj_receivers[] = {
{HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER)},
USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER),
.driver_data = recvr_type_dj},
{HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2)},
USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2),
.driver_data = recvr_type_dj},
{ /* Logitech Nano (non DJ) receiver */
HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
USB_DEVICE_ID_LOGITECH_NANO_RECEIVER),
.driver_data = recvr_type_hidpp},
{ /* Logitech Nano (non DJ) receiver */
HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
USB_DEVICE_ID_LOGITECH_NANO_RECEIVER_2),
.driver_data = recvr_type_hidpp},
{ /* Logitech gaming receiver (0xc539) */
HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
USB_DEVICE_ID_LOGITECH_NANO_RECEIVER_GAMING),
.driver_data = recvr_type_gaming_hidpp},
{ /* Logitech 27 MHz HID++ 1.0 receiver (0xc517) */
HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
USB_DEVICE_ID_S510_RECEIVER_2),
.driver_data = recvr_type_27mhz},
{ /* Logitech 27 MHz HID++ 1.0 mouse-only receiver (0xc51b) */
HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
USB_DEVICE_ID_LOGITECH_27MHZ_MOUSE_RECEIVER),
.driver_data = recvr_type_27mhz},
{ /* Logitech MX5000 HID++ / bluetooth receiver keyboard intf. */
HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
0xc70e),
.driver_data = recvr_type_bluetooth},
{ /* Logitech MX5000 HID++ / bluetooth receiver mouse intf. */
HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH,
0xc70a),
.driver_data = recvr_type_bluetooth},
{}
};
......
......@@ -51,7 +51,11 @@ MODULE_PARM_DESC(disable_tap_to_click,
#define HIDPP_REPORT_SHORT_LENGTH 7
#define HIDPP_REPORT_LONG_LENGTH 20
#define HIDPP_REPORT_VERY_LONG_LENGTH 64
#define HIDPP_REPORT_VERY_LONG_MAX_LENGTH 64
#define HIDPP_SUB_ID_CONSUMER_VENDOR_KEYS 0x03
#define HIDPP_SUB_ID_ROLLER 0x05
#define HIDPP_SUB_ID_MOUSE_EXTRA_BTNS 0x06
#define HIDPP_QUIRK_CLASS_WTP BIT(0)
#define HIDPP_QUIRK_CLASS_M560 BIT(1)
......@@ -68,6 +72,13 @@ MODULE_PARM_DESC(disable_tap_to_click,
#define HIDPP_QUIRK_HI_RES_SCROLL_1P0 BIT(26)
#define HIDPP_QUIRK_HI_RES_SCROLL_X2120 BIT(27)
#define HIDPP_QUIRK_HI_RES_SCROLL_X2121 BIT(28)
#define HIDPP_QUIRK_HIDPP_WHEELS BIT(29)
#define HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS BIT(30)
#define HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS BIT(31)
/* These are just aliases for now */
#define HIDPP_QUIRK_KBD_SCROLL_WHEEL HIDPP_QUIRK_HIDPP_WHEELS
#define HIDPP_QUIRK_KBD_ZOOM_WHEEL HIDPP_QUIRK_HIDPP_WHEELS
/* Convenience constant to check for any high-res support. */
#define HIDPP_QUIRK_HI_RES_SCROLL (HIDPP_QUIRK_HI_RES_SCROLL_1P0 | \
......@@ -106,13 +117,13 @@ MODULE_PARM_DESC(disable_tap_to_click,
struct fap {
u8 feature_index;
u8 funcindex_clientid;
u8 params[HIDPP_REPORT_VERY_LONG_LENGTH - 4U];
u8 params[HIDPP_REPORT_VERY_LONG_MAX_LENGTH - 4U];
};
struct rap {
u8 sub_id;
u8 reg_address;
u8 params[HIDPP_REPORT_VERY_LONG_LENGTH - 4U];
u8 params[HIDPP_REPORT_VERY_LONG_MAX_LENGTH - 4U];
};
struct hidpp_report {
......@@ -149,7 +160,6 @@ struct hidpp_battery {
* @last_time: last event time, used to reset remainder after inactivity
*/
struct hidpp_scroll_counter {
struct input_dev *dev;
int wheel_multiplier;
int remainder;
int direction;
......@@ -158,10 +168,12 @@ struct hidpp_scroll_counter {
struct hidpp_device {
struct hid_device *hid_dev;
struct input_dev *input;
struct mutex send_mutex;
void *send_receive_buf;
char *name; /* will never be NULL and should not be freed */
wait_queue_head_t wait;
int very_long_report_length;
bool answer_available;
u8 protocol_major;
u8 protocol_minor;
......@@ -206,8 +218,6 @@ static int __hidpp_send_report(struct hid_device *hdev,
struct hidpp_device *hidpp = hid_get_drvdata(hdev);
int fields_count, ret;
hidpp = hid_get_drvdata(hdev);
switch (hidpp_report->report_id) {
case REPORT_ID_HIDPP_SHORT:
fields_count = HIDPP_REPORT_SHORT_LENGTH;
......@@ -216,7 +226,7 @@ static int __hidpp_send_report(struct hid_device *hdev,
fields_count = HIDPP_REPORT_LONG_LENGTH;
break;
case REPORT_ID_HIDPP_VERY_LONG:
fields_count = HIDPP_REPORT_VERY_LONG_LENGTH;
fields_count = hidpp->very_long_report_length;
break;
default:
return -ENODEV;
......@@ -342,7 +352,7 @@ static int hidpp_send_rap_command_sync(struct hidpp_device *hidpp_dev,
max_count = HIDPP_REPORT_LONG_LENGTH - 4;
break;
case REPORT_ID_HIDPP_VERY_LONG:
max_count = HIDPP_REPORT_VERY_LONG_LENGTH - 4;
max_count = hidpp_dev->very_long_report_length - 4;
break;
default:
return -EINVAL;
......@@ -434,14 +444,15 @@ static void hidpp_prefix_name(char **name, int name_length)
* emit low-resolution scroll events when appropriate for
* backwards-compatibility with userspace input libraries.
*/
static void hidpp_scroll_counter_handle_scroll(struct hidpp_scroll_counter *counter,
static void hidpp_scroll_counter_handle_scroll(struct input_dev *input_dev,
struct hidpp_scroll_counter *counter,
int hi_res_value)
{
int low_res_value, remainder, direction;
unsigned long long now, previous;
hi_res_value = hi_res_value * 120/counter->wheel_multiplier;
input_report_rel(counter->dev, REL_WHEEL_HI_RES, hi_res_value);
input_report_rel(input_dev, REL_WHEEL_HI_RES, hi_res_value);
remainder = counter->remainder;
direction = hi_res_value > 0 ? 1 : -1;
......@@ -475,7 +486,7 @@ static void hidpp_scroll_counter_handle_scroll(struct hidpp_scroll_counter *coun
low_res_value = remainder / 120;
if (low_res_value == 0)
low_res_value = (hi_res_value > 0 ? 1 : -1);
input_report_rel(counter->dev, REL_WHEEL, low_res_value);
input_report_rel(input_dev, REL_WHEEL, low_res_value);
remainder -= low_res_value * 120;
}
counter->remainder = remainder;
......@@ -491,14 +502,16 @@ static void hidpp_scroll_counter_handle_scroll(struct hidpp_scroll_counter *coun
#define HIDPP_GET_LONG_REGISTER 0x83
/**
* hidpp10_set_register_bit() - Sets a single bit in a HID++ 1.0 register.
* hidpp10_set_register - Modify a HID++ 1.0 register.
* @hidpp_dev: the device to set the register on.
* @register_address: the address of the register to modify.
* @byte: the byte of the register to modify. Should be less than 3.
* @mask: mask of the bits to modify
* @value: new values for the bits in mask
* Return: 0 if successful, otherwise a negative error code.
*/
static int hidpp10_set_register_bit(struct hidpp_device *hidpp_dev,
u8 register_address, u8 byte, u8 bit)
static int hidpp10_set_register(struct hidpp_device *hidpp_dev,
u8 register_address, u8 byte, u8 mask, u8 value)
{
struct hidpp_report response;
int ret;
......@@ -514,7 +527,8 @@ static int hidpp10_set_register_bit(struct hidpp_device *hidpp_dev,
memcpy(params, response.rap.params, 3);
params[byte] |= BIT(bit);
params[byte] &= ~mask;
params[byte] |= value & mask;
return hidpp_send_rap_command_sync(hidpp_dev,
REPORT_ID_HIDPP_SHORT,
......@@ -523,20 +537,28 @@ static int hidpp10_set_register_bit(struct hidpp_device *hidpp_dev,
params, 3, &response);
}
#define HIDPP_REG_GENERAL 0x00
#define HIDPP_REG_ENABLE_REPORTS 0x00
#define HIDPP_ENABLE_CONSUMER_REPORT BIT(0)
#define HIDPP_ENABLE_WHEEL_REPORT BIT(2)
#define HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT BIT(3)
#define HIDPP_ENABLE_BAT_REPORT BIT(4)
#define HIDPP_ENABLE_HWHEEL_REPORT BIT(5)
static int hidpp10_enable_battery_reporting(struct hidpp_device *hidpp_dev)
{
return hidpp10_set_register_bit(hidpp_dev, HIDPP_REG_GENERAL, 0, 4);
return hidpp10_set_register(hidpp_dev, HIDPP_REG_ENABLE_REPORTS, 0,
HIDPP_ENABLE_BAT_REPORT, HIDPP_ENABLE_BAT_REPORT);
}
#define HIDPP_REG_FEATURES 0x01
#define HIDPP_ENABLE_SPECIAL_BUTTON_FUNC BIT(1)
#define HIDPP_ENABLE_FAST_SCROLL BIT(6)
/* On HID++ 1.0 devices, high-res scroll was called "scrolling acceleration". */
static int hidpp10_enable_scrolling_acceleration(struct hidpp_device *hidpp_dev)
{
return hidpp10_set_register_bit(hidpp_dev, HIDPP_REG_FEATURES, 0, 6);
return hidpp10_set_register(hidpp_dev, HIDPP_REG_FEATURES, 0,
HIDPP_ENABLE_FAST_SCROLL, HIDPP_ENABLE_FAST_SCROLL);
}
#define HIDPP_REG_BATTERY_STATUS 0x07
......@@ -741,6 +763,9 @@ static char *hidpp_unifying_get_name(struct hidpp_device *hidpp_dev)
if (2 + len > sizeof(response.rap.params))
return NULL;
if (len < 4) /* logitech devices are usually at least Xddd */
return NULL;
name = kzalloc(len + 1, GFP_KERNEL);
if (!name)
return NULL;
......@@ -836,18 +861,21 @@ static int hidpp_root_get_feature(struct hidpp_device *hidpp, u16 feature,
static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp)
{
const u8 ping_byte = 0x5a;
u8 ping_data[3] = { 0, 0, ping_byte };
struct hidpp_report response;
int ret;
ret = hidpp_send_fap_command_sync(hidpp,
ret = hidpp_send_rap_command_sync(hidpp,
REPORT_ID_HIDPP_SHORT,
HIDPP_PAGE_ROOT_IDX,
CMD_ROOT_GET_PROTOCOL_VERSION,
NULL, 0, &response);
ping_data, sizeof(ping_data), &response);
if (ret == HIDPP_ERROR_INVALID_SUBID) {
hidpp->protocol_major = 1;
hidpp->protocol_minor = 0;
return 0;
goto print_version;
}
/* the device might not be connected */
......@@ -862,21 +890,19 @@ static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp)
if (ret)
return ret;
hidpp->protocol_major = response.fap.params[0];
hidpp->protocol_minor = response.fap.params[1];
if (response.rap.params[2] != ping_byte) {
hid_err(hidpp->hid_dev, "%s: ping mismatch 0x%02x != 0x%02x\n",
__func__, response.rap.params[2], ping_byte);
return -EPROTO;
}
return ret;
}
hidpp->protocol_major = response.rap.params[0];
hidpp->protocol_minor = response.rap.params[1];
static bool hidpp_is_connected(struct hidpp_device *hidpp)
{
int ret;
ret = hidpp_root_get_protocol_version(hidpp);
if (!ret)
hid_dbg(hidpp->hid_dev, "HID++ %u.%u device connected.\n",
print_version:
hid_info(hidpp->hid_dev, "HID++ %u.%u device connected.\n",
hidpp->protocol_major, hidpp->protocol_minor);
return ret == 0;
return 0;
}
/* -------------------------------------------------------------------------- */
......@@ -932,7 +958,7 @@ static int hidpp_devicenametype_get_device_name(struct hidpp_device *hidpp,
switch (response.report_id) {
case REPORT_ID_HIDPP_VERY_LONG:
count = HIDPP_REPORT_VERY_LONG_LENGTH - 4;
count = hidpp->very_long_report_length - 4;
break;
case REPORT_ID_HIDPP_LONG:
count = HIDPP_REPORT_LONG_LENGTH - 4;
......@@ -1012,7 +1038,11 @@ static int hidpp_map_battery_level(int capacity)
{
if (capacity < 11)
return POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
else if (capacity < 31)
/*
* The spec says this should be < 31 but some devices report 30
* with brand new batteries and Windows reports 30 as "Good".
*/
else if (capacity < 30)
return POWER_SUPPLY_CAPACITY_LEVEL_LOW;
else if (capacity < 81)
return POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
......@@ -2211,7 +2241,6 @@ static int hidpp_ff_deinit(struct hid_device *hid)
#define WTP_MANUAL_RESOLUTION 39
struct wtp_data {
struct input_dev *input;
u16 x_size, y_size;
u8 finger_count;
u8 mt_feature_index;
......@@ -2229,7 +2258,7 @@ static int wtp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
}
static void wtp_populate_input(struct hidpp_device *hidpp,
struct input_dev *input_dev, bool origin_is_hid_core)
struct input_dev *input_dev)
{
struct wtp_data *wd = hidpp->private_data;
......@@ -2255,31 +2284,30 @@ static void wtp_populate_input(struct hidpp_device *hidpp,
input_mt_init_slots(input_dev, wd->maxcontacts, INPUT_MT_POINTER |
INPUT_MT_DROP_UNUSED);
wd->input = input_dev;
}
static void wtp_touch_event(struct wtp_data *wd,
static void wtp_touch_event(struct hidpp_device *hidpp,
struct hidpp_touchpad_raw_xy_finger *touch_report)
{
struct wtp_data *wd = hidpp->private_data;
int slot;
if (!touch_report->finger_id || touch_report->contact_type)
/* no actual data */
return;
slot = input_mt_get_slot_by_key(wd->input, touch_report->finger_id);
slot = input_mt_get_slot_by_key(hidpp->input, touch_report->finger_id);
input_mt_slot(wd->input, slot);
input_mt_report_slot_state(wd->input, MT_TOOL_FINGER,
input_mt_slot(hidpp->input, slot);
input_mt_report_slot_state(hidpp->input, MT_TOOL_FINGER,
touch_report->contact_status);
if (touch_report->contact_status) {
input_event(wd->input, EV_ABS, ABS_MT_POSITION_X,
input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_X,
touch_report->x);
input_event(wd->input, EV_ABS, ABS_MT_POSITION_Y,
input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_Y,
wd->flip_y ? wd->y_size - touch_report->y :
touch_report->y);
input_event(wd->input, EV_ABS, ABS_MT_PRESSURE,
input_event(hidpp->input, EV_ABS, ABS_MT_PRESSURE,
touch_report->area);
}
}
......@@ -2287,19 +2315,18 @@ static void wtp_touch_event(struct wtp_data *wd,
static void wtp_send_raw_xy_event(struct hidpp_device *hidpp,
struct hidpp_touchpad_raw_xy *raw)
{
struct wtp_data *wd = hidpp->private_data;
int i;
for (i = 0; i < 2; i++)
wtp_touch_event(wd, &(raw->fingers[i]));
wtp_touch_event(hidpp, &(raw->fingers[i]));
if (raw->end_of_frame &&
!(hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS))
input_event(wd->input, EV_KEY, BTN_LEFT, raw->button);
input_event(hidpp->input, EV_KEY, BTN_LEFT, raw->button);
if (raw->end_of_frame || raw->finger_count <= 2) {
input_mt_sync_frame(wd->input);
input_sync(wd->input);
input_mt_sync_frame(hidpp->input);
input_sync(hidpp->input);
}
}
......@@ -2349,7 +2376,7 @@ static int wtp_raw_event(struct hid_device *hdev, u8 *data, int size)
struct hidpp_report *report = (struct hidpp_report *)data;
struct hidpp_touchpad_raw_xy raw;
if (!wd || !wd->input)
if (!wd || !hidpp->input)
return 1;
switch (data[0]) {
......@@ -2360,11 +2387,11 @@ static int wtp_raw_event(struct hid_device *hdev, u8 *data, int size)
return 1;
}
if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) {
input_event(wd->input, EV_KEY, BTN_LEFT,
input_event(hidpp->input, EV_KEY, BTN_LEFT,
!!(data[1] & 0x01));
input_event(wd->input, EV_KEY, BTN_RIGHT,
input_event(hidpp->input, EV_KEY, BTN_RIGHT,
!!(data[1] & 0x02));
input_sync(wd->input);
input_sync(hidpp->input);
return 0;
} else {
if (size < 21)
......@@ -2482,10 +2509,6 @@ static int wtp_connect(struct hid_device *hdev, bool connected)
static const u8 m560_config_parameter[] = {0x00, 0xaf, 0x03};
struct m560_private_data {
struct input_dev *input;
};
/* how buttons are mapped in the report */
#define M560_MOUSE_BTN_LEFT 0x01
#define M560_MOUSE_BTN_RIGHT 0x02
......@@ -2513,28 +2536,12 @@ static int m560_send_config_command(struct hid_device *hdev, bool connected)
);
}
static int m560_allocate(struct hid_device *hdev)
{
struct hidpp_device *hidpp = hid_get_drvdata(hdev);
struct m560_private_data *d;
d = devm_kzalloc(&hdev->dev, sizeof(struct m560_private_data),
GFP_KERNEL);
if (!d)
return -ENOMEM;
hidpp->private_data = d;
return 0;
};
static int m560_raw_event(struct hid_device *hdev, u8 *data, int size)
{
struct hidpp_device *hidpp = hid_get_drvdata(hdev);
struct m560_private_data *mydata = hidpp->private_data;
/* sanity check */
if (!mydata || !mydata->input) {
if (!hidpp->input) {
hid_err(hdev, "error in parameter\n");
return -EINVAL;
}
......@@ -2561,24 +2568,24 @@ static int m560_raw_event(struct hid_device *hdev, u8 *data, int size)
switch (data[5]) {
case 0xaf:
input_report_key(mydata->input, BTN_MIDDLE, 1);
input_report_key(hidpp->input, BTN_MIDDLE, 1);
break;
case 0xb0:
input_report_key(mydata->input, BTN_FORWARD, 1);
input_report_key(hidpp->input, BTN_FORWARD, 1);
break;
case 0xae:
input_report_key(mydata->input, BTN_BACK, 1);
input_report_key(hidpp->input, BTN_BACK, 1);
break;
case 0x00:
input_report_key(mydata->input, BTN_BACK, 0);
input_report_key(mydata->input, BTN_FORWARD, 0);
input_report_key(mydata->input, BTN_MIDDLE, 0);
input_report_key(hidpp->input, BTN_BACK, 0);
input_report_key(hidpp->input, BTN_FORWARD, 0);
input_report_key(hidpp->input, BTN_MIDDLE, 0);
break;
default:
hid_err(hdev, "error in report\n");
return 0;
}
input_sync(mydata->input);
input_sync(hidpp->input);
} else if (data[0] == 0x02) {
/*
......@@ -2592,59 +2599,55 @@ static int m560_raw_event(struct hid_device *hdev, u8 *data, int size)
int v;
input_report_key(mydata->input, BTN_LEFT,
input_report_key(hidpp->input, BTN_LEFT,
!!(data[1] & M560_MOUSE_BTN_LEFT));
input_report_key(mydata->input, BTN_RIGHT,
input_report_key(hidpp->input, BTN_RIGHT,
!!(data[1] & M560_MOUSE_BTN_RIGHT));
if (data[1] & M560_MOUSE_BTN_WHEEL_LEFT) {
input_report_rel(mydata->input, REL_HWHEEL, -1);
input_report_rel(mydata->input, REL_HWHEEL_HI_RES,
input_report_rel(hidpp->input, REL_HWHEEL, -1);
input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
-120);
} else if (data[1] & M560_MOUSE_BTN_WHEEL_RIGHT) {
input_report_rel(mydata->input, REL_HWHEEL, 1);
input_report_rel(mydata->input, REL_HWHEEL_HI_RES,
input_report_rel(hidpp->input, REL_HWHEEL, 1);
input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
120);
}
v = hid_snto32(hid_field_extract(hdev, data+3, 0, 12), 12);
input_report_rel(mydata->input, REL_X, v);
input_report_rel(hidpp->input, REL_X, v);
v = hid_snto32(hid_field_extract(hdev, data+3, 12, 12), 12);
input_report_rel(mydata->input, REL_Y, v);
input_report_rel(hidpp->input, REL_Y, v);
v = hid_snto32(data[6], 8);
if (v != 0)
hidpp_scroll_counter_handle_scroll(
hidpp_scroll_counter_handle_scroll(hidpp->input,
&hidpp->vertical_wheel_counter, v);
input_sync(mydata->input);
input_sync(hidpp->input);
}
return 1;
}
static void m560_populate_input(struct hidpp_device *hidpp,
struct input_dev *input_dev, bool origin_is_hid_core)
struct input_dev *input_dev)
{
struct m560_private_data *mydata = hidpp->private_data;
mydata->input = input_dev;
__set_bit(EV_KEY, mydata->input->evbit);
__set_bit(BTN_MIDDLE, mydata->input->keybit);
__set_bit(BTN_RIGHT, mydata->input->keybit);
__set_bit(BTN_LEFT, mydata->input->keybit);
__set_bit(BTN_BACK, mydata->input->keybit);
__set_bit(BTN_FORWARD, mydata->input->keybit);
__set_bit(EV_KEY, input_dev->evbit);
__set_bit(BTN_MIDDLE, input_dev->keybit);
__set_bit(BTN_RIGHT, input_dev->keybit);
__set_bit(BTN_LEFT, input_dev->keybit);
__set_bit(BTN_BACK, input_dev->keybit);
__set_bit(BTN_FORWARD, input_dev->keybit);
__set_bit(EV_REL, mydata->input->evbit);
__set_bit(REL_X, mydata->input->relbit);
__set_bit(REL_Y, mydata->input->relbit);
__set_bit(REL_WHEEL, mydata->input->relbit);
__set_bit(REL_HWHEEL, mydata->input->relbit);
__set_bit(REL_WHEEL_HI_RES, mydata->input->relbit);
__set_bit(REL_HWHEEL_HI_RES, mydata->input->relbit);
__set_bit(EV_REL, input_dev->evbit);
__set_bit(REL_X, input_dev->relbit);
__set_bit(REL_Y, input_dev->relbit);
__set_bit(REL_WHEEL, input_dev->relbit);
__set_bit(REL_HWHEEL, input_dev->relbit);
__set_bit(REL_WHEEL_HI_RES, input_dev->relbit);
__set_bit(REL_HWHEEL_HI_RES, input_dev->relbit);
}
static int m560_input_mapping(struct hid_device *hdev, struct hid_input *hi,
......@@ -2746,6 +2749,175 @@ static int g920_get_config(struct hidpp_device *hidpp)
return 0;
}
/* -------------------------------------------------------------------------- */
/* HID++1.0 devices which use HID++ reports for their wheels */
/* -------------------------------------------------------------------------- */
static int hidpp10_wheel_connect(struct hidpp_device *hidpp)
{
return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
HIDPP_ENABLE_WHEEL_REPORT | HIDPP_ENABLE_HWHEEL_REPORT,
HIDPP_ENABLE_WHEEL_REPORT | HIDPP_ENABLE_HWHEEL_REPORT);
}
static int hidpp10_wheel_raw_event(struct hidpp_device *hidpp,
u8 *data, int size)
{
s8 value, hvalue;
if (!hidpp->input)
return -EINVAL;
if (size < 7)
return 0;
if (data[0] != REPORT_ID_HIDPP_SHORT || data[2] != HIDPP_SUB_ID_ROLLER)
return 0;
value = data[3];
hvalue = data[4];
input_report_rel(hidpp->input, REL_WHEEL, value);
input_report_rel(hidpp->input, REL_WHEEL_HI_RES, value * 120);
input_report_rel(hidpp->input, REL_HWHEEL, hvalue);
input_report_rel(hidpp->input, REL_HWHEEL_HI_RES, hvalue * 120);
input_sync(hidpp->input);
return 1;
}
static void hidpp10_wheel_populate_input(struct hidpp_device *hidpp,
struct input_dev *input_dev)
{
__set_bit(EV_REL, input_dev->evbit);
__set_bit(REL_WHEEL, input_dev->relbit);
__set_bit(REL_WHEEL_HI_RES, input_dev->relbit);
__set_bit(REL_HWHEEL, input_dev->relbit);
__set_bit(REL_HWHEEL_HI_RES, input_dev->relbit);
}
/* -------------------------------------------------------------------------- */
/* HID++1.0 mice which use HID++ reports for extra mouse buttons */
/* -------------------------------------------------------------------------- */
static int hidpp10_extra_mouse_buttons_connect(struct hidpp_device *hidpp)
{
return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT,
HIDPP_ENABLE_MOUSE_EXTRA_BTN_REPORT);
}
static int hidpp10_extra_mouse_buttons_raw_event(struct hidpp_device *hidpp,
u8 *data, int size)
{
int i;
if (!hidpp->input)
return -EINVAL;
if (size < 7)
return 0;
if (data[0] != REPORT_ID_HIDPP_SHORT ||
data[2] != HIDPP_SUB_ID_MOUSE_EXTRA_BTNS)
return 0;
/*
* Buttons are either delivered through the regular mouse report *or*
* through the extra buttons report. At least for button 6 how it is
* delivered differs per receiver firmware version. Even receivers with
* the same usb-id show different behavior, so we handle both cases.
*/
for (i = 0; i < 8; i++)
input_report_key(hidpp->input, BTN_MOUSE + i,
(data[3] & (1 << i)));
/* Some mice report events on button 9+, use BTN_MISC */
for (i = 0; i < 8; i++)
input_report_key(hidpp->input, BTN_MISC + i,
(data[4] & (1 << i)));
input_sync(hidpp->input);
return 1;
}
static void hidpp10_extra_mouse_buttons_populate_input(
struct hidpp_device *hidpp, struct input_dev *input_dev)
{
/* BTN_MOUSE - BTN_MOUSE+7 are set already by the descriptor */
__set_bit(BTN_0, input_dev->keybit);
__set_bit(BTN_1, input_dev->keybit);
__set_bit(BTN_2, input_dev->keybit);
__set_bit(BTN_3, input_dev->keybit);
__set_bit(BTN_4, input_dev->keybit);
__set_bit(BTN_5, input_dev->keybit);
__set_bit(BTN_6, input_dev->keybit);
__set_bit(BTN_7, input_dev->keybit);
}
/* -------------------------------------------------------------------------- */
/* HID++1.0 kbds which only report 0x10xx consumer usages through sub-id 0x03 */
/* -------------------------------------------------------------------------- */
/* Find the consumer-page input report desc and change Maximums to 0x107f */
static u8 *hidpp10_consumer_keys_report_fixup(struct hidpp_device *hidpp,
u8 *_rdesc, unsigned int *rsize)
{
/* Note 0 terminated so we can use strnstr to search for this. */
const char consumer_rdesc_start[] = {
0x05, 0x0C, /* USAGE_PAGE (Consumer Devices) */
0x09, 0x01, /* USAGE (Consumer Control) */
0xA1, 0x01, /* COLLECTION (Application) */
0x85, 0x03, /* REPORT_ID = 3 */
0x75, 0x10, /* REPORT_SIZE (16) */
0x95, 0x02, /* REPORT_COUNT (2) */
0x15, 0x01, /* LOGICAL_MIN (1) */
0x26, 0x00 /* LOGICAL_MAX (... */
};
char *consumer_rdesc, *rdesc = (char *)_rdesc;
unsigned int size;
consumer_rdesc = strnstr(rdesc, consumer_rdesc_start, *rsize);
size = *rsize - (consumer_rdesc - rdesc);
if (consumer_rdesc && size >= 25) {
consumer_rdesc[15] = 0x7f;
consumer_rdesc[16] = 0x10;
consumer_rdesc[20] = 0x7f;
consumer_rdesc[21] = 0x10;
}
return _rdesc;
}
static int hidpp10_consumer_keys_connect(struct hidpp_device *hidpp)
{
return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
HIDPP_ENABLE_CONSUMER_REPORT,
HIDPP_ENABLE_CONSUMER_REPORT);
}
static int hidpp10_consumer_keys_raw_event(struct hidpp_device *hidpp,
u8 *data, int size)
{
u8 consumer_report[5];
if (size < 7)
return 0;
if (data[0] != REPORT_ID_HIDPP_SHORT ||
data[2] != HIDPP_SUB_ID_CONSUMER_VENDOR_KEYS)
return 0;
/*
* Build a normal consumer report (3) out of the data, this detour
* is necessary to get some keyboards to report their 0x10xx usages.
*/
consumer_report[0] = 0x03;
memcpy(&consumer_report[1], &data[3], 4);
/* We are called from atomic context */
hid_report_raw_event(hidpp->hid_dev, HID_INPUT_REPORT,
consumer_report, 5, 1);
return 1;
}
/* -------------------------------------------------------------------------- */
/* High-resolution scroll wheels */
/* -------------------------------------------------------------------------- */
......@@ -2781,12 +2953,31 @@ static int hi_res_scroll_enable(struct hidpp_device *hidpp)
/* Generic HID++ devices */
/* -------------------------------------------------------------------------- */
static u8 *hidpp_report_fixup(struct hid_device *hdev, u8 *rdesc,
unsigned int *rsize)
{
struct hidpp_device *hidpp = hid_get_drvdata(hdev);
if (!hidpp)
return rdesc;
/* For 27 MHz keyboards the quirk gets set after hid_parse. */
if (hdev->group == HID_GROUP_LOGITECH_27MHZ_DEVICE ||
(hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS))
rdesc = hidpp10_consumer_keys_report_fixup(hidpp, rdesc, rsize);
return rdesc;
}
static int hidpp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
struct hid_field *field, struct hid_usage *usage,
unsigned long **bit, int *max)
{
struct hidpp_device *hidpp = hid_get_drvdata(hdev);
if (!hidpp)
return 0;
if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
return wtp_input_mapping(hdev, hi, field, usage, bit, max);
else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560 &&
......@@ -2802,6 +2993,9 @@ static int hidpp_input_mapped(struct hid_device *hdev, struct hid_input *hi,
{
struct hidpp_device *hidpp = hid_get_drvdata(hdev);
if (!hidpp)
return 0;
/* Ensure that Logitech G920 is not given a default fuzz/flat value */
if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
if (usage->type == EV_ABS && (usage->code == ABS_X ||
......@@ -2816,15 +3010,20 @@ static int hidpp_input_mapped(struct hid_device *hdev, struct hid_input *hi,
static void hidpp_populate_input(struct hidpp_device *hidpp,
struct input_dev *input, bool origin_is_hid_core)
struct input_dev *input)
{
hidpp->input = input;
if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
wtp_populate_input(hidpp, input, origin_is_hid_core);
wtp_populate_input(hidpp, input);
else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
m560_populate_input(hidpp, input, origin_is_hid_core);
m560_populate_input(hidpp, input);
if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL)
hidpp->vertical_wheel_counter.dev = input;
if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS)
hidpp10_wheel_populate_input(hidpp, input);
if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS)
hidpp10_extra_mouse_buttons_populate_input(hidpp, input);
}
static int hidpp_input_configured(struct hid_device *hdev,
......@@ -2833,7 +3032,10 @@ static int hidpp_input_configured(struct hid_device *hdev,
struct hidpp_device *hidpp = hid_get_drvdata(hdev);
struct input_dev *input = hidinput->input;
hidpp_populate_input(hidpp, input, true);
if (!hidpp)
return 0;
hidpp_populate_input(hidpp, input);
return 0;
}
......@@ -2893,6 +3095,24 @@ static int hidpp_raw_hidpp_event(struct hidpp_device *hidpp, u8 *data,
return ret;
}
if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
ret = hidpp10_wheel_raw_event(hidpp, data, size);
if (ret != 0)
return ret;
}
if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
ret = hidpp10_extra_mouse_buttons_raw_event(hidpp, data, size);
if (ret != 0)
return ret;
}
if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
ret = hidpp10_consumer_keys_raw_event(hidpp, data, size);
if (ret != 0)
return ret;
}
return 0;
}
......@@ -2902,10 +3122,13 @@ static int hidpp_raw_event(struct hid_device *hdev, struct hid_report *report,
struct hidpp_device *hidpp = hid_get_drvdata(hdev);
int ret = 0;
if (!hidpp)
return 0;
/* Generic HID++ processing. */
switch (data[0]) {
case REPORT_ID_HIDPP_VERY_LONG:
if (size != HIDPP_REPORT_VERY_LONG_LENGTH) {
if (size != hidpp->very_long_report_length) {
hid_err(hdev, "received hid++ report of bad size (%d)",
size);
return 1;
......@@ -2950,17 +3173,22 @@ static int hidpp_event(struct hid_device *hdev, struct hid_field *field,
* restriction imposed in hidpp_usages.
*/
struct hidpp_device *hidpp = hid_get_drvdata(hdev);
struct hidpp_scroll_counter *counter = &hidpp->vertical_wheel_counter;
struct hidpp_scroll_counter *counter;
if (!hidpp)
return 0;
counter = &hidpp->vertical_wheel_counter;
/* A scroll event may occur before the multiplier has been retrieved or
* the input device set, or high-res scroll enabling may fail. In such
* cases we must return early (falling back to default behaviour) to
* avoid a crash in hidpp_scroll_counter_handle_scroll.
*/
if (!(hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL) || value == 0
|| counter->dev == NULL || counter->wheel_multiplier == 0)
|| hidpp->input == NULL || counter->wheel_multiplier == 0)
return 0;
hidpp_scroll_counter_handle_scroll(counter, value);
hidpp_scroll_counter_handle_scroll(hidpp->input, counter, value);
return 1;
}
......@@ -3132,33 +3360,46 @@ static void hidpp_connect_event(struct hidpp_device *hidpp)
return;
}
if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
ret = hidpp10_wheel_connect(hidpp);
if (ret)
return;
}
if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
ret = hidpp10_extra_mouse_buttons_connect(hidpp);
if (ret)
return;
}
if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
ret = hidpp10_consumer_keys_connect(hidpp);
if (ret)
return;
}
/* the device is already connected, we can ask for its name and
* protocol */
if (!hidpp->protocol_major) {
ret = !hidpp_is_connected(hidpp);
ret = hidpp_root_get_protocol_version(hidpp);
if (ret) {
hid_err(hdev, "Can not get the protocol version.\n");
return;
}
hid_info(hdev, "HID++ %u.%u device connected.\n",
hidpp->protocol_major, hidpp->protocol_minor);
}
if (hidpp->name == hdev->name && hidpp->protocol_major >= 2) {
name = hidpp_get_device_name(hidpp);
if (!name) {
hid_err(hdev,
"unable to retrieve the name of the device");
return;
}
devm_name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "%s", name);
if (name) {
devm_name = devm_kasprintf(&hdev->dev, GFP_KERNEL,
"%s", name);
kfree(name);
if (!devm_name)
return;
hidpp->name = devm_name;
}
}
hidpp_initialize_battery(hidpp);
......@@ -3188,7 +3429,7 @@ static void hidpp_connect_event(struct hidpp_device *hidpp)
return;
}
hidpp_populate_input(hidpp, input, false);
hidpp_populate_input(hidpp, input);
ret = input_register_device(input);
if (ret)
......@@ -3208,6 +3449,60 @@ static const struct attribute_group ps_attribute_group = {
.attrs = sysfs_attrs
};
static int hidpp_get_report_length(struct hid_device *hdev, int id)
{
struct hid_report_enum *re;
struct hid_report *report;
re = &(hdev->report_enum[HID_OUTPUT_REPORT]);
report = re->report_id_hash[id];
if (!report)
return 0;
return report->field[0]->report_count + 1;
}
static bool hidpp_validate_report(struct hid_device *hdev, int id,
int expected_length, bool optional)
{
int report_length;
if (id >= HID_MAX_IDS || id < 0) {
hid_err(hdev, "invalid HID report id %u\n", id);
return false;
}
report_length = hidpp_get_report_length(hdev, id);
if (!report_length)
return optional;
if (report_length < expected_length) {
hid_warn(hdev, "not enough values in hidpp report %d\n", id);
return false;
}
return true;
}
static bool hidpp_validate_device(struct hid_device *hdev)
{
return hidpp_validate_report(hdev, REPORT_ID_HIDPP_SHORT,
HIDPP_REPORT_SHORT_LENGTH, false) &&
hidpp_validate_report(hdev, REPORT_ID_HIDPP_LONG,
HIDPP_REPORT_LONG_LENGTH, true);
}
static bool hidpp_application_equals(struct hid_device *hdev,
unsigned int application)
{
struct list_head *report_list;
struct hid_report *report;
report_list = &hdev->report_enum[HID_INPUT_REPORT].report_list;
report = list_first_entry_or_null(report_list, struct hid_report, list);
return report && report->application == application;
}
static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
struct hidpp_device *hidpp;
......@@ -3215,20 +3510,48 @@ static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id)
bool connected;
unsigned int connect_mask = HID_CONNECT_DEFAULT;
hidpp = devm_kzalloc(&hdev->dev, sizeof(struct hidpp_device),
GFP_KERNEL);
/* report_fixup needs drvdata to be set before we call hid_parse */
hidpp = devm_kzalloc(&hdev->dev, sizeof(*hidpp), GFP_KERNEL);
if (!hidpp)
return -ENOMEM;
hidpp->hid_dev = hdev;
hidpp->name = hdev->name;
hidpp->quirks = id->driver_data;
hid_set_drvdata(hdev, hidpp);
hidpp->quirks = id->driver_data;
ret = hid_parse(hdev);
if (ret) {
hid_err(hdev, "%s:parse failed\n", __func__);
return ret;
}
/*
* Make sure the device is HID++ capable, otherwise treat as generic HID
*/
if (!hidpp_validate_device(hdev)) {
hid_set_drvdata(hdev, NULL);
devm_kfree(&hdev->dev, hidpp);
return hid_hw_start(hdev, HID_CONNECT_DEFAULT);
}
hidpp->very_long_report_length =
hidpp_get_report_length(hdev, REPORT_ID_HIDPP_VERY_LONG);
if (hidpp->very_long_report_length > HIDPP_REPORT_VERY_LONG_MAX_LENGTH)
hidpp->very_long_report_length = HIDPP_REPORT_VERY_LONG_MAX_LENGTH;
if (id->group == HID_GROUP_LOGITECH_DJ_DEVICE)
hidpp->quirks |= HIDPP_QUIRK_UNIFYING;
if (id->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
hidpp_application_equals(hdev, HID_GD_MOUSE))
hidpp->quirks |= HIDPP_QUIRK_HIDPP_WHEELS |
HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS;
if (id->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
hidpp_application_equals(hdev, HID_GD_KEYBOARD))
hidpp->quirks |= HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS;
if (disable_raw_mode) {
hidpp->quirks &= ~HIDPP_QUIRK_CLASS_WTP;
hidpp->quirks &= ~HIDPP_QUIRK_NO_HIDINPUT;
......@@ -3237,15 +3560,11 @@ static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id)
if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
ret = wtp_allocate(hdev, id);
if (ret)
goto allocate_fail;
} else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) {
ret = m560_allocate(hdev);
if (ret)
goto allocate_fail;
return ret;
} else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
ret = k400_allocate(hdev);
if (ret)
goto allocate_fail;
return ret;
}
INIT_WORK(&hidpp->work, delayed_work_cb);
......@@ -3258,30 +3577,23 @@ static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id)
hid_warn(hdev, "Cannot allocate sysfs group for %s\n",
hdev->name);
ret = hid_parse(hdev);
if (ret) {
hid_err(hdev, "%s:parse failed\n", __func__);
goto hid_parse_fail;
}
if (hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT)
connect_mask &= ~HID_CONNECT_HIDINPUT;
if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
ret = hid_hw_start(hdev, connect_mask);
/*
* Plain USB connections need to actually call start and open
* on the transport driver to allow incoming data.
*/
ret = hid_hw_start(hdev, 0);
if (ret) {
hid_err(hdev, "hw start failed\n");
goto hid_hw_start_fail;
}
ret = hid_hw_open(hdev);
if (ret < 0) {
dev_err(&hdev->dev, "%s:hid_hw_open returned error:%d\n",
__func__, ret);
hid_hw_stop(hdev);
goto hid_hw_start_fail;
goto hid_hw_open_fail;
}
}
/* Allow incoming packets */
hid_device_io_start(hdev);
......@@ -3289,62 +3601,55 @@ static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id)
if (hidpp->quirks & HIDPP_QUIRK_UNIFYING)
hidpp_unifying_init(hidpp);
connected = hidpp_is_connected(hidpp);
connected = hidpp_root_get_protocol_version(hidpp) == 0;
atomic_set(&hidpp->connected, connected);
if (!(hidpp->quirks & HIDPP_QUIRK_UNIFYING)) {
if (!connected) {
ret = -ENODEV;
hid_err(hdev, "Device not connected");
goto hid_hw_open_failed;
goto hid_hw_init_fail;
}
hid_info(hdev, "HID++ %u.%u device connected.\n",
hidpp->protocol_major, hidpp->protocol_minor);
hidpp_overwrite_name(hdev);
}
if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)) {
ret = wtp_get_config(hidpp);
if (ret)
goto hid_hw_open_failed;
goto hid_hw_init_fail;
} else if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_G920)) {
ret = g920_get_config(hidpp);
if (ret)
goto hid_hw_open_failed;
goto hid_hw_init_fail;
}
/* Block incoming packets */
hidpp_connect_event(hidpp);
/* Reset the HID node state */
hid_device_io_stop(hdev);
hid_hw_close(hdev);
hid_hw_stop(hdev);
if (hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT)
connect_mask &= ~HID_CONNECT_HIDINPUT;
if (!(hidpp->quirks & HIDPP_QUIRK_CLASS_G920)) {
/* Now export the actual inputs and hidraw nodes to the world */
ret = hid_hw_start(hdev, connect_mask);
if (ret) {
hid_err(hdev, "%s:hid_hw_start returned error\n", __func__);
goto hid_hw_start_fail;
}
}
/* Allow incoming packets */
hid_device_io_start(hdev);
hidpp_connect_event(hidpp);
return ret;
hid_hw_open_failed:
hid_device_io_stop(hdev);
if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
hid_hw_init_fail:
hid_hw_close(hdev);
hid_hw_open_fail:
hid_hw_stop(hdev);
}
hid_hw_start_fail:
hid_parse_fail:
sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
cancel_work_sync(&hidpp->work);
mutex_destroy(&hidpp->send_mutex);
allocate_fail:
hid_set_drvdata(hdev, NULL);
return ret;
}
......@@ -3352,12 +3657,14 @@ static void hidpp_remove(struct hid_device *hdev)
{
struct hidpp_device *hidpp = hid_get_drvdata(hdev);
if (!hidpp)
return hid_hw_stop(hdev);
sysfs_remove_group(&hdev->dev.kobj, &ps_attribute_group);
if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920)
hidpp_ff_deinit(hdev);
hid_hw_close(hdev);
}
hid_hw_stop(hdev);
cancel_work_sync(&hidpp->work);
mutex_destroy(&hidpp->send_mutex);
......@@ -3367,6 +3674,10 @@ static void hidpp_remove(struct hid_device *hdev)
HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE, \
USB_VENDOR_ID_LOGITECH, (product))
#define L27MHZ_DEVICE(product) \
HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_27MHZ_DEVICE, \
USB_VENDOR_ID_LOGITECH, (product))
static const struct hid_device_id hidpp_devices[] = {
{ /* wireless touchpad */
LDJ_DEVICE(0x4011),
......@@ -3418,11 +3729,37 @@ static const struct hid_device_id hidpp_devices[] = {
{ /* Solar Keyboard Logitech K750 */
LDJ_DEVICE(0x4002),
.driver_data = HIDPP_QUIRK_CLASS_K750 },
{ /* Keyboard MX5000 (Bluetooth-receiver in HID proxy mode) */
LDJ_DEVICE(0xb305),
.driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
{ LDJ_DEVICE(HID_ANY_ID) },
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL),
{ /* Keyboard LX501 (Y-RR53) */
L27MHZ_DEVICE(0x0049),
.driver_data = HIDPP_QUIRK_KBD_ZOOM_WHEEL },
{ /* Keyboard MX3000 (Y-RAM74) */
L27MHZ_DEVICE(0x0057),
.driver_data = HIDPP_QUIRK_KBD_SCROLL_WHEEL },
{ /* Keyboard MX3200 (Y-RAV80) */
L27MHZ_DEVICE(0x005c),
.driver_data = HIDPP_QUIRK_KBD_ZOOM_WHEEL },
{ L27MHZ_DEVICE(HID_ANY_ID) },
{ /* Logitech G403 Gaming Mouse over USB */
HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC082) },
{ /* Logitech G700 Gaming Mouse over USB */
HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC06B) },
{ /* Logitech G900 Gaming Mouse over USB */
HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, 0xC081) },
{ /* Logitech G920 Wheel over USB */
HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL),
.driver_data = HIDPP_QUIRK_CLASS_G920 | HIDPP_QUIRK_FORCE_OUTPUT_REPORTS},
{ /* MX5000 keyboard over Bluetooth */
HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 0xb305),
.driver_data = HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS },
{}
};
......@@ -3436,6 +3773,7 @@ static const struct hid_usage_id hidpp_usages[] = {
static struct hid_driver hidpp_driver = {
.name = "logitech-hidpp-device",
.id_table = hidpp_devices,
.report_fixup = hidpp_report_fixup,
.probe = hidpp_probe,
.remove = hidpp_remove,
.raw_event = hidpp_raw_event,
......
// SPDX-License-Identifier: GPL-2.0+
/*
* HID driver for quirky Macally devices
*
* Copyright (c) 2019 Alex Henrie <alexhenrie24@gmail.com>
*/
#include <linux/hid.h>
#include <linux/module.h>
#include "hid-ids.h"
MODULE_AUTHOR("Alex Henrie <alexhenrie24@gmail.com>");
MODULE_DESCRIPTION("Macally devices");
MODULE_LICENSE("GPL");
/*
* The Macally ikey keyboard says that its logical and usage maximums are both
* 101, but the power key is 102 and the equals key is 103
*/
static __u8 *macally_report_fixup(struct hid_device *hdev, __u8 *rdesc,
unsigned int *rsize)
{
if (*rsize >= 60 && rdesc[53] == 0x65 && rdesc[59] == 0x65) {
hid_info(hdev,
"fixing up Macally ikey keyboard report descriptor\n");
rdesc[53] = rdesc[59] = 0x67;
}
return rdesc;
}
static struct hid_device_id macally_id_table[] = {
{ HID_USB_DEVICE(USB_VENDOR_ID_SOLID_YEAR,
USB_DEVICE_ID_MACALLY_IKEY_KEYBOARD) },
{ }
};
MODULE_DEVICE_TABLE(hid, macally_id_table);
static struct hid_driver macally_driver = {
.name = "macally",
.id_table = macally_id_table,
.report_fixup = macally_report_fixup,
};
module_hid_driver(macally_driver);
......@@ -28,6 +28,7 @@
#include <linux/completion.h>
#include <linux/uaccess.h>
#include <linux/module.h>
#include <linux/string.h>
#include "hid-picolcd.h"
......@@ -275,27 +276,20 @@ static ssize_t picolcd_operation_mode_store(struct device *dev,
{
struct picolcd_data *data = dev_get_drvdata(dev);
struct hid_report *report = NULL;
size_t cnt = count;
int timeout = data->opmode_delay;
unsigned long flags;
if (cnt >= 3 && strncmp("lcd", buf, 3) == 0) {
if (sysfs_streq(buf, "lcd")) {
if (data->status & PICOLCD_BOOTLOADER)
report = picolcd_out_report(REPORT_EXIT_FLASHER, data->hdev);
buf += 3;
cnt -= 3;
} else if (cnt >= 10 && strncmp("bootloader", buf, 10) == 0) {
} else if (sysfs_streq(buf, "bootloader")) {
if (!(data->status & PICOLCD_BOOTLOADER))
report = picolcd_out_report(REPORT_EXIT_KEYBOARD, data->hdev);
buf += 10;
cnt -= 10;
}
if (!report || report->maxfield != 1)
} else {
return -EINVAL;
}
while (cnt > 0 && (buf[cnt-1] == '\n' || buf[cnt-1] == '\r'))
cnt--;
if (cnt != 0)
if (!report || report->maxfield != 1)
return -EINVAL;
spin_lock_irqsave(&data->lock, flags);
......
......@@ -432,7 +432,6 @@ static const struct hid_device_id hid_have_special_driver[] = {
#if IS_ENABLED(CONFIG_HID_LOGITECH)
{ 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) },
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER) },
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP) },
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE) },
......@@ -464,13 +463,8 @@ static const struct hid_device_id hid_have_special_driver[] = {
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR) },
#endif
#if IS_ENABLED(CONFIG_HID_LOGITECH_HIDPP)
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_T651) },
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G920_WHEEL) },
#endif
#if IS_ENABLED(CONFIG_HID_LOGITECH_DJ)
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER) },
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2) },
#endif
#if IS_ENABLED(CONFIG_HID_MAGICMOUSE)
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICMOUSE) },
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGICTRACKPAD) },
......
......@@ -157,8 +157,7 @@ static int usage_id_cmp(const void *p1, const void *p2)
static ssize_t enable_sensor_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct hid_sensor_custom *sensor_inst = platform_get_drvdata(pdev);
struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev);
return sprintf(buf, "%d\n", sensor_inst->enable);
}
......@@ -237,8 +236,7 @@ static ssize_t enable_sensor_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct hid_sensor_custom *sensor_inst = platform_get_drvdata(pdev);
struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev);
int value;
int ret = -EINVAL;
......@@ -283,8 +281,7 @@ static const struct attribute_group enable_sensor_attr_group = {
static ssize_t show_value(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct platform_device *pdev = to_platform_device(dev);
struct hid_sensor_custom *sensor_inst = platform_get_drvdata(pdev);
struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev);
struct hid_sensor_hub_attribute_info *attribute;
int index, usage, field_index;
char name[HID_CUSTOM_NAME_LENGTH];
......@@ -392,8 +389,7 @@ static ssize_t show_value(struct device *dev, struct device_attribute *attr,
static ssize_t store_value(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct hid_sensor_custom *sensor_inst = platform_get_drvdata(pdev);
struct hid_sensor_custom *sensor_inst = dev_get_drvdata(dev);
int index, field_index, usage;
char name[HID_CUSTOM_NAME_LENGTH];
int value;
......
// SPDX-License-Identifier: GPL-2.0
/*
* U2F Zero LED and RNG driver
*
* Copyright 2018 Andrej Shadura <andrew@shadura.me>
* Loosely based on drivers/hid/hid-led.c
* and drivers/usb/misc/chaoskey.c
*
* 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.
*/
#include <linux/hid.h>
#include <linux/hidraw.h>
#include <linux/hw_random.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/usb.h>
#include "usbhid/usbhid.h"
#include "hid-ids.h"
#define DRIVER_SHORT "u2fzero"
#define HID_REPORT_SIZE 64
/* We only use broadcast (CID-less) messages */
#define CID_BROADCAST 0xffffffff
struct u2f_hid_msg {
u32 cid;
union {
struct {
u8 cmd;
u8 bcnth;
u8 bcntl;
u8 data[HID_REPORT_SIZE - 7];
} init;
struct {
u8 seq;
u8 data[HID_REPORT_SIZE - 5];
} cont;
};
} __packed;
struct u2f_hid_report {
u8 report_type;
struct u2f_hid_msg msg;
} __packed;
#define U2F_HID_MSG_LEN(f) (size_t)(((f).init.bcnth << 8) + (f).init.bcntl)
/* Custom extensions to the U2FHID protocol */
#define U2F_CUSTOM_GET_RNG 0x21
#define U2F_CUSTOM_WINK 0x24
struct u2fzero_device {
struct hid_device *hdev;
struct urb *urb; /* URB for the RNG data */
struct led_classdev ldev; /* Embedded struct for led */
struct hwrng hwrng; /* Embedded struct for hwrng */
char *led_name;
char *rng_name;
u8 *buf_out;
u8 *buf_in;
struct mutex lock;
bool present;
};
static int u2fzero_send(struct u2fzero_device *dev, struct u2f_hid_report *req)
{
int ret;
mutex_lock(&dev->lock);
memcpy(dev->buf_out, req, sizeof(struct u2f_hid_report));
ret = hid_hw_output_report(dev->hdev, dev->buf_out,
sizeof(struct u2f_hid_msg));
mutex_unlock(&dev->lock);
if (ret < 0)
return ret;
return ret == sizeof(struct u2f_hid_msg) ? 0 : -EMSGSIZE;
}
struct u2fzero_transfer_context {
struct completion done;
int status;
};
static void u2fzero_read_callback(struct urb *urb)
{
struct u2fzero_transfer_context *ctx = urb->context;
ctx->status = urb->status;
complete(&ctx->done);
}
static int u2fzero_recv(struct u2fzero_device *dev,
struct u2f_hid_report *req,
struct u2f_hid_msg *resp)
{
int ret;
struct hid_device *hdev = dev->hdev;
struct u2fzero_transfer_context ctx;
mutex_lock(&dev->lock);
memcpy(dev->buf_out, req, sizeof(struct u2f_hid_report));
dev->urb->context = &ctx;
init_completion(&ctx.done);
ret = usb_submit_urb(dev->urb, GFP_NOIO);
if (unlikely(ret)) {
hid_err(hdev, "usb_submit_urb failed: %d", ret);
goto err;
}
ret = hid_hw_output_report(dev->hdev, dev->buf_out,
sizeof(struct u2f_hid_msg));
if (ret < 0) {
hid_err(hdev, "hid_hw_output_report failed: %d", ret);
goto err;
}
ret = (wait_for_completion_timeout(
&ctx.done, msecs_to_jiffies(USB_CTRL_SET_TIMEOUT)));
if (ret < 0) {
usb_kill_urb(dev->urb);
hid_err(hdev, "urb submission timed out");
} else {
ret = dev->urb->actual_length;
memcpy(resp, dev->buf_in, ret);
}
err:
mutex_unlock(&dev->lock);
return ret;
}
static int u2fzero_blink(struct led_classdev *ldev)
{
struct u2fzero_device *dev = container_of(ldev,
struct u2fzero_device, ldev);
struct u2f_hid_report req = {
.report_type = 0,
.msg.cid = CID_BROADCAST,
.msg.init = {
.cmd = U2F_CUSTOM_WINK,
.bcnth = 0,
.bcntl = 0,
.data = {0},
}
};
return u2fzero_send(dev, &req);
}
static int u2fzero_brightness_set(struct led_classdev *ldev,
enum led_brightness brightness)
{
ldev->brightness = LED_OFF;
if (brightness)
return u2fzero_blink(ldev);
else
return 0;
}
static int u2fzero_rng_read(struct hwrng *rng, void *data,
size_t max, bool wait)
{
struct u2fzero_device *dev = container_of(rng,
struct u2fzero_device, hwrng);
struct u2f_hid_report req = {
.report_type = 0,
.msg.cid = CID_BROADCAST,
.msg.init = {
.cmd = U2F_CUSTOM_GET_RNG,
.bcnth = 0,
.bcntl = 0,
.data = {0},
}
};
struct u2f_hid_msg resp;
int ret;
size_t actual_length;
if (!dev->present) {
hid_dbg(dev->hdev, "device not present");
return 0;
}
ret = u2fzero_recv(dev, &req, &resp);
if (ret < 0)
return 0;
/* only take the minimum amount of data it is safe to take */
actual_length = min3((size_t)ret - offsetof(struct u2f_hid_msg,
init.data), U2F_HID_MSG_LEN(resp), max);
memcpy(data, resp.init.data, actual_length);
return actual_length;
}
static int u2fzero_init_led(struct u2fzero_device *dev,
unsigned int minor)
{
dev->led_name = devm_kasprintf(&dev->hdev->dev, GFP_KERNEL,
"%s%u", DRIVER_SHORT, minor);
if (dev->led_name == NULL)
return -ENOMEM;
dev->ldev.name = dev->led_name;
dev->ldev.max_brightness = LED_ON;
dev->ldev.flags = LED_HW_PLUGGABLE;
dev->ldev.brightness_set_blocking = u2fzero_brightness_set;
return devm_led_classdev_register(&dev->hdev->dev, &dev->ldev);
}
static int u2fzero_init_hwrng(struct u2fzero_device *dev,
unsigned int minor)
{
dev->rng_name = devm_kasprintf(&dev->hdev->dev, GFP_KERNEL,
"%s-rng%u", DRIVER_SHORT, minor);
if (dev->rng_name == NULL)
return -ENOMEM;
dev->hwrng.name = dev->rng_name;
dev->hwrng.read = u2fzero_rng_read;
dev->hwrng.quality = 1;
return devm_hwrng_register(&dev->hdev->dev, &dev->hwrng);
}
static int u2fzero_fill_in_urb(struct u2fzero_device *dev)
{
struct hid_device *hdev = dev->hdev;
struct usb_device *udev;
struct usbhid_device *usbhid = hdev->driver_data;
unsigned int pipe_in;
struct usb_host_endpoint *ep;
if (dev->hdev->bus != BUS_USB)
return -EINVAL;
udev = hid_to_usb_dev(hdev);
if (!usbhid->urbout || !usbhid->urbin)
return -ENODEV;
ep = usb_pipe_endpoint(udev, usbhid->urbin->pipe);
if (!ep)
return -ENODEV;
dev->urb = usb_alloc_urb(0, GFP_KERNEL);
if (!dev->urb)
return -ENOMEM;
pipe_in = (usbhid->urbin->pipe & ~(3 << 30)) | (PIPE_INTERRUPT << 30);
usb_fill_int_urb(dev->urb,
udev,
pipe_in,
dev->buf_in,
HID_REPORT_SIZE,
u2fzero_read_callback,
NULL,
ep->desc.bInterval);
return 0;
}
static int u2fzero_probe(struct hid_device *hdev,
const struct hid_device_id *id)
{
struct u2fzero_device *dev;
unsigned int minor;
int ret;
if (!hid_is_using_ll_driver(hdev, &usb_hid_driver))
return -EINVAL;
dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL);
if (dev == NULL)
return -ENOMEM;
dev->buf_out = devm_kmalloc(&hdev->dev,
sizeof(struct u2f_hid_report), GFP_KERNEL);
if (dev->buf_out == NULL)
return -ENOMEM;
dev->buf_in = devm_kmalloc(&hdev->dev,
sizeof(struct u2f_hid_msg), GFP_KERNEL);
if (dev->buf_in == NULL)
return -ENOMEM;
ret = hid_parse(hdev);
if (ret)
return ret;
dev->hdev = hdev;
hid_set_drvdata(hdev, dev);
mutex_init(&dev->lock);
ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
if (ret)
return ret;
u2fzero_fill_in_urb(dev);
dev->present = true;
minor = ((struct hidraw *) hdev->hidraw)->minor;
ret = u2fzero_init_led(dev, minor);
if (ret) {
hid_hw_stop(hdev);
return ret;
}
hid_info(hdev, "U2F Zero LED initialised\n");
ret = u2fzero_init_hwrng(dev, minor);
if (ret) {
hid_hw_stop(hdev);
return ret;
}
hid_info(hdev, "U2F Zero RNG initialised\n");
return 0;
}
static void u2fzero_remove(struct hid_device *hdev)
{
struct u2fzero_device *dev = hid_get_drvdata(hdev);
mutex_lock(&dev->lock);
dev->present = false;
mutex_unlock(&dev->lock);
hid_hw_stop(hdev);
usb_poison_urb(dev->urb);
usb_free_urb(dev->urb);
}
static const struct hid_device_id u2fzero_table[] = {
{ HID_USB_DEVICE(USB_VENDOR_ID_CYGNAL,
USB_DEVICE_ID_U2F_ZERO) },
{ }
};
MODULE_DEVICE_TABLE(hid, u2fzero_table);
static struct hid_driver u2fzero_driver = {
.name = "hid-" DRIVER_SHORT,
.probe = u2fzero_probe,
.remove = u2fzero_remove,
.id_table = u2fzero_table,
};
module_hid_driver(u2fzero_driver);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Andrej Shadura <andrew@shadura.me>");
MODULE_DESCRIPTION("U2F Zero LED and RNG driver");
......@@ -184,8 +184,6 @@ static const struct i2c_hid_quirks {
I2C_HID_QUIRK_NO_RUNTIME_PM },
{ USB_VENDOR_ID_ELAN, HID_ANY_ID,
I2C_HID_QUIRK_BOGUS_IRQ },
{ USB_VENDOR_ID_SYNAPTICS, I2C_DEVICE_ID_SYNAPTICS_7E7E,
I2C_HID_QUIRK_NO_RUNTIME_PM },
{ 0, 0 }
};
......
......@@ -14,4 +14,19 @@ config INTEL_ISH_HID
Broxton and Kaby Lake.
Say Y here if you want to support Intel ISH. If unsure, say N.
config INTEL_ISH_FIRMWARE_DOWNLOADER
tristate "Host Firmware Load feature for Intel ISH"
depends on INTEL_ISH_HID
depends on X86
help
The Integrated Sensor Hub (ISH) enables the kernel to offload
sensor polling and algorithm processing to a dedicated low power
processor in the chipset.
The Host Firmware Load feature adds support to load the ISH
firmware from host file system at boot.
Say M here if you want to support Host Firmware Loading feature
for Intel ISH. If unsure, say N.
endmenu
......@@ -20,4 +20,7 @@ obj-$(CONFIG_INTEL_ISH_HID) += intel-ishtp-hid.o
intel-ishtp-hid-objs := ishtp-hid.o
intel-ishtp-hid-objs += ishtp-hid-client.o
obj-$(CONFIG_INTEL_ISH_FIRMWARE_DOWNLOADER) += intel-ishtp-loader.o
intel-ishtp-loader-objs += ishtp-fw-loader.o
ccflags-y += -Idrivers/hid/intel-ish-hid/ishtp
......@@ -31,6 +31,7 @@
#define CNL_H_DEVICE_ID 0xA37C
#define ICL_MOBILE_DEVICE_ID 0x34FC
#define SPT_H_DEVICE_ID 0xA135
#define CML_LP_DEVICE_ID 0x02FC
#define REVISION_ID_CHT_A0 0x6
#define REVISION_ID_CHT_Ax_SI 0x0
......
......@@ -40,6 +40,7 @@ static const struct pci_device_id ish_pci_tbl[] = {
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, CNL_H_DEVICE_ID)},
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, ICL_MOBILE_DEVICE_ID)},
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, SPT_H_DEVICE_ID)},
{PCI_DEVICE(PCI_VENDOR_ID_INTEL, CML_LP_DEVICE_ID)},
{0, }
};
MODULE_DEVICE_TABLE(pci, ish_pci_tbl);
......
// SPDX-License-Identifier: GPL-2.0
/*
* ISH-TP client driver for ISH firmware loading
*
* Copyright (c) 2019, Intel Corporation.
*/
#include <linux/firmware.h>
#include <linux/module.h>
#include <linux/pci.h>
#include <linux/intel-ish-client-if.h>
#include <linux/property.h>
#include <asm/cacheflush.h>
/* Number of times we attempt to load the firmware before giving up */
#define MAX_LOAD_ATTEMPTS 3
/* ISH TX/RX ring buffer pool size */
#define LOADER_CL_RX_RING_SIZE 1
#define LOADER_CL_TX_RING_SIZE 1
/*
* ISH Shim firmware loader reserves 4 Kb buffer in SRAM. The buffer is
* used to temporarily hold the data transferred from host to Shim
* firmware loader. Reason for the odd size of 3968 bytes? Each IPC
* transfer is 128 bytes (= 4 bytes header + 124 bytes payload). So the
* 4 Kb buffer can hold maximum of 32 IPC transfers, which means we can
* have a max payload of 3968 bytes (= 32 x 124 payload).
*/
#define LOADER_SHIM_IPC_BUF_SIZE 3968
/**
* enum ish_loader_commands - ISH loader host commands.
* LOADER_CMD_XFER_QUERY Query the Shim firmware loader for
* capabilities
* LOADER_CMD_XFER_FRAGMENT Transfer one firmware image fragment at a
* time. The command may be executed
* multiple times until the entire firmware
* image is downloaded to SRAM.
* LOADER_CMD_START Start executing the main firmware.
*/
enum ish_loader_commands {
LOADER_CMD_XFER_QUERY = 0,
LOADER_CMD_XFER_FRAGMENT,
LOADER_CMD_START,
};
/* Command bit mask */
#define CMD_MASK GENMASK(6, 0)
#define IS_RESPONSE BIT(7)
/*
* ISH firmware max delay for one transmit failure is 1 Hz,
* and firmware will retry 2 times, so 3 Hz is used for timeout.
*/
#define ISHTP_SEND_TIMEOUT (3 * HZ)
/*
* Loader transfer modes:
*
* LOADER_XFER_MODE_ISHTP mode uses the existing ISH-TP mechanism to
* transfer data. This may use IPC or DMA if supported in firmware.
* The buffer size is limited to 4 Kb by the IPC/ISH-TP protocol for
* both IPC & DMA (legacy).
*
* LOADER_XFER_MODE_DIRECT_DMA - firmware loading is a bit different
* from the sensor data streaming. Here we download a large (300+ Kb)
* image directly to ISH SRAM memory. There is limited benefit of
* DMA'ing 300 Kb image in 4 Kb chucks limit. Hence, we introduce
* this "direct dma" mode, where we do not use ISH-TP for DMA, but
* instead manage the DMA directly in kernel driver and Shim firmware
* loader (allocate buffer, break in chucks and transfer). This allows
* to overcome 4 Kb limit, and optimize the data flow path in firmware.
*/
#define LOADER_XFER_MODE_DIRECT_DMA BIT(0)
#define LOADER_XFER_MODE_ISHTP BIT(1)
/* ISH Transport Loader client unique GUID */
static const guid_t loader_ishtp_guid =
GUID_INIT(0xc804d06a, 0x55bd, 0x4ea7,
0xad, 0xed, 0x1e, 0x31, 0x22, 0x8c, 0x76, 0xdc);
#define FILENAME_SIZE 256
/*
* The firmware loading latency will be minimum if we can DMA the
* entire ISH firmware image in one go. This requires that we allocate
* a large DMA buffer in kernel, which could be problematic on some
* platforms. So here we limit the DMA buffer size via a module_param.
* We default to 4 pages, but a customer can set it to higher limit if
* deemed appropriate for his platform.
*/
static int dma_buf_size_limit = 4 * PAGE_SIZE;
/**
* struct loader_msg_hdr - Header for ISH Loader commands.
* @command: LOADER_CMD* commands. Bit 7 is the response.
* @status: Command response status. Non 0, is error
* condition.
*
* This structure is used as header for every command/data sent/received
* between Host driver and ISH Shim firmware loader.
*/
struct loader_msg_hdr {
u8 command;
u8 reserved[2];
u8 status;
} __packed;
struct loader_xfer_query {
struct loader_msg_hdr hdr;
u32 image_size;
} __packed;
struct ish_fw_version {
u16 major;
u16 minor;
u16 hotfix;
u16 build;
} __packed;
union loader_version {
u32 value;
struct {
u8 major;
u8 minor;
u8 hotfix;
u8 build;
};
} __packed;
struct loader_capability {
u32 max_fw_image_size;
u32 xfer_mode;
u32 max_dma_buf_size; /* only for dma mode, multiples of cacheline */
} __packed;
struct shim_fw_info {
struct ish_fw_version ish_fw_version;
u32 protocol_version;
union loader_version ldr_version;
struct loader_capability ldr_capability;
} __packed;
struct loader_xfer_query_response {
struct loader_msg_hdr hdr;
struct shim_fw_info fw_info;
} __packed;
struct loader_xfer_fragment {
struct loader_msg_hdr hdr;
u32 xfer_mode;
u32 offset;
u32 size;
u32 is_last;
} __packed;
struct loader_xfer_ipc_fragment {
struct loader_xfer_fragment fragment;
u8 data[] ____cacheline_aligned; /* variable length payload here */
} __packed;
struct loader_xfer_dma_fragment {
struct loader_xfer_fragment fragment;
u64 ddr_phys_addr;
} __packed;
struct loader_start {
struct loader_msg_hdr hdr;
} __packed;
/**
* struct response_info - Encapsulate firmware response related
* information for passing between function
* loader_cl_send() and process_recv() callback.
* @data Copy the data received from firmware here.
* @max_size Max size allocated for the @data buffer. If the
* received data exceeds this value, we log an
* error.
* @size Actual size of data received from firmware.
* @error Returns 0 for success, negative error code for a
* failure in function process_recv().
* @received Set to true on receiving a valid firmware
* response to host command
* @wait_queue Wait queue for Host firmware loading where the
* client sends message to ISH firmware and waits
* for response
*/
struct response_info {
void *data;
size_t max_size;
size_t size;
int error;
bool received;
wait_queue_head_t wait_queue;
};
/**
* struct ishtp_cl_data - Encapsulate per ISH-TP Client Data.
* @work_ishtp_reset: Work queue for reset handling.
* @work_fw_load: Work queue for host firmware loading.
* @flag_retry Flag for indicating host firmware loading should
* be retried.
* @retry_count Count the number of retries.
*
* This structure is used to store data per client.
*/
struct ishtp_cl_data {
struct ishtp_cl *loader_ishtp_cl;
struct ishtp_cl_device *cl_device;
/*
* Used for passing firmware response information between
* loader_cl_send() and process_recv() callback.
*/
struct response_info response;
struct work_struct work_ishtp_reset;
struct work_struct work_fw_load;
/*
* In certain failure scenrios, it makes sense to reset the ISH
* subsystem and retry Host firmware loading (e.g. bad message
* packet, ENOMEM, etc.). On the other hand, failures due to
* protocol mismatch, etc., are not recoverable. We do not
* retry them.
*
* If set, the flag indicates that we should re-try the
* particular failure.
*/
bool flag_retry;
int retry_count;
};
#define IPC_FRAGMENT_DATA_PREAMBLE \
offsetof(struct loader_xfer_ipc_fragment, data)
#define cl_data_to_dev(client_data) ishtp_device((client_data)->cl_device)
/**
* get_firmware_variant() - Gets the filename of firmware image to be
* loaded based on platform variant.
* @client_data Client data instance.
* @filename Returns firmware filename.
*
* Queries the firmware-name device property string.
*
* Return: 0 for success, negative error code for failure.
*/
static int get_firmware_variant(struct ishtp_cl_data *client_data,
char *filename)
{
int rv;
const char *val;
struct device *devc = ishtp_get_pci_device(client_data->cl_device);
rv = device_property_read_string(devc, "firmware-name", &val);
if (rv < 0) {
dev_err(devc,
"Error: ISH firmware-name device property required\n");
return rv;
}
return snprintf(filename, FILENAME_SIZE, "intel/%s", val);
}
/**
* loader_cl_send() Send message from host to firmware
* @client_data: Client data instance
* @out_msg Message buffer to be sent to firmware
* @out_size Size of out going message
* @in_msg Message buffer where the incoming data copied.
* This buffer is allocated by calling
* @in_size Max size of incoming message
*
* Return: Number of bytes copied in the in_msg on success, negative
* error code on failure.
*/
static int loader_cl_send(struct ishtp_cl_data *client_data,
u8 *out_msg, size_t out_size,
u8 *in_msg, size_t in_size)
{
int rv;
struct loader_msg_hdr *out_hdr = (struct loader_msg_hdr *)out_msg;
struct ishtp_cl *loader_ishtp_cl = client_data->loader_ishtp_cl;
dev_dbg(cl_data_to_dev(client_data),
"%s: command=%02lx is_response=%u status=%02x\n",
__func__,
out_hdr->command & CMD_MASK,
out_hdr->command & IS_RESPONSE ? 1 : 0,
out_hdr->status);
/* Setup in coming buffer & size */
client_data->response.data = in_msg;
client_data->response.max_size = in_size;
client_data->response.error = 0;
client_data->response.received = false;
rv = ishtp_cl_send(loader_ishtp_cl, out_msg, out_size);
if (rv < 0) {
dev_err(cl_data_to_dev(client_data),
"ishtp_cl_send error %d\n", rv);
return rv;
}
wait_event_interruptible_timeout(client_data->response.wait_queue,
client_data->response.received,
ISHTP_SEND_TIMEOUT);
if (!client_data->response.received) {
dev_err(cl_data_to_dev(client_data),
"Timed out for response to command=%02lx",
out_hdr->command & CMD_MASK);
return -ETIMEDOUT;
}
if (client_data->response.error < 0)
return client_data->response.error;
return client_data->response.size;
}
/**
* process_recv() - Receive and parse incoming packet
* @loader_ishtp_cl: Client instance to get stats
* @rb_in_proc: ISH received message buffer
*
* Parse the incoming packet. If it is a response packet then it will
* update received and wake up the caller waiting to for the response.
*/
static void process_recv(struct ishtp_cl *loader_ishtp_cl,
struct ishtp_cl_rb *rb_in_proc)
{
struct loader_msg_hdr *hdr;
size_t data_len = rb_in_proc->buf_idx;
struct ishtp_cl_data *client_data =
ishtp_get_client_data(loader_ishtp_cl);
/* Sanity check */
if (!client_data->response.data) {
dev_err(cl_data_to_dev(client_data),
"Receiving buffer is null. Should be allocated by calling function\n");
client_data->response.error = -EINVAL;
goto end;
}
if (client_data->response.received) {
dev_err(cl_data_to_dev(client_data),
"Previous firmware message not yet processed\n");
client_data->response.error = -EINVAL;
goto end;
}
/*
* All firmware messages have a header. Check buffer size
* before accessing elements inside.
*/
if (!rb_in_proc->buffer.data) {
dev_warn(cl_data_to_dev(client_data),
"rb_in_proc->buffer.data returned null");
client_data->response.error = -EBADMSG;
goto end;
}
if (data_len < sizeof(struct loader_msg_hdr)) {
dev_err(cl_data_to_dev(client_data),
"data size %zu is less than header %zu\n",
data_len, sizeof(struct loader_msg_hdr));
client_data->response.error = -EMSGSIZE;
goto end;
}
hdr = (struct loader_msg_hdr *)rb_in_proc->buffer.data;
dev_dbg(cl_data_to_dev(client_data),
"%s: command=%02lx is_response=%u status=%02x\n",
__func__,
hdr->command & CMD_MASK,
hdr->command & IS_RESPONSE ? 1 : 0,
hdr->status);
if (((hdr->command & CMD_MASK) != LOADER_CMD_XFER_QUERY) &&
((hdr->command & CMD_MASK) != LOADER_CMD_XFER_FRAGMENT) &&
((hdr->command & CMD_MASK) != LOADER_CMD_START)) {
dev_err(cl_data_to_dev(client_data),
"Invalid command=%02lx\n",
hdr->command & CMD_MASK);
client_data->response.error = -EPROTO;
goto end;
}
if (data_len > client_data->response.max_size) {
dev_err(cl_data_to_dev(client_data),
"Received buffer size %zu is larger than allocated buffer %zu\n",
data_len, client_data->response.max_size);
client_data->response.error = -EMSGSIZE;
goto end;
}
/* We expect only "response" messages from firmware */
if (!(hdr->command & IS_RESPONSE)) {
dev_err(cl_data_to_dev(client_data),
"Invalid response to command\n");
client_data->response.error = -EIO;
goto end;
}
if (hdr->status) {
dev_err(cl_data_to_dev(client_data),
"Loader returned status %d\n",
hdr->status);
client_data->response.error = -EIO;
goto end;
}
/* Update the actual received buffer size */
client_data->response.size = data_len;
/*
* Copy the buffer received in firmware response for the
* calling thread.
*/
memcpy(client_data->response.data,
rb_in_proc->buffer.data, data_len);
/* Set flag before waking up the caller */
client_data->response.received = true;
end:
/* Free the buffer */
ishtp_cl_io_rb_recycle(rb_in_proc);
rb_in_proc = NULL;
/* Wake the calling thread */
wake_up_interruptible(&client_data->response.wait_queue);
}
/**
* loader_cl_event_cb() - bus driver callback for incoming message
* @device: Pointer to the ishtp client device for which this
* message is targeted
*
* Remove the packet from the list and process the message by calling
* process_recv
*/
static void loader_cl_event_cb(struct ishtp_cl_device *cl_device)
{
struct ishtp_cl_rb *rb_in_proc;
struct ishtp_cl *loader_ishtp_cl = ishtp_get_drvdata(cl_device);
while ((rb_in_proc = ishtp_cl_rx_get_rb(loader_ishtp_cl)) != NULL) {
/* Process the data packet from firmware */
process_recv(loader_ishtp_cl, rb_in_proc);
}
}
/**
* ish_query_loader_prop() - Query ISH Shim firmware loader
* @client_data: Client data instance
* @fw: Poiner to firmware data struct in host memory
* @fw_info: Loader firmware properties
*
* This function queries the ISH Shim firmware loader for capabilities.
*
* Return: 0 for success, negative error code for failure.
*/
static int ish_query_loader_prop(struct ishtp_cl_data *client_data,
const struct firmware *fw,
struct shim_fw_info *fw_info)
{
int rv;
struct loader_xfer_query ldr_xfer_query;
struct loader_xfer_query_response ldr_xfer_query_resp;
memset(&ldr_xfer_query, 0, sizeof(ldr_xfer_query));
ldr_xfer_query.hdr.command = LOADER_CMD_XFER_QUERY;
ldr_xfer_query.image_size = fw->size;
rv = loader_cl_send(client_data,
(u8 *)&ldr_xfer_query,
sizeof(ldr_xfer_query),
(u8 *)&ldr_xfer_query_resp,
sizeof(ldr_xfer_query_resp));
if (rv < 0) {
client_data->flag_retry = true;
return rv;
}
/* On success, the return value is the received buffer size */
if (rv != sizeof(struct loader_xfer_query_response)) {
dev_err(cl_data_to_dev(client_data),
"data size %d is not equal to size of loader_xfer_query_response %zu\n",
rv, sizeof(struct loader_xfer_query_response));
client_data->flag_retry = true;
return -EMSGSIZE;
}
/* Save fw_info for use outside this function */
*fw_info = ldr_xfer_query_resp.fw_info;
/* Loader firmware properties */
dev_dbg(cl_data_to_dev(client_data),
"ish_fw_version: major=%d minor=%d hotfix=%d build=%d protocol_version=0x%x loader_version=%d\n",
fw_info->ish_fw_version.major,
fw_info->ish_fw_version.minor,
fw_info->ish_fw_version.hotfix,
fw_info->ish_fw_version.build,
fw_info->protocol_version,
fw_info->ldr_version.value);
dev_dbg(cl_data_to_dev(client_data),
"loader_capability: max_fw_image_size=0x%x xfer_mode=%d max_dma_buf_size=0x%x dma_buf_size_limit=0x%x\n",
fw_info->ldr_capability.max_fw_image_size,
fw_info->ldr_capability.xfer_mode,
fw_info->ldr_capability.max_dma_buf_size,
dma_buf_size_limit);
/* Sanity checks */
if (fw_info->ldr_capability.max_fw_image_size < fw->size) {
dev_err(cl_data_to_dev(client_data),
"ISH firmware size %zu is greater than Shim firmware loader max supported %d\n",
fw->size,
fw_info->ldr_capability.max_fw_image_size);
return -ENOSPC;
}
/* For DMA the buffer size should be multiple of cacheline size */
if ((fw_info->ldr_capability.xfer_mode & LOADER_XFER_MODE_DIRECT_DMA) &&
(fw_info->ldr_capability.max_dma_buf_size % L1_CACHE_BYTES)) {
dev_err(cl_data_to_dev(client_data),
"Shim firmware loader buffer size %d should be multiple of cacheline\n",
fw_info->ldr_capability.max_dma_buf_size);
return -EINVAL;
}
return 0;
}
/**
* ish_fw_xfer_ishtp() Loads ISH firmware using ishtp interface
* @client_data: Client data instance
* @fw: Pointer to firmware data struct in host memory
*
* This function uses ISH-TP to transfer ISH firmware from host to
* ISH SRAM. Lower layers may use IPC or DMA depending on firmware
* support.
*
* Return: 0 for success, negative error code for failure.
*/
static int ish_fw_xfer_ishtp(struct ishtp_cl_data *client_data,
const struct firmware *fw)
{
int rv;
u32 fragment_offset, fragment_size, payload_max_size;
struct loader_xfer_ipc_fragment *ldr_xfer_ipc_frag;
struct loader_msg_hdr ldr_xfer_ipc_ack;
payload_max_size =
LOADER_SHIM_IPC_BUF_SIZE - IPC_FRAGMENT_DATA_PREAMBLE;
ldr_xfer_ipc_frag = kzalloc(LOADER_SHIM_IPC_BUF_SIZE, GFP_KERNEL);
if (!ldr_xfer_ipc_frag) {
client_data->flag_retry = true;
return -ENOMEM;
}
ldr_xfer_ipc_frag->fragment.hdr.command = LOADER_CMD_XFER_FRAGMENT;
ldr_xfer_ipc_frag->fragment.xfer_mode = LOADER_XFER_MODE_ISHTP;
/* Break the firmware image into fragments and send as ISH-TP payload */
fragment_offset = 0;
while (fragment_offset < fw->size) {
if (fragment_offset + payload_max_size < fw->size) {
fragment_size = payload_max_size;
ldr_xfer_ipc_frag->fragment.is_last = 0;
} else {
fragment_size = fw->size - fragment_offset;
ldr_xfer_ipc_frag->fragment.is_last = 1;
}
ldr_xfer_ipc_frag->fragment.offset = fragment_offset;
ldr_xfer_ipc_frag->fragment.size = fragment_size;
memcpy(ldr_xfer_ipc_frag->data,
&fw->data[fragment_offset],
fragment_size);
dev_dbg(cl_data_to_dev(client_data),
"xfer_mode=ipc offset=0x%08x size=0x%08x is_last=%d\n",
ldr_xfer_ipc_frag->fragment.offset,
ldr_xfer_ipc_frag->fragment.size,
ldr_xfer_ipc_frag->fragment.is_last);
rv = loader_cl_send(client_data,
(u8 *)ldr_xfer_ipc_frag,
IPC_FRAGMENT_DATA_PREAMBLE + fragment_size,
(u8 *)&ldr_xfer_ipc_ack,
sizeof(ldr_xfer_ipc_ack));
if (rv < 0) {
client_data->flag_retry = true;
goto end_err_resp_buf_release;
}
fragment_offset += fragment_size;
}
kfree(ldr_xfer_ipc_frag);
return 0;
end_err_resp_buf_release:
/* Free ISH buffer if not done already, in error case */
kfree(ldr_xfer_ipc_frag);
return rv;
}
/**
* ish_fw_xfer_direct_dma() - Loads ISH firmware using direct dma
* @client_data: Client data instance
* @fw: Pointer to firmware data struct in host memory
* @fw_info: Loader firmware properties
*
* Host firmware load is a unique case where we need to download
* a large firmware image (200+ Kb). This function implements
* direct DMA transfer in kernel and ISH firmware. This allows
* us to overcome the ISH-TP 4 Kb limit, and allows us to DMA
* directly to ISH UMA at location of choice.
* Function depends on corresponding support in ISH firmware.
*
* Return: 0 for success, negative error code for failure.
*/
static int ish_fw_xfer_direct_dma(struct ishtp_cl_data *client_data,
const struct firmware *fw,
const struct shim_fw_info fw_info)
{
int rv;
void *dma_buf;
dma_addr_t dma_buf_phy;
u32 fragment_offset, fragment_size, payload_max_size;
struct loader_msg_hdr ldr_xfer_dma_frag_ack;
struct loader_xfer_dma_fragment ldr_xfer_dma_frag;
struct device *devc = ishtp_get_pci_device(client_data->cl_device);
u32 shim_fw_buf_size =
fw_info.ldr_capability.max_dma_buf_size;
/*
* payload_max_size should be set to minimum of
* (1) Size of firmware to be loaded,
* (2) Max DMA buffer size supported by Shim firmware,
* (3) DMA buffer size limit set by boot_param dma_buf_size_limit.
*/
payload_max_size = min3(fw->size,
(size_t)shim_fw_buf_size,
(size_t)dma_buf_size_limit);
/*
* Buffer size should be multiple of cacheline size
* if it's not, select the previous cacheline boundary.
*/
payload_max_size &= ~(L1_CACHE_BYTES - 1);
dma_buf = kmalloc(payload_max_size, GFP_KERNEL | GFP_DMA32);
if (!dma_buf) {
client_data->flag_retry = true;
return -ENOMEM;
}
dma_buf_phy = dma_map_single(devc, dma_buf, payload_max_size,
DMA_TO_DEVICE);
if (dma_mapping_error(devc, dma_buf_phy)) {
dev_err(cl_data_to_dev(client_data), "DMA map failed\n");
client_data->flag_retry = true;
rv = -ENOMEM;
goto end_err_dma_buf_release;
}
ldr_xfer_dma_frag.fragment.hdr.command = LOADER_CMD_XFER_FRAGMENT;
ldr_xfer_dma_frag.fragment.xfer_mode = LOADER_XFER_MODE_DIRECT_DMA;
ldr_xfer_dma_frag.ddr_phys_addr = (u64)dma_buf_phy;
/* Send the firmware image in chucks of payload_max_size */
fragment_offset = 0;
while (fragment_offset < fw->size) {
if (fragment_offset + payload_max_size < fw->size) {
fragment_size = payload_max_size;
ldr_xfer_dma_frag.fragment.is_last = 0;
} else {
fragment_size = fw->size - fragment_offset;
ldr_xfer_dma_frag.fragment.is_last = 1;
}
ldr_xfer_dma_frag.fragment.offset = fragment_offset;
ldr_xfer_dma_frag.fragment.size = fragment_size;
memcpy(dma_buf, &fw->data[fragment_offset], fragment_size);
dma_sync_single_for_device(devc, dma_buf_phy,
payload_max_size,
DMA_TO_DEVICE);
/*
* Flush cache here because the dma_sync_single_for_device()
* does not do for x86.
*/
clflush_cache_range(dma_buf, payload_max_size);
dev_dbg(cl_data_to_dev(client_data),
"xfer_mode=dma offset=0x%08x size=0x%x is_last=%d ddr_phys_addr=0x%016llx\n",
ldr_xfer_dma_frag.fragment.offset,
ldr_xfer_dma_frag.fragment.size,
ldr_xfer_dma_frag.fragment.is_last,
ldr_xfer_dma_frag.ddr_phys_addr);
rv = loader_cl_send(client_data,
(u8 *)&ldr_xfer_dma_frag,
sizeof(ldr_xfer_dma_frag),
(u8 *)&ldr_xfer_dma_frag_ack,
sizeof(ldr_xfer_dma_frag_ack));
if (rv < 0) {
client_data->flag_retry = true;
goto end_err_resp_buf_release;
}
fragment_offset += fragment_size;
}
dma_unmap_single(devc, dma_buf_phy, payload_max_size, DMA_TO_DEVICE);
kfree(dma_buf);
return 0;
end_err_resp_buf_release:
/* Free ISH buffer if not done already, in error case */
dma_unmap_single(devc, dma_buf_phy, payload_max_size, DMA_TO_DEVICE);
end_err_dma_buf_release:
kfree(dma_buf);
return rv;
}
/**
* ish_fw_start() Start executing ISH main firmware
* @client_data: client data instance
*
* This function sends message to Shim firmware loader to start
* the execution of ISH main firmware.
*
* Return: 0 for success, negative error code for failure.
*/
static int ish_fw_start(struct ishtp_cl_data *client_data)
{
struct loader_start ldr_start;
struct loader_msg_hdr ldr_start_ack;
memset(&ldr_start, 0, sizeof(ldr_start));
ldr_start.hdr.command = LOADER_CMD_START;
return loader_cl_send(client_data,
(u8 *)&ldr_start,
sizeof(ldr_start),
(u8 *)&ldr_start_ack,
sizeof(ldr_start_ack));
}
/**
* load_fw_from_host() Loads ISH firmware from host
* @client_data: Client data instance
*
* This function loads the ISH firmware to ISH SRAM and starts execution
*
* Return: 0 for success, negative error code for failure.
*/
static int load_fw_from_host(struct ishtp_cl_data *client_data)
{
int rv;
u32 xfer_mode;
char *filename;
const struct firmware *fw;
struct shim_fw_info fw_info;
struct ishtp_cl *loader_ishtp_cl = client_data->loader_ishtp_cl;
client_data->flag_retry = false;
filename = kzalloc(FILENAME_SIZE, GFP_KERNEL);
if (!filename) {
client_data->flag_retry = true;
rv = -ENOMEM;
goto end_error;
}
/* Get filename of the ISH firmware to be loaded */
rv = get_firmware_variant(client_data, filename);
if (rv < 0)
goto end_err_filename_buf_release;
rv = request_firmware(&fw, filename, cl_data_to_dev(client_data));
if (rv < 0)
goto end_err_filename_buf_release;
/* Step 1: Query Shim firmware loader properties */
rv = ish_query_loader_prop(client_data, fw, &fw_info);
if (rv < 0)
goto end_err_fw_release;
/* Step 2: Send the main firmware image to be loaded, to ISH SRAM */
xfer_mode = fw_info.ldr_capability.xfer_mode;
if (xfer_mode & LOADER_XFER_MODE_DIRECT_DMA) {
rv = ish_fw_xfer_direct_dma(client_data, fw, fw_info);
} else if (xfer_mode & LOADER_XFER_MODE_ISHTP) {
rv = ish_fw_xfer_ishtp(client_data, fw);
} else {
dev_err(cl_data_to_dev(client_data),
"No transfer mode selected in firmware\n");
rv = -EINVAL;
}
if (rv < 0)
goto end_err_fw_release;
/* Step 3: Start ISH main firmware exeuction */
rv = ish_fw_start(client_data);
if (rv < 0)
goto end_err_fw_release;
release_firmware(fw);
kfree(filename);
dev_info(cl_data_to_dev(client_data), "ISH firmware %s loaded\n",
filename);
return 0;
end_err_fw_release:
release_firmware(fw);
end_err_filename_buf_release:
kfree(filename);
end_error:
/* Keep a count of retries, and give up after 3 attempts */
if (client_data->flag_retry &&
client_data->retry_count++ < MAX_LOAD_ATTEMPTS) {
dev_warn(cl_data_to_dev(client_data),
"ISH host firmware load failed %d. Resetting ISH, and trying again..\n",
rv);
ish_hw_reset(ishtp_get_ishtp_device(loader_ishtp_cl));
} else {
dev_err(cl_data_to_dev(client_data),
"ISH host firmware load failed %d\n", rv);
}
return rv;
}
static void load_fw_from_host_handler(struct work_struct *work)
{
struct ishtp_cl_data *client_data;
client_data = container_of(work, struct ishtp_cl_data,
work_fw_load);
load_fw_from_host(client_data);
}
/**
* loader_init() - Init function for ISH-TP client
* @loader_ishtp_cl: ISH-TP client instance
* @reset: true if called for init after reset
*
* Return: 0 for success, negative error code for failure
*/
static int loader_init(struct ishtp_cl *loader_ishtp_cl, int reset)
{
int rv;
struct ishtp_fw_client *fw_client;
struct ishtp_cl_data *client_data =
ishtp_get_client_data(loader_ishtp_cl);
dev_dbg(cl_data_to_dev(client_data), "reset flag: %d\n", reset);
rv = ishtp_cl_link(loader_ishtp_cl);
if (rv < 0) {
dev_err(cl_data_to_dev(client_data), "ishtp_cl_link failed\n");
return rv;
}
/* Connect to firmware client */
ishtp_set_tx_ring_size(loader_ishtp_cl, LOADER_CL_TX_RING_SIZE);
ishtp_set_rx_ring_size(loader_ishtp_cl, LOADER_CL_RX_RING_SIZE);
fw_client =
ishtp_fw_cl_get_client(ishtp_get_ishtp_device(loader_ishtp_cl),
&loader_ishtp_guid);
if (!fw_client) {
dev_err(cl_data_to_dev(client_data),
"ISH client uuid not found\n");
rv = -ENOENT;
goto err_cl_unlink;
}
ishtp_cl_set_fw_client_id(loader_ishtp_cl,
ishtp_get_fw_client_id(fw_client));
ishtp_set_connection_state(loader_ishtp_cl, ISHTP_CL_CONNECTING);
rv = ishtp_cl_connect(loader_ishtp_cl);
if (rv < 0) {
dev_err(cl_data_to_dev(client_data), "Client connect fail\n");
goto err_cl_unlink;
}
dev_dbg(cl_data_to_dev(client_data), "Client connected\n");
ishtp_register_event_cb(client_data->cl_device, loader_cl_event_cb);
return 0;
err_cl_unlink:
ishtp_cl_unlink(loader_ishtp_cl);
return rv;
}
static void loader_deinit(struct ishtp_cl *loader_ishtp_cl)
{
ishtp_set_connection_state(loader_ishtp_cl, ISHTP_CL_DISCONNECTING);
ishtp_cl_disconnect(loader_ishtp_cl);
ishtp_cl_unlink(loader_ishtp_cl);
ishtp_cl_flush_queues(loader_ishtp_cl);
/* Disband and free all Tx and Rx client-level rings */
ishtp_cl_free(loader_ishtp_cl);
}
static void reset_handler(struct work_struct *work)
{
int rv;
struct ishtp_cl_data *client_data;
struct ishtp_cl *loader_ishtp_cl;
struct ishtp_cl_device *cl_device;
client_data = container_of(work, struct ishtp_cl_data,
work_ishtp_reset);
loader_ishtp_cl = client_data->loader_ishtp_cl;
cl_device = client_data->cl_device;
/* Unlink, flush queues & start again */
ishtp_cl_unlink(loader_ishtp_cl);
ishtp_cl_flush_queues(loader_ishtp_cl);
ishtp_cl_free(loader_ishtp_cl);
loader_ishtp_cl = ishtp_cl_allocate(cl_device);
if (!loader_ishtp_cl)
return;
ishtp_set_drvdata(cl_device, loader_ishtp_cl);
ishtp_set_client_data(loader_ishtp_cl, client_data);
client_data->loader_ishtp_cl = loader_ishtp_cl;
client_data->cl_device = cl_device;
rv = loader_init(loader_ishtp_cl, 1);
if (rv < 0) {
dev_err(ishtp_device(cl_device), "Reset Failed\n");
return;
}
/* ISH firmware loading from host */
load_fw_from_host(client_data);
}
/**
* loader_ishtp_cl_probe() - ISH-TP client driver probe
* @cl_device: ISH-TP client device instance
*
* This function gets called on device create on ISH-TP bus
*
* Return: 0 for success, negative error code for failure
*/
static int loader_ishtp_cl_probe(struct ishtp_cl_device *cl_device)
{
struct ishtp_cl *loader_ishtp_cl;
struct ishtp_cl_data *client_data;
int rv;
client_data = devm_kzalloc(ishtp_device(cl_device),
sizeof(*client_data),
GFP_KERNEL);
if (!client_data)
return -ENOMEM;
loader_ishtp_cl = ishtp_cl_allocate(cl_device);
if (!loader_ishtp_cl)
return -ENOMEM;
ishtp_set_drvdata(cl_device, loader_ishtp_cl);
ishtp_set_client_data(loader_ishtp_cl, client_data);
client_data->loader_ishtp_cl = loader_ishtp_cl;
client_data->cl_device = cl_device;
init_waitqueue_head(&client_data->response.wait_queue);
INIT_WORK(&client_data->work_ishtp_reset,
reset_handler);
INIT_WORK(&client_data->work_fw_load,
load_fw_from_host_handler);
rv = loader_init(loader_ishtp_cl, 0);
if (rv < 0) {
ishtp_cl_free(loader_ishtp_cl);
return rv;
}
ishtp_get_device(cl_device);
client_data->retry_count = 0;
/* ISH firmware loading from host */
schedule_work(&client_data->work_fw_load);
return 0;
}
/**
* loader_ishtp_cl_remove() - ISH-TP client driver remove
* @cl_device: ISH-TP client device instance
*
* This function gets called on device remove on ISH-TP bus
*
* Return: 0
*/
static int loader_ishtp_cl_remove(struct ishtp_cl_device *cl_device)
{
struct ishtp_cl_data *client_data;
struct ishtp_cl *loader_ishtp_cl = ishtp_get_drvdata(cl_device);
client_data = ishtp_get_client_data(loader_ishtp_cl);
/*
* The sequence of the following two cancel_work_sync() is
* important. The work_fw_load can in turn schedue
* work_ishtp_reset, so first cancel work_fw_load then
* cancel work_ishtp_reset.
*/
cancel_work_sync(&client_data->work_fw_load);
cancel_work_sync(&client_data->work_ishtp_reset);
loader_deinit(loader_ishtp_cl);
ishtp_put_device(cl_device);
return 0;
}
/**
* loader_ishtp_cl_reset() - ISH-TP client driver reset
* @cl_device: ISH-TP client device instance
*
* This function gets called on device reset on ISH-TP bus
*
* Return: 0
*/
static int loader_ishtp_cl_reset(struct ishtp_cl_device *cl_device)
{
struct ishtp_cl_data *client_data;
struct ishtp_cl *loader_ishtp_cl = ishtp_get_drvdata(cl_device);
client_data = ishtp_get_client_data(loader_ishtp_cl);
schedule_work(&client_data->work_ishtp_reset);
return 0;
}
static struct ishtp_cl_driver loader_ishtp_cl_driver = {
.name = "ish-loader",
.guid = &loader_ishtp_guid,
.probe = loader_ishtp_cl_probe,
.remove = loader_ishtp_cl_remove,
.reset = loader_ishtp_cl_reset,
};
static int __init ish_loader_init(void)
{
return ishtp_cl_driver_register(&loader_ishtp_cl_driver, THIS_MODULE);
}
static void __exit ish_loader_exit(void)
{
ishtp_cl_driver_unregister(&loader_ishtp_cl_driver);
}
late_initcall(ish_loader_init);
module_exit(ish_loader_exit);
module_param(dma_buf_size_limit, int, 0644);
MODULE_PARM_DESC(dma_buf_size_limit, "Limit the DMA buf size to this value in bytes");
MODULE_DESCRIPTION("ISH ISH-TP Host firmware Loader Client Driver");
MODULE_AUTHOR("Rushikesh S Kadam <rushikesh.s.kadam@intel.com>");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("ishtp:*");
......@@ -15,15 +15,16 @@
#include <linux/module.h>
#include <linux/hid.h>
#include <linux/intel-ish-client-if.h>
#include <linux/sched.h>
#include "ishtp/ishtp-dev.h"
#include "ishtp/client.h"
#include "ishtp-hid.h"
/* Rx ring buffer pool size */
#define HID_CL_RX_RING_SIZE 32
#define HID_CL_TX_RING_SIZE 16
#define cl_data_to_dev(client_data) ishtp_device(client_data->cl_device)
/**
* report_bad_packets() - Report bad packets
* @hid_ishtp_cl: Client instance to get stats
......@@ -37,9 +38,9 @@ static void report_bad_packet(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
size_t cur_pos, size_t payload_len)
{
struct hostif_msg *recv_msg = recv_buf;
struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
dev_err(&client_data->cl_device->dev, "[hid-ish]: BAD packet %02X\n"
dev_err(cl_data_to_dev(client_data), "[hid-ish]: BAD packet %02X\n"
"total_bad=%u cur_pos=%u\n"
"[%02X %02X %02X %02X]\n"
"payload_len=%u\n"
......@@ -69,13 +70,15 @@ static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
unsigned char *payload;
struct device_info *dev_info;
int i, j;
size_t payload_len, total_len, cur_pos;
size_t payload_len, total_len, cur_pos, raw_len;
int report_type;
struct report_list *reports_list;
char *reports;
size_t report_len;
struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
int curr_hid_dev = client_data->cur_hid_dev;
struct ishtp_hid_data *hid_data = NULL;
struct hid_device *hid = NULL;
payload = recv_buf + sizeof(struct hostif_msg_hdr);
total_len = data_len;
......@@ -83,12 +86,12 @@ static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
do {
if (cur_pos + sizeof(struct hostif_msg) > total_len) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"[hid-ish]: error, received %u which is less than data header %u\n",
(unsigned int)data_len,
(unsigned int)sizeof(struct hostif_msg_hdr));
++client_data->bad_recv_cnt;
ish_hw_reset(hid_ishtp_cl->dev);
ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
break;
}
......@@ -101,7 +104,7 @@ static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
++client_data->bad_recv_cnt;
report_bad_packet(hid_ishtp_cl, recv_msg, cur_pos,
payload_len);
ish_hw_reset(hid_ishtp_cl->dev);
ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
break;
}
......@@ -116,18 +119,18 @@ static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
report_bad_packet(hid_ishtp_cl, recv_msg,
cur_pos,
payload_len);
ish_hw_reset(hid_ishtp_cl->dev);
ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
break;
}
client_data->hid_dev_count = (unsigned int)*payload;
if (!client_data->hid_devices)
client_data->hid_devices = devm_kcalloc(
&client_data->cl_device->dev,
cl_data_to_dev(client_data),
client_data->hid_dev_count,
sizeof(struct device_info),
GFP_KERNEL);
if (!client_data->hid_devices) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"Mem alloc failed for hid device info\n");
wake_up_interruptible(&client_data->init_wait);
break;
......@@ -135,7 +138,7 @@ static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
for (i = 0; i < client_data->hid_dev_count; ++i) {
if (1 + sizeof(struct device_info) * i >=
payload_len) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"[hid-ish]: [ENUM_DEVICES]: content size %zu is bigger than payload_len %zu\n",
1 + sizeof(struct device_info)
* i, payload_len);
......@@ -165,12 +168,12 @@ static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
report_bad_packet(hid_ishtp_cl, recv_msg,
cur_pos,
payload_len);
ish_hw_reset(hid_ishtp_cl->dev);
ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
break;
}
if (!client_data->hid_descr[curr_hid_dev])
client_data->hid_descr[curr_hid_dev] =
devm_kmalloc(&client_data->cl_device->dev,
devm_kmalloc(cl_data_to_dev(client_data),
payload_len, GFP_KERNEL);
if (client_data->hid_descr[curr_hid_dev]) {
memcpy(client_data->hid_descr[curr_hid_dev],
......@@ -190,12 +193,12 @@ static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
report_bad_packet(hid_ishtp_cl, recv_msg,
cur_pos,
payload_len);
ish_hw_reset(hid_ishtp_cl->dev);
ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
break;
}
if (!client_data->report_descr[curr_hid_dev])
client_data->report_descr[curr_hid_dev] =
devm_kmalloc(&client_data->cl_device->dev,
devm_kmalloc(cl_data_to_dev(client_data),
payload_len, GFP_KERNEL);
if (client_data->report_descr[curr_hid_dev]) {
memcpy(client_data->report_descr[curr_hid_dev],
......@@ -219,16 +222,29 @@ static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
/* Get index of device that matches this id */
for (i = 0; i < client_data->num_hid_devices; ++i) {
if (recv_msg->hdr.device_id ==
client_data->hid_devices[i].dev_id)
if (client_data->hid_sensor_hubs[i]) {
hid_input_report(
client_data->hid_sensor_hubs[
i],
report_type, payload,
payload_len, 0);
ishtp_hid_wakeup(
client_data->hid_sensor_hubs[
i]);
client_data->hid_devices[i].dev_id) {
hid = client_data->hid_sensor_hubs[i];
if (!hid)
break;
hid_data = hid->driver_data;
if (hid_data->raw_get_req) {
raw_len =
(hid_data->raw_buf_size <
payload_len) ?
hid_data->raw_buf_size :
payload_len;
memcpy(hid_data->raw_buf,
payload, raw_len);
} else {
hid_input_report
(hid, report_type,
payload, payload_len,
0);
}
ishtp_hid_wakeup(hid);
break;
}
}
......@@ -295,7 +311,7 @@ static void process_recv(struct ishtp_cl *hid_ishtp_cl, void *recv_buf,
++client_data->bad_recv_cnt;
report_bad_packet(hid_ishtp_cl, recv_msg, cur_pos,
payload_len);
ish_hw_reset(hid_ishtp_cl->dev);
ish_hw_reset(ishtp_get_ishtp_device(hid_ishtp_cl));
break;
}
......@@ -475,7 +491,7 @@ int ishtp_hid_link_ready_wait(struct ishtp_cl_data *client_data)
static int ishtp_enum_enum_devices(struct ishtp_cl *hid_ishtp_cl)
{
struct hostif_msg msg;
struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
int retry_count;
int rv;
......@@ -501,18 +517,18 @@ static int ishtp_enum_enum_devices(struct ishtp_cl *hid_ishtp_cl)
sizeof(struct hostif_msg));
}
if (!client_data->enum_devices_done) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"[hid-ish]: timed out waiting for enum_devices\n");
return -ETIMEDOUT;
}
if (!client_data->hid_devices) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"[hid-ish]: failed to allocate HID dev structures\n");
return -ENOMEM;
}
client_data->num_hid_devices = client_data->hid_dev_count;
dev_info(&hid_ishtp_cl->device->dev,
dev_info(ishtp_device(client_data->cl_device),
"[hid-ish]: enum_devices_done OK, num_hid_devices=%d\n",
client_data->num_hid_devices);
......@@ -531,7 +547,7 @@ static int ishtp_enum_enum_devices(struct ishtp_cl *hid_ishtp_cl)
static int ishtp_get_hid_descriptor(struct ishtp_cl *hid_ishtp_cl, int index)
{
struct hostif_msg msg;
struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
int rv;
/* Get HID descriptor */
......@@ -549,13 +565,13 @@ static int ishtp_get_hid_descriptor(struct ishtp_cl *hid_ishtp_cl, int index)
client_data->hid_descr_done,
3 * HZ);
if (!client_data->hid_descr_done) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"[hid-ish]: timed out for hid_descr_done\n");
return -EIO;
}
if (!client_data->hid_descr[index]) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"[hid-ish]: allocation HID desc fail\n");
return -ENOMEM;
}
......@@ -578,7 +594,7 @@ static int ishtp_get_report_descriptor(struct ishtp_cl *hid_ishtp_cl,
int index)
{
struct hostif_msg msg;
struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
int rv;
/* Get report descriptor */
......@@ -596,12 +612,12 @@ static int ishtp_get_report_descriptor(struct ishtp_cl *hid_ishtp_cl,
client_data->report_descr_done,
3 * HZ);
if (!client_data->report_descr_done) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"[hid-ish]: timed out for report descr\n");
return -EIO;
}
if (!client_data->report_descr[index]) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"[hid-ish]: failed to alloc report descr\n");
return -ENOMEM;
}
......@@ -626,42 +642,42 @@ static int ishtp_get_report_descriptor(struct ishtp_cl *hid_ishtp_cl,
static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset)
{
struct ishtp_device *dev;
struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
struct ishtp_fw_client *fw_client;
int i;
int rv;
dev_dbg(&client_data->cl_device->dev, "%s\n", __func__);
dev_dbg(cl_data_to_dev(client_data), "%s\n", __func__);
hid_ishtp_trace(client_data, "%s reset flag: %d\n", __func__, reset);
rv = ishtp_cl_link(hid_ishtp_cl, ISHTP_HOST_CLIENT_ID_ANY);
rv = ishtp_cl_link(hid_ishtp_cl);
if (rv) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"ishtp_cl_link failed\n");
return -ENOMEM;
}
client_data->init_done = 0;
dev = hid_ishtp_cl->dev;
dev = ishtp_get_ishtp_device(hid_ishtp_cl);
/* Connect to FW client */
hid_ishtp_cl->rx_ring_size = HID_CL_RX_RING_SIZE;
hid_ishtp_cl->tx_ring_size = HID_CL_TX_RING_SIZE;
ishtp_set_tx_ring_size(hid_ishtp_cl, HID_CL_TX_RING_SIZE);
ishtp_set_rx_ring_size(hid_ishtp_cl, HID_CL_RX_RING_SIZE);
fw_client = ishtp_fw_cl_get_client(dev, &hid_ishtp_guid);
if (!fw_client) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"ish client uuid not found\n");
return -ENOENT;
}
hid_ishtp_cl->fw_client_id = fw_client->client_id;
hid_ishtp_cl->state = ISHTP_CL_CONNECTING;
ishtp_cl_set_fw_client_id(hid_ishtp_cl,
ishtp_get_fw_client_id(fw_client));
ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_CONNECTING);
rv = ishtp_cl_connect(hid_ishtp_cl);
if (rv) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"client connect fail\n");
goto err_cl_unlink;
}
......@@ -669,7 +685,7 @@ static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset)
hid_ishtp_trace(client_data, "%s client connected\n", __func__);
/* Register read callback */
ishtp_register_event_cb(hid_ishtp_cl->device, ish_cl_event_cb);
ishtp_register_event_cb(client_data->cl_device, ish_cl_event_cb);
rv = ishtp_enum_enum_devices(hid_ishtp_cl);
if (rv)
......@@ -692,7 +708,7 @@ static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset)
if (!reset) {
rv = ishtp_hid_probe(i, client_data);
if (rv) {
dev_err(&client_data->cl_device->dev,
dev_err(cl_data_to_dev(client_data),
"[hid-ish]: HID probe for #%u failed: %d\n",
i, rv);
goto err_cl_disconnect;
......@@ -707,7 +723,7 @@ static int hid_ishtp_cl_init(struct ishtp_cl *hid_ishtp_cl, int reset)
return 0;
err_cl_disconnect:
hid_ishtp_cl->state = ISHTP_CL_DISCONNECTING;
ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_DISCONNECTING);
ishtp_cl_disconnect(hid_ishtp_cl);
err_cl_unlink:
ishtp_cl_unlink(hid_ishtp_cl);
......@@ -744,16 +760,16 @@ static void hid_ishtp_cl_reset_handler(struct work_struct *work)
hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
hid_ishtp_cl);
dev_dbg(&cl_device->dev, "%s\n", __func__);
dev_dbg(ishtp_device(client_data->cl_device), "%s\n", __func__);
hid_ishtp_cl_deinit(hid_ishtp_cl);
hid_ishtp_cl = ishtp_cl_allocate(cl_device->ishtp_dev);
hid_ishtp_cl = ishtp_cl_allocate(cl_device);
if (!hid_ishtp_cl)
return;
ishtp_set_drvdata(cl_device, hid_ishtp_cl);
hid_ishtp_cl->client_data = client_data;
ishtp_set_client_data(hid_ishtp_cl, client_data);
client_data->hid_ishtp_cl = hid_ishtp_cl;
client_data->num_hid_devices = 0;
......@@ -762,15 +778,17 @@ static void hid_ishtp_cl_reset_handler(struct work_struct *work)
rv = hid_ishtp_cl_init(hid_ishtp_cl, 1);
if (!rv)
break;
dev_err(&client_data->cl_device->dev, "Retry reset init\n");
dev_err(cl_data_to_dev(client_data), "Retry reset init\n");
}
if (rv) {
dev_err(&client_data->cl_device->dev, "Reset Failed\n");
dev_err(cl_data_to_dev(client_data), "Reset Failed\n");
hid_ishtp_trace(client_data, "%s Failed hid_ishtp_cl %p\n",
__func__, hid_ishtp_cl);
}
}
void (*hid_print_trace)(void *unused, const char *format, ...);
/**
* hid_ishtp_cl_probe() - ISHTP client driver probe
* @cl_device: ISHTP client device instance
......@@ -788,21 +806,18 @@ static int hid_ishtp_cl_probe(struct ishtp_cl_device *cl_device)
if (!cl_device)
return -ENODEV;
if (!guid_equal(&hid_ishtp_guid,
&cl_device->fw_client->props.protocol_name))
return -ENODEV;
client_data = devm_kzalloc(&cl_device->dev, sizeof(*client_data),
client_data = devm_kzalloc(ishtp_device(cl_device),
sizeof(*client_data),
GFP_KERNEL);
if (!client_data)
return -ENOMEM;
hid_ishtp_cl = ishtp_cl_allocate(cl_device->ishtp_dev);
hid_ishtp_cl = ishtp_cl_allocate(cl_device);
if (!hid_ishtp_cl)
return -ENOMEM;
ishtp_set_drvdata(cl_device, hid_ishtp_cl);
hid_ishtp_cl->client_data = client_data;
ishtp_set_client_data(hid_ishtp_cl, client_data);
client_data->hid_ishtp_cl = hid_ishtp_cl;
client_data->cl_device = cl_device;
......@@ -811,6 +826,8 @@ static int hid_ishtp_cl_probe(struct ishtp_cl_device *cl_device)
INIT_WORK(&client_data->work, hid_ishtp_cl_reset_handler);
hid_print_trace = ishtp_trace_callback(cl_device);
rv = hid_ishtp_cl_init(hid_ishtp_cl, 0);
if (rv) {
ishtp_cl_free(hid_ishtp_cl);
......@@ -832,13 +849,13 @@ static int hid_ishtp_cl_probe(struct ishtp_cl_device *cl_device)
static int hid_ishtp_cl_remove(struct ishtp_cl_device *cl_device)
{
struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
hid_ishtp_cl);
dev_dbg(&cl_device->dev, "%s\n", __func__);
hid_ishtp_cl->state = ISHTP_CL_DISCONNECTING;
dev_dbg(ishtp_device(cl_device), "%s\n", __func__);
ishtp_set_connection_state(hid_ishtp_cl, ISHTP_CL_DISCONNECTING);
ishtp_cl_disconnect(hid_ishtp_cl);
ishtp_put_device(cl_device);
ishtp_hid_remove(client_data);
......@@ -862,7 +879,7 @@ static int hid_ishtp_cl_remove(struct ishtp_cl_device *cl_device)
static int hid_ishtp_cl_reset(struct ishtp_cl_device *cl_device)
{
struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
hid_ishtp_cl);
......@@ -872,8 +889,6 @@ static int hid_ishtp_cl_reset(struct ishtp_cl_device *cl_device)
return 0;
}
#define to_ishtp_cl_device(d) container_of(d, struct ishtp_cl_device, dev)
/**
* hid_ishtp_cl_suspend() - ISHTP client driver suspend
* @device: device instance
......@@ -884,9 +899,9 @@ static int hid_ishtp_cl_reset(struct ishtp_cl_device *cl_device)
*/
static int hid_ishtp_cl_suspend(struct device *device)
{
struct ishtp_cl_device *cl_device = to_ishtp_cl_device(device);
struct ishtp_cl_device *cl_device = dev_get_drvdata(device);
struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
hid_ishtp_cl);
......@@ -905,9 +920,9 @@ static int hid_ishtp_cl_suspend(struct device *device)
*/
static int hid_ishtp_cl_resume(struct device *device)
{
struct ishtp_cl_device *cl_device = to_ishtp_cl_device(device);
struct ishtp_cl_device *cl_device = dev_get_drvdata(device);
struct ishtp_cl *hid_ishtp_cl = ishtp_get_drvdata(cl_device);
struct ishtp_cl_data *client_data = hid_ishtp_cl->client_data;
struct ishtp_cl_data *client_data = ishtp_get_client_data(hid_ishtp_cl);
hid_ishtp_trace(client_data, "%s hid_ishtp_cl %p\n", __func__,
hid_ishtp_cl);
......@@ -922,6 +937,7 @@ static const struct dev_pm_ops hid_ishtp_pm_ops = {
static struct ishtp_cl_driver hid_ishtp_cl_driver = {
.name = "ish-hid",
.guid = &hid_ishtp_guid,
.probe = hid_ishtp_cl_probe,
.remove = hid_ishtp_cl_remove,
.reset = hid_ishtp_cl_reset,
......@@ -933,7 +949,7 @@ static int __init ish_hid_init(void)
int rv;
/* Register ISHTP client device driver with ISHTP Bus */
rv = ishtp_cl_driver_register(&hid_ishtp_cl_driver);
rv = ishtp_cl_driver_register(&hid_ishtp_cl_driver, THIS_MODULE);
return rv;
......
......@@ -14,8 +14,8 @@
*/
#include <linux/hid.h>
#include <linux/intel-ish-client-if.h>
#include <uapi/linux/input.h>
#include "ishtp/client.h"
#include "ishtp-hid.h"
/**
......@@ -59,10 +59,46 @@ static void ishtp_hid_close(struct hid_device *hid)
{
}
static int ishtp_raw_request(struct hid_device *hdev, unsigned char reportnum,
__u8 *buf, size_t len, unsigned char rtype, int reqtype)
static int ishtp_raw_request(struct hid_device *hid, unsigned char reportnum,
__u8 *buf, size_t len, unsigned char rtype,
int reqtype)
{
return 0;
struct ishtp_hid_data *hid_data = hid->driver_data;
char *ishtp_buf = NULL;
size_t ishtp_buf_len;
unsigned int header_size = sizeof(struct hostif_msg);
if (rtype == HID_OUTPUT_REPORT)
return -EINVAL;
hid_data->request_done = false;
switch (reqtype) {
case HID_REQ_GET_REPORT:
hid_data->raw_buf = buf;
hid_data->raw_buf_size = len;
hid_data->raw_get_req = true;
hid_ishtp_get_report(hid, reportnum, rtype);
break;
case HID_REQ_SET_REPORT:
/*
* Spare 7 bytes for 64b accesses through
* get/put_unaligned_le64()
*/
ishtp_buf_len = len + header_size;
ishtp_buf = kzalloc(ishtp_buf_len + 7, GFP_KERNEL);
if (!ishtp_buf)
return -ENOMEM;
memcpy(ishtp_buf + header_size, buf, len);
hid_ishtp_set_feature(hid, ishtp_buf, ishtp_buf_len, reportnum);
kfree(ishtp_buf);
break;
}
hid_hw_wait(hid);
return len;
}
/**
......@@ -87,6 +123,7 @@ static void ishtp_hid_request(struct hid_device *hid, struct hid_report *rep,
hid_data->request_done = false;
switch (reqtype) {
case HID_REQ_GET_REPORT:
hid_data->raw_get_req = false;
hid_ishtp_get_report(hid, rep->id, rep->type);
break;
case HID_REQ_SET_REPORT:
......@@ -116,7 +153,6 @@ static void ishtp_hid_request(struct hid_device *hid, struct hid_report *rep,
static int ishtp_wait_for_response(struct hid_device *hid)
{
struct ishtp_hid_data *hid_data = hid->driver_data;
struct ishtp_cl_data *client_data = hid_data->client_data;
int rv;
hid_ishtp_trace(client_data, "%s hid %p\n", __func__, hid);
......@@ -204,7 +240,8 @@ int ishtp_hid_probe(unsigned int cur_hid_dev,
hid->ll_driver = &ishtp_hid_ll_driver;
hid->bus = BUS_INTEL_ISHTP;
hid->dev.parent = &client_data->cl_device->dev;
hid->dev.parent = ishtp_device(client_data->cl_device);
hid->version = le16_to_cpu(ISH_HID_VERSION);
hid->vendor = le16_to_cpu(client_data->hid_devices[cur_hid_dev].vid);
hid->product = le16_to_cpu(client_data->hid_devices[cur_hid_dev].pid);
......
......@@ -24,9 +24,9 @@
#define IS_RESPONSE 0x80
/* Used to dump to Linux trace buffer, if enabled */
extern void (*hid_print_trace)(void *unused, const char *format, ...);
#define hid_ishtp_trace(client, ...) \
client->cl_device->ishtp_dev->print_log(\
client->cl_device->ishtp_dev, __VA_ARGS__)
(hid_print_trace)(NULL, __VA_ARGS__)
/* ISH Transport protocol (ISHTP in short) GUID */
static const guid_t hid_ishtp_guid =
......@@ -159,6 +159,9 @@ struct ishtp_cl_data {
* @client_data: Link to the client instance
* @hid_wait: Completion waitq
*
* @raw_get_req: Flag indicating raw get request ongoing
* @raw_buf: raw request buffer filled on receiving get report
* @raw_buf_size: raw request buffer size
* Used to tie hid hid->driver data to driver client instance
*/
struct ishtp_hid_data {
......@@ -166,6 +169,11 @@ struct ishtp_hid_data {
bool request_done;
struct ishtp_cl_data *client_data;
wait_queue_head_t hid_wait;
/* raw request */
bool raw_get_req;
u8 *raw_buf;
size_t raw_buf_size;
};
/* Interface functions between HID LL driver and ISH TP client */
......
......@@ -170,6 +170,19 @@ struct ishtp_fw_client *ishtp_fw_cl_get_client(struct ishtp_device *dev,
}
EXPORT_SYMBOL(ishtp_fw_cl_get_client);
/**
* ishtp_get_fw_client_id() - Get fw client id
*
* This interface is used to reset HW get FW client id.
*
* Return: firmware client id.
*/
int ishtp_get_fw_client_id(struct ishtp_fw_client *fw_client)
{
return fw_client->client_id;
}
EXPORT_SYMBOL(ishtp_get_fw_client_id);
/**
* ishtp_fw_cl_by_id() - return index to fw_clients for client_id
* @dev: the ishtp device structure
......@@ -219,6 +232,26 @@ static int ishtp_cl_device_probe(struct device *dev)
return driver->probe(device);
}
/**
* ishtp_cl_bus_match() - Bus match() callback
* @dev: the device structure
* @drv: the driver structure
*
* This is a bus match callback, called when a new ishtp_cl_device is
* registered during ishtp bus client enumeration. Use the guid_t in
* drv and dev to decide whether they match or not.
*
* Return: 1 if dev & drv matches, 0 otherwise.
*/
static int ishtp_cl_bus_match(struct device *dev, struct device_driver *drv)
{
struct ishtp_cl_device *device = to_ishtp_cl_device(dev);
struct ishtp_cl_driver *driver = to_ishtp_cl_driver(drv);
return guid_equal(driver->guid,
&device->fw_client->props.protocol_name);
}
/**
* ishtp_cl_device_remove() - Bus remove() callback
* @dev: the device structure
......@@ -372,6 +405,7 @@ static struct bus_type ishtp_cl_bus_type = {
.name = "ishtp",
.dev_groups = ishtp_cl_dev_groups,
.probe = ishtp_cl_device_probe,
.match = ishtp_cl_bus_match,
.remove = ishtp_cl_device_remove,
.pm = &ishtp_cl_bus_dev_pm_ops,
.uevent = ishtp_cl_uevent,
......@@ -445,6 +479,7 @@ static struct ishtp_cl_device *ishtp_bus_add_device(struct ishtp_device *dev,
}
ishtp_device_ready = true;
dev_set_drvdata(&device->dev, device);
return device;
}
......@@ -464,7 +499,7 @@ static void ishtp_bus_remove_device(struct ishtp_cl_device *device)
}
/**
* __ishtp_cl_driver_register() - Client driver register
* ishtp_cl_driver_register() - Client driver register
* @driver: the client driver instance
* @owner: Owner of this driver module
*
......@@ -473,7 +508,7 @@ static void ishtp_bus_remove_device(struct ishtp_cl_device *device)
*
* Return: Return value of driver_register or -ENODEV if not ready
*/
int __ishtp_cl_driver_register(struct ishtp_cl_driver *driver,
int ishtp_cl_driver_register(struct ishtp_cl_driver *driver,
struct module *owner)
{
int err;
......@@ -491,7 +526,7 @@ int __ishtp_cl_driver_register(struct ishtp_cl_driver *driver,
return 0;
}
EXPORT_SYMBOL(__ishtp_cl_driver_register);
EXPORT_SYMBOL(ishtp_cl_driver_register);
/**
* ishtp_cl_driver_unregister() - Client driver unregister
......@@ -806,6 +841,59 @@ int ishtp_use_dma_transfer(void)
return ishtp_use_dma;
}
/**
* ishtp_device() - Return device pointer
*
* This interface is used to return device pointer from ishtp_cl_device
* instance.
*
* Return: device *.
*/
struct device *ishtp_device(struct ishtp_cl_device *device)
{
return &device->dev;
}
EXPORT_SYMBOL(ishtp_device);
/**
* ishtp_get_pci_device() - Return PCI device dev pointer
* This interface is used to return PCI device pointer
* from ishtp_cl_device instance.
*
* Return: device *.
*/
struct device *ishtp_get_pci_device(struct ishtp_cl_device *device)
{
return device->ishtp_dev->devc;
}
EXPORT_SYMBOL(ishtp_get_pci_device);
/**
* ishtp_trace_callback() - Return trace callback
*
* This interface is used to return trace callback function pointer.
*
* Return: void *.
*/
void *ishtp_trace_callback(struct ishtp_cl_device *cl_device)
{
return cl_device->ishtp_dev->print_log;
}
EXPORT_SYMBOL(ishtp_trace_callback);
/**
* ish_hw_reset() - Call HW reset IPC callback
*
* This interface is used to reset HW in case of error.
*
* Return: value from IPC hw_reset callback
*/
int ish_hw_reset(struct ishtp_device *dev)
{
return dev->ops->hw_reset(dev);
}
EXPORT_SYMBOL(ish_hw_reset);
/**
* ishtp_bus_register() - Function to register bus
*
......
......@@ -17,6 +17,7 @@
#include <linux/device.h>
#include <linux/mod_devicetable.h>
#include <linux/intel-ish-client-if.h>
struct ishtp_cl;
struct ishtp_cl_device;
......@@ -52,25 +53,6 @@ struct ishtp_cl_device {
void (*event_cb)(struct ishtp_cl_device *device);
};
/**
* struct ishtp_cl_device - ISHTP device handle
* @driver: driver instance on a bus
* @name: Name of the device for probe
* @probe: driver callback for device probe
* @remove: driver callback on device removal
*
* Client drivers defines to get probed/removed for ISHTP client device.
*/
struct ishtp_cl_driver {
struct device_driver driver;
const char *name;
int (*probe)(struct ishtp_cl_device *dev);
int (*remove)(struct ishtp_cl_device *dev);
int (*reset)(struct ishtp_cl_device *dev);
const struct dev_pm_ops *pm;
};
int ishtp_bus_new_client(struct ishtp_device *dev);
void ishtp_remove_all_clients(struct ishtp_device *dev);
int ishtp_cl_device_bind(struct ishtp_cl *cl);
......@@ -98,22 +80,5 @@ void ishtp_recv(struct ishtp_device *dev);
void ishtp_reset_handler(struct ishtp_device *dev);
void ishtp_reset_compl_handler(struct ishtp_device *dev);
void ishtp_put_device(struct ishtp_cl_device *);
void ishtp_get_device(struct ishtp_cl_device *);
void ishtp_set_drvdata(struct ishtp_cl_device *cl_device, void *data);
void *ishtp_get_drvdata(struct ishtp_cl_device *cl_device);
int __ishtp_cl_driver_register(struct ishtp_cl_driver *driver,
struct module *owner);
#define ishtp_cl_driver_register(driver) \
__ishtp_cl_driver_register(driver, THIS_MODULE)
void ishtp_cl_driver_unregister(struct ishtp_cl_driver *driver);
int ishtp_register_event_cb(struct ishtp_cl_device *device,
void (*read_cb)(struct ishtp_cl_device *));
int ishtp_fw_cl_by_uuid(struct ishtp_device *dev, const guid_t *cuuid);
struct ishtp_fw_client *ishtp_fw_cl_get_client(struct ishtp_device *dev,
const guid_t *uuid);
#endif /* _LINUX_ISHTP_CL_BUS_H */
......@@ -126,7 +126,7 @@ static void ishtp_cl_init(struct ishtp_cl *cl, struct ishtp_device *dev)
*
* Return: The allocated client instance or NULL on failure
*/
struct ishtp_cl *ishtp_cl_allocate(struct ishtp_device *dev)
struct ishtp_cl *ishtp_cl_allocate(struct ishtp_cl_device *cl_device)
{
struct ishtp_cl *cl;
......@@ -134,7 +134,7 @@ struct ishtp_cl *ishtp_cl_allocate(struct ishtp_device *dev)
if (!cl)
return NULL;
ishtp_cl_init(cl, dev);
ishtp_cl_init(cl, cl_device->ishtp_dev);
return cl;
}
EXPORT_SYMBOL(ishtp_cl_allocate);
......@@ -168,9 +168,6 @@ EXPORT_SYMBOL(ishtp_cl_free);
/**
* ishtp_cl_link() - Reserve a host id and link the client instance
* @cl: client device instance
* @id: host client id to use. It can be ISHTP_HOST_CLIENT_ID_ANY if any
* id from the available can be used
*
*
* This allocates a single bit in the hostmap. This function will make sure
* that not many client sessions are opened at the same time. Once allocated
......@@ -179,11 +176,11 @@ EXPORT_SYMBOL(ishtp_cl_free);
*
* Return: 0 or error code on failure
*/
int ishtp_cl_link(struct ishtp_cl *cl, int id)
int ishtp_cl_link(struct ishtp_cl *cl)
{
struct ishtp_device *dev;
unsigned long flags, flags_cl;
int ret = 0;
int id, ret = 0;
if (WARN_ON(!cl || !cl->dev))
return -EINVAL;
......@@ -197,10 +194,7 @@ int ishtp_cl_link(struct ishtp_cl *cl, int id)
goto unlock_dev;
}
/* If Id is not assigned get one*/
if (id == ISHTP_HOST_CLIENT_ID_ANY)
id = find_first_zero_bit(dev->host_clients_map,
ISHTP_CLIENTS_MAX);
id = find_first_zero_bit(dev->host_clients_map, ISHTP_CLIENTS_MAX);
if (id >= ISHTP_CLIENTS_MAX) {
spin_unlock_irqrestore(&dev->device_lock, flags);
......@@ -1069,3 +1063,45 @@ void recv_ishtp_cl_msg_dma(struct ishtp_device *dev, void *msg,
eoi:
return;
}
void *ishtp_get_client_data(struct ishtp_cl *cl)
{
return cl->client_data;
}
EXPORT_SYMBOL(ishtp_get_client_data);
void ishtp_set_client_data(struct ishtp_cl *cl, void *data)
{
cl->client_data = data;
}
EXPORT_SYMBOL(ishtp_set_client_data);
struct ishtp_device *ishtp_get_ishtp_device(struct ishtp_cl *cl)
{
return cl->dev;
}
EXPORT_SYMBOL(ishtp_get_ishtp_device);
void ishtp_set_tx_ring_size(struct ishtp_cl *cl, int size)
{
cl->tx_ring_size = size;
}
EXPORT_SYMBOL(ishtp_set_tx_ring_size);
void ishtp_set_rx_ring_size(struct ishtp_cl *cl, int size)
{
cl->rx_ring_size = size;
}
EXPORT_SYMBOL(ishtp_set_rx_ring_size);
void ishtp_set_connection_state(struct ishtp_cl *cl, int state)
{
cl->state = state;
}
EXPORT_SYMBOL(ishtp_set_connection_state);
void ishtp_cl_set_fw_client_id(struct ishtp_cl *cl, int fw_client_id)
{
cl->fw_client_id = fw_client_id;
}
EXPORT_SYMBOL(ishtp_cl_set_fw_client_id);
......@@ -19,15 +19,6 @@
#include <linux/types.h>
#include "ishtp-dev.h"
/* Client state */
enum cl_state {
ISHTP_CL_INITIALIZING = 0,
ISHTP_CL_CONNECTING,
ISHTP_CL_CONNECTED,
ISHTP_CL_DISCONNECTING,
ISHTP_CL_DISCONNECTED
};
/* Tx and Rx ring size */
#define CL_DEF_RX_RING_SIZE 2
#define CL_DEF_TX_RING_SIZE 2
......@@ -169,19 +160,4 @@ static inline bool ishtp_cl_cmp_id(const struct ishtp_cl *cl1,
(cl1->fw_client_id == cl2->fw_client_id);
}
/* exported functions from ISHTP under client management scope */
struct ishtp_cl *ishtp_cl_allocate(struct ishtp_device *dev);
void ishtp_cl_free(struct ishtp_cl *cl);
int ishtp_cl_link(struct ishtp_cl *cl, int id);
void ishtp_cl_unlink(struct ishtp_cl *cl);
int ishtp_cl_disconnect(struct ishtp_cl *cl);
int ishtp_cl_connect(struct ishtp_cl *cl);
int ishtp_cl_send(struct ishtp_cl *cl, uint8_t *buf, size_t length);
int ishtp_cl_flush_queues(struct ishtp_cl *cl);
/* exported functions from ISHTP client buffer management scope */
int ishtp_cl_io_rb_recycle(struct ishtp_cl_rb *rb);
bool ishtp_cl_tx_empty(struct ishtp_cl *cl);
struct ishtp_cl_rb *ishtp_cl_rx_get_rb(struct ishtp_cl *cl);
#endif /* _ISHTP_CLIENT_H_ */
......@@ -79,32 +79,6 @@ struct ishtp_fw_client {
uint8_t client_id;
};
/**
* struct ishtp_msg_data - ISHTP message data struct
* @size: Size of data in the *data
* @data: Pointer to data
*/
struct ishtp_msg_data {
uint32_t size;
unsigned char *data;
};
/*
* struct ishtp_cl_rb - request block structure
* @list: Link to list members
* @cl: ISHTP client instance
* @buffer: message header
* @buf_idx: Index into buffer
* @read_time: unused at this time
*/
struct ishtp_cl_rb {
struct list_head list;
struct ishtp_cl *cl;
struct ishtp_msg_data buffer;
unsigned long buf_idx;
unsigned long read_time;
};
/*
* Control info for IPC messages ISHTP/IPC sending FIFO -
* list with inline data buffer
......@@ -264,11 +238,6 @@ static inline int ish_ipc_reset(struct ishtp_device *dev)
return dev->ops->ipc_reset(dev);
}
static inline int ish_hw_reset(struct ishtp_device *dev)
{
return dev->ops->hw_reset(dev);
}
/* Exported function */
void ishtp_device_init(struct ishtp_device *dev);
int ishtp_start(struct ishtp_device *dev);
......
......@@ -382,6 +382,7 @@ struct hid_item {
#define HID_GROUP_WACOM 0x0101
#define HID_GROUP_LOGITECH_DJ_DEVICE 0x0102
#define HID_GROUP_STEAM 0x0103
#define HID_GROUP_LOGITECH_27MHZ_DEVICE 0x0104
/*
* HID protocol status
......@@ -417,6 +418,7 @@ struct hid_global {
struct hid_local {
unsigned usage[HID_MAX_USAGES]; /* usage array */
u8 usage_size[HID_MAX_USAGES]; /* usage size array */
unsigned collection_index[HID_MAX_USAGES]; /* collection index array */
unsigned usage_index;
unsigned usage_minimum;
......@@ -893,7 +895,7 @@ struct hid_field *hidinput_get_led_field(struct hid_device *hid);
unsigned int hidinput_count_leds(struct hid_device *hid);
__s32 hidinput_calc_abs_res(const struct hid_field *field, __u16 code);
void hid_output_report(struct hid_report *report, __u8 *data);
void __hid_request(struct hid_device *hid, struct hid_report *rep, int reqtype);
int __hid_request(struct hid_device *hid, struct hid_report *rep, int reqtype);
u8 *hid_alloc_report_buf(struct hid_report *report, gfp_t flags);
struct hid_device *hid_allocate_device(void);
struct hid_report *hid_register_report(struct hid_device *device,
......
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Intel ISH client Interface definitions
*
* Copyright (c) 2019, Intel Corporation.
*/
#ifndef _INTEL_ISH_CLIENT_IF_H_
#define _INTEL_ISH_CLIENT_IF_H_
struct ishtp_cl_device;
struct ishtp_device;
struct ishtp_cl;
struct ishtp_fw_client;
/* Client state */
enum cl_state {
ISHTP_CL_INITIALIZING = 0,
ISHTP_CL_CONNECTING,
ISHTP_CL_CONNECTED,
ISHTP_CL_DISCONNECTING,
ISHTP_CL_DISCONNECTED
};
/**
* struct ishtp_cl_device - ISHTP device handle
* @driver: driver instance on a bus
* @name: Name of the device for probe
* @probe: driver callback for device probe
* @remove: driver callback on device removal
*
* Client drivers defines to get probed/removed for ISHTP client device.
*/
struct ishtp_cl_driver {
struct device_driver driver;
const char *name;
const guid_t *guid;
int (*probe)(struct ishtp_cl_device *dev);
int (*remove)(struct ishtp_cl_device *dev);
int (*reset)(struct ishtp_cl_device *dev);
const struct dev_pm_ops *pm;
};
/**
* struct ishtp_msg_data - ISHTP message data struct
* @size: Size of data in the *data
* @data: Pointer to data
*/
struct ishtp_msg_data {
uint32_t size;
unsigned char *data;
};
/*
* struct ishtp_cl_rb - request block structure
* @list: Link to list members
* @cl: ISHTP client instance
* @buffer: message header
* @buf_idx: Index into buffer
* @read_time: unused at this time
*/
struct ishtp_cl_rb {
struct list_head list;
struct ishtp_cl *cl;
struct ishtp_msg_data buffer;
unsigned long buf_idx;
unsigned long read_time;
};
int ishtp_cl_driver_register(struct ishtp_cl_driver *driver,
struct module *owner);
void ishtp_cl_driver_unregister(struct ishtp_cl_driver *driver);
int ishtp_register_event_cb(struct ishtp_cl_device *device,
void (*read_cb)(struct ishtp_cl_device *));
/* Get the device * from ishtp device instance */
struct device *ishtp_device(struct ishtp_cl_device *cl_device);
/* Trace interface for clients */
void *ishtp_trace_callback(struct ishtp_cl_device *cl_device);
/* Get device pointer of PCI device for DMA acces */
struct device *ishtp_get_pci_device(struct ishtp_cl_device *cl_device);
struct ishtp_cl *ishtp_cl_allocate(struct ishtp_cl_device *cl_device);
void ishtp_cl_free(struct ishtp_cl *cl);
int ishtp_cl_link(struct ishtp_cl *cl);
void ishtp_cl_unlink(struct ishtp_cl *cl);
int ishtp_cl_disconnect(struct ishtp_cl *cl);
int ishtp_cl_connect(struct ishtp_cl *cl);
int ishtp_cl_send(struct ishtp_cl *cl, uint8_t *buf, size_t length);
int ishtp_cl_flush_queues(struct ishtp_cl *cl);
int ishtp_cl_io_rb_recycle(struct ishtp_cl_rb *rb);
bool ishtp_cl_tx_empty(struct ishtp_cl *cl);
struct ishtp_cl_rb *ishtp_cl_rx_get_rb(struct ishtp_cl *cl);
void *ishtp_get_client_data(struct ishtp_cl *cl);
void ishtp_set_client_data(struct ishtp_cl *cl, void *data);
struct ishtp_device *ishtp_get_ishtp_device(struct ishtp_cl *cl);
void ishtp_set_tx_ring_size(struct ishtp_cl *cl, int size);
void ishtp_set_rx_ring_size(struct ishtp_cl *cl, int size);
void ishtp_set_connection_state(struct ishtp_cl *cl, int state);
void ishtp_cl_set_fw_client_id(struct ishtp_cl *cl, int fw_client_id);
void ishtp_put_device(struct ishtp_cl_device *cl_dev);
void ishtp_get_device(struct ishtp_cl_device *cl_dev);
void ishtp_set_drvdata(struct ishtp_cl_device *cl_device, void *data);
void *ishtp_get_drvdata(struct ishtp_cl_device *cl_device);
int ishtp_register_event_cb(struct ishtp_cl_device *device,
void (*read_cb)(struct ishtp_cl_device *));
struct ishtp_fw_client *ishtp_fw_cl_get_client(struct ishtp_device *dev,
const guid_t *uuid);
int ishtp_get_fw_client_id(struct ishtp_fw_client *fw_client);
int ish_hw_reset(struct ishtp_device *dev);
#endif /* _INTEL_ISH_CLIENT_IF_H_ */
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment