2 * Copyright 2003 Digi International (www.digi.com)
3 * Scott H Kilau <Scott_Kilau at digi dot com>
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)
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.
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.
20 * NOTE TO LINUX KERNEL HACKERS: DO NOT REFORMAT THIS CODE!
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.
27 * Send any bug fixes/changes to: Eng.Linux at digi dot com.
30 * $Id: dgap_driver.c,v 1.3 2011/06/21 10:35:16 markh Exp $
34 #include <linux/kernel.h>
35 #include <linux/version.h>
36 #include <linux/module.h>
37 #include <linux/pci.h>
38 #include <linux/delay.h> /* For udelay */
39 #include <linux/slab.h>
40 #include <asm/uaccess.h> /* For copy_from_user/copy_to_user */
42 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,39)
43 #include <linux/sched.h>
46 #include "dgap_driver.h"
48 #include "dgap_fep5.h"
50 #include "dgap_conf.h"
51 #include "dgap_parse.h"
52 #include "dgap_trace.h"
53 #include "dgap_sysfs.h"
55 MODULE_LICENSE("GPL");
56 MODULE_AUTHOR("Digi International, http://www.digi.com");
57 MODULE_DESCRIPTION("Driver for the Digi International EPCA PCI based product line");
58 MODULE_SUPPORTED_DEVICE("dgap");
61 * insmod command line overrideable parameters
63 * NOTE: we use a set of macros to create the variables, which allows
64 * us to specify the variable type, name, initial value, and description.
66 PARM_INT(debug, 0x00, 0644, "Driver debugging level");
67 PARM_INT(rawreadok, 1, 0644, "Bypass flip buffers on input");
68 PARM_INT(trcbuf_size, 0x100000, 0644, "Debugging trace buffer size.");
71 /**************************************************************************
73 * protos for this file
77 static int dgap_start(void);
78 static void dgap_init_globals(void);
79 static int dgap_found_board(struct pci_dev *pdev, int id);
80 static void dgap_cleanup_board(struct board_t *brd);
81 static void dgap_poll_handler(ulong dummy);
82 static int dgap_init_pci(void);
83 static int dgap_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
84 static void dgap_remove_one(struct pci_dev *dev);
85 static int dgap_probe1(struct pci_dev *pdev, int card_type);
86 static void dgap_mbuf(struct board_t *brd, const char *fmt, ...);
87 static int dgap_do_remap(struct board_t *brd);
88 static irqreturn_t dgap_intr(int irq, void *voidbrd);
90 /* Driver load/unload functions */
91 int dgap_init_module(void);
92 void dgap_cleanup_module(void);
94 module_init(dgap_init_module);
95 module_exit(dgap_cleanup_module);
99 * File operations permitted on Control/Management major.
101 static struct file_operations DgapBoardFops =
103 .owner = THIS_MODULE,
111 struct board_t *dgap_Board[MAXBOARDS];
112 DEFINE_SPINLOCK(dgap_global_lock);
113 ulong dgap_poll_counter;
114 char *dgap_config_buf;
115 int dgap_driver_state = DRIVER_INITIALIZED;
116 DEFINE_SPINLOCK(dgap_dl_lock);
117 wait_queue_head_t dgap_dl_wait;
119 int dgap_poll_tick = 20; /* Poll interval - 20 ms */
124 static int dgap_Major_Control_Registered = FALSE;
125 static uint dgap_driver_start = FALSE;
127 static struct class * dgap_class;
132 static DEFINE_SPINLOCK(dgap_poll_lock); /* Poll scheduling lock */
133 static ulong dgap_poll_time; /* Time of next poll */
134 static uint dgap_poll_stop; /* Used to tell poller to stop */
135 static struct timer_list dgap_poll_timer;
138 static struct pci_device_id dgap_pci_tbl[] = {
139 { DIGI_VID, PCI_DEVICE_XEM_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
140 { DIGI_VID, PCI_DEVICE_CX_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
141 { DIGI_VID, PCI_DEVICE_CX_IBM_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2 },
142 { DIGI_VID, PCI_DEVICE_EPCJ_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3 },
143 { DIGI_VID, PCI_DEVICE_920_2_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
144 { DIGI_VID, PCI_DEVICE_920_4_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
145 { DIGI_VID, PCI_DEVICE_920_8_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
146 { DIGI_VID, PCI_DEVICE_XR_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 7 },
147 { DIGI_VID, PCI_DEVICE_XRJ_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 8 },
148 { DIGI_VID, PCI_DEVICE_XR_422_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 9 },
149 { DIGI_VID, PCI_DEVICE_XR_IBM_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 10 },
150 { DIGI_VID, PCI_DEVICE_XR_SAIP_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 11 },
151 { DIGI_VID, PCI_DEVICE_XR_BULL_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 12 },
152 { DIGI_VID, PCI_DEVICE_920_8_HP_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 13 },
153 { DIGI_VID, PCI_DEVICE_XEM_HP_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 14 },
154 {0,} /* 0 terminated list. */
156 MODULE_DEVICE_TABLE(pci, dgap_pci_tbl);
160 * A generic list of Product names, PCI Vendor ID, and PCI Device ID.
169 static struct board_id dgap_Ids[] =
171 { PPCM, PCI_DEVICE_XEM_NAME, 64, (T_PCXM | T_PCLITE | T_PCIBUS) },
172 { PCX, PCI_DEVICE_CX_NAME, 128, (T_CX | T_PCIBUS) },
173 { PCX, PCI_DEVICE_CX_IBM_NAME, 128, (T_CX | T_PCIBUS) },
174 { PEPC, PCI_DEVICE_EPCJ_NAME, 224, (T_EPC | T_PCIBUS) },
175 { APORT2_920P, PCI_DEVICE_920_2_NAME, 2, (T_PCXR | T_PCLITE | T_PCIBUS) },
176 { APORT4_920P, PCI_DEVICE_920_4_NAME, 4, (T_PCXR | T_PCLITE | T_PCIBUS) },
177 { APORT8_920P, PCI_DEVICE_920_8_NAME, 8, (T_PCXR | T_PCLITE | T_PCIBUS) },
178 { PAPORT8, PCI_DEVICE_XR_NAME, 8, (T_PCXR | T_PCLITE | T_PCIBUS) },
179 { PAPORT8, PCI_DEVICE_XRJ_NAME, 8, (T_PCXR | T_PCLITE | T_PCIBUS) },
180 { PAPORT8, PCI_DEVICE_XR_422_NAME, 8, (T_PCXR | T_PCLITE | T_PCIBUS) },
181 { PAPORT8, PCI_DEVICE_XR_IBM_NAME, 8, (T_PCXR | T_PCLITE | T_PCIBUS) },
182 { PAPORT8, PCI_DEVICE_XR_SAIP_NAME, 8, (T_PCXR | T_PCLITE | T_PCIBUS) },
183 { PAPORT8, PCI_DEVICE_XR_BULL_NAME, 8, (T_PCXR | T_PCLITE | T_PCIBUS) },
184 { APORT8_920P, PCI_DEVICE_920_8_HP_NAME, 8, (T_PCXR | T_PCLITE | T_PCIBUS) },
185 { PPCM, PCI_DEVICE_XEM_HP_NAME, 64, (T_PCXM | T_PCLITE | T_PCIBUS) },
186 {0,} /* 0 terminated list. */
189 static struct pci_driver dgap_driver = {
191 .probe = dgap_init_one,
192 .id_table = dgap_pci_tbl,
193 .remove = dgap_remove_one,
197 char *dgap_state_text[] = {
199 "Configuration for board not found.\n\t\t\tRun mpi to configure board.",
205 "Need Device Creation",
206 "Requested Device Creation",
207 "Finished Device Creation",
211 "Finished BIOS Load",
216 "Requested PROC creation",
217 "Finished PROC creation",
221 char *dgap_driver_state_text[] = {
222 "Driver Initialized",
223 "Driver needs configuration load.",
224 "Driver requested configuration from download daemon.",
230 /************************************************************************
232 * Driver load/unload functions
234 ************************************************************************/
239 * Module load. This is where it all starts.
241 int dgap_init_module(void)
245 APR(("%s, Digi International Part Number %s\n", DG_NAME, DG_PART));
248 * Initialize global stuff
257 * Find and configure all the cards
259 rc = dgap_init_pci();
262 * If something went wrong in the scan, bail out of driver.
265 /* Only unregister the pci driver if it was actually registered. */
267 pci_unregister_driver(&dgap_driver);
269 printk("WARNING: dgap driver load failed. No DGAP boards found.\n");
271 dgap_cleanup_module();
274 dgap_create_driver_sysfiles(&dgap_driver);
277 DPR_INIT(("Finished init_module. Returning %d\n", rc));
285 static int dgap_start(void)
290 if (dgap_driver_start == FALSE) {
292 dgap_driver_start = TRUE;
294 /* make sure that the globals are init'd before we do anything else */
299 APR(("For the tools package or updated drivers please visit http://www.digi.com\n"));
302 * Register our base character device into the kernel.
303 * This allows the download daemon to connect to the downld device
304 * before any of the boards are init'ed.
306 if (!dgap_Major_Control_Registered) {
308 * Register management/dpa devices
310 rc = register_chrdev(DIGI_DGAP_MAJOR, "dgap", &DgapBoardFops);
312 APR(("Can't register dgap driver device (%d)\n", rc));
316 dgap_class = class_create(THIS_MODULE, "dgap_mgmt");
317 device_create(dgap_class, NULL,
318 MKDEV(DIGI_DGAP_MAJOR, 0),
320 device_create(dgap_class, NULL,
321 MKDEV(DIGI_DGAP_MAJOR, 1),
322 NULL, "dgap_downld");
323 dgap_Major_Control_Registered = TRUE;
327 * Init any global tty stuff.
329 rc = dgap_tty_preinit();
332 APR(("tty preinit - not enough memory (%d)\n", rc));
336 /* Start the poller */
337 DGAP_LOCK(dgap_poll_lock, flags);
338 init_timer(&dgap_poll_timer);
339 dgap_poll_timer.function = dgap_poll_handler;
340 dgap_poll_timer.data = 0;
341 dgap_poll_time = jiffies + dgap_jiffies_from_ms(dgap_poll_tick);
342 dgap_poll_timer.expires = dgap_poll_time;
343 DGAP_UNLOCK(dgap_poll_lock, flags);
345 add_timer(&dgap_poll_timer);
347 dgap_driver_state = DRIVER_NEED_CONFIG_LOAD;
355 * Register pci driver, and return how many boards we have.
357 static int dgap_init_pci(void)
359 return pci_register_driver(&dgap_driver);
363 /* returns count (>= 0), or negative on error */
364 static int dgap_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
368 /* wake up and enable device */
369 rc = pci_enable_device(pdev);
374 rc = dgap_probe1(pdev, ent->driver_data);
377 DPR_INIT(("Incrementing numboards to %d\n", dgap_NumBoards));
384 static int dgap_probe1(struct pci_dev *pdev, int card_type)
386 return dgap_found_board(pdev, card_type);
390 static void dgap_remove_one(struct pci_dev *dev)
397 * dgap_cleanup_module()
399 * Module unload. This is where it all ends.
401 void dgap_cleanup_module(void)
406 DGAP_LOCK(dgap_poll_lock, lock_flags);
408 DGAP_UNLOCK(dgap_poll_lock, lock_flags);
410 /* Turn off poller right away. */
411 del_timer_sync( &dgap_poll_timer);
413 dgap_remove_driver_sysfiles(&dgap_driver);
416 if (dgap_Major_Control_Registered) {
417 device_destroy(dgap_class, MKDEV(DIGI_DGAP_MAJOR, 0));
418 device_destroy(dgap_class, MKDEV(DIGI_DGAP_MAJOR, 1));
419 class_destroy(dgap_class);
420 unregister_chrdev(DIGI_DGAP_MAJOR, "dgap");
424 kfree(dgap_config_buf);
426 for (i = 0; i < dgap_NumBoards; ++i) {
427 dgap_remove_ports_sysfiles(dgap_Board[i]);
428 dgap_tty_uninit(dgap_Board[i]);
429 dgap_cleanup_board(dgap_Board[i]);
432 dgap_tty_post_uninit();
434 #if defined(DGAP_TRACER)
435 /* last thing, make sure we release the tracebuffer */
439 pci_unregister_driver(&dgap_driver);
444 * dgap_cleanup_board()
446 * Free all the memory associated with a board
448 static void dgap_cleanup_board(struct board_t *brd)
452 if(!brd || brd->magic != DGAP_BOARD_MAGIC)
455 if (brd->intr_used && brd->irq)
456 free_irq(brd->irq, brd);
458 tasklet_kill(&brd->helper_tasklet);
460 if (brd->re_map_port) {
461 release_mem_region(brd->membase + 0x200000, 0x200000);
462 iounmap(brd->re_map_port);
463 brd->re_map_port = NULL;
466 if (brd->re_map_membase) {
467 release_mem_region(brd->membase, 0x200000);
468 iounmap(brd->re_map_membase);
469 brd->re_map_membase = NULL;
472 if (brd->msgbuf_head) {
475 DGAP_LOCK(dgap_global_lock, flags);
477 printk("%s", brd->msgbuf_head);
478 kfree(brd->msgbuf_head);
479 brd->msgbuf_head = NULL;
480 DGAP_UNLOCK(dgap_global_lock, flags);
483 /* Free all allocated channels structs */
484 for (i = 0; i < MAXPORTS ; i++) {
485 if (brd->channels[i]) {
486 kfree(brd->channels[i]);
487 brd->channels[i] = NULL;
493 if (brd->flipflagbuf)
494 kfree(brd->flipflagbuf);
496 dgap_Board[brd->boardnum] = NULL;
505 * A board has been found, init it.
507 static int dgap_found_board(struct pci_dev *pdev, int id)
510 unsigned int pci_irq;
514 /* get the board structure and prep it */
515 brd = dgap_Board[dgap_NumBoards] =
516 (struct board_t *) dgap_driver_kzmalloc(sizeof(struct board_t), GFP_KERNEL);
518 APR(("memory allocation for board structure failed\n"));
522 /* make a temporary message buffer for the boot messages */
523 brd->msgbuf = brd->msgbuf_head =
524 (char *) dgap_driver_kzmalloc(sizeof(char) * 8192, GFP_KERNEL);
527 APR(("memory allocation for board msgbuf failed\n"));
531 /* store the info for the board we've found */
532 brd->magic = DGAP_BOARD_MAGIC;
533 brd->boardnum = dgap_NumBoards;
535 brd->vendor = dgap_pci_tbl[id].vendor;
536 brd->device = dgap_pci_tbl[id].device;
538 brd->pci_bus = pdev->bus->number;
539 brd->pci_slot = PCI_SLOT(pdev->devfn);
540 brd->name = dgap_Ids[id].name;
541 brd->maxports = dgap_Ids[id].maxports;
542 brd->type = dgap_Ids[id].config_type;
543 brd->dpatype = dgap_Ids[id].dpatype;
544 brd->dpastatus = BD_NOFEP;
545 init_waitqueue_head(&brd->state_wait);
547 DGAP_SPINLOCK_INIT(brd->bd_lock);
549 brd->state = BOARD_FOUND;
551 brd->inhibit_poller = FALSE;
552 brd->wait_for_bios = 0;
553 brd->wait_for_fep = 0;
555 for (i = 0; i < MAXPORTS; i++) {
556 brd->channels[i] = NULL;
559 /* store which card & revision we have */
560 pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &brd->subvendor);
561 pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &brd->subdevice);
562 pci_read_config_byte(pdev, PCI_REVISION_ID, &brd->rev);
567 /* get the PCI Base Address Registers */
569 /* Xr Jupiter and EPC use BAR 2 */
570 if (brd->device == PCI_DEVICE_XRJ_DID || brd->device == PCI_DEVICE_EPCJ_DID) {
571 brd->membase = pci_resource_start(pdev, 2);
572 brd->membase_end = pci_resource_end(pdev, 2);
574 /* Everyone else uses BAR 0 */
576 brd->membase = pci_resource_start(pdev, 0);
577 brd->membase_end = pci_resource_end(pdev, 0);
581 APR(("card has no PCI IO resources, failing board.\n"));
585 if (brd->membase & 1)
591 * On the PCI boards, there is no IO space allocated
592 * The I/O registers will be in the first 3 bytes of the
593 * upper 2MB of the 4MB memory space. The board memory
594 * will be mapped into the low 2MB of the 4MB memory space
596 brd->port = brd->membase + PCI_IO_OFFSET;
597 brd->port_end = brd->port + PCI_IO_SIZE;
601 * Special initialization for non-PLX boards
603 if (brd->device != PCI_DEVICE_XRJ_DID && brd->device != PCI_DEVICE_EPCJ_DID) {
606 pci_write_config_byte(pdev, 0x40, 0);
607 pci_write_config_byte(pdev, 0x46, 0);
609 /* Limit burst length to 2 doubleword transactions */
610 pci_write_config_byte(pdev, 0x42, 1);
613 * Enable IO and mem if not already done.
614 * This was needed for support on Itanium.
616 pci_read_config_word(pdev, PCI_COMMAND, &cmd);
617 cmd |= (PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
618 pci_write_config_word(pdev, PCI_COMMAND, cmd);
621 /* init our poll helper tasklet */
622 tasklet_init(&brd->helper_tasklet, dgap_poll_tasklet, (unsigned long) brd);
624 /* Log the information about the board */
625 dgap_mbuf(brd, DRVSTR": board %d: %s (rev %d), irq %d\n",
626 dgap_NumBoards, brd->name, brd->rev, brd->irq);
628 DPR_INIT(("dgap_scan(%d) - printing out the msgbuf\n", i));
629 DGAP_LOCK(dgap_global_lock, flags);
631 printk("%s", brd->msgbuf_head);
632 kfree(brd->msgbuf_head);
633 brd->msgbuf_head = NULL;
634 DGAP_UNLOCK(dgap_global_lock, flags);
636 i = dgap_do_remap(brd);
638 brd->state = BOARD_FAILED;
640 brd->state = NEED_RESET;
646 int dgap_finalize_board_init(struct board_t *brd) {
650 DPR_INIT(("dgap_finalize_board_init() - start\n"));
652 if (!brd || brd->magic != DGAP_BOARD_MAGIC)
655 DPR_INIT(("dgap_finalize_board_init() - start #2\n"));
657 brd->use_interrupts = dgap_config_get_useintr(brd);
660 * Set up our interrupt handler if we are set to do interrupts.
662 if (brd->use_interrupts && brd->irq) {
664 rc = request_irq(brd->irq, dgap_intr, IRQF_SHARED, "DGAP", brd);
667 dgap_mbuf(brd, DRVSTR": Failed to hook IRQ %d. Board will work in poll mode.\n",
684 static int dgap_do_remap(struct board_t *brd)
686 if (!brd || brd->magic != DGAP_BOARD_MAGIC)
689 if (!request_mem_region(brd->membase, 0x200000, "dgap")) {
690 APR(("dgap: mem_region %lx already in use.\n", brd->membase));
694 if (!request_mem_region(brd->membase + PCI_IO_OFFSET, 0x200000, "dgap")) {
695 APR(("dgap: mem_region IO %lx already in use.\n",
696 brd->membase + PCI_IO_OFFSET));
697 release_mem_region(brd->membase, 0x200000);
701 brd->re_map_membase = ioremap(brd->membase, 0x200000);
702 if (!brd->re_map_membase) {
703 APR(("dgap: ioremap mem %lx cannot be mapped.\n", brd->membase));
704 release_mem_region(brd->membase, 0x200000);
705 release_mem_region(brd->membase + PCI_IO_OFFSET, 0x200000);
709 brd->re_map_port = ioremap((brd->membase + PCI_IO_OFFSET), 0x200000);
710 if (!brd->re_map_port) {
711 release_mem_region(brd->membase, 0x200000);
712 release_mem_region(brd->membase + PCI_IO_OFFSET, 0x200000);
713 iounmap(brd->re_map_membase);
714 APR(("dgap: ioremap IO mem %lx cannot be mapped.\n",
715 brd->membase + PCI_IO_OFFSET));
719 DPR_INIT(("remapped io: 0x%p remapped mem: 0x%p\n",
720 brd->re_map_port, brd->re_map_membase));
725 /*****************************************************************************
745 * As each timer expires, it determines (a) whether the "transmit"
746 * waiter needs to be woken up, and (b) whether the poller needs to
749 ******************************************************************************/
751 static void dgap_poll_handler(ulong dummy)
755 unsigned long lock_flags;
756 unsigned long lock_flags2;
763 * If driver needs the config file still,
764 * keep trying to wake up the downloader to
767 if (dgap_driver_state == DRIVER_NEED_CONFIG_LOAD) {
769 * Signal downloader, its got some work to do.
771 DGAP_LOCK(dgap_dl_lock, lock_flags2);
772 if (dgap_dl_action != 1) {
774 wake_up_interruptible(&dgap_dl_wait);
776 DGAP_UNLOCK(dgap_dl_lock, lock_flags2);
777 goto schedule_poller;
780 * Do not start the board state machine until
781 * driver tells us its up and running, and has
782 * everything it needs.
784 else if (dgap_driver_state != DRIVER_READY) {
785 goto schedule_poller;
789 * If we have just 1 board, or the system is not SMP,
790 * then use the typical old style poller.
791 * Otherwise, use our new tasklet based poller, which should
792 * speed things up for multiple boards.
794 if ( (dgap_NumBoards == 1) || (num_online_cpus() <= 1) ) {
795 for (i = 0; i < dgap_NumBoards; i++) {
799 if (brd->state == BOARD_FAILED) {
802 if (!brd->intr_running) {
803 /* Call the real board poller directly */
804 dgap_poll_tasklet((unsigned long) brd);
809 /* Go thru each board, kicking off a tasklet for each if needed */
810 for (i = 0; i < dgap_NumBoards; i++) {
814 * Attempt to grab the board lock.
816 * If we can't get it, no big deal, the next poll will get it.
817 * Basically, I just really don't want to spin in here, because I want
818 * to kick off my tasklets as fast as I can, and then get out the poller.
820 if (!spin_trylock(&brd->bd_lock)) {
824 /* If board is in a failed state, don't bother scheduling a tasklet */
825 if (brd->state == BOARD_FAILED) {
826 spin_unlock(&brd->bd_lock);
830 /* Schedule a poll helper task */
831 if (!brd->intr_running) {
832 tasklet_schedule(&brd->helper_tasklet);
836 * Can't do DGAP_UNLOCK here, as we don't have
837 * lock_flags because we did a trylock above.
839 spin_unlock(&brd->bd_lock);
846 * Schedule ourself back at the nominal wakeup interval.
848 DGAP_LOCK(dgap_poll_lock, lock_flags );
849 dgap_poll_time += dgap_jiffies_from_ms(dgap_poll_tick);
851 new_time = dgap_poll_time - jiffies;
853 if ((ulong) new_time >= 2 * dgap_poll_tick) {
854 dgap_poll_time = jiffies + dgap_jiffies_from_ms(dgap_poll_tick);
857 dgap_poll_timer.function = dgap_poll_handler;
858 dgap_poll_timer.data = 0;
859 dgap_poll_timer.expires = dgap_poll_time;
860 DGAP_UNLOCK(dgap_poll_lock, lock_flags );
863 add_timer(&dgap_poll_timer);
872 * Driver interrupt handler.
874 static irqreturn_t dgap_intr(int irq, void *voidbrd)
876 struct board_t *brd = (struct board_t *) voidbrd;
879 APR(("Received interrupt (%d) with null board associated\n", irq));
884 * Check to make sure its for us.
886 if (brd->magic != DGAP_BOARD_MAGIC) {
887 APR(("Received interrupt (%d) with a board pointer that wasn't ours!\n", irq));
894 * Schedule tasklet to run at a better time.
896 tasklet_schedule(&brd->helper_tasklet);
902 * dgap_init_globals()
904 * This is where we initialize the globals from the static insmod
905 * configuration variables. These are declared near the head of
908 static void dgap_init_globals(void)
912 dgap_rawreadok = rawreadok;
913 dgap_trcbuf_size = trcbuf_size;
916 for (i = 0; i < MAXBOARDS; i++) {
917 dgap_Board[i] = NULL;
920 init_timer( &dgap_poll_timer );
922 init_waitqueue_head(&dgap_dl_wait);
927 /************************************************************************
931 ************************************************************************/
935 * dgap_driver_kzmalloc()
937 * Malloc and clear memory,
939 void *dgap_driver_kzmalloc(size_t size, int priority)
941 void *p = kmalloc(size, priority);
951 * Used to print to the message buffer during board init.
953 static void dgap_mbuf(struct board_t *brd, const char *fmt, ...) {
960 DGAP_LOCK(dgap_global_lock, flags);
962 /* Format buf using fmt and arguments contained in ap. */
964 i = vsnprintf(buf, sizeof(buf), fmt, ap);
969 if (!brd || !brd->msgbuf) {
971 DGAP_UNLOCK(dgap_global_lock, flags);
975 length = strlen(buf) + 1;
976 if (brd->msgbuf - brd->msgbuf_head < length)
977 length = brd->msgbuf - brd->msgbuf_head;
978 memcpy(brd->msgbuf, buf, length);
979 brd->msgbuf += length;
981 DGAP_UNLOCK(dgap_global_lock, flags);
988 * Put the driver to sleep for x ms's
990 * Returns 0 if timed out, !0 (showing signal) if interrupted by a signal.
992 int dgap_ms_sleep(ulong ms)
994 current->state = TASK_INTERRUPTIBLE;
995 schedule_timeout((ms * HZ) / 1000);
996 return (signal_pending(current));
1002 * dgap_ioctl_name() : Returns a text version of each ioctl value.
1004 char *dgap_ioctl_name(int cmd)
1008 case TCGETA: return("TCGETA");
1009 case TCGETS: return("TCGETS");
1010 case TCSETA: return("TCSETA");
1011 case TCSETS: return("TCSETS");
1012 case TCSETAW: return("TCSETAW");
1013 case TCSETSW: return("TCSETSW");
1014 case TCSETAF: return("TCSETAF");
1015 case TCSETSF: return("TCSETSF");
1016 case TCSBRK: return("TCSBRK");
1017 case TCXONC: return("TCXONC");
1018 case TCFLSH: return("TCFLSH");
1019 case TIOCGSID: return("TIOCGSID");
1021 case TIOCGETD: return("TIOCGETD");
1022 case TIOCSETD: return("TIOCSETD");
1023 case TIOCGWINSZ: return("TIOCGWINSZ");
1024 case TIOCSWINSZ: return("TIOCSWINSZ");
1026 case TIOCMGET: return("TIOCMGET");
1027 case TIOCMSET: return("TIOCMSET");
1028 case TIOCMBIS: return("TIOCMBIS");
1029 case TIOCMBIC: return("TIOCMBIC");
1032 case DIGI_SETA: return("DIGI_SETA");
1033 case DIGI_SETAW: return("DIGI_SETAW");
1034 case DIGI_SETAF: return("DIGI_SETAF");
1035 case DIGI_SETFLOW: return("DIGI_SETFLOW");
1036 case DIGI_SETAFLOW: return("DIGI_SETAFLOW");
1037 case DIGI_GETFLOW: return("DIGI_GETFLOW");
1038 case DIGI_GETAFLOW: return("DIGI_GETAFLOW");
1039 case DIGI_GETA: return("DIGI_GETA");
1040 case DIGI_GEDELAY: return("DIGI_GEDELAY");
1041 case DIGI_SEDELAY: return("DIGI_SEDELAY");
1042 case DIGI_GETCUSTOMBAUD: return("DIGI_GETCUSTOMBAUD");
1043 case DIGI_SETCUSTOMBAUD: return("DIGI_SETCUSTOMBAUD");
1044 case TIOCMODG: return("TIOCMODG");
1045 case TIOCMODS: return("TIOCMODS");
1046 case TIOCSDTR: return("TIOCSDTR");
1047 case TIOCCDTR: return("TIOCCDTR");
1049 default: return("unknown");