ni_labpc_cs.c revision 3d1c28848ea37bf117940e10826f7a485aa32337
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, 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, 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 struct labpc_board_struct *)dev->board_ptr) 118 119static 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 = ARRAY_SIZE(labpc_cs_boards), 125 .board_name = &labpc_cs_boards[0].name, 126 .offset = sizeof(struct labpc_board_struct), 127}; 128 129static int labpc_attach(struct comedi_device *dev, struct 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(struct 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 216struct local_info_t { 217 struct pcmcia_device *link; 218 dev_node_t node; 219 int stop; 220 struct bus_operations *bus; 221}; 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 struct 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(struct 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_DYNAMIC_SHARING | 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 ((struct 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 struct 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 331 last_ret = pcmcia_get_first_tuple(link, &tuple); 332 if (last_ret) { 333 cs_error(link, GetFirstTuple, last_ret); 334 goto cs_failed; 335 } 336 337 last_ret = pcmcia_get_tuple_data(link, &tuple); 338 if (last_ret) { 339 cs_error(link, GetTupleData, last_ret); 340 goto cs_failed; 341 } 342 343 last_ret = pcmcia_parse_tuple(&tuple, &parse); 344 if (last_ret) { 345 cs_error(link, ParseTuple, last_ret); 346 goto cs_failed; 347 } 348 link->conf.ConfigBase = parse.config.base; 349 link->conf.Present = parse.config.rmask[0]; 350 351 /* 352 In this loop, we scan the CIS for configuration table entries, 353 each of which describes a valid card configuration, including 354 voltage, IO window, memory window, and interrupt settings. 355 356 We make no assumptions about the card to be configured: we use 357 just the information available in the CIS. In an ideal world, 358 this would work for any PCMCIA card, but it requires a complete 359 and accurate CIS. In practice, a driver usually "knows" most of 360 these things without consulting the CIS, and most client drivers 361 will only use the CIS to fill in implementation-defined details. 362 */ 363 tuple.DesiredTuple = CISTPL_CFTABLE_ENTRY; 364 last_ret = pcmcia_get_first_tuple(link, &tuple); 365 if (last_ret) { 366 cs_error(link, GetFirstTuple, last_ret); 367 goto cs_failed; 368 } 369 while (1) { 370 cistpl_cftable_entry_t *cfg = &(parse.cftable_entry); 371 if (pcmcia_get_tuple_data(link, &tuple)) 372 goto next_entry; 373 if (pcmcia_parse_tuple(&tuple, &parse)) 374 goto next_entry; 375 376 if (cfg->flags & CISTPL_CFTABLE_DEFAULT) 377 dflt = *cfg; 378 if (cfg->index == 0) 379 goto next_entry; 380 link->conf.ConfigIndex = cfg->index; 381 382 /* Does this card need audio output? */ 383 if (cfg->flags & CISTPL_CFTABLE_AUDIO) { 384 link->conf.Attributes |= CONF_ENABLE_SPKR; 385 link->conf.Status = CCSR_AUDIO_ENA; 386 } 387 388 /* Do we need to allocate an interrupt? */ 389 if (cfg->irq.IRQInfo1 || dflt.irq.IRQInfo1) 390 link->conf.Attributes |= CONF_ENABLE_IRQ; 391 392 /* IO window settings */ 393 link->io.NumPorts1 = link->io.NumPorts2 = 0; 394 if ((cfg->io.nwin > 0) || (dflt.io.nwin > 0)) { 395 cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt.io; 396 link->io.Attributes1 = IO_DATA_PATH_WIDTH_8; 397 link->io.IOAddrLines = io->flags & CISTPL_IO_LINES_MASK; 398 link->io.BasePort1 = io->win[0].base; 399 link->io.NumPorts1 = io->win[0].len; 400 if (io->nwin > 1) { 401 link->io.Attributes2 = link->io.Attributes1; 402 link->io.BasePort2 = io->win[1].base; 403 link->io.NumPorts2 = io->win[1].len; 404 } 405 /* This reserves IO space but doesn't actually enable it */ 406 if (pcmcia_request_io(link, &link->io)) 407 goto next_entry; 408 } 409 410 if ((cfg->mem.nwin > 0) || (dflt.mem.nwin > 0)) { 411 cistpl_mem_t *mem = 412 (cfg->mem.nwin) ? &cfg->mem : &dflt.mem; 413 req.Attributes = WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_CM; 414 req.Attributes |= WIN_ENABLE; 415 req.Base = mem->win[0].host_addr; 416 req.Size = mem->win[0].len; 417 if (req.Size < 0x1000) 418 req.Size = 0x1000; 419 req.AccessSpeed = 0; 420 link->win = (window_handle_t) link; 421 if (pcmcia_request_window(&link, &req, &link->win)) 422 goto next_entry; 423 map.Page = 0; 424 map.CardOffset = mem->win[0].card_addr; 425 if (pcmcia_map_mem_page(link->win, &map)) 426 goto next_entry; 427 } 428 /* If we got this far, we're cool! */ 429 break; 430 431next_entry: 432 last_ret = pcmcia_get_next_tuple(link, &tuple); 433 if (last_ret) { 434 cs_error(link, GetNextTuple, last_ret); 435 goto cs_failed; 436 } 437 } 438 439 /* 440 Allocate an interrupt line. Note that this does not assign a 441 handler to the interrupt, unless the 'Handler' member of the 442 irq structure is initialized. 443 */ 444 if (link->conf.Attributes & CONF_ENABLE_IRQ) { 445 last_ret = pcmcia_request_irq(link, &link->irq); 446 if (last_ret) { 447 cs_error(link, RequestIRQ, last_ret); 448 goto cs_failed; 449 } 450 } 451 452 /* 453 This actually configures the PCMCIA socket -- setting up 454 the I/O windows and the interrupt mapping, and putting the 455 card and host interface into "Memory and IO" mode. 456 */ 457 last_ret = pcmcia_request_configuration(link, &link->conf); 458 if (last_ret) { 459 cs_error(link, RequestConfiguration, last_ret); 460 goto cs_failed; 461 } 462 463 /* 464 At this point, the dev_node_t structure(s) need to be 465 initialized and arranged in a linked list at link->dev. 466 */ 467 sprintf(dev->node.dev_name, "daqcard-1200"); 468 dev->node.major = dev->node.minor = 0; 469 link->dev_node = &dev->node; 470 471 /* Finally, report what we've done */ 472 printk(KERN_INFO "%s: index 0x%02x", 473 dev->node.dev_name, link->conf.ConfigIndex); 474 if (link->conf.Attributes & CONF_ENABLE_IRQ) 475 printk(", irq %d", link->irq.AssignedIRQ); 476 if (link->io.NumPorts1) 477 printk(", io 0x%04x-0x%04x", link->io.BasePort1, 478 link->io.BasePort1 + link->io.NumPorts1 - 1); 479 if (link->io.NumPorts2) 480 printk(" & 0x%04x-0x%04x", link->io.BasePort2, 481 link->io.BasePort2 + link->io.NumPorts2 - 1); 482 if (link->win) 483 printk(", mem 0x%06lx-0x%06lx", req.Base, 484 req.Base + req.Size - 1); 485 printk("\n"); 486 487 return; 488 489cs_failed: 490 labpc_release(link); 491 492} /* labpc_config */ 493 494static void labpc_release(struct pcmcia_device *link) 495{ 496 DEBUG(0, "labpc_release(0x%p)\n", link); 497 498 pcmcia_disable_device(link); 499} /* labpc_release */ 500 501/*====================================================================== 502 503 The card status event handler. Mostly, this schedules other 504 stuff to run after an event is received. 505 506 When a CARD_REMOVAL event is received, we immediately set a 507 private flag to block future accesses to this device. All the 508 functions that actually access the device should check this flag 509 to make sure the card is still present. 510 511======================================================================*/ 512 513static int labpc_cs_suspend(struct pcmcia_device *link) 514{ 515 struct local_info_t *local = link->priv; 516 517 /* Mark the device as stopped, to block IO until later */ 518 local->stop = 1; 519 return 0; 520} /* labpc_cs_suspend */ 521 522static int labpc_cs_resume(struct pcmcia_device *link) 523{ 524 struct local_info_t *local = link->priv; 525 526 local->stop = 0; 527 return 0; 528} /* labpc_cs_resume */ 529 530/*====================================================================*/ 531 532static struct pcmcia_device_id labpc_cs_ids[] = { 533 /* N.B. These IDs should match those in labpc_cs_boards (ni_labpc.c) */ 534 PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0103), /* daqcard-1200 */ 535 PCMCIA_DEVICE_NULL 536}; 537 538MODULE_DEVICE_TABLE(pcmcia, labpc_cs_ids); 539 540struct pcmcia_driver labpc_cs_driver = { 541 .probe = labpc_cs_attach, 542 .remove = labpc_cs_detach, 543 .suspend = labpc_cs_suspend, 544 .resume = labpc_cs_resume, 545 .id_table = labpc_cs_ids, 546 .owner = THIS_MODULE, 547 .drv = { 548 .name = dev_info, 549 }, 550}; 551 552static int __init init_labpc_cs(void) 553{ 554 DEBUG(0, "%s\n", version); 555 pcmcia_register_driver(&labpc_cs_driver); 556 return 0; 557} 558 559static void __exit exit_labpc_cs(void) 560{ 561 DEBUG(0, "ni_labpc: unloading\n"); 562 pcmcia_unregister_driver(&labpc_cs_driver); 563} 564 565int __init labpc_init_module(void) 566{ 567 int ret; 568 569 ret = init_labpc_cs(); 570 if (ret < 0) 571 return ret; 572 573 return comedi_driver_register(&driver_labpc_cs); 574} 575 576void __exit labpc_exit_module(void) 577{ 578 exit_labpc_cs(); 579 comedi_driver_unregister(&driver_labpc_cs); 580} 581 582MODULE_LICENSE("GPL"); 583module_init(labpc_init_module); 584module_exit(labpc_exit_module); 585