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