Version:  2.0.40 2.2.26 2.4.37 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 3.18

Linux/drivers/hid/hid-emsff.c

  1 /*
  2  *  Force feedback support for EMS Trio Linker Plus II
  3  *
  4  *  Copyright (c) 2010 Ignaz Forster <ignaz.forster@gmx.de>
  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/module.h>
 27 
 28 #include "hid-ids.h"
 29 
 30 struct emsff_device {
 31         struct hid_report *report;
 32 };
 33 
 34 static int emsff_play(struct input_dev *dev, void *data,
 35                          struct ff_effect *effect)
 36 {
 37         struct hid_device *hid = input_get_drvdata(dev);
 38         struct emsff_device *emsff = data;
 39         int weak, strong;
 40 
 41         weak = effect->u.rumble.weak_magnitude;
 42         strong = effect->u.rumble.strong_magnitude;
 43 
 44         dbg_hid("called with 0x%04x 0x%04x\n", strong, weak);
 45 
 46         weak = weak * 0xff / 0xffff;
 47         strong = strong * 0xff / 0xffff;
 48 
 49         emsff->report->field[0]->value[1] = weak;
 50         emsff->report->field[0]->value[2] = strong;
 51 
 52         dbg_hid("running with 0x%02x 0x%02x\n", strong, weak);
 53         hid_hw_request(hid, emsff->report, HID_REQ_SET_REPORT);
 54 
 55         return 0;
 56 }
 57 
 58 static int emsff_init(struct hid_device *hid)
 59 {
 60         struct emsff_device *emsff;
 61         struct hid_report *report;
 62         struct hid_input *hidinput = list_first_entry(&hid->inputs,
 63                                                 struct hid_input, list);
 64         struct list_head *report_list =
 65                         &hid->report_enum[HID_OUTPUT_REPORT].report_list;
 66         struct input_dev *dev = hidinput->input;
 67         int error;
 68 
 69         if (list_empty(report_list)) {
 70                 hid_err(hid, "no output reports found\n");
 71                 return -ENODEV;
 72         }
 73 
 74         report = list_first_entry(report_list, struct hid_report, list);
 75         if (report->maxfield < 1) {
 76                 hid_err(hid, "no fields in the report\n");
 77                 return -ENODEV;
 78         }
 79 
 80         if (report->field[0]->report_count < 7) {
 81                 hid_err(hid, "not enough values in the field\n");
 82                 return -ENODEV;
 83         }
 84 
 85         emsff = kzalloc(sizeof(struct emsff_device), GFP_KERNEL);
 86         if (!emsff)
 87                 return -ENOMEM;
 88 
 89         set_bit(FF_RUMBLE, dev->ffbit);
 90 
 91         error = input_ff_create_memless(dev, emsff, emsff_play);
 92         if (error) {
 93                 kfree(emsff);
 94                 return error;
 95         }
 96 
 97         emsff->report = report;
 98         emsff->report->field[0]->value[0] = 0x01;
 99         emsff->report->field[0]->value[1] = 0x00;
100         emsff->report->field[0]->value[2] = 0x00;
101         emsff->report->field[0]->value[3] = 0x00;
102         emsff->report->field[0]->value[4] = 0x00;
103         emsff->report->field[0]->value[5] = 0x00;
104         emsff->report->field[0]->value[6] = 0x00;
105         hid_hw_request(hid, emsff->report, HID_REQ_SET_REPORT);
106 
107         hid_info(hid, "force feedback for EMS based devices by Ignaz Forster <ignaz.forster@gmx.de>\n");
108 
109         return 0;
110 }
111 
112 static int ems_probe(struct hid_device *hdev, const struct hid_device_id *id)
113 {
114         int ret;
115 
116         ret = hid_parse(hdev);
117         if (ret) {
118                 hid_err(hdev, "parse failed\n");
119                 goto err;
120         }
121 
122         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
123         if (ret) {
124                 hid_err(hdev, "hw start failed\n");
125                 goto err;
126         }
127 
128         ret = emsff_init(hdev);
129         if (ret) {
130                 dev_err(&hdev->dev, "force feedback init failed\n");
131                 hid_hw_stop(hdev);
132                 goto err;
133         }
134 
135         return 0;
136 err:
137         return ret;
138 }
139 
140 static const struct hid_device_id ems_devices[] = {
141         { HID_USB_DEVICE(USB_VENDOR_ID_EMS, USB_DEVICE_ID_EMS_TRIO_LINKER_PLUS_II) },
142         { }
143 };
144 MODULE_DEVICE_TABLE(hid, ems_devices);
145 
146 static struct hid_driver ems_driver = {
147         .name = "hkems",
148         .id_table = ems_devices,
149         .probe = ems_probe,
150 };
151 module_hid_driver(ems_driver);
152 
153 MODULE_LICENSE("GPL");
154 
155 

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