drivers/staging/comedi/range.c

   1 /*
   2     module/range.c
   3     comedi routines for voltage ranges
   4
   5     COMEDI - Linux Control and Measurement Device Interface
   6     Copyright (C) 1997-8 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 #include <linux/uaccess.h>
  20 #include "comedidev.h"
  21 #include "comedi_internal.h"
  22
  23 const struct comedi_lrange range_bipolar10 = { 1, {BIP_RANGE(10)} };
  24 EXPORT_SYMBOL_GPL(range_bipolar10);
  25 const struct comedi_lrange range_bipolar5 = { 1, {BIP_RANGE(5)} };
  26 EXPORT_SYMBOL_GPL(range_bipolar5);
  27 const struct comedi_lrange range_bipolar2_5 = { 1, {BIP_RANGE(2.5)} };
  28 EXPORT_SYMBOL_GPL(range_bipolar2_5);
  29 const struct comedi_lrange range_unipolar10 = { 1, {UNI_RANGE(10)} };
  30 EXPORT_SYMBOL_GPL(range_unipolar10);
  31 const struct comedi_lrange range_unipolar5 = { 1, {UNI_RANGE(5)} };
  32 EXPORT_SYMBOL_GPL(range_unipolar5);
  33 const struct comedi_lrange range_unipolar2_5 = { 1, {UNI_RANGE(2.5)} };
  34 EXPORT_SYMBOL_GPL(range_unipolar2_5);
  35 const struct comedi_lrange range_0_20mA = { 1, {RANGE_mA(0, 20)} };
  36 EXPORT_SYMBOL_GPL(range_0_20mA);
  37 const struct comedi_lrange range_4_20mA = { 1, {RANGE_mA(4, 20)} };
  38 EXPORT_SYMBOL_GPL(range_4_20mA);
  39 const struct comedi_lrange range_0_32mA = { 1, {RANGE_mA(0, 32)} };
  40 EXPORT_SYMBOL_GPL(range_0_32mA);
  41 const struct comedi_lrange range_unknown = { 1, {{0, 1000000, UNIT_none} } };
  42 EXPORT_SYMBOL_GPL(range_unknown);
  43
  44 /*
  45         COMEDI_RANGEINFO
  46         range information ioctl
  47
  48         arg:
  49                 pointer to rangeinfo structure
  50
  51         reads:
  52                 range info structure
  53
  54         writes:
  55                 n struct comedi_krange structures to rangeinfo->range_ptr
  56 */
  57 int do_rangeinfo_ioctl(struct comedi_device *dev,
  58                        struct comedi_rangeinfo __user *arg)
  59 {
  60         struct comedi_rangeinfo it;
  61         int subd, chan;
  62         const struct comedi_lrange *lr;
  63         struct comedi_subdevice *s;
  64
  65         if (copy_from_user(&it, arg, sizeof(struct comedi_rangeinfo)))
  66                 return -EFAULT;
  67         subd = (it.range_type >> 24) & 0xf;
  68         chan = (it.range_type >> 16) & 0xff;
  69
  70         if (!dev->attached)
  71                 return -EINVAL;
  72         if (subd >= dev->n_subdevices)
  73                 return -EINVAL;
  74         s = &dev->subdevices[subd];
  75         if (s->range_table) {
  76                 lr = s->range_table;
  77         } else if (s->range_table_list) {
  78                 if (chan >= s->n_chan)
  79                         return -EINVAL;
  80                 lr = s->range_table_list[chan];
  81         } else {
  82                 return -EINVAL;
  83         }
  84
  85         if (RANGE_LENGTH(it.range_type) != lr->length) {
  86                 DPRINTK("wrong length %d should be %d (0x%08x)\n",
  87                         RANGE_LENGTH(it.range_type), lr->length, it.range_type);
  88                 return -EINVAL;
  89         }
  90
  91         if (copy_to_user(it.range_ptr, lr->range,
  92                          sizeof(struct comedi_krange) * lr->length))
  93                 return -EFAULT;
  94
  95         return 0;
  96 }
  97
  98 static int aref_invalid(struct comedi_subdevice *s, unsigned int chanspec)
  99 {
 100         unsigned int aref;
 101
 102         /*  disable reporting invalid arefs... maybe someday */
 103         return 0;
 104
 105         aref = CR_AREF(chanspec);
 106         switch (aref) {
 107         case AREF_DIFF:
 108                 if (s->subdev_flags & SDF_DIFF)
 109                         return 0;
 110                 break;
 111         case AREF_COMMON:
 112                 if (s->subdev_flags & SDF_COMMON)
 113                         return 0;
 114                 break;
 115         case AREF_GROUND:
 116                 if (s->subdev_flags & SDF_GROUND)
 117                         return 0;
 118                 break;
 119         case AREF_OTHER:
 120                 if (s->subdev_flags & SDF_OTHER)
 121                         return 0;
 122                 break;
 123         default:
 124                 break;
 125         }
 126         DPRINTK("subdevice does not support aref %i", aref);
 127         return 1;
 128 }
 129
 130 /**
 131  * comedi_check_chanlist() - Validate each element in a chanlist.
 132  * @s: comedi_subdevice struct
 133  * @n: number of elements in the chanlist
 134  * @chanlist: the chanlist to validate
 135 */
 136 int comedi_check_chanlist(struct comedi_subdevice *s, int n,
 137                           unsigned int *chanlist)
 138 {
 139         struct comedi_device *dev = s->device;
 140         unsigned int chanspec;
 141         int chan, range_len, i;
 142
 143         if (s->range_table || s->range_table_list) {
 144                 for (i = 0; i < n; i++) {
 145                         chanspec = chanlist[i];
 146                         chan = CR_CHAN(chanspec);
 147                         if (s->range_table)
 148                                 range_len = s->range_table->length;
 149                         else if (s->range_table_list && chan < s->n_chan)
 150                                 range_len = s->range_table_list[chan]->length;
 151                         else
 152                                 range_len = 0;
 153                         if (chan >= s->n_chan ||
 154                             CR_RANGE(chanspec) >= range_len ||
 155                             aref_invalid(s, chanspec)) {
 156                                 dev_warn(dev->class_dev,
 157                                          "bad chanlist[%d]=0x%08x chan=%d range length=%d\n",
 158                                          i, chanspec, chan, range_len);
 159                                 return -EINVAL;
 160                         }
 161                 }
 162         } else {
 163                 dev_err(dev->class_dev, "(bug) no range type list!\n");
 164                 return -EINVAL;
 165         }
 166         return 0;
 167 }
 168 EXPORT_SYMBOL_GPL(comedi_check_chanlist);