/drivers/staging/comedi/drivers/jr3_pci.c

https://bitbucket.org/wisechild/galaxy-nexus · C · 1026 lines · 838 code · 102 blank · 86 comment · 131 complexity · ce4ceeb43a2fcc36ff0913df66f2b9fd MD5 · raw file

  1. /*
  2. comedi/drivers/jr3_pci.c
  3. hardware driver for JR3/PCI force sensor board
  4. COMEDI - Linux Control and Measurement Device Interface
  5. Copyright (C) 2007 Anders Blomdell <anders.blomdell@control.lth.se>
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. GNU General Public License for more details.
  14. You should have received a copy of the GNU General Public License
  15. along with this program; if not, write to the Free Software
  16. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17. */
  18. /*
  19. Driver: jr3_pci
  20. Description: JR3/PCI force sensor board
  21. Author: Anders Blomdell <anders.blomdell@control.lth.se>
  22. Status: works
  23. Devices: [JR3] PCI force sensor board (jr3_pci)
  24. The DSP on the board requires initialization code, which can
  25. be loaded by placing it in /lib/firmware/comedi.
  26. The initialization code should be somewhere on the media you got
  27. with your card. One version is available from http://www.comedi.org
  28. in the comedi_nonfree_firmware tarball.
  29. Configuration options:
  30. [0] - PCI bus number - if bus number and slot number are 0,
  31. then driver search for first unused card
  32. [1] - PCI slot number
  33. */
  34. #include "../comedidev.h"
  35. #include <linux/delay.h>
  36. #include <linux/ctype.h>
  37. #include <linux/firmware.h>
  38. #include <linux/jiffies.h>
  39. #include <linux/slab.h>
  40. #include <linux/timer.h>
  41. #include <linux/kernel.h>
  42. #include "comedi_pci.h"
  43. #include "jr3_pci.h"
  44. #define PCI_VENDOR_ID_JR3 0x1762
  45. #define PCI_DEVICE_ID_JR3_1_CHANNEL 0x3111
  46. #define PCI_DEVICE_ID_JR3_1_CHANNEL_NEW 0x1111
  47. #define PCI_DEVICE_ID_JR3_2_CHANNEL 0x3112
  48. #define PCI_DEVICE_ID_JR3_3_CHANNEL 0x3113
  49. #define PCI_DEVICE_ID_JR3_4_CHANNEL 0x3114
  50. static int jr3_pci_attach(struct comedi_device *dev,
  51. struct comedi_devconfig *it);
  52. static int jr3_pci_detach(struct comedi_device *dev);
  53. static struct comedi_driver driver_jr3_pci = {
  54. .driver_name = "jr3_pci",
  55. .module = THIS_MODULE,
  56. .attach = jr3_pci_attach,
  57. .detach = jr3_pci_detach,
  58. };
  59. static DEFINE_PCI_DEVICE_TABLE(jr3_pci_pci_table) = {
  60. {
  61. PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_1_CHANNEL,
  62. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  63. PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_1_CHANNEL_NEW,
  64. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  65. PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_2_CHANNEL,
  66. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  67. PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_3_CHANNEL,
  68. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  69. PCI_VENDOR_ID_JR3, PCI_DEVICE_ID_JR3_4_CHANNEL,
  70. PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, {
  71. 0}
  72. };
  73. MODULE_DEVICE_TABLE(pci, jr3_pci_pci_table);
  74. struct jr3_pci_dev_private {
  75. struct pci_dev *pci_dev;
  76. int pci_enabled;
  77. volatile struct jr3_t *iobase;
  78. int n_channels;
  79. struct timer_list timer;
  80. };
  81. struct poll_delay_t {
  82. int min;
  83. int max;
  84. };
  85. struct jr3_pci_subdev_private {
  86. volatile struct jr3_channel *channel;
  87. unsigned long next_time_min;
  88. unsigned long next_time_max;
  89. enum { state_jr3_poll,
  90. state_jr3_init_wait_for_offset,
  91. state_jr3_init_transform_complete,
  92. state_jr3_init_set_full_scale_complete,
  93. state_jr3_init_use_offset_complete,
  94. state_jr3_done
  95. } state;
  96. int channel_no;
  97. int serial_no;
  98. int model_no;
  99. struct {
  100. int length;
  101. struct comedi_krange range;
  102. } range[9];
  103. const struct comedi_lrange *range_table_list[8 * 7 + 2];
  104. unsigned int maxdata_list[8 * 7 + 2];
  105. u16 errors;
  106. int retries;
  107. };
  108. /* Hotplug firmware loading stuff */
  109. static int comedi_load_firmware(struct comedi_device *dev, char *name,
  110. int (*cb)(struct comedi_device *dev,
  111. const u8 *data, size_t size))
  112. {
  113. int result = 0;
  114. const struct firmware *fw;
  115. char *firmware_path;
  116. static const char *prefix = "comedi/";
  117. struct jr3_pci_dev_private *devpriv = dev->private;
  118. firmware_path = kmalloc(strlen(prefix) + strlen(name) + 1, GFP_KERNEL);
  119. if (!firmware_path) {
  120. result = -ENOMEM;
  121. } else {
  122. firmware_path[0] = '\0';
  123. strcat(firmware_path, prefix);
  124. strcat(firmware_path, name);
  125. result = request_firmware(&fw, firmware_path,
  126. &devpriv->pci_dev->dev);
  127. if (result == 0) {
  128. if (!cb)
  129. result = -EINVAL;
  130. else
  131. result = cb(dev, fw->data, fw->size);
  132. release_firmware(fw);
  133. }
  134. kfree(firmware_path);
  135. }
  136. return result;
  137. }
  138. static struct poll_delay_t poll_delay_min_max(int min, int max)
  139. {
  140. struct poll_delay_t result;
  141. result.min = min;
  142. result.max = max;
  143. return result;
  144. }
  145. static int is_complete(volatile struct jr3_channel *channel)
  146. {
  147. return get_s16(&channel->command_word0) == 0;
  148. }
  149. struct transform_t {
  150. struct {
  151. u16 link_type;
  152. s16 link_amount;
  153. } link[8];
  154. };
  155. static void set_transforms(volatile struct jr3_channel *channel,
  156. struct transform_t transf, short num)
  157. {
  158. int i;
  159. num &= 0x000f; /* Make sure that 0 <= num <= 15 */
  160. for (i = 0; i < 8; i++) {
  161. set_u16(&channel->transforms[num].link[i].link_type,
  162. transf.link[i].link_type);
  163. udelay(1);
  164. set_s16(&channel->transforms[num].link[i].link_amount,
  165. transf.link[i].link_amount);
  166. udelay(1);
  167. if (transf.link[i].link_type == end_x_form)
  168. break;
  169. }
  170. }
  171. static void use_transform(volatile struct jr3_channel *channel,
  172. short transf_num)
  173. {
  174. set_s16(&channel->command_word0, 0x0500 + (transf_num & 0x000f));
  175. }
  176. static void use_offset(volatile struct jr3_channel *channel, short offset_num)
  177. {
  178. set_s16(&channel->command_word0, 0x0600 + (offset_num & 0x000f));
  179. }
  180. static void set_offset(volatile struct jr3_channel *channel)
  181. {
  182. set_s16(&channel->command_word0, 0x0700);
  183. }
  184. struct six_axis_t {
  185. s16 fx;
  186. s16 fy;
  187. s16 fz;
  188. s16 mx;
  189. s16 my;
  190. s16 mz;
  191. };
  192. static void set_full_scales(volatile struct jr3_channel *channel,
  193. struct six_axis_t full_scale)
  194. {
  195. printk("%d %d %d %d %d %d\n",
  196. full_scale.fx,
  197. full_scale.fy,
  198. full_scale.fz, full_scale.mx, full_scale.my, full_scale.mz);
  199. set_s16(&channel->full_scale.fx, full_scale.fx);
  200. set_s16(&channel->full_scale.fy, full_scale.fy);
  201. set_s16(&channel->full_scale.fz, full_scale.fz);
  202. set_s16(&channel->full_scale.mx, full_scale.mx);
  203. set_s16(&channel->full_scale.my, full_scale.my);
  204. set_s16(&channel->full_scale.mz, full_scale.mz);
  205. set_s16(&channel->command_word0, 0x0a00);
  206. }
  207. static struct six_axis_t get_min_full_scales(volatile struct jr3_channel
  208. *channel)
  209. {
  210. struct six_axis_t result;
  211. result.fx = get_s16(&channel->min_full_scale.fx);
  212. result.fy = get_s16(&channel->min_full_scale.fy);
  213. result.fz = get_s16(&channel->min_full_scale.fz);
  214. result.mx = get_s16(&channel->min_full_scale.mx);
  215. result.my = get_s16(&channel->min_full_scale.my);
  216. result.mz = get_s16(&channel->min_full_scale.mz);
  217. return result;
  218. }
  219. static struct six_axis_t get_max_full_scales(volatile struct jr3_channel
  220. *channel)
  221. {
  222. struct six_axis_t result;
  223. result.fx = get_s16(&channel->max_full_scale.fx);
  224. result.fy = get_s16(&channel->max_full_scale.fy);
  225. result.fz = get_s16(&channel->max_full_scale.fz);
  226. result.mx = get_s16(&channel->max_full_scale.mx);
  227. result.my = get_s16(&channel->max_full_scale.my);
  228. result.mz = get_s16(&channel->max_full_scale.mz);
  229. return result;
  230. }
  231. static int jr3_pci_ai_insn_read(struct comedi_device *dev,
  232. struct comedi_subdevice *s,
  233. struct comedi_insn *insn, unsigned int *data)
  234. {
  235. int result;
  236. struct jr3_pci_subdev_private *p;
  237. int channel;
  238. p = s->private;
  239. channel = CR_CHAN(insn->chanspec);
  240. if (p == NULL || channel > 57) {
  241. result = -EINVAL;
  242. } else {
  243. int i;
  244. result = insn->n;
  245. if (p->state != state_jr3_done ||
  246. (get_u16(&p->channel->errors) & (watch_dog | watch_dog2 |
  247. sensor_change))) {
  248. /* No sensor or sensor changed */
  249. if (p->state == state_jr3_done) {
  250. /* Restart polling */
  251. p->state = state_jr3_poll;
  252. }
  253. result = -EAGAIN;
  254. }
  255. for (i = 0; i < insn->n; i++) {
  256. if (channel < 56) {
  257. int axis, filter;
  258. axis = channel % 8;
  259. filter = channel / 8;
  260. if (p->state != state_jr3_done) {
  261. data[i] = 0;
  262. } else {
  263. int F = 0;
  264. switch (axis) {
  265. case 0:{
  266. F = get_s16
  267. (&p->channel->filter
  268. [filter].fx);
  269. }
  270. break;
  271. case 1:{
  272. F = get_s16
  273. (&p->channel->filter
  274. [filter].fy);
  275. }
  276. break;
  277. case 2:{
  278. F = get_s16
  279. (&p->channel->filter
  280. [filter].fz);
  281. }
  282. break;
  283. case 3:{
  284. F = get_s16
  285. (&p->channel->filter
  286. [filter].mx);
  287. }
  288. break;
  289. case 4:{
  290. F = get_s16
  291. (&p->channel->filter
  292. [filter].my);
  293. }
  294. break;
  295. case 5:{
  296. F = get_s16
  297. (&p->channel->filter
  298. [filter].mz);
  299. }
  300. break;
  301. case 6:{
  302. F = get_s16
  303. (&p->channel->filter
  304. [filter].v1);
  305. }
  306. break;
  307. case 7:{
  308. F = get_s16
  309. (&p->channel->filter
  310. [filter].v2);
  311. }
  312. break;
  313. }
  314. data[i] = F + 0x4000;
  315. }
  316. } else if (channel == 56) {
  317. if (p->state != state_jr3_done) {
  318. data[i] = 0;
  319. } else {
  320. data[i] =
  321. get_u16(&p->channel->model_no);
  322. }
  323. } else if (channel == 57) {
  324. if (p->state != state_jr3_done) {
  325. data[i] = 0;
  326. } else {
  327. data[i] =
  328. get_u16(&p->channel->serial_no);
  329. }
  330. }
  331. }
  332. }
  333. return result;
  334. }
  335. static int jr3_pci_open(struct comedi_device *dev)
  336. {
  337. int i;
  338. struct jr3_pci_dev_private *devpriv = dev->private;
  339. printk("jr3_pci_open\n");
  340. for (i = 0; i < devpriv->n_channels; i++) {
  341. struct jr3_pci_subdev_private *p;
  342. p = dev->subdevices[i].private;
  343. if (p) {
  344. printk("serial: %p %d (%d)\n", p, p->serial_no,
  345. p->channel_no);
  346. }
  347. }
  348. return 0;
  349. }
  350. int read_idm_word(const u8 * data, size_t size, int *pos, unsigned int *val)
  351. {
  352. int result = 0;
  353. if (pos != 0 && val != 0) {
  354. /* Skip over non hex */
  355. for (; *pos < size && !isxdigit(data[*pos]); (*pos)++) {
  356. }
  357. /* Collect value */
  358. *val = 0;
  359. for (; *pos < size; (*pos)++) {
  360. int value;
  361. value = hex_to_bin(data[*pos]);
  362. if (value >= 0) {
  363. result = 1;
  364. *val = (*val << 4) + value;
  365. } else
  366. break;
  367. }
  368. }
  369. return result;
  370. }
  371. static int jr3_download_firmware(struct comedi_device *dev, const u8 * data,
  372. size_t size)
  373. {
  374. /*
  375. * IDM file format is:
  376. * { count, address, data <count> } *
  377. * ffff
  378. */
  379. int result, more, pos, OK;
  380. result = 0;
  381. more = 1;
  382. pos = 0;
  383. OK = 0;
  384. while (more) {
  385. unsigned int count, addr;
  386. more = more && read_idm_word(data, size, &pos, &count);
  387. if (more && count == 0xffff) {
  388. OK = 1;
  389. break;
  390. }
  391. more = more && read_idm_word(data, size, &pos, &addr);
  392. while (more && count > 0) {
  393. unsigned int dummy;
  394. more = more && read_idm_word(data, size, &pos, &dummy);
  395. count--;
  396. }
  397. }
  398. if (!OK) {
  399. result = -ENODATA;
  400. } else {
  401. int i;
  402. struct jr3_pci_dev_private *p = dev->private;
  403. for (i = 0; i < p->n_channels; i++) {
  404. struct jr3_pci_subdev_private *sp;
  405. sp = dev->subdevices[i].private;
  406. more = 1;
  407. pos = 0;
  408. while (more) {
  409. unsigned int count, addr;
  410. more = more
  411. && read_idm_word(data, size, &pos, &count);
  412. if (more && count == 0xffff)
  413. break;
  414. more = more
  415. && read_idm_word(data, size, &pos, &addr);
  416. printk("Loading#%d %4.4x bytes at %4.4x\n", i,
  417. count, addr);
  418. while (more && count > 0) {
  419. if (addr & 0x4000) {
  420. /* 16 bit data, never seen in real life!! */
  421. unsigned int data1;
  422. more = more
  423. && read_idm_word(data,
  424. size, &pos,
  425. &data1);
  426. count--;
  427. /* printk("jr3_data, not tested\n"); */
  428. /* jr3[addr + 0x20000 * pnum] = data1; */
  429. } else {
  430. /* Download 24 bit program */
  431. unsigned int data1, data2;
  432. more = more
  433. && read_idm_word(data,
  434. size, &pos,
  435. &data1);
  436. more = more
  437. && read_idm_word(data, size,
  438. &pos,
  439. &data2);
  440. count -= 2;
  441. if (more) {
  442. set_u16(&p->
  443. iobase->channel
  444. [i].program_low
  445. [addr], data1);
  446. udelay(1);
  447. set_u16(&p->
  448. iobase->channel
  449. [i].program_high
  450. [addr], data2);
  451. udelay(1);
  452. }
  453. }
  454. addr++;
  455. }
  456. }
  457. }
  458. }
  459. return result;
  460. }
  461. static struct poll_delay_t jr3_pci_poll_subdevice(struct comedi_subdevice *s)
  462. {
  463. struct poll_delay_t result = poll_delay_min_max(1000, 2000);
  464. struct jr3_pci_subdev_private *p = s->private;
  465. int i;
  466. if (p) {
  467. volatile struct jr3_channel *channel = p->channel;
  468. int errors = get_u16(&channel->errors);
  469. if (errors != p->errors) {
  470. printk("Errors: %x -> %x\n", p->errors, errors);
  471. p->errors = errors;
  472. }
  473. if (errors & (watch_dog | watch_dog2 | sensor_change)) {
  474. /* Sensor communication lost, force poll mode */
  475. p->state = state_jr3_poll;
  476. }
  477. switch (p->state) {
  478. case state_jr3_poll:{
  479. u16 model_no = get_u16(&channel->model_no);
  480. u16 serial_no = get_u16(&channel->serial_no);
  481. if ((errors & (watch_dog | watch_dog2)) ||
  482. model_no == 0 || serial_no == 0) {
  483. /*
  484. * Still no sensor, keep on polling. Since it takes up to 10 seconds
  485. * for offsets to stabilize, polling each second should suffice.
  486. */
  487. result = poll_delay_min_max(1000, 2000);
  488. } else {
  489. p->retries = 0;
  490. p->state =
  491. state_jr3_init_wait_for_offset;
  492. result = poll_delay_min_max(1000, 2000);
  493. }
  494. }
  495. break;
  496. case state_jr3_init_wait_for_offset:{
  497. p->retries++;
  498. if (p->retries < 10) {
  499. /* Wait for offeset to stabilize (< 10 s according to manual) */
  500. result = poll_delay_min_max(1000, 2000);
  501. } else {
  502. struct transform_t transf;
  503. p->model_no =
  504. get_u16(&channel->model_no);
  505. p->serial_no =
  506. get_u16(&channel->serial_no);
  507. printk
  508. ("Setting transform for channel %d\n",
  509. p->channel_no);
  510. printk("Sensor Model = %i\n",
  511. p->model_no);
  512. printk("Sensor Serial = %i\n",
  513. p->serial_no);
  514. /* Transformation all zeros */
  515. for (i = 0; i < ARRAY_SIZE(transf.link); i++) {
  516. transf.link[i].link_type =
  517. (enum link_types)0;
  518. transf.link[i].link_amount = 0;
  519. }
  520. set_transforms(channel, transf, 0);
  521. use_transform(channel, 0);
  522. p->state =
  523. state_jr3_init_transform_complete;
  524. result = poll_delay_min_max(20, 100); /* Allow 20 ms for completion */
  525. }
  526. } break;
  527. case state_jr3_init_transform_complete:{
  528. if (!is_complete(channel)) {
  529. printk
  530. ("state_jr3_init_transform_complete complete = %d\n",
  531. is_complete(channel));
  532. result = poll_delay_min_max(20, 100);
  533. } else {
  534. /* Set full scale */
  535. struct six_axis_t min_full_scale;
  536. struct six_axis_t max_full_scale;
  537. min_full_scale =
  538. get_min_full_scales(channel);
  539. printk("Obtained Min. Full Scales:\n");
  540. printk("%i ", (min_full_scale).fx);
  541. printk("%i ", (min_full_scale).fy);
  542. printk("%i ", (min_full_scale).fz);
  543. printk("%i ", (min_full_scale).mx);
  544. printk("%i ", (min_full_scale).my);
  545. printk("%i ", (min_full_scale).mz);
  546. printk("\n");
  547. max_full_scale =
  548. get_max_full_scales(channel);
  549. printk("Obtained Max. Full Scales:\n");
  550. printk("%i ", (max_full_scale).fx);
  551. printk("%i ", (max_full_scale).fy);
  552. printk("%i ", (max_full_scale).fz);
  553. printk("%i ", (max_full_scale).mx);
  554. printk("%i ", (max_full_scale).my);
  555. printk("%i ", (max_full_scale).mz);
  556. printk("\n");
  557. set_full_scales(channel,
  558. max_full_scale);
  559. p->state =
  560. state_jr3_init_set_full_scale_complete;
  561. result = poll_delay_min_max(20, 100); /* Allow 20 ms for completion */
  562. }
  563. }
  564. break;
  565. case state_jr3_init_set_full_scale_complete:{
  566. if (!is_complete(channel)) {
  567. printk
  568. ("state_jr3_init_set_full_scale_complete complete = %d\n",
  569. is_complete(channel));
  570. result = poll_delay_min_max(20, 100);
  571. } else {
  572. volatile struct force_array *full_scale;
  573. /* Use ranges in kN or we will overflow arount 2000N! */
  574. full_scale = &channel->full_scale;
  575. p->range[0].range.min =
  576. -get_s16(&full_scale->fx) * 1000;
  577. p->range[0].range.max =
  578. get_s16(&full_scale->fx) * 1000;
  579. p->range[1].range.min =
  580. -get_s16(&full_scale->fy) * 1000;
  581. p->range[1].range.max =
  582. get_s16(&full_scale->fy) * 1000;
  583. p->range[2].range.min =
  584. -get_s16(&full_scale->fz) * 1000;
  585. p->range[2].range.max =
  586. get_s16(&full_scale->fz) * 1000;
  587. p->range[3].range.min =
  588. -get_s16(&full_scale->mx) * 100;
  589. p->range[3].range.max =
  590. get_s16(&full_scale->mx) * 100;
  591. p->range[4].range.min =
  592. -get_s16(&full_scale->my) * 100;
  593. p->range[4].range.max =
  594. get_s16(&full_scale->my) * 100;
  595. p->range[5].range.min =
  596. -get_s16(&full_scale->mz) * 100;
  597. p->range[5].range.max =
  598. get_s16(&full_scale->mz) * 100;
  599. p->range[6].range.min = -get_s16(&full_scale->v1) * 100; /* ?? */
  600. p->range[6].range.max = get_s16(&full_scale->v1) * 100; /* ?? */
  601. p->range[7].range.min = -get_s16(&full_scale->v2) * 100; /* ?? */
  602. p->range[7].range.max = get_s16(&full_scale->v2) * 100; /* ?? */
  603. p->range[8].range.min = 0;
  604. p->range[8].range.max = 65535;
  605. {
  606. int i;
  607. for (i = 0; i < 9; i++) {
  608. printk("%d %d - %d\n",
  609. i,
  610. p->
  611. range[i].range.
  612. min,
  613. p->
  614. range[i].range.
  615. max);
  616. }
  617. }
  618. use_offset(channel, 0);
  619. p->state =
  620. state_jr3_init_use_offset_complete;
  621. result = poll_delay_min_max(40, 100); /* Allow 40 ms for completion */
  622. }
  623. }
  624. break;
  625. case state_jr3_init_use_offset_complete:{
  626. if (!is_complete(channel)) {
  627. printk
  628. ("state_jr3_init_use_offset_complete complete = %d\n",
  629. is_complete(channel));
  630. result = poll_delay_min_max(20, 100);
  631. } else {
  632. printk
  633. ("Default offsets %d %d %d %d %d %d\n",
  634. get_s16(&channel->offsets.fx),
  635. get_s16(&channel->offsets.fy),
  636. get_s16(&channel->offsets.fz),
  637. get_s16(&channel->offsets.mx),
  638. get_s16(&channel->offsets.my),
  639. get_s16(&channel->offsets.mz));
  640. set_s16(&channel->offsets.fx, 0);
  641. set_s16(&channel->offsets.fy, 0);
  642. set_s16(&channel->offsets.fz, 0);
  643. set_s16(&channel->offsets.mx, 0);
  644. set_s16(&channel->offsets.my, 0);
  645. set_s16(&channel->offsets.mz, 0);
  646. set_offset(channel);
  647. p->state = state_jr3_done;
  648. }
  649. }
  650. break;
  651. case state_jr3_done:{
  652. poll_delay_min_max(10000, 20000);
  653. }
  654. break;
  655. default:{
  656. poll_delay_min_max(1000, 2000);
  657. }
  658. break;
  659. }
  660. }
  661. return result;
  662. }
  663. static void jr3_pci_poll_dev(unsigned long data)
  664. {
  665. unsigned long flags;
  666. struct comedi_device *dev = (struct comedi_device *)data;
  667. struct jr3_pci_dev_private *devpriv = dev->private;
  668. unsigned long now;
  669. int delay;
  670. int i;
  671. spin_lock_irqsave(&dev->spinlock, flags);
  672. delay = 1000;
  673. now = jiffies;
  674. /* Poll all channels that are ready to be polled */
  675. for (i = 0; i < devpriv->n_channels; i++) {
  676. struct jr3_pci_subdev_private *subdevpriv =
  677. dev->subdevices[i].private;
  678. if (now > subdevpriv->next_time_min) {
  679. struct poll_delay_t sub_delay;
  680. sub_delay = jr3_pci_poll_subdevice(&dev->subdevices[i]);
  681. subdevpriv->next_time_min =
  682. jiffies + msecs_to_jiffies(sub_delay.min);
  683. subdevpriv->next_time_max =
  684. jiffies + msecs_to_jiffies(sub_delay.max);
  685. if (sub_delay.max && sub_delay.max < delay) {
  686. /*
  687. * Wake up as late as possible -> poll as many channels as possible
  688. * at once
  689. */
  690. delay = sub_delay.max;
  691. }
  692. }
  693. }
  694. spin_unlock_irqrestore(&dev->spinlock, flags);
  695. devpriv->timer.expires = jiffies + msecs_to_jiffies(delay);
  696. add_timer(&devpriv->timer);
  697. }
  698. static int jr3_pci_attach(struct comedi_device *dev,
  699. struct comedi_devconfig *it)
  700. {
  701. int result = 0;
  702. struct pci_dev *card = NULL;
  703. int opt_bus, opt_slot, i;
  704. struct jr3_pci_dev_private *devpriv;
  705. printk("comedi%d: jr3_pci\n", dev->minor);
  706. opt_bus = it->options[0];
  707. opt_slot = it->options[1];
  708. if (sizeof(struct jr3_channel) != 0xc00) {
  709. printk("sizeof(struct jr3_channel) = %x [expected %x]\n",
  710. (unsigned)sizeof(struct jr3_channel), 0xc00);
  711. return -EINVAL;
  712. }
  713. result = alloc_private(dev, sizeof(struct jr3_pci_dev_private));
  714. if (result < 0)
  715. return -ENOMEM;
  716. card = NULL;
  717. devpriv = dev->private;
  718. init_timer(&devpriv->timer);
  719. while (1) {
  720. card = pci_get_device(PCI_VENDOR_ID_JR3, PCI_ANY_ID, card);
  721. if (card == NULL) {
  722. /* No card found */
  723. break;
  724. } else {
  725. switch (card->device) {
  726. case PCI_DEVICE_ID_JR3_1_CHANNEL:{
  727. devpriv->n_channels = 1;
  728. }
  729. break;
  730. case PCI_DEVICE_ID_JR3_1_CHANNEL_NEW:{
  731. devpriv->n_channels = 1;
  732. }
  733. break;
  734. case PCI_DEVICE_ID_JR3_2_CHANNEL:{
  735. devpriv->n_channels = 2;
  736. }
  737. break;
  738. case PCI_DEVICE_ID_JR3_3_CHANNEL:{
  739. devpriv->n_channels = 3;
  740. }
  741. break;
  742. case PCI_DEVICE_ID_JR3_4_CHANNEL:{
  743. devpriv->n_channels = 4;
  744. }
  745. break;
  746. default:{
  747. devpriv->n_channels = 0;
  748. }
  749. }
  750. if (devpriv->n_channels >= 1) {
  751. if (opt_bus == 0 && opt_slot == 0) {
  752. /* Take first available card */
  753. break;
  754. } else if (opt_bus == card->bus->number &&
  755. opt_slot == PCI_SLOT(card->devfn)) {
  756. /* Take requested card */
  757. break;
  758. }
  759. }
  760. }
  761. }
  762. if (!card) {
  763. printk(" no jr3_pci found\n");
  764. return -EIO;
  765. } else {
  766. devpriv->pci_dev = card;
  767. dev->board_name = "jr3_pci";
  768. }
  769. result = comedi_pci_enable(card, "jr3_pci");
  770. if (result < 0)
  771. return -EIO;
  772. devpriv->pci_enabled = 1;
  773. devpriv->iobase = ioremap(pci_resource_start(card, 0),
  774. offsetof(struct jr3_t, channel[devpriv->n_channels]));
  775. if (!devpriv->iobase)
  776. return -ENOMEM;
  777. result = alloc_subdevices(dev, devpriv->n_channels);
  778. if (result < 0)
  779. goto out;
  780. dev->open = jr3_pci_open;
  781. for (i = 0; i < devpriv->n_channels; i++) {
  782. dev->subdevices[i].type = COMEDI_SUBD_AI;
  783. dev->subdevices[i].subdev_flags = SDF_READABLE | SDF_GROUND;
  784. dev->subdevices[i].n_chan = 8 * 7 + 2;
  785. dev->subdevices[i].insn_read = jr3_pci_ai_insn_read;
  786. dev->subdevices[i].private =
  787. kzalloc(sizeof(struct jr3_pci_subdev_private), GFP_KERNEL);
  788. if (dev->subdevices[i].private) {
  789. struct jr3_pci_subdev_private *p;
  790. int j;
  791. p = dev->subdevices[i].private;
  792. p->channel = &devpriv->iobase->channel[i].data;
  793. printk("p->channel %p %p (%tx)\n",
  794. p->channel, devpriv->iobase,
  795. ((char *)(p->channel) -
  796. (char *)(devpriv->iobase)));
  797. p->channel_no = i;
  798. for (j = 0; j < 8; j++) {
  799. int k;
  800. p->range[j].length = 1;
  801. p->range[j].range.min = -1000000;
  802. p->range[j].range.max = 1000000;
  803. for (k = 0; k < 7; k++) {
  804. p->range_table_list[j + k * 8] =
  805. (struct comedi_lrange *)&p->
  806. range[j];
  807. p->maxdata_list[j + k * 8] = 0x7fff;
  808. }
  809. }
  810. p->range[8].length = 1;
  811. p->range[8].range.min = 0;
  812. p->range[8].range.max = 65536;
  813. p->range_table_list[56] =
  814. (struct comedi_lrange *)&p->range[8];
  815. p->range_table_list[57] =
  816. (struct comedi_lrange *)&p->range[8];
  817. p->maxdata_list[56] = 0xffff;
  818. p->maxdata_list[57] = 0xffff;
  819. /* Channel specific range and maxdata */
  820. dev->subdevices[i].range_table = 0;
  821. dev->subdevices[i].range_table_list =
  822. p->range_table_list;
  823. dev->subdevices[i].maxdata = 0;
  824. dev->subdevices[i].maxdata_list = p->maxdata_list;
  825. }
  826. }
  827. /* Reset DSP card */
  828. devpriv->iobase->channel[0].reset = 0;
  829. result = comedi_load_firmware(dev, "jr3pci.idm", jr3_download_firmware);
  830. printk("Firmare load %d\n", result);
  831. if (result < 0)
  832. goto out;
  833. /*
  834. * TODO: use firmware to load preferred offset tables. Suggested
  835. * format:
  836. * model serial Fx Fy Fz Mx My Mz\n
  837. *
  838. * comedi_load_firmware(dev, "jr3_offsets_table", jr3_download_firmware);
  839. */
  840. /*
  841. * It takes a few milliseconds for software to settle as much as we
  842. * can read firmware version
  843. */
  844. msleep_interruptible(25);
  845. for (i = 0; i < 0x18; i++) {
  846. printk("%c",
  847. get_u16(&devpriv->iobase->channel[0].
  848. data.copyright[i]) >> 8);
  849. }
  850. /* Start card timer */
  851. for (i = 0; i < devpriv->n_channels; i++) {
  852. struct jr3_pci_subdev_private *p = dev->subdevices[i].private;
  853. p->next_time_min = jiffies + msecs_to_jiffies(500);
  854. p->next_time_max = jiffies + msecs_to_jiffies(2000);
  855. }
  856. devpriv->timer.data = (unsigned long)dev;
  857. devpriv->timer.function = jr3_pci_poll_dev;
  858. devpriv->timer.expires = jiffies + msecs_to_jiffies(1000);
  859. add_timer(&devpriv->timer);
  860. out:
  861. return result;
  862. }
  863. MODULE_FIRMWARE("comedi/jr3pci.idm");
  864. static int jr3_pci_detach(struct comedi_device *dev)
  865. {
  866. int i;
  867. struct jr3_pci_dev_private *devpriv = dev->private;
  868. printk("comedi%d: jr3_pci: remove\n", dev->minor);
  869. if (devpriv) {
  870. del_timer_sync(&devpriv->timer);
  871. if (dev->subdevices) {
  872. for (i = 0; i < devpriv->n_channels; i++)
  873. kfree(dev->subdevices[i].private);
  874. }
  875. if (devpriv->iobase)
  876. iounmap((void *)devpriv->iobase);
  877. if (devpriv->pci_enabled)
  878. comedi_pci_disable(devpriv->pci_dev);
  879. if (devpriv->pci_dev)
  880. pci_dev_put(devpriv->pci_dev);
  881. }
  882. return 0;
  883. }
  884. static int __devinit driver_jr3_pci_pci_probe(struct pci_dev *dev,
  885. const struct pci_device_id *ent)
  886. {
  887. return comedi_pci_auto_config(dev, driver_jr3_pci.driver_name);
  888. }
  889. static void __devexit driver_jr3_pci_pci_remove(struct pci_dev *dev)
  890. {
  891. comedi_pci_auto_unconfig(dev);
  892. }
  893. static struct pci_driver driver_jr3_pci_pci_driver = {
  894. .id_table = jr3_pci_pci_table,
  895. .probe = &driver_jr3_pci_pci_probe,
  896. .remove = __devexit_p(&driver_jr3_pci_pci_remove)
  897. };
  898. static int __init driver_jr3_pci_init_module(void)
  899. {
  900. int retval;
  901. retval = comedi_driver_register(&driver_jr3_pci);
  902. if (retval < 0)
  903. return retval;
  904. driver_jr3_pci_pci_driver.name = (char *)driver_jr3_pci.driver_name;
  905. return pci_register_driver(&driver_jr3_pci_pci_driver);
  906. }
  907. static void __exit driver_jr3_pci_cleanup_module(void)
  908. {
  909. pci_unregister_driver(&driver_jr3_pci_pci_driver);
  910. comedi_driver_unregister(&driver_jr3_pci);
  911. }
  912. module_init(driver_jr3_pci_init_module);
  913. module_exit(driver_jr3_pci_cleanup_module);
  914. MODULE_AUTHOR("Comedi http://www.comedi.org");
  915. MODULE_DESCRIPTION("Comedi low-level driver");
  916. MODULE_LICENSE("GPL");