Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/staging/dgnc/dgnc_driver.c

  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_cls.h"
 44 #include "dgnc_neo.h"
 45 #include "dgnc_sysfs.h"
 46 
 47 MODULE_LICENSE("GPL");
 48 MODULE_AUTHOR("Digi International, http://www.digi.com");
 49 MODULE_DESCRIPTION("Driver for the Digi International Neo and Classic PCI based product line");
 50 MODULE_SUPPORTED_DEVICE("dgnc");
 51 
 52 /*
 53  * insmod command line overrideable parameters
 54  *
 55  * NOTE: we use a set of macros to create the variables, which allows
 56  * us to specify the variable type, name, initial value, and description.
 57  */
 58 PARM_INT(debug,         0x00,           0644,   "Driver debugging level");
 59 PARM_INT(rawreadok,     1,              0644,   "Bypass flip buffers on input");
 60 PARM_INT(trcbuf_size,   0x100000,       0644,   "Debugging trace buffer size.");
 61 
 62 /**************************************************************************
 63  *
 64  * protos for this file
 65  *
 66  */
 67 static int              dgnc_start(void);
 68 static int              dgnc_finalize_board_init(struct dgnc_board *brd);
 69 static void             dgnc_init_globals(void);
 70 static int              dgnc_found_board(struct pci_dev *pdev, int id);
 71 static void             dgnc_cleanup_board(struct dgnc_board *brd);
 72 static void             dgnc_poll_handler(ulong dummy);
 73 static int              dgnc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent);
 74 static void             dgnc_do_remap(struct dgnc_board *brd);
 75 
 76 /*
 77  * File operations permitted on Control/Management major.
 78  */
 79 static const struct file_operations dgnc_BoardFops = {
 80         .owner          =       THIS_MODULE,
 81         .unlocked_ioctl =       dgnc_mgmt_ioctl,
 82         .open           =       dgnc_mgmt_open,
 83         .release        =       dgnc_mgmt_close
 84 };
 85 
 86 
 87 /*
 88  * Globals
 89  */
 90 uint                    dgnc_NumBoards;
 91 struct dgnc_board               *dgnc_Board[MAXBOARDS];
 92 DEFINE_SPINLOCK(dgnc_global_lock);
 93 uint                    dgnc_Major;
 94 int                     dgnc_poll_tick = 20;    /* Poll interval - 20 ms */
 95 
 96 /*
 97  * Static vars.
 98  */
 99 static struct class *dgnc_class;
