home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / hid.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  22.8 KB  |  812 lines
  1. #ifndef __HID_H
  2. #define __HID_H
  3.  
  4. /*
  5.  *  Copyright (c) 1999 Andreas Gal
  6.  *  Copyright (c) 2000-2001 Vojtech Pavlik
  7.  *  Copyright (c) 2006-2007 Jiri Kosina
  8.  */
  9.  
  10. /*
  11.  * This program is free software; you can redistribute it and/or modify
  12.  * it under the terms of the GNU General Public License as published by
  13.  * the Free Software Foundation; either version 2 of the License, or
  14.  * (at your option) any later version.
  15.  *
  16.  * This program is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * You should have received a copy of the GNU General Public License
  22.  * along with this program; if not, write to the Free Software
  23.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  24.  *
  25.  * Should you need to contact me, the author, you can do so either by
  26.  * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
  27.  * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
  28.  */
  29.  
  30. /*
  31.  * USB HID (Human Interface Device) interface class code
  32.  */
  33.  
  34. #define USB_INTERFACE_CLASS_HID        3
  35.  
  36. /*
  37.  * USB HID interface subclass and protocol codes
  38.  */
  39.  
  40. #define USB_INTERFACE_SUBCLASS_BOOT    1
  41. #define USB_INTERFACE_PROTOCOL_KEYBOARD    1
  42. #define USB_INTERFACE_PROTOCOL_MOUSE    2
  43.  
  44. /*
  45.  * HID class requests
  46.  */
  47.  
  48. #define HID_REQ_GET_REPORT        0x01
  49. #define HID_REQ_GET_IDLE        0x02
  50. #define HID_REQ_GET_PROTOCOL        0x03
  51. #define HID_REQ_SET_REPORT        0x09
  52. #define HID_REQ_SET_IDLE        0x0A
  53. #define HID_REQ_SET_PROTOCOL        0x0B
  54.  
  55. /*
  56.  * HID class descriptor types
  57.  */
  58.  
  59. #define HID_DT_HID            (USB_TYPE_CLASS | 0x01)
  60. #define HID_DT_REPORT            (USB_TYPE_CLASS | 0x02)
  61. #define HID_DT_PHYSICAL            (USB_TYPE_CLASS | 0x03)
  62.  
  63. #define HID_MAX_DESCRIPTOR_SIZE        4096
  64.  
  65. #ifdef __KERNEL__
  66.  
  67. #include <linux/types.h>
  68. #include <linux/slab.h>
  69. #include <linux/list.h>
  70. #include <linux/mod_devicetable.h> /* hid_device_id */
  71. #include <linux/timer.h>
  72. #include <linux/workqueue.h>
  73. #include <linux/input.h>
  74.  
  75. /*
  76.  * We parse each description item into this structure. Short items data
  77.  * values are expanded to 32-bit signed int, long items contain a pointer
  78.  * into the data area.
  79.  */
  80.  
  81. struct hid_item {
  82.     unsigned  format;
  83.     __u8      size;
  84.     __u8      type;
  85.     __u8      tag;
  86.     union {
  87.         __u8   u8;
  88.         __s8   s8;
  89.         __u16  u16;
  90.         __s16  s16;
  91.         __u32  u32;
  92.         __s32  s32;
  93.         __u8  *longdata;
  94.     } data;
  95. };
  96.  
  97. /*
  98.  * HID report item format
  99.  */
  100.  
  101. #define HID_ITEM_FORMAT_SHORT    0
  102. #define HID_ITEM_FORMAT_LONG    1
  103.  
  104. /*
  105.  * Special tag indicating long items
  106.  */
  107.  
  108. #define HID_ITEM_TAG_LONG    15
  109.  
  110. /*
  111.  * HID report descriptor item type (prefix bit 2,3)
  112.  */
  113.  
  114. #define HID_ITEM_TYPE_MAIN        0
  115. #define HID_ITEM_TYPE_GLOBAL        1
  116. #define HID_ITEM_TYPE_LOCAL        2
  117. #define HID_ITEM_TYPE_RESERVED        3
  118.  
  119. /*
  120.  * HID report descriptor main item tags
  121.  */
  122.  
  123. #define HID_MAIN_ITEM_TAG_INPUT            8
  124. #define HID_MAIN_ITEM_TAG_OUTPUT        9
  125. #define HID_MAIN_ITEM_TAG_FEATURE        11
  126. #define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION    10
  127. #define HID_MAIN_ITEM_TAG_END_COLLECTION    12
  128.  
  129. /*
  130.  * HID report descriptor main item contents
  131.  */
  132.  
  133. #define HID_MAIN_ITEM_CONSTANT        0x001
  134. #define HID_MAIN_ITEM_VARIABLE        0x002
  135. #define HID_MAIN_ITEM_RELATIVE        0x004
  136. #define HID_MAIN_ITEM_WRAP        0x008
  137. #define HID_MAIN_ITEM_NONLINEAR        0x010
  138. #define HID_MAIN_ITEM_NO_PREFERRED    0x020
  139. #define HID_MAIN_ITEM_NULL_STATE    0x040
  140. #define HID_MAIN_ITEM_VOLATILE        0x080
  141. #define HID_MAIN_ITEM_BUFFERED_BYTE    0x100
  142.  
  143. /*
  144.  * HID report descriptor collection item types
  145.  */
  146.  
  147. #define HID_COLLECTION_PHYSICAL        0
  148. #define HID_COLLECTION_APPLICATION    1
  149. #define HID_COLLECTION_LOGICAL        2
  150.  
  151. /*
  152.  * HID report descriptor global item tags
  153.  */
  154.  
  155. #define HID_GLOBAL_ITEM_TAG_USAGE_PAGE        0
  156. #define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM    1
  157. #define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM    2
  158. #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM    3
  159. #define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM    4
  160. #define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT    5
  161. #define HID_GLOBAL_ITEM_TAG_UNIT        6
  162. #define HID_GLOBAL_ITEM_TAG_REPORT_SIZE        7
  163. #define HID_GLOBAL_ITEM_TAG_REPORT_ID        8
  164. #define HID_GLOBAL_ITEM_TAG_REPORT_COUNT    9
  165. #define HID_GLOBAL_ITEM_TAG_PUSH        10
  166. #define HID_GLOBAL_ITEM_TAG_POP            11
  167.  
  168. /*
  169.  * HID report descriptor local item tags
  170.  */
  171.  
  172. #define HID_LOCAL_ITEM_TAG_USAGE        0
  173. #define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM    1
  174. #define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM    2
  175. #define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX    3
  176. #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM    4
  177. #define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM    5
  178. #define HID_LOCAL_ITEM_TAG_STRING_INDEX        7
  179. #define HID_LOCAL_ITEM_TAG_STRING_MINIMUM    8
  180. #define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM    9
  181. #define HID_LOCAL_ITEM_TAG_DELIMITER        10
  182.  
  183. /*
  184.  * HID usage tables
  185.  */
  186.  
  187. #define HID_USAGE_PAGE        0xffff0000
  188.  
  189. #define HID_UP_UNDEFINED    0x00000000
  190. #define HID_UP_GENDESK        0x00010000
  191. #define HID_UP_SIMULATION    0x00020000
  192. #define HID_UP_KEYBOARD        0x00070000
  193. #define HID_UP_LED        0x00080000
  194. #define HID_UP_BUTTON        0x00090000
  195. #define HID_UP_ORDINAL        0x000a0000
  196. #define HID_UP_CONSUMER        0x000c0000
  197. #define HID_UP_DIGITIZER    0x000d0000
  198. #define HID_UP_PID        0x000f0000
  199. #define HID_UP_HPVENDOR         0xff7f0000
  200. #define HID_UP_MSVENDOR        0xff000000
  201. #define HID_UP_CUSTOM        0x00ff0000
  202. #define HID_UP_LOGIVENDOR    0xffbc0000
  203.  
  204. #define HID_USAGE        0x0000ffff
  205.  
  206. #define HID_GD_POINTER        0x00010001
  207. #define HID_GD_MOUSE        0x00010002
  208. #define HID_GD_JOYSTICK        0x00010004
  209. #define HID_GD_GAMEPAD        0x00010005
  210. #define HID_GD_KEYBOARD        0x00010006
  211. #define HID_GD_KEYPAD        0x00010007
  212. #define HID_GD_MULTIAXIS    0x00010008
  213. #define HID_GD_X        0x00010030
  214. #define HID_GD_Y        0x00010031
  215. #define HID_GD_Z        0x00010032
  216. #define HID_GD_RX        0x00010033
  217. #define HID_GD_RY        0x00010034
  218. #define HID_GD_RZ        0x00010035
  219. #define HID_GD_SLIDER        0x00010036
  220. #define HID_GD_DIAL        0x00010037
  221. #define HID_GD_WHEEL        0x00010038
  222. #define HID_GD_HATSWITCH    0x00010039
  223. #define HID_GD_BUFFER        0x0001003a
  224. #define HID_GD_BYTECOUNT    0x0001003b
  225. #define HID_GD_MOTION        0x0001003c
  226. #define HID_GD_START        0x0001003d
  227. #define HID_GD_SELECT        0x0001003e
  228. #define HID_GD_VX        0x00010040
  229. #define HID_GD_VY        0x00010041
  230. #define HID_GD_VZ        0x00010042
  231. #define HID_GD_VBRX        0x00010043
  232. #define HID_GD_VBRY        0x00010044
  233. #define HID_GD_VBRZ        0x00010045
  234. #define HID_GD_VNO        0x00010046
  235. #define HID_GD_FEATURE        0x00010047
  236. #define HID_GD_UP        0x00010090
  237. #define HID_GD_DOWN        0x00010091
  238. #define HID_GD_RIGHT        0x00010092
  239. #define HID_GD_LEFT        0x00010093
  240.  
  241. /*
  242.  * HID report types --- Ouch! HID spec says 1 2 3!
  243.  */
  244.  
  245. #define HID_INPUT_REPORT    0
  246. #define HID_OUTPUT_REPORT    1
  247. #define HID_FEATURE_REPORT    2
  248.  
  249. /*
  250.  * HID connect requests
  251.  */
  252.  
  253. #define HID_CONNECT_HIDINPUT        0x01
  254. #define HID_CONNECT_HIDINPUT_FORCE    0x02
  255. #define HID_CONNECT_HIDRAW        0x04
  256. #define HID_CONNECT_HIDDEV        0x08
  257. #define HID_CONNECT_HIDDEV_FORCE    0x10
  258. #define HID_CONNECT_FF            0x20
  259. #define HID_CONNECT_DEFAULT    (HID_CONNECT_HIDINPUT|HID_CONNECT_HIDRAW| \
  260.         HID_CONNECT_HIDDEV|HID_CONNECT_FF)
  261.  
  262. /*
  263.  * HID device quirks.
  264.  */
  265.  
  266. /* 
  267.  * Increase this if you need to configure more HID quirks at module load time
  268.  */
  269. #define MAX_USBHID_BOOT_QUIRKS 4
  270.  
  271. #define HID_QUIRK_INVERT            0x00000001
  272. #define HID_QUIRK_NOTOUCH            0x00000002
  273. #define HID_QUIRK_NOGET                0x00000008
  274. #define HID_QUIRK_BADPAD            0x00000020
  275. #define HID_QUIRK_MULTI_INPUT            0x00000040
  276. #define HID_QUIRK_SKIP_OUTPUT_REPORTS        0x00010000
  277. #define HID_QUIRK_FULLSPEED_INTERVAL        0x10000000
  278.  
  279. /*
  280.  * This is the global environment of the parser. This information is
  281.  * persistent for main-items. The global environment can be saved and
  282.  * restored with PUSH/POP statements.
  283.  */
  284.  
  285. struct hid_global {
  286.     unsigned usage_page;
  287.     __s32    logical_minimum;
  288.     __s32    logical_maximum;
  289.     __s32    physical_minimum;
  290.     __s32    physical_maximum;
  291.     __s32    unit_exponent;
  292.     unsigned unit;
  293.     unsigned report_id;
  294.     unsigned report_size;
  295.     unsigned report_count;
  296. };
  297.  
  298. /*
  299.  * This is the local environment. It is persistent up the next main-item.
  300.  */
  301.  
  302. #define HID_MAX_USAGES            12288
  303. #define HID_DEFAULT_NUM_COLLECTIONS    16
  304.  
  305. struct hid_local {
  306.     unsigned usage[HID_MAX_USAGES]; /* usage array */
  307.     unsigned collection_index[HID_MAX_USAGES]; /* collection index array */
  308.     unsigned usage_index;
  309.     unsigned usage_minimum;
  310.     unsigned delimiter_depth;
  311.     unsigned delimiter_branch;
  312. };
  313.  
  314. /*
  315.  * This is the collection stack. We climb up the stack to determine
  316.  * application and function of each field.
  317.  */
  318.  
  319. struct hid_collection {
  320.     unsigned type;
  321.     unsigned usage;
  322.     unsigned level;
  323. };
  324.  
  325. struct hid_usage {
  326.     unsigned  hid;            /* hid usage code */
  327.     unsigned  collection_index;    /* index into collection array */
  328.     /* hidinput data */
  329.     __u16     code;            /* input driver code */
  330.     __u8      type;            /* input driver type */
  331.     __s8      hat_min;        /* hat switch fun */
  332.     __s8      hat_max;        /* ditto */
  333.     __s8      hat_dir;        /* ditto */
  334. };
  335.  
  336. struct hid_input;
  337.  
  338. struct hid_field {
  339.     unsigned  physical;        /* physical usage for this field */
  340.     unsigned  logical;        /* logical usage for this field */
  341.     unsigned  application;        /* application usage for this field */
  342.     struct hid_usage *usage;    /* usage table for this function */
  343.     unsigned  maxusage;        /* maximum usage index */
  344.     unsigned  flags;        /* main-item flags (i.e. volatile,array,constant) */
  345.     unsigned  report_offset;    /* bit offset in the report */
  346.     unsigned  report_size;        /* size of this field in the report */
  347.     unsigned  report_count;        /* number of this field in the report */
  348.     unsigned  report_type;        /* (input,output,feature) */
  349.     __s32    *value;        /* last known value(s) */
  350.     __s32     logical_minimum;
  351.     __s32     logical_maximum;
  352.     __s32     physical_minimum;
  353.     __s32     physical_maximum;
  354.     __s32     unit_exponent;
  355.     unsigned  unit;
  356.     struct hid_report *report;    /* associated report */
  357.     unsigned index;            /* index into report->field[] */
  358.     /* hidinput data */
  359.     struct hid_input *hidinput;    /* associated input structure */
  360.     __u16 dpad;            /* dpad input code */
  361. };
  362.  
  363. #define HID_MAX_FIELDS 64
  364.  
  365. struct hid_report {
  366.     struct list_head list;
  367.     unsigned id;                    /* id of this report */
  368.     unsigned type;                    /* report type */
  369.     struct hid_field *field[HID_MAX_FIELDS];    /* fields of the report */
  370.     unsigned maxfield;                /* maximum valid field index */
  371.     unsigned size;                    /* size of the report (bits) */
  372.     struct hid_device *device;            /* associated device */
  373. };
  374.  
  375. struct hid_report_enum {
  376.     unsigned numbered;
  377.     struct list_head report_list;
  378.     struct hid_report *report_id_hash[256];
  379. };
  380.  
  381. #define HID_REPORT_TYPES 3
  382.  
  383. #define HID_MIN_BUFFER_SIZE    64        /* make sure there is at least a packet size of space */
  384. #define HID_MAX_BUFFER_SIZE    4096        /* 4kb */
  385. #define HID_CONTROL_FIFO_SIZE    256        /* to init devices with >100 reports */
  386. #define HID_OUTPUT_FIFO_SIZE    64
  387.  
  388. struct hid_control_fifo {
  389.     unsigned char dir;
  390.     struct hid_report *report;
  391.     char *raw_report;
  392. };
  393.  
  394. struct hid_output_fifo {
  395.     struct hid_report *report;
  396.     char *raw_report;
  397. };
  398.  
  399. #define HID_CLAIMED_INPUT    1
  400. #define HID_CLAIMED_HIDDEV    2
  401. #define HID_CLAIMED_HIDRAW    4
  402.  
  403. #define HID_STAT_ADDED        1
  404. #define HID_STAT_PARSED        2
  405.  
  406. #define HID_CTRL_RUNNING    1
  407. #define HID_OUT_RUNNING        2
  408. #define HID_IN_RUNNING        3
  409. #define HID_RESET_PENDING    4
  410. #define HID_SUSPENDED        5
  411. #define HID_CLEAR_HALT        6
  412. #define HID_DISCONNECTED    7
  413. #define HID_STARTED        8
  414.  
  415. struct hid_input {
  416.     struct list_head list;
  417.     struct hid_report *report;
  418.     struct input_dev *input;
  419. };
  420.  
  421. enum hid_type {
  422.     HID_TYPE_OTHER = 0,
  423.     HID_TYPE_USBMOUSE
  424. };
  425.  
  426. struct hid_driver;
  427. struct hid_ll_driver;
  428.  
  429. struct hid_device {                            /* device report descriptor */
  430.     __u8 *rdesc;
  431.     unsigned rsize;
  432.     struct hid_collection *collection;                /* List of HID collections */
  433.     unsigned collection_size;                    /* Number of allocated hid_collections */
  434.     unsigned maxcollection;                        /* Number of parsed collections */
  435.     unsigned maxapplication;                    /* Number of applications */
  436.     __u16 bus;                            /* BUS ID */
  437.     __u32 vendor;                            /* Vendor ID */
  438.     __u32 product;                            /* Product ID */
  439.     __u32 version;                            /* HID version */
  440.     enum hid_type type;                        /* device type (mouse, kbd, ...) */
  441.     unsigned country;                        /* HID country */
  442.     struct hid_report_enum report_enum[HID_REPORT_TYPES];
  443.  
  444.     struct device dev;                        /* device */
  445.     struct hid_driver *driver;
  446.     struct hid_ll_driver *ll_driver;
  447.  
  448.     unsigned int status;                        /* see STAT flags above */
  449.     unsigned claimed;                        /* Claimed by hidinput, hiddev? */
  450.     unsigned quirks;                        /* Various quirks the device can pull on us */
  451.  
  452.     struct list_head inputs;                    /* The list of inputs */
  453.     void *hiddev;                            /* The hiddev structure */
  454.     void *hidraw;
  455.     int minor;                            /* Hiddev minor number */
  456.  
  457.     int open;                            /* is the device open by anyone? */
  458.     char name[128];                            /* Device name */
  459.     char phys[64];                            /* Device physical location */
  460.     char uniq[64];                            /* Device unique identifier (serial #) */
  461.  
  462.     void *driver_data;
  463.  
  464.     /* temporary hid_ff handling (until moved to the drivers) */
  465.     int (*ff_init)(struct hid_device *);
  466.  
  467.     /* hiddev event handler */
  468.     int (*hiddev_connect)(struct hid_device *, unsigned int);
  469.     void (*hiddev_hid_event) (struct hid_device *, struct hid_field *field,
  470.                   struct hid_usage *, __s32);
  471.     void (*hiddev_report_event) (struct hid_device *, struct hid_report *);
  472.  
  473.     /* handler for raw output data, used by hidraw */
  474.     int (*hid_output_raw_report) (struct hid_device *, __u8 *, size_t);
  475. };
  476.  
  477. static inline void *hid_get_drvdata(struct hid_device *hdev)
  478. {
  479.     return dev_get_drvdata(&hdev->dev);
  480. }
  481.  
  482. static inline void hid_set_drvdata(struct hid_device *hdev, void *data)
  483. {
  484.     dev_set_drvdata(&hdev->dev, data);
  485. }
  486.  
  487. #define HID_GLOBAL_STACK_SIZE 4
  488. #define HID_COLLECTION_STACK_SIZE 4
  489.  
  490. struct hid_parser {
  491.     struct hid_global     global;
  492.     struct hid_global     global_stack[HID_GLOBAL_STACK_SIZE];
  493.     unsigned              global_stack_ptr;
  494.     struct hid_local      local;
  495.     unsigned              collection_stack[HID_COLLECTION_STACK_SIZE];
  496.     unsigned              collection_stack_ptr;
  497.     struct hid_device    *device;
  498. };
  499.  
  500. struct hid_class_descriptor {
  501.     __u8  bDescriptorType;
  502.     __le16 wDescriptorLength;
  503. } __attribute__ ((packed));
  504.  
  505. struct hid_descriptor {
  506.     __u8  bLength;
  507.     __u8  bDescriptorType;
  508.     __le16 bcdHID;
  509.     __u8  bCountryCode;
  510.     __u8  bNumDescriptors;
  511.  
  512.     struct hid_class_descriptor desc[1];
  513. } __attribute__ ((packed));
  514.  
  515. #define HID_DEVICE(b, ven, prod) \
  516.     .bus = (b), \
  517.     .vendor = (ven), .product = (prod)
  518.  
  519. #define HID_USB_DEVICE(ven, prod)    HID_DEVICE(BUS_USB, ven, prod)
  520. #define HID_BLUETOOTH_DEVICE(ven, prod)    HID_DEVICE(BUS_BLUETOOTH, ven, prod)
  521.  
  522. #define HID_REPORT_ID(rep) \
  523.     .report_type = (rep)
  524. #define HID_USAGE_ID(uhid, utype, ucode) \
  525.     .usage_hid = (uhid), .usage_type = (utype), .usage_code = (ucode)
  526. /* we don't want to catch types and codes equal to 0 */
  527. #define HID_TERMINATOR        (HID_ANY_ID - 1)
  528.  
  529. struct hid_report_id {
  530.     __u32 report_type;
  531. };
  532. struct hid_usage_id {
  533.     __u32 usage_hid;
  534.     __u32 usage_type;
  535.     __u32 usage_code;
  536. };
  537.  
  538. /**
  539.  * struct hid_driver
  540.  * @name: driver name (e.g. "Footech_bar-wheel")
  541.  * @id_table: which devices is this driver for (must be non-NULL for probe
  542.  *           to be called)
  543.  * @probe: new device inserted
  544.  * @remove: device removed (NULL if not a hot-plug capable driver)
  545.  * @report_table: on which reports to call raw_event (NULL means all)
  546.  * @raw_event: if report in report_table, this hook is called (NULL means nop)
  547.  * @usage_table: on which events to call event (NULL means all)
  548.  * @event: if usage in usage_table, this hook is called (NULL means nop)
  549.  * @report_fixup: called before report descriptor parsing (NULL means nop)
  550.  * @input_mapping: invoked on input registering before mapping an usage
  551.  * @input_mapped: invoked on input registering after mapping an usage
  552.  *
  553.  * raw_event and event should return 0 on no action performed, 1 when no
  554.  * further processing should be done and negative on error
  555.  *
  556.  * input_mapping shall return a negative value to completely ignore this usage
  557.  * (e.g. doubled or invalid usage), zero to continue with parsing of this
  558.  * usage by generic code (no special handling needed) or positive to skip
  559.  * generic parsing (needed special handling which was done in the hook already)
  560.  * input_mapped shall return negative to inform the layer that this usage
  561.  * should not be considered for further processing or zero to notify that
  562.  * no processing was performed and should be done in a generic manner
  563.  * Both these functions may be NULL which means the same behavior as returning
  564.  * zero from them.
  565.  */
  566. struct hid_driver {
  567.     char *name;
  568.     const struct hid_device_id *id_table;
  569.  
  570.     int (*probe)(struct hid_device *dev, const struct hid_device_id *id);
  571.     void (*remove)(struct hid_device *dev);
  572.  
  573.     const struct hid_report_id *report_table;
  574.     int (*raw_event)(struct hid_device *hdev, struct hid_report *report,
  575.             u8 *data, int size);
  576.     const struct hid_usage_id *usage_table;
  577.     int (*event)(struct hid_device *hdev, struct hid_field *field,
  578.             struct hid_usage *usage, __s32 value);
  579.  
  580.     void (*report_fixup)(struct hid_device *hdev, __u8 *buf,
  581.             unsigned int size);
  582.  
  583.     int (*input_mapping)(struct hid_device *hdev,
  584.             struct hid_input *hidinput, struct hid_field *field,
  585.             struct hid_usage *usage, unsigned long **bit, int *max);
  586.     int (*input_mapped)(struct hid_device *hdev,
  587.             struct hid_input *hidinput, struct hid_field *field,
  588.             struct hid_usage *usage, unsigned long **bit, int *max);
  589. /* private: */
  590.     struct device_driver driver;
  591. };
  592.  
  593. /**
  594.  * hid_ll_driver - low level driver callbacks
  595.  * @start: called on probe to start the device
  596.  * @stop: called on remove
  597.  * @open: called by input layer on open
  598.  * @close: called by input layer on close
  599.  * @hidinput_input_event: event input event (e.g. ff or leds)
  600.  * @parse: this method is called only once to parse the device data,
  601.  *       shouldn't allocate anything to not leak memory
  602.  */
  603. struct hid_ll_driver {
  604.     int (*start)(struct hid_device *hdev);
  605.     void (*stop)(struct hid_device *hdev);
  606.  
  607.     int (*open)(struct hid_device *hdev);
  608.     void (*close)(struct hid_device *hdev);
  609.  
  610.     int (*hidinput_input_event) (struct input_dev *idev, unsigned int type,
  611.             unsigned int code, int value);
  612.  
  613.     int (*parse)(struct hid_device *hdev);
  614. };
  615.  
  616. /* Applications from HID Usage Tables 4/8/99 Version 1.1 */
  617. /* We ignore a few input applications that are not widely used */
  618. #define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || (a == 0x00010080) || (a == 0x000c0001) || (a == 0x000d0002))
  619.  
  620. /* HID core API */
  621.  
  622. #ifdef CONFIG_HID_DEBUG
  623. extern int hid_debug;
  624. #endif
  625.  
  626. extern int hid_add_device(struct hid_device *);
  627. extern void hid_destroy_device(struct hid_device *);
  628.  
  629. extern int __must_check __hid_register_driver(struct hid_driver *,
  630.         struct module *, const char *mod_name);
  631. static inline int __must_check hid_register_driver(struct hid_driver *driver)
  632. {
  633.     return __hid_register_driver(driver, THIS_MODULE, KBUILD_MODNAME);
  634. }
  635. extern void hid_unregister_driver(struct hid_driver *);
  636.  
  637. extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
  638. extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);
  639. extern int hidinput_connect(struct hid_device *hid, unsigned int force);
  640. extern void hidinput_disconnect(struct hid_device *);
  641.  
  642. int hid_set_field(struct hid_field *, unsigned, __s32);
  643. int hid_input_report(struct hid_device *, int type, u8 *, int, int);
  644. int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field);
  645. void hid_output_report(struct hid_report *report, __u8 *data);
  646. struct hid_device *hid_allocate_device(void);
  647. int hid_parse_report(struct hid_device *hid, __u8 *start, unsigned size);
  648. int hid_connect(struct hid_device *hid, unsigned int connect_mask);
  649.  
  650. /**
  651.  * hid_map_usage - map usage input bits
  652.  *
  653.  * @hidinput: hidinput which we are interested in
  654.  * @usage: usage to fill in
  655.  * @bit: pointer to input->{}bit (out parameter)
  656.  * @max: maximal valid usage->code to consider later (out parameter)
  657.  * @type: input event type (EV_KEY, EV_REL, ...)
  658.  * @c: code which corresponds to this usage and type
  659.  */
  660. static inline void hid_map_usage(struct hid_input *hidinput,
  661.         struct hid_usage *usage, unsigned long **bit, int *max,
  662.         __u8 type, __u16 c)
  663. {
  664.     struct input_dev *input = hidinput->input;
  665.  
  666.     usage->type = type;
  667.     usage->code = c;
  668.  
  669.     switch (type) {
  670.     case EV_ABS:
  671.         *bit = input->absbit;
  672.         *max = ABS_MAX;
  673.         break;
  674.     case EV_REL:
  675.         *bit = input->relbit;
  676.         *max = REL_MAX;
  677.         break;
  678.     case EV_KEY:
  679.         *bit = input->keybit;
  680.         *max = KEY_MAX;
  681.         break;
  682.     case EV_LED:
  683.         *bit = input->ledbit;
  684.         *max = LED_MAX;
  685.         break;
  686.     }
  687. }
  688.  
  689. /**
  690.  * hid_map_usage_clear - map usage input bits and clear the input bit
  691.  *
  692.  * The same as hid_map_usage, except the @c bit is also cleared in supported
  693.  * bits (@bit).
  694.  */
  695. static inline void hid_map_usage_clear(struct hid_input *hidinput,
  696.         struct hid_usage *usage, unsigned long **bit, int *max,
  697.         __u8 type, __u16 c)
  698. {
  699.     hid_map_usage(hidinput, usage, bit, max, type, c);
  700.     clear_bit(c, *bit);
  701. }
  702.  
  703. /**
  704.  * hid_parse - parse HW reports
  705.  *
  706.  * @hdev: hid device
  707.  *
  708.  * Call this from probe after you set up the device (if needed). Your
  709.  * report_fixup will be called (if non-NULL) after reading raw report from
  710.  * device before passing it to hid layer for real parsing.
  711.  */
  712. static inline int __must_check hid_parse(struct hid_device *hdev)
  713. {
  714.     int ret;
  715.  
  716.     if (hdev->status & HID_STAT_PARSED)
  717.         return 0;
  718.  
  719.     ret = hdev->ll_driver->parse(hdev);
  720.     if (!ret)
  721.         hdev->status |= HID_STAT_PARSED;
  722.  
  723.     return ret;
  724. }
  725.  
  726. /**
  727.  * hid_hw_start - start underlaying HW
  728.  *
  729.  * @hdev: hid device
  730.  * @connect_mask: which outputs to connect, see HID_CONNECT_*
  731.  *
  732.  * Call this in probe function *after* hid_parse. This will setup HW buffers
  733.  * and start the device (if not deffered to device open). hid_hw_stop must be
  734.  * called if this was successfull.
  735.  */
  736. static inline int __must_check hid_hw_start(struct hid_device *hdev,
  737.         unsigned int connect_mask)
  738. {
  739.     int ret = hdev->ll_driver->start(hdev);
  740.     if (ret || !connect_mask)
  741.         return ret;
  742.     ret = hid_connect(hdev, connect_mask);
  743.     if (ret)
  744.         hdev->ll_driver->stop(hdev);
  745.     return ret;
  746. }
  747.  
  748. /**
  749.  * hid_hw_stop - stop underlaying HW
  750.  *
  751.  * @hdev: hid device
  752.  *
  753.  * This is usually called from remove function or from probe when something
  754.  * failed and hid_hw_start was called already.
  755.  */
  756. static inline void hid_hw_stop(struct hid_device *hdev)
  757. {
  758.     hdev->ll_driver->stop(hdev);
  759. }
  760.  
  761. void hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
  762.         int interrupt);
  763.  
  764. extern int hid_generic_init(void);
  765. extern void hid_generic_exit(void);
  766.  
  767. /* HID quirks API */
  768. u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct);
  769. int usbhid_quirks_init(char **quirks_param);
  770. void usbhid_quirks_exit(void);
  771. void usbhid_set_leds(struct hid_device *hid);
  772.  
  773. #ifdef CONFIG_HID_PID
  774. int hid_pidff_init(struct hid_device *hid);
  775. #else
  776. #define hid_pidff_init NULL
  777. #endif
  778.  
  779. #ifdef CONFIG_HID_DEBUG
  780. #define dbg_hid(format, arg...) if (hid_debug) \
  781.                 printk(KERN_DEBUG "%s: " format ,\
  782.                 __FILE__ , ## arg)
  783. #define dbg_hid_line(format, arg...) if (hid_debug) \
  784.                 printk(format, ## arg)
  785. #else
  786. static inline int __attribute__((format(printf, 1, 2)))
  787. dbg_hid(const char *fmt, ...)
  788. {
  789.     return 0;
  790. }
  791. #define dbg_hid_line dbg_hid
  792. #endif /* HID_DEBUG */
  793.  
  794. #define err_hid(format, arg...) printk(KERN_ERR "%s: " format "\n" , \
  795.         __FILE__ , ## arg)
  796. #endif /* HID_FF */
  797.  
  798. #ifdef CONFIG_HID_COMPAT
  799. #define HID_COMPAT_LOAD_DRIVER(name)    \
  800. void hid_compat_##name(void) { }    \
  801. EXPORT_SYMBOL(hid_compat_##name)
  802. #else
  803. #define HID_COMPAT_LOAD_DRIVER(name)
  804. #endif /* HID_COMPAT */
  805. #define HID_COMPAT_CALL_DRIVER(name)    do {    \
  806.     extern void hid_compat_##name(void);    \
  807.     hid_compat_##name();            \
  808. } while (0)
  809.  
  810. #endif
  811.  
  812.