开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
iforce.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：29k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

iforce.c：源码内容
  1. /*
  2.  * $Id: iforce.c,v 1.56 2001/05/27 14:41:26 jdeneux Exp $
  3.  *
  4.  *  Copyright (c) 2000-2001 Vojtech Pavlik <vojtech@suse.cz>
  5.  *  Copyright (c) 2001 Johann Deneux <deneux@ifrance.com>
  6.  *
  7.  *  USB/RS232 I-Force joysticks and wheels.
  8.  *
  9.  *  Sponsored by SuSE
  10.  */
  12. /*
  13.  * This program is free software; you can redistribute it and/or modify
  14.  * it under the terms of the GNU General Public License as published by
  15.  * the Free Software Foundation; either version 2 of the License, or
  16.  * (at your option) any later version.
  17.  *
  18.  * This program is distributed in the hope that it will be useful,
  19.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21.  * GNU General Public License for more details.
  22.  *
  23.  * You should have received a copy of the GNU General Public License
  24.  * along with this program; if not, write to the Free Software
  25.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  26.  *
  27.  * Should you need to contact me, the author, you can do so either by
  28.  * e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:
  29.  * Vojtech Pavlik, Ucitelska 1576, Prague 8, 182 00 Czech Republic
  30.  */
  32. #include <linux/kernel.h>
  33. #include <linux/slab.h>
  34. #include <linux/input.h>
  35. #include <linux/module.h>
  36. #include <linux/init.h>
  37. #include <linux/spinlock.h>
  38. #include <linux/usb.h>
  39. #include <linux/serio.h>
  40. #include <linux/config.h>
  42. /* FF: This module provides arbitrary resource management routines.
  43.  * I use it to manage the device's memory.
  44.  * Despite the name of this module, I am *not* going to access the ioports.
  45.  */
  46. #include <linux/ioport.h>
  48. MODULE_AUTHOR("Vojtech Pavlik <vojtech@suse.cz>, Johann Deneux <deneux@ifrance.com>");
  49. MODULE_DESCRIPTION("USB/RS232 I-Force joysticks and wheels driver");
  50. MODULE_LICENSE("GPL");
  52. #define IFORCE_MAX_LENGTH 16
  54. #if defined(CONFIG_INPUT_IFORCE_232) || defined(CONFIG_INPUT_IFORCE_232_MODULE)
  55. #define IFORCE_232 1
  56. #endif
  57. #if defined(CONFIG_INPUT_IFORCE_USB) || defined(CONFIG_INPUT_IFORCE_USB_MODULE)
  58. #define IFORCE_USB 2
  59. #endif
  61. #define FF_EFFECTS_MAX 32
  63. /* Each force feedback effect is made of one core effect, which can be
  64.  * associated to at most to effect modifiers
  65.  */
  66. #define FF_MOD1_IS_USED 0
  67. #define FF_MOD2_IS_USED 1
  68. #define FF_CORE_IS_USED 2
  69. #define FF_CORE_IS_PLAYED 3
  70. #define FF_MODCORE_MAX 3
  72. struct iforce_core_effect {
  73. /* Information about where modifiers are stored in the device's memory */
  74. struct resource mod1_chunk;
  75. struct resource mod2_chunk;
  76. unsigned long flags[NBITS(FF_MODCORE_MAX)];
  77. };
  79. #define FF_CMD_EFFECT 0x010e
  80. #define FF_CMD_SHAPE 0x0208
  81. #define FF_CMD_MAGNITUDE 0x0303
  82. #define FF_CMD_PERIOD 0x0407
  83. #define FF_CMD_INTERACT 0x050a
  85. #define FF_CMD_AUTOCENTER 0x4002
  86. #define FF_CMD_PLAY 0x4103
  87. #define FF_CMD_ENABLE 0x4201
  88. #define FF_CMD_GAIN 0x4301
  90. #define FF_CMD_QUERY 0xff01
  92. static signed short btn_joystick[] = { BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
  93. BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_BASE5, BTN_A, BTN_B, BTN_C, BTN_DEAD, -1 };
  94. static signed short btn_wheel[] =    { BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
  95. BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_BASE5, BTN_A, BTN_B, BTN_C, -1 };
  96. static signed short abs_joystick[] = { ABS_X, ABS_Y, ABS_THROTTLE, ABS_HAT0X, ABS_HAT0Y, -1 };
  97. static signed short abs_wheel[] =    { ABS_WHEEL, ABS_GAS, ABS_BRAKE, ABS_HAT0X, ABS_HAT0Y, -1 };
  98. static signed short ff_iforce[] =    { FF_PERIODIC, FF_CONSTANT, FF_SPRING, FF_FRICTION,
  99. FF_SQUARE, FF_TRIANGLE, FF_SINE, FF_SAW_UP, FF_SAW_DOWN, FF_GAIN, FF_AUTOCENTER, -1 };
  101. static struct iforce_device {
  102. u16 idvendor;
  103. u16 idproduct;
  104. char *name;
  105. signed short *btn;
  106. signed short *abs;
  107. signed short *ff;
  108. } iforce_device[] = {
  109. { 0x046d, 0xc281, "Logitech WingMan Force", btn_joystick, abs_joystick, ff_iforce },
  110. { 0x046d, 0xc291, "Logitech WingMan Formula Force", btn_wheel, abs_wheel, ff_iforce },
  111. { 0x05ef, 0x020a, "AVB Top Shot Pegasus", btn_joystick, abs_joystick, ff_iforce },
  112. { 0x05ef, 0x8884, "AVB Mag Turbo Force", btn_wheel, abs_wheel, ff_iforce },
  113. { 0x06f8, 0x0001, "Guillemot Race Leader Force Feedback", btn_wheel, abs_wheel, ff_iforce },
  114. { 0x0000, 0x0000, "Unknown I-Force Device [%04x:%04x]", btn_joystick, abs_joystick, ff_iforce }
  115. };
  117. struct iforce {
  118. struct input_dev dev; /* Input device interface */
  119. struct iforce_device *type;
  120. char name[64];
  121. int open;
  122. int bus;
  124. unsigned char data[IFORCE_MAX_LENGTH];
  125. unsigned char edata[IFORCE_MAX_LENGTH];
  126. u16 ecmd;
  127. u16 expect_packet;
  129. #ifdef IFORCE_232
  130. struct serio *serio; /* RS232 transfer */
  131. int idx, pkt, len, id;
  132. unsigned char csum;
  133. #endif
  134. #ifdef IFORCE_USB
  135. struct usb_device *usbdev; /* USB transfer */
  136. struct urb irq, out, ctrl;
  137. struct usb_ctrlrequest dr;
  138. #endif
  139. /* Force Feedback */
  140. wait_queue_head_t wait;
  141. struct resource device_memory;
  142. struct iforce_core_effect core_effects[FF_EFFECTS_MAX];
  143. };
  145. static struct {
  146. __s32 x;
  147. __s32 y;
  148. } iforce_hat_to_axis[16] = {{ 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
  150. /* Get hi and low bytes of a 16-bits int */
  151. #define HI(a) ((unsigned char)((a) >> 8))
  152. #define LO(a) ((unsigned char)((a) & 0xff))
  154. /* Encode a time value */
  155. #define TIME_SCALE(a) ((a) == 0xffff ? 0xffff : (a) * 1000 / 256)
  157. static void dump_packet(char *msg, u16 cmd, unsigned char *data)
  158. {
  159. int i;
  161. printk(KERN_DEBUG "iforce.c: %s ( cmd = %04x, data = ", msg, cmd);
  162. for (i = 0; i < LO(cmd); i++)
  163. printk("%02x ", data[i]);
  164. printk(")n");
  165. }
  167. /*
  168.  * Send a packet of bytes to the device
  169.  */
  170. static void send_packet(struct iforce *iforce, u16 cmd, unsigned char* data)
  171. {
  172. switch (iforce->bus) {
  174. #ifdef IFORCE_232
  175. case IFORCE_232: {
  177. int i;
  178. unsigned char csum = 0x2b ^ HI(cmd) ^ LO(cmd);
  180. serio_write(iforce->serio, 0x2b);
  181. serio_write(iforce->serio, HI(cmd));
  182. serio_write(iforce->serio, LO(cmd));
  184. for (i = 0; i < LO(cmd); i++) {
  185. serio_write(iforce->serio, data[i]);
  186. csum = csum ^ data[i];
  187. }
  189. serio_write(iforce->serio, csum);
  190. return;
  191. }
  192. #endif
  193. #ifdef IFORCE_USB
  194. case IFORCE_USB: {
  196. DECLARE_WAITQUEUE(wait, current);
  197. int timeout = HZ; /* 1 second */
  199. memcpy(iforce->out.transfer_buffer + 1, data, LO(cmd));
  200. ((char*)iforce->out.transfer_buffer)[0] = HI(cmd);
  201. iforce->out.transfer_buffer_length = LO(cmd) + 2;
  202. iforce->out.dev = iforce->usbdev;
  204. set_current_state(TASK_INTERRUPTIBLE);
  205. add_wait_queue(&iforce->wait, &wait);
  207. if (usb_submit_urb(&iforce->out)) {
  208. set_current_state(TASK_RUNNING);
  209. remove_wait_queue(&iforce->wait, &wait);
  210. return;
  211. }
  213. while (timeout && iforce->out.status == -EINPROGRESS)
  214. timeout = schedule_timeout(timeout);
  216. set_current_state(TASK_RUNNING);
  217. remove_wait_queue(&iforce->wait, &wait);
  219. if (!timeout)
  220. usb_unlink_urb(&iforce->out);
  222. return;
  223. }
  224. #endif
  225. }
  226. }
  228. static void iforce_process_packet(struct iforce *iforce, u16 cmd, unsigned char *data)
  229. {
  230. struct input_dev *dev = &iforce->dev;
  231. int i;
  233. #ifdef IFORCE_232
  234. if (HI(iforce->expect_packet) == HI(cmd)) {
  235. iforce->expect_packet = 0;
  236. iforce->ecmd = cmd;
  237. memcpy(iforce->edata, data, IFORCE_MAX_LENGTH);
  238. if (waitqueue_active(&iforce->wait))
  239. wake_up(&iforce->wait);
  240. }
  241. #endif
  243. if (!iforce->type)
  244. return;
  246. switch (HI(cmd)) {
  248. case 0x01: /* joystick position data */
  249. case 0x03: /* wheel position data */
  251. if (HI(cmd) == 1) {
  252. input_report_abs(dev, ABS_X, (__s16) (((__s16)data[1] << 8) | data[0]));
  253. input_report_abs(dev, ABS_Y, (__s16) (((__s16)data[3] << 8) | data[2]));
  254. input_report_abs(dev, ABS_THROTTLE, 255 - data[4]);
  255. } else {
  256. input_report_abs(dev, ABS_WHEEL, (__s16) (((__s16)data[1] << 8) | data[0]));
  257. input_report_abs(dev, ABS_GAS,   255 - data[2]);
  258. input_report_abs(dev, ABS_BRAKE, 255 - data[3]);
  259. }
  261. input_report_abs(dev, ABS_HAT0X, iforce_hat_to_axis[data[6] >> 4].x);
  262. input_report_abs(dev, ABS_HAT0Y, iforce_hat_to_axis[data[6] >> 4].y);
  264. for (i = 0; iforce->type->btn[i] >= 0; i++)
  265. input_report_key(dev, iforce->type->btn[i], data[(i >> 3) + 5] & (1 << (i & 7)));
  267. break;
  269. case 0x02: /* status report */
  271. input_report_key(dev, BTN_DEAD, data[0] & 0x02);
  272. break;
  273. }
  274. }
  276. static int get_id_packet(struct iforce *iforce, char *packet)
  277. {
  278. DECLARE_WAITQUEUE(wait, current);
  279. int timeout = HZ; /* 1 second */
  281. switch (iforce->bus) {
  283. #ifdef IFORCE_USB
  284. case IFORCE_USB:
  286. iforce->dr.bRequest = packet[0];
  287. iforce->ctrl.dev = iforce->usbdev;
  289. set_current_state(TASK_INTERRUPTIBLE);
  290. add_wait_queue(&iforce->wait, &wait);
  292. if (usb_submit_urb(&iforce->ctrl)) {
  293. set_current_state(TASK_RUNNING);
  294. remove_wait_queue(&iforce->wait, &wait);
  295. return -1;
  296. }
  298. while (timeout && iforce->ctrl.status == -EINPROGRESS)
  299. timeout = schedule_timeout(timeout);
  301. set_current_state(TASK_RUNNING);
  302. remove_wait_queue(&iforce->wait, &wait);
  304. if (!timeout) {
  305. usb_unlink_urb(&iforce->ctrl);
  306. return -1;
  307. }
  309. break;
  310. #endif
  311. #ifdef IFORCE_232
  312. case IFORCE_232:
  314. iforce->expect_packet = FF_CMD_QUERY;
  315. send_packet(iforce, FF_CMD_QUERY, packet);
  317. set_current_state(TASK_INTERRUPTIBLE);
  318. add_wait_queue(&iforce->wait, &wait);
  320. while (timeout && iforce->expect_packet)
  321. timeout = schedule_timeout(timeout);
  323. set_current_state(TASK_RUNNING);
  324. remove_wait_queue(&iforce->wait, &wait);
  326. if (!timeout) {
  327. iforce->expect_packet = 0;
  328. return -1;
  329. }
  331. break;
  332. #endif
  333. }
  335. return -(iforce->edata[0] != packet[0]);
  336. }
  338. static int iforce_open(struct input_dev *dev)
  339. {
  340. struct iforce *iforce = dev->private;
  342. switch (iforce->bus) {
  343. #ifdef IFORCE_USB
  344. case IFORCE_USB:
  345. if (iforce->open++)
  346. break;
  347. iforce->irq.dev = iforce->usbdev;
  348. if (usb_submit_urb(&iforce->irq))
  349. return -EIO;
  350. break;
  351. #endif
  352. }
  353. return 0;
  354. }
  356. static void iforce_close(struct input_dev *dev)
  357. {
  358. struct iforce *iforce = dev->private;
  360. switch (iforce->bus) {
  361. #ifdef IFORCE_USB
  362. case IFORCE_USB:
  363. if (!--iforce->open)
  364. usb_unlink_urb(&iforce->irq);
  365. break;
  366. #endif
  367. }
  368. }
  370. /*
  371.  * Start or stop playing an effect
  372.  */
  374. static int iforce_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
  375. {
  376. struct iforce* iforce = (struct iforce*)(dev->private);
  377. unsigned char data[3];
  379. printk(KERN_DEBUG "iforce.c: input_event(type = %d, code = %d, value = %d)n", type, code, value);
  381. if (type != EV_FF)
  382. return -1;
  384. switch (code) {
  386. case FF_GAIN:
  388. data[0] = value >> 9;
  389. send_packet(iforce, FF_CMD_GAIN, data);
  391. return 0;
  393. case FF_AUTOCENTER:
  395. data[0] = 0x03;
  396. data[1] = value >> 9;
  397. send_packet(iforce, FF_CMD_AUTOCENTER, data);
  399. data[0] = 0x04;
  400. data[1] = 0x01;
  401. send_packet(iforce, FF_CMD_AUTOCENTER, data);
  403. return 0;
  405. default: /* Play an effect */
  407. if (code >= iforce->dev.ff_effects_max)
  408. return -1;
  410. data[0] = LO(code);
  411. data[1] = (value > 0) ? ((value > 1) ? 0x41 : 0x01) : 0;
  412. data[2] = LO(value);
  413. send_packet(iforce, FF_CMD_PLAY, data);
  415. return 0;
  416. }
  418. return -1;
  419. }
  421. /*
  422.  * Set the magnitude of a constant force effect
  423.  * Return error code
  424.  *
  425.  * Note: caller must ensure exclusive access to device
  426.  */
  428. static int make_magnitude_modifier(struct iforce* iforce,
  429. struct resource* mod_chunk, __s16 level)
  430. {
  431. unsigned char data[3];
  433. if (allocate_resource(&(iforce->device_memory), mod_chunk, 2,
  434. iforce->device_memory.start, iforce->device_memory.end, 2L,
  435. NULL, NULL)) {
  436. return -ENOMEM;
  437. }
  439. data[0] = LO(mod_chunk->start);
  440. data[1] = HI(mod_chunk->start);
  441. data[2] = HI(level);
  443. send_packet(iforce, FF_CMD_MAGNITUDE, data);
  445. return 0;
  446. }
  448. /*
  449.  * Upload the component of an effect dealing with the period, phase and magnitude
  450.  */
  452. static int make_period_modifier(struct iforce* iforce, struct resource* mod_chunk,
  453. __s16 magnitude, __s16 offset, u16 period, u16 phase)
  454. {
  455. unsigned char data[7];
  457. period = TIME_SCALE(period);
  459. if (allocate_resource(&(iforce->device_memory), mod_chunk, 0x0c,
  460. iforce->device_memory.start, iforce->device_memory.end, 2L,
  461. NULL, NULL)) {
  462. return -ENOMEM;
  463. }
  465. data[0] = LO(mod_chunk->start);
  466. data[1] = HI(mod_chunk->start);
  468. data[2] = HI(magnitude);
  469. data[3] = HI(offset);
  470. data[4] = HI(phase);
  472. data[5] = LO(period);
  473. data[6] = HI(period);
  475. send_packet(iforce, FF_CMD_PERIOD, data);
  477. return 0;
  478. }
  480. /*
  481.  * Uploads the part of an effect setting the shape of the force
  482.  */
  484. static int make_shape_modifier(struct iforce* iforce, struct resource* mod_chunk,
  485. u16 attack_duration, __s16 initial_level,
  486. u16 fade_duration, __s16 final_level)
  487. {
  488. unsigned char data[8];
  490. attack_duration = TIME_SCALE(attack_duration);
  491. fade_duration = TIME_SCALE(fade_duration);
  493. if (allocate_resource(&(iforce->device_memory), mod_chunk, 0x0e,
  494. iforce->device_memory.start, iforce->device_memory.end, 2L,
  495. NULL, NULL)) {
  496. return -ENOMEM;
  497. }
  499. data[0] = LO(mod_chunk->start);
  500. data[1] = HI(mod_chunk->start);
  502. data[2] = LO(attack_duration);
  503. data[3] = HI(attack_duration);
  504. data[4] = HI(initial_level);
  506. data[5] = LO(fade_duration);
  507. data[6] = HI(fade_duration);
  508. data[7] = HI(final_level);
  510. send_packet(iforce, FF_CMD_SHAPE, data);
  512. return 0;
  513. }
  515. /*
  516.  * Component of spring, friction, inertia... effects
  517.  */
  519. static int make_interactive_modifier(struct iforce* iforce,
  520. struct resource* mod_chunk,
  521. __s16 rsat, __s16 lsat, __s16 rk, __s16 lk, u16 db, __s16 center)
  522. {
  523. unsigned char data[10];
  525. if (allocate_resource(&(iforce->device_memory), mod_chunk, 8,
  526. iforce->device_memory.start, iforce->device_memory.end, 2L,
  527. NULL, NULL)) {
  528. return -ENOMEM;
  529. }
  531. data[0] = LO(mod_chunk->start);
  532. data[1] = HI(mod_chunk->start);
  534. data[2] = HI(rk);
  535. data[3] = HI(lk);
  537. data[4] = LO(center);
  538. data[5] = HI(center);
  540. data[6] = LO(db);
  541. data[7] = HI(db);
  543. data[8] = HI(rsat);
  544. data[9] = HI(lsat);
  546. send_packet(iforce, FF_CMD_INTERACT, data);
  548. return 0;
  549. }
  551. static unsigned char find_button(struct iforce *iforce, signed short button)
  552. {
  553. int i;
  554. for (i = 1; iforce->type->btn[i] >= 0; i++)
  555. if (iforce->type->btn[i] == button)
  556. return i + 1;
  557. return 0;
  558. }
  560. /*
  561.  * Send the part common to all effects to the device
  562.  */
  564. static int make_core(struct iforce* iforce, u16 id, u16 mod_id1, u16 mod_id2,
  565. u8 effect_type, u8 axes, u16 duration, u16 delay, u16 button,
  566. u16 interval, u16 direction)
  567. {
  568. unsigned char data[14];
  570. duration = TIME_SCALE(duration);
  571. delay    = TIME_SCALE(delay);
  572. interval = TIME_SCALE(interval);
  574. data[0]  = LO(id);
  575. data[1]  = effect_type;
  576. data[2]  = LO(axes) | find_button(iforce, button);
  578. data[3]  = LO(duration);
  579. data[4]  = HI(duration);
  581. data[5]  = HI(direction);
  583. data[6]  = LO(interval);
  584. data[7]  = HI(interval);
  586. data[8]  = LO(mod_id1);
  587. data[9]  = HI(mod_id1);
  588. data[10] = LO(mod_id2);
  589. data[11] = HI(mod_id2);
  591. data[12] = LO(delay);
  592. data[13] = HI(delay);
  594. send_packet(iforce, FF_CMD_EFFECT, data);
  596. return 0;
  597. }
  599. /*
  600.  * Upload a periodic effect to the device
  601.  */
  603. static int iforce_upload_periodic(struct iforce* iforce, struct ff_effect* effect)
  604. {
  605. u8 wave_code;
  606. int core_id = effect->id;
  607. struct iforce_core_effect* core_effect = iforce->core_effects + core_id;
  608. struct resource* mod1_chunk = &(iforce->core_effects[core_id].mod1_chunk);
  609. struct resource* mod2_chunk = &(iforce->core_effects[core_id].mod2_chunk);
  610. int err = 0;
  612. err = make_period_modifier(iforce, mod1_chunk,
  613. effect->u.periodic.magnitude, effect->u.periodic.offset,
  614. effect->u.periodic.period, effect->u.periodic.phase);
  615. if (err) return err;
  616. set_bit(FF_MOD1_IS_USED, core_effect->flags);
  618. err = make_shape_modifier(iforce, mod2_chunk,
  619. effect->u.periodic.shape.attack_length,
  620. effect->u.periodic.shape.attack_level,
  621. effect->u.periodic.shape.fade_length,
  622. effect->u.periodic.shape.fade_level);
  623. if (err) return err;
  624. set_bit(FF_MOD2_IS_USED, core_effect->flags);
  626. switch (effect->u.periodic.waveform) {
  627. case FF_SQUARE: wave_code = 0x20; break;
  628. case FF_TRIANGLE: wave_code = 0x21; break;
  629. case FF_SINE: wave_code = 0x22; break;
  630. case FF_SAW_UP: wave_code = 0x23; break;
  631. case FF_SAW_DOWN: wave_code = 0x24; break;
  632. default: wave_code = 0x20; break;
  633. }
  635. err = make_core(iforce, effect->id,
  636. mod1_chunk->start,
  637. mod2_chunk->start,
  638. wave_code,
  639. 0x20,
  640. effect->replay.length,
  641. effect->replay.delay,
  642. effect->trigger.button,
  643. effect->trigger.interval,
  644. effect->u.periodic.direction);
  646. return err;
  647. }
  649. /*
  650.  * Upload a constant force effect
  651.  */
  652. static int iforce_upload_constant(struct iforce* iforce, struct ff_effect* effect)
  653. {
  654. int core_id = effect->id;
  655. struct iforce_core_effect* core_effect = iforce->core_effects + core_id;
  656. struct resource* mod1_chunk = &(iforce->core_effects[core_id].mod1_chunk);
  657. struct resource* mod2_chunk = &(iforce->core_effects[core_id].mod2_chunk);
  658. int err = 0;
  660. printk(KERN_DEBUG "iforce.c: make constant effectn");
  662. err = make_magnitude_modifier(iforce, mod1_chunk, effect->u.constant.level);
  663. if (err) return err;
  664. set_bit(FF_MOD1_IS_USED, core_effect->flags);
  666. err = make_shape_modifier(iforce, mod2_chunk,
  667. effect->u.constant.shape.attack_length,
  668. effect->u.constant.shape.attack_level,
  669. effect->u.constant.shape.fade_length,
  670. effect->u.constant.shape.fade_level);
  671. if (err) return err;
  672. set_bit(FF_MOD2_IS_USED, core_effect->flags);
  674. err = make_core(iforce, effect->id,
  675. mod1_chunk->start,
  676. mod2_chunk->start,
  677. 0x00,
  678. 0x20,
  679. effect->replay.length,
  680. effect->replay.delay,
  681. effect->trigger.button,
  682. effect->trigger.interval,
  683. effect->u.constant.direction);
  685. return err;
  686. }
  688. /*
  689.  * Upload an interactive effect. Those are for example friction, inertia, springs...
  690.  */
  691. static int iforce_upload_interactive(struct iforce* iforce, struct ff_effect* effect)
  692. {
  693. int core_id = effect->id;
  694. struct iforce_core_effect* core_effect = iforce->core_effects + core_id;
  695. struct resource* mod_chunk = &(core_effect->mod1_chunk);
  696. u8 type, axes;
  697. u16 mod1, mod2, direction;
  698. int err = 0;
  700. printk(KERN_DEBUG "iforce.c: make interactive effectn");
  702. switch (effect->type) {
  703. case FF_SPRING: type = 0x40; break;
  704. case FF_FRICTION: type = 0x41; break;
  705. default: return -1;
  706. }
  708. err = make_interactive_modifier(iforce, mod_chunk,
  709. effect->u.interactive.right_saturation,
  710. effect->u.interactive.left_saturation,
  711. effect->u.interactive.right_coeff,
  712. effect->u.interactive.left_coeff,
  713. effect->u.interactive.deadband,
  714. effect->u.interactive.center);
  715. if (err) return err;
  716. set_bit(FF_MOD1_IS_USED, core_effect->flags);
  718. switch ((test_bit(ABS_X, &effect->u.interactive.axis) ||
  719. test_bit(ABS_WHEEL, &effect->u.interactive.axis)) |
  720. (!!test_bit(ABS_Y, &effect->u.interactive.axis) << 1)) {
  722. case 0: /* Only one axis, choose orientation */
  723. mod1 = mod_chunk->start;
  724. mod2 = 0xffff;
  725. direction = effect->u.interactive.direction;
  726. axes = 0x20;
  727. break;
  729. case 1: /* Only X axis */
  730. mod1 = mod_chunk->start;
  731. mod2 = 0xffff;
  732. direction = 0x5a00;
  733. axes = 0x40;
  734. break;
  736. case 2: /* Only Y axis */
  737. mod1 = 0xffff;
  738. mod2 = mod_chunk->start;
  739. direction = 0xb400;
  740. axes = 0x80;
  741. break;
  743. case 3: /* Both X and Y axes */
  744. /* TODO: same setting for both axes is not mandatory */
  745. mod1 = mod_chunk->start;
  746. mod2 = mod_chunk->start;
  747. direction = 0x6000;
  748. axes = 0xc0;
  749. break;
  751. default:
  752. return -1;
  753. }
  755. err = make_core(iforce, effect->id,
  756. mod1, mod2,
  757. type, axes,
  758. effect->replay.length, effect->replay.delay,
  759. effect->trigger.button, effect->trigger.interval,
  760. direction);
  762. return err;
  763. }
  765. /*
  766.  * Function called when an ioctl is performed on the event dev entry.
  767.  * It uploads an effect to the device
  768.  */
  769. static int iforce_upload_effect(struct input_dev *dev, struct ff_effect *effect)
  770. {
  771. struct iforce* iforce = (struct iforce*)(dev->private);
  772. int id;
  774. printk(KERN_DEBUG "iforce.c: upload effectn");
  776. /*
  777.  * Get a free id
  778.  */
  780. for (id=0; id < FF_EFFECTS_MAX; ++id)
  781. if (!test_bit(FF_CORE_IS_USED, iforce->core_effects[id].flags)) break;
  783. if ( id == FF_EFFECTS_MAX || id >= iforce->dev.ff_effects_max)
  784. return -ENOMEM;
  786. effect->id = id;
  787. set_bit(FF_CORE_IS_USED, iforce->core_effects[id].flags);
  789. /*
  790.  * Upload the effect
  791.  */
  793. switch (effect->type) {
  795. case FF_PERIODIC:
  796. return iforce_upload_periodic(iforce, effect);
  798. case FF_CONSTANT:
  799. return iforce_upload_constant(iforce, effect);
  801. case FF_SPRING:
  802. case FF_FRICTION:
  803. return iforce_upload_interactive(iforce, effect);
  805. default:
  806. return -1;
  807. }
  808. }
  810. /*
  811.  * Erases an effect: it frees the effect id and mark as unused the memory
  812.  * allocated for the parameters
  813.  */
  814. static int iforce_erase_effect(struct input_dev *dev, int effect_id)
  815. {
  816. struct iforce* iforce = (struct iforce*)(dev->private);
  817. int err = 0;
  818. struct iforce_core_effect* core_effect;
  820. printk(KERN_DEBUG "iforce.c: erase effect %dn", effect_id);
  822. if (effect_id < 0 || effect_id >= FF_EFFECTS_MAX)
  823. return -EINVAL;
  825. core_effect = iforce->core_effects + effect_id;
  827. if (test_bit(FF_MOD1_IS_USED, core_effect->flags))
  828. err = release_resource(&(iforce->core_effects[effect_id].mod1_chunk));
  830. if (!err && test_bit(FF_MOD2_IS_USED, core_effect->flags))
  831. err = release_resource(&(iforce->core_effects[effect_id].mod2_chunk));
  833. /*TODO: remember to change that if more FF_MOD* bits are added */
  834. core_effect->flags[0] = 0;
  836. return err;
  837. }
  838. static int iforce_init_device(struct iforce *iforce)
  839. {
  840. unsigned char c[] = "CEOV";
  841. int i;
  843. init_waitqueue_head(&iforce->wait);
  844. iforce->dev.ff_effects_max = 10;
  846. /*
  847.  * Input device fields.
  848.  */
  850. iforce->dev.idbus = BUS_USB;
  851. iforce->dev.private = iforce;
  852. iforce->dev.name = iforce->name;
  853. iforce->dev.open = iforce_open;
  854. iforce->dev.close = iforce_close;
  855. iforce->dev.event = iforce_input_event;
  856. iforce->dev.upload_effect = iforce_upload_effect;
  857. iforce->dev.erase_effect = iforce_erase_effect;
  859. /*
  860.  * On-device memory allocation.
  861.  */
  863. iforce->device_memory.name = "I-Force device effect memory";
  864. iforce->device_memory.start = 0;
  865. iforce->device_memory.end = 200;
  866. iforce->device_memory.flags = IORESOURCE_MEM;
  867. iforce->device_memory.parent = NULL;
  868. iforce->device_memory.child = NULL;
  869. iforce->device_memory.sibling = NULL;
  871. /*
  872.  * Wait until device ready - until it sends its first response.
  873.  */
  875. for (i = 0; i < 20; i++)
  876. if (!get_id_packet(iforce, "O"))
  877. break;
  879. if (i == 20) { /* 5 seconds */
  880. printk(KERN_ERR "iforce.c: Timeout waiting for response from device.n");
  881. iforce_close(&iforce->dev);
  882. return -1;
  883. }
  885. /*
  886.  * Get device info.
  887.  */
  889. if (!get_id_packet(iforce, "M"))
  890. iforce->dev.idvendor = (iforce->edata[2] << 8) | iforce->edata[1];
  891. if (!get_id_packet(iforce, "P"))
  892. iforce->dev.idproduct = (iforce->edata[2] << 8) | iforce->edata[1];
  893. if (!get_id_packet(iforce, "B"))
  894. iforce->device_memory.end = (iforce->edata[2] << 8) | iforce->edata[1];
  895. if (!get_id_packet(iforce, "N"))
  896. iforce->dev.ff_effects_max = iforce->edata[1];
  898. /*
  899.  * Display additional info.
  900.  */
  902. for (i = 0; c[i]; i++)
  903. if (!get_id_packet(iforce, c + i))
  904. dump_packet("info", iforce->ecmd, iforce->edata);
  906. /*
  907.  * Disable spring, enable force feedback.
  908.  * FIXME: We should use iforce_set_autocenter() et al here.
  909.  */
  911. send_packet(iforce, FF_CMD_AUTOCENTER, "0400");
  912. send_packet(iforce, FF_CMD_ENABLE, "04");
  914. /*
  915.  * Find appropriate device entry
  916.  */
  918. for (i = 0; iforce_device[i].idvendor; i++)
  919. if (iforce_device[i].idvendor == iforce->dev.idvendor &&
  920.     iforce_device[i].idproduct == iforce->dev.idproduct)
  921. break;
  923. iforce->type = iforce_device + i;
  925. sprintf(iforce->name, iforce->type->name,
  926. iforce->dev.idproduct, iforce->dev.idvendor);
  928. /*
  929.  * Set input device bitfields and ranges.
  930.  */
  932. iforce->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_FF);
  934. for (i = 0; iforce->type->btn[i] >= 0; i++) {
  935. signed short t = iforce->type->btn[i];
  936. set_bit(t, iforce->dev.keybit);
  937. if (t != BTN_DEAD)
  938. set_bit(FF_BTN(t), iforce->dev.ffbit);
  939. }
  941. for (i = 0; iforce->type->abs[i] >= 0; i++) {
  943. signed short t = iforce->type->abs[i];
  944. set_bit(t, iforce->dev.absbit);
  946. switch (t) {
  948. case ABS_X:
  949. case ABS_Y:
  950. case ABS_WHEEL:
  952. iforce->dev.absmax[t] =  1920;
  953. iforce->dev.absmin[t] = -1920;
  954. iforce->dev.absflat[t] = 128;
  955. iforce->dev.absfuzz[t] = 16;
  957. set_bit(FF_ABS(t), iforce->dev.ffbit);
  958. break;
  960. case ABS_THROTTLE:
  961. case ABS_GAS:
  962. case ABS_BRAKE:
  964. iforce->dev.absmax[t] = 255;
  965. iforce->dev.absmin[t] = 0;
  966. break;
  968. case ABS_HAT0X:
  969. case ABS_HAT0Y:
  970. iforce->dev.absmax[t] =  1;
  971. iforce->dev.absmin[t] = -1;
  972. break;
  973. }
  974. }
  976. for (i = 0; iforce->type->ff[i] >= 0; i++)
  977. set_bit(iforce->type->ff[i], iforce->dev.ffbit);
  979. /*
  980.  * Register input device.
  981.  */
  983. input_register_device(&iforce->dev);
  985. return 0;
  986. }
  988. #ifdef IFORCE_USB
  990. static void iforce_usb_irq(struct urb *urb)
  991. {
  992. struct iforce *iforce = urb->context;
  993. if (urb->status) return;
  994. iforce_process_packet(iforce,
  995. (iforce->data[0] << 8) | (urb->actual_length - 1), iforce->data + 1);
  996. }
  998. static void iforce_usb_out(struct urb *urb)
  999. {
  1000. struct iforce *iforce = urb->context;
  1001. if (urb->status) return;
  1002. if (waitqueue_active(&iforce->wait))
  1003. wake_up(&iforce->wait);
  1004. }
  1006. static void iforce_usb_ctrl(struct urb *urb)
  1007. {
  1008. struct iforce *iforce = urb->context;
  1009. if (urb->status) return;
  1010. iforce->ecmd = 0xff00 | urb->actual_length;
  1011. if (waitqueue_active(&iforce->wait))
  1012. wake_up(&iforce->wait);
  1013. }
  1015. static void *iforce_usb_probe(struct usb_device *dev, unsigned int ifnum,
  1016. const struct usb_device_id *id)
  1017. {
  1018. struct usb_endpoint_descriptor *epirq, *epout;
  1019. struct iforce *iforce;
  1021. epirq = dev->config[0].interface[ifnum].altsetting[0].endpoint + 0;
  1022. epout = dev->config[0].interface[ifnum].altsetting[0].endpoint + 1;
  1024. if (!(iforce = kmalloc(sizeof(struct iforce) + 32, GFP_KERNEL))) return NULL;
  1025. memset(iforce, 0, sizeof(struct iforce));
  1027. iforce->bus = IFORCE_USB;
  1028. iforce->usbdev = dev;
  1030. iforce->dr.bRequestType = USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_INTERFACE;
  1031. iforce->dr.wIndex = 0;
  1032. iforce->dr.wLength = 16;
  1034. FILL_INT_URB(&iforce->irq, dev, usb_rcvintpipe(dev, epirq->bEndpointAddress),
  1035. iforce->data, 16, iforce_usb_irq, iforce, epirq->bInterval);
  1037. FILL_BULK_URB(&iforce->out, dev, usb_sndbulkpipe(dev, epout->bEndpointAddress),
  1038. iforce + 1, 32, iforce_usb_out, iforce);
  1040. FILL_CONTROL_URB(&iforce->ctrl, dev, usb_rcvctrlpipe(dev, 0),
  1041. (void*) &iforce->dr, iforce->edata, 16, iforce_usb_ctrl, iforce);
  1043. if (iforce_init_device(iforce)) {
  1044. kfree(iforce);
  1045. return NULL;
  1046. }
  1048. printk(KERN_INFO "input%d: %s [%d effects, %ld bytes memory] on usb%d:%d.%dn",
  1049. iforce->dev.number, iforce->dev.name, iforce->dev.ff_effects_max,
  1050. iforce->device_memory.end, dev->bus->busnum, dev->devnum, ifnum);
  1052. return iforce;
  1053. }
  1055. static void iforce_usb_disconnect(struct usb_device *dev, void *ptr)
  1056. {
  1057. struct iforce *iforce = ptr;
  1058. usb_unlink_urb(&iforce->irq);
  1059. input_unregister_device(&iforce->dev);
  1060. kfree(iforce);
  1061. }
  1063. static struct usb_device_id iforce_usb_ids [] = {
  1064. { USB_DEVICE(0x046d, 0xc281) }, /* Logitech WingMan Force */
  1065. { USB_DEVICE(0x046d, 0xc291) }, /* Logitech WingMan Formula Force */
  1066. { USB_DEVICE(0x05ef, 0x020a) }, /* AVB Top Shot Pegasus */
  1067. { USB_DEVICE(0x05ef, 0x8884) }, /* AVB Mag Turbo Force */
  1068. { USB_DEVICE(0x06f8, 0x0001) }, /* Guillemot Race Leader Force Feedback */
  1069. { } /* Terminating entry */
  1070. };
  1072. MODULE_DEVICE_TABLE (usb, iforce_usb_ids);
  1074. static struct usb_driver iforce_usb_driver = {
  1075. name: "iforce",
  1076. probe: iforce_usb_probe,
  1077. disconnect: iforce_usb_disconnect,
  1078. id_table: iforce_usb_ids,
  1079. };
  1081. #endif
  1083. #ifdef IFORCE_232
  1085. static void iforce_serio_irq(struct serio *serio, unsigned char data, unsigned int flags)
  1086. {
  1087. struct iforce* iforce = serio->private;
  1089. if (!iforce->pkt) {
  1090. if (data != 0x2b) {
  1091. return;
  1092. }
  1093. iforce->pkt = 1;
  1094. return;
  1095. }
  1097. if (!iforce->id) {
  1098. if (data > 3 && data != 0xff) {
  1099. iforce->pkt = 0;
  1100. return;
  1101. }
  1102. iforce->id = data;
  1103. return;
  1104. }
  1106. if (!iforce->len) {
  1107. if (data > IFORCE_MAX_LENGTH) {
  1108. iforce->pkt = 0;
  1109. iforce->id = 0;
  1110. return;
  1111. }
  1112. iforce->len = data;
  1113. return;
  1114. }
  1116. if (iforce->idx < iforce->len) {
  1117. iforce->csum += iforce->data[iforce->idx++] = data;
  1118. return;
  1119. }
  1121. if (iforce->idx == iforce->len) {
  1122. iforce_process_packet(iforce, (iforce->id << 8) | iforce->idx, iforce->data);
  1123. iforce->pkt = 0;
  1124. iforce->id  = 0;
  1125. iforce->len = 0;
  1126. iforce->idx = 0;
  1127. iforce->csum = 0;
  1128. }
  1129. }
  1131. static void iforce_serio_connect(struct serio *serio, struct serio_dev *dev)
  1132. {
  1133. struct iforce *iforce;
  1134. if (serio->type != (SERIO_RS232 | SERIO_IFORCE))
  1135. return;
  1137. if (!(iforce = kmalloc(sizeof(struct iforce), GFP_KERNEL))) return;
  1138. memset(iforce, 0, sizeof(struct iforce));
  1140. iforce->bus = IFORCE_232;
  1141. iforce->serio = serio;
  1142. serio->private = iforce;
  1144. if (serio_open(serio, dev)) {
  1145. kfree(iforce);
  1146. return;
  1147. }
  1149. if (iforce_init_device(iforce)) {
  1150. serio_close(serio);
  1151. kfree(iforce);
  1152. return;
  1153. }
  1155. printk(KERN_INFO "input%d: %s [%d effects, %ld bytes memory] on serio%dn",
  1156. iforce->dev.number, iforce->dev.name, iforce->dev.ff_effects_max,
  1157. iforce->device_memory.end, serio->number);
  1158. }
  1160. static void iforce_serio_disconnect(struct serio *serio)
  1161. {
  1162. struct iforce* iforce = serio->private;
  1164. input_unregister_device(&iforce->dev);
  1165. serio_close(serio);
  1166. kfree(iforce);
  1167. }
  1169. static struct serio_dev iforce_serio_dev = {
  1170. interrupt: iforce_serio_irq,
  1171. connect: iforce_serio_connect,
  1172. disconnect: iforce_serio_disconnect,
  1173. };
  1175. #endif
  1177. static int __init iforce_init(void)
  1178. {
  1179. #ifdef IFORCE_USB
  1180. usb_register(&iforce_usb_driver);
  1181. #endif
  1182. #ifdef IFORCE_232
  1183. serio_register_device(&iforce_serio_dev);
  1184. #endif
  1185. return 0;
  1186. }
  1188. static void __exit iforce_exit(void)
  1189. {
  1190. #ifdef IFORCE_USB
  1191. usb_deregister(&iforce_usb_driver);
  1192. #endif
  1193. #ifdef IFORCE_232
  1194. serio_unregister_device(&iforce_serio_dev);
  1195. #endif
  1196. }
  1198. module_init(iforce_init);
  1199. module_exit(iforce_exit);