Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/drivers/staging/comedi/drivers/c6xdigio.c

  1 /*
  2  * c6xdigio.c
  3  * Hardware driver for Mechatronic Systems Inc. C6x_DIGIO DSP daughter card.
  4  * http://web.archive.org/web/%2A/http://robot0.ge.uiuc.edu/~spong/mecha/
  5  *
  6  * COMEDI - Linux Control and Measurement Device Interface
  7  * Copyright (C) 1999 Dan Block
  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 /*
 21  * Driver: c6xdigio
 22  * Description: Mechatronic Systems Inc. C6x_DIGIO DSP daughter card
 23  * Author: Dan Block
 24  * Status: unknown
 25  * Devices: (Mechatronic Systems Inc.) C6x_DIGIO DSP daughter card [c6xdigio]
 26  * Updated: Sun Nov 20 20:18:34 EST 2005
 27  *
 28  * Configuration Options:
 29  *      [0] - base address
 30  */
 31 
 32 #include <linux/kernel.h>
 33 #include <linux/module.h>
 34 #include <linux/sched.h>
 35 #include <linux/mm.h>
 36 #include <linux/errno.h>
 37 #include <linux/interrupt.h>
 38 #include <linux/timex.h>
 39 #include <linux/timer.h>
 40 #include <linux/io.h>
 41 #include <linux/pnp.h>
 42 
 43 #include "../comedidev.h"
 44 
 45 /*
 46  * Register I/O map
 47  */
 48 #define C6XDIGIO_DATA_REG       0x00
 49 #define C6XDIGIO_DATA_CHAN(x)   (((x) + 1) << 4)
 50 #define C6XDIGIO_DATA_PWM       (1 << 5)
 51 #define C6XDIGIO_DATA_ENCODER   (1 << 6)
 52 #define C6XDIGIO_STATUS_REG     0x01
 53 #define C6XDIGIO_CTRL_REG       0x02
 54 
 55 #define C6XDIGIO_TIME_OUT 20
 56 
 57 static int c6xdigio_chk_status(struct comedi_device *dev, unsigned long context)
 58 {
 59         unsigned int status;
 60         int timeout = 0;
 61 
 62         do {
 63                 status = inb(dev->iobase + C6XDIGIO_STATUS_REG);
 64                 if ((status & 0x80) != context)
 65                         return 0;
 66                 timeout++;
 67         } while  (timeout < C6XDIGIO_TIME_OUT);
 68 
 69         return -EBUSY;
 70 }
 71 
 72 static int c6xdigio_write_data(struct comedi_device *dev,
 73                                unsigned int val, unsigned int status)
 74 {
 75         outb_p(val, dev->iobase + C6XDIGIO_DATA_REG);
 76         return c6xdigio_chk_status(dev, status);
 77 }
 78 
 79 static int c6xdigio_get_encoder_bits(struct comedi_device *dev,
 80                                      unsigned int *bits,
 81                                      unsigned int cmd,
 82                                      unsigned int status)
 83 {
 84         unsigned int val;
 85 
 86         val = inb(dev->iobase + C6XDIGIO_STATUS_REG);
 87         val >>= 3;
 88         val &= 0x07;
 89 
 90         *bits = val;
 91 
 92         return c6xdigio_write_data(dev, cmd, status);
 93 }
 94 
 95 static void c6xdigio_pwm_write(struct comedi_device *dev,
 96                                unsigned int chan, unsigned int val)
 97 {
 98         unsigned int cmd = C6XDIGIO_DATA_PWM | C6XDIGIO_DATA_CHAN(chan);
 99         unsigned int bits;
100 
101         if (val > 498)
102                 val = 498;
103         if (val < 2)
104                 val = 2;
105 
106         bits = (val >> 0) & 0x03;
107         c6xdigio_write_data(dev, cmd | bits | (0 << 2), 0x00);
108         bits = (val >> 2) & 0x03;
109         c6xdigio_write_data(dev, cmd | bits | (1 << 2), 0x80);
110         bits = (val >> 4) & 0x03;
111         c6xdigio_write_data(dev, cmd | bits | (0 << 2), 0x00);
112         bits = (val >> 6) & 0x03;
113         c6xdigio_write_data(dev, cmd | bits | (1 << 2), 0x80);
114         bits = (val >> 8) & 0x03;
115         c6xdigio_write_data(dev, cmd | bits | (0 << 2), 0x00);
116 
117         c6xdigio_write_data(dev, 0x00, 0x80);
118 }
119 
120 static int c6xdigio_encoder_read(struct comedi_device *dev,
121                                  unsigned int chan)
122 {
123         unsigned int cmd = C6XDIGIO_DATA_ENCODER | C6XDIGIO_DATA_CHAN(chan);
124         unsigned int val = 0;
125         unsigned int bits;
126 
127         c6xdigio_write_data(dev, cmd, 0x00);
128 
129         c6xdigio_get_encoder_bits(dev, &bits, cmd | (1 << 2), 0x80);
130         val |= (bits << 0);
131 
132         c6xdigio_get_encoder_bits(dev, &bits, cmd | (0 << 2), 0x00);
133         val |= (bits << 3);
134 
135         c6xdigio_get_encoder_bits(dev, &bits, cmd | (1 << 2), 0x80);
136         val |= (bits << 6);
137 
138         c6xdigio_get_encoder_bits(dev, &bits, cmd | (0 << 2), 0x00);
139         val |= (bits << 9);
140 
141         c6xdigio_get_encoder_bits(dev, &bits, cmd | (1 << 2), 0x80);
142         val |= (bits << 12);
143 
144         c6xdigio_get_encoder_bits(dev, &bits, cmd | (0 << 2), 0x00);
145         val |= (bits << 15);
146 
147         c6xdigio_get_encoder_bits(dev, &bits, cmd | (1 << 2), 0x80);
148         val |= (bits << 18);
149 
150         c6xdigio_get_encoder_bits(dev, &bits, cmd | (0 << 2), 0x00);
151         val |= (bits << 21);
152 
153         c6xdigio_write_data(dev, 0x00, 0x80);
154 
155         return val;
156 }
157 
158 static int c6xdigio_pwm_insn_write(struct comedi_device *dev,
159                                    struct comedi_subdevice *s,
160                                    struct comedi_insn *insn,
161                                    unsigned int *data)
162 {
163         unsigned int chan = CR_CHAN(insn->chanspec);
164         unsigned int val = (s->state >> (16 * chan)) & 0xffff;
165         int i;
166 
167         for (i = 0; i < insn->n; i++) {
168                 val = data[i];
169                 c6xdigio_pwm_write(dev, chan, val);
170         }
171 
172         /*
173          * There are only 2 PWM channels and they have a maxdata of 500.
174          * Instead of allocating private data to save the values in for
175          * readback this driver just packs the values for the two channels
176          * in the s->state.
177          */
178         s->state &= (0xffff << (16 * chan));
179         s->state |= (val << (16 * chan));
180 
181         return insn->n;
182 }
183 
184 static int c6xdigio_pwm_insn_read(struct comedi_device *dev,
185                                   struct comedi_subdevice *s,
186                                   struct comedi_insn *insn,
187                                   unsigned int *data)
188 {
189         unsigned int chan = CR_CHAN(insn->chanspec);
190         unsigned int val;
191         int i;
192 
193         val = (s->state >> (16 * chan)) & 0xffff;
194 
195         for (i = 0; i < insn->n; i++)
196                 data[i] = val;
197 
198         return insn->n;
199 }
200 
201 static int c6xdigio_encoder_insn_read(struct comedi_device *dev,
202                                       struct comedi_subdevice *s,
203                                       struct comedi_insn *insn,
204                                       unsigned int *data)
205 {
206         unsigned int chan = CR_CHAN(insn->chanspec);
207         unsigned int val;
208         int i;
209 
210         for (i = 0; i < insn->n; i++) {
211                 val = c6xdigio_encoder_read(dev, chan);
212 
213                 /* munge two's complement value to offset binary */
214                 data[i] = comedi_offset_munge(s, val);
215         }
216 
217         return insn->n;
218 }
219 
220 static void c6xdigio_init(struct comedi_device *dev)
221 {
222         /* Initialize the PWM */
223         c6xdigio_write_data(dev, 0x70, 0x00);
224         c6xdigio_write_data(dev, 0x74, 0x80);
225         c6xdigio_write_data(dev, 0x70, 0x00);
226         c6xdigio_write_data(dev, 0x00, 0x80);
227 
228         /* Reset the encoders */
229         c6xdigio_write_data(dev, 0x68, 0x00);
230         c6xdigio_write_data(dev, 0x6c, 0x80);
231         c6xdigio_write_data(dev, 0x68, 0x00);
232         c6xdigio_write_data(dev, 0x00, 0x80);
233 }
234 
235 static const struct pnp_device_id c6xdigio_pnp_tbl[] = {
236         /* Standard LPT Printer Port */
237         {.id = "PNP0400", .driver_data = 0},
238         /* ECP Printer Port */
239         {.id = "PNP0401", .driver_data = 0},
240         {}
241 };
242 
243 static struct pnp_driver c6xdigio_pnp_driver = {
244         .name = "c6xdigio",
245         .id_table = c6xdigio_pnp_tbl,
246 };
247 
248 static int c6xdigio_attach(struct comedi_device *dev,
249                            struct comedi_devconfig *it)
250 {
251         struct comedi_subdevice *s;
252         int ret;
253 
254         ret = comedi_request_region(dev, it->options[0], 0x03);
255         if (ret)
256                 return ret;
257 
258         ret = comedi_alloc_subdevices(dev, 2);
259         if (ret)
260                 return ret;
261 
262         /*  Make sure that PnP ports get activated */
263         pnp_register_driver(&c6xdigio_pnp_driver);
264 
265         s = &dev->subdevices[0];
266         /* pwm output subdevice */
267         s->type         = COMEDI_SUBD_PWM;
268         s->subdev_flags = SDF_WRITEABLE;
269         s->n_chan       = 2;
270         s->maxdata      = 500;
271         s->range_table  = &range_unknown;
272         s->insn_write   = c6xdigio_pwm_insn_write;
273         s->insn_read    = c6xdigio_pwm_insn_read;
274 
275         s = &dev->subdevices[1];
276         /* encoder (counter) subdevice */
277         s->type         = COMEDI_SUBD_COUNTER;
278         s->subdev_flags = SDF_READABLE | SDF_LSAMPL;
279         s->n_chan       = 2;
280         s->maxdata      = 0xffffff;
281         s->range_table  = &range_unknown;
282         s->insn_read    = c6xdigio_encoder_insn_read;
283 
284         /*  I will call this init anyway but more than likely the DSP board */
285         /*  will not be connected when device driver is loaded. */
286         c6xdigio_init(dev);
287 
288         return 0;
289 }
290 
291 static void c6xdigio_detach(struct comedi_device *dev)
292 {
293         comedi_legacy_detach(dev);
294         pnp_unregister_driver(&c6xdigio_pnp_driver);
295 }
296 
297 static struct comedi_driver c6xdigio_driver = {
298         .driver_name    = "c6xdigio",
299         .module         = THIS_MODULE,
300         .attach         = c6xdigio_attach,
301         .detach         = c6xdigio_detach,
302 };
303 module_comedi_driver(c6xdigio_driver);
304 
305 MODULE_AUTHOR("Comedi http://www.comedi.org");
306 MODULE_DESCRIPTION("Comedi driver for the C6x_DIGIO DSP daughter card");
307 MODULE_LICENSE("GPL");
308 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us