LXR linux/drivers/hid/hid-petalynx.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  HID driver for some petalynx "special" devices
   4 *
   5 *  Copyright (c) 1999 Andreas Gal
   6 *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
   7 *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
   8 *  Copyright (c) 2006-2007 Jiri Kosina
   9 *  Copyright (c) 2008 Jiri Slaby
  10 */
  11
  12/*
  13 */
  14
  15#include <linux/device.h>
  16#include <linux/hid.h>
  17#include <linux/module.h>
  18
  19#include "hid-ids.h"
  20
  21/* Petalynx Maxter Remote has maximum for consumer page set too low */
  22static __u8 *pl_report_fixup(struct hid_device *hdev, __u8 *rdesc,
  23                unsigned int *rsize)
  24{
  25        if (*rsize >= 62 && rdesc[39] == 0x2a && rdesc[40] == 0xf5 &&
  26                        rdesc[41] == 0x00 && rdesc[59] == 0x26 &&
  27                        rdesc[60] == 0xf9 && rdesc[61] == 0x00) {
  28                hid_info(hdev, "fixing up Petalynx Maxter Remote report descriptor\n");
  29                rdesc[60] = 0xfa;
  30                rdesc[40] = 0xfa;
  31        }
  32        return rdesc;
  33}
  34
  35#define pl_map_key_clear(c)     hid_map_usage_clear(hi, usage, bit, max, \
  36                                        EV_KEY, (c))
  37static int pl_input_mapping(struct hid_device *hdev, struct hid_input *hi,
  38                struct hid_field *field, struct hid_usage *usage,
  39                unsigned long **bit, int *max)
  40{
  41        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_LOGIVENDOR) {
  42                switch (usage->hid & HID_USAGE) {
  43                case 0x05a: pl_map_key_clear(KEY_TEXT);         break;
  44                case 0x05b: pl_map_key_clear(KEY_RED);          break;
  45                case 0x05c: pl_map_key_clear(KEY_GREEN);        break;
  46                case 0x05d: pl_map_key_clear(KEY_YELLOW);       break;
  47                case 0x05e: pl_map_key_clear(KEY_BLUE);         break;
  48                default:
  49                        return 0;
  50                }
  51                return 1;
  52        }
  53
  54        if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) {
  55                switch (usage->hid & HID_USAGE) {
  56                case 0x0f6: pl_map_key_clear(KEY_NEXT);         break;
  57                case 0x0fa: pl_map_key_clear(KEY_BACK);         break;
  58                default:
  59                        return 0;
  60                }
  61                return 1;
  62        }
  63
  64        return 0;
  65}
  66
  67static int pl_probe(struct hid_device *hdev, const struct hid_device_id *id)
  68{
  69        int ret;
  70
  71        hdev->quirks |= HID_QUIRK_NOGET;
  72
  73        ret = hid_parse(hdev);
  74        if (ret) {
  75                hid_err(hdev, "parse failed\n");
  76                goto err_free;
  77        }
  78
  79        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
  80        if (ret) {
  81                hid_err(hdev, "hw start failed\n");
  82                goto err_free;
  83        }
  84
  85        return 0;
  86err_free:
  87        return ret;
  88}
  89
  90static const struct hid_device_id pl_devices[] = {
  91        { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
  92        { }
  93};
  94MODULE_DEVICE_TABLE(hid, pl_devices);
  95
  96static struct hid_driver pl_driver = {
  97        .name = "petalynx",
  98        .id_table = pl_devices,
  99        .report_fixup = pl_report_fixup,
 100        .input_mapping = pl_input_mapping,
 101        .probe = pl_probe,
 102};
 103module_hid_driver(pl_driver);
 104
 105MODULE_LICENSE("GPL");
 106