Commit | Line | Data |
---|---|---|
1da177e4 | 1 | /* |
1da177e4 | 2 | * Copyright (c) 2000-2002 Vojtech Pavlik <vojtech@ucw.cz> |
598972d4 | 3 | * Copyright (c) 2001-2002, 2007 Johann Deneux <johann.deneux@gmail.com> |
1da177e4 LT |
4 | * |
5 | * USB/RS232 I-Force joysticks and wheels. | |
6 | */ | |
7 | ||
8 | /* | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2 of the License, or | |
12 | * (at your option) any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
22 | * | |
23 | * Should you need to contact me, the author, you can do so either by | |
24 | * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail: | |
25 | * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic | |
26 | */ | |
27 | ||
28 | #include "iforce.h" | |
29 | ||
30 | static struct { | |
31 | __s32 x; | |
32 | __s32 y; | |
33 | } iforce_hat_to_axis[16] = {{ 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}}; | |
34 | ||
35 | ||
36 | void iforce_dump_packet(char *msg, u16 cmd, unsigned char *data) | |
37 | { | |
38 | int i; | |
39 | ||
598972d4 | 40 | printk(KERN_DEBUG __FILE__ ": %s cmd = %04x, data = ", msg, cmd); |
1da177e4 LT |
41 | for (i = 0; i < LO(cmd); i++) |
42 | printk("%02x ", data[i]); | |
598972d4 | 43 | printk("\n"); |
1da177e4 LT |
44 | } |
45 | ||
46 | /* | |
47 | * Send a packet of bytes to the device | |
48 | */ | |
49 | int iforce_send_packet(struct iforce *iforce, u16 cmd, unsigned char* data) | |
50 | { | |
51 | /* Copy data to buffer */ | |
52 | int n = LO(cmd); | |
53 | int c; | |
54 | int empty; | |
55 | int head, tail; | |
56 | unsigned long flags; | |
57 | ||
58 | /* | |
59 | * Update head and tail of xmit buffer | |
60 | */ | |
61 | spin_lock_irqsave(&iforce->xmit_lock, flags); | |
62 | ||
63 | head = iforce->xmit.head; | |
64 | tail = iforce->xmit.tail; | |
65 | ||
598972d4 | 66 | |
1da177e4 | 67 | if (CIRC_SPACE(head, tail, XMIT_SIZE) < n+2) { |
1817b169 GKH |
68 | dev_warn(&iforce->dev->dev, |
69 | "not enough space in xmit buffer to send new packet\n"); | |
1da177e4 LT |
70 | spin_unlock_irqrestore(&iforce->xmit_lock, flags); |
71 | return -1; | |
72 | } | |
73 | ||
74 | empty = head == tail; | |
75 | XMIT_INC(iforce->xmit.head, n+2); | |
76 | ||
77 | /* | |
78 | * Store packet in xmit buffer | |
79 | */ | |
80 | iforce->xmit.buf[head] = HI(cmd); | |
81 | XMIT_INC(head, 1); | |
82 | iforce->xmit.buf[head] = LO(cmd); | |
83 | XMIT_INC(head, 1); | |
84 | ||
85 | c = CIRC_SPACE_TO_END(head, tail, XMIT_SIZE); | |
86 | if (n < c) c=n; | |
87 | ||
88 | memcpy(&iforce->xmit.buf[head], | |
89 | data, | |
90 | c); | |
91 | if (n != c) { | |
92 | memcpy(&iforce->xmit.buf[0], | |
93 | data + c, | |
94 | n - c); | |
95 | } | |
96 | XMIT_INC(head, n); | |
97 | ||
98 | spin_unlock_irqrestore(&iforce->xmit_lock, flags); | |
99 | /* | |
100 | * If necessary, start the transmission | |
101 | */ | |
102 | switch (iforce->bus) { | |
103 | ||
104 | #ifdef CONFIG_JOYSTICK_IFORCE_232 | |
105 | case IFORCE_232: | |
106 | if (empty) | |
107 | iforce_serial_xmit(iforce); | |
108 | break; | |
109 | #endif | |
110 | #ifdef CONFIG_JOYSTICK_IFORCE_USB | |
111 | case IFORCE_USB: | |
112 | ||
113 | if (iforce->usbdev && empty && | |
114 | !test_and_set_bit(IFORCE_XMIT_RUNNING, iforce->xmit_flags)) { | |
115 | ||
116 | iforce_usb_xmit(iforce); | |
117 | } | |
118 | break; | |
119 | #endif | |
120 | } | |
121 | return 0; | |
122 | } | |
123 | ||
124 | /* Start or stop an effect */ | |
125 | int iforce_control_playback(struct iforce* iforce, u16 id, unsigned int value) | |
126 | { | |
127 | unsigned char data[3]; | |
128 | ||
1da177e4 LT |
129 | data[0] = LO(id); |
130 | data[1] = (value > 0) ? ((value > 1) ? 0x41 : 0x01) : 0; | |
131 | data[2] = LO(value); | |
132 | return iforce_send_packet(iforce, FF_CMD_PLAY, data); | |
133 | } | |
134 | ||
135 | /* Mark an effect that was being updated as ready. That means it can be updated | |
136 | * again */ | |
137 | static int mark_core_as_ready(struct iforce *iforce, unsigned short addr) | |
138 | { | |
139 | int i; | |
17dd3f0f | 140 | |
f6a01c85 AH |
141 | if (!iforce->dev->ff) |
142 | return 0; | |
143 | ||
144 | for (i = 0; i < iforce->dev->ff->max_effects; ++i) { | |
1da177e4 LT |
145 | if (test_bit(FF_CORE_IS_USED, iforce->core_effects[i].flags) && |
146 | (iforce->core_effects[i].mod1_chunk.start == addr || | |
147 | iforce->core_effects[i].mod2_chunk.start == addr)) { | |
148 | clear_bit(FF_CORE_UPDATE, iforce->core_effects[i].flags); | |
149 | return 0; | |
150 | } | |
151 | } | |
1817b169 | 152 | dev_warn(&iforce->dev->dev, "unused effect %04x updated !!!\n", addr); |
1da177e4 LT |
153 | return -1; |
154 | } | |
155 | ||
7d12e780 | 156 | void iforce_process_packet(struct iforce *iforce, u16 cmd, unsigned char *data) |
1da177e4 | 157 | { |
17dd3f0f | 158 | struct input_dev *dev = iforce->dev; |
1da177e4 LT |
159 | int i; |
160 | static int being_used = 0; | |
161 | ||
162 | if (being_used) | |
1817b169 GKH |
163 | dev_warn(&iforce->dev->dev, |
164 | "re-entrant call to iforce_process %d\n", being_used); | |
1da177e4 LT |
165 | being_used++; |
166 | ||
167 | #ifdef CONFIG_JOYSTICK_IFORCE_232 | |
168 | if (HI(iforce->expect_packet) == HI(cmd)) { | |
169 | iforce->expect_packet = 0; | |
170 | iforce->ecmd = cmd; | |
171 | memcpy(iforce->edata, data, IFORCE_MAX_LENGTH); | |
1da177e4 LT |
172 | } |
173 | #endif | |
97d4ebfe | 174 | wake_up(&iforce->wait); |
1da177e4 LT |
175 | |
176 | if (!iforce->type) { | |
177 | being_used--; | |
178 | return; | |
179 | } | |
180 | ||
181 | switch (HI(cmd)) { | |
182 | ||
183 | case 0x01: /* joystick position data */ | |
184 | case 0x03: /* wheel position data */ | |
1da177e4 LT |
185 | if (HI(cmd) == 1) { |
186 | input_report_abs(dev, ABS_X, (__s16) (((__s16)data[1] << 8) | data[0])); | |
187 | input_report_abs(dev, ABS_Y, (__s16) (((__s16)data[3] << 8) | data[2])); | |
188 | input_report_abs(dev, ABS_THROTTLE, 255 - data[4]); | |
189 | if (LO(cmd) >= 8 && test_bit(ABS_RUDDER ,dev->absbit)) | |
190 | input_report_abs(dev, ABS_RUDDER, (__s8)data[7]); | |
191 | } else { | |
192 | input_report_abs(dev, ABS_WHEEL, (__s16) (((__s16)data[1] << 8) | data[0])); | |
193 | input_report_abs(dev, ABS_GAS, 255 - data[2]); | |
194 | input_report_abs(dev, ABS_BRAKE, 255 - data[3]); | |
195 | } | |
196 | ||
197 | input_report_abs(dev, ABS_HAT0X, iforce_hat_to_axis[data[6] >> 4].x); | |
198 | input_report_abs(dev, ABS_HAT0Y, iforce_hat_to_axis[data[6] >> 4].y); | |
199 | ||
200 | for (i = 0; iforce->type->btn[i] >= 0; i++) | |
201 | input_report_key(dev, iforce->type->btn[i], data[(i >> 3) + 5] & (1 << (i & 7))); | |
202 | ||
203 | /* If there are untouched bits left, interpret them as the second hat */ | |
204 | if (i <= 8) { | |
205 | int btns = data[6]; | |
206 | if (test_bit(ABS_HAT1X, dev->absbit)) { | |
207 | if (btns & 8) input_report_abs(dev, ABS_HAT1X, -1); | |
208 | else if (btns & 2) input_report_abs(dev, ABS_HAT1X, 1); | |
209 | else input_report_abs(dev, ABS_HAT1X, 0); | |
210 | } | |
211 | if (test_bit(ABS_HAT1Y, dev->absbit)) { | |
212 | if (btns & 1) input_report_abs(dev, ABS_HAT1Y, -1); | |
213 | else if (btns & 4) input_report_abs(dev, ABS_HAT1Y, 1); | |
214 | else input_report_abs(dev, ABS_HAT1Y, 0); | |
215 | } | |
216 | } | |
217 | ||
218 | input_sync(dev); | |
219 | ||
220 | break; | |
221 | ||
222 | case 0x02: /* status report */ | |
1da177e4 LT |
223 | input_report_key(dev, BTN_DEAD, data[0] & 0x02); |
224 | input_sync(dev); | |
225 | ||
226 | /* Check if an effect was just started or stopped */ | |
227 | i = data[1] & 0x7f; | |
228 | if (data[1] & 0x80) { | |
229 | if (!test_and_set_bit(FF_CORE_IS_PLAYED, iforce->core_effects[i].flags)) { | |
f6a01c85 AH |
230 | /* Report play event */ |
231 | input_report_ff_status(dev, i, FF_STATUS_PLAYING); | |
1da177e4 | 232 | } |
f6a01c85 | 233 | } else if (test_and_clear_bit(FF_CORE_IS_PLAYED, iforce->core_effects[i].flags)) { |
1da177e4 LT |
234 | /* Report stop event */ |
235 | input_report_ff_status(dev, i, FF_STATUS_STOPPED); | |
236 | } | |
237 | if (LO(cmd) > 3) { | |
238 | int j; | |
f6a01c85 | 239 | for (j = 3; j < LO(cmd); j += 2) |
1da177e4 | 240 | mark_core_as_ready(iforce, data[j] | (data[j+1]<<8)); |
1da177e4 LT |
241 | } |
242 | break; | |
243 | } | |
244 | being_used--; | |
245 | } | |
246 | ||
247 | int iforce_get_id_packet(struct iforce *iforce, char *packet) | |
248 | { | |
1da177e4 LT |
249 | switch (iforce->bus) { |
250 | ||
d9f03831 | 251 | case IFORCE_USB: { |
1da177e4 | 252 | #ifdef CONFIG_JOYSTICK_IFORCE_USB |
d9f03831 AM |
253 | int status; |
254 | ||
1da177e4 LT |
255 | iforce->cr.bRequest = packet[0]; |
256 | iforce->ctrl->dev = iforce->usbdev; | |
257 | ||
c0338c15 JD |
258 | status = usb_submit_urb(iforce->ctrl, GFP_ATOMIC); |
259 | if (status) { | |
a852d78e | 260 | dev_err(&iforce->intf->dev, |
7b22a885 | 261 | "usb_submit_urb failed %d\n", status); |
1da177e4 | 262 | return -1; |
c0338c15 | 263 | } |
1da177e4 | 264 | |
fb76b099 VP |
265 | wait_event_interruptible_timeout(iforce->wait, |
266 | iforce->ctrl->status != -EINPROGRESS, HZ); | |
1da177e4 | 267 | |
97d4ebfe | 268 | if (iforce->ctrl->status) { |
a852d78e | 269 | dev_dbg(&iforce->intf->dev, |
f576125d GKH |
270 | "iforce->ctrl->status = %d\n", |
271 | iforce->ctrl->status); | |
1da177e4 LT |
272 | usb_unlink_urb(iforce->ctrl); |
273 | return -1; | |
274 | } | |
275 | #else | |
f576125d | 276 | printk(KERN_DEBUG "iforce_get_id_packet: iforce->bus = USB!\n"); |
1da177e4 | 277 | #endif |
d9f03831 | 278 | } |
1da177e4 LT |
279 | break; |
280 | ||
281 | case IFORCE_232: | |
282 | ||
283 | #ifdef CONFIG_JOYSTICK_IFORCE_232 | |
284 | iforce->expect_packet = FF_CMD_QUERY; | |
285 | iforce_send_packet(iforce, FF_CMD_QUERY, packet); | |
286 | ||
fb76b099 VP |
287 | wait_event_interruptible_timeout(iforce->wait, |
288 | !iforce->expect_packet, HZ); | |
1da177e4 | 289 | |
fb76b099 | 290 | if (iforce->expect_packet) { |
1da177e4 LT |
291 | iforce->expect_packet = 0; |
292 | return -1; | |
293 | } | |
294 | #else | |
7b22a885 GKH |
295 | dev_err(&iforce->dev->dev, |
296 | "iforce_get_id_packet: iforce->bus = SERIO!\n"); | |
1da177e4 LT |
297 | #endif |
298 | break; | |
299 | ||
300 | default: | |
7b22a885 GKH |
301 | dev_err(&iforce->dev->dev, |
302 | "iforce_get_id_packet: iforce->bus = %d\n", | |
303 | iforce->bus); | |
1da177e4 LT |
304 | break; |
305 | } | |
306 | ||
307 | return -(iforce->edata[0] != packet[0]); | |
308 | } | |
309 |