dgnc_driver.c revision 0e4f66b448c650851b1e16cae08f9700e403c341
1/* 2 * Copyright 2003 Digi International (www.digi.com) 3 * Scott H Kilau <Scott_Kilau at digi dot com> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2, or (at your option) 8 * any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY, EXPRESS OR IMPLIED; without even the 12 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 13 * PURPOSE. See the GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 18 * 19 * 20 * NOTE TO LINUX KERNEL HACKERS: DO NOT REFORMAT THIS CODE! 21 * 22 * This is shared code between Digi's CVS archive and the 23 * Linux Kernel sources. 24 * Changing the source just for reformatting needlessly breaks 25 * our CVS diff history. 26 * 27 * Send any bug fixes/changes to: Eng.Linux at digi dot com. 28 * Thank you. 29 * 30 */ 31 32 33#include <linux/kernel.h> 34#include <linux/module.h> 35#include <linux/pci.h> 36#include <linux/slab.h> 37#include <linux/sched.h> 38#include "dgnc_driver.h" 39#include "dgnc_pci.h" 40#include "dpacompat.h" 41#include "dgnc_mgmt.h" 42#include "dgnc_tty.h" 43#include "dgnc_trace.h" 44#include "dgnc_cls.h" 45#include "dgnc_neo.h" 46#include "dgnc_sysfs.h" 47 48MODULE_LICENSE("GPL"); 49MODULE_AUTHOR("Digi International, http://www.digi.com"); 50MODULE_DESCRIPTION("Driver for the Digi International Neo and Classic PCI based product line"); 51MODULE_SUPPORTED_DEVICE("dgnc"); 52 53/* 54 * insmod command line overrideable parameters 55 * 56 * NOTE: we use a set of macros to create the variables, which allows 57 * us to specify the variable type, name, initial value, and description. 58 */ 59PARM_INT(debug, 0x00, 0644, "Driver debugging level"); 60PARM_INT(rawreadok, 1, 0644, "Bypass flip buffers on input"); 61PARM_INT(trcbuf_size, 0x100000, 0644, "Debugging trace buffer size."); 62 63/************************************************************************** 64 * 65 * protos for this file 66 * 67 */ 68static int dgnc_start(void); 69static int dgnc_finalize_board_init(struct dgnc_board *brd); 70static void dgnc_init_globals(void); 71static int dgnc_found_board(struct pci_dev *pdev, int id); 72static void dgnc_cleanup_board(struct dgnc_board *brd); 73static void dgnc_poll_handler(ulong dummy); 74static int dgnc_init_pci(void); 75static int dgnc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent); 76static void dgnc_remove_one(struct pci_dev *dev); 77static int dgnc_probe1(struct pci_dev *pdev, int card_type); 78static void dgnc_do_remap(struct dgnc_board *brd); 79 80/* Driver load/unload functions */ 81int dgnc_init_module(void); 82void dgnc_cleanup_module(void); 83 84module_init(dgnc_init_module); 85module_exit(dgnc_cleanup_module); 86 87 88/* 89 * File operations permitted on Control/Management major. 90 */ 91static struct file_operations dgnc_BoardFops = 92{ 93 .owner = THIS_MODULE, 94 .unlocked_ioctl = dgnc_mgmt_ioctl, 95 .open = dgnc_mgmt_open, 96 .release = dgnc_mgmt_close 97}; 98 99 100/* 101 * Globals 102 */ 103uint dgnc_NumBoards; 104struct dgnc_board *dgnc_Board[MAXBOARDS]; 105DEFINE_SPINLOCK(dgnc_global_lock); 106int dgnc_driver_state = DRIVER_INITIALIZED; 107ulong dgnc_poll_counter; 108uint dgnc_Major; 109int dgnc_poll_tick = 20; /* Poll interval - 20 ms */ 110 111/* 112 * Static vars. 113 */ 114static uint dgnc_Major_Control_Registered = FALSE; 115static uint dgnc_driver_start = FALSE; 116 117static struct class *dgnc_class; 118 119/* 120 * Poller stuff 121 */ 122static DEFINE_SPINLOCK(dgnc_poll_lock); /* Poll scheduling lock */ 123static ulong dgnc_poll_time; /* Time of next poll */ 124static uint dgnc_poll_stop; /* Used to tell poller to stop */ 125static struct timer_list dgnc_poll_timer; 126 127 128static struct pci_device_id dgnc_pci_tbl[] = { 129 { DIGI_VID, PCI_DEVICE_CLASSIC_4_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, 130 { DIGI_VID, PCI_DEVICE_CLASSIC_4_422_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 }, 131 { DIGI_VID, PCI_DEVICE_CLASSIC_8_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 }, 132 { DIGI_VID, PCI_DEVICE_CLASSIC_8_422_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 }, 133 { DIGI_VID, PCI_DEVICE_NEO_4_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 }, 134 { DIGI_VID, PCI_DEVICE_NEO_8_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 }, 135 { DIGI_VID, PCI_DEVICE_NEO_2DB9_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 }, 136 { DIGI_VID, PCI_DEVICE_NEO_2DB9PRI_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 7 }, 137 { DIGI_VID, PCI_DEVICE_NEO_2RJ45_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 }, 138 { DIGI_VID, PCI_DEVICE_NEO_2RJ45PRI_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 9 }, 139 { DIGI_VID, PCI_DEVICE_NEO_1_422_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 10 }, 140 { DIGI_VID, PCI_DEVICE_NEO_1_422_485_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 11 }, 141 { DIGI_VID, PCI_DEVICE_NEO_2_422_485_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 12 }, 142 { DIGI_VID, PCI_DEVICE_NEO_EXPRESS_8_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 13 }, 143 { DIGI_VID, PCI_DEVICE_NEO_EXPRESS_4_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 14 }, 144 { DIGI_VID, PCI_DEVICE_NEO_EXPRESS_4RJ45_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 15 }, 145 { DIGI_VID, PCI_DEVICE_NEO_EXPRESS_8RJ45_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 16 }, 146 {0,} /* 0 terminated list. */ 147}; 148MODULE_DEVICE_TABLE(pci, dgnc_pci_tbl); 149 150struct board_id { 151 uchar *name; 152 uint maxports; 153 unsigned int is_pci_express; 154}; 155 156static struct board_id dgnc_Ids[] = 157{ 158 { PCI_DEVICE_CLASSIC_4_PCI_NAME, 4, 0 }, 159 { PCI_DEVICE_CLASSIC_4_422_PCI_NAME, 4, 0 }, 160 { PCI_DEVICE_CLASSIC_8_PCI_NAME, 8, 0 }, 161 { PCI_DEVICE_CLASSIC_8_422_PCI_NAME, 8, 0 }, 162 { PCI_DEVICE_NEO_4_PCI_NAME, 4, 0 }, 163 { PCI_DEVICE_NEO_8_PCI_NAME, 8, 0 }, 164 { PCI_DEVICE_NEO_2DB9_PCI_NAME, 2, 0 }, 165 { PCI_DEVICE_NEO_2DB9PRI_PCI_NAME, 2, 0 }, 166 { PCI_DEVICE_NEO_2RJ45_PCI_NAME, 2, 0 }, 167 { PCI_DEVICE_NEO_2RJ45PRI_PCI_NAME, 2, 0 }, 168 { PCI_DEVICE_NEO_1_422_PCI_NAME, 1, 0 }, 169 { PCI_DEVICE_NEO_1_422_485_PCI_NAME, 1, 0 }, 170 { PCI_DEVICE_NEO_2_422_485_PCI_NAME, 2, 0 }, 171 { PCI_DEVICE_NEO_EXPRESS_8_PCI_NAME, 8, 1 }, 172 { PCI_DEVICE_NEO_EXPRESS_4_PCI_NAME, 4, 1 }, 173 { PCI_DEVICE_NEO_EXPRESS_4RJ45_PCI_NAME, 4, 1 }, 174 { PCI_DEVICE_NEO_EXPRESS_8RJ45_PCI_NAME, 8, 1 }, 175 { NULL, 0, 0 } 176}; 177 178static struct pci_driver dgnc_driver = { 179 .name = "dgnc", 180 .probe = dgnc_init_one, 181 .id_table = dgnc_pci_tbl, 182 .remove = dgnc_remove_one, 183}; 184 185 186char *dgnc_state_text[] = { 187 "Board Failed", 188 "Board Found", 189 "Board READY", 190}; 191 192char *dgnc_driver_state_text[] = { 193 "Driver Initialized", 194 "Driver Ready." 195}; 196 197 198 199/************************************************************************ 200 * 201 * Driver load/unload functions 202 * 203 ************************************************************************/ 204 205 206/* 207 * init_module() 208 * 209 * Module load. This is where it all starts. 210 */ 211int dgnc_init_module(void) 212{ 213 int rc = 0; 214 215 APR(("%s, Digi International Part Number %s\n", DG_NAME, DG_PART)); 216 217 /* 218 * Initialize global stuff 219 */ 220 rc = dgnc_start(); 221 222 if (rc < 0) { 223 return rc; 224 } 225 226 /* 227 * Find and configure all the cards 228 */ 229 rc = dgnc_init_pci(); 230 231 /* 232 * If something went wrong in the scan, bail out of driver. 233 */ 234 if (rc < 0) { 235 /* Only unregister the pci driver if it was actually registered. */ 236 if (dgnc_NumBoards) 237 pci_unregister_driver(&dgnc_driver); 238 else 239 printk("WARNING: dgnc driver load failed. No Digi Neo or Classic boards found.\n"); 240 241 dgnc_cleanup_module(); 242 } 243 else { 244 dgnc_create_driver_sysfiles(&dgnc_driver); 245 } 246 247 DPR_INIT(("Finished init_module. Returning %d\n", rc)); 248 return rc; 249} 250 251 252/* 253 * Start of driver. 254 */ 255static int dgnc_start(void) 256{ 257 int rc = 0; 258 unsigned long flags; 259 260 if (dgnc_driver_start == FALSE) { 261 262 dgnc_driver_start = TRUE; 263 264 /* make sure that the globals are init'd before we do anything else */ 265 dgnc_init_globals(); 266 267 dgnc_NumBoards = 0; 268 269 APR(("For the tools package or updated drivers please visit http://www.digi.com\n")); 270 271 /* 272 * Register our base character device into the kernel. 273 * This allows the download daemon to connect to the downld device 274 * before any of the boards are init'ed. 275 */ 276 if (!dgnc_Major_Control_Registered) { 277 /* 278 * Register management/dpa devices 279 */ 280 rc = register_chrdev(0, "dgnc", &dgnc_BoardFops); 281 if (rc <= 0) { 282 APR(("Can't register dgnc driver device (%d)\n", rc)); 283 rc = -ENXIO; 284 return rc; 285 } 286 dgnc_Major = rc; 287 288 dgnc_class = class_create(THIS_MODULE, "dgnc_mgmt"); 289 device_create(dgnc_class, NULL, 290 MKDEV(dgnc_Major, 0), 291 NULL, "dgnc_mgmt"); 292 dgnc_Major_Control_Registered = TRUE; 293 } 294 295 /* 296 * Init any global tty stuff. 297 */ 298 rc = dgnc_tty_preinit(); 299 300 if (rc < 0) { 301 APR(("tty preinit - not enough memory (%d)\n", rc)); 302 return rc; 303 } 304 305 /* Start the poller */ 306 DGNC_LOCK(dgnc_poll_lock, flags); 307 init_timer(&dgnc_poll_timer); 308 dgnc_poll_timer.function = dgnc_poll_handler; 309 dgnc_poll_timer.data = 0; 310 dgnc_poll_time = jiffies + dgnc_jiffies_from_ms(dgnc_poll_tick); 311 dgnc_poll_timer.expires = dgnc_poll_time; 312 DGNC_UNLOCK(dgnc_poll_lock, flags); 313 314 add_timer(&dgnc_poll_timer); 315 316 dgnc_driver_state = DRIVER_READY; 317 } 318 319 return rc; 320} 321 322/* 323 * Register pci driver, and return how many boards we have. 324 */ 325static int dgnc_init_pci(void) 326{ 327 return pci_register_driver(&dgnc_driver); 328} 329 330 331/* returns count (>= 0), or negative on error */ 332static int dgnc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent) 333{ 334 int rc; 335 336 /* wake up and enable device */ 337 rc = pci_enable_device(pdev); 338 339 if (rc < 0) { 340 rc = -EIO; 341 } else { 342 rc = dgnc_probe1(pdev, ent->driver_data); 343 if (rc == 0) { 344 dgnc_NumBoards++; 345 DPR_INIT(("Incrementing numboards to %d\n", dgnc_NumBoards)); 346 } 347 } 348 return rc; 349} 350 351static int dgnc_probe1(struct pci_dev *pdev, int card_type) 352{ 353 return dgnc_found_board(pdev, card_type); 354} 355 356 357static void dgnc_remove_one(struct pci_dev *dev) 358{ 359 /* Do Nothing */ 360} 361 362/* 363 * dgnc_cleanup_module() 364 * 365 * Module unload. This is where it all ends. 366 */ 367void dgnc_cleanup_module(void) 368{ 369 int i; 370 ulong lock_flags; 371 372 DGNC_LOCK(dgnc_poll_lock, lock_flags); 373 dgnc_poll_stop = 1; 374 DGNC_UNLOCK(dgnc_poll_lock, lock_flags); 375 376 /* Turn off poller right away. */ 377 del_timer_sync(&dgnc_poll_timer); 378 379 dgnc_remove_driver_sysfiles(&dgnc_driver); 380 381 if (dgnc_Major_Control_Registered) { 382 device_destroy(dgnc_class, MKDEV(dgnc_Major, 0)); 383 class_destroy(dgnc_class); 384 unregister_chrdev(dgnc_Major, "dgnc"); 385 } 386 387 for (i = 0; i < dgnc_NumBoards; ++i) { 388 dgnc_remove_ports_sysfiles(dgnc_Board[i]); 389 dgnc_tty_uninit(dgnc_Board[i]); 390 dgnc_cleanup_board(dgnc_Board[i]); 391 } 392 393 dgnc_tty_post_uninit(); 394 395#if defined(DGNC_TRACER) 396 /* last thing, make sure we release the tracebuffer */ 397 dgnc_tracer_free(); 398#endif 399 if (dgnc_NumBoards) 400 pci_unregister_driver(&dgnc_driver); 401} 402 403 404/* 405 * dgnc_cleanup_board() 406 * 407 * Free all the memory associated with a board 408 */ 409static void dgnc_cleanup_board(struct dgnc_board *brd) 410{ 411 int i = 0; 412 413 if(!brd || brd->magic != DGNC_BOARD_MAGIC) 414 return; 415 416 switch (brd->device) { 417 case PCI_DEVICE_CLASSIC_4_DID: 418 case PCI_DEVICE_CLASSIC_8_DID: 419 case PCI_DEVICE_CLASSIC_4_422_DID: 420 case PCI_DEVICE_CLASSIC_8_422_DID: 421 422 /* Tell card not to interrupt anymore. */ 423 outb(0, brd->iobase + 0x4c); 424 break; 425 426 default: 427 break; 428 } 429 430 if (brd->irq) 431 free_irq(brd->irq, brd); 432 433 tasklet_kill(&brd->helper_tasklet); 434 435 if (brd->re_map_membase) { 436 iounmap(brd->re_map_membase); 437 brd->re_map_membase = NULL; 438 } 439 440 if (brd->msgbuf_head) { 441 unsigned long flags; 442 443 DGNC_LOCK(dgnc_global_lock, flags); 444 brd->msgbuf = NULL; 445 printk("%s", brd->msgbuf_head); 446 kfree(brd->msgbuf_head); 447 brd->msgbuf_head = NULL; 448 DGNC_UNLOCK(dgnc_global_lock, flags); 449 } 450 451 /* Free all allocated channels structs */ 452 for (i = 0; i < MAXPORTS ; i++) { 453 if (brd->channels[i]) { 454 if (brd->channels[i]->ch_rqueue) 455 kfree(brd->channels[i]->ch_rqueue); 456 if (brd->channels[i]->ch_equeue) 457 kfree(brd->channels[i]->ch_equeue); 458 if (brd->channels[i]->ch_wqueue) 459 kfree(brd->channels[i]->ch_wqueue); 460 461 kfree(brd->channels[i]); 462 brd->channels[i] = NULL; 463 } 464 } 465 466 if (brd->flipbuf) 467 kfree(brd->flipbuf); 468 469 dgnc_Board[brd->boardnum] = NULL; 470 471 kfree(brd); 472} 473 474 475/* 476 * dgnc_found_board() 477 * 478 * A board has been found, init it. 479 */ 480static int dgnc_found_board(struct pci_dev *pdev, int id) 481{ 482 struct dgnc_board *brd; 483 unsigned int pci_irq; 484 int i = 0; 485 int rc = 0; 486 unsigned long flags; 487 488 /* get the board structure and prep it */ 489 brd = dgnc_Board[dgnc_NumBoards] = 490 kzalloc(sizeof(struct dgnc_board), GFP_KERNEL); 491 if (!brd) { 492 APR(("memory allocation for board structure failed\n")); 493 return -ENOMEM; 494 } 495 496 /* make a temporary message buffer for the boot messages */ 497 brd->msgbuf = brd->msgbuf_head = 498 kzalloc(sizeof(char) * 8192, GFP_KERNEL); 499 if (!brd->msgbuf) { 500 kfree(brd); 501 APR(("memory allocation for board msgbuf failed\n")); 502 return -ENOMEM; 503 } 504 505 /* store the info for the board we've found */ 506 brd->magic = DGNC_BOARD_MAGIC; 507 brd->boardnum = dgnc_NumBoards; 508 brd->vendor = dgnc_pci_tbl[id].vendor; 509 brd->device = dgnc_pci_tbl[id].device; 510 brd->pdev = pdev; 511 brd->pci_bus = pdev->bus->number; 512 brd->pci_slot = PCI_SLOT(pdev->devfn); 513 brd->name = dgnc_Ids[id].name; 514 brd->maxports = dgnc_Ids[id].maxports; 515 if (dgnc_Ids[i].is_pci_express) 516 brd->bd_flags |= BD_IS_PCI_EXPRESS; 517 brd->dpastatus = BD_NOFEP; 518 init_waitqueue_head(&brd->state_wait); 519 520 DGNC_SPINLOCK_INIT(brd->bd_lock); 521 DGNC_SPINLOCK_INIT(brd->bd_intr_lock); 522 523 brd->state = BOARD_FOUND; 524 525 for (i = 0; i < MAXPORTS; i++) { 526 brd->channels[i] = NULL; 527 } 528 529 /* store which card & revision we have */ 530 pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &brd->subvendor); 531 pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &brd->subdevice); 532 pci_read_config_byte(pdev, PCI_REVISION_ID, &brd->rev); 533 534 pci_irq = pdev->irq; 535 brd->irq = pci_irq; 536 537 538 switch(brd->device) { 539 540 case PCI_DEVICE_CLASSIC_4_DID: 541 case PCI_DEVICE_CLASSIC_8_DID: 542 case PCI_DEVICE_CLASSIC_4_422_DID: 543 case PCI_DEVICE_CLASSIC_8_422_DID: 544 545 brd->dpatype = T_CLASSIC | T_PCIBUS; 546 547 DPR_INIT(("dgnc_found_board - Classic.\n")); 548 549 /* 550 * For PCI ClassicBoards 551 * PCI Local Address (i.e. "resource" number) space 552 * 0 PLX Memory Mapped Config 553 * 1 PLX I/O Mapped Config 554 * 2 I/O Mapped UARTs and Status 555 * 3 Memory Mapped VPD 556 * 4 Memory Mapped UARTs and Status 557 */ 558 559 560 /* get the PCI Base Address Registers */ 561 brd->membase = pci_resource_start(pdev, 4); 562 563 if (!brd->membase) { 564 APR(("card has no PCI IO resources, failing board.\n")); 565 return -ENODEV; 566 } 567 568 brd->membase_end = pci_resource_end(pdev, 4); 569 570 if (brd->membase & 1) 571 brd->membase &= ~3; 572 else 573 brd->membase &= ~15; 574 575 brd->iobase = pci_resource_start(pdev, 1); 576 brd->iobase_end = pci_resource_end(pdev, 1); 577 brd->iobase = ((unsigned int) (brd->iobase)) & 0xFFFE; 578 579 /* Assign the board_ops struct */ 580 brd->bd_ops = &dgnc_cls_ops; 581 582 brd->bd_uart_offset = 0x8; 583 brd->bd_dividend = 921600; 584 585 dgnc_do_remap(brd); 586 587 /* Get and store the board VPD, if it exists */ 588 brd->bd_ops->vpd(brd); 589 590 /* 591 * Enable Local Interrupt 1 (0x1), 592 * Local Interrupt 1 Polarity Active high (0x2), 593 * Enable PCI interrupt (0x40) 594 */ 595 outb(0x43, brd->iobase + 0x4c); 596 597 break; 598 599 600 case PCI_DEVICE_NEO_4_DID: 601 case PCI_DEVICE_NEO_8_DID: 602 case PCI_DEVICE_NEO_2DB9_DID: 603 case PCI_DEVICE_NEO_2DB9PRI_DID: 604 case PCI_DEVICE_NEO_2RJ45_DID: 605 case PCI_DEVICE_NEO_2RJ45PRI_DID: 606 case PCI_DEVICE_NEO_1_422_DID: 607 case PCI_DEVICE_NEO_1_422_485_DID: 608 case PCI_DEVICE_NEO_2_422_485_DID: 609 case PCI_DEVICE_NEO_EXPRESS_8_DID: 610 case PCI_DEVICE_NEO_EXPRESS_4_DID: 611 case PCI_DEVICE_NEO_EXPRESS_4RJ45_DID: 612 case PCI_DEVICE_NEO_EXPRESS_8RJ45_DID: 613 614 /* 615 * This chip is set up 100% when we get to it. 616 * No need to enable global interrupts or anything. 617 */ 618 if (brd->bd_flags & BD_IS_PCI_EXPRESS) 619 brd->dpatype = T_NEO_EXPRESS | T_PCIBUS; 620 else 621 brd->dpatype = T_NEO | T_PCIBUS; 622 623 DPR_INIT(("dgnc_found_board - NEO.\n")); 624 625 /* get the PCI Base Address Registers */ 626 brd->membase = pci_resource_start(pdev, 0); 627 brd->membase_end = pci_resource_end(pdev, 0); 628 629 if (brd->membase & 1) 630 brd->membase &= ~3; 631 else 632 brd->membase &= ~15; 633 634 /* Assign the board_ops struct */ 635 brd->bd_ops = &dgnc_neo_ops; 636 637 brd->bd_uart_offset = 0x200; 638 brd->bd_dividend = 921600; 639 640 dgnc_do_remap(brd); 641 642 if (brd->re_map_membase) { 643 644 /* After remap is complete, we need to read and store the dvid */ 645 brd->dvid = readb(brd->re_map_membase + 0x8D); 646 647 /* Get and store the board VPD, if it exists */ 648 brd->bd_ops->vpd(brd); 649 } 650 break; 651 652 default: 653 APR(("Did not find any compatible Neo or Classic PCI boards in system.\n")); 654 return -ENXIO; 655 656 } 657 658 /* 659 * Do tty device initialization. 660 */ 661 662 rc = dgnc_tty_register(brd); 663 if (rc < 0) { 664 dgnc_tty_uninit(brd); 665 APR(("Can't register tty devices (%d)\n", rc)); 666 brd->state = BOARD_FAILED; 667 brd->dpastatus = BD_NOFEP; 668 goto failed; 669 } 670 671 rc = dgnc_finalize_board_init(brd); 672 if (rc < 0) { 673 APR(("Can't finalize board init (%d)\n", rc)); 674 brd->state = BOARD_FAILED; 675 brd->dpastatus = BD_NOFEP; 676 677 goto failed; 678 } 679 680 rc = dgnc_tty_init(brd); 681 if (rc < 0) { 682 dgnc_tty_uninit(brd); 683 APR(("Can't init tty devices (%d)\n", rc)); 684 brd->state = BOARD_FAILED; 685 brd->dpastatus = BD_NOFEP; 686 687 goto failed; 688 } 689 690 brd->state = BOARD_READY; 691 brd->dpastatus = BD_RUNNING; 692 693 dgnc_create_ports_sysfiles(brd); 694 695 /* init our poll helper tasklet */ 696 tasklet_init(&brd->helper_tasklet, brd->bd_ops->tasklet, (unsigned long) brd); 697 698 DPR_INIT(("dgnc_scan(%d) - printing out the msgbuf\n", i)); 699 DGNC_LOCK(dgnc_global_lock, flags); 700 brd->msgbuf = NULL; 701 printk("%s", brd->msgbuf_head); 702 kfree(brd->msgbuf_head); 703 brd->msgbuf_head = NULL; 704 DGNC_UNLOCK(dgnc_global_lock, flags); 705 706 /* 707 * allocate flip buffer for board. 708 * 709 * Okay to malloc with GFP_KERNEL, we are not at interrupt 710 * context, and there are no locks held. 711 */ 712 brd->flipbuf = kzalloc(MYFLIPLEN, GFP_KERNEL); 713 714 wake_up_interruptible(&brd->state_wait); 715 716 return 0; 717 718failed: 719 720 return -ENXIO; 721 722} 723 724 725static int dgnc_finalize_board_init(struct dgnc_board *brd) { 726 int rc = 0; 727 728 DPR_INIT(("dgnc_finalize_board_init() - start\n")); 729 730 if (!brd || brd->magic != DGNC_BOARD_MAGIC) 731 return -ENODEV; 732 733 DPR_INIT(("dgnc_finalize_board_init() - start #2\n")); 734 735 if (brd->irq) { 736 rc = request_irq(brd->irq, brd->bd_ops->intr, IRQF_SHARED, "DGNC", brd); 737 738 if (rc) { 739 printk("Failed to hook IRQ %d\n",brd->irq); 740 brd->state = BOARD_FAILED; 741 brd->dpastatus = BD_NOFEP; 742 rc = -ENODEV; 743 } else { 744 DPR_INIT(("Requested and received usage of IRQ %d\n", brd->irq)); 745 } 746 } 747 return rc; 748} 749 750/* 751 * Remap PCI memory. 752 */ 753static void dgnc_do_remap(struct dgnc_board *brd) 754{ 755 756 if (!brd || brd->magic != DGNC_BOARD_MAGIC) 757 return; 758 759 brd->re_map_membase = ioremap(brd->membase, 0x1000); 760 761 DPR_INIT(("remapped mem: 0x%p\n", brd->re_map_membase)); 762} 763 764 765/***************************************************************************** 766* 767* Function: 768* 769* dgnc_poll_handler 770* 771* Author: 772* 773* Scott H Kilau 774* 775* Parameters: 776* 777* dummy -- ignored 778* 779* Return Values: 780* 781* none 782* 783* Description: 784* 785* As each timer expires, it determines (a) whether the "transmit" 786* waiter needs to be woken up, and (b) whether the poller needs to 787* be rescheduled. 788* 789******************************************************************************/ 790 791static void dgnc_poll_handler(ulong dummy) 792{ 793 struct dgnc_board *brd; 794 unsigned long lock_flags; 795 int i; 796 unsigned long new_time; 797 798 dgnc_poll_counter++; 799 800 /* 801 * Do not start the board state machine until 802 * driver tells us its up and running, and has 803 * everything it needs. 804 */ 805 if (dgnc_driver_state != DRIVER_READY) { 806 goto schedule_poller; 807 } 808 809 /* Go thru each board, kicking off a tasklet for each if needed */ 810 for (i = 0; i < dgnc_NumBoards; i++) { 811 brd = dgnc_Board[i]; 812 813 DGNC_LOCK(brd->bd_lock, lock_flags); 814 815 /* If board is in a failed state, don't bother scheduling a tasklet */ 816 if (brd->state == BOARD_FAILED) { 817 DGNC_UNLOCK(brd->bd_lock, lock_flags); 818 continue; 819 } 820 821 /* Schedule a poll helper task */ 822 tasklet_schedule(&brd->helper_tasklet); 823 824 DGNC_UNLOCK(brd->bd_lock, lock_flags); 825 } 826 827schedule_poller: 828 829 /* 830 * Schedule ourself back at the nominal wakeup interval. 831 */ 832 DGNC_LOCK(dgnc_poll_lock, lock_flags); 833 dgnc_poll_time += dgnc_jiffies_from_ms(dgnc_poll_tick); 834 835 new_time = dgnc_poll_time - jiffies; 836 837 if ((ulong) new_time >= 2 * dgnc_poll_tick) { 838 dgnc_poll_time = jiffies + dgnc_jiffies_from_ms(dgnc_poll_tick); 839 } 840 841 init_timer(&dgnc_poll_timer); 842 dgnc_poll_timer.function = dgnc_poll_handler; 843 dgnc_poll_timer.data = 0; 844 dgnc_poll_timer.expires = dgnc_poll_time; 845 DGNC_UNLOCK(dgnc_poll_lock, lock_flags); 846 847 if (!dgnc_poll_stop) 848 add_timer(&dgnc_poll_timer); 849} 850 851/* 852 * dgnc_init_globals() 853 * 854 * This is where we initialize the globals from the static insmod 855 * configuration variables. These are declared near the head of 856 * this file. 857 */ 858static void dgnc_init_globals(void) 859{ 860 int i = 0; 861 862 dgnc_rawreadok = rawreadok; 863 dgnc_trcbuf_size = trcbuf_size; 864 dgnc_debug = debug; 865 866 for (i = 0; i < MAXBOARDS; i++) { 867 dgnc_Board[i] = NULL; 868 } 869 870 init_timer(&dgnc_poll_timer); 871} 872 873 874/************************************************************************ 875 * 876 * Utility functions 877 * 878 ************************************************************************/ 879 880/* 881 * dgnc_ms_sleep() 882 * 883 * Put the driver to sleep for x ms's 884 * 885 * Returns 0 if timed out, !0 (showing signal) if interrupted by a signal. 886 */ 887int dgnc_ms_sleep(ulong ms) 888{ 889 current->state = TASK_INTERRUPTIBLE; 890 schedule_timeout((ms * HZ) / 1000); 891 return signal_pending(current); 892} 893 894 895 896/* 897 * dgnc_ioctl_name() : Returns a text version of each ioctl value. 898 */ 899char *dgnc_ioctl_name(int cmd) 900{ 901 switch(cmd) { 902 903 case TCGETA: return "TCGETA"; 904 case TCGETS: return "TCGETS"; 905 case TCSETA: return "TCSETA"; 906 case TCSETS: return "TCSETS"; 907 case TCSETAW: return "TCSETAW"; 908 case TCSETSW: return "TCSETSW"; 909 case TCSETAF: return "TCSETAF"; 910 case TCSETSF: return "TCSETSF"; 911 case TCSBRK: return "TCSBRK"; 912 case TCXONC: return "TCXONC"; 913 case TCFLSH: return "TCFLSH"; 914 case TIOCGSID: return "TIOCGSID"; 915 916 case TIOCGETD: return "TIOCGETD"; 917 case TIOCSETD: return "TIOCSETD"; 918 case TIOCGWINSZ: return "TIOCGWINSZ"; 919 case TIOCSWINSZ: return "TIOCSWINSZ"; 920 921 case TIOCMGET: return "TIOCMGET"; 922 case TIOCMSET: return "TIOCMSET"; 923 case TIOCMBIS: return "TIOCMBIS"; 924 case TIOCMBIC: return "TIOCMBIC"; 925 926 /* from digi.h */ 927 case DIGI_SETA: return "DIGI_SETA"; 928 case DIGI_SETAW: return "DIGI_SETAW"; 929 case DIGI_SETAF: return "DIGI_SETAF"; 930 case DIGI_SETFLOW: return "DIGI_SETFLOW"; 931 case DIGI_SETAFLOW: return "DIGI_SETAFLOW"; 932 case DIGI_GETFLOW: return "DIGI_GETFLOW"; 933 case DIGI_GETAFLOW: return "DIGI_GETAFLOW"; 934 case DIGI_GETA: return "DIGI_GETA"; 935 case DIGI_GEDELAY: return "DIGI_GEDELAY"; 936 case DIGI_SEDELAY: return "DIGI_SEDELAY"; 937 case DIGI_GETCUSTOMBAUD: return "DIGI_GETCUSTOMBAUD"; 938 case DIGI_SETCUSTOMBAUD: return "DIGI_SETCUSTOMBAUD"; 939 case TIOCMODG: return "TIOCMODG"; 940 case TIOCMODS: return "TIOCMODS"; 941 case TIOCSDTR: return "TIOCSDTR"; 942 case TIOCCDTR: return "TIOCCDTR"; 943 944 default: return "unknown"; 945 } 946} 947