Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * $Id: iforce-packets.c,v 1.16 2002/07/07 10:22:50 jdeneux Exp $ | |
3 | * | |
4 | * Copyright (c) 2000-2002 Vojtech Pavlik <vojtech@ucw.cz> | |
5 | * Copyright (c) 2001-2002 Johann Deneux <deneux@ifrance.com> | |
6 | * | |
7 | * USB/RS232 I-Force joysticks and wheels. | |
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 | #include "iforce.h" | |
31 | ||
32 | static struct { | |
33 | __s32 x; | |
34 | __s32 y; | |
35 | } iforce_hat_to_axis[16] = {{ 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}}; | |
36 | ||
37 | ||
38 | void iforce_dump_packet(char *msg, u16 cmd, unsigned char *data) | |
39 | { | |
40 | int i; | |
41 | ||
42 | printk(KERN_DEBUG "iforce.c: %s ( cmd = %04x, data = ", msg, cmd); | |
43 | for (i = 0; i < LO(cmd); i++) | |
44 | printk("%02x ", data[i]); | |
45 | printk(")\n"); | |
46 | } | |
47 | ||
48 | /* | |
49 | * Send a packet of bytes to the device | |
50 | */ | |
51 | int iforce_send_packet(struct iforce *iforce, u16 cmd, unsigned char* data) | |
52 | { | |
53 | /* Copy data to buffer */ | |
54 | int n = LO(cmd); | |
55 | int c; | |
56 | int empty; | |
57 | int head, tail; | |
58 | unsigned long flags; | |
59 | ||
60 | /* | |
61 | * Update head and tail of xmit buffer | |
62 | */ | |
63 | spin_lock_irqsave(&iforce->xmit_lock, flags); | |
64 | ||
65 | head = iforce->xmit.head; | |
66 | tail = iforce->xmit.tail; | |
67 | ||
68 | if (CIRC_SPACE(head, tail, XMIT_SIZE) < n+2) { | |
69 | printk(KERN_WARNING "iforce.c: not enough space in xmit buffer to send new packet\n"); | |
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 | ||
129 | printk(KERN_DEBUG "iforce-packets.c: control_playback %d %d\n", id, value); | |
130 | ||
131 | data[0] = LO(id); | |
132 | data[1] = (value > 0) ? ((value > 1) ? 0x41 : 0x01) : 0; | |
133 | data[2] = LO(value); | |
134 | return iforce_send_packet(iforce, FF_CMD_PLAY, data); | |
135 | } | |
136 | ||
137 | /* Mark an effect that was being updated as ready. That means it can be updated | |
138 | * again */ | |
139 | static int mark_core_as_ready(struct iforce *iforce, unsigned short addr) | |
140 | { | |
141 | int i; | |
17dd3f0f | 142 | |
f6a01c85 AH |
143 | if (!iforce->dev->ff) |
144 | return 0; | |
145 | ||
146 | for (i = 0; i < iforce->dev->ff->max_effects; ++i) { | |
1da177e4 LT |
147 | if (test_bit(FF_CORE_IS_USED, iforce->core_effects[i].flags) && |
148 | (iforce->core_effects[i].mod1_chunk.start == addr || | |
149 | iforce->core_effects[i].mod2_chunk.start == addr)) { | |
150 | clear_bit(FF_CORE_UPDATE, iforce->core_effects[i].flags); | |
151 | return 0; | |
152 | } | |
153 | } | |
154 | printk(KERN_WARNING "iforce-packets.c: unused effect %04x updated !!!\n", addr); | |
155 | return -1; | |
156 | } | |
157 | ||
7d12e780 | 158 | void iforce_process_packet(struct iforce *iforce, u16 cmd, unsigned char *data) |
1da177e4 | 159 | { |
17dd3f0f | 160 | struct input_dev *dev = iforce->dev; |
1da177e4 LT |
161 | int i; |
162 | static int being_used = 0; | |
163 | ||
164 | if (being_used) | |
165 | printk(KERN_WARNING "iforce-packets.c: re-entrant call to iforce_process %d\n", being_used); | |
166 | being_used++; | |
167 | ||
168 | #ifdef CONFIG_JOYSTICK_IFORCE_232 | |
169 | if (HI(iforce->expect_packet) == HI(cmd)) { | |
170 | iforce->expect_packet = 0; | |
171 | iforce->ecmd = cmd; | |
172 | memcpy(iforce->edata, data, IFORCE_MAX_LENGTH); | |
1da177e4 LT |
173 | } |
174 | #endif | |
97d4ebfe | 175 | wake_up(&iforce->wait); |
1da177e4 LT |
176 | |
177 | if (!iforce->type) { | |
178 | being_used--; | |
179 | return; | |
180 | } | |
181 | ||
182 | switch (HI(cmd)) { | |
183 | ||
184 | case 0x01: /* joystick position data */ | |
185 | case 0x03: /* wheel position data */ | |
1da177e4 LT |
186 | if (HI(cmd) == 1) { |
187 | input_report_abs(dev, ABS_X, (__s16) (((__s16)data[1] << 8) | data[0])); | |
188 | input_report_abs(dev, ABS_Y, (__s16) (((__s16)data[3] << 8) | data[2])); | |
189 | input_report_abs(dev, ABS_THROTTLE, 255 - data[4]); | |
190 | if (LO(cmd) >= 8 && test_bit(ABS_RUDDER ,dev->absbit)) | |
191 | input_report_abs(dev, ABS_RUDDER, (__s8)data[7]); | |
192 | } else { | |
193 | input_report_abs(dev, ABS_WHEEL, (__s16) (((__s16)data[1] << 8) | data[0])); | |
194 | input_report_abs(dev, ABS_GAS, 255 - data[2]); | |
195 | input_report_abs(dev, ABS_BRAKE, 255 - data[3]); | |
196 | } | |
197 | ||
198 | input_report_abs(dev, ABS_HAT0X, iforce_hat_to_axis[data[6] >> 4].x); | |
199 | input_report_abs(dev, ABS_HAT0Y, iforce_hat_to_axis[data[6] >> 4].y); | |
200 | ||
201 | for (i = 0; iforce->type->btn[i] >= 0; i++) | |
202 | input_report_key(dev, iforce->type->btn[i], data[(i >> 3) + 5] & (1 << (i & 7))); | |
203 | ||
204 | /* If there are untouched bits left, interpret them as the second hat */ | |
205 | if (i <= 8) { | |
206 | int btns = data[6]; | |
207 | if (test_bit(ABS_HAT1X, dev->absbit)) { | |
208 | if (btns & 8) input_report_abs(dev, ABS_HAT1X, -1); | |
209 | else if (btns & 2) input_report_abs(dev, ABS_HAT1X, 1); | |
210 | else input_report_abs(dev, ABS_HAT1X, 0); | |
211 | } | |
212 | if (test_bit(ABS_HAT1Y, dev->absbit)) { | |
213 | if (btns & 1) input_report_abs(dev, ABS_HAT1Y, -1); | |
214 | else if (btns & 4) input_report_abs(dev, ABS_HAT1Y, 1); | |
215 | else input_report_abs(dev, ABS_HAT1Y, 0); | |
216 | } | |
217 | } | |
218 | ||
219 | input_sync(dev); | |
220 | ||
221 | break; | |
222 | ||
223 | case 0x02: /* status report */ | |
1da177e4 LT |
224 | input_report_key(dev, BTN_DEAD, data[0] & 0x02); |
225 | input_sync(dev); | |
226 | ||
227 | /* Check if an effect was just started or stopped */ | |
228 | i = data[1] & 0x7f; | |
229 | if (data[1] & 0x80) { | |
230 | if (!test_and_set_bit(FF_CORE_IS_PLAYED, iforce->core_effects[i].flags)) { | |
f6a01c85 AH |
231 | /* Report play event */ |
232 | input_report_ff_status(dev, i, FF_STATUS_PLAYING); | |
1da177e4 | 233 | } |
f6a01c85 | 234 | } else if (test_and_clear_bit(FF_CORE_IS_PLAYED, iforce->core_effects[i].flags)) { |
1da177e4 LT |
235 | /* Report stop event */ |
236 | input_report_ff_status(dev, i, FF_STATUS_STOPPED); | |
237 | } | |
238 | if (LO(cmd) > 3) { | |
239 | int j; | |
f6a01c85 | 240 | for (j = 3; j < LO(cmd); j += 2) |
1da177e4 | 241 | mark_core_as_ready(iforce, data[j] | (data[j+1]<<8)); |
1da177e4 LT |
242 | } |
243 | break; | |
244 | } | |
245 | being_used--; | |
246 | } | |
247 | ||
248 | int iforce_get_id_packet(struct iforce *iforce, char *packet) | |
249 | { | |
1da177e4 LT |
250 | switch (iforce->bus) { |
251 | ||
252 | case IFORCE_USB: | |
253 | ||
254 | #ifdef CONFIG_JOYSTICK_IFORCE_USB | |
255 | iforce->cr.bRequest = packet[0]; | |
256 | iforce->ctrl->dev = iforce->usbdev; | |
257 | ||
fb76b099 | 258 | if (usb_submit_urb(iforce->ctrl, GFP_ATOMIC)) |
1da177e4 | 259 | return -1; |
1da177e4 | 260 | |
fb76b099 VP |
261 | wait_event_interruptible_timeout(iforce->wait, |
262 | iforce->ctrl->status != -EINPROGRESS, HZ); | |
1da177e4 | 263 | |
97d4ebfe | 264 | if (iforce->ctrl->status) { |
1da177e4 LT |
265 | usb_unlink_urb(iforce->ctrl); |
266 | return -1; | |
267 | } | |
268 | #else | |
269 | printk(KERN_ERR "iforce_get_id_packet: iforce->bus = USB!\n"); | |
270 | #endif | |
271 | break; | |
272 | ||
273 | case IFORCE_232: | |
274 | ||
275 | #ifdef CONFIG_JOYSTICK_IFORCE_232 | |
276 | iforce->expect_packet = FF_CMD_QUERY; | |
277 | iforce_send_packet(iforce, FF_CMD_QUERY, packet); | |
278 | ||
fb76b099 VP |
279 | wait_event_interruptible_timeout(iforce->wait, |
280 | !iforce->expect_packet, HZ); | |
1da177e4 | 281 | |
fb76b099 | 282 | if (iforce->expect_packet) { |
1da177e4 LT |
283 | iforce->expect_packet = 0; |
284 | return -1; | |
285 | } | |
286 | #else | |
287 | printk(KERN_ERR "iforce_get_id_packet: iforce->bus = SERIO!\n"); | |
288 | #endif | |
289 | break; | |
290 | ||
291 | default: | |
292 | printk(KERN_ERR "iforce_get_id_packet: iforce->bus = %d\n", | |
293 | iforce->bus); | |
294 | break; | |
295 | } | |
296 | ||
297 | return -(iforce->edata[0] != packet[0]); | |
298 | } | |
299 |