drivers/staging/comedi/drivers/8255.c

   1 /*
   2     comedi/drivers/8255.c
   3     Driver for 8255
   4
   5     COMEDI - Linux Control and Measurement Device Interface
   6     Copyright (C) 1998 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 /*
  19 Driver: 8255
  20 Description: generic 8255 support
  21 Devices: [standard] 8255 (8255)
  22 Author: ds
  23 Status: works
  24 Updated: Fri,  7 Jun 2002 12:56:45 -0700
  25
  26 The classic in digital I/O.  The 8255 appears in Comedi as a single
  27 digital I/O subdevice with 24 channels.  The channel 0 corresponds
  28 to the 8255's port A, bit 0; channel 23 corresponds to port C, bit
  29 7.  Direction configuration is done in blocks, with channels 0-7,
  30 8-15, 16-19, and 20-23 making up the 4 blocks.  The only 8255 mode
  31 supported is mode 0.
  32
  33 You should enable compilation this driver if you plan to use a board
  34 that has an 8255 chip.  For multifunction boards, the main driver will
  35 configure the 8255 subdevice automatically.
  36
  37 This driver also works independently with ISA and PCI cards that
  38 directly map the 8255 registers to I/O ports, including cards with
  39 multiple 8255 chips.  To configure the driver for such a card, the
  40 option list should be a list of the I/O port bases for each of the
  41 8255 chips.  For example,
  42
  43   comedi_config /dev/comedi0 8255 0x200,0x204,0x208,0x20c
  44
  45 Note that most PCI 8255 boards do NOT work with this driver, and
  46 need a separate driver as a wrapper.  For those that do work, the
  47 I/O port base address can be found in the output of 'lspci -v'.
  48
  49 */
  50
  51 /*
  52    This file contains an exported subdevice for driving an 8255.
  53
  54    To use this subdevice as part of another driver, you need to
  55    set up the subdevice in the attach function of the driver by
  56    calling:
  57
  58      subdev_8255_init(device, subdevice, io_function, iobase)
  59
  60    device and subdevice are pointers to the device and subdevice
  61    structures.  io_function will be called to provide the
  62    low-level input/output to the device, i.e., actual register
  63    access.  io_function will be called with the value of iobase
  64    as the last parameter.  If the 8255 device is mapped as 4
  65    consecutive I/O ports, you can use NULL for io_function
  66    and the I/O port base for iobase, and an internal function will
  67    handle the register access.
  68
  69    In addition, if the main driver handles interrupts, you can
  70    enable commands on the subdevice by calling subdev_8255_init_irq()
  71    instead.  Then, when you get an interrupt that is likely to be
  72    from the 8255, you should call subdev_8255_interrupt(), which
  73    will copy the latched value to a Comedi buffer.
  74  */
  75
  76 #include "../comedidev.h"
  77
  78 #include <linux/ioport.h>
  79
  80 #include "comedi_fc.h"
  81 #include "8255.h"
  82
  83 #define _8255_SIZE      4
  84
  85 #define _8255_DATA      0
  86 #define _8255_CR        3
  87
  88 #define CR_C_LO_IO      0x01
  89 #define CR_B_IO         0x02
  90 #define CR_B_MODE       0x04
  91 #define CR_C_HI_IO      0x08
  92 #define CR_A_IO         0x10
  93 #define CR_A_MODE(a)    ((a)<<5)
  94 #define CR_CW           0x80
  95
  96 struct subdev_8255_private {
  97         unsigned long iobase;
  98         int (*io) (int, int, int, unsigned long);
  99 };
 100
 101 static int subdev_8255_io(int dir, int port, int data, unsigned long iobase)
 102 {
 103         if (dir) {
 104                 outb(data, iobase + port);
 105                 return 0;
 106         } else {
 107                 return inb(iobase + port);
 108         }
 109 }
 110
 111 void subdev_8255_interrupt(struct comedi_device *dev,
 112                            struct comedi_subdevice *s)
 113 {
 114         struct subdev_8255_private *spriv = s->private;
 115         unsigned long iobase = spriv->iobase;
 116         short d;
 117
 118         d = spriv->io(0, _8255_DATA, 0, iobase);
 119         d |= (spriv->io(0, _8255_DATA + 1, 0, iobase) << 8);
 120
 121         comedi_buf_put(s->async, d);
 122         s->async->events |= COMEDI_CB_EOS;
 123
 124         comedi_event(dev, s);
 125 }
 126 EXPORT_SYMBOL_GPL(subdev_8255_interrupt);
 127
 128 static int subdev_8255_insn(struct comedi_device *dev,
 129                             struct comedi_subdevice *s,
 130                             struct comedi_insn *insn, unsigned int *data)
 131 {
 132         struct subdev_8255_private *spriv = s->private;
 133         unsigned long iobase = spriv->iobase;
 134         unsigned int mask;
 135         unsigned int bits;
 136         unsigned int v;
 137
 138         mask = data[0];
 139         bits = data[1];
 140
 141         if (mask) {
 142                 v = s->state;
 143                 v &= ~mask;
 144                 v |= (bits & mask);
 145
 146                 if (mask & 0xff)
 147                         spriv->io(1, _8255_DATA, v & 0xff, iobase);
 148                 if (mask & 0xff00)
 149                         spriv->io(1, _8255_DATA + 1, (v >> 8) & 0xff, iobase);
 150                 if (mask & 0xff0000)
 151                         spriv->io(1, _8255_DATA + 2, (v >> 16) & 0xff, iobase);
 152
 153                 s->state = v;
 154         }
 155
 156         v = spriv->io(0, _8255_DATA, 0, iobase);
 157         v |= (spriv->io(0, _8255_DATA + 1, 0, iobase) << 8);
 158         v |= (spriv->io(0, _8255_DATA + 2, 0, iobase) << 16);
 159
 160         data[1] = v;
 161
 162         return insn->n;
 163 }
 164
 165 static void subdev_8255_do_config(struct comedi_device *dev,
 166                                   struct comedi_subdevice *s)
 167 {
 168         struct subdev_8255_private *spriv = s->private;
 169         unsigned long iobase = spriv->iobase;
 170         int config;
 171
 172         config = CR_CW;
 173         /* 1 in io_bits indicates output, 1 in config indicates input */
 174         if (!(s->io_bits & 0x0000ff))
 175                 config |= CR_A_IO;
 176         if (!(s->io_bits & 0x00ff00))
 177                 config |= CR_B_IO;
 178         if (!(s->io_bits & 0x0f0000))
 179                 config |= CR_C_LO_IO;
 180         if (!(s->io_bits & 0xf00000))
 181                 config |= CR_C_HI_IO;
 182
 183         spriv->io(1, _8255_CR, config, iobase);
 184 }
 185
 186 static int subdev_8255_insn_config(struct comedi_device *dev,
 187                                    struct comedi_subdevice *s,
 188                                    struct comedi_insn *insn, unsigned int *data)
 189 {
 190         unsigned int mask;
 191         unsigned int bits;
 192
 193         mask = 1 << CR_CHAN(insn->chanspec);
 194         if (mask & 0x0000ff)
 195                 bits = 0x0000ff;
 196         else if (mask & 0x00ff00)
 197                 bits = 0x00ff00;
 198         else if (mask & 0x0f0000)
 199                 bits = 0x0f0000;
 200         else
 201                 bits = 0xf00000;
 202
 203         switch (data[0]) {
 204         case INSN_CONFIG_DIO_INPUT:
 205                 s->io_bits &= ~bits;
 206                 break;
 207         case INSN_CONFIG_DIO_OUTPUT:
 208                 s->io_bits |= bits;
 209                 break;
 210         case INSN_CONFIG_DIO_QUERY:
 211                 data[1] = (s->io_bits & bits) ? COMEDI_OUTPUT : COMEDI_INPUT;
 212                 return insn->n;
 213                 break;
 214         default:
 215                 return -EINVAL;
 216         }
 217
 218         subdev_8255_do_config(dev, s);
 219
 220         return 1;
 221 }
 222
 223 static int subdev_8255_cmdtest(struct comedi_device *dev,
 224                                struct comedi_subdevice *s,
 225                                struct comedi_cmd *cmd)
 226 {
 227         int err = 0;
 228
 229         /* Step 1 : check if triggers are trivially valid */
 230
 231         err |= cfc_check_trigger_src(&cmd->start_src, TRIG_NOW);
 232         err |= cfc_check_trigger_src(&cmd->scan_begin_src, TRIG_EXT);
 233         err |= cfc_check_trigger_src(&cmd->convert_src, TRIG_FOLLOW);
 234         err |= cfc_check_trigger_src(&cmd->scan_end_src, TRIG_COUNT);
 235         err |= cfc_check_trigger_src(&cmd->stop_src, TRIG_NONE);
 236
 237         if (err)
 238                 return 1;
 239
 240         /* Step 2a : make sure trigger sources are unique */
 241         /* Step 2b : and mutually compatible */
 242
 243         if (err)
 244                 return 2;
 245
 246         /* Step 3: check if arguments are trivially valid */
 247
 248         err |= cfc_check_trigger_arg_is(&cmd->start_arg, 0);
 249         err |= cfc_check_trigger_arg_is(&cmd->scan_begin_arg, 0);
 250         err |= cfc_check_trigger_arg_is(&cmd->convert_arg, 0);
 251         err |= cfc_check_trigger_arg_is(&cmd->scan_end_arg, 1);
 252         err |= cfc_check_trigger_arg_is(&cmd->stop_arg, 0);
 253
 254         if (err)
 255                 return 3;
 256
 257         /* step 4 */
 258
 259         if (err)
 260                 return 4;
 261
 262         return 0;
 263 }
 264
 265 static int subdev_8255_cmd(struct comedi_device *dev,
 266                            struct comedi_subdevice *s)
 267 {
 268         /* FIXME */
 269
 270         return 0;
 271 }
 272
 273 static int subdev_8255_cancel(struct comedi_device *dev,
 274                               struct comedi_subdevice *s)
 275 {
 276         /* FIXME */
 277
 278         return 0;
 279 }
 280
 281 int subdev_8255_init(struct comedi_device *dev, struct comedi_subdevice *s,
 282                      int (*io) (int, int, int, unsigned long),
 283                      unsigned long iobase)
 284 {
 285         struct subdev_8255_private *spriv;
 286
 287         spriv = comedi_alloc_spriv(s, sizeof(*spriv));
 288         if (!spriv)
 289                 return -ENOMEM;
 290
 291         spriv->iobase   = iobase;
 292         spriv->io       = io ? io : subdev_8255_io;
 293
 294         s->type         = COMEDI_SUBD_DIO;
 295         s->subdev_flags = SDF_READABLE | SDF_WRITABLE;
 296         s->n_chan       = 24;
 297         s->range_table  = &range_digital;
 298         s->maxdata      = 1;
 299         s->insn_bits    = subdev_8255_insn;
 300         s->insn_config  = subdev_8255_insn_config;
 301
 302         s->state        = 0;
 303         s->io_bits      = 0;
 304
 305         subdev_8255_do_config(dev, s);
 306
 307         return 0;
 308 }
 309 EXPORT_SYMBOL_GPL(subdev_8255_init);
 310
 311 int subdev_8255_init_irq(struct comedi_device *dev, struct comedi_subdevice *s,
 312                          int (*io) (int, int, int, unsigned long),
 313                          unsigned long iobase)
 314 {
 315         int ret;
 316
 317         ret = subdev_8255_init(dev, s, io, iobase);
 318         if (ret)
 319                 return ret;
 320
 321         s->do_cmdtest   = subdev_8255_cmdtest;
 322         s->do_cmd       = subdev_8255_cmd;
 323         s->cancel       = subdev_8255_cancel;
 324
 325         return 0;
 326 }
 327 EXPORT_SYMBOL_GPL(subdev_8255_init_irq);
 328
 329 /*
 330
 331    Start of the 8255 standalone device
 332
 333  */
 334
 335 static int dev_8255_attach(struct comedi_device *dev,
 336                            struct comedi_devconfig *it)
 337 {
 338         struct comedi_subdevice *s;
 339         int ret;
 340         unsigned long iobase;
 341         int i;
 342
 343         for (i = 0; i < COMEDI_NDEVCONFOPTS; i++) {
 344                 iobase = it->options[i];
 345                 if (!iobase)
 346                         break;
 347         }
 348         if (i == 0) {
 349                 dev_warn(dev->class_dev, "no devices specified\n");
 350                 return -EINVAL;
 351         }
 352
 353         ret = comedi_alloc_subdevices(dev, i);
 354         if (ret)
 355                 return ret;
 356
 357         for (i = 0; i < dev->n_subdevices; i++) {
 358                 s = &dev->subdevices[i];
 359                 iobase = it->options[i];
 360
 361                 ret = __comedi_request_region(dev, iobase, _8255_SIZE);
 362                 if (ret) {
 363                         s->type = COMEDI_SUBD_UNUSED;
 364                 } else {
 365                         ret = subdev_8255_init(dev, s, NULL, iobase);
 366                         if (ret)
 367                                 return ret;
 368                 }
 369         }
 370
 371         return 0;
 372 }
 373
 374 static void dev_8255_detach(struct comedi_device *dev)
 375 {
 376         struct comedi_subdevice *s;
 377         struct subdev_8255_private *spriv;
 378         int i;
 379
 380         for (i = 0; i < dev->n_subdevices; i++) {
 381                 s = &dev->subdevices[i];
 382                 if (s->type != COMEDI_SUBD_UNUSED) {
 383                         spriv = s->private;
 384                         release_region(spriv->iobase, _8255_SIZE);
 385                 }
 386         }
 387 }
 388
 389 static struct comedi_driver dev_8255_driver = {
 390         .driver_name    = "8255",
 391         .module         = THIS_MODULE,
 392         .attach         = dev_8255_attach,
 393         .detach         = dev_8255_detach,
 394 };
 395 module_comedi_driver(dev_8255_driver);
 396
 397 MODULE_AUTHOR("Comedi http://www.comedi.org");
 398 MODULE_DESCRIPTION("Comedi low-level driver");
 399 MODULE_LICENSE("GPL");