drivers/staging/comedi/drivers/ssv_dnp.c

   1 /*
   2     comedi/drivers/ssv_dnp.c
   3     generic comedi driver for SSV Embedded Systems' DIL/Net-PCs
   4     Copyright (C) 2001 Robert Schwebel <robert@schwebel.de>
   5
   6     COMEDI - Linux Control and Measurement Device Interface
   7     Copyright (C) 2000 David A. Schleef <ds@schleef.org>
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18 */
  19 /*
  20 Driver: ssv_dnp
  21 Description: SSV Embedded Systems DIL/Net-PC
  22 Author: Robert Schwebel <robert@schwebel.de>
  23 Devices: [SSV Embedded Systems] DIL/Net-PC 1486 (dnp-1486)
  24 Status: unknown
  25 */
  26
  27 /* include files ----------------------------------------------------------- */
  28
  29 #include <linux/module.h>
  30 #include "../comedidev.h"
  31
  32 /* Some global definitions: the registers of the DNP ----------------------- */
  33 /*                                                                           */
  34 /* For port A and B the mode register has bits corresponding to the output   */
  35 /* pins, where Bit-N = 0 -> input, Bit-N = 1 -> output. Note that bits       */
  36 /* 4 to 7 correspond to pin 0..3 for port C data register. Ensure that bits  */
  37 /* 0..3 remain unchanged! For details about Port C Mode Register see         */
  38 /* the remarks in dnp_insn_config() below.                                   */
  39
  40 #define CSCIR 0x22              /* Chip Setup and Control Index Register     */
  41 #define CSCDR 0x23              /* Chip Setup and Control Data Register      */
  42 #define PAMR  0xa5              /* Port A Mode Register                      */
  43 #define PADR  0xa9              /* Port A Data Register                      */
  44 #define PBMR  0xa4              /* Port B Mode Register                      */
  45 #define PBDR  0xa8              /* Port B Data Register                      */
  46 #define PCMR  0xa3              /* Port C Mode Register                      */
  47 #define PCDR  0xa7              /* Port C Data Register                      */
  48
  49 static int dnp_dio_insn_bits(struct comedi_device *dev,
  50                              struct comedi_subdevice *s,
  51                              struct comedi_insn *insn,
  52                              unsigned int *data)
  53 {
  54         unsigned int mask;
  55         unsigned int val;
  56
  57         /*
  58          * Ports A and B are straight forward: each bit corresponds to an
  59          * output pin with the same order. Port C is different: bits 0...3
  60          * correspond to bits 4...7 of the output register (PCDR).
  61          */
  62
  63         mask = comedi_dio_update_state(s, data);
  64         if (mask) {
  65                 outb(PADR, CSCIR);
  66                 outb(s->state & 0xff, CSCDR);
  67
  68                 outb(PBDR, CSCIR);
  69                 outb((s->state >> 8) & 0xff, CSCDR);
  70
  71                 outb(PCDR, CSCIR);
  72                 val = inb(CSCDR) & 0x0f;
  73                 outb(((s->state >> 12) & 0xf0) | val, CSCDR);
  74         }
  75
  76         outb(PADR, CSCIR);
  77         val = inb(CSCDR);
  78         outb(PBDR, CSCIR);
  79         val |= (inb(CSCDR) << 8);
  80         outb(PCDR, CSCIR);
  81         val |= ((inb(CSCDR) & 0xf0) << 12);
  82
  83         data[1] = val;
  84
  85         return insn->n;
  86 }
  87
  88 static int dnp_dio_insn_config(struct comedi_device *dev,
  89                                struct comedi_subdevice *s,
  90                                struct comedi_insn *insn,
  91                                unsigned int *data)
  92 {
  93         unsigned int chan = CR_CHAN(insn->chanspec);
  94         unsigned int mask;
  95         unsigned int val;
  96         int ret;
  97
  98         ret = comedi_dio_insn_config(dev, s, insn, data, 0);
  99         if (ret)
 100                 return ret;
 101
 102         if (chan < 8) {                 /* Port A */
 103                 mask = 1 << chan;
 104                 outb(PAMR, CSCIR);
 105         } else if (chan < 16) {         /* Port B */
 106                 mask = 1 << (chan - 8);
 107                 outb(PBMR, CSCIR);
 108         } else {                        /* Port C */
 109                 /*
 110                  * We have to pay attention with port C.
 111                  * This is the meaning of PCMR:
 112                  *   Bit in PCMR:              7 6 5 4 3 2 1 0
 113                  *   Corresponding port C pin: d 3 d 2 d 1 d 0   d= don't touch
 114                  *
 115                  * Multiplication by 2 brings bits into correct position
 116                  * for PCMR!
 117                  */
 118                 mask = 1 << ((chan - 16) * 2);
 119                 outb(PCMR, CSCIR);
 120         }
 121
 122         val = inb(CSCDR);
 123         if (data[0] == COMEDI_OUTPUT)
 124                 val |= mask;
 125         else
 126                 val &= ~mask;
 127         outb(val, CSCDR);
 128
 129         return insn->n;
 130
 131 }
 132
 133 static int dnp_attach(struct comedi_device *dev, struct comedi_devconfig *it)
 134 {
 135         struct comedi_subdevice *s;
 136         int ret;
 137
 138         ret = comedi_alloc_subdevices(dev, 1);
 139         if (ret)
 140                 return ret;
 141
 142         s = &dev->subdevices[0];
 143         /* digital i/o subdevice                                             */
 144         s->type = COMEDI_SUBD_DIO;
 145         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 146         s->n_chan = 20;
 147         s->maxdata = 1;
 148         s->range_table = &range_digital;
 149         s->insn_bits = dnp_dio_insn_bits;
 150         s->insn_config = dnp_dio_insn_config;
 151
 152         /* We use the I/O ports 0x22,0x23 and 0xa3-0xa9, which are always
 153          * allocated for the primary 8259, so we don't need to allocate them
 154          * ourselves. */
 155
 156         /* configure all ports as input (default)                            */
 157         outb(PAMR, CSCIR);
 158         outb(0x00, CSCDR);
 159         outb(PBMR, CSCIR);
 160         outb(0x00, CSCDR);
 161         outb(PCMR, CSCIR);
 162         outb((inb(CSCDR) & 0xAA), CSCDR);
 163
 164         return 0;
 165 }
 166
 167 static void dnp_detach(struct comedi_device *dev)
 168 {
 169         outb(PAMR, CSCIR);
 170         outb(0x00, CSCDR);
 171         outb(PBMR, CSCIR);
 172         outb(0x00, CSCDR);
 173         outb(PCMR, CSCIR);
 174         outb((inb(CSCDR) & 0xAA), CSCDR);
 175 }
 176
 177 static struct comedi_driver dnp_driver = {
 178         .driver_name    = "dnp-1486",
 179         .module         = THIS_MODULE,
 180         .attach         = dnp_attach,
 181         .detach         = dnp_detach,
 182 };
 183 module_comedi_driver(dnp_driver);
 184
 185 MODULE_AUTHOR("Comedi http://www.comedi.org");
 186 MODULE_DESCRIPTION("Comedi low-level driver");
 187 MODULE_LICENSE("GPL");