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