jr3_pci.c revision 351a1d35d61e7cb5fd0bebddb851973a12a0b0e1
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 dev_dbg(dev->hw_dev, "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 dev_dbg(dev->hw_dev, "serial: %p %d (%d)\n", p, 382 p->serial_no, 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 dev_dbg(dev->hw_dev, "Loading#%d %4.4x bytes at %4.4x\n", 461 i, 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 opt_bus = it->options[0]; 777 opt_slot = it->options[1]; 778 779 if (sizeof(struct jr3_channel) != 0xc00) { 780 dev_err(dev->hw_dev, "sizeof(struct jr3_channel) = %x [expected %x]\n", 781 (unsigned)sizeof(struct jr3_channel), 0xc00); 782 return -EINVAL; 783 } 784 785 result = alloc_private(dev, sizeof(struct jr3_pci_dev_private)); 786 if (result < 0) 787 return -ENOMEM; 788 card = NULL; 789 devpriv = dev->private; 790 init_timer(&devpriv->timer); 791 while (1) { 792 card = pci_get_device(PCI_VENDOR_ID_JR3, PCI_ANY_ID, card); 793 if (card == NULL) { 794 /* No card found */ 795 break; 796 } else { 797 switch (card->device) { 798 case PCI_DEVICE_ID_JR3_1_CHANNEL:{ 799 devpriv->n_channels = 1; 800 } 801 break; 802 case PCI_DEVICE_ID_JR3_1_CHANNEL_NEW:{ 803 devpriv->n_channels = 1; 804 } 805 break; 806 case PCI_DEVICE_ID_JR3_2_CHANNEL:{ 807 devpriv->n_channels = 2; 808 } 809 break; 810 case PCI_DEVICE_ID_JR3_3_CHANNEL:{ 811 devpriv->n_channels = 3; 812 } 813 break; 814 case PCI_DEVICE_ID_JR3_4_CHANNEL:{ 815 devpriv->n_channels = 4; 816 } 817 break; 818 default:{ 819 devpriv->n_channels = 0; 820 } 821 } 822 if (devpriv->n_channels >= 1) { 823 if (opt_bus == 0 && opt_slot == 0) { 824 /* Take first available card */ 825 break; 826 } else if (opt_bus == card->bus->number && 827 opt_slot == PCI_SLOT(card->devfn)) { 828 /* Take requested card */ 829 break; 830 } 831 } 832 } 833 } 834 if (!card) { 835 dev_err(dev->hw_dev, "no jr3_pci found\n"); 836 return -EIO; 837 } else { 838 devpriv->pci_dev = card; 839 dev->board_name = "jr3_pci"; 840 } 841 842 result = comedi_pci_enable(card, "jr3_pci"); 843 if (result < 0) 844 return -EIO; 845 846 devpriv->pci_enabled = 1; 847 devpriv->iobase = ioremap(pci_resource_start(card, 0), 848 offsetof(struct jr3_t, channel[devpriv->n_channels])); 849 if (!devpriv->iobase) 850 return -ENOMEM; 851 852 result = alloc_subdevices(dev, devpriv->n_channels); 853 if (result < 0) 854 goto out; 855 856 dev->open = jr3_pci_open; 857 for (i = 0; i < devpriv->n_channels; i++) { 858 dev->subdevices[i].type = COMEDI_SUBD_AI; 859 dev->subdevices[i].subdev_flags = SDF_READABLE | SDF_GROUND; 860 dev->subdevices[i].n_chan = 8 * 7 + 2; 861 dev->subdevices[i].insn_read = jr3_pci_ai_insn_read; 862 dev->subdevices[i].private = 863 kzalloc(sizeof(struct jr3_pci_subdev_private), GFP_KERNEL); 864 if (dev->subdevices[i].private) { 865 struct jr3_pci_subdev_private *p; 866 int j; 867 868 p = dev->subdevices[i].private; 869 p->channel = &devpriv->iobase->channel[i].data; 870 dev_dbg(dev->hw_dev, "p->channel %p %p (%tx)\n", 871 p->channel, devpriv->iobase, 872 ((char *)(p->channel) - 873 (char *)(devpriv->iobase))); 874 p->channel_no = i; 875 for (j = 0; j < 8; j++) { 876 int k; 877 878 p->range[j].length = 1; 879 p->range[j].range.min = -1000000; 880 p->range[j].range.max = 1000000; 881 for (k = 0; k < 7; k++) { 882 p->range_table_list[j + k * 8] = 883 (struct comedi_lrange *)&p-> 884 range[j]; 885 p->maxdata_list[j + k * 8] = 0x7fff; 886 } 887 } 888 p->range[8].length = 1; 889 p->range[8].range.min = 0; 890 p->range[8].range.max = 65536; 891 892 p->range_table_list[56] = 893 (struct comedi_lrange *)&p->range[8]; 894 p->range_table_list[57] = 895 (struct comedi_lrange *)&p->range[8]; 896 p->maxdata_list[56] = 0xffff; 897 p->maxdata_list[57] = 0xffff; 898 /* Channel specific range and maxdata */ 899 dev->subdevices[i].range_table = 0; 900 dev->subdevices[i].range_table_list = 901 p->range_table_list; 902 dev->subdevices[i].maxdata = 0; 903 dev->subdevices[i].maxdata_list = p->maxdata_list; 904 } 905 } 906 907 /* Reset DSP card */ 908 devpriv->iobase->channel[0].reset = 0; 909 910 result = comedi_load_firmware(dev, "jr3pci.idm", jr3_download_firmware); 911 dev_dbg(dev->hw_dev, "Firmare load %d\n", result); 912 913 if (result < 0) 914 goto out; 915/* 916 * TODO: use firmware to load preferred offset tables. Suggested 917 * format: 918 * model serial Fx Fy Fz Mx My Mz\n 919 * 920 * comedi_load_firmware(dev, "jr3_offsets_table", jr3_download_firmware); 921 */ 922 923/* 924 * It takes a few milliseconds for software to settle as much as we 925 * can read firmware version 926 */ 927 msleep_interruptible(25); 928 for (i = 0; i < 0x18; i++) { 929 dev_dbg(dev->hw_dev, "%c\n", 930 get_u16(&devpriv->iobase->channel[0]. 931 data.copyright[i]) >> 8); 932 } 933 934 /* Start card timer */ 935 for (i = 0; i < devpriv->n_channels; i++) { 936 struct jr3_pci_subdev_private *p = dev->subdevices[i].private; 937 938 p->next_time_min = jiffies + msecs_to_jiffies(500); 939 p->next_time_max = jiffies + msecs_to_jiffies(2000); 940 } 941 942 devpriv->timer.data = (unsigned long)dev; 943 devpriv->timer.function = jr3_pci_poll_dev; 944 devpriv->timer.expires = jiffies + msecs_to_jiffies(1000); 945 add_timer(&devpriv->timer); 946 947out: 948 return result; 949} 950 951MODULE_FIRMWARE("comedi/jr3pci.idm"); 952 953static int jr3_pci_detach(struct comedi_device *dev) 954{ 955 int i; 956 struct jr3_pci_dev_private *devpriv = dev->private; 957 958 if (devpriv) { 959 del_timer_sync(&devpriv->timer); 960 961 if (dev->subdevices) { 962 for (i = 0; i < devpriv->n_channels; i++) 963 kfree(dev->subdevices[i].private); 964 } 965 966 if (devpriv->iobase) 967 iounmap((void *)devpriv->iobase); 968 if (devpriv->pci_enabled) 969 comedi_pci_disable(devpriv->pci_dev); 970 971 if (devpriv->pci_dev) 972 pci_dev_put(devpriv->pci_dev); 973 } 974 return 0; 975} 976 977static int __devinit driver_jr3_pci_pci_probe(struct pci_dev *dev, 978 const struct pci_device_id *ent) 979{ 980 return comedi_pci_auto_config(dev, driver_jr3_pci.driver_name); 981} 982 983static void __devexit driver_jr3_pci_pci_remove(struct pci_dev *dev) 984{ 985 comedi_pci_auto_unconfig(dev); 986} 987 988static struct pci_driver driver_jr3_pci_pci_driver = { 989 .id_table = jr3_pci_pci_table, 990 .probe = &driver_jr3_pci_pci_probe, 991 .remove = __devexit_p(&driver_jr3_pci_pci_remove) 992}; 993 994static int __init driver_jr3_pci_init_module(void) 995{ 996 int retval; 997 998 retval = comedi_driver_register(&driver_jr3_pci); 999 if (retval < 0) 1000 return retval; 1001 1002 driver_jr3_pci_pci_driver.name = (char *)driver_jr3_pci.driver_name; 1003 return pci_register_driver(&driver_jr3_pci_pci_driver); 1004} 1005 1006static void __exit driver_jr3_pci_cleanup_module(void) 1007{ 1008 pci_unregister_driver(&driver_jr3_pci_pci_driver); 1009 comedi_driver_unregister(&driver_jr3_pci); 1010} 1011 1012module_init(driver_jr3_pci_init_module); 1013module_exit(driver_jr3_pci_cleanup_module); 1014 1015MODULE_AUTHOR("Comedi http://www.comedi.org"); 1016MODULE_DESCRIPTION("Comedi low-level driver"); 1017MODULE_LICENSE("GPL"); 1018