drivers/staging/comedi/drivers/ni_mio_cs.c

   1 /*
   2     comedi/drivers/ni_mio_cs.c
   3     Hardware driver for NI PCMCIA MIO E series cards
   4
   5     COMEDI - Linux Control and Measurement Device Interface
   6     Copyright (C) 1997-2000 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 */
  23 /*
  24 Driver: ni_mio_cs
  25 Description: National Instruments DAQCard E series
  26 Author: ds
  27 Status: works
  28 Devices: [National Instruments] DAQCard-AI-16XE-50 (ni_mio_cs),
  29   DAQCard-AI-16E-4, DAQCard-6062E, DAQCard-6024E, DAQCard-6036E
  30 Updated: Thu Oct 23 19:43:17 CDT 2003
  31
  32 See the notes in the ni_atmio.o driver.
  33 */
  34 /*
  35         The real guts of the driver is in ni_mio_common.c, which is
  36         included by all the E series drivers.
  37
  38         References for specifications:
  39
  40            341080a.pdf  DAQCard E Series Register Level Programmer Manual
  41
  42 */
  43
  44 #include "../comedidev.h"
  45
  46 #include <linux/delay.h>
  47
  48 #include "ni_stc.h"
  49 #include "8255.h"
  50
  51 #include <pcmcia/cs_types.h>
  52 #include <pcmcia/cs.h>
  53 #include <pcmcia/cistpl.h>
  54 #include <pcmcia/ds.h>
  55
  56 #undef DEBUG
  57
  58 #define ATMIO 1
  59 #undef PCIMIO
  60
  61 /*
  62  *  AT specific setup
  63  */
  64
  65 #define NI_SIZE 0x20
  66
  67 #define MAX_N_CALDACS 32
  68
  69 static const ni_board ni_boards[] = {
  70       {device_id:0x010d,
  71               name:     "DAQCard-ai-16xe-50",
  72               n_adchan:16,
  73               adbits:   16,
  74               ai_fifo_depth:1024,
  75               alwaysdither:0,
  76               gainlkup:ai_gain_8,
  77               ai_speed:5000,
  78               n_aochan:0,
  79               aobits:   0,
  80               ao_fifo_depth:0,
  81               ao_unipolar:0,
  82               num_p0_dio_channels:8,
  83               has_8255:0,
  84               caldac:   {dac8800, dac8043},
  85                 },
  86       {device_id:0x010c,
  87               name:     "DAQCard-ai-16e-4",
  88               n_adchan:16,
  89               adbits:   12,
  90               ai_fifo_depth:1024,
  91               alwaysdither:0,
  92               gainlkup:ai_gain_16,
  93               ai_speed:4000,
  94               n_aochan:0,
  95               aobits:   0,
  96               ao_fifo_depth:0,
  97               ao_unipolar:0,
  98               num_p0_dio_channels:8,
  99               has_8255:0,
 100               caldac:   {mb88341},      /* verified */
 101                 },
 102       {device_id:0x02c4,
 103               name:     "DAQCard-6062E",
 104               n_adchan:16,
 105               adbits:   12,
 106               ai_fifo_depth:8192,
 107               alwaysdither:0,
 108               gainlkup:ai_gain_16,
 109               ai_speed:2000,
 110               n_aochan:2,
 111               aobits:   12,
 112               ao_fifo_depth:2048,
 113               ao_range_table:&range_bipolar10,
 114               ao_unipolar:0,
 115               ao_speed:1176,
 116               num_p0_dio_channels:8,
 117               has_8255:0,
 118               caldac:   {ad8804_debug}, /* verified */
 119                 },
 120       {device_id:0x075e,
 121               name:     "DAQCard-6024E",        /* specs incorrect! */
 122               n_adchan:16,
 123               adbits:   12,
 124               ai_fifo_depth:1024,
 125               alwaysdither:0,
 126               gainlkup:ai_gain_16,
 127               ai_speed:5000,
 128               n_aochan:2,
 129               aobits:   12,
 130               ao_fifo_depth:0,
 131               ao_range_table:&range_bipolar10,
 132               ao_unipolar:0,
 133               ao_speed:1000000,
 134               num_p0_dio_channels:8,
 135               has_8255:0,
 136               caldac:   {ad8804_debug},
 137                 },
 138       {device_id:0x0245,
 139               name:     "DAQCard-6036E",        /* specs incorrect! */
 140               n_adchan:16,
 141               adbits:   16,
 142               ai_fifo_depth:1024,
 143               alwaysdither:1,
 144               gainlkup:ai_gain_4,
 145               ai_speed:5000,
 146               n_aochan:2,
 147               aobits:   16,
 148               ao_fifo_depth:0,
 149               ao_range_table:&range_bipolar10,
 150               ao_unipolar:0,
 151               ao_speed:1000000,
 152               num_p0_dio_channels:8,
 153               has_8255:0,
 154               caldac:   {ad8804_debug},
 155                 },
 156 #if 0
 157       {device_id:0x0000,        /* unknown */
 158               name:     "DAQCard-6715",
 159               n_adchan:0,
 160               n_aochan:8,
 161               aobits:   12,
 162               ao_671x:  8192,
 163               num_p0_dio_channels:8,
 164               caldac:   {mb88341, mb88341},
 165                 },
 166 #endif
 167         /* N.B. Update ni_mio_cs_ids[] when entries added above. */
 168 };
 169
 170 #define interrupt_pin(a)        0
 171
 172 #define IRQ_POLARITY 1
 173
 174 #define NI_E_IRQ_FLAGS          IRQF_SHARED
 175
 176 struct ni_private {
 177
 178         struct pcmcia_device *link;
 179
 180  NI_PRIVATE_COMMON};
 181
 182 #define devpriv ((struct ni_private *)dev->private)
 183
 184 /* How we access registers */
 185
 186 #define ni_writel(a,b)          (outl((a),(b)+dev->iobase))
 187 #define ni_readl(a)             (inl((a)+dev->iobase))
 188 #define ni_writew(a,b)          (outw((a),(b)+dev->iobase))
 189 #define ni_readw(a)             (inw((a)+dev->iobase))
 190 #define ni_writeb(a,b)          (outb((a),(b)+dev->iobase))
 191 #define ni_readb(a)             (inb((a)+dev->iobase))
 192
 193 /* How we access windowed registers */
 194
 195 /* We automatically take advantage of STC registers that can be
 196  * read/written directly in the I/O space of the board.  The
 197  * DAQCard devices map the low 8 STC registers to iobase+addr*2. */
 198
 199 static void mio_cs_win_out(struct comedi_device * dev, uint16_t data, int addr)
 200 {
 201         unsigned long flags;
 202
 203         comedi_spin_lock_irqsave(&devpriv->window_lock, flags);
 204         if (addr < 8) {
 205                 ni_writew(data, addr * 2);
 206         } else {
 207                 ni_writew(addr, Window_Address);
 208                 ni_writew(data, Window_Data);
 209         }
 210         comedi_spin_unlock_irqrestore(&devpriv->window_lock, flags);
 211 }
 212
 213 static uint16_t mio_cs_win_in(struct comedi_device * dev, int addr)
 214 {
 215         unsigned long flags;
 216         uint16_t ret;
 217
 218         comedi_spin_lock_irqsave(&devpriv->window_lock, flags);
 219         if (addr < 8) {
 220                 ret = ni_readw(addr * 2);
 221         } else {
 222                 ni_writew(addr, Window_Address);
 223                 ret = ni_readw(Window_Data);
 224         }
 225         comedi_spin_unlock_irqrestore(&devpriv->window_lock, flags);
 226
 227         return ret;
 228 }
 229
 230 static int mio_cs_attach(struct comedi_device * dev, struct comedi_devconfig * it);
 231 static int mio_cs_detach(struct comedi_device * dev);
 232 static struct comedi_driver driver_ni_mio_cs = {
 233       driver_name:"ni_mio_cs",
 234       module:THIS_MODULE,
 235       attach:mio_cs_attach,
 236       detach:mio_cs_detach,
 237 };
 238
 239 #include "ni_mio_common.c"
 240
 241 static int ni_getboardtype(struct comedi_device * dev, struct pcmcia_device *link);
 242
 243 /* clean up allocated resources */
 244 /* called when driver is removed */
 245 static int mio_cs_detach(struct comedi_device * dev)
 246 {
 247         mio_common_detach(dev);
 248
 249         /* PCMCIA layer frees the IO region */
 250
 251         if (dev->irq) {
 252                 comedi_free_irq(dev->irq, dev);
 253         }
 254
 255         return 0;
 256 }
 257
 258 static void mio_cs_config(struct pcmcia_device *link);
 259 static void cs_release(struct pcmcia_device *link);
 260 static void cs_detach(struct pcmcia_device *);
 261
 262 static struct pcmcia_device *cur_dev = NULL;
 263 static const dev_info_t dev_info = "ni_mio_cs";
 264 static dev_node_t dev_node = {
 265         "ni_mio_cs",
 266         COMEDI_MAJOR, 0,
 267         NULL
 268 };
 269 static int cs_attach(struct pcmcia_device *link)
 270 {
 271         link->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
 272         link->io.NumPorts1 = 16;
 273         link->irq.Attributes = IRQ_TYPE_EXCLUSIVE;
 274         link->irq.IRQInfo1 = IRQ_LEVEL_ID;
 275         link->conf.Attributes = CONF_ENABLE_IRQ;
 276         link->conf.IntType = INT_MEMORY_AND_IO;
 277
 278         cur_dev = link;
 279
 280         mio_cs_config(link);
 281
 282         return 0;
 283 }
 284
 285 static void cs_release(struct pcmcia_device *link)
 286 {
 287         pcmcia_disable_device(link);
 288 }
 289
 290 static void cs_detach(struct pcmcia_device *link)
 291 {
 292         DPRINTK("cs_detach(link=%p)\n", link);
 293
 294         if (link->dev_node) {
 295                 cs_release(link);
 296         }
 297 }
 298
 299 static int mio_cs_suspend(struct pcmcia_device *link)
 300 {
 301         DPRINTK("pm suspend\n");
 302
 303         return 0;
 304 }
 305
 306 static int mio_cs_resume(struct pcmcia_device *link)
 307 {
 308         DPRINTK("pm resume\n");
 309         return 0;
 310 }
 311
 312 static void mio_cs_config(struct pcmcia_device *link)
 313 {
 314         tuple_t tuple;
 315         u_short buf[128];
 316         cisparse_t parse;
 317         int manfid = 0, prodid = 0;
 318         int ret;
 319
 320         DPRINTK("mio_cs_config(link=%p)\n", link);
 321
 322         tuple.TupleData = (cisdata_t *) buf;
 323         tuple.TupleOffset = 0;
 324         tuple.TupleDataMax = 255;
 325         tuple.Attributes = 0;
 326
 327         tuple.DesiredTuple = CISTPL_CONFIG;
 328         ret = pcmcia_get_first_tuple(link, &tuple);
 329         ret = pcmcia_get_tuple_data(link, &tuple);
 330         ret = pcmcia_parse_tuple(&tuple, &parse);
 331         link->conf.ConfigBase = parse.config.base;
 332         link->conf.Present = parse.config.rmask[0];
 333
 334 #if 0
 335         tuple.DesiredTuple = CISTPL_LONGLINK_MFC;
 336         tuple.Attributes = TUPLE_RETURN_COMMON | TUPLE_RETURN_LINK;
 337         info->multi(first_tuple(link, &tuple, &parse) == 0);
 338 #endif
 339
 340         tuple.DesiredTuple = CISTPL_MANFID;
 341         tuple.Attributes = TUPLE_RETURN_COMMON;
 342         if ((pcmcia_get_first_tuple(link, &tuple) == 0) &&
 343                 (pcmcia_get_tuple_data(link, &tuple) == 0)) {
 344                 manfid = le16_to_cpu(buf[0]);
 345                 prodid = le16_to_cpu(buf[1]);
 346         }
 347         //printk("manfid = 0x%04x, 0x%04x\n",manfid,prodid);
 348
 349         tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
 350         tuple.Attributes = 0;
 351         ret = pcmcia_get_first_tuple(link, &tuple);
 352         ret = pcmcia_get_tuple_data(link, &tuple);
 353         ret = pcmcia_parse_tuple(&tuple, &parse);
 354
 355 #if 0
 356         printk(" index: 0x%x\n", parse.cftable_entry.index);
 357         printk(" flags: 0x%x\n", parse.cftable_entry.flags);
 358         printk(" io flags: 0x%x\n", parse.cftable_entry.io.flags);
 359         printk(" io nwin: 0x%x\n", parse.cftable_entry.io.nwin);
 360         printk(" io base: 0x%x\n", parse.cftable_entry.io.win[0].base);
 361         printk(" io len: 0x%x\n", parse.cftable_entry.io.win[0].len);
 362         printk(" irq1: 0x%x\n", parse.cftable_entry.irq.IRQInfo1);
 363         printk(" irq2: 0x%x\n", parse.cftable_entry.irq.IRQInfo2);
 364         printk(" mem flags: 0x%x\n", parse.cftable_entry.mem.flags);
 365         printk(" mem nwin: 0x%x\n", parse.cftable_entry.mem.nwin);
 366         printk(" subtuples: 0x%x\n", parse.cftable_entry.subtuples);
 367 #endif
 368
 369 #if 0
 370         link->io.NumPorts1 = 0x20;
 371         link->io.IOAddrLines = 5;
 372         link->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
 373 #endif
 374         link->io.NumPorts1 = parse.cftable_entry.io.win[0].len;
 375         link->io.IOAddrLines =
 376                 parse.cftable_entry.io.flags & CISTPL_IO_LINES_MASK;
 377         link->io.NumPorts2 = 0;
 378
 379         {
 380                 int base;
 381                 for (base = 0x000; base < 0x400; base += 0x20) {
 382                         link->io.BasePort1 = base;
 383                         ret = pcmcia_request_io(link, &link->io);
 384                         //printk("RequestIO 0x%02x\n",ret);
 385                         if (!ret)
 386                                 break;
 387                 }
 388         }
 389
 390         link->irq.IRQInfo1 = parse.cftable_entry.irq.IRQInfo1;
 391         link->irq.IRQInfo2 = parse.cftable_entry.irq.IRQInfo2;
 392         ret = pcmcia_request_irq(link, &link->irq);
 393         if (ret) {
 394                 printk("pcmcia_request_irq() returned error: %i\n", ret);
 395         }
 396         //printk("RequestIRQ 0x%02x\n",ret);
 397
 398         link->conf.ConfigIndex = 1;
 399
 400         ret = pcmcia_request_configuration(link, &link->conf);
 401         //printk("RequestConfiguration %d\n",ret);
 402
 403         link->dev_node = &dev_node;
 404 }
 405
 406 static int mio_cs_attach(struct comedi_device * dev, struct comedi_devconfig * it)
 407 {
 408         struct pcmcia_device *link;
 409         unsigned int irq;
 410         int ret;
 411
 412         DPRINTK("mio_cs_attach(dev=%p,it=%p)\n", dev, it);
 413
 414         link = cur_dev;         /* XXX hack */
 415         if (!link)
 416                 return -EIO;
 417
 418         dev->driver = &driver_ni_mio_cs;
 419         dev->iobase = link->io.BasePort1;
 420
 421         irq = link->irq.AssignedIRQ;
 422
 423         printk("comedi%d: %s: DAQCard: io 0x%04lx, irq %u, ",
 424                 dev->minor, dev->driver->driver_name, dev->iobase, irq);
 425
 426 #if 0
 427         {
 428                 int i;
 429
 430                 printk(" board fingerprint:");
 431                 for (i = 0; i < 32; i += 2) {
 432                         printk(" %04x %02x", inw(dev->iobase + i),
 433                                 inb(dev->iobase + i + 1));
 434                 }
 435                 printk("\n");
 436                 printk(" board fingerprint (windowed):");
 437                 for (i = 0; i < 10; i++) {
 438                         printk(" 0x%04x", win_in(i));
 439                 }
 440                 printk("\n");
 441         }
 442 #endif
 443
 444         dev->board_ptr = ni_boards + ni_getboardtype(dev, link);
 445
 446         printk(" %s", boardtype.name);
 447         dev->board_name = boardtype.name;
 448
 449         if ((ret = comedi_request_irq(irq, ni_E_interrupt, NI_E_IRQ_FLAGS,
 450                                 "ni_mio_cs", dev)) < 0) {
 451                 printk(" irq not available\n");
 452                 return -EINVAL;
 453         }
 454         dev->irq = irq;
 455
 456         /* allocate private area */
 457         if ((ret = ni_alloc_private(dev)) < 0)
 458                 return ret;
 459         devpriv->stc_writew = &mio_cs_win_out;
 460         devpriv->stc_readw = &mio_cs_win_in;
 461         devpriv->stc_writel = &win_out2;
 462         devpriv->stc_readl = &win_in2;
 463
 464         if ((ret = ni_E_init(dev, it)) < 0) {
 465                 return ret;
 466         }
 467
 468         return 0;
 469 }
 470
 471 static int get_prodid(struct comedi_device * dev, struct pcmcia_device *link)
 472 {
 473         tuple_t tuple;
 474         u_short buf[128];
 475         int prodid = 0;
 476
 477         tuple.TupleData = (cisdata_t *) buf;
 478         tuple.TupleOffset = 0;
 479         tuple.TupleDataMax = 255;
 480         tuple.DesiredTuple = CISTPL_MANFID;
 481         tuple.Attributes = TUPLE_RETURN_COMMON;
 482         if ((pcmcia_get_first_tuple(link, &tuple) == 0) &&
 483                 (pcmcia_get_tuple_data(link, &tuple) == 0)) {
 484                 prodid = le16_to_cpu(buf[1]);
 485         }
 486
 487         return prodid;
 488 }
 489
 490 static int ni_getboardtype(struct comedi_device * dev, struct pcmcia_device *link)
 491 {
 492         int id;
 493         int i;
 494
 495         id = get_prodid(dev, link);
 496
 497         for (i = 0; i < n_ni_boards; i++) {
 498                 if (ni_boards[i].device_id == id) {
 499                         return i;
 500                 }
 501         }
 502
 503         printk("unknown board 0x%04x -- pretend it is a ", id);
 504
 505         return 0;
 506 }
 507
 508 #ifdef MODULE
 509
 510 MODULE_LICENSE("GPL");
 511
 512 static struct pcmcia_device_id ni_mio_cs_ids[] = {
 513         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x010d),        /* DAQCard-ai-16xe-50 */
 514         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x010c),        /* DAQCard-ai-16e-4 */
 515         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x02c4),        /* DAQCard-6062E */
 516         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x075e),        /* DAQCard-6024E */
 517         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0245),        /* DAQCard-6036E */
 518         PCMCIA_DEVICE_NULL
 519 };
 520
 521 MODULE_DEVICE_TABLE(pcmcia, ni_mio_cs_ids);
 522
 523 struct pcmcia_driver ni_mio_cs_driver = {
 524         .probe = &cs_attach,
 525         .remove = &cs_detach,
 526         .suspend = &mio_cs_suspend,
 527         .resume = &mio_cs_resume,
 528         .id_table = ni_mio_cs_ids,
 529         .owner = THIS_MODULE,
 530         .drv = {
 531                         .name = dev_info,
 532                 },
 533 };
 534
 535 int init_module(void)
 536 {
 537         pcmcia_register_driver(&ni_mio_cs_driver);
 538         comedi_driver_register(&driver_ni_mio_cs);
 539         return 0;
 540 }
 541
 542 void cleanup_module(void)
 543 {
 544         pcmcia_unregister_driver(&ni_mio_cs_driver);
 545 #if 0
 546         while (cur_dev != NULL)
 547                 cs_detach(cur_dev->handle);
 548 #endif
 549         comedi_driver_unregister(&driver_ni_mio_cs);
 550 }
 551 #endif