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