Hi guys,
just a little up to this patch, and a more technical question:
On Thu, Aug 25, 2011 at 10:11, Benjamin Tissoires
<benjamin.tissoires@xxxxxxxxx> wrote:
> From: Nestor Lopez Casado <nlopezcasad@xxxxxxxxxxxx>
>
> With this driver, all the devices paired to a single Unifying
> receiver are exposed to user processes in separated /input/dev
> nodes.
>
> Keyboards with different layouts can be treated differently,
> Multiplayer games on single PC (like home theater PC) can
> differentiate input coming from different kbds paired to the
> same receiver.
>
> Up to now, when Logitech Unifying receivers are connected to a
> Linux based system, a single keyboard and a single mouse are
> presented to the HID Layer, even if the Unifying receiver can
> pair up to six compatible devices. The Unifying receiver by default
> multiplexes all incoming events (from multiple keyboards/mice)
> into these two.
>
> Signed-off-by: Nestor Lopez Casado <nlopezcasad@xxxxxxxxxxxx>
> Signed-off-by: Benjamin Tissoires <btissoires@xxxxxxxxxxxx>
> ---
>
> Hi guys,
>
> this is the third version of the unifying receiver. I made the changes requested
> by Dmitry:
> - switch to kfifo
> - introduce __func__ in all debugs/errors messages
> - in logi_dj_ll_input_event, do not use the report of the device, but a copy
> (is it the right way to do it to avoid the DMA problem?)
> - switch to BUS_USB for the created devices
> - small other cosmetic changes
>
> One side note:
> We really thing using BUS_USB is not the right way to do it when we will have
> more drivers:
> by keeping it, we will have no choice but to provide the VIP/PID of the
> receiver to the created devices. We then will have to handle a manual parsing
> of the wireless id to know which driver to use. This will result in having
> all the Logitech's drivers loaded when someone plug an unifying receiver.
> if we switch to a new BUS_DJ, we could then rely on the automatic user-space
> loading of the drivers to load only the right drivers.
>
> BTW, as long as Logitech does not provide those drivers (I hope they will come
> out soon), there is no point using BUS_DJ. So it's fine not using it right now.
>
> Thanks,
> Benjamin
>
> drivers/hid/Kconfig | 9 +
> drivers/hid/Makefile | 1 +
> drivers/hid/hid-core.c | 2 +
> drivers/hid/hid-ids.h | 2 +
> drivers/hid/hid-logitech-dj.c | 893 +++++++++++++++++++++++++++++++++++++++++
> drivers/hid/hid-logitech-dj.h | 123 ++++++
> 6 files changed, 1030 insertions(+), 0 deletions(-)
> create mode 100644 drivers/hid/hid-logitech-dj.c
> create mode 100644 drivers/hid/hid-logitech-dj.h
>
> diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
> index 36ca465..0eb7f04 100644
> --- a/drivers/hid/Kconfig
> +++ b/drivers/hid/Kconfig
> @@ -231,6 +231,15 @@ config HID_LOGITECH
> ---help---
> Support for Logitech devices that are not fully compliant with HID standard.
>
> +config HID_LOGITECH_DJ
> + tristate "Logitech Unifying receivers full support"
> + depends on HID_LOGITECH
> + default m
> + ---help---
> + Say Y if you want support for Logitech Unifying receivers and devices.
> + Unifying receivers are capable of pairing up to 6 Logitech compliant
> + devices to the same receiver.
> +
> config LOGITECH_FF
> bool "Logitech force feedback support"
> depends on HID_LOGITECH
> diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
> index a24cee4..3aba5e7 100644
> --- a/drivers/hid/Makefile
> +++ b/drivers/hid/Makefile
> @@ -44,6 +44,7 @@ obj-$(CONFIG_HID_KEYTOUCH) += hid-keytouch.o
> obj-$(CONFIG_HID_KYE) += hid-kye.o
> obj-$(CONFIG_HID_LCPOWER) += hid-lcpower.o
> obj-$(CONFIG_HID_LOGITECH) += hid-logitech.o
> +obj-$(CONFIG_HID_LOGITECH_DJ) += hid-logitech-dj.o
> obj-$(CONFIG_HID_MAGICMOUSE) += hid-magicmouse.o
> obj-$(CONFIG_HID_MICROSOFT) += hid-microsoft.o
> obj-$(CONFIG_HID_MONTEREY) += hid-monterey.o
> diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
> index b0e618b..ebe4fdd 100644
> --- a/drivers/hid/hid-core.c
> +++ b/drivers/hid/hid-core.c
> @@ -1423,6 +1423,8 @@ static const struct hid_device_id hid_have_special_driver[] = {
> { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL) },
> { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL) },
> { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL) },
> + { 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) },
> { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL) },
> { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2) },
> { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER) },
> diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
> index a756ee6..c42764b 100644
> --- a/drivers/hid/hid-ids.h
> +++ b/drivers/hid/hid-ids.h
> @@ -440,6 +440,8 @@
> #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_UNIFYING_RECEIVER 0xc52b
> +#define USB_DEVICE_ID_LOGITECH_UNIFYING_RECEIVER_2 0xc532
> #define USB_DEVICE_ID_SPACETRAVELLER 0xc623
> #define USB_DEVICE_ID_SPACENAVIGATOR 0xc626
> #define USB_DEVICE_ID_DINOVO_DESKTOP 0xc704
> diff --git a/drivers/hid/hid-logitech-dj.c b/drivers/hid/hid-logitech-dj.c
> new file mode 100644
> index 0000000..896328d
> --- /dev/null
> +++ b/drivers/hid/hid-logitech-dj.c
> @@ -0,0 +1,893 @@
> +/*
> + * HID driver for Logitech Unifying receivers
> + *
> + * Copyright (c) 2011 Logitech (c)
> + */
> +
> +/*
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> +
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
> + *
> + * Should you need to contact me, the author, you can do so by e-mail send
> + * your message to Nestor Lopez Casado <xnlopez at gmail com>
> + *
> + */
> +
> +
> +#include <linux/device.h>
> +#include <linux/hid.h>
> +#include <linux/module.h>
> +#include <linux/usb.h>
> +#include "usbhid/usbhid.h"
> +#include "hid-ids.h"
> +#include "hid-logitech-dj.h"
> +
> +/* Keyboard descriptor (1) */
> +static const char kbd_descriptor[] = {
> + 0x05, 0x01, /* USAGE_PAGE (generic Desktop) */
> + 0x09, 0x06, /* USAGE (Keyboard) */
> + 0xA1, 0x01, /* COLLECTION (Application) */
> + 0x85, 0x01, /* REPORT_ID (1) */
> + 0x95, 0x08, /* REPORT_COUNT (8) */
> + 0x75, 0x01, /* REPORT_SIZE (1) */
> + 0x15, 0x00, /* LOGICAL_MINIMUM (0) */
> + 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */
> + 0x05, 0x07, /* USAGE_PAGE (Keyboard) */
> + 0x19, 0xE0, /* USAGE_MINIMUM (Left Control) */
> + 0x29, 0xE7, /* USAGE_MAXIMUM (Right GUI) */
> + 0x81, 0x02, /* INPUT (Data,Var,Abs) */
> + 0x95, 0x05, /* REPORT COUNT (5) */
> + 0x05, 0x08, /* USAGE PAGE (LED page) */
> + 0x19, 0x01, /* USAGE MINIMUM (1) */
> + 0x29, 0x05, /* USAGE MAXIMUM (5) */
> + 0x91, 0x02, /* OUTPUT (Data, Variable, Absolute) */
> + 0x95, 0x01, /* REPORT COUNT (1) */
> + 0x75, 0x03, /* REPORT SIZE (3) */
> + 0x91, 0x01, /* OUTPUT (Constant) */
> + 0x95, 0x06, /* REPORT_COUNT (6) */
> + 0x75, 0x08, /* REPORT_SIZE (8) */
> + 0x15, 0x00, /* LOGICAL_MINIMUM (0) */
> + 0x26, 0xFF, 0x00, /* LOGICAL_MAXIMUM (255) */
> + 0x05, 0x07, /* USAGE_PAGE (Keyboard) */
> + 0x19, 0x00, /* USAGE_MINIMUM (no event) */
> + 0x2A, 0xFF, 0x00, /* USAGE_MAXIMUM (reserved) */
> + 0x81, 0x00, /* INPUT (Data,Ary,Abs) */
> + 0xC0
> +};
> +
> +/* Mouse descriptor (2) */
> +static const char mse_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, 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 */
> +};
> +
> +/* Consumer Control descriptor (3) */
> +static const char consumer_descriptor[] = {
> + 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, 0x8C, 0x02, /* LOGICAL_MAX (652) */
> + 0x19, 0x01, /* USAGE_MIN (1) */
> + 0x2A, 0x8C, 0x02, /* USAGE_MAX (652) */
> + 0x81, 0x00, /* INPUT (Data Ary Abs) */
> + 0xC0, /* END_COLLECTION */
> +}; /* */
> +
> +/* System control descriptor (4) */
> +static const char syscontrol_descriptor[] = {
> + 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */
> + 0x09, 0x80, /* USAGE (System Control) */
> + 0xA1, 0x01, /* COLLECTION (Application) */
> + 0x85, 0x04, /* REPORT_ID = 4 */
> + 0x75, 0x02, /* REPORT_SIZE (2) */
> + 0x95, 0x01, /* REPORT_COUNT (1) */
> + 0x15, 0x01, /* LOGICAL_MIN (1) */
> + 0x25, 0x03, /* LOGICAL_MAX (3) */
> + 0x09, 0x82, /* USAGE (System Sleep) */
> + 0x09, 0x81, /* USAGE (System Power Down) */
> + 0x09, 0x83, /* USAGE (System Wake Up) */
> + 0x81, 0x60, /* INPUT (Data Ary Abs NPrf Null) */
> + 0x75, 0x06, /* REPORT_SIZE (6) */
> + 0x81, 0x03, /* INPUT (Cnst Var Abs) */
> + 0xC0, /* END_COLLECTION */
> +};
> +
> +/* Media descriptor (8) */
> +static const char media_descriptor[] = {
> + 0x06, 0xbc, 0xff, /* Usage Page 0xffbc */
> + 0x09, 0x88, /* Usage 0x0088 */
> + 0xa1, 0x01, /* BeginCollection */
> + 0x85, 0x08, /* Report ID 8 */
> + 0x19, 0x01, /* Usage Min 0x0001 */
> + 0x29, 0xff, /* Usage Max 0x00ff */
> + 0x15, 0x01, /* Logical Min 1 */
> + 0x26, 0xff, 0x00, /* Logical Max 255 */
> + 0x75, 0x08, /* Report Size 8 */
> + 0x95, 0x01, /* Report Count 1 */
> + 0x81, 0x00, /* Input */
> + 0xc0, /* EndCollection */
> +}; /* */
> +
> +/* Maximum size of all defined hid reports in bytes (including report id) */
> +#define MAX_REPORT_SIZE 8
> +
> +/* Number of possible hid report types that can be created by this driver.
> + *
> + * Right now, RF report types have the same report types (or report id's)
> + * than the hid report created from those RF reports. In the future
> + * this doesnt have to be true.
> + *
> + * For instance, RF report type 0x01 which has a size of 8 bytes, corresponds
> + * to hid report id 0x01, this is standard keyboard. Same thing applies to mice
> + * reports and consumer control, etc. If a new RF report is created, it doesn't
> + * has to have the same report id as its corresponding hid report, so an
> + * translation may have to take place for future report types.
> + */
> +#define NUMBER_OF_HID_REPORTS 32
> +static const u8 hid_reportid_size_map[NUMBER_OF_HID_REPORTS] = {
> + [1] = 8, /* Standard keyboard */
> + [2] = 8, /* Standard mouse */
> + [3] = 5, /* Consumer control */
> + [4] = 2, /* System control */
> + [8] = 2, /* Media Center */
> +};
> +
> +
> +#define LOGITECH_DJ_INTERFACE_NUMBER 0x02
> +
> +static struct hid_ll_driver logi_dj_ll_driver;
> +
> +static int logi_dj_output_hidraw_report(struct hid_device *hid, u8 * buf,
> + size_t count,
> + unsigned char report_type);
> +
> +static void logi_dj_recv_destroy_djhid_device(struct dj_receiver_dev *djrcv_dev,
> + struct dj_report *dj_report)
> +{
> + /* 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;
> + 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",
> + __func__);
> + }
> +}
> +
> +static void logi_dj_recv_add_djhid_device(struct dj_receiver_dev *djrcv_dev,
> + struct dj_report *dj_report)
> +{
> + /* 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 *dj_hiddev;
> + struct dj_device *dj_dev;
> + unsigned char tmpstr[20];
> +
> + if (dj_report->report_params[DEVICE_PAIRED_PARAM_SPFUNCTION] &
> + SPFUNCTION_DEVICE_LIST_EMPTY) {
> + dbg_hid("%s: device list is empty\n", __func__);
> + return;
> + }
> +
> + dj_hiddev = hid_allocate_device();
> + if (IS_ERR(dj_hiddev)) {
> + dev_err(&djrcv_hdev->dev, "%s: hid_allocate_device failed\n",
> + __func__);
> + return;
> + }
> +
> + dj_hiddev->ll_driver = &logi_dj_ll_driver;
> + dj_hiddev->hid_output_raw_report = logi_dj_output_hidraw_report;
> +
> + dj_hiddev->dev.parent = &djrcv_hdev->dev;
> + dj_hiddev->bus = BUS_USB;
> + dj_hiddev->vendor = le16_to_cpu(usbdev->descriptor.idVendor);
> + dj_hiddev->product = le16_to_cpu(usbdev->descriptor.idProduct);
> + snprintf(dj_hiddev->name, sizeof(dj_hiddev->name),
> + "Logitech Unifying Device. Wireless PID:%02x%02x",
> + dj_report->report_params[DEVICE_PAIRED_PARAM_EQUAD_ID_MSB],
> + dj_report->report_params[DEVICE_PAIRED_PARAM_EQUAD_ID_LSB]);
> +
> + usb_make_path(usbdev, dj_hiddev->phys, sizeof(dj_hiddev->phys));
> + snprintf(tmpstr, sizeof(tmpstr), ":%d", dj_report->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__);
> + goto dj_device_allocate_fail;
> + }
> +
> + dj_dev->reports_supported = le32_to_cpu(
> + dj_report->report_params[DEVICE_PAIRED_RF_REPORT_TYPE]);
> + dj_dev->hdev = dj_hiddev;
> + dj_dev->dj_receiver_dev = djrcv_dev;
> + dj_dev->device_index = dj_report->device_index;
> + dj_hiddev->driver_data = dj_dev;
> +
> + djrcv_dev->paired_dj_devices[dj_report->device_index] = dj_dev;
> +
> + if (hid_add_device(dj_hiddev)) {
> + dev_err(&djrcv_hdev->dev, "%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;
> + kfree(dj_dev);
> +dj_device_allocate_fail:
> + hid_destroy_device(dj_hiddev);
> +}
> +
> +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;
> + unsigned long flags;
> + int count;
> +
> + dbg_hid("%s\n", __func__);
> +
> + spin_lock_irqsave(&djrcv_dev->lock, flags);
> +
> + count = kfifo_out(&djrcv_dev->notif_fifo, &dj_report,
> + sizeof(struct dj_report));
> +
> + if (count != sizeof(struct dj_report)) {
> + dev_err(&djrcv_dev->hdev->dev, "%s: workitem triggered without "
> + "notifications available\n", __func__);
> + 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__);
> + }
> + }
> +
> + spin_unlock_irqrestore(&djrcv_dev->lock, flags);
> +
> + switch (dj_report.report_type) {
> + case REPORT_TYPE_NOTIF_DEVICE_PAIRED:
> + logi_dj_recv_add_djhid_device(djrcv_dev, &dj_report);
> + break;
> + case REPORT_TYPE_NOTIF_DEVICE_UNPAIRED:
> + logi_dj_recv_destroy_djhid_device(djrcv_dev, &dj_report);
> + break;
> + default:
> + dbg_hid("%s: unexpected report type\n", __func__);
> + }
> +}
> +
> +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) */
> +
> + 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__);
> + }
> +}
> +
> +static void logi_dj_recv_forward_null_report(struct dj_receiver_dev *djrcv_dev,
> + struct dj_report *dj_report)
> +{
> + /* We are called from atomic context (tasklet && djrcv->lock held) */
> + unsigned int i;
> + u8 reportbuffer[MAX_REPORT_SIZE];
> + struct dj_device *djdev;
> +
> + djdev = djrcv_dev->paired_dj_devices[dj_report->device_index];
> +
> + if (!djdev) {
> + dbg_hid("djrcv_dev->paired_dj_devices[dj_report->device_index]"
> + " is NULL, index %d\n", dj_report->device_index);
> + return;
> + }
> +
> + memset(reportbuffer, 0, sizeof(reportbuffer));
> +
> + for (i = 0; i < NUMBER_OF_HID_REPORTS; i++) {
> + if (djdev->reports_supported & (1 << i)) {
> + reportbuffer[0] = i;
> + if (hid_input_report(djdev->hdev,
> + HID_INPUT_REPORT,
> + reportbuffer,
> + hid_reportid_size_map[i], 1)) {
> + dbg_hid("hid_input_report error sending null "
> + "report\n");
> + }
> + }
> + }
> +}
> +
> +static void logi_dj_recv_forward_report(struct dj_receiver_dev *djrcv_dev,
> + struct dj_report *dj_report)
> +{
> + /* We are called from atomic context (tasklet && djrcv->lock held) */
> + struct dj_device *dj_device;
> +
> + dj_device = djrcv_dev->paired_dj_devices[dj_report->device_index];
> +
> + if (dj_device == NULL) {
> + dbg_hid("djrcv_dev->paired_dj_devices[dj_report->device_index]"
> + " is NULL, index %d\n", dj_report->device_index);
> + return;
> + }
> +
> + if ((dj_report->report_type > ARRAY_SIZE(hid_reportid_size_map) - 1) ||
> + (hid_reportid_size_map[dj_report->report_type] == 0)) {
> + dbg_hid("invalid report type:%x\n", dj_report->report_type);
> + return;
> + }
> +
> + if (hid_input_report(dj_device->hdev,
> + HID_INPUT_REPORT, &dj_report->report_type,
> + hid_reportid_size_map[dj_report->report_type], 1)) {
> + dbg_hid("hid_input_report error\n");
> + }
> +}
> +
> +
> +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;
> + int sent_bytes;
> +
> + if (!hdev->hid_output_raw_report) {
> + dev_err(&hdev->dev, "%s:"
> + "hid_output_raw_report is null\n", __func__);
> + return -ENODEV;
> + }
> +
> + sent_bytes = hdev->hid_output_raw_report(hdev, (u8 *) dj_report,
> + sizeof(struct dj_report),
> + HID_OUTPUT_REPORT);
> +
> + return (sent_bytes < 0) ? sent_bytes : 0;
> +}
> +
> +static int logi_dj_recv_query_paired_devices(struct dj_receiver_dev *djrcv_dev)
> +{
> + struct dj_report dj_report;
> +
> + memset(&dj_report, 0, sizeof(dj_report));
> + dj_report.report_id = REPORT_ID_DJ_SHORT;
> + dj_report.device_index = 0xFF;
> + dj_report.report_type = REPORT_TYPE_CMD_GET_PAIRED_DEVICES;
> + return logi_dj_recv_send_report(djrcv_dev, &dj_report);
> +}
> +
> +static int logi_dj_recv_switch_to_dj_mode(struct dj_receiver_dev *djrcv_dev,
> + unsigned timeout)
> +{
> + struct dj_report dj_report;
> +
> + memset(&dj_report, 0, sizeof(dj_report));
> + 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] = 0x1F;
> + dj_report.report_params[CMD_SWITCH_PARAM_TIMEOUT_SECONDS] = (u8)timeout;
> + return logi_dj_recv_send_report(djrcv_dev, &dj_report);
> +}
> +
> +
> +static int logi_dj_ll_open(struct hid_device *hid)
> +{
> + 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);
> +}
> +
> +static int logi_dj_output_hidraw_report(struct hid_device *hid, u8 * buf,
> + size_t count,
> + unsigned char report_type)
> +{
> + /* Called by hid raw to send data */
> + dbg_hid("%s\n", __func__);
> +
> + return 0;
> +}
> +
> +static int logi_dj_ll_parse(struct hid_device *hid)
> +{
> + struct dj_device *djdev = hid->driver_data;
> + int retval;
> +
> + dbg_hid("%s\n", __func__);
> +
> + djdev->hdev->version = 0x0111;
> + djdev->hdev->country = 0x00;
> +
> + if (djdev->reports_supported & STD_KEYBOARD) {
> + dbg_hid("%s: sending a kbd descriptor, reports_supported: %x\n",
> + __func__, djdev->reports_supported);
> + retval = hid_parse_report(hid,
> + (u8 *) kbd_descriptor,
> + sizeof(kbd_descriptor));
> + if (retval) {
> + dbg_hid("%s: sending a kbd descriptor, hid_parse failed"
> + " error: %d\n", __func__, retval);
> + return retval;
> + }
> + }
> +
> + if (djdev->reports_supported & STD_MOUSE) {
> + dbg_hid("%s: sending a mouse descriptor, reports_supported: "
> + "%x\n", __func__, djdev->reports_supported);
> + retval = hid_parse_report(hid,
> + (u8 *) mse_descriptor,
> + sizeof(mse_descriptor));
> + if (retval) {
> + dbg_hid("%s: sending a mouse descriptor, hid_parse "
> + "failed error: %d\n", __func__, retval);
> + return retval;
> + }
> + }
> +
> + if (djdev->reports_supported & MULTIMEDIA) {
> + dbg_hid("%s: sending a multimedia report descriptor: %x\n",
> + __func__, djdev->reports_supported);
> + retval = hid_parse_report(hid,
> + (u8 *) consumer_descriptor,
> + sizeof(consumer_descriptor));
> + if (retval) {
> + dbg_hid("%s: sending a consumer_descriptor, hid_parse "
> + "failed error: %d\n", __func__, retval);
> + return retval;
> + }
> + }
> +
> + if (djdev->reports_supported & POWER_KEYS) {
> + dbg_hid("%s: sending a power keys report descriptor: %x\n",
> + __func__, djdev->reports_supported);
> + retval = hid_parse_report(hid,
> + (u8 *) syscontrol_descriptor,
> + sizeof(syscontrol_descriptor));
> + if (retval) {
> + dbg_hid("%s: sending a syscontrol_descriptor, "
> + "hid_parse failed error: %d\n",
> + __func__, retval);
> + return retval;
> + }
> + }
> +
> + if (djdev->reports_supported & MEDIA_CENTER) {
> + dbg_hid("%s: sending a media center report descriptor: %x\n",
> + __func__, djdev->reports_supported);
> + retval = hid_parse_report(hid,
> + (u8 *) media_descriptor,
> + sizeof(media_descriptor));
> + if (retval) {
> + dbg_hid("%s: sending a media_descriptor, hid_parse "
> + "failed error: %d\n", __func__, retval);
> + return retval;
> + }
> + }
> +
> + if (djdev->reports_supported & KBD_LEDS) {
> + dbg_hid("%s: need to send kbd leds report descriptor: %x\n",
> + __func__, djdev->reports_supported);
> + }
> +
> + return 0;
> +}
> +
> +static int logi_dj_ll_input_event(struct input_dev *dev, unsigned int type,
> + unsigned int code, int value)
> +{
> + /* Sent by the input layer to handle leds and Force Feedback */
> + struct hid_device *dj_hiddev = input_get_drvdata(dev);
> + struct dj_device *dj_dev = dj_hiddev->driver_data;
> +
> + struct dj_receiver_dev *djrcv_dev =
> + dev_get_drvdata(dj_hiddev->dev.parent);
> + struct hid_device *dj_rcv_hiddev = djrcv_dev->hdev;
> + struct hid_report_enum *output_report_enum;
> +
> + struct hid_field *field;
> + struct hid_report report;
> + unsigned char data[8];
> + int offset;
> +
> + dbg_hid("%s: %s, type:%d | code:%d | value:%d\n",
> + __func__, dev->phys, type, code, value);
> +
> + if (type != EV_LED)
> + return -1;
> +
> + offset = hidinput_find_field(dj_hiddev, type, code, &field);
> +
> + if (offset == -1) {
> + dev_warn(&dev->dev, "event field not found\n");
> + return -1;
> + }
> + hid_set_field(field, offset, value);
> + hid_output_report(field->report, &data[0]);
> +
> + output_report_enum = &dj_rcv_hiddev->report_enum[HID_OUTPUT_REPORT];
> + report = *output_report_enum->report_id_hash[REPORT_ID_DJ_SHORT];
> + hid_set_field(report.field[0], 0, dj_dev->device_index);
> + hid_set_field(report.field[0], 1, REPORT_TYPE_LEDS);
> + hid_set_field(report.field[0], 2, data[1]);
> +
> + usbhid_submit_report(dj_rcv_hiddev, &report, USB_DIR_OUT);
This is not working when the receiver is paired to a keyboard. When
the session launches, Gnome try to send leds commands to the keyboard
and this results in an oops.
Using a pointer to the struct hid_report solves the crash.
However, Dmitry, you told us about a DMA stack problem. Can you give
us a better way to handle that?
Thanks,
Benjamin
> +
> + return 0;
> +
> +}
> +
> +static int logi_dj_ll_start(struct hid_device *hid)
> +{
> + dbg_hid("%s\n", __func__);
> + return 0;
> +}
> +
> +static void logi_dj_ll_stop(struct hid_device *hid)
> +{
> + dbg_hid("%s\n", __func__);
> +}
> +
> +
> +static struct hid_ll_driver logi_dj_ll_driver = {
> + .parse = logi_dj_ll_parse,
> + .start = logi_dj_ll_start,
> + .stop = logi_dj_ll_stop,
> + .open = logi_dj_ll_open,
> + .close = logi_dj_ll_close,
> + .hidinput_input_event = logi_dj_ll_input_event,
> +};
> +
> +
> +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);
> + struct dj_report *dj_report = (struct dj_report *) data;
> + unsigned long flags;
> + bool report_processed = false;
> +
> + dbg_hid("%s, size:%d\n", __func__, size);
> +
> + /* Here we receive all data coming from iface 2, there are 4 cases:
> + *
> + * 1) Data should continue its normal processing i.e. data does not
> + * come from the DJ collection, in which case we do nothing and
> + * return 0, so hid-core can continue normal processing (will forward
> + * to associated hidraw device)
> + *
> + * 2) Data is from DJ collection, and is intended for this driver i. e.
> + * data contains arrival, departure, etc notifications, in which case
> + * we queue them for delayed processing by the work queue. We return 1
> + * to hid-core as no further processing is required from it.
> + *
> + * 3) Data is from DJ collection, and informs a connection change,
> + * if the change means rf link loss, then we must send a null report
> + * to the upper layer to discard potentially pressed keys that may be
> + * repeated forever by the input layer. Return 1 to hid-core as no
> + * further processing is required.
> + *
> + * 4) Data is from DJ collection and is an actual input event from
> + * a paired DJ device in which case we forward it to the correct hid
> + * device (via hid_input_report() ) and return 1 so hid-core does not do
> + * anything else with it.
> + */
> +
> + spin_lock_irqsave(&djrcv_dev->lock, flags);
> + if (dj_report->report_id == REPORT_ID_DJ_SHORT) {
> + switch (dj_report->report_type) {
> + case REPORT_TYPE_NOTIF_DEVICE_PAIRED:
> + case REPORT_TYPE_NOTIF_DEVICE_UNPAIRED:
> + logi_dj_recv_queue_notification(djrcv_dev, dj_report);
> + break;
> + case REPORT_TYPE_NOTIF_CONNECTION_STATUS:
> + if (dj_report->report_params[CONNECTION_STATUS_PARAM_STATUS] ==
> + STATUS_LINKLOSS) {
> + logi_dj_recv_forward_null_report(djrcv_dev, dj_report);
> + }
> + break;
> + default:
> + logi_dj_recv_forward_report(djrcv_dev, dj_report);
> + }
> + report_processed = true;
> + }
> + spin_unlock_irqrestore(&djrcv_dev->lock, flags);
> +
> + return report_processed;
> +}
> +
> +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 dj_receiver_dev *djrcv_dev;
> + int retval;
> +
> + if (is_dj_device((struct dj_device *)hdev->driver_data))
> + return -ENODEV;
> +
> + dbg_hid("%s called for ifnum %d\n", __func__,
> + intf->cur_altsetting->desc.bInterfaceNumber);
> +
> + /* 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);
> + return -ENODEV;
> + }
> +
> + /* Treat interface 2 */
> +
> + djrcv_dev = kzalloc(sizeof(struct dj_receiver_dev), GFP_KERNEL);
> + if (!djrcv_dev) {
> + dev_err(&hdev->dev,
> + "%s:failed allocating dj_receiver_dev\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;
> + }
> +
> + /* Starts the usb device and connects to upper interfaces hiddev and
> + * hidraw */
> + retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
> + if (retval) {
> + dev_err(&hdev->dev,
> + "%s:hid_hw_start returned error\n", __func__);
> + goto hid_hw_start_fail;
> + }
> +
> + 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",
> + __func__, retval);
> + goto switch_to_dj_mode_fail;
> + }
> +
> + /* This is enabling the polling urb on the IN endpoint */
> + retval = hdev->ll_driver->open(hdev);
> + if (retval < 0) {
> + dev_err(&hdev->dev, "%s:hdev->ll_driver->open returned "
> + "error:%d\n", __func__, retval);
> + goto llopen_failed;
> + }
> +
> + 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);
> + goto logi_dj_recv_query_paired_devices_failed;
> + }
> +
> + return retval;
> +
> +logi_dj_recv_query_paired_devices_failed:
> + hdev->ll_driver->close(hdev);
> +
> +llopen_failed:
> +switch_to_dj_mode_fail:
> + 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);
> + return retval;
> +
> +}
> +
> +static void logi_dj_remove(struct hid_device *hdev)
> +{
> + struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
> + struct dj_device *dj_dev;
> + int i;
> +
> + dbg_hid("%s\n", __func__);
> +
> + cancel_work_sync(&djrcv_dev->work);
> +
> + hdev->ll_driver->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 (i = 0; i < DJ_MAX_PAIRED_DEVICES; i++) {
> + dj_dev = djrcv_dev->paired_dj_devices[i];
> + 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);
> +}
> +
> +static int logi_djdevice_probe(struct hid_device *hdev,
> + const struct hid_device_id *id)
> +{
> + int ret;
> + struct dj_device *dj_dev = hdev->driver_data;
> +
> + if (!is_dj_device(dj_dev))
> + return -ENODEV;
> +
> + ret = hid_parse(hdev);
> + if (!ret)
> + ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
> +
> + return ret;
> +}
> +
> +static const struct hid_device_id logi_dj_receivers[] = {
> + {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)},
> + {}
> +};
> +
> +MODULE_DEVICE_TABLE(hid, logi_dj_receivers);
> +
> +static struct hid_driver logi_djreceiver_driver = {
> + .name = "logitech-djreceiver",
> + .id_table = logi_dj_receivers,
> + .probe = logi_dj_probe,
> + .remove = logi_dj_remove,
> + .raw_event = logi_dj_raw_event
> +};
> +
> +
> +static const struct hid_device_id logi_dj_devices[] = {
> + {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)},
> + {}
> +};
> +
> +static struct hid_driver logi_djdevice_driver = {
> + .name = "logitech-djdevice",
> + .id_table = logi_dj_devices,
> + .probe = logi_djdevice_probe,
> +};
> +
> +
> +static int __init logi_dj_init(void)
> +{
> + int retval;
> +
> + dbg_hid("Logitech-DJ:%s\n", __func__);
> +
> + retval = hid_register_driver(&logi_djreceiver_driver);
> + if (retval)
> + return retval;
> +
> + retval = hid_register_driver(&logi_djdevice_driver);
> + if (retval)
> + hid_unregister_driver(&logi_djreceiver_driver);
> +
> + return retval;
> +
> +}
> +
> +static void __exit logi_dj_exit(void)
> +{
> + dbg_hid("Logitech-DJ:%s\n", __func__);
> +
> + hid_unregister_driver(&logi_djdevice_driver);
> + hid_unregister_driver(&logi_djreceiver_driver);
> +
> +}
> +
> +module_init(logi_dj_init);
> +module_exit(logi_dj_exit);
> +MODULE_LICENSE("GPL");
> +MODULE_AUTHOR("Logitech");
> +MODULE_AUTHOR("Nestor Lopez Casado");
> diff --git a/drivers/hid/hid-logitech-dj.h b/drivers/hid/hid-logitech-dj.h
> new file mode 100644
> index 0000000..8dcdccd
> --- /dev/null
> +++ b/drivers/hid/hid-logitech-dj.h
> @@ -0,0 +1,123 @@
> +#ifndef __HID_LOGITECH_DJ_H
> +#define __HID_LOGITECH_DJ_H
> +
> +/*
> + * HID driver for Logitech Unifying receivers
> + *
> + * Copyright (c) 2011 Logitech (c)
> + */
> +
> +/*
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 as
> + * published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
> + *
> + * Should you need to contact me, the author, you can do so by e-mail send
> + * your message to Nestor Lopez Casado <xnlopez at gmail com>
> + *
> + */
> +
> +#include <linux/kfifo.h>
> +
> +#define DJ_MAX_PAIRED_DEVICES 6
> +#define DJ_MAX_NUMBER_NOTIFICATIONS 8
> +
> +#define DJREPORT_SHORT_LENGTH 15
> +#define DJREPORT_LONG_LENGTH 32
> +
> +#define REPORT_ID_DJ_SHORT 0x20
> +#define REPORT_ID_DJ_LONG 0x21
> +
> +#define REPORT_TYPE_RFREPORT_FIRST 0x01
> +#define REPORT_TYPE_RFREPORT_LAST 0x1F
> +
> +/* Command Switch to DJ mode */
> +#define REPORT_TYPE_CMD_SWITCH 0x80
> +#define CMD_SWITCH_PARAM_DEVBITFIELD 0x00
> +#define CMD_SWITCH_PARAM_TIMEOUT_SECONDS 0x01
> +#define TIMEOUT_NO_KEEPALIVE 0x00
> +
> +/* Command to Get the list of Paired devices */
> +#define REPORT_TYPE_CMD_GET_PAIRED_DEVICES 0x81
> +
> +/* Device Paired Notification */
> +#define REPORT_TYPE_NOTIF_DEVICE_PAIRED 0x41
> +#define SPFUNCTION_MORE_NOTIF_EXPECTED 0x01
> +#define SPFUNCTION_DEVICE_LIST_EMPTY 0x02
> +#define DEVICE_PAIRED_PARAM_SPFUNCTION 0x00
> +#define DEVICE_PAIRED_PARAM_EQUAD_ID_LSB 0x01
> +#define DEVICE_PAIRED_PARAM_EQUAD_ID_MSB 0x02
> +#define DEVICE_PAIRED_RF_REPORT_TYPE 0x03
> +
> +/* 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
> +#define STATUS_LINKLOSS 0x01
> +
> +/* Error Notification */
> +#define REPORT_TYPE_NOTIF_ERROR 0x7F
> +#define NOTIF_ERROR_PARAM_ETYPE 0x00
> +#define ETYPE_KEEPALIVE_TIMEOUT 0x01
> +
> +/* supported DJ HID && RF report types */
> +#define REPORT_TYPE_KEYBOARD 0x01
> +#define REPORT_TYPE_MOUSE 0x02
> +#define REPORT_TYPE_CONSUMER_CONTROL 0x03
> +#define REPORT_TYPE_SYSTEM_CONTROL 0x04
> +#define REPORT_TYPE_MEDIA_CENTER 0x08
> +#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
> +
> +struct dj_report {
> + u8 report_id;
> + u8 device_index;
> + u8 report_type;
> + u8 report_params[DJREPORT_SHORT_LENGTH - 3];
> +};
> +
> +struct dj_receiver_dev {
> + struct hid_device *hdev;
> + struct dj_device *paired_dj_devices[DJ_MAX_PAIRED_DEVICES];
> + struct work_struct work;
> + struct kfifo notif_fifo;
> + spinlock_t lock;
> +};
> +
> +struct dj_device {
> + struct hid_device *hdev;
> + struct dj_receiver_dev *dj_receiver_dev;
> + u32 reports_supported;
> + u8 device_index;
> +};
> +
> +/**
> + * is_dj_device - know if the given dj_device is not the receiver.
> + * @dj_dev: the dj device to test
> + *
> + * This macro tests if a struct dj_device pointer is a device created
> + * by the bus enumarator.
> + */
> +#define is_dj_device(dj_dev) \
> + (&(dj_dev)->dj_receiver_dev->hdev->dev == (dj_dev)->hdev->dev.parent)
> +
> +#endif
> --
> 1.7.4.4
>
>
--
To unsubscribe from this list: send the line "unsubscribe linux-input" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
