ni_labpc_cs.c revision eb14120f743d29744d9475bffec56ff4ad43a749 
1/*
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>
5
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.
11
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.
16
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.
21
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.
25
26************************************************************************
27*/
28/*
29Driver: ni_labpc_cs
30Description: National Instruments Lab-PC (& compatibles)
31Author: Frank Mori Hess <fmhess@users.sourceforge.net>
32Devices: [National Instruments] DAQCard-1200 (daqcard-1200)
33Status: works
34
35Thanks go to Fredrik Lingvall for much testing and perseverance in
36helping to debug daqcard-1200 support.
37
38The 1200 series boards have onboard calibration dacs for correcting
39analog input/output offsets and gains.  The proper settings for these
40caldacs are stored on the board's eeprom.  To read the caldac values
41from the eeprom and store them into a file that can be then be used by
42comedilib, use the comedi_calibrate program.
43
44Configuration options:
45  none
46
47The daqcard-1200 has quirky chanlist requirements
48when scanning multiple channels.  Multiple channel scan
49sequence must start at highest channel, then decrement down to
50channel 0.  Chanlists consisting of all one channel
51are also legal, and allow you to pace conversions in bursts.
52
53*/
54
55/*
56
57NI manuals:
58340988a (daqcard-1200)
59
60*/
61
62#undef LABPC_DEBUG  /* debugging messages */
63
64#include "../comedidev.h"
65
66#include <linux/delay.h>
67#include <linux/slab.h>
68
69#include "8253.h"
70#include "8255.h"
71#include "comedi_fc.h"
72#include "ni_labpc.h"
73
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>
79
80static struct pcmcia_device *pcmcia_cur_dev;
81
82static int labpc_attach(struct comedi_device *dev, struct comedi_devconfig *it);
83
84static const struct labpc_board_struct labpc_cs_boards[] = {
85	{
86	 .name = "daqcard-1200",
87	 .device_id = 0x103,	/* 0x10b is manufacturer id,
88				   0x103 is device id */
89	 .ai_speed = 10000,
90	 .bustype = pcmcia_bustype,
91	 .register_layout = labpc_1200_layout,
92	 .has_ao = 1,
93	 .ai_range_table = &range_labpc_1200_ai,
94	 .ai_range_code = labpc_1200_ai_gain_bits,
95	 .ai_range_is_unipolar = labpc_1200_is_unipolar,
96	 .ai_scan_up = 0,
97	 .memory_mapped_io = 0,
98	 },
99	/* duplicate entry, to support using alternate name */
100	{
101	 .name = "ni_labpc_cs",
102	 .device_id = 0x103,
103	 .ai_speed = 10000,
104	 .bustype = pcmcia_bustype,
105	 .register_layout = labpc_1200_layout,
106	 .has_ao = 1,
107	 .ai_range_table = &range_labpc_1200_ai,
108	 .ai_range_code = labpc_1200_ai_gain_bits,
109	 .ai_range_is_unipolar = labpc_1200_is_unipolar,
110	 .ai_scan_up = 0,
111	 .memory_mapped_io = 0,
112	 },
113};
114
115/*
116 * Useful for shorthand access to the particular board structure
117 */
118#define thisboard ((const struct labpc_board_struct *)dev->board_ptr)
119
120static struct comedi_driver driver_labpc_cs = {
121	.driver_name = "ni_labpc_cs",
122	.module = THIS_MODULE,
123	.attach = &labpc_attach,
124	.detach = &labpc_common_detach,
125	.num_names = ARRAY_SIZE(labpc_cs_boards),
126	.board_name = &labpc_cs_boards[0].name,
127	.offset = sizeof(struct labpc_board_struct),
128};
129
130static int labpc_attach(struct comedi_device *dev, struct comedi_devconfig *it)
131{
132	unsigned long iobase = 0;
133	unsigned int irq = 0;
134	struct pcmcia_device *link;
135
136	/* allocate and initialize dev->private */
137	if (alloc_private(dev, sizeof(struct labpc_private)) < 0)
138		return -ENOMEM;
139
140	/*  get base address, irq etc. based on bustype */
141	switch (thisboard->bustype) {
142	case pcmcia_bustype:
143		link = pcmcia_cur_dev;	/* XXX hack */
144		if (!link)
145			return -EIO;
146		iobase = link->io.BasePort1;
147		irq = link->irq;
148		break;
149	default:
150		printk("bug! couldn't determine board type\n");
151		return -EINVAL;
152		break;
153	}
154	return labpc_common_attach(dev, iobase, irq, 0);
155}
156
157/*====================================================================*/
158
159/*
160   The event() function is this driver's Card Services event handler.
161   It will be called by Card Services when an appropriate card status
162   event is received.  The config() and release() entry points are
163   used to configure or release a socket, in response to card
164   insertion and ejection events.  They are invoked from the dummy
165   event handler.
166
167   Kernel version 2.6.16 upwards uses suspend() and resume() functions
168   instead of an event() function.
169*/
170
171static void labpc_config(struct pcmcia_device *link);
172static void labpc_release(struct pcmcia_device *link);
173static int labpc_cs_suspend(struct pcmcia_device *p_dev);
174static int labpc_cs_resume(struct pcmcia_device *p_dev);
175
176/*
177   The attach() and detach() entry points are used to create and destroy
178   "instances" of the driver, where each instance represents everything
179   needed to manage one actual PCMCIA card.
180*/
181
182static int labpc_cs_attach(struct pcmcia_device *);
183static void labpc_cs_detach(struct pcmcia_device *);
184
185/*
186   You'll also need to prototype all the functions that will actually
187   be used to talk to your device.  See 'memory_cs' for a good example
188   of a fully self-sufficient driver; the other drivers rely more or
189   less on other parts of the kernel.
190*/
191
192/*
193   The dev_info variable is the "key" that is used to match up this
194   device driver with appropriate cards, through the card configuration
195   database.
196*/
197
198static const dev_info_t dev_info = "daqcard-1200";
199
200struct local_info_t {
201	struct pcmcia_device *link;
202	dev_node_t node;
203	int stop;
204	struct bus_operations *bus;
205};
206
207/*======================================================================
208
209    labpc_cs_attach() creates an "instance" of the driver, allocating
210    local data structures for one device.  The device is registered
211    with Card Services.
212
213    The dev_link structure is initialized, but we don't actually
214    configure the card at this point -- we wait until we receive a
215    card insertion event.
216
217======================================================================*/
218
219static int labpc_cs_attach(struct pcmcia_device *link)
220{
221	struct local_info_t *local;
222
223	dev_dbg(&link->dev, "labpc_cs_attach()\n");
224
225	/* Allocate space for private device-specific data */
226	local = kzalloc(sizeof(struct local_info_t), GFP_KERNEL);
227	if (!local)
228		return -ENOMEM;
229	local->link = link;
230	link->priv = local;
231
232	/*
233	   General socket configuration defaults can go here.  In this
234	   client, we assume very little, and rely on the CIS for almost
235	   everything.  In most clients, many details (i.e., number, sizes,
236	   and attributes of IO windows) are fixed by the nature of the
237	   device, and can be hard-wired here.
238	 */
239	link->conf.Attributes = 0;
240	link->conf.IntType = INT_MEMORY_AND_IO;
241
242	pcmcia_cur_dev = link;
243
244	labpc_config(link);
245
246	return 0;
247}				/* labpc_cs_attach */
248
249/*======================================================================
250
251    This deletes a driver "instance".  The device is de-registered
252    with Card Services.  If it has been released, all local data
253    structures are freed.  Otherwise, the structures will be freed
254    when the device is released.
255
256======================================================================*/
257
258static void labpc_cs_detach(struct pcmcia_device *link)
259{
260	dev_dbg(&link->dev, "labpc_cs_detach\n");
261
262	/*
263	   If the device is currently configured and active, we won't
264	   actually delete it yet.  Instead, it is marked so that when
265	   the release() function is called, that will trigger a proper
266	   detach().
267	 */
268	if (link->dev_node) {
269		((struct local_info_t *)link->priv)->stop = 1;
270		labpc_release(link);
271	}
272
273	/* This points to the parent local_info_t struct (may be null) */
274	kfree(link->priv);
275
276}				/* labpc_cs_detach */
277
278/*======================================================================
279
280    labpc_config() is scheduled to run after a CARD_INSERTION event
281    is received, to configure the PCMCIA socket, and to make the
282    device available to the system.
283
284======================================================================*/
285
286static int labpc_pcmcia_config_loop(struct pcmcia_device *p_dev,
287				cistpl_cftable_entry_t *cfg,
288				cistpl_cftable_entry_t *dflt,
289				unsigned int vcc,
290				void *priv_data)
291{
292	win_req_t *req = priv_data;
293	memreq_t map;
294
295	if (cfg->index == 0)
296		return -ENODEV;
297
298	/* Does this card need audio output? */
299	if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
300		p_dev->conf.Attributes |= CONF_ENABLE_SPKR;
301		p_dev->conf.Status = CCSR_AUDIO_ENA;
302	}
303
304	/* Do we need to allocate an interrupt? */
305	p_dev->conf.Attributes |= CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ;
306
307	/* IO window settings */
308	p_dev->io.NumPorts1 = p_dev->io.NumPorts2 = 0;
309	if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
310		cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
311		p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_AUTO;
312		if (!(io->flags & CISTPL_IO_8BIT))
313			p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_16;
314		if (!(io->flags & CISTPL_IO_16BIT))
315			p_dev->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
316		p_dev->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK;
317		p_dev->io.BasePort1 = io->win[0].base;
318		p_dev->io.NumPorts1 = io->win[0].len;
319		if (io->nwin > 1) {
320			p_dev->io.Attributes2 = p_dev->io.Attributes1;
321			p_dev->io.BasePort2 = io->win[1].base;
322			p_dev->io.NumPorts2 = io->win[1].len;
323		}
324		/* This reserves IO space but doesn't actually enable it */
325		if (pcmcia_request_io(p_dev, &p_dev->io) != 0)
326			return -ENODEV;
327	}
328
329	if ((cfg->mem.nwin > 0) || (dflt->mem.nwin > 0)) {
330		cistpl_mem_t *mem =
331			(cfg->mem.nwin) ? &cfg->mem : &dflt->mem;
332		req->Attributes = WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_CM;
333		req->Attributes |= WIN_ENABLE;
334		req->Base = mem->win[0].host_addr;
335		req->Size = mem->win[0].len;
336		if (req->Size < 0x1000)
337			req->Size = 0x1000;
338		req->AccessSpeed = 0;
339		if (pcmcia_request_window(p_dev, req, &p_dev->win))
340			return -ENODEV;
341		map.Page = 0;
342		map.CardOffset = mem->win[0].card_addr;
343		if (pcmcia_map_mem_page(p_dev, p_dev->win, &map))
344			return -ENODEV;
345	}
346	/* If we got this far, we're cool! */
347	return 0;
348}
349
350
351static void labpc_config(struct pcmcia_device *link)
352{
353	struct local_info_t *dev = link->priv;
354	int ret;
355	win_req_t req;
356
357	dev_dbg(&link->dev, "labpc_config\n");
358
359	ret = pcmcia_loop_config(link, labpc_pcmcia_config_loop, &req);
360	if (ret) {
361		dev_warn(&link->dev, "no configuration found\n");
362		goto failed;
363	}
364
365	if (!link->irq)
366		goto failed;
367
368	/*
369	   This actually configures the PCMCIA socket -- setting up
370	   the I/O windows and the interrupt mapping, and putting the
371	   card and host interface into "Memory and IO" mode.
372	 */
373	ret = pcmcia_request_configuration(link, &link->conf);
374	if (ret)
375		goto failed;
376
377	/*
378	   At this point, the dev_node_t structure(s) need to be
379	   initialized and arranged in a linked list at link->dev.
380	 */
381	sprintf(dev->node.dev_name, "daqcard-1200");
382	dev->node.major = dev->node.minor = 0;
383	link->dev_node = &dev->node;
384
385	/* Finally, report what we've done */
386	printk(KERN_INFO "%s: index 0x%02x",
387	       dev->node.dev_name, link->conf.ConfigIndex);
388	if (link->conf.Attributes & CONF_ENABLE_IRQ)
389		printk(", irq %d", link->irq);
390	if (link->io.NumPorts1)
391		printk(", io 0x%04x-0x%04x", link->io.BasePort1,
392		       link->io.BasePort1 + link->io.NumPorts1 - 1);
393	if (link->io.NumPorts2)
394		printk(" & 0x%04x-0x%04x", link->io.BasePort2,
395		       link->io.BasePort2 + link->io.NumPorts2 - 1);
396	if (link->win)
397		printk(", mem 0x%06lx-0x%06lx", req.Base,
398		       req.Base + req.Size - 1);
399	printk("\n");
400
401	return;
402
403failed:
404	labpc_release(link);
405
406}				/* labpc_config */
407
408static void labpc_release(struct pcmcia_device *link)
409{
410	dev_dbg(&link->dev, "labpc_release\n");
411
412	pcmcia_disable_device(link);
413}				/* labpc_release */
414
415/*======================================================================
416
417    The card status event handler.  Mostly, this schedules other
418    stuff to run after an event is received.
419
420    When a CARD_REMOVAL event is received, we immediately set a
421    private flag to block future accesses to this device.  All the
422    functions that actually access the device should check this flag
423    to make sure the card is still present.
424
425======================================================================*/
426
427static int labpc_cs_suspend(struct pcmcia_device *link)
428{
429	struct local_info_t *local = link->priv;
430
431	/* Mark the device as stopped, to block IO until later */
432	local->stop = 1;
433	return 0;
434}				/* labpc_cs_suspend */
435
436static int labpc_cs_resume(struct pcmcia_device *link)
437{
438	struct local_info_t *local = link->priv;
439
440	local->stop = 0;
441	return 0;
442}				/* labpc_cs_resume */
443
444/*====================================================================*/
445
446static struct pcmcia_device_id labpc_cs_ids[] = {
447	/* N.B. These IDs should match those in labpc_cs_boards (ni_labpc.c) */
448	PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0103),	/* daqcard-1200 */
449	PCMCIA_DEVICE_NULL
450};
451
452MODULE_DEVICE_TABLE(pcmcia, labpc_cs_ids);
453
454struct pcmcia_driver labpc_cs_driver = {
455	.probe = labpc_cs_attach,
456	.remove = labpc_cs_detach,
457	.suspend = labpc_cs_suspend,
458	.resume = labpc_cs_resume,
459	.id_table = labpc_cs_ids,
460	.owner = THIS_MODULE,
461	.drv = {
462		.name = dev_info,
463		},
464};
465
466static int __init init_labpc_cs(void)
467{
468	pcmcia_register_driver(&labpc_cs_driver);
469	return 0;
470}
471
472static void __exit exit_labpc_cs(void)
473{
474	pcmcia_unregister_driver(&labpc_cs_driver);
475}
476
477int __init labpc_init_module(void)
478{
479	int ret;
480
481	ret = init_labpc_cs();
482	if (ret < 0)
483		return ret;
484
485	return comedi_driver_register(&driver_labpc_cs);
486}
487
488void __exit labpc_exit_module(void)
489{
490	exit_labpc_cs();
491	comedi_driver_unregister(&driver_labpc_cs);
492}
493
494MODULE_LICENSE("GPL");
495module_init(labpc_init_module);
496module_exit(labpc_exit_module);
497