drivers/staging/comedi/drivers/cb_das16_cs.c

   1 /*
   2     comedi/drivers/das16cs.c
   3     Driver for Computer Boards PC-CARD DAS16/16.
   4
   5     COMEDI - Linux Control and Measurement Device Interface
   6     Copyright (C) 2000, 2001, 2002 David A. Schleef <ds@schleef.org>
   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     PCMCIA support code for the is adapted from the dummy_cs.c driver
  23     of the Linux PCMCIA Card Services package.
  24
  25     The initial developer of the original code is David A. Hinds
  26     <dahinds@users.sourceforge.net>.  Portions created by David A. Hinds
  27     are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  28
  29 */
  30 /*
  31 Driver: cb_das16_cs
  32 Description: Computer Boards PC-CARD DAS16/16
  33 Devices: [ComputerBoards] PC-CARD DAS16/16 (cb_das16_cs), PC-CARD DAS16/16-AO
  34 Author: ds
  35 Updated: Mon, 04 Nov 2002 20:04:21 -0800
  36 Status: experimental
  37
  38
  39 */
  40
  41 #include <linux/interrupt.h>
  42 #include <linux/slab.h>
  43 #include "../comedidev.h"
  44 #include <linux/delay.h>
  45
  46 #include <pcmcia/cistpl.h>
  47 #include <pcmcia/ds.h>
  48
  49 #include "8253.h"
  50
  51 #define DAS16CS_SIZE                    18
  52
  53 #define DAS16CS_ADC_DATA                0
  54 #define DAS16CS_DIO_MUX                 2
  55 #define DAS16CS_MISC1                   4
  56 #define DAS16CS_MISC2                   6
  57 #define DAS16CS_CTR0                    8
  58 #define DAS16CS_CTR1                    10
  59 #define DAS16CS_CTR2                    12
  60 #define DAS16CS_CTR_CONTROL             14
  61 #define DAS16CS_DIO                     16
  62
  63 struct das16cs_board {
  64         const char *name;
  65         int device_id;
  66         int n_ao_chans;
  67 };
  68
  69 static const struct das16cs_board das16cs_boards[] = {
  70         {
  71                 .name           = "PC-CARD DAS16/16-AO",
  72                 .device_id      = 0x0039,
  73                 .n_ao_chans     = 2,
  74         }, {
  75                 .name           = "PCM-DAS16s/16",
  76                 .device_id      = 0x4009,
  77                 .n_ao_chans     = 0,
  78         }, {
  79                 .name           = "PC-CARD DAS16/16",
  80                 .device_id      = 0x0000,       /* unknown */
  81                 .n_ao_chans     = 0,
  82         },
  83 };
  84
  85 struct das16cs_private {
  86         unsigned int ao_readback[2];
  87         unsigned short status1;
  88         unsigned short status2;
  89 };
  90
  91 static struct pcmcia_device *cur_dev;
  92
  93 static const struct comedi_lrange das16cs_ai_range = { 4, {
  94                                                            RANGE(-10, 10),
  95                                                            RANGE(-5, 5),
  96                                                            RANGE(-2.5, 2.5),
  97                                                            RANGE(-1.25, 1.25),
  98                                                            }
  99 };
 100
 101 static irqreturn_t das16cs_interrupt(int irq, void *d)
 102 {
 103         /* struct comedi_device *dev = d; */
 104         return IRQ_HANDLED;
 105 }
 106
 107 static int das16cs_ai_rinsn(struct comedi_device *dev,
 108                             struct comedi_subdevice *s,
 109                             struct comedi_insn *insn, unsigned int *data)
 110 {
 111         struct das16cs_private *devpriv = dev->private;
 112         int chan = CR_CHAN(insn->chanspec);
 113         int range = CR_RANGE(insn->chanspec);
 114         int aref = CR_AREF(insn->chanspec);
 115         int i;
 116         int to;
 117
 118         outw(chan, dev->iobase + DAS16CS_DIO_MUX);
 119
 120         devpriv->status1 &= ~0xf320;
 121         devpriv->status1 |= (aref == AREF_DIFF) ? 0 : 0x0020;
 122         outw(devpriv->status1, dev->iobase + DAS16CS_MISC1);
 123
 124         devpriv->status2 &= ~0xff00;
 125         switch (range) {
 126         case 0:
 127                 devpriv->status2 |= 0x800;
 128                 break;
 129         case 1:
 130                 devpriv->status2 |= 0x000;
 131                 break;
 132         case 2:
 133                 devpriv->status2 |= 0x100;
 134                 break;
 135         case 3:
 136                 devpriv->status2 |= 0x200;
 137                 break;
 138         default:
 139                 return -EINVAL;
 140         }
 141         outw(devpriv->status2, dev->iobase + DAS16CS_MISC2);
 142
 143         for (i = 0; i < insn->n; i++) {
 144                 outw(0, dev->iobase + DAS16CS_ADC_DATA);
 145
 146 #define TIMEOUT 1000
 147                 for (to = 0; to < TIMEOUT; to++) {
 148                         if (inw(dev->iobase + DAS16CS_MISC1) & 0x0080)
 149                                 break;
 150                 }
 151                 if (to == TIMEOUT) {
 152                         dev_dbg(dev->class_dev, "cb_das16_cs: ai timeout\n");
 153                         return -ETIME;
 154                 }
 155                 data[i] = inw(dev->iobase + DAS16CS_ADC_DATA);
 156         }
 157
 158         return i;
 159 }
 160
 161 static int das16cs_ai_cmd(struct comedi_device *dev, struct comedi_subdevice *s)
 162 {
 163         return -EINVAL;
 164 }
 165
 166 static int das16cs_ai_cmdtest(struct comedi_device *dev,
 167                               struct comedi_subdevice *s,
 168                               struct comedi_cmd *cmd)
 169 {
 170         int err = 0;
 171         int tmp;
 172
 173         /* step 1: make sure trigger sources are trivially valid */
 174
 175         tmp = cmd->start_src;
 176         cmd->start_src &= TRIG_NOW;
 177         if (!cmd->start_src || tmp != cmd->start_src)
 178                 err++;
 179
 180         tmp = cmd->scan_begin_src;
 181         cmd->scan_begin_src &= TRIG_TIMER | TRIG_EXT;
 182         if (!cmd->scan_begin_src || tmp != cmd->scan_begin_src)
 183                 err++;
 184
 185         tmp = cmd->convert_src;
 186         cmd->convert_src &= TRIG_TIMER | TRIG_EXT;
 187         if (!cmd->convert_src || tmp != cmd->convert_src)
 188                 err++;
 189
 190         tmp = cmd->scan_end_src;
 191         cmd->scan_end_src &= TRIG_COUNT;
 192         if (!cmd->scan_end_src || tmp != cmd->scan_end_src)
 193                 err++;
 194
 195         tmp = cmd->stop_src;
 196         cmd->stop_src &= TRIG_COUNT | TRIG_NONE;
 197         if (!cmd->stop_src || tmp != cmd->stop_src)
 198                 err++;
 199
 200         if (err)
 201                 return 1;
 202
 203         /* step 2: make sure trigger sources are unique and
 204          * mutually compatible */
 205
 206         /* note that mutual compatibility is not an issue here */
 207         if (cmd->scan_begin_src != TRIG_TIMER &&
 208             cmd->scan_begin_src != TRIG_EXT)
 209                 err++;
 210         if (cmd->convert_src != TRIG_TIMER && cmd->convert_src != TRIG_EXT)
 211                 err++;
 212         if (cmd->stop_src != TRIG_COUNT && cmd->stop_src != TRIG_NONE)
 213                 err++;
 214
 215         if (err)
 216                 return 2;
 217
 218         /* step 3: make sure arguments are trivially compatible */
 219
 220         if (cmd->start_arg != 0) {
 221                 cmd->start_arg = 0;
 222                 err++;
 223         }
 224 #define MAX_SPEED       10000   /* in nanoseconds */
 225 #define MIN_SPEED       1000000000      /* in nanoseconds */
 226
 227         if (cmd->scan_begin_src == TRIG_TIMER) {
 228                 if (cmd->scan_begin_arg < MAX_SPEED) {
 229                         cmd->scan_begin_arg = MAX_SPEED;
 230                         err++;
 231                 }
 232                 if (cmd->scan_begin_arg > MIN_SPEED) {
 233                         cmd->scan_begin_arg = MIN_SPEED;
 234                         err++;
 235                 }
 236         } else {
 237                 /* external trigger */
 238                 /* should be level/edge, hi/lo specification here */
 239                 /* should specify multiple external triggers */
 240                 if (cmd->scan_begin_arg > 9) {
 241                         cmd->scan_begin_arg = 9;
 242                         err++;
 243                 }
 244         }
 245         if (cmd->convert_src == TRIG_TIMER) {
 246                 if (cmd->convert_arg < MAX_SPEED) {
 247                         cmd->convert_arg = MAX_SPEED;
 248                         err++;
 249                 }
 250                 if (cmd->convert_arg > MIN_SPEED) {
 251                         cmd->convert_arg = MIN_SPEED;
 252                         err++;
 253                 }
 254         } else {
 255                 /* external trigger */
 256                 /* see above */
 257                 if (cmd->convert_arg > 9) {
 258                         cmd->convert_arg = 9;
 259                         err++;
 260                 }
 261         }
 262
 263         if (cmd->scan_end_arg != cmd->chanlist_len) {
 264                 cmd->scan_end_arg = cmd->chanlist_len;
 265                 err++;
 266         }
 267         if (cmd->stop_src == TRIG_COUNT) {
 268                 if (cmd->stop_arg > 0x00ffffff) {
 269                         cmd->stop_arg = 0x00ffffff;
 270                         err++;
 271                 }
 272         } else {
 273                 /* TRIG_NONE */
 274                 if (cmd->stop_arg != 0) {
 275                         cmd->stop_arg = 0;
 276                         err++;
 277                 }
 278         }
 279
 280         if (err)
 281                 return 3;
 282
 283         /* step 4: fix up any arguments */
 284
 285         if (cmd->scan_begin_src == TRIG_TIMER) {
 286                 unsigned int div1 = 0, div2 = 0;
 287
 288                 tmp = cmd->scan_begin_arg;
 289                 i8253_cascade_ns_to_timer(100, &div1, &div2,
 290                                           &cmd->scan_begin_arg,
 291                                           cmd->flags & TRIG_ROUND_MASK);
 292                 if (tmp != cmd->scan_begin_arg)
 293                         err++;
 294         }
 295         if (cmd->convert_src == TRIG_TIMER) {
 296                 unsigned int div1 = 0, div2 = 0;
 297
 298                 tmp = cmd->convert_arg;
 299                 i8253_cascade_ns_to_timer(100, &div1, &div2,
 300                                           &cmd->scan_begin_arg,
 301                                           cmd->flags & TRIG_ROUND_MASK);
 302                 if (tmp != cmd->convert_arg)
 303                         err++;
 304                 if (cmd->scan_begin_src == TRIG_TIMER &&
 305                     cmd->scan_begin_arg <
 306                     cmd->convert_arg * cmd->scan_end_arg) {
 307                         cmd->scan_begin_arg =
 308                             cmd->convert_arg * cmd->scan_end_arg;
 309                         err++;
 310                 }
 311         }
 312
 313         if (err)
 314                 return 4;
 315
 316         return 0;
 317 }
 318
 319 static int das16cs_ao_winsn(struct comedi_device *dev,
 320                             struct comedi_subdevice *s,
 321                             struct comedi_insn *insn, unsigned int *data)
 322 {
 323         struct das16cs_private *devpriv = dev->private;
 324         int i;
 325         int chan = CR_CHAN(insn->chanspec);
 326         unsigned short status1;
 327         unsigned short d;
 328         int bit;
 329
 330         for (i = 0; i < insn->n; i++) {
 331                 devpriv->ao_readback[chan] = data[i];
 332                 d = data[i];
 333
 334                 outw(devpriv->status1, dev->iobase + DAS16CS_MISC1);
 335                 udelay(1);
 336
 337                 status1 = devpriv->status1 & ~0xf;
 338                 if (chan)
 339                         status1 |= 0x0001;
 340                 else
 341                         status1 |= 0x0008;
 342
 343 /*              printk("0x%04x\n",status1);*/
 344                 outw(status1, dev->iobase + DAS16CS_MISC1);
 345                 udelay(1);
 346
 347                 for (bit = 15; bit >= 0; bit--) {
 348                         int b = (d >> bit) & 0x1;
 349                         b <<= 1;
 350 /*                      printk("0x%04x\n",status1 | b | 0x0000);*/
 351                         outw(status1 | b | 0x0000, dev->iobase + DAS16CS_MISC1);
 352                         udelay(1);
 353 /*                      printk("0x%04x\n",status1 | b | 0x0004);*/
 354                         outw(status1 | b | 0x0004, dev->iobase + DAS16CS_MISC1);
 355                         udelay(1);
 356                 }
 357 /*              make high both DAC0CS and DAC1CS to load
 358                 new data and update analog output*/
 359                 outw(status1 | 0x9, dev->iobase + DAS16CS_MISC1);
 360         }
 361
 362         return i;
 363 }
 364
 365 static int das16cs_ao_rinsn(struct comedi_device *dev,
 366                             struct comedi_subdevice *s,
 367                             struct comedi_insn *insn, unsigned int *data)
 368 {
 369         struct das16cs_private *devpriv = dev->private;
 370         int i;
 371         int chan = CR_CHAN(insn->chanspec);
 372
 373         for (i = 0; i < insn->n; i++)
 374                 data[i] = devpriv->ao_readback[chan];
 375
 376         return i;
 377 }
 378
 379 static int das16cs_dio_insn_bits(struct comedi_device *dev,
 380                                  struct comedi_subdevice *s,
 381                                  struct comedi_insn *insn, unsigned int *data)
 382 {
 383         if (data[0]) {
 384                 s->state &= ~data[0];
 385                 s->state |= data[0] & data[1];
 386
 387                 outw(s->state, dev->iobase + DAS16CS_DIO);
 388         }
 389
 390         data[1] = inw(dev->iobase + DAS16CS_DIO);
 391
 392         return insn->n;
 393 }
 394
 395 static int das16cs_dio_insn_config(struct comedi_device *dev,
 396                                    struct comedi_subdevice *s,
 397                                    struct comedi_insn *insn, unsigned int *data)
 398 {
 399         struct das16cs_private *devpriv = dev->private;
 400         int chan = CR_CHAN(insn->chanspec);
 401         int bits;
 402
 403         if (chan < 4)
 404                 bits = 0x0f;
 405         else
 406                 bits = 0xf0;
 407
 408         switch (data[0]) {
 409         case INSN_CONFIG_DIO_OUTPUT:
 410                 s->io_bits |= bits;
 411                 break;
 412         case INSN_CONFIG_DIO_INPUT:
 413                 s->io_bits &= bits;
 414                 break;
 415         case INSN_CONFIG_DIO_QUERY:
 416                 data[1] =
 417                     (s->io_bits & (1 << chan)) ? COMEDI_OUTPUT : COMEDI_INPUT;
 418                 return insn->n;
 419                 break;
 420         default:
 421                 return -EINVAL;
 422                 break;
 423         }
 424
 425         devpriv->status2 &= ~0x00c0;
 426         devpriv->status2 |= (s->io_bits & 0xf0) ? 0x0080 : 0;
 427         devpriv->status2 |= (s->io_bits & 0x0f) ? 0x0040 : 0;
 428
 429         outw(devpriv->status2, dev->iobase + DAS16CS_MISC2);
 430
 431         return insn->n;
 432 }
 433
 434 static const struct das16cs_board *das16cs_probe(struct comedi_device *dev,
 435                                                  struct pcmcia_device *link)
 436 {
 437         int i;
 438
 439         for (i = 0; i < ARRAY_SIZE(das16cs_boards); i++) {
 440                 if (das16cs_boards[i].device_id == link->card_id)
 441                         return das16cs_boards + i;
 442         }
 443
 444         dev_dbg(dev->class_dev, "unknown board!\n");
 445
 446         return NULL;
 447 }
 448
 449 static int das16cs_attach(struct comedi_device *dev,
 450                           struct comedi_devconfig *it)
 451 {
 452         const struct das16cs_board *thisboard;
 453         struct pcmcia_device *link;
 454         struct comedi_subdevice *s;
 455         int ret;
 456
 457         link = cur_dev;         /* XXX hack */
 458         if (!link)
 459                 return -EIO;
 460
 461         dev->board_ptr = das16cs_probe(dev, link);
 462         if (!dev->board_ptr)
 463                 return -EIO;
 464         thisboard = comedi_board(dev);
 465
 466         dev->board_name = thisboard->name;
 467
 468         dev->iobase = link->resource[0]->start;
 469
 470         ret = request_irq(link->irq, das16cs_interrupt,
 471                           IRQF_SHARED, "cb_das16_cs", dev);
 472         if (ret < 0)
 473                 return ret;
 474         dev->irq = link->irq;
 475
 476         if (alloc_private(dev, sizeof(struct das16cs_private)) < 0)
 477                 return -ENOMEM;
 478
 479         ret = comedi_alloc_subdevices(dev, 3);
 480         if (ret)
 481                 return ret;
 482
 483         s = dev->subdevices + 0;
 484         dev->read_subdev = s;
 485         /* analog input subdevice */
 486         s->type         = COMEDI_SUBD_AI;
 487         s->subdev_flags = SDF_READABLE | SDF_GROUND | SDF_DIFF | SDF_CMD_READ;
 488         s->n_chan       = 16;
 489         s->maxdata      = 0xffff;
 490         s->range_table  = &das16cs_ai_range;
 491         s->len_chanlist = 16;
 492         s->insn_read    = das16cs_ai_rinsn;
 493         s->do_cmd       = das16cs_ai_cmd;
 494         s->do_cmdtest   = das16cs_ai_cmdtest;
 495
 496         s = dev->subdevices + 1;
 497         /* analog output subdevice */
 498         if (thisboard->n_ao_chans) {
 499                 s->type         = COMEDI_SUBD_AO;
 500                 s->subdev_flags = SDF_WRITABLE;
 501                 s->n_chan       = thisboard->n_ao_chans;
 502                 s->maxdata      = 0xffff;
 503                 s->range_table  = &range_bipolar10;
 504                 s->insn_write   = &das16cs_ao_winsn;
 505                 s->insn_read    = &das16cs_ao_rinsn;
 506         } else {
 507                 s->type         = COMEDI_SUBD_UNUSED;
 508         }
 509
 510         s = dev->subdevices + 2;
 511         /* digital i/o subdevice */
 512         s->type         = COMEDI_SUBD_DIO;
 513         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 514         s->n_chan       = 8;
 515         s->maxdata      = 1;
 516         s->range_table  = &range_digital;
 517         s->insn_bits    = das16cs_dio_insn_bits;
 518         s->insn_config  = das16cs_dio_insn_config;
 519
 520         dev_info(dev->class_dev, "%s: %s, I/O base=0x%04lx, irq=%u\n",
 521                 dev->driver->driver_name, dev->board_name,
 522                 dev->iobase, dev->irq);
 523
 524         return 0;
 525 }
 526
 527 static void das16cs_detach(struct comedi_device *dev)
 528 {
 529         if (dev->irq)
 530                 free_irq(dev->irq, dev);
 531 }
 532
 533 static struct comedi_driver driver_das16cs = {
 534         .driver_name    = "cb_das16_cs",
 535         .module         = THIS_MODULE,
 536         .attach         = das16cs_attach,
 537         .detach         = das16cs_detach,
 538 };
 539
 540 static int das16cs_pcmcia_config_loop(struct pcmcia_device *p_dev,
 541                                 void *priv_data)
 542 {
 543         if (p_dev->config_index == 0)
 544                 return -EINVAL;
 545
 546         return pcmcia_request_io(p_dev);
 547 }
 548
 549 static int das16cs_pcmcia_attach(struct pcmcia_device *link)
 550 {
 551         int ret;
 552
 553         /* Do we need to allocate an interrupt? */
 554         link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 555
 556         ret = pcmcia_loop_config(link, das16cs_pcmcia_config_loop, NULL);
 557         if (ret)
 558                 goto failed;
 559
 560         if (!link->irq)
 561                 goto failed;
 562
 563         ret = pcmcia_enable_device(link);
 564         if (ret)
 565                 goto failed;
 566
 567         cur_dev = link;
 568         return 0;
 569
 570 failed:
 571         pcmcia_disable_device(link);
 572         return ret;
 573 }
 574
 575 static void das16cs_pcmcia_detach(struct pcmcia_device *link)
 576 {
 577         pcmcia_disable_device(link);
 578         cur_dev = NULL;
 579 }
 580
 581 static const struct pcmcia_device_id das16cs_id_table[] = {
 582         PCMCIA_DEVICE_MANF_CARD(0x01c5, 0x0039),
 583         PCMCIA_DEVICE_MANF_CARD(0x01c5, 0x4009),
 584         PCMCIA_DEVICE_NULL
 585 };
 586 MODULE_DEVICE_TABLE(pcmcia, das16cs_id_table);
 587
 588 static struct pcmcia_driver das16cs_driver = {
 589         .name           = "cb_das16_cs",
 590         .owner          = THIS_MODULE,
 591         .probe          = das16cs_pcmcia_attach,
 592         .remove         = das16cs_pcmcia_detach,
 593         .id_table       = das16cs_id_table,
 594 };
 595
 596 static int __init das16cs_init(void)
 597 {
 598         int ret;
 599
 600         ret = comedi_driver_register(&driver_das16cs);
 601         if (ret < 0)
 602                 return ret;
 603
 604         ret = pcmcia_register_driver(&das16cs_driver);
 605         if (ret < 0) {
 606                 comedi_driver_unregister(&driver_das16cs);
 607                 return ret;
 608         }
 609
 610         return 0;
 611 }
 612 module_init(das16cs_init);
 613
 614 static void __exit das16cs_exit(void)
 615 {
 616         pcmcia_unregister_driver(&das16cs_driver);
 617         comedi_driver_unregister(&driver_das16cs);
 618 }
 619 module_exit(das16cs_exit);
 620
 621 MODULE_AUTHOR("David A. Schleef <ds@schleef.org>");
 622 MODULE_DESCRIPTION("Comedi driver for Computer Boards PC-CARD DAS16/16");
 623 MODULE_LICENSE("GPL");