lib/comedi.c

   1 /*
   2     lib/comedi.c
   3     generic functions
   4
   5     COMEDILIB - Linux Control and Measurement Device Interface Library
   6     Copyright (C) 1997-2001 David A. Schleef <ds@schleef.org>
   7
   8     This library is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU Lesser General Public
  10     License as published by the Free Software Foundation, version 2.1
  11     of the License.
  12
  13     This library 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 GNU
  16     Lesser General Public License for more details.
  17
  18     You should have received a copy of the GNU Lesser General Public
  19     License along with this library; if not, write to the Free Software
  20     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  21     USA.
  22 */
  23
  24 #include <stdio.h>
  25 #include <math.h>
  26 #include <stdlib.h>
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30 #include <unistd.h>
  31 #include <sys/ioctl.h>
  32 #include <errno.h>
  33 #include <string.h>
  34
  35 #include "libinternal.h"
  36
  37 INTERNAL int __comedi_init=0;
  38
  39 INTERNAL void initialize(void)
  40 {
  41         char *s;
  42
  43         __comedi_init=1;
  44
  45         if( (s=getenv("COMEDILIB_LOGLEVEL")) ){
  46                 __comedi_loglevel=strtol(s,NULL,0);
  47                 COMEDILIB_DEBUG(3,"setting loglevel to %d\n",__comedi_loglevel);
  48         }
  49 }
  50
  51 EXPORT_ALIAS_DEFAULT(_comedi_open,comedi_open,0.7.18);
  52 comedi_t* _comedi_open(const char *fn)
  53 {
  54         comedi_t *it;
  55
  56         if(!__comedi_init)
  57                 initialize();
  58
  59         if(!(it=malloc(sizeof(comedi_t))))
  60                 goto cleanup;
  61         memset(it,0,sizeof(comedi_t));
  62
  63         if((it->fd=open(fn,O_RDWR))<0){
  64                 libc_error();
  65                 goto cleanup;
  66         }
  67
  68         if(comedi_ioctl(it->fd, COMEDI_DEVINFO, &it->devinfo) < 0)
  69                 goto cleanup;
  70
  71         it->n_subdevices=it->devinfo.n_subdevs;
  72
  73         if(get_subdevices(it) < 0)
  74                 goto cleanup;
  75
  76         it->magic=COMEDILIB_MAGIC;
  77
  78         return it;
  79 cleanup:
  80         if(it)
  81                 free(it);
  82
  83         return NULL;
  84 }
  85
  86 EXPORT_ALIAS_DEFAULT(_comedi_close,comedi_close,0.7.18);
  87 int _comedi_close(comedi_t *it)
  88 {
  89         subdevice *s;
  90         int i,j;
  91
  92         if(!valid_dev(it))
  93                 return -1;
  94         it->magic=0;
  95
  96         for(i=0;i<it->n_subdevices;i++){
  97                 s=it->subdevices+i;
  98                 if(s->type==COMEDI_SUBD_UNUSED)
  99                         continue;
 100
 101                 if(s->subd_flags&SDF_FLAGS){
 102                         free(s->flags_list);
 103                 }
 104                 if(s->subd_flags&SDF_MAXDATA){
 105                         free(s->maxdata_list);
 106                 }
 107                 if(s->subd_flags&SDF_RANGETYPE){
 108                         free(s->range_type_list);
 109                         for(j=0;j<s->n_chan;j++)
 110                                 free(s->rangeinfo_list[j]);
 111                         free(s->rangeinfo_list);
 112                 }else{
 113                         free(s->rangeinfo);
 114                 }
 115                 if(s->cmd_mask)free(s->cmd_mask);
 116                 if(s->cmd_timed)free(s->cmd_timed);
 117         }
 118         if(it->subdevices){
 119                 free(it->subdevices);
 120         }
 121         close(it->fd);
 122         free(it);
 123         return 0;
 124 }
 125
 126 EXPORT_ALIAS_DEFAULT(_comedi_cancel,comedi_cancel,0.7.18);
 127 int _comedi_cancel(comedi_t *it,unsigned int subdevice)
 128 {
 129         if(!valid_dev(it)) return -1;
 130         return comedi_ioctl(it->fd, COMEDI_CANCEL, (void*)(unsigned long)subdevice);
 131 }
 132
 133 EXPORT_ALIAS_DEFAULT(_comedi_poll,comedi_poll,0.7.18);
 134 int _comedi_poll(comedi_t *it,unsigned int subdevice)
 135 {
 136         if(!valid_dev(it)) return -1;
 137         return comedi_ioctl(it->fd, COMEDI_POLL, (void*)(unsigned long)subdevice);
 138 }
 139
 140 EXPORT_ALIAS_DEFAULT(_comedi_fileno,comedi_fileno,0.7.18);
 141 int _comedi_fileno(comedi_t *it)
 142 {
 143         if(!valid_dev(it)) return -1;
 144         return it->fd;
 145 }
 146
 147 EXPORT_ALIAS_DEFAULT(_comedi_trigger,comedi_trigger,0.7.18);
 148 int _comedi_trigger(comedi_t *it,comedi_trig *t)
 149 {
 150         if(!valid_dev(it) || !t)
 151                 return -1;
 152
 153         return comedi_ioctl(it->fd, COMEDI_TRIG, t);
 154 }
 155
 156 EXPORT_ALIAS_DEFAULT(_comedi_command,comedi_command,0.7.18);
 157 int _comedi_command(comedi_t *it,comedi_cmd *t)
 158 {
 159         int ret;
 160         if(!valid_dev(it)) return -1;
 161         ret = comedi_ioctl(it->fd, COMEDI_CMD, t);
 162         __comedi_errno = errno;
 163         switch(__comedi_errno){
 164         case EIO:
 165                 __comedi_errno = ECMDNOTSUPP;
 166                 break;
 167         }
 168         return ret;
 169 }
 170
 171 EXPORT_ALIAS_DEFAULT(_comedi_command_test,comedi_command_test,0.7.18);
 172 int _comedi_command_test(comedi_t *it,comedi_cmd *t)
 173 {
 174         int ret;
 175         if(!valid_dev(it)) return -1;
 176         ret = comedi_ioctl(it->fd, COMEDI_CMDTEST, t);
 177         __comedi_errno = errno;
 178         switch(__comedi_errno){
 179         case EIO:
 180                 __comedi_errno = ECMDNOTSUPP;
 181                 break;
 182         }
 183         return ret;
 184 }
 185
 186 EXPORT_ALIAS_DEFAULT(_comedi_do_insnlist,comedi_do_insnlist,0.7.18);
 187 int _comedi_do_insnlist(comedi_t *it,comedi_insnlist *il)
 188 {
 189         int ret;
 190         if(!valid_dev(it)) return -1;
 191         ret = comedi_ioctl(it->fd, COMEDI_INSNLIST, il);
 192         __comedi_errno = errno;
 193         return ret;
 194 }
 195
 196 EXPORT_ALIAS_DEFAULT(_comedi_do_insn,comedi_do_insn,0.7.18);
 197 int _comedi_do_insn(comedi_t *it,comedi_insn *insn)
 198 {
 199         if(!valid_dev(it)) return -1;
 200         if(it->has_insn_ioctl){
 201                 return comedi_ioctl(it->fd, COMEDI_INSN, insn);
 202         }else{
 203                 comedi_insnlist il;
 204                 int ret;
 205
 206                 il.n_insns = 1;
 207                 il.insns = insn;
 208
 209                 ret = comedi_ioctl(it->fd, COMEDI_INSNLIST, &il);
 210
 211                 if(ret<0)return ret;
 212                 return insn->n;
 213         }
 214 }
 215
 216 EXPORT_ALIAS_DEFAULT(_comedi_lock,comedi_lock,0.7.18);
 217 int _comedi_lock(comedi_t *it,unsigned int subdevice)
 218 {
 219         if(!valid_dev(it)) return -1;
 220         return comedi_ioctl(it->fd, COMEDI_LOCK, (void*)(unsigned long)subdevice);
 221 }
 222
 223 EXPORT_ALIAS_DEFAULT(_comedi_unlock,comedi_unlock,0.7.18);
 224 int _comedi_unlock(comedi_t *it,unsigned int subdevice)
 225 {
 226         if(!valid_dev(it)) return -1;
 227         return comedi_ioctl(it->fd, COMEDI_UNLOCK, (void*)(unsigned long)subdevice);
 228 }
 229