ni_labpc_cs.c revision 124b13b26df5dab0236520de95e1cc1dea06e3c3
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 63//#define LABPC_DEBUG // enable debugging messages 64 65#include "../comedidev.h" 66 67#include <linux/delay.h> 68#include <linux/version.h> 69 70#include "8253.h" 71#include "8255.h" 72#include "comedi_fc.h" 73#include "ni_labpc.h" 74 75#include <pcmcia/cs_types.h> 76#include <pcmcia/cs.h> 77#include <pcmcia/cistpl.h> 78#include <pcmcia/cisreg.h> 79#include <pcmcia/ds.h> 80 81static struct pcmcia_device *pcmcia_cur_dev = NULL; 82 83static int labpc_attach(comedi_device * dev, comedi_devconfig * it); 84 85static const labpc_board labpc_cs_boards[] = { 86 { 87 name: "daqcard-1200", 88 device_id:0x103, // 0x10b is manufacturer id, 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 labpc_board *)dev->board_ptr) 119 120static 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 = sizeof(labpc_cs_boards) / sizeof(labpc_board), 126 .board_name = &labpc_cs_boards[0].name, 127 .offset = sizeof(labpc_board), 128}; 129 130static int labpc_attach(comedi_device * dev, 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(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.AssignedIRQ; 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 All the PCMCIA modules use PCMCIA_DEBUG to control debugging. If 159 you do not define PCMCIA_DEBUG at all, all the debug code will be 160 left out. If you compile with PCMCIA_DEBUG=0, the debug code will 161 be present but disabled -- but it can then be enabled for specific 162 modules at load time with a 'pc_debug=#' option to insmod. 163*/ 164#ifdef PCMCIA_DEBUG 165static int pc_debug = PCMCIA_DEBUG; 166module_param(pc_debug, int, 0644); 167#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args) 168static const char *version = 169 "ni_labpc.c, based on dummy_cs.c 1.31 2001/08/24 12:13:13"; 170#else 171#define DEBUG(n, args...) 172#endif 173 174/*====================================================================*/ 175 176/* 177 The event() function is this driver's Card Services event handler. 178 It will be called by Card Services when an appropriate card status 179 event is received. The config() and release() entry points are 180 used to configure or release a socket, in response to card 181 insertion and ejection events. They are invoked from the dummy 182 event handler. 183 184 Kernel version 2.6.16 upwards uses suspend() and resume() functions 185 instead of an event() function. 186*/ 187 188static void labpc_config(struct pcmcia_device *link); 189static void labpc_release(struct pcmcia_device *link); 190static int labpc_cs_suspend(struct pcmcia_device *p_dev); 191static int labpc_cs_resume(struct pcmcia_device *p_dev); 192 193/* 194 The attach() and detach() entry points are used to create and destroy 195 "instances" of the driver, where each instance represents everything 196 needed to manage one actual PCMCIA card. 197*/ 198 199static int labpc_cs_attach(struct pcmcia_device *); 200static void labpc_cs_detach(struct pcmcia_device *); 201 202/* 203 You'll also need to prototype all the functions that will actually 204 be used to talk to your device. See 'memory_cs' for a good example 205 of a fully self-sufficient driver; the other drivers rely more or 206 less on other parts of the kernel. 207*/ 208 209/* 210 The dev_info variable is the "key" that is used to match up this 211 device driver with appropriate cards, through the card configuration 212 database. 213*/ 214 215static const dev_info_t dev_info = "daqcard-1200"; 216 217typedef struct local_info_t { 218 struct pcmcia_device *link; 219 dev_node_t node; 220 int stop; 221 struct bus_operations *bus; 222} local_info_t; 223 224/*====================================================================== 225 226 labpc_cs_attach() creates an "instance" of the driver, allocating 227 local data structures for one device. The device is registered 228 with Card Services. 229 230 The dev_link structure is initialized, but we don't actually 231 configure the card at this point -- we wait until we receive a 232 card insertion event. 233 234======================================================================*/ 235 236static int labpc_cs_attach(struct pcmcia_device *link) 237{ 238 local_info_t *local; 239 240 DEBUG(0, "labpc_cs_attach()\n"); 241 242 /* Allocate space for private device-specific data */ 243 local = kzalloc(sizeof(local_info_t), GFP_KERNEL); 244 if (!local) 245 return -ENOMEM; 246 local->link = link; 247 link->priv = local; 248 249 /* Interrupt setup */ 250 link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_FORCED_PULSE; 251 link->irq.IRQInfo1 = IRQ_INFO2_VALID | IRQ_PULSE_ID; 252 link->irq.Handler = NULL; 253 254 /* 255 General socket configuration defaults can go here. In this 256 client, we assume very little, and rely on the CIS for almost 257 everything. In most clients, many details (i.e., number, sizes, 258 and attributes of IO windows) are fixed by the nature of the 259 device, and can be hard-wired here. 260 */ 261 link->conf.Attributes = 0; 262 link->conf.IntType = INT_MEMORY_AND_IO; 263 264 pcmcia_cur_dev = link; 265 266 labpc_config(link); 267 268 return 0; 269} /* labpc_cs_attach */ 270 271/*====================================================================== 272 273 This deletes a driver "instance". The device is de-registered 274 with Card Services. If it has been released, all local data 275 structures are freed. Otherwise, the structures will be freed 276 when the device is released. 277 278======================================================================*/ 279 280static void labpc_cs_detach(struct pcmcia_device *link) 281{ 282 DEBUG(0, "labpc_cs_detach(0x%p)\n", link); 283 284 /* 285 If the device is currently configured and active, we won't 286 actually delete it yet. Instead, it is marked so that when 287 the release() function is called, that will trigger a proper 288 detach(). 289 */ 290 if (link->dev_node) { 291 ((local_info_t *) link->priv)->stop = 1; 292 labpc_release(link); 293 } 294 295 /* This points to the parent local_info_t struct */ 296 if (link->priv) 297 kfree(link->priv); 298 299} /* labpc_cs_detach */ 300 301/*====================================================================== 302 303 labpc_config() is scheduled to run after a CARD_INSERTION event 304 is received, to configure the PCMCIA socket, and to make the 305 device available to the system. 306 307======================================================================*/ 308 309static void labpc_config(struct pcmcia_device *link) 310{ 311 local_info_t *dev = link->priv; 312 tuple_t tuple; 313 cisparse_t parse; 314 int last_ret; 315 u_char buf[64]; 316 win_req_t req; 317 memreq_t map; 318 cistpl_cftable_entry_t dflt = { 0 }; 319 320 DEBUG(0, "labpc_config(0x%p)\n", link); 321 322 /* 323 This reads the card's CONFIG tuple to find its configuration 324 registers. 325 */ 326 tuple.DesiredTuple = CISTPL_CONFIG; 327 tuple.Attributes = 0; 328 tuple.TupleData = buf; 329 tuple.TupleDataMax = sizeof(buf); 330 tuple.TupleOffset = 0; 331 if ((last_ret = pcmcia_get_first_tuple(link, &tuple))) { 332 cs_error(link, GetFirstTuple, last_ret); 333 goto cs_failed; 334 } 335 if ((last_ret = pcmcia_get_tuple_data(link, &tuple))) { 336 cs_error(link, GetTupleData, last_ret); 337 goto cs_failed; 338 } 339 if ((last_ret = pcmcia_parse_tuple(&tuple, &parse))) { 340 cs_error(link, ParseTuple, last_ret); 341 goto cs_failed; 342 } 343 link->conf.ConfigBase = parse.config.base; 344 link->conf.Present = parse.config.rmask[0]; 345 346 /* 347 In this loop, we scan the CIS for configuration table entries, 348 each of which describes a valid card configuration, including 349 voltage, IO window, memory window, and interrupt settings. 350 351 We make no assumptions about the card to be configured: we use 352 just the information available in the CIS. In an ideal world, 353 this would work for any PCMCIA card, but it requires a complete 354 and accurate CIS. In practice, a driver usually "knows" most of 355 these things without consulting the CIS, and most client drivers 356 will only use the CIS to fill in implementation-defined details. 357 */ 358 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; 359 if ((last_ret = pcmcia_get_first_tuple(link, &tuple))) { 360 cs_error(link, GetFirstTuple, last_ret); 361 goto cs_failed; 362 } 363 while (1) { 364 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry); 365 if (pcmcia_get_tuple_data(link, &tuple)) 366 goto next_entry; 367 if (pcmcia_parse_tuple(&tuple, &parse)) 368 goto next_entry; 369 370 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) 371 dflt = *cfg; 372 if (cfg->index == 0) 373 goto next_entry; 374 link->conf.ConfigIndex = cfg->index; 375 376 /* Does this card need audio output? */ 377 if (cfg->flags & CISTPL_CFTABLE_AUDIO) { 378 link->conf.Attributes |= CONF_ENABLE_SPKR; 379 link->conf.Status = CCSR_AUDIO_ENA; 380 } 381 382 /* Do we need to allocate an interrupt? */ 383 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1) 384 link->conf.Attributes |= CONF_ENABLE_IRQ; 385 386 /* IO window settings */ 387 link->io.NumPorts1 = link->io.NumPorts2 = 0; 388 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) { 389 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io; 390 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; 391 link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK; 392 link->io.BasePort1 = io->win[0].base; 393 link->io.NumPorts1 = io->win[0].len; 394 if (io->nwin > 1) { 395 link->io.Attributes2 = link->io.Attributes1; 396 link->io.BasePort2 = io->win[1].base; 397 link->io.NumPorts2 = io->win[1].len; 398 } 399 /* This reserves IO space but doesn't actually enable it */ 400 if (pcmcia_request_io(link, &link->io)) 401 goto next_entry; 402 } 403 404 if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) { 405 cistpl_mem_t *mem = 406 (cfg->mem.nwin) ? &cfg->mem : &dflt.mem; 407 req.Attributes = WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_CM; 408 req.Attributes |= WIN_ENABLE; 409 req.Base = mem->win[0].host_addr; 410 req.Size = mem->win[0].len; 411 if (req.Size < 0x1000) 412 req.Size = 0x1000; 413 req.AccessSpeed = 0; 414 link->win = (window_handle_t) link; 415 if (pcmcia_request_window(&link, &req, &link->win)) 416 goto next_entry; 417 map.Page = 0; 418 map.CardOffset = mem->win[0].card_addr; 419 if (pcmcia_map_mem_page(link->win, &map)) 420 goto next_entry; 421 } 422 /* If we got this far, we're cool! */ 423 break; 424 425 next_entry: 426 if ((last_ret = pcmcia_get_next_tuple(link, &tuple))) { 427 cs_error(link, GetNextTuple, last_ret); 428 goto cs_failed; 429 } 430 } 431 432 /* 433 Allocate an interrupt line. Note that this does not assign a 434 handler to the interrupt, unless the 'Handler' member of the 435 irq structure is initialized. 436 */ 437 if (link->conf.Attributes & CONF_ENABLE_IRQ) 438 if ((last_ret = pcmcia_request_irq(link, &link->irq))) { 439 cs_error(link, RequestIRQ, last_ret); 440 goto cs_failed; 441 } 442 443 /* 444 This actually configures the PCMCIA socket -- setting up 445 the I/O windows and the interrupt mapping, and putting the 446 card and host interface into "Memory and IO" mode. 447 */ 448 if ((last_ret = pcmcia_request_configuration(link, &link->conf))) { 449 cs_error(link, RequestConfiguration, last_ret); 450 goto cs_failed; 451 } 452 453 /* 454 At this point, the dev_node_t structure(s) need to be 455 initialized and arranged in a linked list at link->dev. 456 */ 457 sprintf(dev->node.dev_name, "daqcard-1200"); 458 dev->node.major = dev->node.minor = 0; 459 link->dev_node = &dev->node; 460 461 /* Finally, report what we've done */ 462 printk(KERN_INFO "%s: index 0x%02x", 463 dev->node.dev_name, link->conf.ConfigIndex); 464 if (link->conf.Attributes & CONF_ENABLE_IRQ) 465 printk(", irq %d", link->irq.AssignedIRQ); 466 if (link->io.NumPorts1) 467 printk(", io 0x%04x-0x%04x", link->io.BasePort1, 468 link->io.BasePort1 + link->io.NumPorts1 - 1); 469 if (link->io.NumPorts2) 470 printk(" & 0x%04x-0x%04x", link->io.BasePort2, 471 link->io.BasePort2 + link->io.NumPorts2 - 1); 472 if (link->win) 473 printk(", mem 0x%06lx-0x%06lx", req.Base, 474 req.Base + req.Size - 1); 475 printk("\n"); 476 477 return; 478 479 cs_failed: 480 labpc_release(link); 481 482} /* labpc_config */ 483 484static void labpc_release(struct pcmcia_device *link) 485{ 486 DEBUG(0, "labpc_release(0x%p)\n", link); 487 488 pcmcia_disable_device(link); 489} /* labpc_release */ 490 491/*====================================================================== 492 493 The card status event handler. Mostly, this schedules other 494 stuff to run after an event is received. 495 496 When a CARD_REMOVAL event is received, we immediately set a 497 private flag to block future accesses to this device. All the 498 functions that actually access the device should check this flag 499 to make sure the card is still present. 500 501======================================================================*/ 502 503static int labpc_cs_suspend(struct pcmcia_device *link) 504{ 505 local_info_t *local = link->priv; 506 507 /* Mark the device as stopped, to block IO until later */ 508 local->stop = 1; 509 return 0; 510} /* labpc_cs_suspend */ 511 512static int labpc_cs_resume(struct pcmcia_device *link) 513{ 514 local_info_t *local = link->priv; 515 516 local->stop = 0; 517 return 0; 518} /* labpc_cs_resume */ 519 520/*====================================================================*/ 521 522static struct pcmcia_device_id labpc_cs_ids[] = { 523 /* N.B. These IDs should match those in labpc_cs_boards (ni_labpc.c) */ 524 PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0103), /* daqcard-1200 */ 525 PCMCIA_DEVICE_NULL 526}; 527 528MODULE_DEVICE_TABLE(pcmcia, labpc_cs_ids); 529 530struct pcmcia_driver labpc_cs_driver = { 531 .probe = labpc_cs_attach, 532 .remove = labpc_cs_detach, 533 .suspend = labpc_cs_suspend, 534 .resume = labpc_cs_resume, 535 .id_table = labpc_cs_ids, 536 .owner = THIS_MODULE, 537 .drv = { 538 .name = dev_info, 539 }, 540}; 541 542static int __init init_labpc_cs(void) 543{ 544 DEBUG(0, "%s\n", version); 545 pcmcia_register_driver(&labpc_cs_driver); 546 return 0; 547} 548 549static void __exit exit_labpc_cs(void) 550{ 551 DEBUG(0, "ni_labpc: unloading\n"); 552 pcmcia_unregister_driver(&labpc_cs_driver); 553} 554 555int __init labpc_init_module(void) 556{ 557 int ret; 558 559 ret = init_labpc_cs(); 560 if (ret < 0) 561 return ret; 562 563 return comedi_driver_register(&driver_labpc_cs); 564} 565 566void __exit labpc_exit_module(void) 567{ 568 exit_labpc_cs(); 569 comedi_driver_unregister(&driver_labpc_cs); 570} 571 572MODULE_LICENSE("GPL"); 573module_init(labpc_init_module); 574module_exit(labpc_exit_module); 575