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.
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/pci.h>
19 #include <linux/slab.h>
20 #include <linux/sched.h>
21 #include "dgnc_driver.h"
23 #include "dgnc_mgmt.h"
27 #include "dgnc_sysfs.h"
29 MODULE_LICENSE("GPL");
30 MODULE_AUTHOR("Digi International, http://www.digi.com");
31 MODULE_DESCRIPTION("Driver for the Digi International Neo and Classic PCI based product line");
32 MODULE_SUPPORTED_DEVICE("dgnc");
34 /**************************************************************************
36 * protos for this file
39 static int dgnc_start(void);
40 static int dgnc_finalize_board_init(struct dgnc_board
*brd
);
41 static int dgnc_found_board(struct pci_dev
*pdev
, int id
);
42 static void dgnc_cleanup_board(struct dgnc_board
*brd
);
43 static void dgnc_poll_handler(ulong dummy
);
44 static int dgnc_init_one(struct pci_dev
*pdev
,
45 const struct pci_device_id
*ent
);
46 static void dgnc_do_remap(struct dgnc_board
*brd
);
49 * File operations permitted on Control/Management major.
51 static const struct file_operations dgnc_BoardFops
= {
53 .unlocked_ioctl
= dgnc_mgmt_ioctl
,
54 .open
= dgnc_mgmt_open
,
55 .release
= dgnc_mgmt_close
62 struct dgnc_board
*dgnc_Board
[MAXBOARDS
];
63 DEFINE_SPINLOCK(dgnc_global_lock
);
64 DEFINE_SPINLOCK(dgnc_poll_lock
); /* Poll scheduling lock */
66 int dgnc_poll_tick
= 20; /* Poll interval - 20 ms */
71 static struct class *dgnc_class
;
76 static ulong dgnc_poll_time
; /* Time of next poll */
77 static uint dgnc_poll_stop
; /* Used to tell poller to stop */
78 static struct timer_list dgnc_poll_timer
;
80 static const struct pci_device_id dgnc_pci_tbl
[] = {
81 {PCI_DEVICE(DIGI_VID
, PCI_DEVICE_CLASSIC_4_DID
), .driver_data
= 0},
82 {PCI_DEVICE(DIGI_VID
, PCI_DEVICE_CLASSIC_4_422_DID
), .driver_data
= 1},
83 {PCI_DEVICE(DIGI_VID
, PCI_DEVICE_CLASSIC_8_DID
), .driver_data
= 2},
84 {PCI_DEVICE(DIGI_VID
, PCI_DEVICE_CLASSIC_8_422_DID
), .driver_data
= 3},
87 MODULE_DEVICE_TABLE(pci
, dgnc_pci_tbl
);
92 unsigned int is_pci_express
;
95 static struct board_id dgnc_Ids
[] = {
96 { PCI_DEVICE_CLASSIC_4_PCI_NAME
, 4, 0 },
97 { PCI_DEVICE_CLASSIC_4_422_PCI_NAME
, 4, 0 },
98 { PCI_DEVICE_CLASSIC_8_PCI_NAME
, 8, 0 },
99 { PCI_DEVICE_CLASSIC_8_422_PCI_NAME
, 8, 0 },
100 { PCI_DEVICE_NEO_4_PCI_NAME
, 4, 0 },
101 { PCI_DEVICE_NEO_8_PCI_NAME
, 8, 0 },
102 { PCI_DEVICE_NEO_2DB9_PCI_NAME
, 2, 0 },
103 { PCI_DEVICE_NEO_2DB9PRI_PCI_NAME
, 2, 0 },
104 { PCI_DEVICE_NEO_2RJ45_PCI_NAME
, 2, 0 },
105 { PCI_DEVICE_NEO_2RJ45PRI_PCI_NAME
, 2, 0 },
106 { PCI_DEVICE_NEO_1_422_PCI_NAME
, 1, 0 },
107 { PCI_DEVICE_NEO_1_422_485_PCI_NAME
, 1, 0 },
108 { PCI_DEVICE_NEO_2_422_485_PCI_NAME
, 2, 0 },
109 { PCI_DEVICE_NEO_EXPRESS_8_PCI_NAME
, 8, 1 },
110 { PCI_DEVICE_NEO_EXPRESS_4_PCI_NAME
, 4, 1 },
111 { PCI_DEVICE_NEO_EXPRESS_4RJ45_PCI_NAME
, 4, 1 },
112 { PCI_DEVICE_NEO_EXPRESS_8RJ45_PCI_NAME
, 8, 1 },
116 static struct pci_driver dgnc_driver
= {
118 .probe
= dgnc_init_one
,
119 .id_table
= dgnc_pci_tbl
,
122 /************************************************************************
124 * Driver load/unload functions
126 ************************************************************************/
128 static void cleanup(bool sysfiles
)
133 spin_lock_irqsave(&dgnc_poll_lock
, flags
);
135 spin_unlock_irqrestore(&dgnc_poll_lock
, flags
);
137 /* Turn off poller right away. */
138 del_timer_sync(&dgnc_poll_timer
);
141 dgnc_remove_driver_sysfiles(&dgnc_driver
);
143 device_destroy(dgnc_class
, MKDEV(dgnc_Major
, 0));
144 class_destroy(dgnc_class
);
145 unregister_chrdev(dgnc_Major
, "dgnc");
147 for (i
= 0; i
< dgnc_NumBoards
; ++i
) {
148 dgnc_remove_ports_sysfiles(dgnc_Board
[i
]);
149 dgnc_tty_uninit(dgnc_Board
[i
]);
150 dgnc_cleanup_board(dgnc_Board
[i
]);
153 dgnc_tty_post_uninit();
157 * dgnc_cleanup_module()
159 * Module unload. This is where it all ends.
161 static void dgnc_cleanup_module(void)
164 pci_unregister_driver(&dgnc_driver
);
170 * Module load. This is where it all starts.
172 static int __init
dgnc_init_module(void)
177 * Initialize global stuff
185 * Find and configure all the cards
187 rc
= pci_register_driver(&dgnc_driver
);
189 pr_warn("WARNING: dgnc driver load failed. No Digi Neo or Classic boards found.\n");
193 dgnc_create_driver_sysfiles(&dgnc_driver
);
198 module_init(dgnc_init_module
);
199 module_exit(dgnc_cleanup_module
);
204 static int dgnc_start(void)
210 /* make sure timer is initialized before we do anything else */
211 init_timer(&dgnc_poll_timer
);
214 * Register our base character device into the kernel.
215 * This allows the download daemon to connect to the downld device
216 * before any of the boards are init'ed.
218 * Register management/dpa devices
220 rc
= register_chrdev(0, "dgnc", &dgnc_BoardFops
);
222 pr_err(DRVSTR
": Can't register dgnc driver device (%d)\n", rc
);
227 dgnc_class
= class_create(THIS_MODULE
, "dgnc_mgmt");
228 if (IS_ERR(dgnc_class
)) {
229 rc
= PTR_ERR(dgnc_class
);
230 pr_err(DRVSTR
": Can't create dgnc_mgmt class (%d)\n", rc
);
234 dev
= device_create(dgnc_class
, NULL
,
235 MKDEV(dgnc_Major
, 0),
239 pr_err(DRVSTR
": Can't create device (%d)\n", rc
);
244 * Init any global tty stuff.
246 rc
= dgnc_tty_preinit();
249 pr_err(DRVSTR
": tty preinit - not enough memory (%d)\n", rc
);
253 /* Start the poller */
254 spin_lock_irqsave(&dgnc_poll_lock
, flags
);
255 setup_timer(&dgnc_poll_timer
, dgnc_poll_handler
, 0);
256 dgnc_poll_time
= jiffies
+ dgnc_jiffies_from_ms(dgnc_poll_tick
);
257 dgnc_poll_timer
.expires
= dgnc_poll_time
;
258 spin_unlock_irqrestore(&dgnc_poll_lock
, flags
);
260 add_timer(&dgnc_poll_timer
);
265 device_destroy(dgnc_class
, MKDEV(dgnc_Major
, 0));
267 class_destroy(dgnc_class
);
269 unregister_chrdev(dgnc_Major
, "dgnc");
273 /* returns count (>= 0), or negative on error */
274 static int dgnc_init_one(struct pci_dev
*pdev
, const struct pci_device_id
*ent
)
278 /* wake up and enable device */
279 rc
= pci_enable_device(pdev
);
284 rc
= dgnc_found_board(pdev
, ent
->driver_data
);
292 * dgnc_cleanup_board()
294 * Free all the memory associated with a board
296 static void dgnc_cleanup_board(struct dgnc_board
*brd
)
300 if (!brd
|| brd
->magic
!= DGNC_BOARD_MAGIC
)
303 switch (brd
->device
) {
304 case PCI_DEVICE_CLASSIC_4_DID
:
305 case PCI_DEVICE_CLASSIC_8_DID
:
306 case PCI_DEVICE_CLASSIC_4_422_DID
:
307 case PCI_DEVICE_CLASSIC_8_422_DID
:
309 /* Tell card not to interrupt anymore. */
310 outb(0, brd
->iobase
+ 0x4c);
318 free_irq(brd
->irq
, brd
);
320 tasklet_kill(&brd
->helper_tasklet
);
322 if (brd
->re_map_membase
) {
323 iounmap(brd
->re_map_membase
);
324 brd
->re_map_membase
= NULL
;
327 if (brd
->msgbuf_head
) {
330 spin_lock_irqsave(&dgnc_global_lock
, flags
);
332 dev_dbg(&brd
->pdev
->dev
, "%s\n", brd
->msgbuf_head
);
333 kfree(brd
->msgbuf_head
);
334 brd
->msgbuf_head
= NULL
;
335 spin_unlock_irqrestore(&dgnc_global_lock
, flags
);
338 /* Free all allocated channels structs */
339 for (i
= 0; i
< MAXPORTS
; i
++) {
340 if (brd
->channels
[i
]) {
341 kfree(brd
->channels
[i
]->ch_rqueue
);
342 kfree(brd
->channels
[i
]->ch_equeue
);
343 kfree(brd
->channels
[i
]->ch_wqueue
);
344 kfree(brd
->channels
[i
]);
345 brd
->channels
[i
] = NULL
;
349 dgnc_Board
[brd
->boardnum
] = NULL
;
357 * A board has been found, init it.
359 static int dgnc_found_board(struct pci_dev
*pdev
, int id
)
361 struct dgnc_board
*brd
;
362 unsigned int pci_irq
;
367 /* get the board structure and prep it */
368 dgnc_Board
[dgnc_NumBoards
] = kzalloc(sizeof(*brd
), GFP_KERNEL
);
369 brd
= dgnc_Board
[dgnc_NumBoards
];
374 /* make a temporary message buffer for the boot messages */
375 brd
->msgbuf_head
= kcalloc(8192, sizeof(u8
), GFP_KERNEL
);
376 brd
->msgbuf
= brd
->msgbuf_head
;
383 /* store the info for the board we've found */
384 brd
->magic
= DGNC_BOARD_MAGIC
;
385 brd
->boardnum
= dgnc_NumBoards
;
386 brd
->vendor
= dgnc_pci_tbl
[id
].vendor
;
387 brd
->device
= dgnc_pci_tbl
[id
].device
;
389 brd
->pci_bus
= pdev
->bus
->number
;
390 brd
->pci_slot
= PCI_SLOT(pdev
->devfn
);
391 brd
->name
= dgnc_Ids
[id
].name
;
392 brd
->maxports
= dgnc_Ids
[id
].maxports
;
393 if (dgnc_Ids
[i
].is_pci_express
)
394 brd
->bd_flags
|= BD_IS_PCI_EXPRESS
;
395 brd
->dpastatus
= BD_NOFEP
;
396 init_waitqueue_head(&brd
->state_wait
);
398 spin_lock_init(&brd
->bd_lock
);
399 spin_lock_init(&brd
->bd_intr_lock
);
401 brd
->state
= BOARD_FOUND
;
403 for (i
= 0; i
< MAXPORTS
; i
++)
404 brd
->channels
[i
] = NULL
;
406 /* store which card & revision we have */
407 pci_read_config_word(pdev
, PCI_SUBSYSTEM_VENDOR_ID
, &brd
->subvendor
);
408 pci_read_config_word(pdev
, PCI_SUBSYSTEM_ID
, &brd
->subdevice
);
409 pci_read_config_byte(pdev
, PCI_REVISION_ID
, &brd
->rev
);
414 switch (brd
->device
) {
415 case PCI_DEVICE_CLASSIC_4_DID
:
416 case PCI_DEVICE_CLASSIC_8_DID
:
417 case PCI_DEVICE_CLASSIC_4_422_DID
:
418 case PCI_DEVICE_CLASSIC_8_422_DID
:
420 brd
->dpatype
= T_CLASSIC
| T_PCIBUS
;
423 * For PCI ClassicBoards
424 * PCI Local Address (i.e. "resource" number) space
425 * 0 PLX Memory Mapped Config
426 * 1 PLX I/O Mapped Config
427 * 2 I/O Mapped UARTs and Status
428 * 3 Memory Mapped VPD
429 * 4 Memory Mapped UARTs and Status
432 /* get the PCI Base Address Registers */
433 brd
->membase
= pci_resource_start(pdev
, 4);
436 dev_err(&brd
->pdev
->dev
,
437 "Card has no PCI IO resources, failing.\n");
441 brd
->membase_end
= pci_resource_end(pdev
, 4);
443 if (brd
->membase
& 1)
448 brd
->iobase
= pci_resource_start(pdev
, 1);
449 brd
->iobase_end
= pci_resource_end(pdev
, 1);
450 brd
->iobase
= ((unsigned int)(brd
->iobase
)) & 0xFFFE;
452 /* Assign the board_ops struct */
453 brd
->bd_ops
= &dgnc_cls_ops
;
455 brd
->bd_uart_offset
= 0x8;
456 brd
->bd_dividend
= 921600;
460 /* Get and store the board VPD, if it exists */
461 brd
->bd_ops
->vpd(brd
);
464 * Enable Local Interrupt 1 (0x1),
465 * Local Interrupt 1 Polarity Active high (0x2),
466 * Enable PCI interrupt (0x40)
468 outb(0x43, brd
->iobase
+ 0x4c);
472 case PCI_DEVICE_NEO_4_DID
:
473 case PCI_DEVICE_NEO_8_DID
:
474 case PCI_DEVICE_NEO_2DB9_DID
:
475 case PCI_DEVICE_NEO_2DB9PRI_DID
:
476 case PCI_DEVICE_NEO_2RJ45_DID
:
477 case PCI_DEVICE_NEO_2RJ45PRI_DID
:
478 case PCI_DEVICE_NEO_1_422_DID
:
479 case PCI_DEVICE_NEO_1_422_485_DID
:
480 case PCI_DEVICE_NEO_2_422_485_DID
:
481 case PCI_DEVICE_NEO_EXPRESS_8_DID
:
482 case PCI_DEVICE_NEO_EXPRESS_4_DID
:
483 case PCI_DEVICE_NEO_EXPRESS_4RJ45_DID
:
484 case PCI_DEVICE_NEO_EXPRESS_8RJ45_DID
:
487 * This chip is set up 100% when we get to it.
488 * No need to enable global interrupts or anything.
490 if (brd
->bd_flags
& BD_IS_PCI_EXPRESS
)
491 brd
->dpatype
= T_NEO_EXPRESS
| T_PCIBUS
;
493 brd
->dpatype
= T_NEO
| T_PCIBUS
;
495 /* get the PCI Base Address Registers */
496 brd
->membase
= pci_resource_start(pdev
, 0);
497 brd
->membase_end
= pci_resource_end(pdev
, 0);
499 if (brd
->membase
& 1)
504 /* Assign the board_ops struct */
505 brd
->bd_ops
= &dgnc_neo_ops
;
507 brd
->bd_uart_offset
= 0x200;
508 brd
->bd_dividend
= 921600;
512 if (brd
->re_map_membase
) {
513 /* Read and store the dvid after remapping */
514 brd
->dvid
= readb(brd
->re_map_membase
+ 0x8D);
516 /* Get and store the board VPD, if it exists */
517 brd
->bd_ops
->vpd(brd
);
522 dev_err(&brd
->pdev
->dev
,
523 "Didn't find any compatible Neo/Classic PCI boards.\n");
528 * Do tty device initialization.
531 rc
= dgnc_tty_register(brd
);
533 pr_err(DRVSTR
": Can't register tty devices (%d)\n", rc
);
537 rc
= dgnc_finalize_board_init(brd
);
539 pr_err(DRVSTR
": Can't finalize board init (%d)\n", rc
);
543 rc
= dgnc_tty_init(brd
);
545 pr_err(DRVSTR
": Can't init tty devices (%d)\n", rc
);
549 brd
->state
= BOARD_READY
;
550 brd
->dpastatus
= BD_RUNNING
;
552 dgnc_create_ports_sysfiles(brd
);
554 /* init our poll helper tasklet */
555 tasklet_init(&brd
->helper_tasklet
,
556 brd
->bd_ops
->tasklet
,
559 spin_lock_irqsave(&dgnc_global_lock
, flags
);
561 dev_dbg(&brd
->pdev
->dev
, "%s\n", brd
->msgbuf_head
);
562 kfree(brd
->msgbuf_head
);
563 brd
->msgbuf_head
= NULL
;
564 spin_unlock_irqrestore(&dgnc_global_lock
, flags
);
566 wake_up_interruptible(&brd
->state_wait
);
571 dgnc_tty_uninit(brd
);
572 brd
->state
= BOARD_FAILED
;
573 brd
->dpastatus
= BD_NOFEP
;
578 static int dgnc_finalize_board_init(struct dgnc_board
*brd
)
582 if (!brd
|| brd
->magic
!= DGNC_BOARD_MAGIC
)
586 rc
= request_irq(brd
->irq
, brd
->bd_ops
->intr
,
587 IRQF_SHARED
, "DGNC", brd
);
590 dev_err(&brd
->pdev
->dev
,
591 "Failed to hook IRQ %d\n", brd
->irq
);
592 brd
->state
= BOARD_FAILED
;
593 brd
->dpastatus
= BD_NOFEP
;
603 static void dgnc_do_remap(struct dgnc_board
*brd
)
605 if (!brd
|| brd
->magic
!= DGNC_BOARD_MAGIC
)
608 brd
->re_map_membase
= ioremap(brd
->membase
, 0x1000);
611 /*****************************************************************************
631 * As each timer expires, it determines (a) whether the "transmit"
632 * waiter needs to be woken up, and (b) whether the poller needs to
635 ******************************************************************************/
637 static void dgnc_poll_handler(ulong dummy
)
639 struct dgnc_board
*brd
;
642 unsigned long new_time
;
644 /* Go thru each board, kicking off a tasklet for each if needed */
645 for (i
= 0; i
< dgnc_NumBoards
; i
++) {
648 spin_lock_irqsave(&brd
->bd_lock
, flags
);
650 /* If board is in a failed state don't schedule a tasklet */
651 if (brd
->state
== BOARD_FAILED
) {
652 spin_unlock_irqrestore(&brd
->bd_lock
, flags
);
656 /* Schedule a poll helper task */
657 tasklet_schedule(&brd
->helper_tasklet
);
659 spin_unlock_irqrestore(&brd
->bd_lock
, flags
);
663 * Schedule ourself back at the nominal wakeup interval.
665 spin_lock_irqsave(&dgnc_poll_lock
, flags
);
666 dgnc_poll_time
+= dgnc_jiffies_from_ms(dgnc_poll_tick
);
668 new_time
= dgnc_poll_time
- jiffies
;
670 if ((ulong
)new_time
>= 2 * dgnc_poll_tick
)
671 dgnc_poll_time
= jiffies
+ dgnc_jiffies_from_ms(dgnc_poll_tick
);
673 setup_timer(&dgnc_poll_timer
, dgnc_poll_handler
, 0);
674 dgnc_poll_timer
.expires
= dgnc_poll_time
;
675 spin_unlock_irqrestore(&dgnc_poll_lock
, flags
);
678 add_timer(&dgnc_poll_timer
);