Version:  2.0.40 2.2.26 2.4.37 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 3.15 3.16 3.17

Linux/drivers/hid/hid-zpff.c

  1 /*
  2  *  Force feedback support for Zeroplus based devices
  3  *
  4  *  Copyright (c) 2005, 2006 Anssi Hannula <anssi.hannula@gmail.com>
  5  */
  6 
  7 /*
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License as published by
 10  * the Free Software Foundation; either version 2 of the License, or
 11  * (at your option) any later version.
 12  *
 13  * This program is distributed in the hope that it will be useful,
 14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16  * GNU General Public License for more details.
 17  *
 18  * You should have received a copy of the GNU General Public License
 19  * along with this program; if not, write to the Free Software
 20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 21  */
 22 
 23 
 24 #include <linux/hid.h>
 25 #include <linux/input.h>
 26 #include <linux/slab.h>
 27 #include <linux/module.h>
 28 
 29 #include "hid-ids.h"
 30 
 31 #ifdef CONFIG_ZEROPLUS_FF
 32 
 33 struct zpff_device {
 34         struct hid_report *report;
 35 };
 36 
 37 static int zpff_play(struct input_dev *dev, void *data,
 38                          struct ff_effect *effect)
 39 {
 40         struct hid_device *hid = input_get_drvdata(dev);
 41         struct zpff_device *zpff = data;
 42         int left, right;
 43 
 44         /*
 45          * The following is specified the other way around in the Zeroplus
 46          * datasheet but the order below is correct for the XFX Executioner;
 47          * however it is possible that the XFX Executioner is an exception
 48          */
 49 
 50         left = effect->u.rumble.strong_magnitude;
 51         right = effect->u.rumble.weak_magnitude;
 52         dbg_hid("called with 0x%04x 0x%04x\n", left, right);
 53 
 54         left = left * 0x7f / 0xffff;
 55         right = right * 0x7f / 0xffff;
 56 
 57         zpff->report->field[2]->value[0] = left;
 58         zpff->report->field[3]->value[0] = right;
 59         dbg_hid("running with 0x%02x 0x%02x\n", left, right);
 60         hid_hw_request(hid, zpff->report, HID_REQ_SET_REPORT);
 61 
 62         return 0;
 63 }
 64 
 65 static int zpff_init(struct hid_device *hid)
 66 {
 67         struct zpff_device *zpff;
 68         struct hid_report *report;
 69         struct hid_input *hidinput = list_entry(hid->inputs.next,
 70                                                 struct hid_input, list);
 71         struct input_dev *dev = hidinput->input;
 72         int i, error;
 73 
 74         for (i = 0; i < 4; i++) {
 75                 report = hid_validate_values(hid, HID_OUTPUT_REPORT, 0, i, 1);
 76                 if (!report)
 77                         return -ENODEV;
 78         }
 79 
 80         zpff = kzalloc(sizeof(struct zpff_device), GFP_KERNEL);
 81         if (!zpff)
 82                 return -ENOMEM;
 83 
 84         set_bit(FF_RUMBLE, dev->ffbit);
 85 
 86         error = input_ff_create_memless(dev, zpff, zpff_play);
 87         if (error) {
 88                 kfree(zpff);
 89                 return error;
 90         }
 91 
 92         zpff->report = report;
 93         zpff->report->field[0]->value[0] = 0x00;
 94         zpff->report->field[1]->value[0] = 0x02;
 95         zpff->report->field[2]->value[0] = 0x00;
 96         zpff->report->field[3]->value[0] = 0x00;
 97         hid_hw_request(hid, zpff->report, HID_REQ_SET_REPORT);
 98 
 99         hid_info(hid, "force feedback for Zeroplus based devices by Anssi Hannula <anssi.hannula@gmail.com>\n");
100 
101         return 0;
102 }
103 #else
104 static inline int zpff_init(struct hid_device *hid)
105 {
106         return 0;
107 }
108 #endif
109 
110 static int zp_probe(struct hid_device *hdev, const struct hid_device_id *id)
111 {
112         int ret;
113 
114         ret = hid_parse(hdev);
115         if (ret) {
116                 hid_err(hdev, "parse failed\n");
117                 goto err;
118         }
119 
120         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
121         if (ret) {
122                 hid_err(hdev, "hw start failed\n");
123                 goto err;
124         }
125 
126         zpff_init(hdev);
127 
128         return 0;
129 err:
130         return ret;
131 }
132 
133 static const struct hid_device_id zp_devices[] = {
134         { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0005) },
135         { HID_USB_DEVICE(USB_VENDOR_ID_ZEROPLUS, 0x0030) },
136         { }
137 };
138 MODULE_DEVICE_TABLE(hid, zp_devices);
139 
140 static struct hid_driver zp_driver = {
141         .name = "zeroplus",
142         .id_table = zp_devices,
143         .probe = zp_probe,
144 };
145 module_hid_driver(zp_driver);
146 
147 MODULE_LICENSE("GPL");
148 

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