Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/hid/hid-dr.c

  1 /*
  2  * Force feedback support for DragonRise Inc. game controllers
  3  *
  4  * From what I have gathered, these devices are mass produced in China and are
  5  * distributed under several vendors. They often share the same design as
  6  * the original PlayStation DualShock controller.
  7  *
  8  * 0079:0006 "DragonRise Inc.   Generic   USB  Joystick  "
  9  *  - tested with a Tesun USB-703 game controller.
 10  *
 11  * Copyright (c) 2009 Richard Walmsley <richwalm@gmail.com>
 12  */
 13 
 14 /*
 15  * This program is free software; you can redistribute it and/or modify
 16  * it under the terms of the GNU General Public License as published by
 17  * the Free Software Foundation; either version 2 of the License, or
 18  * (at your option) any later version.
 19  *
 20  * This program is distributed in the hope that it will be useful,
 21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 23  * GNU General Public License for more details.
 24  *
 25  * You should have received a copy of the GNU General Public License
 26  * along with this program; if not, write to the Free Software
 27  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 28  */
 29 
 30 #include <linux/input.h>
 31 #include <linux/slab.h>
 32 #include <linux/hid.h>
 33 #include <linux/module.h>
 34 
 35 #include "hid-ids.h"
 36 
 37 #ifdef CONFIG_DRAGONRISE_FF
 38 
 39 struct drff_device {
 40         struct hid_report *report;
 41 };
 42 
 43 static int drff_play(struct input_dev *dev, void *data,
 44                                  struct ff_effect *effect)
 45 {
 46         struct hid_device *hid = input_get_drvdata(dev);
 47         struct drff_device *drff = data;
 48         int strong, weak;
 49 
 50         strong = effect->u.rumble.strong_magnitude;
 51         weak = effect->u.rumble.weak_magnitude;
 52 
 53         dbg_hid("called with 0x%04x 0x%04x", strong, weak);
 54 
 55         if (strong || weak) {
 56                 strong = strong * 0xff / 0xffff;
 57                 weak = weak * 0xff / 0xffff;
 58 
 59                 /* While reverse engineering this device, I found that when
 60                    this value is set, it causes the strong rumble to function
 61                    at a near maximum speed, so we'll bypass it. */
 62                 if (weak == 0x0a)
 63                         weak = 0x0b;
 64 
 65                 drff->report->field[0]->value[0] = 0x51;
 66                 drff->report->field[0]->value[1] = 0x00;
 67                 drff->report->field[0]->value[2] = weak;
 68                 drff->report->field[0]->value[4] = strong;
 69                 hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT);
 70 
 71                 drff->report->field[0]->value[0] = 0xfa;
 72                 drff->report->field[0]->value[1] = 0xfe;
 73         } else {
 74                 drff->report->field[0]->value[0] = 0xf3;
 75                 drff->report->field[0]->value[1] = 0x00;
 76         }
 77 
 78         drff->report->field[0]->value[2] = 0x00;
 79         drff->report->field[0]->value[4] = 0x00;
 80         dbg_hid("running with 0x%02x 0x%02x", strong, weak);
 81         hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT);
 82 
 83         return 0;
 84 }
 85 
 86 static int drff_init(struct hid_device *hid)
 87 {
 88         struct drff_device *drff;
 89         struct hid_report *report;
 90         struct hid_input *hidinput = list_first_entry(&hid->inputs,
 91                                                 struct hid_input, list);
 92         struct list_head *report_list =
 93                         &hid->report_enum[HID_OUTPUT_REPORT].report_list;
 94         struct input_dev *dev = hidinput->input;
 95         int error;
 96 
 97         if (list_empty(report_list)) {
 98                 hid_err(hid, "no output reports found\n");
 99                 return -ENODEV;
100         }
101 
102         report = list_first_entry(report_list, struct hid_report, list);
103         if (report->maxfield < 1) {
104                 hid_err(hid, "no fields in the report\n");
105                 return -ENODEV;
106         }
107 
108         if (report->field[0]->report_count < 7) {
109                 hid_err(hid, "not enough values in the field\n");
110                 return -ENODEV;
111         }
112 
113         drff = kzalloc(sizeof(struct drff_device), GFP_KERNEL);
114         if (!drff)
115                 return -ENOMEM;
116 
117         set_bit(FF_RUMBLE, dev->ffbit);
118 
119         error = input_ff_create_memless(dev, drff, drff_play);
120         if (error) {
121                 kfree(drff);
122                 return error;
123         }
124 
125         drff->report = report;
126         drff->report->field[0]->value[0] = 0xf3;
127         drff->report->field[0]->value[1] = 0x00;
128         drff->report->field[0]->value[2] = 0x00;
129         drff->report->field[0]->value[3] = 0x00;
130         drff->report->field[0]->value[4] = 0x00;
131         drff->report->field[0]->value[5] = 0x00;
132         drff->report->field[0]->value[6] = 0x00;
133         hid_hw_request(hid, drff->report, HID_REQ_SET_REPORT);
134 
135         hid_info(hid, "Force Feedback for DragonRise Inc. "
136                  "game controllers by Richard Walmsley <richwalm@gmail.com>\n");
137 
138         return 0;
139 }
140 #else
141 static inline int drff_init(struct hid_device *hid)
142 {
143         return 0;
144 }
145 #endif
146 
147 /*
148  * The original descriptor of joystick with PID 0x0011, represented by DVTech PC
149  * JS19. It seems both copied from another device and a result of confusion
150  * either about the specification or about the program used to create the
151  * descriptor. In any case, it's a wonder it works on Windows.
152  *
153  *  Usage Page (Desktop),             ; Generic desktop controls (01h)
154  *  Usage (Joystik),                  ; Joystik (04h, application collection)
155  *  Collection (Application),
156  *    Collection (Logical),
157  *      Report Size (8),
158  *      Report Count (5),
159  *      Logical Minimum (0),
160  *      Logical Maximum (255),
161  *      Physical Minimum (0),
162  *      Physical Maximum (255),
163  *      Usage (X),                    ; X (30h, dynamic value)
164  *      Usage (X),                    ; X (30h, dynamic value)
165  *      Usage (X),                    ; X (30h, dynamic value)
166  *      Usage (X),                    ; X (30h, dynamic value)
167  *      Usage (Y),                    ; Y (31h, dynamic value)
168  *      Input (Variable),
169  *      Report Size (4),
170  *      Report Count (1),
171  *      Logical Maximum (7),
172  *      Physical Maximum (315),
173  *      Unit (Degrees),
174  *      Usage (00h),
175  *      Input (Variable, Null State),
176  *      Unit,
177  *      Report Size (1),
178  *      Report Count (10),
179  *      Logical Maximum (1),
180  *      Physical Maximum (1),
181  *      Usage Page (Button),          ; Button (09h)
182  *      Usage Minimum (01h),
183  *      Usage Maximum (0Ah),
184  *      Input (Variable),
185  *      Usage Page (FF00h),           ; FF00h, vendor-defined
186  *      Report Size (1),
187  *      Report Count (10),
188  *      Logical Maximum (1),
189  *      Physical Maximum (1),
190  *      Usage (01h),
191  *      Input (Variable),
192  *    End Collection,
193  *    Collection (Logical),
194  *      Report Size (8),
195  *      Report Count (4),
196  *      Physical Maximum (255),
197  *      Logical Maximum (255),
198  *      Usage (02h),
199  *      Output (Variable),
200  *    End Collection,
201  *  End Collection
202  */
203 
204 /* Size of the original descriptor of the PID 0x0011 joystick */
205 #define PID0011_RDESC_ORIG_SIZE 101
206 
207 /* Fixed report descriptor for PID 0x011 joystick */
208 static __u8 pid0011_rdesc_fixed[] = {
209         0x05, 0x01,         /*  Usage Page (Desktop),           */
210         0x09, 0x04,         /*  Usage (Joystik),                */
211         0xA1, 0x01,         /*  Collection (Application),       */
212         0xA1, 0x02,         /*      Collection (Logical),       */
213         0x14,               /*          Logical Minimum (0),    */
214         0x75, 0x08,         /*          Report Size (8),        */
215         0x95, 0x03,         /*          Report Count (3),       */
216         0x81, 0x01,         /*          Input (Constant),       */
217         0x26, 0xFF, 0x00,   /*          Logical Maximum (255),  */
218         0x95, 0x02,         /*          Report Count (2),       */
219         0x09, 0x30,         /*          Usage (X),              */
220         0x09, 0x31,         /*          Usage (Y),              */
221         0x81, 0x02,         /*          Input (Variable),       */
222         0x75, 0x01,         /*          Report Size (1),        */
223         0x95, 0x04,         /*          Report Count (4),       */
224         0x81, 0x01,         /*          Input (Constant),       */
225         0x25, 0x01,         /*          Logical Maximum (1),    */
226         0x95, 0x0A,         /*          Report Count (10),      */
227         0x05, 0x09,         /*          Usage Page (Button),    */
228         0x19, 0x01,         /*          Usage Minimum (01h),    */
229         0x29, 0x0A,         /*          Usage Maximum (0Ah),    */
230         0x81, 0x02,         /*          Input (Variable),       */
231         0x95, 0x0A,         /*          Report Count (10),      */
232         0x81, 0x01,         /*          Input (Constant),       */
233         0xC0,               /*      End Collection,             */
234         0xC0                /*  End Collection                  */
235 };
236 
237 static __u8 *dr_report_fixup(struct hid_device *hdev, __u8 *rdesc,
238                                 unsigned int *rsize)
239 {
240         switch (hdev->product) {
241         case 0x0011:
242                 if (*rsize == PID0011_RDESC_ORIG_SIZE) {
243                         rdesc = pid0011_rdesc_fixed;
244                         *rsize = sizeof(pid0011_rdesc_fixed);
245                 }
246                 break;
247         }
248         return rdesc;
249 }
250 
251 static int dr_probe(struct hid_device *hdev, const struct hid_device_id *id)
252 {
253         int ret;
254 
255         dev_dbg(&hdev->dev, "DragonRise Inc. HID hardware probe...");
256 
257         ret = hid_parse(hdev);
258         if (ret) {
259                 hid_err(hdev, "parse failed\n");
260                 goto err;
261         }
262 
263         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
264         if (ret) {
265                 hid_err(hdev, "hw start failed\n");
266                 goto err;
267         }
268 
269         switch (hdev->product) {
270         case 0x0006:
271                 ret = drff_init(hdev);
272                 if (ret) {
273                         dev_err(&hdev->dev, "force feedback init failed\n");
274                         hid_hw_stop(hdev);
275                         goto err;
276                 }
277                 break;
278         }
279 
280         return 0;
281 err:
282         return ret;
283 }
284 
285 static const struct hid_device_id dr_devices[] = {
286         { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006),  },
287         { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0011),  },
288         { }
289 };
290 MODULE_DEVICE_TABLE(hid, dr_devices);
291 
292 static struct hid_driver dr_driver = {
293         .name = "dragonrise",
294         .id_table = dr_devices,
295         .report_fixup = dr_report_fixup,
296         .probe = dr_probe,
297 };
298 module_hid_driver(dr_driver);
299 
300 MODULE_LICENSE("GPL");
301 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us