ni_labpc_cs.c revision 71b5f4f11971dea972832ad63a994c7e5b45db6b
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 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 = NULL; 81 82static int labpc_attach(struct comedi_device * dev, comedi_devconfig * it); 83 84static const labpc_board labpc_cs_boards[] = { 85 { 86 name: "daqcard-1200", 87 device_id:0x103, // 0x10b is manufacturer id, 0x103 is device id 88 ai_speed:10000, 89 bustype: pcmcia_bustype, 90 register_layout:labpc_1200_layout, 91 has_ao: 1, 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, 95 ai_scan_up:0, 96 memory_mapped_io:0, 97 }, 98 /* duplicate entry, to support using alternate name */ 99 { 100 name: "ni_labpc_cs", 101 device_id:0x103, 102 ai_speed:10000, 103 bustype: pcmcia_bustype, 104 register_layout:labpc_1200_layout, 105 has_ao: 1, 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, 109 ai_scan_up:0, 110 memory_mapped_io:0, 111 }, 112}; 113 114/* 115 * Useful for shorthand access to the particular board structure 116 */ 117#define thisboard ((const labpc_board *)dev->board_ptr) 118 119static 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), 127}; 128 129static int labpc_attach(struct comedi_device * dev, comedi_devconfig * it) 130{ 131 unsigned long iobase = 0; 132 unsigned int irq = 0; 133 struct pcmcia_device *link; 134 135 /* allocate and initialize dev->private */ 136 if (alloc_private(dev, sizeof(labpc_private)) < 0) 137 return -ENOMEM; 138 139 // get base address, irq etc. based on bustype 140 switch (thisboard->bustype) { 141 case pcmcia_bustype: 142 link = pcmcia_cur_dev; /* XXX hack */ 143 if (!link) 144 return -EIO; 145 iobase = link->io.BasePort1; 146 irq = link->irq.AssignedIRQ; 147 break; 148 default: 149 printk("bug! couldn't determine board type\n"); 150 return -EINVAL; 151 break; 152 } 153 return labpc_common_attach(dev, iobase, irq, 0); 154} 155 156/* 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. 162*/ 163#ifdef PCMCIA_DEBUG 164static int pc_debug = PCMCIA_DEBUG; 165module_param(pc_debug, int, 0644); 166#define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args) 167static const char *version = 168 "ni_labpc.c, based on dummy_cs.c 1.31 2001/08/24 12:13:13"; 169#else 170#define DEBUG(n, args...) 171#endif 172 173/*====================================================================*/ 174 175/* 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 181 event handler. 182 183 Kernel version 2.6.16 upwards uses suspend() and resume() functions 184 instead of an event() function. 185*/ 186 187static void labpc_config(struct pcmcia_device *link); 188static void labpc_release(struct pcmcia_device *link); 189static int labpc_cs_suspend(struct pcmcia_device *p_dev); 190static int labpc_cs_resume(struct pcmcia_device *p_dev); 191 192/* 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. 196*/ 197 198static int labpc_cs_attach(struct pcmcia_device *); 199static void labpc_cs_detach(struct pcmcia_device *); 200 201/* 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. 206*/ 207 208/* 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 211 database. 212*/ 213 214static const dev_info_t dev_info = "daqcard-1200"; 215 216typedef struct local_info_t { 217 struct pcmcia_device *link; 218 dev_node_t node; 219 int stop; 220 struct bus_operations *bus; 221} local_info_t; 222 223/*====================================================================== 224 225 labpc_cs_attach() creates an "instance" of the driver, allocating 226 local data structures for one device. The device is registered 227 with Card Services. 228 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. 232 233======================================================================*/ 234 235static int labpc_cs_attach(struct pcmcia_device *link) 236{ 237 local_info_t *local; 238 239 DEBUG(0, "labpc_cs_attach()\n"); 240 241 /* Allocate space for private device-specific data */ 242 local = kzalloc(sizeof(local_info_t), GFP_KERNEL); 243 if (!local) 244 return -ENOMEM; 245 local->link = link; 246 link->priv = local; 247 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; 252 253 /* 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. 259 */ 260 link->conf.Attributes = 0; 261 link->conf.IntType = INT_MEMORY_AND_IO; 262 263 pcmcia_cur_dev = link; 264 265 labpc_config(link); 266 267 return 0; 268} /* labpc_cs_attach */ 269 270/*====================================================================== 271 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. 276 277======================================================================*/ 278 279static void labpc_cs_detach(struct pcmcia_device *link) 280{ 281 DEBUG(0, "labpc_cs_detach(0x%p)\n", link); 282 283 /* 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 287 detach(). 288 */ 289 if (link->dev_node) { 290 ((local_info_t *) link->priv)->stop = 1; 291 labpc_release(link); 292 } 293 294 /* This points to the parent local_info_t struct */ 295 if (link->priv) 296 kfree(link->priv); 297 298} /* labpc_cs_detach */ 299 300/*====================================================================== 301 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. 305 306======================================================================*/ 307 308static void labpc_config(struct pcmcia_device *link) 309{ 310 local_info_t *dev = link->priv; 311 tuple_t tuple; 312 cisparse_t parse; 313 int last_ret; 314 u_char buf[64]; 315 win_req_t req; 316 memreq_t map; 317 cistpl_cftable_entry_t dflt = { 0 }; 318 319 DEBUG(0, "labpc_config(0x%p)\n", link); 320 321 /* 322 This reads the card's CONFIG tuple to find its configuration 323 registers. 324 */ 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); 332 goto cs_failed; 333 } 334 if ((last_ret = pcmcia_get_tuple_data(link, &tuple))) { 335 cs_error(link, GetTupleData, last_ret); 336 goto cs_failed; 337 } 338 if ((last_ret = pcmcia_parse_tuple(&tuple, &parse))) { 339 cs_error(link, ParseTuple, last_ret); 340 goto cs_failed; 341 } 342 link->conf.ConfigBase = parse.config.base; 343 link->conf.Present = parse.config.rmask[0]; 344 345 /* 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. 349 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. 356 */ 357 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; 358 if ((last_ret = pcmcia_get_first_tuple(link, &tuple))) { 359 cs_error(link, GetFirstTuple, last_ret); 360 goto cs_failed; 361 } 362 while (1) { 363 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry); 364 if (pcmcia_get_tuple_data(link, &tuple)) 365 goto next_entry; 366 if (pcmcia_parse_tuple(&tuple, &parse)) 367 goto next_entry; 368 369 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) 370 dflt = *cfg; 371 if (cfg->index == 0) 372 goto next_entry; 373 link->conf.ConfigIndex = cfg->index; 374 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; 379 } 380 381 /* Do we need to allocate an interrupt? */ 382 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1) 383 link->conf.Attributes |= CONF_ENABLE_IRQ; 384 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; 393 if (io->nwin > 1) { 394 link->io.Attributes2 = link->io.Attributes1; 395 link->io.BasePort2 = io->win[1].base; 396 link->io.NumPorts2 = io->win[1].len; 397 } 398 /* This reserves IO space but doesn't actually enable it */ 399 if (pcmcia_request_io(link, &link->io)) 400 goto next_entry; 401 } 402 403 if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) { 404 cistpl_mem_t *mem = 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) 411 req.Size = 0x1000; 412 req.AccessSpeed = 0; 413 link->win = (window_handle_t) link; 414 if (pcmcia_request_window(&link, &req, &link->win)) 415 goto next_entry; 416 map.Page = 0; 417 map.CardOffset = mem->win[0].card_addr; 418 if (pcmcia_map_mem_page(link->win, &map)) 419 goto next_entry; 420 } 421 /* If we got this far, we're cool! */ 422 break; 423 424 next_entry: 425 if ((last_ret = pcmcia_get_next_tuple(link, &tuple))) { 426 cs_error(link, GetNextTuple, last_ret); 427 goto cs_failed; 428 } 429 } 430 431 /* 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. 435 */ 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); 439 goto cs_failed; 440 } 441 442 /* 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. 446 */ 447 if ((last_ret = pcmcia_request_configuration(link, &link->conf))) { 448 cs_error(link, RequestConfiguration, last_ret); 449 goto cs_failed; 450 } 451 452 /* 453 At this point, the dev_node_t structure(s) need to be 454 initialized and arranged in a linked list at link->dev. 455 */ 456 sprintf(dev->node.dev_name, "daqcard-1200"); 457 dev->node.major = dev->node.minor = 0; 458 link->dev_node = &dev->node; 459 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); 471 if (link->win) 472 printk(", mem 0x%06lx-0x%06lx", req.Base, 473 req.Base + req.Size - 1); 474 printk("\n"); 475 476 return; 477 478 cs_failed: 479 labpc_release(link); 480 481} /* labpc_config */ 482 483static void labpc_release(struct pcmcia_device *link) 484{ 485 DEBUG(0, "labpc_release(0x%p)\n", link); 486 487 pcmcia_disable_device(link); 488} /* labpc_release */ 489 490/*====================================================================== 491 492 The card status event handler. Mostly, this schedules other 493 stuff to run after an event is received. 494 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. 499 500======================================================================*/ 501 502static int labpc_cs_suspend(struct pcmcia_device *link) 503{ 504 local_info_t *local = link->priv; 505 506 /* Mark the device as stopped, to block IO until later */ 507 local->stop = 1; 508 return 0; 509} /* labpc_cs_suspend */ 510 511static int labpc_cs_resume(struct pcmcia_device *link) 512{ 513 local_info_t *local = link->priv; 514 515 local->stop = 0; 516 return 0; 517} /* labpc_cs_resume */ 518 519/*====================================================================*/ 520 521static 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 */ 524 PCMCIA_DEVICE_NULL 525}; 526 527MODULE_DEVICE_TABLE(pcmcia, labpc_cs_ids); 528 529struct 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, 536 .drv = { 537 .name = dev_info, 538 }, 539}; 540 541static int __init init_labpc_cs(void) 542{ 543 DEBUG(0, "%s\n", version); 544 pcmcia_register_driver(&labpc_cs_driver); 545 return 0; 546} 547 548static void __exit exit_labpc_cs(void) 549{ 550 DEBUG(0, "ni_labpc: unloading\n"); 551 pcmcia_unregister_driver(&labpc_cs_driver); 552} 553 554int __init labpc_init_module(void) 555{ 556 int ret; 557 558 ret = init_labpc_cs(); 559 if (ret < 0) 560 return ret; 561 562 return comedi_driver_register(&driver_labpc_cs); 563} 564 565void __exit labpc_exit_module(void) 566{ 567 exit_labpc_cs(); 568 comedi_driver_unregister(&driver_labpc_cs); 569} 570 571MODULE_LICENSE("GPL"); 572module_init(labpc_init_module); 573module_exit(labpc_exit_module); 574