comedi/drivers/serial2002.c

   1 /*
   2     comedi/drivers/serial2002.c
   3     Skeleton code for a Comedi driver
   4
   5     COMEDI - Linux Control and Measurement Device Interface
   6     Copyright (C) 2002 Anders Blomdell <anders.blomdell@control.lth.se>
   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 /*
  25 Driver: serial2002.o
  26 Description: Driver for serial connected hardware
  27 Devices:
  28 Author: Anders Blomdell
  29 Updated: Fri,  7 Jun 2002 12:56:45 -0700
  30 Status: in development
  31
  32 */
  33
  34 #include <linux/comedidev.h>
  35
  36 #include <linux/delay.h>
  37 #include <linux/ioport.h>
  38
  39 #include <asm/termios.h>
  40 #include <asm/ioctls.h>
  41 #include <linux/serial.h>
  42 #include <linux/poll.h>
  43
  44 /*
  45  * Board descriptions for two imaginary boards.  Describing the
  46  * boards in this way is optional, and completely driver-dependent.
  47  * Some drivers use arrays such as this, other do not.
  48  */
  49 typedef struct serial2002_board_struct {
  50         char *name;
  51 } serial2002_board;
  52
  53 serial2002_board serial2002_boards[] = {
  54   {
  55     name:               "serial2002"
  56   }
  57 };
  58 /*
  59  * Useful for shorthand access to the particular board structure
  60  */
  61 #define thisboard ((serial2002_board *)dev->board_ptr)
  62
  63 typedef struct {
  64   // HACK...
  65   int length;
  66   comedi_krange range;
  67 } serial2002_range_table_t;
  68
  69 typedef struct {
  70   int port;             // /dev/ttyS<port>
  71   int speed;            // baudrate
  72   struct file *tty;
  73   lsampl_t ao_readback[32];
  74   unsigned char digital_in_mapping[32];
  75   unsigned char digital_out_mapping[32];
  76   unsigned char analog_in_mapping[32];
  77   unsigned char analog_out_mapping[32];
  78   unsigned char encoder_in_mapping[32];
  79   serial2002_range_table_t in_range[32], out_range[32];
  80 } serial2002_private;
  81
  82 /*
  83  * most drivers define the following macro to make it easy to
  84  * access the private structure.
  85  */
  86 #define devpriv ((serial2002_private *)dev->private)
  87
  88 static int serial2002_attach(comedi_device *dev,comedi_devconfig *it);
  89 static int serial2002_detach(comedi_device *dev);
  90 comedi_driver driver_serial2002={
  91         driver_name:    "serial2002",
  92         module:         THIS_MODULE,
  93         attach:         serial2002_attach,
  94         detach:         serial2002_detach,
  95         board_name:     serial2002_boards,
  96         offset:         sizeof(serial2002_board),
  97         num_names:      sizeof(serial2002_boards) / sizeof(serial2002_board),
  98 };
  99
 100 static int serial2002_di_rinsn(comedi_device *dev, comedi_subdevice *s,
 101                                comedi_insn *insn, lsampl_t *data);
 102 static int serial2002_do_winsn(comedi_device *dev, comedi_subdevice *s,
 103                                comedi_insn *insn, lsampl_t *data);
 104 static int serial2002_ai_rinsn(comedi_device *dev, comedi_subdevice *s,
 105                                comedi_insn *insn,lsampl_t *data);
 106 static int serial2002_ao_winsn(comedi_device *dev, comedi_subdevice *s,
 107                                comedi_insn *insn, lsampl_t *data);
 108 static int serial2002_ao_rinsn(comedi_device *dev, comedi_subdevice *s,
 109                                comedi_insn *insn, lsampl_t *data);
 110
 111 struct serial_data {
 112   enum { is_invalid, is_digital, is_channel } kind;
 113   int index;
 114   unsigned long value;
 115 };
 116
 117 static int tty_write(struct file *f, unsigned char *buf, int count) {
 118   int result;
 119   mm_segment_t oldfs;
 120
 121   oldfs = get_fs();
 122   set_fs(KERNEL_DS);
 123   f->f_pos = 0;
 124   result = f->f_op->write(f, buf, count, &f->f_pos);
 125   set_fs(oldfs);
 126   return result;
 127 }
 128
 129
 130 static int tty_available(struct file *f)
 131 {
 132   long result = 0;
 133   mm_segment_t oldfs;
 134
 135   oldfs = get_fs();
 136   set_fs(KERNEL_DS);
 137   f->f_op->ioctl(f->f_dentry->d_inode, f, FIONREAD, (int)&result);
 138   set_fs(oldfs);
 139   return result;
 140 }
 141
 142 static int tty_read(struct file *f, int timeout)
 143 {
 144   int result;
 145
 146   result = -1;
 147   if (!IS_ERR(f)) {
 148     mm_segment_t oldfs;
 149
 150     oldfs = get_fs();
 151     set_fs(KERNEL_DS);
 152     if (f->f_op->poll) {
 153       struct poll_wqueues table;
 154       struct timeval start, now;
 155
 156       do_gettimeofday(&start);
 157       poll_initwait(&table);
 158       while (1) {
 159         long elapsed;
 160         int mask;
 161
 162         mask = f->f_op->poll(f, &table.pt);
 163         if (mask & (POLLRDNORM|POLLRDBAND|POLLIN|POLLHUP|POLLERR)) { break; }
 164         do_gettimeofday(&now);
 165         elapsed = (1000000 * (now.tv_sec - start.tv_sec) +
 166                    now.tv_usec - start.tv_usec);
 167         if (elapsed > timeout) { break; }
 168         set_current_state(TASK_INTERRUPTIBLE);
 169         schedule_timeout(((timeout - elapsed)* HZ) / 10000);
 170       }
 171       poll_freewait(&table);
 172     } else {
 173       /* Device does not support poll, busy wait */
 174       int retries = 0;
 175       while (1) {
 176       retries++;
 177         if (retries >= timeout) { break; }
 178         if (tty_available(f) > 0) { break; }
 179         comedi_udelay(100);
 180       }
 181     }
 182       if (tty_available(f) > 0) {
 183         unsigned char ch;
 184
 185         f->f_pos = 0;
 186       if (f->f_op->read(f, &ch, 1, &f->f_pos) == 1) {
 187         result = ch;
 188       }
 189     }
 190     set_fs(oldfs);
 191   }
 192   return result;
 193 }
 194
 195 static void tty_setspeed(struct file *f, int speed)
 196 {
 197   mm_segment_t        oldfs;
 198
 199   oldfs = get_fs();
 200   set_fs(KERNEL_DS);
 201   {
 202     // Set speed
 203     struct termios settings;
 204
 205     f->f_op->ioctl(f->f_dentry->d_inode, f, TCGETS, (int)&settings);
 206 //    printk("Speed: %d\n", settings.c_cflag & (CBAUD | CBAUDEX));
 207     settings.c_iflag = 0;
 208     settings.c_oflag = 0;
 209     settings.c_lflag = 0;
 210     settings.c_cflag = CLOCAL | CS8 | CREAD;
 211     settings.c_cc[VMIN] = 1;
 212     settings.c_cc[VTIME] = 0;
 213     switch (speed) {
 214       case   2400: { settings.c_cflag |=   B2400; } break;
 215       case   4800: { settings.c_cflag |=   B4800; } break;
 216       case   9600: { settings.c_cflag |=   B9600; } break;
 217       case  19200: { settings.c_cflag |=  B19200; } break;
 218       case  38400: { settings.c_cflag |=  B38400; } break;
 219       case  57600: { settings.c_cflag |=  B57600; } break;
 220       case 115200: { settings.c_cflag |= B115200; } break;
 221       default:     { settings.c_cflag |=   B9600; } break;
 222     }
 223     f->f_op->ioctl(f->f_dentry->d_inode, f, TCSETS, (int)&settings);
 224 //    printk("Speed: %d\n", settings.c_cflag & (CBAUD | CBAUDEX));
 225   }
 226   {
 227     // Set low latency
 228     struct serial_struct settings;
 229     f->f_op->ioctl(f->f_dentry->d_inode, f, TIOCGSERIAL, (int)&settings);
 230     settings.flags |= ASYNC_LOW_LATENCY;
 231     f->f_op->ioctl(f->f_dentry->d_inode, f, TIOCSSERIAL, (int)&settings);
 232   }
 233
 234   set_fs(oldfs);
 235 }
 236
 237 static void poll_digital(struct file *f, int channel) {
 238   char cmd;
 239
 240   cmd = 0x40 | (channel & 0x1f);
 241   tty_write(f, &cmd, 1);
 242 }
 243
 244 static void poll_channel(struct file *f, int channel) {
 245   char cmd;
 246
 247   cmd = 0x60 | (channel & 0x1f);
 248   tty_write(f, &cmd, 1);
 249 }
 250
 251 static struct serial_data serial_read(struct file *f, int timeout)
 252 {
 253   struct serial_data result;
 254   int length;
 255
 256   result.kind = is_invalid;
 257   result.index = 0;
 258   result.value = 0;
 259   length = 0;
 260   while (1) {
 261     int data = tty_read(f, timeout);
 262
 263     length++;
 264     if (data < 0) {
 265       printk("serial2002 error\n");
 266       break;
 267     } else if (data & 0x80) {
 268       result.value = (result.value << 7) | (data & 0x7f);
 269     } else {
 270       if (length == 1) {
 271         switch ((data>>5) & 0x03) {
 272           case 0: { result.value = 0; result.kind = is_digital; } break;
 273           case 1: { result.value = 1; result.kind = is_digital; } break;
 274         }
 275       } else {
 276         result.value = (result.value << 2) | ((data & 0x60) >> 5);
 277         result.kind = is_channel;
 278       }
 279       result.index = data & 0x1f;
 280       break;
 281     }
 282   }
 283   return result;
 284
 285 }
 286
 287 static void serial_write(struct file *f, struct serial_data data)
 288 {
 289   if (data.kind == is_digital) {
 290     unsigned char ch = ((data.value<<5) & 0x20) | (data.index & 0x1f);
 291     tty_write(f, &ch, 1);
 292   } else {
 293     unsigned char ch[6];
 294     int i = 0;
 295     if (data.value >= (1L<<30)) { ch[i] =  0x80|((data.value>>30)&0x03); i++; }
 296     if (data.value >= (1L<<23)) { ch[i] =  0x80|((data.value>>23)&0x7f); i++; }
 297     if (data.value >= (1L<<16)) { ch[i] =  0x80|((data.value>>16)&0x7f); i++; }
 298     if (data.value >= (1L<< 9)) { ch[i] =  0x80|((data.value>> 9)&0x7f); i++; }
 299     ch[i] =  0x80|((data.value>> 2)&0x7f); i++;
 300     ch[i] =  ((data.value<< 5)&0x60)|(data.index & 0x1f); i++;
 301     tty_write(f, ch, i);
 302   }
 303 }
 304
 305 static void serial_2002_open(comedi_device *dev) {
 306   char port[20];
 307
 308   sprintf(port, "/dev/ttyS%d", devpriv->port);
 309   devpriv->tty = filp_open(port, 0, O_RDWR);
 310   if (IS_ERR(devpriv->tty)) {
 311     printk("serial_2002: file open error = %x\n", (int)devpriv->tty);
 312   } else {
 313     typedef struct {
 314       int kind;
 315       int bits;
 316       int min;
 317       int max;
 318     } config_t;
 319     config_t dig_in_config[32];
 320     config_t dig_out_config[32];
 321     config_t chan_in_config[32];
 322     config_t chan_out_config[32];
 323     int i;
 324
 325     for (i = 0 ; i < 32 ; i++) {
 326       dig_in_config[i].kind = 0; dig_in_config[i].bits = 0;
 327       dig_in_config[i].min = 0; dig_in_config[i].max = 0;
 328       dig_out_config[i].kind = 0; dig_out_config[i].bits = 0;
 329       dig_out_config[i].min = 0; dig_out_config[i].max = 0;
 330       chan_in_config[i].kind = 0; chan_in_config[i].bits = 0;
 331       chan_in_config[i].min = 0; chan_in_config[i].max = 0;
 332       chan_out_config[i].kind = 0; chan_out_config[i].bits = 0;
 333       chan_out_config[i].min = 0; chan_out_config[i].max = 0;
 334     }
 335
 336     tty_setspeed(devpriv->tty, devpriv->speed);
 337     poll_channel(devpriv->tty, 31); // Start reading configuration
 338     while (1) {
 339       struct serial_data data;
 340
 341       data = serial_read(devpriv->tty, 1000);
 342       if (data.kind!=is_channel || data.index!=31 || !(data.value & 0xe0)) {
 343         break;
 344       } else {
 345         int command, channel, kind;
 346         config_t *cur_config = 0;
 347
 348         channel = data.value & 0x1f;
 349         kind = (data.value>>5) & 0x7;
 350         command = (data.value>>8) & 0x3;
 351         switch (kind) {
 352           case 1: { cur_config = dig_in_config; } break;
 353           case 2: { cur_config = dig_out_config; } break;
 354           case 3: { cur_config = chan_in_config; } break;
 355           case 4: { cur_config = chan_out_config; } break;
 356           case 5: { cur_config = chan_in_config; } break;
 357         }
 358
 359         if (cur_config) {
 360           cur_config[channel].kind = kind;
 361           switch (command) {
 362             case 0: {
 363               cur_config[channel].bits = (data.value >> 10) & 0x3f;
 364             } break;
 365             case 1: {
 366               int unit, sign, min;
 367               unit = (data.value >> 10) & 0x7;
 368               sign = (data.value >> 13) & 0x1;
 369               min = (data.value >> 14) & 0xfffff;
 370
 371               switch (unit) {
 372                 case 0: { min = min * 1000000; } break;
 373                 case 1: { min = min * 1000; } break;
 374                 case 2: { min = min * 1; } break;
 375               }
 376               if (sign) { min = -min; }
 377               cur_config[channel].min = min;
 378             } break;
 379             case 2: {
 380               int unit, sign, max;
 381               unit = (data.value >> 10) & 0x7;
 382               sign = (data.value >> 13) & 0x1;
 383               max = (data.value >> 14) & 0xfffff;
 384
 385               switch (unit) {
 386                 case 0: { max = max * 1000000; } break;
 387                 case 1: { max = max * 1000; } break;
 388                 case 2: { max = max * 1; } break;
 389               }
 390               if (sign) { max = -max; }
 391               cur_config[channel].max = max;
 392             } break;
 393           }
 394         }
 395       }
 396     }
 397     for (i = 0 ; i <= 4 ; i++) {
 398       // Fill in subdev data
 399       config_t *c;
 400       unsigned char *mapping = 0;
 401       serial2002_range_table_t *range = 0;
 402       int kind = 0;
 403
 404       switch (i) {
 405         case  0: {
 406           c = dig_in_config;
 407           mapping = devpriv->digital_in_mapping;
 408           kind = 1;
 409         } break;
 410         case  1: {
 411           c = dig_out_config;
 412           mapping = devpriv->digital_out_mapping;
 413           kind = 2;
 414         } break;
 415         case  2: {
 416           c = chan_in_config;
 417           mapping = devpriv->analog_in_mapping;
 418           range = devpriv->in_range;
 419           kind = 3;
 420         } break;
 421         case  3: {
 422           c = chan_out_config;
 423           mapping = devpriv->analog_out_mapping;
 424           range = devpriv->out_range;
 425           kind = 4;
 426         } break;
 427         case  4: {
 428           c = chan_in_config;
 429           mapping = devpriv->encoder_in_mapping;
 430           range = devpriv->in_range;
 431           kind = 5;
 432         } break;
 433         default: { c = 0; } break;
 434       }
 435       if (c) {
 436         comedi_subdevice *s;
 437         int j, chan;
 438
 439         for (chan = 0, j = 0 ; j < 32 ; j++) {
 440           if (c[j].kind == kind) { chan++; }
 441         }
 442         s = &dev->subdevices[i];
 443         s->n_chan = chan;
 444         s->maxdata = 0;
 445         if (s->maxdata_list) { kfree(s->maxdata_list); }
 446         s->maxdata_list = kmalloc(sizeof(lsampl_t)*s->n_chan, GFP_KERNEL);
 447         if (s->range_table_list) { kfree(s->range_table_list); }
 448         if (range) {
 449           s->range_table = 0;
 450           s->range_table_list =
 451             kmalloc(sizeof(serial2002_range_table_t)*s->n_chan, GFP_KERNEL);
 452         }
 453         for (chan = 0, j = 0 ; j < 32 ; j++) {
 454           if (c[j].kind == kind) {
 455             if (mapping) { mapping[chan] = j; }
 456             if (range) {
 457               range[j].length = 1;
 458               range[j].range.min = c[j].min;
 459               range[j].range.max = c[j].max;
 460               s->range_table_list[chan] = (comedi_lrange*)&range[j];
 461             }
 462             s->maxdata_list[chan] = ((long long)1<<c[j].bits) - 1;
 463             chan++;
 464           }
 465         }
 466       }
 467     }
 468   }
 469 }
 470
 471 static void serial_2002_close(comedi_device *dev) {
 472   if (!IS_ERR(devpriv->tty) && (devpriv->tty != 0)) {
 473     filp_close(devpriv->tty, 0);
 474   }
 475 }
 476
 477 static int serial2002_di_rinsn(comedi_device *dev, comedi_subdevice *s,
 478                                comedi_insn *insn, lsampl_t *data)
 479 {
 480   int n;
 481   int chan;
 482
 483   chan = devpriv->digital_in_mapping[CR_CHAN(insn->chanspec)];
 484   for(n = 0 ; n < insn->n ; n++){
 485     struct serial_data read;
 486
 487     poll_digital(devpriv->tty, chan);
 488     while (1) {
 489       read = serial_read(devpriv->tty, 1000);
 490       if (read.kind != is_digital || read.index == chan) { break; }
 491     }
 492     data[n] = read.value;
 493   }
 494   return n;
 495 }
 496
 497 static int serial2002_do_winsn(comedi_device *dev, comedi_subdevice *s,
 498                                comedi_insn *insn, lsampl_t *data)
 499 {
 500   int n;
 501   int chan;
 502
 503   chan = devpriv->digital_out_mapping[CR_CHAN(insn->chanspec)];
 504   for(n = 0 ; n < insn->n ; n++){
 505     struct serial_data write;
 506
 507     write.kind = is_digital;
 508     write.index = chan;
 509     write.value = data[n];
 510     serial_write(devpriv->tty, write);
 511   }
 512   return n;
 513 }
 514
 515 static int serial2002_ai_rinsn(comedi_device *dev, comedi_subdevice *s,
 516                                comedi_insn *insn, lsampl_t *data)
 517 {
 518   int n;
 519   int chan;
 520
 521   chan = devpriv->analog_in_mapping[CR_CHAN(insn->chanspec)];
 522   for(n = 0 ; n < insn->n ; n++){
 523     struct serial_data read;
 524
 525     poll_channel(devpriv->tty, chan);
 526     while (1) {
 527       read = serial_read(devpriv->tty, 1000);
 528       if (read.kind != is_channel || read.index == chan) { break; }
 529     }
 530     data[n] = read.value;
 531   }
 532   return n;
 533 }
 534
 535 static int serial2002_ao_winsn(comedi_device *dev, comedi_subdevice *s,
 536                                comedi_insn *insn,lsampl_t *data)
 537 {
 538   int n;
 539   int chan;
 540
 541   chan = devpriv->analog_out_mapping[CR_CHAN(insn->chanspec)];
 542   for(n = 0 ; n < insn->n ; n++){
 543     struct serial_data write;
 544
 545     write.kind = is_channel;
 546     write.index = chan;
 547     write.value = data[n];
 548     serial_write(devpriv->tty, write);
 549     devpriv->ao_readback[chan] = data[n];
 550   }
 551   return n;
 552 }
 553
 554 static int serial2002_ao_rinsn(comedi_device *dev, comedi_subdevice *s,
 555                                comedi_insn *insn,lsampl_t *data)
 556 {
 557   int n;
 558   int chan = CR_CHAN(insn->chanspec);
 559
 560   for(n = 0; n < insn->n ; n++) {
 561     data[n] = devpriv->ao_readback[chan];
 562   }
 563
 564   return n;
 565 }
 566
 567 static int serial2002_ei_rinsn(comedi_device *dev, comedi_subdevice *s,
 568                                comedi_insn *insn, lsampl_t *data)
 569 {
 570   int n;
 571   int chan;
 572
 573   chan = devpriv->encoder_in_mapping[CR_CHAN(insn->chanspec)];
 574   for(n = 0 ; n < insn->n ; n++){
 575     struct serial_data read;
 576
 577     poll_channel(devpriv->tty, chan);
 578     while (1) {
 579       read = serial_read(devpriv->tty, 1000);
 580       if (read.kind != is_channel || read.index == chan) { break; }
 581     }
 582     data[n] = read.value;
 583   }
 584   return n;
 585 }
 586
 587 static int serial2002_attach(comedi_device *dev, comedi_devconfig *it)
 588 {
 589   comedi_subdevice *s;
 590
 591   printk("comedi%d: serial2002: ",dev->minor);
 592   dev->board_name = thisboard->name;
 593   if(alloc_private(dev,sizeof(serial2002_private)) < 0) {
 594     return -ENOMEM;
 595   }
 596   dev->open = serial_2002_open;
 597   dev->close = serial_2002_close;
 598   devpriv->port = it->options[0];
 599   devpriv->speed = it->options[1];
 600   printk("/dev/ttyS%d @ %d\n", devpriv->port, devpriv->speed);
 601
 602   if(alloc_subdevices(dev, 5)<0)
 603     return -ENOMEM;
 604
 605   /* digital input subdevice */
 606   s = dev->subdevices+0;
 607   s->type = COMEDI_SUBD_DI;
 608   s->subdev_flags = SDF_READABLE;
 609   s->n_chan = 0;
 610   s->maxdata = 1;
 611   s->range_table = &range_digital;
 612   s->insn_read = &serial2002_di_rinsn;
 613
 614   /* digital output subdevice */
 615   s = dev->subdevices+1;
 616   s->type = COMEDI_SUBD_DO;
 617   s->subdev_flags = SDF_WRITEABLE;
 618   s->n_chan = 0;
 619   s->maxdata = 1;
 620   s->range_table = &range_digital;
 621   s->insn_write = &serial2002_do_winsn;
 622
 623   /* analog input subdevice */
 624   s=dev->subdevices+2;
 625   s->type = COMEDI_SUBD_AI;
 626   s->subdev_flags = SDF_READABLE|SDF_GROUND;
 627   s->n_chan = 0;
 628   s->maxdata = 1;
 629   s->range_table = 0;
 630   s->insn_read = &serial2002_ai_rinsn;
 631
 632   /* analog output subdevice */
 633   s=dev->subdevices+3;
 634   s->type = COMEDI_SUBD_AO;
 635   s->subdev_flags = SDF_WRITEABLE;
 636   s->n_chan = 0;
 637   s->maxdata = 1;
 638   s->range_table = 0;
 639   s->insn_write = &serial2002_ao_winsn;
 640   s->insn_read = &serial2002_ao_rinsn;
 641
 642   /* encoder input subdevice */
 643   s=dev->subdevices+4;
 644   s->type = COMEDI_SUBD_COUNTER;
 645   s->subdev_flags = SDF_READABLE | SDF_LSAMPL;
 646   s->n_chan = 0;
 647   s->maxdata = 1;
 648   s->range_table = 0;
 649   s->insn_read = &serial2002_ei_rinsn;
 650
 651   printk("attached\n");
 652
 653   return 1;
 654 }
 655
 656
 657 static int serial2002_detach(comedi_device *dev)
 658 {
 659   comedi_subdevice *s;
 660   int i;
 661
 662   printk("comedi%d: serial2002: remove\n",dev->minor);
 663   for (i = 0 ; i < 4 ; i++) {
 664     s = &dev->subdevices[i];
 665     if (s->maxdata_list) { kfree(s->maxdata_list); }
 666     if (s->range_table_list) { kfree(s->range_table_list); }
 667   }
 668   return 0;
 669 }
 670
 671 COMEDI_INITCLEANUP(driver_serial2002);
 672
 673