100 
101 /*
102  * Poller stuff
103  */
104 static DEFINE_SPINLOCK(dgnc_poll_lock); /* Poll scheduling lock */
105 static ulong            dgnc_poll_time;                         /* Time of next poll */
106 static uint             dgnc_poll_stop;                         /* Used to tell poller to stop */
107 static struct timer_list dgnc_poll_timer;
108 
109 
110 static struct pci_device_id dgnc_pci_tbl[] = {
111         {       DIGI_VID, PCI_DEVICE_CLASSIC_4_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,       0 },
112         {       DIGI_VID, PCI_DEVICE_CLASSIC_4_422_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,   1 },
113         {       DIGI_VID, PCI_DEVICE_CLASSIC_8_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,       2 },
114         {       DIGI_VID, PCI_DEVICE_CLASSIC_8_422_DID, PCI_ANY_ID, PCI_ANY_ID, 0, 0,   3 },
115         {0,}                                            /* 0 terminated list. */
116 };
117 MODULE_DEVICE_TABLE(pci, dgnc_pci_tbl);
118 
119 struct board_id {
120         unsigned char *name;
121         uint maxports;
122         unsigned int is_pci_express;
123 };
124 
125 static struct board_id dgnc_Ids[] = {
126         {       PCI_DEVICE_CLASSIC_4_PCI_NAME,          4,      0       },
127         {       PCI_DEVICE_CLASSIC_4_422_PCI_NAME,      4,      0       },
128         {       PCI_DEVICE_CLASSIC_8_PCI_NAME,          8,      0       },
129         {       PCI_DEVICE_CLASSIC_8_422_PCI_NAME,      8,      0       },
130         {       PCI_DEVICE_NEO_4_PCI_NAME,              4,      0       },
131         {       PCI_DEVICE_NEO_8_PCI_NAME,              8,      0       },
132         {       PCI_DEVICE_NEO_2DB9_PCI_NAME,           2,      0       },
133         {       PCI_DEVICE_NEO_2DB9PRI_PCI_NAME,        2,      0       },
134         {       PCI_DEVICE_NEO_2RJ45_PCI_NAME,          2,      0       },
135         {       PCI_DEVICE_NEO_2RJ45PRI_PCI_NAME,       2,      0       },
136         {       PCI_DEVICE_NEO_1_422_PCI_NAME,          1,      0       },
137         {       PCI_DEVICE_NEO_1_422_485_PCI_NAME,      1,      0       },
138         {       PCI_DEVICE_NEO_2_422_485_PCI_NAME,      2,      0       },
139         {       PCI_DEVICE_NEO_EXPRESS_8_PCI_NAME,      8,      1       },
140         {       PCI_DEVICE_NEO_EXPRESS_4_PCI_NAME,      4,      1       },
141         {       PCI_DEVICE_NEO_EXPRESS_4RJ45_PCI_NAME,  4,      1       },
142         {       PCI_DEVICE_NEO_EXPRESS_8RJ45_PCI_NAME,  8,      1       },
143         {       NULL,                                   0,      0       }
144 };
145 
146 static struct pci_driver dgnc_driver = {
147         .name           = "dgnc",
148         .probe          = dgnc_init_one,
149         .id_table       = dgnc_pci_tbl,
150 };
151 
152 
153 char *dgnc_state_text[] = {
154         "Board Failed",
155         "Board Found",
156         "Board READY",
157 };
158 
159 
160 /************************************************************************
161  *
162  * Driver load/unload functions
163  *
164  ************************************************************************/
165 
166 /*
167  * dgnc_cleanup_module()
168  *
169  * Module unload.  This is where it all ends.
170  */
171 static void dgnc_cleanup_module(void)
172 {
173         int i;
174         unsigned long flags;
175 
176         spin_lock_irqsave(&dgnc_poll_lock, flags);
177         dgnc_poll_stop = 1;
178         spin_unlock_irqrestore(&dgnc_poll_lock, flags);
179 
180         /* Turn off poller right away. */
181         del_timer_sync(&dgnc_poll_timer);
182 
183         dgnc_remove_driver_sysfiles(&dgnc_driver);
184 
185         device_destroy(dgnc_class, MKDEV(dgnc_Major, 0));
186         class_destroy(dgnc_class);
187         unregister_chrdev(dgnc_Major, "dgnc");
188 
189         for (i = 0; i < dgnc_NumBoards; ++i) {
190                 dgnc_remove_ports_sysfiles(dgnc_Board[i]);
191                 dgnc_tty_uninit(dgnc_Board[i]);
192                 dgnc_cleanup_board(dgnc_Board[i]);
193         }
194 
195         dgnc_tty_post_uninit();
196 
197         if (dgnc_NumBoards)
198                 pci_unregister_driver(&dgnc_driver);
199 }
200 
201 /*
202  * init_module()
203  *
204  * Module load.  This is where it all starts.
205  */
206 static int __init dgnc_init_module(void)
207 {
208         int rc = 0;
209 
210         APR(("%s, Digi International Part Number %s\n", DG_NAME, DG_PART));
211 
212         /*
213          * Initialize global stuff
214          */
215         rc = dgnc_start();
216 
217         if (rc < 0)
218                 return rc;
219 
220         /*
221          * Find and configure all the cards
222          */
223         rc = pci_register_driver(&dgnc_driver);
224 
225         /*
226          * If something went wrong in the scan, bail out of driver.
227          */
228         if (rc < 0) {
229                 /* Only unregister the pci driver if it was actually registered. */
230                 if (dgnc_NumBoards)
231                         pci_unregister_driver(&dgnc_driver);
232                 else
233                         pr_warn("WARNING: dgnc driver load failed.  No Digi Neo or Classic boards found.\n");
234 
235                 dgnc_cleanup_module();
236         } else {
237                 dgnc_create_driver_sysfiles(&dgnc_driver);
238         }
239 
240         return rc;
241 }
242 
243 module_init(dgnc_init_module);
244 module_exit(dgnc_cleanup_module);
245 
246 /*
247  * Start of driver.
248  */
249 static int dgnc_start(void)
250 {
251         int rc = 0;
252         unsigned long flags;
253 
254         /* make sure that the globals are init'd before we do anything else */
255         dgnc_init_globals();
256 
257         APR(("For the tools package or updated drivers please visit http://www.digi.com\n"));
258 
259         /*
260          * Register our base character device into the kernel.
261          * This allows the download daemon to connect to the downld device
262          * before any of the boards are init'ed.
263          *
264          * Register management/dpa devices
265          */
266         rc = register_chrdev(0, "dgnc", &dgnc_BoardFops);
267         if (rc <= 0) {
268                 APR(("Can't register dgnc driver device (%d)\n", rc));
269                 return -ENXIO;
270         }
271         dgnc_Major = rc;
272 
273         dgnc_class = class_create(THIS_MODULE, "dgnc_mgmt");
274         device_create(dgnc_class, NULL,
275                 MKDEV(dgnc_Major, 0),
276                 NULL, "dgnc_mgmt");
277 
278         /*
279          * Init any global tty stuff.
280          */
281         rc = dgnc_tty_preinit();
282 
283         if (rc < 0) {
284                 APR(("tty preinit - not enough memory (%d)\n", rc));
285                 return rc;
286         }
287 
288         /* Start the poller */
289         spin_lock_irqsave(&dgnc_poll_lock, flags);
290         init_timer(&dgnc_poll_timer);
291         dgnc_poll_timer.function = dgnc_poll_handler;
292         dgnc_poll_timer.data = 0;
293         dgnc_poll_time = jiffies + dgnc_jiffies_from_ms(dgnc_poll_tick);
294         dgnc_poll_timer.expires = dgnc_poll_time;
295         spin_unlock_irqrestore(&dgnc_poll_lock, flags);
296 
297         add_timer(&dgnc_poll_timer);
298 
299         return rc;
300 }
301 
302 /* returns count (>= 0), or negative on error */
303 static int dgnc_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
304 {
305         int rc;
306 
307         /* wake up and enable device */
308         rc = pci_enable_device(pdev);
309 
310         if (rc < 0) {
311                 rc = -EIO;
312         } else {
313                 rc = dgnc_found_board(pdev, ent->driver_data);
314                 if (rc == 0)
315                         dgnc_NumBoards++;
316         }
317         return rc;
318 }
319 
320 /*
321  * dgnc_cleanup_board()
322  *
323  * Free all the memory associated with a board
324  */
325 static void dgnc_cleanup_board(struct dgnc_board *brd)
326 {
327         int i = 0;
328 
329         if (!brd || brd->magic != DGNC_BOARD_MAGIC)
330                 return;
331 
332         switch (brd->device) {
333         case PCI_DEVICE_CLASSIC_4_DID:
334         case PCI_DEVICE_CLASSIC_8_DID:
335         case PCI_DEVICE_CLASSIC_4_422_DID:
336         case PCI_DEVICE_CLASSIC_8_422_DID:
337 
338                 /* Tell card not to interrupt anymore. */
339                 outb(0, brd->iobase + 0x4c);
340                 break;
341 
342         default:
343                 break;
344         }
345 
346         if (brd->irq)
347                 free_irq(brd->irq, brd);
348 
349         tasklet_kill(&brd->helper_tasklet);
350 
351         if (brd->re_map_membase) {
352                 iounmap(brd->re_map_membase);
353                 brd->re_map_membase = NULL;
354         }
355 
356         if (brd->msgbuf_head) {
357                 unsigned long flags;
358 
359                 spin_lock_irqsave(&dgnc_global_lock, flags);
360                 brd->msgbuf = NULL;
361                 printk("%s", brd->msgbuf_head);
362                 kfree(brd->msgbuf_head);
363                 brd->msgbuf_head = NULL;
364                 spin_unlock_irqrestore(&dgnc_global_lock, flags);
365         }
366 
367         /* Free all allocated channels structs */
368         for (i = 0; i < MAXPORTS ; i++) {
369                 if (brd->channels[i]) {
370                         kfree(brd->channels[i]->ch_rqueue);
371                         kfree(brd->channels[i]->ch_equeue);
372                         kfree(brd->channels[i]->ch_wqueue);
373                         kfree(brd->channels[i]);
374                         brd->channels[i] = NULL;
375                 }
376         }
377 
378         kfree(brd->flipbuf);
379 
380         dgnc_Board[brd->boardnum] = NULL;
381 
382         kfree(brd);
383 }
384 
385 
386 /*
387  * dgnc_found_board()
388  *
389  * A board has been found, init it.
390  */
391 static int dgnc_found_board(struct pci_dev *pdev, int id)
392 {
393         struct dgnc_board *brd;
394         unsigned int pci_irq;
395         int i = 0;
396         int rc = 0;
397         unsigned long flags;
398 
399         /* get the board structure and prep it */
400         dgnc_Board[dgnc_NumBoards] = kzalloc(sizeof(*brd), GFP_KERNEL);
401         brd = dgnc_Board[dgnc_NumBoards];
402 
403         if (!brd)
404                 return -ENOMEM;
405 
406         /* make a temporary message buffer for the boot messages */
407         brd->msgbuf_head = kzalloc(sizeof(u8) * 8192, GFP_KERNEL);
408         brd->msgbuf = brd->msgbuf_head;
409 
410         if (!brd->msgbuf) {
411                 kfree(brd);
412                 return -ENOMEM;
413         }
414 
415         /* store the info for the board we've found */
416         brd->magic = DGNC_BOARD_MAGIC;
417         brd->boardnum = dgnc_NumBoards;
418         brd->vendor = dgnc_pci_tbl[id].vendor;
419         brd->device = dgnc_pci_tbl[id].device;
420         brd->pdev = pdev;
421         brd->pci_bus = pdev->bus->number;
422         brd->pci_slot = PCI_SLOT(pdev->devfn);
423         brd->name = dgnc_Ids[id].name;
424         brd->maxports = dgnc_Ids[id].maxports;
425         if (dgnc_Ids[i].is_pci_express)
426                 brd->bd_flags |= BD_IS_PCI_EXPRESS;
427         brd->dpastatus = BD_NOFEP;
428         init_waitqueue_head(&brd->state_wait);
429 
430         spin_lock_init(&brd->bd_lock);
431         spin_lock_init(&brd->bd_intr_lock);
432 
433         brd->state              = BOARD_FOUND;
434 
435         for (i = 0; i < MAXPORTS; i++)
436                 brd->channels[i] = NULL;
437 
438         /* store which card & revision we have */
439         pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &brd->subvendor);
440         pci_read_config_word(pdev, PCI_SUBSYSTEM_ID, &brd->subdevice);
441         pci_read_config_byte(pdev, PCI_REVISION_ID, &brd->rev);
442 
443         pci_irq = pdev->irq;
444         brd->irq = pci_irq;
445 
446 
447         switch (brd->device) {
448 
449         case PCI_DEVICE_CLASSIC_4_DID:
450         case PCI_DEVICE_CLASSIC_8_DID:
451         case PCI_DEVICE_CLASSIC_4_422_DID:
452         case PCI_DEVICE_CLASSIC_8_422_DID:
453 
454                 brd->dpatype = T_CLASSIC | T_PCIBUS;
455 
456                 /*
457                  * For PCI ClassicBoards
458                  * PCI Local Address (i.e. "resource" number) space
459                  * 0    PLX Memory Mapped Config
460                  * 1    PLX I/O Mapped Config
461                  * 2    I/O Mapped UARTs and Status
462                  * 3    Memory Mapped VPD
463                  * 4    Memory Mapped UARTs and Status
464                  */
465 
466 
467                 /* get the PCI Base Address Registers */
468                 brd->membase = pci_resource_start(pdev, 4);
469 
470                 if (!brd->membase) {
471                         APR(("card has no PCI IO resources, failing board.\n"));
472                         return -ENODEV;
473                 }
474 
475                 brd->membase_end = pci_resource_end(pdev, 4);
476 
477                 if (brd->membase & 1)
478                         brd->membase &= ~3;
479                 else
480                         brd->membase &= ~15;
481 
482                 brd->iobase     = pci_resource_start(pdev, 1);
483                 brd->iobase_end = pci_resource_end(pdev, 1);
484                 brd->iobase     = ((unsigned int) (brd->iobase)) & 0xFFFE;
485 
486                 /* Assign the board_ops struct */
487                 brd->bd_ops = &dgnc_cls_ops;
488 
489                 brd->bd_uart_offset = 0x8;
490                 brd->bd_dividend = 921600;
491 
492                 dgnc_do_remap(brd);
493 
494                 /* Get and store the board VPD, if it exists */
495                 brd->bd_ops->vpd(brd);
496 
497                 /*
498                  * Enable Local Interrupt 1               (0x1),
499                  * Local Interrupt 1 Polarity Active high (0x2),
500                  * Enable PCI interrupt                   (0x40)
501                  */
502                 outb(0x43, brd->iobase + 0x4c);
503 
504                 break;
505 
506 
507         case PCI_DEVICE_NEO_4_DID:
508         case PCI_DEVICE_NEO_8_DID:
509         case PCI_DEVICE_NEO_2DB9_DID:
510         case PCI_DEVICE_NEO_2DB9PRI_DID:
511         case PCI_DEVICE_NEO_2RJ45_DID:
512         case PCI_DEVICE_NEO_2RJ45PRI_DID:
513         case PCI_DEVICE_NEO_1_422_DID:
514         case PCI_DEVICE_NEO_1_422_485_DID:
515         case PCI_DEVICE_NEO_2_422_485_DID:
516         case PCI_DEVICE_NEO_EXPRESS_8_DID:
517         case PCI_DEVICE_NEO_EXPRESS_4_DID:
518         case PCI_DEVICE_NEO_EXPRESS_4RJ45_DID:
519         case PCI_DEVICE_NEO_EXPRESS_8RJ45_DID:
520 
521                 /*
522                  * This chip is set up 100% when we get to it.
523                  * No need to enable global interrupts or anything.
524                  */
525                 if (brd->bd_flags & BD_IS_PCI_EXPRESS)
526                         brd->dpatype = T_NEO_EXPRESS | T_PCIBUS;
527                 else
528                         brd->dpatype = T_NEO | T_PCIBUS;
529 
530                 /* get the PCI Base Address Registers */
531                 brd->membase     = pci_resource_start(pdev, 0);
532                 brd->membase_end = pci_resource_end(pdev, 0);
533 
534                 if (brd->membase & 1)
535                         brd->membase &= ~3;
536                 else
537                         brd->membase &= ~15;
538 
539                 /* Assign the board_ops struct */
540                 brd->bd_ops = &dgnc_neo_ops;
541 
542                 brd->bd_uart_offset = 0x200;
543                 brd->bd_dividend = 921600;
544 
545                 dgnc_do_remap(brd);
546 
547                 if (brd->re_map_membase) {
548 
549                         /* After remap is complete, we need to read and store the dvid */
550                         brd->dvid = readb(brd->re_map_membase + 0x8D);
551 
552                         /* Get and store the board VPD, if it exists */
553                         brd->bd_ops->vpd(brd);
554                 }
555                 break;
556 
557         default:
558                 APR(("Did not find any compatible Neo or Classic PCI boards in system.\n"));
559                 return -ENXIO;
560 
561         }
562 
563         /*
564          * Do tty device initialization.
565          */
566 
567         rc = dgnc_tty_register(brd);
568         if (rc < 0) {
569                 dgnc_tty_uninit(brd);
570                 APR(("Can't register tty devices (%d)\n", rc));
571                 brd->state = BOARD_FAILED;
572                 brd->dpastatus = BD_NOFEP;
573                 goto failed;
574         }
575 
576         rc = dgnc_finalize_board_init(brd);
577         if (rc < 0) {
578                 APR(("Can't finalize board init (%d)\n", rc));
579                 brd->state = BOARD_FAILED;
580                 brd->dpastatus = BD_NOFEP;
581 
582                 goto failed;
583         }
584 
585         rc = dgnc_tty_init(brd);
586         if (rc < 0) {
587                 dgnc_tty_uninit(brd);
588                 APR(("Can't init tty devices (%d)\n", rc));
589                 brd->state = BOARD_FAILED;
590                 brd->dpastatus = BD_NOFEP;
591 
592                 goto failed;
593         }
594 
595         brd->state = BOARD_READY;
596         brd->dpastatus = BD_RUNNING;
597 
598         dgnc_create_ports_sysfiles(brd);
599 
600         /* init our poll helper tasklet */
601         tasklet_init(&brd->helper_tasklet, brd->bd_ops->tasklet, (unsigned long) brd);
602 
603         spin_lock_irqsave(&dgnc_global_lock, flags);
604         brd->msgbuf = NULL;
605         printk("%s", brd->msgbuf_head);
606         kfree(brd->msgbuf_head);
607         brd->msgbuf_head = NULL;
608         spin_unlock_irqrestore(&dgnc_global_lock, flags);
609 
610         /*
611          * allocate flip buffer for board.
612          *
613          * Okay to malloc with GFP_KERNEL, we are not at interrupt
614          * context, and there are no locks held.
615          */
616         brd->flipbuf = kzalloc(MYFLIPLEN, GFP_KERNEL);
617 
618         wake_up_interruptible(&brd->state_wait);
619 
620         return 0;
621 
622 failed:
623 
624         return -ENXIO;
625 
626 }
627 
628 
629 static int dgnc_finalize_board_init(struct dgnc_board *brd)
630 {
631         int rc = 0;
632 
633         if (!brd || brd->magic != DGNC_BOARD_MAGIC)
634                 return -ENODEV;
635 
636         if (brd->irq) {
637                 rc = request_irq(brd->irq, brd->bd_ops->intr,
638                                  IRQF_SHARED, "DGNC", brd);
639 
640                 if (rc) {
641                         dev_err(&brd->pdev->dev,
642                                 "Failed to hook IRQ %d\n", brd->irq);
643                         brd->state = BOARD_FAILED;
644                         brd->dpastatus = BD_NOFEP;
645                         rc = -ENODEV;
646                 }
647         }
648         return rc;
649 }
650 
651 /*
652  * Remap PCI memory.
653  */
654 static void dgnc_do_remap(struct dgnc_board *brd)
655 {
656 
657         if (!brd || brd->magic != DGNC_BOARD_MAGIC)
658                 return;
659 
660         brd->re_map_membase = ioremap(brd->membase, 0x1000);
661 }
662 
663 
664 /*****************************************************************************
665 *
666 * Function:
667 *
668 *    dgnc_poll_handler
669 *
670 * Author:
671 *
672 *    Scott H Kilau
673 *
674 * Parameters:
675 *
676 *    dummy -- ignored
677 *
678 * Return Values:
679 *
680 *    none
681 *
682 * Description:
683 *
684 *    As each timer expires, it determines (a) whether the "transmit"
685 *    waiter needs to be woken up, and (b) whether the poller needs to
686 *    be rescheduled.
687 *
688 ******************************************************************************/
689 
690 static void dgnc_poll_handler(ulong dummy)
691 {
692         struct dgnc_board *brd;
693         unsigned long flags;
694         int i;
695         unsigned long new_time;
696 
697         /* Go thru each board, kicking off a tasklet for each if needed */
698         for (i = 0; i < dgnc_NumBoards; i++) {
699                 brd = dgnc_Board[i];
700 
701                 spin_lock_irqsave(&brd->bd_lock, flags);
702 
703                 /* If board is in a failed state, don't bother scheduling a tasklet */
704                 if (brd->state == BOARD_FAILED) {
705                         spin_unlock_irqrestore(&brd->bd_lock, flags);
706                         continue;
707                 }
708 
709                 /* Schedule a poll helper task */
710                 tasklet_schedule(&brd->helper_tasklet);
711 
712                 spin_unlock_irqrestore(&brd->bd_lock, flags);
713         }
714 
715         /*
716          * Schedule ourself back at the nominal wakeup interval.
717          */
718         spin_lock_irqsave(&dgnc_poll_lock, flags);
719         dgnc_poll_time += dgnc_jiffies_from_ms(dgnc_poll_tick);
720 
721         new_time = dgnc_poll_time - jiffies;
722 
723         if ((ulong) new_time >= 2 * dgnc_poll_tick)
724                 dgnc_poll_time = jiffies +  dgnc_jiffies_from_ms(dgnc_poll_tick);
725 
726         init_timer(&dgnc_poll_timer);
727         dgnc_poll_timer.function = dgnc_poll_handler;
728         dgnc_poll_timer.data = 0;
729         dgnc_poll_timer.expires = dgnc_poll_time;
730         spin_unlock_irqrestore(&dgnc_poll_lock, flags);
731 
732         if (!dgnc_poll_stop)
733                 add_timer(&dgnc_poll_timer);
734 }
735 
736 /*
737  * dgnc_init_globals()
738  *
739  * This is where we initialize the globals from the static insmod
740  * configuration variables.  These are declared near the head of
741  * this file.
742  */
743 static void dgnc_init_globals(void)
744 {
745         int i = 0;
746 
747         dgnc_rawreadok          = rawreadok;
748         dgnc_trcbuf_size        = trcbuf_size;
749         dgnc_debug              = debug;
750         dgnc_NumBoards          = 0;
751 
752         for (i = 0; i < MAXBOARDS; i++)
753                 dgnc_Board[i] = NULL;
754 
755         init_timer(&dgnc_poll_timer);
756 }
757 
758 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us