2 comedi/drivers/ni_labpc_cs.c
3 Driver for National Instruments daqcard-1200 boards
4 Copyright (C) 2001, 2002, 2003 Frank Mori Hess <fmhess@users.sourceforge.net>
6 PCMCIA crap is adapted from dummy_cs.c 1.31 2001/08/24 12:13:13
7 from the pcmcia package.
8 The initial developer of the pcmcia dummy_cs.c code is David A. Hinds
9 <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
10 are Copyright (C) 1999 David A. Hinds.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 ************************************************************************
30 Description: National Instruments Lab-PC (& compatibles)
31 Author: Frank Mori Hess <fmhess@users.sourceforge.net>
32 Devices: [National Instruments] DAQCard-1200 (daqcard-1200)
35 Thanks go to Fredrik Lingvall for much testing and perseverance in
36 helping to debug daqcard-1200 support.
38 The 1200 series boards have onboard calibration dacs for correcting
39 analog input/output offsets and gains. The proper settings for these
40 caldacs are stored on the board's eeprom. To read the caldac values
41 from the eeprom and store them into a file that can be then be used by
42 comedilib, use the comedi_calibrate program.
44 Configuration options:
47 The daqcard-1200 has quirky chanlist requirements
48 when scanning multiple channels. Multiple channel scan
49 sequence must start at highest channel, then decrement down to
50 channel 0. Chanlists consisting of all one channel
51 are also legal, and allow you to pace conversions in bursts.
58 340988a (daqcard-1200)
63 //#define LABPC_DEBUG // enable debugging messages
65 #include "../comedidev.h"
67 #include <linux/delay.h>
71 #include "comedi_fc.h"
74 #include <pcmcia/cs_types.h>
75 #include <pcmcia/cs.h>
76 #include <pcmcia/cistpl.h>
77 #include <pcmcia/cisreg.h>
78 #include <pcmcia/ds.h>
80 static struct pcmcia_device *pcmcia_cur_dev = NULL;
82 static int labpc_attach(struct comedi_device * dev, struct comedi_devconfig * it);
84 static const labpc_board labpc_cs_boards[] = {
87 device_id:0x103, // 0x10b is manufacturer id, 0x103 is device id
89 bustype: pcmcia_bustype,
90 register_layout:labpc_1200_layout,
92 ai_range_table:&range_labpc_1200_ai,
93 ai_range_code:labpc_1200_ai_gain_bits,
94 ai_range_is_unipolar:labpc_1200_is_unipolar,
98 /* duplicate entry, to support using alternate name */
103 bustype: pcmcia_bustype,
104 register_layout:labpc_1200_layout,
106 ai_range_table:&range_labpc_1200_ai,
107 ai_range_code:labpc_1200_ai_gain_bits,
108 ai_range_is_unipolar:labpc_1200_is_unipolar,
115 * Useful for shorthand access to the particular board structure
117 #define thisboard ((const labpc_board *)dev->board_ptr)
119 static struct comedi_driver driver_labpc_cs = {
120 .driver_name = "ni_labpc_cs",
121 .module = THIS_MODULE,
122 .attach = &labpc_attach,
123 .detach = &labpc_common_detach,
124 .num_names = sizeof(labpc_cs_boards) / sizeof(labpc_board),
125 .board_name = &labpc_cs_boards[0].name,
126 .offset = sizeof(labpc_board),
129 static int labpc_attach(struct comedi_device * dev, struct comedi_devconfig * it)
131 unsigned long iobase = 0;
132 unsigned int irq = 0;
133 struct pcmcia_device *link;
135 /* allocate and initialize dev->private */
136 if (alloc_private(dev, sizeof(labpc_private)) < 0)
139 // get base address, irq etc. based on bustype
140 switch (thisboard->bustype) {
142 link = pcmcia_cur_dev; /* XXX hack */
145 iobase = link->io.BasePort1;
146 irq = link->irq.AssignedIRQ;
149 printk("bug! couldn't determine board type\n");
153 return labpc_common_attach(dev, iobase, irq, 0);
157 All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If
158 you do not define PCMCIA_DEBUG at all, all the debug code will be
159 left out. If you compile with PCMCIA_DEBUG=0, the debug code will
160 be present but disabled -- but it can then be enabled for specific
161 modules at load time with a 'pc_debug=#' option to insmod.
164 static int pc_debug = PCMCIA_DEBUG;
165 module_param(pc_debug, int, 0644);
166 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
167 static const char *version =
168 "ni_labpc.c, based on dummy_cs.c 1.31 2001/08/24 12:13:13";
170 #define DEBUG(n, args...)
173 /*====================================================================*/
176 The event() function is this driver's Card Services event handler.
177 It will be called by Card Services when an appropriate card status
178 event is received. The config() and release() entry points are
179 used to configure or release a socket, in response to card
180 insertion and ejection events. They are invoked from the dummy
183 Kernel version 2.6.16 upwards uses suspend() and resume() functions
184 instead of an event() function.
187 static void labpc_config(struct pcmcia_device *link);
188 static void labpc_release(struct pcmcia_device *link);
189 static int labpc_cs_suspend(struct pcmcia_device *p_dev);
190 static int labpc_cs_resume(struct pcmcia_device *p_dev);
193 The attach() and detach() entry points are used to create and destroy
194 "instances" of the driver, where each instance represents everything
195 needed to manage one actual PCMCIA card.
198 static int labpc_cs_attach(struct pcmcia_device *);
199 static void labpc_cs_detach(struct pcmcia_device *);
202 You'll also need to prototype all the functions that will actually
203 be used to talk to your device. See 'memory_cs' for a good example
204 of a fully self-sufficient driver; the other drivers rely more or
205 less on other parts of the kernel.
209 The dev_info variable is the "key" that is used to match up this
210 device driver with appropriate cards, through the card configuration
214 static const dev_info_t dev_info = "daqcard-1200";
216 typedef struct local_info_t {
217 struct pcmcia_device *link;
220 struct bus_operations *bus;
223 /*======================================================================
225 labpc_cs_attach() creates an "instance" of the driver, allocating
226 local data structures for one device. The device is registered
229 The dev_link structure is initialized, but we don't actually
230 configure the card at this point -- we wait until we receive a
231 card insertion event.
233 ======================================================================*/
235 static int labpc_cs_attach(struct pcmcia_device *link)
239 DEBUG(0, "labpc_cs_attach()\n");
241 /* Allocate space for private device-specific data */
242 local = kzalloc(sizeof(local_info_t), GFP_KERNEL);
248 /* Interrupt setup */
249 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_FORCED_PULSE;
250 link->irq.IRQInfo1 = IRQ_INFO2_VALID | IRQ_PULSE_ID;
251 link->irq.Handler = NULL;
254 General socket configuration defaults can go here. In this
255 client, we assume very little, and rely on the CIS for almost
256 everything. In most clients, many details (i.e., number, sizes,
257 and attributes of IO windows) are fixed by the nature of the
258 device, and can be hard-wired here.
260 link->conf.Attributes = 0;
261 link->conf.IntType = INT_MEMORY_AND_IO;
263 pcmcia_cur_dev = link;
268 } /* labpc_cs_attach */
270 /*======================================================================
272 This deletes a driver "instance". The device is de-registered
273 with Card Services. If it has been released, all local data
274 structures are freed. Otherwise, the structures will be freed
275 when the device is released.
277 ======================================================================*/
279 static void labpc_cs_detach(struct pcmcia_device *link)
281 DEBUG(0, "labpc_cs_detach(0x%p)\n", link);
284 If the device is currently configured and active, we won't
285 actually delete it yet. Instead, it is marked so that when
286 the release() function is called, that will trigger a proper
289 if (link->dev_node) {
290 ((local_info_t *) link->priv)->stop = 1;
294 /* This points to the parent local_info_t struct */
298 } /* labpc_cs_detach */
300 /*======================================================================
302 labpc_config() is scheduled to run after a CARD_INSERTION event
303 is received, to configure the PCMCIA socket, and to make the
304 device available to the system.
306 ======================================================================*/
308 static void labpc_config(struct pcmcia_device *link)
310 local_info_t *dev = link->priv;
317 cistpl_cftable_entry_t dflt = { 0 };
319 DEBUG(0, "labpc_config(0x%p)\n", link);
322 This reads the card's CONFIG tuple to find its configuration
325 tuple.DesiredTuple = CISTPL_CONFIG;
326 tuple.Attributes = 0;
327 tuple.TupleData = buf;
328 tuple.TupleDataMax = sizeof(buf);
329 tuple.TupleOffset = 0;
330 if ((last_ret = pcmcia_get_first_tuple(link, &tuple))) {
331 cs_error(link, GetFirstTuple, last_ret);
334 if ((last_ret = pcmcia_get_tuple_data(link, &tuple))) {
335 cs_error(link, GetTupleData, last_ret);
338 if ((last_ret = pcmcia_parse_tuple(&tuple, &parse))) {
339 cs_error(link, ParseTuple, last_ret);
342 link->conf.ConfigBase = parse.config.base;
343 link->conf.Present = parse.config.rmask[0];
346 In this loop, we scan the CIS for configuration table entries,
347 each of which describes a valid card configuration, including
348 voltage, IO window, memory window, and interrupt settings.
350 We make no assumptions about the card to be configured: we use
351 just the information available in the CIS. In an ideal world,
352 this would work for any PCMCIA card, but it requires a complete
353 and accurate CIS. In practice, a driver usually "knows" most of
354 these things without consulting the CIS, and most client drivers
355 will only use the CIS to fill in implementation-defined details.
357 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY;
358 if ((last_ret = pcmcia_get_first_tuple(link, &tuple))) {
359 cs_error(link, GetFirstTuple, last_ret);
363 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry);
364 if (pcmcia_get_tuple_data(link, &tuple))
366 if (pcmcia_parse_tuple(&tuple, &parse))
369 if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
373 link->conf.ConfigIndex = cfg->index;
375 /* Does this card need audio output? */
376 if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
377 link->conf.Attributes |= CONF_ENABLE_SPKR;
378 link->conf.Status = CCSR_AUDIO_ENA;
381 /* Do we need to allocate an interrupt? */
382 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1)
383 link->conf.Attributes |= CONF_ENABLE_IRQ;
385 /* IO window settings */
386 link->io.NumPorts1 = link->io.NumPorts2 = 0;
387 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) {
388 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io;
389 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
390 link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
391 link->io.BasePort1 = io->win[0].base;
392 link->io.NumPorts1 = io->win[0].len;
394 link->io.Attributes2 = link->io.Attributes1;
395 link->io.BasePort2 = io->win[1].base;
396 link->io.NumPorts2 = io->win[1].len;
398 /* This reserves IO space but doesn't actually enable it */
399 if (pcmcia_request_io(link, &link->io))
403 if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) {
405 (cfg->mem.nwin) ? &cfg->mem : &dflt.mem;
406 req.Attributes = WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_CM;
407 req.Attributes |= WIN_ENABLE;
408 req.Base = mem->win[0].host_addr;
409 req.Size = mem->win[0].len;
410 if (req.Size < 0x1000)
413 link->win = (window_handle_t) link;
414 if (pcmcia_request_window(&link, &req, &link->win))
417 map.CardOffset = mem->win[0].card_addr;
418 if (pcmcia_map_mem_page(link->win, &map))
421 /* If we got this far, we're cool! */
425 if ((last_ret = pcmcia_get_next_tuple(link, &tuple))) {
426 cs_error(link, GetNextTuple, last_ret);
432 Allocate an interrupt line. Note that this does not assign a
433 handler to the interrupt, unless the 'Handler' member of the
434 irq structure is initialized.
436 if (link->conf.Attributes & CONF_ENABLE_IRQ)
437 if ((last_ret = pcmcia_request_irq(link, &link->irq))) {
438 cs_error(link, RequestIRQ, last_ret);
443 This actually configures the PCMCIA socket -- setting up
444 the I/O windows and the interrupt mapping, and putting the
445 card and host interface into "Memory and IO" mode.
447 if ((last_ret = pcmcia_request_configuration(link, &link->conf))) {
448 cs_error(link, RequestConfiguration, last_ret);
453 At this point, the dev_node_t structure(s) need to be
454 initialized and arranged in a linked list at link->dev.
456 sprintf(dev->node.dev_name, "daqcard-1200");
457 dev->node.major = dev->node.minor = 0;
458 link->dev_node = &dev->node;
460 /* Finally, report what we've done */
461 printk(KERN_INFO "%s: index 0x%02x",
462 dev->node.dev_name, link->conf.ConfigIndex);
463 if (link->conf.Attributes & CONF_ENABLE_IRQ)
464 printk(", irq %d", link->irq.AssignedIRQ);
465 if (link->io.NumPorts1)
466 printk(", io 0x%04x-0x%04x", link->io.BasePort1,
467 link->io.BasePort1 + link->io.NumPorts1 - 1);
468 if (link->io.NumPorts2)
469 printk(" & 0x%04x-0x%04x", link->io.BasePort2,
470 link->io.BasePort2 + link->io.NumPorts2 - 1);
472 printk(", mem 0x%06lx-0x%06lx", req.Base,
473 req.Base + req.Size - 1);
483 static void labpc_release(struct pcmcia_device *link)
485 DEBUG(0, "labpc_release(0x%p)\n", link);
487 pcmcia_disable_device(link);
488 } /* labpc_release */
490 /*======================================================================
492 The card status event handler. Mostly, this schedules other
493 stuff to run after an event is received.
495 When a CARD_REMOVAL event is received, we immediately set a
496 private flag to block future accesses to this device. All the
497 functions that actually access the device should check this flag
498 to make sure the card is still present.
500 ======================================================================*/
502 static int labpc_cs_suspend(struct pcmcia_device *link)
504 local_info_t *local = link->priv;
506 /* Mark the device as stopped, to block IO until later */
509 } /* labpc_cs_suspend */
511 static int labpc_cs_resume(struct pcmcia_device *link)
513 local_info_t *local = link->priv;
517 } /* labpc_cs_resume */
519 /*====================================================================*/
521 static struct pcmcia_device_id labpc_cs_ids[] = {
522 /* N.B. These IDs should match those in labpc_cs_boards (ni_labpc.c) */
523 PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0103), /* daqcard-1200 */
527 MODULE_DEVICE_TABLE(pcmcia, labpc_cs_ids);
529 struct pcmcia_driver labpc_cs_driver = {
530 .probe = labpc_cs_attach,
531 .remove = labpc_cs_detach,
532 .suspend = labpc_cs_suspend,
533 .resume = labpc_cs_resume,
534 .id_table = labpc_cs_ids,
535 .owner = THIS_MODULE,
541 static int __init init_labpc_cs(void)
543 DEBUG(0, "%s\n", version);
544 pcmcia_register_driver(&labpc_cs_driver);
548 static void __exit exit_labpc_cs(void)
550 DEBUG(0, "ni_labpc: unloading\n");
551 pcmcia_unregister_driver(&labpc_cs_driver);
554 int __init labpc_init_module(void)
558 ret = init_labpc_cs();
562 return comedi_driver_register(&driver_labpc_cs);
565 void __exit labpc_exit_module(void)
568 comedi_driver_unregister(&driver_labpc_cs);
571 MODULE_LICENSE("GPL");
572 module_init(labpc_init_module);
573 module_exit(labpc_exit_module);