root/drivers/hid/hid-petalynx.c

DEFINITIONS

1. pl_report_fixup
2. pl_input_mapping
3. pl_probe

   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 */
  22 static __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))
  37 static 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 
  67 static 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;
  86 err_free:
  87         return ret;
  88 }
  89 
  90 static const struct hid_device_id pl_devices[] = {
  91         { HID_USB_DEVICE(USB_VENDOR_ID_PETALYNX, USB_DEVICE_ID_PETALYNX_MAXTER_REMOTE) },
  92         { }
  93 };
  94 MODULE_DEVICE_TABLE(hid, pl_devices);
  95 
  96 static 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 };
 103 module_hid_driver(pl_driver);
 104 
 105 MODULE_LICENSE("GPL");